day03 变量和运算符

最新推荐文章于 2024-06-12 23:40:32 发布

Libra_97

最新推荐文章于 2024-06-12 23:40:32 发布

阅读量79

点赞数

分类专栏： javase 文章标签： java

本文链接：https://blog.csdn.net/Libra_97/article/details/126659324

版权

javase 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

变量和运算符

1. 强制类型转换特殊情况

长度不够数据截断

符号位发生变化

计算机统一以补码的形式表示所有的整数
补码是在反码的基础之上+1
反码是原码符号位不变其余各位取反是0改为1 是1改为0
原码

正数的原码反码补码都一样

public class Test1{
	public static void main(String [] args){
		// 强制类型转换特殊情况：将超过强转类型取值范围的数据进行强转
		
		// 计算机统一以补码的形式表示所有的整数
		// 补码是在反码的基础之上+1
		// 反码是原码符号位不变 其它位取反 0改为1 1改为0
		// 原码
		
		// 正数的原码 反码 补码都一样
		
		short s1 = 257;
		byte b1 = (byte)s1;  // 
		
		System.out.println(b1);  // 1  byte的长度不够 前面的数据截断
		System.out.println("--------------");
		
		short s2 = 128;
		byte b2 = (byte)s2;
		
		System.out.println(b2);  // -128 符号位发生变化 正数变为负数
		System.out.println("--------------");
		
		short s3 = 129;
		byte b3 = (byte)s3;
		
		System.out.println(b3);  // -127
		System.out.println("--------------");

	}
}

2. 类型提升

进行算数运算时：
两个操作数有一个为double，计算结果提升为double。
如果操作数中没有double，有一个为float，计算结果提升为float。
如果操作数中没有float，有一个为long，计算结果提升为long。
如果操作数中没有long，有一个为int，计算结果提升为int。
如果操作数中没有int，均为short或byte或者char，计算结果仍旧提升为int。

两个或者多个操作数进行计算，哪个类型范围更大结果就提升为哪个类型，如果均为byte，short，char，则结果依旧为int类型

特殊：任何类型与String相加（+）时，实为拼接，其结果为String。

public class Test1{
	public static void main(String [] args){
		char c1 = 65;
		
		int a = c1;
		System.out.println(a);  // 65
		
		int b = 66;
		char c2 = (char)b;
		System.out.println(c2);  // B
		
		System.out.println("------------------");
		
		char c3 = 65;
		// char类型和String类型进行拼接
		System.out.println(c3 + "1");  // A1
		
		// char类型和int类型相加
		System.out.println(c3 + 1);  // 66
		
		// char类型和float类型相加
		System.out.println(c3 + 1.0);  // 66.0
	}
}

3. 运算符

3.1 算数运算符

++或者-- 如果单独作为一条语句书写在前在后没有区别

如果不是单独作为一条语句书写有区别

如果++或者–在前先执行++或者-- 再执行其他的(包括但不限于赋值比较等操作)

如果++或者–在后先执行其他的(包括但不限于赋值比较等操作) 再执行++或者–

算数运算符

一元运算符

public class Test1{
	public static void main(String [] args){
		// 算数运算符 + - * /
		int a = 10;
		int b = 5;
		
		System.out.println(a + b);  // 15
		System.out.println(a - b);  // 5
		System.out.println(a * b);  // 50
		System.out.println(a / b);  // 2
		System.out.println(a % b);  // 0  取余数
		
		System.out.println("--------------");
		
		int c = 10;
		int d = 4;
		System.out.println(c % d);  // 2
	}
}

public class Test2{
	public static void main(String [] args){
		// 一元运算符 ++ --
		// ++ 表示自增1
		// -- 表示自减1
		
		int a = 10;
		a++;  // a = a + 1
		
		System.out.println(a);  // 11
		System.out.println("----------------");
		
		int b = 10;
		++b;
		System.out.println(b);  // 11
		System.out.println("----------------");
		
		int c = 10;
		c--;
		System.out.println(c);  // 9
		System.out.println("----------------");
		
		int d = 10;
		--d;
		System.out.println(d);  // 9
		System.out.println("----------------");
		
		// ++ 或者-- 如果单独作为一条语句书写， 在前在后没有区别
		// 如果不是单独作为一条语句书写 有区别
		// 如果++或者--在前 先执行++或者--再执行其他的(包括但不限于赋值 比较等操作)
		// 如果++或者--在后先执行其他的(包括但不限于赋值 比较等操作) 再执行++或者--
		
		int a1 = 10;
		int b1 = a1--;  // 先赋值给b1，后--
		
		System.out.println("a1的取值为：" + a1);  // 9
		System.out.println("b1的取值为：" + b1);  // 10
		System.out.println("----------------");
		
		int c1 = 10;
		int d1 = --c1;  // 先--,后赋值给d1
		
		System.out.println("c1的取值为：" + c1);  // 9
		System.out.println("d1的取值为：" + d1);  // 9

		
		
	}
}

public class Test1{
	public static void main(String [] args){
		int a = 2;
		int b = 5;
		
		System.out.println(a / b);  // 0  精度丢失
		System.out.println(a % b);  // 2  b比a小，无法取模 所以余数为a
	}
}

3.2 赋值运算符

赋值运算符

public class Test1{
	public static void main(String [] args){
		// 赋值运算符
		int a = 10;
		
		a += 10;  // 等同于 a = a + 10
		System.out.println(a);  // 20
		
		a -= 5;  // 等同于 a = a - 5
		System.out.println(a);  // 15
		
		a *= 3;  // 等同于 a = a * 3
		System.out.println(a);  // 45
		
		a /= 5;  // 等同于 a = a / 5
		System.out.println(a);  // 9
		
		a %= 2;  // 等同于 a = a % 2
		System.out.println(a);  // 1 
	}
}

3.3 关系运算符

关系运算符

关系运算符最终的结果都为布尔类型要么关系成立要么不成立

public class Test2{
	public static void main(String [] args){
		// 关系运算符 最终的结果都为布尔类型 要么关系成立 要么不成立
		
		int a = 10;
		int b = 20;
		int c = 20;
		
		System.out.println(a > b);  // false
		System.out.println(a >= b);  // false
		System.out.println(a < b);  // true
		System.out.println(c <= b);  // true
		System.out.println(c == b);  // true
		System.out.println(a != b);  // true
	}
}

3.4 逻辑运算符

逻辑运算符

&& 短路与：要求两个或者多个条件同时都成立则结果为true
短路与有短路的效果如果前边的条件不成立则后续的条件不再执行

& 与：要求两个或者多个条件同时都成立则结果为true
不管前边的条件是否成立都将执行完所有的条件没有短路的效果

|| 短路或：要求两个或者多个条件有一个成立则结果为true
短路或有短路的效果如果前边的条件已经成立后续的条件不再执行

| 或：要求两个或者多个条件有一个成立则结果为true
有短路的效果不管前边的条件是否成立都将执行完所有的条件

public class Test1{
	public static void main(String [] args){
		// 逻辑运算符
		// && 短路与：要求两个或者多个条件同时都成立 则结果为true
		// 短路与 有短路的效果 如果前边的条件不成立则后续的条件不再执行
		
		// & 与：要求两个或者多个条件同时都成立 则结果为true
		// 不管前面的条件是否成立 都将执行完所有的条件 没有短路的效果
		
		int a = 10;
		int b = 20;
		int c = 30;
		
		System.out.println(a > b && b < c);  // false
		System.out.println(a < b && b < c);  // true
		
		System.out.println("-------------");
		
		System.out.println(a > b & b < c);  // false
		System.out.println(a < b & b < c);  // true
		
		System.out.println("-------------");
		
		
		// || 短路或：要求两个或者多个条件有一个成立 则结果为true
		// 短路或 有短路的效果 如果前面的条件已经成立 则后续的条件不再执行
		
		// | 或：要求两个或者多个条件有一个成立 则结果为true
		// 没有短路的效果 不管前面的条件是否成立 都要执行完所有的条件
		
		int d = 10;
		int e = 20;
		int f = 30;
		
		System.out.println(d > e || e < f);  // true
		System.out.println(d < e || e < f);  // true
		System.out.println(d > e || e > f);  // false
		
		System.out.println("-------------");

		System.out.println(d > e | e < f);  // true
		System.out.println(d < e | e < f);  // true
		System.out.println(d > e | e > f);  // false
	}
}

public class Test2{
	public static void main(String [] args){
		
		int x = 8;
		int y = 9;
		
		System.out.println((++x == y) && (++x != y));  // true
		System.out.println(x);  // 10
		
		System.out.println("-------------------");
		
		int a = 8;
		int b = 9;
		
		System.out.println((++a != b) && (++a == b));  // false
		System.out.println(a);  // 9
		
		System.out.println("-------------------");
		
		int c = 8;
		int d = 9;
		
		System.out.println((++c != d) & (++c == d));  // false
		System.out.println(c);  // 10
		
		System.out.println("-------------------");
		
		int e = 8;
		int f = 9;
		
		System.out.println((e++ != f) || (++e == f));  // true
		System.out.println(e);  // 9
		
		System.out.println("-------------------");
		
		int h = 8;
		int j = 9;
		
		System.out.println((h++ != j) | (++h == j));  // true
		System.out.println(h);  // 10
	}
}

public class Test3{
	public static void main(String [] args){
		
		// ! 取反 非真即假 非假即真
		System.out.println(!true);  // false
		System.out.println(!false);  // true
	}
}

3.5 三目运算符

三目运算符

public class Test4{
	public static void main(String [] args){
		// 三目/三元运算符  布尔表达式 ? 结果1 : 结果2   布尔表达式为true 输出结果1  为false 则输出结果2
		
		int age = 19;
		
		System.out.println(age >= 18 ? "成年了" : "未成年");  // 成年了
		
		int a = 50;
		int b = a > 50 ? 66 : 77;  // 条件成立 将66赋值给b 不成立则将77赋值给b
		System.out.println(b);  // 77
	}
}

3.6 位运算符(了解)

位运算符

public class Test1{
	public static void main(String [] args){
		
		// 左移 << 运算符 在有效的范围内 左移几位表示乘以2的几次方
		
		System.out.println(1 << 1);  //  1 * 2^1 = 2
		System.out.println(1 << 2);  //  1 * 2^2 = 4
		System.out.println(1 << 3);  //  1 * 2^3 = 8
		System.out.println(1 << 4);  //  1 * 2^4 = 16
		
		System.out.println("-----------------");
		
		System.out.println(1 << 31);  // 左移的位数到了符号位 变为负数 -2147483648,超过31位后又从2^0开始算
		System.out.println(1 << 32);  // 左移的位数32位，相当于1 * 2^0 变成1了
		System.out.println(1 << 33);  // 左移的位数33位，相当于1 * 2^1 变成2了
		System.out.println(1 << 34);  // 左移的位数34位，相当于1 * 2^2 变成4了
		
	}
}

public class Test2{
	public static void main(String [] args){
		// 右移 >> 在有效的范围以内 右移几位 表示 除以2的几次方
		// 右移 当前数最高位为0 则右移以后空缺的位以0填充
		// 当前数最高位为1 则右移以后空缺的位以1填充
		
		System.out.println(32 >> 1);  // 32 / 2^1 = 16
		System.out.println(32 >> 2);  // 32 / 2^2 = 8
		System.out.println(32 >> 3);  // 32 / 2^3 = 4
		System.out.println(32 >> 4);  // 32 / 2^4 = 2
		System.out.println(32 >> 5);  // 32 / 2^6 = 1
		System.out.println(32 >> 6);  // 32 / 2^7 = 0  精度丢失取整
		
		System.out.println("-------------------------");
		
		System.out.println(-20 >> 2);  // -20 / 2^2 = -5;
		
		
		
	}
}

public class Test3{
	public static void main(String [] args){
		// >>> 无符号右移 右移以后 空位的位 统一以0填充
		System.out.println(-20 >> 2);  // -5
		System.out.println(-20 >>> 1);  // 2147483638
		
		System.out.println(20 >> 2);  // 5
		System.out.println(20 >>> 2);  // 5
	}
}

public class Test4{
	public static void main(String [] args){
		// & 运算 二进制数值 相同位都为1 则为1 其他都为0
		System.out.println(36 & 55);  // 36
		System.out.println("-------------------");
		
		// | 运算 二进制数值 相同位 有一个为1 或者两个都为1 则为1 其他都为0
		
		System.out.println(36 | 55);  // 55
		System.out.println("-------------------");
		
		// ^ 异或 二进制数组相同位 不同为1 相同为0
		System.out.println(36 ^ 55);  // 19
		System.out.println("-------------------");
		
		// ~ 取反 包括符号位在内 每一位是0改为1 是1改为0
		System.out.println(~55);  // -56

	}
}