【Java】运算符

运算符

        是对字面量或者变量进行操作的符号

基本算数运算符

package com.dazz.type;

public class TypeDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;
        System.out.println(a + b);// 13
        System.out.println(a - b);// 7
        System.out.println(a * b);// 30
        System.out.println(a % b);//1
        System.out.println(a / b);// 3
        
        System.out.println(a / b *1.0);// 3.0
        System.out.println(a *1.0 / b);//3.333333....
    }
}

1.算数运算符有哪些？

        + - * / %

2. / 需要注意什么？

        如果是两个整数做除法运算，其结果一定是整数，因为最高类型是整数

 + 符号做连接符

        "+" 符号与字符串运算的时候是用作连接的，其结果依然是一个字符串

        能算则算，不能算就在一起

public class OperatorDemo {
        public static void main(String[] args) {
            int a =5;
            System.out.println("abc"+'a');//abca
            System.out.println("abc"+a);//abc5
            System.out.println(5+a);//10
            System.out.println("abc"+5+'a');//abc5a
            System.out.println(a+'a');//102
            System.out.println(a+""+'a');//5a
            System.out.println(a+'a'+"dazz");//102dazz
            System.out.println("dazz"+a+'a');//dazz5a
            System.out.println("dazz"+(a+'a'));//dazz102
        }
}

+ 除了做基本数学运算，还有哪些功能？

        与字符串做+运算时会被当成连接符，其结果还是字符串

        能算则算，不能算在一起

自增自减运算符

注意：++和--  既可以放在变量的后边，也可以放在变量的前边

           ++和--  只能操作变量，不能操作字面量

自增自减的使用注意事项

        ++ -- 如果不是单独使用(如在表达式中，或者同时有其它操作)，放在变量前后会存在明显区别

        放在变量的前面，先对变量进行+1，-1，再拿变量的值进行运算。

                        int a = 10;

                        int rs = ++a;

        放在变量的后面，先拿变量的值进行运算，再对变量的值进行+1，-1。

                        int b = 20;

                        int rs = b++;

public class OperatorDemo {
    public static void main(String[] args) {
//        单独使用没有区别
        int i = 10;
        int j = i++;//  11
        int j2 = ++i;// 11

        int i1 = 10;
        int j3 = i--;//  11
        int j4 = --i;// 11
        
//        整体使用：++/--变量在前，先增先减，在使用变量
        int a = 10;
        int b = ++a;
        System.out.println(a);// 11
        System.out.println(b);// 11
        
//        整体使用：++/--变量在后，在使用变量，先增先减
        int a1 = 10;
        int b1 = a1++;
        System.out.println(a1);// 11
        System.out.println(b1);// 10
    }
}

1.自增，自减运算符是什么，有什么作用？

        ++ -- 对当前变量值+1，-1

2.自增，自减运算符变量前后有区别吗？

        如果单独使用放前后是没有区别的

        非单独使用：在变量前，先进行变量自减/自减，再使用变量

        非单独使用：再变量后，先使用变量，再进行变量自增/自减

基本赋值运算符

        就是"="：int a = 10;

先看"="右边，把数据10赋值给左边的变量a存储

扩展赋值运算符

注意：扩展的赋值运算符隐含了强制类型转换 

public class OperatorDemo {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;
        i+=j;// 30 等于i =（类型强转）i+j

        byte i1 = 10;
        byte j2 = 20;
        i1+=j2;// 30 等于i1 = （类型强转）i1+j1
//        错误：i1 = i1+j2;
    }
}

1.赋值运算符有那些？

        =，+=，-=，*=，/=，%=

2.作用是什么？

        基本作用是赋值，扩展运算符还自带了强制类型转换

        +=还可以实现数据的累加，把别人的数据加给自己 

关系/条件运算符

        是对数据进行条件判断的符号，最终会返回一个比较的布尔结果(true,false)。

注意：在做相等判断时，千万不要把  ==  误写成  =

public class OperatorDemo {
    public static void main(String[] args) {
        int i = 10;
        int j = 10;
        boolean b = i==j ;
        System.out.println(b);//true
        
        System.out.println(i == j);//true
        System.out.println(i != j);//false
        System.out.println(i > j);//false
        System.out.println(i >= j);//true
        System.out.println(i < j);//false
        System.out.println(i <= j);//true
    }
}

逻辑运算符

        可以把多个条件的布尔值结果放在一起运算，最终返回一个布尔结果

短路逻辑运算符

论性能来说，& | 两边都需要执行，所以&& ||性能更优

public class OperatorDemo {
    public static void main(String[] args) {
        int i = 10;
        int j = 10;
//      &（逻辑与） 都是true，结果才是true，只要有1个false，结果是false
        System.out.println(i > 1 & j > 1);
        // true
        System.out.println(i > 100 & j > 1);
        // false
        System.out.println(i > 1 & j > 100);
        // false
        System.out.println(i > 100 & j > 100);
        // false

//      |（逻辑或） 只要有1个true，结果就是true
        System.out.println(i > 1 | j > 1);
        // true
        System.out.println(i > 100 | j > 1);
        // true
        System.out.println(i > 1 | j > 100);
        // true
        System.out.println(i > 100 | j > 100);
        // false

//      !（逻辑非）!true=false  !false=true
        System.out.println(!true);// false
        System.out.println(!false);// true

//      ^（逻辑异或） 2个条件都是false，结果是false
//      ^（逻辑异或） 2个条件都是true，结果是false
//      ^（逻辑异或） 2个条件结果不同为，结果是true
        System.out.println(false^false);// false
        System.out.println(true^true);// false
        System.out.println(false^true);// true
        System.out.println(true^false);// true

//      &&（短路与/双与） 左边为false，右边不执行
        System.out.println(i > 100 && ++j > 1);
        // false
        System.out.println(j);//10
        
        System.out.println(i > 1 && ++j > 100);
        // false
        System.out.println(j);//11

//      ||（短路或/双或） 左边为true，右边不执行
        System.out.println(i > 100 || ++j > 1);
        // false
        System.out.println(j);//12
        
        System.out.println(i > 1 || ++j > 100);
        // false
        System.out.println(j);//12
    }
}

逻辑运算符有那些，有什么优点？

        逻辑与&      有一个为false，结果是false

        短路与&&    一个为false，结果是false，前一个为false，后一个条件不执行

        逻辑或|        有一个为true，结果是true

        短路或||       一个为true，结果是true，前一个为true，后一个条件不执行

        逻辑非!        !true = false，!false = true

        逻辑异或^   相同时false，不同是true

 三元运算符

        格式：条件表达式?值1:值2

执行流程：首先计算关系表达式的值，如果值为true，返回值1，如果为false，返回值2

public class OperatorDemo {
    public static void main(String[] args) {
        double d = 99.0;
        String s = d >= 100 ? "满分":"加油";
        System.out.println(s);// 加油

        int a = 10;
        int b = 100;
        int max = a>b?a:b;
        System.out.println(max);// 100

    }
}

运算符优先级

& 比 | 优先级大，优先级大的先执行

public class OperatorDemo {
    public static void main(String[] args) {
// 优先级
        System.out.println(10 > 3 || 10 > 3 && 10 < 3);
        // true
        
        System.out.println((10 > 3 || 10 > 3)&&10 < 3);
        // false
    }
}