我有一个名为Parent.java的类和4个子类，如Child1.java、Child2.java等。
有两种方法：
还有一个字段：
字段f1基于子类具有不同的值。
方法m1有共同的实现，所以我把它放在了Parent.java类中。它还引用了方法m2。
方法m2有共同的实现，但处理的字段f1对于所有子类都是不同的。
因此我的问题如下：
Q1. 我应该将字段f1放在父类中并让所有子类继承它们并在自己的构造函数中初始化它们，还是应该为所有子类创建一个字段f1？
Q2. 由于方法m2具有共同的实现，但处理的字段f1不是每个子类都具有相同的值，所以我应该将其放在父类或子类中？
Q3. 如果我应该将方法m2放在父类中，那么就会有一个问题，方法m1（具有共同的实现）引用了方法m2，这会创建任何问题吗？
如果m2的实现对于所有类都相同，则将m2和f1放置在父类中。如果每个子类都有特定部分可以在通用部分之后运行-请将其分开并将其放置在子类中，同时调用super.m2()。在每个子类的构造函数中设置f1。
结果将如下所示：
public abstract class parent {
private int field = 0;
public parent(int f) {
field = f;
}
public void m1() { /* m1's implementation */ }
public void m2() { /* m2's common implementation */ }
}
public class child1 {
public child1() {
super(1);
}
@Override
public void m2() { super.m2() /* m2's child1 implementation */ }
}
public class child2 {
public child2() {
super(2);
}
@Override
public void m2() { super.m2() /* m2's child2 implementation */ }
}
这应该允许你将尽可能多的代码推到层次结构的最后面。最少的代码重复。
编辑后修复了从子类中尝试访问私有成员的问题。改为在构造函数中设置它。
我认为:
从您所描述的情况来看，我认为这个实现没有任何问题：
public class Parent {
private int f1;
public Parent(int f1) {
this.f1 = f1;
}
public void m1() { }
public void m2() {
// do something with f1
System.out.println(f1);
}
}
public class Child1 extends Parent {
private final int DEFAULT_FIELD_VALUE = 1;
public Child1() {
super(DEFAULT_FIELD_VALUE);
}
}
public class Child2 extends Parent {
public Child2(int value) {
super(value);
}
}
{...}
你正在尝试的听起来像是模板方法设计模式：http://en.wikipedia.org/wiki/Template_method_pattern
我建议将f1放在父类中，并在父类中声明m2为抽象（这将使该类本身成为抽象类）。
f1的值上有所不同，那么甚至创建子类也没有意义，你应该只需在构造函数中传递f1或使用静态工厂方法为不同情况创建实例。例如：public class Parent {
private Value f1;
private Parent(Value f1) {
this.f1 = f1;
}
public static Parent makeChild1() {
return new Parent(valueOfF1ForChild1);
}
public static Parent makeChild2() {
return new Parent(valueOfF1ForChild2);
}
}
另外，您可能需要检查一下枚举是否适合您的情况。