文章目录

• 前言
• 一、运算符
• • 1、算数运算符
  • • 1.1、案例
  • 2、自增自减运算符
  • • 2.1、案例一（认识自增自减法）
    • 2.2、案例二（自增自减法运算规则）
    • 2.3、案例三（自增自减综合练习）
    • • 2.3.1、增强练习（根据上述代码，进行如下练习）
      • 2.3.2、增强结果
  • 3、关系运算符
  • • 3.1、案例一
  • 4、逻辑运算符
  • • 4.1、简单逻辑梳理
    • 4.2、案例一
  • 5、赋值运算符
  • • 5.1、案例一
  • 6、三目运算符
  • • 6.1、案例一（小杨同学找教室）
    • 6.2、案例二（小杨同学找教室-进阶版）
  • 7、加号(+)的使用
  • • 7.1、案例一(测试+号的用途)
  • 8、扩展练习

前言

提示：以下是本篇文章正文内容，下面案例可供参考

一、运算符

1、算数运算符

相信大家对算数运算符应该都很了解，无非就是加“减乘除以及取余数”

1.1、案例

（1）声明三个int类型的变量，名字分别为(a、b、c);
（2）运用三个数练习加减乘除、取余的练习操作

注意: “+”加号可以用来加法运算，也可以用来做字符串的拼接

public static void main(String[] args) {
	//1.创建三个变量，名字分别为a、b、c
	int a = 10;
	int b = 20;
	int c = 25;
	//2.加减乘除、取余运算
	//2.1.加法运算，注意这里+可以用来加法运算,也可以拼接。
	System.out.println("+是加法运算:" + (a + b));//30
	
	//2.2.减法运算
	System.out.println("-是减法运算:" + (b - a));//10
	
	//2.3.乘法运算
	System.out.println("*是乘法运算:" + (a * b));//2000
		
	//2.4.除法运算
	System.out.println("/是除法运算:" + (b / a));//2
		
	/*
	* 2.5.取余运算、也叫求模
	* 	   例如：
	* 			20 / 10 = 2 ...... 0  余数是 0
	* 			10 / 20 = 0 ...... 10 余数是 10
	* 			25 / 10 = 2 ...... 5  余数是 5 
	*/
	System.out.println("%数余数运算:" + (b % a));//0
	System.out.println("%数余数运算:" + (a % b));//10
	System.out.println("%数余数运算:" + (c % a));//5		
}

“%”的用法:
   用于判断是一个奇数还是偶数，或者是否可以被整除

（1）整数值 %2 结果为零，则这个数一定是偶数
（2）整数值 %2 结果为1， 则这个数一定是奇数
（3）整数值 %n 结果为0，则这个数一定能被n整除

2、自增自减运算符

  自增自减运算符存在于C/C++/C#/Java/等高级语言中，它的作用是在运算结束前（前置自增自减运算符）或后（后置自增自减运算符）将变量的值加（或减）1。后面我们会去具体了解

注意:
   （1）“++a” 前置自增，会先自增在输出结果
   （2）“--a”   前置自减，会先自减再输出结果
   （3）“a++” 后置自增，会先输出结果再自增
   （4）“a--”   后置自减，会先输出结果再自减

2.1、案例一（认识自增自减法）

（1）声明四个int类型的变量，名字分别为(d、e、f、g);
（2）认识前置自增和后置自增
（3）认识前置自减和后置自减

public static void main(String[] args) {
	//1.声明四个int类型的变量，名字分别为d、e、f、g
	int d = 10;
	int e = 10;
	int f = 10;
	int g = 10;
	//2.认识前置自增和后置自增
	//2.1. 前置自增,表示如果++符号出现在前面,就先自增再输出结果
	System.out.println("前置自增:" + (++d));//打印结果为:11,先为d自增1(10+1=11)然后执行打印所以结果时11
		
	//2.2. 后置自增,表示如果++符号出现在后面,就先输出结果再自增
	System.out.println("后置自增:" + (e++));//打印结果为:10,先输出e,e此时为10,然后再执行++自增1,此时e为11,我们再打印查看结果
	System.out.println(e);//打印结果为:11
		
	//3.认识前置自减和后置自减
	//3.1. 前置自减,表示如果--符号出现在前面,就先自减再输出结果
	System.out.println("前置自减:" + (--f));//打印结果为:9,先为f自减1(10-1=9)然后执行打印所以结果为9
	
	//3.2. 后置自减,表示如果--符号出现在后面,就先输出结果再自减
	System.out.println("后置自增:" + (g--));//打印结果为:10,先输出g,g此时为10,然后再执行--自增1,此时g为9,我们再打印查看结果
	System.out.println(g);//打印结果为:9		
}

2.2、案例二（自增自减法运算规则）

（1）声明两个int类型的变量（h，i）
（2）使用乘法和自增运算，并声明x，y接收结果值

注意:
   自增自减的优先级高于四则运算(前面我们将的算数运算)
   前置自增自减法(++a,--a): 先进行自增或者自减运算，再进行表达式运算;
   后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算;   

public static void main(String[] args) {
	//1.声明两个int类型的变量（h，i）
	int h=5;
	int i=5;
	
	//2.使用乘法和自增运算，并声明x，y接收结果值
	int x=2*++h;//先进行自增,然后再进行表达式运算
	int y=2*i++;//先进行表达式运算,然后再自增
	
	//3.打印结果
	System.out.println(x);//12
	System.out.println(y);//10
}

2.3、案例三（自增自减综合练习）

注意（对自增自减我们要谨记两点）:
   （1）符号在前（前置），先变化再使用；
   （2）符号在后（后置），先使用后变化；

public static void main(String[] args) {		
	//1.自增
	int a=1;
	System.out.println("后置自增:a=" + (a++));//后置自增，先运算再变化，所以这里输出还是1
	System.out.println("后置自增后的:a=" + a);//运算完就会发生变化，此时a是2
	
	int b=1;
	System.out.println("前置自增:b=" + (++b));//前置自增，先变化再运算。所以这里输出的是自增后的结果2
	System.out.println("前置自增后的:b=" + b);//运算前就会发生自增变化，所以此时的b还是2
		
	//2.自减
	int c=1;
	System.out.println("后置自减:c=" + (c--));//后置自减，先运算再变化，所以这里输出的依然是1
	System.out.println("后置自减后的:c=" + c);//运算完后才会发生改变，所以此时的c是0
	
	int d=1;
	System.out.println("前置自减:d=" + (--d));//前置自减，先变化再运算，所以这里输出的是自减后的结果0
	System.out.println("前置自减后的:d=" + d);//运算前就会发生自减变化，所以此时的d还是0
}

2.3.1、增强练习（根据上述代码，进行如下练习）

public static void main(String[] args) {		
	
	...... 这里是案例三的代码
	
	//增强练习
	/**
	 * 增强一:自增，思考如下的运算结果。a目前是几，b目前又是几，最后的运算结果是多少？
	 */
	System.out.println(++a+a+b++);//???
	/**
	 * 增强二:自减，思考如下的运算结果。三个c分别是几，最后的运算结果是多少？
	 */
	System.out.println(--c-c-c--);//???
}

2.3.2、增强结果

//增强练习
/**
 * 增强一:自增，思考如下的运算结果。a目前是几，b目前又是几，最后的运算结果是多少？
 */
System.out.println(a);//案例三,最终a得值为2
System.out.println(b);//案例三,最终b得值也为2
System.out.println(++a+a+b++);//???
System.out.println(b);
/*
 * 增强一分析:
 * 	   1.在案例三的练习中，最后a的值是2，b是的值也是2。所以此时增强一运算前的a=2，b=2
 * 	   2.在运算的过程中，加法运算所以我们从左到右看：
 * 	  	 >先是前置自增++a,前置的规则是先变化再运算,所以此时的a就都是3，此时的公式就是:3+3+b++
 * 		 >随后是后置的自增运算b++,后置的规则是先运算再变化,所以在运算的时候b此时的值依然是2，此时的公式就是3+3+2
 * 		 >最终的运算结果就是8
 * 注意，因b是后置运算，所以经过运算后b最终的值是3;
 */
		
		
/**
 * 增强二:自减，思考如下的运算结果。三个c分别是几，最后的运算结果是多少？
 */
System.out.println(c);//案例三,最终c的值为0
System.out.println(--c-c-c--);//???
System.out.println(c);
/*
 * 增强二分析:
 * 		1.再看案例三的练习中，最后c的值是0，所以在增强二运算前此时c=0
 * 		2.减法运算还是从左往右我们看一下
 * 		  >先是一个前置自减--c,前置的规则是先变化再运算,所以此时的c就都是-1，此时的公式就是(-1 减 -1 减 -1--)
 * 		  >随后是一个后置的自减运算c--,后置的规则是先运算再变化，所以在运算的时候c的值依然是-1,此时的公式就是(-1 减 -1 减 -1)
 * 		  >因为我们是负数在运算的过程中呢,可以看到(-1 减 -1)负负得正，此时运算公式就变成了(-1 + 1)所以运算结果最后是0
 * 		  >然后就是(0 减 -1)依然是负负得正，此时运算公式就变成了(0 + 1)
 * 		  >最终我们得到得运算结果是1
 * 注意:因c最后是后置运算,所以经过运算后c得值是-2;
 */

3、关系运算符

3.1、案例一

1.分别声明两个int类型的变量；
2.使用关系运算符，对操作数进行对比；

注意：false代表假，true代表真；

public static void main(String[] args) {	
	//1.分别声明两个int类型的变量
	int a = 10;
	int b = 20;
		
	//2.使用关系运算符，对操作数进行对比
	/*
	 * 2.1.“==” -- 等于
	 * 	   >等与则返回true，不等于则返回false
	 */
	System.out.println("a是否等于b: " + (a == b));//打印结果为:false,因为10不等于20,结果为假,返回false;
		
	/*
	 * 2.2.“!=” -- 不等于
	 *     >!表示非，等于则为false，不等于则为true
	 */
	System.out.println("a是否不等b: " + (a != b));//打印结果为:true,因为10不等于20,结果为真,返回true;
	
	/*
	 * 2.3.">" -- 大于
	 *	   >大于则返回true,小于则返回false
	 */
	System.out.println("a是否大于b: " + (a > b));//打印结果为:false,因为10不大于20,结果为假,返回false
		
	/*
	 * 2.4.">" -- 小于
	 *     >小于则返回true,大于则返回false
	 */
	System.out.println("a是否小于b: " + (a < b));//打印结果为:true,因为10小于20,结果为真,返回true
		
	/*
	 * 2.5.">=" -- 大于等于
	 *     >大于等于则返回true,小于则返回false
	 */
	System.out.println("a是否大于等于b: " + (a >= b));//打印结果为:false,因为10不大于也不等于20,结果为假,返回false
		
	/*
	 * 2.5."<=" -- 大于等于
	 *     >小于等于则返回true,大于则返回false
	 */
	System.out.println("a是否小于等于b: " + (a <= b));//打印结果为:false,因为10小于等于20,结果为假,返回true
}

4、逻辑运算符

逻辑与、逻辑非均有短路（逻辑运算符当能得到结果时，就不会再继续运算右边的代码，以节省空间以及一定的性能）效果:
   "&&" 左边操作数（表达式1）如果是false，右边不会执行
   "||" 左边操作数（表达式1）如果是true，右边不会执行

4.1、简单逻辑梳理

逻辑与的理解：（我请你吃饭 && 我请你唱歌）
  其实很好理解，我们可以理解为我们生活中的"并且"关系，比如吃饭唱歌，我请你吃饭并且请你唱歌。从字面我们可以看出来，只有我满足了并且的所有关系，我才不算食言，结果才为真（true），反则只要有一条没满足，我就算食言了。结果就为假（false）。


逻辑或的理解：（我请你吃饭 || 我请你唱歌）
  其实也很好理解，我们可以理解为我们生活中的"或者"关系，还是比如吃饭唱歌，我请你吃饭或者我请你唱歌。从字面意思我们可以看的出来，总共有三种可能，（1）我是要请你吃饭。（2）我请你唱歌。（3）我即请你吃饭，又请你唱歌。只要我满足其中一条关系，我就不算食言，结果就为真（true）。如果我即没请你吃饭，又没带你去唱歌，反而带你去图书馆了。只有没满足逻辑或中的任何一条关系，我就算食言了，结果就为假（false）。

总结：
  假如判断A && B，A如果是false，B无论是false，还是true，结果均为false。
  加入判断A || B，A如果是true，B无论是false，还是true，结果均为true。

4.2、案例一

（1）声明三个int类型的变量
（2）练习逻辑运算符的使用

public static void main(String[] args) {	
	//1.声明三个int类型的变量
	int a = 50;
	int b = 40;
	int c = 30;
		
	//2.练习逻辑运算符的使用
	/*
	 * 2.1.逻辑与练习
	 * 	   >必须满足"&&"两侧所有判断的条件,结果才为true,否则为false
	 */
	System.out.println("a大于b并且b大于c: " + (a > b && b > c));//打印结果为:true,(50 > 40 && 40 > 30),可以看到"&&"两侧的判断均为true,所以结果也为true
	System.out.println("a大于b并且b小于c: " + (a > b && b < c));//打印结果为:false,(50 > 40 && 40 < 30),可以看到"&&"右侧的判断为false,所以结果为false
		
	/*
	 * 2.2.逻辑或练习
	 * 	   >只有"||"两侧所有的判断条件都不成立,结果才为false,否则为true
	 */
	System.out.println("a大于b或者b小于c: " + (a > b && b < c));//打印结果为:true,(50 > 40 && 40 < 30),可以看到"||"左侧的判断为true,由于逻辑或的短路效应,他不会再判断后面的条件,直接就会返回true
	System.out.println("a小于b或者b小于c: " + (a < b && b < c));//打印结果为:false,(50 < 40 && 40 < 30),可以看到"||"两侧的判断均为false,所以结果为false
	
	/*
	 * 2.3."!"表示非,就是不的意思,取反,!true = false\!false = true
	 */
	System.out.println(!true);//打印结果为false,因为我们对true进行了取反
	System.out.println(!false);//打印结果为true,因为我们对false进行了取反
		
	/**
	 * "&&"左侧的判断(50>40)结果为true,右侧的判断(40<30)结果应为false,
	 * 但是我们对其进行了取反,右侧就也变成了true,此时左右两侧均为true。所以我们得到的最终结果就为true
	 */
	System.out.println(a > b && !(b < c));//打印结果为true,公式为:true && !false = true
		
	/**
	 * "||"左侧的判断(50<40)结果应为false,但是我们对左侧的结果进行了取反,此时左侧为true
	 * 	   因为"||"的短路效应,前面只要出现一个true,就不会进行下面的判断了,所以结果为true
	 */
	System.out.println(!(a < b) || b < c);//答应结果为true,判断公式为:!false || false = true

}

5、赋值运算符

5.1、案例一

（1）声明三个int类型的变量
（2）练习赋值运算符

public static void main(String[] args) {
	//1.声明三个int类型的变量
	int a = 10;
	int b = 20;
	int c = 0;
		
	//2.练习赋值运算符
	//2.1.“=” 赋值操作符
	c = a + b;
	System.out.println("a+b=" + c);//打印结果为30
		
	//2.2.“+=” 赋值操作符
	System.out.println("目前c=" + c);
	c += a;
	System.out.println("c+a=" + c);//打印结果为40
		
	//2.3.“-=” 赋值操作符
	System.out.println("目前c=" + c);
	c -= a;
	System.out.println("c-a=" + c);//打印结果为30

	//2.4.“*=” 赋值操作符
	System.out.println("目前c=" + c);
	c *= a;
	System.out.println("c*a=" + c);//打印结果为300

	//2.5.“/=” 赋值操作符
	System.out.println("目前c=" + c);
	c /= a;
	System.out.println("c/a=" + c);//打印结果为30
}

感觉这个应该都可以理解吧，其实和前面的加减乘除都一样，只不过简写了

6、三目运算符

如果表达式结果为true则返回值1，否则返回值2

	格式：
		布尔表达式 ? 表达式1 : 表达式2

6.1、案例一（小杨同学找教室）

  小杨同学上学分班，A班 : B班（分数在200以上包括200为A班，其余为B班）
（1）告诉小杨输入总分数，并接收小明输入的总分数。
（2）通过接收的分数判断小杨同学分到的班级
  （2.1）如果大于或等于200（true）。表示他是A班的学生。
  （2.2）如果不大于或等于200（false）。表示他是B班的学生。

这里我们会用到Scanner类，如果有不了解的可以去看笔者前面写的内容《输入个人信息、计算圆的面积、变量交换》

public static void main(String[] args) {
	//1.告诉小杨输入总分数，并接收小杨输入的总分数。
	//1.1.告诉小杨输入总分数
	System.out.println("请输入您的您的总分数:");
	//1.2.接收小杨输入的总分数
	int xiaoYang = new Scanner(System.in).nextInt();
		
	//2.判断小杨总分数是否大于等于200，如果是则为A班学生
	String SchoolClass = (xiaoYang >= 200) ? "A班级" : "B班级";
		
	//3.告诉小样分到的班级
	System.out.println("小杨同学,您的班级在:" + SchoolClass);
}

6.2、案例二（小杨同学找教室-进阶版）

  小杨同学升学了，又要分班，现在分为S班、A班 、 B班、C班
（1）告诉小杨输入总分数，并接收小明输入的总分数。
（2）通过接收的分数判断小杨同学分到的班级
  （2.1）如果大于或等于700。表示他是S班的学生。
  （2.2）如果大于等于400但小于700。表示他是A班的学生。
  （2.3）如果大于等于200但小于400。表示他是B班的学生。
  （2.4）其余学生均为C班。

希望各位读者，可以试着自己写一下。如果写不出来再去看下面的代码分析逻辑。锻炼各位的自己梳理逻辑的能力。大佬忽略哈哈~~

public static void main(String[] args) {
	//1.告诉小杨输入总分数，并接收小杨输入的总分数。
	//1.1.告诉小杨输入总分数
	System.out.println("请输入您的您的总分数:");
	//1.2.接收小杨输入的总分数
	int xiaoYang = new Scanner(System.in).nextInt();
		
	//2.判断小杨是否哪个班的同学
	String SchoolClass = (xiaoYang >= 400) ? (xiaoYang >= 700 ? "S班级" : "A班级") : (xiaoYang >= 200 ? "B班级" : "C班级");
		
	//3.告诉小样分到的班级
	System.out.println("小杨同学,您的班级在:" + SchoolClass);
}

7、加号(+)的使用

  加号可以做加法运算(要求两边都得是数值),也可以作为拼接符来使用(只要两边有一个是字符串)

7.1、案例一(测试+号的用途)

public static void main(String[] args) {
	//1.加号的两边都是数字,加号会执行加法运算
	System.out.println(18 + 5);//打印结果为23,数值与数值之间的+号表示进行加法运算
		
	//2.注意char类型底层也是数字
	System.out.println('A' + 1);//打印结果为:66 ,A在char中的表示的数为65。所以这里不会作为拼接而是转换为65进行值与值之间的加法运算
		
	//3.加号可以做为拼接符,将任意的数据和字符串拼接,加号两边只要有一个字符串,就作为拼接符使用
	System.out.println("1" + 1);//因1用双引号包裹,底层会认为是字符串,此时+号就作为拼接符来使用了
		
	//4.输出个人信息
	String name = "小杨";
	int age = 18;
	String salary = "20000";
	//name芳龄age,竟然高薪如此,月入salary
	System.out.println("姓名:"+ name + "-芳龄:" + age + "-月入:" + salary);
}

8、扩展练习

使用三目表达式判断用户输入的最大值
（1）提醒用户输入两个值
（2）接收用户数入的两个值
（3）使用三木运算符获取用户输入的值

我相信各位经历过了上面的练习，到这里应该也有思路了吧。还是那句话可以试着自己写一下。如果写不出来再去看下面的代码分析逻辑。锻炼各位的自己梳理逻辑的能力。大佬忽略哈哈~~

public static void main(String[] args) {
	//1.提醒用户输入两个值
	System.out.println("获取最大值,需要您提供两个值");
		
	//2.接受键盘输入的两个值
	Scanner scanner = new Scanner(System.in);
	int one = scanner.nextInt();
	int two = scanner.nextInt();
		
	//2.使用三目运算符获取a,b中的最大值
	//a如果大于b,为真,最大值为a,a如果不大于b,为假,最大值为b
	int max = one > two ? one : two;
	System.out.println("最大值为:"+max);
}