Java基础-Java数据类型

　　　　　　　　　　　　　　　　　　　　Java基础-Java数据类型

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

 

 

一.数据类型的作用

　　数据类型就是一组值，以及这一组值上的操作，数据类型可以决定数据的存储方式，取值范围，允许的操作。

 

二.数据类型的分类

　　Java中的数据分为基本类型与引用类型两大类：

　　1>.变量名所标识的存储空间和存储的内容就是变量的值，这是基本类型。

　　2>.变量名所标识的存储空间中存储的内容是另外一块存储空间的起始地址（引用），这是引用数据类型。

　　java中的基本类型又分为：整数类型，小数类型，字符类型，布尔类型。Java中引用类型又分为：类，接口，数组等。

三.基本数据

1>.整数类型

数据类型

所占字节数

取值范围

byte

1

-128~127

short

2

-32768~32767

int

4

-2147483648~2147483647

long

8

-263~263-1

　　a>.对于一个字节来说，用二进制表示它的取值范围：

　　　　1000 0000 　　　　(-128)

　　　　 0111 1111　　　　 (127)

　　b>.对于四个字节int类型，用二进制表示取值范围

　　　　1000 0000 0000 0000 0000 0000 0000 0000　　　　（-2147483648）

　　　　 0111 1111 1111 1111 1111 1111 1111 1111　　　　　　（2147483647）

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 public class IntDemo{
 8     public static void main(String[] args){
 9         //1>.整数字面量默认为int类型，我们这里定义一个int类型的变量。
10         int a = 100;
11         
12         //2>.定义一个byte类型的变量。
13         byte  b = 20;
14         /**
15             给byte类型变量赋值时，如果这个整数字面量在byte类型的取值范围
16         之类可以赋值，如果给byte类型变量赋值的整数字面量超过了byte的取值
17         范围，则不可以赋值。
18         
19         */
20         // b = 200;    //"错误: 不兼容的类型: 从int转换到byte可能会有损失"。
21         
22         //3>.byte/short/char这三种数据类型在进行运算之前，会先把字节提升为int再运算
23         System.out.println(b);
24         
25         // b = b + 1;    //错误: 不兼容的类型: 从int转换到byte可能会有损失
26         /**
27             上面的“b = b + 1”想把b变量的值加上1之后，把和21再赋值给b变量。
28         在b变量加1之前，系统会自动把b提升为int类型再加1，b+1这个表达式为
29         int类型，不能直接赋值给byte类型变量。
30         */
31         
32         // b = a;        //错误: 不兼容的类型: 从int转换到byte可能会有损失
33         /**
34             编译器在进行语法检查时，不管a变量的值是多少，编译器也看不到变量
35         的值是多少，编译器只认识a是int类型的变量，不能直接赋值给byte类型变量。
36         */
37         
38         
39         b = 100 + 20;
40         System.out.println(b);
41         
42         //4>.short类型变量赋值也要在short的取值范围之内
43         short c = 456;
44         // c = c + 1;    //错误: 不兼容的类型: 从int转换到short可能会有损失.
45         c += 1;        //其实这里系统做了一个隐藏的操作：c = (short)c + 1;和上面的还是有一定区别的。
46         System.out.println(c);
47         
48         //5>.long类型变量
49         long d = 123;
50         /**
51             整数字面量123是int类型，变量d是long类型，在把整数字面量赋值给long类型时隐含着一个
52         自动类型装换，就是把int类型的字面量转换为long类型。建议在给long类型变量赋值时，在整数
53         字面量后面加上字符L(l)表示这个整数就是L类型。
54         */
55         
56         // d = 4147483647231;        //错误: 过大的整数: 4147483647231.原因是这个字面量已经超过了int类型能保存的最大数值。
57         d = 4147483647231L;            //省去了自动转换这一步。我们在后面加上L即可解决问题。
58         System.out.println(d);
59     
60         
61     }
62 }

2>.小数类型

数据类型

所占字节数

精度

Float

4

7

Double

8

15

 
 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 public class DecimalDome{
 8     public static void main(String[] args){
 9         //1>.小数字面量默认是double类型，定义一个double类型变量。
10         double a = 3.14;
11         
12         //2>.定义一个float类型变量，需要在小数后面加一个字符F（f）。
13         float b = 4.56F;
14         
15         //3>.float类型精度有7位
16         b = 456789.456789f;
17         System.out.println(b);
18         
19         //4>.小数在计算机中采用近似值保存，不准确。
20         b = 456789.987F;
21         System.out.println(b);
22         
23         System.out.println(2 - 1.1);
24         /**
25             一般情况下，小数不直接判断是否与另外一个小数相等，如果两个
26         小数相减，他们的差小于某个值是就认为这两个小数相等。
27         */
28     }
29 }

3>.字符类型

　　char，占2个字节，采用Unicode编码。

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 
 8 public class CharDemo{
 9     public static void main(String[] args){
10         //1>.定义一个字符类型的变量
11         char s1 = 'A';
12         
13         //2>.字符类型采用Unicode编码（utf-16格式），每个字符占两个字节，存储汉字
14         s1 = '尹';
15         System.out.println(s1);
16         
17         //3>.字符类型实际上存储的是这个字符对应的码值。
18         /*
19             s1 = 'A'
20             在s1变量中实际存储的是字符‘A’的码值是65
21             常见的码值有：
22                 a>.‘A’：    65
23                 b>.‘a’:    97
24                 c>.‘0’：    48
25                 d>.‘回车’ 13
26                 e>.‘换行’    10
27         
28         */
29         
30         //4>.因为字符存储的是码值，直接把一个整数赋值给字符类型变量。这个整数应该在0~65535之间，因为码值不存在负值。
31         s1 = 97;
32         System.out.println(s1);
33         
34         s1 = 'Y';
35         System.out.println(s1 + 1);
36         /**
37             上面一行是把 s1 + 1 这个表达式的值打印到屏幕上
38             先把s1变量的值89取出来，加上1的和90，打印到屏幕上
39         */
40         
41         //5>.char、byte、short在进行算术运算之前，先把自己提升为int类型。
42         // s1 = s1 + 1;     //错误: 不兼容的类型: 从int转换到char可能会有损失
43         
44         
45         /**
46             6>.转移字符：
47                 a>. \t            tab,跳到下一个制表位，不是产生8个空格。
48                 b>.    \n            换行
49                 c>.    \\            \
50                 d>.    \'            ’
51                 e>.    \"            "
52         */
53         System.out.println("abcdefg");
54         System.out.println("\"abcdefg\"");
55         //在Java中，遇到“\”就会默认为是转义字符的开始。
56         // System.out.println("abc\defg");        //这里的\d是：“错误: 非法转义符”
57         
58     }
59 }

4>.布尔类型

 　　boolean，占1个字节，只有true和flase两个值。

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 
 8 public class BoolDemo{
 9     public static void main(String[] args){
10         boolean flag = true;
11         
12         System.out.println(flag);
13         
14         //boolean类型只有true/false;
15         // flag = 0;        //错误: 不兼容的类型: int无法转换为boolean.
16         
17         System.out.println(flag);
18     }
19 }

 

四.基本类型转换

1>.基本数据类型转换

　　布尔类型不能和其它类型进行转换，整数，小数，字符类型可以相互转换。

2>.自动类型转换

3>.强制类型转换

　　不能进行自动类型转换时就可以进行强类型转换。格式：（目标类型）（表达式） 。

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 
 8 public class AutoDome{
 9     public static void main(String[] args){
10         //1>.自动类型转换
11         byte  bb = 10;
12         
13         short ss = bb;
14         
15         int   ii = ss;
16               ii = bb;
17         
18         long  gg = ii;
19               gg = ss;
20               gg = bb;
21         
22         float ff = gg;
23               ff = ii;
24               ff = ss;
25               ff = bb;
26             
27         double dd = ff;
28                dd = gg;
29               
30         //2>.自动类型转换也可能丢失精度
31         ii = 2147456321;
32         ff = ii;                    //int可以自动转换float类型。
33         System.out.println(ff);        //2.14745638E9
34         
35         
36         //3>.强制类型转换-小数转换为整数，舍弃小数部分
37         dd = 3.789123;
38         ii = (int)dd;                //把double类型强制转换为int类型。
39         System.out.println(ii);
40         
41         //4>.强制类型转换-大的整数类型转换为小的之整数类型
42         ii = 270;
43         bb = (byte)ii;
44         System.out.println(bb);
45         /**
46             ii变量在计算机中的存储形式：
47                 0000 0000 0000 0000 0000 0001 0000 1110
48             把ii强制转换为byte类型型，只把最后一个字节的数存储到bb变量中，bb变量中存储的内容为：
49                 0000 1110
50         */
51         
52         //5>.强制类型转换-整数可以转字符
53         ii = 110;
54         char cc = (char)ii;
55         System.out.println(cc);
56         
57         //6>.强制类型转换-可以对表达式进行强制类型转换
58         bb  = 123;
59         bb = (byte)(bb +1);
60         System.out.println(bb);
61         
62     }
63 }

 

五.基本数据类型与引用数据类型的区别

　　在Java中，基础数据类型的定义很简单，如：“int a = 18;”虽然就一行，其实是做了2步操作，第一，就是在内存中开辟了一块单独的内存空间，而这个变量对应的字面量就是这个内存空间所存储的值。也就是是说，当你修改“a”变量时，内存空间（或者说内存地址）并不发生改变，只是修改了内存变量所对应的字面量的值。

　　定义引用类型的变量也很简单，如：“String s = "hello world";”，从定义的格式上来看，跟基础数据类型定义方式如出一辙。但是在存储数据的时候却又很大的差异，引用数据类型定义之后，会在栈中存储一个内存地址，这个内存地址会对应到具体字面量的值。我们可以通过下面的图来记忆一下：

 

posted @ 2018-03-30 21:04  尹正杰  阅读(460)  评论(0)  编辑  收藏  举报