常用设计模式（面试）

Singleton（单例模式）

一句话总结：一个类在Java虚拟机中只有一个对象，并提供一个全局访问点。

生活中例子：太阳、月亮、国家主席等。

解决什么问题：对象的唯一性，性能浪费太多。

项目里面怎么用：数据库连接对象，属性配置文件的读取对象。

模式结构：分为饿汉式和懒汉式（如果考虑性能问题的话，就使用懒汉式，因为懒汉式是在方法里面进行初始化的），构造器私  有化，对外提供方法加同步关键字。

框架里面使用：Struts1的Action。

JDK里面使用：java.lang.Runtime#getRuntimejava.awt.Desktop#getDesktop。

饿汉式代码：

（所谓饿汉，即jvm一加载类就会创建实例，线程安全，JVM在加载这个类时就马上创建此唯一的单例实例）

public class HurgrySingleton {  
private static HurgrySingleton hurgry=new HurgrySingleton();  
private HurgrySingleton(){};  
     public static HurgrySingleton getSinletonHurgry(){  
         return hurgry;  
        }  
}  

懒汉式代码：

（所谓懒汉，即要使用此实例时才创建，由于使用了synchronize关键字，所以也是线程安全的）

public class LarzySingleton {  
   private static LarzySingleton larzy=null;  
   private LarzySingleton(){};  
   public static synchronized Larzy getSinletonLarzy(){  
        if(larzy==null){  
              larzy=new LarzySingleton();  
        }  
        return larzy;  
    }  
}  

 这里注意饿汉式和懒汉式的实现中，均要把构造方法声明为private，以防止其他地方调用构造方法，而且，getSinleton（）也要声明为static方法，以方便通过类来调用以获得实例

 双重检验实现单例模式：

（在懒汉模式中，每次调用getSinletonLazy时，不管实例是否存在，都要加锁，会导致多线程下效率低下，而我们只想在实例不存在是才加锁，实例存在时就不加锁，直接返回对象实例，那么双重校验锁则实现了这一功能）

public class Singleton {
 
    //采用volatile修饰
    private volatile static Singleton singleton;
 
    //构造方法私有化
    private Singleton(){}
 
    //双重校验锁
    public static Singleton getInstance(){
        //先判断对象是否已经实例过，没有实例化过才进入加锁代码
        if(singleton == null){
            //类对象加锁
            synchronized(Singleton.class){
                //再次判断
                if (singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

注意：singleton 采用 volatile 修饰是很有必要的，因为 singleton = new Singleton() 这句话可以分为三步：
     1. 为 singleton 分配内存空间；
     2. 初始化 singleton；
     3. 将 singleton 指向分配的内存空间。
     但是由于JVM具有指令重排的特性，执行顺序有可能变成 1-3-2。 指令重排在单线程下不会出现问题，但是在多线程下会导致一个线程获得一个未初始化的实例。例如：线程T1执行了1和3，此时T2调用 getInstance() 后发现 singleton 不为空，因此返回 singleton， 但是此时的 singleton 还没有被初始化。
     使用 volatile 会禁止JVM指令重排，从而保证在多线程下也能正常执行。

Factory（简单的工厂模式）

一句话总结：用一个方法来代替new关键字

生活中的例子：制衣厂、面包厂等生产厂。

解决什么问题：对象产生过多，或者经常有子类替换生成。

项目里面怎么用：对于经常生成的对象，或者父子类替换的对象。

模式结构：写一个对外声明的方法，方法里面使用new关键字代替。

框架里面使用：spring的核心就是工厂模式。

JDK里面使用：newInstance。

工厂模式代码：

public class UserFactory {  
     public static User createUser(int i){  
//如果输入的是1，就创建它的子类，否则就创建父类  
         if(i==1){  
             return new Alices();  
          }  
         return new User();  
     }  
}  

 

Proxy（代理模式）

一句话总结：为其他对象提供一个代理，以控制对当前对象的访问。

生活中的例子：房屋中介、婚姻介绍所。

解决什么问题：不能直接访问该对象，或者太大的资源耗费多。

项目里面怎么用：权限，或者大对象的访问权限。

模式结构：代理类和被代理类实现同一个接口，用户访问的时候先访问代理对象，然后让代理对象去访问被代理对象。

框架里面使用：Spring里面的AOP实现。

JDK里面使用：java.lang.reflect.Proxy。

 

代理模式代码：

创建一个接口：

public interface SellHouse {  
    void sell(double money);  
}  

 

创建一个被代理类：

        

public class Hoster implements SellHouse {  
        @Override  
        public void sell(double money) {  
            System.out.println("祝你居住愉快");  
        }  
    }  

 

创建一个代理类：

 

public class Medium implements SellHouse {  
    SellHouse hoster=new Hoster();  
    @Override  
    public void sell(double money) {  
        if(money>=1000){  
            hoster.sell(money);  
        }else{  
            System.out.println("你的价格太低了");  
        }  
    }  
}  

测试类：

 

public class Renter {  
    public static void main(String[] args) {  
        SellHouse renter=new Medium();  
        renter.sell(500);  
    }  
}  

 

 

Adapter（适配器模式）

一句话总结：将两个原来不兼容的类兼容起来一起工作。

生活中的例子：变压器、充电器

解决什么问题：已经存在的相同功能的代码，但是接口不兼容，不能直接调用。

项目里面怎么用：在使用旧的API的时候，没有源码，和新的不能兼容。

模式结构：分为类适配器和对象适配，一般常用的就是对象适配器，因为组合由于继承。

框架里面使用：单元测试里面的asserEquels。

JDK里面使用：java.util.Arrays#asListjava.io.InputStreamReader(InputStream) java.io.outputStreamWriter(OutputStream)。

 

 

Strategy（策略模式）

一句话总结：定义一系列算法并可以互相替换。

生活中的例子：图片的格式，压缩文件的格式。

解决什么问题：做一件事情有很多种方法。

项目里面怎么用：购物车里面的付款方式。

模式结构：声明一个顶级接口，定义一个策略方法，具体的实例都要实现这个接口。

框架里面使用：hibernate的主键生成策略。

JDK里面使用：java.util.Comparator#compare。

 

策略模式代码：

定义一个顶级接口：

public interface Person {  
    void repast();  
}  

具体的实例类1：

public class African implements Person {  
    @Override  
    public void repast() {  
        System.out.println("非洲人用手吃饭");  
    }  
}  

具体的实例类2：

public class America implements Person {  
    @Override  
    public void repast() {  
        System.out.println("美国人用刀叉吃饭");  
    }  
}  

具体的实例类3：

public class Chinese implements Person {  
    @Override  
    public void repast() {  
        System.out.println("中国人用筷子吃饭");  
    }  
}  

测试类：

public class Test {  
    public static void main(String[] args) {  
        Person chinese=new Chinese();  
        Person america=new America();  
        Person african=new African();  
        chinese.repast();  
        america.repast();  
        african.repast();  
    }  
}  

 

Template（模板模式）

一句话总结：父类定义流程，子类实现流程。

生活中的例子：iphone生产有多个国家，但流程只有一个。

解决什么问题：业务有多种，但都有规定的流程。

项目里面怎么用：一般基类的实现都是模板模式，BaseDAO，bBaseService。

模式结构：定义一个抽象父类定义流程，或者常用方法和常量，子类继承父类，实现具体的细节方法。

框架里面使用：hibernate里面的方言，是跨数据库的基础。

JDK里面使用：IO流里面的InputStream，Writer等。

 

模板模式代码：

//定义一个父类，定义流程

public abstract class IPhoneTemplate {  
    public void createIPhone(){  
        setupCpu();  
        setupAll();  
        check();  
        box();  
    }  
    protected abstract void box();  
    protected abstract boolean check();   
    protected abstract void setupAll();  
    protected abstract void setupCpu();   
}  

//子类实现父类的细节方法1

public class ChinaIPhone extends IPhoneTemplate {  
    @Override  
    protected void box() {  
        System.out.println("box()");  
    }  
    @Override  
    protected boolean check() {  
        System.out.println("check()");  
        return true;  
    }  
    @Override  
    protected void setupAll() {  
        System.out.println("setupAll()");  
    }  
    @Override  
    protected void setupCpu() {  
        System.out.println("setupCpu()");  
    }  
}  

//子类实现父类的细节方法2

public class AfricanIPhone extends IPhoneTemplate {  
    @Override  
    protected void box() {  
        System.out.println("box()");  
    }  
    @Override  
    protected boolean check() {  
        System.out.println("check()");  
        return true;  
    }  
    @Override  
    protected void setupAll() {  
        System.out.println("setupAll()");  
    }  
    @Override  
    protected void setupCpu() {  
        System.out.println("setupCpu()");  
    }  
}