WEB RESOURCES

Gangs of Four (GoF) Design Patterns | DigitalOcean

Examples of GoF Design Patterns in Java's core libraries

Os padrões de design GoF são classificados em três categorias: criacionais, estruturais e comportamentais. Os padrões criacionais tratam da criação de objetos, enquanto os padrões estruturais lidam com a estrutura das classes, como herança e composição. Por fim, os padrões comportamentais lidam com a comunicação entre objetos e suas interações.Estes padrões de projeto se encontram no livro “Padrões de Projetos: Soluções Reutilizáveis de Software Orientado a Objetos” escrito por 4 autores denominados GoF (Gang of Four).

<—> ABSTRACT FACTORY ****<—>

O padrão Abstract Factory é um padrão de projeto de software que fornece uma interface para criar famílias de objetos relacionados ou dependentes sem especificar suas classes concretas. Isso significa que o padrão Abstract Factory encapsula um grupo de fábricas relacionadas, sem especificar suas classes concretas.

Um exemplo de uso do padrão Abstract Factory em Java pode ser uma aplicação que trabalha com diferentes tipos de veículos, como carros, caminhões e motocicletas. Cada tipo de veículo pode ter diferentes variantes, como um carro de luxo ou um carro esportivo. O padrão Abstract Factory pode ser usado para criar diferentes famílias de objetos relacionados, como diferentes tipos de carros, caminhões e motocicletas, sem especificar suas classes concretas.

Aqui está um exemplo de como implementar o padrão Abstract Factory em Java:

// Interface para a fábrica de veículos
interface VehicleFactory {
    Car createCar();
    Truck createTruck();
    Motorcycle createMotorcycle();
}

// Implementação da fábrica de veículos para a família de carros
class CarFactory implements VehicleFactory {
    public Car createCar() {
        return new LuxuryCar();
    }
    
    public Truck createTruck() {
        return new PickupTruck();
    }
    
    public Motorcycle createMotorcycle() {
        return new SportMotorcycle();
    }
}

// Implementação da fábrica de veículos para a família de caminhões
class TruckFactory implements VehicleFactory {
    public Car createCar() {
        return new BasicCar();
    }
    
    public Truck createTruck() {
        return new SemiTruck();
    }
    
    public Motorcycle createMotorcycle() {
        return new CruiserMotorcycle();
    }
}

// Interface para os diferentes tipos de veículos
interface Car {
    String getType();
}

interface Truck {
    String getType();
}

interface Motorcycle {
    String getType();
}

// Implementação de diferentes tipos de veículos
class LuxuryCar implements Car {
    public String getType() {
        return "Luxury Car";
    }
}

class BasicCar implements Car {
    public String getType() {
        return "Basic Car";
    }
}

class PickupTruck implements Truck {
    public String getType() {
        return "Pickup Truck";
    }
}

class SemiTruck implements Truck {
    public String getType() {
        return "Semi Truck";
    }
}

class SportMotorcycle implements Motorcycle {
    public String getType() {
        return "Sport Motorcycle";
    }
}

class CruiserMotorcycle implements Motorcycle {
    public String getType() {
        return "Cruiser Motorcycle";
    }
}

// Exemplo de uso do padrão Abstract Factory
public class VehicleApp {
    public static void main(String[] args) {
        VehicleFactory carFactory = new CarFactory();
        VehicleFactory truckFactory = new TruckFactory();
        
        Car luxuryCar = carFactory.createCar();
        Truck semiTruck = truckFactory.createTruck();
        Motorcycle cruiserMotorcycle = truckFactory.createMotorcycle();
        
        System.out.println("Created a " + luxuryCar.getType());
        System.out.println("Created a " + semiTruck.getType());
        System.out.println("Created a " + cruiserMotorcycle.getType());
    }
}

Este exemplo mostra como a fábrica de veículos é implementada para criar diferentes famílias de objetos relacionados, como diferentes tipos de carros, caminhões e motocicletas. Note que o código usa o padrão Abstract Factory para encapsular um grupo de fábricas relacionadas.

links externos:

Neste exemplo, são criadas duas implementações do Factory Method Design pattern: AnimalFactory e ColorFactory. Em seguida, o acesso a elas é gerenciado usando uma Abstract Factory.

https://www.baeldung.com/java-abstract-factory-pattern

Este artigo descreve a Abstract Factory Pattern, seus componentes e como implementá-la em Java. O exemplo inclui classes como AbstractFactory, ConcreteFactory e AbstractProduct.

https://dzone.com/articles/design-patterns-abstract-factory