Java中常用的设计模式

本文简单介绍Java中常用的几种设计模式：单例模式，工厂模式，建造者模式，适配器模式，装饰模式，观察者模式。

1.单例模式：

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
（1）饿汉式：直接创建一个对象。

public class Singleton {
 	// 直接创建对象
 	public static Singleton instance = new Singleton();
 
 	// 私有化构造函数
  	private Singleton() {}

	// 返回对象实例
	public static Singleton getInstance() { 
		return instance;
	}
}

（2）懒汉式：先判断对象是否已经创建，若已经创建则不再创建对象，而是直接返回之前创建的对象；若没有创建对象，则创建一个对象并返回。

 class Singleton {
 	// 声明变量
    private static Singleton instance = null;
    // 私有构造函数
    private Singleton() {}
    // 提供对外方法
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
		}
        return instance;
    }
}

（3）线程安全版本（效率低）

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

（4）线程安全版本（效率高）

public class Singleton {
	// 声明变量
	private static volatile Singleton singleton = null;
	
	// 私有构造函数
	private Singleton() {}

	// 提供对外方法
	public static Singleton getInstance() {
	    if (singleton == null) {
	        synchronized (Singleton.class) {
	            if (singleton == null) {
	                singleton = new Singleton();
	             } 
	        }
		}
	    return singleton;
	}
}

2.工厂模式：

工厂方法模式分为四种:
a)普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。
b)多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能 正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。
c)静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。
d)抽象工厂模式，创建多个工厂 类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
（1）普通工厂模式：

 public interface Sender {
	public void Send();
}
	public class MailSender implements Sender {
 		@Override
 		public void Send() {
			System.out.println("this is mail sender!"); 
	}
}

public class SmsSender implements Sender {
	@Override
	 public void Send() {
	 	System.out.println("this is sms sender!");
	 } 
}
	 
public class SendFactory {
	public Sender produce(String type) {
	    if ("mail".equals(type)) {
	        return new MailSender();
	    } else if ("sms".equals(type)) {
	        return new SmsSender();
		} else {
			System.out.println("请输入正确的类型!"); 
			return null;
	  	} 
	} 
}

（2）多个工厂模式:该模式是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。

public class SendFactory {
 	public Sender produceMail() {
		return new MailSender();
  	}
  	public Sender produceSms() {
      return new SmsSender();
	}
}

public class FactoryTest {
	public static void main(String[] args) {
	    SendFactory factory = new SendFactory();
	    Sender sender = factory.produceMail();
		sender.send(); 
  	}
}

（3）静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

 public class SendFactory {
  	public static Sender produceMail() {
 		return new MailSender();
	}

	public static Sender produceSms(){
   		return new SmsSender();
	}
}

 public class FactoryTest {
 	public static void main(String[] args) {
   		Sender sender = SendFactory.produceMail(); 
  		sender.send();
	}
}

（4）抽象工厂方法模式，工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修 改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决?就用到抽象工厂模式，创建多个工厂 类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

public interface Provider {
 	public Sender produce();
}

public interface Sender {
 	public void send();
}

public class MailSender implements Sender {
	@Override
	public void send() {
	    System.out.println("this is mail sender!");
	}
}

public class SmsSender implements Sender {
	@Override
	 public void send() {
	 	System.out.println("this is sms sender!");
	 }
 }

public class SendSmsFactory implements Provider {
	 @Override
	 public Sender produce() {
	 	return new SmsSender();
 	} 
 }

public class SendMailFactory implements Provider {
 	 @Override
	 public Sender produce() {
	 	return new MailSender();
 	} 
}


public class Test {
	public static void main(String[] args) {
	    Provider provider = new SendMailFactory();
	    Sender sender = provider.produce();
	    sender.send();
	} 
}
   

3.建造者模式：

工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象， 所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的 Test 结合起来得到的。

public class Builder {
 	private List<Sender> list = new ArrayList<Sender>();
 	public void produceMailSender(int count) {
	     for (int i = 0; i < count; i++) {
	         list.add(new MailSender());
	     }
	}
	public void produceSmsSender(int count) {
	    for (int i = 0; i < count; i++) {
	        list.add(new SmsSender());
	    }
	} 

public class TestBuilder {
	 public static void main(String[] args) {  
		 	Builder builder = new Builder();
		  	builder.produceMailSender(10); 
	   }
}

4.适配器模式：

适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类:类的适配器模式、对象的适配器模式、接口的适配器模式。
（1）类的适配器

public class Source {
	 public void method1() {
	 	System.out.println("this is original method!"); 
	 }
}
 
public interface Targetable {
	 /* 与原类中的方法相同 */
	 public void method1();
	 
	/* 新类的方法 */
	public void method2();
}

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

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

（2）对象的适配器模式，基本思路和类的适配器模式相同，只是将 Adapter 类作修改，这次不继承 Source 类，而是持有 Source 类的实
例，以达到解决兼容性的问题。

 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();
    }
}

（3）接口的适配器模式，接口的适配器是这样的:有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个 问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。

interface Target {
    void fun1();
    void fun2();
    void fun3();
}

abstract class Source implements Target {
    @Override
    public void fun1() {
        System.out.println("Source fun1 method");
    }

    @Override
    public void fun2() {
        System.out.println("Source fun2 method");
    }

    @Override
    public void fun3() {
        System.out.println("Source fun3 method");
    }
}

class Test extends Source {
    @Override
    public void fun2() {
        System.out.println("重写我们需要的方法");
    }
}

5.装饰模式：

顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。

public interface Sourceable { 
	public void method();
}

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


public class Decorator implements Sourceable {
	private Sourceable source;
	public Decorator(Sourceable source) {
		super();
	    this.source = source;
	}
	@Override
	public void method() {
	    System.out.println("before decorator!");
	    source.method();
	    System.out.println("after decorator!");
	} 
}

public class DecoratorTest {
	public static void main(String[] args) {
	    Sourceable source = new Source();
	    Sourceable obj = new Decorator(source);
	    obj.method();
	}
}
 

6.观察者模式：

当一个对象变化时，其 它依赖该对象的对象都会收到通知，并且随着变化!对象之间是一种一对多的关系。

/**
 * 观察者模式
 */
 
interface Observer {
    void update();
}

class Observer1 implements Observer {
    @Override
    public void update() {
        System.out.println("Observer1 has received");
    }
}

class Observer2 implements Observer {
    @Override
    public void update() {
        System.out.println("Observer2 has received");
    }
}

interface Subject {
    /*增加观察者*/
    void add(Observer observer);

    /*删除观察者*/
    void del(Observer observer);

    /*通知所有的观察者*/
    void notifyObservers();

    /*自身的操作*/
    void operation();
}

abstract class AbstractSubject implements Subject {
    private List<Observer> list = new LinkedList<>();

    @Override
    public void add(Observer observer) {
        list.add(observer);
    }

    @Override
    public void del(Observer observer) {
        list.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : list) {
            observer.update();
        }
    }
}

class MySubject extends AbstractSubject {
    @Override
    public void operation() {
        System.out.println("update self!");
        notifyObservers();
    }
}