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

例如，我有一个父类：

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（）。还有比这更好的办法吗？

---

非常感谢您的任何回复。

< P>我将创建一个抽象类（如果没有实际的功能提供，考虑把它变成一个接口）：

然后，我将根据您需要的不同实现对其进行多次扩展：

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

及

然后将这些子类划分为以下子类：

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

及

---

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

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"; }
}

并让子类继承相应的基（例如，child 1-3扩展

StringedChild

，4-6扩展

StringlessChild

）

一般来说，拥有大量重复功能意味着这些子级的行为有一些非常常见的地方，这表明实现该行为的公共根可能是合适的

---

请注意，抽象基础或接口之类的东西在这里也可能是按顺序排列的（正如一些问题注释中所指出的），为了清晰起见，上面的示例仅限于简化的/人为的示例。

这样做-在两者之间使用另一层：

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

---

有没有一个特殊的原因使得

Parent

不是

abstract

，并且不只是实现重复的方法？您可以在Parent中编写一个实现，而只重写其他实现类…没有特殊的原因。父对象可以是抽象的。我只是举个例子BRSO05：如果我这样做了，那么我仍然需要做3次超控，对吗？不；如果您将类抽象化并在那里实现冗余方法，那么在不重写它的情况下进行日志记录，它将具有相同的功能。忘记让子类

扩展父类

，并填充这个想法——如果您有两组方法，

getString（）

和

getFoo（）

，其中“另一个类”divide不匹配（即，有些类使用getString-A，但使用getFoo-B），那么您的类可能应该被拆分为两个单独的类，每个类都有自己的层次结构。换句话说，这可能表明您的类正在尝试做太多的事情。我认为父类应该是抽象的，因为

getString（）

方法在所有子类中都被重写。@TheMetalBeard可能，在这个奇怪的不现实的小示例中，但就像我在最后一段中试图理解的那样，这并不是这个问题的实质，也不在这个答案的范围之内。将

Intermediate2

作为一个抽象类有什么好处？我认为使父类成为抽象类是一个更好的解决方案，因为

getString（）

方法在任何地方都会被覆盖。

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"; }
}

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