Question

例如，我有一个父类：

public class Parent {
    public String getString() {
        return "";
    }
}

一组子类覆盖getString（）并返回相同的结果：

public class Child1 extends Parent {
    @Override
    public String getString() {
        return "return a string";
    }
}

public class Child2 extends Parent {
    @Override
    public String getString() {
        return "return a string";
    }
}

public class Child3 extends Parent {
    @Override
    public String getString() {
        return "return a string";
    }
}

另一组子类也返回相同的结果：

public class Child4 extends Parent {
    @Override
    public String getString() {
        return "return nothing";
    }
}

public class Child5 extends Parent {
    @Override
    public String getString() {
        return "return nothing";
    }
}

public class Child6 extends Parent {
    @Override
    public String getString() {
        return "return nothing";
    }
}

结果是，我必须编写相同的实现来重写getString（）很多次。还有比这更好的方法吗？非常感谢您的回复。

Answer 1

如果您发现自己这样做，那么在层次结构中创建另一个类来执行这样的公共逻辑是一个很好的例子，并将每个子类的内容留给子类。例如，在您的情况下，您可能会有：

public class Parent {
    public String getString () { return ""; }
}

public class StringlessChild extends Parent {
    @Override public String getString () { return "nothing"; }
}

public class StringedChild extends Parent {
    @Override public String getString () { return "a string"; }
}

让子类继承适当的基础（例如，子1-3扩展StringedChild，4-6扩展StringlessChild）。

通常，具有大量重复功能意味着这些子行为的行为有一些共同点，这表明实现该行为的公共根可能是合适的。

请注意，抽象基础或接口之类的东西也可能在这里（如某些问题评论中所指出的那样），上面的例子只是为了清楚起见，只是坚持你的简化/设计的例子。

Answer 2

这样做 - 在中间使用另一层：

public class Parent {
    public String getString() {
        return "";
    }
 }

 //This class can be abstract even the parent is not.
 public abstract class Intermediate1 extends Parent {
     public String getString() {
        return "Do something";
     }
 }

 public class Child1 extends Intermediate1 {
     //Do something here
     //The getString method is inherited and will return "return a string"
 }
 //Do the same for Child2 and Child3

因此，对于第二个返回值，您只需添加另一个中级类，而不需要重复代码：

 public abstract class Intermediate2 extends Parent {
     public String getString() {
        return "return another string";
     }
 }

 public class Child4 extends Intermediate2 {
     //Do something here
     //The getString method is inherited and will return "return another string"
 }
 //Do the same for Child5 and Child6

Answer 3

我会创建一个抽象类（如果没有提供实际功能，请考虑将其设置为接口）：

public abstract class Parent {
    public abstract String getString();
}

然后，我会多次扩展它，因为你需要不同的实现：

public class Child1 extends Parent {
    public String getString(){
        return "return a string"
    }
}

和

public class Child2 extends Parent {
    public String getString(){
        return "return nothing"
    }
}

然后继承那些孩子：

public class Child3 extends Child1 {
    //other methods, variables... etc. 
    //no need to override getString(). It will return "return a string"
}

和

public class Child4 extends Child2 {
    //other methods, variables... etc. 
    //no need to override getString(). It will return "return nothing"
}

重写方法时如何避免重复？

3 个答案: