数据类型转换
为了什么需要数据类型转换呢?就像我们日常生活中你有100张1块钱,但是你想要将这100元存到银行就必须要将100张1块钱转换为1张100元。
在Java中也是这样,当数据类型不一致时就会发生数据类型转换。
- 自动类型转换(隐式类型转换)
指的是不需要特殊的代码处理,Java自动帮我们实现数据类型的转换
前提是要符合规则:
数据范围是从小到大发生转换
public class DataType {
public static void main(String[] args) {
System.out.println(1234); // 整数默认是int类型
System.out.println(6.18); // 浮点数默认是double类型
// int --> long,符合了数据范围从小到大的要求
// 发生了自动类型转换。
long num1 = 100;
System.out.println(num1); // 100
// float --> double,符合从小到大的规则
// 发生自动类型转换
double num2 = 2.5F;
System.out.println(num2); // 2.5
// long --> float,虽然long是8个字节float是4个字节,但是范围来说是float更大一些,所以符合从小到大的规则
// 也发生了自动类型转换
float num3 = 30L;
System.out.println(num3); // 30.0
}
}
- 强制类型转换(显示类型转换)
- 指的是需要特殊的代码处理,我们需要指定数据类型才能实现数据类型的转换
前提是要符合规则:
数据范围是从大到小发生转换
格式:小数据类型 变量名 = (小数据类型)大数据
int num = (int) 100L;
System.out.println(num);//100
需要注意的是这里的100L本身就是100,在int范围之内,所以数值没变只是数据类型变换。
注意事项:
- 强制类型转换一般不推荐使用,因为有可能发生精度损失、数据溢出。
- byte/short/char这三种类型都可以发生数学运算。
- byte/short/char这三种类型在运算的时候,都会被提升成为int类型再参与运算。
- boolean类型不能发生数据类型转换
数据溢出(可能发生)
指的是大的整型数据类型转为小的整型数据类型,发生的数据超出范围情况。
// long强制转换成为int类型
int num2 = (int) 6000000000L;
System.out.println(num2); // 1705032704
因为这里的6000000000L已经超过了int范围,将一个大数据装进一个小容器,肯定会发生数据溢出。
精度损失(一定发生)
指的是浮点型数据转为整型数据,发生精度丢失情况。
// double --> int,强制类型转换
int num3 = (int) 3.99;
System.out.println(num3); // 3
int整型数据类型,没有小数点,所以就会发生精度损失情况。
byte、short、char发生运算
char zifu1 = 'A'; // 定义字符型变量,里面存放大写字母A,ASCII表为65,下次介绍
System.out.println(zifu1 + 1); // 66
byte num1 = 40;
byte num2 = 50;
// byte + byte --> int + int --> int
int result1 = num1 + num2;
System.out.println(result1); // 90
short num6 = 60;
// byte + short --> int + int --> int
// int强制转换为short:100并没有超过short范围,否则会发生数据溢出
short result2 = (short) (num4 + num6);
System.out.println(result2); // 100
编码表
我们都知道,在我们的计算机中是用二进制进行数据处理的,字符也要用二进制表示,为了让计算机读懂我们生活中所用到的字符,出现了
数字和字符的对照关系表(编码表):
ASCII码表:American Standard Code for Information Interchange,美国信息交换标准代码。(毕竟一开始的计算机都是美国人发明的)
Unicode码表:通用码。开头0-127部分和ASCII完全一样,但是从128开始包含有更多字符。包含中国、韩国…
常用的字符编码
48 - ‘0’ …
65 - ‘A’ .…
97 - ‘a’ …
通过编码表,我们就能明确了解char数据类型在参与运算时的数值大小。
运算符
指的是变量或者常量之间进行运算的符号,通过运算符来组成表达式。
算术运算符
- 加减乘除
int a = 20;
int b = 30;
System.out.println(a - b); // -10
System.out.println(a * 10); // 200
int x = 10;
int y = 3;
int result1 = x / y;
System.out.println(result1); // 3
- 取模
int x = 10;
int y = 3;
int result2 = x % y;
System.out.println(result2); // 余数,模,1
注意事项:
一旦运算当中有不同类型的数据,那么结果将会是数据类型范围大的那种。
// int + double --> double + double --> double
int x = 10;
double result3 = x + 2.5;
System.out.println(result3); // 12.5
我们说一下加法+,因为+在我们的运算中有很多种情况。
数值加法
就是普通的 1+1 2+2
char数据类型加法
char数据类型在参与运算时会自动提升为int,其值为ASCII码表和Unicode表中所对应的数值。
字符串加法
对于String字符串数据类型,它是一种引用数据类型,不是关键字。用到加法的时候就表示连接符,一切的数据类型和字符串相加时都会通过+变成字符串。
// 字符串类型的变量基本使用
// 数据类型 变量名称 = 数据值;
System.out.println("Hello" + "World"); // HelloWorld
String str2 = "Java";
// String + int --> String
System.out.println(str2 + 20); // Java20
// 优先级问题
System.out.println(str2 + 20 + 30); // Java2030
System.out.println(str2 + (20 + 30)); // Java50
- 自增、自减运算符
自增运算符:++
自减运算符:–
使用格式:写在变量名称前或者变量名之后。例如:++num或num++
使用方式:
- 单独使用:不和其他任何操作混合,自己独立使用。
- 混合使用:和其他操作混合,例如与赋值混合,或者与打印操作混合,等。
使用区别: - 在单独使用的时候,前++和后++是完全一样的。
- 在混合的时候,有【重大区别】
A. 如果是【前++】,那么变量【立刻马上+1】,然后拿着结果进行使用。 【先加后用】
B. 如果是【后++】,那么首先使用变量本来的数值,【然后再让变量+1】。 【先用后加】
注意事项:
只有变量才能使用自增、自减运算符。常量不可发生改变,所以不能用。
public class Operator {
public static void main(String[] args) {
int num1 = 10;
++num1; // 单独使用,前++
System.out.println(num1); // 11
num1++; // 单独使用,后++
System.out.println(num1); // 12
System.out.println("=================");
// 与打印操作混合的时候
int num2 = 20;
// 混合使用,先++,变量立刻马上变成21,然后打印结果21
System.out.println(++num2); // 21
System.out.println(num2); // 21
System.out.println("=================");
int num3 = 30;
// 混合使用,后++,首先使用变量本来的30,然后再让变量+1得到31
System.out.println(num3++); // 30
System.out.println(num3); // 31
System.out.println("=================");
int num4 = 40;
// 和赋值操作混合
int result1 = --num4; // 混合使用,前--,变量立刻马上-1变成39,然后将结果39交给result1变量
System.out.println(result1); // 39
System.out.println(num4); // 39
System.out.println("=================");
int num5 = 50;
// 混合使用,后--,首先把本来的数字50交给result2,然后自己再-1变成49
int result2 = num5--;
System.out.println(result2); // 50
System.out.println(num5); // 49
System.out.println("=================");
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++; 错误写法!常量不可以使用++或者--
}
}
赋值运算符
基本赋值运算符
= 表示右边的数据赋值给左边的变量
复合赋值运算符
+=
*= 5
d /= 6
e %= 7
类型 | 举例 | 相等于 |
+= | a += 3 | a = a + 3 |
-= | b -= 4 | b = b - 4 |
*= | c *= 5 | c = c * 5 |
/= | d /= 6 | d = d / 6 |
%= | e %= 7 | e = e % 7 |
注意事项:
1. 只有变量才能使用赋值运算符,常量不能进行赋值。
2. 复合赋值运算符其中隐含了一个强制类型转换。我们感觉不到是因为编译器帮我们做处理好了,如果想要看底层运行代码,可以使用反编译工具查看。
public class Operator {
public static void main(String[] args) {
int a = 10;
a += 5;
System.out.println(a); // 15
int x = 10;
// x本来是10,现在重新赋值得到1
x %= 3;
System.out.println(x); // 1
byte num = 30;
// num = num + 5;
// num = byte + int
// num = int + int
// num = int
// num = (byte) int
num += 5;
System.out.println(num); // 35
}
}
比较运算符
大于: >
小于: <
大于等于: >=
小于等于: <=
相等: == 【两个等号连写才是相等,一个等号代表的是赋值】
不相等: !=
注意事项:
- 比较运算符的结果一定是一个boolean值,成立就是true,不成立就是false。
- 如果进行多次判断,不能连着写。
数学当中的写法,例如:1 < x < 3
Java程序当中【不允许】这种写法。
public class Operator {
public static void main(String[] args) {
System.out.println(10 > 5); // true
int num1 = 10;
int num2 = 12;
System.out.println(num1 < num2); // true
System.out.println(num2 >= 100); // false
System.out.println(num2 <= 100); // true
System.out.println(num2 <= 12); // true
System.out.println("===============");
System.out.println(10 == 10); // true
System.out.println(20 != 25); // true
System.out.println(20 != 20); // false
int x = 2;
// System.out.println(1 < x < 3); // 错误写法!编译报错!不能连着写。
}
}
逻辑运算符
- 与(并且) && 全都是true,才是true;否则就是false,丈母娘要有车还有房。
- 或(或者) || 至少一个是true,就是true;全都是false,才是false,丈母娘只要车和房其中一个就行。
- 非(取反) ! 本来是true,变成false;本来是false,变成true。生的反义词是熟
注意事项
- 逻辑运算符操作对象时boolean型
- 与、或需要左右各自有一个boolean值,但是取反只要有唯一的一个boolean值即可。
- 与、或两种运算符,如果有多个条件,可以连续写。
两个条件:条件A && 条件B
多个条件:条件A && 条件B && 条件C&&… - “&&”、“||”,具有短路效果:如果根据左边已经可以判断得到最终结果,那么右边的代码将不再执行,从而节省一定的性能。也就是说&&前面条件是false就不必再判断后面的条件,||前面条件是True不必再判断后面的条件,
public class Logic {
public static void main(String[] args) {
System.out.println(true && false); // false
// true && true --> true
System.out.println(3 < 4 && 10 > 5); // true
System.out.println("============");
System.out.println(true || false); // true
System.out.println(true || true); // true
System.out.println(false || false); // false
System.out.println("============");
System.out.println(true); // true
System.out.println(!true); // false
System.out.println("============");
int a = 10;
// false && ...
System.out.println(3 > 4 && ++a < 100); // false
System.out.println(a); // 10
System.out.println("============");
int b = 20;
// true || ...
System.out.println(3 < 4 || ++b < 100); // true
System.out.println(b); // 20
}
}
三元运算符
指的是三个数据进行运算
格式要求:
数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;
首先判断条件是否成立:
如果成立为true,那么将表达式A的值赋值给左侧的变量;
如果不成立为false,那么将表达式B的值赋值给左侧的变量;
二者必须选其一。
注意事项:
- 必须同时保证表达式A和表达式B都符合左侧数据类型的要求。(不管逻辑如何,都要确保两个表达式复合左边的数据类型)
- 三元运算符的结果必须被使用。(打印也算是使用的一种,不能只运算不使用!)
public class Operator {
public static void main(String[] args) {
int a = 10;
int b = 20;
// 判断a > b是否成立,如果成立将a的值赋值给max;如果不成立将b的值赋值给max。二者选其一
int max = a > b ? a : b; // 最大值的变量
System.out.println("最大值:" + max); // 20
// int result = 3 > 4 ? 2.5 : 10; // 错误写法!因为2.5不是int类型
System.out.println(a > b ? a : b); // 正确写法!
// a > b ? a : b; // 错误写法!必须使用
}
}
方法
指的是将一些代码用大括号包起来,形成一个单独的功能。
方法的好处在于减少代码的冗余性和复用性。
格式:
修饰符 返回值类型 方法名 (参数列表){
代码...
return ;
}
元素解析
- 修饰符,目前写死public static
- 返回值类型,目前写死void
- 方法名,满足命名规则的标识符即可
- 参数列表,指的是方法需不需要参数,可以没有
- return,指的是方法结束需要携带的返回值,方法可以不写return
方法的调用
方法不调用不执行,需要在主方法main里面调用已经定义好的方法。
public static void main(String[] args) {
//调用定义的方法method
method();
}
//定义方法,被main方法调用
public static void method() {
System.out.println("被main调用运行的方法!");
}
举例
public static void main(String[] args) {
//调用定义的方法operator
operator();
}
//定义方法,方法中定义三元运算符
public static void operator() {
int i = 0;
i = (1==2 ? 100:200);
System.out.println(i);
int j = 0 ;
j = (3<=4 ? 500:600);
System.out.println(j);
}
注意事项
- 方法必须定义在类中方法外
- 方法不能定义在另一个方法的里面
举例
public class Demo {
public static void main(String[] args){
}
//正确写法,类中,main方法外面可以定义方法
public static void method(){}
}
public class Demo1 {
public static void main(String[] args){
//错误写法,一个方法不能定义在另一方法内部
public static void method(){}
}
}