Diseño Patrón-Patrón de fábrica Implementación JAVA

Una vez que se completa la selección de salida, es natural enviar los productos al cliente final 2B o 2C a través de la logística. En este momento, puede haber múltiples formas. Por ejemplo, los ejemplos mencionados son la entrega de bienes a la parte final a través de cuatro métodos: flota propia, flota de terceros, entrega urgente y logística. Luego, al seleccionar la fiesta final, puede considerar usar el modo de fábrica para crear objetos relacionados

El primer modelo de fábrica es similar al modelo de fábrica simple.
La fábrica simple es una variable que le paso, y después de que la vea, la envío al objeto que quiero usar de acuerdo con la variable especificada.

Aquí, en primer lugar, seguiremos diseñando una interfaz logística de primer nivel y luego implementaremos los cuatro formularios de logística (flota propia, flota de terceros, entrega urgente, logística) para una implementación específica.

paquete de fábrica;

/ **

Interfaz TMS de nivel superior
@author [email protected]
* /
ITms de interfaz pública {

// Transport
public void transport ();
}

paquete de fábrica;

/ **

Flota propia de la empresa
@author [email protected]
* /
public class Tms implementa ITms {

@Override
public void transport () {
```
System.out.println("使用自有车队承运");
```
}

}

paquete de fábrica;

/ **

Empresa de mensajería
@author zhous
* /
public class TmsExpress implementa ITms {

@Override
public void transport () {
```
System.out.println("使用快递公司承运");
```
}

paquete de fábrica;

/ **

Empresa de logística
@author zhous
* /
public class TmsLogistics implementa ITms {

@Override
public void transport () {
```
System.out.println("使用物流公司承运");
```
}

}

paquete de fábrica;

/ **

Flota de terceros
@author [email protected]
* /
public class TmsThird implementa ITms {

@Override
public void transport () {
```
System.out.println("使用第三方车队承运");
```
}

}

Después de completar la abstracción y la implementación del formulario de logística básica,
la forma más fácil de mostrar el ejemplo de implementación de una fábrica simple es que le pase un nombre y me devuelva el objeto de acuerdo con la imagen . Luego me devuelve un objeto basado en el nombre completo y finalmente me devuelve un objeto basado en el tipo.

En resumen, el objeto de la clase se encuentra de acuerdo con los parámetros y luego se devuelve a la persona que llama.

paquete factory.factorysimple;

fábrica de importación.
fábrica de importación. Tms;
fábrica de importación. TmsExpress;
fábrica de importación. TmsLogistics;
fábrica de importación. TmsThird;

/ **

Implementación simple de patrones de fábrica
@author [email protected]
* /
public class SimpleFactory {

/ **
- Determine qué implementación logística específica tomará variables
  * /
  public ITms getTms (String name) {
  if ("tms" .equals (name))
  return new Tms ();
  if ("third" .equals (name))
  return new TmsThird ();
  if ("express" .equals (name))
  return new TmsExpress ();
  if ("logistics" .equals (name))
  return new TmsLogistics ();
  else
  return null;
  }
  / **
- Cargue con el nombre completo de la clase, puede escribir menos tonterías
  * /
  public ITms getTms1 (String className) {
  try {
  if (null! = ClassName &&! "". Equals (className)) {
  return (ITms) Class.forName (className) .newInstance ();
  }
  } catch (Exception e) {
  e.printStackTrace ();
  }
  return null;
  }
/ **
- 传入 Class
  * /
  public ITms getTms2 (Class clazz) {
  if (null! = Clazz) {
  try {
  return (ITms) clazz.newInstance ();
  } catch (Excepción e) {
  e.printStackTrace ();
  }
  }
  return null;
  }

} La
instancia llama al
paquete factory.factorysimple;

fábrica de importación.
fábrica de importación. TmsExpress;

clase pública SimpleFactoryMain {

public static void main(String[] args) {

    SimpleFactory factory = new  SimpleFactory();

    //自有车队承运
    ITms tms = factory.getTms("tms");

    tms.transport();

    //第三方车队承运
    ITms tms1 = factory.getTms1("factory.TmsThird");

    tms1.transport();

    //快递公司承运
    ITms tms2 = factory.getTms2(TmsExpress.class);

    tms2.transport();
}

}

Pantalla de llamada
Diseño Patrón-Patrón de fábrica Implementación JAVA

El segundo es el patrón de fábrica en el sentido general:
este conjunto de patrones de fábrica en realidad abstrae la fábrica. Estableció un conjunto de interfaces de fábrica y sistemas de implementación, devolviendo diferentes objetos a través de diferentes fábricas.

Primero cree la interfaz de nivel de elemento correspondiente y la implementación de cada
paquete de fábrica factory.fatorymethod;

fábrica de importación.

/ **

Cree la interfaz superior de la fábrica de Tms
@author zhous
* /
interfaz pública ITmsFactory {

ITms público getTms ();

}

paquete factory.fatorymethod;

fábrica de importación.
fábrica de importación. Tms;

/ **

Fábrica propia de flota
@author zhous
* /
public class TmsFactory implementa ITmsFactory {

@Override
public ITms getTms () {
```
return new Tms();
```
}

}

paquete factory.fatorymethod;

fábrica de importación.
fábrica de importación. TmsThird;

/ **

Fábrica de flotas de terceros
@author zhous
* /
public class TmsThirdFactory implementa ITmsFactory {

@Override
public ITms getTms () {
```
return new TmsThird();
```
}

}

paquete factory.fatorymethod;

fábrica de importación.
fábrica de importación. TmsExpress;

/ **

Fábrica de mensajería
@author zhous
* /
public class TmsExpressFactory implementa ITmsFactory {

@Override
public ITms getTms () {
```
return new TmsExpress();
```
}

}

paquete factory.fatorymethod;

fábrica de importación.
fábrica de importación. TmsLogistics;

/ **

Fábrica de logística
@author zhous
* /
public class TmsLogicticsFactory implementa ITmsFactory {

@Override
public ITms getTms () {
```
return new TmsLogistics();
```
}

}

La instancia llama al
paquete factory.fatorymethod;

fábrica de importación.

public class MethodFactoryMain {

public static void main(String[] args) {

    //调用自营车队
    ITmsFactory factory1 = new TmsFactory();
    ITms tms1 = factory1.getTms();
    tms1.transport();

    //调用自营车队
    ITmsFactory factory2 = new TmsThirdFactory();
    ITms tms2 = factory2.getTms();
    tms2.transport();

    //调用物流
    ITmsFactory factory3 = new TmsLogicticsFactory();
    ITms tms3 = factory3.getTms();
    tms3.transport();
}

}

Visualización del resultado de la llamada
Diseño Patrón-Patrón de fábrica Implementación JAVA

El tercero es el patrón abstracto de fábrica, que es adecuado para una lógica comercial más complicada en negocios reales, como variables comerciales comunes y métodos comerciales comunes. Las partes que deben implementarse por separado se extienden por clases concretas. De lo contrario, mire el ejemplo simple a continuación, no es diferente del método de fábrica ordinario

Lo siguiente se abrevia. Es suficiente para entender este tipo de manera. Aquí, no hay una interfaz para escribir la capa superior. Comience directamente desde el
paquete de clase abstracta factory.factoryabstract;

fábrica de importación.

/ **

declarar clase abstracta
@author [email protected]
* /
public abstract class AbstractTmsFactory {

resumen público ITms getTms ();

}

El
paquete de clase de implementación específica factory.factoryabstract;

fábrica de importación.
fábrica de importación. Tms;

/ **

declara la clase extendida de tms
@author [email protected]
* /
public class TmsAbstractFactory extiende AbstractTmsFactory {

@Override
public ITms getTms () {
```
return new Tms();
```
}

}

paquete factory.factoryabstract;

fábrica de importación.
fábrica de importación. TmsExpress;

/ **

declara la clase extendida de TmsExpress
@author [email protected]
* /
public class TmsExpressAbstractFactory extiende AbstractTmsFactory {

@Override
public ITms getTms () {
```
return new TmsExpress();
```
}

}

La instancia llama al
paquete factory.factoryabstract;

clase pública AbstractFactoryMain {

public static void main(String[] args) {

    //自有车队
    AbstractTmsFactory factory = new TmsAbstractFactory();
    //快递
    AbstractTmsFactory factory1 = new TmsExpressAbstractFactory();

    factory.getTms().transport();

    factory1.getTms().transport();
}

}

Efecto de llamada
Diseño Patrón-Patrón de fábrica Implementación JAVA

Diseño Patrón-Patrón de fábrica Implementación JAVA

Supongo que te gusta