擴展一個通用持有者類，讓它只接受特定的對象？

Question

我想了解並完成任務，試圖創建一個類來擴展一個接受所有類的類的泛型類。到目前爲止，我有這樣的工作。我正在嘗試創建一個擴展通用持有者類的類，並讓此類僅接受特定的對象。

示例，名爲「ComputerOrder」的類將不接受Apple或Orange對象，而只接受ComputerPart或Peripheral對象，如主板或打印機對象。一直堅持了2周。我不能爲了我的生活想出這個概念。任何幫助，將不勝感激。

abstract class Product{ 
    protected float price; 
    abstract float price(); 
    public String toString() { 
     return "Price = " + String.valueOf(price) + " "; 
    } 
} 

class Apple extends Product{} 
class Orange extends Product{} 

class ComputerPart extends Product{ 
    public ComputerPart(float p){ 
     price = p; 
    } 
    public float price() { 
     return price; 
    } 
} 

class Motherboard extends ComputerPart{ 
    protected String manufacturer; 
    public Motherboard(String mfg, float p) { 
     super(p); 
     manufacturer = mfg; 
} 
    public String getManufacturer() { 
     return manufacturer; 
    } 
} 

class Peripheral extends Product{ 
    public Peripheral(float p) { 
     price = p; 
    } 
    public float price() { 
     return price; 
    } 
} 

class Printer extends Peripheral{ 
    protected String model; 
    public Printer(String model, float p) { 
     super(p); 
     this.model = model; 
    } 
    public String getModel() { 
     return model; 
    } 
} 

class Cheese extends Product{ 
    public Cheese(float p) { 
     price = p; 
    } 
    public float price() { 
     return price; 
    } 
} 

class Cheddar extends Cheese{ 
    public Cheddar(float p) { 
     super(p); 
    } 
} 

class GenericOrder<T>{ 
    public ArrayList<T> storage = new ArrayList<T>(); 
    private static int counter = 1; 
    public final int id; 
    public T obj; 
    public GenericOrder(){ 
     id = counter; 
     counter++; 
    } 
    public void add(T item){ 
     storage.add(item); 
    } 
    public T get(int in){ 
     return obj; 
    } 
    public void getId(){ 
     System.out.println(this.id); 
    } 
    public String toString(){ 
     String ret = ""; 
     Iterator<T> it = storage.iterator(); 
     while (it.hasNext()) { 
      ret += it.next() + "\n"; 
     } 
     return ret; 
    } 
} 

class ComputerOrder extends GenericOrder { 
    public void add(ComputerPart in){ 
     if(in instanceof ComputerPart){ 
      storage.add(in); 
     } 
    } 
} 

public class Tme2{ 
    public static void main(String[] args){ 
     ComputerOrder com = new ComputerOrder(); 
     com.add(new Motherboard("bla", 3.33f)) 
    } 
} 

Answer 1

你可以這樣說：

class ComputerOrder<T extends ComputerProduct> extends GenericOrder<T> { 
    //... 
} 

這裏，ComputerProduct是擴展Product和你所有的計算機產品，如ComputerPart或Peripheral擴展ComputerProduct類。同樣的，你可以創建一個類FoodProduct從Product，源於其Apple，Orange和Cheese推導：

class FoodOrder<T extends FoodProduct> extends GenericOrder<T> { 
    //... 
} 

聲明<T extends ComputerProduct>是類型限制，這保證了所有類型的T從ComputerPart衍生，否則你會得到一個編譯器錯誤。

的ComputerOrder類仍然是通用的，所以你可以實例的所有計算機產品的訂單：

ComputerOrder order = new ComputerOrder<ComputerProduct>(); 
// Add peripherals, printers, motherboards... 
// Apples, ... will throw compiler errors... 

但你也可以將它限制爲僅外設：

ComputerOrder order = new ComputerOrder<Peripheral>(); 
// Add peripherals, printers,... 
// Apples, motherboards (ComputerProduct, but NOT Peripheral) will fail...