java设计模式记录

///创建型模式/

1.抽象工厂模式：

对工厂类抽象一个接口出来，分别对每一个需要工厂类实例化的实现类进行实例化。

2.单例模式：

public class Singleton {    
 /* 私有构造方法，防止被实例化 */  
 private Singleton() {  
 } 
   /* 此处使用一个内部类来维护单例 */  
   private static class SingletonFactory {  
       private static Singleton instance = new Singleton();  
   }  
 
   /* 获取实例 */  
   public static Singleton getInstance() {  
       return SingletonFactory.instance;  
   }
   
   //本类的其他实现功能的方法
   
}

3.建造者模式

建造者模式是对抽象工厂模式的延伸，用于创建大量对象出来。

 public void produceMailSender(int count){  
       for(int i=0; i<count; i++){  
           list.add(new MailSender());  
       }  
   } 

这个抽象工厂接收创建实例个数的参数，进行大量的实例创建。

4.原型模式

实现原型模式，首先要得实现原型空接口（Cloneable），覆写clone()方法。基本上可以分为浅克隆和深克隆。

将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的
public class Prototype implements Cloneable {  
 
    public Object clone() throws CloneNotSupportedException {  
        Prototype proto = (Prototype) super.clone();  //调用native的clone（）实现浅克隆就可以了
        return proto;  
    }  
}  

将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。

public class Prototype implements Cloneable, Serializable {  
 
    private static final long serialVersionUID = 1L;  
    private String string;  
  
    private SerializableObject obj;  
  
    /* 浅复制 */  
    public Object clone() throws CloneNotSupportedException {  
        Prototype proto = (Prototype) super.clone();  
        return proto;  
    }  
  
    /* 深复制 */  
    public Object deepClone() throws IOException, ClassNotFoundException {  
  
        /* 写入当前对象的二进制流 */  
        ByteArrayOutputStream bos = new ByteArrayOutputStream();  
        ObjectOutputStream oos = new ObjectOutputStream(bos);  
        oos.writeObject(this);  
  
        /* 读出二进制流产生的新对象 */  
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());  
        ObjectInputStream ois = new ObjectInputStream(bis);  
        return ois.readObject();  
    }  
}

将当前需要克隆的对象序列化，再读出来返回回去。

//结构型模式

5.适配器模式

a.类的适配器模式：c类继承a类实现b类，这时候c类同时有了a和b类的所有方法。

A类

public class Source {  
 
    public void method1() {  
        System.out.println("this is original method!");  
    }  
}

B类接口：

public interface Targetable {  
    /* 新类的方法 */  
    public void method2();  
}  

C类：

public class Adapter extends Source implements Targetable {  
 
    @Override  
    public void method2() {  
        System.out.println("this is the targetable method!");  
    }  
} 

b.接口级别的适配器，c类实现b类，再用一个方法接收a类实例，把a类实例的方法暴露出来。

public class Wrapper implements Targetable {  
 
    private Source source;  
      
    public Wrapper(Source source){  
        super();  
        this.source = source;  
    }  
    @Override  
    public void method2() {  
        System.out.println("this is the targetable method!");  
    }  
  
    @Override  
    public void method1() {  
        source.method1();  
    }  
}   

测试：

public class AdapterTest {  
 
    public static void main(String[] args) {  
        Source source = new Source();  
        Targetable target = new Wrapper(source);  
        target.method1();  
        target.method2();  
    }  
}

c：接口的适配器

有接口a和接口b，一个抽象类d实现接口a的方法（空方法），然后用不同的类继承抽象类，重写抽象类中需要的方法。

抽象类d，实现空方法

public abstract class Wrapper2 implements Sourceable{  
    
    public void method1(){}  
    public void method2(){}  
}

public class SourceSub1 extends Wrapper2 {  
    public void method1(){  
        System.out.println("the sourceable interface's first Sub1!");  
    }  
}

public class SourceSub2 extends Wrapper2 {  
    public void method2(){  
        System.out.println("the sourceable interface's second Sub2!");  
    }  
}