Java核心运算符

---

前言

---

一、算术运算符概述

1.运算符概述

(1)运算符的定义

• 运算符：对常量和变量进行运算操作的符号
• 程序对数据进行运算时要用运算符

(2)常见的运算符

(3)表达式

表达式：用运算符把常量或变量连接起来的式子

表达式的类型：

表达式的类型为表达式运算结果的数据类型
举例：
整数表达式：1+2 10*20
布尔型表达式：2>1 (20-10)<15

2.算术运算符概述

算术运算符：用来进行算术运算的符号

注意事项：

• /：除法运算符，得到两个数据相除的商。
  特点：Java中整数除以整数结果还是整数。
• 取模（取余）运算，得到两个数据相除的余数。
  特点：可以用来判断两个数是否能够整除。
• 浮点数参与运算，结果是浮点数类型

package cn.itcast.demo;

public class OperatorDemo1 {
    public static void main(String[] args) {
        //定义两个int类型的变量
        int a = 5;
        int b = 3
                
        System.out.println(a+b);//8
        System.out.println(a-b);//2
        System.out.println(a*b);//15
        System.out.println(a/b);//1
        System.out.println(a%b);//2
        System.out.println("----------------------");
        
        System.out.println(5/4);//1
        System.out.println(5.0/4);//1.25
        System.out.println(5/4.0);//1.25
    }
}

二、字符和字符串参与加法运算

1.加法运算（+）的特点

• 加号两边是数值型数值时，进行加法运算
  ‘a’，‘0’等字符型数据参与运算时，用该字符在计算机中所表示的数值进行运算。

字符	0	……	9
计算机中存储的值	48	……	57
字符	a	……	z
计算机中存储的值	97	……	122
字符	A	……	Z
计算机中存储的值	65	……	90

• 加号两边有任意一百年是字符串时，进行字符串的拼接
• 字符型数据参与运算，是用字符在计算机中存储的数据来运算

package cn.itcast.demo;

/**
 * 字符参与加法运算，其实就是拿该字符在计算机中存储的数值来运算的。
 * ‘a’ 97
 * ‘A’ 65
 * ‘0’ 48
 * <p>
 * 字符串参与加法运算，其实这里不是加法，而是字符串的拼接
 */
public class OperatorDemo2 {
    public static void main(String[] args) {
        //字符的加法运算
        //定义两个变量，int，char
        int a = 10;
        char ch = 'a'; //97
        System.out.println(a + ch); //107

        //字符串的加法运算
        System.out.println("hello" + "world"); //"helloworld"
        System.out.println("hello" + 10); //"hello10"
        System.out.println("hello" + 10 + 20);//"hello10"+20-->"hello1020"
        System.out.println(10 + 20 + "hello");// 30+"hello"-->"30hello"
    }
}

三、自增和自减运算符

自增和自减（++和–）运算

• ++：自增1

• --：自减1

• 单独使用：放在变量前或变量后结果一样

• 参与运算：
  在变量前，先自增（自减），再进行其他运算
  在变量后，先以原值进行其它运算，再自增（自减）

package cn.itcast.demo;

/**
 * 自增运算符（++）演示：
 * 作用：
 * 表示自身的值 +1
 * 用法：
 * 单独使用：放在变量前或后结果一样，都是自身+1
 * 参与运算：
 * 在变量前，先自增，再以新值进行其它运算
 * 在变量后，先以原值进行其他运算，再自增
 */
public class OperatorDemo3 {
    public static void main(String[] args) {
        //定义一个int类型的变量
        int a = 5;

        //单独使用
        //a++;
       /* ++a;
        System.out.println(a);
        //下述输出语句的结果是：把字符串“a：”和变量a的值进行拼接
        System.out.println("a:" + a);*/

        //参与运算
        //++在后
        /* int b = a++;
        System.out.println("a:"+a);//a:6
        System.out.println("b:"+b);//b:58
        */

        //参与运算
        // ++ 在前
        int b = ++a;
        System.out.println("a:" + a);
        System.out.println("b:" + b);
    }
}

四、赋值运算符

1.常见的赋值运算符

2.扩展赋值运算符的好处

省略了强制类型转换的操作

用法：

 int a = 10;
 a+=20;//相当于a=a+20；
 System.out.println(a);//30

好处：
自动强转

short s = 1;
//s=s+1;//报错
s+=1;//相当于s = （short）（s + 1）；
 System.out.println("s:" + s);// 2

package cn.itcast.demo;

/**
 * 赋值运算符：
 * 基本的赋值运算符：
 * =
 * 扩展的赋值运算符：
 * +=，-=，*=，/=，%=
 */
public class OperatorDemo4 {
    public static void main(String[] args) {
        //基本的赋值运算符
        int a = 10;//把10赋值给变量a
        System.out.println("a:" + a);
        System.out.println("----------------");

        //扩展的赋值运算符：
        //+=的作用：把左右两边的数据相加，然后把结果赋值给左边：a = a + 20;
        a += 20;
        System.out.println("a:" + a);
        
        // 扩展赋值运算符的好处
        short s = 2;
        //s = s + 1;//为什么报错？因为s+1的结果是一个int类型的数据赋值给short类型的变量，肯定不行。
        //怎么解决呢?
        //方案一：强制转换类型
        s = (short) (s + 1);
        System.out.println("s:" + s);
        System.out.println("-------------");

        //方案二：通过扩展赋值运算符实现
        s += 3;
        System.out.println("s:" + s);
    }
}

3.注意

= 表示赋值操作，不是相等

== 用来表示相等

五、关系运算符

关系运算符

• 定义：关系运算符是用来描述两个变量值之间的关系的。
• 关系运算符的运算结果都是布尔（Boolean）类型，要么是true，要么是false。
  
• 关系运算符是用来描述两个变量的大小是否为相等关系的
• 常见的关系运算符：>,<,==,!=,>=,<=
• 注意：关系运算符== 和赋值运算符= 的区别

package cn.itcast.demo;

/**
 * 关系运算符：
 * 分类：
 * ==，！=，>，>=,<,<=
 * <p>
 * 运算结果：
 * 关系运算符操作完毕后的运算结果肯定是Boolean类型
 * <p>
 * 注意事项：
 * 千万不要把==写成了=
 */
public class OperatorDemo5 {
    public static void main(String[] args) {
        //定义三个变量
        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);//判断变量a和变量b的值是否相等，false
        System.out.println(a=b);//将变量b的值赋值给变量a，然后打印结果，20
    }
}

六、逻辑运算符

• 用于判断“并且”、“或者”、“除非”等逻辑关系。
• 逻辑运算符两端一般连接值为布尔类型的关系表达式或逻辑表达式。
• 逻辑运算符的运算结果为布尔值：true或false
• 偶数个逻辑非！结果不变

常见的逻辑运算符

1. &&：逻辑与，并且
2. ||：逻辑或，或者
3. ！： 逻辑非，表示否定

package cn.itcast.demo;

/**
 * 逻辑运算符：
 *      分类：
 *          逻辑与：&&，并且的关系，要求所有条件都满足，即有false则整体为false
 *          逻辑或：||，或者的关系，要求只要满足任意一个条件即可，即有true则整体为true
 *          逻辑非：！，取反的意思，以前为false，现在为true；以前为true，现在为false
 *
 *      注意：
 *          偶数个逻辑非，结果不变
 */
public class OperatorDemo6 {
    public static void main(String[] args) {
        //案例：韦小宝找媳妇

        //刚开始眼光比较高，要求即要长的好看，还要身材好
        //前面的true表示：长的好看，false表示长的不好看
        //后面的true表示：身材好，false表示身材不好
        System.out.println(true&&true);//输出结果：true
        System.out.println(true&&false);//输出结果：false
        System.out.println(false&&true);//输出结果：false
        System.out.println(false&&false);//输出结果：false
        System.out.println("--------------------");

        //韦小宝发现那样的媳妇不好找，于是降低了择偶标准，只要长的好看，或者身材好
        System.out.println(true||true);//true
        System.out.println(true||false);//true
        System.out.println(false||true);//true
        System.out.println(false||false);//false
        System.out.println("---------------------");

        //韦小宝发现那样的媳妇不好找，于是降低了择偶标准，只要不是男的就行
        //true：女  false：男
        System.out.println(!true);//false
        System.out.println(!false);//true
        System.out.println("---------------");

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

七、三元运算符

三元运算都又叫“三目运算符”，即由三部分组成，格式如下：（关系表达式）？表达式1：表达式2；

运算流程：

• 如果关系表达式结果为true，运算后的结果是表达式1
• 如果关系表达式结果为false，运算后的结果是表达式2

案例：
要求：求两个整数的最大值
思路：

1. 定义两个int型的变量
2. 关系表达式中比较两个变量的最大值
3. 根据结果返回最大值，并打印

package cn.itcast.demo;

/**
 * 三元运算符：
 * 概述：
 * 也叫三目运算符，即由三部分组成的。
 * <p>
 * 格式：关系表达式？表达式1：表达式2；
 * <p>
 * 执行流程：
 * 先判断关系表达式是否成立，
 * 成立，执行表达式1；
 * 不成立，执行表达式2.
 */
public class OperatorDemo7 {
    public static void main(String[] args) {
        //需求：求两个整数的最大值
        //1.定义两个变量记录两个整数
        int a = 10;
        int b = 20;

        //2.通过三元运算符计算他们的最大值
        int max = (a >= b) ? a : b;

        //3.将结果打印到控制台上
        System.out.println("max:" + max);
    }
}