java学习笔记（4）运算符

java中的运算符分为以下几种：

算数运算符	+、-、*、/、++、--、%
关系运算符	<、<=、>、>=、==、!=
布尔运算符	&&、||、&、|、!
位运算符	&、|、~、^、>>、>>>、<< &：按位与（AND） 【真真为真，真假为假，（一假即为假）】 |：按位或（OR） 【假假为假，其余全为真，（一真即为真）】 ^：按位异【相同为假，不同为真】 ~：按位非（NOT）【真则假，假则真】 >>：右移 >>>：右移，左边空出的位以0填充 <<：左移
赋值类运算符	=、+=、-=、*=、/=、%=
字符串连接运算符	+
条件运算符	?
其它运算符	instanceof、new

下面我们介绍这几种运算符，其余的后面介绍：

*算数运算符

*关系运算符

*逻辑运算符

*赋值类运算符

*字符串连接运算符

*三元运算符

---------------------------------------------

算数运算符：

/*
关于java编程之算数运算符：
+：相加、
-：相减、
*：乘积、
/：商、
++：自加1、
--：自减1、
%：取余数【取模】

注意：一个表达式中有多个运算符，运算符有优先级，不确定的加小括号()，优先级得到提升。

*/

public class OperatorTest01{
    public static void main(String[] args){
        int i = 10;
        int j = 3;
        System.out.println(i + j);//
        System.out.println(i - j);//
        System.out.println(i * j);//
        System.out.println(i / j);//
        System.out.println(i % j);//1

        // 以下以++为例，--运算符相同
        // 关于++运算符，【自加1】
        int k = 10;
        // ++运算符可以出现在变量后面【单目运算符】
        k++;
        System.out.println(k);//
        int y = 10;
        // ++运算符可以出现在变量前面【单目运算符】
        ++y;
        System.out.println(y);//11
        // 小结
        // ++运算符可以出现在变量前，也可以出现在变量后，无论是变量前还是变量后，
        // 只要++运算结束，该变量的值一定会自加1

        // ++出现在变量后
        // 规则：先做赋值运算，再对变量中保存的值自加1
        int a = 100;
        int b = a++;
        System.out.println(a);//
        System.out.println(b);//100

        // ++出现在变量之前
        // 先进行自加1运算，再进行赋值操作。
        int m = 20;
        int n = ++m;
        System.out.println(m);//
        System.out.println(n);//21

        // 分析一下以下代码，println实际上也是java基础库里的一个方法，是先将mm赋值给println中的一个形参，是stream流，其实mm到println中有一个赋值过程
        int mm = 500;
        System.out.println(mm);//

        int e = 100;
        System.out.println(e++);//100  括号内有个赋值过程，++在变量后，所以打印之后还未自加1
        //相当于： println(int x = e++)
        System.out.println(e);//

        int s = 100;
        System.out.println(++s);//
        System.out.println(s);//

    }
}

 关系运算符：

/*
关于java编程之关系运算符：
>    大于
>=   大于等于
<    小于
<=   小于等于
==   等于等于
!=   不等于
注意：关系运算符的运算结果一定是布尔值：true/false
*/  

public class OperatorTest01{
    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

    }
}

逻辑运算符：

/*
逻辑运算符：
    &      逻辑与    （两边的算子都是真，结果才是真）
    |      逻辑或    （两边的算子只要有一个是真，结果就是真）
    !      逻辑非    （取反）
    ^      逻辑异或   （两边的算子只要不一样，结果就是真） true^true 是假  false^false 是假  ture^false是真

    &&     短路与     这个和逻辑与最终运算结果是相同的
    ||     短路或     这个和逻辑或最终运算结果是相同的

    特点：
    1、逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型。
    2、短路与和逻辑与，最终的运算结果是相同的，只不过短路与存在短路现象。
    3、短路或和逻辑或，最终的运算结果是相同的，只不过短路或存在短路现象。
    4、什么时候发生短路现象？
            当第一个算子就可以确定运算结果时，后面的表达式就不用执行了，这种现象较短路现象。
    5、什么时候选择使用短路与运算符？什么时候选择逻辑与运算符？
            大多使用短路与就行了，当要求两边的算子必须执行时，就需要用逻辑与。

*/  

public class OperatorTest01{
    public static void main(String[] args){
        // 运算符优先级不确定可以加小括号
        System.out.println(5>3 & 5>2);//true
        System.out.println(5>3 | 5>2);//true
        System.out.println(!(5>2));//false
        System.out.println(5>3 ^ 5>2);//flase

        // 逻辑与和短路与
        int x = 10;
        int y = 8;
        // 逻辑与
        System.out.println(x < y & ++x < y);//false
        System.out.println(x);//11    这里的++x执行了

        int m = 10;
        int n = 8;
        // 短路与
        System.out.println(m < n && ++m < n);//false   在这里当计算过m<n为假时就已经判断出这个表达式为假了，所以发生短路现象，后面的++m就没执行
        System.out.println(m);//10   这里的++m没有执行

        // 从某个角度来看，短路与更智能。由于后面的表达式可能不执行，所以执行效率较高。
        // 所以短路与比逻辑与使用的多。
        // 如果要求两边的表达式都要执行，就必须使用逻辑与。
    }
}

 赋值运算符：

/*
    *赋值运算符
        赋值类运算符包括两种：
            1、基本的赋值运算符
                =
            2、扩展的赋值运算符
                +=
                *=
                /=
                %=
            *赋值类运算符优先级：先执行等号右边的表达式，将执行结果赋值给左边的变量。
            *注意以下代码：
                byte i = 10;
                i += 100;等同于 i = (byte)(i+100);

                int k = 10;
                k += 5;等同于 k = (int)(k+5);

                long x = 10L;
                int y = 20;
                y +=x;等同于x = (int)(x+y);
            *重要结论
                扩展类的赋值运算符不改变运算结果类型，假设最初这个变量的类型是byte
                类型，无论怎么追加或追减，最终该变量的数据类型还是byte类型
*/  

public class OperatorTest01{
    public static void main(String[] args){
        // 基本的赋值运算符
        int i = 10;
        System.out.println(i);//
        i = i + 5;
        System.out.println(i);//15
        // 扩展的赋值运算符[加等可以翻译为"追加/累加"]
        i += 5;//等同于 i=i+5;
        System.out.println(i);//
        i -=5;//等同于 i=i-5;
        System.out.println(i);//
        i *=2;
        System.out.println(i);//
        i /= 4;
        System.out.println(i);//
        i %= 2;
        System.out.println(i);//1
        // ----------------------------------
        // 10没有超出byte取值范围，可以直接赋值
        byte b = 10;
        // 以下编译错误，为什么？
        // 编译器只检查语法，不执行运算，编译器发现b+5的类型是int类型，而b变量是byte类型
        // 大容量向小容量转换需要加强制类型转换符，所以以下程序编译报错。
        // b = b + 5;

        // 纠正错误
        b = (byte)(b + 5);
        System.out.println(b);//

        byte x = 10;
        x += 5;//这样却不会报错！！！！因为此表达式等同于 x = (byte)(x+5); 其实并不等同于x=x+5
        System.out.println(x);//

        byte z = 0;
        z += 128;//等同于 z = (byte)(z+128);
        System.out.println(z);//精度损失  -128

        z += 10000;//等同于z = (byte)(z+10000);  所以编译不会报错，但运行会损失精度
        System.out.println(z);//-112
    }
}

字符串连接运算符：

/*
    *字符转连接运算符 +
    1、java语言中 + 运算符有两个作用：
        *加法运算符，求和
        *字符串的连接运算符

    2、当"+"两边的数据都是数据的话，一定进行加法运算。
    3、当"+"两边的数据有一个是字符串的话，一定会进行字符串连接运算。
        并且连接运算之后的结果还是字符串类型。

        数字 + 数字 = 数字 【求和】
        数字 + 字符串 = 字符串 【字符串连接】
    4、在一个表达式当中可以出现多个"+",在没有添加小括号的情况下，遵循自左向右的顺序依次执行。

*/  

public class OperatorTest01{
    public static void main(String[] args){
        System.out.println(10 + 20);//求和 30
        System.out.println(10 + 20 + 30);//求和 60
        System.out.println(10 + 20 + "30");//字符串连接 3030

        int a = 10;
        int b = 20;
        //要求 在控制台输出 10 + 20 = 30；
        System.out.println("10 + 20 = 30");
        // 注意，要求以动态的方式输出
        System.out.println("10 + 20 =" + (a + b));//10 + 20 = 30
        System.out.println(a + " + " + b + " = " + (a + b));//10 + 20 = 30

        // 引用类型String
        // String是SUN在java中提供的字符串类型
        // String.class字节码文件
        int i = 10;

        // String是引用数据类型，s是变量名，"abc"是String类型的字面值
        // String s = "abc";

        // 编译错误   类型不兼容
        // String ss = 10;
        // 定义一个String类型的变量，起名username，赋值"张三"
        String username = "张三";
        System.out.println("登录成功，欢迎"+username+"回来");//登录成功，欢迎张三回来

    }
}

三目运算符/条件运算符/三元运算符:

/*
    *三元运算符/三目运算符/条件运算符
        1、语法规则：
            布尔表达式?表达式1:表达式2
        2、三元运算符的执行原理？
            当布尔表达式的结果是true的时候，选择表达式1做为整个表达式的执行结果。
            当布尔表达式的结果是false的时候，选择表达式2做为整个表达式的执行结果。

*/  

public class OperatorTest01{
    public static void main(String[] args){
        // 编译错误，不是语句
        // 10;
        // 编译错误，不是语句
        // "男";

        // 布尔类型的变量
        boolean sex = false;
        // 分析以下程序是否可以编译通过
        // 下面代码 相当于   '女';   不是语句，编译无法通过。
        // sex ? '男' : '女';

        char c = sex ? '男' : '女';//相当于 char c = '女';
        System.out.println(c);//女 

        sex = true;
        c = sex ? '男' : '女';//相当于 char c = '男';
        System.out.println(c);//男

        // 类型错误 结果有可能是String也有可能是char，但是不能用char接收数据
        // 类型不兼容
        // char c1 = sex ? "男" : '女';

        // 可以
        System.out.println(sex ? "男" : '女');//男     这方法很牛

        // 可以  类型兼容
        String s = sex ? "男的" : "女的";
        System.out.println(s);//男的
    }
}

。