设计模式-二

简单工厂模式

定义：简单工厂模式属于创建型模式，其又被称为静态工厂方法模式，这是由一个工厂对象决定创建哪一种产品类的实例。
结构流程：
Factory --> Product —> IProduct

• Factory： 工厂类，这是简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。

• IProduct:抽象产品类，这是简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

• Product:具体产品类，这是简单工厂模式的创建目标。

   public class SimpleFactory {
  
   public static void main(String[] args){
   	//用户使用
   	ComputerFactory.createComputer("lenvo").start();
   }
  
  
  
   public abstract  class  Computer{
   	/**
   	 * 产品的抽象方法
   	 */
   	public abstract void start();
   }
  
   /**
   * 具体实现类
   */
   public class  LenovoComputer extends Computer{
   	@Override
   	public void start() {
       	System.out.print("联想计算机启动");
   	}
   }
  
   /**
   * 具体实现类
    */
   public class  HpComputer extends Computer{
   	@Override
   	public void start() {
       	System.out.print("惠普计算机启动");
   	}
   }
  
  
   /**
   * 工厂
   */
   public class  ComputerFactory{
   	public static Computer createComputer(String type){
       	Computer mComputer = null;
       	switch (type){
           	case "lenvo":
               	mComputer = new LenovoComputer();
               	break;
           	case "hp":
               	mComputer = new HpComputer();
               	break;
            	default:
               	 break;
       	}
       	return mComputer;
   	}
   }
  
   }  
  

简单的说厂就像一个中转站一样。

• 使用场景：
  • 工厂类负责创建的对象比较小。
  • 客户只需要知道传入工厂类的参数，而无须关心创建对象的逻辑。
• 优点：使用用户根据参数获得对应类的实例，避免了直接实例化类，降低了耦合性。
• 缺点：可实例化的类型在编译期间已经被确定。如果增加新类型，则需要修改工厂，者违背了开放封闭原则。简单工厂需要知道所有要生成的类型，其当子类过多或者子类层次过多时不适合使用。

工厂方法模式

定义：定义一个用于创建对象的接口，让子类决定实例化哪个类。工厂方法使一个类的实例化延迟到其子类。
结构流程：
Facory <-- ConcreateFactory --> ConcreProduct --> Product
(1)创建抽象工厂

public abstract class ComputerFactory1 {
	public abstract  <T extends Computer> T createComputer (Class<T> clz);
}  

(2) 具体工厂

public class GDComputerFactor extends ComputerFactory1 {
@Override
public <T extends Computer> T createComputer(Class<T> clz) {
    Computer computer = null;
    String classname = clz.getName();
    try {
        //通过反射来得到具体的实现类
        computer = (Computer) Class.forName(classname).newInstance();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    return (T) computer;
}

}

(3) 客户端调用

public class Client {
public static void main(String[] args){
    ComputerFactory1 computerFactory1 = new GDComputerFactor();
    LenovoComputer lenovoComputer = computerFactory1.createComputer(LenovoComputer.class);
    lenovoComputer.start();
    HpComputer hpComputer = computerFactory1.createComputer(HpComputer.class);
    hpComputer.start();
}
}

从这里可以看出工厂模式比简单工厂模式的优势之处了，就是当新增实例类时，不用去修改工厂中的逻辑，这样就没有违背开放封闭原则。

建造者模式

定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
结构流程：
Director --> Builder <-- ConcreteBuilder --> Product

• Director: 导演类，负责安排已有模块的顺序，然后通过 Builder 开始建造。
• Builder : 抽象 Builder 类，规范产品的组建，一般由子类实现。
• ConcreteBuilder: 具体建造者，实现抽象 Builder 类定义的所有方法，并且返回一个组建好的对象。
• Product: 产品类。

(1) 创建产品类

/**
* 计算机 Bean
*/
public class Computer {
private String Cpu;
private String mMainboard;
private String mRam;

public void setCpu(String cpu) {
    Cpu = cpu;
}

public void setmMainboard(String mMainboard) {
    this.mMainboard = mMainboard;
}

public void setmRam(String mRam) {
    this.mRam = mRam;
}
}  

(2) 创建 Builder 类规范产品的组建

public  abstract class Builder  {
public abstract  void  buildCpu(String cpu);
public abstract  void  buildMainboard(String mainboard);
public abstract  void  buildRam(String ram);
public abstract  Computer create();
}

/**
* Builder 的实例类
*/
public class MoonComputerBuilder extends Builder {
private Computer mComputer = new Computer();
@Override
public void buildCpu(String cpu) {
    mComputer.setCpu(cpu);
}

@Override
public void buildMainboard(String mainboard) {
    mComputer.setmMainboard(mainboard);
}

@Override
public void buildRam(String ram) {
    mComputer.setmRam(ram);
}

@Override
public Computer create() {
    return mComputer;
}
}

(3) 用导演类来统一组装过程

public class Director {
private  Builder mBuild = null;
public Director (Builder builder){
    this.mBuild = builder;
}

/**
 * 构建的计算机的方法
 * @param cpu
 * @param manboard
 * @param ram
 * @return
 */
public Computer CreateComputer(String cpu,String manboard,String ram){
    this.mBuild.buildCpu(cpu);
    this.mBuild.buildMainboard(manboard);
    this.mBuild.buildRam(ram);
    return this.mBuild.create();
}
}

(4)客户端调用导演类

public class CreateComputer {
public static void main(String[] args){
    Builder builder = new MoonComputerBuilder();
    Director director = new Director(builder);
    director.CreateComputer("很牛的cpu","好的主板","厉害的内存");
}

}  

• 使用场景：
  • 相同的方法，不同的执行顺序，产生不同的事件结果时。
• 优点：
  • 使用建造者模式可以使客户端不必知道产品内部组成的细节。
  • 具体的建造者类之间使相互独立的，容易扩展。
  • 由于具体的建造者使独立的，因此可以对建造者过程逐步细化，而不是对其他的模块产生任何影响。
• 缺点： 产生多余的 Build 对象以及 Director 。