編程入門：掌握J(rèn)ava運算符技巧

更新時間：2023年12月23日 09:14:00 作者：Y423x

掌握J(rèn)ava運算符技巧,能讓你的編程之旅輕松許多,本指南將帶你深入了解如何巧妙地使用這些強大的工具,讓代碼不僅高效,還充滿樂趣,跟著我們一起,讓你的Java代碼在運算符的魔法下煥發(fā)新生！

運算符和表達(dá)式

int a = 10;
int b = 20;
int c = a + b;

+：是運算符，并且是算術(shù)運算符

a + b:是表達(dá)式，由于+是算術(shù)運算符，所以這個表達(dá)式叫算術(shù)表達(dá)式

算術(shù)運算符

符號

符號	作用
+	加
-	減
*	乘
/	除
%	取模、取余

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        //+
        System.out.println(3 + 2);//5
        //-
        System.out.println(5 - 1);//4
        //*
        System.out.println(7 * 9);//63

        //如果在運算的時候有小數(shù)參與
        //結(jié)論：
        //在代碼中，如果有效數(shù)參與，結(jié)果有可能不精確的。
        System.out.println(1.1 + 1.1);//2.2
        System.out.println(1.1 + 1.01);//2.1100000000000003

        //除法
        //結(jié)論：
        //1.整數(shù)參與計算，結(jié)果只能得到整數(shù)
        //2.小數(shù)參與計算，結(jié)果有可能是不精確的
        System.out.println(10 / 2);//5
        System.out.println(10 / 3);//3
        System.out.println(10.0 / 3);//3.3333333333333335

        //取模、取余。實際上也是做除法運算，只不過得到的是余數(shù)而已。
        System.out.println(10 % 2);//0
        System.out.println(10 % 3);//1
        
        //應(yīng)用場景：
        //1.可以用取模判斷，A是否可以被B整除
        //A % B    10 % 3
        //2.可以判斷A是否為偶數(shù)
        //A % 2 如果結(jié)果為0，那么證明A是一個偶數(shù)。如果結(jié)果為1，那么證明A是一個奇數(shù)
        //3.斗地主發(fā)牌
        //三個玩家
        //把每一張牌都定義一個序號
        //拿著序號 % 3 如果結(jié)果為1，就發(fā)給第一個玩家
        //如果結(jié)果為2，那么就發(fā)給第二個玩家
        //如果結(jié)果為0，那么就發(fā)給第三個玩家

    }
}

練習(xí)--數(shù)值拆分

需求：鍵盤錄入一個三位數(shù)，將其拆分為個位、十位、百位后，打印在控制臺

公式總結(jié)：

個位：數(shù)值 % 10
十位：數(shù)值 / 10 % 10
百位：數(shù)值 / 100 % 10
千位：數(shù)值 / 1000 % 10
...

import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
        //鍵盤錄入一個三位數(shù)，將其拆分為個位、十位、百位后，打印在控制臺

        //1.鍵盤錄入
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入一個三位數(shù)");
        int number = sc.nextInt();

        //2.獲取個位，十位，百位
        //公式：
        //個位：  數(shù)字 % 10
        //十位：  數(shù)字 / 10 % 10
        //百位：  數(shù)字 / 10 / 10 % 10
        //...
        int ge = number % 10;
        int shi = number / 10 % 10;
        int bai = number / 100 % 10;
        System.out.println(ge);
        System.out.println(shi);
        System.out.println(bai);
    }
}

數(shù)字相加

數(shù)字進(jìn)行運算時，數(shù)據(jù)類型不一樣不能運算，需要轉(zhuǎn)成一樣的，才能運算。

類型轉(zhuǎn)換的分類

隱式轉(zhuǎn)換（自動類型提升）

取值范圍小的數(shù)值-->取值范圍大的數(shù)值

//范例： 
int a = 10;
double b = a;//b = 10.0

取值范圍：double>float>long>int>short>byte

隱式轉(zhuǎn)換的兩種提升規(guī)則

取值范圍小的，和取值范圍大的進(jìn)行運算，小的會先提升為大的，再進(jìn)行運算

byte、short、char 三種類型的數(shù)據(jù)在運算的時候，都會直接先提升為int，然后再進(jìn)行運算

public class Test {
    public static void main(String[] args) {
        int a = 10;//取值范圍小
        double b = 12.3;//取值范圍大
        
        double c = a + b;//+ 取值范圍小的，和取值范圍大的進(jìn)行運算，小的會先提升為大的，再進(jìn)行運算
    }
}

public class Test {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        
        int c = a + b;//byte、short、char 三種類型的數(shù)據(jù)在運算的時候，都會直接先提升為int，然后再進(jìn)行運算
    }
}

強制轉(zhuǎn)換

取值范圍大的數(shù)值-->取值范圍小的數(shù)值（如果把一個取值范圍大的數(shù)值，賦值給取值范圍小的變量。是不允許直接賦值的。如果一定要這么做就需要加入強制轉(zhuǎn)換）

格式：目標(biāo)數(shù)據(jù)類型變量名 = （目標(biāo)數(shù)據(jù)類型）被強轉(zhuǎn)的數(shù)據(jù)；

//范例： 
double a = 12.3;
int b = (int) a;

//范例： 
int a = 300;
byte b = (byte) a;//會出現(xiàn)錯誤，byte的取值范圍是-128~127，300超出取值范圍

//范例：
public class ArithmeticoperatorDemo2 {
    public static void main(String[] args) {
        byte b1 = 10;
        byte b2 = 20;
        //現(xiàn)在要強轉(zhuǎn)的是b1 + b2計算之后的結(jié)果。
        //（byte)b1 + b2 強轉(zhuǎn)的是b1，并不是最終的結(jié)果
        byte result = (byte) b1 + b2;//錯誤
        byte result = (byte) (b1 + b2);//正確
        System.out.println(result);//30
    }
}

字符串相加

字符串的“+”操作

當(dāng)“+”操作中出現(xiàn)字符串時，這個“+”是字符串連接符，而不是算術(shù)運算符了。

會將前后的數(shù)據(jù)進(jìn)行拼接，并產(chǎn)生一個新的字符串。
- ```
"123" + 123//結(jié)果是"123123"
```

連續(xù)進(jìn)行“+”操作時，從左到右逐個執(zhí)行。

1 + 99 +"世界"http://結(jié)果是"100世界"

//范例：
int age = 18;
System.out.println("剛滿" + age + "歲");//"剛滿18歲"
System.out.println("剛滿" + "age" + "歲");//"剛滿age歲"

//范例：
System.out.println(1 + 2 + "abc" + 2 + 1);//"3abc21"

練習(xí)：數(shù)值拆分

需求：鍵盤錄入一個三位數(shù)，將其拆分為個位、十位、百位后，打印在控制臺

import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
        //鍵盤錄入一個三位數(shù)，將其拆分為個位、十位、百位后，打印在控制臺

        //1.鍵盤錄入
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入一個三位數(shù)");
        int number = sc.nextInt();

        //2.獲取個位，十位，百位
        //公式：
        //個位：  數(shù)字 % 10
        //十位：  數(shù)字 / 10 % 10
        //百位：  數(shù)字 / 10 / 10 % 10
        //...
        int ge = number % 10;
        int shi = number / 10 % 10;
        int bai = number / 100 % 10;
        System.out.println("個位是" + ge);
        System.out.println("十位是" + shi);
        System.out.println("百位是" + bai);
    }
}

字符相加

當(dāng) 字符 + 字符 或 字符 + 數(shù)字 時，會把字符通過ASCLL碼表查詢到對應(yīng)的數(shù)字再進(jìn)行計算。
```
//范例：
System.out.println(1 + 'a');//98
System.out.println('a' + "abc");//"aabc"
```

自增自減運算符

基本用法

符號	作用	說明
++	加	變量的值加1
--	減	變量的值減1

注意事項：++和--既可以放在變量的前面，也可以放在變量的后面

int a = 10;
a++;//(++a;)后加加(先加加),表示將變量里面得值加1
System.out.println(a);//11

單獨使用（用法一）：++和--無論是放在變量的前邊還是后邊，單獨寫一行結(jié)果都是一樣的。

//范例：
public class ArithmeticoperatorDemo3 {
    public static void main(String[] args) {
        //++ 和 --
        int a = 10;
        //表示把變量a里面的值+1
        a++;
        System.out.println(a);//11
        //表示把變量a里面的值+1
        ++a;
        System.out.println(a);//12
        //表示把變量a里面的值-1
        a--;
        System.out.println(a);//11
        //表示把變量a里面的值-1
        --a;
        System.out.println(a);//10
    }
}

應(yīng)用場景一：

一歲-->生日后-->兩歲

int age = 1;
age++;
System.out.println(age);

應(yīng)用場景二：

購買物品增減購買數(shù)量時

-	2	+

應(yīng)用場景三：數(shù)￥號

￥	&	￥	&	￥
++		++		++

參與計算（用法二）：

先用后加
```
int a = 10;
int b = a++;//a=11,b=10
```
先加后用
```
int a = 10;
int b = ++a;//a=11,b=11
```

練習(xí)

public class ArithmeticoperatorDemo4 {
    public static void main(String[] args) {
        int x = 10;
        //后++：先用后加
        int y = x++;
        //先++：先加后用
        int z = ++x;
        System.out.println("x:" + x);//12
        System.out.println("y:" + y);//10
        System.out.println("z:" + z);//12
    }
}

賦值運算符

分類

符號	作用	說明
=	賦值	int a = 10,將10賦值給變量a
+=	加后賦值	a+ = b,將a+b的值給a
-=	減后賦值	a -= b,將a-b的值給a
*=	乘后賦值	a *= b,將a×b的值給a
/=	除后賦值	a /= b,將a÷b的商給a
%=	取余后賦值	a %=b,將a÷b的余數(shù)給a

注意事項：+=，-=，*=，/=，%= 底層都隱藏了一個強制類型轉(zhuǎn)換

//范例：
public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        //+=
        //規(guī)則：將左邊和右邊進(jìn)行相加，然后再把結(jié)果賦值給左邊
        int a = 10;
        int b = 20;
        a += b;//等同于 a = (int) (a + b);
        System.out.println(a);
        System.out.println(b);


        //細(xì)節(jié)：
        //+=，-=，*=，/=，%= 底層都隱藏了一個強制類型轉(zhuǎn)換
        short s = 1;
        s += 1;//等同于：s = (short) (s + 1);
        System.out.println(s);//2
    }
}

關(guān)系運算符

（關(guān)系運算符/比較運算符）的分類

符號	說明
==	a==b,判斷a和b的值是否相等，成立為true,不成立為false
!=	a!=b,判斷a和b的值是否不相等，成立為true,不成立為false

|a>b,判斷a是否大于b，成立為true,不成立為false
=|a>=b,判斷a是否大于等于b，成立為true,不成立為false
<|a<b,判斷a是否小于b，成立為true,不成立為false
<=|a<=b,判斷a是否小于等于b,成立為true,不成立為false
注意事項：

關(guān)系運算符的結(jié)果都是boolean類型，要么是true,要么是false。
千萬不要把“==”誤寫成“=”。

//范例：
public class CompareoperatorDemo1 {
    public static void main(String[] args) {
        //== 判斷左右兩邊是否相等
        int a = 10;
        int b = 10;
        int c = 20;
        System.out.println(a == b);//true
        System.out.println(a == c);//false
    }
}

練習(xí)--約會

需求：

您和您的約會對象在餐廳里面正在約會。

鍵盤錄入兩個整數(shù)，表示你和你約會對象衣服的時髦度。（手動錄入0~10之間的整數(shù)，不能錄其他）

如果你的時髦程度大于你對象的時髦程度，相親就成功，輸出true。

否則輸出false。

import java.util.Scanner;

public class Test2 {
    public static void main(String[] args) {
        /* 需求：
         您和您的約會對象在餐廳里面正在約會。
         鍵盤錄入兩個整數(shù)，表示你和你約會對象衣服的時髦度。（手動錄入0~10之間的整數(shù)，不能錄其他）
         如果你的時髦程度大于你對象的時髦程度，相親就成功，輸出true。
         否則輸出false。*/

        //1.鍵盤錄入兩個整數(shù)表示衣服的時髦度
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入我們自己的衣服時髦度");
        int myFashion = sc.nextInt();
        System.out.println("請輸入相親對象衣服的時髦度");
        int girlFashion = sc.nextInt();

        //2.把我衣服的時髦度跟女孩的時髦度進(jìn)行對比
        boolean result = myFashion > girlFashion;

        //3.打印結(jié)果
        System.out.println(result);
    }
}

邏輯運算符

在數(shù)學(xué)中，一個數(shù)據(jù)x，大于5，小于15，表示成：5<x<15。
在Java中，需要把上面的式子先進(jìn)行拆解，在進(jìn)行合并表達(dá)。
- 拆解為：x>5 和 x<15
- 合并后：x>5 & x<15（&：并且）

分類

符號	作用	說明
&	邏輯（且）	并且，兩邊都為真，結(jié)果才是真（兩邊都要滿足）
\|	邏輯或	或者，兩邊都為假，結(jié)果才是假（兩邊滿足一個）
^	邏輯異或	相同為false，不同為true
!	邏輯非	取反

//范例"&""|""：
public class LogicoperatorDemo1 {
    public static void main(String[] args) {
        //1. & 并且
        //兩邊都為真，結(jié)果才是真
        System.out.println(true & true);//true
        System.out.println(false & false);//false
        System.out.println(true & false);//false
        System.out.println(false & true);//false


        //2. | 或者
        //兩邊都為假，結(jié)果才是假
        System.out.println(true | true);//true
        System.out.println(false | false);//false
        System.out.println(true | false);//true
        System.out.println(false | true);//true
    }
}

使用場景一

輸入用戶名和密碼時，成功登陸的條件是：

用戶名正確并且密碼正確

使用場景二

結(jié)婚時女方要求要有

房子或者車子；（房子并且車子）

//范例"^""!"：
public class LogicoperatorDemo2 {
    public static void main(String[] args) {
        // ^ 異或
        //相同為false，不同為true
        System.out.println(true ^ true);//false
        System.out.println(false ^ false);//false
        System.out.println(true ^ false);//true
        System.out.println(false ^ true);//true


        // ! 邏輯非 取反
        //提示：
        //取反的感嘆號不要寫多次，要么不寫，要么只寫一次
        System.out.println(!false);//true
        System.out.println(!true);//false
    }
}

短路邏輯運算符

符號	作用	說明
&&	短路與	結(jié)果和&相同，但是有短路效果
\|\|	短路或	結(jié)果和\|相同，但是有短路效果

//范例：
public class LogicoperatorDemo3 {
    public static void main(String[] args) {
        //1.&&
        //運行結(jié)果跟單個&是一樣的
        //表示兩邊都為真，結(jié)果才是真
        System.out.println(true && true);//true
        System.out.println(false && false);//false
        System.out.println(false && true);//false
        System.out.println(true && false);//false


        //2.||
        //運行結(jié)果跟單個|是一樣的
        //表示兩邊都為假，結(jié)果才是假
        System.out.println(true || true);//true
        System.out.println(false || false);//false
        System.out.println(false || true);//true
        System.out.println(true || false);//true


        //3.短路邏輯運算符具有短路效果
        //簡單理解：當(dāng)左邊的表達(dá)式能確定最終的結(jié)果，那么右邊就不會參與運行了
        int a = 10;
        int b = 10;
        boolean result = ++a < 5 && ++b < 5;
        System.out.println(result);//false
        System.out.println(a);//11
        System.out.println(b);//10
    }
}

注意事項：
- &|，無論左邊 true false,右邊都要執(zhí)行。
  
  &&||，如果左邊能確定整個表達(dá)式的結(jié)果，右邊不執(zhí)行。
  
  &&：左邊為false，右邊不管是真是假，整個表達(dá)式的結(jié)果一定是false。
  
  ||：左邊為true，右邊不管是真是假，整個表達(dá)式的結(jié)果一定是true。
  
  這兩種情況下，右邊不執(zhí)行，提高了效率。
- 最常用的邏輯運算符：&&，||，!

練習(xí)--數(shù)字6

需求：

數(shù)字6是一個真正偉大的數(shù)字，鍵盤錄入兩個整數(shù)。

如果其中一個為6，最終結(jié)果輸出true。

如果他們的和為6的倍數(shù)。最終結(jié)果輸出true。

其他情況都是false。

import java.util.Scanner;

public class Test3 {
    public static void main(String[] args) {
        /*數(shù)字6是一個真正偉大的數(shù)字，鍵盤錄入兩個整數(shù)。
        如果其中一個為6，最終結(jié)果輸出true。
        如果他們的和為6的倍數(shù)。最終結(jié)果輸出true。
        其他情況都是false。*/

        //分析：
        //1.鍵盤錄入兩個整數(shù)
        // 變量a  變量b

        //2.a == 6 || b == 6 || (a + b) % 6 = 0
        //如果滿足其中一個，那么就可以輸出true


        //鍵盤錄入兩個整數(shù)
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入一個整數(shù)");
        int number1 = sc.nextInt();
        System.out.println("請輸入第二個整數(shù)");
        int number2 = sc.nextInt();

        //用短路邏輯運算符去鏈接三個判斷
        boolean result = number1 == 6 || number2 == 6 || (number1 + number2) % 6 == 0;

        System.out.println(result);
    }
}

三元運算符

需求：定義一個變量記錄兩個整數(shù)的較大值。

int number = 拿著兩個整數(shù)進(jìn)行比較
System.out.println(number);

作用：可以進(jìn)行判斷，根據(jù)判斷結(jié)果得到不同的內(nèi)容

格式（三元運算符/三元表達(dá)式）

格式：關(guān)系表達(dá)式 ? 表達(dá)式1 : 表達(dá)式2；

范例：求兩個數(shù)的較大值。

int max = a > b ? a : b;//把三元運算符的結(jié)果賦值給一個變量
System.out.println(a > b ? a : b);//把三元運算符的結(jié)果直接打印

//范例：
public class TernaryoperatorDemo1 {
    public static void main(String[] args) {
        //需求：使用三元運算符，獲取兩個數(shù)的較大值

        //分析：
        //1.定義兩個變量記錄兩個整數(shù)
        int number1 = 10;
        int number2 = 20;

        //2.使用千元運算符獲取兩個整數(shù)的較大值
        //格式：關(guān)系表達(dá)式 ? 表達(dá)式1 : 表達(dá)式2；
        //整個三元運算符的結(jié)果必須要使用

        int max = number1 > number2 ? number1 : number2;
        System.out.println(max);

        System.out.println(number1 > number2 ? number1 : number2);
    }
}

計算規(guī)則
- 首先計算關(guān)系表達(dá)式的值
- 如果值為true，表達(dá)式1的值就是運算結(jié)果
- 如果值為false，表達(dá)式2的值就是運算結(jié)果

練習(xí)1--兩只老虎

需求：

動物園里有兩只老虎，體重分別通過鍵盤錄入獲得，

請用程序?qū)崿F(xiàn)判斷兩只老虎的體重是否相同。

import java.util.Scanner;

public class Test4 {
    public static void main(String[] args) {
        /*需求：動物園里有兩只老虎，體重分別通過鍵盤錄入獲得，
        請用程序?qū)崿F(xiàn)判斷兩只老虎的體重是否相同。*/

        //分析：
        //1.鍵盤錄入兩只老虎的體重
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入第一紙老虎的體重");
        int weight1 = sc.nextInt();
        System.out.println("請輸入第二紙老虎的體重");
        int weight2 = sc.nextInt();
        //2.比較
        //相同  不同

        String result = weight1 == weight2 ? "相同" : "不同";
        System.out.println(result);
    }
}

練習(xí)2--求最高身高的和尚

需求：

一座寺廟里住著三個和尚，已知他們的身高分別為150cm、210cm、165cm，

請用程序?qū)崿F(xiàn)獲取這三個和尚的最高身高。

public class Test5 {
    public static void main(String[] args) {
        /*需求：一座寺廟里住著三個和尚，已知他們的身高分別為150cm、210cm、165cm，
        請用程序?qū)崿F(xiàn)獲取這三個和尚的最高身高。*/


        //1.定義三個變量記錄三個和尚的身高
        int height1 = 150;
        int height2 = 210;
        int height3 = 165;
        //2.拿著第一個和尚和第二個和尚進(jìn)行比較
        //再拿著結(jié)果跟第三個和尚進(jìn)行比較即可
        int temp = height1 > height2 ? height1 : height2;
        int max = temp > height3 ? temp : height3;

        System.out.println(max);
    }
}