初级Java开发面试必问项！！！标识符、字面值、变量、数据类型，该学学了！

怼烎@ 2022-08-30 15:48 102阅读 0赞

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

前面我己写过多篇推文，相信看过我文章的伙伴们已经了解掌握了不少。从目前流行的开发技术、常见的面试问题以及问题的答案都已经写的特别清楚了，今天我给写一篇初级Java开发面试必问项！供大家阅读参考。![297ce2865e9d5bbe770108e4576070eb.png][]

### 初级Java开发面试必问项！！！ 标识符、字面值、变量、数据类型，该学学了！ ###

*  标识符
 *   *  关于java语言当中的标识符
     *   *  1、什么是标识符
         *  2、标识符的命名规则【不按照这个规则来，编译器会报错，这是语法】
         *  3、表示符的命名规则【只是一种规范，不属于语法，不遵守规范编译器不会报错】
         *  4、合法和不合法的标识符
 *  字面值
 *   *  关于字面值：
 *  变量
 *   *  一、关于java语言当中的变量：
     *  二、关于java语言当中的变量：使用所有的基础语法开发系统业务
     *  三、关于java中的变量；
     *  四、关于变量的分类:
 *  数据类型
 *   *  一、关于java中的数据类型：
     *  二、关于八种数据类型的默认值
     *  三、关于java语言中的char类型：
     *  四、关于java语言当中的整数型：
     *  五、关于java中的整数型
     *  六、关于浮点型数据类型：
     *  七、关于布尔型数据类型
     *  八、关于基本数据类型之间的互相转换：转换规则

# 标识符 #

## 关于java语言当中的标识符 ##

### 1、什么是标识符 ###

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

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

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

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

//最好见名知意
                public class UserService{
        
                    public void login(String username,String password){
        
                    }
                }
    //遵守驼峰命名方式
    //Java开发交流君样：593142328
                SystemService  UserService  CustomerService

*  类名、接口名：首字母大写，后面每个单词首字母大写
 *  变量名、方法名：首字母大写，后面每个单词首字母大写
 *  长量名：全部大写

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

<table> 
 <thead> 
  <tr> 
   <th>合法</th> 
   <th>不合法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>_123Test</td> 
   <td>123Test</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>HelloWorld!</td> 
  </tr> 
  <tr> 
   <td>A_B_C</td> 
   <td>HelloWorld#</td> 
  </tr> 
  <tr> 
   <td>$ABC</td> 
   <td>Hello World</td> 
  </tr> 
  <tr> 
   <td>class1</td> 
   <td>class</td> 
  </tr> 
  <tr> 
   <td>public0</td> 
   <td>public</td> 
  </tr> 
 </tbody> 
</table>

*/
    public class IdentifierTest01 
    //IdentifierTest01是一个类名，名字可以修改  
    {
        
        //main是一个方法名
        public static void main(String[] agrs){
         
        //args是一个变量名
        }
    
        //doSome就是方法名
        public static void doSome(){
        
            //i就是变量名
            int i = 10;
        }//Java开发交流君样：593142328
    }

# 字面值 #

## 关于字面值： ##

*  字面值：

*  10、100、3.14、“abc”、‘a’、true、false

*  字面值就是数据
 *  字面值是java源程序的组成部分之一，包括标识符和关键字他们都是java源程序的组成部分。
 *  数据在现实世界当中是分门别类的，所以数据在计算机编程语言当中也是有类型的：【数据类型】

<table> 
 <thead> 
  <tr> 
   <th>【数据类型】</th> 
   <th>【数据类型】</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>10、100</td> 
   <td>属于整数字面值</td> 
  </tr> 
  <tr> 
   <td>3.14</td> 
   <td>属于浮点型字面值</td> 
  </tr> 
  <tr> 
   <td>true、false</td> 
   <td>属于布尔型字面值</td> 
  </tr> 
  <tr> 
   <td>“abc”、“程序员”</td> 
   <td>属于字符串型字面值</td> 
  </tr> 
  <tr> 
   <td>‘A’、‘人’</td> 
   <td>属于字符型字面值</td> 
  </tr> 
 </tbody> 
</table>

**注意：**

*  java语言当中所有的字符串字面值必须使用双引号括起来，双引号是半角
 *  java语言当中所有的字符型字面值必须使用单引号括起来，单引号是半角

*/
    public class ConstTest01
    {
        
        public static void main(String[] args){
        
            System.out.println("abc");
            System.out.println("你最近过得好吗？");
            System.out.println(10);
            System.out.println(false);
            System.out.println(true);
            System.out.println('A');
            System.out.println(3.14);
            // 编译报错，因为单引号中只能存放单个字符，属于字符型字面值
            // System.out.println('ABC');
            //Java开发交流君样：593142328
            // 100是一个字面值，是一个整数型数值，那么既然是数据存储在内存当中，必定会占用一定的内存空间。
            System.out.println(100);//加入Java开发交流君样：756584822一起吹水聊天
        }
    }

# 变量 #

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

**1、什么是变量？**

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

**2、数据类型的作用？**

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

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

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

*  数据类型 变量名；

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

**5、变量声明之后怎么赋值？**  
\- 语法格式：变量名 = 字面值;  
\- 要求：字面值的数据类型必须和变量的数据类型一致。  
= 等号是一个运算符，叫做赋值运算符，赋值运算等号右边的表示，表示式执行结束之后的结果赋值给左边的变量。

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

int i = 10;

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

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

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

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

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

*  第一种：读取变量中保存的具体数据 get/获取
 *  第二种：修改变量中保存的具体数据 set/设置

i = 20: //set
                     System.out.println(i); //get

**10、变量在一行上可以声明多个**  
int a，b，c；  
**11、变量必须先声明，再赋值，才能访问。**

*  int i; 程序执行到这里，内存空间并没有开辟出来，变量i并没有初始化。所以没有赋值之前是无法访问的。

public class VarTest01
    {
        
        public static void main(String[] args){
        
        
            //声明一个int类型的变量，起名i
            int i;//Java开发交流君样：593142328
            // 编译报错，变量i并没有初始化
            // System.out.println(i);
            
    //加入Java开发交流君样：756584822一起吹水聊天
            // 给i变量赋值，i 变量在这里完成初始化，内存开辟
            i = 100;
            System.out.println(i);
    
            // i 再次重新赋值
            i = 200;
            System.out.println(i);
    
            // 一行上可以同时声明多个变量
            // a和b尚未初始化，c赋值300
            // int a,b,c = 300;
        }
    }

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

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

*  第一行；第二行；第三行；

\*\*特点：\*\*第二行的代码必须完整的结束之后，第三行程序才能执行。

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

public class VarTest02
    {
        
        public static void main(String[] args)
            int i = 100;
            System.out.println(i); //100
    
            i = 200;
            System.out.println(i); //200
    
            // 以下代码顺序有错误，先声明然后复制再访问
            /*
            System.out.println(k);
            int k = 100;
            */
            /*
            int i = 90;
            System.out.println(i);
            */
    }

## 三、关于java中的变量； ##

变量的作用域

**1、什么是作用域？**

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

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

出了大括号就不认识了。

public class VarTest03
    {
        
        //注意： 这里在static不要去掉
        static int k = 90;
    
        public static void main(String[] args)
            // 变量i的作用域是main方法
            // 在整个main方法当中是有效的，可见的，可以访问的
            int i = 100;
            System.out.println(i): // 可以
            System.out.println(k): // 可以
    
            // 以下会编写一个for循环语句
            // 这个for循环后面的控制语句的时候详细讲解
            for(int a=0;a<10;a++){
         //a变量的作用域是整个for循环，for循环结束之后，a变量的内存就释放了
            }
            // 这里无法访问a变量
            // System.out.println(a):
    
            int j; // 作用域是main方法
            for (int j=0;j<10;j++){
        
            }
            System.out.println(j): // 访问的是main方法中的j变量
            
        }
        public static void doSome(String[] args)
            // 这里无法访问main方法当中的变量i
            // 已经出了i变量的作用域。
            // System.out.println(i):
    
    //加入Java开发交流君样：756584822一起吹水聊天
            // 可以
            System.out.println(k):
        }
    }

## 四、关于变量的分类: ##

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

*  局部变量

*  在方法体当中声明的变量叫做局部变量

*  成员变量

*  在方法体外【类体之内】声明的变量叫做成员变量
 *  在不同的作用域当中，变量名是可以相同的。
 *  在同一个作用域当中，变量名不能重名。

public class VarTest04
    {
            
        // 成员变量
        int k = 200;
    
        // 主方法：入口
        public static void main(String[] args){
        
            // i变量就是局部变量
            int i = 10;
            
    //加入Java开发交流君样：756584822一起吹水聊天
            // java遵循“就近原则”
            System.out.println(i);
        }
    
        // 成员变量
        int i = 100; // 什么变量
        // 类体中不能直接编写java语句【除声明变量之外】
        // System.out.println(i):
    
        // doSome方法
        public static void doSome(){
        
            // 局部变量
            int i = 90;
    
            
        }
    }

# 数据类型 #

## 一、关于java中的数据类型： ##

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

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

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

*  基本数据类型
 *  引用数据类型【后边解释】

*  类、接口、数据、等等…

**3、关于基本数据类型：**

*  基本数据类型包括四大类八小种：

第一类：整数型

*  `byte、short、int、long`  
    第二类：浮点型
 *  `float、double`  
    第三类：布尔型
 *  `boolean`  
    第四类：字符型
 *  `char`

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

*  字符串使用双引号 “abc”
 *  字符使用单引号 ‘a’

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

<table> 
 <thead> 
  <tr> 
   <th>基本数据类型</th> 
   <th>占用空间大小</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>2</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>4</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>8</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>4</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>8</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>2</td> 
  </tr> 
 </tbody> 
</table>

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

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

**7、什么是二进制？**

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

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

**8、字节(byte)**

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

**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][byte_short_int_long_float_double_boolean]这7种数据类型计算机在表示的时候比较容易，因为底层都是数字，十进制的数字和二进制之间存在一种固定的转换规则。
 *  但是八种基本数据类型当中char类型表示的是现实世界中的文字，文字和计算机二进制之间”默认“情况下是不存在任何转换关系的。
 *  为了让计算机可以表示现实世界当中的文字，我们需要进行人为的干涉，需要人负责提前制定好”文字“和”二进制“之间的对照关系。这种对照转换关系被称为：字符编码。
 *  计算机最初只支持英文，最先出现的字符编码是：ASCII码

'a' -> 97 【01100001】
                    'A' -> 65
                    '0' -> 48
    
                    'a' -- (按照ASCII解码) --> 01100001
                    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、八种基本数据类型的取值范围：**

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>取值范围</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>[-128 ~ 127]</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>[-32768 ~ 32767]</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>[-2147483648 ~ 2147483647]</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>/</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>/</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>/</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>[true,falese]</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>[0 ~ 65535]</td> 
  </tr> 
 </tbody> 
</table>

注意：short和char所表示的种类总数是一样的，只不过char可以标识更大的正整数。
            因为char没有负数。

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

public class DataTypeTest01
    {
        
        public static void main(String[] args){
        
            // 定义一个char类型的变量，起名c，同时赋值字符'a'
            char c = 'a';
            System.out.print(c);
    
            // 一个中文占用2个字节，char类型正好是2个字节
            // 所以java中的char类型变量可以存储一个中文字符
            char x = '国'；
            System.out.print(x);
            
            // 编译错误
            // ab是字符串不能使用单引号括起来
            // char y = 'ab';
    
            // "a"是字符串类型
            // k变量是char类型
            // 类型不兼容，编译错误
            char k = "a";
            
            // 声明
            char e;
    
            // 赋值
            e = "e";
    
            // 再次赋值
            System.out.print(e);
        }
    }

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

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte，short，int，long</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>float，double</td> 
   <td>0.0</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>false【在C语言中，true是1，false是0】</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>\u0000</td> 
  </tr> 
 </tbody> 
</table>

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

public class DataTypeTest02
    {
        
            // 这里的static必须加，别问。
            static int k = 1000;
            
            // 变量还是遵守这个语法：必须先声明，在赋值,才能访问。
            // 成员变量没有手动赋值系统会默认赋值【局部变量不会】
            static int f; //成员变量
    
            public static void main(String[] args){
        
                /*
                    int i; //局部变量
                    System.out.print(i);
                */
                System.out.print(k);
    
                System.out.print(f);
            }
    }

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

**转义字符**

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

**\\n 换行符**  
**\\t 制表符**  
**’ 普通的单引号**  
**\\ 普通的反斜杠**  
**" 普通的双引号**

public class DataTypeTest03
    {
        
        public static void main(String[] args){
        
    
            // 普通的n字符
            char c1 = 'n':
            System.out.print(c1);
            
            // 依照目前所学知识，一下程序无法编译通过，因为显示是一个字符串，不能使用单引号括起来
            // 但是经过编译，发现编译通过了，这说明以下并不是一个字符串，而是“一个”字符
            // 这是一个“换行符”，属于char类型的数据
            // 反斜杠在java语言当中具有转义功能。
            char c2 = '\n';
    
            /*
            System.out.print("Hello");
            System.out.print("World!");
            */
            
            // System.out.println()和System.out.print()区别：
            // println输出之后换行，print表示输出，但是不换行
            /*
            System.out.print("Hello");
            System.out.println("World!");
            */
    
            System.out.print("A");
            // System.out.print(c2);
            System.out.println("B");
    
            // 普通的t字符
            char x = 't';
            System.out.print("t");
    
            // 制表符tab
            // 强调：制表符和空格不一样，他们的ASCII不一样，体现在键盘上两个不同的“按键”
            char y = '\t';
            System.out.println("A");
            System.out.print(y);
            System.out.println("B");
    
            // 要求在控制台上输出“反斜杠字符”
            /*
            // 反斜杠蒋后面的单引号转义成不具备特殊含义的普通单引号字符，左边的单引号缺少了结束的单引号字符，编译报错
            char k = '\';
            System.out.println(k);
            */
            /*
              // 解释：第一个反斜杠具有转义功能，将后面的反斜杠转义为普通的反斜杠字符。
              结论：在java当中两个反斜杠代表一个普通的反斜杠字符
            */
            char k = '\\';
            System.out.println(k);
    
            // 在控制台上输出一个普通的单引号字符
            // java中不允许这样编写程序，编译报错
            // char a = ''; 
    
            // 以下编译报错：第一个单引号和第二个单引号配对儿，最后的单引号找不到另一半！
            // char a = ''';
            // System.out.println(a);
            
            // 反斜杠具有转义功能，将第二个单引号转换成普通的单引号字符，第一个单引号和最后单引号配对。
            char a = '\'';
            System.out.println(a);
    
            char f = '"';
            System.out.println(f);
    
            // 编译错误
            // System.out.println(""HelloWorld!"");
    
            // 纠正
            System.out.println("\"HelloWorld!\"");
    
            char m = '中';
            System.out.println(m);
    
            // JDK中自带的native2ascii.exe命令，可以将文字转换成unicode编码形式
            // 怎么使用这个命令：
            // 在命令行输出native2ascii,回车，然后输入文字之后回车即可得到unicode编码
            char n = "\u4e2d"; // '中'对应的unicode编码是 4e2d
            System.out.println(n);
    
            // 编译错误
            // char g = '4e2d';
    
            // 编译错误
            // char g = 'u4e2d';
    
            // 通过：反斜杠u联合起来后面的一串数字是某个文字的unicode编码
            char g = '\u4e2d';
            System.out.println(g);
            
            // char类型的默认值
            char c = '\u0000'；
            System.out.println(c);
    
    
    
        }
    }

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

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

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

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

*  第一种方式：十进制【是一种缺省的默认的方式】
 *  第二种方式：八进制【在编写八进制整数型字面值的时候需要以0开始】
 *  第三中方式：十六进制【在编写十六进制整数型字面值的时候需要以0x开始】

public class DataTypeTest04
    {
        public static void main(String[] args){
            int a = 10;      // 缺省
            int b = 010;  // 整数型字面值以开头的，后面那一串数字就是八进制形式
            int c = 0x10; // 整数型字面值以0x开头的，后面一串数字就是十六进制形成
    
            System.out.println(a); // 10
            System.out.println(b); // 8
            System.out.println(c); // 16
    
            System.out.println(a + b + c); //34
    
            // 123这个整数型字面值int类型
            // i 变量声明的时候也是int类型
            // int类型的123赋值给int类型的变量i，不存在类型转换
            int i = 123;
            System.out.println(i);
    
            // 456整数型字面值被当做int类型，占用4个字节
            // x变量在声明的时候是long类型，占用8个字节
            // int类型的字面值456赋值给long类型的变量x，存在类型转换
            // int类型转换成long类型
            // long类型是大容量
            // 小容量可以自动转换成大容量，称为自动类型转换机制。
            long x =456;
            System.out.println(x);
            
            // 2147483647字面值是int类型，占用4个字节
            // y是long类型，占用8个字节，自动类型转换
            long y = 2147483647;
            System.out.println(y);
    
            // 编译错误：过大的整数，2147483648
            // 2147483648 被当做int类型4个字节处理，但是这个字面值超出int类型范围
            // long z = 2147483648;
    
            // 解决错误
            // 2147483648字面值一上来就当做long类型来处理，在字面值后面添加L
            // 2147483648L是8个字节的long类型
            // z是long类型变量，以下程序不存在类型转换
            long z = 2147483648L;
            System.out.println(z);
        
        }
    }

## 五、关于java中的整数型 ##

**byte**  
**short**  
**int**  
**long**

public class DataTypeTest05
    {
        
        public static void main(String[] args){
        
            
            // l00L是long类型字面值
            // x是long类型变量
            // 不存在类型转换，直接赋值
            long x = 100L;
    
            // x变量是long类型，8个字节
            // y变量是int类型，4个字节
            // 以下程序可以编译通过吗？
            // 编译报错，大容量不能直接赋值给小容量
            // int y = x;
    
            // 大容量转换成小容量，需要进行强制类型转换
            // 强制类型转换需要加“强制类型转换符”
            // 加上强制类型转换符之后编译通过了，但是运行阶段可能损失精度。
            // 所以强制类型转换谨慎使用，因为损失精度之后可能损失很严重。
            // 强转原理：
               // 原始数据：00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100
               // 强转之后的数据；00000000 00000000 00000000 01100100
               // 将左边的二进制砍掉【所有的数据强转的时候都是这样完成的】
            int y = (int)x;
            System.out.println(y);
            
            // 原始数据：00000000 00000000 00000000 00000000 10000000 00000000 00000000 00000000
            // 强转之后的数据；10000000 00000000 00000000 00000000
            // 10000000 00000000 00000000 00000000 目前存储在计算机内部，计算机存储数据都是采用补码的形式存储
            // 所以 10000000 00000000 00000000 00000000 现在是一个补码形式
            // 将以上的补码转换到原码就是最终的结果
            long k = 2147483648L;
            int e = (int)k;
            System.out.println(e); // 损失精度严重，结果是负数 【-2147483648】
    
            // 分析以下程序是否可以编译通过？
            // 依据目前所学内容，以下程序是无法编译通过的
            // 理由：50是int类型的字面值，b是byte类型的变量，显然是大容量int转换成小容量byte
            // 大容量转换成小容量是需要添加强制类型转换符的，以下程序没有添加强转符号，所以编译报错。
            // 但是，在实际编译的时候，一下代码编译通过，这说明：在java语言中，当一个整数型字面值
            // 没有超过byte类型取值范围的话，该字面值可以直接赋值给byte类型的变量。
            byte b = 50; // 可以
    
            byte c = 127;  // 可以
    
            // 编译报错，128这个int类型的字面值已经超出了byte类型的取值范围，不能直接赋值给byte类型的变量
            // byte b1 = 128;  
    
            // 纠正错误，需要使用强制类型转换符
            // 但是一定会损失精度
            // 原始数据：10000000 00000000 00000000 00000000
            // 强转之后：10000000 【这是存储在计算机内部的，这是一个补码，它的原码是什么？】
            byte b1 = (byte)128; // -128
            System.out.println(b1);
    
            /*
                计算机二进制有三种表示形式：
                    原码、反码、补码
                计算机在任何情况下底层表示和存储数据的时候采用了补码形式。
                整数的补码：和原码相同
                负数的补码：负数的绝对值对应的二进制码所有二进制拉取反，再加1
    
                补码：10000000
                原码计算机过程：
                    - 10000000 - 1 --> 01111111
                    - 10000000 --> 128
                    - -128
            */
            // 原始数据：00000000 00000000 00000000 11000110
            // 强制类型转换之后：11000110
            // 11000110 - 1 --> 11000101
            // 00111010 【2 + 8 + 16 + 32】 --> 58
            // 58
            byte m = (byte)198;
            System.out.println(m);  // -58
    
            short s = 32767;  // 通过
            // short s = 32768;  // 编译报错
    
            // 65535是int类型，4个字节
            // cc是char类型，2个字节
            // 按照以前所学知识点来说，以下程序是编译报错的。
            // char cc = 65535;  // 通过
            // cc = 65536; //编译报错
    
            /*
                当一个整数字面值没有超出byte，short，char的取值范围，这个字面值
                可以直接赋值给byte，short，char类型的变量，这种机制SUN允许了，目的是为了方便程序员的编程。
            */
        }
    }

## 六、关于浮点型数据类型： ##

`float`单精度[【4个字节】][byte_short_int_long_float_double_boolean]  
`double` 双精度[【8个字节，精度较高】][byte_short_int_long_float_double_boolean]

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…  
计算机的资源是有限的，用有限的资源存储无限的数据只能存储近似值

public class DataTypeTest06
    {
        
        public static void main(String[] args){
        
            // 3.0是double类型的字面值
            // d是double类型的变量
            // 不存在类型转换
            double d = 3.0;
            System.out.println(d);
            
            // 5.1是double类型的字面值
            // f是float类型的变量
            // 大容量转换成小容量需要加强制类型转换符，所以以下程序编译错误。
            // float f = 5.1;
    
            // 解决方案：
            // 第一种方式：强制类型转换
            // float f = (float)5.1;
    
            // 第二种方式：没有类型转换
            float f = 5.1f;
        }
    }

## 七、关于布尔型数据类型 ##

**boolean**

在java语言当boolea类型只有两个值：`ture`fals，没有其他值。  
不像C语言当中，0和1可以表示假和真。

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

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

public class DataTypeTest07
    {
        
        public static void main(String[] args){
        
            // 编译错误：不兼容的类型
            // boolean flag = 1;
    
            //boolean loginSuccess = true; 
            boolean loginSuccess = false;
    
            // if语句以后在解释【条件控制语句】
            if(loginSuccess){
        
                System.out.println("恭喜你，登录成功");
            }else{
        
                System.out.println("对不起，用户名不存在或者密码错误！");
                }
        }
    }

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

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

public class DataTypeTest08
    {
        
        public static void main(String[] args){
        
    
            // 出现错误，1000超出了byte的范围
            // byte a = 1000;
    
            // 正确，因为20没有超出byte范围
            byte a = 20;
    
            // 变量不能重名
            // short a = 1000;
    
            // 正确，因为数值1000没有超出short类型的范围
            // 所以赋值正确
            short b = 1000;
    
            // 正确，因为默认就是int，并没有超出int范围
            int c = 1000;
    
            // 正确，可以自动转换
            long d = c;
    
            // 错误，出现精度丢失问题，大类型-->>小类型会出现问题
            // int e = d;
    
            // 将long强制转换成int类型
            // 因为值1000，没有超出int范围，所以转换是正确的
            int e = (int)d;
    
            // 因为java中的运算会转成最大类型
            // 而10和3默认为int，所以运算后的最大类型也是int
            // 所以是正确的
            int f = 10/3; // 3
    
            // 声明10为long类型
            long g = 10;
    
            // 出现错误，多个数值在运算过程中，会转换成容量大的类型
            // 以下示例最大的类型为double，而h为int，所以就会出现大类型（long）到小类型（int）的转换，将会出现精度丢失问题
            // int h = g/3;
            
            // 可以强制转换，因为运算结果没有超出int范围
            // int h = (int)g/3;
    
            // 可以采用long类型来接受运算结果
            // long h = g/3;
    
            // 出现精度损失问题，以下问题主要是优先级的问题
            // 将g转换int，然后又将int类型的g转换成byte，最后byte类型的g和3运算，那么它的运算结果类型就是int，所以int赋值给byte就出现了精度损失问题
            // byte h = (byte)(int)g/3;
            
            // 正确
            // byte h = (byte)(int)(g/3);
    
            // 不能转换，还有因为优先级问题
            // byte h = (byte)g/3;
    
            // 可以转换，因为运算结果没有超出byte范围
            // byte h = (byte)(g/3);
    
            // 可以转换，因为运算结果没有超出short范围
            short h = (short)(g/3);
            short i = 10;
    
            // 错误，short和byte运算，首先会转换成int再运算
            // 所以运算结果为int，int赋值给short就会出现精度丢失问题
            // short k = i + j;
    
            // 可以将运算结果强制转换成short
            // short k = (short)(i + j);
    
            // 因为运算结果为int，所以可以采用int类型接手
            int k = i + j;
            char l = 'a';
            System.out.println(l); // a
    
            // 输出结果为97，也就是a的ascii值
            System.out.println((byte)l);  // 97
    
            int m = l + 100;
            // 输出结果为197，取得a的ascii码值，然后与100进行先加运算
            System.out.println(m); // 197
    
        }
    }

**最后，祝大家早日学有所成，拿到满意offer**

[297ce2865e9d5bbe770108e4576070eb.png]: /images/20220829/ba4ebf255ac645a480b516db673a528a.png
[byte_short_int_long_float_double_boolean]: https://shimo.im/docs/9GTP6XrJg9J88cJD/