在Java中使用带多个参数的工厂模式

我的班级结构如下： 基类“消息”，其中包含一些常见成员（/字段）， “Imessage”接口，该接口具有所有消息都应实现的某些方法， 许多不同的消息类扩展（继承）了基本的“消息”类，并且有很多字段，每个消息类型都有一个枚举，一个工厂类提供了一个枚举，该工厂类创建了一个适当消息类的实例

问题是，我不确定在何处/如何实现每个消息类的值设置。 它不能在它的构造函数中，因为在工厂方法中，我需要构建泛型实例。 我应该为每个消息实现一个“Create”方法来设置它的所有成员吗

    public static Message buildMessage(MessageType messageType)
        {
            Message message = null;
            switch (messageType) //TODO: add all messages!
            {
                case CONNECT: 
                    message = new ConnectMessage();
                    break;
                case CONNECT_RESPONSE: 
                    message = new ConnectResponseMessage();
                    break;  
                case DISCONNECT: 
                    message = new DisconnectMessage();
                    break;
                case FLOWSTART: 
                    message = new FlowStartMessage();
                    break;
                default: return null;
            }

            return message;
        }

---

工厂模式应该返回一个有效的、完全填充的对象，因此为每种类型的消息对象添加一个Create方法并不理想（除非从

buildMessage

中调用它）

我不知道你说的是什么意思：

它不能在它的构造函数中，因为在工厂方法中我需要 构建通用实例

初始化这样的对象是完全有效的：

Message message = new ComplexMessage(type, value, something, somethingElse);
Message message = new LessComplexMessage(type, value);

在这种情况下，您的

buildMessage

方法可以接收构建消息的所有子类型所需的所有对象

如果由于必填字段的变化太多而变得太复杂，则可能值得升级到生成器模式：

---

这是一种可能的解决方案。您可以在

Message

中编写构造函数，并在子类中重写它

public class Message {
    private final String commonField;

    public Message(String commonField){
        this.commonField = commonField;
    }
}

在子类中

public ConnectMessage(String commonField){
    super(commonField);
    //initialize
}

在工厂里呢

public static Message buildMessage(MessageType messageType, String commonValue)
        {
            Message message = null;
            switch (messageType) //TODO: add all messages!
            {
                case CONNECT: 
                    message = new ConnectMessage(commonValue);
                    break;
                case CONNECT_RESPONSE: 
                    message = new ConnectResponseMessage(commonValue);
                    break;  
                case DISCONNECT: 
                    message = new DisconnectMessage(commonValue);
                    break;
                case FLOWSTART: 
                    message = new FlowStartMessage(commonValue);
                    break;
                default: return null;
            }

            return message;
        }

---

如果消息定义是严格的，并且您没有创建消息的组合或配置它们的属性，那么为什么要使用factory类呢

另一方面，仅

enum

就能够：

public class Main {

    public static interface IMessage{
        public String getName();
    }

    public static class GoodMessage implements IMessage{
        @Override
        public String getName() {
            return "Good";
        }
    }

    public static class BadMessage implements IMessage{
        @Override
        public String getName() {
            return "Bad";
        }
    }

    public static interface IMsgGen{
        public IMessage create();
    }

    public static enum Messages implements IMsgGen {

        GOOD_MSG(GoodMessage.class),

        BAD_MSG(BadMessage.class),

        CUSTOM_MSG(null){
            @Override
            public IMessage create() {
                return new IMessage() {
                    @Override
                    public String getName() {
                        return "Custom";
                    }
                };
            }
        };

        private final Class<? extends IMessage> mClass;
        private Messages(Class<? extends IMessage> aClass) {
            mClass = aClass;
        }

        @Override
        public IMessage create() {
            try {
                return mClass.newInstance();
            } catch (Exception e) {
                throw new RuntimeException(e.getMessage(),e);
            }
        }
    }

    public static void main(String[] args){
        IMessage msg = Messages.GOOD_MSG.create();
        System.out.println(msg.getName());

        msg = Messages.BAD_MSG.create();
        System.out.println(msg.getName());

        msg = Messages.CUSTOM_MSG.create();
        System.out.println(msg.getName());
    }
}

公共类主{
公共静态接口IMessage{
公共字符串getName（）；
}
公共静态类GoodMessage实现IMessage{
@凌驾
公共字符串getName（）{
返回“好”；
}
}
公共静态类BadMessage实现IMessage{
@凌驾
公共字符串getName（）{
返回“坏”；
}
}
公共静态接口IMsgGen{
公共IMessage create（）；
}
公共静态枚举消息实现IMsgGen{
好消息（GoodMessage.class），
错误消息（BadMessage.class），
自定义消息（空）{
@凌驾
公共IMessage创建（）{
返回新的IMessage（）{
@凌驾
公共字符串getName（）{
返回“自定义”；
}
};
}
};
private final Classs你能从构造函数中进一步解释一下泛型问题吗？用一个例子还是别的什么？