Java基础
1、变量的基本概念
2、变量的声明方式
数据类型 变量名=初始值;
- 变量要声明
- 变量要初始化
- 变量不能重复声明
public class VarTest{
public static void main(String[] args){
//声明变量
int age=18;
String name="张三";
//打印值
System.out.println("age:"+age);
}
}
从终端获取数据并打印
import java.util.Scanner;
public class VarIOTest{
public static void main(String[] args){
String name;
int age;
System.out.println("输入姓名和年龄");
// 从终端获取数据
Scanner sc = new Scanner(System.in);
// 把获取到的数据赋值给name,age
name = sc.next();
age = sc.nextInt();
// 打印姓名年龄
System.out.println("姓名:"+name);
System.out.println("年龄:"+age);
}
}
- 标识符
- 由数字、字母、下划线以及¥等组成,其中数字不能开头。
- 不能使用Java语言的关键字,所谓关键字就是java语言用于表示特殊含义的单词;
- 区分大小写,长度没有限制但不宜过长;
- 尽量做到见名知意,支持中文但不推荐使用
- 标识符可以给类、变量、属性、方法、包起名。
关键字
3、数据类型
数据类型的分类
1、 基本数据类型
byte、short、int、long、float、double、boolean、char
2、引用数据类型
数组、类、接口、枚举、标注
整数类型
/*
编程实现整数类型的使用
*/
public class IntTest {
public static void main(String[] args) {
// 1.声明一个byte类型的变量并初始化
byte b1 = 25;
//byte b1 = 250; // 错误: 不兼容的类型: 从int转换到byte可能会有损失 250这样直接写出的整数数据叫做直接量/常量/字面值 默认为int类型
// 2.打印变量的数值
System.out.println("b1 = " + b1); // b1 = 25
System.out.println("---------------------------------------------");
// 3.声明一个short类型的变量并初始化
short s1 = 250;
//short s1 = 250250; // 错误:不兼容的类型:从int转换到short可能会有损失
System.out.println("s1 = " + s1); // s1 = 250
System.out.println("---------------------------------------------");
// 4.声明一个int类型的变量并初始化
int i1 = 250250;
//int i1 = 2502505006; // 错误: 整数太大 默认为int类型,这个数据自身已经出错,无法表示
//int i1 = 2502505006L; // 错误:不兼容的类型:从long转换到int可能会有损失
System.out.println("i1 = " + i1); // i1 = 250250
System.out.println("---------------------------------------------");
// 5.声明一个long类型的变量并初始化,若描述比long类型还大的数据则使用java.math.BigInteger类型
long g1 = 2502505006L;
System.out.println("g1 = " + g1); // g1 = 2502505006
System.out.println("---------------------------------------------");
// 6.请问下面的代码是否有错误?若有请指出并说明原因
//int i2 = 25;
//byte b2 = i2; // 错误: 不兼容的类型: 从int转换到byte可能会有损失
//System.out.println("b2 = " + b2);
}
}
浮点类型
/*
编程实现浮点类型的使用
*/
public class DoubleTest {
public static void main(String[] args) {
// 1.声明一个float类型的变量并初始化
//float f1 = 3.1415926; // 错误: 不兼容的类型: 从double转换到float可能会有损失 小数数据叫做直接量,默认为double类型
float f1 = 3.1415926f;
// 2.打印变量的数值
System.out.println("f1 = " + f1); // f1 = 3.1415925 一般是7位有效数字
System.out.println("---------------------------------------------------------");
// 3.声明一个double类型的变量并初始化
double d1 = 3.1415926;
System.out.println("d1 = " + d1); // d1 = 3.1415926 一般是15位有效数字
System.out.println("---------------------------------------------------------");
// 4.笔试考点
System.out.println(0.1 + 0.2); // 0.30000000000000004 运算时可能会有误差,若希望实现精确运算则借助java.math.BigDecimal类型
}
}
字符型
/*
编程实现字符类型的使用
*/
public class CharTest {
public static void main(String[] args) {
// 1.声明一个char类型的变量并初始化
char c1 = 'a';
// 2.打印变量的数值
System.out.println("c1 = " + c1); // c1 = a
System.out.println("对应的编号是:" + (int)c1); // 表示将char类型的c1强制转换为int类型并打印 97
System.out.println("-------------------------------------------------------------------------");
// 2.声明一个char类型的变量并初始化
char c2 = 98;
System.out.println("c2 = " + c2); // c2 = b
System.out.println("对应的编号是:" + (int)c2); // 98
System.out.println("-------------------------------------------------------------------------");
// 3.使用Unicode字符集来表示一下我的名字 奇点 对应的编号是: \u5947\u70b9
char c3 = '\u5947';
char c4 = '\u70b9';
System.out.println("最终的结果是:" + c3 + c4); // 奇点
System.out.println("-------------------------------------------------------------------------");
// 4.特殊字符的使用 双引号本身有2个含义:a.字符串的开头和结尾标志 b.双引号自身 \ 转义就是转换原有的含义
System.out.println("我想过过\"过过过过的生活!"); // \" - "
System.out.println("我想过过\'过过过过的生活!");
System.out.println("我想过过\\过过过过的生活!");
System.out.println("我想过过\t过过过过的生活!");
System.out.println("我想过过\n过过过过的生活!");
}
}
布尔类型
/*
编程实现布尔类型的使用
*/
public class BooleanTest {
public static void main(String[] args) {
// 1.声明一个boolean类型的变量并初始化
boolean b1 = true;
// 2.打印变量的数值
System.out.println("b1 = " + b1); // b1 = true
System.out.println("-------------------------------------------");
// 3.修改变量b1的数值 = 赋值运算符,用于将=右边的数据赋值给=左边的变量,覆盖变量中原来的数值
b1 = false;
System.out.println("b1 = " + b1); // b1 = false
System.out.println("-------------------------------------------");
//b1 = 1; // 错误: 不兼容的类型: int无法转换为boolean
}
}
4、进制
正十进制转二进制
- 除2取余法:使用十进制整数不断地除以2取出榆树,知道商为0时将余数逆序排序。
0b/0B为二进制标识 - 拆分法,将十进制整数拆分为若干个二进制权重的和,有该权重下面写1,否则写0.
二进制转十进制
- 加权法,使用二进制中的每个数字乘以当前位的权重再累加起来。
负数之间的进制转换
先将十进制的绝对值转为二进制,然后进行按位取反加1;负数的需要补码:按位取反,再加1。
验证:-45+45=0
负二进制转十进制
:先减1再按位取反,合并为十进制整数后添加负号
单个字节表示的范围
- 在计算机中单个字节表示八位二进制,其中最高位(最左边)代表符号位,使用0代表非负数,使用1代表负数,具体的整数范围如下:
- 非负数表示范围:0000 0000 ~ 0111 1111 =>0 ~ 127=>0~2^7-1
- 负数的表示范围:1000 0000 ~ 1111 1111=>-128 ~ -1=>-2^7 ~ 2^0
- 单个字节表示的整数范围是:-128 ~ 127
整数类型
- Java语言中描述整数数据的类型有:byte、short、int、long;推荐使用int类型(系统默认为int)
- 其中byte类型在内存空间占1个字节,表示范围是:-2^7 ~ 2^7-1
- 其中short类型在内存空间占2个字节,表示范围是:-2^15 ~ 2^15-1
- 其中int类型在内存空间占4个字节,表示范围是:-2^31 ~ 2^31-1
- 其中long类型在内存空间占8个字节,表示范围是:-2^63 ~ 2^63-1
- 在java程序中直接写出的整数数据叫做直接量/字面值/常量,默认为int类型。若希望表达更大的直接量,则在直接量的后面加上l或者L,推荐L。
浮点型
- java语言中用于描述小数数据的类型:float 和 double,推荐double类型;
- 其中float类型在内存空间占4个字节,叫做单精度浮点数,可以表示7位有效数字,范围:-3.403E38 ~ 3.403E38。
- 其中double类型在内存空间占8个字节,叫做双精度浮点数,可以表示15位有效数字,范围:-1.798E308 ~ 1.798E308。
- java程序中直接写出的小数数据叫做直接量,默认为double类型,若希望
表达float类型的直接量,则需要在直接量的后面加上f或者F。
布尔类型
只有两个值,true,false
布尔类型在内存空间中所占大小没有明确的规定,可以认为是1个字节
字符类型
-
计算机的底层只识别0和1组成的二进制序列,对于字符 ‘a’ 这样的图案来说不满足该规则,因此该数据无法直接在计算机中存储,但现实生活中存在这样的图案数据需要计算机存储,为了使得该数据能够存储起来就可以给该数据指定一个编号,然后将编号存储起来即可,该编号就叫做
ASCII。 -
要求掌握的ASCII有:‘0’ -48 ‘A’ -65 ‘a’ -97 空格 -32 换行符 -10
-
java 字符类型采用Unicode字符集编码。Unicode是世界通用的定长字符集,所有的字符都是16位。
-
常用的转义字符有:
基本数据类型的转换
- 小转大自动转
- 大转小需要强转
类型之间的转换
/*
编程实现基本数据类型之间转换的使用
*/
public class TransformTest {
public static void main(String[] args) {
// 1.声明两个变量并初始化
byte b1 = 10;
short s1 = 20;
// 2.打印变量的数值
System.out.println("b1 = " + b1); // b1 = 10
System.out.println("s1 = " + s1); // s1 = 20
System.out.println("----------------------------------------------");
// 3.实现自动类型转换的使用
// 表示将变量b1的数值赋值给变量s1,并覆盖变量s1中原来的数值,相当于从byte类型到short类型的转换,小到大 自动转换
s1 = b1;
System.out.println("b1 = " + b1); // b1 = 10
System.out.println("s1 = " + s1); // s1 = 10
System.out.println("----------------------------------------------");
// 4.实现强制类型转换的使用
// 表示将变量s1的数值赋值给变量b1,并覆盖变量b1中原来的数值,相当于从short类型到byte类型的转换,大到小 强制转换
//b1 = s1; // 错误: 不兼容的类型: 从short转换到byte可能会有损失
s1 = 128; // 故意加该行代码 128:0000 0000 1000 0000 => 1000 0000 => 0111 1111 => 1000 0000 => 128 => -128
b1 = (byte)s1;
System.out.println("b1 = " + b1); // b1 = 10 -128
System.out.println("s1 = " + s1); // s1 = 10 128
}
}
5、运算符
算数运算符
· + 表示加法运算符
· - 表示减法运算符
· * 表示乘法运算符
· / 表示除法运算符
· % 表示取模/取余运算符
重点:
- int类型整除怎么保留小数
- 0不能做除数
/*
编程实现算术运算符的使用
*/
public class ArithmeticTest {
public static void main(String[] args) {
// 1.声明两个int类型的变量并初始化
//int ia = 6, ib = 2; // 表示声明两个int类型的变量ia和ib,不推荐使用
int ia = 6; // 推荐该方式,提高了代码的可读性
int ib = 2;
System.out.println("ia = " + ia); // ia = 6
System.out.println("ib = " + ib); // ib = 2
System.out.println("----------------------------------------");
// 2.使用上述变量实现算术运算符的使用 + - * / %
// 表示声明变量ic来记录ia与ib的和
int ic = ia + ib;
System.out.println("ic = " + ic); // ic = 8
// 其中ia+ib这个整体叫做表达式 ia、ib叫做操作数 +叫做操作符/运算符
System.out.println(ia + ib); // 8
System.out.println(ia - ib); // 4
System.out.println(ia * ib); // 12
System.out.println(ia / ib); // 3
System.out.println(ia % ib); // 0
System.out.println("----------------------------------------");
// 3.注意事项
// 3.1 当两个整数相除时结果只保留整数部分,丢弃小数部分
System.out.println(5 / 2); // 2
System.out.println("----------------------------------------");
// 3.2 若希望保留小数部分该如何处理?
// 处理方式一:使用强制类型转换将其中一个操作数转换为double类型再运算即可
System.out.println((double)5 / 2); // 2.5
System.out.println(5 / (double)2); // 2.5
System.out.println((double)5 / (double)2); // 2.5
System.out.println((double)(5 / 2)); // 2.0
// 处理方式二:让其中一个操作数乘以1.0即可(推荐)
System.out.println(5*1.0 / 2); // 2.5
System.out.println(5.0 / 2); // 2.5 ia.0 错误的表示
System.out.println("----------------------------------------");
// 3.3 0不能作除数
//System.out.println(5 / 0); // 编译ok,运行发生java.lang.ArithmeticException(算术异常 记住): / by zero
System.out.println(5 / 0.0); // Infinity 无穷
System.out.println(0 / 0.0); // NaN Not a Number
}
}
时间拆分
重点:整除,取余
知识点:
- +既可以作为字符串连接符,又可以作为加法运算符;只要+两边的操作数中有一个操作数是字符串类型,则该+就被当做字符串连接符处理,否则当做加法运算符处理
/*
编程使用算术运算符实现秒数的拆分
*/
import java.util.Scanner;
public class ArithmeticTimeTest {
public static void main(String[] args) {
// 1.提示用户输入一个正整数的秒数并使用变量记录
System.out.println("请输入一个正整数的秒数:");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
// 2.将正整数的秒数拆分为时分秒后并使用变量记录
// 3666秒 => 1小时1分钟6秒钟
// 3666 / 3600 = 1 小时 3666 % 3600 = 66 / 60 = 1 分钟 3666 % 60 = 6 秒钟
int hour = num / 3600; // 拆分小时数
int min = num % 3600 / 60; // 拆分分钟数
int sec = num % 60; // 拆分秒数
// 3.打印最终的拆分结果
System.out.println(num + "秒转换为" + hour + "小时" + min + "分钟" + sec + "秒钟");
System.out.println("---------------------------------------------------------------------");
// 4.+既可以作为字符串连接符,又可以作为加法运算符
// 只要+两边的操作数中有一个操作数是字符串类型,则该+就被当做字符串连接符处理,否则当做加法运算符处理
System.out.println(hour + min + sec); // 8
System.out.println(hour + min + sec + ""); // 8
System.out.println(hour + min + "" + sec); // 26
System.out.println(hour + "" + min + sec); // 116
System.out.println("" + hour + min + sec); // 116
System.out.println("" + (hour + min + sec));// 8
}
}
赋值运算符
重点知识
- b1 += 2(ia = ia + 2); 真正等价于b1 = (byte)(b1 + 2);
byte b1 = 10;
System.out.println("b1 = " + b1);
b1 + 2; // 错误: 不兼容的类型: 从int转换到byte可能会有损失;byte + int 相加结果还是int类型
b1 = b1 + (byte)2; 错误: 不兼容的类型: 从int转换到byte可能会有损失
byte + byte 相加结果还是int类型 编译器优化
b1 = (byte)(b1 + 2); 强制类型转换,将int类型转换为byte
b1 += 2; 真正等价于b1 = (byte)(b1 + 2);
- 判断2是否等于变量ia的数值
2 == ia; 从结果上来说等价,推荐该方式
/*
赋值运算符的使用
*/
public class AssignTest {
public static void main(String[] args) {
// 1.声明一个int类型的变量并初始化
int ia = 3;
// 2.打印变量的数值
System.out.println("ia = " + ia); // ia = 3
System.out.println("-----------------------------------");
// 3.简单赋值运算符的使用
// 表示将数据5赋值给变量ia并且覆盖变量ia原来的数值
ia = 5;
System.out.println("ia = " + ia); // ia = 5
// 下面的代码是在打印表达式的结果
System.out.println( ia = 5 ); // 5
System.out.println("ia = " + ia); // ia = 5
int ib = ia = 6;
System.out.println("ia = " + ia); // ia = 6
System.out.println("ib = " + ib); // ib = 6
int ic;
ic = ib = ia = 8;
System.out.println("ia = " + ia); // ia = 8
System.out.println("ib = " + ib); // ib = 8
System.out.println("ic = " + ic); // ic = 8
System.out.println("-----------------------------------");
// 4.复合赋值运算符的使用
//ia = ia + 2; 目前推荐使用该方式
ia += 2; // 简化写法,从结果上来看是等价的
System.out.println("ia = " + ia); // ia = 10
System.out.println("-----------------------------------");
// 5.笔试考点1
byte b1 = 10;
System.out.println("b1 = " + b1); // b1 = 10
//b1 = b1 + 2; // 错误: 不兼容的类型: 从int转换到byte可能会有损失 byte + int 相加结果还是int类型
//b1 = b1 + (byte)2; // 错误: 不兼容的类型: 从int转换到byte可能会有损失 byte + byte 相加结果还是int类型 编译器优化
//b1 = (byte)(b1 + 2); // 强制类型转换,将int类型转换为byte
b1 += 2; // 真正等价于b1 = (byte)(b1 + 2);
System.out.println("b1 = " + b1); // b1 = 12
System.out.println("-----------------------------------");
// 6.笔试考点2
//ia == 2; - 表示判断变量ia的数值是否等于2
//2 == ia; - 表示判断2是否等于变量ia的数值,从结果上来说等价,推荐该方式
//ia = 2; - 表示将2赋值给变量ia,覆盖变量ia原来的数值
//2 = ia; //- 编译报错 错误: 意外的类型
}
}
关系/比较运算符
- >表示是否大于
- >=表示是否大于等于
- <表示是否小于
- <=表示是否小于等于
- ==表示是否等于
- \!=表示是否不等于
所有以关系运算符作为最终运算的表达式的结果一定是boolean类型。
自增减运算符
-
++ 表示自增运算符,用于使得当前变量自身的数值加1的效果
-
- - 表示自减运算符,用于使得当前变量自身的数值减1的效果
-
只能用于变量,常数不可以
重点:
前++,后++的区别
/*
编程实现自增减运算符的使用
*/
public class SelfTest {
public static void main(String[] args) {
// 1.声明一个int类型的变量并初始化
int ia = 10;
// 2.打印变量的数值
System.out.println("ia = " + ia); // ia = 10
System.out.println("---------------------------------------------");
// 3.实现自增减运算符的使用
// 表示让变量ia自身的数值加1,并覆盖该变量原来的数值
ia++; // ia = ia + 1;
System.out.println("ia = " + ia); // ia = 11
// 表示让变量ia自身的数值加1,并覆盖该变量原来的数值
++ia;
System.out.println("ia = " + ia); // ia = 12
// 表示让变量ia自身的数值减1,并覆盖该变量原来的数值
--ia;
System.out.println("ia = " + ia); // ia = 11
ia--;
System.out.println("ia = " + ia); // ia = 10
System.out.println("---------------------------------------------");
// 4.简单的变换
// 其中ia++这个整体叫做表达式 其中ia叫做操作数/变量 也就是ia++和ia表示不同的含义,因此所占的内存空间应该不同
// 下面的代码是在打印表达式的结果
// 后++表示先让变量ia的数值作为整个表达式的最终结果,然后再让ia变量自身的数值加1
System.out.println(ia++); // 10
System.out.println("ia = " + ia); // 11
// 前++表示先让变量自身的数值加1,然后再让变量的数值作为整个表达式的结果
System.out.println(++ia); // 12
System.out.println("ia = " + ia); // 12
System.out.println("---------------------------------------------");
// 5.笔试考点
int ib = ia++;
System.out.println("ib = " + ib); // 12
System.out.println("ia = " + ia); // 13
int ic = ++ia;
System.out.println("ic = " + ic); // 14
System.out.println("ia = " + ia); // 14
// 14 + 16
System.out.println(ia++ + ++ia); // 30
System.out.println("ia = " + ia); // 16
}
}
逻辑运算符
· && 表示逻辑与运算符,相当于"并且",同真为真,一假为假。
· || 表示逻辑或运算符,相当于"或者",一真为真,同假为假。
· ! 表示逻辑非运算符,相当于"取反",真为假,假为真。
· 逻辑运算符的操作数均为boolean表达式。
逻辑运算符的短路特性
-
对于逻辑与运算符来说,若第一个表达式为假则结果为假,此时跳过第二个表达式;
-
对于逻辑或运算符来说,若第一个表达式为真则结果为真,此时跳过第二个表达式;
/*
编程实现逻辑运算符的使用
*/
public class LogicTest {
public static void main(String[] args) {
// 1.声明两个boolean类型的变量并初始化
boolean b1 = true;
boolean b2 = false;
// 2.打印变量的数值
System.out.println("b1 = " + b1); // b1 = true
System.out.println("b2 = " + b2); // b2 = false
System.out.println("---------------------------------------------");
// 3.使用上述变量实现逻辑运算符的使用
boolean b3 = b1 && b2;
System.out.println("b3 = " + b3); // false
System.out.println(b1 && b2); // false 并且
System.out.println(b1 || b2); // true 或者
System.out.println(!b1); // false 取反
System.out.println(!b2); // true
System.out.println("---------------------------------------------");
// 4.测试一下短路特性
int ia = 3;
int ib = 5;
// 对于逻辑与运算符来说,若第一个条件为假则整个表达式为假,此时跳过第二个表达式不执行
boolean b4 = (++ia == 3) && (++ib == 5);
System.out.println("b4 = " + b4); // false
System.out.println("ia = " + ia); // 4
System.out.println("ib = " + ib); // 5
// 对于逻辑或运算符来说,若第一个条件为真则整个表达式为真,此时跳过第二个表达式不执行
boolean b5 = (++ia == 5) || (++ib == 5);
System.out.println("b5 = " + b5); // true
System.out.println("ia = " + ia); // 5
System.out.println("ib = " + ib); // 5
}
}
赋值运算符
· = 表示赋值运算符,用于将=右边的数据赋值给=左边的变量,覆盖变量原来的数值。
· 赋值表达式本身也有值,其本身之值即为所赋之值。
· +=、 -=、 *=、 /=
条件/三目运算符
· 条件表达式? 表达式1: 表达式2
· 判断条件表达式是否成立,若成立则执行表达式1,否则执行表达式2 。
/*
编程使用三目运算符查找最大值
*/
import java.util.Scanner;
public class ThreeEyeTest {
public static void main(String[] args) {
// 1.提示用户输入两个整数并使用变量记录
System.out.println("请输入两个整数:");
Scanner sc = new Scanner(System.in);
int ia = sc.nextInt();
int ib = sc.nextInt();
// 2.使用三目运算符找到最大值并打印
int max = ia > ib? ia: ib;
System.out.println("最大值是:" + max);
System.out.println("最大值是:" + (ia > ib? ia: ib));
}
}
移位运算符(了解)
· << 左移运算符,用于将数据的二进制位向左移动,右边使用0补充
· >> 右移运算符,用于将数据的二进制位向右移动,左边使用符号位补充
· >>> 表示逻辑右移运算符,用于将数据的二进制位向右移动,左边使用0补充。
/*
编程实现移位运算符的使用
*/
public class MoveBitTest {
public static void main(String[] args) {
// 1.声明一个byte类型的变量并初始化
byte b1 = 13;
// 2.打印变量的数值
System.out.println("b1 = " + b1); // b1 = 13
System.out.println("---------------------------------------------------");
// 3.移位运算符的使用
// 13的二进制是:... 0000 1101 => 左移1位的结果是:... 0001 1010 => 换算为十进制整数是:26
//byte b2 = b1 << 1; // 错误: 不兼容的类型: 从int转换到byte可能会有损失 自动提升为int类型,也就是32位二进制
byte b2 = (byte)(b1 << 1);
System.out.println("b2 = " + b2); // 26
System.out.println(b1 << 1); // 26 左移1位相当于当前整数的数值*2
System.out.println(b1 << 2); // 52 左移2位相当于当前整数的数值*4
System.out.println("---------------------------------------------------");
// 13的二进制是:... 0000 1101 => 右移1位的结果是:... 0000 0110 => 换算为十进制整数是:6
System.out.println(b1 >> 1); // 6 右移1位相当于当前整数的数值/2
System.out.println(b1 >> 2); // 3 右移2位相当于当前整数的数值/4
System.out.println("---------------------------------------------------");
// 逻辑右移 对于非负数来说,逻辑右移和右移的效果一致
System.out.println(b1 >>> 2); // 3
}
}
位运算符(了解)
· & 表示按位与运算符,按照二进制位进行与运算,同1为1,一0为0.
· | 表示按位或运算符,按照二进制位进行或运算,一1为1,同0为0.
· ~ 表示按位取反运算符,按照二进制位进行取反,1为0,0为1.
· ^ 表示按位异或运算符,按照二进制位进行异或运算,同为0,不同为1.
/*
编程实现位运算符的使用
*/
public class BitTest {
public static void main(String[] args) {
// 1.声明两个byte类型的变量并初始化
byte b1 = 11;
byte b2 = 13;
// 2.打印变量的数值
System.out.println("b1 = " + b1); // b1 = 11
System.out.println("b2 = " + b2); // b2 = 13
System.out.println("---------------------------------------------------");
// 3.实现位运算符的使用
// b1的二进制为: 0000 1011
// b2的二进制为: 0000 1101
System.out.println( b1 & b2); // 按位与:同1为1,一0为0 按位与后的二进制为:0000 1001 => 转为十进制是:9
System.out.println( b1 | b2); // 按位或:一1为1,同0为0 按位或后的二进制为:0000 1111 => 转为十进制是:15
System.out.println( b1 ^ b2); // 按位异或:相同为0,不同为1 按位异或的二进制为:0000 0110 => 转为十进制是:6
System.out.println( ~ b1); // 按位取反:1为0,0为1 按位取反的二进制为:1111 0100
// 二进制1111 0100转为十进制 => 先减1: 1111 0011 => 按位取反:0000 1100 => 转为十进制:12 => 添加负号:-12
}
}
运算符的优先级
· ()的优先级极高。
· =的优先级极低。
· 若无法确认优先级,则使用()来确保即可