设计模式之工厂模式--慕课网笔记

最新推荐文章于 2021-12-10 15:22:11 发布

lmjun3

最新推荐文章于 2021-12-10 15:22:11 发布

阅读量421

点赞数

分类专栏：慕课网笔记文章标签：设计模式

本文链接：https://blog.csdn.net/helloPurple/article/details/77348898

版权

慕课网笔记专栏收录该内容

21 篇文章 0 订阅

订阅专栏

第1章工厂模式概述

1-1 工厂模式概述

什么是设计模式？

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、
代码设计经验总结。

应用设计模式有什么好处？

设计模式是优秀的使用案例，使用设计模式可提高代码的重用性、让代码更容易被他人理解、
保证代码可靠性。

工厂模式的概念
工厂模式的意图
工厂模式的应用场景
工厂模式的设计思想
工厂模式的好处

工厂模式概率：
实例化对象，用工厂方法代替new操作。
工程模式包括工厂方法模式和抽象工厂模式。
抽象工厂模式是工厂方法模式的扩展。

工厂模式的意图：
定义一个接口来创建对象，但是让子类来决定哪些类需要被实例化。
工厂方法把实例化的工作推迟到子类中去实现。

什么情况下适合工厂模式？

有一组类似的对象需要创建。
在编码时不能预见需要创建哪些种类的实例。
系统需要考虑扩展性，不应依赖于产品类实例如何被创建、组合和表达的细节。

项目中的状况：
在软件系统中经常面临着“对象”的创建工作，由于需求的变化，这个对象可能随之
发生改变，但它却拥有比较稳定的接口。
为此，我们需要提供一种封装机制来隔离出这个易变对象的变化，从而保持系统中
其他依赖该对象的对象不随这需求变化而变化。

基于项目状态将代码进行如下设计：

尽量松耦合，一个对象的依赖对象的变化与本身无关
具体产品与客户端剥离，责任分割

客户端–>creator–>Interface<–product1、2、3

多个产品族，就是抽象工厂模式

应用场景举例
myotee脸萌，一款制作头像的软件
可以自由选择发型，发色，脸型，肤色，眉毛，眼镜，嘴巴，鼻子等。

以发型为例，发型是这个大产品中的一个小部件，如果制作出了发型，其它部分也都
相似。再有更高级的应用，不同的用户级别需要不同的产品部件，这样就产生了一个
产品系列。

第2章工厂模式应用

2-1 工厂模式应用

/**
 * 发型接口
 * @author Administrator
 *
 */
public interface HairInterface {

    /**
     * 画图
     */
    public void draw();
}

/**
 * 左偏分发型
 * @author Administrator
 *
 */
public class LeftHair implements HairInterface {

    @Override
    public void draw() {
        // TODO Auto-generated method stub
        System.out.println("-----------------左偏分发型-------------------");
    }

}

/**
 * 右偏分发型
 * @author Administrator
 *
 */
public class RightHair implements HairInterface {

    @Override
    public void draw() {
        // TODO Auto-generated method stub
        System.out.println("-----------------右偏分发型-------------------");
    }

}

/**
 * properties文件的读取工具
 * @author Administrator
 *
 */
public class PropertiesReader {


    public Map<String, String> getProperties() {

        Properties props = new Properties();
        Map<String, String> map = new HashMap<String, String>();
        try {

            InputStream in = getClass().getResourceAsStream("type.properties");
            props.load(in);
            Enumeration en = props.propertyNames();
            while (en.hasMoreElements()) {
                String key = (String) en.nextElement();
                String property = props.getProperty(key);
                map.put(key, property);
//              System.out.println(key + "  " + property);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return map;
    }
}

left=com.sunny.project.LeftHair
right=com.sunny.project.RightHair
in=com.sunny.project.InHair

/**
 * 中分发型
 * @author Administrator
 *
 */
public class InHair implements HairInterface {

    @Override
    public void draw() {
        // TODO Auto-generated method stub
        System.out.println("-----------------中分发型-------------------");

    }

}

/**
 * 发型工厂
 * @author Administrator
 *
 */
public class HairFactory {

    /**
     * 根据类型来创建对象
     * @param key
     * @return
     */
    public HairInterface getHair(String key){
        if("left".equals(key)){
            return new LeftHair();          
        }else if("right".equals(key)){
            return new RightHair();
        }
        return null;
    }
    /**
     * 根据类的名称来生产对象
     * @param className
     * @return
     */
    public HairInterface getHairByClass(String className){

        try {
            HairInterface hair = (HairInterface) Class.forName(className).newInstance();
            return hair;
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 根据类的名称来生产对象
     * @param className
     * @return
     */
    public HairInterface getHairByClassKey(String key){

        try {
            Map<String, String> map = new PropertiesReader().getProperties();

            HairInterface hair = (HairInterface) Class.forName(map.get(key)).newInstance();
            return hair;
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }
}

第3章抽象工厂模式应用

3-1 抽象工厂模式应用

/**
 * 男孩
 * @author Administrator
 *
 */
public interface Boy {


    public void drawMan();
}

/**
 * 女孩子
 * @author Administrator
 *
 */
public interface Girl {

    public void drawWomen();
}

/**
 * 圣诞系列的女孩
 * @author Administrator
 *
 */
public class MCGirl implements Girl {

    @Override
    public void drawWomen() {
        // TODO Auto-generated method stub
        System.out.println("-----------------圣诞系列的女孩子--------------------");
    }

}

/**
 * 新年系列的女孩子
 * @author Administrator
 *
 */
public class HNGirl implements Girl {

    @Override
    public void drawWomen() {
        // TODO Auto-generated method stub
        System.out.println("-----------------新年系列的女孩子--------------------");
    }

}

/**
 * 圣诞系列的男孩子
 * @author Administrator
 *
 */
public class MCBoy implements Boy {

    @Override
    public void drawMan() {
        // TODO Auto-generated method stub
        System.out.println("-----------------圣诞系列的男孩子--------------------");
    }

}

/**
 * 新年系列的男孩子
 * @author Administrator
 *
 */
public class HNBoy implements Boy {

    @Override
    public void drawMan() {
        // TODO Auto-generated method stub
        System.out.println("-----------------新年系列的男孩子--------------------");
    }

}

/**
 * 人物的实现接口
 * @author Administrator
 *
 */
public interface PersonFactory {

    //男孩接口
    public Boy getBoy();
    //女孩接口
    public Girl getGirl();

}

/**
 * 圣诞系列加工厂
 * @author Administrator
 *
 */
public class MCFctory implements PersonFactory {

    @Override
    public Boy getBoy() {
        // TODO Auto-generated method stub
        return new MCBoy();
    }

    @Override
    public Girl getGirl() {
        // TODO Auto-generated method stub
        return new MCGirl();
    }

}

/**
 * 新年系列加工厂
 * @author Administrator
 *
 */
public class HNFactory implements PersonFactory {

    @Override
    public Boy getBoy() {
        // TODO Auto-generated method stub
        return new HNBoy();
    }

    @Override
    public Girl getGirl() {
        // TODO Auto-generated method stub
        return new HNGirl();
    }

}

public class SunnyTest {

    public static void main(String[] args){

//      HairInterface left = new LeftHair();
//      left.draw();

        HairFactory factory = new HairFactory();
//      HairInterface right =  factory.getHair("right");
//      right.draw();

//      HairInterface left = factory.getHairByClass("com.sunny.project.LeftHair");
//      left.draw();

//      HairInterface hair = factory.getHairByClassKey("in");
//      hair.draw();

//      PersonFactory facoty = new MCFctory();
//      Girl girl = facoty.getGirl();
//      girl.drawWomen();

        PersonFactory facoty = new HNFactory();
        Boy boy =  facoty.getBoy();
        boy.drawMan();
    }
}

第4章总结

4-1 总结

常见应用

JDBC
是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用
Java语言编写的类和接口组成。
客户端–>数据操作工程–>jdbc接口<–db2/mysql/oracle/sqlserver
Spring BeanFactroy
BeanFactroy，作为Spring基础的IoC容器，是Spring的一个Bean工厂。
如果单从工厂模式的角度来考虑，它就是用来“生产 Bean”，然后提供给
客户端。

Bean的实例化过程如下：

调用Bean的默认构造方法，或指定的构造方法，生成bean实例（暂称为instance1）
如果Bean的配置文件中注入了Bean的属性值，则在instance基础上进行属性注入形成
instance2，这种注入是覆盖性的
如果Bean实现了InitializingBean接口，则调用afterPropertiesSet()方法，来改变或
操作instance2，得到instance3
如果Bean的配置文件中指定了init-method=”init”属性，则会调用指定的初始化方法
则在instance3的基础上调用初始化方法init()，将对象最终初始化为instance4;当然
这个初始化的名字是任意的

工厂方法模式和抽象工厂模式对比

工厂模式是一种极端情况的抽象工厂模式，而抽象模式可以看成是工厂模式的推广
工厂模式用来创建一个产品等级结构，而抽象工厂模式是用来创建多个产品的等级结构
工厂模式只有一个抽象产品类，而抽象工厂模式有多个抽象产品类

工厂模式的实现帮助我们

系统可以在不修改具体工厂角色的情况下引进新的产品
客户端不必关心对象如何创建，明确了职责
更好的理解面向对象的原则面向接口编程，而不要面向实现编程

工厂模式适用于哪些场景

一个系统应当不依赖于产品类实例被创立，组成，和表示的细节。这对于所有
形态的工厂模式都是重要的
这个系统的产品有至少一个的产品族
同属于同一个产品族的产品是设计成在一起使用的。这一约束必须得在系统的设计
中体现出来
不同的产品以一系列的接口的面貌出现，从而使系统不依赖于接口实现的细节

《模式的秘密——工厂模式》视频地址

lmjun3

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
设计模式之工厂模式--慕课网笔记

第1章工厂模式概述1-1 工厂模式概述什么是设计模式？设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验总结。应用设计模式有什么好处？设计模式是优秀的使用案例，使用设计模式可提高代码的重用性、让代码更容易被他人理解、保证代码可靠性。工厂模式的概念工厂模式的意图工厂模式的应用场景工厂模式的设计思想工厂模式的好处工厂
复制链接

扫一扫