欧美一区二区三区大片,1区2区3区视频,最近中文字幕第一页

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

從目前流行的開發技術、常見的面試問題以及問題的答案都已經寫的特別清楚了，今天我給寫一篇初級Java開發面試必問項!供大家閱讀參考。

Java開發面試必問項！標識符、字面值、變量、數據類型

標識符

關于java語言當中的標識符

1、什么是標識符

在java源程序當中凡是程序員有權利自己命名的單詞都是標識符
標識符在EditPlus編輯器當中以黑色字體高亮顯示
標識符可以標識什么元素呢?
類名 * 方法名 * 變量名 * 常量名等等...

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

一個合法的標識符只能由“數字、字母、下劃線_、美元符號$”組成，不能含有其他符號
不能數字開頭
嚴格區分大小寫
關鍵字不能做標識符
理論上無長度限制，但是最好不要太長

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

//最好見名知意
public class UserService{
public void login(String username,String password){
}
}
//遵守駝峰命名方式
SystemService UserService CustomerService

類名、接口名：首字母大寫，后面每個單詞首字母大寫
變量名、方法名：首字母大寫，后面每個單詞首字母大寫
長量名：全部大寫

4、合法和不合法的標識符

Java開發面試必問項！標識符、字面值、變量、數據類型

*/
public class IdentifierTest01
//IdentifierTest01是一個類名，名字可以修改
{
//main是一個方法名
public static void main(String[] agrs){
//args是一個變量名
}
//doSome就是方法名
public static void doSome(){
//i就是變量名
int i = 10;
}
}

字面值

關于字面值：

字面值：
10、100、3.14、"abc"、'a'、true、false
字面值就是數據
字面值是java源程序的組成部分之一，包括標識符和關鍵字他們都是java源程序的組成部分。
數據在現實世界當中是分門別類的，所以數據在計算機編程語言當中也是有類型的：【數據類型】

Java開發面試必問項！標識符、字面值、變量、數據類型

注意：

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語言當中的變量：

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;
// 編譯報錯，變量i并沒有初始化
// System.out.println(i);
// 給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):
// 可以
System.out.println(k):
}
}

四、關于變量的分類:

根據變量聲明的位置分類;

局部變量
在方法體當中聲明的變量叫做局部變量
成員變量
在方法體外【類體之內】聲明的變量叫做成員變量
在不同的作用域當中，變量名是可以相同的。
在同一個作用域當中，變量名不能重名。

public class VarTest04
{
// 成員變量
int k = 200;
// 主方法：入口
public static void main(String[] args){
// i變量就是局部變量
int i = 10;
// 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、八種基本數據類型各自占用空間大小是多少?

Java開發面試必問項！標識符、字面值、變量、數據類型

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、八種基本數據類型的取值范圍：

Java開發面試必問項！標識符、字面值、變量、數據類型

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

二、關于八種數據類型的默認值

Java開發面試必問項！標識符、字面值、變量、數據類型

八種基本數據類型的默認值是一切向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);
//vx小助手：xiehuangbao1123 領取資料面試真題
// 編譯錯誤
// 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);
//vx小助手：xiehuangbao1123 領取資料面試真題
// 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
//vx小助手：xiehuangbao1123 領取資料面試真題
補碼：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);
//vx小助手：xiehuangbao1123 領取資料面試真題
// 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;//vx小助手：xiehuangbao1123 領取資料面試真題
// 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;
//vx小助手：xiehuangbao1123 領取資料面試真題
// 正確
// 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
}
}