2. 程式人生 > >java基礎總結 -- 泛型 在類、介面、方法、匿名類、元組等使用 堆疊例子 商店模型

java基礎總結 -- 泛型 在類、介面、方法、匿名類、元組等使用 堆疊例子 商店模型

阿新 • • 發佈：2018-12-26
為什麼使用泛型：
    在面向物件程式語言中，多型算是一種泛化機制。例如，你可以將方法的引數型別設為基類，那麼
該方法就可以接受從這個基類中匯出的任何類作為引數，這樣的方法更通用一些，可應用的地方也多一點。
    在類的內部也是如此，凡是能夠使用基類，確實是能夠具備更好的靈活性。
    但單繼承會使程式受限。如果方法引數是一個介面而不是一個類，那麼限制就放鬆多了，因為
任何實現了該介面的類都能滿足該方法，這也包含了不存在的類。這就給客戶端程式設計師一種選擇，它可以通過
實現一個介面來滿足類或方法。因此，介面允許我們快速實現類繼承，也可以建立新的型別來實現這點。
    可是有的時候，實現介面，對程式的約束也還是太強了。因為一旦指明瞭介面，方法就需要使用特定的介面。
而我們希望達到的目的是編寫更通用的程式碼，要使程式碼能夠應用於“某種不具體的型別”，而不是一個具體的介面或類。

泛型方法
    泛型方法使得該方法能夠獨立於類而發生改變。這個方法鎖在的類可以時泛型類，也可以不是泛型類。
是否擁有泛型方法，與其所在的類是否是泛型沒有關係
    無論何時，只要你能做到，你就應該儘量使用泛型方法。如果使用泛型方法可以取代將整個型別泛型化，那麼就應該只
使用泛型方法，因為它可以使事情更清楚明白。
    對於一個static的方法而言，無法訪問泛型類的型別引數，所以，如果static方法需要使用泛型能力，就必須使其成為泛型
方法。    

    要定義泛型方法，只需將泛型引數列表置於返回值之前    

package com.zghw.base.generic;

/**
 * 泛型的演變
 * 
 * @author zghw
 *
 */
public class Develop {
	class Automobile {
	}

	// Holder1直接指明瞭持有物件的型別
	class Holder1 {
		private Automobile automobile;

		public Holder1(Automobile automobile) {
			this.automobile = automobile;
		}

		public void set(Automobile automobile) {
			this.automobile = automobile;
		}

		public Automobile get() {
			return automobile;
		}
	}

	// Holder2使用Object作為持有物件的型別更加泛化。
	class Holder2 {
		private Object obj;

		public Holder2(Object obj) {
			this.obj = obj;
		}

		public void set(Object obj) {
			this.obj = obj;
		}

		public Object get() {
			return obj;
		}
	}

	// 暫時不指定型別，稍後在決定具體使用的型別，需要使用型別引數
	class Holder3<T> {
		private T t;

		public Holder3(T t) {
			this.t = t;
		}

		public void set(T t) {
			this.t = t;
		}

		public T get() {
			return t;
		}
	}

	public static void main(String[] args) {
		Develop de = new Develop();
		// 使用Holder2可以設定不同的型別物件，
		// 通常我們使用容器來儲存一種型別物件
		Holder2 h2 = de.new Holder2(de.new Automobile());
		h2 = de.new Holder2("1122");
		h2.set(123);
		h2.set(de.new Automobile());
		Automobile a = (Automobile) h2.get();// 明確需要型別轉換
		//
		Holder3<Automobile> h3 = de.new Holder3<Automobile>(de.new Automobile());

		Automobile aa = h3.get();// 自動地轉換為正確型別
	}

}

 

package com.zghw.base.generic;

/**
 * 元組 它是將一組物件直接打包儲存於其中一個單一物件。這個容器物件允許 讀取其中元素，但是不允許向其中存放新的對專案。也可叫做資料傳遞物件或信使
 * 主要用於僅一次方法呼叫就能返回多個物件。 元祖可以具有任意長度，同時，元組中地物件可以是任意不同的型別。不過我們希望能夠為
 * 每一個物件指明其型別，並且從容器中讀取出來時，能夠得到正確的型別。要處理不同長度的問題， 我們需要建立多個不同的元祖
 * 
 * @author zghw
 *
 * @param <A>
 * @param <B>
 */
public class TwoTuple<A, B> {
	// 這裡沒有first和second沒有使用private 並且沒有設定set和get方法
	// 而是採用了public final ，因為只為了讀取first 和second
	// 不用於修改，要向修改需要重新構造新物件放入，final保證了不能修改
	public final A first;
	public final B second;

	public TwoTuple(A first, B second) {
		this.first = first;
		this.second = second;
	}

	public String toString() {
		return "first " + " second ";
	}
}

 

</pre><pre name="code" class="java">package com.zghw.base.generic;

import java.util.Date;

/**
 * 僅一次方法呼叫就能返回多個物件，在開發中經常碰到。 可是return語句只允許返回單個物件，因此，解決辦法就是建立一個物件，用它來持有想要返回的多個
 * 物件。可以在每次需要的時候，專門建立一個類來完成這樣的工作。
 * 使用元組，只需要定一個長度時適合的元組，將其作為方法的返回值，然後在return語句中建立該元組， 並返回即可。
 * 
 * @author zghw
 *
 */
public class TestTuple {
	static TwoTuple<Integer,String> returnTwoParam(){
		return new TwoTuple<Integer,String>(22,"ss");
	}
	static ThreeTuple<Integer,Develop,Date> returnThreeParam(){
		return new ThreeTuple<Integer,Develop,Date>(22,new Develop(),new Date());
	}
	public static void main(String[] args) {
		System.out.println(returnTwoParam());
		System.out.println(returnThreeParam());
	}

}


package com.zghw.base.generic;

/**
 * 如果使用多元組就使用繼承來實現
 * 
 * @author zghw
 *
 * @param <A>
 * @param <B>
 * @param <C>
 */
public class ThreeTuple<A, B, C> extends TwoTuple<A, B> {

	public final C three;

	public ThreeTuple(A first, B second, C three) {
		super(first, second);
		this.three = three;
	}

	public String toString() {
		return super.toString() + " three ";
	}
}


package com.zghw.base.generic;

/**
 * 連結串列的棧，實現了先進後出
 * 
 * @author zghw
 *
 */
public class LinkStack<T> {
	// 最頂層元素
	private Node<T> top = new Node<T>();// 初始化為null

	// 入棧 ：入棧後當前最頂元素變為下一個元素，最新的最頂層元素為新增的新元素，
	public void push(T item) {
		top = new Node<T>(item, top);
	}

	// 出棧：最頂層元素出棧，當前最頂元素變為下一個元素，最新的最頂層元素變為下一個元素
	public T pop() {
		T result = top.item;
		if (!top.end()) {
			top = top.next;// 下一個當成當前最頂元素
		}
		return result;
	}

	class Node<U> {
		U item;
		Node<U> next;// next 連結串列主要點 當前物件連線下一個當前物件就形成了連結串列

		public Node() {
			this.item = null;
			this.next = null;
		}

		public Node(U item, Node<U> next) {
			this.item = item;
			this.next = next;
		}

		/**
		 * 是否時最後一個元素
		 * 
		 * @return
		 */
		public boolean end() {
			return ((top == null) && (next == null));
		}
	}

	public static void main(String[] args) {
		LinkStack<String> s = new LinkStack<String>();
		s.push("a");
		s.push("b");
		s.push("c");
		s.push("d");
		s.push("e");
		System.out.println(s.pop());
		System.out.println(s.pop());
		System.out.println(s.pop());
		System.out.println(s.pop());
		System.out.println(s.pop());
		System.out.println(s.pop());
	}

}


package com.zghw.base.generic;

import java.util.ArrayList;
import java.util.Random;

/**
 * 隨機選取一個元素
 * 
 * @author zghw
 *
 * @param <T>
 */
public class RandomList<T> {
	private ArrayList<T> stroage = new ArrayList<T>();
	private Random random = new Random(47);

	/**
	 * 隨機選取一個型別例項
	 */
	public T select() {
		return stroage.get(random.nextInt(stroage.size()));
	}

	public void add(T item) {
		stroage.add(item);
	}

	public static void main(String[] args) {
		RandomList<String> rl = new RandomList<String>();
		for (String s : "// TODO Auto-generated method stub".split(" ")) {
			rl.add(s);
		}
		for (int i = 0; i < 10; i++) {
			System.out.println(rl.select());
		}
	}

}


package com.zghw.base.generic.coffee;

public class Coffee {
	//static + final 聯合使用 全域性計數器
	private static int counter=0;
	private final int id=counter++;
	public String toString(){
		return  getClass().getSimpleName()+" 建立例項數量："+id;
	}
	public static void main(String[] args) {
		for(int i=0;i<10;i++){
			Coffee c =new Coffee();
			System.out.println(c);
		}
	}

}

package com.zghw.base.generic.coffee;

public class Americano extends Coffee {

}


package com.zghw.base.generic.coffee;

public class Breve extends Coffee {

}


package com.zghw.base.generic.coffee;

public class Cappuccino extends Coffee {

}


package com.zghw.base.generic.coffee;

public class Latte extends Coffee {

}


package com.zghw.base.generic.coffee;

public class Mocha extends Coffee {

}


package com.zghw.base.generic;

import java.util.Iterator;
import java.util.Random;

import com.zghw.base.Generator;
import com.zghw.base.generic.coffee.Americano;
import com.zghw.base.generic.coffee.Breve;
import com.zghw.base.generic.coffee.Cappuccino;
import com.zghw.base.generic.coffee.Coffee;
import com.zghw.base.generic.coffee.Latte;
import com.zghw.base.generic.coffee.Mocha;

/**
 * 泛型介面的使用 隨機生成不同的子類物件 Iterable迭代器使用
 * 
 * @author zghw
 *
 */
public class CoffeeGenerator implements Generator<Coffee>, Iterable<Coffee> {
	// 使用型別資訊陣列儲存類資訊
	private Class<?>[] types = new Class<?>[] { Breve.class, Americano.class,
			Latte.class, Mocha.class, Cappuccino.class };
	private Random random = new Random(47);
	private int size = 0;

	public CoffeeGenerator() {
	}

	public CoffeeGenerator(int size) {
		this.size = size;
	}

	@Override
	public Coffee next() {
		try {// 隨機取得Coffee實現類例項物件
			return (Coffee) types[random.nextInt(types.length)].newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	@Override
	public Iterator<Coffee> iterator() {
		return new CoffeeIterator();
	}

	class CoffeeIterator implements Iterator<Coffee> {
		int count = size;

		@Override
		public boolean hasNext() {
			return count > 0;
		}

		@Override
		public Coffee next() {
			count--;// 內部類呼叫外部類方法
			return CoffeeGenerator.this.next();
		}

		@Override
		public void remove() {
		}
	}

	public static void main(String[] args) {
		CoffeeGenerator cg = new CoffeeGenerator();
		for (int i = 0; i < 5; i++) {
			System.out.println(cg.next());
		}
		for (Coffee c : new CoffeeGenerator(3)) {
			System.out.println(c);
		}
	}

}


package com.zghw.base;

public interface Generator<T> {
	public T next();
}


package com.zghw.base.generic;
/**
 * 泛型方法
	泛型方法使得該方法能夠獨立於類而發生改變。這個方法鎖在的類可以時泛型類，也可以不是泛型類。
是否擁有泛型方法，與其所在的類是否是泛型沒有關係
	無論何時，只要你能做到，你就應該儘量使用泛型方法。如果使用泛型方法可以取代將整個型別泛型化，那麼就應該只
使用泛型方法，因為它可以使事情更清楚明白。
	對於一個static的方法而言，無法訪問泛型類的型別引數，所以，如果static方法需要使用泛型能力，就必須使其成為泛型
方法。	
	要定義泛型方法，只需將泛型引數列表置於返回值之前	
 * @author zghw
 *
 */
//GenericMethods並不是引數化的，儘管這個類和其內部方法可以被同時引數化，但是阻止由方法f()擁有型別引數
//這是由該方法的返回型別前面的型別引數列表指明的
public class GenericMethods {
	public <T> void f(T t){
		System.out.println(t.getClass().getName());
	}
	public static void main(String[] args) {
		//在使用泛型類時，必須在建立物件的時候指定引數型別的值，而使用泛型方法的時候，不必指明引數型別。
		//因為編譯器會為我們找出具體的型別。這被成為型別引數推斷
		GenericMethods gm =new GenericMethods();
		//我們可以像呼叫普通方法一樣呼叫f()，而且好像是f()被無限次地過載過。它甚至可以接受GenericMethods
		//作為其型別引數
		//如果呼叫f()時傳入地基本型別，自動打包機制就會介入其中，將基本型別的值包裝為對應的物件。
		//事實上，泛型方法與自動打包避免了許多以前我們不得不自己編寫出來的程式碼。
		gm.f("");
		gm.f(1);
		gm.f(1.0);
		gm.f(1.0F);
		gm.f('c');
		gm.f(gm);
	}

}


package com.zghw.base.generic;

import java.util.ArrayList;
import java.util.List;

/**
 * 泛型方法與可變引數使用
 * @author zghw
 *
 */
public class GenericVarargs {
	public static <T> List<T> makeList(T... args ){
		List<T> ls = new ArrayList<T>();
		for(T t: args){
			ls.add(t);
		}
		return ls;
	}
	public static void main(String[] args) {
		List<String> ls = GenericVarargs.makeList("11","22","33");
		System.out.println(ls);
		ls=GenericVarargs.makeList("A B C D E F G H I J K L M N O P Q".split(" "));
		System.out.println(ls);
	}

}


package com.zghw.base.generic;

import java.util.ArrayList;
import java.util.Collection;

import com.zghw.base.Generator;
import com.zghw.base.generic.coffee.Coffee;

/**
 * 利用生成器，填充一個Collection，泛化這種操作很有意義
 * 
 * @author zghw
 *
 */
public class Generators {

	/**
	 * 向容器中填充物件
	 * 
	 * @param coll
	 *            容器
	 * @param gen
	 *            物件生成器
	 * @param size
	 *            數量
	 * @return
	 */
	public static <T> Collection<T> fill(Collection<T> coll, Generator<T> gen,
			int size) {
		for (int i = 0; i < size; i++) {
			coll.add(gen.next());
		}
		return coll;
	}

	public static void main(String[] args) {
		Collection<Coffee> cc = fill(new ArrayList<Coffee>(),
				new CoffeeGenerator(), 5);
		for (Coffee c : cc) {
			System.out.println(c);
		}
	}

}


package com.zghw.base;

import com.zghw.base.generic.coffee.Coffee;

/**
 * 為任意類構造一個Generator 滿足條件： （1）必須宣告為public （2）具備預設的建構函式
 * 
 * @author zghw
 *
 * @param <T>
 */
public class BasicGenerator<T> implements Generator<T> {
	private Class<T> type;

	public BasicGenerator(Class<T> type) {
		this.type = type;
	}

	@Override
	public T next() {
		try {
			return type.newInstance();
		} catch (Exception e) {
			throw new RuntimeException();
		}
	}

	public static <T> BasicGenerator<T> create(Class<T> type) {
		return new BasicGenerator<T>(type);
	}

	public static void main(String args[]) {
		Generator<Coffee> gr = BasicGenerator.create(Coffee.class);
		for (int i = 0; i < 5; i++) {
			System.out.println(gr.next());
		}
	}
}


package com.zghw.base.generic;

import java.util.HashSet;
import java.util.Set;

/**
 * 數學關係式 交集 並集 合集
 * 
 * @author zghw
 *
 */
public class Sets {
	/**
	 * 合集
	 */
	public static <T> Set<T> union(Set<T> a, Set<T> b) {
		Set<T> reslut = new HashSet<T>(a);
		reslut.addAll(b);
		return reslut;
	}

	/**
	 * 交集
	 */
	public static <T> Set<T> intersection(Set<T> a, Set<T> b) {
		Set<T> reslut = new HashSet<T>(a);
		reslut.retainAll(b);
		return reslut;
	}

	/**
	 * 補集
	 */
	public static <T> Set<T> complement(Set<T> a, Set<T> b) {
		return difference(union(a, b), intersection(a, b));
	}

	/**
	 * 除了交集
	 */
	public static <T> Set<T> difference(Set<T> superset, Set<T> subset) {
		Set<T> reslut = new HashSet<T>(superset);
		reslut.removeAll(subset);
		return reslut;
	}
}


package com.zghw.base.generic;

import java.lang.reflect.Method;
import java.util.*;

/**
 * java.util包中各種Collection類與Map類之間的方法差異
 * 
 * @author zghw
 *
 */
public class ContainerMethodDifferences {
	private static Set<String> objSet = methods(Object.class);// Object物件的方法集合

	/**
	 * 取得類對應的方法集合
	 * 
	 * @return
	 */
	public static Set<String> methods(Class<?> type) {
		Set<String> set = new HashSet<String>();
		for (Method m : type.getMethods()) {
			set.add(m.getName());
		}
		return set;
	}

	public static void interfaces(Class<?> type) {
		System.out.println("Interfaces in " + type.getSimpleName());
		List<String> list = new ArrayList<String>();
		for (Class<?> c : type.getInterfaces()) {
			list.add(c.getSimpleName());
		}
		System.out.println(list);
	}

	public static void different(Class<?> subClass, Class<?> superClass) {
		System.out.println(subClass.getSimpleName() + " extends "
				+ superClass.getSimpleName() + " adds:");
		Set<String> diff = Sets.difference(methods(superClass),
				methods(subClass));
		diff.removeAll(objSet);// 去掉Object的方法
		System.out.println("= " + diff + "=");
		interfaces(superClass);
	}

	public static void main(String args[]) {
		System.out.println("Collection: " + methods(Collection.class));
		interfaces(Collection.class);
		different(Set.class, Collection.class);
		different(HashSet.class, Set.class);
		different(LinkedHashSet.class, HashSet.class);
		different(TreeSet.class, Set.class);
		different(List.class, Collection.class);
		different(ArrayList.class, List.class);
		different(LinkedList.class, List.class);
		different(Queue.class, Collection.class);
		different(PriorityQueue.class, Queue.class);
		System.out.println("Map: " + methods(Map.class));
		different(HashMap.class, Map.class);
		different(LinkedHashMap.class, HashMap.class);
		different(SortedMap.class, Map.class);
		different(TreeMap.class, Map.class);
	}
}


package com.zghw.base.generic;

import java.util.ArrayList;
import java.util.Random;

import com.zghw.base.Generator;

/**
 * 使用泛型構建商店模型
 * 
 * @author zghw
 *
 */
// 商品
class Product {
	private int id;
	private String desc;
	private double price;

	public Product(int id, String desc, double price) {
		this.id = id;
		this.desc = desc;
		this.price = price;
		System.out.println(this);
	}

	public String toString() {
		return id + " : " + desc + " " + price;
	}

	public static Generator<Product> gen = new Generator<Product>() {
		Random random = new Random(47);

		@Override
		public Product next() {
			return new Product(random.nextInt(1000), "test", Math.round(random
					.nextDouble() * 1000.0) + 0.99);
		}
	};
}

// 貨架
class Self extends ArrayList<Product> {
	public Self(int nproduct) {
		Generators.fill(this, Product.gen, nproduct);
	}
}

// 走廊
class Ailse extends ArrayList<Self> {
	public Ailse(int nself, int nproduct) {
		for (int i = 0; i < nself; i++) {
			add(new Self(nproduct));
		}
	}
}

public class Store extends ArrayList<Ailse> {
	public Store(int nailse, int nself, int nproduct) {
		for (int i = 0; i < nailse; i++) {
			add(new Ailse(nself, nproduct));
		}
	}

	public String toString() {
		StringBuilder result = new StringBuilder();
		for (Ailse a : this) {
			for (Self s : a) {
				for (Product p : s) {
					result.append(p);
					result.append("\n");
				}
			}
		}
		return result.toString();
	}

	public static void main(String[] args) {
		Store store = new Store(1, 2, 2);
		System.out.println(store);
	}

}


相關推薦

java基礎總結 -- 泛型 在類、介面、方法、匿名類、元組等使用 堆疊例子 商店模型

為什麼使用泛型：     在面向物件程式語言中，多型算是一種泛化機制。例如，你可以將方法的引數型別設為基類，那麼 該方法就可以接受從這個基類中匯出的任何類作為引數，這樣的方法更通用一些，可應用的地方也多一點。     在類的內部也是如此，凡是能夠使用基類，確實是能夠具備更好

java基礎總結 --- 泛型 擦除、邊界、萬用字元、

* 擦除的問題 * 為什麼要擦除： 1.5版本才出現泛型 為了相容之前地程式碼 * 它使得泛化的客戶端可以用非泛化的類庫來使用。 * 以及不破壞現有類庫的情況下，將泛型融入java語言。 * 擦除使得現有的非泛型客戶端程式碼能夠在不改變的情況繼續使用，直至客戶端準

Java基礎Demo -- 泛型介面的示例

泛型介面 public interface MyInterface<T>{} 的簡單入門示例 /** * 類實現了一個泛型介面,並擴容下 */ interface AI<T> { void sss(T t); } class BI<T,K> imple

Java基礎Demo -- 泛型類的示例

泛型類 public class MyClass<T>{} 的簡單入門示例 /** * 泛型類 class MyClass<T>{} */ class MyGen<T> { private T t; public void setValue(T t){

Java基礎18--泛型--工具類--JDK1.5新特性

18-1，泛型-概述 1，泛型是JDK1.5出現的新技術，新技術的出現是為了解決問題。 2，泛型可以用於明確一個集合中儲存什麼型別的元素 ArrayList<String> al = new ArrayList<String>(); al.add("

java基礎(28)--泛型與型別擦除、泛型與繼承

【泛型與型別擦除】 泛型是JDK 1.5的一項新特性，它的本質是引數化型別（Parameterized Type）的應用，也就是說所操作的資料型別被指定為一個引數。這種引數型別可以用在類、介面和方法的建立中，分別稱為泛型類、泛型介面和泛型方法。 泛

Java基礎：泛型

ret 原來 不能 使用 自定義泛型 編程 讀取數組 yum 實現 　　同樣是面試當中遇到的問題，在平常寫代碼的過程當中，經常有使用到泛型編程，比如用到的各種集合方式，如Arraylist、hashmap、List、等，都有使用到泛型。但是當面試官讓自己系統的介紹一下泛型編

Java基礎學習——泛型

() logs 調用 自定義 sta class string [] lis 一、泛型方法 1 /** 2 3 自定義泛型：自定義泛型可以理解為是一個數據類型的占位符，或者理解為是一個數據類型的變量。 4 5 泛型方法： 6 泛型方法的自定義格式：修飾符&

14. Java基礎之泛型

remove 角度 分享 The 兩個 -a 類型形參 建議 set 引用自：https://www.cnblogs.com/lwbqqyumidi/p/3837629.html ， https://blog.csdn.net/s10461/article/details/

java基礎——3——泛型+異常+IO

在Java釋出的JDK1.5版本中增加了泛型支援，所謂的泛型就是為了讓集合在很大程度上記住元素的資料型別。在沒有使用泛型之前，一旦把物件存放進Java集合中，集合只會將元素作為Object物件進行處理。當從集合中取出物件時就需要進行強制型別轉換。如果轉換錯誤，則將會引起ClassCastEx

java基礎-04泛型

介紹 泛型就是資料型別的引數化表示，泛型的本質是引數化型別，常用E代表任何資料型別，在實際使用的時候把實際的資料型別傳遞給E。 泛型的好處是設計通用的功能，多個數據型別可以共用。 泛型型別E只能代表Object型別，不能代表 int,double等基本型別，要使用Integer,Double代

Java基礎Demo -- 泛型上界的示例

<T extends SuperClass> 泛型上界的定義 <? extends SuperClass> 有界萬用字元的運用 普通泛型方法的運用 靜態泛型方法的運用 class Grandpa { private int x,y; public Gran

【Java基礎】泛型記錄概要

泛型記錄概要 泛型出現重要原因之一:創造容器類 泛型主要目的之一：指定容器持有什麼型別的物件，保證編譯的正確性 泛型簡單例項 class GenericsClass<T>{ private T property; public

Java基礎學習——泛型(generics)二

萬用字元(Wildcard) 考慮一個列印集合內所有元素的問題。下面這個可能是在Java舊版本中的寫法： void printCollection(Collection c) { Iterator i = c.iterator(); fo

Java基礎學習——泛型(generics)學習一

概述 在JDK 5.0，Java語言引入了好幾個新的功能，其中很重要的一個就是泛型(generics)。 本文就是對泛型的一個概述。你可以很熟悉其他語言中的類似結構，比如C++裡的模板(templates)。如果這樣，你將會看到兩者之間有相似，同時也有很大的

JAVA基礎之泛型與集合

一：泛型： 泛型類的定義格式： class class-name  <type -parma-list>{} 例項化泛型類的格式： class-name<type-parma-list> obj = new class-name<type

JAVA基礎知識|泛型

一、什麼是泛型？ 泛型，即“引數化型別”。 比如定義一個變數A，我們可以通過如下方式將這個變數定義為字串型別或者整形。 S

java 基礎總結 -- enum 列舉與介面、泛型、集合的使用

/** * 隨機取得enum中的一個enum例項工具類 * 列舉和泛型的使用 * @author zghw * */ public class Enums { private static

java 獲取 泛型型別（介面及超類）

package generic.portal; /** * Created by Administrator on 2017/1/10. */ public interface GenericInterface<T> { } package gener

java 泛型在類，介面和方法上的應用

雖然我在泛型的使用這塊，應用的地方不是很多，但是還是要總結一下的，這一篇文章主要是從使用的角度，對泛型進行介紹。 如果一個類有一個或者多個型別的變數，那麼這個類就是泛型類，這些型別變數是類的型別引數。下邊這個類是一個簡單的java類，有一個屬性t，它的型別是Object 方