设计者模式

常见的设计者模式：

1.单例模式

单例模式的作用：用于保证一个类有且仅有一个实例，用来解决一个全局使用的类频繁的创建和销毁，从而节约系统资源。

单例模式分为饿汉型与懒汉型

（1）饿汉型，无论如何都会创建一个实例

实现流程：私有化构造方法，实例化一个对象，定义一个静态方法返回该对象

public class GiantDragon {
 
    //私有化构造方法使得该类无法在外部通过new 进行实例化
    private GiantDragon(){
         
    }
 
    //准备一个类属性，指向一个实例化对象。 因为是类属性，所以只有一个
 
    private static GiantDragon instance = new GiantDragon();
     
    //public static 方法，返回该实例化对象
    public static GiantDragon getInstance(){
        return instance;
    }
     
}

public class TestGiantDragon {
 
    public static void main(String[] args) {
        //通过new实例化会报错
//      GiantDragon g = new GiantDragon();
         
        //只能通过getInstance得到对象
         
        GiantDragon g1 = GiantDragon.getInstance();
        GiantDragon g2 = GiantDragon.getInstance();
        GiantDragon g3 = GiantDragon.getInstance();
         
        //都是同一个对象
        System.out.println(g1==g2);
        System.out.println(g1==g3);
    }
}

（2）懒汉型，只有实例化对象的方法被调用时，才会实例化一个对象，有线程安全方面的考虑

实现流程：私有化构造方法，定义一个类属性，但暂时不指向一个对象，静态方法判断，当该变量为null时，实例化一个对象并指向该变量，方法返回该对象。

public class GiantDragon {
  
    //私有化构造方法使得该类无法在外部通过new 进行实例化
    private GiantDragon(){       
    }
  
    //准备一个类属性，用于指向一个实例化对象，但是暂时指向null
    private static GiantDragon instance;
      
    //public static 方法，返回实例对象
    public static GiantDragon getInstance(){
        //第一次访问的时候，发现instance没有指向任何对象，这时实例化一个对象
        if(null==instance){
            instance = new GiantDragon();
        }
        //返回 instance指向的对象
        return instance;
    }
      
}

2.工厂模式

实体类由工厂类来“生产”。

作用：用于创建复制对象，明确地计划不同条件下创建不同的实例。

优点：使代码结构清晰，能够更加有效的进行封装。对调用者屏蔽具体的产品实现。降低耦合度。

缺点：对于简单的对象，使用工厂模式会增加系统复杂程度。

实现流程：

定义产品类接口，定义业务方法，定义产品类实现该接口，并重写业务方法

//产品类接口
interface IProduct {  
    public void productMethod();  
}

//产品类实体
class Product implements IProduct {  
    public void productMethod() {  
        System.out.println("产品");  
    }  
}

定义工厂类接口，定义生产类的方法，定义工厂类实现该接口，并重写方法，返回一个产品类

//工厂类接口
interface IFactory {  
    public IProduct createProduct();  
}  

//工厂类实体
class Factory implements IFactory {  
    public IProduct createProduct() {  
        return new Product();  
    }  
}

使用时，先实例化一个工厂类，工厂类调用生产产品类的方法，生成一个产品类对象，利用该对象来调用产品类的业务方法

public class Client {  
    public static void main(String[] args) {  
        IFactory factory = new Factory();  //实例化一个工厂类
        IProduct prodect = factory.createProduct();  //利用工程厂类的生产方法实例化一个产品类
        prodect.productMethod();  //利用产品类调用业务方法
    }  
}

3.代理模式

用过设置一个代理类，来充当业务实体类的“替身”，控制对业务实体类的访问

作用：为其他对象提供一种代理来控制对某个对象的访问，在一些已有的方法在使用的时候需要对已有的方法进行拓展，可用此模式来完成。

优点：职责清晰，有更高的拓展性，更加的智能。

缺点：实现代理模式增加了工作量，且通过代理模式访问会使性能降低。

实现流程：

定义业务方法接口，业务类实现该接口并重写方法

//业务方法接口
public interface Sourceable {  
    public void method();  
}

//业务方法接口实现类
public class Source implements Sourceable {  

    @Override  
    public void method() {  
        System.out.println("the original method!");  
    }  
}

定义一个代理类，把业务类的对象定义为代理类的一个私有成员变量，在代理类构造方法中实例化一个业务类，同时代理类实现业务方法接口并重写方法，重写的方法中要用业务类去调用业务方法，也就是说，要调用业务方法，首先实例化一个代理类对象，该对象去调用重写后的业务方法

//代理类
public class Proxy implements Sourceable { //实现业务方法接口 

    private Source source;  //私有化成员变量，值为业务类
    public Proxy(){
        this.source = new Source();  //构造方法实例化一个业务类
    }

    @Override  
    public void method() {  //重写业务接口的方法
        if (source == null){
            source = new Source ();
        } 
        source.method();  //利用代理类的成员变量（业务类实例）调用业务方法
    }   
}

猜你喜欢