Java运算符

4 运算符

概述:

　运算符：

　　　对常量和变量进行操作的符号称为运算符

　表达式：

　　　　用运算符把常量或者变量连接起来符号Java语法的式子就可以称为表达式

　　　　不同运算符连接的式子体现的是不同类型的表达式

　　　　定义两个int类型的变量a，b，做加法则是(a+b)

　常用运算符:

　　　　算术运算符

　　　　赋值运算符

　　　　关系运算符

　　　　逻辑运算符

　　　　三元运算符

4.1 算术运算符:

　　算术运算符的运算数必须是数字类型。算术运算符不能用在布尔类型上，但是可以用在char类型上，因为实质上在Java中，char类型是int类型的一个子集。

　　有哪些运算符？

　　　　+  加法

　　　　-　减法

　　　　*　乘法

　　　　/　除法(取整)

　　　　%　取余

　　　　++ 自增

　　　　-- 自减

　　案例一: +,-,*,/

package com.lyc.test;

public class ArithmeticTest01 {
    /**
     * 算数运算符的基本用法:+,-,*,/
     * @param args
     */
    public static void main(String[] args) {
        //定义两个变量
        int a = 5;
        int b = 6;
        
        System.out.println(a+b);//加法
        System.out.println(a-b);//减法
        System.out.println(a*b);//乘法
        System.out.println(a/b);//除法
        
        //整数相除只能得到整数，要想得到小数，就必须有浮点数参与运算
        System.out.println(5/6.0);
        System.out.println(5.0/6);
    }

}
　　

　　案例二: / 和 % 的区别

　　　算数运算符的基本用法:/ 和 % 的区别:

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

　　　　　　/：除法运算符。得到的是两个相除数据的商(取整)

　　　　　　使用场景: %用来判断两个数据是否整除(如:判断是否是闰年)

package com.lyc.test;

public class ArithmeticTest02 {
    /**
     * 算数运算符的基本用法:/ 和 % 的区别
     * %：取余运算符。得到的是两个相除数据的余数(取余)
     * /：除法运算符。得到的是两个相除数据的商(取整)
     * 
     * 使用场景: %用来判断两个数据是否整除
     */
    public static void main(String[] args) {
        //定义两个变量
        int a = 10;
        int b = 6;
        
        System.out.println(a/b);// a/b 取整得到  1
        System.out.println(a%b);// a%b 取余得到  4
    }

}

　　案例三: 字符和字符串参与加法运算

package com.lyc.test;

public class ArithmeticTest03 {
    /**
     * 整数的加法
     * 字符参与加法的操作
     * 拿字符在计算器中底层存储对应的数据值来参与运算
     *     0--->48
     *     a--->97
     *     A--->65
     * 
     * 字符串参与加法的操作
     *     这里的“+”其实不是加法，而是讲字符串拼接起来
     * 
     */
    public static void main(String[] args) {
        //整数的加法
        int a = 10;
        int b = 20;
        System.out.println(a+b);
        System.out.println("=========================");
        
        //字符参与加法的操作
        char c = '0';
        char d = 'a';
        System.out.println(a+c);//结果为:58
        System.out.println(c+d);//结果为:145
        System.out.println("=========================");
        
        //字符串参与加法的操作
        System.out.println("hello"+a);  //结果为:hello10
        System.out.println("hello"+a+b);//结果为:hello1020
        System.out.println(a+b+"hello");//结果为:30hello
    }

}

　　案例四: 算数运算符++和--的用法

　　　　++,--运算符：对变量做加1或者减1的操作。

　　　　++或者--既可以放在变量的前面，也可以放在变量的后面。

　　　　单独使用的时候，++或者--无论是放在变量的前面还是后面，结果是一样的。

　　　　参与操作的时候：

　　　　如果++或者--在变量的前面，变量先++或者--，变量再参与操作

  　　　如果++或者--在变量的后面，变量先参与操作，变量再++或者--

package com.lyc.test;

public class ArithmeticTest04 {

    public static void main(String[] args) {
        int a = 10;
        System.out.println("a:"+a);
        
        //单独使用
        //a++;
        ++a;    //先用后加
        System.out.println("a:"+a);
        //参与操作时
        //int b = a++;
        int b = ++a;
        System.out.println("a:"+a);
        System.out.println("b:"+b);
    }

}

4.2 赋值运算符：

　　基本的赋值运算符:　=

　　扩展的赋值运算符:　+=,-=,*=,/=,%=

　　案例：

package com.lyc.test;

public class OperatorDemo {

    public static void main(String[] args) {
        /**
         *     赋值运算符:
         *         A：基本:    =
         *         B：扩展： += -= *= ......
         *     +=:
         *         a += 20;
         *         相当于 a = (a的数据类型)a + 20;
         */
        int a = 10;//把10赋值为int类型的变量a
        
        // += 把左边和右边的数据进行运算,最后赋值给左边
        a += 10;//相当于 a = a + 10;
        System.out.println("a:"+a);//结果为:20
        
        short b = 10;
        b = (short) (b+20);//相当于 a = (a的数据类型)a + 20;
        System.out.println(b);//结果为:30
    }
}

4.3 关系运算符：

　4.3.1 基本使用及注意事项:

　　关系运算符包含以下内容：

　  　　< 　　小于　　 a<b时为true，否则为false　　

　　　　　<=　 小于等于  a<=b时为true，否则为false

　　 　　　>　　大于　　　a>b时为true，否则为false

　　　　　>=　 大于等于　a>=b时为true，否则为false

　　　　　==　 等等于　　a==b时为true，否则为false

　　　　　!=　 不等于　　a!=b时为true，否则为false

　　　　　关系运算符的结果都是boolean型，也就是要么是true，要么是false。　

　　　　　关系运算符“==”不能误写成“=”。

　　案例：

package com.lyc.test;

public class OperatorDemo {

    public static void main(String[] args) {
        /**
         * 
         * 关系运算符： ==,!=,>,>=,<,<= 关系运算符的结果是boolean类型。
         * 
         * 注意： 千万不要把==写成=
         */
        int a = 10;
        int b = 20;
        int c = 10;
        // ==
        System.out.println(a==b);    //false
        System.out.println(a==c);    //true
        System.out.println("-------------------------");
        
        // !=
        System.out.println(a!=b);    //true
        System.out.println(a!=c);    //false
        System.out.println("-------------------------");
        
        // >
        System.out.println(a > b);    //false
        System.out.println(a > c);    //false
        System.out.println("-------------------------");
        
        // >=
        System.out.println(a >= b);    //false
        System.out.println(a >= c);    //true
        System.out.println("-------------------------");
        
        // <
        System.out.println(a < b);    //true
        System.out.println(a < c);    //false
        System.out.println("-------------------------");
        
        // <=
        System.out.println(a <= b);    //true
        System.out.println(a <= c);    //true
        System.out.println("-------------------------");
        
        int x = 3;
        int y = 4;
        
        System.out.println(x==y);//false
        System.out.println(x=y); //先把y的值赋值为x,然后输出    结果为4
        System.out.println(x);
        //x=y 就将y的值赋值给了x,所以此时x=4 
        boolean d = (x==y);
        System.out.println(d);//true。
        
        //报错
        //boolean e = (x=y);
        
        int e = (x=y);
        System.out.println(e);
    }

}

4.4 逻辑运算符：

　4.4.1 逻辑运算符的概述:

　　逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。

　　有哪些逻辑运算符:

　　　　&&  逻辑与  a&&b  a与b都为true，则返回true

　　　　||  逻辑或　a||b　a与b任一为true，则返回true

　　　　！  逻辑非　!a　　a为false，则返回true，即取反

　　　　^　　异或　  a^b　a与b有仅只有一个为true，则返回true

　　案例：

package com.lyc.test;

public class OperatorDemo {

    public static void main(String[] args) {
        /*
         * 逻辑运算符：用于连接关系表达式。
         * &,|,^,!
         * &&,||
         * 
         * 与：&    有false则false
         * 或：|    有true则true
         * 异或：^ 相同则false,不同则true。(男女朋友)
         * 非：!    true则false,false则true
         */
        int a = 10;
        int b = 20;
        int c = 30;

        System.out.println((a > b) & (a > c));// false & false ===>false
        System.out.println((a < b) & (a > c)); // true & false ===>false
        System.out.println((a > b) & (a < c)); // false & true ===>false
        System.out.println((a < b) & (a < c)); // true & true  ===>true
        System.out.println("---------------");
        System.out.println((a > b) | (a > c));// false | false ===>false
        System.out.println((a < b) | (a > c)); // true | false ===>true
        System.out.println((a > b) | (a < c)); // false | true ===>true
        System.out.println((a < b) | (a < c)); // true | true  ===>true
        System.out.println("---------------");
        System.out.println((a > b) ^ (a > c));// false ^ false ===>false
        System.out.println((a < b) ^ (a > c)); // true ^ false ===>true
        System.out.println((a > b) ^ (a < c)); // false ^ true ===>true
        System.out.println((a < b) ^ (a < c)); // true ^ true  ===>false
        System.out.println("---------------");
        System.out.println((a > b)); // false        ===>false
        System.out.println(!(a > b)); // !false        ===>true
        System.out.println(!!(a > b)); // !!false    ===>false
    }
}

　　4.4.2 逻辑运算符&&和&的区别:

　　&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。

　　&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式。

　　案例：

package com.lyc.test;

public class OperatorDemo {

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;

        System.out.println((a > b) && (a > c));// false && false ===>false
        System.out.println((a < b) && (a > c)); // true && false ===>false
        System.out.println((a > b) && (a < c)); // false && true ===>false
        System.out.println((a < b) && (a < c)); // true && true  ===>true
        System.out.println("---------------");
        System.out.println((a > b) || (a > c));// false || false ===>false
        System.out.println((a < b) || (a > c)); // true || false ===>true
        System.out.println((a > b) || (a < c)); // false || true ===>true
        System.out.println((a < b) || (a < c)); // true || true  ===>true
        System.out.println("---------------");

        int x = 3;
        int y = 4;
        // System.out.println((x++ > 4) & (y++ > 5)); // false & false
        System.out.println((x++ > 4) && (y++ > 5)); // false && false ===>false
        System.out.println("x:" + x);
        System.out.println("y:" + y);
    }
}

4.5 三元运算符:　

　A:格式

　　(关系表达式)?表达式1：表达式2；

　　如果条件为true，运算后的结果是表达式1；

　　如果条件为false，运算后的结果是表达式2；

　B:示例：

　　获取两个数中大数。

　　int x=3,y=4,z;

　　z = (x>y)?x:y;//z变量存储的就是两个数的大数

　案例一：

package com.lyc.test;

public class OperatorDemo {

    public static void main(String[] args) {
        /*
         * 三元运算符：
         * 格式：
         *         (关系表达式)?表达式1:表达式2;
         * 执行流程:
         *         A:计算关系表达式的值，看是true还是false
         *         B:如果是true,表达式1就是运算结果
         *               如果是false,表达式2就是运算结果
         */
        int a = 10;
        int b = 20;

        int c = (a > b) ? a : b;
        System.out.println("c:" + c);
    }
}

　　案例二：比较两个数是否相同

package com.lyc.test;

public class OperatorDemo {

    public static void main(String[] args) {
        /*
         * 三元运算符的练习 比较两个整数是否相同
         */
        // 定义两个int类型的变量
        int a = 10;
        int b = 20;

        boolean flag = (a == b) ? true : false;
        // boolean flag = (a == b);
        System.out.println(flag); // ===>false
    }
}

　　案例三: 获取三个数中的最大值

package com.lyc.test;

public class OperatorDemo {

    public static void main(String[] args) {
        // 定义三个int类型的变量
        int a = 10;
        int b = 30;
        int c = 20;

        // 先比较两个整数的大值
        int temp = ((a > b) ? a : b);
        int max = ((temp > c) ? temp : c);
        System.out.println("max:" + max);
    }
}