Java基础-运算符

• 运算符
  对常量和变量进行操作的符号称为运算符
• 表达式
  用运算符把常量或者变量连接起来符号的java语法的式子就可以称为表达式。
  不同运算符连接的式子体现的是不同类型的表达式。
• 常用运算符
  算术运算符、赋值运算符、关系运算符(比较运算)、逻辑运算符和三元运算符。

算数运算符(掌握)

算数运算符概述

算术运算：和数学中的算术运算基本一致。
运算符号： + - *(×) /(÷) % (算余数 模运算) ++(自增) --(自减)
算术运算规则：

1. 在Java中进行算术运算的时候，运算符两侧的类型一致的时候，运算的结果必须和运算的数据类型保持一致。

int d = 4321 / 1000* 1000;
4321 是int类型数据
1000 是int类型数据
他们的商 必须是int类型
故4321 /1000 结果是 4 不是4.321

2. 当算术运算两侧的类型不一致的时候，结果向大的类型保持。

double d = 4321 / 1000.0* 1000;
4321 是int类型数据
1000.0 是double类型数据
他们的商 保持大类型double
故4321 /1000.0 不是4.321

public class ArithmeticOperator {
    public static void main(String[] args) {

        // 定义两个变量
        int a = 3;
        int b = 4;

        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);

        System.out.println(4321 / 1000 * 1000);//4000
        System.out.println(4321 / 1000.0 * 1000);//4321.0
    }
}

算数运算符取余和除法的区别

%：取余运算符。得到的是两个相除数据的余数。

10 % 4 = 2
4 % 10 = 4
20 % 3 = 2
/: 除法运算符,得到是两个相除数据的商。

拓展：任何一个正整数，模（%）2，结果要么是零， 要么是1。故我们经常通过将一个数对2取模以确定被除数的奇偶性。

字符和字符串参与加法操作

字符与+运算：
其实是拿该字符对应的数值来操作
‘a’ 97
‘A’ 65
‘0’ 48
字符串与+运算：
在Java中如果让字符串和+进行运算，这时这个+号变成连接符，它会把当前这个字符串和+号后面的内容连接成一个更长的字符串。

/*
 * 1整数的加法。
 * 字符参与加法操作。拿字符在计算机中底层存储对应的数据值来参与运算的。
 *      '0'     48
 *      'a'     97
 *      'A'     65
 * 字符串参与加法操作。
 *      这里的+其实不是加法，而是字符串连接符。
 */
public class CharAdd {
    public static void main(String[] args) {
        // 整数加法
        int a = 10;
        int b = 20;
        System.out.println(a + b);
        System.out.println("------------------");

        // 字符参与加法操作
        char c = '0';
        char c2 = 'a';
        System.out.println(a + c);//58
        System.out.println(a + c2);//107
        System.out.println("------------------");

        // 字符串参与加法操作
        System.out.println("hello" + a);
         // "hello"+10,然后再和b进行拼接
        System.out.println("hello" + a + b);//hello1020 
         //30hello
        System.out.println(a + b + "hello");
    }
}

算数运算符++和- - 的用法

++（自加，自增）,--（自减）运算符：对变量做加1或者减1的操作。
++或者--既可以放在变量的后面，也可以放在变量的前面。

表现形式：
++或者--在变量的右侧，举例：i++，j--；
++或者--在变量的左侧，举例：++i，--j；

单独使用的时候:
++或者--无论是放在变量的前面还是后面，结果是一样的。
参与操作的时候：
如果++或者--在变量的后面(右侧)，先拿变量参与操作，后变量做++或者--；
如果++或者--在变量的前面(左侧)，先变量做++或者--，后拿变量参与操作；

public class SelfOperation {
    public static void main(String[] args) {
        int a = 10;
        System.out.println("a:" + a);//a:10

        // 单独使用
        a++;
        ++a;
        System.out.println("a:" + a);//a:11

        // 参与操作使用
        int b = a++;//a:11 b:10
        int b = ++a;//a:11 b:11
        System.out.println("a:" + a);
        System.out.println("b:" + b);
    }
}

赋值运算符

赋值运算符分类

基本的赋值运算符：=
混合的赋值运算符：+=,-=,*=,/=,%=
如：
+=: a+=20;相当于a = (a的数据类型)(a + 20);

/*
 * 赋值运算符：
 *      A:基本    =
 *      B:混合    +=,-=,*=,...
 * 
 * +=:
 *      a+=20;
 *      相当于
 *      a = (a的数据类型)(a + 20);
 */
public class AssignmentOperator {
    public static void main(String[] args) {
        // 把10赋值给int类型的变量a
        int a = 10;

        // += 把左边和右边的数据进行运算，最后赋值给左边。左边的只能是变量
        a += 10;// 相当于a = a + 10
        System.out.println("a:" + a);
        System.out.println("----------------------");

        byte s = 10;
        // s += 20; // 相当于 s = s + 20;
        s = (byte) (s + 20);
        System.out.println("s:" + s);
    }
}

关系运算符(比较运算符)

基本使用及注意事项

关系运算符:==,!=,>,>=,<,<=
关系运算符的结果都是boolean型，也就是要么是true，要么是false。

注意事项:

• 关系运算符“==”不能误写成“=”。
• ==表示的是左右两边是否相等。如果相等结果为true，不等结果false
• = 在Java中称为赋值号。

/*
 * 比较运算符：
 */
class ComparisonOperator {
    public static void main(String[] args) {
        int a = 3;
        int b = 5;

        System.out.println(a > b);  
        //比较a和b空间中值的大小
        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=3;
2 在java中不能像数学中那样去写，必须分开两个表达式。
i>2 i<5
他们的中间就用逻辑运算符连接。

逻辑运算符概述

Java中的逻辑运算符：要求两侧的运算类型必须是boolean类型。逻辑运算符就是把多个boolean类型的值连接在一起。常见的逻辑运算符如下：
双与（短路与）&& 单与 &
双或（短路或）|| 单或 |
异或 ^ 非 !

运算规则

1. 逻辑与运算规则：
   针对逻辑与运算：当两侧都为true的时候，结果才为true。否则结果为false（一假即假）。
   true 与 true = true
   false 与 true = false
   true 与 false = false
   false 与 false = false

tips：
单与(&)和双与(&&)的区别：
双与(&&)：它在进行运算的时候，当左侧为false的时候，右侧不会参与运算。
单与（&） ：它在进行运算的时候，不管左边是什么，右边都要运算。（遵守逻辑与运算规则）

class LogicalOperatorAnd {
    public static void main(String[] args) {
        boolean flag1=10>1;//true
        boolean flag2=10<1;//false
        boolean flag3=10>5;//true
        boolean flag4=10<5;//false
        //true&&true------>true
        System.out.println(flag1&&flag3);
        //false&&true------>false
        System.out.println(flag2&&flag3);
        //true&&false------>false
        System.out.println(flag1&&flag2);
        //false&&false------>false
        System.out.println(flag2&&flag4);
    }
}

2. 或运算原则：
   针对逻辑或运算：当两侧都为false的时候，结果才为false。否则结果为true（一真即真）。
   true 或 true = true
   false 或 true = true
   true 或 false = true
   false 或 false = false

tips:单或和双或的区别：
||：当左边为true的时候，右侧的不参与运算。
|：不管左边是什么结果，右侧都要运算。

class LogicalOperatorOr{
    public static void main(String[] args) 
    {
        boolean flag1=10>1;//true
        boolean flag2=10<1;//false
        boolean flag3=10>5;//true
        boolean flag4=10<5;//false
        //true||true------>true。
        System.out.println(flag1||flag3);
        //false||true------>true。
        System.out.println(flag2||flag3);
        //true||false------>true。
        System.out.println(flag1||flag2);
        //false||false------>false。
        System.out.println(flag2||flag4);
    }
}

3. 逻辑异或：(了解)
   两侧相同,结果为false；两侧不同，结果为true。
   true ^ true = false
   false ^ true = true
   true ^ false = true
   false ^ false = false

4. 非运算:
   !true 为false ，!false 为 true

结论：逻辑运算符的运算结果也是boolean类型。

三元运算符

三元运算符的格式

变量名 = 表达式1 ? 表达式2 ： 表达式3;

三元运算符的运算原则

1. 要求表达式1 运行的结果必须是一个boolean的结果。通过表达式1的这个结果确定到底是执行表达式2还是表达式
2. 当表达式1为true，就把表达式2的结果作为三元运算的结果;当表达式1为false的时候，把表达式3的结果作为三元运算的结果。
3. 表达式1、表达式2、表达式3不能是语句，必须是表达式。
4. 三元运算符运算后必须有结果。

class TernaryOperator {
    public static void main(String[] args) {
        /*
            利用三元运算算出最大值
        */
        //定义变量
        int a = 3;
        int b = 5;
        int max;
        max=a > b ? a : b;
        System.out.println(max);
    }
}

在运行上面程序的时候，JVM遇到了三元运算，这时JVM 会先执行 a > b 这个表达式，3 > 5不成立
这时JVM 就会把变量b=5的结果作为三元运算的结果，赋值给max