การดำเนินการทางคณิตศาสตร์
เริ่มจากสิ่งที่ง่ายที่สุด - ด้วยการดำเนินการทางคณิตศาสตร์ สิ่งเหล่านี้คือการบวก (เครื่องหมาย +) การลบ (-) การคูณ (*) และการหาร (/) ที่รู้จักกันดีpublic class Main {
public static void main(String[] args) {
int x = 999;
int y = 33;
System.out.println(x+y);
System.out.println(x-y);
System.out.println(x*y);
System.out.println(x/y);
}
}
เอาต์พุตคอนโซล:
1032
966
32967
30
คุณใช้ทั้งหมดนี้แล้ว คุณสามารถเพิ่มการดำเนินการให้กับพวกเขา%
- ส่วนที่เหลือของการแบ่ง
public class Main {
public static void main(String[] args) {
int x = 33;
int y = 33%2;
System.out.println(y);
}
}
เอาต์พุตคอนโซล:
1
ในตัวอย่างนี้ เราหาร 33 ด้วย 2 ผลลัพธ์ที่ได้คือ 16 และยังมี "หาง" พิเศษอีกอันที่หารด้วย 2 ไม่ลงตัว - หนึ่ง “ส่วนหาง” นี้จะเป็นผลจากการดำเนินการ “ส่วนที่เหลือ” Java (เช่นเดียวกับคณิตศาสตร์) ใช้ตัวดำเนินการเปรียบเทียบ คุณอาจรู้จักพวกเขาจากโรงเรียนด้วย:
- เท่ากับ (
==
) - มากกว่า (
>
) - น้อย (
<
) - มากกว่าหรือเท่ากับ (
>=
) - น้อยกว่าหรือเท่ากับ (
<=
) - ไม่เท่ากับ (
!=
)
==
และไม่มีเครื่องหมาย=
เดียว เครื่องหมายหน่วย=
ใน Java เป็นตัวดำเนินการกำหนด โดยที่ตัวแปรถูกกำหนดเป็นตัวเลข สตริง หรือค่าของตัวแปรอื่น
public class Main {
public static void main(String[] args) {
int x = 33;
int y = 999;
System.out.println(x=y);// expect false to be printed to the console
}
}
เอาต์พุตคอนโซล:
999
อ๊ะ! เห็นได้ชัดว่านี่ไม่ใช่ผลลัพธ์ที่เราคาดหวัง นี่เป็นข้อมูลประเภทที่แตกต่างไปจากเดิมอย่างสิ้นเชิง: เราคาดว่าจะเห็นboolean
แต่ได้ตัวเลขมา เนื่องจากในวงเล็บเรามีการดำเนินการมอบหมาย ไม่ใช่การเปรียบเทียบ x=y
กำหนด ค่าy
(999) ให้กับตัวแปรx
จากนั้นเราก็พิมพ์มันx
ไปที่คอนโซล ตัวเลือกที่ถูกต้อง:
public class Main {
public static void main(String[] args) {
int x = 33;
int y = 999;
System.out.println(x==y);
}
}
เอาต์พุตคอนโซล:
false
ตอนนี้เราเปรียบเทียบตัวเลข 2 ตัวได้อย่างถูกต้องแล้ว! :) คุณสมบัติอีกประการหนึ่งของการดำเนินการมอบหมาย ( =
) ก็คือสามารถดำเนินการแบบ "ถูกล่ามโซ่" ได้:
public class Main {
public static void main(String[] args) {
int x = 999;
int y = 33;
int z = 256;
x = y = z;
System.out.println(x);
}
}
เอาต์พุตคอนโซล:
256
ข้อควรจำ: การมอบหมายเสร็จสิ้นจากขวาไปซ้าย นิพจน์นี้ ( x = y = z
) จะถูกดำเนินการตามขั้นตอน:
- y = z นั่นคือ y = 256
- x = y นั่นคือ x = 256
การดำเนินการ Unary
พวกเขาเรียกว่า "unary" จากคำว่า "uno" - "หนึ่ง" พวกเขาได้รับชื่อนี้เพราะไม่เหมือนกับก่อนหน้านี้คือใช้หมายเลขเดียวไม่ใช่หลายหมายเลข ซึ่งรวมถึง:-
อูนารีลบ มันกลับเครื่องหมายของตัวเลข
public class Main { public static void main(String[] args) { int x = 999; // change the sign for the first time x = -x; System.out.println(x); // change the sign a second time x= -x; System.out.println(x); } }
เอาต์พุตคอนโซล:
-999 999
เราใช้ยูนินารีลบสองครั้ง ผลก็คือ จำนวนของเรากลายเป็นลบในตอนแรก จากนั้นก็บวกอีกครั้ง!
-
การเพิ่มขึ้น (
++
) และการลดลง (--
)การดำเนินการ
++
จะเพิ่มตัวเลขทีละหนึ่ง และการดำเนินการ--
จะลดลงตามหน่วยเดียวกันpublic class Main { public static void main(String[] args) { int x = 999; x++; System.out.println(x); x--; System.out.println(x); } }
เอาต์พุตคอนโซล:
1000 999
x++
- สัญกรณ์ postfix ++x
- สัญกรณ์นำหน้า อะไรคือความแตกต่างพื้นฐานหากคุณใส่เครื่องหมายบวกและเครื่องหมายลบก่อนหรือหลังตัวเลข? ลองดูตัวอย่าง:
public class Main {
public static void main(String[] args) {
int x = 999;
int y = x++;
System.out.println(y);
}
}
เอาต์พุตคอนโซล:
999
มีอะไรผิดปกติหรือเปล่า! เราต้องการเพิ่มขึ้น 1 และกำหนดค่า ใหม่x
ให้กับตัวแปร y
นั่นคือ y ควรเท่ากับ 1,000 แต่เราได้ผลลัพธ์ที่แตกต่างออกไป - 999 ปรากฎว่าไม่ได้x
เพิ่มขึ้นและการดำเนินการเพิ่มไม่ทำงานใช่ไหม มันทำงานอย่างไร หากต้องการตรวจสอบสิ่งนี้ ให้ลองพิมพ์ x ไปที่คอนโซลตอนท้าย :)
public class Main {
public static void main(String[] args) {
int x = 999;
int y = x++;
System.out.println(y);
System.out.println(x);
}
}
เอาต์พุตคอนโซล:
999
1000
ที่จริงแล้ว นั่นคือสาเหตุว่าทำไมการดำเนินการ postfix จึงถูกเรียกเช่นนั้น: ดำเนินการหลังจากนิพจน์หลัก นั่นคือในกรณีของเรา: int y = x++;
ขั้นแรกให้ดำเนินการ y = x
(และตัวแปร y จะได้รับการกำหนดค่าเริ่มต้นx
) และหลังจากนั้น x++
. จะเกิดอะไรขึ้นถ้าเราไม่พอใจกับพฤติกรรมนี้? คุณต้องใช้สัญลักษณ์นำหน้า:
public class Main {
public static void main(String[] args) {
int x = 999;
int y = ++x;
System.out.println(y);
}
}
ในกรณีนี้มันจะทำงานก่อน ++x
และหลังเท่านั้น y = x;
ความแตกต่างนี้ควรค่าแก่การจดจำทันทีเพื่อไม่ให้เกิดข้อผิดพลาดในโปรแกรมจริงซึ่งพฤติกรรมทั้งหมดสามารถกลับหัวกลับหางได้ด้วยเหตุนี้ :)
การดำเนินงานแบบผสมผสาน
นอกจากนี้ใน Java ยังมีสิ่งที่เรียกว่าการดำเนินการแบบรวม พวกเขาใช้การดำเนินการสองอย่างรวมกัน:- งานที่มอบหมาย
- การดำเนินการทางคณิตศาสตร์
+=
-=
*=
/=
%=
public class Main {
public static void main(String[] args) {
int x = 999;
int y = 33;
x += y;
System.out.println(x);
}
}
เอาต์พุตคอนโซล:
1032
x += y
วิธีx = x + y
. เพื่อความกระชับ จึงมีการใช้อักขระสองตัวติดต่อกัน นอกจาก นี้ยังใช้ได้กับการผสมของ -=
, *=
และ/=
%=
การดำเนินการเชิงตรรกะ
นอกเหนือจากการดำเนินการกับตัวเลขแล้ว Java ยังมีการดำเนินการกับตัวแปรบูลีน -true
และfalse
. การดำเนินการเหล่านี้ดำเนินการโดยใช้ตัวดำเนินการเชิงตรรกะ
-
!
— ตัวดำเนินการ "ไม่ใช่" กลับค่าของตัวแปรบูลีนpublic class Main { public static void main(String[] args) { boolean x = true; System.out.println(!x); } }
เอาต์พุตคอนโซล:
false
-
&&
— ตัวดำเนินการ “และ” ส่งคืนค่าtrue
เฉพาะในกรณีที่ตัวถูกดำเนินการทั้งสองtrue
เป็นpublic class Main { public static void main(String[] args) { System.out.println(100 > 10 && 100 > 200); System.out.println(100 > 50 && 100 >= 100); } }
เอาต์พุตคอนโซล:
false true
ผลลัพธ์ของการดำเนินการแรกคือ
false
เนื่องจากเงื่อนไขข้อใดข้อหนึ่งเป็นเท็จ กล่าวคือ 100 > 200 ตัวดำเนินการต้องการให้เงื่อนไขทั้งหมดเป็นจริง (เช่น ในบรรทัดที่สอง เป็นต้น)&&
เพื่อส่งคืนtrue
-
||
— ตัวดำเนินการ “หรือ” ส่งคืนtrue
เมื่อตัวถูกดำเนินการอย่างน้อยหนึ่งตัวเป็นจริงตัวอย่างก่อนหน้านี้ของเราจะทำงานแตกต่างออกไป:
public class Main { public static void main(String[] args) { System.out.println(100 > 10 || 100 > 200); } }
เอาต์พุตคอนโซล:
true
นิพจน์ 100 > 200 ยังคงเป็นเท็จ แต่ตัวดำเนินการ "หรือ" ค่อนข้างพอใจที่ส่วนแรก (100 > 10) เป็นจริง
GO TO FULL VERSION