创建型模式和关于状态视图、活动视图、交互视图的总结

单例模式（singleton）

什么是单例模式？顾名思义一个类的实例只能存在一个类的实例，并提供一个实例的全局访问点，这样的类设计的思想叫做单例模式

下面是java程序实现：

public class DanLiMode {
//这样保证该类的实例对象只能由一个，利用private关键字私有化
//设置该类可访问的唯一一个方法，来进行对象的获取
     private static DanLiMode danLiMode;
     
     private static DanLiMode getDanLiMode() {
         if(danLiMode==null) {
             synchronized ("123") {
                 if(danLiMode==null) {
                     danLiMode=new DanLiMode();
                 } 
            }     
         }
        return danLiMode;
     }
     public static void main(String[] args) {
        DanLiMode dLiMode=DanLiMode.getDanLiMode();
        DanLiMode dLiMode2=DanLiMode.getDanLiMode();
        System.out.println(dLiMode==dLiMode2);
    }
     
     //输出结果是同一对象
}

输出结果为true

下面简述一下单例模式的优缺点

优点：因为只有一个实例，减少内存开支和系统的开销，可以避免对资源的占用，单例模式可以在系统设置全局访问点

缺点：单例模式一般没有接口，基本无法扩展

抽象工厂模式（Abstract Factory）

抽象工厂模式的应用场景：当需要面临“一系列相互依赖的对象”的创建工作，同时需要满足需求的变化，随着变化创建不同的对象，换种书法就是，当一些项目需要多系列对象构建时，此时需要使用抽象工厂模式多系列对象就指的是对象之间相互依赖，或作用。

下面是java程序实现：

UML图：

  

代码：

public interface  Car {
     public void get();
}
public abstract class BigCar  implements Car{
    @Override
    public abstract void get();
}
 public abstract class SmailCar implements Car{
    @Override
    public abstract void get();
}
public class ChinaBigCar extends BigCar {
    @Override
    public void get() {
        System.out.println("中国大车...");
    }
}
public class ChinaSmailCar extends SmailCar {
    @Override
    public void get() {
        System.out.println("中国小车");
    }
}
public class EnglandBigCar extends BigCar{
    @Override
    public void get() {
        // TODO Auto-generated method stub
        System.out.println("英国大车");
    }
}
 public class EnglandSmailCar  extends SmailCar{
    @Override
    public void get() {
        System.out.println("英国小车");
    }
}
public interface CarFactory {

    public BigCar getBigCar();
    
    public SmailCar getSmailCar();
}
public class ChinaCarFactory  implements CarFactory{

    @Override
    public BigCar getBigCar() {
        // TODO Auto-generated method stub
        return new ChinaBigCar();
    }

    @Override
    public SmailCar getSmailCar() {
        // TODO Auto-generated method stub
        return new ChinaSmailCar();
    }

}
public class EnglandCarFactory implements CarFactory{

    @Override
    public BigCar getBigCar() {
        // TODO Auto-generated method stub
        return new EnglandBigCar();
    }

    @Override
    public SmailCar getSmailCar() {
        // TODO Auto-generated method stub
        return new EnglandSmailCar();
    }

}
 public class Client {
public static void main(String[] args) {
//首先我们创建一个ChinaCarFactory对象
    ChinaCarFactory carFactory=new ChinaCarFactory();
    //利用工厂创建对象，可得到该对象的实例，因为时中国工厂，所以创建的一定时中国车，此处使用父类指向子类对象
    BigCar bigCar = carFactory.getBigCar();
    bigCar.get();
    
    SmailCar smailCar=carFactory.getSmailCar();
    smailCar.get();
    
//其次我们创建一个EnglandCarFactory对象
    
    EnglandCarFactory englandCarFactory=new EnglandCarFactory();
            
    BigCar bigCar2=englandCarFactory.getBigCar();
    bigCar2.get();
            
    SmailCar smailCar2=englandCarFactory.getSmailCar();
    smailCar2.get();
    
}
} 

输出结果：

中国大车...
中国小车
英国大车
英国小车

下面简述一下抽象工厂的优缺点：

优点：分离了具体的类。客户通过抽象接口操纵实例，产品的类名也在具体工厂的实现中被分离，它们不出现在客户代码中。 

           易于交换产品系列。一个具体工厂类只在初始化时出现一次，这使得改变一个应用的具体工厂变得很容易，只需改变具体的工厂即可使用不同的产品配置。 

缺点：不利用纵向的扩展，比如现在需要生产一个大卡车，那么ChinaCarFactory和EnglandCarFactory等等一系列类和工厂接口都要进行改动

     生成器模式（Builder）

当一个复杂对象的构建与其表示相分离，使得同样的构建过程可以创建不同的表示时，可以使用Builder模式

下面时java程序实现：

UML:

 

代码:

public  class BuilderTest {
    public static void main(String[] args) {
        
        ProductBuilder defaultConcreteProduct = new DefaultConcreteProduct();
        Director director=new Director(defaultConcreteProduct);
        Product product = director.makeProduct("XXX", "XXX", "XXX", "XXX", "XXX", "XXX");
        System.out.println(product);
          }
    

}
interface ProductBuilder{
    void buildProductName(String productName);
    
    void buildCompanyName(String companyName);
    
    void buildPart1(String part1);
    
    void buildPart2(String part2);
    
    void buildPart3(String part3);
    
    void buildPart4(String part4);
    
    Product getProduct();
}        

class DefaultConcreteProduct implements ProductBuilder{
    private String productName;
    private String companyName;
    private String part1;
    private String part2;
    private String part3;
    private String part4;
    
    
    public DefaultConcreteProduct() {
        
    }

    @Override
    public void buildProductName(String productName) {
        this.productName=productName;
    }

    @Override
    public void buildCompanyName(String companyName) {
        this.companyName=companyName;
        
    }

    @Override
    public void buildPart1(String part1) {
        this.part1=part1;
        
    }

    @Override
    public void buildPart2(String part2) {
        this.part2=part2;
        
    }

    @Override
    public void buildPart3(String part3) {
        this.part3=part3;
    }

    @Override
    public void buildPart4(String part4) {
        this.part4=part4;
    }

    @Override
    public Product getProduct() {
        // TODO Auto-generated method stub
        return new Product(this.productName,this.companyName,this.part1,this.part2,this.part3,this.part4);
    }
    
}
class Director{
    private ProductBuilder builder;
    
    public Director(ProductBuilder builder) {
        this.builder=builder;
    }
    public Product makeProduct(String productName, String companyName, String part1, String part2, String part3, String part4) {
        builder.buildProductName(productName);
        builder.buildCompanyName(companyName);
        builder.buildPart1(part1);
        builder.buildPart2(part2);
        builder.buildPart3(part3);    
        builder.buildPart4(part4);
        return builder.getProduct();
        
    }
}
    
class Product{
    private String productName;
    private String companyName;
    private String part1;
    private String part2;
    private String part3;
    private String part4;
    
    
    public Product() {
        super();
    }
    public Product(String productName, String companyName, String part1, String part2, String part3, String part4) {
        super();
        this.productName = productName;
        this.companyName = companyName;
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
        this.part4 = part4;
    }
    public String getProductName() {
        return productName;
    }
    public void setProductName(String productName) {
        this.productName = productName;
    }
    public String getCompanyName() {
        return companyName;
    }
    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }
    public String getPart1() {
        return part1;
    }
    public void setPart1(String part1) {
        this.part1 = part1;
    }
    public String getPart2() {
        return part2;
    }
    public void setPart2(String part2) {
        this.part2 = part2;
    }
    public String getPart3() {
        return part3;
    }
    public void setPart3(String part3) {
        this.part3 = part3;
    }
    public String getPart4() {
        return part4;
    }
    public void setPart4(String part4) {
        this.part4 = part4;
    }
    @Override
    public String toString() {
        return "Product [productName=" + productName + ", companyName=" + companyName + ", part1=" + part1 + ", part2="
                + part2 + ", part3=" + part3 + ", part4=" + part4 + "]";
    }

}

以上时Builder设计模式的实现

其优点是：建造者独立，易扩展，便于控制细节风险

缺点：如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大

 工厂方法模式（FactoryMethod）

Factory Method模式主要用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型，紧耦合关系会导致软件的脆弱。这样我们需要定义一个用于创建对象的接口，让子类决定实例化

哪一个类。Factory Method使得一个类的实例化延迟到子类

下面是java代码实现：

 UML:

代码;

public interface Car {
          void run();
}
public class BaoMa implements Car{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("宝马 running......");
    }

}
public class BenChi implements Car{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("奔驰 running......");
    }
    

}
public interface CarFactory {

     Car createCar();
}
public class BaoMaFactory implements CarFactory {

    @Override
    public Car createCar() {
        // TODO Auto-generated method stub
        return new BaoMa();
    }
    

}
public class BenChiFavtory implements CarFactory {

    @Override
    public Car createCar() {
        // TODO Auto-generated method stub
        return new BenChi();
    }

}
public class Client {
public static void main(String[] args) {
    //生成宝马
    Car c1=new BaoMaFactory().createCar();
    c1.run();
    
    //生成奔驰
    Car c2=new BenChiFavtory().createCar();
    c2.run();
    
}
}

输出结果：

宝马 running......
奔驰 running......

描述工厂方法：

一个抽象产品类，可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类只能创建一个具体产品类的实例。

原型模式（prototype）

使用原型实例指定创建对象的种类，然后通过拷贝这些原型来创建新的对象。因为通过new产生一个对象需要非常繁琐的数据准备或访问全限，则可以使用原型模式。就是克隆技术，以某个对象为原型，复制出新的对象，新的对象具有原型对象的特点。

下面是java代码实现：

  

public class Car  implements Cloneable{

    
    private String name;
    private int place;
    private Date outFactoryTime;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPlace() {
        return place;
    }

    public void setPlace(int place) {
        this.place = place;
    }

    public Date getOutFactoryTime() {
        return outFactoryTime;
    }

    public void setOutFactoryTime(Date outFactoryTime) {
        this.outFactoryTime = outFactoryTime;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object object=super.clone();//克隆对象
        
        Car car=(Car) object;
        car.outFactoryTime=(Date) this.outFactoryTime.clone();//克隆属性
        return  car;
    }

    public Car(String name, int place, Date outFactoryTime) {
        super();
        this.name = name;
        this.place = place;
        this.outFactoryTime = outFactoryTime;
    }


    @Override
    public String toString() {
        return "Car [name=" + name + ", place=" + place + ", outFactoryTime=" + outFactoryTime + "]";
    }
    
}
public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
      Date date=new Date();
      Car c1=new Car("宝马",180000,date); 
      System.out.println(c1);
      date.setTime(125218L);
      
      Car c2=(Car) c1.clone();
      c2.setName("奔驰");
      c2.setPlace(560000);
      System.out.println(c2);
      
      
}
}

优点很明显效率高，因为是直接克隆，避免了重新执行构造过程。

Prototype模式对于“如何创建易变类的实体对象”采用“原型克隆”的方法来做。

它使得我们可以非常灵活地动态创建“拥有某些稳定接口”的新对象——所需工作仅仅是注册一个新类的对象（即原型），然后在任何需要的地方不断地Clone。

 状态机试图

 

状态机视图：状态机对类的对象的可能生命历史建模。
状态机包含由迁移连接的状态，每个状态对对象生命期中的一段时间建模，该时间内对象满足一定的条件。当事件发生时，它可能导致迁移的激发，使对象改变至新状态。当迁移激发时，附属于迁移的动作可能被执行。状态机显示为状态图。 

 

活动试图

活动视图：活动视图是用于显示执行某个计算过程中的运算活动的状态机的一种变形。活动状态表现了一项活动：工作流的步骤或操作的执行。活动图描述了顺序和并发活动分组。活动视图表达为活动图。
动作的输入和输出参数可以显示成连接动作的流关系和对象流状态。

交互式图

交互式图：交互式图描述了实现系统行为角色之间的消息交换序列。交互式图用侧重点不同的两种图显示：顺序图和协作图。
顺序图：表示了随时间安排的一系列消息，可以表达场景—即一项事物的特定历史。顺序图的一个用途是显示用例的行为序列。当行为被实现时，每个顺序图中的消息同类的操作或状态机中迁移上的事件触发相一致。
协作图：协作对交互中存在意义的对象和链建模。协作图通过图形的集合排布显示交互中的角色。协作图的一个用途是表现操作的实现。

 

有什么不准确或者错误的地方，还望指出与谅解