java基礎------運算符

 一.運算符

　　　　　　　　1.算術運算符

　　　　　　　　　　　　+（正號、加、連接符）

　　　　　　　　　　　　　　　連接符的作用：讓任何數據都可以與字符串連接

　　　　　　　　　　　　　　　連接符要注意的事項：任何類型的數據與字符串使用連接符連接時，結果都是字符串的數據類型

class Demo1{
       public static void main(String[] args){
            byte age=+10;//"+"代表整數的符號，是正數
            System.out.println("age="+age);//輸出的結果:age=10

            int a=10;//聲明一個int類型的變量，該變量名為a,並把10賦值給變量a
            int b=20;//聲明一個int類型的變量，該變量名為b,並把20賦值給變量b
            int c=a+b;//分別取出變量a、b的值，求和，並賦值給變量c
            System.out.println("a+b="+c);//輸出的結果:a+b=30

            //任何類型的數據與字符串使用連接符連接時，結果都是字符串的數據類型
            System.out.println("Hello"+a);//輸出的結果:Hello10

            //計算機每次運算的時候只能取兩個數據運算。
            System.out.println(1+2+3+"Hello"+4+5+6);//輸出的結果:6Hello456
        } 
}

　　　　　　　　　　　　-（負號、減）

　　　　　　　　　　　　*（乘）

　　　　　　　　　　　　/（除）：做除法時求得的結果取整

class Demo2{
        public static void main(String[] args){
             int a=3;
             double b=12.0;
             //前面說過，兩個不同數據類型的數據在運算的時候，結果取決於大的數據類型
             System.out.println("b/a="+(b/a));//輸出的結果:4.0
         }
}     

　　　　　　　　　　　　%（取余/取模）：所求出的結果取余數

class Demo3{
        public static void main(String[] args){
            //java在做取模運算時，結果的正負號取決於被除數
            System.out.println("結果:"+(10%3)); //輸出的結果:1
            System.out.println("結果:"+(10%-3)); //輸出的結果:1
            System.out.println("結果:"+(-10%3)); //輸出的結果:-1
            System.out.println("結果:"+(-10%-3)); //輸出的結果:-1
        }
}     

　　　　　　　　　　　　　　　++（自增）：自增就是操作數加1

　　　　　　　　　　　　　　　前自增：++位於操作數的前面。例如：++i

　　　　　　　　　　　　　　　前自增：先自增，后使用

class Demo4{
        public static void main(String[] args){
            int a=0;
            int sum=++a;//前自增 a=a+1,sum=a
            System.out.println("sum="+sum+"a="+a);//輸出的結果:sum=1 a=1
}
} 

　　　　　　　　　　　　　　　后自增：++位於操作數的后面。例如：i++

　　　　　　　　　　　　　　　后自增：先使用，后自增

class Demo5{
        public static void main(String[] args){
            int a=0;
            int sum=a++;//后自增 sum=a,a=a+0
            System.out.println("sum="+sum+" a="+a);//輸出的結果:sum=0 a=1
　 
            /*
            i=i++原理：
            1. int temp = i; // 聲明了一個臨時變量temp用於記錄了i沒有加1之前的值。i=0,temp=0
            2. 自增。 i = i+1; i = 1;
            3. 把臨時變量temp用作了表達式的結果。
            */
　　　　 int i=0;
　　　　 i=i++;
            System.out.println("i="+i);//輸出的結果:i=0
        }
} 

　　　　　　　　　　　 --（自減）：自減就是操作數減1

　　　　　　　　　　　　　　　前自減：--位於操作數的前面。例如：--i

　　　　　　　　　　　　　　　前自減：先自減，后使用

class Demo6{
        public static void main(String[] args){
            int a=1;
            int difference=--a;//前自減 a=a-1,difference=a
            System.out.println("difference="+difference+"a="+a);//輸出的結果:difference=0 a=0
        }
} 

　　　　　　　　　　　　　　　后自減：--位於操作數的后面。例如：i--

　　　　　　　　　　　　　　　后自減：先使用，后自減

class Demo7{
        public static void main(String[] args){
            int a=1;
            int difference=a--;//后自減 difference=a,a=a-1
            System.out.println("difference="+difference+" a="+a);//輸出的結果:difference=1 a=0
        }
} 

　　　　　　　　2.賦值運算符

　　　　　　　　　　　　=（賦值）

　　　　　　　　　　　　+=（加等於）

　　　　　　　　　　　　-+（減等於）

　　　　　　　　　　　　*=（乘等於）

　　　　　　　　　　　　/=（除等於）

　　　　　　　　　　　　%=（模等於）

class Demo8 
{
    public static void main(String[] args) 
    {        
        int i = 10; // 把10賦予給i變量。
        i+=2;  // 相當於i = i+2; 
        System.out.println("i = "+i);//結果是:i=12
    
        byte b1 = 1;
        byte b2 = 2;
        b2+=b1;  //相當於b2 = b2+ b1;b2+=b1在編譯的時候，java編譯器會進行強制類型轉換，不需要我們手動去轉換。如果寫成b2=b2+b1,則需要我們手動強制類型轉換，變成b2=（byte）b2+b1;
        System.out.println("b2="+ b2);//結果是:b2=3
    }
}

　　　　　　　　3.比較運算符：比較運算符的返回結果都是布爾值

　　　　　　　　　　　　==（等於）

　　　　　　　　　　　　　　==用於比較兩個基本數據類型的時候，比較的是兩個變量存儲的值是否相等

　　　　　　　　　　　　　　==用於比較兩個引用數據類型的時候，比較的是兩個引用類型變量所記錄的內存地址是否相等

class Demo8{
public static void main(String[] args){
                int a=10;
                int b=10;
                System.out.println("a==b?",(a==b));//結果是:a==b?true
    
                String str1="Hello";
                String str2="Hello";
                System.out.println("str1==str2?",(str1==str2));//結果是:str==str2?false
    }
}     

　　　　　　　　　　　  ！=（不等於）

　　　　　　　　　　　　>（大於）

　　　　　　　　　　　　<（小於）

　　　　　　　　　　　　>=(大於等於）

　　　　　　　　　　　　<=（小於等於）

class Demo9
{
    public static void main(String[] args) 
    {
                int a = 10;
                int b =2;
                System.out.println("a!=b？"+ (a!=b) );//結果是:a!=b？true
                System.out.println("a>b？"+ (a>b) );//結果是:a>b？true
                System.out.println("a<b？"+ (a<b) );//結果是:a<b？false
                System.out.println("a>=b？"+ (a>=b) );//結果是:a>=b？true
                System.out.println("a<=b？"+ (a<=b) );//結果是:a<=b？false

                int b  = 10;
                long l = 30;
                /*兩個不同類型的數據是否可以比較呢?
                   可以的，但是兩個不同類型的數據必須是兼用的數據;這個比較的過程會先把b轉換了long類型的數據，然后再進行比較 */
                System.out.println(l>b);//true
    }
}

　　　　　　　　4.邏輯運算符：用於連接布爾表達式　

　　　　　　　　　　　　&（與）

　　　　　　　　　　　　&&（短路與）

　　　　　　　　　　　　　　規律：只有兩邊的布爾表達式同時為true，那么結果才是true；否則為false

　　　　　　　　　　　　　　&&與&的相同點及不同點：

　　　　　　　　　　　　　　　　　　相同點：&&與&的運算結果是一樣的

　　　　　　　　　　　　　　　　　　不用點：使用&&的時候，如果左邊的布爾表達式為false，則不會在運算右邊的布爾表達式，從而提高了效率；使用&的時候，即使左邊的布爾表達式為false，還是會運算右邊的布爾表達式

　　　　　　　　　　　　|（或）

　　　　　　　　　　　　||（短路或）

　　　　　　　　　　　　　　規律：只要兩邊的布爾表達式有一邊為true，結果就為true；如果兩邊同時都為false，才為false　　　　　

　　　　　　　　　　　　　　相同點：||與|的運算結果是一樣的

　　　　　　　　　　　　　   不用點：使用||的時候，如果左邊的布爾表達式為true，則不會在運算右邊的布爾表達式，從而提高了效率；使用|的時候，即使左邊的布爾表達式為true，還是會運算右邊的布爾表達式

　　　　　　　　　　　　^（異或）

　　　　　　　　　　　　　　規律：只要兩邊的布爾表達式不一致，結果就為true；如果兩邊的布爾表達式一致，則為false

　　　　　　　　　　　　!（非）　　　　

class Demo11 
{
    public static void main(String[] args) 
    {
                //&（與）
        System.out.println(true&true); //結果是:true
        System.out.println(true&false); //結果是: false
        System.out.println(false&true); //結果是:false
        System.out.println(false&false); //結果是:false
        
                //&&（短路與）
                System.out.println(true&&true); //結果是:true
        System.out.println(true&&false); //結果是:false
        System.out.println(false&&true); //結果是: false
        System.out.println(false&&false); //結果是: false

                //|（或）
        System.out.println(true|true);  //結果是: true
        System.out.println(true|false); //結果是:true
        System.out.println(false|true); // 結果是:true
        System.out.println(false|false); //結果是: false

                //||（短路或）
        System.out.println(true||true);  //結果是:true
        System.out.println(true||false); //結果是:true
        System.out.println(false||true); //結果是: true
        System.out.println(false||false); //結果是: false
        
               //^（異或）
        System.out.println(true^true);  //結果是: false
        System.out.println(true^false); //結果是:true
        System.out.println(false^true); //結果是: true
        System.out.println(false^false); //結果是: false
        
                //!（非）
        System.out.println(!true); //結果是: false
        System.out.println(!false); //結果是:true
    }
}

　　　　　　　　5.位運算符：直接操作二進制位的

　　　　　　　　　　　　&（與）

　　　　　　　　　　　　|（或）

　　　　　　　　　　　　^（異或）　　

　　　　　　　　　　　　　　規律：如果操作數A連續異或同一個操作數兩次，那么結果還是操作數A　　　

　　　　　　　　　　　　~（取反）

class Demo12{
    public static void main(String[] args){
        System.out.println(6&3); //結果是:2 
        System.out.println(6|3); //結果是:7
        System.out.println(6^3); //結果是:5
        System.out.println(~7);  // 結果是:-8
    }
}

 

　　　　　　　　6.移位運算符

　　　　　　　　　　　　<<（左移）

　　　　　　　　　　　　　　規律：一個操作數進行左移運算的時候，結果就是等於操作數乘以2的n次方，n就是左移的位數

　　　　　　　　　　　　　　3<<1=3*2^1=6

　　　　　　　　　　　　　　3<<2=3*2^2=12

　　　　　　　　　　　　>>（右移）

　　　　　　　　　　　　　　規律：一個操作數進行右移運算的時候，結果就是等於操作數除以2的n次方，n就是右移的位數

　　　　　　　　　　　　　　3>>1=3/2^1=1

　　　　　　　　　　　　　　3>>2=3/2^2=0

　　　　　　　　　　　　>>>（無符號右移）

　　　　　　　　　　　　　　無符號右移與右移的區別：進行右移運算的時候，如果操作數是一個正數，那么左邊的空缺用0補，如果操作數是一個負數，那么左邊的空缺用1補；使用無符號右移的時候，不管操作數是正數還是負數，空缺的位置都用0補

class Demo13{
    public static void main(String[] args){
        //左移：
        System.out.println(3<<1); //結果是:6 
        System.out.println(3<<2); //結果是:12
        System.out.println(3<<3); //結果是:24 

                //右移
                System.out.println(3>>1);結果是:1
                System.out.println(3>>2);//結果是:0

        //無符號右移：
        System.out.println(3>>>1); //結果是:1 
        System.out.println(3>>>2);  //結果是:0 
    }
}

　　　　　　　　7.三元運算符

　　　　　　　　　　　　格式：布爾表達式?值1:值2；

　　　　　　　　　　　　使用三元運算符要注意的細節：使用三元運算符的時候，一定要使用該表達式返回的結果或者是定義一個變量接收該表達式返回的結果

                                                   

class Demo14{
    public static void main(String[] args) {
            int age = 26;
            String result = age>=18?"成年人":"未成年人";
            System.out.println(result);//結果是:成年人

                    int a = 1;
            int b = 2;
            int c = 3;
            int result = a*b+c/2+2*(a+b)/c;
            System.out.println("result="+result);//結果是:result=5
    }
}