factory-pattern

问题 So I am trying override __new__ and let it exist as a factory to create derived instances. After reading a bit on SO, I am under the impression that I should be calling __new__ on the derived instance as well. BaseThing class BaseThing: def __init(self, name, **kwargs): self.name = name # methods to be derived ThingFactory class Thing(BaseThing): def __new__(cls, name, **kwargs): if name == 'A': return A.__new__(name, **kwargs) if name == 'B': return B.__new__(name, **kwargs) def __init__

问题 This question is probably exact duplicate of this one Pass parameter to constructor with Guice Difference is that I use roboguice for android, not just Guice, so answers there does not work for me. Question is - how can I pass initialize parameters into created object? I.e. I have injected interface which should be initialize with some parameter which roboguice does not know. What I see in link I provide, I should create factory interface and register it like this void configure(Binder binder

问题 I'm reading about the Factory Method pattern. I can understand when there is a single factory class, i.e. StoreFactory#getStore() , that returns a Store implementation based on some runtime or other state. But, from reading (e.g. this link), there seems to be a general pattern of people creating an abstract factory class, to which other factory classes extend: public abstract class AbstractFactory { public abstract Store getStore(int store); } public class StoreFactoryA extends

问题 I've been reviewing Java Regex Library, surprised by the fact the Pattern class does not have a public constructor which I've taken for granted for years. One reason I suspect the static compile method is being used in favor of constructor could be that constructor would always return a new object while a static method might return a previously created (and cached) object provided that the pattern string is the same. However, it is not the case as demonstrated by the following. public class

问题 I want to change the object return from call to a constuctor FROM public class A { public A(){ } public String sayHello() { return "hello"; } public String foo() { return "foo"; } } TO public class AWrapped extends A { private A wrapped; public AWrapped() { super(); } public AWrapped(A pWrapped) { wrapped=pWrapped; } public String foo() { return wrapped.foo(); } public String sayHello { return "gday mate"; } } What i want to do is to change the object that is returned from a call A a = new A(

问题 I understand that one of the main advantages of the Factory Method over Simple Factory is that it doesn't violate the Open-Closed SOLID Principle. That is, the former doesn't require modifying the switch statement when new types are added. There is one piece on which I am hoping to get clarification. If I were to use a simple factory, I would have a factory like this (simplified): public class ObjectFactory { public static IObject CreateObject(ObjectTypeEnum objectType) { switch (objectType)

问题 In the book Domain Driven Design, by Eric Evans, in Chapter 6 in the section on "Factories" (page 139) it says the following: "The two basic requirements for any good FACTORY are: ... "2. The FACTORY should be abstracted to the type desired rather than the concrete class(es) created." Could you please elaborate on what is meant by that statement about basic requirement number 2. 回答1: Carlos Loth's answer is correct, but you should always remember to use an Abstract Factory as well, as this

问题 I have been reading Effective Java by Joshua Bloch and so far it really lives up to its reputation. The very first item makes a convincing case for static factory methods over constructors . So much that I began to question the validity of the good old constructors :). The advantages/disadvantages from the book are summarized below: Advantages: They have names! We have total instance control (Singletons, performance, etc.) They can return a subtype/interface Compiler can provide type

问题 I am trying to use a factory pattern to create a QuestionTypeFactory where the instantiated classes will be like MultipleChoice, TrueFalseQuestion etc. The factory code looks something like this class QuestionFactory { public enum QuestionType { TrueFalse, MultipleChoice, Essay } public static Question createQuestion(QuestionType quesType) { switch (quesType) { case TrueFalse: return new TrueFalseQuestion(); case MultipleChoice: return new MultipleChoiceQuestion(); case Essay: return new

问题 I don't believe I am implementing the factory pattern correctly because the Application class' createDocument method accepts any class type, not just subclasses of Document . In other words, is there a way I can restrict the createDocument method to only accept subclasses of Document ? Document.java package com.example.factory; public abstract class Document { public Document() { System.out.println("New Document instance created: " + this.toString()); } } DrawingDocument.java package com