當前位置:首頁 » 編程語言 » java里的

java里的

發布時間: 2022-01-15 08:42:27

java里的 「!=」 和「==」什麼意思呀

==和!=是邏輯操作符號,返回一個boolean值
=是賦值符號
==和!=用於比較基本類型時,就是比較相等不相等
==和!=用於比較對象的時候,就是比較內存中對象的引用地址,相同返回真。
-----------------------------------------------------------
n==0這句,n如果等於0則返回一個true,不等於就返回一個false
你可以用一個boolean變數接住返回的值,或者直接列印出來。
System.out.println(n==0);

⑵ java里的.的作用

.表示對象的引用

Character.toLowerCase(),表示引用character 對象的 toLowerCase()方法。因為toLowerCase()是一個方法。
a.b.c(), 表示引用對象a的b對象的c()方法。

⑶ 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的類型。

⑷ java里的 | 什麼意思

結果為6

計算機里數字保存是用二進制
6:110
4:100
|代表或
二進制或會算吧?1或1為1,1或0為1,0或0為0
所以結果為:110 還是6

如果換成&(與)
1與1為1,1與0為0,0與0為0
與的結果為:100 為4

⑸ java里的

i++和++i單獨使用產生的效果一樣,但是前後肯定有區別,區別在於他們所作用的環境中

inti=0;
System.out.println(i++);//0
System.out.println(++i);//1

後++,先使用後自增1;前++,先自增1在使用。

sum=sum+i;
sum+=i;

表示的意思是一樣的,使用自己加上i值在賦值給自己;

sun=sum+i;

表示讓sum與i相加在將結果賦值給另外一個變數。

⑹ javA裡面的點是什麼意思

Java是由Sun
Microsystems公司於1995年5月推出的Java程序設計語言(以下簡稱Java語言)和Java平台的總稱。用Java實現的HotJava瀏覽器(支持Java
applet)顯示了Java的魅力:跨平台、動感的Web、Internet計算。從此,Java被廣泛接受並推動了Web的迅速發展,常用的瀏覽器現在均支持Java
applet。另一方面,Java技術也不斷更新。
Java平台由Java虛擬機(Java
Virtual
Machine)和Java
應用編程介面(Application
Programming
Interface、簡稱API)構成。Java
應用編程介面為Java應用提供了一個獨立於操作系統的標准介面,可分為基本部分和擴展部分。在硬體或操作系統平台上安裝一個Java平台之後,Java應用程序就可運行。現在Java平台已經嵌入了幾乎所有的操作系統。這樣Java程序可以只編譯一次,就可以在各種系統中運行。Java應用編程介面已經從1.1x版發展到1.2版。目前常用的Java平台基於Java1.4,最近版本為Java1.6。
Java分為三個體系J2SE(Java2
Standard
Edition),J2EE(Java
2
Platform,Enterprise
Edition),J2ME(Java
2
Micro
Edition)。

⑺ java里&是什麼意思

大致等同於:並且 這個意思 比如m=1&n=2 如同m=1並且n=2的條件。僅供參考

⑻ java 中/**是什麼

你的j2se只學了一點而已,不管怎樣,都要先把j2se學好,這是基礎。j2se的學習順序一般是這樣的:基礎語法 -> 面向對象入門 -> 異常處理 -> 數組 -> 常用類 -> 容器(相當重要) -> IO -> 線程 -> 網路 -> GUI。
既然你io,thread都學了,其餘那些還有沒學的,建議去看看馬士兵的j2se視頻,其實我覺得如果想打好基礎的話,這套視頻應該全部過過,特別是開始的內存分析和面向對象分析。學完j2se要做做幾個基礎的桌面項目,像什麼貪吃蛇啊、俄羅斯方塊、簡單的聊天器等等,這樣才能把知識整合起來,加深對j2se的理解。
如果想走j2ee路線的話,接下來應該學資料庫,再學html、css、JavaScript、jsp/servlet,也就是web的入門,之後做做web項目,比如小bbs、網上商城等等。學通了就學框架,這期間會穿插很多東西,例如xml、uml、log4j、jUnit等等,最後學設計模式和面向對象的分析。計算機的東西是很多的,不要學死,也不要想著學完,最重要的是學會解決問題的方法。開始肯定要模仿別人的代碼,不斷模仿,多看,看完一定要自己寫幾遍,只有能寫出來了的,才是自己的東西,建議開始時多背點東西,包括一些常用類啊、一些概念性的東西,因為背多了自己就熟悉了。
資料庫的要另找,網上能找到馬士兵的Oracle,講的很不錯的!!
shopping這個項目也有從頭帶到尾的,也是馬士兵的,要找找
做項目是很重要的,從簡單的做起,慢慢體會其中的分析與設計
學java還是從視頻入門的好,千萬不要一開始就去看《Thinking in java》,吃力不討好,學到web時可以看看張孝祥的《深入體驗JAVA Web開發內幕——核心基礎》,寫的很詳細,不過他的視頻一般,JavaScript就看《JavaScript高級程序設計》,html比較簡單,css也比較簡單,不過css布局因人而異,有人覺得很好理解,有人覺得很難,搞個Dreamweaver多練練也就熟悉了。設計模式可以看《大話設計模式》,入門很好!
你的j2se只學了一點而已,不管怎樣,都要先把j2se學好,這是基礎。j2se的學習順序一般是這樣的:基礎語法 -> 面向對象入門 -> 異常處理 -> 數組 -> 常用類 -> 容器(相當重要) -> IO -> 線程 -> 網路 -> GUI。
既然你io,thread都學了,其餘那些還有沒學的,建議去看看馬士兵的j2se視頻,其實我覺得如果想打好基礎的話,這套視頻應該全部過過,特別是開始的內存分析和面向對象分析。學完j2se要做做幾個基礎的桌面項目,像什麼貪吃蛇啊、俄羅斯方塊、簡單的聊天器等等,這樣才能把知識整合起來,加深對j2se的理解。
如果想走j2ee路線的話,接下來應該學資料庫,再學html、css、JavaScript、jsp/servlet,也就是web的入門,之後做做web項目,比如小bbs、網上商城等等。學通了就學框架,這期間會穿插很多東西,例如xml、uml、log4j、jUnit等等,最後學設計模式和面向對象的分析。計算機的東西是很多的,不要學死,也不要想著學完,最重要的是學會解決問題的方法。開始肯定要模仿別人的代碼,不斷模仿,多看,看完一定要自己寫幾遍,只有能寫出來了的,才是自己的東西,建議開始時多背點東西,包括一些常用類啊、一些概念性的東西,因為背多了自己就熟悉了。
資料庫的要另找,網上能找到馬士兵的Oracle,講的很不錯的!!
shopping這個項目也有從頭帶到尾的,也是馬士兵的,要找找
做項目是很重要的,從簡單的做起,慢慢體會其中的分析與設計
學java還是從視頻入門的好,千萬不要一開始就去看《Thinking in java》,吃力不討好,學到web時可以看看張孝祥的《深入體驗JAVA Web開發內幕——核心基礎》,寫的很詳細,不過他的視頻一般,JavaScript就看《JavaScript高級程序設計》,html比較簡單,css也比較簡單,不過css布局因人而異,有人覺得很好理解,有人覺得很難,搞個Dreamweaver多練練也就熟悉了。設計模式可以看《大話設計模式》,入門很好!

⑼ java里.的意思是什麼

System.out 的「.」類似路徑中的「/」 ,你在找相關文件時,可按照system 包..等等的順序找
c.run()指的是c文件所存在的許可權內可見的方法函數
---以上:xx.aa.bb.cc.ss.aa() /xx.aa.bb.cc.ss.aa 倒數第一個是 方法/或者是欄位,倒數第二個是該 方法/或者欄位所在的文件 ,其他的都是文件夾(即包)
其他的,請稍等,我整一下

熱點內容
0123我的世界伺服器 發布:2022-01-18 06:59:27 瀏覽:752
如何編譯代碼 發布:2022-01-18 06:59:23 瀏覽:419
壓縮冰 發布:2022-01-18 06:57:41 瀏覽:768
c語言窗口程序 發布:2022-01-18 06:56:29 瀏覽:517
apache伺服器搭建 發布:2022-01-18 06:47:39 瀏覽:975
資料庫名修改 發布:2022-01-18 06:45:01 瀏覽:386
演算法的優化 發布:2022-01-18 06:41:53 瀏覽:991
方舟伺服器ip 發布:2022-01-18 06:41:51 瀏覽:515
伺服器名稱或ip地址 發布:2022-01-18 06:41:48 瀏覽:672
雲伺服器組建 發布:2022-01-18 06:41:37 瀏覽:855