Implementação JAVA de Design Pattern-Factory Pattern

Depois que a separação de saída é concluída, é natural enviar as mercadorias para o cliente final 2B ou 2C através da logística.Neste momento, pode haver várias maneiras. Por exemplo, os exemplos mencionados são a entrega de mercadorias à parte final por meio de quatro métodos: frota própria, frota de terceiros, entrega expressa e logística. Então, ao selecionar a parte final, considere usar o modo de fábrica para criar objetos relacionados

O primeiro modelo de fábrica é semelhante ao modelo de fábrica simples.
A fábrica simples é uma variável que eu passo para você e, depois que você a vê, a envio ao objeto que quero usar de acordo com a variável especificada.

Aqui, em primeiro lugar, ainda projetaremos uma interface logística de nível superior e, em seguida, implementaremos os quatro formulários de logística (frota própria, frota de terceiros, entrega expressa, logística) para implementação específica.

fábrica de embalagens;

/ **

Interface de nível superior do TMS
@author [email protected]
* /
interface pública ITms {

// Transport
public void transport ();
}

fábrica de embalagens;

/ **

Frota própria da empresa
@author [email protected]
* /
public class Tms implementa ITms {

@ Substituir
transporte público vazio () {
```
System.out.println("使用自有车队承运");
```
}

}

fábrica de embalagens;

/ **

Empresa de courier
@author zhous
* /
public class TmsExpress implementa ITms {

@ Substituir
transporte público vazio () {
```
System.out.println("使用快递公司承运");
```
}

fábrica de embalagens;

/ **

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

@ Substituir
transporte público vazio () {
```
System.out.println("使用物流公司承运");
```
}

}

fábrica de embalagens;

/ **

Frota de terceiros
@author [email protected]
* /
public class TmsThird implementa ITms {

@ Substituir
transporte público vazio () {
```
System.out.println("使用第三方车队承运");
```
}

}

Depois de concluir a abstração e a implementação do formulário de logística básica,
a maneira mais fácil de mostrar o exemplo de implementação de uma fábrica simples é que eu passo um nome e você me devolve o objeto de acordo com a figura . Em seguida, ele retorna um objeto com base no nome completo e, finalmente, retorna um objeto com base no tipo.

Em resumo, o objeto da classe é encontrado de acordo com os parâmetros e retornado ao chamador

pacote factory.factorysimple;

factory.ITms de importação;
import factory.Tms;
factory de importação.TmsExpress;
fábrica de importação.TmsLogistics;
import factory.TmsThird;

/ **

Implementação simples de padrão de fábrica
@author [email protected]
* /
classe pública SimpleFactory {

/ **
- Determine qual implementação de logística específica deve levar em consideração as variáveis
  * /
  public ITms getTms (String name) {
  if ("tms" .equals (name))
  retorna new Tms ();
  if ("third" .equals (name))
  retorna new TmsThird ();
  if ("express" .equals (name))
  retorna novo TmsExpress ();
  if ("logística" .equals (name))
  retorna novo TmsLogistics ();
  else
  return null;
  }
  / **
- Carregue com o nome completo da classe, você pode escrever menos bobagens
  * /
  public ITms getTms1 (String className) {
  try {
  if (null! = ClassName &&! "". Igual a (className)) {
  return (ITms) Class.forName (className) .newInstance ();
  }
  } catch (Exceção e) {
  e.printStackTrace ();
  }
  return null;
  }
/ **
- 传入 Classe
  * /
  public ITms getTms2 (classe clazz) {
  if (null! = Clazz) {
  try {
  return (ITms) clazz.newInstance ();
  } catch (Exceção e) {
  e.printStackTrace ();
  }
  }
  retornar nulo;
  }

} A
instância chama o
pacote factory.factorysimple;

factory.ITms de importação;
factory de importação.TmsExpress;

classe 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();
}

}

Exibição de chamada
Implementação JAVA de Design Pattern-Factory Pattern

O segundo é o padrão de fábrica no sentido
geral.Este conjunto de padrões de fábrica realmente abstrai a fábrica. Estabeleceu um conjunto de interfaces de fábrica e sistemas de implementação, retornando objetos diferentes através de diferentes fábricas

Primeiro, crie a interface em nível de item correspondente e a implementação de cada
pacote de fábrica factory.fatorymethod;

factory.ITms de importação;

/ **

Crie a interface superior da fábrica do Tms
@author zhous
* /
interface pública ITmsFactory {

public ITms getTms ();

}

fábrica factory.fatorymethod;

factory.ITms de importação;
import factory.Tms;

/ **

Fábrica própria de frota
@author zhous
* /
public class TmsFactory implementa ITmsFactory {

@Override
ITMS público getTms () {
```
return new Tms();
```
}

}

fábrica factory.fatorymethod;

factory.ITms de importação;
import factory.TmsThird;

/ **

Fábrica de frota de terceiros
@author zhous
* /
public class TmsThirdFactory implementa ITmsFactory {

@Override
ITMS público getTms () {
```
return new TmsThird();
```
}

}

fábrica factory.fatorymethod;

factory.ITms de importação;
factory de importação.TmsExpress;

/ **

Fábrica de Courier
@author zhous
* /
public class TmsExpressFactory implementa ITmsFactory {

@Override
ITMS público getTms () {
```
return new TmsExpress();
```
}

}

fábrica factory.fatorymethod;

factory.ITms de importação;
fábrica de importação.TmsLogistics;

/ **

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

@Override
ITMS público getTms () {
```
return new TmsLogistics();
```
}

}

A instância chama o
pacote factory.fatorymethod;

factory.ITms de importação;

classe pública 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();
}

}

Exibição do resultado da chamada
Implementação JAVA de Design Pattern-Factory Pattern

O terceiro é o padrão abstrato de fábrica, adequado para lógica de negócios mais complicada nos negócios reais, como variáveis de negócios comuns e métodos de negócios comuns. As partes que precisam ser implementadas separadamente são estendidas por classes concretas. Caso contrário, veja o exemplo simples abaixo, não é diferente do método comum de fábrica

O seguinte é abreviado: basta entender esse tipo de caminho: aqui não há interface para escrever a camada superior. Comece diretamente no
pacote de classes abstratas factory.factoryabstract;

factory.ITms de importação;

/ **

declarar classe abstrata
@author [email protected]
* /
classe abstrata pública AbstractTmsFactory {

resumo público ITms getTms ();

}

O
pacote de classe de implementação específica factory.factoryabstract;

factory.ITms de importação;
import factory.Tms;

/ **

declarar tms estende a classe
@author [email protected]
* /
public class TmsAbstractFactory estende AbstractTmsFactory {

@Override
ITMS público getTms () {
```
return new Tms();
```
}

}

pacote factory.factoryabstract;

factory.ITms de importação;
factory de importação.TmsExpress;

/ **

declarar a classe estende do TmsExpress
@author [email protected]
* /
public class TmsExpressAbstractFactory estende AbstractTmsFactory {

@Override
ITMS público getTms () {
```
return new TmsExpress();
```
}

}

A instância chama
package factory.factoryabstract;

classe pública AbstractFactoryMain {

public static void main(String[] args) {

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

    factory.getTms().transport();

    factory1.getTms().transport();
}

}

Efeito de chamada
Implementação JAVA de Design Pattern-Factory Pattern

Implementação JAVA de Design Pattern-Factory Pattern

Acho que você gosta