sa

1. /*
   
2. 1、关键字
   
3.         定义：被java语言赋予了特殊含义的单词。main不是关键字。goto  const是保留字
   
4.         特点：字母均为小写
   
5.        
   
6.         用于定义数据类型的关键字：class interface byte short char int float long
   
7.         double boolean void
   
8.         用于定义数据类型值： true false null
   
9.         用于定义访问权限修饰符：public protected private
   
10.         用于定义定义类，函数，变量修饰符的关键字：abstract final static synchronized
    
11.         用于定义类与类之间的关系：extends implements
    
12.         用于定义新建实例和引用实例，判断实例的关键字：new this super instanceof
    
13.         用于异常处理的：throws throw try catch finally
    
14.         用于包的关键字：package import
    
15.         其他修饰符： native strictfp transient volatile assert
    
16. 
    
17. 2、java中的常量分类
    
18.         1 整数常量
    
19.         2 小数常量
    
20.         3 boolean型常量：true false
    
21.         4 字符常量：单引号括起的单数字或字母或符号，如'a' '\t'
    
22.         5 字符串常量：双引号标识的一个或多个字符，"h","hello woer"
    
23.         5 null常量:只有一个数值，null
    
24. 
    
25. 3、java中的8中基本数据类型
    
26.         byte 1字节                char 2字节                short 2字节                int 4字节
    
27.         float 4字节                long 8字节                double 8字节        boolean
    
28. 
    
29.         PS:整数的默认类型是 int                小数的默认类型是 double
    
30. 
    
31.         long l = 1234355654; //错误，超出int范围
    
32.         long l = 1234355654L;//正确，加L使编译器知道数据类型是long
    
33. 
    
34.         float f = 2.3;// 错误，默认小数数double
    
35.         float f = 2.3f；//正确 ，加标识f
    
36. 
    
37.         3种引用数据类型： 类 class                接口 interface                数组[]
    
38. 
    
39.         常见错误：        1 定义long型数据，赋值时未加标识L
    
40.                                 2 定义float,赋值或初始化没添加f，编译器识别为double型
    
41.                                 3 定义变量后，未初始化即使用
    
42.                                         int a; System.out.println(a);
    
43.                                 4 使用不存在的变量或在变量作用域之外使用变量
    
44. 
    
45. 4、类型转换
    
46.         1 自动类型转换
    
47.                 int a = 3;
    
48.                 byte b = 2;
    
49.                 a = a + b;
    
50.                 运算时，b自动转换为int型  再与a相加
    
51. 
    
52.         2 强制类型转换
    
53.                 运算时，数据类型不一致，需要进行手动强制转换
    
54.                 int a = 3;
    
55.                 byte b = 2;
    
56.                 b = (byte)(a + b);
    
57.                 (a+b)运算时，自动转换为int型，要将结果赋给byte型，必须强制转换
    
58. 
    
59.         PS：1 非数值类型不能进行数学运算，如  
    
60.                         int a = 2; boolean n = true;
    
61.                         a = a + n;//错误
    
62.                 2 char类型数据可以直接与int类型相加，但char类型数据会自动提升为int型
    
63.                         byte a = 0;
    
64.                         char b = 'a';
    
65.                         byte result = a + b;// 错误: 不兼容的类型: 从int转换到byte可能会有损失
    
66.                         ____________________________________________________
    
67.                         int a = 97;
    
68.                         char b = 'a';
    
69.                         boolean res = (a==b);//true
    
70. 
    
71.         总结：表达式的数据类型的自动提升；
    
72. 
    
73.                 1 所有的byte short char型自动提升为int型
    
74.                 2 提升等级 double -> float -> int,表达式中如果存在等级高的类型，则结果为等级高的类型
    
75. 
    
76.                         int a = 2;
    
77.                         float f = 2.1f;
    
78.                         long l = 2L;
    
79.                         double d = 2.0;
    
80.                         l = l + f;//错误: 不兼容的类型: 从float转换到long可能会有损失
    
81.                         f = f + l;
    
82.                         d = d + l;
    
83.                         f = f + d;//错误
    
84. 
    
85.                 PS: 表达式中只有常量与常量的运算时不会自动提升
    
86.                         class Test
    
87.                         {
    
88.                                 public static void main(String[] args)
    
89.                                 {
    
90.                                         byte b = 3 + 7;
    
91.                                         byte a = 3 + 'a';
    
92.                                         System.out.println(b+"..."+a);
    
93.                                         byte b1 = 3;
    
94.                                         byte b2 = 7;
    
95.                                         byte b3 = b1 + b2;//错误
    
96.                                 }
    
97.                         }
    
98. 
    
99.                         输出结果：10...100
    
100. 
     
101.                         错误原因：涉及到编译器编译程序时候的细节，之所以byte b = 3 +7;，没有报错，是因为3和7都是
     
102.                                 常量，编译器知道结果是10，并且在byte范围之内，因此就自动进行了强转，所以不会报错。 而b = b1
     
103.                                 + b2;中b1和b2都是变量，编译器编译程序是一行一行编译的，它根本不知道b1和b2到底是多少，两个
     
104.                                 byte类型的数据相加时，首先都会被提升为int类型，他们的和也是int类型，其值可能会超过byte的范
     
105.                                 围，因此就会报错。
     
106. 
     
107. 5、b = a++;(假设数据都是整型)语句在计算机中的实际执行：
     
108. 
     
109.         说明：计算机中的实际操作为：当执行b = a++;语句时，先把a放在一个临时内存空间中，然后将a自
     
110. 加1，再将临时内存空间中的a赋值给b，因此b还是原来的a的值。
     
111.         代码表现：        int temp = a; //将a的值存至临时内存
     
112.                                 b = temp; //a的值赋给b
     
113.                                 a = a + 1; //变量a加1
     
114. 
     
115. 6、short s = 3; 则语句 s += 4;和语句 s = s + 4; 的区别：
     
116.        
     
117.         1 在执行s+=4;语句时，编译器在编译的时候，默认进行了强制类型转换，也就是将int类型的数
     
118. 据转换成short类型的数据。
     
119. 
     
120.         2 在执行s = s + 4;语句时，编译器在编译的时候，默认并没有强制类型转换。 所以，s是short类
     
121. 型，4是int类型，s会自动提升为int类型，相加的和也是int类型，赋值给short类型的变量肯定会损失精
     
122. 度。 这时候就需要进行强制类型转换：s = (short)(s + 4);。
     
123. */

复制代码

这是新学到的知识吗