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

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

@设计模式---工厂模式的总结

一、工厂方法模式和抽象工厂模式的对比：
    1.工厂模式是一种极端情况下的抽象工厂模式，通过前面的类图和代码实现我们可以看到这样一个对比，而抽象工厂模式可以看成是工厂模式的推广，
    2.工厂模式用来创建一个产品的等级结构，而抽象工厂模式是用来创建多个产品的等级结构，
    3.工厂模式只有一个抽象产品类，而抽象工厂模式有多个抽象产品类，总之就是单一对多个产品的这种对比。

二、工厂模式帮助我们实现了什么呢？
    1.系统可以在不修改具体工厂角色的情况下引进新的产品，
    2.客户端不必关系对象如何去创建，明确了职责，对象具体的创建交给了具体的产品，product1，product2，客户端只要告诉工厂我需要哪一，product1还是product2，它们具体是怎么创建的，怎么组合的，都交给了具体的产品product1，product2
    3.更好的理解面向对象的原则，面向接口编程，而不是面向实现编程。
那我们整体的工厂模式就是这样一个原则。

三、工厂模式适用于哪些场景呢？
    1.一个系统应当不依赖于产品类实例被创立，组成和表示的细节，就是说这个产品如何被创建，组成和表现，我们都归结到具体的产品是如何实现上去了，与前端的client，和中端的factory都是没有关系的，
    2.这个系统的产品至少有一个产品族，工厂方法模式就是一个产品族，它是最简单的一个等级，
    3.同属于同一个产品族的产品是设计成在一起使用的，这是毋庸置疑的，同属于一个系列的产品，就是在一起的，
    4.不同的产品以一系列的接口的面貌出现，从未使系统不依赖于接口实现的细节，我们都是面向接口编程的，不是面向实现编程的，

@设计模式---工厂模式之 抽象工厂模式
1.创建两个接口，如：Boy，有drawMan();Girl，有drawWoman()。

public interface Boy {
  public void drawMan();
}
public interface Girl {
  public void drawWoman();
}

2.创建接口的各两个实现类，如：HNBoy、MCBoy;HNGirl、MCGirl。

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

3.创建主工厂接口，如：PersonFactory。

public interface PersonFactory {
  //男孩接口
  public Boy getBoy();
  //女孩接口
  public Girl getGirl();
}

4.创建次工厂类实现主工厂接口，如：HNFactory和MCFactory。

public class HNFactory implements PersonFactory {
  @Override
  public Boy getBoy() {
    return new HNBoy();
  }
  @Override
  public Girl getGirl() {
    return new HNGirl();
  }
}
public class MCFactory implements PersonFactory {
  @Override
  public Boy getBoy() {
    return new MCBoy();
  }
  @Override
  public Girl getGirl() {
    return new MCGirl();
  }
}

5.测试用例

PersonFactory factory = new MCFactory();
Girl girl = factory.getGirl();
girl.drawWoman();

@设计模式---工厂模式之 工厂方法模式
1.创建一个接口，如：HairInterface，有个抽象方法draw。

public interface HairInterface {
    public void draw();
}

2.创建实现接口的子类，如：LeftHair、RightHair、InHair。

public class LeftHair implements HairInterface {
    @Override
    public void draw() {
        System.out.println("左偏分发型");
    }
}

3.创建工厂类，如：HairFactory，根据类的名称来生产对象。

public HairInterface getHairByClass(String className){
    try {
        HairInterface hair=(HairInterface) Class.forName(className).newInstance();
        return hair;
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    return null;
}

4.通过映射文件，简化类的名称，如：type.properties。

left=onetry.DesigntonDemo.LeftHair
right=onetry.DesigntonDemo.RighttHair
in=onetry.DesigntonDemo.InHair

5.创建properties文件的读取工具，如：PropertiesReader。

public class PropertiesReader {
    public Map<String,String> getProperties(){  
        Properties props = new Properties();
        Map<String,String> map = new HashMap<String,String>();
        try{
          //以流的形式读取properties文件
          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);
            }
        }catch(Exception e){
          e.printStackTrace();
        }
        return map;
    }
}

6.修改HairFactory，用PropertiesReader读取 替换 原来的className。

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) {
      e.printStackTrace();
    } catch (IllegalAccessException e) {
      e.printStackTrace();
    } catch (ClassNotFoundException e) {
      e.printStackTrace();
    }
    return null;
}

7.测试用例

HairFactory factory = new HairFactory();
//HairInterface left = factory.getHairByClass("onetry.DesigntonDemo.LeftHair");
HairInterface hair = factory.getHairByClassKey("in");
hair.draw();

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

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