Question

我的validateData类中有一个名为Parent的方法。在我的Child类中，我重写了该方法，添加了一些其他功能。如果一切正常，我需要调用名为sendData()的方法。这是我的Java代码：

  public class Parent {

    protected int sum;
    protected double commission;

    protected void validateData() {
        if (!isSumWrittenCorrectly()) {
            return;
        }

        performData();
    }

    private boolean isSumWrittenCorrectly() {
        if (sum < 100) {
            return false;
        }

        return true;
    }


    protected void performData() {
        commission = sum * 0.02;
    }


}


class Child extends Parent {
    private String email;

    @Override
    protected void validateData() {
        super.validateData();

        if (!isEmailWrittenCorrectly()) {
            return;
        }

        performData();
    }

    @Override
    protected void performData() {
        super.performData();


        sendData(email, commission, sum);

    }
}

因此，问题是，即使sum可以被错误地写入，子类的performData仍可以被调用。如何预防呢？我有个想法，validateData需要返回boolean，在我的子班级中，我通过super关键字进行检查。但这是一个坏主意。那么，如果基础方法失败，如何中断被覆盖的方法呢？

Answer 1

我建议您让performData()检查是否可以通过验证，这样会容易得多。您可能还希望使performData() public在班级之外可以访问。

public class Parent {

    protected int sum;
    protected double commission;

    protected boolean validateData() {
        return isSumWrittenCorrectly();
    }

    private boolean isSumWrittenCorrectly() {
        if (sum < 100) {
            return false;
        }
        return true;
    }

    protected void performData() {
        if(!validateData()) {
            return;
        }
        commission = sum * 0.02;
    }
}


class Child extends Parent {

    private String email;

    @Override
    protected boolean validateData() {
        if(!super.validateData()) {
            return false;
        }
        if (!isEmailWrittenCorrectly()) {
            return false;
        }
        return true;
    }

    @Override
    protected void performData() {
        super.performData();
        if(!validateData()) {
            return;
        }
        sendData(email, commission, sum);
    }
}

最后，在验证失败的情况下抛出异常也可能会更容易，这将节省一些true false比较。

public class Parent {

    protected int sum;
    protected double commission;

    protected void validateData() {
        if(!isSumWrittenCorrectly()) {
            throw new IllegalArgumentException("sum is not correct");
        }
    }

    private boolean isSumWrittenCorrectly() {
        if (sum < 100) {
            return false;
        }
        return true;
    }


    protected boolean performData() {
        validateData();
        commission = sum * 0.02;
    }
}


class Child extends Parent {

    private String email;

    @Override
    protected boolean validateData() {
        super.validateData();
        if (!isEmailWrittenCorrectly()) {
            throw new IllegalArgumentException("email is not correct")
        }
    }

    @Override
    protected void performData() {
        validateData();
        super.performData();
        sendData(email, commission, sum);
    }
}

Answer 2

以下是一种常见的技术。不幸的是，依赖于致电super.validateData的需要。

public class Parent {
    protected boolean validateData() { ... }

public class Child extends Parent {
    protected boolean validateData() {
        if (!super.validateData()) {
            return false;
        }
        ...
    }

或者，您可以在其中拆分功能

提供服务（public final validateData）和
提供（protected dataValidate/onValidateData）的要求。

所以：

public class Parent {
    public final void validateData() {
        boolean valid = dataValidated();
        ...
    }
    protected boolean dataValidated() {
        return true;
    }

public class Child extends Parent {
    @Override
    protected boolean dataValidated() {
        ...
    }

这允许父类控制行为，例如，为受保护的回调方法提供参数。

Answer 3

进入method overriding时，JVM在parent method中编译compile time，并在runtime处执行child method。这意味着子类将覆盖父类的方法。

您的validateData方法不会返回boolean，因为它的return类型是void。

如果要阻止子方法执行，则创建一个parent之类的对象，例如parent p = new parent();，则子方法将不会执行。

如果基础方法失败，该如何中断替代方法？

3 个答案: