如果它的基本方法失败，如何打破重写方法？

Question

我的Parent类中有一个名为validateData的方法。 在我的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在compile time编译parent method ，并在runtime执行child method 。 这意味着子类会覆盖父类方法。

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

如果要阻止子方法执行，则创建parent对象，如parent p = new parent(); 那么子方法将不会执行。