Java复习总结之设计模式及其实现

引言

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应。每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。

设计模式六大原则

1、开闭原则（Open Close Principle）
开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

2、里氏代换原则（Liskov Substitution Principle）

里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。
里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。
LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。
实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

3、依赖倒转原则（Dependence Inversion Principle）

这个是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。

5、迪米特法则（最少知道原则）（Demeter Principle）

为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）

原则是尽量使用合成/聚合的方式，而不是使用继承。

设计模式的分类

创建型模式：用于描述“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”。
结构型模式：用于描述如何将类或对象按某种布局组成更多的结构。
行为型模式：用于描述类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，以及怎样分配职责。

常用的设计模式及其实现

单例模式

public class SingletonTest {
	private static Student instance = null;

	private static synchronized void syncInit() {
		if (instance == null) {
			instance = new Student();
			System.out.println("初始化成功");
		}
	}

	public static Student getInstance() {
		if (instance == null) {
			syncInit();
		}
		return instance;
	}

	public static void main(String[] args) {
		Student s1 =getInstance();
		System.out.println(s1);
		s1.setUserName("流星");
		System.out.println(s1);
		Student s2 =getInstance();
		System.out.println(s2);
		s2.setUserName("云影");
		System.out.println(s2);
	}
}
class Student {

	private String userName;

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

//    @Override
//    public String toString() {
//        return "SingletonTest{" +
//                "userName='" + userName + '\'' +
//                '}';
//    }
}

优点：

• 某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。
• 省去了new操作符，降低了系统内存的使用频率，减轻GC压力。
• 使用单例模式，保证核心服务器独立控制整个流程，避免出现一个军队多个司令员同时指挥的局面。

缺点：

• 没有抽象层，不能扩展
• 职责过重，违背了单一性原则

工厂模式

public interface Sender {
	void Send();
}

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

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

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

适用范围：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。
优点：客户端不需要创建对象，明确了各个类的职责
缺点：该工厂类负责创建所有实例，如果有新的类加入，需要不断的修改工厂类，不利于后期的维护
【注】工厂模式又分为普通工厂、抽象工厂和静态工厂，我们常用的是静态工厂，因为不需要创建工厂实例。

适配器模式

类的适配器模式

public class AdapterTest {

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

public class Adapter extends Source implements Targetable {

	@Override
	public void method2() {
		System.out.println("this is the targetable method!");
	}
}

public interface Targetable {
	/**
	 * 与原类中的方法相同
	 */
	void method1();
	/**
	 * 新类的方法
	 */
	void method2();
}

public class Source {

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

对象的适配器模式

public class AdapterTest {

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

public class Source {

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

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 interface Targetable {
	/**
	 * 与原类中的方法相同
	 */
	void method1();
	/**
	 * 新类的方法
	 */
	void method2();
}

接口的适配器模式

public interface Sourceable {
	
	public void method1();
	public void method2();
}

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

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

public class WrapperTest {
 
	public static void main(String[] args) {
		Sourceable source1 = new SourceSub1();
		Sourceable source2 = new SourceSub2();
		
		source1.method1();
		source1.method2();
		source2.method1();
		source2.method2();
	}
}

适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。

应用场景及实现方式：
类的适配器模式：将一个类转换成满足一个新接口的类

• 创建一个新类，继承原有的类，实现新的接口

对象的适配器模式：将一个对象转换成满足一个新接口的对象

• 创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法

接口的适配器模式：不希望实现一个接口中所有的方法

• 创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类

代理模式

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(){
		super();
		this.source = new Source();
	}
	@Override
	public void method() {
		before();
		source.method();
		atfer();
	}
	private void atfer() {
		System.out.println("after proxy!");
	}
	private void before() {
		System.out.println("before proxy!");
	}
}

public class ProxyTest {
 
	public static void main(String[] args) {
		Sourceable source = new Proxy();
		source.method();
	}
}

代理（Proxy）模式：为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访问该对象，从而限制、增强或修改该对象的一些特性。

应用场景：
如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：

• 修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。
• 就是采用一个代理类调用原有的方法，且对产生的结果进行控制。

使用代理模式，可以将功能划分的更加清晰，有助于后期维护！

观察者模式

public class ObserverTest {

	public static void main(String[] args) {
		Subject sub = new MySubject();
		sub.add(new Observer1());
		sub.add(new Observer2());
		sub.operation();
	}
}

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

public abstract class AbstractSubject implements Subject {

	private Vector<Observer> vector = new Vector<Observer>();
	@Override
	public void add(Observer observer) {
		vector.add(observer);
	}

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

	/**
	 * 通过枚举集合通知所有观察者
	 */
	@Override
	public void notifyObservers() {
		Enumeration<Observer> enums = vector.elements();
		while(enums.hasMoreElements()){
			enums.nextElement().update();
		}
	}
}

public interface Subject {

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

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

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

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

public interface Observer {
	void update();
}

public class Observer1 implements Observer {

	@Override
	public void update() {
		System.out.println("observer1 has received!");
	}
}

public class Observer2 implements Observer {

	@Override
	public void update() {
		System.out.println("observer2 has received!");
	}
}

类说明：

• MySubject类就是我们的主对象，Observer1和Observer2是依赖于MySubject的对象。当MySubject变化时，Observer1和Observer2必然变化。
• AbstractSubject类中定义着需要监控的对象列表，可以对其进行修改：增加或删除被监控对象，且当MySubject变化时，负责通知在列表内存在的对象

观察者（Observer）模式：多个对象间存在一对多关系，当一个对象发生改变时，会把这种改变通知给其他多个对象，从而影响其他对象的行为。

附：参考资料

Java中常用的设计模式