最近事情太多，沒太時間寫博客，今天抽空再整理整理面試中的那點事吧，幫助那些正在找作業或想跳槽找作業的學弟學妹們，

前面我己寫過多篇推文，相信看過我文章的伙伴們已經了解掌握了不少，從目前流行的開發技術、常見的面試問題以及問題的答案都已經寫的特別清楚了，今天我給寫一篇初級Java開發面試必問項！供大家閱讀參考，

初級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、合法和不合法的識別符號

合法	不合法
_123Test	123Test
	HelloWorld!
A_B_C	HelloWorld#
$ABC	Hello World
class1	class
public0	public

*/
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源程式的組成部分，
資料在現實世界當中是分門別類的，所以資料在計算機編程語言當中也是有型別的：【資料型別】

【資料型別】	【資料型別】
10、100	屬于整數字面值
3.14	屬于浮點型字面值
true、false	屬于布爾型字面值
“abc”、“程式員”	屬于字串型字面值
‘A’、‘人’	屬于字符型字面值

注意：

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、八種基本資料型別各自占用空間大小是多少？

基本資料型別	占用空間大小
byte	1
short	2
int	4
long	8
float	4
double	8
boolean	1
char	2

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這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、八種基本資料型別的取值范圍：

型別	取值范圍
byte	[-128 ~ 127]
short	[-32768 ~ 32767]
int	[-2147483648 ~ 2147483647]
long	/
float	/
double	/
boolean	[true,falese]
char	[0 ~ 65535]

        注意：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);
    }
}

二、關于八種資料型別的默認值

資料型別	默認值
byte，short，int，long	0
float，double	0.0
boolean	false【在C語言中，true是1，false是0】
char	\u0000

八種基本資料型別的默認值是一切向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個位元組】
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…
計算機的資源是有限的，用有限的資源存盤無限的資料只能存盤近似值

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型別只有兩個值：turefals，沒有其他值，
不像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("對不起，用戶名不存在或者密碼錯誤！");
            }
    }
}

八、關于基本資料型別之間的互相轉換：轉換規則

八種基本資料型別當中出布爾型別之外剩下的7種型別之間都可以互相轉換【白嫖資料】
小容量向大容量轉換，稱為自動型別轉換，容量從小到大排序：
byte < short < int < long < float < double char <
注：任何浮點型別不管占用多少個位元組，都比整數型容量大，
char和short可表示的種類數量相同，但是char可以取更大的正整數
大容量轉換成小容量，叫做強制型別轉換，需要加強制型別轉換符，程式才能編譯通過，但是在運行階段可能會損失精度，所以謹慎使用，
當整數字面值沒有超出byte，short，char的取值范圍，可以直接賦值給byte，short，char型別的變數
byte，short，char混合運算的時候，各自先轉換成int型別在做運算，
多種資料型別混合運算，先轉換成容量最大的那種型別再做運算，

注意：

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，快速升職加薪，走上人生巔峰，

可以的話請給我一個三連支持一下我喲???

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/289573.html

標籤：java

上一篇：MySQL讀寫分離---你確定不瞅一眼！！！

下一篇：鴻蒙使用java語言撰寫一個登錄界面

初級Java開發面試必問項！！！ 識別符號、字面值、變數、資料型別，該學學了！

初級Java開發面試必問項！！！ 識別符號、字面值、變數、資料型別，該學學了！

識別符號

關于java語言當中的識別符號

1、什么是識別符號

2、識別符號的命名規則【不按照這個規則來，編譯器會報錯，這是語法】

3、表示符的命名規則【只是一種規范，不屬于語法，不遵守規范編譯器不會報錯】

4、合法和不合法的識別符號

字面值

關于字面值：

變數

一、關于java語言當中的變數：

二、關于java語言當中的變數：使用所有的基礎語法開發系統業務

三、關于java中的變數；

四、關于變數的分類:

資料型別

一、關于java中的資料型別：

二、關于八種資料型別的默認值

三、關于java語言中的char型別：

四、關于java語言當中的整數型：

五、關于java中的整數型

六、關于浮點型資料型別：

七、關于布爾型資料型別

八、關于基本資料型別之間的互相轉換：轉換規則

初級Java開發面試必問項！！！識別符號、字面值、變數、資料型別，該學學了！

初級Java開發面試必問項！！！識別符號、字面值、變數、資料型別，該學學了！