Java 这段代码正确地演示了多态性吗？（爪哇）

我写了一个小程序来练习和演示Java中的多态性，所以请看一看，让我知道这个想法是否得到了正确的实现

public class Main {

    public static void main(String[] args) {
        porche porche_car = new porche("Porche 9/11",8,"black");

        porche_car.startEngine(true);
        porche_car.accelerate(250);
        porche_car.brake(true);


        Ford ford_car = new Ford("Ford SUV",4,"blue");

        ford_car.startEngine(true);
        ford_car.accelerate(200);
        ford_car.brake(false);
    }
}

public class Car {

    private boolean engine;
    private String name;
    private int cylinders;
    private int wheels;

    public Car(String name, int cylinders)
    {
        this.engine = true;
        this.name = name;
        this.cylinders = cylinders;
        this.wheels = 4;
    }

    public void startEngine(boolean start)
    {
        if(start)
        {
            System.out.println(getName()+"Class.Engine Started.");
        }
        else
        {
            System.out.println(getName()+" Class.Engine Stopped.");
        }
    }

    public void accelerate(int acceleration)
    {
            System.out.println(getName()+" class.Accelerating car at " + acceleration + " Km/h");

    }
    public void brake(boolean applybrake)
    {
        if (applybrake)
        {
            System.out.println(getName()+" class called.Brakes applied.");
        }
        else
        {
            System.out.println(getName()+" class, brakes released.");
        }
    }

    public boolean isEngine() {
        return engine;
    }

    public String getName() {
        return name;
    }

    public int getCylinders() {
        return cylinders;
    }

    public int getWheels() {
        return wheels;
    }
}

public class porche extends Car{
    private String color;
    private int doors;

    public porche(String name, int cylinders, String color) {
        super(name, cylinders);
        this.color = color;
        this.doors = 2;
    }

    @Override
    public void startEngine(boolean start) {
        super.startEngine(start);
    }

    @Override
    public void accelerate(int acceleration) {
        super.accelerate(acceleration);
    }

    @Override
    public void brake(boolean applybrake) {
        super.brake(applybrake);
    }

    public String getColor() {
        return color;
    }

    public int getDoors() {
        return doors;
    }
}

public class Ford extends Car{
    private String color;
    private int doors;

    public Ford(String name, int cylinders, String color) {
        super(name, cylinders);
        this.color = color;
        this.doors = 2;
    }

    @Override
    public void startEngine(boolean start) {
        super.startEngine(start);
    }

    @Override
    public void accelerate(int acceleration) {
        super.accelerate(acceleration);
    }

    @Override
    public void brake(boolean applybrake) {
        super.brake(applybrake);
    }

    public String getColor() {
        return color;
    }

    public int getDoors() {
        return doors;
    }
}

注意：总而言之，我创建了一个基类Car，并对其进行了扩展，以创建另外两个类（Porche和Ford），并且我还跳过了Car类中的方法，以将基类Car的功能添加到其子类中。（为了实现多态性。）实现是否可以接受

更新事实上，我发布的代码是一个挑战，我正在学习udemy（java master class）的课程。在我完成挑战后，我查看了那里给出的解决方案。在该解决方案中，使用了与我类似的方法，该解决方案的代码如下所示：

class Car {
private boolean engine;
private int cylinders;
private String name;
private int wheels;

public Car(int cylinders, String name) {
    this.cylinders = cylinders;
    this.name = name;
    this.wheels = 4;
    this.engine = true;
}

public int getCylinders() {
    return cylinders;
}

public String getName() {
    return name;
}

public String startEngine() {
    return "Car -> startEngine()";
}

public String accelerate() {
    return "Car -> accelerate()";
}

public String brake() {
    return "Car -> brake()";
}

三菱级轿车{

public Mitsubishi(int cylinders, String name) {
    super(cylinders, name);
}

@Override
public String startEngine() {
    return "Mitsubishi -> startEngine()";
}

@Override
public String accelerate() {
    return "Mitsubishi -> accelerate()";
}

@Override
public String brake() {
    return "Mitsubishi -> brake()";
}

public Holden(int cylinders, String name) {
    super(cylinders, name);
}

@Override
public String startEngine() {
    return getClass().getSimpleName() +  " -> startEngine()";
}

@Override
public String accelerate() {
    return getClass().getSimpleName() +  " -> accelerate()";
}

@Override
public String brake() {
    return getClass().getSimpleName() +  " -> brake()";
}

public Ford(int cylinders, String name) {
    super(cylinders, name);
}

@Override
public String startEngine() {
    return "Ford -> startEngine()";
}

@Override
public String accelerate() {
    return "Ford -> accelerate()";
}

@Override
public String brake() {
    return "Ford -> brake()";
}

霍顿级汽车{

public Mitsubishi(int cylinders, String name) {
    super(cylinders, name);
}

@Override
public String startEngine() {
    return "Mitsubishi -> startEngine()";
}

@Override
public String accelerate() {
    return "Mitsubishi -> accelerate()";
}

@Override
public String brake() {
    return "Mitsubishi -> brake()";
}

public Holden(int cylinders, String name) {
    super(cylinders, name);
}

@Override
public String startEngine() {
    return getClass().getSimpleName() +  " -> startEngine()";
}

@Override
public String accelerate() {
    return getClass().getSimpleName() +  " -> accelerate()";
}

@Override
public String brake() {
    return getClass().getSimpleName() +  " -> brake()";
}

public Ford(int cylinders, String name) {
    super(cylinders, name);
}

@Override
public String startEngine() {
    return "Ford -> startEngine()";
}

@Override
public String accelerate() {
    return "Ford -> accelerate()";
}

@Override
public String brake() {
    return "Ford -> brake()";
}

福特级轿车{

public Mitsubishi(int cylinders, String name) {
    super(cylinders, name);
}

@Override
public String startEngine() {
    return "Mitsubishi -> startEngine()";
}

@Override
public String accelerate() {
    return "Mitsubishi -> accelerate()";
}

@Override
public String brake() {
    return "Mitsubishi -> brake()";
}

public Holden(int cylinders, String name) {
    super(cylinders, name);
}

@Override
public String startEngine() {
    return getClass().getSimpleName() +  " -> startEngine()";
}

@Override
public String accelerate() {
    return getClass().getSimpleName() +  " -> accelerate()";
}

@Override
public String brake() {
    return getClass().getSimpleName() +  " -> brake()";
}

public Ford(int cylinders, String name) {
    super(cylinders, name);
}

@Override
public String startEngine() {
    return "Ford -> startEngine()";
}

@Override
public String accelerate() {
    return "Ford -> accelerate()";
}

@Override
public String brake() {
    return "Ford -> brake()";
}

公共班机{

public static void main(String[] args) {
    // We are going to go back to the car analogy.
    // Create a base class called Car
    // It should have a few fields that would be appropriate for a generice car calss.
    // engine, cylinders, wheels, etc.
    // Constructor should initialize cylinders (number of) and name, and set wheels to 4
    // and engine to true. Cylinders and names would be passed parameters.
    //
    // Create appropriate getters
    //
    // Create some methods like startEngine, accelerate, and brake
    //
    // show a message for each in the base class
    // Now create 3 sub classes for your favorite vehicles.
    // Override the appropriate methods to demonstrate polymorphism in use.
    // put all classes in the one java file (this one).

    Car car = new Car(8, "Base car");
    System.out.println(car.startEngine());
    System.out.println(car.accelerate());
    System.out.println(car.brake());

    Mitsubishi mitsubishi = new Mitsubishi(6, "Outlander VRX 4WD");
    System.out.println(mitsubishi.startEngine());
    System.out.println(mitsubishi.accelerate());
    System.out.println(mitsubishi.brake());

    Ford ford = new Ford(6, "Ford Falcon");
    System.out.println(ford.startEngine());
    System.out.println(ford.accelerate());
    System.out.println(ford.brake());

    Holden holden = new Holden(6, "Holden Commodore");
    System.out.println(holden.startEngine());
    System.out.println(holden.accelerate());
    System.out.println(holden.brake());
}

---

首先，您的示例是简单易用的多态性。您已经从基类调用了方法，如上面的注释所述。您不需要重写这些方法来在派生类中使用它们

其次，您在main函数中使用派生类作为变量类型，这样您就不会注意到多态性是如何工作的。您应该改用基类Car

Car porche_car = new Porche("Porche 9/11",8,"black");
porche_car.startEngine(true); // uses method from Porsche class if overriden

---

演示多态性示例的最佳方法是编写一个接受基类参数的方法，并通过传递子类的对象重用该方法

例如：

     public class Test{

     public static void main(String[] args){

         Car c = new Car();
        checkCar(c);
        c = new Ferrari();
        checkCar(c);
        c = new Honda();
        checkCar(c);

     }




    public static void checkCar(Car c){

        c.start();
    }
  }

 class Car{

    public void start(){
        System.out.println("Car Starts");
    }

 };

 class Ferrari extends Car{
    public void start(){
        System.out.println("Ferrari Starts");
    }
 };

 class Honda extends Car{
    public void start(){
        System.out.println("Honda Starts");
    }
 };

---

如果您只调用基类方法，则无需重写方法。不需要。您可以无需重写这些方法，因为它们所做的只是调用超类实现。如果您有两个Car类型的变量，并且如果对这两个变量调用相同的方法会做一些不同的事情，那么多态性将得到更好的说明，因为实际的具体类是不同的，两个类都重写方法来做一些不同的事情。我明白，我的目标只是展示动态多态性的概念，即使我在重写超类中的方法时没有删除或修改功能。使用Car作为基类的原因是什么？@calculusnoob，因为多态性就是这样的所有内容：当你有一辆车时，如果车的实际类型是保时捷，调用polmorphic方法将调用Porsche方法，如果车的实际类型是福特，则调用Ford方法，而不需要你知道具体类型是什么。再次看我的帖子，我提供了更多信息。