Provide an interface for creating families of related or dependent objects without specifying their concrete classes.



Source Code

/**
 * Abstract factory declares an interface for operations that create abstract
 * product objects.
 * 
 * @role __Factory
 */
public interface AbstractFactory {
        /**
  * Creates abstract product
  */
        ProductA createProductA();        /**
  * Creates abstract product
  */
        ProductB createProductB();}

/**
 * Abstract factory declares an interface for operations that create abstract
 * product objects.
 * 
 * @role __Factory
 */
public interface AbstractFactory {
        /**
  * Creates abstract product
  */
        ProductA createProductA();        /**
  * Creates abstract product
  */
        ProductB createProductB();}

/**
 * Abstract product - an interface for a type of Product object.
 * 
 * @role __Product
 * @see AbstractFactory
 */
public interface ProductA {

        /*
  * add product method declarations here
  */
}

/**
 * Concrete Factory implements operations of AbstractFactory to create Concrete
 * product objects.
 */
public class MyFactory implements AbstractFactory {

        /**
  * Creates concrete product ConcreteProduct1
  */
        public ProductA createProductA() {
                return new ConcreteProduct1();        }

        /**
  * Creates concrete product ConcreteProduct2
  */
        public ProductB createProductB() {
                return new ConcreteProduct2();        }

}

/**
 * Concrete product defines a product object to be created by the corresponding
 * concrete factory.
 * 
 * @see MyFactory
 */
public class ConcreteProduct1 implements ProductA {

}

/**
 * Concrete product defines a product object to be created by the corresponding
 * concrete factory.
 * 
 * @see MyFactory
 */
public class ConcreteProduct2 implements ProductB {

}

You might like also

No Thumbnail was found
You do not create your objects but describe (using cofiguration file) how they should be created and wired together in code. A container (for ex: in case of Spring framework, the IOC container) is then responsible for hooking it all up. In a typical IOC scenario, the container creates all the objects, wires them together by setting the necessary properties, and determines when methods will be invoked. The three implementation pattern types for IOC are: Type 1 Services need to …
4890 Days ago
Type Safe Enumeration
Create a class that approximates an equivalent Pascal enumeration or C enum. A specific enumeration will be represented by a class with specific instances corresponding to each element of the enumerations and public static final fields to access the instances.Existing in Java Tiger 1.5Elements are ordered and comparableEnumeration elements are serializableEnumeration element Name lookup is supportedMethods sequencing is includedSource Code/** * Type Safe Enumeration: Colors elements: Red, Blue, Green, Yellow, White */ public final class Colors implements Comparable, Serializable /** …
5347 Days ago
Singleton
Ensure a class only has one instance, and provide a global point of access to it. Statically Initialized The singleton class is implemented by defining a static field that is statically initialized (that is, the field is initialized when the class is initialized). This has the advantage that invocations of the method used to access the singleton do not incur the overhead of checking whether or not the instance has been created. Dynamically Initialized The singleton class is implemented by …
5347 Days ago
Dynamic polymorphic abstract factory
This package contains a dynamic polymorphic factory... New class can be add dynamically to the factory... even during runtime (dynamic)Factory methods are in a separate class as virtual functions. (polymorphism)Different types of factories can be subclassed from the basic factory.. (abstract)Useful iin case of licence problem, since Concrete classes are created at runtime, and only need to reside in classpath (If they are not present the code still compile). Below, the example show multiple authorization and autorisation scheme, that can …
5347 Days ago
Prototype
Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.Source Code/** * Declares interface for cloning itself. * @role __Prototype */ public interface Prototype /** * Implements an operation for cloning itself. */ public class ConcretePrototype1 implements Prototype public Prototype createCopy() } /** * Implements an operation for cloning itself. */ public class ConcretePrototype1 implements Prototype public Prototype createCopy() } …
5354 Days ago
Builder
Separate the construction of a complex object from its representation so that the same construction process can create different representations.Source Code /** * The interface Product defines interface to create parts of the * Product. */ public interface Builder /** * The ConcreteBuilder is the product of a concrete builder. * */ public class ConcreteBuilder implements Product /** * The ConcreteBuilderBuilder creates and assembles parts of * the Product. * */ public class ConcreteBuilderBuilder implements Builder /** * Construct the …
5354 Days ago