【原】Java学习笔记003

1 package cn.temptation;
2 
3 public class Sample01 {
4     public static void main(String[] args) {
5         System.out.println("第一个例子");
6     }
7 }
 1 package cn.temptation;
 2 
 3 public class Sample02 {
 4     public static void main(String[] args) {
 5         // Java的基本数据类型
 6         // 分为四大类,共八种数据类型
 7         /*                        占用字节数
 8          * 1、整数类型
 9          * byte:    字节类型            1            -128~127
10          * short:    短整型            2
11          * int:        整型                4
12          * long:    长整型            8
13          * 
14          * 2、浮点数类型
15          * float:    单精度类型        4
16          * double:    双精度类型        8
17          * 
18          * 3、字符类型
19          * char:    字符类型            2
20          * 
21          * 4、布尔类型
22          * boolean:    布尔类型            1
23          */
24         
25         // 变量:在程序执行过程中发生变化的量
26         
27         // 思考:为什么要使用变量?全部都使用常量行不行?
28 //        System.out.println(123);
29 //        System.out.println(123);
30 //        System.out.println(123);
31         
32         // 现在要进行修改,不要显示123了,要显示456,那么需要把前面使用常量123的地方全部改为常量456
33 //        System.out.println(456);
34 //        System.out.println(456);
35 //        System.out.println(456);
36         
37         // 注意:使用变量是一种思想:通过封装变化来达到拥抱变化的结果,即在变化时,只需要修改变量赋值的地方,不需要修改变量使用的地方
38         // int i = 123;
39         // 变化时,只要修改变量赋值的地方
40         // int i = 456;
41         
42         // 把变量使用的地方 和 变量赋值的地方 分离开
43 //        System.out.println(i);
44 //        System.out.println(i);
45 //        System.out.println(i);
46         
47         // 定义变量的格式:
48         // 数据类型        变量名        =       初始化的值;
49         
50         byte i = 3;
51         System.out.println(i);
52         
53         short j = 4;
54         System.out.println(j);
55         
56         int k = 123;
57         System.out.println(k);
58         
59         // Java中书写整型数字,不加说明,默认认为是int类型
60         // The literal 12345678901 of type int is out of range
61         // long m = 12345678901;
62         // 要使用long类型,需要在数字后添加大写的L 或是 小写的l(因为小写的l和数字1容易混淆,所以使用大写的L)
63         long m = 12345678901L;
64         System.out.println(m);
65         
66         // Java中书写浮点书数字,不加说明,默认认为是double类型
67         // Type mismatch: cannot convert from double to float
68         // float x = 123.456;
69         // 要使用float类型,需要在数字后添加大写的F 或是 小写的f(为了保持风格的一致,所以使用大写的F)
70         float x = 123.456F;
71         System.out.println(x);
72         
73         double y = 987.654;
74         System.out.println(y);
75         
76         // 字符类型使用单引号把字符包含其中
77         char z = 'a';
78         System.out.println(z);
79         
80         // 布尔类型有两个特殊值:true 和 false
81         boolean flag1 = true;
82         boolean flag2 = false;
83         System.out.println(flag1);
84         System.out.println(flag2);
85     }
86 }
 1 package cn.temptation;
 2 
 3 public class Sample03 {
 4 //    int i = 123;
 5     
 6     public static void main(String[] args) {
 7         // 使用变量的注意事项:
 8         /*
 9          * 1、作用范围(作用域):通过大括号来划定作用范围,变量不在该大括号内且没有其他的范围描述时,是无法使用的
10          * 2、在同一作用域下,变量不能重复命名
11          * 3、变量的初始化值:
12          *         变量没有初始化就直接使用会语法出错
13          *         要不在声明变量的时候就进行变量的初始化;要不就在使用的时候进行初始化
14          */
15 //        int i = 123;
16         // 在主函数之外定义int类型的变量i,在主函数中(大括号)中无法访问到
17         // Cannot make a static reference to the non-static field i
18 //        System.out.println(i);
19         
20 //        int i = 3;
21 //        System.out.println(i);
22         // Duplicate local variable i
23 //        int i = 4;
24 //        System.out.println(i);
25         
26         // 只对变量进行声明但是不赋值
27 //        int i;
28         // 对只声明但是不赋值的变量直接使用
29         // The local variable i may not have been initialized
30 //        System.out.println(i);
31         
32         // 先做声明
33 //        int i;
34         // 在使用前进行赋值
35 //        i = 5;
36         // 再使用变量,这样没有语法问题
37 //        System.out.println(i);
38         
39         // 声明变量时并对变量进行初始化赋值(初始化)
40 //        int i = 2;
41         
42         // 如下写法语法没有问题,但是不建议这样写(可读性差)
43 //        int i = 2; int j = 3;
44 //        System.out.println(i);
45 //        System.out.println(j);
46         
47         // 如下写法也可以,但是不推荐这样写
48 //        int i = 2, j = 3;
49 //        System.out.println(i);
50 //        System.out.println(j);
51         
52         // 在一行语句中对多个变量进行声明是可以的,并且多个变量之间使用英文的逗号分隔开
53         int i, j;
54         // 在一行语句中对于声明好的多个变量进行赋值,不能使用英文的逗号分隔开进行赋值,而只能使用英文的分号分隔开进行赋值
55         // Syntax error on token ",", ; expected
56 //        i = 2, j = 3;
57         i = 2; j = 3;
58         // 上句等价于
59         i = 2;
60         j = 3;
61         System.out.println(i);
62         System.out.println(j);
63     }
64 }
 1 package cn.temptation;
 2 
 3 public class Sample04 {
 4     public static void main(String[] args) {
 5         // 两个int类型的变量做加法
 6 //        int i = 2;
 7 //        int j = 3;
 8 //        int result = i + j;
 9 //        System.out.println(result);
10         
11         // byte类型的变量 和 int类型的变量做加法
12 //        byte i = 2;
13 //        int j = 3;
14 //        int result = i + j;
15 //        System.out.println(result);
16         
17         // int类型的变量 和 int类型的变量做加法,得到的结果赋值给一个byte类型的变量
18 //        int i = 2;
19 //        int j = 3;
20         // Type mismatch: cannot convert from int to byte
21         // 赋值号右侧两个int类型的变量相加,得到的结果还是一个int类型的结果,把这个int类型的结果赋值给byte类型的变量,提示类型不匹配
22 //        byte result = i + j;
23 //        System.out.println(result);
24         
25         // byte类型的变量 和 int类型的变量做加法,得到的结果赋值给一个byte类型的变量
26 //        byte i = 2;
27 //        int j = 3;
28         // Type mismatch: cannot convert from int to byte
29         // 赋值号右侧byte类型的变量  和  int类型的变量相加,得到的结果还是一个int类型的结果(类型提升),把这个int类型的结果赋值给byte类型的变量,提示类型不匹配
30 //        byte result = i + j;
31 //        System.out.println(result);
32         
33         // 解决类型不匹配错误的方法:
34         /*
35          * 1、将结果的数据类型改为范围大的数据类型
36          * 2、使用强制类型转换,注意可能会发生精度丢失的问题
37          *         联想一下:小碗盛米,大锅里的米比较少的时候,倒入小碗中是没有问题的;大锅里的米比较多的时候,倒入小碗里就有问题了
38          */
39         
40         // 强制类型转换的格式:(要转换为的数据类型)(被转换的数据内容);
41         int i = 2;
42         int j = 3;
43         byte result = (byte)(i + j);
44         System.out.println(result);
45     }
46 }
 1 package cn.temptation;
 2 
 3 public class Sample05 {
 4     public static void main(String[] args) {
 5         // 字面量常量整数不加说明,默认是int类型
 6 //        byte i = 127;
 7 //        System.out.println(i);
 8         
 9 //        byte i = (byte)127;
10 //        System.out.println(i);
11         
12         // Type mismatch: cannot convert from int to byte
13 //        byte j = 130;
14 //        System.out.println(j);
15         
16         byte j = (byte)130;
17         System.out.println(j);        // -126
18     }
19 }
20 /*
21  * 原码、反码 和 补码
22  * 规则:
23  * 1、正数的原码、反码和补码都相同
24  * 2、负数的反码和原码符号位相同,其他位取反;负数的补码  = 负数的反码 + 1;
25  * 3、计算机在进行运算时,使用的是补码,最终显示出来的是原码
26  * 
27  * int类型的正整数130的原码:0000 0000 0000 0000 0000 0000 1000 0010
28  * int类型的正整数130的反码:0000 0000 0000 0000 0000 0000 1000 0010
29  * int类型的正整数130的补码:0000 0000 0000 0000 0000 0000 1000 0010
30  * 
31  * 强制类型转换做了截取
32  * 
33  * byte类型的           补码:1000 0010        最高位是符号位
34  * byte类型的           反码:1000 0001    
35  * byte类型的           原码:1111 1110        -126
36  */
 1 package cn.temptation;
 2 
 3 public class Sample06 {
 4     public static void main(String[] args) {
 5         double i = 123.45;
 6         System.out.println(i);
 7         
 8         // 在单精度浮点数后添加F 和 对单精度浮点书进行强制类型转换为float类型,效果一致
 9 //        float j = 987.65F;
10         float j = (float) 987.65;
11         System.out.println(j);
12     }
13 }
 1 package cn.temptation;
 2 
 3 public class Sample07 {
 4     public static void main(String[] args) {
 5         // 定义两个byte类型的变量
 6 //        byte i = 2;
 7 //        byte j = 3;
 8         
 9         // Type mismatch: cannot convert from int to byte
10         // 使用加号进行加法计算时,对于比int类型范围小的数据类型进行了类型提升
11 //        byte result = i + j;
12 //        byte result = (byte) (i + j);
13 //        System.out.println(result);
14         
15         // 第11行使用byte类型的变量相加提示语法错误,第16行使用int类型的字面量常量相加没有语法错误
16         byte result = 2 + 3;
17         
18         // Type mismatch: cannot convert from int to byte
19 //        byte result = 2 + 126;
20         
21         System.out.println(result);
22         
23         // 注意:
24         // 变量相加,先看变量的数据类型是否有问题
25         // 常量相加,先看结果是否在被赋值的变量的数据类型范围内
26     }
27 }
 1 package cn.temptation;
 2 
 3 public class Sample08 {
 4     public static void main(String[] args) {
 5         // char字符类型 和 整型存在转换的关系
 6         System.out.println('a');            // a
 7         
 8         char i = 'b';
 9         System.out.println(i);                // b
10         
11         // 把字符'c' 和 int类型的数字1做加法,加出来的结果赋值给char类型的变量j
12         // 因为j的数据类型为char字符类型,所以输出的结果还是字符
13         char j = 'c' + 1;
14         System.out.println(j);                // d
15         
16         // 字符类型和int类型做加法,得到的结果是int类型
17         System.out.println('c' + 1);        // 100
18         
19         // 字符类型和int类型做加法,得到的结果是int类型
20         System.out.println('B' + 'e' + 'i' + 'J' + 'i' + 'n' + 'g' + 2008);        // 2672
21         
22         // 字符类型和字符类型做加法,得到的结果是int类型
23         System.out.println('B' + 'e' + 'i' + 'J' + 'i' + 'n' + 'g');            // 664
24         
25         // 布尔类型不参与加法运算
26         // The operator + is undefined for the argument type(s) boolean, int
27 //        System.out.println(true + 1);
28         
29 //        boolean flag = false;
30         // The operator + is undefined for the argument type(s) boolean, int
31 //        System.out.println(flag + 1);
32     }
33 }
原文地址:https://www.cnblogs.com/iflytek/p/6443130.html