Java—Abstract Factory Pattern

The abstract factory pattern is to create other factories around a super factory. This super factory is also called the factory of other factories

Business category:

Engine:
1. Engine:

public abstract class Engine {
    
    
    public abstract void createEngine();
}

1） BaoMaEngine ：

public class BaoMaEngine extends Engine{
    
    
    @Override
    public void createEngine() {
    
    
        System.out.println("宝马发动机...");
    }
}

2) BenChiEngine:

public class BenChiEngine extends Engine{
    
    
    @Override
    public void createEngine() {
    
    
        System.out.println("奔驰发动机...");
    }
}

Color:
2. Colour:

public abstract class Colour {
    
    
    public abstract void createColour();
}

1）Red：

public class Red extends Colour {
    
    
    @Override
    public void createColour() {
    
    
        System.out.println("红色喷漆...");
    }
}

2）Black：

public class Black extends Colour {
    
    
    @Override
    public void createColour() {
    
    
        System.out.println("黑色喷漆...");
    }
}

Factory class:

CarFactory：

public abstract class CarFactory {
    
    
    public abstract Engine getEngine();

    public abstract Colour getColour();
}

1、EngineFactory：

public abstract class EngineFactory extends CarFactory{
    
    
    public abstract Engine getEngine();
}

1）BaoMaFactory：

public class BaoMaFactory extends EngineFactory{
    
    
    @Override
    public Engine getEngine() {
    
    
        return new BaoMaEngine();
    }

    @Override
    public Colour getColour() {
    
    
        //Do Nothing
        //此处为语法要求，没有任何世纪作用
        return null;
    }
}

2) BenChiFactory:

public class BenChiFactory extends EngineFactory{
    
    
    @Override
    public Engine getEngine() {
    
    
        return new BenChiEngine();
    }

    @Override
    public Colour getColour() {
    
    
        //Do Nothing
        //此处为语法要求，没有任何世纪作用
        return null;
    }
}

2、ColourFactory：

public abstract class ColourFactory extends CarFactory{
    
    
    public abstract Colour getColour();
}

1） RedFactory

public class RedFactory extends ColourFactory{
    
    
    @Override
    public Engine getEngine() {
    
    
        //Do Nothing
        //此处为语法要求，没有任何世纪作用
        return null;
    }

    @Override
    public Colour getColour() {
    
    
        return new Red();
    }
}

2）BlackFactory

public class BlackFactory extends ColourFactory{
    
    
    @Override
    public Engine getEngine() {
    
    
        //Do Nothing
        //此处为语法要求，没有任何世纪作用
        return null;
    }

    @Override
    public Colour getColour() {
    
    
        return new Black();
    }
}

Test：

public class Test {
    
    
    public static void main(String[] args) {
    
    
        CarFactory carColour=new BlackFactory();
        CarFactory carEngine=new BaoMaFactory();

        Colour colour=carColour.getColour();
        Engine engine=carEngine.getEngine();

        colour.createColour();
        engine.createEngine();
    }
}

operation result:

黑色喷漆...
宝马发动机...