java常见的设计模式

一.单例设计模式

1. 定义
   Singleton是一种创建型模式，指某个类使用了Singleton模式，则这个类被创建后，只能产生一个实例供外部访问，并且提供一个全局的访问点。单例设计模式指的就是无论程序如何运行，采用单例设计模式的类（Singleton）永远都只会有一个实例化对象产生。

2. 具体实现步骤
   具体实现步骤如下：
   1.在其内部产生该类的实例化对象，并将其封装成private static类型；
   2.将采用单例设计模式的类的构造方法私有化；
   3.定义一个静态方法返回该类的实例。

3. 代码示例：

class Singleton{
    // 1.在内部产生本类的实例化对象
    private static Singleton instance = new Singleton();        
    // 2.将构造方法封装为私有化
    private Singleton(){            
    }   
    // 3.通过静态方法返回instance对象
    public static Singleton getInstance(){      
        return instance;
    }   
    public void print(){
        System.out.println("hello world!");
    }
}

public class Singleton_Summary {
    public static void main(String[] args) {        
        // 声明三个对象
        Singleton st1 = null;
        Singleton st2 = null;
        Singleton st3 = null;       
        st1 = Singleton.getInstance();
        st2 = Singleton.getInstance();
        st3 = Singleton.getInstance();      
        st1.print();
        st2.print();
        st3.print();        
        System.out.println("st1==st2==st3: " + (st1 == st2));       
    }
}

单例模式的实现一：
恶汉式，线程安全，但效率比较低。
代码示例：

class SingletonTest01{
    private static final SingletonTest01 instance = new SingletonTest01();
    private SingletonTest01(){      
    }
    public static SingletonTest01 getInstance(){
        return instance;
    }
}

public class Singleton01_Ehan {
    public static void main(String[] args) {        
    }
}

单例模式的实现二：
饱汉式，非线程安全

class SingletonTest02{
    private static SingletonTest02 instance;
    private SingletonTest02(){      
    }
    public static SingletonTest02 getInstance(){
        if(instance == null){
            instance = new SingletonTest02();
        }
        return instance;
    }
}

public class Singleton02_Baohan {
    public static void main(String[] args) {        
    }
}

单例模式的实现三：
线程安全，但是效率非常低

class SingletonTest03{
    private static SingletonTest03 instance;
    private SingletonTest03(){

    }
    public static synchronized SingletonTest03 getInstance(){
        if(instance == null){
            instance = new SingletonTest03();
        }
        return instance;
    }
}

public class Singleton03_Thread_di {
    public static void main(String[] args) {

    }
}

单例模式的实现四：
线程安全，并且效率高

class SingletonTest04{
    private static SingletonTest04 instance;
    private SingletonTest04(){      
    }
    public static SingletonTest04 getInstance(){
        if(instance == null){
            synchronized (SingletonTest04.class) {
                if(instance == null){
                    instance = new SingletonTest04();
                }
            }
        }
        return instance;
    }
}

public class Singleton04_Thread_gao {
    public static void main(String[] args) {

    }
}

二.工厂设计模式

1. 定义
   主要用来实例化有共同接口的类，工厂模式可以动态决定应该实例化那一个类。具体做法即程序在接口和子类之间加入了一个过渡端，通过此过渡端可以动态取得实现了共同接口的子类实例化对象。
   工厂模式主要有以下几种形态：
   1）简单工厂（Simple Factory）；
   2）工厂方法（Factory Method）；
   3）抽象工厂（Abstract Factory）。

2. 代码示例

interface Animal{
    public void say();
}

class Cat implements Animal{    
    public void say() {
        System.out.println("我是cat，hello world！");
    }
}

class Dog implements Animal{    
    public void say() {
        System.out.println("我是dog，no bug!");
    }
}

class Factory{          // 定义工厂类
    public static Animal getInstance(String className){
        Animal a = null;        // 定义接口对象
        if("Cat".equals(className)){    // 判断是哪个子类的标记
            a = new Cat();      // 通过Cat类实例化接口
        }
        if("Dog".equals(className)){
            a = new Dog();      // 通过Dog类实例化接口
        }
        return a;
    }
}

public class FactoryDemo01 {
    public static void main(String[] args) {

        Animal a = null;
        a = Factory.getInstance("Cat");     // 通过工厂获取一个实例

        if(a != null){
            a.say();
        }
    }
}

三.代理设计模式

1. 定义
   指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。
   比如生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）。

2. 代码示例

interface Network{                      // 定义Network接口
    public void browse();               // 定义浏览的抽象方法
}

class Server implements Network{        // 真实上网操作
    public void browse() {
        System.out.println("上网浏览信息！");
    }
}

class Proxy implements Network{         // 代理上网
    private Network network;
    public Proxy(Network network){      // 设置代理的真实操作
        this.network = network;         // 设置代理的子类
    }
    public void check(){                // 身份验证操作
        System.out.println("检查用户是否合法！");
    }
    public void browse() {
        this.check();                   // 调用具体的代理业务操作
        this.network.browse();          // 调用真实的上网操作
    }
}

四.观察者设计模式

1. 定义
   观察者设计模式，比如：现在许多购房者都密切观察者房价的变化，当房价变化时，所有的购房者都能观察到，以上的购房者属于观察者，这就是观察者设计模式。
   java中可以借助Observable类和Observer接口轻松实现以上功能，当然此种模式并不仅仅局限于采用这两个类。

2. 代码示例

class House extends Observable{
    private float price;
    public House(float price){
        this.price = price;
    }
    public void setPrice(float price){
        this.setChanged();                  // 设置变化点
        this.notifyObservers(price);        // 通知所有观察者变化改变
        this.price = price;
    }
    public float getPrice(){
        return this.price;
    }
    public String toString(){
        return "房子的价格为：" + this.price;
    }
}

class HousePriceObserver implements Observer{
    private String name;
    public HousePriceObserver(String name){
        super();
        this.name = name;
    }
    // 只要改变了，Observable 对象就调用此方法；
    public void update(Observable o, Object arg) {  
        if(arg instanceof Float){
            System.out.println(this.name + "观察的价格更改为：" + ((Float) arg).floatValue());
        }
    }
}

public class ObserverDemo01 {
    public static void main(String[] args) {

        // 通过构造方法给房子价格赋值
        House house = new House(1000000);

        // 输出房子价格
        System.out.println("价格未修改时:\n" + house);

        // 实例化观察者
        HousePriceObserver hpo1 = new HousePriceObserver("瑞文");
        HousePriceObserver hpo2 = new HousePriceObserver("亚索");
        HousePriceObserver hpo3 = new HousePriceObserver("剑圣");

        // 给房子注册观察者
        house.addObserver(hpo1);
        house.addObserver(hpo2);
        house.addObserver(hpo3);

        // 修改房价，会触发update(Observable o, Object arg) 方法通知购房者新的房价信息；
        house.setPrice(2000000);    

        System.out.println("\n价格修改之后:" + "\n" + house);
    }
}

五.适配器设计模式

1. 定义
   如果一个类想要实现一个有很多抽象方法的接口，但是本身只需要实现接口中的部分方法就可以达成目的，因此，此时就需要一个中间过渡类。但此过渡类又不希望直接使用，因此将此过渡类定义为抽象类最为合适，再让以后的子类直接继承该抽象类便可以选择性覆盖所需要的方法，而此抽象类便是适配器类。

2. 代码示例

interface Window{
    public void open();         // 窗口打开
    public void close();        // 窗口关闭
    public void iconified();    // 窗口最小化
    public void deiconified();  // 窗口恢复
    public void activated();    // 窗口活动
}

/*
 * 定义抽象类实现接口，在此类中重写方法，但是所有方法体为空
 */
abstract class WindowAdapter implements Window{

    public void open() {            // 窗口打开     
    }

    public void close() {           // 窗口关闭     
    }

    public void iconified() {       // 窗口最小化        
    }

    public void deiconified() {     // 窗口恢复     
    }

    public void activated() {       
    }

}

/*
 * 子类继承WindowAdapter抽象类，选择性实现需要的方法
 */
class WindowImpl extends WindowAdapter{
    public void open(){
        System.out.println("窗口打开！");
    }
    public void close(){
        System.out.println("窗口关闭！");
    }
}

public class AdapterDemo01 {
    public static void main(String[] args) {

        Window win = new WindowImpl();

        win.open();
        win.close();
    }
}

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。

本文只是对于常见的五种设计模式进行简单的理解和实现，用简单的代码来体会设计模式的精髓。当然，具体业务具体分析，希望自己以后再接再厉，为自己的编程生涯铺好道路。