算術運算子：
package com.zhiyou100;
public class Demo01_Operator {
public static void main(String[] args) {
/*
運算子 程式中一種很特殊的符號 連接程式中需要參與運算的變數（前提條件是該變數有值）
算術運算子
+ - * / % ++i i++ i自加1； --i i-- i自減1
賦值運算子 +=
比較運算子（關系運算子） 數字（整數，小數） 運算式（變數+運算子）
邏輯運算子 與 & 或 | 非 !
位運算子
三目運算子 ?:
語法格式：
布爾型別值 ？ 該布爾型別值是真的結果值 : 該布爾型別值為假的結果值
結果值要根據布爾型別值運算式，當運算式為真，結果就是緊鄰問號 "?" 后面的結果值
當運算式為真，結果就是緊鄰冒號 ":" 后面的結果值
*/
// + 第一個作用：連接變數（變數的型別：基本+參考（String）） 通常情況下進行字串拼接
String name = "張三";
int age = 20;
System.out.println(name+ age);
// + 第二個作用：相加運算
int a1 = 10;
int b1 = 20;
int c1 = a1+b1;
System.out.println(c1);
// + 第三個作用：正數>0
int a2 = +10;
int b2 = +a2;
System.out.println(b2+ " "+ a2);
// - 第一個作用：相減運算
int a3 = 20;
int b3 = 10;
int c3 = a3-b3;
System.out.println(c3);
// - 第二個作用：負數 <0
int a4 = 20;
int b4 = -20;
int c4 = -a4;
System.out.println(c4);
// * 重量級 作用：乘法運算
int a5 = 10;
int b5 = 20;
int c5 = a5*b5;
System.out.println(c5);
// / 作用：除法運算
int a6 = 13;
int b6 = 5;
int c6 = a6/b6;
System.out.println(c6);
// % 作用：求余數（取模）
int a7 = 13;
int b7 = 5;
int c7 = 13%5;
System.out.println(c7);
// / 正數 除以 負數
System.out.println(a7 / (-b7));
System.out.println(a7 % (-b7));
//在除法運算中·，余數的正負隨著被除數走，但是商的正負（只要除數和被除數其中有且僅有一個為負數即為負數），否則為正數
// ++ 自加1
int number = 10;
number += 5;
System.out.println("number="+ number);
int number2 = 10;
number2++;
System.out.println("number2="+ number2);
int num3 = 10;
int plus = 5;
num3 += plus++;
//如果變數在++運算子左邊，那么在運算程序中，先進行++運算子左邊的運算，在執行++運算
System.out.println(plus);// 6
System.out.println(num3);// 15
//變數在++運算子的右邊
int num4 = 10;
int plus2 = 5;
num4 += ++plus2;
System.out.println("num4="+ num4);//16
System.out.println("plus2="+ plus2);//6
//如果變數在++運算子的右邊，那么在運算程序中，先進行++運算，再運行其他運算
// -- 自減運算
int num5 = 10;
int reduction = 5;
--num5;
System.out.println(num5);
}
}
賦值運算子：
package com.zhiyou100;
//賦值運算子
public class Demo02_Operator {
public static void main(String[] args) {
/*
賦值運算子：就是給變數賦值（初始化）
= 等號代表的意思是把等號右邊的資料賦值給等號左邊的變數
+= 相加賦值
-= 相減賦值
*= 相乘賦值
/= 相除賦值
*/
int a;
a = 10;
int a1 = 10;
/*
a1 = a1+10;//20
等價于 a1 += 10;
*/
//a1 += 10;
a1 = a1+10;//20
System.out.println("a1="+ a1);
int b1 = a1+a1;
// -= 相減賦值
int a2 = 10;
//a2 = a2-5;
a2 -= 5;
System.out.println("a2="+ a2);
// *= 相乘賦值
int a3 = 10;
//a3 = a3*5;
a3 *= 5;
System.out.println("a3="+ a3);
// /= 相除賦值
int a4 = 13;
//a4 = a4/5;
a4 /= 5;
System.out.println("a4="+ a4);
// %= 取余賦值
int a5 = 13;
//a5 = a5 % 5;
a5 %= 5;
System.out.println("a5="+ a5);
}
}
比較運算子：
package com.zhiyou100;
public class Demo03_Operator {
public static void main(String[] args) {
/*
比較運算子
> < == >= <= !=
大于 小于 等于 大于等于 小于等于 不等于
1.比較運算子中的“ = ”是“ == ”，而不是“ = ”
2.比較運算子運算的結果就是布爾型別值：true/false
*/
int a = 20;
int b = 10;
System.out.println("a > b: "+ (a > b));//false
System.out.println("a < b: "+ (a < b));//true
System.out.println("a == b: "+ (a == b));//false
System.out.println("a != b: "+ (a != b));//true
System.out.println("a <= b: "+ (a <= b));//true
System.out.println("a >= b: "+ (a >= b));//false
//比較運算子前后都是陳述句
System.out.println("a++ > b--: "+ (a++ > b--));
}
}
邏輯運算子：
package com.zhiyou100;
//邏輯運算子
public class Demo04_Operator {
public static void main(String[] args) {
/*
邏輯運算子: 與 & 或 | 非 !
在程式中，運算的是布爾型別值（可以是具體的true或者false，也可以是布爾型別的運算式)
結果依然是布爾型別值，
*/
boolean bool = true;
boolean bool2 = false;
boolean bool3 = bool & bool2;
System.out.println(bool3);
//說明：與運算子 在程式運算程序中，只要有一個fals，結果就是false，否則為true
// 或運算 |
boolean var01 = false;
boolean var02 = false;
boolean var03 = var01 | var02;
System.out.println(var03);
//說明：或運算，在程式運算程序中，只要有一個為true，結果就為true，否則為false，
// 非運算 ！
boolean var04 = false;
boolean var05 = true;
boolean var06 = !var04;//true
//說明：非運算，在程式中運算中，一般只能連接一個布爾型別值，而且非運算子只能放在布爾型別值的左邊
//結果就是對連接的該布爾型別值取相反結果
//異或 ^ 異或運算子
boolean var07 = false;
boolean var08 = true;
boolean result = var07 ^ var08;
System.out.println(result);
//說明：異或運算子，在程式運算中，同為false，異為true
// 如果異或運算子連接的左右布爾型別變數（運算式）的值不同，結果為true
// 如果異或運算子連接的左右布爾型別變數（運算式）的值相同，結果為false
//備注：如果和或運算子做對比，不同之處：當左右都為true的時候，結果為false
//拓展：與& && 或| || 非! 異或 ^
boolean bool4 = true;
boolean bool5 = false;
boolean bool6 = bool4 && bool5;
System.out.println(bool6);
//在程式中，與運算子，通常使用&&
/*
&與&&異同點：
相同點：都是做與運算
不同點：&&可以實作斷路
備注：短路效果，當&&符號左邊的布爾型別值可以確定為false的時候，那么在執行到&&的時候，會發生跳躍，&&后面的運算式不運行
或運算子||效果等同與&&
*/
boolean bool7 = true;
boolean bool8 = false;
boolean bool9 = bool4 || bool5;
System.out.println(bool9);
//當||符號左邊的布爾型別值可以確定為true的時候，那么在執行到||的時候，會發生跳躍，||后面的運算式不運行
}
}
位運算子：
package com.zhiyou100;
public class Demo05_Operator {
public static void main(String[] args) {
/*
位運算子 位
位 bit 計算機中最小的資訊單位為bit（位） 一個bit上存盤的是0或者1
計算機中最小的存盤單位是byte（位元組） 1byte=8bit
二進制的運算
與位運算 &
或位運算 |
非位運算 ×
異或位運算 ^
移位位運算 >>右移 <<左移 >>>無符號右移動
*/
// 與位運算 &
int a = 13;
int b = 5;
int c = a & b;//5
System.out.println(c);
// 說明：在與位運算中，如果參與運算的二進制值中有一個為0，那么運算的結果即為0
// 當前后運算的二進制的長度不一致時，那么程式會在短的那一方高位補0，短幾位就補幾個0，保持長度一致
//或位運算子
int a1 = 28;// 011100
int b1 = 36; // 100100
int c1 = a1 | b1; // 111100=60
System.out.println(c1);
//異或運算子 同為0，異為1
int a2 = 123;// 01111011
int b2 = 134;// 10000110
int c2 = a2 ^ b2;// 11111101
System.out.println(c2);//253
}
}
三目運算子：
package com.zhiyou100;
// 三目運算子 ?:
public class Demo06_Operator {
public static void main(String[] args) {
/*
三目運算子 ?:
語法格式：
布爾型別值 ？ 該布爾型別值是真的結果值 : 該布爾型別值為假的結果值
結果值要根據布爾型別值運算式，當運算式為真，結果就是緊鄰問號 "?" 后面的結果值
當運算式為真，結果就是緊鄰冒號 ":" 后面的結果值
*/
//第一種：直接在輸出陳述句使用
int a = 10;
int b = 20;
System.out.println(a > b ? "a>b" : "a<b");
System.out.println(a > b ? true : false);//false
System.out.println(a <= b ? "a<=b" : false);
System.out.println(a >= b ? a : b);//20
//第二種用法：在陳述句中使用(不是輸出陳述句) 賦值運算中
int c = a > b ? a : b;//20
System.out.println(c);
String d = a > b ? "是真的嗎？" : "你是假的";
System.out.println(d);
/*
說明：如果三目運算子是在輸出陳述句中，那么對三目運算子的結果值真偽的資料型別不要求
如果不在輸出陳述句中，在其他陳述句中，如賦值運算陳述句，那么就要嚴格控制三目運算子的結果值真偽的資料型別
真偽的結果值型別要一致，保持和賦值運算中的變數的資料型別一致
*/
}
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/173238.html
標籤：其他
上一篇：【SSM - SpringMVC篇】03 - SpringMVC的引數系結 - 引數自動系結 - javabean物件引數綁 - 嵌套bean引數系結