3-运算符

拾贰i
176 阅读12分钟

第三章 运算符

3.1 运算符介绍

运算符是一种特殊的符号，用以表述数据的比较和赋值等等。

3.2 算术运算符

算术运算符是对数值类型的变量进行运算的，在 Java 程序中使用的非常多。

3.2.1 算术运算符一览

在这里插入图片描述

算数运算符的使用： +：正 -：负 +：加 -：减 *：乘 /：除法 %：取余 公式：a % b = a - a / b * b ++：自增1 eg：i++ 等价于 i = i + 1; eg：++i 等价于 i = i + 1; 作为表达式使用： 前++：++i 先自增后赋值 后++：i++ 先赋值后自增 --：自减1

​ 前--：--i 先自减后赋值

​ 后--：i-- 先赋值后自减

public class ArithmeticOperator{
	public static void main(String[] args){
		//	/的使用
		System.out.println(10 / 4); //从数学角度是2.5 但是在java中是int所以摸出小数点
		System.out.println(10.0 / 4);//2.5

		double d = 10 / 4;

		System.out.println(d); //2.0  

		System.out.println("----------------------------");
		// % 取模（取余）
		// 在 % 的本质，看一个公式 a % b = a - a / b * b
		// -10 % 3 --> -10 - (-10) / 3 * 3 = -1
		// 10 % -3 --> 10 - 10 / -3 * -3 =  1
		// -10 % -3 --> -10 - -10 / -3 * -3 = 1
		System.out.println(10 % 3);// 1 
		System.out.println(-10 % 3);// -1
		System.out.println(10 % -3);// 1
		System.out.println(-10 % -3);// -1

		System.out.println("----------------------------");

		// ++的使用
		//
		//		
		int i = 10;
		i++;// 自增 等价于 i = i + 1；
		++i;
		System.out.println("i="+i);

		/*
		作为表达式使用
			前++：++i 先自增后赋值
			后++：i++ 先赋值后自增
		 */
		int j = 8 ;
		int k = ++j; // 等价于 j = j + 1; k = j;
		int n = j++; // 等价于 n = j  j = j + 1;
		System.out.println("k="+ k + "j=" + j);// 9 9
		System.out.println("n="+ n + "j=" + j);// 9 10

	}
}

算数运算符练习题

public class ArithmeticOperatorExercise{
	public static void main(String[] args){
		/*int i = 1 ;
		i = i++; //规则使用临时变量 1. temp = i 2. i = i + 1 ; i = temp;
		System.out.println(i);// 1*/

		/*int i = 1 ; 
		i = ++i; // i = i + 1 -> 2   temp = i ; i = temp ;
		System.out.println(i); // 2 */

		int i1 = 10;
		int i2 = 20;
		int i = i1++;
		System.out.print("i="+i);//10
		System.out.println("i2="+i2);//20
		i = --i2;// 19
		System.out.print("i="+i);//19
		System.out.println("i2="+i2);//19
	}
}

public class ArithmeticOperatorExercise01{
	public static void main(String[] args){
		//1 假如还有59天放假，合xx个星期零几天
		int days = 59;
		int week = days % 7;
		int leftDays = days / 7;
		System.out.println(days + "天 合计"+week+"个星期零"+leftDays+"天");

		//2.定义一个变量保存华氏温度，华氏温度转换公式为 5/9*（华氏温度 - 100） 
		//请求出华氏温度对应的摄氏温度
		// 分析：1.定义一个double  huaShi类型的变量来储存温度 
		// 		2.给出的公式进行计算
		// 		3.将得到结果保存到一个变量sheShi
		//3.代码
		double huaShi = 415.2;
		double sheSHi = 5.0 / 9 *(huaShi - 100); // 5 / 9  为int  = 0
		System.out.println("华氏温度"+huaShi+"度 对应的摄氏温度为"+sheSHi+"度");
	}
}

3.3 关系运算符

3.3.1 关系运算符介绍
  • 关系运算符的结果都是 boolean 型，也就是要么是 true，要么是 false
  • 关系运算符组成的表达式，我们成为关系表达式
  • 比较运算符”==“ 不能误写成”=“

在这里插入图片描述

public class RelationalOperator{
	public static void main(String[] args){
		int a = 10;
		int b = 5;
		System.out.println(a > b); //T
		System.out.println(a < b);//f
		System.out.println(a >= b);//T
		System.out.println(a <= b);//F
		System.out.println(a == b);//F
		System.out.println(a != b);//T
		boolean flag = a > b;//T
		System.out.println(flag);
	}
}

3.4 逻辑运算符

3.4.1介绍

​ 用于连接多个条件（条件表达式），最终结果为boolean类型

3.4.2 逻辑运算符一览图

在这里插入图片描述

逻辑运算符： 1.a&b: & 叫逻辑与：规则：当a 和 b 同时为true，则结果为true，否则false 2.a&&b：&& 叫短路与：规则：当a 和 b 同时为true，则结果为true，否则为false 3.a|b : | 叫逻辑或，规则：当 a 和 b ，有一个为 true ,则结果为 true,否则为 false 4.a||b : || 叫短路或，规则：当 a 和 b ，有一个为 true ,则结果为 true,否则为 false 5.!a : 叫取反，或者非运算。当 a 为 true, 则结果为 false, 当 a 为 false 是，结果为 true

​ 6.a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false

&& 和 & 基本规则

名称 语法 结果

短路与&& 条件1&&条件2 两个结果都为true，结果为true

逻辑与& 条件1&条件2 两个结果都为true，结果为true

&& 和 & 的区别 1.&&短路与：如果第一个条件为false，那么第二个条件不再进行判断，结果为false，效率高 2.&逻辑与：如果第一个条件为false，第二个条件继续进行判断，结果为false，效率低

​ 3.开发中推荐使用短路与&& 效率高

&& 和 & 案例演示

public class LogicalOperator {
	public static void main(String[] args){
		// && 和 & 的使用
		int age = 50;
		//&&的使用
		if(age > 20 && age < 90){
			System.out.println("ok100");
		}
		//&的使用
		if(age > 20 && age < 90){
			System.out.println("ok200");
		}
		//区别
		int a = 4;
		int b = 9;
		//1.&&短路与：如果第一个条件为false，那么第二个条件不再进行判断结果为false
		//&逻辑与：如果第一个条件为false，后面条件仍继续进行判断结果为false
		if(a < 10 && ++b > 5){
			System.out.println("ok300");a
		System.out.println("a=" + a + "b=" + b);
	}
}

|| 和 | 基本规则

名称 语法 结果

短路或|| 条件1||条件2 两个条件只要有一个为true，结果为true

逻辑与| 条件1|条件2 只要有一个条件成立，则为true

|| 和 | 使用区别

  • ||短路或：如果第一个条件为true，则第二个条件则不会判断，最终结果为true，效率高
  • |逻辑或：不管第一个条件是否为true，第二个条件都会判断，效率低
  • 开发中推荐使用||短路或
public class LogicalOperator01 {
	public static void main(String[] args){
		// ||短路或 和 |逻辑或 演示
		int age = 50;
		// ||短路或
		if(age > 20 || age < 30){
			System.out.println("ok110");
		}

		// |逻辑或
		if(age > 20 | age < 30){
			System.out.println("ok200");
		}

		//区别
		//|| 和 | 使用区别
		//	||短路或：如果第一个条件为true，则第二个条件则不会判断，最终结果为true，效率高
		//	|逻辑或：不管第一个条件是否为true，第二个条件都会判断，效率低
		//	开发中推荐使用||逻辑或
		
		/*int a = 4;
		int b = 9;
		if( a > 1 || ++b > 4){
			System.out.println("ok330");
		}
		System.out.println("a="+ a + "b=" + b);*/


		int a = 4;
		int b = 9;
		if( a > 1 | ++b > 4){
			System.out.println("ok330");
		}
		System.out.println("a="+ a + "b=" + b);
	}
}

！（取反）和 ^ 逻辑异或

!取反操作 T->F F->T

a^b:叫做逻辑异或 ，当 a 和 b 条件结果不同时，则结果为true，否则为false

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

		// !取反操作 T->F  F->T
		System.out.println(20 > 5);//t
		System.out.println(!(20 > 5));//f

		//a^b:叫做逻辑异或 ，当a 和 b 不同时，则结果为true，否则为false
		
		boolean b = (10 > 1 ) ^ (3 < 5);
		System.out.println(b);
	}
}

3.5 赋值运算符

3.5.1赋值运算符介绍

基本赋值运算符 "=" int a = 10; 复合赋值运算符 += ，-= ，*= ， /= ，%= 等 , 重点讲解一个 += ，其它的使用是一个道理 a += b; [等价 a = a + b; ] a -= b; [等价 a = a - b; ]

3.5.2赋值运算符特点

赋值运算符的特点： 1)运算顺序从右往左 int num = a + b + c; 2)赋值运算符的左边，只能是变量，而右边可以是变量，表达式，常量值 eg：int num = 20； int num2 = 7 * 8 - 3; 3)复合赋值运算符等价于下面的效果 eg：a += 3; 等价于 a = a + 3;其他类型也是一样 4)复合赋值运算符进行类型转换(会有一个强转) byte b = 2;

​ b += 3; 等价于 b = (byte)(b + 3);

​ b++;等价于 b = (byte)(b + 1);

3.6 三元运算符

3.6.1 三元介绍

三元运算符 基本语法：条件表达式？表达式1 ： 表达式2; 运算规则： 1）如果条件表达式为true，运算后的结果为表达式1 2）如果条件表达式为false，运算后的结果为表达式2 口诀：一真二假

public class TernaryOperator {
	public static void main(String[] args){
		int a = 10;
		int b = 99;
		int result = a < b ? a++ : b--;
		//分析
		//a > b -> F
		//输出 b--  先返回 b 的值 然后在 b -1  所以结果：99
		System.out.println(result); // 10
		System.out.println(a);//11
		System.out.println(b);// 99

	}
}

/*
	三元运算符细节
		1）表达式1和表达式2要为可以赋给接收变量的类型（自动类型转换）
		2）三元运算符可以转成if-else语句
 */

public class TernaryOperatorDeatil {
	public static void main(String[] args){
		//1）表达式1和表达式2要为可以赋给接收变量的类型（或自动类型转换或强制转换）
		int a = 3;
		int b = 8;
		int c = a > b ? (int)1.1 : (int)2.2;
		double  c1 = a > b ? a : b + 2;
	}
}

3.7 运算符优先级

  • 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。
  • 只有单目运算符、赋值运算符是从右向左运算的。
  • 一览表, 不要背，使用多了，就熟悉了.
    • （），{} ; . 等
    • 单目运算符 ++ -- ^ ~
    • 算术运算符 * / % + -
    • 位移运算符 << >> >>>
    • 比较运算符 < > <= >= instanceof == !=
    • 逻辑运算符 & ^ |
    • 三元运算符 ? :
    • 赋值运算符 = *= /= %=

在这里插入图片描述

3.8 标识符的命名规则和规范

  1. 标识符：

  • java对各种变量，方法和类等要素命名时使用的字符序列成为标识符
  • 技巧：凡是可以自己其名字的地方都叫标识符

    • 比如：类名，方法名，包名，接口名....

  1. 定义合法标识符规则：

  • 由26个英文字母大小写，0-9，_或者$组成

  • 数字不可以开头

  • 不可以使用关键字和保留字，但能包含关键字保留字

  • java种严格区分大小写，长度无限制

  • 标识符不能包含空格

  1. Java中的名称命名规范：

  • 包名：多单词组成时所有字母都小写：xxx.yyy.zzz

  • 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

  • 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz

  • 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

  1. 注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。 注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。

3.9 关键字与保留字

在这里插入图片描述

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7D07KNyE-1685024495208)(E:\Java_learning\typora_note\images\image-20230221110035361.png)]

3.10 保留字

3.10.1 介绍

Java 保留字：现有 Java 版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留 字 byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const

3.11 键盘输入语句

3.11.1 介绍

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。Input.java , 需要一个 扫描器(对象), 就是 Scanner

3.11.2 使用步骤
/*
    import java.util.Scanner;引入Java.util下的Scanner类
    Scanner scanner = new Scanner(System.in); 创建实例
    String name = scanner.next();
    int age = scanner.nextInt();
*/



import java.util.Scanner;//表示把java.until下的Scanner类导入
public class Input {
	public static void main(String[] args){
		//演示用户输入
		//步骤
		//Scanner类表示 简单文本扫描器 在java.util包
		//1.引入 Scanner类所在的包
		//2.创建Scanner对象 
		//eg：Scanner scanner = new Scanner(System.in);
		Scanner scanner = new Scanner(System.in);
		//3.接受用户输入了，使用相关方法
		System.out.println("请输入名字："); //输入名字
		String name = scanner.next();
		
		System.out.println("请输入年龄："); //输入年龄
		int age = scanner.nextInt();

		System.out.println("请输入薪水："); //输入薪水
		double salary = scanner.nextDouble();

		System.out.println("信息如下：");
		System.out.println("name =" + name + "age =" + age 
			+ "salary = " + salary);

	}
}

3.12 进制

3.12.1 进制介绍

对于整数，有四种表示方式： 二进制：0,1 ，满 2 进 1.以 0b 或 0B 开头。 十进制：0-9 ，满 10 进 1。 八进制：0-7 ，满 8 进 1. 以数字 0 开头表示。 十六进制：0-9 及 A(10)-F(15)，满 16 进 1. 以 0x 或 0X 开头表示。此处的 A-F 不区分大小写。

3.12.2 二进制转十进制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mXAlUySh-1685024495208)(E:\Java_learning\typora_note\images\image-20230308175815512.png)]

3.12.3 八进制转十进制

在这里插入图片描述

3.12.4 十六进制转十进制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iicNvpc4-1685024495209)(E:\Java_learning\typora_note\images\image-20230308181508469.png)]

3.12.5 十进制转二进制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xR4kaQCe-1685024495209)(E:\Java_learning\typora_note\images\image-20230308181751297.png)] 在这里插入图片描述

3.12.6 十进制转八进制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tzRB2ile-1685024495209)(E:\Java_learning\typora_note\images\image-20230308201535138.png)]

3.12.7 十进制转十六进制

在这里插入图片描述

3.12.8 二进制转八进制

在这里插入图片描述

3.12.9 二进制转十六进制

在这里插入图片描述

3.12.10 八进制转二进制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nfIgwLWl-1685024495211)(E:\Java_learning\typora_note\images\image-20230308210439477.png)]

3.12.11 十六进制转二进制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DFjEGgwA-1685024495211)(E:\Java_learning\typora_note\images\image-20230308210500604.png)]

3.12.12 原码，反码，补码(重点，难点，需要背)

对于有符号的而言：

  1. 二进制最高位是符号位，0表示正数，1表示负数（0->正 1->负）
  2. 正数的原码，反码，补码都一样（三码合一）
  3. 负数的反码 = 它的原码符号位不变，其他位置取反（0->1 1->0）
  4. 负数的补码 = 它的反码 + 1，负数的反码 = 负数的补码 - 1
  5. 0的反码 ，补码都是 0
  6. java中没有无符号数，换言之，java中数都是有符号的
  7. 在计算机运算的时候，都是以补码的方式运算的
  8. 当我们看运算结果时，要看他的原码（ ！！！）

3.13 位运算符

在这里插入图片描述

//BitOperator 演示
public class BitOperator {
	public static void main(String[] args){
		//分析：
		//1.先得到2的补码  => 2的原码 00000000 00000000 00000000 00000010
		//	2的补码	00000000 00000000 00000000 00000010
		//2.3的补码 => 3的原码 00000000 00000000 00000000 00000011
		//	3的补码	00000000 00000000 00000000 00000011
		//3.按位&
		//	00000000 00000000 00000000 00000010
		//	00000000 00000000 00000000 00000011
		//	00000000 00000000 00000000 00000010 -> &运算过后的补码
		//	运算后的原码：00000000 00000000 00000000 00000010	
		//	结果为：2
		System.out.println(2&3);
		//分析
		//1.先得到-2的补码 -> -2的原码 10000000 00000000 00000000 00000010
		//2.      -2的补码 -> -2的反码 11111111 11111111 11111111 11111101
		//3.      -2的补码 -> -2的反码 + 1 -> 11111111 11111111 11111111 11111110
		//4. ~-2  运算-> 00000000 00000000 00000000 00000001  运算后的补码
		//5.运算后的原码 00000000 00000000 00000000 00000001 
		//6运算后的结果： 1
		System.out.println(~-2);
		//分析
		//1.得到2的补码 00000000 00000000 00000000 00000010
		//2.~2  	   11111111 11111111 11111111 11111101 运算后的补码
		//3.运算后的反码 -> 可以看出是负数 -> 
		//4.运算后的反码 ->  11111111 11111111 11111111 11111100
		//5.运算后的原码 ->  10000000 00000000 00000000 00000011 -> -3
		System.out.println(~2);	

		//分析正数 三码合一
		//1.得到2的补码 00000000 00000000 00000000 00000010
		//2.得到3的补码 00000000 00000000 00000000 00000011
		//3.2|3按位或   00000000 00000000 00000000 00000011 运算后的补码
		//4.运算后的原码 00000000 00000000 00000000 00000011 ->3
		System.out.println(2|3);

		//分析
		//1.得到2的补码 00000000 00000000 00000000 00000010
		//2.得到3的补码 00000000 00000000 00000000 00000011
		//3.2^3 		00000000 00000000 00000000 00000001 运算后的补码
		//4.运算后的原码 00000000 00000000 00000000 00000001 -> 1
		System.out.println(2^3);	
	}
}
3.13.1 位运算符2

1）算术右移 >>：低位溢出,符号位不变,并用符号位补溢出的高位 eg：1 >> 2 本质 1 / 2 / 2

2）算术左移 <<: 符号位不变,低位补 0 eg：1 << 2 本质 1 * 2 * 2

3）逻辑右移也叫无符号右移 >>> ,运算规则是: 低位溢出，高位补 0

特别说明：没有 <<< 符号

avatar
文章
阅读
粉丝