Patrón de creador - fábrica simple/fábrica/abstracta - resuelve el problema de la creación de objetos simples

Patrones creacionales

Fábrica sencilla

Resolver problemas simples de creación de objetos

describir

Al encapsular el proceso de creación de objetos en una clase de fábrica, el cliente no necesita conocer el método de creación específico y los detalles del objeto, y solo necesita pasar parámetros a la clase de fábrica para obtener el objeto requerido. Este enfoque puede reducir el acoplamiento del código, haciendo que el sistema sea más fácil de mantener y expandir.

Entorno aplicable

Cuando es necesario crear menos objetos y no se cambian con frecuencia. El cliente solo conoce los parámetros pasados ​​a la clase de fábrica y no le importa el proceso de cómo crear objetos específicos.

ventaja:

La clase de fábrica puede ocultar los detalles de la creación del producto, realizando el desacoplamiento del cliente y la clase de implementación del producto. Al pasar parámetros a la clase de fábrica, se pueden agregar nuevos tipos de productos sin modificar el código.

defecto:

La clase de fábrica contiene la lógica de creación de todos los productos. Una vez que hay algún cambio o se agrega un nuevo producto, el código de la clase de fábrica debe modificarse y recompilarse para la implementación.

violación de principios

Puede violar el principio de apertura y cierre: agregar nuevos productos requiere modificar la clase de fábrica.
Puede violar el principio de inversión de dependencia: los clientes confían en clases de implementación de productos concretos en lugar de interfaces de productos abstractas.

Código

Una biblioteca en la nube implementa un intérprete de historias, que genera explicaciones de historias correspondientes según el tipo de libro ingresado por el usuario.Usando el
patrón de fábrica simple, defina un método estático createBook() en la clase BookFactory, que crea diferentes libros según el tipo de libro pasado en. objeto, y devuelve un objeto StoryTeller.

// 在客户端调用
public class Client {
    
    
    public static void main(String[] args) {
    
    
        String bookType = "小说";
        StoryTeller book = BookFactory.createBook(bookType);
        if (book != null) {
    
    
            book.tellStory();
        }
    }
}

public interface StoryTeller {
    
    
    void tellStory();
}

public class NovelBook implements StoryTeller {
    
    
    @Override
    public void tellStory() {
    
    
        System.out.println("这是一本小说，它讲述了一个动人的故事。");
    }
}

public class EssayBook implements StoryTeller {
    
    
    @Override
    public void tellStory() {
    
    
        System.out.println("这是一本散文集，它引领读者进入优美的诗意世界。");
    }
}

public class PoetryBook implements StoryTeller {
    
    
    @Override
    public void tellStory() {
    
    
        System.out.println("这是一本诗集，它将伟大的诗人的思想和情感传递给读者。");
    }
}

public class BookFactory {
    
    
    public static StoryTeller createBook(String bookType) {
    
    
        if (bookType.equals("小说")) {
    
    
            return new NovelBook();
        } else if (bookType.equals("散文")) {
    
    
            return new EssayBook();
        } else if (bookType.equals("诗集")) {
    
    
            return new PoetryBook();
        }
        return null;
    }
}

Método de fábrica

Solucionar problemas de creación de objetos de productos

describir

Retrasar la creación de objetos en subclases oculta la implementación específica de productos de los clientes y también admite la adición de nuevos tipos de productos sin modificar el código existente. Este enfoque puede mejorar la flexibilidad y la escalabilidad del sistema, al mismo tiempo que cumple con el "principio de apertura y cierre".

Entorno aplicable

Es necesario crear un conjunto de objetos de producto para una determinada familia de productos. El cliente solo debe prestar atención a la interfaz del producto, no a la clase de implementación específica del producto.

ventaja:

Es posible dejar que las subclases decidan qué tipo de producto se crea realmente. Puede evitar el problema de que la clase de fábrica original deba modificarse debido al nuevo tipo de producto.

defecto:

Cada vez que se agrega un nuevo producto, se debe agregar una clase de fábrica de productos correspondiente, lo que aumenta la complejidad del sistema.

violación de principios

Puede violar el principio de apertura y cierre: agregar nuevos productos requiere modificar la clase de fábrica específica.
Puede violar el principio de inversión de dependencia: los clientes confían en clases de implementación de productos concretos en lugar de interfaces de productos abstractas.

Código

Usando el patrón del método de fábrica, defina una interfaz de libro y permita que diferentes tipos de libros implementen esta interfaz. Cree una interfaz BookFactory y varias clases específicas de BookFactory al mismo tiempo, y cada clase de fábrica puede crear un tipo de objeto de libro. El cliente obtiene el objeto de libro del tipo correspondiente llamando a una fábrica de subclase específica.

// 在客户端调用
public class Client {
    
    
    public static void main(String[] args) {
    
    
        String bookType = "小说";
        BookFactory bookFactory = null;
        if (bookType.equals("小说")) {
    
    
            bookFactory = new NovelBookFactory();
        } else if (bookType.equals("散文")) {
    
    
            bookFactory = new EssayBookFactory();
        } else if (bookType.equals("诗集")) {
    
    
            bookFactory = new PoetryBookFactory();
        }
        Book book = bookFactory.createBook();
        book.storyTelling();
    }
}
public interface Book {
    
    
    void storyTelling();
}

public class NovelBook implements Book {
    
    
    @Override
    public void storyTelling() {
    
    
        System.out.println("这是一本小说，它讲述了一个动人的故事。");
    }
}

public class EssayBook implements Book {
    
    
    @Override
    public void storyTelling() {
    
    
        System.out.println("这是一本散文集，它引领读者进入优美的诗意世界。");
    }
}

public class PoetryBook implements Book {
    
    
    @Override
    public void storyTelling() {
    
    
        System.out.println("这是一本诗集，它将伟大的诗人的思想和情感传递给读者。");
    }
}

public interface BookFactory {
    
    
    Book createBook();
}

public class NovelBookFactory implements BookFactory {
    
    
    @Override
    public Book createBook() {
    
    
        return new NovelBook();
    }
}

public class EssayBookFactory implements BookFactory {
    
    
    @Override
    public Book createBook() {
    
    
        return new EssayBook();
    }
}

public class PoetryBookFactory implements BookFactory {
    
    
    @Override
    public Book createBook() {
    
    
        return new PoetryBook();
    }
}

Fábrica abstracta

Solucionar problemas de creación de objetos de familia de productos

describir

Proporcione una interfaz para crear una serie de productos interdependientes o interrelacionados, evitando así la complejidad y el acoplamiento causado por el uso directo de múltiples clases de fábrica. Este enfoque puede admitir la colaboración de componentes de nivel superior y también hace que el sistema sea más fácil de mantener y expandir.

Entorno aplicable

El sistema necesita crear múltiples familias de productos, y estos productos están estrechamente relacionados y deben cooperar entre sí. El sistema no está vinculado a una línea de productos específica.

ventaja:

Se pueden agregar nuevas familias de productos sin modificar el código. La fábrica abstracta aísla la relación entre el cliente y la clase de producto específico, y hace que el cambio del producto específico no tenga efecto en el cliente.

defecto:

Cuando es necesario agregar una nueva familia de productos, la interfaz de fábrica abstracta y todas las clases de implementación concretas deben agregarse al mismo tiempo, lo que aumenta la complejidad del sistema.

violación de principios

Puede violar el principio abierto-cerrado: agregar una nueva familia de productos requiere modificar la fábrica abstracta y todas sus clases de implementación.
Puede violar el principio de inversión de dependencia: los clientes confían en clases de implementación de productos concretos en lugar de interfaces de productos abstractas.

Código

Usando el patrón de fábrica abstracto, defina una interfaz de libro y permita que diferentes tipos de libros implementen esta interfaz. Cree una interfaz BookFactory y varias clases específicas de BookFactory al mismo tiempo, y cada clase de fábrica puede crear un tipo de objeto de libro. Sobre esta base, defina una interfaz AbstractBookFactory, que tenga tres métodos para crear colecciones de novelas, prosa y poesía. La versión de idioma específico (como chino o inglés) se puede pasar al cliente como un parámetro, y el cliente crea la versión de idioma correspondiente del objeto AbstractBookFactory instanciando diferentes clases de fábrica y llama a su método para obtener el tipo de libro correspondiente. objeto.

// 在客户端调用
public class Client {
    
    
    public static void main(String[] args) {
    
    
        String languageType = "英文";
        AbstractBookFactory bookFactory = null;
        if (languageType.equals("英文")) {
    
    
            bookFactory = new EnglishBookFactory();
        } else if (languageType.equals("中文")) {
    
    
            bookFactory = new ChineseBookFactory();
        }
        Book novelBook = bookFactory.createNovelBook();
        Book essayBook = bookFactory.createEssayBook();
        Book poetryBook = bookFactory.createPoetryBook();

        novelBook.storyTelling();
        essayBook.storyTelling();
        poetryBook.storyTelling();
    }
}

public interface Book {
    
    
    void storyTelling();
}

public class EnglishNovelBook implements Book {
    
    
    @Override
    public void storyTelling() {
    
    
        System.out.println("This is a novel book, it tells an inspiring story.");
    }
}

public class EnglishEssayBook implements Book {
    
    
    @Override
    public void storyTelling() {
    
    
        System.out.println("This is an essay book, it leads readers into a poetic world.");
    }
}

public class EnglishPoetryBook implements Book {
    
    
    @Override
    public void storyTelling() {
    
    
        System.out.println("This is a poetry book, it conveys the thoughts and emotions of great poets.");
    }
}

public class ChineseNovelBook implements Book {
    
    
    @Override
    public void storyTelling() {
    
    
        System.out.println("这是一本小说，它讲述了一个动人的故事。");
    }
}

public class ChineseEssayBook implements Book {
    
    
    @Override
    public void storyTelling() {
    
    
        System.out.println("这是一本散文集，它引领读者进入优美的诗意世界。");
    }
}

public class ChinesePoetryBook implements Book {
    
    
    @Override
    public void storyTelling() {
    
    
        System.out.println("这是一本诗集，它将伟大的诗人的思想和情感传递给读者。");
    }
}

public interface AbstractBookFactory {
    
    
    Book createNovelBook();
    Book createEssayBook();
    Book createPoetryBook();
}

public class EnglishBookFactory implements AbstractBookFactory {
    
    
    @Override
    public Book createNovelBook() {
    
    
        return new EnglishNovelBook();
    }

    @Override
    public Book createEssayBook() {
    
    
        return new EnglishEssayBook();
    }

    @Override
    public Book createPoetryBook() {
    
    
        return new EnglishPoetryBook();
    }
}

public class ChineseBookFactory implements AbstractBookFactory {
    
    
    @Override
    public Book createNovelBook() {
    
    
        return new ChineseNovelBook();
    }

    @Override
    public Book createEssayBook() {
    
    
        return new ChineseEssayBook();
    }

    @Override
    public Book createPoetryBook() {
    
    
        return new ChinesePoetryBook();
    }
}