【Java從入門到天黑|02】SE入門之Java基礎

目錄

注釋

識別符號

資料型別

型別轉換

變數，常量

運算子

注釋

平時我們撰寫代碼，在代碼量比較少的時候，我們還可以看懂自己寫的，但是當專案結構一旦復雜起來，我們就需要用到一個注釋了，注釋就類似于我們上學時候寫的筆記，我們看著筆記就知道自己寫的什么

東西了！在程式中也是如此，我們來看一下Java中的注釋怎么寫，看以下代碼：

1 /*

2 * @Description HelloWorld類

3 * @Author Diamond 狂神QQ:24736743

4 **/

5 public class HelloWorld {

6 /*

7 這是我們Java程式的主入口，

8 main方法也是程式的主執行緒，

9 */

10 public static void main(String[] args) {

11 //輸出HelloWorld！

12 System.out.println("Hello,World!");

13 }

14 }

注釋并不會被執行，是給我們寫代碼的人看的，書寫注釋是一個非常好的習慣，在很多大公司都是強制要求各位去進行撰寫注釋！比如，我們的BAT三大巨頭等等，，，

Java中的注釋有三種：

單行注釋：只能注釋當前行，以//開始，直到行結束

1 //輸出HelloWorld！

多行注釋：注釋一段文字，以/ /結束！

1 /*

2 這是我們Java程式的主入口，

3 main方法也是程式的主執行緒，

4 */

檔案注釋：用于生產API檔案，配合JavaDoc，

【注】檔案注釋我們現在只作為了解，在學習JavaDoc時候我們會詳細給大家說,目前知道有這樣的注釋就好，

1 /*

2 * @Description HelloWorld類

3 * @Author Diamond 狂神QQ:24736743

4 **/

【狂神建議】平時寫代碼一定要注意注釋的規范性，一個好的程式員，一定是有非常良好的編碼習慣

的，我希望大家能夠從小事開始鍛煉自己的行為習慣！

識別符號

每個人從出生開始就有一個名字，咋們生活中的所有事物也都有名字，這名字是誰規定呢？回答是：造物主，誰生產出來的誰規定名字，在我們的程式中也不例外，

我們作為造物主，需要給所有的東西給上一個名字，比如我們的HelloWorld程式：

HelloWorld是類名，也是我們的檔案名，它前面的 public class是關鍵字，不過是搞Java那群人已經定義好的有特殊作用的，下面的每一個代碼都有自己的意思和名字對吧，就是用來作區分！和我們的名字一

樣，拿來被叫或者稱呼的，程式一切都源自于生活，一定要把學程式和生活中的一切聯系起來，你會發現這一切都是息息相關的，

我們來看看有哪些是Java自己定義好的關鍵字呢？

這些看起來非常的多，但是隨著我們以后的學習我們都會用到，所以完全不用擔心自己 看不懂，這些被Java已經規定的關鍵字，我們自己就不能拿它當做名字了！

Java 所有的組成部分都需要名字，類名、變數名以及方法名都被稱為識別符號，

我們自己起名字有哪些要求呢？

表示類名的識別符號用大寫字母開始，

1 如：Man, GoodMan

表示方法和變數的識別符號用小寫字母開始，后面的描述性詞以大寫開始，

1 如：eat(),eatFood()

2 //駝峰命名法

關于 Java 識別符號，有以下幾點需要注意：

所有的識別符號都應該以字母（A-Z 或者 a-z）,美元符（$）、或者下劃線（_）開始

首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下劃線（_）或數字的任何字符組合

不能使用關鍵字作為變數名或方法名，

識別符號是大小寫敏感的

合法識別符號舉例：age、$salary、_value、__1_value

非法識別符號舉例：123abc、-salary、#abc

【 JAVA不采用通常語言使用的ASCII字符集，而是采用unicode這樣的標準的國際字符集，因此，這里的字母的含義：可以表示英文、漢字等等，】

【可以使用中文命名，但是一般不建議這樣去使用，也不建議使用拼音，很Low】

1 public static void main(String[] args) {

2 String 王者榮耀 = "最強王者";

3 System.out.println(王者榮耀);

4 }

課外擴展：各種字符集和編碼詳解

演示：合法識別符號以及不合法識別符號

資料型別

Java是一種強型別語言，每個變數都必須宣告其型別，

1、強弱型別語言

說到強型別語言，那什么是強型別語言呢？

強型別語言也稱為強型別定義語言，要求變數的使用要嚴格符合規定，所有變數都必須先定義后才能使用，

Java、.NET、C++等都是強制型別定義的，也就是說，一旦一個變數被指定了某個資料型別，如果不經過轉換，那么它就永遠是這個資料型別了，

安全性高，運行效率相對較慢，魚和熊掌不可兼得！強型別定義語言在速度上可能略遜色于弱型別定義語言，但是強型別定義語言帶來的嚴謹性能夠有效的避免許多錯誤，與其相對應的是弱型別語言，

弱型別語言也稱為弱型別定義語言，與強型別定義相反，像vb，php等就屬于弱型別語言·在VBScript中，可以將字串‘12’和整數3進行連接得到字串‘123’，也可以把它看成整數123，而不需要顯示轉換，是不

是十分的隨便，我們Java就不是這樣的，但其實它們的型別沒有改變，VB只是在判斷出一個運算式含有不同型別的變數之后，自動在這些變數前加了一個clong（）或（int）（）這樣的轉換函式而已，能做到這

一點其實是歸功于VB的編譯器的智能化而已，這并非是VB語言本身的長處或短處，

好了，到這里，我們應該對強弱型別語言有了一定的了解！我們繼續回到資料型別這個話題.

2、資料型別

Java的資料型別分為兩大類：基本型別（primitive type）和參考型別 （reference type）

【注：參考資料型別的大小統一為4個位元組，記錄的是其參考物件的地址！】

如果你看到這一堆頭疼的話，沒關系，不用記，JDK中型別對應的包裝類都幫忙寫好了，我們需要時候可以直接看到！可以把以下代碼拷貝進行查看結果：

1 public static void main(String[] args) {

2 // byte

3 System.out.println("基本型別：byte 二進制位數：" + Byte.SIZE);

4 System.out.println("包裝類：java.lang.Byte");

5 System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);

6 System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);

7 System.out.println();

8

9 // short

10 System.out.println("基本型別：short 二進制位數：" + Short.SIZE);

11 System.out.println("包裝類：java.lang.Short");

12 System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);

13 System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);

14 System.out.println();

15

16 // int

17 System.out.println("基本型別：int 二進制位數：" + Integer.SIZE);

18 System.out.println("包裝類：java.lang.Integer");

19 System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);

20 System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);

21 System.out.println();

22

23 // long

24 System.out.println("基本型別：long 二進制位數：" + Long.SIZE);

25 System.out.println("包裝類：java.lang.Long");

26 System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);

27 System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);

28 System.out.println();

29

30 // float

31 System.out.println("基本型別：float 二進制位數：" + Float.SIZE);

32 System.out.println("包裝類：java.lang.Float");

33 System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);

34 System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);

35 System.out.println();

36

37 // double

38 System.out.println("基本型別：double 二進制位數：" + Double.SIZE);

}

System.out.println("包裝類：java.lang.Double");

System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);

System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);

System.out.println();

// char

System.out.println("基本型別：char 二進制位數：" + Character.SIZE);

System.out.println("包裝類：java.lang.Character");

// 以數值形式而不是字符形式將Character.MIN_VALUE輸出到控制臺

System.out.println("最小值：Character.MIN_VALUE="

+ (int) Character.MIN_VALUE);

// 以數值形式而不是字符形式將Character.MAX_VALUE輸出到控制臺

System.out.println("最大值：Character.MAX_VALUE="

+ (int) Character.MAX_VALUE);

如果你是熱愛學習的人，你現在應該非常想知道這位元組到底是什么東西，所以我給大家科普一下相關知識：

1 /*

2 位（bit）：是計算機 內部資料 儲存的最小單位，11001100是一個八位二進制數，

3 位元組（byte）：是計算機中 資料處理 的基本單位，習慣上用大寫 B 來表示,

4 1B（byte,位元組）= 8bit（位）

5 字符：是指計算機中使用的字母、數字、字和符號

6

7 ASCIIS碼：

8 1個英文字母（不分大小寫）= 1個位元組的空間

9 1個中文漢字 = 2個位元組的空間

10 1個ASCII碼 = 一個位元組

11 UTF-8編碼：

12 1個英文字符 = 1個位元組

13 英文標點 = 1個位元組

14 1個中文（含繁體） = 3個位元組

15 中文標點 = 3個位元組

16 Unicode編碼：

17 1個英文字符 = 2個位元組

18 英文標點 = 2個位元組

19 1個中文（含繁體） = 2個位元組

20 中文標點 = 2個位元組

21

22 1bit表示1位，

23 1Byte表示一個位元組 1B=8b，

24 1024B=1KB

25 1024KB=1M

26 1024M=1G.

27 */

那有人會問：電腦的32位和64位的區別是什么呢？

1 /*

2 32位作業系統只可以使用32位的cpu，而64位的CPU既可以安裝32位作業系統也可以安裝64位操作

系統，

3

4 尋址能力簡單點說就是支持的記憶體大小能力，64位系統最多可以支達128 GB的記憶體，而32位系統最

多只可以支持4G記憶體，

5

6 32位作業系統只可以安裝使用32位架構設計的軟體，而64位的CPU既可以安裝使用32位軟體也可以

安裝使用64位軟體，

7

8 現在的電腦都是64位了！

9 */

【好了，回到正題，我們了解了這些知識后，我們自己定義一些變數來看！】

1 public static void main(String[] args) {

2

3 //整型

4 int i1=100;

5 //長整型

6 long i2=998877665544332211L;

7 //短整型

8 short i3=235;

9 //浮點型

10 double d1=3.5; //雙精度

11 double d2=3;

12 float f1=(float)3.5; //單精度

13 float f2=3.5f; //單精度

14

15 //布爾型別 boolean true真/false假

16 boolean isPass=true;

17 boolean isOk=false;

18 boolean isBig=5>8;


}

if(isPass){

System.out.println("通過了");

}else{

System.out.println("未通過");

}

//單字符

char f='女';

char m='男';

【Java語言的整型常數默認為int型，浮點數默認是Double】

3、整型拓展

在我們計算機中存在很多進制問題，十進制，八進制，十六進制等等的問題，他們怎么表示呢？

1 十進制整數，如：99, -500, 0，

2

3 八進制整數，要求以 0 開頭，如：015，

4

5 十六進制數，要求 0x 或 0X 開頭，如：0x15 ，

演示：

1 //整型

2 int i=10;

3 int i2=010;

4 int i3=0x10;

5 System.out.println(i); //10

6 System.out.println(i2); //8

7 System.out.println(i3); //16

4、浮點型拓展

【金融面試問：銀行金融業務用什么型別表示？】

浮點型別?oat, double的資料不適合在不容許舍入誤差的金融計算領域，

如果需要進行不產生舍入誤差的精確數字計算，需要使用BigDecimal類，

1 public static void main(String[] args) {

2 float f = 0.1f;

3 double d = 1.0/10;

4 System.out.println(f==d); //false

5

6 float d1 = 2131231231f;

7 float d2 = d1+1;

8 if(d1==d2){

9 System.out.println("d1==d2");

10 }else{

11 System.out.println("d1!=d2");

12 }

13 }

主要理由：

由于字長有限，浮點數能夠精確表示的數是有限的，因而也是離散的，浮點數一般都存在舍入誤差，很多數字無法精確表示，其結果只能是接近，但不等于；二進制浮點數不能精確的表示0.1,0.01,0.001這樣

10的負次冪，并不是所有的小數都能可以精確的用二進制浮點數表示，

最好完全避免使用浮點數比較 !

大數值：Java.math下面的兩個有用的類：BigInteger和BigDecimal，這兩個類可以處理任意長度的數值，BigInteger實作了任意精度的整數運算，BigDecimal實作了任意精度的浮點運算，

浮點數使用總結：

1. 默認是double

2. 浮點數存在舍入誤差，很多數字不能精確表示，如果需要進行不產生舍入誤差的精確數字計算，需

要使用BigDecimal類，

3. 避免比較中使用浮點數

5、字符型拓展

單引號用來表示字符常量，例如‘A’是一個字符，它與“A”是不同的，“A”表示一個字串，

char 型別用來表示在Unicode編碼表中的字符，.

Unicode編碼被設計用來處理各種語言的所有文字，它占2個位元組，可允許有65536個字符；

【科普：2位元組=16位 2的16次方=65536，我們用的Excel原來就只有這么多行，并不是無限的】

【代碼演示：字符轉int看結果】

1 public static void main(String[] args) {

2 char c1 = 'a';

3 char c2 = '中';

4 System.out.println(c1);

5 System.out.println((int) c1); //97

6 System.out.println(c2);

7 System.out.println((int) c2); //20013

8 }

Unicode具有從0到65535之間的編碼，他們通常用從’u0000’到’uFFFF’之間的十六進制值來表示（前綴為u表示Unicode）

1 char c3 = '\u0061';

2 System.out.println(c3); //a

Java 語言中還允許使用轉義字符 ‘’ 來將其后的字符轉變為其它的含義，有如下常用轉義字符：

【以后我們學的String類，其實是字符序列(char sequence)，在這里給大家一個思考題】

1 //代碼1

2 String sa=new String("Hello world");

3 String sb=new String("Hello world");

4 System.out.println(sa==sb); // false

5 //代碼2

6 String sc="Hello world";

7 String sd="Hello world";

8 System.out.println(sc==sd); // true

大家可以先思考下為什么，之后我們學到物件的時候，會給大家進行記憶體級別的分析，那時候你會恍然大悟！

6、布爾型拓展

boolean型別（一位，不是一個位元組），就是0|1

boolean型別有兩個值，true和false,不可以 0 或非 0 的整數替代 true 和 false ，這點和C語言不同，

boolean 型別用來判斷邏輯條件，一般用于程式流程控制，

1 boolean flag = false;

2 if(flag){

3 // true分支

4 }else{

5 // false分支

6 }

【編碼規范：很多新手程式員喜歡這樣寫】

1 if (is == true && un == false ) {...}

只有新手才那么寫，對于一個熟練的人來說，應該用如下方式來表示：

1 if ( is && !un ) {....}

這點都不難理解吧，所以要習慣去掉所有的==fasle 和 ==true，Less is More！！ 代碼要精簡易讀！

型別轉換

由于Java是強型別語言，所以要進行有些運算的時候的，需要用到型別轉換，

整型、實型（常量）、字符型資料可以混合運算，

運算中，不同型別的資料先轉化為同一型別，然后進行運算，

轉換從低級到高級（根據容量來看），

1 低 ------------------------------------> 高

2

3 byte,short,char—> int —> long—> float —> double

資料型別轉換必須滿足如下規則：

不能對boolean型別進行型別轉換，

不能把物件型別轉換成不相關類的物件，

在把容量大的型別轉換為容量小的型別時必須使用強制型別轉換，

轉換程序中可能導致溢位或損失精度，例如：

1 int i =128;

2 byte b = (byte)i;

因為 byte 型別是 8 位，最大值為127，所以當 int 強制轉換為 byte 型別時，值 128 時候就會導致溢位，

浮點數到整數的轉換是通過舍棄小數得到，而不是四舍五入，例如：

1 (int)23.7 == 23;

2 (int)-45.89f == -45

1、自動型別轉換

自動型別轉換：容量小的資料型別可以自動轉換為容量大的資料型別，

例如: short資料型別的位數為16位，就可以自動轉換位數為32的int型別，同樣?oat資料型別的位數為

32，可以自動轉換為64位的double型別，

【演示】

1 public class ZiDongLeiZhuan{

2 public static void main(String[] args){

3 char c1='a';//定義一個char型別

4 int i1 = c1;//char自動型別轉換為int

5 System.out.println("char自動型別轉換為int后的值等于"+i1);

6 char c2 = 'A';//定義一個char型別

7 int i2 = c2+1;//char 型別和 int 型別計算

8 System.out.println("char型別和int計算后的值等于"+i2);

9 }

10 }

【決議：c1 的值為字符 a ,查 ASCII 碼表可知對應的 int 型別值為 97， A 對應值為 65，所以i2=65+1=66，】

2、強制型別轉換

強制型別轉換，又被稱為造型，用于顯式的轉換一個數值的型別.

在有可能丟失資訊的情況下進行的轉換是通過造型來完成的，但可能造成精度降低或溢位，

強制型別轉換的語法格式： (type)var ，運算子“()”中的type表示將值var想要轉換成的目標資料型別， 條件是轉換的資料型別必須是兼容的，

【演示】

1 public static void main(String[] args) {

2 double x = 3.14;

3 int nx = (int)x; //值為3

4

5 char c = 'a';

6 int d = c+1;

7 System.out.println(d); //98

8 System.out.println((char)d); //b

9 }

當將一種型別強制轉換成另一種型別，而又超出了目標型別的表示范圍，就會被截斷成為一個完全不同的值，溢位，

1 public static void main(String[] args) {

2 int x = 300;

3 byte bx = (byte)x; //值為44

4 System.out.println(bx);

5 }

3、常見錯誤和問題

1. 操作比較大的數時，要留意是否溢位，尤其是整數操作時；

1 public static void main(String[] args) {

2 int money = 1000000000; //10億

3 int years = 20;

4 int total = money*years; //回傳的是負數

5 long total1 = money*years; //回傳的仍然是負數，默認是int，因此結果會轉成int值，再轉成long，但是已經發生了資料丟失

6 long total2 = money*((long)years); //先將一個因子變成long，整個運算式發生提升，全部用long來計算，

7 System.out.println(total);

8 System.out.println(total1);

9 System.out.println(total2);

10 }

2. L和l 的問題：

不要命名名字為l的變數，long型別使用大寫L不要用小寫，

1 public static void main(String[] args) {

2 int l = 2;

3 long a = 23451l;

4 System.out.println(l+1); //3

5 System.out.println(a); //23451

6 }

4、JDK7擴展

JDK7新特性: 二進制整數

由于我們在開發中也經常使用二進制整數，因此JDK7為我們直接提供了二進制整數的型別，

我們只要以：0b開頭即可，

1 int a = 0b0101：

JDK7新特性：下劃線分隔符

在實際開發和學習中，如果遇到特別長的數字，讀懂它令人頭疼！JDK7為我們提供了下劃線分隔符，可以按照自己的習慣進行分割，

1 int b = 1_2234_5678;

我們很容易就知道這是1億2234萬5678啦！ 非常符合國人的習慣！

1 public static void main(String[] args) {

2 int a = 0b0101;

3 int b = 1_2345_7893;

4 System.out.println(a); //5

5 System.out.println(b); //123457893

6 }

變數，常量

1、變數（variable）

變數是什么：就是可以變化的量！

我們通過變數來操縱存盤空間中的資料，變數就是指代這個存盤空間！空間位置是確定的，但是里面放置什么值不確定！ 打個比方：

這就好像我們家里有一個大衣柜，里面有十分多的小格子，我們給格子上貼上標簽，放衣服，放鞋子，放手表等等，此時我們知道了哪里該放什么，但是，我們并不知道里面到底放的是什么牌子的鞋子，是

衣服還是褲子，那個標簽就相當于我們的變數，我們給他起了個名字，但是里面要放什么需要我們自己去放，

Java是一種強型別語言，每個變數都必須宣告其型別，

Java變數是程式中最基本的存盤單元，其要素包括變數名，變數型別和作用域，

變數在使用前必須對其宣告, 只有在變數宣告以后，才能為其分配相應長度的存盤單元，宣告格式為：

1 type varName [=value] [{,varName[=value]}] ；

2 //資料型別 變數名 = 值；可以使用逗號隔開來宣告多個同型別變數，

注意事項：

每個變數都有型別，型別可以是基本型別，也可以是參考型別，

變數名必須是合法的識別符號，

變數宣告是一條完整的陳述句，因此每一個宣告都必須以分號結束

【演示】

1 int a, b, c; // 宣告三個int型整數：a、 b、c

2 int d = 3, e = 4, f = 5; // 宣告三個整數并賦予初值

3 byte z = 22; // 宣告并初始化 z

4 String s = "runoob"; // 宣告并初始化字串 s

5 double pi = 3.14159; // 宣告了雙精度浮點型變數 pi

6 char x = 'x'; // 宣告變數 x 的值是字符 'x'，

【編碼規范】

雖然可以在一行宣告多個變數，但是不提倡這個風格，逐一宣告每一個變數可以提高程式可讀性，

2、變數作用域

變數根據作用域可劃分為三種：

類變數（靜態變數： static variable）：獨立于方法之外的變數，用 static 修飾，

實體變數（成員變數：member variable）：獨立于方法之外的變數，不過沒有 static 修飾，

區域變數（lacal variable）：類的方法中的變數，

1 public class Variable{

2 static int allClicks=0; // 類變數

3 String str="hello world"; // 實體變數

4

5 public void method(){

6 int i =0; // 區域變數

7 }

8 }

區域變數

方法或陳述句塊內部定義的變數，生命周期是從宣告位置開始到”}”為止，

在使用前必須先宣告和初始化(賦初值)，

區域變數沒有默認值，所以區域變數被宣告后，必須經過初始化，才可以使用，

1 public static void main(String[] args) {

2 int i;

3 int j = i+5 ; // 編譯出錯，變數i還未被初始化

4 System.out.println(j);

5 }

修改為：

1 public static void main(String[] args) {

2 int i=10;

3 int j = i+5 ;

4 System.out.println(j);

5 }

實體變數

方法外部、類的內部定義的變數，

從屬于物件，生命周期伴隨物件始終，

如果不自行初始化，他會自動初始化成該型別的默認初始值（數值型變數初始化成0或0.0，字符型變數的初始化值是16位的0，布爾型默認是false）

1 public class Test {

2 // 這個實體變數對子類可見

3 public String name;

4 // 私有變數，僅在該類可見

5 private double salary;

6 ...

7 }

靜態變數

使用static定義，

從屬于類，生命周期伴隨類始終，從類加載到卸載，(注：講完記憶體分析后我們再深入！先放一放這個概念！)

如果不自行初始化，他會自動初始化成該型別的默認初始值（數值型變數初始化成0或0.0，字符型變數的初始化值是16位的0，布爾型默認是false）

1 public class Employee {

2 //salary是靜態的私有變數

3 private static double salary;

4 // DEPARTMENT是一個常量

5 public static final String DEPARTMENT = "開發人員";

6 public static void main(String[] args){

7 salary = 10000;

8 System.out.println(DEPARTMENT+"平均工資:"+salary);

9 }

10 }

3、常量

常量(Constant)：初始化(initialize)后不能再改變值！不會變動的值，

所謂常量可以理解成一種特殊的變數，它的值被設定后，在程式運行程序中不允許被改變，

1 final 常量名=值;

2 final double PI=3.14; final String LOVE="hello";

常量名一般使用大寫字符，

程式中使用常量可以提高代碼的可維護性，例如，在專案開發時，我們需要指定用戶的性別，此時可以定義一個常量 SEX，賦值為 "男"，在需要指定用戶性別的地方直接呼叫此常量即可，避免了由于用戶的

不規范賦值導致程式出錯的情況，

4、變數的命名規范

1. 所有變數、方法、類名：見名知意

2. 類成員變數：首字母小寫和駝峰原則 : monthSalary

3. 區域變數：首字母小寫和駝峰原則

4. 常量：大寫字母和下劃線：MAX_VALUE

5. 類名：首字母大寫和駝峰原則: Man, GoodMan

6. 方法名：首字母小寫和駝峰原則: run(), runRun()

運算子

運算子operator

Java 語言支持如下運算子：

算術運算子: +，-，*，/，%，++，--

賦值運算子 =

關系運算子: >，<，>=，<=，==，!= instanceof

邏輯運算子: &&，||，!

位運算子: &，|，^，~ ， >>，<<，>>> (了解！！！)

條件運算子 ？：

擴展賦值運算子:+=，-=，*=，/=

1、二元運算子

兩個運算元，來看看我們小時候的數學運算；

1 public static void main(String[] args) {

2 int a = 10;

3 int b = 20;

4 int c = 25;

5 int d = 25;

6 System.out.println("a + b = " + (a + b) );

7 System.out.println("a - b = " + (a - b) );

8 System.out.println("a * b = " + (a * b) );

9 System.out.println("b / a = " + (b / a) );

10 }

整數運算

如果兩個運算元有一個為Long, 則結果也為long

沒有long時，結果為int，即使運算元全為shot,byte，結果也是int.

1 public static void main(String[] args) {

2 long a = 1231321311231231L;

3 int b = 1213;

4 short c = 10;

5 byte d = 8;

6

7 System.out.println((a+b+c+d)); //Long型別

8 System.out.println((b + c + d));//Int型別

9 System.out.println((c + d));//Int型別

10 }

浮點運算

如果兩個運算元有一個為double, 則結果為double.

只有兩個運算元都是?oat, 則結果才為?oat.

1 public static void main(String[] args) {

2 float a = 3.14565F;

3 double b = 3.194546464;

4 float c = 1.3123123F;

5

6 System.out.println(a+b); //double型別

7 System.out.println(b+c); //double型別

8 System.out.println(a+c); //float型別

9 }

關系運算子

回傳布林值！

2、取模運算

就是我們小學的取余； 5%3 余 2

其運算元可以為浮點數,一般使用整數，如：5.9%3.9=2.000000004

要點：

負數%負數＝負數；

負數%正數＝負數；

正數%負數＝正數；

1 public static void main(String[] args) {

2 System.out.println(9 % 4); //1

3 System.out.println(-9 % -4); //-1

4 System.out.println(-10 % 4); //-2

5 System.out.println(9 % -4); //1

6 }

【注：一般都是正整數運算，進行結果的判斷！】

3、一元運算子

自增（++）自減（--）運算子是一種特殊的算術運算子，在算術運算子中需要兩個運算元來進行運算，而自增自減運算子是一個運算元，分為前綴和后綴兩種，

1 public static void main(String[] args) {

2 int a = 3;

3 int b = a++; //執行完后,b=3，先給b賦值，再自增，

4 int c = ++a; //執行完后,c=5，先自增,再給b賦值

5 }

注意：java中的乘冪處理

1 public static void main(String[] args) {

2 int a = 3^2; //java中不能這么處理， ^是異或符號，

3 double b = Math.pow(3, 2);

4 }

Math類提供了很多科學和工程計算需要的方法和常數，特殊的運算都需要運用到方法!

4、邏輯運算子

邏輯與：&&和&，邏輯或：||和|，邏輯非：！，

【演示】

1 public static void main(String[] args) {

2 boolean a = true;

3 boolean b = false;

4 System.out.println("a && b = " + (a&&b));

5 System.out.println("a || b = " + (a||b) );

6 System.out.println("!(a && b) = " + !(a && b));

7 }

邏輯與和邏輯或采用短路的方式，從左到右計算，如果確定值則不會再計算下去，在兩個運算元都為true時，結果才為true，但是當得到第一個操作為false時，其結果就必定是false，這時候就不會再判斷

第二個操作了，

邏輯與只要有一個為false, 則直接回傳false.

邏輯或只要有一個為true, 則直接回傳true;

【演示】

1 public static void main(String[] args){

2 int a = 5;//定義一個變數；

3 boolean b = (a<4)&&(a++<10);

4 System.out.println("使用短路邏輯運算子的結果為"+b);

5 System.out.println("a的結果為"+a);

6 }

決議：

(&&) a<4 false b false

a++<10 a 5

5、位運算子

Java定義了位運算子，應用于整數型別(int)，長整型(long)，短整型(short)，字符型(char)，和位元組型(byte)等型別，位運算子作用在所有的位上，并且按位運算，

1 A = 0011 1100

2 B = 0000 1101

3 -----------------

4 A&b = 0000 1100

5 A | B = 0011 1101

6 A ^ B = 0011 0001

7 ~A= 1100 0011

右移一位相當于除2取商，

左移一位相當于乘2，

【常見面試題：int a=2*8怎樣運算效率最快？】

決議：

1 public static void main(String[] args) {

2 System.out.println(2 << 3);

3 }

用移位運算 int a=2<<3;

a就是2乘以8 最后結果是16 這是最省記憶體 最有效率的方法

這個方法確實高效率的，我來解釋一下：

2的二進制是10 在32位存盤器里面是0000 0000 0000 0010

左移三位后變成 0000 0000 0001 0000 也就是16

解釋一下，在系統中運算是以二進制的形式進行的，相比來說倆個二進制數相乘運算比移位運算慢一些，位操作是程式設計中對位模式按位或二進制數的一元和二元操作， 在許多古老的微處理器上， 位運算比

加減運算略快， 通常位運算比乘除法運算要快很多， 在現代架構中， 情況并非如此:位運算的運算速度通常與加法運算相同(仍然快于乘法運算). 詳細的需要了解計算機的組成原理！

6、擴展運算子

1 public static void main(String[] args) {

2 int a=10;

3 int b=20;

4

5 a+=b; // a = a + b

6

7 System.out.println(a+":"+b);

8 }

7、字串連接符

“+” 運算子兩側的運算元中只要有一個是字串(String)型別，系統會自動將另一個運算元轉換為字串然后再進行連接，

1 //字串

2 String s1="Hello 中文!";

3 String s2=1+""; //轉換成String

4 //int

5 int c = 12;

6 System.out.println("c=" + c);

8、三目條件運算子

三目條件運算子，語法格式：

1 x ? y : z

其中x為boolean型別運算式，先計算x的值，若為true，則整個三目運算的結果為運算式y的值，否則整個運算結果為運算式z的值，

【演示】

1 public static void main(String[] args) {

2 int score = 80;

3 String type = score < 60 ? "不及格" : "及格";

4 System.out.println("type= " + type);

5 }

三元運算子在真實開發中十分的常見，大家可以多練習使用，之后我們會講解分支陳述句，可以利用三元運算子做到更加精簡代碼！便于理解！

9、運算子優先級

我們小學都學過：先加減，后乘除，所以優先級我們并不陌生，

當多個運算子出現在一個運算式中，誰先誰后呢？這就涉及到運算子的優先級別的問題，在一個多運算子的運算式中，運算子優先級不同會導致最后得出的結果差別甚大，

下表中具有最高優先級的運算子在的表的最上面，最低優先級的在表的底部，

大家不需要去刻意的記住，運算式里面優先使用小括號來組織！！方便理解和使用，不建議寫非常冗余的代碼運算！

1 public static void main(String[] args) {

2 boolean flag = 1<4*5&&122>3||'q'+3<5;

3 System.out.println(flag);

4 }

包機制

1、問題發現

存在這樣一個問題：當定義了多個類的時候，可能會發生類名的重復問題，

解決方式：在java中采用包機制處理開發者定義的類名沖突問題，

就好比我們平時的用電腦，一個檔案夾下不能存在同名的檔案，我們要是有這樣的需求，但是又不想換名字，我們就可以考慮使用新建一個檔案夾來存放！在我們的Java中也是這樣的，

【演示：重名檔案】

還有一個問題：我們平時在IDE中可以跑的檔案，用命令列就會報錯；

【演示：HelloWorld！IDE和命令列】

這是為什么呢？

罪魁禍首正是代碼第一行：package com.kuang.demo01;

這就是Java中的包機制，使用package com.kuang.demo01;

就要求此份.java檔案必須保存在這樣一個目錄下，這樣Java解釋器才能找到它， 在IDEA中能正確運行，

你可以去Windows下的工程中查看，HelloWorld這個檔案必是在這樣的目錄結構下的，

2、包的作用

為了更好地組織類，Java 提供了包機制，用于區別類名的命名空間，

包的作用：

1、把功能相似或相關的類或介面組織在同一個包中，方便類的查找和使用，

2、如同檔案夾一樣，包也采用了樹形目錄的存盤方式，同一個包中的類名字是不同的，不同的包中的類的名字是可以相同的，當同時呼叫兩個不同包中相同類名的類時，應該加上包名加以區別，因此，包可

以避免名字沖突，

3、包也限定了訪問權限，擁有包訪問權限的類才能訪問某個包中的類，Java 使用包（package）這種機制是為了防止命名沖突，訪問控制，提供搜索和定位類（class）、介面、列舉（enumerations）和注釋

（annotation）等，

包陳述句的語法格式為：

1 package pkg1[．pkg2[．pkg3…]];

例如,一個Something.java 檔案它的內容:

1 package net.java.util;

2 public class Something{

3 ...

4 }

那么它的路徑應該是 net/java/util/Something.java 這樣保存的， package(包) 的作用是把不同的java 程式分類保存，更方便的被其他 java 程式呼叫，

一個包（package）可以定義為一組相互聯系的型別（類、介面、列舉和注釋），為這些型別提供訪問保護和命名空間管理的功能，

以下是一些 Java 中的包：

java.lang-打包基礎的類

java.io-包含輸入輸出功能的函式

開發者可以自己把一組類和介面等打包，并定義自己的包，而且在實際開發中這樣做是值得提倡的，當你自己完成類的實作之后，將相關的類分組，可以讓其他的編程者更容易地確定哪些類、介面、列舉和

注釋等是相關的，由于包創建了新的命名空間（namespace），所以不會跟其他包中的任何名字產生命名沖突，使用包這種機制，更容易實作訪問控制，并且讓定位相關類更加簡單，

3、創建包

創建包的時候，你需要為這個包取一個合適的名字，之后，如果其他的一個源檔案包含了這個包提供的類、介面、列舉或者注釋型別的時候，都必須將這個包的宣告放在這個源檔案的開頭，

包宣告應該在源檔案的第一行，每個源檔案只能有一個包宣告，這個檔案中的每個型別都應用于它，如果一個源檔案中沒有使用包宣告，那么其中的類，函式，列舉，注釋等將被放在一個無名的包

（unnamed package）中，一般利用公司域名倒置作為報名；

例子：

www.baidu.com 包名：com.baidu.www

bbs.baidu.com 包名：com.baidu.bbs

blog.baidu.com 包名：com.baidu.blog

我們平時也可以按照自己的公司域名去寫，比如：com.kuangstudy.utils

4、import 關鍵字

為了能夠使用某一個包的成員，我們需要在 Java 程式中明確匯入該包，使用 "import" 陳述句可完成此功能，

在 java 源檔案中 import 陳述句應位于 package 陳述句之后，所有類的定義之前，可以沒有，也可以有多

條，其語法格式為：

1 import package1[.package2…].(classname|*);

如果在一個包中，一個類想要使用本包中的另一個類，那么該包名可以省略，要是要用到其他包下的類，就必須要先導包！

如果兩個類重名，需要匯入對應的包，否則就需要寫出完整地址：

1 com.kuang.dao.Hello hello = new com.kuang.dao.Hello()

用 import 關鍵字引入，使用通配符 "*" , 匯入io包下的所有類！

1 import java.io.*;

【不建議這樣使用，因為會全域掃描，影響速度！】

使用 import 關鍵字引入指定類:

1 import com.kuang.Hello;

【注意】類檔案中可以包含任意數量的 import 宣告，import 宣告必須在包宣告之后，類宣告之前，

【編碼規范：推薦參考阿里巴巴開發手冊編程規范】

下載地址：阿里巴巴開發手冊

JavaDoc

1、簡介

JavaDoc是一種將注釋生成HTML檔案的技術，生成的HTML檔案類似于Java的API，易讀且清晰明了，在簡略介紹JavaDoc寫法之后，再看一下在Intellij Idea 中如何將代碼中的注釋生成HTML檔案，

javadoc是Sun公司提供的一個技術，它從程式源代碼中抽取類、方法、成員等注釋形成一個和源代碼配套的API幫助檔案，也就是說，只要在撰寫程式時以一套特定的標簽作注釋，在程式撰寫完成后，通過

Javadoc就可以同時形成程式的開發檔案了，javadoc命令是用來生成自己API檔案的，使用方式：使用命令列在目標檔案所在目錄輸入javadoc +檔案名.java，

先看一段樣例代碼：

1 /** 這是一個Javadoc測驗程式

2 * @author Kuangshen

3 * @version 1.0

4 * @since 1.5

5 * */

6 public class HelloWorld {

7

8 public String name;

9 /**

10 * @param name 姓名

11 * @return 回傳name姓名

12 * @throws Exception 無例外拋出

13 * */

14 public String function(String name) throws Exception{

15 return name;

16 }

17 }

稍微解釋一下：

以 /* / 結束，

@author 作者名

@version 版本號

@since 指明需要最早使用的jdk版本

@param 引數名

@return 回傳值情況

@throws 例外拋出情況

2、命令列生成Doc

1 -encoding UTF-8 -charset UTF-8

2 //解決GBK亂碼問題，在中間添加編碼設定

【演示：生成并查看檔案】

回顧及總結

這一章，我們學習了Java的基礎

安裝使用了IDEA

使用注釋

了解了Java的關鍵字

資料型別

怎么定義一個變數