第五章 运算符

1 运算符

1.1 算术运算符

算术运算符：
    +  求和
    -  相减
    *  乘积
    /  商
    %  求余数(求模)
​
    ++ 自加1
    -- 自减1
​
对于++运算符来说：
    可以出现在变量前，也可以出现在变量后。
    不管出现在变量前还是后，总之++执行结束之后，变量的值一定会自加1
​
​
public class OperatorTest01{
    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);  // 3
        System.out.println(a % b);  //1
​
        // 重点掌握 ++ 和 --
        // ++ 自加1（++可以出现在变量前，也可以出现在变量后。）
        int i = 10;
        i++;  // i变量自加1
        System.out.println(i);  // 11
​
        int k = 10;
        ++k;  // k变量自加1
        System.out.println(k);  // 11
​
        // 研究：++出现在变量前和变量后有什么区别？
        // 先看++出现在变量后。
        // 语法：当++出现在变量后，会先做赋值运算，再自加1
        int m = 10;
        int n = m++;
        System.out.println(n);  // 10
        System.out.println(m);  // 11
​
        // ++出现在变量前呢
        // 语法规则：当++出现在变量前的时候，会先进行自加1的运算，然后再赋值
        int x = 100;
        int y = ++x;
        System.out.println(x);
        System.out.println(y);
​
        // 题目
        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
    }
}
​

1.2 关系运算符

​
/*
    关系运算符：
        >
        >=
        <
        <=
        ==
        !=
​
    一定要记住一个规则：
        所有的关系运算符的运算结果都是布尔类型，不是true就是false，不可能是其他值。
​
    在java语言中：
        =：赋值运算符
        ==：关系运算符，判断是否相等。
​
    注意：关系运算符中如果有两个符号的话，两个符号之间不能有空格。
*/
​
public class OperatorTest02{
    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.3 逻辑运算符

​
/*
    逻辑运算符：
        &   逻辑与（可以翻译成并且）
        |   逻辑或（可以翻译成或者）
        !   逻辑非（取反）
        &&  短路与
        ||  短路或
​
    非常重要：
        逻辑运算符的两边要求都是布尔类型，并且最终的运算结果也是布尔类型
​
    100 & 200  不行，语法错误
    100 & true  不行，语法错误
    true & false  这样可以。
*/
​
public class OperatorTest03{
    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
​
        int a = 100;
        int b = 101;
        int c = 90;
        // 对于逻辑或呢？
        // 只要有一边是true，结果就是true。
        System.out.println(false | false);  // false
        System.out.println(false | true);  // true
        System.out.println(true | true);  // true
​
        System.out.println(!false);  // true
        System.out.println(!true);  // false
​
        /*
            关于短路与 &&，短路或 ||
​
            短路与&& 和 逻辑与 & 有什么区别？
                首先这两个运算符的运算结果没有任何区别，完全相同。
                只不过“短路与&&”会发生短路现象。
​
            什么是短路现象呢？
                当通过判断左边的表达式就可以得出结果的时候，右边表达式不再执行
​
            什么时候使用&&，什么时候使用& ？
                从效率方面来说，&&比&的效率高一些。
                因为逻辑与&不管第一个表达式结果是什么，第二个表达式一定会执行
                以后的开发中，短路与&&和逻辑与&还是需要同时并存的。
                    大部分情况下都建议使用短路与&&
                    只有当既需要左边表达式执行，又需要右边表达式执行的时候，才会选择逻辑与&。
        */
        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）
        System.out.println(x > y & x > y++);  // x > y这个结果已经是false了，其实整个表达式的结果已经确定是false了，按道理来说，右边的表达式没有必要执行了。
        // 通过这个测试得出：x > y++这个表达式执行了。
        System.out.println(y);  // 12
​
        int m = 10;
        int n = 11;
        // 当使用短路与&&的时候，当左边的表达式为false的时候，右边的表达式不执行，这种现象被称为短路现象。
        System.out.println(m > n && n++);
        System.out.println(n);  // 11
​
        // 问题：什么时候发生短路或现象？
        // || 短路或
        // “或”的时候只要有一边是true，结果就是true。
        // 所以，当左边的表达式结果是true的时候，右边的表达式不需要执行，此时会短路。
    }
}

1.4 赋值运算符

赋值运算符：
    1、赋值运算符包括“基本赋值运算符”和“扩展赋值运算符”
    2、基本赋值运算符？
        =
    3、扩展的赋值运算符？
        +=
        -= 
        *=
        /=
        %=
        注意：扩展赋值运算符在编写的时候，两个符号之间不能有空格
    4、使用扩展赋值运算符的时候，永远都不会改变运算结果类型。 
        byte x = 100;
        x += 1;
        x自诞生以来是byte类型，那么x变量的类型永远都是byte。不会变。不管后面累加的数字多大。
​
​
public class OperatorTest04{
    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);
​
        // 研究：
        // i += 10 和 i = i + 10 真的完全一样吗？
        // 答案：不一样，只能说相似，其实本质上并不是完全相同的。
        // 100没有超出byte类型的取值范围，可以直接赋值
        byte b1 = 100;  
​
        // 分析：这个代码是否能够编译通过
        // 错误：不兼容的类型：从int转换到byte可能会有损失
        // x = x + 1;  // 编译器检测到x + 1是int类型，int类型可以直接赋值给byte类型的变量x吗？ 
​
        // 使用扩展赋值运算符可以吗？
        // 可以的，所以得出结论：x += 1 和 x = x + 1不一样。
        // 其实 x += 1 等同于：x = (byte)(x + 1);
        int x = 100;
        x += 1;
        System.out.println(x);  // 101
​
        // 早就超出byte的取值范围了。
        x += 199;  // x = (byte)(x + 199);
        System.out.println(x);  // 44（会损失精度）
​
        int j = 100;
        j += 100;
        System.out.println(j);  // 200
​
        j -= 100;
        System.out.println(j);  // 100
​
        j *= 10;
        System.out.println(j);  // 1000
​
        j /= 3;
        System.out.println(j);  // 33
​
        j %= 10;
        System.out.println(j);  // 3
    }
​
}
​

1.5 三目运算符

条件运算符（三目运算符）：
    语法格式：
        布尔表达式 ? 表达式1 : 表达式2
    执行原理是什么？
        布尔表达式的结果为true时，表达式1的执行结果作为整个表达式的结果。
        布尔表达式的结果为false时，表达式2的执行结果作为整个表达式的结果。
public class OperatorTest05{
    public static void main(String[] args){
​
        // 这里会编译出错吗？
        // 错误：不是语句
        // 100;
​
        // 错误：不是语句
        // '男';
​
        boolean sex = false;
        // 分析以下代码是否存在语法错误？ 
        // 错误：不是语句
        // sex ? '男' : '女';
        // 前面的变量的c的类型不能随意编写。
        // 最终的计算结果是字符型，所以变量也需要使用char类型
        char c = sex ? '男' : '女';
        System.out.println(c);
​
        // 错误：不兼容的类型：条件表达式中的类型错误
        // char x = sex ? '男' : '女';
        // System.out.println(x);
​
        // 这样可以吗？可以
        System.out.println(sex ? '男' : '女');
    }
}
​

1.6 字符串连接运算符

+ 运算符：
    1、 + 运算符在java语言中有两个作用。
        作用1：求和
        作用2：字符串拼接
    2、什么时候求和？什么时候进行字符串的拼接呢？
        当 + 运算符两边都是数字类型的时候，求和。 
        当 + 运算 符两边的任意一边是字符串类型，那么会进行字符串拼接操作。
    3、一家要记住：字符串拼接完之后的结果还是一个字符串。
​
​
public class OperatorTest06{
    public static void main(String[] args){
​
        // 定义一个年龄的变量。
        int year = 18;
        // + 在这里会进行字符串的拼接操作。
        System.out.println("年龄：" + year);
​
        int a = 100;
        int b = 200;
        // 这里的 + 两边都是数字，所以做加法运算
        int c = a + b;
        System.out.println(c);
​
        // 注意：当一个表达式当中有多个加号的时候
        // 遵循自左向右的顺序依次执行。（除非额外添加了小括号，小括号的优先级高）
        // 第一个 + 先运算，由于第一个 + 左右两边都是数字，所以会进行求和。
        // 求和之后结果是300，代码就变成了：System.out.println(300 + "110");
        // 那么这个时候，由于 + 的右边是字符串"110"，所以此时的 + 会进行字符串的拼接。
        System.out.println(a + b + "110");  // 最后是字符串“300110”
​
        // 先执行小括号当中的程序：b + "110"，这里的 + 会进行字符串拼接。
        // 拼接之后的结果是："200110"，这个结果是一个字符串类型。
        // 代码就变成了：System.out.println(a + "200110");
        // 这个时候的 + 还是进行字符串的拼接，最终结果是：“100200110”
        System.out.println(a + (b + "110"));
​
        // 在借助上面已经定义好的变量在控制台上输出"100+200=300"
        // 分析这个结果是多少？
        // 以下表达式中没有小括号，所以遵循自左向右的顺序依次执行。
        System.out.println(a + "+" + b + "=" + a + b);  // 100+200=100200
        
        // 和上面程序不一样的地方是：最后一个括号先执行，并且会先进行求和运算。
        System.out.println(a + "+" + b + "=" + (a + b));
​
        // 在java语言中怎么定义字符串类型的变量呢？
        // int是整数型，i是变量名，10是字面量
        // int i = 10;
        // String是字符串类型，并且String类型不属于基本数据数据范畴，属于引用类型。
        // name是变量名，只要是合法的标识符就可以。
        // "jack" 是一个字符串型字面量
        String name = "xiaohong";  
        // 口诀：加一个双引号""，然后双引号之间加两个加号："++"，然后两个加号中间加变量名
        System.out.println("登录成功欢迎" + name + "回来");
    }
}
​

 

​
// 大家讨论最多的一个问题
​
public class HomeWork01{
    public static void main(String[] args){
​
        int i = 10;
        i = i++;
        // 大部分同学都会认为这个i是11
        // 这个i这是最终的结果是10
        // 首先，第一点：这种代码以后不会有人写。
        // 其次：第二点：没必要讨论这个问题，因为在c++中运行结果确实是11
        // java中运行结果是10
        // c++中运行结果是11
        // 为什么？因为java和c++的编译器是不同的人开发的，原理不同。 
        System.out.println(i);
​
        // 在java语言中i++，这种表达式在执行的时候，，会提前先将i变量找一个临时变量存储一下。
        // c++中没有这样做
        /*
        int k = 10;
        k = k++;
        */
        int k = 10;
        // k = k++; 对应的是下面三行代码
        int temp = k;
        k++;
        k = temp;
        System.out.println(k);
​
    }
}
​

​
public class HomeWork02{
    public static void main(String[] args){
        int x = 10;
        int a = x + x++;  // 该行代码只要结束，x就是11
        System.out.println("a =" + a);  // 20
        System.out.println("x =" + x);  // 11
​
        int b = x + ++x;
        System.out.println("b =" + b);  // 23
        System.out.println("x =" + x);  // 12
​
        int c = x + x--;
        System.out.println("c =" + c);  // 24
        System.out.println("x =" + x);  // 11
​
        int d = x + --x;
        System.out.println("d =" + d);  // 21
        System.out.println("x =" + x);  // 10
    }
}
​

​
public class Homework03{
    public static void main(String[] args){
        int i = 5;
        int j = 5;
        int m = 5;
        int n = 5;
        i++;  // 这行代码执行结束之后，i是6
        j = j + 1;  // 这行代码执行结束之后，j是6
        m--;  // 这行代码执行结束之后，m是4
        n = n - 1;  // 这行代码执行结束之后，n是4
        System.out.println(i);  // 6
        System.out.println(i++);  // 6（虽然输出结果是6，但是这行代码执行结束之后i就是7了）
        System.out.println(++i);  // 8（这行代码执行结束之后，i本身的值变成了8）
        System.out.println(i--);  // 8（这行代码执行结束之后，i本身的值变成了7）
        System.out.println();
        System.out.println(j);  
        System.out.println(j++);
        System.out.println(j--);
        System.out.println(--j);
        System.out.println();
        System.out.println(m);
        System.out.println(n);
    }
}
​

​
/*
    1、输出信息到控制台
        System.out.println(...);
    2、在java中怎么接收键盘的输入呢？
*/
​
public class KeyInput{
    public static void main(String[] args){
​
        // 创建一个键盘扫描器对象
        java.util.Scanner s = new java.util.Scanner(System.in);
​
        // 接收用户的输入，从键盘上接收一个int类型的数据
        // 代码执行到这里的时候，会暂停下来，等待用户的输入，用户可以从键盘上输入一个整数，然后回车，回车之后userInputNum就有值了。并且该变量中保存的这个值是用户输入的数值。
        // 如果输入的不是数字，那么会出异常：InputMismatchException
        int userInputNum = s.nextInt();
        System.out.println(userInputNum);
​
        // 我们怎么从键盘上接收一个字符串呢？
        // 程序执行到此处会停下来，等待用户的输入，用户可以输入字符串
        String name = s.next();
        System.out.println(name);
​
        System.out.print("请输入用户名：");
        String name1 = s.next();
        System.out.println("你的名字是:" + name1);
    }
}
​

​
import java.util.Scanner;
​
public class KeyInput2{
    public static void main(String[] args){
    Scanner s = new Scanner(System.in);
    int age = s.nextInt();
    System.out.println(age);
    }
}
​