Java自學-泛型 支援泛型的類

Java 如何設計支援泛型的類

步驟 1 : 不支援泛型的Stack

以Stack棧為例子，如果不使用泛型

當需要一個隻能放Hero的棧的時候，就需要設計一個HeroStack

當需要一個隻能放Item的棧的時候，就需要一個ItemStack

package generic;
   
import java.util.LinkedList;
 
import charactor.Hero;
   
public class HeroStack {
   
    LinkedList<Hero> heros = new LinkedList<Hero>();
       
    public void push(Hero h) {
        heros.addLast(h);
    }
   
    public Hero pull() {
        return heros.removeLast();
    }
   
    public Hero peek() {
        return heros.getLast();
    }
       
    public static void main(String[] args) {
           
        HeroStack heroStack = new HeroStack();
        for (int i = 0; i < 5; i++) {
            Hero h = new Hero("hero name " + i);
            System.out.println("壓入 hero:" + h);
            heroStack.push(h);
        }
        for (int i = 0; i < 5; i++) {
            Hero h =heroStack.pull();
            System.out.println("彈出 hero" + h);
        }
    }
   
}
package generic;
   
import java.util.LinkedList;
 
import property.Item;
   
public class ItemStack {
   
    LinkedList<Item> Items = new LinkedList<Item>();
       
    public void push(Item h) {
        Items.addLast(h);
    }
   
    public Item pull() {
        return Items.removeLast();
    }
   
    public Item peek() {
        return Items.getLast();
    }
       
    public static void main(String[] args) {
           
        ItemStack ItemStack = new ItemStack();
        for (int i = 0; i < 5; i++) {
            Item item = new Item("Item name " + i);
            System.out.println("壓入 Item:" + item);
            ItemStack.push(item);
        }
        for (int i = 0; i < 5; i++) {
            Item item =ItemStack.pull();
            System.out.println("彈出 Item" + item);
        }
    }
   
}
           

步驟 2 : 支援泛型的Stack

設計一個支援泛型的棧MyStack

設計這個類的時候，在類的聲明上，加上一個，表示該類支援泛型。

T是type的縮寫，也可以使用任何其他的合法的變量，比如A,B,X都可以，但是一般約定成俗使用T，代表類型。

package generic;
   
import java.util.HashMap;
import java.util.LinkedList;
 
import charactor.Hero;
import property.Item;
   
public class MyStack<T> {
   
    LinkedList<T> values = new LinkedList<T>();
       
    public void push(T t) {
        values.addLast(t);
    }
   
    public T pull() {
        return values.removeLast();
    }
   
    public T peek() {
        return values.getLast();
    }
       
    public static void main(String[] args) {
        //在聲明這個Stack的時候，使用泛型<Hero>就表示該Stack隻能放Hero
        MyStack<Hero> heroStack = new MyStack<>();
        heroStack.push(new Hero());
        //不能放Item
        heroStack.push(new Item());
         
        //在聲明這個Stack的時候，使用泛型<Item>就表示該Stack隻能放Item
        MyStack<Item> itemStack = new MyStack<>();
        itemStack.push(new Item());
        //不能放Hero
        itemStack.push(new Hero());
    }
   
}