重用繼承在Java

Question

定義一個方法我是一個新的Java開發人員，我會見了在Java中繼承的概念了一些困難來定義我的課......

在一邊，我有一個泛型類名爲車輛，它定義了幾十年的屬性（與他們的getter/setters）。我有一個Vehicle1類延伸車輛類。

在另一邊，我有一個通用的CLASSE名爲VehicleFactory定義一個單一的靜態方法是這樣的：

public class VehicleFactory { 

    protected static Vehicle makeResult() { 
     Vehicle result = new Vehicle(); 

     result.setCode("1"); 
     result.setNumber("2"); 
     // other setters methods 
     return result; 
    } 

的問題是，我想創建一個Vehicle1Factory類都有自己的makeResult方法，它使用其父類的makeResult方法。但我沒有做到這一點（這裏的目標是優化，因爲Vehicle1擁有Vehicle類的所有通用屬性，但有一些額外的屬性）。

我試着寫是這樣的：

public class Vehicle1Factory extends VehicleFactory { 

    protected static Vehicle1 makeResult() { 
     Vehicle1 result = new Vehicle1(); 

     result = (Vehicle1) VehicleFactory.makeResult(); 

     // I want to reuse the makeResult of its parent class to define 
     // its own makeResult method 
    } 
} 

但我這樣做的時候，Java的告訴我，有一個ClassCastException和我不能在這裏使用的投...

在這種情況下是否有解決方案？

Answer 1

一旦創建了Something的實例，它就永遠不會成爲別的東西的實例。由於VehicleFactory.makeResult創建了Vehicle實例，因此無法將其轉換爲Vehicle1。 您必須爲此創建new Vehicle1。

一個解決方案可以是移動你想重用的工具方法的代碼，例如：

class Vehicle { } 

class Bike extends Vehicle { } 

class VehicleFactory { 
    static Vehicle create() { 
     Vehicle vehicle = new Vehicle(); 
     initialize(vehicle); 
     return vehicle; 
    } 

    private static void initialize(Vehicle vehicle) { 
     result.setCode("1"); 
     result.setNumber("2"); 
     // ... 
    } 
} 

class BikeFactory { 
    static Bike create() { 
     Bike bike = new Bike(); 
     VehicleFactory.initialize(bike); 
     return bike; 
    } 
} 

Answer 2

ClassCastException發生是因爲您要將Vehicle投射到Vehicle1;

爲什麼你不能這樣做？因爲如果對象類型爲參考類型下的Vehicle1，則可以投射它。

public class Vehicle1Factory extends VehicleFactory { 

    protected static Vehicle1 makeResult() { 
     // Change reference type to Vehicle 
     Vehicle result = VehicleFactory.makeResult(); 

     // I want to reuse the makeResult of its parent class to define 
     // its own makeResult method 
    } 
} 

讓我們試圖澄清鑄造的所有黑暗點。

Super sub1 = new Sub(); // No casting required! 
Super super1 = new Super(); 
Sub sub2 = new Sub(); 
sub2 = (Sub) sub1; // Casting required, because reference type is Super, but it's okay because real object under the reference is Sub(); 
sub2 = (Sub) super1(); // ClassCastException because real object is of Super type 

在最後一行演員告訴編譯器不要擔心，我是一個優秀的程序員，我知道我在做什麼，並通過超類引用引用的對象在實際上是子類的運行。所以沒有編譯時錯誤。但在運行時，這會失敗，因爲實際對象不是Sub，而是Super。

Answer 3

由於ClassCastException異常問題已回答。我想給你一些關於你如何設置抽象的評論。

1）在抽象類中定義抽象工廠概念通常是一個好主意。

2）我沒有看到「保護」和「靜態」在一起的一點。除非你的類只能被相同包中的子類和類使用。

3）擴展具體類，只是使用它的靜態方法是沒有意義的。將靜態和繼承混合在一起通常是不好的做法。

反正這裏是示例代碼與清潔抽象的定義：

public class Vehicle { 
    private int code = 0; 
    private int number = 0; 

    public int getCode() { 
     return code; 
    } 

    public void setCode(int code) { 
     this.code = code; 
    } 

    public int getNumber() { 
     return number; 
    } 

    public void setNumber(int number) { 
     this.number = number; 
    } 
} 

public class Vehicle1 extends Vehicle { 
    private String engine = null; 

    public String getEngine() { 
     return engine; 
    } 

    public void setEngine(String engine) { 
     this.engine = engine; 
    } 
} 

public abstract class AbstractVehicleFactory<T extends Vehicle> { 

    protected T makeVehicle() { 
     T result = create(); 

     result.setCode(11); 
     result.setNumber(24); 

     return result; 
    } 

    protected abstract T create(); 
} 

public class VehicleFactory extends AbstractVehicleFactory<Vehicle> { 

    public static Vehicle makeResult(){ 
     return new VehicleFactory().makeVehicle(); 
    } 

    @Override 
    protected Vehicle makeVehicle() { 
     Vehicle result = super.makeVehicle(); 
     return result; 
    } 

    @Override 
    protected Vehicle create(){ 
     return new Vehicle(); 
    } 
} 

public class Vehicle1Factory extends AbstractVehicleFactory<Vehicle1> { 

    public static Vehicle1 makeResult(){ 
     return new Vehicle1Factory().makeVehicle(); 
    } 

    @Override 
    protected Vehicle1 makeVehicle() { 
     Vehicle1 result = super.makeVehicle(); 

     result.setEngine("V8"); 

     return result; 
    } 

    @Override 
    protected Vehicle1 create(){ 
     return new Vehicle1(); 
    } 
} 

Answer 4

的問題是一個向下轉換的問題。認爲在Vehicle中有X和Y參數，但在Vehicle1中加入Z參數。 Vehicle1擁有它們全部3個作爲Vehicle的女兒。當你將它投到車輛上時，它只是隱藏Z的參考，但是當你將車輛投射到車輛1時，由於車輛1的Z變量未初始化，所以出現了投擲問題。

在方法中初始化vehicle1並設置參數。 as

public class 

    Vehicle1Factory extends VehicleFactory { 

    protected static Vehicle1 makeResult(){ 
     Vehicle1 result = new Vehicle1(); 
     Vehicle veh = (Vehicle1) VehicleFactory.makeResult(); 
     result.setCode(veh.getCode); 
     result.setNumber(veh.getNumber); 
     return result; 
    } 
}