我正在尝试在Java中创建一个父类，它将静态变量传递给它的每个子类，以便每个子类都有自己的副本。
以下是代码示例：
import java.util.*;
public class JavaFiddle {
public static void main(String[] args) {
Animal rex = new Dog("Rex", 3.2, 'M');
Animal luna = new Dog("Luna", 1.2, 'M');
Animal sadie = new Dog("Sadie", 0.1, 'F');
Animal daisy = new Dog("Daisy", 5.9, 'F');
Animal snowball = new Cat("Snowball", 3.8, 'M');
Animal tiger = new Cat("Tiger", 9.8, 'M');
System.out.println(Dog.getCount()); // output => 4
System.out.println(Cat.getCount()); // output => 2
}
}
class Animal {
protected static final List<Animal> list = new ArrayList<>(); // Each child class should get it's own static list
String name;
double age;
char gender;
Animal (String name, double age, char gender) {
this.name = name;
this.age = age;
this.gender = gender;
list.add(this); // This should add the child object to the the static list in the child class
}
public static int getCount() { // This should return the size of the static list for the child class
return list.size();
}
}
class Dog extends Animal {
protected static final List<Dog> list = new ArrayList<>(); // I don't want to have to add this for each child class. It should just get a copy from the parrent.
Dog (String name, double age, char gender) {
super(name, age, gender);
list.add(this); // I don't want to have to add this for each child class. It should just be added from the parrent.
// other stuff
}
public static int getCount() { // I don't want to have to add this for each child class. It should just get a copy from the parrent.
return list.size();
}
}
class Cat extends Animal {
protected static final List<Cat> list = new ArrayList<>(); // I don't want to have to add this for each child class. It should just get a copy from the parrent.
Cat (String name, double age, char gender) {
super(name, age, gender);
list.add(this); // I don't want to have to add this for each child class. It should just be added from the parrent.
// other stuff
}
public static int getCount() { // I don't want to have to add this for each child class. It should just get a copy from the parrent.
return list.size();
}
}
我不想在每个子类中重新创建这些类和变量中的每一个。这会破坏拥有父母的目的。
这是否可能，或者我是否必须为每一个构建它？我想我可能会使用<T>这样的事情，就像他们List<T> ...那样，但我对此知之甚少，甚至不知道什么。
任何帮助都会很棒。
答案 0 :(得分：1)
另一个答案概述了如何做到这一点的技术解决方案。
但除此之外，我在这里有一个明显的非答案：不要这样做！
假设我们正在谈论＆＃34;现实世界＆＃34; OO设计和最佳实践 - 然后问题中显示的代码将提供数小时广泛的材料＆＃34;为什么不这样做OO＆＃34;讨论：
静态更多是一个好的OOP异常。将字段暴露给子类的想法也是如此。 OOP中的密钥事物是多态性 - 通过子类化和覆盖方法来改变行为的能力。一旦你开始使用 static 告别多态。 然后：字段是一个实现细节 - 它们不应该被其他类使用。
如果忽略这些基本规则，最终会得到遍布各处的代码。使用不同类的想法是构建可以尽可能孤立地工作的独立单元。
你的方法归结为恰恰相反。您可能无法在一个地方进行单一更改 - 因为您最有可能在大多数时间必须更改其他地方。
从这个意义上说：退后一步，再看看你想要解决的问题。然后提出一个遵循良好OOP实践的设计 - 而不是否定它们。
提供一些更实际的建议：乍一看，在您的类中有一个计算实例数的静态列表可能看起来非常方便。但这是对Single Responsibility Principle的直接违反。你看，真实的业务逻辑对象应该有一个非常明确的目的。您可以创建类，并实例化这些类的对象，因为它在您的模型中是有意义的。你的模型很好，是现实世界的典范。你打算代表什么的东西。来自那里：狗或猫是否了解其他狗或猫？并不是的。所以应该是你的代码。如果你有充分的理由保留＆＃34;实例化对象列表＆＃34; - 然后使用特定的类。您正试图让动物也成为动物清单管理员。并且为了实现您仍然需要零使用静态。您可以使用工厂来创建对象，并且该工厂可以使用该ListKeeper实现。只是为了记录：你明白只是在这样的列表中保留引用会导致内存泄漏？因为这些对象永远不会变成垃圾，所以你只需要不断添加新对象......
所以，再说一遍：你不需要或不想要那个静态的继承列表 - 因为在一个好的OO模型中，你会有一个独特的类来负责管理这些事情。
想象一下，例如，单个列表在某一点上不再起作用。也许你想在不同的名单中组织不同的狗？这意味着你必须更新狗类 - 虽然＆＃34;组织狗在不同的列表＆＃34;对于Dog类本身有没有。
然后你希望你的课程为open for extension but closed for modification。在你的情况下，这看起来像这样：
public abstract class Animal {
private final String name;
public Animal(String name) {
this.name = Objects.requireNonNull(name, "name must not be null"); }
private final String getName() { return name; }
public abstract foo();
public abstract String getEnhancedName();
换句话说：您只使用 protected 和＆＃34;字段继承＆＃34;如果有充分的理由这样做。因为，如上所述：字段是实现细节 - 和没有其他类（或者您的孩子）应该知道这些事情。或者您的信用卡可用给您的孩子？不 - 如果有的话，你提供一个＆＃34; getter＆＃34;允许你保持一定程度的控制。你不要只是把你的钱包放在桌子上并告诉你的孩子：＆＃34;现在你可以按照自己的意愿去使用我的信用卡了。
答案 1 :(得分：0)
import java.util.*;
public class Animal {
protected static final List<Animal> list = new ArrayList<>(); // Each child class should get it's own static list
String name;
double age;
char gender;
Animal(String name, double age, char gender) {
this.name = name;
this.age = age;
this.gender = gender;
list.add(this); // This should add the child object to the the static list in the child class
}
public static int getCount() { // This should return the size of the static list for the child class
return list.size();
}
}
class Dog extends Animal {
Dog(String name, double age, char gender) {
super(name, age, gender);
}
}
class Cat extends Animal {
Cat(String name, double age, char gender) {
super(name, age, gender);
}
public static void main(String[] args) {
Animal rex = new Dog("Rex", 3.2, 'M');
Animal luna = new Dog("Luna", 1.2, 'M');
Animal sadie = new Dog("Sadie", 0.1, 'F');
Animal daisy = new Dog("Daisy", 5.9, 'F');
Animal snowball = new Cat("Snowball", 3.8, 'M');
Animal tiger = new Cat("Tiger", 9.8, 'M');
for(Animal anim : Animal.list){
if(anim instanceof Dog){
System.out.println("Dog");
}else if(anim instanceof Cat){
System.out.println("Cat");
}
}
}
}
这输出： 狗 狗 狗 狗 猫 猫
答案 2 :(得分：0)
您可以在Animal
public class Animal {
private static final Map<Class, List<Animal>> map = new HashMap<>();
Animal (String name, double age, char gender) {
//...
map.computeIfAbsent(this.getClass(), key -> new ArrayList<>()).add(this);
}
public static int getCount(Class clazz) {
return map.get(clazz).size();
}
}
public class Dog extends Animal {
Dog(String name, double age, char gender) {
super(name, age, gender);
}
//optional
public static int getCount() {
return Animal.getCount(Dog.class);
}
}
在main中你会有：
System.out.println(Animal.getCount(Dog.class)); // output => 4
System.out.println(Animal.getCount(Cat.class)); // output => 2
//or
System.out.println(Dog.getCount()); // output => 4
System.out.println(Cat.getCount()); // output => 2