What is Abstract Factory Design Pattern in Java?
The Abstract Factory Design Pattern is a creational design pattern that provides an interface for creating families of related or dependent objects without specifying their concrete classes. It is widely used in Java and other object-oriented programming languages to simplify the process of object creation and to enhance the flexibility of the code. This pattern is particularly useful when dealing with complex object hierarchies and when the creation of objects is tightly coupled with their dependencies.
In Java, the Abstract Factory Design Pattern involves two main components: the Abstract Factory and the Concrete Factories. The Abstract Factory defines an interface for creating families of related or dependent objects, while the Concrete Factories implement this interface and create specific objects. The client code interacts with the Abstract Factory, which in turn delegates the creation of objects to the appropriate Concrete Factory.
The main purpose of the Abstract Factory Design Pattern is to isolate the client code from the specifics of object creation. This allows the client code to remain flexible and easy to maintain, as it is not tightly coupled to the concrete classes of the objects being created. Instead, the client code only needs to know about the Abstract Factory and its methods, which simplifies the process of creating objects and reduces the risk of errors.
The following is a simple example of the Abstract Factory Design Pattern in Java:
“`java
// Abstract Factory interface
interface AbstractFactory {
Color getColor(String color);
Shape getShape(String shape);
}
// Concrete Factory 1
class ShapeFactory implements AbstractFactory {
public Color getColor(String color) {
return new Red();
}
public Shape getShape(String shape) {
return new Circle();
}
}
// Concrete Factory 2
class ColorFactory implements AbstractFactory {
public Color getColor(String color) {
return new Green();
}
public Shape getShape(String shape) {
return new Square();
}
}
// Color interface
interface Color {
void fill();
}
// Red class
class Red implements Color {
public void fill() {
System.out.println(“Filling with red color”);
}
}
// Green class
class Green implements Color {
public void fill() {
System.out.println(“Filling with green color”);
}
}
// Shape interface
interface Shape {
void draw();
}
// Circle class
class Circle implements Shape {
public void draw() {
System.out.println(“Drawing Circle”);
}
}
// Square class
class Square implements Shape {
public void draw() {
System.out.println(“Drawing Square”);
}
}
// Client code
public class AbstractFactoryPatternDemo {
public static void main(String[] args) {
// Using Concrete Factory 1
AbstractFactory factory1 = new ShapeFactory();
Color red = factory1.getColor(“RED”);
red.fill();
Shape circle = factory1.getShape(“CIRCLE”);
circle.draw();
// Using Concrete Factory 2
AbstractFactory factory2 = new ColorFactory();
Color green = factory2.getColor(“GREEN”);
green.fill();
Shape square = factory2.getShape(“SQUARE”);
square.draw();
}
}
“`
In this example, the `AbstractFactoryPatternDemo` class demonstrates how to use the Abstract Factory Design Pattern to create objects of different families (colors and shapes) without specifying their concrete classes. The client code only needs to know about the `AbstractFactory` interface and its methods, making it easy to extend and maintain the code.
