這一節我們來學習java語言中的運算符。
Java語言支持如下運算符:
算術運算符:+,-,*,/,%,++,--
關系運算符:>,<,>=,<=,==,!=
邏輯運算符:!,&,|,^,&&,||
位運算符:&,|,^,~,>>,<<,>>>
賦值運算符:=
擴展賦值運算符:+=,-=,*=,/=
字符串連接運算符:+
我們直接看例子吧:
先看一下算術運算符。
~~~
class OperateDemo
{
public static void main(String[] args)
{
//算術運算符 + - * / %(取余,模運算) +(連接符)
// ++ (自增:就是在原有基礎上加一,再賦給原有數據) --
int x = 6370;
x = x / 1000 * 1000;//結果是6000,也就是說java是強制運算語言
System.out.println(x);
//取模運算主要用于開關算法的定義
System.out.println(3 + 2);//加法
System.out.println("3" + 2);//String連接符
System.out.println("5 + 5 =" + 5 + 5);//5 + 5 =55
System.out.println("5 + 5 =" + (5 + 5));//5 + 5 =10
int a = 4,b = 5;
System.out.println("a:" + a + ",b:" + b);//a:4,b:5
int a1 = 3,b1;
//a1 ++;//相當于a1=a1+1;
//b1 = a1++;//a1=4,b1=3 這個過程是先把a的值留存在一個臨時空間內,然后在原空間進行++運算并將結果存進去,然后把臨時空間的值賦給b
b1 = ++a1;//a1=4,b1=4 這個過程中先進行++運算,并把結果賦給a,再把a的值賦給b
System.out.println("a1="+a1+",b1="+b1);//a1=4,b1=4
int i = 3;//更加清晰的反映了這個過程
i = i++;
System.out.println("i="+i);//i=3
int j = 3;
j = ++j;
System.out.println("j="+j);//j=4
}
}
~~~
結果:

再看符值運算符
~~~
class OperateDemo2
{
public static void main(String[] args)
{
//賦值運算符 = += -= *= /= %=
int a,b,c;
a = b = c = 4;
int a1 = 4;
a1 += 2;//a1 = a1 + 2;
short s = 3;//賦值,s是兩個字節,3是四個字節,自行檢測
//s += 4;//這個在底層做了自動轉換
//s = s + 4;//這個報錯,缺失精度,不能自動轉換,把int類型存入short中
s = (short)(s + 4);//等價于s += 4;
System.out.println("s="+s);
}
}
~~~
結果:

比較運算符
~~~
class OperateDemo3
{
public static void main(String[] args)
{
//比較運算符 > < == >= <= != instanceof(是不是實例)
//比較運算符,運算要么為真,要么為假,true or false
System.out.println(3>2);//true
/*邏輯去處符 &(與) |(或) ^(異或) !(非) &&(雙與) ||(雙或)
x > 2 && x < 5 等價于 2<x<5
邏輯運算符是用于連接兩個boolean類型的表達式
&:符號的去處特點:
true & true = true;
true & false = false;
false & false = false;
false & true = false;
&:運算規律:
運算的兩邊只要有一個是false,結果一定為false;只有兩邊同為true,結果才為true
|:運算特點:
true | true = true;
true | false = true;
false | false = false;
false | true = true;
|:運算規律:
去處兩過只要有一個是true,結果為true;只有兩邊都為false,結果才為false
^:異或:和或有點不一樣.
^:運算特點:
true | true = false;
true | false = true;
false | false = false;
false | true = true;
^:運算規律:
兩邊的結果相同,結果為false;兩邊的結果不同,結果為true.
!:運算特點:!true = false; !false = true;
&&和||可以短路運算
&&:當左邊為false時,右邊不再參與運算
||:當左邊為true時,右邊不再參與運算
*/
int x = 3;
System.out.println(x>2&x<5);
System.out.println(x<2|x>5);
}
}
~~~
結果:

位運算符
~~~
class OperateDemo4
{
public static void main(String[] args)
{
/*
位運算符:二進制
&(與) |(或) ^(異或) ~(去反) <<(左移) >>(右移) >>>(無符號右移)
6 & 3 = 2
0000-0000 0000-0000 0000-0000 0000-0110 6
&0000-0000 0000-0000 0000-0000 0000-0011 3
-----------------------------------------
0000-0000 0000-0000 0000-0000 0000-0010 2
6 | 3 = 7
0000-0000 0000-0000 0000-0000 0000-0110 6
|0000-0000 0000-0000 0000-0000 0000-0011 3
-----------------------------------------
0000-0000 0000-0000 0000-0000 0000-0111 7
6 ^ 3 = 5
0000-0000 0000-0000 0000-0000 0000-0110 6
^0000-0000 0000-0000 0000-0000 0000-0011 3
-----------------------------------------
0000-0000 0000-0000 0000-0000 0000-0101 5
6 ^ 3 ^ 3 = 6:一個數異或同一個數兩次,結果還是這個數.
3 << 2 = 12 3 << 3 = 24 //向左移幾位,左邊的幾位就被舍取,右邊加幾個0
0000000000000000000000000000011 3
0000000000000000000000000001100 12
@左移幾位,其實就是該數乘以2的幾次方,可以完成2的次冪運算
6 >> 1 =
對于高位出現的高位,原來最高位為0,就用0補位,原來最高位為1,就用1補位
右移幾位其實就是該數據除以2的幾次方
>>>:無符號右移:數據進行右移時,高位出現的空位,無論原高位是什么,空位都用0補.
*/
System.out.println(6 & 3);//6在計算中:0000-0000 0000-0000 0000-0000 0000-0110
System.out.println(6 | 3);
System.out.println(6 ^ 3);
System.out.println(~6);//-7
System.out.println(3 << 2);//左移兩位,相當于乘以2的2次方
}
}
~~~
結果:

三元運算符
~~~
class OperateDemo5
{
public static void main(String[] args)
{
/*
三元運算符:
格式:(條件表達式)?表達式1:表達式2
如果條件為true,運算表達式1
如果條件為false,去處表達式2
*/
int x = 3,y;
y = (x > 1) ? 100 : 200;
System.out.println("y="+y);
//三元運算符的一個小應用
//獲取兩個整數中的較大的整數
int x1 = 3;
int y1 = 4;
int max = (x1>y1)?x1:y1;
System.out.println(max);
//獲取三個整數中的最大的整數
int o,p,q;
o = 5;
p = 6;
q = 4;
int temp = (o>p)?o:p;
int max1 = (temp>q)?temp:q;
}
}
~~~
結果:

最后看一個簡單的測試就過吧
~~~
class OperateTest
{
public static void main(String[] args)
{
//最有效率的方式算出2乘以8等于幾?
System.out.println(2 << 3);
System.out.println(8 << 1);
//對兩個整數變量直接互換(不需要第三方變量)
int a = 3,b = 5;
/*
閱讀性好,開發時用
int c;
c = a;
a = b;
b = c;
*/
/*
這種方式一般不要用,如果兩個整數的數值過大,會超出int范圍,會強制轉換,數據會變化.
a = a + b;
b = a - b;
a = a - b;
*/
/*
面試時用,可讀性差
a = a ^ b;//a = 3 ^ 5;
b = a ^ b;//(3 ^ 5) ^ 5;
a = a ^ b;//(3 ^ 5) ^ 3;
*/
System.out.println("a="+a+",b="+b);
}
}
~~~
結果:

這一節就到這里吧,下節再說。
- 前言
- 1.1 基本常識
- 1.2 Java語言概述
- 1.3 Java語言的環境搭建
- 1.4 Java程序開發之初體驗--Hello World
- 2.1 關鍵字
- 2.2 標識符
- 2.3 注釋
- 2.4 常量
- 2.5 進制掃盲
- 2.6 變量和數據類型(1)
- 2.7 變量和數據類型(2)
- 2.8 運算符
- 3.1 if語句
- 3.2 switch語句
- 3.3 while和do-while語句
- 3.4 for語句
- 3.5 for循環的嵌套
- 3.6 break語句與continue語句
- 4.1 函數的定義
- 4.2 定義函數的兩個明確
- 4.3 函數的內存加載過程
- 4.4 函數的重載
- 5.1 數組的定義
- 5.2 數組的內存分配及特點
- 5.3 數組操作中常見問題
- 5.4 數組常用操作(1)
- 5.5 數組常用操作(2)
- 5.6 二維數組
- 6.1 面向對象的概述
- 6.2 類與對象的關系
- 6.3 對象的內存體現
- 6.4 成員變量與局部變量
- 6.5 類類型參數與匿名對象
- 6.6 基本數據類型參數與引用數據類型參數的傳遞過程
- 6.7 封裝
- 7.1 構造函數概述與默認構造函數
- 7.2 構造函數與一般函數的區別
- 7.3 構造函數的重載
- 7.4 構造函數的內存加載
- 7.5 構造函數需要注意的幾個細節
- 7.6 this關鍵字的原理
- 7.7 this關鍵字的細節與應用
- 8.1 static關鍵字之特點
- 8.2 成員變量與靜態變量的區別
- 8.3 static關鍵字使用的注意細節
- 8.4 main函數的解析與細節
- 8.5 static關鍵字的使用場景
- 8.6 靜態的內存加載
- 8.7 靜態代碼塊
- 8.8 構造代碼塊
- 9.1 繼承
- 9.2 單繼承與多重繼承
- 9.3 子父類中成員變量特征體現