• 设计模式——工厂模式

一、概念

    1、实例化对象，用工厂方法替代new操作；

    2、工厂模式包括工厂方法模式和抽象工厂模式；

    3、抽象工厂模式是工厂方法模式的扩展。

二、意图

    1、定义一个接口来创建对象，但是子类来决定哪些类需要被实例化；

    2、工厂方法把实例化的工作推迟到子类中去实现。

三、应用场景

    1、有一组类似的对象需要创建；

    2、在编码时不能预见需要创建哪种类的实例；

    3、系统需要考虑扩展性，不应依赖于产品类实例如何被创建、组合和表达的细节。

工厂适用于哪些场景：

    1、一个系统应当不依赖于产品类实例被创建、组成和表示的细节，这对于所有形态的工厂模式都是重要的；

    2、这个系统的产品有至少一个的产品族；

    3、同属于同一个产品族（例如圣诞系列、元旦系列）的产品是设计成在一起使用的，这一约束必须得在系统的设计中体现出来；

    4、不同的产品以一系列的接口的面貌出现，从而使系统不依赖于接口实现的细节。

常见应用：

   1、 JDBC——一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。

   2、 SpringBeanFactory

        BeanFactory 作为Spring基础的IOC容器，是Spring的一个Bean工厂；如果单从工厂模式的角度考虑，它就是用来“生产Bean”，然后提供给客户端。

        Bean实例化的过程如下：

            （1）、调用Bean的默认构造方法，或者指定的构造方法，生成bean实例（赞成为instance1）；

            （2）、如果Bean的配置文件中注入了Bean属性，则在instance1基础上进行属性注入形成instance2，这 种注入是覆盖性的；

            （3）、如果Bean实现了InitializingBean接口，则调用afterPropertiesSet()方法，来改变或操作instance2，得到instance3；

            （4）、如果Bean的配置文件中制定了init-method="init"属性，则会调用指定的初始化方法，则在instance3的基础上调用初始化方法init()，讲对象最终初始化为instance4；当然，这个初始化的名字是任意的

四、动机

    项目现状：在软件系统中经常面临着“对象”的创建工作，由于需求的变化，这个“对象”也可能随之发生变化，但它却拥有比较稳定的接口。

    提供封装机制去隔离易变“对象”的变化，从而保持系统中依赖该“对象”的“其他对象”不随着需求的变化而变化。

    代码设计：

        1、尽量松耦合，一个对象的依赖对象的变化与对象本身无关；

        2、具体产品与客户端剥离，责任分割。

工厂模式代码示例：

public interface HairInterface{
    //实现发型
    public void draw();
}
//左偏分发型
public class LeftHair implements HairInterface{
    //画一个左偏分发型
    @Override
    public void draw(){
        System.out.println("实现了一个左偏分发型......");
    }
}
//右偏分发型
public class RightHair implements HairInterface{
    //画一个右偏分发型
    @Override
    public void draw(){
        System.out.println("实现了一个右偏分发型......");
    }
}
//中分发型
public class InHair implements HairInterface{
    //画一个中分发型
    @Override
    public void draw(){
        System.out.println("实现了一个中分发型......");
    }
}

public class SunnyTest{
    public static void main(String[] args){
          //此类调用不利于代码维护，也不利于管理，每次都要自己new一个对象
       HairInterface left = new LeftHair();
       left.draw();
       HairInterface right = new RightHair();
              right.draw();
              
       //工厂创建对象，将类交给工厂管理，要做什么样的事情让工厂帮我们创建对象
       HairFactory factory = new HairFactory();
       HairInterface left = factory.getHair("left");
       left.draw();
       HairInterface right = factory.getHair("right");
       right.draw();
              
       //工厂根据类的名称获取对象,这样只需增加类，在创建的时候传入类限定名就可以
       HairInterface left = factory.getHairByClass("LeftHair的全类限定名");
       left.draw();
       HairInterface right = factory.getHair("RightHair的全类限定名");
       right.draw();
              
       //向上面传入全类限定名很麻烦，在Java中有properties文件可以对类做映射关系，传参的时候传入类对应的别名就OK
       HairInterface left = factory.getHairByClassKey("right");
       right.draw();
       HairInterface in = factory.getHairByClassKey("in");
              in.draw();
    }
}

//对发型进行统一的管理
public class HairFactory{
    //根据类型来创建对象，但是每多创建一种就要加if判断
    public HairInterface getHair(String key){
        if("left".equals(key)){
            return new LeftHair();
        }else if("right".equals(key)){
            return new RightHair();
        }
        return null;
    }
    //Java反射机制创建对象，根据类的名称创建对象
    public HairInterface getHairByClass(String className){
        try{
            HairInterface hair = Class.forName(className).newInstance();
            return hair;
        }catch(Exception e){//有具体的异常抓捕，这里用Exception代替
            e.printStackTrace();
        }
        return null;
    }
    //读取properties文件获取全类限定名
        public HairInterface getHairByClassKey(String key){
            try{
                Map<String,String> map = new PropertiesReader().getProperties();
                HairInterface hair = Class.forName(map.get(key)).newInstance();
                return hair;
            }catch(Exception e){//有具体的异常抓捕，这里用Exception代替
                e.printStackTrace();
            }
            return null;
    }
    
}

--type.properties
left=LeftHair的全类限定名
right=RightHair的全类限定名
in=InHair的全类限定名

//读取properties文件类
public class PropertiesReader{
    public Map<String,String> getProperties(){
        Properties props = new Properties();
        Map<String,String> map = new HashMap<String,String>();
        try{
            InputStream in = getClass.getReaourceAsStream("type.properties");
            props.load(in);
            Enumration 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;
    }
    public static void main(String[] args){
        PropertiesReader reader = new PropertiesReader();
        Map<String,String> map = reader.getProperties();
        Syatem.out.println(map.get("in"));
    }
}

抽象工厂模式类图：

抽象工厂模式代码示例：

//男孩
public interface Boy{
    public void drawMan();
}
//女孩
public interface Girl{
    public void drawWomen();
}

//圣诞系列女孩
public class MCGirl implements Girl{  
    @override
    public void drawWomen(){
        System.out.println("圣诞系列的女孩子......");
    }
}
//元旦系列女孩
public class HNGirl implements Girl{    
    @override
    public void drawWomen(){
        System.out.println("新年系列的女孩子......");
    }
}
//圣诞系列男孩
public class MCBoy implements Boy{  
    @override
    public void drawMan(){
        System.out.println("圣诞系列的男孩子......");
    }  
}
//元旦系列男孩
public class HNBoy implements Boy{
   @override
   public void drawMan(){
       System.out.println("新年系列的男孩子......");
   }    
}

//人物的实现接口
public interface PersonFactory{
    public Boy getBoy();
    
    public Girl getGirl();
}
//圣诞系列工厂
public class MCFactory implements PersonFactory{
   @override
   public Boy getBoy(){
       return new MCBoy();
   }
   @override
   public Girl getGirl(){
       return new MCGirl();
   }
   
}
//元旦系列工厂
public class HNFactory implements PersonFactory{
   @override
   public Boy getBoy(){
       return new HNBoy();
   }
   @override
   public Girl getGirl(){
       return new HNGirl();
   }
}

public class SunnyTest{
   public static void main(String[] args){
       //生产圣诞系列女孩
       PersonFactory factory = new MCFactory();
       Girl girl = factory.getGirl();
       girl.drawWomen();
       //生产元旦系列男孩
       PersonFactory factory = new HNFactory();
       Boy boy = factory.getBoy();
       boy.drawMan();
   }
}

五、总结

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

    1、工厂模式是一种极端情况的抽象工厂模式，而抽象工厂模式可以看成是工厂模式的推广；

    2、工厂模式用来创建一个产品的等级结构，而抽象工厂模式是用来创建多个产品的等级结构；

    3、工厂模式只有一个抽象产品类，而抽象工厂模式有多个抽象产品类

工厂模式的是想帮助我们：

    1、系统可以在不修改具体工厂角色的情况下引进新的产品；

    2、客户端不必关心对象如何创建，交给工厂创建，明确了创建；

    3、更好的理解面向对象的原则，面向接口编程，而不要面向实现编程。

工厂模式.

工厂模式：1、有一组类似的对象需要创建。

2、在编码时不能预见需要创建哪种类的实例。

3、系统需要考虑拓展性，不依赖于产品类实例如何被创建、组合和表达的细节

抽象工厂模式类图

@设计模式——工厂模式——工厂模式概述

设计模式：是一套被反复使用，多数人知晓的，经过分类编目的，代码设计经验的总结 好处：可以提高代码的重用性，让代码更容易被他人理解，保证代码的可靠性 工厂模式： 实例化对象，用工厂方法代替new操作 工厂模式包括工厂方法模式和抽象工厂模式 抽象工厂模式是工厂方法模式的扩展。 工厂模式的意图：定义一个接口来创建对象，但是让子类来决定哪些类需要被实例化。 工厂方法把实例化的工作推迟到子类中去实现。 适合工厂模式的情况： （1）有一组类似的对象需要创建。 （2）在编码的时候不能预见需要创建哪种类的实例。 （3）系统需要考虑扩展性，不应依赖于产品类实例化如何被创建，组合和表达的细节。 设计： （1）尽量松耦合，（2）具体产品与客户端剥离

应用场景举例

抽象工厂产品等级结构

抽象工厂模式类图

工厂模式类图

工厂模式应用场景

 什么情况下适合工厂模式

 工厂模式的意图

 什么是工厂模式

 主要内容。。。

应用设计模式的好处

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

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

@设计模式---工厂模式
一、工厂模式概念
    1.实例化对象，用工厂方法代替new操作；
    2.包括工厂方法模式和抽象工厂模式；
    3.抽象工厂模式是工厂方法模式的推广。
二、工厂模式的意图
    1.定义【接口】来创建对象，但让子类来决定哪些类需要被实例化；
    2.工厂方法把实例化的工作推迟到子类中去实现。
三、适合工厂模式的情况
    1.有一组类似的对象需要创建。
    2.在编码的时候不能预见需要创建哪种类的实例。
    3.系统需要考虑扩展性，不应依赖于产品类实例化如何被创建，组合和表达的细节。
四、项目中的现状
    在软件系统中经常面临着“对象”的创建工作，由于需求的变化，这个对象可能随之也会发生变化，但它却拥有比较稳定的接口。为此，我们需要提供一种封装机制来隔离出这个易变对象的变化，从而保持系统中其他依赖该对象的对象不随着需求变化而变化。
五、基于项目现状将代码进行如下设计
    1.尽量松耦合，一个对象的依赖队形的变化与本身无关；
    2.具体产品与客户端剥离，责任分割。

接口创建对象，子类决定哪些被实例化