Question

最近我了解了工厂和单件设计模式，并希望将它们一起实现。我遇到的问题是单例类中定义的getInstance方法必须是静态的，那么如何在接口中声明此方法呢？ Java 1.8允许在接口中使用静态方法，但是这坚持在实际接口中实现方法体 - 这会立即减少使用工厂单例的功效。

例如：

// Logger.java (interface)
public interface Logger {

    public Logger getInstance();
    public static void log(String message);

}

实现时

产生错误：

// File implementation of Logger (also a database implementation)
public class FileLogger implements Logger {

    private static FileLogger instance;

    private FileLogger() {
    }

    @Override
    public static Logger getInstance() {
        synchronized (FileLogger.class) {
            if (instance == null) {
                instance = new FileLogger();
            }
        }
        return instance;
    }

    @Override
    public void log(String message) {
        System.out.println(new Date() + " " + message);
    }

}

来自像：

这样的工厂

// Factory pattern to create differing types of logger
public class LoggerFactory {

    private LoggerFactory() {

    }

    public static Logger getLogger(LoggerType loggerType) {
        Logger logger;

        switch (loggerType) {
            case DATABASE:
                logger = DatabaseLogger.getInstance();
                break;
            default:
                logger = FileLogger.getInstance();
        }
        return logger;
    }

    public enum LoggerType {
        DATABASE, FILE;
    }
}

希望这能解释我的困境。我得到的错误是missing method body

有什么方法可以解决这个问题吗？

Answer 1

我不确定我是否完全理解你的问题，但是你可以做一些这样的事情让工厂“生产”单身人士。

您在工厂中寻找的通常是特定界面的实例。从工厂方法的调用者的角度来看，它是否是单例是无关紧要的。所以我定义了一个接口：

public interface InterestingInterface {
    public void print(); // my interesting method that I need all 
                         // "products to implement"
}

然后我实现界面的类可能是单身或不依赖于它们的目的，所以：

public class SingletonA implements InterestingInterface {

    private static SingletonA instance = null;

    private SingletonA(){}

    public static SingletonA getInstance() {
        if (instance == null) {
            instance = new SingletonA();
        }

        return instance;
    }

    @Override
    public void print() {
        System.out.println("I am A");
    }
}

class SingletonB implements InterestingInterface {
    private static SingletonB instance = null;

    private SingletonB(){}

    public static SingletonB getInstance() {
        if (instance == null) {
            instance = new SingletonB();
        }

        return instance;
    }

    @Override
    public void print() {
        System.out.println("I am B");
    }
}

public class C implements InterestingInterface {
    @override
    public void print() {
        System.out.println("I am C");
    }
}

工厂的责任是知道要实例化哪个实现类以及如何实现它。在这种情况下，它可能看起来像这样：

public class SingletonFactory {
    public static InterestingInterface produce(int id) {
        switch(id) {
            case 1:
                return SingletonA.getInstance();
            case 2:
                return SingletonB.getInstance();
            case 3:
                return new C();
            default:
                return null;
        }
    }
}

有了这个，你的工厂根据你的输入为你提供正确的接口实现（可能是你在问题中使用的类型而不是整数），有些实现（或者如果你愿意的话，可以是所有的）可以是单例。

是否可以从工厂

1 个答案: