javaobject泛型

⑴ java，泛型問題和Object，類型轉換問題

簡單點說，不扯那些書上的，弱類型語言無類型，高級語言有類型，每個類型有自己的方法，這里就說java，java基本數據類型有8中，對應的包裝類也是有方法的，比如int對應的Integer，按你說的統一就Object類型，那麼每個類型都有自己的方法，你都用Object方法要怎麼用？你可以如果我要用String，那麼我就把Object轉換為String，可是往往寫代碼的時候，你還不知道未來那個數據是什麼類型，這種情況也是有的，再說泛型，泛型這個東西簡單來說就是在編譯期間確定類型，這樣IDE可以幫你檢查類型，舉例一個集合List，這里以前是可以裝任何Object的，有了泛型以後，我們可以這樣List<String>意思說這里的集合我只能裝字元串類型，否則編譯時就過不去，這樣的好處是你內心知道這里只是字元串，未來在從集合中獲取一個對象時，直接就可以用字元串的方法，而不是拿出Object在轉換，並且如果只是單純的List集合，你如何確定代碼裝入集合中的對象就一定是字元串，倘若很復雜的代碼，裡面不小心裝入的Integer對象，也很難檢測，恐怕只有運行報錯的時候你才知道，最後要說泛型只存在於編譯期間，編譯過後泛型擦除！

⑵ java泛型<T>和<Object>的區別

使用<T>來聲明類型持有者名稱，自定義泛型類時，類持有者名稱可以使用T(Type)，如果是容器的元素可以使用E(Element)，若鍵值匹配可以用K(Key)和V(Value)等，若是<?>，則是默認是允許Object及其下的子類，也就是java的所有對象了。

⑶ java 泛型 對象 如何判斷

java中的泛型對象使用instanceof來判斷。
具體代碼如下：

public class Demo {
public static void main(String[] args) {
List<Task> list = new ArrayList<Task>();
list.add(new Task());
for(int i=0;i<list.size();i++){
if(list.get(i) instanceof Task){
System.out.println(true);
}else{
System.out.println(false);
}
}

}
static class Task{
}
}

instanceof作用是判斷其左邊對象是否為其右邊類的實例，返回boolean類型的數據。可以用來判斷繼承中的子類的實例是否為父類的實現。

⑷ 如何在Java程序中使用泛型

在使用泛型前，存入集合中的元素可以是任何類型的，當從集合中取出時，所有的元素都是Object類型，需要進行向下的強制類型轉換，轉換到特定的類型。
比如：
List myIntList = new LinkedList(); // 1

myIntList.add(new Integer(0)); // 2

Integer x = (Integer) myIntList.iterator().next(); // 3

第三行的這個強制類型轉換可能會引起運行時的錯誤。
泛型的思想就是由程序員指定類型，這樣集合就只能容納該類型的元素。
使用泛型：
List<Integer> myIntList = new LinkedList<Integer>(); // 1'

myIntList.add(new Integer(0)); // 2'

Integer x = myIntList.iterator().next(); // 3'

將第三行的強制類型轉換變為了第一行的List類型說明，編譯器會為我們檢查類型的正確性。這樣，代碼的可讀性和健壯性也會增強。

泛型使用基礎
例如：

public interface List <E>
{
void add(E x);
Iterator<E> iterator();
}

public interface Iterator<E>
{
E next();
boolean hasNext();
}

尖括弧中包含的是形式類型參數（formal type parameters），它們就如同一般的類型一樣，可以在整個類的聲明中被使用。
當類被使用時，會使用具體的實際類型參數（actual type argument）代替。
比如前面的例子中的List<Integer>，那麼所有的E將會被Integer類型所代替。
泛型類型參數只能被類或介面類型賦值，不能被原生數據類型賦值，原生數據類型需要使用對應的包裝類。
形式類型參數的命名：盡量使用單個的大寫字母（有時候多個泛型類型時會加上數字，比如T1，T2），比如許多容器集合使用E，代表element（元素），Map中用K代表鍵keys，V代表值。

⑸ java泛型中 <Object>是對象類型 <T>代表什麼類型 能否把所有泛型的簡寫介紹小

<T>表示的是形式泛型類型(formal generic type)，一般在介面中聲明一個泛型類型；
在實現中，要用具體類型來代替它。
根據約定：像E或T這樣的單個大寫字母用於指示形式泛型類型。

⑹ java中list集合存儲了object元素，根據泛型進行分組

for(Object object : list) {
String str = object.toString();
if (StringUtils.isNumeric(str )) {
// 是數字
} else {
// 不是數字
}
}

⑺ java中泛型指的是什麼

我來簡述一下泛型的知識吧:

如果一個類的後面跟上一個尖括弧,表示這個類是泛型類.

可以這樣聲明:class 名稱<泛型列表>
如:class A<E>
其中A是泛型類的名稱,E是泛型.(可以是任何對象或介面)

其中給出的泛型可以作為類的成員變數的類型,方法的類型以及局部變數的類型.類體和變通類完全一樣,由成員變數和方法構成.

舉個例子:
class Chorus<E,F>
{
void makeChorus(E person,F yueqi)
{
yueqi.toString();
person.toString() ;
}
}
--------------
上面的類中將類E和類F作為類Chorus的一部分來使用.這就是泛型類的目的,將多個類包含進一個類來使用!!!

如果你想深入理解就可以找一些書來看,一些基本的教材裡面也都有提到泛型的.

希望我說的對你有所幫助!!!

⑻ java泛型的深入泛型

因為上面的類中，成員和方法的邏輯都一樣，就是類型不一樣，因此考慮重構。Object是所有類的父類，因此可以考慮用Object做為成員類型，這樣就可以實現通用了，實際上就是「Object泛型」，暫時這么稱呼。 publicclassObjectFoo{privateObjectx;publicObjectFoo(Objectx){this.x=x;}publicObjectgetX(){returnx;}publicvoidsetX(Objectx){this.x=x;}}寫出Demo方法如下： publicclassObjectFooDemo{publicstaticvoidmain(Stringargs[]){ObjectFoostrFoo=newObjectFoo(newStringFoo(HelloGenerics!));ObjectFoodouFoo=newObjectFoo(newDoubleFoo(newDouble(33)));ObjectFooobjFoo=newObjectFoo(newObject());System.out.println(strFoo.getX=+(StringFoo)strFoo.getX());System.out.println(douFoo.getX=+(DoubleFoo)douFoo.getX());System.out.println(objFoo.getX=+objFoo.getX());}}運行結果如下：
strFoo.getX=StringFoo@5d748654
douFoo.getX=DoubleFoo@d1f24bb
objFoo.getX=java.lang.Object@19821f
解說：在Java 5之前，為了讓類有通用性，往往將參數類型、返回類型設置為Object類型，當獲取這些返回類型來使用時候，必須將其「強制」轉換為原有的類型或者介面，然後才可以調用對象上的方法。 強制類型轉換很麻煩，我還要事先知道各個Object具體類型是什麼，才能做出正確轉換。否則，要是轉換的類型不對，比如將「Hello Generics!」字元串強制轉換為Double,那麼編譯的時候不會報錯，可是運行的時候就掛了。那有沒有不強制轉換的辦法----有，改用 Java5泛型來實現。 classGenericsFoo<T>{privateTx;publicGenericsFoo(Tx){this.x=x;}publicTgetX(){returnx;}publicvoidsetX(Tx){this.x=x;}}publicclassGenericsFooDemo{publicstaticvoidmain(Stringargs[]){GenericsFoo<String>strFoo=newGenericsFoo<String>(HelloGenerics!);GenericsFoo<Double>douFoo=newGenericsFoo<Double>(newDouble(33));GenericsFoo<Object>objFoo=newGenericsFoo<Object>(newObject());System.out.println(strFoo.getX=+strFoo.getX());System.out.println(douFoo.getX=+douFoo.getX());System.out.println(objFoo.getX=+objFoo.getX());}}運行結果：
strFoo.getX=Hello Generics!
douFoo.getX=33.0
objFoo.getX=java.lang.Object@19821f
和使用「Object泛型」方式實現結果的完全一樣，但是這個Demo簡單多了，裡面沒有強制類型轉換信息。
下面解釋一下上面泛型類的語法：
使用<T>來聲明一個類型持有者名稱，然後就可以把T當作一個類型代表來聲明成員、參數和返回值類型。
當然T僅僅是個名字，這個名字可以自行定義。
class GenericsFoo<T> 聲明了一個泛型類，這個T沒有任何限制，實際上相當於Object類型，實際上相當於 class GenericsFoo<T extends Object>。
與Object泛型類相比，使用泛型所定義的類在聲明和構造實例的時候，可以使用「<實際類型>」來一並指定泛型類型持有者的真實類型。類如
GenericsFoo<Double> douFoo=new GenericsFoo<Double>(new Double(33));
當然，也可以在構造對象的時候不使用尖括弧指定泛型類型的真實類型，但是你在使用該對象的時候，就需要強制轉換了。比如：GenericsFoo douFoo=new GenericsFoo(new Double(33));
實際上，當構造對象時不指定類型信息的時候，默認會使用Object類型，這也是要強制轉換的原因。

⑼ （Java泛型）為什麼Object不能直接引用Integer內的值 （後面有源代碼）

java的泛型實現機制就是這一要求的。泛型參數必須是一個類，即object類的子類。
但是java中，int屬於原始數據類型，並不是一個類，也就無法使用於java泛型。
所以只能用integer類。

⑽ Java中泛型如果沒有指定類型，為什麼會把添加的類型轉成object呢

java是面對對象的編程，所有的類都是直接或者間接繼承object類。可以說object類為java中的根類(root class)
所以當泛型沒有指定類型時，就會轉成object類