java语言基础--运算符

一、算术运算符：

       +、-、*、/、%、++（自加）、--（自减）

       对于++运算符来说：

可以出现在变量前，也可以出现在变量后

不管++出现在变量前还是后，总之++执行结束后，变量的值一定会自加1

public class OperatorTest{
    public static void main(String[] args) {
        
        int a = 10;
        int b = 3;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);
        System.out.println(a % b);
        
        //重点掌握++和--
        //++可以出现在变量前，也可以出现在变量后
        int i = 10;
        //i变量自加1
        i++;
        System.out.println(i);//11
        
        int k = 10;
        //k变量自加1
        ++k;
        System.out.println(k);//11
        
        //语法：当++出现在变量后，会先做赋值运算，再自加1
        int m = 20;
        int n =m++;
        System.out.println(n);//20
        System.out.println(m);//21
        
        //语法规则：当++出现在变量前时，会先进行自加1的运算，然后再赋值
        int x = 100;
        int y = ++x;
        System.out.println(x);//101
        System.out.println(y);//101
    }
}

练习：

public class Test {
    public static void main(String[] args) {
        //题目
        int c = 90;
        System.out.println(c++);//90
        //分解上面程序：先赋值后运算
        //int temp = c++;
        //System.out.println(temp);
        System.out.println(c);//91
        
        int d = 80;
        System.out.println(++d);//81
        System.out.println(d);//81
    }
}

二、关系运算符：

>、>=、<、<=、==、!=

规则：所有的关系运算符的运算结果都是布尔类型，不是true就是false

在java语言中：

=：赋值运算符

==：关系运算符，判断是否相等

注意：关系运算符中如果有两个符号的话，两个符号之间不能有空格

public class Test {
    public static void main(String[] args) {
        
        int a = 10;
        int b = 10;
        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);//true
        System.out.println(a != b);//false
    }
}

三、逻辑运算符：

&（逻辑与）、|（逻辑或）、！（逻辑非）、&&（短路与）、||（短路或）

      并且                 或者               取反

特点：逻辑运算符要求两边都是布尔类型，并且最终的运算结果也是布尔类型

1、&（逻辑与）、|（逻辑或）、！（逻辑非）

public class Test {
    public static void main(String[] args) {
        
        //对逻辑&来说，只要有一边是false，结果就是false
        //只有两边同时为true结果才为true
        System.out.println(true & true);//true
        System.out.println(true & false);//false
        System.out.println(false & false);//false
        
        //逻辑或是只要有一边是true，结果就是true
        System.out.println(true | true);//true
        System.out.println(true | false);//true
        System.out.println(false | false);//false
        
        //逻辑非：取反
        System.out.println(!true);//false
    }
}

2、&&（短路与）、||（短路或）

短路与 和 逻辑与 有什么区别？

• 这两个运算符的运算结果没有任何区别，完全相同。
• 只不过 短路与 会发生短路现象

短路现象：右边表达式不执行

什么时候使用&&，什么时候使用&

• 从效率方面，&&比&的效率高一些
• 因为逻辑与&不管第一个表达式结果是什么，第二个表达式一定会执行。
• 以后的开发中，短路与&&和逻辑与&还是同时并存的
• 大部分情况下都建议使用短路与&&，只有当既需要左边表达式执行，又需要右边表达式执行的时候，才会选择逻辑与&

什么时候发生短路或||现象？

• 只要有一边true，结果就是true
• 所以当左边的表达式结果是true的时候，右边的表达式不要执行，此时会短路

public class Test {
    public static void main(String[] args) {
        //&，&&运行结果一样
        System.out.println(true & true);//true
        System.out.println(true & false);//false
        System.out.println(false & false);//false
        
        System.out.println(true && true);//true
        System.out.println(true && false);//false
        System.out.println(false && false);//false
        
        //短路现象，什么会发生短路现象
        int x = 10;
        int y = 11;
        //逻辑与什么时候为true(两边都为true，结果才是true)
        //左边 x>y表达式结果是false了，整个表达式的结果都是false
        //按理来说右边的表达式不应该执行
        System.out.println(x>y & x>y++);
        //通过这个测试得出：x>y++这个表达式执行了
        System.out.println(y);//12
        
        //测试短路与&&
        int m = 10;
        int n =11;
        //使用短路与的时候，当左边的表达式为false的时候，右边表达式不执行，
        //这种现象被称为短路现象
        System.out.println(m>n && m>n++);
        System.out.println(n);//11
        
    }
}

四、赋值运算符：

1、赋值运算符包括：基本赋值运算符 和 扩展赋值运算符

2、基本赋值运算符：=

3、扩展赋值运算符：+=、-=、*=、/=、%=

注意：扩展赋值运算符在编写的时候，两个符号之间不能有空格

4、很重要的语法机制：

• 使用扩展赋值运算符的时候，永远都不会改变运算结果类型

byte x = 100；

x += 1；

x自诞生以来是byte类型，那么x变量的类型永远都是byte类型。不管后面是多大的数字

public class Test{
    public static void main(String[] args) {
        //赋值运算符“=”右边优先级比较高，先执行右边的表达式
        //然后将表达式执行结果放到左边“盒子”中（赋值）
        int i = 10;
        //重新赋值
        i = 20;
        byte b = 10;
        b = 20;
        
        /*
           以 +=运算符作为代表，学习扩展赋值运算符
         其他运算符原理相似
         */
        int k = 10;
        k += 20;//k变量追加20
        System.out.println(k);//30
        
        int m = 10;
        //+=运算符类似于下面表达式
        m = m + 20;
        System.out.println(m);//30
        
        //研究：i += 10 和 i = i + 10真的完全一样吗？
        //答案：不一样，只能说相似，其实本质上并不是完全相同
        byte x = 100;
        System.out.println(x);
        
        //分析：这个代码是否能编译通过
        //错误：不兼容的类型：从int转换到byte可能有损失
        //x=x+1;//编译器检测到x+1是int类型，int类型可以直接赋值给byte类型的变量吗？
        
        //使用扩展赋值运算符可以吗？
        //可以，所以得出结论：x += 1;和 x = x+1;不一样
        //其实：x += 1 等同于：x = (byte)(x+1);
        x += 1; 
        System.out.println(x);//101
        
        //早就超出byte的取值范围了
        x += 199;//x = (byte)(x+199);
        System.out.println(x);//44(自动损失精度)
        
        
        int a = 100;
        a +=100;
        System.out.println(a);//200
        
        a -=100;
        System.out.println(a);//100
        
        a *= 10;
        System.out.println(a);//1000
        
        a /= 30;
        System.out.println(a);//33
        
        a %= 10;
        System.out.println(a);//3
        
    }
}

五、条件运算符：（三目运算符）

语法格式：

• 布尔表达式 ？表达式1 ：表达式2

执行原理：

• 布尔表达式的结果为true时，表达式1的执行结果作为整个表达式的结果。
• 布尔表达式的结果为false时，表达式2的执行结果作为整个表达式的结果。

public class Test {
    public static void main(String[] args) {
        
        //合法的java语句
        //表示声明一个变量，起名i
        int  i = 100;
        
        //错误：不是语句
        //The left-hand side of an assignment must be a variable
        //100;
        
        boolean sex = false;
        
        //分析以下代码是否存在语法错误？
        //错误：不是语句
        //Void methods cannot return a value
        //sex ? '男' : '女';
        
        //前面的变量的类型不能随意编写
        //最终的计算结果是字符型，所以变量也需要使用char类型
        char  c = sex ? '男' : '女';
        System.out.println(c);
        
        //错误：不兼容的类型：条件表达式中的类型错误
        //char x = sex ? '男' : "女";
        //System.out.println(x);
        
        //这样可以吗
        System.out.println(sex ? '男' : "女");//这里很牛，什么类型数据都可以放
        
        
    }
}

六、字符串连接运算符：

/*
   +运算符：
   1、+运算符在java语言中有两个作用
               作用1：求和
               作用2：字符串拼接
   2、什么时候求和？什么时候进行字符串拼接？
               当+运算符两边都是数字类型的时候，求和
               当+运算符两边的任意一边是字符串类型，那么这个+会进行字符串拼接操作。
   3、一定要记住：：字符串拼接完之后结果还是一个字符串。
 */
public class Test1 {
    public static void main(String[] args) {
        //定义一个年龄的变量
        int age = 35;
        //+在这里会进行字符串的拼接操作
        System.out.println("年龄=" + age);//年龄=35
        
        int a = 100;
        int b = 200;
        //+ 加法运算
        int c = a + b;
        System.out.println(c);//300
        
        //注意：当一个表达式中有多个加号的时候
        //遵循自左向右的顺序依次执行（除非加小括号，小括号优先级高）
        //先求和后拼接
        System.out.println(a + b + "110");//300110
        System.out.println(a + (b + "110"));//100200110
        
        //在控制台上输出“100+200=300”
        //以下有效的运算符+一共有4个，均为字符串拼接操作
        System.out.println(a + "+" + b + "=" + c);
        
        //分析这个结果是多少
        //拼接后的结果是 100+200=100200；
        System.out.println(a + "+" + b + "=" + a + b);
        //小括号里的+是求和操作
        System.out.println(a + "+" + b + "=" + (a + b));//100+200=300
        
        //在java语言中怎么定义字符串类型的变量
        //String是字符串类型，String是引用数据类型
        //name是变量名，合法标识符
        //“jack”是字符串型字面量
        String name = "jack";
        
        //错误：类型不兼容
        //String = 100;
        
        //口诀：加一个双引号""，双引号之间加两个加号++，两个加号中间加变量名："+变量名+"
        System.out.println("登陆成功欢迎"+name+"回来");
    }
}