重用继承在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; 
    } 
}