3.6 KiB

Raw Blame History

title	localeTitle
Factory	Fábrica

A fábrica é um padrão de projeto que visa reduzir as dependências entre as classes que instanciam (criam) objetos e os próprios objetos, criando uma classe "factory" que lida com a criação de classes. Ao fazer isso, permitimos que as subclasses redefinam qual classe instanciar e agrupe a lógica de criação potencialmente complexa em uma única interface.

Os programadores usam padrões de projeto de fábrica porque permite que eles criem instâncias de objetos que implementam uma interface comum, sem necessariamente saber de antemão a classe concreta exata (implementação) sendo usada. Uma situação comum em que isso é útil é quando uma classe pai está contando com suas classes filhas para especificar o tipo de objeto que deve ser instanciado. Também é útil quando a criação de um objeto é complexa, pois permite que o programador agrupe o código em uma única classe e reduza a duplicação.

Usando o padrão de fábrica em Java

Para usar o padrão de design de fábrica, você primeiro precisa ter uma interface - um objeto com nomes de classe e variável, mas sem definições. Por exemplo, aqui temos uma interface Java para animais.

`` `
public interface Animal { void talk (); }

We now need to have "concrete classes" - classes which implement our interface and define the associated functions/ variables.

public class Dog implements Animal { 
 
    @Override 
    public void talk() { 
        System.out.println("Woof"); 
    } 
 }

public class Cat implements Animal { 
 
    @Override 
    public void talk() { 
        System.out.println("Meow!"); 
    } 
 }

We now define our "AnimalFactory" - the class which will handle the creation of these classes.

public class AnimalFactory { 
 
    public Animal getAnimal(String animalType) { 
        if (animalType.equals("dog")) { 
            return new Dog(); 
        } else if (animalType.equals("cat")) { 
            return new Cat(); 
        } 
        return null; 
    } 
 }

Now when we want to create a new Cat object, instead of saying something like ``` Cat cat = new Cat(); ```, we use the factory class that we have defined. For example:

    AnimalFactory animalFactory = new AnimalFactory(); 
 
    Animal cat = animalFactory.getAnimal("cat"); 
    cat.talk();

Here we can see that the class with this instance of "Cat" doesn't really know which animal it has. But this doesn't matter - because all the classes the factory creates are concrete classes of the same interface, the parent class doesn't need to know the exact class it is using. 
 
 
 ## Factory in Python3 
 We can implement a Factory easily with static methods.

python bebida da classe (objeto): def init (self, nome, preço = Nenhum): self.name = name self.price = price

Classe Chá (Bebida): def str (self): return 'Isto é chá: {} em $ {}'. format (self.name, self.price)

class Milk (bebida): def str (self): return 'Isto é leite: {} em $ {}'. format (self.name, self.price)

classe DrinkFactory (objeto): @staticmethod def generate ( tipo de bebida = Nenhum, * args, * kwargs): se beber tipo == 'chá': return Tea ( args, * kwargs) tipo de bebida elif == 'leite': retorno Milk ( args, ** kwargs) raise NotImplementedError ("{} bebida não existe.". format ( tipo de bebida ))

Testando

chá preto = DrinkFactory.generate ('chá', 'Chá preto', preço = 4.39) leite integral = DrinkFactory.generate ('leite', 'Leite Integral', preço = 5,49) imprimir ( chá preto ) imprimir ( leite integral ) `` `

3.6 KiB Raw Blame History

Usando o padrão de fábrica em Java

Testando

3.6 KiB

Raw Blame History