疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

设计模式实例学习-工厂方法


 

 
设计模式实例学习-工厂方法
定义 概念定义
(对象创建型模式)
 
    定义一个用于创建对象的接口,让子类决定实例化那个类。工程方法使一个类的实例化延迟到其子类。
角色职责
抽象产品类
具体产品类
抽象工厂类
具体工厂类
 
  这个模式的角色比较好理解,产品类就是产品,工厂类就是负责生产产品的。(具体参看实例分析后就能很好的明白了)
实例分析 场景描述
  大学里面有很多不同的学院,不同的学院教育并输出(生产出)不同专业的学生。现在有三个学院,分别是软件专业,物理专业,英语专业。输出每个学院的一个学生。
 
代码实现及讲解
抽象产品类
public abstract class Student {
 
    //学生都是同一个学校的。
    public void mySchool(){
        System.out.println("From SCNU");
    }
 
    //专业不同,由子类去实现。
    public abstract void myMajor(); 
 
}
具体产品类 
EnglishStudent.java 
PhysicsStudent.java 
SoftwareStudent.java
//英语专业学生
public class EnglishStudent extends Student{
 
    @Override
    public void myMajor() {
        System.out.println("My Major is English...");       
    }
 
}
//物理专业学生
public class PhysicsStudent extends Student{
 
    @Override
    public void myMajor() {
        System.out.println("My Major is Physics...");
    }
 
}
//软件专业学生
public class SoftwareStudent extends Student{
 
    @Override
    public void myMajor() {
        System.out.println("My Major is Software...");
    }
 
}
抽象工厂类
public abstract class College {
    public abstract <T extends Student> T teachingStudent(Class<T> c);
}
teachingStudent:负责生产学生对象。
 
具体工厂类
public class ScnuCollege extends College{
 
    @Override
    public <T extends Student> T teachingStudent(Class<T> c) {
        Student student = null;
        try {
            student = (Student) Class.forName(c.getName()).newInstance();
        } catch (InstantiationException | IllegalAccessException
                | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (T)student;
    }
 
}
通过反正获取类的名字,实例化生成对应的学生类对象
场景类
package factoryMethod;
 
public class Main {
    public static void main(String[] args) {
        College mCollege = new ScnuCollege();
        Student physicsStudent = mCollege.teachingStudent(PhysicsStudent.class);
        Student englishStudent = mCollege.teachingStudent(EnglishStudent.class);
        Student softwareStudent = mCollege.teachingStudent(SoftwareStudent.class);
        physicsStudent.myMajor();
        englishStudent.myMajor();
        softwareStudent.myMajor();
    }
}
输出:
 
My Major is Physics...
My Major is English...
My Major is Software...
  可以很明显看出该模式的特点,定义抽象父类(Student)或接口而不决定它对应的是哪个具体对象,由子类(PhysicsStudent/EnglishStudent/softwareStudent)去决定。
 
工厂方法模式优点
封装性好,代码结构清晰。
调用者只需要知道类名就可以使用,无需关心内部实现。(即屏蔽了产品类)
拓展性好,增加同类产品的时候增加一个产品类即可。增加不同类的产品的时候增加一个新的具体工厂类即可。
工厂方法的拓展-简单工厂模式 简单工厂模式定义
    事实上我们只用到了一个工厂类,没有必要将它作为对象实例化。省去了抽象工厂类,直接通过具体类里面的一个静态方法负责生产产品类。因此也叫静态工厂方法。
角色代码
具体工厂类 
StaticCollege.java
public class StaticCollege {
    //通过一个静态方法来创建实例化产品。
    public static <T extends Student> T teachingStudent(Class<T> c) {
        Student student = null;
        try {
            student = (Student) Class.forName(c.getName()).newInstance();
        } catch (InstantiationException | IllegalAccessException
                | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (T)student;
    }
}
场景类
public class Main {
    public static void main(String[] args) {
        //拓展:简单(静态)工厂方法
        Student physicsStudent = StaticCollege.teachingStudent(PhysicsStudent.class);
        Student englishStudent = StaticCollege.teachingStudent(EnglishStudent.class);
        Student softwareStudent = StaticCollege.teachingStudent(SoftwareStudent.class);
        physicsStudent.myMajor();
        englishStudent.myMajor();
        softwareStudent.myMajor();
    }
}
输出:
 
My Major is Physics...
My Major is English...
My Major is Software...
输出分析
  运行结果相同,但省略了抽象类及实例化具体工厂类的代码,直接通过类的静态方法实例化产品。 
  缺点的话是拓展性差,无法增加新的工厂生产新产品。
 
其他拓展类型
替代单例模式(略)
延迟初始化(缓存) 
  关于延迟实例化,是在工厂内部定义一个Map对象,每次生产产品时,通过HashMap来缓存生产的对象。创建对象时会在HashMap中查找是否已经缓存了这个产品,已经有了就直接在HashMap中取出。