patrón de diseño (2) - Modelo detallado de la fábrica

I. Introducción

  Hoy en día este blog para introducir patrones de diseño muy comúnmente utilizado - el modelo de fábrica. De hecho, el nombre del modelo de fábrica solamente un término general, que se divide en la fábrica simple, método de fábrica y la fábrica abstracta. A continuación, tiene que introducir por separado.

En segundo lugar, el texto

 2.1 Interfaz para la programación

  Es una interfaz de programación de los principios de diseño de lenguaje de programación orientado a objetos, lo que indica que estamos en el proceso de programación, usted debe tratar de utilizar la interfaz de nuestras referencias específicas a los objetos en lugar de utilizar clases concretas El objetivo es utilizar este código objeto no es demasiado dependiente del tipo específico. Si estamos usando la interfaz, en lugar de tipos específicos, entonces conservamos cierta flexibilidad para el código de aquí, porque simplemente puede sustituir a otra subclase, sin afectar el código que lo utiliza.

Nota: hablando aquí es de la interfaz no requiere interfaz, lo que indica que todos los del tipo de los padres, puede ser una interfaz, puede ser una clase abstracta, o incluso una categoría general, se refiere a un cierto tipo de tipo de capa superior;

  Conseguido método de fábrica es seguir este principio, con el fin de lograr una disociación.

 Simple de la fábrica 2.2

  simple planta y su nombre, muy simple de implementar, que se define como sigue:

Cuando se crea un objeto no está expuesto a los datos de usuario para crear un objeto, sólo para proporcionar una interfaz común para crear objetos a través de esta interfaz;

  simple planta creará un código que tiene un objeto de la clase padre común separe, colocado en una clase, y proporciona una interfaz, el objeto puede ser creado por llamar a esta interfaz, pero que es objeto creado específicamente clase hija está determinada por simple fábrica . Entendimos directamente por el código siguiente. Supongamos que necesitamos para crear Aproductos y Aproductos en cuatro productos específicos, de la siguiente manera:

// A类产品
abstract class A {
}

// 以下均为具体产品
class A1 extends A {
}

class A2 extends A{
}

class A3 extends A{
}

  Suponiendo que los anteriores tres números de productos específicos son 1、2、3, tenemos que seleccionar un producto necesita ser creados de acuerdo con el número en el código, por lo que podemos escribir:

public static void main(String[] args) throws IOException {
    int type = System.in.read();
    A a = null;
    if (type == 1) {
        a = new A1();
    } else if (type == 2) {
        a = new A2();
    } else if (type == 3) {
        a = new A3();
    } else {
        System.out.println("no product");
    }
}

  Obviamente, el código anterior es muy malo, hace que el código para crear un objeto con una específica tipos de objetos tienen un gran acoplamiento. Desde la perspectiva de la reutilización de código, supongamos que queremos crear en el resto del Aproducto, cada lugar tiene que ser utilizado para escribir en el código anterior, a continuación, en términos de escalabilidad, si tenemos que añadir un nuevo producto A4, o modificar el número de productos que para cada uso del código anterior lugares necesitan ser modificados, incrementando en gran medida la dificultad de mantener el programa, que es el acoplamiento de alto perjudicial. Por lo que necesitamos para desacoplar el código anterior, por lo que el código para crear la lógica específica y de separación de objetos. De acuerdo con la experiencia de nuestra programación, que se puede realizar:

class AFactory {
    public static A createA(int type) {
        if (type == 1) {
            return new A1();
        } else if (type == 2) {
            return new A2();
        } else if (type == 3) {
            return new A3();
        } else {
            System.out.println("no product");
        }
        return null;
    }
}

  Estas son plantas simples. Método público vamos a crear un proceso de extracción del objeto a una clase, el valor de retorno es el padre común de estos productos, por lo que llamamos la fábrica directamente encima de donde se necesita para crear el objeto. Y el método oculta el tipo específico del objeto, reduciendo el tipo particular de acoplamiento. Y cuando se necesita modificar sólo tenga que modificar el método, las llamadas de código para que se oculta.

  De hecho, el diseño simple de la planta no es un patrón , es un buen hábito cuando codificamos - Código extracto reutilizable, fácil reutilización.

 2.3 Método de fábrica

  Vamos a echar un vistazo al método de fábrica definición:

Factory Method define la interfaz de un objeto creado, pero la interfaz se implementa mediante una subclase, la subclase decidió dirigirse a las necesidades específicas creadas. El método de fábrica para crear un objeto de trabajo de la clase retrasada hasta que el niño;

  método de fábrica define primero una instalación de clase superior, que ofrece un método para crear un objeto, pero este método por lo general no tienen que poner en práctica, ya que no determina qué necesidades objeto que se ha creado. El trabajo de creación del objeto específico es entregado a una subclase de la implementación de fábrica. Bajo la responsabilidad de la subclase programador de la fábrica, para poner en práctica el método de interfaz en la fábrica matriz para crear objetos, es necesario crear tipos específicos de la subclase. Elija una fábrica subclase diferente, naturalmente, va a crear diferentes objetos. Vamos a echar un vistazo a través del código.

  Supongamos ahora tenemos que crear el Producttipo de producto, pero Producthay dos tipos de productos específicos y Producttipos de productos que tienen una showoperación, de la siguiente manera:

// 抽象的产品
abstract class Product {
    // 定义产品的公共方法
    abstract void show();
}

// 具体产品1
class Product1 extends Product{
    @Override
    void show() {
        System.out.println("Product1");
    }
}

// 具体产品2
class Product2 extends Product{
    @Override
    void show() {
        System.out.println("Product2");
    }
}

  Necesitamos fábricas Factorypara crear este producto, pero queremos tener varias fábricas, cada fábrica es responsable de la creación de diferentes tipos de productos. Sin embargo, esperamos que estas plantas no hay diferencia en el uso, no quieren saber el uso específico de las cuales habitante querer usarlo, yo era capaz de crear productos necesarios. Así podemos crear una clase de fábrica común, pero es sólo una norma común, y no va a funcionar, pero el trabajo real se basa en la norma de construcción de esta planta, que son responsables de la creación Product1y Product2:

// 抽象的工厂类提供了一个创建对象的接口
// 它是具体工厂的一个标准
abstract class Factory {
    /**
     * 创建对象的接口，但是没有实现，由子类来决定创建什么对象
     * 不需要在意产品的具体类型，因为它们都有公共的父类
     */
    abstract public Product createProduct();
}

// 子类实现抽象的工厂类，实现具体的创建对象的接口
class Factory1 extends Factory{
    @Override
    public Product createProduct() {
        // Factory1创建Product1
        return new Product1();
    }
}

class Factory2 extends Factory{
    @Override
    public Product createProduct() {
        // Factory2创建Product2
        return new Product2();
    }
}

  Así que ahora podemos crear un objeto específico. Elegimos diferentes plantas para crear diferentes productos:

public static void main(String[] args) {
    // 根据选择的工厂不同，创建的产品也不同
    // 但是不需要在意产品的具体类型，因为产品有公共的分类Product

    // 选择工厂1
    Factory f1 = new Factory1();
    Product p1 = f1.createProduct();
    p1.show();  // 执行Product1的show方法

    // 选择工厂2
    Factory f2 = new Factory2();
    Product p2 = f2.createProduct();
    p2.show();  // 执行Product2的show方法
}

// 执行结果
Product1
Product2

  Se puede ver, hemos creado de acuerdo a las diferentes plantas, para producir el producto final es diferente, pero no importa lo que las opciones son una fábrica, puede utilizar Factoryuna referencia de tipo, independientemente de lo que es la creación de un producto que se puede utilizar Productpara recibir, y nos que no se preocupan por puntos a los que fábrica o cuál es el producto que realmente importa, salvo que puedan hacer los movimientos correctos, nada más, lo que es los beneficios de la programación orientada a interfaz.

 2.4 patrón Abstract Factory

  Planta abstracta se basa realmente en un método de fábrica total, que se define como sigue:

Resumen patrón de fábrica proporciona una interfaz para crear un conjunto de objetos relacionados, pero no es necesario especificar explícitamente la versión de estos objetos;

  Descripción definido anteriormente, el patrón de fábrica abstracta se utiliza para producir un conjunto de una pluralidad de objetos relacionados entre sí, pero no tiene que preocuparse por el tipo específico de objeto, por lo que puede hacer que estos objetos y usarlos desacoplar código. Método para crear cada objeto de la serie del objeto, es el uso de métodos de fábrica descritos anteriormente. En otras palabras, la fábrica de resumen contiene un número de método de fábrica. Todavía nos miramos y vemos a través de un caso.

  Supongamos que queremos producir un coche Car, por simplicidad, se supone que las ventanillas del coche y las ruedas compuestas de dos partes, y diferentes tipos de ruedas y ventanas pueden estar compuestos de diferentes coches. Necesitamos algunos tipos diferentes de ruedas y ventanas, escriba los siguientes define un abstractas Wheelruedas de representación, pero define dos tipos diferentes de ruedas, una rueda de goma, que se utilizan en la producción de automóviles, mientras que una rueda de madera se utiliza para producir carro de madera;

// 轮子抽象类
abstract class Wheel {
}

// 轮子的第一个产品：橡胶轮子
class RubberWheel extends Wheel {
}

// 轮子的第二个产品：木头轮子
class WoodenWheel extends Wheel {
}

  A continuación, también necesitamos las ventanas, por lo que definimos una clase abstracta Windowrepresenta una ventana, pero hay dos tipos de ventanas de cristal y ventanas de madera subclases:

// 窗户抽象类
abstract class Window {
}

// 玻璃窗户
class GlassWindow extends Window {
}

// 木头窗户
class WoodenWindow extends Window {
}

  Entonces tenemos que tener una Carclase representa coche, esto Carpor las ruedas y ventanas composición:

// 车
class Car {
    // 车轮
    Wheel wheel;
    // 车窗
    Window window;

    public Car(Wheel wheel, Window window) {
        this.wheel = wheel;
        this.window = window;
    }
}

  A continuación, se debe tener en cuenta la forma de producir diferentes tipos de coche. Necesitamos una fábrica que puede producir ruedas, también puede producir ventanas, y luego las ruedas y ventanas también se pueden combinar para formar a sí mismos en un coche. Así se define una fábrica de automóviles, que cuenta con dos métodos abstractos para la producción de ruedas y ventanas, así como un método para el montaje de automóviles. Montaje del vehículo se fija, las ruedas y la ventana es para ser combinados, sin embargo, dependiendo de las necesidades de producción del vehículo, pueden requerir diferentes partes, por lo que la siguiente definición de clase de vehículos estándar, a no productoras, el coche específico de cómo generar qué partes necesitan ser utilizados, lo que requiere subclases para decidir de acuerdo a sus funciones:

// 造车工厂：需要生产一系列车需要的零件，组合成车
abstract class CarFactory {
    // 造轮子
    abstract Wheel createWheel();

    // 造窗户
    abstract Window createWindow();

    // 将零件组合成车，这个过程是固定的，所以不需要在子类中实现
     Car createCar() {
        Wheel wheel = createWheel();
        Window window = createWindow();
        return new Car(wheel, window);
    }
}

  Esperamos que tenemos dos fábricas, una generación de automóviles, el uso de ventanas de vidrio y ruedas de goma; generando un carro de madera, rueda utilizando la madera y ventanas. Así que tenemos que heredar definido anteriormente coche de producción estándar CarFactory, y luego seleccionar las partes que necesitan para crear, de la siguiente manera:

// 制造小汽车
class CompactCarFactory extends CarFactory{
    @Override
    Wheel createWheel() {
        // 小汽车需要橡胶轮子
        return new RubberWheel();
    }

    @Override
    Window createWindow() {
        // 徐爱汽车需要玻璃窗户
        return new GlassWindow();
    }
}


// 制造木头车
class WoodenCarFactory extends CarFactory{
    @Override
    Wheel createWheel() {
        // 木头车需要木头轮子
        return new WoodenWheel();
    }

    @Override
    Window createWindow() {
        // 木头车需要木头窗户
        return new WoodenWindow();
    }
}

  Ahora bien, dependiendo de nuestra elección de la planta, es posible producir diferentes tipos de coches, el código siguiente utiliza la fábrica abstracta. Si elegimos una fábrica de automóviles, el coche de producción que la interfaz de llamada, la producción real es ventanas de vidrio y ruedas de goma, la combinación es salir del coche, si elegimos una fábrica de carro de madera, utilizando piezas carro de madera que se necesita , se produjo un carro de madera.

public static void main(String[] args) {
    // 使用小汽车工厂创建小汽车
    CarFactory f1 = new CompactCarFactory();
    Car compactCar = f1.createCar();
    System.out.println(compactCar.wheel.getClass());
    System.out.println(compactCar.window.getClass());

    // 使用木头车工厂创建木头车
    CarFactory f2 = new WoodenCarFactory();
    Car woodenCar = f2.createCar();
    System.out.println(woodenCar.wheel.getClass());
    System.out.println(woodenCar.window.getClass());
}

  Fácil de ver, en la fábrica de resumen, el proceso de producción de cada parte, de hecho, utilice el patrón método de fábrica, y se encargará de unir estos métodos de fábrica para producir una serie de objetos relacionados, se convierte en la fábrica abstracta. Vamos fábrica de resumen en el proceso de crear varios objetos asociados con el uso de su desvinculación de código, que no se preocupan por los tipos específicos de plantas, ya que son el tipo de su clase padre común, sólo tenemos que llamar a la clase madre ofreció las interfaces, el mecanismo de polimorfismo funcionarán correctamente subclase. No necesitamos que se preocupan por lo que producimos está sujeta, porque estamos usando una referencia a su tipo padre, pero no afecta a la funcionalidad real. Si tenemos que modificar los objetos de una fábrica, sólo es necesario modificar un método de fábrica puede ser, y para el código que llama, no tendrán ningún efecto, ya que la apariencia de la interfaz y devuelve el resultado no cambió.

En tercer lugar, el resumen

  El propósito principal del patrón de la fábrica es disociar el código para crear un objeto con un objeto lógico, que sigue las directrices para la interfaz de programación, de hecho, también siguió la Dependencia Inversión Principio. No sólo es el modo de fábrica, casi todo el patrón de diseño, el efecto es reducir el acoplamiento del código para mejorar la reutilización de código.

En cuarto lugar, la referencia

• "Head First Design Patterns"