Question

好的，我想以一个我基本上喜欢做的例子来开始我的问题，虽然它没有这样做。

我希望有一个接口IDog来强制执行其实现以获得一些方法。我还希望超类AbstractDog implements IDog为所有Dog类提供基本属性和方法。然后我想要像Poodle extends AbstractDog这样的子类。我的问题是static方法 - 我基本上希望AbstractDog的每个子类都有不同的static方法，但我希望能够从IDog强制执行此方法。< / p>

所以我的天真（和错误）实现将是：

public interface IDog {

    String getName(); // every dog instance should be able to call name
    static String getDescription(); // every dog class should be able to get its description

}

public abstract class AbstractDog implements IDog {

    private String name; // every dog instance will have this

    public AbstractDog(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return this.name; // every dog instance can call this
    }

}

public class Poodle extends AbstractDog {

    private static String description = "It's a poodle!"; // all Poodles have the same description

    public Poodle(String name) {
        super(name);
    }

    @Override // from IDog
    public static String getDescription() {
        return description;
    } 

}

现在，正如我所说，这是不正确的，因为AbstractDog类需要static abstract方法getDescription()而IDog需要实现其方法，它可以不被覆盖。

我想知道，如果有一个符合我问题的设计模式：强制执行一组类（可以或应该有一个中间超类）来实现（不同的！）静态方法。

我发现的一种可能性，但我不确定它是否有用甚至是足够的，是enum DogType的使用，然后只有class Dog {{1}属性：

DogType

然而，这种“解决方法”失去了对我最初想法的能力：我现在不能只有一个狗类的附加功能，如实例方法public enum DogType { Poodle("This is a poodle."), Havanese("This is a Havanese.)"; private String description; private DogType(String description) { this.description = description; } public String getDescription() { return this.description; } } public class Dog { private String name; private DogType dogType; public Dog(String name, DogType dogType) { this.name = name; this.dogType = dogType; } public String getName() { return this.name; } public String getDescription { return this.dogType.getDescription(); } }，只有void prance()才能访问。

关于类似问题的许多主题都涉及工厂模式，但我不确定它是如何适合我的问题的，因为我不一定需要构造方法。随着狗赛数量的增加，我认为我的代码会变得非常混乱。或者也许我只是没有得到如何在我的情况下正确使用工厂。

Answer 1

接口是强制行为。类用于指定属性。静态方法被隐藏。它们不会被子类覆盖。因此，如果您的子类中有静态方法，但您的对象引用是超类型类，那么将调用来自超类的静态方法。这是类方法隐藏，使用静态方法。

我想知道，如果有一个符合我问题的设计模式：强制执行一组类（可以或应该有一个中间类）超类）实现一个（不同的！）静态方法。

对不起。静态方法和继承不是齐头并进的。

我现在不能只为一个狗类增加功能了实例方法void prance（）只能访问它贵宾犬。

您可以使用方法Prancable引入接口void prance()。

public interface Prancable{
      void prance();
}
public class Poodle extends Dog implements Prancable{
      @Override
      public void prance(){
           System.out.println("My Poodle can prance.");
      }
}

您可以通过这种方式继续为不同的犬种添加行为的特定方法。

Answer 2

这是代码味道，可能有更好的方法。

如果静态方法总是为类的所有对象返回相同的东西，那么你应该把它作为常规的get方法。

@Override \\ from IDog
public String getDescription() {
    return "This is a poodle";
}

如果可以更改静态变量，则创建一个保持此类范围状态的新对象，并将其提供给构造函数中的每个类。

离。

// StringState is a new class that holds a string and has a set and get method
StringState desc = new StringState("original description");
IDog dog1 = new Poodle(desc);
IDog dog2 = new Poodle(desc);
// prints original description
System.out.Println(dog1.getDescription());
System.out.Println(dog2.getDescription());

desc.set("New description");
// prints new description, since both objects share the same
// StringState,changing it here changes it in all of them.
System.out.Println(dog1.getDescription());
System.out.Println(dog2.getDescription());

实施静态方法所需的设计模式

2 个答案: