工厂模式

工厂模式（Factory Pattern）是在开发中使用比较多的一种设计模式，通过工厂模式可以实现对对象的一种比较好的创建。工厂模式一般分为简单工厂、工厂方法和抽象工厂。

1.简单工厂

简单工厂包含以下角色：

• 抽象产品：说明产品的规范内容等。Person类，定义一个简单的sayHello()方法。
• 具体产品：抽象产品的子类或者实现抽象产品接口。以下Tearher,Student类。
• 具体工厂：提供生产产品的方法。PersonFactory类，createPersion()方法。

public interface Person {

    void sayHello();
}

public class Teacher implements Person {
    @Override
    public void sayHello() {
        System.out.print("teacher says hello");
    }
}

public class Student implements Person {
    @Override
    public void sayHello() {
        System.out.print("student says hello");
    }
}

public class PersonFactory {


    public static Person createPerson(Integer type) {
        if (1 == type) {
            return new Teacher();

        } else if (2 == type) {
            return new Student();
        }
        return null;
    }
}

@Test
public void test() {
    Person person = PersonFactory.createPerson(1);
    person.sayHello();
}

2.工厂方法

工厂方法模式在简单工厂的基础上把工厂对象也做了抽象，加入了抽象工厂。

工厂方法包含以下角色：

• 抽象工厂：工厂的抽象类，定义生产产品的接口 PersonInterfaceFactory 类
• 具体工厂：实现抽象工厂，具体生产产品的类 StudentFactory、TeacherFactory类
• 抽象产品：产品抽象类
• 具体产品：具体产品

public interface PersonInterfaceFactory {
    Person createPerson();
}

public class StudentFactory implements PersonInterfaceFactory {
    @Override
    public Person createPerson() {

        return new Student();
    }
}

public class TeacherFactory implements PersonInterfaceFactory {
    @Override
    public Person createPerson() {

        return new Teacher();
    }
}

public class PersonInterfaceFactorySupport {
    private static Map<Integer, PersonInterfaceFactory> factoryMap = new HashMap<Integer, PersonInterfaceFactory>();

    static {
        factoryMap.put(1, new StudentFactory());
        factoryMap.put(2, new TeacherFactory());
    }

    public static Person createPerson(Integer type) {
        return factoryMap.get(type).createPerson();
    }

}

@Test
public void test() {
    Person person = PersonInterfaceFactorySupport.createPerson(1);
    person.sayHello();
}

3.抽象工厂

包含以下角色：

• 抽象工厂：声明创建产品的方法。 PersonAbstractFactory 抽象工厂类，声明了创建学生createStudent()和创建老师createTeacher()的接口。
• 具体工厂：实现抽象工厂，完成具体产品创建。ClassOneFactory 类可以表示一班的工厂，它创建一年级的学生那个和老师，ClassTwoFactory 表示二班的工厂
• 抽象产品：定义产品的抽象角色 PersonStudent 学生抽象类，PersonTeacher 老师抽象类
• 具体产品：产品具体角色。StudentOneClass、StudentTwoClass、TeacherOneClass、TeacherTwoClass 分别表示一班的学生老师和二班的学生老师。

public interface PersonAbstractFactory {

    PersonStudent createStudent();

    PersonTeacher createTeacher();
}

public class ClassOneFactory implements PersonAbstractFactory {
    @Override
    public PersonStudent createStudent() {
        return new StudentOneClass();
    }

    @Override
    public PersonTeacher createTeacher() {
        return new TeacherOneClass();
    }
}

public class ClassTwoFactory implements PersonAbstractFactory {
    @Override
    public PersonStudent createStudent() {
        return new StudentOneClass();
    }

    @Override
    public PersonTeacher createTeacher() {
        return new TeacherOneClass();
    }
}

public abstract class PersonStudent {

    public abstract void sayStudentHello();
}

public abstract class PersonTeacher {

    public abstract void sayTeacherHello();
}

public class StudentOneClass extends PersonStudent {
    @Override
    public void sayStudentHello() {
        System.out.print("student says hello");
    }
}

public class StudentTwoClass extends PersonStudent {
    @Override
    public void sayStudentHello() {
        System.out.print("student says hello");
    }
}

public class TeacherOneClass extends PersonTeacher {
    @Override
    public void sayTeacherHello() {
        System.out.print("teacher says hello");
    }
}

public class TeacherTwoClass extends PersonTeacher {
    @Override
    public void sayTeacherHello() {
        System.out.print("teacher says hello");
    }
}

@Test
public void test() {
    PersonAbstractFactory factory = new ClassOneFactory();
    PersonTeacher teacher = factory.createTeacher();
    PersonStudent student = factory.createStudent();
    teacher.sayTeacherHello();
    student.sayStudentHello();
}