文章目录
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);
}
}