introduce
- Provides an interface for creating a series of related or interdependent objects without specifying their concrete classes.
-
AbstractFactory: AbstractFactory role that declares a set of methods for creating a product, one for each product.
-
ConcreteFactory: ConcreteFactory role that implements the method of creating a product defined in an abstract factory, producing a set of concrete products. The concrete product components become a product category, each in a product hierarchy.
-
AbstractProduct: Abstracts product roles, declaring interfaces for each product.
-
ConcreteProduct: ConcreteProduct roles that define ConcreteProduct objects produced by factories and implement business methods for abstract product interface declarations.
case
Transmitter interface
/ / the engine
public interface Engine {
void run(a);
void start(a);
}
Copy the code
The engine implements class EngineA
public class EngineA implements Engine{
@Override
public void run(a) {
System.out.println("Turn fast!");
}
@Override
public void start(a) {
System.out.println("Quick start, automatic."); }}Copy the code
The engine implements class EngineB
public class EngineB implements Engine{
@Override
public void run(a) {
System.out.println("Slow turn!);
}
@Override
public void start(a) {
System.out.println("Quick start, manual."); }}Copy the code
Seat interface
/ / seat
public interface Chair {
void run(a);
}
Copy the code
The chair implements the class ChairA
public class ChairA implements Chair{
@Override
public void run(a) {
System.out.println("Self-heating!"); }}Copy the code
The chair implements the class ChairB
public class ChairB implements Chair{
@Override
public void run(a) {
System.out.println("No heating!"); }}Copy the code
The car factory
public interface CarFactory {
// Create engine
Engine createEngine(a);
// Create the seat
Chair createChair(a);
}
Copy the code
Car factory implementation class
public class JiLiFactory implements CarFactory {
@Override
public Engine createEngine(a) {
return new EngineA();
}
@Override
public Chair createChair(a) {
return newChairA(); }}Copy the code
The client
public class Client {
public static void main(String[] args) {
CarFactory carFactory=newJiLiFactory(); Engine engine=carFactory.createEngine(); engine.run(); engine.start(); }}Copy the code
Advantages and disadvantages
Advantages:
1) Reduce coupling: Abstract factory mode delays the creation of specific products to subclasses of specific factories. In this way, the creation of objects is encapsulated, which can reduce the dependence between clients and specific product classes, so that the coupling degree of the system is low, which is more conducive to later maintenance and expansion; 2) More in line with the open-closed principle: when a new product class is added, only the corresponding specific product class and the corresponding factory subclass need to be addedCopy the code
Disadvantages:
1) The biggest disadvantage of the abstract factory pattern is that product family extension is very difficultCopy the code
Applicable scenarios:
1) A system is not required to rely on the expression of how product class instances are created, composed, and expressed, which is a prerequisite for all factory pattern applications. 2) The system has multiple series of products, and only one series of products is consumed in the systemCopy the code
Github Demo address: ~ ~ ~ portal ~ ~ ~
Personal blog address: blog.yanxiaolu.cn /