• 设计模式——工厂模式

一、概念

    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、更好的理解面向对象的原则，面向接口编程，而不要面向实现编程。

工厂模式.

Enumeration在这里我并不推荐使用，而是推荐使用Iterator接口。此接口的功能与 Iterator 接口的功能是重复的。此外，Iterator 接口添加了一个可选的移除操作，并使用较短的方法名。新的实现应该优先考虑使用 Iterator 接口而不是 Enumeration 接口。

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

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

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

工厂模式的优点

抽象工厂模式类图

设计模式---工厂模式——总结  1、接下来看spring beanfactory,这是非常有名的工具，我们知道spring容器是一个控制反转，主要作用是生成bean，管理bean，从工厂模式来看，spring beanfactory就是生产bean，然后提供给客户端。 2、来看一下bean实例化的过程：调用bena的默认构造方式生成bean的实例，暂称为instance1，如果在bean配置文件中注入了bean的属性，则在instance1基础上进行属性注入形成instance2，这种注入是覆盖性的，如果bean实现了InitializingBean接口，则调用afterPropertiesSet()方法，来改变或者操作instance2，得到instance3。其中：InitializingBean是spring提供的一个初始化bean的类，如果实现了这个类，则必须实现afterPropertiesSet()方法，接下来，如果bean的配置文件中指定了inti-method="init"属性，又会调用一个初始化方法，则在instance3的基础上又会进行一些改变，编程instance4.

抽象工厂类就是有一个工厂类接口，有多个具体的工厂类继承这个工厂类接口，获取工厂类需要制定具体调用哪一个工厂类实例，然后调用这个工厂类中的方法获取指定的对象。

property工具类的实现

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 propery = props.getProperty(key);
map.put(key, propery);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return map;
}
}

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

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

在java开发中，应该活用配置文件去进行开发，将配置文件，加入到我们的撸代码的思路中，这样，撸代码的思维，就比较的开阔

我们现在有动物，植物，两个对象，这两个对象可以抽象出一个对象，生物；其中，动物，植物，都分别具有自己的独有属性，此时如果采用工厂模式，是否可以对动物，植物，进行增删改查(自我感觉不适用)；其次，如果是生物中的方法，是否可以通过工厂模式实现，比如呼吸(自我感觉适用)。

因此，针对于工厂模式来说，适用于，在一个方法中，使用了相同属性的不同对象，如果在一个方法中，使用的不同的属性，个人感觉，不适用工厂模式

实例  instance

工厂模式的应用：jdbc

根据类的名称来创建对象    反射机制

工厂模式总结 适用于哪些场景

工厂方法 vs 抽象工厂

抽象工厂模式 常见应用

应用场景举例

抽象工厂产品等级结构

抽象工厂模式类图

工厂模式类图

工厂模式应用场景

 什么情况下适合工厂模式

 工厂模式的意图

 什么是工厂模式

 主要内容。。。