Java开发面试必问项!标识符、字面值、变量、数据类型,该学了

开发 后端
从目前流行的开发技术、常见的面试问题以及问题的答案都已经写的特别清楚了,今天我给写一篇初级Java开发面试必问项!供大家阅读参考。

最近事情太多,没太时间写博客。今天抽空再整理整理面试中的那点事吧,帮助那些正在找工作或想跳槽找工作的学弟学妹们。

从目前流行的开发技术、常见的面试问题以及问题的答案都已经写的特别清楚了,今天我给写一篇初级Java开发面试必问项!供大家阅读参考。

[[414621]]

标识符

关于java语言当中的标识符

1、什么是标识符

  • 在java源程序当中凡是程序员有权利自己命名的单词都是标识符
  • 标识符在EditPlus编辑器当中以黑色字体高亮显示
  • 标识符可以标识什么元素呢?
  • 类名 * 方法名 * 变量名 * 常量名 等等...

2、标识符的命名规则【不按照这个规则来,编译器会报错,这是语法】

  • 一个合法的标识符只能由“数字、字母、下划线_、美元符号$”组成,不能含有其他符号
  • 不能数字开头
  • 严格区分大小写
  • 关键字不能做标识符
  • 理论上无长度限制,但是最好不要太长

3、表示符的命名规则【只是一种规范,不属于语法,不遵守规范编译器不会报错】

  1. //最好见名知意 
  2.             public class UserService{ 
  3.                 public void login(String username,String password){ 
  4.                 } 
  5.             } 
  6. //遵守驼峰命名方式 
  7.  
  8.             SystemService  UserService  CustomerService 
  • 类名、接口名:首字母大写,后面每个单词首字母大写
  • 变量名、方法名:首字母大写,后面每个单词首字母大写
  • 长量名:全部大写

4、合法和不合法的标识符

  1. */ 
  2. public class IdentifierTest01  
  3. //IdentifierTest01是一个类名,名字可以修改   
  4.     //main是一个方法名 
  5.     public static void main(String[] agrs){  
  6.     //args是一个变量名 
  7.     } 
  8.  
  9.     //doSome就是方法名 
  10.     public static void doSome(){ 
  11.         //i就是变量名 
  12.         int i = 10; 
  13.     } 

字面值

关于字面值:

  • 字面值:
  • 10、100、3.14、"abc"、'a'、true、false
  • 字面值就是数据
  • 字面值是java源程序的组成部分之一,包括标识符和关键字他们都是java源程序的组成部分。
  • 数据在现实世界当中是分门别类的,所以数据在计算机编程语言当中也是有类型的:【数据类型】

注意:

  • java语言当中所有的字符串字面值必须使用双引号括起来,双引号是半角
  • java语言当中所有的字符型字面值必须使用单引号括起来,单引号是半角
  1. */ 
  2. public class ConstTest01 
  3.     public static void main(String[] args){ 
  4.         System.out.println("abc"); 
  5.         System.out.println("你最近过得好吗?"); 
  6.         System.out.println(10); 
  7.         System.out.println(false); 
  8.         System.out.println(true); 
  9.         System.out.println('A'); 
  10.         System.out.println(3.14); 
  11.         // 编译报错,因为单引号中只能存放单个字符,属于字符型字面值 
  12.         // System.out.println('ABC'); 
  13.         //Java开发交流君样:593142328 
  14.         // 100是一个字面值,是一个整数型数值,那么既然是数据存储在内存当中,必定会占用一定的内存空间。 
  15.         System.out.println(100); 
  16.     } 

变量

一、关于java语言当中的变量:

1、什么是变量?

  • 变量本质上来说是内存中的一块空间,这块空间有:数据类型,有名字、有字面值。
  • 变量包含三部分:数据类型、名称、字面值【数据】
  • 变量是内存中存储数据的最基本的单元。

2、数据类型的作用?

  • 不同的数据有不同的类型,不同的数据类型底层会分配不同大小的空间。
  • 数据类型是指导程序在运行阶段应该分配多大的内存空间。

3、变量要求:变量中存储的具体的“数据”必须和变量的“数据类型”一致,当不一致的时候编译报错。

4、声明/定义变量的语法格式:

  • 数据类型 变量名;
  • 数据类型:目前我们还没有学习数据类型,但是有一种数据类型是整数型,叫做int
  • 变量名:只要是合法的标识符就行,规范中要求:首字母小写,后面每个单词首字母大写
  • 例如: int i: 、int age; 、int length; 、int size;、 int num;其中int是数据类型,i,age,length,size,num 都是变量名。

5、变量声明之后怎么赋值?

- 语法格式:变量名 = 字面值;

- 要求:字面值的数据类型必须和变量的数据类型一致。

= 等号是一个运算符,叫做赋值运算符,赋值运算等号右边的表示,表示式执行结束之后的结果赋值给左边的变量。

6、声明和赋值可以放到一起完成。

  1. int i = 10; 

7、变量赋值之后,可以重新赋值,变量的值可变化:

  1. int i = 10; System.out.println(i); //10 
  2.           int i = 20; System.out.println(i); //20 
  3.           int i = 100; System.out.println(i); //100 

8、有了变量的概念之后,内存空间得到了重复的使用;

  1. int i = 10;  System.out.println(i); ...  System.out.println(i); 

9、通常访问一个变量包括两种访问形式:

  • 第一种:读取变量中保存的具体数据 get/获取
  • 第二种:修改变量中保存的具体数据 set/设置
  1. i = 20: //set 
  2.               System.out.println(i); //get 

10、变量在一行上可以声明多个

  1. int a,b,c; 

11、变量必须先声明,再赋值,才能访问。

  • int i; 程序执行到这里,内存空间并没有开辟出来,变量i并没有初始化。所以没有赋值之前是无法访问的。
  1. public class VarTest01 
  2.     public static void main(String[] args){ 
  3.      
  4.         //声明一个int类型的变量,起名i 
  5.         int i; 
  6.         // 编译报错,变量i并没有初始化 
  7.         // System.out.println(i); 
  8.          
  9.  
  10.         // 给i变量赋值,i 变量在这里完成初始化,内存开辟 
  11.         i = 100; 
  12.         System.out.println(i); 
  13.  
  14.         // i 再次重新赋值 
  15.         i = 200; 
  16.         System.out.println(i); 
  17.  
  18.         // 一行上可以同时声明多个变量 
  19.         // a和b尚未初始化,c赋值300 
  20.         // int a,b,c = 300; 
  21.     } 

二、关于java语言当中的变量:使用所有的基础语法开发系统业务

1、在方法体当中的java代码,是遵守自上而下的顺序依次执行的,逐行执行。

  • 第一行;第二行;第三行;

特点:第二行的代码必须完整的结束之后,第三行程序才能执行。

2、在同一个“作用域”当中,变量名不能重名,但是变量可以重新赋值。

  1. public class VarTest02 
  2.     public static void main(String[] args) 
  3.         int i = 100; 
  4.         System.out.println(i); //100 
  5.  
  6.         i = 200; 
  7.         System.out.println(i); //200 
  8.  
  9.         // 以下代码顺序有错误,先声明然后复制再访问 
  10.         /* 
  11.         System.out.println(k); 
  12.         int k = 100; 
  13.         */ 
  14.         /* 
  15.         int i = 90; 
  16.         System.out.println(i); 
  17.         */ 

三、关于java中的变量;

  1. 变量的作用域 

1、什么是作用域?

  1. - 变量的作用域,其实描述的就是变量的有效范围。 
  2.          在什么范围之内是可以被访问的,只要出了这个范围该变量就无法访问了。 

2、变量的作用域只要记住一句话:

  1. 出了大括号就不认识了。 
  1. public class VarTest03 
  2.     //注意: 这里在static不要去掉 
  3.     static int k = 90; 
  4.  
  5.     public static void main(String[] args) 
  6.         // 变量i的作用域是main方法 
  7.         // 在整个main方法当中是有效的,可见的,可以访问的 
  8.         int i = 100; 
  9.         System.out.println(i): // 可以 
  10.         System.out.println(k): // 可以 
  11.  
  12.         // 以下会编写一个for循环语句 
  13.         // 这个for循环后面的控制语句的时候详细讲解 
  14.         for(int a=0;a<10;a++){ //a变量的作用域是整个for循环,for循环结束之后,a变量的内存就释放了 
  15.         } 
  16.         // 这里无法访问a变量 
  17.         // System.out.println(a): 
  18.  
  19.         int j; // 作用域是main方法 
  20.         for (int j=0;j<10;j++){ 
  21.         } 
  22.         System.out.println(j): // 访问的是main方法中的j变量 
  23.          
  24.     } 
  25.     public static void doSome(String[] args) 
  26.         // 这里无法访问main方法当中的变量i 
  27.         // 已经出了i变量的作用域。 
  28.         // System.out.println(i): 
  29.  
  30.  
  31.         // 可以 
  32.         System.out.println(k): 
  33.     } 

四、关于变量的分类:

根据变量声明的位置分类;

  • 局部变量
  • 在方法体当中声明的变量叫做局部变量
  • 成员变量
  • 在方法体外【类体之内】声明的变量叫做成员变量
  • 在不同的作用域当中,变量名是可以相同的。
  • 在同一个作用域当中,变量名不能重名。
  1. public class VarTest04 
  2. {     
  3.     // 成员变量 
  4.     int k = 200; 
  5.  
  6.     // 主方法:入口 
  7.     public static void main(String[] args){ 
  8.         // i变量就是局部变量 
  9.         int i = 10; 
  10.          
  11.         // java遵循“就近原则” 
  12.         System.out.println(i); 
  13.     } 
  14.  
  15.     // 成员变量 
  16.     int i = 100; // 什么变量 
  17.     // 类体中不能直接编写java语句【除声明变量之外】 
  18.     // System.out.println(i): 
  19.  
  20.     // doSome方法 
  21.     public static void doSome(){ 
  22.         // 局部变量 
  23.         int i = 90; 
  24.  
  25.          
  26.     } 

数据类型

一、关于java中的数据类型:

1、数据类型的作用是什么?

  • 程序当中有很多数据,每一个数据都是有相关类型的,不同的数据类型的数据占用空间大小不同。
  • 数据类型的作用是指导JVM在运行程序的时候给该数据分配多大的内存空间。

2、java中的数据类型包括两种:

  • 基本数据类型
  • 引用数据类型【后边解释】
  • 类、接口、数据、等等...

3、关于基本数据类型:

  • 基本数据类型包括四大类八小种:

第一类:整数型

  • byte、short、int、long

第二类:浮点型

  • float、double

第三类:布尔型

  • boolean

第四类:字符型

  • char

4、字符串“abc”不属于基本数据类型,属于"引用数据类型",字符属于基本数据类型:

  • 字符串使用双引号 "abc"
  • 字符使用单引号 'a'

5、八种基本数据类型各自占用空间大小是多少?

6、计算机在任何情况下都只能识别二进制。例如:只认识101000101...

现代的计算机底层采用交流电的方式,接通和断开就两种状态,计算机只识别1或0,其他不认识】

7、什么是二进制?

数据的一种表示形式,十进制表示满十进一原则。二进制表示满二进一原则。

  1. /  例如:十进制 
  2.                   0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20  
  3.           /  例如:二进制 
  4.                   0 1 10 11 100 101 110 111 1000 1001 ... 
  5.                   0 1 2  3  4    5  6   7    8     9 

8、字节(byte)

  1. 1 byte = 8 bit 【1个字节 = 8个比特位】1比特位表示一个二进制位: 1/0 
  2.            1 KB = 1024 Byte、1 MB = 1024 KB、1 GB = 1024 MB、1 TB = 1024 GB 
  3.            1 TB = 1024 * 1024 * 1024 * 1024 * 8 
  4.             

9、整数型当中的byte类型,占用1个字节,所以byte类型的数据占用9个比特位,那么byte类型的取值范围是什么?

  • 关于java中的数字类型,数字都是有正负之分的,所以在数字的二进制当中有一个二进制位被称为”符号位“。并且这个”符号位“在所有二进制的最左边,0表示正数,1表示负数。
  • byte类型最大值:01111111 【0000010000000(二进制) - 1】
  • byte类型最大值:2的7次方-1,结果是:127
  • byte类型最小值: -128 【具体的怎么用二进制表示,这个和源码、反码、补码有关】
  • byte类型取值范围:【-128~127】
  • bytp类型可以标识256个不同的数字【256个不同的二进制】

10、二进制和十进制之间的转换规则:

  • 二进制转换成十进制
  • 十进制转换成二进制

11、计算机只认识二进制,那么计算机是怎么表示现实世界当中的文字的呢?

  • 八种基本数据类型当中,byte、short、int、long、float、double、boolean这7种数据类型计算机在表示的时候比较容易,因为底层都是数字,十进制的数字和二进制之间存在一种固定的转换规则。
  • 但是八种基本数据类型当中char类型表示的是现实世界中的文字,文字和计算机二进制之间”默认“情况下是不存在任何转换关系的。
  • 为了让计算机可以表示现实世界当中的文字,我们需要进行人为的干涉,需要人负责提前制定好”文字“和”二进制“之间的对照关系。这种对照转换关系被称为:字符编码。
  • 计算机最初只支持英文,最先出现的字符编码是:ASCII码
  1. 'a' -> 97 【01100001】 
  2.                'A' -> 65 
  3.                '0' -> 48 
  4.  
  5.                'a' -- (按照ASCII解码) --> 01100001 
  6.                01100001 -- 按照ASCII编码 --> 'a' 

编码和解码的时候采用同一套字典/对照表,不会出现乱码。

当解码和编码的时候采用的不是同一套对照表,会出现乱码问题,

  • 跟着计算机的发展,后来出现了一种编码方式,是国际标组织ISO制定,这种编码方式支持西欧语言,向上兼容ASCII码仍然不支持中文,这种编码方式是:ISO-8859-1,又被称为latin-1
  • 跟着计算机向亚洲发展,计算机开始支持中文、日文、韩文等国家文字,其中支持简体中文的编码方式:GB2312 < GBK < GB18030
  • 支持繁体中文:大五码
  • 后来出现了一种编码方式统一了全球所有的文字,容量较大,这种编码方式叫做:unicode编码
  • unicode编码方式有很多种具体的实现:
  • UTF-8、UTF-16、UTF-32....
  • java语言采用的是哪一种编码方式呢?
  • java语言源代码采用的是unicode编码方式,所以标识符可以写中文。
  • 现在在实际开发中,一般使用UTF-8编码方式较多。【统一编码方式】

12、八种基本数据类型的取值范围:

注意:short和char所表示的种类总数是一样的,只不过char可以标识更大的正整数。

因为char没有负数。

13、以下java程序主要讲解的是数据类型之,char类型

  1. public class DataTypeTest01 
  2.     public static void main(String[] args){ 
  3.         // 定义一个char类型的变量,起名c,同时赋值字符'a' 
  4.         char c = 'a'
  5.         System.out.print(c); 
  6.  
  7.         // 一个中文占用2个字节,char类型正好是2个字节 
  8.         // 所以java中的char类型变量可以存储一个中文字符 
  9.         char x = '国'; 
  10.         System.out.print(x); 
  11.          
  12.         // 编译错误 
  13.         // ab是字符串不能使用单引号括起来 
  14.         // char y = 'ab'
  15.  
  16.         // "a"是字符串类型 
  17.         // k变量是char类型 
  18.         // 类型不兼容,编译错误 
  19.         char k = "a"
  20.          
  21.         // 声明 
  22.         char e; 
  23.  
  24.         // 赋值 
  25.         e = "e"
  26.  
  27.         // 再次赋值 
  28.         System.out.print(e); 
  29.     } 

二、关于八种数据类型的默认值

八种基本数据类型的默认值是一切向0看齐。

  1. public class DataTypeTest02 
  2.         // 这里的static必须加,别问。 
  3.         static int k = 1000; 
  4.          
  5.         // 变量还是遵守这个语法:必须先声明,在赋值,才能访问。 
  6.         // 成员变量没有手动赋值系统会默认赋值【局部变量不会】 
  7.         static int f; //成员变量 
  8.  
  9.         public static void main(String[] args){ 
  10.             /* 
  11.                 int i; //局部变量 
  12.                 System.out.print(i); 
  13.             */ 
  14.             System.out.print(k); 
  15.  
  16.             System.out.print(f); 
  17.         } 

三、关于java语言中的char类型:

转义字符

转义字符出现在特殊字符之前,会将特殊字符转换成普通字符。

  • \n 换行符
  • \t 制表符
  • ' 普通的单引号
  • \ 普通的反斜杠
  • " 普通的双引号
  1. public class DataTypeTest03 
  2.     public static void main(String[] args){ 
  3.  
  4.         // 普通的n字符 
  5.         char c1 = 'n'
  6.         System.out.print(c1); 
  7.          
  8.         // 依照目前所学知识,一下程序无法编译通过,因为显示是一个字符串,不能使用单引号括起来 
  9.         // 但是经过编译,发现编译通过了,这说明以下并不是一个字符串,而是“一个”字符 
  10.         // 这是一个“换行符”,属于char类型的数据 
  11.         // 反斜杠在java语言当中具有转义功能。 
  12.         char c2 = '\n'
  13.  
  14.         /* 
  15.         System.out.print("Hello"); 
  16.         System.out.print("World!"); 
  17.         */ 
  18.          
  19.         // System.out.println()和System.out.print()区别: 
  20.         // println输出之后换行,print表示输出,但是不换行 
  21.         /* 
  22.         System.out.print("Hello"); 
  23.         System.out.println("World!"); 
  24.         */ 
  25.  
  26.         System.out.print("A"); 
  27.         // System.out.print(c2); 
  28.         System.out.println("B"); 
  29.  
  30.         // 普通的t字符 
  31.         char x = 't'
  32.         System.out.print("t"); 
  33.  
  34.         // 制表符tab 
  35.         // 强调:制表符和空格不一样,他们的ASCII不一样,体现在键盘上两个不同的“按键” 
  36.         char y = '\t'
  37.         System.out.println("A"); 
  38.         System.out.print(y); 
  39.         System.out.println("B"); 
  40.  
  41.         // 要求在控制台上输出“反斜杠字符” 
  42.         /* 
  43.         // 反斜杠蒋后面的单引号转义成不具备特殊含义的普通单引号字符,左边的单引号缺少了结束的单引号字符,编译报错 
  44.         char k = '\'
  45.         System.out.println(k); 
  46.         */ 
  47.         /* 
  48.           // 解释:第一个反斜杠具有转义功能,将后面的反斜杠转义为普通的反斜杠字符。 
  49.           结论:在java当中两个反斜杠代表一个普通的反斜杠字符 
  50.         */ 
  51.         char k = '\\'
  52.         System.out.println(k); 
  53.  
  54.         // 在控制台上输出一个普通的单引号字符 
  55.         // java中不允许这样编写程序,编译报错 
  56.         // char a = '';  
  57.  
  58.         // 以下编译报错:第一个单引号和第二个单引号配对儿,最后的单引号找不到另一半! 
  59.         // char a = '''; 
  60.         // System.out.println(a); 
  61.          
  62.         // 反斜杠具有转义功能,将第二个单引号转换成普通的单引号字符,第一个单引号和最后单引号配对。 
  63.         char a = '\''
  64.         System.out.println(a); 
  65.  
  66.         char f = '"'
  67.         System.out.println(f); 
  68.  
  69.         // 编译错误 
  70.         // System.out.println(""HelloWorld!""); 
  71.  
  72.         // 纠正 
  73.         System.out.println("\"HelloWorld!\""); 
  74.  
  75.         char m = '中'
  76.         System.out.println(m); 
  77.  
  78.         // JDK中自带的native2ascii.exe命令,可以将文字转换成unicode编码形式 
  79.         // 怎么使用这个命令: 
  80.         // 在命令行输出native2ascii,回车,然后输入文字之后回车即可得到unicode编码 
  81.         char n = "\u4e2d"; // '中'对应的unicode编码是 4e2d 
  82.         System.out.println(n); 
  83. //vx小助手:xiehuangbao1123 领取资料面试真题 
  84.         // 编译错误 
  85.         // char g = '4e2d'
  86.  
  87.         // 编译错误 
  88.         // char g = 'u4e2d'
  89.  
  90.         // 通过:反斜杠u联合起来后面的一串数字是某个文字的unicode编码 
  91.         char g = '\u4e2d'
  92.         System.out.println(g); 
  93.          
  94.         // char类型的默认值 
  95.         char c = '\u0000'; 
  96.         System.out.println(c); 
  97.  
  98.  
  99.  
  100.     } 

四、关于java语言当中的整数型:

数据类型 占用空间大小 默认值 取值范围

  1. 数据类型            占用空间大小        默认值            取值范围 
  2.        ---------------------------------------------------------------- 
  3.        byte                1                    0                [-128 ~ 127] 
  4.        short                2                    0                [-32768 ~ 32767] 
  5.        int                    4                    0                [-2147483648 ~ 2147483647] 
  6.        long                8                    0L 

1、java语言当中的“整数型字面值”被默认当做int类型来处理,要让这个“整数型字面值”被当做long类型来处理的话,需要在“整数型字面值”后面添加1/L,建议使用大写的L

2、java语言当中的整数型字面值有三种表示方式:

  • 第一种方式:十进制【是一种缺省的默认的方式】
  • 第二种方式:八进制【在编写八进制整数型字面值的时候需要以0开始】
  • 第三中方式:十六进制【在编写十六进制整数型字面值的时候需要以0x开始】
  1. public class DataTypeTest04 
  2.     public static void main(String[] args){ 
  3.         int a = 10;      // 缺省 
  4.         int b = 010;  // 整数型字面值以开头的,后面那一串数字就是八进制形式 
  5.         int c = 0x10; // 整数型字面值以0x开头的,后面一串数字就是十六进制形成 
  6.  
  7.         System.out.println(a); // 10 
  8.         System.out.println(b); // 8 
  9.         System.out.println(c); // 16 
  10.  
  11.         System.out.println(a + b + c); //34 
  12.  
  13.         // 123这个整数型字面值int类型 
  14.         // i 变量声明的时候也是int类型 
  15.         // int类型的123赋值给int类型的变量i,不存在类型转换 
  16.         int i = 123; 
  17.         System.out.println(i); 
  18.  
  19.         // 456整数型字面值被当做int类型,占用4个字节 
  20.         // x变量在声明的时候是long类型,占用8个字节 
  21.         // int类型的字面值456赋值给long类型的变量x,存在类型转换 
  22.         // int类型转换成long类型 
  23.         // long类型是大容量 
  24.         // 小容量可以自动转换成大容量,称为自动类型转换机制。 
  25.         long x =456; 
  26.         System.out.println(x); 
  27.         //vx小助手:xiehuangbao1123 领取资料面试真题 
  28.         // 2147483647字面值是int类型,占用4个字节 
  29.         // y是long类型,占用8个字节,自动类型转换 
  30.         long y = 2147483647; 
  31.         System.out.println(y); 
  32.  
  33.         // 编译错误:过大的整数,2147483648 
  34.         // 2147483648 被当做int类型4个字节处理,但是这个字面值超出int类型范围 
  35.         // long z = 2147483648; 
  36.  
  37.         // 解决错误 
  38.         // 2147483648字面值一上来就当做long类型来处理,在字面值后面添加L 
  39.         // 2147483648L是8个字节的long类型 
  40.         // z是long类型变量,以下程序不存在类型转换 
  41.         long z = 2147483648L; 
  42.         System.out.println(z); 
  43.      
  44.     } 

五、关于java中的整数型

  • byte
  • short
  • int
  • long
  1. public class DataTypeTest05 
  2.     public static void main(String[] args){ 
  3.          
  4.         // l00L是long类型字面值 
  5.         // x是long类型变量 
  6.         // 不存在类型转换,直接赋值 
  7.         long x = 100L; 
  8.  
  9.         // x变量是long类型,8个字节 
  10.         // y变量是int类型,4个字节 
  11.         // 以下程序可以编译通过吗? 
  12.         // 编译报错,大容量不能直接赋值给小容量 
  13.         // int y = x; 
  14.  
  15.         // 大容量转换成小容量,需要进行强制类型转换 
  16.         // 强制类型转换需要加“强制类型转换符” 
  17.         // 加上强制类型转换符之后编译通过了,但是运行阶段可能损失精度。 
  18.         // 所以强制类型转换谨慎使用,因为损失精度之后可能损失很严重。 
  19.         // 强转原理: 
  20.            // 原始数据:00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100 
  21.            // 强转之后的数据;00000000 00000000 00000000 01100100 
  22.            // 将左边的二进制砍掉【所有的数据强转的时候都是这样完成的】 
  23.         int y = (int)x; 
  24.         System.out.println(y); 
  25.          
  26.         // 原始数据:00000000 00000000 00000000 00000000 10000000 00000000 00000000 00000000 
  27.         // 强转之后的数据;10000000 00000000 00000000 00000000 
  28.         // 10000000 00000000 00000000 00000000 目前存储在计算机内部,计算机存储数据都是采用补码的形式存储 
  29.         // 所以 10000000 00000000 00000000 00000000 现在是一个补码形式 
  30.         // 将以上的补码转换到原码就是最终的结果 
  31.         long k = 2147483648L; 
  32.         int e = (int)k; 
  33.         System.out.println(e); // 损失精度严重,结果是负数 【-2147483648】 
  34.  
  35.         // 分析以下程序是否可以编译通过? 
  36.         // 依据目前所学内容,以下程序是无法编译通过的 
  37.         // 理由:50是int类型的字面值,b是byte类型的变量,显然是大容量int转换成小容量byte 
  38.         // 大容量转换成小容量是需要添加强制类型转换符的,以下程序没有添加强转符号,所以编译报错。 
  39.         // 但是,在实际编译的时候,一下代码编译通过,这说明:在java语言中,当一个整数型字面值 
  40.         // 没有超过byte类型取值范围的话,该字面值可以直接赋值给byte类型的变量。 
  41.         byte b = 50; // 可以 
  42.  
  43.         byte c = 127;  // 可以 
  44.  
  45.         // 编译报错,128这个int类型的字面值已经超出了byte类型的取值范围,不能直接赋值给byte类型的变量 
  46.         // byte b1 = 128;   
  47.  
  48.         // 纠正错误,需要使用强制类型转换符 
  49.         // 但是一定会损失精度 
  50.         // 原始数据:10000000 00000000 00000000 00000000 
  51.         // 强转之后:10000000 【这是存储在计算机内部的,这是一个补码,它的原码是什么?】 
  52.         byte b1 = (byte)128; // -128 
  53.         System.out.println(b1); 
  54.  
  55.         /* 
  56.             计算机二进制有三种表示形式: 
  57.                 原码、反码、补码 
  58.             计算机在任何情况下底层表示和存储数据的时候采用了补码形式。 
  59.             整数的补码:和原码相同 
  60.             负数的补码:负数的绝对值对应的二进制码所有二进制拉取反,再加1 
  61. //vx小助手:xiehuangbao1123 领取资料面试真题 
  62.             补码:10000000 
  63.             原码计算机过程: 
  64.                 - 10000000 - 1 --> 01111111 
  65.                 - 10000000 --> 128 
  66.                 - -128 
  67.         */ 
  68.         // 原始数据:00000000 00000000 00000000 11000110 
  69.         // 强制类型转换之后:11000110 
  70.         // 11000110 - 1 --> 11000101 
  71.         // 00111010 【2 + 8 + 16 + 32】 --> 58 
  72.         // 58 
  73.         byte m = (byte)198; 
  74.         System.out.println(m);  // -58 
  75.  
  76.         short s = 32767;  // 通过 
  77.         // short s = 32768;  // 编译报错 
  78.  
  79.         // 65535是int类型,4个字节 
  80.         // cc是char类型,2个字节 
  81.         // 按照以前所学知识点来说,以下程序是编译报错的。 
  82.         // char cc = 65535;  // 通过 
  83.         // cc = 65536; //编译报错 
  84.  
  85.         /* 
  86.             当一个整数字面值没有超出byte,short,char的取值范围,这个字面值 
  87.             可以直接赋值给byte,short,char类型的变量,这种机制SUN允许了,目的是为了方便程序员的编程。 
  88.         */ 
  89.     } 

六、关于浮点型数据类型:

float单精度【4个字节】

double 双精度【8个字节,精度较高】

double的精度太低【相对来说的】,不适合做财务软件。

财务涉及到钱的问题,要求精度较高,所以SUN在基础SE类库当中

为程序员准备了精确度更高的类型,只不过这种类型是一种引用数据类型,不属于基本数据类型,它是:

java.math.BigDecimal

其实java程序中SUN提供了一套庞大的类库,java程序员是基于这套基础的类库来进行开发的,所以要知道java的SE类库的字节码在哪里,要知道java的SE类库的源码在哪里。

  • SE类库字节码:\Java\jdk1.8.0_101\jre\lib\rt.jar
  • SE类库源码: D:\Java\jdk1.8.0_101\src.zip
  • 例如;String.java和String.class
  • 我们的(String[] args)中的String使用的就是String.class字节码文件

在java语言当中,所有的浮点型字面值【3.0】,默认被当做double类型来处理

要想改字面值当做float类型来处理,需要在字面值后面添加F/f

注意:

double和float在计算机内部二进制存储的时候存储的都是近似值。

在现实世界当中有一些数字是无限循环的,例如:3.3333333333333......

计算机的资源是有限的,用有限的资源存储无限的数据只能存储近似值

  1. public class DataTypeTest06 
  2.     public static void main(String[] args){ 
  3.         // 3.0是double类型的字面值 
  4.         // d是double类型的变量 
  5.         // 不存在类型转换 
  6.         double d = 3.0; 
  7.         System.out.println(d); 
  8.         //vx小助手:xiehuangbao1123 领取资料面试真题 
  9.         // 5.1是double类型的字面值 
  10.         // f是float类型的变量 
  11.         // 大容量转换成小容量需要加强制类型转换符,所以以下程序编译错误。 
  12.         // float f = 5.1; 
  13.  
  14.         // 解决方案: 
  15.         // 第一种方式:强制类型转换 
  16.         // float f = (float)5.1; 
  17.  
  18.         // 第二种方式:没有类型转换 
  19.         float f = 5.1f; 
  20.     } 

七、关于布尔型数据类型

boolean

在java语言当boolea类型只有两个值:turefals,没有其他值。

不像C语言当中,0和1可以表示假和真。

在底层存储的时候boolean类型占用1个字节,因为实际存储的时候false底层是0,true底层是1.

布尔类型在实际开发当中非常重要,经常使用在逻辑运算和条件控制语句当中。

  1. public class DataTypeTest07 
  2.     public static void main(String[] args){ 
  3.         // 编译错误:不兼容的类型 
  4.         // boolean flag = 1; 
  5.  
  6.         //boolean loginSuccess = true;  
  7.         boolean loginSuccess = false;//vx小助手:xiehuangbao1123 领取资料面试真题 
  8.  
  9.         // if语句以后在解释【条件控制语句】 
  10.         if(loginSuccess){ 
  11.             System.out.println("恭喜你,登录成功"); 
  12.         }else
  13.             System.out.println("对不起,用户名不存在或者密码错误!"); 
  14.             } 
  15.     } 

八、关于基本数据类型之间的互相转换:转换规则

1.八种基本数据类型当中出布尔类型之外剩下的7种类型之间都可以互相转换【白嫖资料】

2.小容量向大容量转换,称为自动类型转换,容量从小到大排序:

byte < short < int < long < float < double char <

注:任何浮点类型不管占用多少个字节,都比整数型容量大。char和short可表示的种类数量相同,但是char可以取更大的正整数

3.大容量转换成小容量,叫做强制类型转换,需要加强制类型转换符,程序才能编译通过,但是在运行阶段可能会损失精度,所以谨慎使用。

4.当整数字面值没有超出byte,short,char的取值范围,可以直接赋值给byte,short,char类型的变量

5.byte,short,char混合运算的时候,各自先转换成int类型在做运算。

6.多种数据类型混合运算,先转换成容量最大的那种类型再做运算。

注意:

byte b = 3; 可以编译通过,3没有超出byte类型取值范围

int i = 10;

byte b = i / 3; 编译报错,编译器只检查语法,不会“运算” i / 3

  1. public class DataTypeTest08 
  2.     public static void main(String[] args){ 
  3.  
  4.         // 出现错误,1000超出了byte的范围 
  5.         // byte a = 1000; 
  6.  
  7.         // 正确,因为20没有超出byte范围 
  8.         byte a = 20; 
  9.  
  10.         // 变量不能重名 
  11.         // short a = 1000; 
  12.  
  13.         // 正确,因为数值1000没有超出short类型的范围 
  14.         // 所以赋值正确 
  15.         short b = 1000; 
  16.  
  17.         // 正确,因为默认就是int,并没有超出int范围 
  18.         int c = 1000; 
  19.  
  20.         // 正确,可以自动转换 
  21.         long d = c; 
  22.  
  23.         // 错误,出现精度丢失问题,大类型-->>小类型会出现问题 
  24.         // int e = d; 
  25.  
  26.         // 将long强制转换成int类型 
  27.         // 因为值1000,没有超出int范围,所以转换是正确的 
  28.         int e = (int)d; 
  29.  
  30.         // 因为java中的运算会转成最大类型 
  31.         // 而10和3默认为int,所以运算后的最大类型也是int 
  32.         // 所以是正确的 
  33.         int f = 10/3; // 3 
  34.  
  35.         // 声明10为long类型 
  36.         long g = 10; 
  37.  
  38.         // 出现错误,多个数值在运算过程中,会转换成容量大的类型 
  39.         // 以下示例最大的类型为double,而h为int,所以就会出现大类型(long)到小类型(int)的转换,将会出现精度丢失问题 
  40.         // int h = g/3; 
  41.          
  42.         // 可以强制转换,因为运算结果没有超出int范围 
  43.         // int h = (int)g/3; 
  44.  
  45.         // 可以采用long类型来接受运算结果 
  46.         // long h = g/3; 
  47.  
  48.         // 出现精度损失问题,以下问题主要是优先级的问题 
  49.         // 将g转换int,然后又将int类型的g转换成byte,最后byte类型的g和3运算,那么它的运算结果类型就是int,所以int赋值给byte就出现了精度损失问题 
  50.         // byte h = (byte)(int)g/3; 
  51.         //vx小助手:xiehuangbao1123 领取资料面试真题 
  52.         // 正确 
  53.         // byte h = (byte)(int)(g/3); 
  54.  
  55.         // 不能转换,还有因为优先级问题 
  56.         // byte h = (byte)g/3; 
  57.  
  58.         // 可以转换,因为运算结果没有超出byte范围 
  59.         // byte h = (byte)(g/3); 
  60.  
  61.         // 可以转换,因为运算结果没有超出short范围 
  62.         short h = (short)(g/3); 
  63.         short i = 10; 
  64.  
  65.         // 错误,short和byte运算,首先会转换成int再运算 
  66.         // 所以运算结果为intint赋值给short就会出现精度丢失问题 
  67.         // short k = i + j; 
  68.  
  69.         // 可以将运算结果强制转换成short 
  70.         // short k = (short)(i + j); 
  71.  
  72.         // 因为运算结果为int,所以可以采用int类型接手 
  73.         int k = i + j; 
  74.         char l = 'a'
  75.         System.out.println(l); // a 
  76.  
  77.         // 输出结果为97,也就是a的ascii值 
  78.         System.out.println((byte)l);  // 97 
  79.  
  80.         int m = l + 100; 
  81.         // 输出结果为197,取得a的ascii码值,然后与100进行先加运算 
  82.         System.out.println(m); // 197 
  83.  
  84.     } 

 

责任编辑:姜华 来源: 今日头条
相关推荐

2009-07-09 17:02:04

JDK学习笔记数据类型

2009-09-23 10:41:10

对象标识符Hibernate

2009-08-26 14:01:18

C#标识符

2012-02-08 14:01:18

HibernateJava

2020-07-28 08:59:22

JavahreadLocal面试

2010-02-02 09:32:32

C++ typedef

2009-10-27 14:20:37

VB.NET动态标识符

2023-05-16 08:01:26

限流算法滑动窗口

2011-03-14 10:17:40

JavaScript

2022-07-17 06:57:02

时间戳唯一标识符

2023-03-27 10:04:27

数据类型浮点型布尔型

2020-10-26 13:46:07

Java基础入门篇

2021-12-09 12:22:28

MyBatis流程面试

2023-06-07 08:08:43

JVM内存模型

2023-03-13 10:01:27

Java注释

2009-09-04 09:00:29

Java基础语法

2009-06-26 18:07:12

JSF客户端标识符

2009-07-21 12:59:25

Scala标识符

2009-12-08 19:29:10

PHP生成唯一标识符

2017-04-21 12:30:45

AndroidAndroid O设备标识符
点赞
收藏

51CTO技术栈公众号