java design pattern factory method pattern

Summary

Design pattern is an art. If you truly understand this art, you will find that the world will become more beautiful.

Definition

Define an interface for creating objects and let its subclasses decide which class to instantiate

Usage scenarios

Any use of complex objects You can use the factory pattern everywhere

UML

1. Abstract Factory

Abstract Factory: We all know that factories, generally There is only one function, that is, production. For example, Geely Automobile Factory manufactures Geely cars, iPhone mobile phone manufacturer manufactures iPhones, etc.
So it can be summarized in a simple way, which is create();
2 .Concrete car manufacturing plant

Concrete car manufacturing plant: realizes the abstract factory, with actual processes and methods for manufacturing cars, etc.

3.Abstract car

Abstract car: We generally know that cars can run, play music, navigate, and turn. These are the common features of cars

4. Concrete car

Abstract car: concrete The car realizes the abstract car and has all its functions. Of course, different cars may have different functions.

The above is a brief introduction. Generally speaking, specific car factories manufacture corresponding cars. For example: Audi's factory, which manufactures Audi cars, Volkswagen's factory, which manufactures Volkswagen cars, etc.

Code Demonstration

We have clearly understood the relationship between them above, so next Just use code to demonstrate and express our ideas and logic above in code:

(1) Abstract car factory

package com.zengtao.demo.factory;
 
/**
 * 抽象工厂
 */
public abstract class CarFactory {
 
  public abstract <T extends Car> T createCar(Class<T> cla);
 
}

(2) Specific car factory

package com.zengtao.demo.factory;
 
/**
 * 奥迪工厂
 */
public class AudiFactory extends CarFactory {
 
  @SuppressWarnings("unchecked")
  @Override
  public <T extends Car> T createCar(Class<T> cla) {
    Car car = null;
    try {
      car = (Car) Class.forName(cla.getName()).newInstance();
    } catch (Exception e) {
      e.printStackTrace();
    }
    return (T) car;
  }
 
}

(3) Define abstract car

package com.zengtao.demo.factory;
 
public abstract class Car {
 
  public abstract void drive();
 
  public abstract void selfNagive();
 
  public abstract void playMusic();
 
}

(4) Specific car

(Audi q3)

package com.zengtao.demo.factory;
 
public class AudiQ3Car extends AudiCar {
 
  @Override
  public void drive() {
    System.out.println("AudiQ3Car 已经制造成功");
    System.out.println("AudiQ3Car drive");
  }
 
  @Override
  public void selfNagive() {
    System.out.println("AudiQ3Car selfNagive");
  }
 
  @Override
  public void playMusic() {
    System.out.println("AudiQ3Car playMusic");
    System.out.println("");
  }
}

（Audi q5）

package com.zengtao.demo.factory;
 
public class AudiQ5Car extends AudiCar {
 
  @Override
  public void drive() {
    System.out.println("AudiQ5Car 已经制造成功");
    System.out.println("AudiQ5Car drive");
  }
 
  @Override
  public void selfNagive() {
    System.out.println("AudiQ5Car selfNagive");
  }
 
  @Override
  public void playMusic() {
    System.out.println("AudiQ5Car playMusic");
    System.out.println("");
  }
 
}

(5) Call

package com.zengtao.demo;
 
import com.zengtao.demo.factory.AudiFactory;
import com.zengtao.demo.factory.AudiQ3Car;
import com.zengtao.demo.factory.AudiQ5Car;
 
public class Main {
 
  public static void main(String[] str) {
 
    // 创建工厂
    AudiFactory audiFactory = new AudiFactory();
 
    // 利用工厂制造q3车
    AudiQ3Car audiQ3Car = audiFactory.createCar(AudiQ3Car.class);
     // 利用工厂制造q5车
    AudiQ5Car audiQ5Car = audiFactory.createCar(AudiQ5Car.class);
 
    // 开始开车放音乐
    audiQ3Car.drive();
    audiQ3Car.playMusic();
 
    audiQ5Car.drive();
    audiQ5Car.playMusic();
 
  }
}

(6) Result

As above, the factory method pattern is used to realize the simple process of manufacturing a car

First point:

In the abstract factory, we see the createCar(Class cla) method. Why do we define it like this? We use reflection to create specific cars. In this way, we have different types of cars. , only the corresponding conditions are required, can it be produced, so it is beneficial to write it like this, just like many, Audi has q3, q5, a4, a6, a7, a8 and other series

Second point:

If we have other cars, such as BMW, and BMW x1, 320, x5, etc., we can also implement it very simply. We only need to implement the abstract factory and then implement the specific car Abstract car is just fine, and it is very convenient to extend.

Summary

The abstract factory is almost here. The factory method pattern is a relatively simple and good design pattern

But there are also disadvantages. For example: if there are new types of cars, you only need to implement abstract factories and abstract cars, and create two new classes.

But if it is not a car but a mobile phone, then Write them all once, which will result in a lot of classes appearing. Whether to use the factory method pattern or not depends on the needs.

Note: You should not apply design patterns for the sake of design. Of course, the factory method pattern is also very commonly used. For example, in the onCreate method of Activity, we also load and generate the corresponding interface based on the xml layout defined by ourselves, etc. Wait

The above is the entire content of this article. I hope it will be helpful to everyone's learning, and I also hope that everyone will support the PHP Chinese website.

For more articles related to the factory method pattern of java design patterns, please pay attention to the PHP Chinese website!