1、簡單工廠模式（靜態工廠方法模式）

抽象例項：

public interface People {
    void talk();
}

具體例項：

public class Doctor implements People {
    public void talk() {
        System.out.println("我是醫生");
    }
}

public class Teacher implements People {
    public void talk() {
        System.out.println("我是教師
 
");
    }
}

具體工廠

public class Factory {
    public static People createInstance(String flag){
        if("doctor".equals(flag)){
            return new Doctor();
        }
        if("teacher".equals(flag)){
            return new Teacher();
        }
        return null;
    }
}

測試類：

public
 
 class Test {
    public static void main(String[] args){
        People people = Factory.createInstance("doctor");
        people.talk();
        people = Factory.createInstance("teacher");
        people.talk();
    }
}

我是醫生
我是教師

該模式的缺點：增加 具體例項  需要修改工廠類

2、工廠方法模式

抽象例項：

public interface People {
    void talk();
}
 

具體例項：

public class Doctor implements People {
    public void talk() {
        System.out.println("我是醫生");
    }
}

public class Teacher implements People {
    public void talk() {
        System.out.println("我是教師");
    }
}

抽象工廠

public abstract class AbstractFactory {
    abstract People createInstance();
}

具體工廠

public class DoctorFactory extends AbstractFactory {
    People createInstance() {
        return new Doctor();
    }
}

public class TeacherFactory extends AbstractFactory {
    People createInstance() {
        return new Teacher();
    }
}

測試類：

public class Test {
    public static void main(String[] args){
        AbstractFactory doctorFactory = new DoctorFactory();
        AbstractFactory teacherFactory = new TeacherFactory();
        doctorFactory.createInstance().talk();
        teacherFactory.createInstance().talk();
    }
}

我是醫生
我是教師

該模式的相對於 簡單工廠模式 來說，如果要增加新的 具體例項  不需要修改原來的工廠方法，只需要新增一個 具體工廠。缺點就是當 具體例項 很多的時候，會增加很多與之對應的 具體工廠

3、工廠方法模式

抽象例項和具體例項和前面的一樣，此處省略不寫

抽象工廠

public interface AbstractFactory {
    People createDoctorInstance();
    People createTeacherInstance();
}

具體工廠

public class ConcreteFactory  implements AbstractFactory {

    public People createDoctorInstance() {
        return new Doctor();
    }

    public People createTeacherInstance() {
        return new Teacher();
    }
}

測試類：

public class Test {
    public static void main(String[] args){
        AbstractFactory doctorFactory = new ConcreteFactory();
        doctorFactory.createDoctorInstance().talk();
        doctorFactory.createTeacherInstance().talk();
    }
}

我是醫生
我是教師

該模式缺點和簡單工廠模式一樣：增加 具體例項 需要修改 工廠類。

4、工廠模式與反射結合，實現新增 具體例項 不需要修改和新增 工廠類

抽象例項和具體例項和前面的一樣，此處省略不寫

具體工廠

public class ReflectFactory {
    public People createInstance(String className) throws Exception {
        Class<?> cls = Class.forName(className);
        People people = (People) cls.newInstance();
        return people;
    }
}

測試類：

public class Test {
    public static void main(String[] args) throws Exception {
        ReflectFactory reflectFactory = new ReflectFactory();
        reflectFactory.createInstance("factory.demo.Doctor").talk();
        reflectFactory.createInstance("factory.demo.Teacher").talk();
    }
}

我是醫生
我是教師