2. 基礎語法

1. 註釋

1、java中註釋分為三種：註釋不會被編譯成位元組碼檔案

(1)、單行註釋：   //   只能註釋一行程式碼。如：//類成員變數

(2)、多行註釋：  /*註釋內容*/ 可註釋多行程式碼，其中不允許出現巢狀。

(3)、文件註釋： /**  */   使用文件註釋，當匯出doc檔案的時候會一起匯出來

建議：宣告多個相同型別變數時要分行宣告，有利於提高程式碼。

2、如何將專案中的介面方法匯出？

   右擊選擇export--》javadoc-->finish

3、註釋

   註釋就是程式設計師為讀者作的說明，是提高程式可讀性的一種手段

(1)、在Java中，有2種表示註釋的方法

   // 單行註釋----註釋內容從//到本行結尾

   /*

  單行或多行註釋

   */

   /* */註釋不能巢狀

(2)、Java中的註釋不會出現在位元組碼檔案中。即JAVA編譯器編譯時會跳過註釋語句。

public class Welcome {

   //我是單行註釋

   public static void main(String[] args/*我是行內註釋 */) {

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

   }

   /*

      我是多行註釋！

      我是多行註釋！

    */

}  
 

A=65    a=97    0=48    空格=32

2. 識別符號

1、識別符號：給變數，常量，方法，類和包起的名稱

2、需要遵循的規範：（必須遵守）

(1)、首字母必須是字母，下劃線，或者$   如：Man, GoodMan

(2)、其餘部分可以是字母，下劃線，$或者數字

(3)、java嚴格區分大小寫，並且長度無限制

(4)、表示方法和變數的識別符號用小寫字母開始，後面的描述性詞以大寫開始。eat(),eatFood()

(5)、禁止使用java中的保留字（關鍵字）

(6)、可以使用漢字命名，但是不建議

(7)、需要遵守的準則：不遵守程式不會報錯，但是不規範（道德約束）

(8)、駝峰標識：一個名稱由多個單片語成，每個組成的單詞必須首字母大寫，其餘部分小寫（給方法，變數起名字的時候第一個字母也小寫）

(9)、見名知意：看到名稱即知道是什麼意思

3、JAVA不採用通常語言使用的ASCII字符集，而是採用unicode這樣的標準的國際字符集。因此，這裡的字母的含義：英文、漢字等等。(不建議大家使用漢字來定義識別符號！)，ascll佔用1個位元組，佔8位，一共128個字元，記住48‘0’，65‘A’,97 'a'

4、各種字符集的關係？

(1)、合法的識別符號：

int a = 3;

int _123 = 3;

int $12aa = 3;

int 變數1 = 55;

(2)、不合法的識別符號：

int 1a = 3;   //不能用數字開頭

int a# = 3;   //不能包含#這樣的特殊字元

int int = 3;  //不能使用關鍵字

3. 關鍵字/保留字

關鍵字/保留字

Java關鍵字是Java語言保留供內部使用的,如class用於定義類。 關鍵字也可以稱為保留字,它們的意思是一樣的。

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

abstract	Assert	boolean	break	byte	case
catch	char	class	const	continue	default
do	Double	else	extends	final	finally
float	For	goto	if	implements	import
instanceof	Int	interface	long	native	new
null	Package	private	protected	public	return
short	Static	strictfp	super	switch	synchronized
this	Throw	throws	transient	try	void
volatile	While

4. 變數和常量

1、變數(variable)

在程式執行過程中，值發生變化，我們通過變數來操縱儲存空間中的資料，變數就是指代這個儲存空間！空間位置是確定的，但是裡面放置什麼值不確定！

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

(1)、Java變數是程式中最基本的儲存單元，其要素包括變數名，變數型別和作用域。

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

(3)、type  varName  [=value] [{,varName[=value]}] ；

(4)、注意事項：

(5)、每個變數都有型別，型別可以是基本型別，也可以是引用型別。

(6)、變數名必須是合法的識別符號。

3、變數如何定義？

宣告加賦值或者先宣告，後賦值。變數宣告是一條完整的語句，因此每一個宣告都必須以分號結束。

（1）變數宣告舉例：

double salary ；          boolean done；

long earthPopulation ；   int age ；

（2）可以在一行中宣告多個變數：

int i ,j; // both are integers

不提倡這種風格，逐一宣告每一個變數可以提高程式可讀性。

（3）可以將變數的宣告和初始化放在同一行中，例如：

int age = 18;    float e = 2.718281828f;

4、變數可劃分為：

（1）區域性變數(lacal  variable)：定義在方法內的變數，作用域：宣告位置開始到整個方法結束

區域性變數在定義的時候必須賦初值，不賦初始值會報錯，該方法呼叫結束後，則會釋放方法中的區域性變數佔用的記憶體空間，即銷燬。

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

      public void incorrectLocalV() {

         int i;

         i=10;

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

      }  

（2）成員變數（member variable）：方法外部、類的內部定義的變數。作用域：整個類體有效，從屬於物件，生命週期伴隨物件始終。成員變數又可以分為靜態變數（static int  i=5）和例項變數(int k=6)；

成員變數在定義的時候可以不賦初值，，他會自動初始化成該型別的預設初始值（數值型變數初始化成0或0.0，字元型變數的初始化值是16位的0，布林型預設是false）。

（3）靜態變數（類變數 static variable）：使用static定義。 作用域：有效範圍可以跨類，從屬於類，生命週期伴隨類始終，從類載入到解除安裝。 除了能在定義它的類記憶體中取值，還可以直接以“類名.靜態變數”的方式在其他類內使用。

注：區域性變數與靜態變數名字相同時，此時成員變數將被隱藏。即這個靜態變數在此方法中暫時失效。如果想呼叫成員變數，需要使用“類名.靜態變數”

練習1：

public class LocalVariableTest {

   public static void main(String[ ] arg) {

      boolean flag = true;  // 宣告boolean型變數並賦值

      char c1, c2;   // 宣告char型變數

      c1 = '\u0041';   // 為char型變數賦值

      c2 = 'B';   // 為char型變數賦值

      int x;   // 宣告int型變數

      x = 9;  //為int型變數賦值 

      int y = x;  // 宣告並初始化int型變數

      float f = 3.15f;   // 宣告float型變數並賦值

      double d = 3.1415926;  //宣告double型變數並賦值

   }

}

5、常量(Constant)：

（1）初始化(initialize)後不能再改變值！

（2）在程式執行過程中，值不會發生變化的量，只進行一次賦值，叫做常量

（3）常量一般使用final進行修飾，值被物件共享

補充：在進行常量宣告定義的時候，一般取名全部大寫並且用 _  隔開，但是是不必須的，只是為了讓符合命名規範。如果常量屬於成員變數，必須在定義時並賦初值。

public class Constants {

   public static void main(String[] args) {

      final double PI = 3.14;

      // PI = 3.15;    //error

      double r = 4;

      double area = PI * r * r;

      double circle = 2 * PI * r;

      System.out.println("area = " + area);

      System.out.println("circle = " + circle);

   }

}

6、命名規則(規範)

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

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

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

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

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

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

7、變數記憶體分析

（1）定義成員變數

   int count = 10;

   //在方法執行的時候，會先從棧中找變數，如果棧中沒有對應的值，則再從堆中尋找變數值

   public void show(int count){

      //就近原則：距離誰近，就輸出誰

      System.out.println(count);

      count = 100;

      System.out.println(count);

      System.out.println(this.count);

   } 

   public void show2(){   

      System.out.println(count);

      int count = 20;

      System.out.println(count);

   } 

   public static void main(String[] args) {

      VariableDemo vd = new VariableDemo();

      vd.show(50);//50-->100-->10

      vd.show2();//10-->20

     }

（2） Point p1 = new Point();

      p1.x = 3;

      p1.y = 4;

      // 設定x,y的座標

      // p1.setX(5);

      // p1.setY(6);

      Point p2 = new Point(6, 8);

      p1.show();

      p2.show();

      System.out.println(p1.calaDistance(p2.x, p2.y));

      System.out.println(p1.calaDistance(p2));

      p1.swap(p1.x, p1.y);

      p1.show();

      p1.swap();

      p1.show();

   （3）// 建立物件

      Adminstrator admin1 = new Adminstrator();

      // 給物件賦值

      admin1.username = "admin1";

      admin1.password = "111111";

      Adminstrator admin2 = new Adminstrator();

      admin2.username = "admin2";

      admin2.password = "222222";

      admin1.show();

      admin2.show();

      System.out.println(admin1.toString());

       System.out.println(admin2);

使用者名稱是：admin1，密碼：111111

使用者名稱是：admin2，密碼：222222

[email protected]

[email protected]

5. 基本資料型別

1、基本資料型別(primitive  data  type)

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

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

（3）Java中定義了4類8種基本資料型別

邏輯型－boolean   文字型－ char

數值型－ byte,  short,  int,  long, float,  double

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

2、整型變數

（1）整型用於表示沒有小數部分的數值，它允許是負數。

（2）整型的範圍與執行Java程式碼的機器無關，這正是Java程式具有很強移植能力的原因之一。

（3）型別    佔用儲存空間      表數範圍    

Byte       1位元組             -128~127       

Short     2位元組             -215 ~ 215-1 （-32768~32767）

Int         4位元組             -231 ~ 231-1 (2147483648~2147483647) 約21億    

Long       8位元組             -263 ~ 263-1

（4）Java 語言整型常數的三種表示形式：

      十進位制整數，0-9 如：99, -500, 0。

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

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

      正常情況下，使用十進位制表示一個數，但是在計算機中，還可以使用其他進製表示數

3、進位制之間的轉換

(1)、十進位制轉二進位制：將十進位制數依次除以2，並保留餘數，當除完為0的時候，將餘數逆序輸出即為二進位制的表示

(2)、二進位制轉十進位制：將二進位制的每位依次乘以對應位數的次冪，然後想加即為十進位制數

(3)、十進位制轉十六進位制：將十進位制數依次除以16，並保留餘數，當除完為0的時候，將餘數逆序輸出

將十進位制首先轉為二進位制數，從右向左，四位組成一組，每組轉成一個16進位制數即可

(4)、十六進位制十進位制：將十六進位制的每位依次乘以對應位數的次冪，然後想加即為十進位制數

(5)、將十六進位制轉為二進位制：每一位十六進位制數換為4位二進位制表示即可

(6)、將二進位制轉為十六進位制：將4位二進位制陣列成一組，轉成十六進位制即可

4、Java語言的整型常數預設為int型，宣告long型常量可以後加‘ l ’或‘ L ’ ，如：

long a = 55555555;  //不出錯，在Int表示的範圍內(21億內)。

long b = 55555555555;//不加l出錯，已經超過int表示的範圍。報錯：

5、Java中沒有無符號型別，浮點型

      型別            佔用儲存空間          表數範圍     

      Float             4位元組              -3.403E38~3.403E38      

      Double           8位元組             -1.798E308~1.798E308     

（1）float型別又被稱作單精度型別，尾數可以精確到7位有效數字，在很多情況下，float型別的精度很難滿足需求。

（2）double表示這種型別的數值精度是float型別的兩倍，又被稱作雙精度，絕大部分應用程式都採用double型別。

（3）Java 浮點型別常量有兩種表示形式

十進位制數形式，例如:3.14       314.0      0.314

科學記數法形式，如：314e2      314E2      314E-2

double f = 314e2;  //314*10^2-->31400.0

double f2 = 314e-2; //314*10^(-2)-->3.14

（4）Float型別的數值有一個字尾F/f ，沒有後綴F/f的浮點數值預設為double型別。也可以在浮點數值後新增字尾D/d, 以明確其為double型別：

（5）浮點型別float, double的資料不適合在不容許舍入誤差的金融計算領域。如果需要進行不產生舍入誤差的精確數字計算，需要使用BigDecimal類。

主要理由：由於字長有限，浮點數能夠精確表示的數是有限的，因而也是離散的。浮點數一般都存在舍入誤差，很多數字無法精確表示(例如0.1)，其結果只能是接近，但不等於。

（6）二進位制浮點數不能精確的表示0.1,0.01,0.001這樣10的負次冪。並不是所有的小數都能可以精確的用二進位制浮點數表示。

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

（7）大數值：

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

（8）浮點數使用總結：

預設是double

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

避免比較中使用浮點數     

6、字元型（2個位元組）

（1）單引號用來表示字元常量。例如‘A’是一個字元，它與“A”是不同的，“A”表示含有一個字元的字串。

（2）char 型別用來表示在Unicode編碼表中的字元。

（3）Unicode編碼被設計用來處理各種語言的所有文字，它佔2個位元組，可允許有65536個字元；ASCII碼佔1個位元組，可允許有128個字元，是Unicode編碼表中前128個字元。

char eChar = 'a';

char cChar ='中';

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

         char c = ‘\u0061;

（5）Java 語言中還允許使用轉義字元 ‘\’ 來將其後的字元轉變為其它的含義，

         char c2 = '\n';  //代表換行符

（6）轉義符   含義    Unicode值       

\b        退格（backspace）   \u0008       

\n        換行                     \u000a       

\r         回車                     \u000d       

\t         製表符（tab）           \u0009       

\“ 雙引號            \u0022       

\‘ 單引號            \u0027       

\\         反斜槓            \u005c    

注：以後我們學的String類，其實是字元序列(char sequence)。

5、boolean型別（一位，不是一個位元組）：

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

（2）boolean 型別用來判斷邏輯條件，一般用於程式流程控制 。

      boolean flag ;

      flag = ………;

   if(flag) {

      // true分支

       } else {

     //  false分支

}

（3）實踐：Less is More！！請不要這樣寫：if ( is == true && done == false ) ，只有新手才那麼寫。對於任何程式設計師 if ( whether && !done ) 都不難理解吧。所以去掉所有的==fasle 和 ==true。

6. 運算子

1、運算子(operator)

 Java 語言支援如下運算子：

（1）算術運算子:  +，-，*，/，%，++，--

（2）賦值運算子 =

（3）關係運算符:  >，<，>=，<=，==，!=  instanceof

（4）邏輯運算子:  &&，||，!

（5）位運算子:  &，|，^，~ ， >>，<<，>>> (瞭解！！！)

（6）條件運算子 ？：

（7）擴充套件賦值運算子:+=，-=，*=，/=

2、一元運算子(++, --)

      int a = 3;

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

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

注意：java中的乘冪處理：

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

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

單目運算子，表示自增1或者自減1，誰在前，就先運算誰；

3、二元運算子

（1）整數運算：

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

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

（2）浮點運算：

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

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

（3）取模運算：

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

（4）要點：

負數%負數＝負數；

負數%正數＝負數；

正數%負數＝正數；

注：一般都是正整數運算，不用考慮這麼細！

4、布林邏輯表達符

（1）邏輯與：&&和&，邏輯或：||和|，邏輯非：！。

（2）邏輯與和邏輯或採用短路的方式。從左到右計算，如果確定值則不會再計算下去。

（3）邏輯與只要有一個為false, 則直接返回false.

（4）邏輯或只要有一個為true, 則直接返回true;

注：!取反；&& 短路與：當表示式左邊為false的時候，不需要關心右邊是什麼結果；|| 短路或：當表示式左邊為true的時候，不需要關心右邊是什麼結果；建議使用短路與短路或

boolean c = 1>2&&2>(3/0);

5、位運算子

當進行位運算的時候，需要把數轉為對應的二進位制

（1）~  -- 取反             &   -- 按位與        

（2）|  -- 按位或            ^   -- 按位異或  

（3）<<：左移運算子，            >>：右移運算子 >>>：無符號移位運算子

（4）按位與 &（兩個運算元都為1才為1，否則為0）

（5）按位或 |  （兩個運算元都為0才為0，否則為1）

（6）按位非~  （二進位制數中有1全部改為0，0全部改為1）                   

（7）按位異或^（兩個運算元相異為1，相同為0）

（8）<<左移：左移一位相當於乘2。

（9）>> 右移：右移一位相當於除2取商。（說明，最高位是0，左移空的位就填入0，如果最高位是1，左移空的位就填入1）

 （10）>>>無符號右移（不管最高位是0還是1，最高位都填入0）

           int a = 3*2*2;

           int b = 3<<2;  //相當於：3*2*2;  數 <<移動幾位

           int a = 12/2/2;

           int b = 12>>2;

6、擴充套件運算子

運算子            用法舉例        等效的表示式    

+=                     a += b            a = a+b   

-=                      a -= b             a = a-b     

*=                     a *= b              a = a*b    

/=                      a /= b              a = a/b     

%=                   a %= b             a = a%b       

7、字串連線符

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

           int c = 12;

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

8、三目條件運算子

 （1）三目條件運算子，語法格式：x ? y : z

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

舉例：

      int score = 80; int x = -100;

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

      int flag = x > 0 ? 1 : (x == 0 ? 0 : -1);

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

      System.out.println("flag= "+ flag);

9、運算子符優先順序：增量和減量運算 > 算數運算 > 比較運算 > 邏輯運算 > 賦值運算（簡記：自算比邏賦）

10、自動型別轉換：

（1）自動型別轉換：容量小的資料型別可以自動轉換為容量大的資料型別。在圖中，黑色的實線表示無資料丟失的自動型別轉換，而紅色的虛線表示在轉換時可能會精度的損失。

（2）特例: 可以將整型常量直接賦值給byte, short, char等型別變數，而不需要進行強制型別轉換，只要不超出其表數範圍。

Short  b = 12;        //合法

short  b = 1234567;       //非法

 short sh = 1;   sh = sh + 1;  //報錯：在進行運算的時候會進行型別轉換，運算完成的數值是int型，無法直接賦值給short；如果是 sh+=1,正常執行。

（3）強制型別轉換（Cast）： 強制型別轉換，又被稱為造型，用於顯式的轉換一個數值的型別. 在有可能丟失資訊的情況下進行的轉換是通過造型來完成的，但可能造成精度降低或溢位。

（4）強制型別轉換的語法格式：“(type)var”，運算子“()”中的type表示將值var想要轉換成的目標資料型別。

    例如：double x  = 3.14；

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

      char c = 'a';

      int d = c+1;

      System.out.println(d);

      System.out.println((char)d);

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

     例如： int x = 300;

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

（6）不能在布林型別和任何數值型別之間做強制型別轉換。

11、基本型別轉化時常見錯誤和問題

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

      int money = 1000000000;  //10億

      int years = 20;

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

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

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

（2）L和l 的問題：不要命名名字為l的變數，long型別使用大寫L不要用小寫。

      int l = 2;

      long a = 23451l;

      System.out.println(l+1);     

12、注意：

（1）在java中，除法是整除； %取模運算，取餘數；

（2）關係運算符 > < >= <= != ==  ，返回的型別是boolean，用於做邏輯判斷

相關推薦