运算符

运算符

运算符：进行特定操作的符号。例如 +

表达式：用运算符连起来的式子。例如：20 + 5，a + b

算术运算符

四则运算

加：+

减：-

乘：*

除：/

取模（取余数）：%

• 首先计算得到表达式的结果，然后再打印输出这个结果

• 对于一个整数的表达式来说，除法用的是整除，整数除以整数，结果仍然是整数。只看商，不看余数

  只有对于整数除法来说，取模运算符才有余数的意义

注意事项

1. 一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种

public class test1 {
    public static void main(String[] args){
        //两个常量可以进行数学运算
        System.out.println(20 + 30);

        //两个变量也可以进行数学运算
        int a = 20;
        int b = 30;
        System.out.println(a - b); //-10

        //变量常量之间可以混合使用
        System.out.println(a * 10); //200

        int x = 10;
        int y = 3;
        int result1 = x / y;
        System.out.println(result1); //3

        int result2 = x % y;
        System.out.println(result2); //1 余数，模

        //int + double -->double + double = double
        //数据类型不一样就先变成一样的再运算，最后的结果就是数据类型大的那个
        double result3 =  x + 2.5;
        System.out.println(result3); //12.5
    }
}

四则运算中的“+”有常见的三种用法

1. 对于数值来说，那就是加法

2. 对于字符char类型来说，在计算之前，char会被提升为int，然后再计算

   char类型字符和Int类型数字之间的对照关系表：ASCII,Unicode

3. 对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作

   任何数据类型和字符串进行连接的时候，结果都会编程字符串

	//字符串类型变量基本使用
        //数据类型 变量名称 = 数据值；
        String str1 = "hello";
        System.out.println(str1); //hello

        System.out.println("hello" + "world" ); //helloworld

        String str2 = "java";
        //String + int --> String
        System.out.println(str2 + 20); //java20

        //优先级问题
        //String + int  + int
        //String        + int
        //String
        System.out.println(str2 + 20 + 30); //java2030

        System.out.println(str2 + (20 + 30)); //java50  记住小括号中的东西总是最先执行的，小括号里也可以套小括号

自增运算符：++

自减运算符：–

基本含义：让一个变量涨一个数字1，或者减一个数字1

使用格式：写在变量名称之前或者之后。例如：++num 也可以num++

使用方式：

1. 单独使用：不和其他任何操作混合，使自己独立成为一个步骤
2. 混合使用：和其他操作混合，例如与赋值混合，或者与打印操作混合，等

使用区别：

1. 再单独使用时，++在前或者在后没有任何区别

2. 再混合使用时，有重大区别

   • 如果是“前++”，那么变量立刻马上+1，然后拿着结果进行使用 先加后用
   • 如果是“后++”，那么首先使用变量本来的数值，然后再让变量+1 先用后加

   注意事项

   • 只有变量才可以使用自增自减运算符，常量不可发生改变，所以不能用

   		int num1 = 10;
           System.out.println(num1); //10
           ++num1; //单独使用，前++
           System.out.println(num1); //11
           num1++; //单独使用，后++
           System.out.println(num1); //12
   
           //与打印操作混合的时候
           int num2 = 20;
           //混合使用，先++，变量立刻马上变成21，然后打印结果为21
           System.out.println(++num2); //21
           System.out.println(num2); //21
   
           int num3 = 30;
           //混合使用，后++，首先使用变量本来的30，然后让变量+1得到31
           System.out.println(num3++); //30
           System.out.println(num3); //31
   
           int num4 = 40;
           //和赋值操作混合
           int result1 = --num4; // 混合使用，前--。白能量立刻马上-变成39，然后再将39交给result变量
           System.out.println(result1); //39
           System.out.println(num4); //39
   
           int num5 = 50;
           //混合使用，后--，首先把本来的数字50交给result2，然后自己-1变成49
           int result2 = num5--;
           System.out.println(result2); //50
           System.out.println(num5); //49
   
           int x = 10;
           int y = 20;
           int result3 = ++x + y--;
           System.out.println(result3); //31
           System.out.println(x); //11
           System.out.println(y); //19

赋值运算符

基本赋值运算符：就是一个等号“=”，代表将右侧的数交给左侧的变量

复合赋值运算符：

​ += a += 1 相当于 a = a + 1

-= b -= 4 相当于 b = b - 4

​ *= c *= 5 相当于 c = c * 5

​ /= d /= 6 相当于 d = d / 6

​ %= e %= 7 相当于 e = e % 7

注意事项：

1. 只有变量才能使用赋值运算符，常量不能进行赋值
2. 复合赋值运算符其中隐含了一个强制类型的转换

	int a = 10;
        //按照公式进行翻译：a = a + 5；
        //a = 10 + 5；
        //a = 15
        //a本来就是10，现在重新赋值得到15
        a += 5;
        System.out.println(a); //15

        int x = 10;
        x %= 3;
        System.out.println(x); //1

        byte num = 30;
        //num = num + 5
        //num = byte + int
        //num = int = int
        //num = int
        //num = (byte)int 
        num += 5;
        System.out.println(num); //35

比较运算符

大于: >

小于: <

大于等于: >=

小于等于: <=

相等: == 两个等号连写才是相等

不相等： ！=

注意事项

1. 比较运算符的结果一定是一个布尔值，成立就是true,不成立就是false

2. 如果进行多次判断，不能连着写

   数学当中的写法：1<x<3

   程序当中不允许这种写法

System.out.println(10 > 5 ); //true
        int num1 = 10;
        int num2 = 12;
        System.out.println(num1 < num2); //true
        System.out.println(num2 >= 100); //false

        System.out.println(10 == 10); //true
        System.out.println(20 != 25); //true
        System.out.println(20 >= 20); //false

逻辑运算符

与（并且） && 全都是true，才是true,否则就是false

或（或者） || 至少一个是true就是true，全都是false才是false

非（取反） ！ 本来是true 变成false ，反之一样

注意事项

1. 逻辑运算符只能用于布尔值

2. 与，或需要左右各自有一个布尔值，但是取反只要有唯一的一个布尔值即可

3. 与，或两种运算符，如果有多个条件，可以连续写

   两个条件：条件A &&条件B

   多个条件：条件A && 条件B && 条件C

tips:

对于1 < x < 3的情况，应该拆成两部分，然后使用运算符连接起来

int x = 2;

1 < x && x < 3;

        System.out.println(true && false); //false
        //true && true --> true
        System.out.println(3 < 4 && 10 > 5 ); //true

        System.out.println(true || false); //true
        System.out.println(false || false); //false

        System.out.println(true); // true
        System.out.println(!true); //false

        int a = 10;
        //false && ...
        System.out.println(3 > 4 && ++a < 100); //false
        System.out.println(a); //10 在与中，false已经错了，后面就不执行了

        int b = 20;
        //true || ...
        System.out.println(3 < 4 || ++b < 100); //true
        System.out.println(b); //20 在或中，前面已经是true了，后面没必要执行了，所以写啥都不会再执行了

三元运算符

一元运算符：只需要一个数据就可以操作的运算符。例如：！，++，–

二元运算符：需要两个。+，=

三元运算符：需要三个。

格式：

数据类型 变量名称 = 条件判断 ？ 表达式A ： 表达式B；

流程：

首先判断条件是否成立：

​ 如果成立为true，那么将表达式A的值将赋值给左侧变量；

​ 如果不成立为false，那么将表达式B的值赋值给左侧的变量；

二者选其一

注意事项：

1. 必须同时保证表达式A和表达式B都符合左侧数据类型的要求
2. 三元运算符的结果必须被使用

 	int a = 10;
        int b = 20;

        //数据类型 变量名称 = 条件判断 ？ 表达式A ： 表达式B；
        //判断a > b 是否成立，如果成立将a 的值赋给max,反之。 二者选其一
        int max =(a > b ? a : b) ;
        System.out.println("最大值：" + max); //20

        System.out.println(a > b ? a : b); //正确写法！
        //a > b ? a : b； //错误写法！  要么赋值，要么打印，不能不用它