Na programação de programação orientada a objetos, nossa operação mais comum é um novo objeto, mas, no processo de criação de um novo objeto, haverá alguns problemas, como precisamos prestar atenção aos detalhes da implementação da criação de um novo objeto, inicializar alguns parâmetros necessários etc. Isso nos fará focar mais na criação de objetos em vez de implementação da lógica do programa, que atrasa seriamente nossa eficiência de desenvolvimento do programa. O surgimento de padrões de fábrica e padrões abstratos de fábrica resolve perfeitamente esse problema, permitindo que não nos importemos mais com a criação de objetos, mas focamos mais na implementação dos negócios.
Características:
1. Os programadores criam objetos diretamente através de métodos de fábrica e não prestam mais atenção aos detalhes da criação de objetos.
2. Esconder os detalhes da implementação do objeto também é propício à segurança do programa.
3. Reduza o grau de acoplamento do programa.
Aplicações em desenvolvimento de nível corporativo e estruturas comuns:
SessionFactory, etc. em Hibernate
Classificação do modelo de fábrica:
Modelo de fábrica simples, a forma mais usada no desenvolvimento do programa, o código específico é o seguinte:
classe pública demonstração { /*** A classe de demonstração é a nossa classe de operação usual. Nesta classe, não precisamos nos preocupar com os detalhes da implementação da criação de carros*/ public static void main (string [] args) {car car = carfactory.createCar ("dz"); car.run (); Carro car2 = carfactory.createCar ("at"); car2.run (); }} Interface Car {public void run ();} classe dz implementa carr {public void run () {System.out.println ("Volkswagen está em execução"); }} classe nos implementos car {public void run () {System.out.println ("Alto Car está em execução"); }} classe CarFactory {public static car CreateCar (string type) {if ("dz" .equals (type)) {System.out.println ("criou um carro Volkswagen"); retornar novo dz (); } if ("at" .equals (type)) {System.out.println ("criou um carro alto"); retornar novo em (); } retornar nulo; }}O modo de método de fábrica é mais fácil de expandir do que o modo simples de fábrica e não há necessidade de modificar o código anterior.
classe pública demonstração { /*** A classe de demonstração é a nossa classe de operação usual. Nesta classe, não precisamos nos preocupar com os detalhes da implementação da criação de carros*/ public static void main (string [] args) {atTFactory AtFactory = new AtFactory (); DzFactory dzFactory = new DzFactory (); Carro em = attfactory.createCar (); Carro dz = dzfactory.createCar (); at.run (); dz.run (); }} Interface Car {public void run ();} classe dz implementa carr {public void run () {System.out.println ("Volkswagen está em execução"); }} classe nos implementos car {public void run () {System.out.println ("carro automático está em execução"); }} interface CarFactory {Car CreateCar ();} classe DzFactory implementa carfactory {public Car CreateCar () {return new dz (); }} classe Attfactory implementos carfactoriais {public Car CreateCar () {return novo em (); }}Padrão de método de fábrica abstrato:
classe pública Demo {public static void main (string [] args) {carfactory = new GDCarFactory (); Fdz fdz = carfactory.createfdz (); fdz.zhuansu (); }} interface fdz {void zhuansu ();} classe gdfdz implementa fdz {public void zhuansu () {System.out.println ("velocidade do motor de ponta"); }} classe ddfdz implementa fdz {public void zhuansu () {System.out.println ("velocidade de baixa velocidade da velocidade do motor"); }} interface zy {void shushidu ();} classe gdzy implementa zy {public void shushidu () {system.out.println ("assentos de ponta são confortáveis"); }} classe ddzy implementa zy {public void shushidu () {System.out.println ("Assentos de ponta são desconfortáveis"); }} interface lt {void Mosundu ();} classe GDLT implementa lt {public void Mosundu () {System.out.println ("pneus sofisticados não usam"); }} classe DDLT implementa lt {public void Mosundu () {System.out.println ("pneus de ponta desgastem rápido"); }} carro interface {fdz createfdz (); Zy createzy (); Lt createLel ();} classe gdcarfactory implementa car {@Override public fdz createfdz () {return new gdfdz (); } @Override public zy createzy () {return new gdzy (); } @Override public lt cretelel () {return new gdlt (); }} classe ddCarFactory implementa car {@Override public fdz createfdz () {return new ddfdz (); } @Override public zy createzy () {return new ddzy (); } @Override public lt cretelel () {return new ddlt (); }}Comparação de três métodos:
1. Modo simples de fábrica: o modo simples de fábrica é simples em design, com volume de código pequeno, mas baixa escalabilidade. Quando é necessário expandir, você precisa modificar o código anterior.
2. Modo de método da fábrica: forte escalabilidade, mas aumenta a complexidade do código
3. Modelo de fábrica abstrato: o modelo de fábrica abstrato e o modelo de fábrica são diferentes. O modelo de fábrica abstrato divide os produtos em notas, mas o modelo de fábrica é classificar os produtos. Para dar um exemplo de carro: o modelo de fábrica é produzir diferentes tipos de carros, como Audi e Volkswagen, enquanto o modelo abstrato de fábrica divide o mesmo carro em notas. Por exemplo, ambos a Volkswagen, dividimos carros de ponta e carros baixos. De uma perspectiva metodológica, o padrão de fábrica abstrato é mais parecido com o refinamento do padrão de fábrica. Um é destinado a produtos diferentes e o outro é destinado à mesma família de produtos.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.