RV2-Java：常用的设计模式

2.1 简介

  本文主要内容： 工厂模式、迭代器模式、适配器模式、装饰者模式、代理模式、责任链模式、观察者模式、单例模式。

2.2 软件设计的原则

1. 单一职责原则；
2. 里氏替换原则；
3. 依赖倒置原则；
4. 接口隔离原则；
5. 迪米特原则；
6. 开闭原则。

2.3 内容

2.3.1 工厂模式

1. 定义
  将A类对象的创建工作，完全交给B类来负责，而B类则称为工厂类，例如Mybatis的 SqlSessionFactory 与Spring的 BeanFactory 。

2. 代码例子：

public class Student {
	public Student(int i) {
	}
}
public class StudentFactory {
	public Student createStudent() {
		return new Student(10);
	}
}
public class Test {
	public static void main(String[] args) {
		Student student = new StudentFactory().createStudent();
		System.out.println(student);
	}
}

3. 优势
  1.代码解耦： 对象的创建与使用不再绑定在一起了，当我们要获取对象时，直接从工厂中拿；
  2.减少代码量： 对于一些繁琐的对象创建，我可以封装成为一个工厂。当需要创建对象时，就可以从工厂获取，减少了大部分的冗余代码。

对于设计模式的理解，还只是停留在皮毛之上，但应该明白的是，设计模式应该应对的是某些情况，而不是所有情况。

2.3.2 迭代器模式

1. 定义
  当自定义一个存储数据的容器时，应该给调用者提供一个遍历数据的工具，于是用户可以通过特定的接口，巡访容器中的每一个元素而不用了解底层的实现，最耳熟能详的例子便是集合的迭代器iterator。

2. 代码例子

//链表节点类
public class Node {
	private Object value;//值
	private Node next;//下一个节点
	public Object getValue() {
		return value;
	}
	public void setValue(Object value) {
		this.value = value;
	}
	public Node getNext() {
		return next;
	}
	public void setNext(Node next) {
		this.next = next;
	}
}

public class WoniuLinkedList implements Iterable<Object>{
	private Node head;//链表首元素
	private int size;//数据长度
	public Node getHead() {
		return head;
	}
	public void setHead(Node head) {
		this.head = head;
	}
	public void add(Object value) {
		Node node = new Node();
		node.setValue(value);
		Node current=head;
		if(current==null) {
			head=node;
		}else {
			while(true) {
				if(current.getNext()==null) {
					current.setNext(node);
					break;
				}else {
					current=current.getNext();
				}
			}
		}
		size++;
	}
	public Object get(int index) {
		return node(index)==null?null:node(index).getValue();
	}
	public Node node(int index) {
		Node current=head;
		for(int i=0;i<index;i++) {
			if(current==null) {
				return null;
			}
			current=current.getNext();
		}
		return current;
	}
	public int getSize() {
		return size;
	}
	public void setSize(int size) {
		this.size = size;
	}
    //返回一个迭代器
	@Override
	public Iterator<Object> iterator() {
		return new WoniuLinkedListIterator(this);
	}
	
}

//自定义迭代器
public class WoniuLinkedListIterator implements Iterator<Object>{
	private WoniuLinkedList list;
	public WoniuLinkedListIterator(WoniuLinkedList list) {
		this.list=list;
		current=list.getHead();
	}
	private Node current;
	@Override
	public boolean hasNext() {
		//判断下一个是否存在
		boolean b=current==null?false:true;
		return b;
	}
	@Override
	public Object next() {
		//返回当前这一个
		Node result=current;
		current=current.getNext();
		return result.getValue();
	}
}

2.3.3 适配器模式

1.定义
  百度百科显示，适配器模式指的是，将一个类的接口适配成为用户所期待的样子。

2. 代码例子

//主类
public class Master {
	public static void main(String[] args) {
		Cat cat = new Cat();
		Dog dog = new Dog();
		CatAdapter catAdapter = new CatAdapter();
		DogAdapter dogAdapter = new DogAdapter();
		ArrayList<Object> list = new ArrayList<Object>();
		list.add(cat);
		list.add(dog);
		ArrayList<Adapter> adapters = new ArrayList<Adapter>();
		adapters.add(catAdapter);
		adapters.add(dogAdapter);
		
		int index = (int) Math.floor(Math.random() * list.size());
		Object pet = list.get(index);
		for (Adapter adapter : adapters) {
			if(adapter.supports(pet)) {
				adapter.execute(pet);
				break;
			}
		}

	}
}

//适配器接口
public interface Adapter {
	//执行函数
	public void execute(Object pet);
	//是否支持函数
	public boolean supports(Object pet); 
}

//宠物猫
public class Cat {
	public void jump() {
		System.out.println("СèßäÌøµÃÕæ¸ß");
	}
}

//宠物猫适配器
public class CatAdapter implements Adapter{
	@Override
	public void execute(Object pet) {
		((Cat)pet).jump();
	}
	@Override
	public boolean supports(Object pet) {
		if(pet instanceof Cat) {
			return true;
		}
		return false;
	}
}

//宠物狗
public class Dog {
	public void run() {
		System.out.println("¹·×ÓÅܵÄÕ滶ʵ");
	}
}

//宠物狗适配器
public class DogAdapter implements Adapter{
	@Override
	public void execute(Object pet) {
		((Dog)pet).run();
	}
	@Override
	public boolean supports(Object pet) {
		if(pet instanceof Dog) {
			return true;
		}
		return false;
	}
}

正如菜鸟教程所言，过多地使用适配器，对于一个系统而言，无疑是一场灾难。

2.3.4 装饰器模式

1. 定义
  允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。最经典的例子便是，IO流中的字节流、字节缓冲流、对象流。

2. 代码