数据类型转换
为了什么需要数据类型转换呢？就像我们日常生活中你有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); // 3int整型数据类型，没有小数点，所以就会发生精度损失情况。
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(){}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
