Analyze three practical application cases of Java factory pattern

Analysis of Three Practical Cases of Java Factory Pattern

Factory pattern is a commonly used design pattern, which can separate the creation and use of objects, making the program The scalability is better. In Java, there are three common practice cases of factory pattern: simple factory pattern, factory method pattern and abstract factory pattern. This article will analyze these three practical cases in detail and provide specific code examples.

1. Simple Factory Pattern

The simple factory pattern is the most basic factory pattern, which creates objects through a factory class. In the simple factory pattern, the client only needs to interact with the factory class and does not need to interact directly with the specific product class.

The following takes creating a graphical object as an example to demonstrate the practice of the simple factory pattern:

// Create a graphical interface
public interface Shape {

void draw();

}

// Create a specific graphic class
public class Circle implements Shape {

@Override
public void draw() {
    System.out.println("画一个圆形");
}

}

public class Rectangle implements Shape {

@Override
public void draw() {
    System.out.println("画一个矩形");
}

}

// Create factory class
public class ShapeFactory {

public static Shape createShape(String type) {
    switch (type) {
        case "circle":
            return new Circle();
        case "rectangle":
            return new Rectangle();
        default:
            throw new IllegalArgumentException("不支持的图形类型");
    }
}

}

// Client usage example
public class Client {

public static void main(String[] args) {
    Shape circle = ShapeFactory.createShape("circle");
    circle.draw();

    Shape rectangle = ShapeFactory.createShape("rectangle");
    rectangle.draw();
}

}

In the above code, a specific graphic object is created through the createShape method of the ShapeFactory factory class. The client only needs to call this method and pass in the corresponding parameters to obtain the corresponding graphic object and perform subsequent operations.

2. Factory method pattern

The factory method pattern is a slightly more complex factory pattern. In the factory method pattern, each specific product class corresponds to a factory. kind. The client creates specific product objects by interacting with the corresponding factory class.

The following takes creating a car object as an example to demonstrate the practice of the factory method pattern:

// Create a car interface
public interface Car {

void drive();

}

// Create a specific car class
public class BenzCar implements Car {

@Override
public void drive() {
    System.out.println("开奔驰车");
}

}

public class BmwCar implements Car {

@Override
public void drive() {
    System.out.println("开宝马车");
}

}

// Create a factory interface
public interface CarFactory {

Car createCar();

}

// Create a specific factory class
public class BenzCarFactory implements CarFactory {

@Override
public Car createCar() {
    return new BenzCar();
}

}

public class BmwCarFactory implements CarFactory {

@Override
public Car createCar() {
    return new BmwCar();
}

}

// Client usage example
public class Client {

public static void main(String[] args) {
    CarFactory benzFactory = new BenzCarFactory();
    Car benzCar = benzFactory.createCar();
    benzCar.drive();

    CarFactory bmwFactory = new BmwCarFactory();
    Car bmwCar = bmwFactory.createCar();
    bmwCar.drive();
}

}

In the above code, a specific car object is created through the CarFactory factory interface and its corresponding specific factory class. The client only needs to interact with the corresponding factory class to obtain the corresponding car object and perform subsequent operations.

3. Abstract Factory Pattern

The abstract factory pattern is the most complex factory pattern. In the abstract factory pattern, each specific factory class can create multiple different types. product object. The client creates a series of related product objects by interacting with the factory class.

The following takes the creation of a mobile phone object as an example to demonstrate the practice of the abstract factory pattern:

// Create a mobile phone interface
public interface Phone {

void call();

}

// Create a specific mobile phone class
public class ApplePhone implements Phone {

@Override
public void call() {
    System.out.println("使用苹果手机打电话");
}

}

public class HuaweiPhone implements Phone {

@Override
public void call() {
    System.out.println("使用华为手机打电话");
}

}

// Create a factory interface
public interface PhoneFactory {

Phone createPhone();

}

// Create a specific factory class
public class ApplePhoneFactory implements PhoneFactory {

@Override
public Phone createPhone() {
    return new ApplePhone();
}

}

public class HuaweiPhoneFactory implements PhoneFactory {

@Override
public Phone createPhone() {
    return new HuaweiPhone();
}

}

// Client usage example
public class Client {

public static void main(String[] args) {
    PhoneFactory appleFactory = new ApplePhoneFactory();
    Phone applePhone = appleFactory.createPhone();
    applePhone.call();

    PhoneFactory huaweiFactory = new HuaweiPhoneFactory();
    Phone huaweiPhone = huaweiFactory.createPhone();
    huaweiPhone.call();
}

}

In the above code, a specific mobile phone object is created through the PhoneFactory factory interface and its corresponding specific factory class. The client only needs to interact with the corresponding factory class to obtain the corresponding mobile phone object and perform subsequent operations.

Summary:

The above introduces three practical cases of the factory pattern: simple factory pattern, factory method pattern and abstract factory pattern. These three modes can effectively separate the creation and use of objects and improve the scalability of the program. In actual development, you can choose the appropriate factory mode to use according to specific needs.

The above is the detailed content of Analyze three practical application cases of Java factory pattern. For more information, please follow other related articles on the PHP Chinese website!