Java 对于这种未明确定义的继承，什么是正确的设计模式？

假设我们有一个包含子类mini和sedan的类

Car

，它们都有相同的安全检查，我调用了一个名为safety（）的公共函数，它类似于一个模板。因此：

class Car {
    safety() {
        check1();
        check2();
        check3();
        check4();
    }
}

class Mini extends Car {
    // use the safety() belonging to Car
}


class Sedan extends Car {
    // use the safety() belonging to Car
}

但后来情况发生了变化，我们有了新的类型和新的安全装置

sports

需要检查1、检查3和新检查5

jeep

需要检查1、检查4和新检查6

豪华型

仅需检查2和检查3

---

哪些设计模式可以帮助我们解决这个问题

忘记模式并以适合您的用例的方式实现类。在你的例子中，我认为，安全不是汽车的真正属性，而是应用于汽车的某些程序的结果

---

通过这种方式，您可以相互比较安全性，根据安全性做出决策，汇总安全性或随时间保存安全性。

在我看来，非常适合作为访客模式

有两个基本接口：

public interface Visitable {

    void accept(Visitor visitor);

}

public interface Visitor {

    void visit(Mini mini);

    void visit(Sedan sedan);

}

Visitable的示例实现可能如下所示（请注意accept方法）：

这可能是访问者的示例实现（请注意访问方法）：

这是示例客户机代码：

public class Client {

    public static void main(String[] args) {

        SafetyVisitor safetyVisitor = new SafetyVisitor();

        Mini safeMini = new Mini(6, 6);
        Mini unsafeMini = new Mini(6, 3);
        Sedan safeSedan = new Sedan(6, true, false);
        Sedan unsafeSedan = new Sedan(6, false, false);

        safetyVisitor.visit(safeMini);
        System.out.println("safeMini is safe: " + safetyVisitor.getResult());
        safetyVisitor.visit(unsafeMini);
        System.out.println("unsafeMini is safe: " + safetyVisitor.getResult());
        safetyVisitor.visit(safeSedan);
        System.out.println("safeSedan is safe: " + safetyVisitor.getResult());
        safetyVisitor.visit(unsafeSedan);
        System.out.println("unsafeSedan is safe: " + safetyVisitor.getResult());
    }

}

这里的优点是，您不需要知道正在检查的对象的类型。因此，您可以轻松地获得可访问对象的列表，以便一次检查所有对象。如果是像下面这样的简单检查类，则不可能：

public interface CarSaeftyChecker {

    boolean check(Mini mini);

    boolean check(Sedan sedan);

}

我的设计

将安全作为一个单独的对象，不同的网络安全实现接口安全

interface Safety
{
    boolean isSafe();
    // Each safety will have its own weightage.
    float   weightage();
}

class AirbagSafety extends Safety
{
    public boolean isSafe()
    {
        // TODO: Your impl goes here.
    }

    public float weightage()
    {
        // A constant
    }
}

让汽车具备一些标准的安全功能，以通过政府法规

class Car
{
    Safety[] standardSafety;  // As prescribed by government.

    public float standardSafetyPoint()
    {
        float safetyPoint;
        for (Safety s : standardSafety) { s.isSafe() ? safetyPoint + weightage(); }
        return safetyPoint;
    }
}

让每辆车都有自己的安全点

 

class Sedan extends Car
{
    Safety[] sedanSafety;

    public int safetyPoint()
    {
        float safetyPoint = 0;
        safetyPoint += super.standardSafetyPoint();
        // do a while loop like above and calculate the specific safety point.
        return safetyPoint;
    }
}

---

这样，您可以更好地控制安全。您可以专门设计BMW安全等级，继承许多安全性，并将它们放在您的BMW汽车中，等等。

不确定模式是什么-可能-但我会按照您的想法编写代码：

enum Check {

    Brakes {
                @Override
                boolean pass(Vehicle vehicle) {
                    return checkBrakes(vehicle);
                }
            },
    Lights {
                @Override
                boolean pass(Vehicle vehicle) {
                    return checkLights(vehicle);
                }
            },
    Steering {
                @Override
                boolean pass(Vehicle vehicle) {
                    return checkSteering(vehicle);
                }
            },
    Oil {
                @Override
                boolean pass(Vehicle vehicle) {
                    return checkOil(vehicle);
                }
            },
    Suspension {
                @Override
                boolean pass(Vehicle vehicle) {
                    return checkSuspension(vehicle);
                }
            };

    abstract boolean pass(Vehicle vehicle);
}

enum Vehicle {

    Car(Check.Brakes, Check.Lights, Check.Oil, Check.Steering),
    Mini(Car, Check.Suspension);

    Set<Check> checks = EnumSet.noneOf(Check.class);

    Vehicle(Check... checks) {
        this.checks.addAll(Arrays.asList(checks));
    }

    Vehicle(Vehicle like, Check... checks) {
        this.checks.addAll(like.checks);
        this.checks.addAll(Arrays.asList(checks));
    }

    public Set<Check> fail () {
        Set<Check> failed = EnumSet.noneOf(Check.class);
        for ( Check check : checks ) {
            if ( !check.pass(this) ) {
                failed.add(check);
            }
        }
        return failed;
    }
}

private static boolean checkBrakes(Vehicle vehicle) {
    return true;
}

private static boolean checkLights(Vehicle vehicle) {
    return true;
}

private static boolean checkSteering(Vehicle vehicle) {
    return true;
}

private static boolean checkOil(Vehicle vehicle) {
    return true;
}

private static boolean checkSuspension(Vehicle vehicle) {
    return true;
}

枚举检查{
刹车{
@凌驾
布尔通行证（车辆）{
返回检查制动器（车辆）；
}
},
灯光{
@凌驾
布尔通行证（车辆）{
返回检查灯（车辆）；
}
},
操舵{
@凌驾
布尔通行证（车辆）{
返回检查转向（车辆）；
}
},
油{
@凌驾
布尔通行证（车辆）{
回油检查（车辆）；
}
},
暂停{
@凌驾
布尔通行证（车辆）{
返回检查悬架（车辆）；
}
};
抽象布尔通行证（车辆）；
}
枚举车辆{
汽车（检查刹车，检查灯，检查油，检查转向），
迷你（汽车，检查，悬挂）；
Set checks=EnumSet.noneOf（Check.class）；
车辆（检查……检查）{
this.checks.addAll（Arrays.asList（checks））；
}
车辆（类似车辆，检查…检查）{
this.checks.addAll（比如.checks）；
this.checks.addAll（Arrays.asList（checks））；
}
公共集失败（）{
Set failed=EnumSet.noneOf（Check.class）；
用于（检查：检查）{
如果（！检查通过（此））{
失败。添加（检查）；
}
}
返回失败；
}
}
专用静态制动器（车辆）{
返回true；
}
专用静态布尔检查灯（车辆）{
返回true；
}
专用静态转向（车辆）{
返回true；
}
专用静态布尔检查油（车辆）{
返回true；
}
专用静态悬架（车辆）{
返回true；
}

您只需将check方法公开为受保护的方法，并让子类覆盖safety（）通过调用他们想要的任何检查方法。策略和装饰模式可能会有所帮助。使用这些检查抽象方法使Car类抽象，并按照@JBNizet所说的将这些检查实现为适当的子类。我将非常感谢详细说明。我编辑了我的文章，提供了示例实现。

class Car
{
    Safety[] standardSafety;  // As prescribed by government.

    public float standardSafetyPoint()
    {
        float safetyPoint;
        for (Safety s : standardSafety) { s.isSafe() ? safetyPoint + weightage(); }
        return safetyPoint;
    }
}

 

class Sedan extends Car
{
    Safety[] sedanSafety;

    public int safetyPoint()
    {
        float safetyPoint = 0;
        safetyPoint += super.standardSafetyPoint();
        // do a while loop like above and calculate the specific safety point.
        return safetyPoint;
    }
}

enum Check {

    Brakes {
                @Override
                boolean pass(Vehicle vehicle) {
                    return checkBrakes(vehicle);
                }
            },
    Lights {
                @Override
                boolean pass(Vehicle vehicle) {
                    return checkLights(vehicle);
                }
            },
    Steering {
                @Override
                boolean pass(Vehicle vehicle) {
                    return checkSteering(vehicle);
                }
            },
    Oil {
                @Override
                boolean pass(Vehicle vehicle) {
                    return checkOil(vehicle);
                }
            },
    Suspension {
                @Override
                boolean pass(Vehicle vehicle) {
                    return checkSuspension(vehicle);
                }
            };

    abstract boolean pass(Vehicle vehicle);
}

enum Vehicle {

    Car(Check.Brakes, Check.Lights, Check.Oil, Check.Steering),
    Mini(Car, Check.Suspension);

    Set<Check> checks = EnumSet.noneOf(Check.class);

    Vehicle(Check... checks) {
        this.checks.addAll(Arrays.asList(checks));
    }

    Vehicle(Vehicle like, Check... checks) {
        this.checks.addAll(like.checks);
        this.checks.addAll(Arrays.asList(checks));
    }

    public Set<Check> fail () {
        Set<Check> failed = EnumSet.noneOf(Check.class);
        for ( Check check : checks ) {
            if ( !check.pass(this) ) {
                failed.add(check);
            }
        }
        return failed;
    }
}

private static boolean checkBrakes(Vehicle vehicle) {
    return true;
}

private static boolean checkLights(Vehicle vehicle) {
    return true;
}

private static boolean checkSteering(Vehicle vehicle) {
    return true;
}

private static boolean checkOil(Vehicle vehicle) {
    return true;
}

private static boolean checkSuspension(Vehicle vehicle) {
    return true;
}