public class Demo01 { public static void main(String[] args) { // 将int类型的10直接赋值给double类型 double num = 10; System.out.println(num); // 10.0 } }
数据类型范围从小到大关系图：
注意事项
整数默认是int类型，byte、short和char类型数据参与运算均会自动转换为int类型
public class Demo { public static void main(String[] args) { byte a = 3; byte b = 4; /* 错误原因: byte c = a + b; 这里的a和b是两个byte类型, 它们在运算之前会将自己提升为int类型, 然后再进行运算 两个int相加, 结果还是int, 想要把一个int类型的结果, 赋值给byte类型的变量 大的给小的, 不能直接给. 非要给的话, 就需要强制类型转换. 解决方案: 首先让a和b进行相加, 使用()提升算数优先级 再对相加的结果整体进行强转. 或者使用int类型的变量去接收 */ byte c = (byte) (a + b); // 错误: 不兼容的类型: 从int转换到byte可能会有损失 System.out.println(c); //或者 int i = a + b; /* Java存在常量优化机制: byte d = 3 + 4; 这里的3和4是两个常量, Java存在常量优化机制, 会在编译的时候就会让3和4进行相加, 然后会自动判断7是否在byte的取值范围内 不在范围内: 编译出错 在范围内: 通过编译 */ byte d = 3 + 4; System.out.println(d); } }
特别提醒：boolean类型不能与其他基本数据类型相互转换
把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量，就是强制转换。强制类型转换格式：目标数据类型 变量名 = (目标数据类型)值或者变量。示例代码
/* 强制转换: 把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量 简答理解: 大的给小的, 不能直接给, 需要强转 格式：目标数据类型 变量名 = (目标数据类型)值或者变量; */ public class Demo { public static void main(String[] args) { double num1 = 5.99; int num2 = (int) num1; // 将double类型的num1强制转换为int类型 //损失精度 System.out.println(num2); //5 // 数据溢出 byte b = (byte) 454545455; System.out.println(b);// } }
表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。不同运算符连接的表达式体现的是不同类型的表达式。Java中的常见的运算符如下所示：
注意：
- /和%的区别：两个数据做除法，/取结果的商，%取结果的余数。
- 整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。
示例代码
public class Demo { public static void main(String[] args) { System.out.println(10 + 20);//30 System.out.println(10 - 20);//-10 System.out.println(10 * 20);//200 /* / : 整数相除,结果只能得到整数,如果想要得到带有小数的结果,必须加入小数(浮点类型)的运算 */ System.out.println(13 / 3); // 4 System.out.println(13 / 3.0); // 4.333333333333333 /* %(取模) : 取余数 */ System.out.println(13 % 2); // 1 } }
public class Demo { public static void main(String[] args) { // 字符串可以使用 +号, 跟[任意数据类型]拼接 System.out.println("it" + 666);//it666 System.out.println("it" + true);// ittrue System.out.println(1 + 99 + "年" + 1 + 2 + 3); // 100年123 System.out.println("5+5=" + 5 + 5); // 5+5=55 //使用小括号改变运算顺序 System.out.println("5+5=" + (5 + 5)); // 5+5=10 } }
public class Demo { public static void main(String[] args) { // 可以通过使用字符与整数做算术运算，得出字符对应的数值是多少 char ch1 = 'a'; System.out.println(ch1 + 1); // 98 char ch2 = 'A'; System.out.println(ch2 + 1); // 66 char ch3 = '0'; System.out.println(ch3 + 1); // 49 } }
算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。
提升规则：
- 整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型
- 等级顺序：byte,short,char --> int --> long --> float --> double
示例代码
byte b1 = 10; byte b2 = 20; // byte b3 = b1 + b2; // 该行报错，因为byte类型参与算术运算会自动提示为int，int赋值给byte可能损失精度 int i3 = b1 + b2; // 应该使用int接收 byte b3 = (byte) (b1 + b2); // 或者将结果强制转换为byte类型 ------------------------------- int num1 = 10; double num2 = 20.0; double num3 = num1 + num2; // 使用double接收，因为num1会自动提升为double类型
需求：
import java.util.Scanner; public class Demo { public static void main(String[] args) { // 1：使用Scanner键盘录入一个三位数 Scanner sc = new Scanner(System.in); System.out.println("请输入一个三位数"); int num = sc.nextInt(); // 2：个位的计算：数值 % 10 int ge = num % 10; // 3：十位的计算：数值 / 10 % 10 int shi = num / 10 % 10; // 4：百位的计算：数值 / 100 int bai = num / 100 % 10; // 5：将个位, 十位, 百位拼接上正确的字符串, 打印即可 System.out.println("整数" + num + "个位为:" + ge); System.out.println("整数" + num + "十位为:" + shi); System.out.println("整数" + num + "百位为:" + bai); } }
注意事项：
- ++和-- 既可以放在变量的后边，也可以放在变量的前边。
- 单独使用的时候： ++和-- 无论是放在变量的前边还是后边，结果是一样的。
- 参与操作的时候：如果放在变量的后边，先拿变量参与操作，后拿变量做++或者--。
- 参与操作的时候：如果放在变量的前边，先拿变量做++或者--，后拿变量参与操作。
示例代码
public class Demo { public static void main(String[] args) { int i = 10; i++; // 单独使用 System.out.println("i:" + i); // i:11 int j = 10; ++j; // 单独使用 System.out.println("j:" + j); // j:11 int x = 10; int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1 System.out.println("x:" + x + ", y:" + y); // x:11，y:10 int m = 10; int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1 System.out.println("m:" + m + ", m:" + m); // m:11，m:11 } }
注意：
- 扩展的赋值运算符隐含了强制类型转换。
示例代码
/* 基本赋值运算符: = : 将符号右侧的数据, 赋值给左边 扩展赋值运算符: += -= *= /= %= += : 将符号左右两边的数据, 做加法运算, 结果赋值给左边 -= : 将符号左右两边的数据, 做减法运算, 结果赋值给左边 *= : 将符号左右两边的数据, 做乘法运算, 结果赋值给左边 /= : 将符号左右两边的数据, 做除运算, 结果赋值给左边 %= : 将符号左右两边的数据, 做取余运算, 结果赋值给左边 */ public class Demo { public static void main(String[] args) { int a = 10; // += : 将符号左右两边的数据, 做加法运算, 结果赋值给左边 a += 20; System.out.println(a);//30 short s = 1; // s = s + 1; // 错误: 不兼容的类型: 从int转换到short可能会有损失 s = (short) (s + 1); System.out.println(s);//2 short ss = 1; ss += 1; // ss = (short)(ss + 1); // 注意: 扩展赋值运算符底层会自带强转功能 System.out.println(ss);//2 } }
注意事项：
- 关系运算符的结果都是boolean类型，要么是true，要么是false。
- 千万不要把“==”误写成“=”，"=="是判断是否相等的关系，"="是赋值
示例代码
public class Demo { public static void main(String[] args) { int a = 10; int b = 20; System.out.println(a == b); // false System.out.println(a != b); // true System.out.println(a > b); // false System.out.println(a >= b); // false System.out.println(a < b); // true System.out.println(a <= b); // true // 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量 boolean flag = a > b; System.out.println(flag); // false } }
示例代码
public class Demo { public static void main(String[] args) { //定义变量 int i = 10; int j = 20; int k = 30; //& “与”，并且的关系，只要表达式中有一个值为false，结果即为false System.out.println((i > j) & (i > k)); //false & false,输出false System.out.println((i < j) & (i > k)); //true & false,输出false System.out.println((i > j) & (i < k)); //false & true,输出false System.out.println((i < j) & (i < k)); //true & true,输出true System.out.println("--------"); //| “或”，或者的关系，只要表达式中有一个值为true，结果即为true System.out.println((i > j) | (i > k)); //false | false,输出false System.out.println((i < j) | (i > k)); //true | false,输出true System.out.println((i > j) | (i < k)); //false | true,输出true System.out.println((i < j) | (i < k)); //true | true,输出true System.out.println("--------"); //^ “异或”，相同为false，不同为true System.out.println((i > j) ^ (i > k)); //false ^ false,输出false System.out.println((i < j) ^ (i > k)); //true ^ false,输出true System.out.println((i > j) ^ (i < k)); //false ^ true,输出true System.out.println((i < j) ^ (i < k)); //true ^ true,输出false System.out.println("--------"); //! “非”，取反 System.out.println((i > j)); //false System.out.println(!(i > j)); //!false，,输出true } }
在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。
- 逻辑与&，无论左边真假，右边都要执行。
- 短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。
- 逻辑或|，无论左边真假，右边都要执行。
- 短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。
示例代码
public class Demo { public static void main(String[] args) { int x = 3; int y = 4; // 两个表达都会运算 System.out.println((x++ > 4) & (y++ > 5)); //false System.out.println(x); // 4 System.out.println(y); // 5 //左边已经可以确定结果为false，右边不参与运算 System.out.println((x++ > 4) && (y++ > 5)); // false System.out.println(x); // 4 System.out.println(y); // 4 } }
public class Demo { /* 位移运算符: << 有符号左移运算，二进制位向左移动, 左边符号位丢弃, 右边补齐0 运算规律: 向左移动几位, 就是乘以2的几次幂 12 << 2 (0)0000000 00000000 00000000 000011000 // 12的二进制 ----------------------------------------------------------------------------- >> 有符号右移运算，二进制位向右移动, 使用符号位进行补位 运算规律: 向右移动几位, 就是除以2的几次幂 000000000 00000000 00000000 0000001(1) // 3的二进制 ----------------------------------------------------------------------------- >>> 无符号右移运算符, 无论符号位是0还是1，都补0 010000000 00000000 00000000 00000110 // -6的二进制 */ public static void main(String[] args) { System.out.println(12 << 1); // 24 System.out.println(12 << 2); // 48 } }
执行流程：
- 首先计算关系表达式的值
- 如果值为true，取表达式1的值
- 如果值为false，取表达式2的值
示例代码
//一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三个和尚的最高身高。 public class Demo { public static void main(String[] args) { //1：定义三个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。 int height1 = 150; int height2 = 210; int height3 = 165; //2：用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。 int tempHeight = height1 > height2 ? height1 : height2; //3：用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。 int maxHeight = tempHeight > height3 ? tempHeight : height3; //4：输出结果 System.out.println("maxHeight:" + maxHeight);// maxHeight:210 } }