小林带你学Java--day03--数据类型转换、编码表、运算符、方法

数据类型转换

为了什么需要数据类型转换呢？就像我们日常生活中你有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范围之内，所以数值没变只是数据类型变换。
注意事项：

1. 强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。
2. byte/short/char这三种类型都可以发生数学运算。
3. byte/short/char这三种类型在运算的时候，都会被提升成为int类型再参与运算。
4. 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++
  使用方式：
  1. 单独使用：不和其他任何操作混合，自己独立使用。
  2. 混合使用：和其他操作混合，例如与赋值混合，或者与打印操作混合，等。
     使用区别：
  3. 在单独使用的时候，前++和后++是完全一样的。
  4. 在混合的时候，有【重大区别】
     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
	}
}

比较运算符

大于： >
小于： <
大于等于： >=
小于等于： <=
相等： == 【两个等号连写才是相等，一个等号代表的是赋值】
不相等： !=
注意事项：

1. 比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false。
2. 如果进行多次判断，不能连着写。
   数学当中的写法，例如：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); // 错误写法！编译报错！不能连着写。
	}
}

逻辑运算符

1. 与（并且） && 全都是true，才是true；否则就是false，丈母娘要有车还有房。
2. 或（或者） || 至少一个是true，就是true；全都是false，才是false，丈母娘只要车和房其中一个就行。
3. 非（取反） ! 本来是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的值赋值给左侧的变量；
二者必须选其一。
注意事项：

1. 必须同时保证表达式A和表达式B都符合左侧数据类型的要求。（不管逻辑如何，都要确保两个表达式复合左边的数据类型）
2. 三元运算符的结果必须被使用。（打印也算是使用的一种，不能只运算不使用！）

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 ;       
}

元素解析

1. 修饰符，目前写死public static
2. 返回值类型，目前写死void
3. 方法名，满足命名规则的标识符即可
4. 参数列表，指的是方法需不需要参数，可以没有
5. 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);
 }

注意事项

1. 方法必须定义在类中方法外
2. 方法不能定义在另一个方法的里面
   举例

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(){}    
   }
 }