设计模式：工厂模式

工厂模式：创建型模式

通过使用同一个接口，隐藏了创建对象的具体逻辑。（通俗点说就是）

使用场景：在不关心怎么创建，只要需要最后的实例结果时可以使用工厂模式。比如你要买一辆车，你会去关心他的建造过程吗，大多数人只是去使用这辆车。

优点：① 建造灵活：新建对象时，很容易创建，只需要提供你需要的具体对象类型即可。

           ② 类型灵活：如果这个工厂出现新产品，或者暂时下架旧产品，只需要在增加或删除一个子类，最后在工厂中增加或删除对应的一条语句即可。

           ③ 调用灵活：具体使用时，不需要考虑逻辑，直接使用接口即可。

缺点：① 如果大多工厂中的子类很少，就会出现杀鸡用牛刀的的感觉，不必要再去使用工厂模式。

           ② 而且会产生很多依赖关系，耦合性变高。

实际组成：一个相同接口、多个实现此接口的子类、以及工厂类。

工厂也可抽象，让其他子工厂实现抽象工厂。

1 具体工厂的实现：

共同接口：

public interface Course {
    void printCourseName();
}

实现接口的子类：

public class Chinese implements Course {
    @Override
    public void printCourseName() {
        System.out.println("Chinese");
    }
}

public class English implements Course {
    @Override
    public void printCourseName() {
        System.out.println("English");
    }
}

public class Math implements Course {
    @Override
    public void printCourseName() {
        System.out.println("Math");
    }
}

......

工厂类：

public class CourseFactory {
    public Course getCourse(String courseType){
        if (courseType == null){
            return null;
        }
        if (courseType.equalsIgnoreCase("Chinese")){
            return new Chinese();
        }else if (courseType.equalsIgnoreCase("Math")){
            return new Math();
        }else if (courseType.equalsIgnoreCase("English")){
            return new English();
        }
        return null;
    }
}

2 抽象工厂：

共同接口：

①课程具体工厂接口

public interface Course {
    void printCourseName();
}

②老师具体工厂接口

public interface Teacher {
    void printTeacherName();
}

实现接口的子类：

①课程所有具体子类：

public class Chinese implements Course {
    @Override
    public void printCourseName() {
        System.out.println("Chinese");
    }
}

public class English implements Course {
    @Override
    public void printCourseName() {
        System.out.println("English");
    }
}

public class Math implements Course {
    @Override
    public void printCourseName() {
        System.out.println("Math");
    }
}

......

②老师所有具体子类：

public class ChineseTeacher implements Teacher{
    @Override
    public void printTeacherName() {
        System.out.println("ChineseTeacher");
    }
}

public class MathTeacher implements Teacher{
    @Override
    public void printTeacherName() {
        System.out.println("MathTeacher");
    }
}

public class EnglishTeacher implements Teacher{
    @Override
    public void printTeacherName() {
        System.out.println("EnglishTeacher");
    }
}

......

工厂类：

①抽象工厂

public abstract class AbstractFactory {
    public abstract Course getCourse(String courseType);
    public abstract Teacher getTeacher(String teacherType);
}

②两个具体工厂

public class CourseFactory {
    public Course getCourse(String courseType) {
        if (courseType == null){
            return null;
        }
        if (courseType.equalsIgnoreCase("Chinese")){
            return new Chinese();
        }else if (courseType.equalsIgnoreCase("Math")){
            return new Math();
        }else if (courseType.equalsIgnoreCase("English")){
            return new English();
        }
        return null;
    }

    public Teacher getTeacher(String teacherType) {
        return null;
    }
}

public class TeacherFactory {
    public Course getCourse(String courseType) {
        return null;
    }

    public Teacher getTeacher(String teacherType) {
        if (teacherType == null){
            return null;
        }
        if (teacherType.equalsIgnoreCase("ChineseTeacher")){
            return new ChineseTeacher();
        }else if (teacherType.equalsIgnoreCase("MathTeacher")){
            return new MathTeacher();
        }else if (teacherType.equalsIgnoreCase("EnglishTeacher")){
            return new ChineseTeacher();
        }
        return null;
    }
}