设计模式——1.工厂模式

前言：

本篇博客主要是总结一下自己对工厂模式的认识，例子可能不太恰当，uml类图也可能线用错。不过思想还是正确的

望各位指出错误

一、最简单的工厂模式——简单工厂（静态）模式。

    简单工厂模式严格意义上不属于设计模式

1.UML类图

2.角色分类

    2.1 抽象产品角色：是具体产品角色的共同父类，提供了一个标准接口。

    e.g:   将计算机专业看成一个抽象产品角色

public abstract class CS{
    /**
     * 描述具体专业
     */
    public abstract void major();
}

    2.2 具体产品角色：继承实现抽象产品角色，有自己具体的实现

    e.g:  具体的计算机专业

     物联网工程

public class Iot extends Cs{
    @Override
    public void major() {
        System.out.println("物联网不是搞物流的");
    }
}

    软件工程

public class Soft extends Cs{
    @Override
    public void major() {
        System.out.println("软件工程不一定会修电脑");
    }
}

    2.3 工厂角色：简单工厂模式的核心，创建具体的产品类对象（create方法为静态的）

public class CsFactory {
    public static final int TYPE_IOT = 1;//物联网
    public static final int TYPE_SOFT = 2;//软件工程


    public static Cs CreateMajor(int type) {
        switch (type) {
            case TYPE_IOT:
                return new Iot();
            case TYPE_SOFT:
                return new Soft();
            default:
                return 0;
        }
    }
}

3.  测试类

public class TestFactory{
    public static void main(String args[]){
        Cs cs =new Csfactory.CreateMajor(1); 
         cs.major();
   }
}

4.小结

简单工厂模式主要是为了介绍工厂模式的进门，虽然比较简单，但却是理解的基础，为后面其他工厂模式的理解打下基础、

5.优点&缺点

5.1 优点：使用者无需知道方法的具体实现过程。

缺点 ：扩展性差，产生新的计算机专业的时候，需要更改工厂类。（破坏了代码的开闭原则（设计模式原则之一）：对扩展开放，对修改关闭）

二、工厂方法模式

1.UML类图

2.对象分类

    2.1 抽象工厂对象：工厂模式的核心，具体工厂对象实现/继承该工厂对象

    e.g.  计算机类专业工厂产生计算机专业

public abstract CsFactory {
      public abstract Cs createCs();
}

    2.2 抽象产品角色：是具体产品角色的共同父类，提供了一个标准接口。

    e.g :  将计算机专业看成一个抽象产品角色

public abstract class Cs{
    public abstract void major();
}

    2.3具体产品角色：继承实现抽象产品角色，有自己具体的实现。

     e.g： 计算机专业分为物联网工程以及软件工程。

public class  Iot extends  Cs{
    @Override
    public void major() {
        System.out.println("物联网工程");
    }
}
public class  Soft extends  Cs{
    @Override
    public void major() {
        System.out.println("软件工程");
    }
}

    2.4  具体工厂对象：实现/继承抽象工厂对象。

    e.g:物联网以及软件工程两个专业有对应的工厂

public class  IotCsFactory extends CsFactory{
    @Override
    public Cs createCs() {
        return new Iot();
    }
}
public class  SoftCsFactory extends CsFactory{
    @Override
    public Cs createCs() {
        return new Soft();
    }
}

3.测试类

public class TestFactory{
    public static void main(String args[]){
      CsFactory iotcsfactory= new IotCsFactory();
      iotcsfactory.createCs().major();
      TeCsFactory softcsfactory= new SoftCsFactory();
      softcsfactory.createCs().major();
}      
}

4.小结

 简单工厂模式的衍生，是对简单工厂模式的抽象。相当于将简单工厂模式中的工厂分为抽象工厂和具体工厂。符合开闭原则，添加新的专业，只要其工厂继承原有抽象工厂，以及本身继承原有的抽象Cs类。

5.缺点

5.1 添加新的专业，除了添加新的专业类，也要提供其对应的具体工厂类。不用改变原来的代码，

5.2 一个具体工厂只能创建一个具体产品。

三、抽象工厂类

1.UML类图

2.角色分类

2.1 抽象工厂对象：工厂模式的核心，具体工厂对象实现/继承该工厂对象

e.g 抽象Cs工厂，会产生物联网以及软件工程两个专业

public abstract AbstractCsFactory {
      public abstract Iot createIot();
      public abstract Soft createSoft();
}

2.2 抽象产品角色：是具体产品角色的共同父类，提供了一个标准接口。

e.g  物联网以及软件专业都可以细分，所以都设置为抽象类

public abstract class Iot{
    public abstract void major();
}
public abstract class Soft{
    public abstract void major();
}

2.3具体产品角色：继承实现抽象产品角色，有自己具体的实现。

e.g 物联网以及软件工程两个专业都有师范和非师范类

public class  TeIot extends  Iot{
    @Override
    public void major() {
        System.out.println("物联网师范");
    }
}
public class  NoTeIot extends  Iot{
    @Override
    public void major() {
        System.out.println("物联网非师范");
    }
}
public class  TeSoft extends  Soft{
    @Override
    public void major() {
        System.out.println("软件工程师范");
    }
}
public class  NoTeSoft extends  Soft{
    @Override
    public void major() {
        System.out.println("软件工程非师范");
    }
}

2.4  具体工厂对象：实现/继承抽象工厂对象。

e.g. 分为师范类工厂和非师范类工厂

public class TeCsfactory extends AbstractCsFactory {  
    @Override  
    public Iot createIot() {  
        return new TeIot();  
    }  
  
    @Override  
    public Soft createSoft() {  
        return new TeSoft();  
    }   
}  

public class NoTeCsfactory extends AbstractCsFactory 
{  
    @Override  
    public Iot createIot() {  
        return new NoTeIOT();  
    }  
    @Override  
    public Soft createSoft() {  
        return new NoTeSoft();  
    }   
}  

3.测试类

public class TestFactory {
	public static void main(String args[]){
		AbstractFactory tefactory = new TeCsfactory ();
		tefactory.createIot().major();
		tefactory.createSoft().major();
	}
}

4.小结

相对于工厂方法模式，抽象工厂模式可以产生多余的其他功能。一个具体的工厂可以产生多个有类似功能的对象。