concepto
Factory Pattern (Factory Pattern) es uno de los patrones de diseño más utilizados en Java. Este tipo de patrón de diseño es un patrón de creación, que proporciona la mejor manera de crear objetos.
En el modo de fábrica, no exponemos la lógica de creación al cliente al crear un objeto, y usamos una interfaz común para apuntar al objeto recién creado.
Patrón de fábrica simple
Patrón de fábrica simple (Patrón de fábrica simple) se refiere a una clase de instancia en la que un objeto de fábrica determina qué producto se crea, pero no pertenece a los patrones de diseño de GOF23.
1. Crea una interfaz
public interface ICourse {
public void record();
}
2. Cree una clase de implementación de interfaz
public class JavaCourse implements ICourse{
@Override
public void record() {
System.out.println("Java 语言");
}
}
public class PythonCourse implements ICourse {
@Override
public void record() {
System.out.println("pythod语言");
}
}
3. Crea una clase de fábrica
public class SimpleFactory {
public ICourse getCourse(String name){
if("java".equals(name)){
return new JavaCourse();
}
if("python".equals(name)){
return new PythonCourse();
}else{
return null;
}
}
}
4. Crea una clase de prueba
public class FactoryTest {
public static void main(String[] args) {
SimpleFactory simpleFactory = new SimpleFactory();
ICourse course = simpleFactory.getCourse("java");
course.record();
}
}
Resultado de la operación: la
fábrica simple es adecuada para escenarios donde la clase de fábrica es responsable de crear menos objetos, y el cliente solo necesita pasar los parámetros de la clase de fábrica y no necesita preocuparse por la lógica de cómo crear objetos
Desventaja
- Las responsabilidades de la clase de fábrica son relativamente pesadas y no es fácil ampliar la estructura de producto demasiado compleja.
Patrón de método de fábrica
El patrón de método de fábrica (Factory Method Pattern) se refiere a la definición de una interfaz para crear objetos, pero deje que la clase que implementa esta interfaz decida qué clase instanciar, y el método de fábrica retrasa la instanciación de la clase a la subclase.
1. Crea una interfaz de fábrica
public interface ICourseFactory {
public ICourse create();
}
2. Cree una clase de fábrica que implemente la interfaz.
public class JavaCourseFactory implements ICourseFactory{
@Override
public ICourse create() {
return new JavaCourse();
}
}
public class PythonCourseFactory implements ICourseFactory{
@Override
public ICourse create() {
return new PythonCourse();
}
}
3. Clase de prueba
public class FactoryMethodTest {
public static void main(String[] args) {
ICourseFactory iCourseFactory=new JavaCourseFactory();
ICourse icourse=iCourseFactory.create();
icourse.record();
}
}
Resultado de la operación:
en el modo de método de fábrica, el usuario solo debe preocuparse por la fábrica correspondiente al producto requerido, no los detalles de creación
Desventaja
- Es fácil que el número de clases sea demasiado, aumentando la complejidad
- Aumentó la abstracción y la dificultad de comprender el sistema.
Patrón de fábrica abstracto
Abstract Factory Pattern (Patrón abstracto de fábrica) consiste en crear otras fábricas alrededor de una súper fábrica. Esta súper fábrica también se llama fábrica de otras fábricas. Este tipo de patrón de diseño es un patrón de creación, que proporciona la mejor manera de crear objetos.
En el patrón de fábrica abstracto, la interfaz es responsable de crear una fábrica para objetos relacionados y no es necesario especificar explícitamente sus clases. Cada fábrica generada puede proporcionar objetos de acuerdo con el patrón de fábrica.
1. Cree una interfaz de producto
public interface IAirConditioning {
public void cold();
}
public interface IPhone {
public void call();
}
2. Crea un producto
public class GreePhone implements IPhone {
@Override
public void call() {
System.out.println("格力电话");
}
}
public class GreeAirConditioning implements IAirConditioning {
@Override
public void cold() {
System.out.println("好空调，格力造");
}
}
public class MideaPhone implements IPhone{
@Override
public void call() {
System.out.println("美的电话");
}
}
public class MideaAirConditioning implements IAirConditioning {
@Override
public void cold() {
System.out.println("美的空调-精彩生活由我创造");
}
}
3. Crea una fábrica abstracta
public abstract class AbstractFactory {
public void init(){
System.out.println("开始。。。");
}
protected abstract IPhone createPhone();
protected abstract IAirConditioning createAirConditioning();
}
4. Crea una fábrica específica
public class MideaFactory extends AbstractFactory{
@Override
protected IPhone createPhone() {
return new MideaPhone();
}
@Override
protected IAirConditioning createAirConditioning() {
return new MideaAirConditioning();
}
}
public class GreeFactory extends AbstractFactory {
@Override
protected IPhone createPhone() {
return new GreePhone();
}
@Override
protected IAirConditioning createAirConditioning() {
return new GreeAirConditioning();
}
}
4. Prueba
public class AbstractFactoryTest {
public static void main(String[] args) {
GreeFactory greeFactory=new GreeFactory();
greeFactory.createAirConditioning().cold();
}
}
resultado de la operación:
Desventaja
- Especifica todos los conjuntos de productos que se pueden crear. Si la familia de productos cambia, entonces se producirán ajustes desde la fábrica abstracta a la fábrica específica, que no se ajusta al principio de apertura y cierre.
- Aumentó la abstracción y la dificultad de comprender el sistema.
El principio de apertura y cierre: una entidad de software como clase, módulo y función debe estar abierta para extensión y cerrada para modificación.