java語法

1. java語句/語法解釋

1 我所接觸過的編程語言，基本都可以把字元串作為參數傳入吧？（或者是字元數組），其實就是傳值
2 這里"156".xxx屬於特殊寫法，java虛擬機會自動給一個獨立字元串new一個String對象，然後實際上是類似於 String abc = new String("156"); abc.xxx，相當於這兩步

2. java基礎語法都有哪些

數據類型
語法結構:順序 分支 循環
面向對象
數組 集合 異常 API

3. java語法基礎,具體內容

Java基礎——Java開發前奏

Java的特點

Java最主要的特點是：一次編譯，到處運行（WriteOnce,RunAnywhere.）。

原理：Java源程序經編譯後生成.class位元組碼文件，.class文件由Java虛擬機（JVM）解釋執行。不同的操作系統下，只要有相應的Java位元組碼解釋程序，.class文件就能夠運行，這是Java跨平台性的根本。c和java編程與執行的過程如下圖所示：

Java的內涵

1、是一種編程語言

2、是一套開發工具

3、是一個運行環境

Java應用平台

1、J2EE（）——用於企業級應用程序的開發

2、J2SE（Java2PlatformStandardEdition）——用於普通標准應用程序的開發

3、J2ME（Java2PlatformMicroEdition）——用於小型消費類電子產品或嵌入式系統的開發

J2SE包括4部分——JVM、JRE、JDK與Java語言。

環境變數的設置

環境變數——在操作系統中定義的變數，可供操作系統上所有的應用程序使用。

1、查看環境變數

a.命令提示行：環境變數的命令——set（環境變數名）

b.窗口方式：我的電腦->屬性->高級->環境變數

2、設置path環境變數

path環境變數的作用：設置操作系統尋找和執行應用程序的路徑。

JAVA_HOME：C:ProgramFilesJavajdk1.6.0_14

path：%JAVA_HOME%in;%JAVA_HOME%jrein

3、設置classpath環境變數

classpath環境變數的作用：讓Java執行環境找到指定的java程序（.class文件）。

classpath：.;%JAVA_HOME%libdt.jar;%JAVA_HOME%lib ools.jar

注意：a.%JAVA_HOME%前面有「.;」，「.」表示當前目錄，兩個路徑之間用「;」隔開。

b.設置classpath的路徑中不能有空格，也不能有中文字元。

JVM的運行過程

Java反編譯工具——JAD、FrontEnd

Java開發工具

1、記事本

注意保存時文件名應為*.java。

2、UltraEdit、EditPlus

使用EditPlus編輯和編譯Java程序，需要進行相應配置。選擇「工具」->「參數選擇」->「工具」->「用戶工具」->「添加工具」->「應用程序」。首先設置「javac」的參數，具體如下圖，其中「命令」為javac.exe文件的地址。

然後設置「java」的參數，如下圖所示，其中「命令」為java.exe文件的路徑。

設置好後默認「javac」工具的快捷鍵為Ctrl+1，「java」工具的快捷鍵為Ctrl+2。當編輯好Java源程序後，使用Ctrl+1即可對其進行編譯，然後按Ctrl+2運行程序。如下圖所示：

3、集成開發環境——Eclipse、MyEclipse、JBuilder等。

關於Eclipse和MyEclipse，剛用的時候感覺二者差不多，查了資料才知道Eclipse是基礎，如同操作系統；而MyEclipse是在Eclipse上面運行的程序，不過進行了增強並提供了新功能。

以前用過Microsoft的VisualStudio2005，個人感覺VS2005是一個功能非常強大的集成開發環境，不過.NET和Java畢竟不是一家人，學Java還是要用Eclipse的。

JDK中的常用包

1、java.lang——包含一些Java語言的核心類，如String、Math、Thread、System、Integer類等。

2、java.awt——包含構成抽象窗口工具集的多個類，用來構建和管理應用程序的圖形用戶界面（GUI）。

3、java.applet——包含applet運行所需的一些類。

4、java.net——包含執行與網路相關操作的類。

5、java.io——包含能提供多種輸入/輸出功能的類。

6、java.util——包含一些實用工具類。

Java的命名習慣

1、包名中的字母一律小寫。如：xxxyyyzzz。

2、類名、介面名應使用名詞，每個單詞的首字母大寫。如：XxxYyyZzz。

3、方法名，第一個單詞小寫，後面每個單詞的首字母大寫。如：xxxYyyZzz。

4、變數名，第一個單詞小寫，後面每個單詞的首字母大寫。

5、常量名中的每個字母一律大寫。如：XXXYYYZZZ。

Java基礎——Java語法基礎（1）

Java代碼基本格式

Java中所有程序代碼都必須存在於一個類中，用class關鍵字定義類，在class之前可以有一些修飾符。格式如下：

修飾符class類名

{

程序代碼

}

註：

1、Java是嚴格區分大小寫的。

2、Java程序中一句連續的字元串不能分開在兩行中寫。

Java程序的注釋

Java里的注釋有三種類型：

1、單行注釋

在注釋內容前面加「//」，格式為：

代碼;//注釋內容

2、多行注釋

以斜杠加星號開頭，以星號加斜杠結尾。

3、文檔注釋

以斜杠加兩個星號開頭，以一個星號加斜杠結束。

用這種方法注釋的內容會被解釋成程序的正式文檔，並能包含進諸如javadoc之類的工具程序生成的文檔里，用以說明該程序的層次結構及其方法。

補充：

1、多行注釋中可以嵌套「//」注釋，但不能嵌套多行注釋符號。

2、程序注釋一般占程序代碼總量的20%-50%，「可讀性第一，效率第二」。

Java中的標識符

Java中的包、類、方法、參數、變數的名字，可以由任意順序的大小寫字母、數字、下劃線（_）、美元符號（$）組成，但不能以數字開頭，不能是Java中的保留關鍵字。

Java的關鍵字

1、用於類和介面的聲明：class,extends,implements,interface

2、包引入和包聲明：import,package

3、數據類型：byte,boolean,char,double,int,long,float,short

4、某些數據類型的可選值：flase,ture,null

5、流程式控制制：break,case,continue,default,do,else,for,if,return,switch,while

6、異常處理：catch,finally,throw,throws,try

7、修飾符：abstract,final,native,private,protected,public,static,synchronilzed,transient,volatitle

8、操作符：instanceof

9、創建對象:new

10、引用：this,supper

11、方法返回類型：void

12、保留字：const,goto

Java中的常量

1、整形常量

十進制

十六進制——以0x或0X開頭

八進制——以0開頭

長整形——以L(l)結尾

2、浮點數常量

單精度浮點數——後面加f(F)

雙精度浮點數——後面加d(D)

註：

a.小數常量的默認類型是double型，所以float類型常量後一定要加f(F)。

b.浮點數常量可以用指數形式表示，如5.022e+23f

3、布爾常量

true或false

4、字元常量

由英文字母、數字、轉義序列、特殊字元等的字元所表示，如'a'、' '等。

Java中的字元占兩個位元組，是用Unicode碼表示的，也可以使用'u'加Unicode碼值來表示對應字元，如'u0027'。

常用的轉義字元有：

——表示接受鍵盤輸入，相當於按了一下回車鍵

——表示換行

——表示製表符，相當於Tab鍵

——表示退格鍵，相當於BackSpace鍵

'——表示單引號

」——表示雙引號

\——表示反斜杠「」

5、字元串常量

字元串常量用雙引號括起來。

6、null常量

null常量表示對象的引用為空。

Java的變數類型

基本數據類型之間的轉換

1、自動類型轉換（隱式類型轉換）

條件：

a.兩種類型彼此兼容

b.目標類型的取值范圍要大於源類型

2、強制類型轉換（顯示類型轉換）

格式：目標類型常量=（目標類型）值

註：字元串可以使用加號「+」同其他的數據類型相連而形成一個新的字元串。

變數的作用域

代碼塊決定了變數的作用域，作用域決定了變數的可見性和存在時間。

局部變數

在一個函數或函數裡面的代碼塊中定義的變數稱為局部變數。

局部變數在進行取值操作前必須被初始化或進行過賦值操作。

函數

1、定義函數的格式

返回值類型函數名（參數類型形式參數1，參數類型形式參數2，...）

{

程序代碼

return返回值;

}

2、函數的重載

函數的重載就是在一個類中可以同時存在一個以上的同名函數，只要它們的參數個數或類型不同即可。

Java基礎——Java語法基礎（2）——運算符

Java中的運算符

1、算術運算符

a.字元串+其他類型=字元串

b.如果對負數求余，可以把除數負號忽略不計，如5%-1=1。但如果被除數是負數就另當別論了。

2、賦值運算符

a.在Java中，可以把賦值語句連在一起，如：x=y=z=5;

b.x+=y相當於x=x+y

3、比較運算符

a.要注意比較運算符「==」和賦值運算符「=」的區別，特別是布爾型變數進行比較時。

b.可以將比較運算的表達式寫為「false==變數」的形式，以防止誤寫為賦值運算。

4、邏輯運算符

a.邏輯運算符用於對boolean型結果的表達式進行運算，運算的結果都是boolean型。

b.「&」和「&&」的區別在於，如果使用前者連接，那麼無論任何情況，「&」兩邊的表達式都會參與計算。如果使用後者連接，當「&&」的左邊為false，則將不會計算其右邊的表達式。「|」和「||」的區別與「&」和「&&」的區別一樣。

5、位運算符

位運算——對數據按二進制位進行移位操作。

適用類型：byte,short,char,int,long

位運算包括：

&位與

|位或

^位異或

<<左移，左移n位相當於乘以2的n次方

>>右移，右移n位相當於除以2的n次方

>>>無符號右移

註：

a.位運算符也可以與「=」賦值運算符組合產生新的賦值運算符，如：&=,<<=等。

b.移位不會改變變數本身的值，如a>>1在一行語句中單獨存在毫無意義。

c.對低於int型的操作數將先自動轉換為int型再移位；對int型整數移位a>>b，系統先將b對32取模，得到的結果才是真正移位的位數；對於long型整數移位時則是先將移位位數對64取模。

運算符的優先順序

編程技巧：

1、不要在一行中編寫太復雜的表達式，可以將其分解為幾條語句。

2、多用括弧。

Java基礎——Java語法基礎（3）

程序控制流程

1、順序結構

按順序執行

2、if條件語句

a.if...

b.if...else...

可簡寫為：變數=布爾表達式?語句1:語句2;

c.if...elseif...else...

3、switch選擇語句

switch(表達式)

{

case取值1:

語句塊1;

break;

...

case取值n:

語句塊n;

break;

default:

語句塊n+1;

break;

}

4、while循環語句

while(條件表達式)

{

執行語句

}

5、dowhile循環語句

do

{

執行語句

}while(條件表達式)

6、for循環語句

for(初始化表達式;循環條件表達式;循環後操作表達式)

{

執行語句

}

7、增強for循環

for(循環變數類型循環變數名稱:要被遍歷的對象)

{

執行語句

}

8、break與continue語句

a.一個無標號的break語句會把控制傳回當前最內層循環（while,do,for,switch）的下一條語句。

b.無標號的continue語句的作用是跳過當前循環的剩餘語句塊，接著執行下一次循環。

數組

1、數組的定義

如：int[]x=newint[100];

或intx[]=newint[100];

2、數組的靜態初始化

如：int[]aa=newint[]{3,4,5};

3、多維數據

如：

int[][]xx=newint[3][];

xx[0]=newint[3];

xx[1]=newint[2];

4、一些與數組相關的函數

a.System.array(Objectsrc,intsrcPos,Objectdest,intdestPos,intlength)復制數組，將源數組srcPos開始的length個元素從目標數組的destPos位置開始存儲。

b.Array.sort()數組升序排序

4. java裡面<>的語法

這是JDK5的新特性，叫泛型，看看JDK5的文檔吧

泛型（Generic type 或者generics）是對 Java 語言的類型系統的一種擴展，以支持創建可以按類型進行參數化的類。可以把類型參數看作是使用參數化類型時指定的類型的一個佔位符，就像方法的形式參數是運行時傳遞的值的佔位符一樣。
可以在集合框架（Collection framework）中看到泛型的動機。例如，Map類允許您向一個Map添加任意類的對象，即使最常見的情況是在給定映射（map）中保存某個特定類型（比如String）的對象。
因為Map.get()被定義為返回Object，所以一般必須將Map.get()的結果強制類型轉換為期望的類型，如下面的代碼所示：

Map m = new HashMap();

m.put("key", "blarg");

String s = (String) m.get("key");

要讓程序通過編譯，必須將get()的結果強制類型轉換為String，並且希望結果真的是一個String。但是有可能某人已經在該映射中保存了不是String的東西，這樣的話，上面的代碼將會拋出ClassCastException。
理想情況下，您可能會得出這樣一個觀點，即m是一個Map，它將String鍵映射到String值。這可以讓您消除代碼中的強制類型轉換，同時獲得一個附加的類型檢查層，該檢查層可以防止有人將錯誤類型的鍵或值保存在集合中。這就是泛型所做的工作。
泛型的好處
Java 語言中引入泛型是一個較大的功能增強。不僅語言、類型系統和編譯器有了較大的變化，以支持泛型，而且類庫也進行了大翻修，所以許多重要的類，比如集合框架，都已經成為泛型化的了。這帶來了很多好處：
· 類型安全。泛型的主要目標是提高 Java 程序的類型安全。通過知道使用泛型定義的變數的類型限制，編譯器可以在一個高得多的程度上驗證類型假設。沒有泛型，這些假設就只存在於程序員的頭腦中（或者如果幸運的話，還存在於代碼注釋中）。
Java 程序中的一種流行技術是定義這樣的集合，即它的元素或鍵是公共類型的，比如「String列表」或者「String到String的映射」。通過在變數聲明中捕獲這一附加的類型信息，泛型允許編譯器實施這些附加的類型約束。類型錯誤現在就可以在編譯時被捕獲了，而不是在運行時當作ClassCastException展示出來。將類型檢查從運行時挪到編譯時有助於您更容易找到錯誤，並可提高程序的可靠性。
· 消除強制類型轉換。泛型的一個附帶好處是，消除源代碼中的許多強制類型轉換。這使得代碼更加可讀，並且減少了出錯機會。
盡管減少強制類型轉換可以降低使用泛型類的代碼的羅嗦程度，但是聲明泛型變數會帶來相應的羅嗦。比較下面兩個代碼例子。
該代碼不使用泛型：

List li = new ArrayList();

li.put(new Integer(3));

Integer i = (Integer) li.get(0);

該代碼使用泛型：

List<Integer> li = new ArrayList<Integer>();

li.put(new Integer(3));

Integer i = li.get(0);

在簡單的程序中使用一次泛型變數不會降低羅嗦程度。但是對於多次使用泛型變數的大型程序來說，則可以累積起來降低羅嗦程度。
· 潛在的性能收益。泛型為較大的優化帶來可能。在泛型的初始實現中，編譯器將強制類型轉換（沒有泛型的話，程序員會指定這些強制類型轉換）插入生成的位元組碼中。但是更多類型信息可用於編譯器這一事實，為未來版本的JVM 的優化帶來可能。
由於泛型的實現方式，支持泛型（幾乎）不需要JVM 或類文件更改。所有工作都在編譯器中完成，編譯器生成類似於沒有泛型（和強制類型轉換）時所寫的代碼，只是更能確保類型安全而已。
泛型用法的例子
泛型的許多最佳例子都來自集合框架，因為泛型讓您在保存在集合中的元素上指定類型約束。考慮這個使用Map類的例子，其中涉及一定程度的優化，即Map.get()返回的結果將確實是一個String：

Map m = new HashMap();

m.put("key", "blarg");

String s = (String) m.get("key");

如果有人已經在映射中放置了不是String的其他東西，上面的代碼將會拋出ClassCastException。泛型允許您表達這樣的類型約束，即m是一個將String鍵映射到String值的Map。這可以消除代碼中的強制類型轉換，同時獲得一個附加的類型檢查層，這個檢查層可以防止有人將錯誤類型的鍵或值保存在集合中。
下面的代碼示例展示了 JDK 5.0 中集合框架中的Map介面的定義的一部分：

public interface Map<K, V> {

public void put(K key, V value);

public V get(K key);

}

注意該介面的兩個附加物：

* 類型參數 K 和 V 在類級別的規格說明，表示在聲明一個 Map 類型的變數時指定的類型的佔位符。
* 在 get()、put() 和其他方法的方法簽名中使用的 K 和 V。

為了贏得使用泛型的好處，必須在定義或實例化Map類型的變數時為K和V提供具體的值。以一種相對直觀的方式做這件事：

Map<String, String> m = new HashMap<String, String>();

m.put("key", "blarg");

String s = m.get("key");

當使用Map的泛型化版本時，您不再需要將Map.get()的結果強制類型轉換為String，因為編譯器知道get()將返回一個String。
在使用泛型的版本中並沒有減少鍵盤錄入；實際上，比使用強制類型轉換的版本需要做更多鍵入。使用泛型只是帶來了附加的類型安全。因為編譯器知道關於您將放進Map中的鍵和值的類型的更多信息，所以類型檢查從執行時挪到了編譯時，這會提高可靠性並加快開發速度。
向後兼容
在 Java 語言中引入泛型的一個重要目標就是維護向後兼容。盡管 JDK 5.0 的標准類庫中的許多類，比如集合框架，都已經泛型化了，但是使用集合類（比如HashMap和ArrayList）的現有代碼將繼續不加修改地在 JDK 5.0 中工作。當然，沒有利用泛型的現有代碼將不會贏得泛型的類型安全好處。
類型參數
在定義泛型類或聲明泛型類的變數時，使用尖括弧來指定形式類型參數。形式類型參數與實際類型參數之間的關系類似於形式方法參數與實際方法參數之間的關系，只是類型參數表示類型，而不是表示值。
泛型類中的類型參數幾乎可以用於任何可以使用類名的地方。例如，下面是java.util.Map介面的定義的摘錄：

public interface Map<K, V> {

public void put(K key, V value);

public V get(K key);

}

Map介面是由兩個類型參數化的，這兩個類型是鍵類型K和值類型V。（不使用泛型）將會接受或返回Object的方法現在在它們的方法簽名中使用K或V，指示附加的類型約束位於Map的規格說明之下。
當聲明或者實例化一個泛型的對象時，必須指定類型參數的值：

Map<String, String> map = new HashMap<String, String>();

注意，在本例中，必須指定兩次類型參數。一次是在聲明變數map的類型時，另一次是在選擇HashMap類的參數化以便可以實例化正確類型的一個實例時。
編譯器在遇到一個Map<String, String>類型的變數時，知道K和V現在被綁定為String，因此它知道在這樣的變數上調用Map.get()將會得到String類型。
除了異常類型、枚舉或匿名內部類以外，任何類都可以具有類型參數。
命名類型參數
推薦的命名約定是使用大寫的單個字母名稱作為類型參數。這與C++ 約定有所不同（參閱附錄 A：與 C++ 模板的比較），並反映了大多數泛型類將具有少量類型參數的假定。對於常見的泛型模式，推薦的名稱是：

* K —— 鍵，比如映射的鍵。
* V —— 值，比如 List 和 Set 的內容，或者 Map 中的值。
* E —— 異常類。
* T —— 泛型。

泛型不是協變的
關於泛型的混淆，一個常見的來源就是假設它們像數組一樣是協變的。其實它們不是協變的。List<Object>不是List<String>的父類型。
如果 A 擴展 B，那麼 A 的數組也是 B 的數組，並且完全可以在需要B[]的地方使用A[]：

Integer[] intArray = new Integer[10];

Number[] numberArray = intArray;

上面的代碼是有效的，因為一個Integer是一個Number，因而一個Integer數組是一個Number數組。但是對於泛型來說則不然。下面的代碼是無效的：

List<Integer> intList = new ArrayList<Integer>();

List<Number> numberList = intList; // invalid

最初，大多數 Java 程序員覺得這缺少協變很煩人，或者甚至是「壞的（broken）」，但是之所以這樣有一個很好的原因。如果可以將List<Integer>賦給List<Number>，下面的代碼就會違背泛型應該提供的類型安全：

List<Integer> intList = new ArrayList<Integer>();

List<Number> numberList = intList; // invalid

numberList.add(new Float(3.1415));

因為intList和numberList都是有別名的，如果允許的話，上面的代碼就會讓您將不是Integers的東西放進intList中。但是，正如下一屏將會看到的，您有一個更加靈活的方式來定義泛型。
package com.ibm.course.generics;
import java.util.ArrayList;
import java.util.List;
public class GenericsExample {
public static void main(String[] args) {
Integer[] integer = new Integer[5];
Number[] number = integer;
System.out.println(number[0]);// null
number[0] = new Float(7.65);
System.out.println(number[0]);
System.out.println(integer[0]);
List<Integer> list = new ArrayList<Integer>();
// Type mismatch: cannot convert from List<Integer> to List<Number>
// List<Number> listObj = list;
}
}
List<Number> listObj = list;導致編譯錯誤：Type mismatch: cannot convert from List<Integer> to List<Number>
而System.out.println(number[0]);和System.out.println(integer[0]);導致運行時異常：
Exception in thread "main" java.lang.ArrayStoreException: java.lang.Float
at com.ibm.course.generics.GenericsExample.main(GenericsExample.java:15)

類型通配符
假設您具有該方法：

void printList(List l) {

for (Object o : l)

System.out.println(o);

}

上面的代碼在 JDK 5.0 上編譯通過，但是如果試圖用List<Integer>調用它，則會得到警告。出現警告是因為，您將泛型（List<Integer>）傳遞給一個只承諾將它當作List（所謂的原始類型）的方法，這將破壞使用泛型的類型安全。
如果試圖編寫像下面這樣的方法，那麼將會怎麼樣？

void printList(List<Object> l) {

for (Object o : l)

System.out.println(o);

}

它仍然不會通過編譯，因為一個List<Integer>不是一個List<Object>（正如前一屏泛型不是協變的 中所學的）。這才真正煩人——現在您的泛型版本還沒有普通的非泛型版本有用！
解決方案是使用類型通配符：

void printList(List<?> l) {

for (Object o : l)

System.out.println(o);

}

上面代碼中的問號是一個類型通配符。它讀作「問號」。List<?>是任何泛型List的父類型，所以您完全可以將List<Object>、List<Integer>或List<List<List<Flutzpah>>>傳遞給printList()。
package com.ibm.course.generics;
import java.util.ArrayList;
import java.util.List;
public class GenericExample {
public static void main(String[] args) {
List<Integer> integer = new ArrayList<Integer>();
integer.add(new Integer(0));
integer.add(new Integer(1));
List<String> str = new ArrayList<String>();
str.add(new String("Hello"));
str.add(new String("World"));
List<?> li=integer;
li=str;
printList(integer);
printList(str);
}
public static void printList(List<?> l) {
for (Object o : l) {
System.out.println(o);
}
}
}
上面的例子程序沒有警告也沒有編譯錯誤。
類型通配符的作用
前一屏類型通配符 中引入了類型通配符，這讓您可以聲明List<?>類型的變數。您可以對這樣的List做什麼呢？非常方便，可以從中檢索元素，但是不能添加元素（可以添加null）。原因不是編譯器知道哪些方法修改列表哪些方法不修改列表，而是（大多數）變化的方法比不變化的方法需要更多的類型信息。下面的代碼則工作得很好：

List<Integer> li = new ArrayList<Integer>();

li.add(new Integer(42));

List<?> lu = li;

System.out.println(lu.get(0));

為什麼該代碼能工作呢？對於lu，編譯器一點都不知道List的類型參數的值。但是編譯器比較聰明，它可以做一些類型推理。在本例中，它推斷未知的類型參數必須擴展Object。（這個特定的推理沒有太大的跳躍，但是編譯器可以作出一些非常令人佩服的類型推理，後面就會看到（在底層細節 一節中）。所以它讓您調用List.get()並推斷返回類型為Object。
另一方面，下面的代碼不能工作：

List<Integer> li = new ArrayList<Integer>();

li.add(new Integer(42));

List<?> lu = li;

lu.add(new Integer(43)); // error

在本例中，對於lu，編譯器不能對List的類型參數作出足夠嚴密的推理，以確定將Integer傳遞給List.add()是類型安全的。所以編譯器將不允許您這么做。
以免您仍然認為編譯器知道哪些方法更改列表的內容哪些不更改列表內容，請注意下面的代碼將能工作，因為它不依賴於編譯器必須知道關於lu的類型參數的任何信息：

List<Integer> li = new ArrayList<Integer>();

li.add(new Integer(42));

List<?> lu = li;

lu.clear();

泛型方法
（在類型參數 一節中）您已經看到，通過在類的定義中添加一個形式類型參數列表，可以將類泛型化。方法也可以被泛型化，不管它們定義在其中的類是不是泛型化的。
泛型類在多個方法簽名間實施類型約束。在List<V>中，類型參數V出現在get()、add()、contains()等方法的簽名中。當創建一個Map<K, V>類型的變數時，您就在方法之間宣稱一個類型約束。您傳遞給add()的值將與get()返回的值的類型相同。
類似地，之所以聲明泛型方法，一般是因為您想要在該方法的多個參數之間宣稱一個類型約束。例如，下面代碼中的ifThenElse()方法，根據它的第一個參數的布爾值，它將返回第二個或第三個參數：

public <T> T ifThenElse(boolean b, T first, T second) {

return b ? first : second;

}

注意，您可以調用ifThenElse()，而不用顯式地告訴編譯器，您想要T的什麼值。編譯器不必顯式地被告知 T 將具有什麼值；它只知道這些值都必須相同。編譯器允許您調用下面的代碼，因為編譯器可以使用類型推理來推斷出，替代T的String滿足所有的類型約束：

String s = ifThenElse(b, "a", "b");

類似地，您可以調用：

Integer i = ifThenElse(b, new Integer(1), new Integer(2));

但是，編譯器不允許下面的代碼，因為沒有類型會滿足所需的類型約束：

String s = ifThenElse(b, "pi", new Float(3.14));

為什麼您選擇使用泛型方法，而不是將類型T添加到類定義呢？（至少）有兩種情況應該這樣做：

* 當泛型方法是靜態的時，這種情況下不能使用類類型參數。
* 當 T 上的類型約束對於方法真正是局部的時，這意味著沒有在相同類的另一個 方法簽名中使用相同 類型 T 的約束。通過使得泛型方法的類型參數對於方法是局部的，可以簡化封閉類型的簽名。

有限制類型
在前一屏泛型方法 的例子中，類型參數V是無約束的或無限制的類型。有時在還沒有完全指定類型參數時，需要對類型參數指定附加的約束。
考慮例子Matrix類，它使用類型參數V，該參數由Number類來限制：

public class Matrix<V extends Number> { ... }

編譯器允許您創建Matrix<Integer>或Matrix<Float>類型的變數，但是如果您試圖定義Matrix<String>類型的變數，則會出現錯誤。類型參數V被判斷為由Number限制。在沒有類型限制時，假設類型參數由Object限制。這就是為什麼前一屏泛型方法 中的例子，允許List.get()在List<?>上調用時返回Object，即使編譯器不知道類型參數V的類型。

5. Java的基本語法

編寫Java程序時，應注意以下幾點： 大小寫敏感：Java是大小寫敏感的，這就意味著標識符Hello與hello是不同的。 類名：對於所有的類來說，類名的首字母應該大寫。如果類名由若干單片語成，那麼每個單詞的首字母應該大寫，例如 MyFirstJavaClass。 方法名：所有的方法名都應該以小寫字母開頭。如果方法名含有若干單詞，則後面的每個單詞首字母大寫，例如myFirstJavaMethod。 源文件名：源文件名必須和類名相同。當保存文件的時候，你應該使用類名作為文件名保存（切記Java是大小寫敏感的），文件名的後綴為.java。（如果文件名和類名不相同則會導致編譯錯誤）。 主方法入口：所有的Java 程序由public static void main(String [] args)方法開始執行。

6. java語法有哪些

Java程序中的每個變數要麼是基本數據類型（boolean, char, byte, short, int, long, float, double），要麼是對對象的引用

C++有許多種基本類型，額外還有struct, union, enum, 數組和指針，C++指針可以指向對象，也可以不指向對象

Java沒有枚舉、聯合類型，因為Java認為沒有必要。將可有可無的語言元素去掉是Java對C/C++做出的一大改變，因此，普遍認為Java較C++更輕便，更精簡

Java採用Unicode字元集，C++通常用ASCII字元集。但ASCII是Unicode的子集，對於習慣於ASCII的程序員感覺不到區別

Java中的boolean類型不能轉換成其他類型，反之亦然。C++最近引進了bool類型，代表布爾類型，整型也作為邏輯判斷

模板是一種「泛型編程思想」，它有別於「面向對象編程思想」。C++在很大程度上已經支持了這種新型編程方法，特別是STL的出現
Java目前仍未支持泛型編程，不過據說Sun公司有在Java中引入模板的計劃

C++支持「運算符的重載」，這是它的一個很重要的多態特徵，是數據抽象和泛型編程的利器。它允許直接對對象進行四則運算，正像基本數據類型那樣
Java不支持這種多態機制，也是為降低復雜性

兩種語言都支持方法重載(overloading)

在C++中，為了允許運行時動態決定哪個函數被調用，一個函數必須用virtual修飾。virtual關鍵字被自動繼承，用以支持多態

凡是沒有用virtual修飾的成員函數（包括static）都是靜態綁定的，即在編譯時決定調用哪個版本

而在Java中，除了static、final、private是靜態綁定以外，所有方法一律按動態綁定處理
C++中有「拷貝構造函數」的概念，在三種情況下，自動調用它
用一個對象初始化另一對象
對象作實參進行函數調用
對象作函數的返回值

通常，當一個對象需要做「深拷貝」(錢能：《C++程序設計教程》)時，我們需要為它事先定義「拷貝構造函數」、「賦值運算符的重載函數」和「析構函數」；否則編譯器將以「按位」的形式自動生成相應的預設函數。倘若類中含有指針成員或引用成員，那麼這三個默認的函數就隱含了錯誤

Java則沒有這種語法結構和語義邏輯
C++支持inline函數，可以避免函數的堆棧調用，提高運行效率

Java無這種語義

C++中，構造函數的初始化列表是這樣使用的：首先按繼承順序調用基類的構造函數構造基類對象，然後按聲明順序調用成員對象的構造函數構造成員對象，最後對列表中出現的成員變數做初始化
Java不採用初始化列表這種構造機制
它們的構造順序基本一致：
靜態變數初始化
靜態初始化塊（Java）
調用基類的構造函數構造基類對象
實例變數的初始化
構造函數的其餘部分
Java使用abstract關鍵字修飾抽象方法或抽象類

C++的對等語法是「純虛函數」和「抽象類」

兩者都使用抽象類作為繼承層次中的基類，提供一般概念，由子類實現其抽象方法，且抽象類都不能被直接實例化為對象
Java中有final關鍵字，修飾類、方法或變數
final類不能被繼承
final方法不能被子類覆蓋
final變數就是常量

C++中沒有這個關鍵字，常量可以使用const或#define定義
const還可以修飾成員函數，即「常成員函數」，當一個const成員函數修改成員數據，或調用非const成員函數時，編譯器會報錯
我們應將不修改成員數據的函數聲明為const
Java和C++中的static關鍵字語法和語義基本相同
static成員變數又叫類變數，被類的所有對象共享
A::x (C++)：必須在類體外初始化
A.x (Java)：必須在類體內初始化
static成員方法又叫類方法，訪問static變數
A::f( ) (C++)
A.f( ) (Java)
兩者都有內部類和局部類的語法和語義
Java中沒有友元函數和友元類的概念，嚴格支持封裝，不允許外部方法訪問類的私有成員
而C++支持friend關鍵字，允許外部方法訪問類的私有成員，因此不是一種純面向對象的編程語言
Java中類或interface可以用public修飾，也可以不修飾；而C++類不能修飾
三種訪問許可權的語義相同，語法略有差別
C++中還有繼承許可權修飾符，Java則沒有
class A: protected B, public C (C++)

7. java中的語法是什麼意思

語法就是編程語言的規則啊, 例如java中定義一個整數類型的變數:
int i= 10;
而在javascript里是這樣的
var i = 10;
例如在java中寫個方法(函數)是這樣的:
public int getNumber(){
return i;
}
javascript里是這樣的:
function getNumber(){
reture i;
}

8. java的語法

1)Object s=e.getSource();//Object是什麼意思？
Object,就是java世界中所有類的根類,就是所有類的祖先,其他類都實現object類裡面的方法

2)if(s instanceof JButton){//instanceof是什麼意思？
A instanceof B:判斷A是否是B的實例(具體的一個例子)
舉個例子就是:有的人是學生,有的人是老師,現在有個人想用學生的方法,但實例話這個人的時候實例化的是人,並不是學生(雖然你知道他是個學生),這怎麼辦呢?強轉的話會報錯,虛擬機認為不能把一個人強轉成學生,這時候就應該用instanceof判斷一下,看那個人是否是學生的實例,是的話,就可以強轉,執行學生的方法.
例子有點繞,希望你能理解....

3) JButton b=(JButton)s;//JBtton加括弧是什麼意思？
如果s是JButton的實例(也就是說s是個JButton),則執行這行代碼,將S強轉成JButton
....
}

9. java中方法是什麼

我們先來理解一下什麼叫做方法，通俗一點來說：在我們的日常生活中，方法可以理解為要做某件事情，而採取的解決辦法。如：小明同學在路邊准備坐車來學校學習。這就面臨著一件事情（坐車到學校這件事情）需要解決，解決辦法呢？可採用坐公交車或坐計程車的方式來學校，那麼，這種解決某件事情的辦法，我們就稱為方法。在java中，方法就是用來完成解決某件事情或實現某個功能的辦法。方法實現的過程中，會包含很多條語句用於完成某些有意義的功能——通常是處理文本，控制輸入或計算數值。
我們可以通過在程序代碼中引用方法名稱和所需的參數，實現在該程序中執行（或稱調用）該方法。方法，一般都有一個返回值，用來作為事情的處理結果。
方法的語法格式
在Java中，聲明一個方法的具體語法格式如下
修飾符 返回值類型 方法名(參數類型 參數名1,參數類型 參數名2,．．．．．．){
執行語句
………
return 返回值;
}