文章目录
1. 数据类型转换
当数据类型不一样时，将会发生数据类型转换。
1.1. 自动类型转换：
- 特点：代码不需要进行特殊处理，自动完成。
- 规则：数据范围从小到大；与字节数无关
public class Demo01DataType {
public static void main(String[] args){
System.out.println(1024); // 这就是一个整数，默认是int类型
System.out.println(3.14); // 这就是一个浮点数，默认是double类型
// 左边是long类型，右边是默认的int类型，左右边不一样
// 一个等号代表赋值，将右侧的int变量，交给左侧的long变量进行存储
// int --> long， 符合了数据范围从小到大的要求
// 这一行代码发生了自动转换类型
long num1 = 100L;
System.out.println(num1);
// 左边是double类型，右边是float类型，左右不一样
// float --> double，符合从小到大的规则
// 发生了自动类型转换
double num2 = 2.5F;
//左边是float类型，右边是long类型
// long --> float， 范围是float更大些，符合从小到大的规则
float num3 = 30L;
}
}
1.2. 强制转换
- 特点：代码需要进行特殊的格式处理，不能自动完成。
- 格式：
范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据
- 注意事项：
- 强制类型转换一般不推荐使用！因为有可能发生精度损失，数据溢出！
byte/short/char这三种类型都可以发生数学运算，例如加法“+”。byte/short/char这三种数据类型在运算的时候，都会被首先提升称为int，然后再计算。boolean类型不能发生数据转变。
public class Demo02DataType {
public static void main(String[] args){
// 左边是int类型，右边是long类型，不一样
// long --> int，不是从小到大！
// 不能发生自动转换！
// 范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据
int num = (int) 100L;
System.out.println(num);
// long强制转换晟int类型；但是int最多到20多亿
int num2 = (int) 7000000000L;
System.out.printLn(num2); // 出现的结果不会是70亿，打印出来是17亿
// 精度损失：
// double --> int，强制类型转换
int num3 = (int) 3.5;
System.out.printLn(num3); //出现的结果是3，所有小数位都被舍弃
// 发生数学运算：
char zifu1 = 'A'; // 这事一个字符型变量
Sysmte.out.printLn(zifu1 + 1); // 66，大写字母A被当作65来处理的
// 提成为int：
byte num4 = 40; // 注意！右侧的数值大小不能超过左侧的类型范围
byte num5 = 50;
// byte + byte --> int + int
// byte result1 = num4 + num5; -->这么些报错！
int result1 = num4 + num5;
System.out.printLn(result1);
short num6 = 60;
// byte + short --> int + int
// int强制转换为short：注意必须保证逻辑上正式大小本来就没有超过short范围，否则会溢出
short result2 = (short) (num4 + num5);
System.out.printLn(result2);
}
}
1.3. ASCII 编码表
-
ASCII码表：American Standard Code for Information Interchange
-
Unicode码表：万国码；也是数字和符号的对照关系，开头0-127和ASCII完全一样，但是从128开始包含更多的字符。
-
记住以下几个：
48 --> ‘0’
65 --> ‘A’
97 --> ‘a’
public class Demo03DataTypeChar {
public static void main(String[] args) {
char zifu1 = '1';
System.out.println(zifu1 + 0); //49
char zifu2 = 'A'; // 底层保存的事数字65
char zifu3 = 'c';
//左侧事int类型，右侧是char类型
//char --> int，确实是从小到大
//发生了自动类型转换
int num = zifu3；
System.out.println(num);// 99
}
}
2. 运算符
2.1. 加减乘除、取模、自增/自减
-
加减乘除取模和Python一样。
-
注意加号
“+”在字符串中的使用（基本和Python中一样）。 -
和Python不一样的是，Java中有自增
“++”和自减“--”。例如：/* 自增/自减运算符 使用方式： 1. 单独使用： 不和其他任何操作混合，自己独立成为一个步骤。 2. 混合使用： 和其他操作混合，例如与赋值混合，或者与打印操作混合，等。 使用区别： 1. 在单独使用的时候，前++和后++没有任何区别。 2. 在混合使用的时候，有【重大区别】 A. 如果是【前++】，那么变量【立马+1】，然后拿着结果进行使用。【先加候用】 B. 如果是【后++】，那么首先使用变量本来的数值，【然后再让变量+1】。【先用后加】 */ public class Demo06Operator { public static void main(String[] args) { // 1. 单独使用的情况： int num1 = 10; System.out.println(num1); //10 ++num1; System.out.println(num1): //11 num1++; System.out.println(num1); // 2. 混合使用的情况： // 与打印操作混使用的时候 int num2 = 20; // 混合使用，【先++】，变量立马变成21，然后打印21。 System.out.println(++num2); //21 System.out.println(num2); //21 int num3 = 30; // 混合使用，【后++】，首先使用变量本来的30，然后再让变量+1，得到31 System.out.println(num3++); //30 System.out.println(num3); //31 int num5 = 50; // 混合使用，后--，首先把本来的数字50交给result2，然后自己再-1变成49 int result2 = num5-- System.out.println(result2); //50 System.out.println(num5); //49 int x = 10; int y = 20; // 11 + 20 = 31 int result3 = ++x + y--; System.out.println(result3); //31 System.out.println(x); //11 System.out.println(y); //19 //30++ //常量不可以使用++或者--！ } }
- 注意事项：只有变量才能使用自增、自减运算符。常量不可发生改变，所以不能用。
2.2. 赋值运算符
- 赋值运算符：“=”
- 复合赋值运算符：“+=”；“-+”，“*=”；“/=”；“%=”。
- 注意事项：符合运算符其中隐含了一个强制类型转换。
public class Demo07Operator {
public static void main(Sring[] args) {
int a = 10;
a += 5;
System.out.println(a); //15
int x = 10;
// x = 10 % 3
// x = 1
x %= 3;
System.out.println(x); //1
// 符合运算符其中隐含了一个强制类型转换
byte num = 30;
// num = byte + int
// num = int + int
num += 5;
System.out.println(num); //35
}
}
2.3. 比较运算符
和Python基本一样，但是Java不允许连着比较，例如：10 > 9 > 6；但是Python可以这么写。
public class Demo08Operator {
public static void main(String[] args) {
// python中可以连着比较，但是Java中不行！报错！！！
System.out.println(10 > 9 >6);
}
}
2.4. 逻辑运算符
- 与：
&&--> python中的and - 或：
||--> python中的or - 非：
!--> python中的是not
- 注意：python中的是：
True和False；而在Java中首字母都是小写，即：true和false
- 短路：
&&和||，具有短路效果：如果左边已经可以判断得到最终结果，那么有百年的代码将不会再执行，从而节省一些性能。
2.5. 三元运算符
-
一元运算符：取反！；自增++
-
二元运算符：加法；减法
-
三元运算符：需要三个数据才可以进行操作的运算符。
-
格式：
数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B; -
流程：首先判断条件是否成立：
- 如果成立为true，那么将表达式A的值赋值给左侧的变量；
- 如果不成立为false，那么表达式B的值赋值给左侧的变量。
-
注意事项：
- 必须同时保证表达式A和B都符合左侧数据类型的要求。
- 三元运算符的结果必须被使用。
public class Demo10Operator {
public static void main(String[] args) {
int a = 10;
int b = 20;
// 判断a>b是否成立，如果成立将a的值赋给max；如果不成立将b赋值给max。二者选其一:
int max = a > b ? a : b; //最大值
// 必须同时保证表达式A和B都符合左侧数据类型的要求:
int result = 3 > 4 ? 2.5 : 10; // 错误写法！
// 三元运算符的结果必须被使用:
System.out.println(a > b ? a : b); // 正确写法！
a > b ? a : b; //错误写法！
}
}
3. 方法入门
格式：
public static void 方法名称() {
方法体
}
注意事项：
- 方法的定义的先后顺序无所谓。
- 方法的定义不能产生嵌套包含关系。
- 方法定义好了，不会执行的。如果要想执行，一定要进行方法的【调用】
4. jshell使用
jshell是脚本，在command命令行中直接输入jshell。类似于IPython。
退出输入命令/exit，注意不要忘记/。
5. 扩展：编译器自动补全byte/short/char；编译器的常量优化
- 对于byte/short/char三种类型来说，如果右侧赋值的数值没有超过范围，那么javac编译器将会自动隐含的为我们补上一个
(byte)、(short)、(char)。
public class Demo12Notice {
public static void main(String[] args) {
// 右侧确实是一个int数字，但是没有超多左侧的范围，就是正确的
// int --> byte，不是自动类型转换
byte num1 = 10; // 右侧没有超过左侧的范围
System.out.println(num1); // 10
byte num2 = 123; //右侧超过了左侧的范围，所以报错！！！
// int --> char，没有超多范围
// 编译器将会自动不上一个隐含的(char)
char zifu1 = /*char()*/ 65;
System.out.println(zifu1); // A
}
}
-
再给变量进行赋值的时候，如果右侧的表达式当中全都是变量，没有任何变量，那么编译器javac将会直接将若干个变量表达式计算得到结果。
例如：
short result = 5 + 8，这种情况下，等号右边全都是常量，没有任何变量参与运算，编译之后，得到的.class字节码文件当中相当于直接就是：short result = 13。右边的常量结果数值没有超多左侧的范围，所以正确。这称之为：“编译器的常量优化”。但是，一旦表达式中有变量参与，那么就不能进行这种优化了！
public static Demo13Notice {
public static void main(Sting[] args) {
short num1 = 10; // 正确写法，右侧没有超多左侧的范围
short a = 5;
short b = 8;
// short + short --> int + int --> int
short result = a + b; // 错误写法！左侧需要是int类型
// 右侧不用变量，而是采用常量，而且只有两个常量，没有别人
short result = 5 + 8;
System.out.println(result);
}
}
1558
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
