Java-Basic-day03

最新推荐文章于 2024-07-23 19:46:11 发布

原创最新推荐文章于 2024-07-23 19:46:11 发布 · 123 阅读

0 ·

CC 4.0 BY-SA版权

本文详细介绍了Java中的基本运算操作，包括取余运算的特点及其应用、数值拆分的方法、自增自减运算符的功能、关系运算符的使用、逻辑运算符的真值表以及短路逻辑现象、赋值运算符的特性和扩展用法、字符串连接运算符的重载特性等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

n%m余数特点：
1.范围：[0,m)
2.周期变化：0 1 2 . . . m-1 0 1 2 . . . m- 1
3.结果的数学意义：是不够m个数的剩余个数

public static void main(String[] args) {
		/**
		 * 取余计算 %
		 */
		System.out.println(0%3); 
		System.out.println(1%3); 
		System.out.println(2%3); 
		System.out.println(3%3); 
		System.out.println(4%3); 
		System.out.println(5%3); 
		System.out.println(6%3); 
		System.out.println(7%3); 
		System.out.println(8%3);

将一个数按照10进制进行拆分

int n = 12434;
int m = n%10; // 4，10进制最后一位数
n = n/10;     // 1243 去掉最后一位
m = n%10;     // 3最后一位
n = n/10;     // 124
m = n%10;     // 4
n = n/10;     // 12
m = n%10;	  // 2
n = n/10;     // 1
m = n%10;	  // 1
n = n/10;     // 0

public static void main(String[] args) {
		/**
		 * 将一个数按照10进制进行拆分
		 */
		int n = 12327;
		System.out.println(n);
		int m = n%10; //7
		System.out.println(m);
		n = n/10;  
		System.out.println(n);
		m = n%10;     //2
		System.out.println(m);
		n = n/10;
		System.out.println(n);
		m = n%10;     //3
		System.out.println(m);
		n = n/10;
		System.out.println(n);
		m = n%10;     //2
		System.out.println(m);
		n = n/10;
		System.out.println(n);
		m = n%10;     //1
		System.out.println(m);
		n = n/10;
		System.out.println(n);
		
	}

自增（自减）运算
运算符（单目运算符）：++ –
单目运算符：只有一个变量参与运算，成为单目运算

将当前变量的值，增加1或者减少1
	案例：
		int a = 8;
		a++;//将变量a的值增加1
		System.out.println(a);//9
		int b = 8;
		b--;//将变量自我减少1
		System.out.println(b);//7

public static void main(String[] args) {
		/**
		 * 自增（自减）运算符, 单目运算，
		 * 将变量的值增加（减少）一
		 */
		int a = 8;
		a++;
		int b = 8;
		b--;
		System.out.println(a+","+b); 
		//单独行使用 ++\-- 在前，在后没有区别。 
		a = 8;
		++a;
		b = 8;
		--b;
		System.out.println(a+","+b);
		//++在前称为“先++”: 先增加1再取值
		//先将变量增加1 再取变量的值作为表达式的值
		a = 8;
		System.out.println(++a); //++a取a增加以后的值9
		System.out.println(a);//9
		//++在后称为“后++”：先取值再增加1
		//将变量的值取出作为表达式的值，然后变量增加1
		a = 8;
		System.out.println(a++); //取出8作为a++的值，
		//然后a增加1， a为9
		System.out.println(a);//9
		
	}

关系运算：
1：关系运算符用于判断数据之间大小关系。
2：包括大于(>) 、小于(<)、大于等于(>=)、小于等于(<=)、等于(==)、不等于(!=) 六个运算符
3：关系运算的结果为boolean类型，如果关系成立为true，否则为false

public static void main(String[] args) {
		/**
		 * 比较运算符： >大于 <小于 >=大于等于 
		 *   <=小于等于  ==等于  !=不等于
		 * 比较结果成立返回 true，不成立返回false  
		 */
		int a = 6;
		int b = 9;
		boolean v = a>b; // 检查a是否大于b，不成立false
		System.out.println(v);//false
		
		Scanner console = new Scanner(System.in);
		System.out.print("请输入年龄：");
		//根据年龄检查是否为小孩（年龄小于等于12）
		int age = console.nextInt();
		//kid 小孩
		boolean kid = age <= 12; //false
		System.out.println(kid); //false
		
		
	}

逻辑运算
与运算 && 并且
false && false -> false
false && true -> false
true && false -> false
true && true -> true

有false就是false

或运算  ||
false || false -> false
false || true  -> true
true  || false -> true
true  || true  -> true

有true就是true

非！表示：否则关系
!false -> true
!true -> false

短路逻辑现象
短路“与”计算 && ：第一个条件是false时候，执行短路规则，不执行第二个表达式

char sex = '男';
	int age = 66;
	boolean b = sex == '女' && age++ >= 60;
	//如何检测 第二个 表达式是否执行了？ 利用++计算作为探针检测
	//第二个表达式是否执行
	System.out.println(b);//false
	System.out.println(age);//66

短路“或”计算 || ：第一个条件是true时候，执行短路规则，不执行第二个表达式

public static void main(String[] args) {
		/**
		 * 测试 短路逻辑计算
		 */
		//设定短路条件
		char sex='男';
		int age = 66;
		//测试短路逻辑计算
		boolean b = sex == '女' && age++ >= 60;
		System.out.println(b);
		System.out.println(age);
		//在&&计算时候，第一个表达式为false时候，就直接
		//得到整体 && 计算的结果，跳过第二个表达式的执行。
	}

赋值计算：
“=”称为赋值运算符，用于对变量赋值。
关于赋值运算符，除了将右边的表达式计算出来赋给左边
赋值计算的优先级很低，一般是最后计算
赋值表达式本身也有值，其本身之值即为所赋之值。
案例：
int a;
a = 6;//将6赋值给a
//赋值本身是一种表达式，有整体值, 值是最后赋值的结果
System.out.println(a=8); //8
int b = a = a+1; //赋值计算的“结合性” 由右到左计算
//加法的优先级高于赋值计算，所有加法先执行再执行赋值计算
System.out.println(b);//9
System.out.println(a);//9

符合（扩展）赋值计算：

案例：

int a = 5;
//a = a + 5;
a += 5;//a在基础上增加5
System.out.println(a);//10
int b = 5;
//b = b * 2;
b *= 2;//b在基础上乘以2
System.out.println(b);//10
int n = 1232;
n /= 10;
//n = n / 10;
System.out.println(n);//123

符合赋值运算包含强制转换计算：

public static void main(String[] args) {
		/**
		 * 符合（扩展）赋值运算
		 */
		int a = 5;
		a += 5; // a = a + 5;
		System.out.println(a); //10
		int b = 5;	
		b *= 2; //b = b*2;
		System.out.println(b);//10
		int n = 1235;
		n /= 10; //n = n / 10;
		System.out.println(n);//123 
		
		//符合（扩展）赋值计算，在计算过程转换包含强制类型转换
		int x = 5;
		x += 3.5; //完全等价于 x = (int)(x+3.5)
		System.out.println(x);//8
		byte y = 5;
		//y = y + 2;//y按照int计算
		y += 2; //完全等价于 y = (byte)(y+2);
		System.out.println(y);//7 
		
		char c = 30000;
		c += 0.6;
		System.out.println(c); 
	}

字符串连接计算：
加号 + 是Java中唯一的一个“重载”运算符：
重载：一个符号两种以上功能。

1.数值计算
加号两端都是数值时候，是数学加法计算
2.字符串连接
加号两端出现一个字符串时候，是字符串连接

案例：

int a = 5, b = 6;
System.out.println(a + b);
System.out.println("a=" + a); //"a=5"
System.out.println(a + "," + b); //5,6