Operasi aritmetik
Mari kita mulakan dengan perkara yang paling mudah - dengan operasi aritmetik. Ini ialah penambahan (+), penolakan (-), pendaraban (*) dan pembahagian (/) yang terkenal.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);
}
}
Output konsol:
1032
966
32967
30
Anda telah menggunakan semua ini. Anda boleh menambah operasi kepada mereka %
- baki bahagian.
public class Main {
public static void main(String[] args) {
int x = 33;
int y = 33%2;
System.out.println(y);
}
}
Output konsol:
1
Dalam contoh ini, kita bahagikan 33 dengan 2. Akibatnya, kita mendapat 16 dan masih ada "ekor" tambahan yang tidak boleh dibahagikan dengan 2 - satu. "Ekor" ini akan menjadi hasil daripada operasi "baki bahagian". Java (serta matematik) melaksanakan pengendali perbandingan . Anda mungkin juga mengenali mereka dari sekolah:
- sama dengan (
==
) - lagi (
>
) - kurang (
<
) - lebih besar daripada atau sama dengan (
>=
) - kurang daripada atau sama dengan (
<=
) - tidak sama (
!=
)
==
, dan bukan dengan satu tanda =
. Tanda unit =
dalam Java ialah pengendali tugasan, di mana pembolehubah diberikan nombor, rentetan atau nilai pembolehubah lain.
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
}
}
Output konsol:
999
Aduh! Ini jelas bukan keputusan yang kami jangkakan. Ini adalah jenis data yang berbeza sama sekali: kami menjangkakan untuk melihat boolean
, tetapi mendapat nombor. Ini kerana dalam kurungan kita mempunyai operasi tugasan, bukan perbandingan. x=y
Nilai y
(999) telah diberikan kepada pembolehubah x
, dan kemudian kami mencetaknya x
ke konsol. Pilihan yang betul:
public class Main {
public static void main(String[] args) {
int x = 33;
int y = 999;
System.out.println(x==y);
}
}
Output konsol:
false
Sekarang kita telah membandingkan 2 nombor dengan betul! :) Satu lagi ciri operasi penugasan ( =
) ialah ia boleh dilakukan "dirantai":
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);
}
}
Output konsol:
256
Ingat: tugasan dilakukan dari kanan ke kiri. Ungkapan ini ( x = y = z
) akan dilaksanakan dalam langkah-langkah:
- y = z, iaitu y = 256
- x = y, iaitu x = 256
Operasi unary
Mereka dipanggil "unary" dari perkataan "uno" - "satu". Mereka menerima nama ini kerana, tidak seperti yang sebelumnya, mereka dijalankan pada satu nombor, dan bukan pada beberapa. Ini termasuk:-
Unary tolak. Ia membalikkan tanda nombor.
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); } }
Output konsol:
-999 999
Kami menggunakan tolak unary dua kali. Akibatnya, nombor kami menjadi negatif pada mulanya, dan kemudian positif semula!
-
Kenaikan (
++
) dan penurunan (--
)Operasi
++
menambah satu nombor, dan operasi--
mengurangkannya dengan unit yang sama.public class Main { public static void main(String[] args) { int x = 999; x++; System.out.println(x); x--; System.out.println(x); } }
Output konsol:
1000 999
x++
- tatatanda postfix ++x
- notasi awalan Apakah perbezaan asas jika anda meletakkan tambah dan tolak sebelum atau selepas nombor? Mari kita lihat dalam contoh:
public class Main {
public static void main(String[] args) {
int x = 999;
int y = x++;
System.out.println(y);
}
}
Output konsol:
999
Adakah terdapat sesuatu yang salah! Kami mahu menambah x
sebanyak 1 dan memberikan nilai baharu kepada pembolehubah y
. Iaitu, y sepatutnya sama dengan 1000. Tetapi kami mempunyai hasil yang berbeza - 999. Ternyata ia x
tidak meningkat, dan operasi kenaikan tidak berfungsi? Bagaimana ia berfungsi. Untuk mengesahkan ini, cuba cetak x ke konsol pada akhir :)
public class Main {
public static void main(String[] args) {
int x = 999;
int y = x++;
System.out.println(y);
System.out.println(x);
}
}
Output konsol:
999
1000
Malah, itulah sebabnya operasi postfix dipanggil sedemikian: ia dilakukan selepas ungkapan utama. Iaitu, dalam kes kami: int y = x++;
pertama ia dilaksanakan y = x
(dan pembolehubah y akan diberikan nilai asalnya x
), dan hanya kemudian x++
. Bagaimana jika kita tidak berpuas hati dengan tingkah laku ini? Anda perlu menggunakan notasi awalan:
public class Main {
public static void main(String[] args) {
int x = 999;
int y = ++x;
System.out.println(y);
}
}
Dalam kes ini, ia akan berfungsi terlebih dahulu ++x
dan hanya selepas itu. y = x;
Perbezaan ini patut diingati dengan segera agar tidak membuat kesilapan dalam program sebenar, di mana semua tingkah laku boleh terbalik kerana ini :)
Operasi gabungan
Di samping itu, di Jawa terdapat operasi gabungan yang dipanggil. Mereka menggunakan gabungan dua operasi:- Tugasan
- Operasi aritmetik
+=
-=
*=
/=
%=
public class Main {
public static void main(String[] args) {
int x = 999;
int y = 33;
x += y;
System.out.println(x);
}
}
Output konsol:
1032
x += y
bermakna x = x + y
. Hanya untuk kepentingan ringkas, dua aksara berturut-turut digunakan. Ini juga berfungsi dengan gabungan -=
, *=
, /=
dan %=
.
Operasi logik
Selain operasi pada nombor, Java juga mempunyai operasi pada pembolehubah Boolean -true
dan false
. Operasi ini dilakukan menggunakan operator logik
-
!
— pengendali “TIDAK”. Membalikkan nilai pembolehubah booleanpublic class Main { public static void main(String[] args) { boolean x = true; System.out.println(!x); } }
Output konsol:
false
-
&&
— operator “DAN”. Mengembalikan nilaitrue
hanya jika kedua-dua operan ialahtrue
.public class Main { public static void main(String[] args) { System.out.println(100 > 10 && 100 > 200); System.out.println(100 > 50 && 100 >= 100); } }
Output konsol:
false true
Hasil daripada operasi pertama ialah
false
, kerana salah satu syarat adalah palsu, iaitu 100 > 200. Operator memerlukan semua syarat adalah benar (seperti dalam baris kedua, sebagai contoh)&&
untuk mengembalikan .true
-
||
— pengendali “ATAU”. Kembalitrue
apabila sekurang-kurangnya satu daripada operan adalah benar.Di sini contoh terdahulu kami akan berfungsi secara berbeza:
public class Main { public static void main(String[] args) { System.out.println(100 > 10 || 100 > 200); } }
Output konsol:
true
Ungkapan 100 > 200 masih palsu, tetapi pengendali "atau" agak berpuas hati bahawa bahagian pertama (100 > 10) adalah benar.
GO TO FULL VERSION