Java基础-运算符

 1 /*
 2     演示算术运算符
 3     + - * /
 4     %:取余
 5     ++ :针对变量操作,每次都加1.
 6     -- :针对变量操作,每次都减1.
 7         当++,--放在变量后,表示先使用,后变化.
 8         当++,--放在变量前,表示先变化,然后再使用.
 9         
10             +  :连接符,用于出现字符串的地方,简单的拼接.
11 */
12 public class ArithmeticDemo{
13     public static void main(String[] args){
14         
15         /*
16         int a = 10;
17         int b = 5;
18         
19                   //算术运算
20         System.out.println(a + b);  //15
21         System.out.println(a - b);  // 5
22         System.out.println(a * b);  //50
23         System.out.println(a / b);  //2
24         System.out.println(a % b);  // 0
25         */
26         /*
27                 // + 有重载操作:在算数运算中,它是加法,在遇到字符串时,它是连接符.
28         System.out.println("hello" + 10);   // hello10
29         
30             //注意 + 两侧的数据类型.
31         System.out.println(a + b + "world");  // 15world
32             // + 两侧都是字符串.
33         System.out.println("hello" + "\\world");  // hello\world
34             
35         System.out.println("hello" + (5 + 5));  //hello10  加()提升优先级.
36         */
37         
38         /*
39             //++表示对变量每次自增1
40         int a = 10;
41         //a++;
42         //System.out.println(a);  //11
43         
44             //--表示对变量每次减1
45         int b = 10;
46         //b--;
47         //System.out.println(b);  // 9
48         System.out.println(a++);  //10   先使用a原来的值,然后让a增加1
49         System.out.println(++b);  //11   先让变量值增加,然后使用   
50         */
51         
52         // double d = 3.14;
53         // System.out.println(++d); //4.1400000001
54         /*
55         //思考题1
56         int a = 10;
57         int b = 10;
58         int c = 10;
59         a = --c;   // c = 9, a = 9
60         b = c++;   // b = 9, c = 10
61         c = ++a;   // a = 10 , c = 10
62         System.out.println(a + "," + b + "," + c);   // a = 10 , b = 9 , c = 10
63         */
64         
65         //思考题2
66         // int a = 10;
67         // int b = 3;
68         // System.out.println(a*1.0 / b);   // 3.333333333
69                 
70         // int a = 4;
71         // int b = (++a) + (a++) + (a*10);
72         // System.out.println(a + "," + b);  // a = 6, b = 70
73                 //%结果的正负取决于被模数,就是%前面的数的正负.
74         int a = -10;
75         int b = -3;
76         System.out.println(a % b);   // -1
77         
78     }
79 }

/*
    赋值运算符的演示:
        =    就是把右边的常量(字面量),变量,表达式的值赋值给左边的变量
        扩展赋值运算符:就是一些赋值运算符的简化写法.
            +=   a += 10 ->  a = a + 10;
            -=
            *=
            /=
            %=
            特点:不改变左侧变量的数据类型.
                short s = 1;
                s = s + 1;       //报错
                s += 1;        //不改变左侧变量的数据类型

*/
public class AssignmentDemo{
    public static void main(String[] args){
        
        
        // int a = 10;                //用常量给变量赋值
        // int b = a;              //用变量给变量赋值
        // b = b + a;              //用表达式的值给变量赋值
        // System.out.println(a + "," + b);  // 10,20
        
        //连续赋值
        // int a,b,c;
        // a = b = c = 10;
        // System.out.println(a + "," + b + "," + c);  //10,10,10
        
        
        short s = 1;
        s = (short)(s + 1);
        System.out.println(s);   // 2
        
        
    }
}

/*
    比较运算符的演示
    ==
    !=
    >
    <
    >=
    <=
    instanceof:判断某个对象是否是某个类的实例.
    总结:比较运算符的结果肯定是一个boolean类型值(true/false)

*/
public class CompareDemo{
    public static void main(String[] args){
        /*
        //比较两个常量
        System.out.println(10 == 20);   //false
        
        //比较两个变量
        int a = 10;
        int b = 20;
        System.out.println(a == b); //false
        System.out.println(a != b); //true
        System.out.println(a >= b); //false
        System.out.println(a <= b); //true
        System.out.println(a > b); //false
        System.out.println(a */
        //比较表达式
        int a = 20;
        boolean b1 = a > (a - 10);
        System.out.println(b1);   //true
        
        
    }
}

/*
    逻辑操作符的演示
    &     :两个操作数都是true,结果才为true,否则就是false
    |     :两个操作数都有一个是true,其结果就为true
    &&    :短路与,当左侧操作数为false时,整体的结果已经是false,右侧就不参与运算了
    ||    :短路或,当左侧操作数为true时,整体的结果已经是true,右侧就不参与运算了.
    ^     :异或,两个操作数不同时,结果为true,否则为false
    !     :取反,单操作数,相反.


*/
public class LogicDemo{
    public static void main(String[] args){
        /*
        System.out.println(true && true);      //布尔常量进行逻辑运算
        
            //布尔类型的变量进行运算
        boolean b1 = true ;
        boolean b2 = false ;
        boolean b3 = true ;
        System.out.println(b1 & b2);   // false
        System.out.println(b1 | b2);   // true
        System.out.println(b1 && b2);  // false
        System.out.println(b1 || b2);  // true
        System.out.println(b1 ^ b2);   // true
        System.out.println(b1 ^ b3);   // false
        System.out.println(!b1);       // false
        */
        /*    
            //短路操作
        int a = 1;
        boolean b = true && (a++) > 1;    
        System.out.println(a);    //  a = 2
        System.out.println(b);    //  b = false
        */
        /*
            //&&左侧为false,直接结果为false,右侧不参与运算.
        int a = 1;
        boolean b = false && (a++) > 1;    
        System.out.println(a);    //  a = 1
        System.out.println(b);    //  b = false
        */
        
        
    }
}

/* 
    位运算符的演示:
        <<: 对操作数的二进制表示形式操作,左边移出的位丢弃,右边全以0填充
        >> : 带符号右移,左边空出的位,以符号位填充.
        >>> : 无符号右移,左边空出的位,总以0填充.
        &  : 按位与操作.
        |  : 按位或操作.
        ^  : 按位异或操作.
        ~  : 按位取反.


*/
public class BitDemo{
    public static void main(String[] args){
            
        /*
        System.out.println(3 <<2);  //  相当于3*2^2 = 12   
             //带符号右移
        System.out.println(3 >> 2);  //  0
        System.out.println(-1 >> 2);  //  -1    
        System.out.println(-1 >> 9);  //  -1    
        System.out.println(-1 >> 30);  //  -1    
        
             //无符号右移
        System.out.println(-1 >>> 1);  //  21yi    
        */
            //按位与操作
        System.out.println(3 & 6);   //  2
            //按位或操作
        System.out.println(3 | 6);   //  7
            //按位异或操作
        System.out.println(3 ^ 6);   //  5
            //按位取反
        System.out.println(~6);   //  -7
        
        
        
        
    }
}

/*
    演示三元运算符:
    格式:
        (布尔值)?表达式1:表达式2;
    ()可选,建议加上.
    
*/
public class TernaryDemo{
    public static void main(String[] args){
        //直接使用布尔常量
        System.out.println((false)?1:2);
        
        int x = (false)?1:2;//
        
        //
        // int a = 10;
        // int b = 20;
        // double d = (b > a) ? 1.0:2.0;
        // System.out.println(d);
        
        //
        // int a = 4,b = 4;
        // System.out.println((a > b) ? a : b);
        
    }
}

*
    分支结构(选择结构)
    第一种:
        if(条件表达式){
            语句体;//可以是多条语句
        }
        
    
    第二种:
        if(条件表达式){
            语句体1;//可以是多条语句
        }else{
            语句体2;//可以是多条语句
        }
    
    第三种:
        if(条件表达式1){
            语句体1;//可以是多条语句
        }else if(条件表达式2){
            语句体2;//可以是多条语句
        }else if(条件表达式3){
            语句体3;//可以是多条语句
        }
        ...
        else{
            语句体n;//可以是多条语句
        }
        
*/



public class IfDemo1{
    public static void main(String[] args){
        // int a = 150;
        /*
        if(a > 0){
            System.out.println("a > 0");
        }
        //..
        System.out.println("if后的语句");
        */
        
        /*
        //第二种格式;
        if(a > 0){
            System.out.println("a>0");
        }else{
            System.out.println("a<=0");
        }
        System.out.println("if后的语句");
        */
        /*
        //第三种格式
        if(a <0){
            System.out.println("a <0");
        }else if(a <10){ //else隐含一个条件 a >= 0,
            System.out.println("a >= 0 a <10");
        }else if(a <20){//隐含条件 a >= 10,
            System.out.println("a >= 10 a <20");
        }else{    //隐含条件 a >= 20
            System.out.println("a >= 20");
        }
        //
        System.out.println("if后的语句");
        */
        
        
        // int a = 10;
        // int b = 20;
        // if(a > 0 && b > 5){
            
        // }else{
            
        // }
        
        // System.out.println((a > b)?a:b);
        
        //if后的{}可以省略,但是此时只能控制到第一个;结束
        if(false){
            System.out.println("ok");
            System.out.println("可以");
        }
        
        //建议不论if后面有多少条语句,一定要加{}
        
        
        
    }
}

/*
    从键盘录入三个int值,取其中的最大值.
    作业:
        使用三元运算符求键盘录入的三个数中的最大值(嵌套/不嵌套)
*/
//导包
import java.util.Scanner;

public class ScannerDemo1{
    public static void main(String[] args){
        //创建扫描器对象
        Scanner s = new Scanner(System.in);

        //提示输入三个数
        System.out.println("输入第一个int值:");
        int a = s.nextInt();
        System.out.println("输入第二个int值:");
        int b = s.nextInt();
        System.out.println("输入第三个int值:");
        int c = s.nextInt();
        /*
        //if-else取最大值
        if(a > b){
            if(a > c){
                System.out.println("最大值是: " + a);
            }else{ //c >= a
                System.out.println("最大值是: " + c);
            }
        }else{//b >= a
            if(b > c){
                System.out.println("最大值是: " + b);
            }else{ //c >= b
                System.out.println("最大值是: " + c);
            }
        }
        */
        //三元运算符求最大值.
        // int Max1 = (a > b)?a:b;
        // int Max2 = (Max1 > c)?Max1:c;
        // System.out.println("最大值为: " + Max2);
        
        int Max = (((a > b)?a:b)>c)?((a > b)?a:b):c;
        System.out.println("最大值为: " + Max);
    }
}