你都是会点啥技术（八）--- 设计模式

都是会点啥技术（八）— 设计模式

写在前面的话：大学学了一遍设计模式，阅读过《大话设计模式》，还是一直不能完全熟练掌握运用它，这次好好做个笔记，目的是把23中设计模式的设计理念搞懂！

不得不说人家总结的好，先记录这，等功力深了再自己总结（2019-7-29）
https://www.cnblogs.com/pony1223/p/7594803.html 六大设计原则

https://www.cnblogs.com/pony1223/p/7608955.html 23种设计模式

上面两遍博客对设计模式的思想和概念讲解的特别清晰，我这里主要是代码实现。

1.创建型

1.1单例设计模式

1.1.1饿汉式

/**
 * 
 * @description:饿汉式
 * @author: libl
 * @date: 2019年7月29日
 */
public class Singleton {
	// 直接创建对象
	public static Singleton instance = new Singleton();

	// 私有化构造函数
	private Singleton() {
	}

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

1.1.2懒汉式

package org.lbl.design;

/**
 * 
 * @description:懒汉式
 * @author: libl
 * @date: 2019年7月29日
 */
public class Singleton2 {
	// 声明变量
	public static Singleton2 instance = null;

	// 私有化构造函数
	private Singleton2() {
	}

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

1.2工厂设计模式

1.2.1工厂方法模式

public interface Sender {
	public void send();
}


public class MailSender implements Sender{

	@Override
	public void send() {
		System.out.println("mail sender");
	}

}

public class SmsSender implements Sender {

	@Override
	public void send() {
		System.out.println("sms sender");
	}

}

普通工厂模式：建立一个工厂类，对实现了同一接口的一些类进行实例的创建

/**
 * 
 * @description:普通工厂方法
 * @author: libl  
 * @date: 2019年7月29日
 */
public class SendFactory1 {
	public Sender produce(String type) {
		if ("mail".equals(type)) {
			return new MailSender();
		} else if ("sms".equals(type)) {
			return new SmsSender();
		}
		System.out.println("请输入正确的额类型!");
		return null;
	}
}

public class SendFactory1Test {
	public static void main(String[] args) {
		SendFactory1 factory = new SendFactory1();
		Sender produce = factory.produce("mail");
		produce.send();
	}
}

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

/**
 * 
 * @description:多工厂方法模式
 * @author: libl  
 * @date: 2019年7月29日
 */
public class SendFactory2 {
	public Sender produceMail() {
		return new MailSender();
	}
	public Sender produceSms() {
		return new SmsSender();
	}
	
}
public class SendFactory2Test {
	public static void main(String[] args) {
		SendFactory2 factory = new SendFactory2();
		Sender sender = factory.produceMail();
		sender.send();
	}
}

静态工厂方法模式：将上面的多个工厂方法模式里的方法置位静态得当，不需要创建实例，直接调用即可。

/**
 * 
 * @description:静态工厂方法模式
 * @author: libl  
 * @date: 2019年7月29日
 */
public class SendFactory3 {
	public static Sender produceMail() {
		return new MailSender();
	}
	public static Sender produceSms() {
		return new SmsSender();
	}
}


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

1.2.1抽象工厂模式

工厂方法模式的缺点就是：类的创建依赖工厂类，如果扩展程序，必须对工厂类进行修改，违背了闭包原则。解决方案就用到抽象工厂模式，创建多个工厂类，如果需要增加新功能，直接增加新的工厂类就可以了，而不需要修改之前的代码。

public interface Provider {
	public Sender produce();
}


public class SendMailFactory implements Provider{

	@Override
	public Sender produce() {
		return new MailSender();
	}

}

public class SendSmsFactory implements Provider{

	@Override
	public Sender produce() {
		return new SmsSender();
	}

}


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

1.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 BuliderTest {
	public static void main(String[] args) {
		Builder builder = new Builder();
		builder.produceMailSender(10);
	}
}

1.4适配器模式

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

1.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 targettable method");		
	}
	
}

/**
 * 
 * @description:类的适配器，会有兼容问题，类的方法和接口方法重名，用对象适配器模式解决重名问题。
 * @author: libl  
 * @date: 2019年7月31日
 */
public class AdapterTest {
	public static void main(String[] args) {
		Targetable target = new Adapter();
		target.method1();
		target.method2();
	}
}

1.4.2对象的适配器模式

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

public class Wrapper implements Targetable{

	private Source source;

	public Wrapper(Source source) {
		super();
		this.source = source;
	}

	@Override
	public void method1() {
		source.method1();
	}

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

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

1.4.2接口的适配器模式

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

1.4装饰模式

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

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

1.5策略模式

策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数。策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可。

public interface ICalculator {
	public int calculate(String exp);
}

public class AbstractCalculator {
	public int[] split(String exp,String opt) {
		String array[] = exp.split(opt);
		int arrayInt[] = new int[2];
		arrayInt[0] = Integer.parseInt(array[0]);
		arrayInt[1] = Integer.parseInt(array[1]);
		return arrayInt;
	}
}


public class Plus extends AbstractCalculator implements ICalculator {

	@Override
	public int calculate(String exp) {
		int arrayInt[] = split(exp,"\\+");
		return arrayInt[0] + arrayInt[1];
	}

}

public class StrategyTest {
	public static void main(String[] args) {
		String exp = "2+8";
		ICalculator cal = new Plus();
		int result = cal.calculate(exp);
		System.out.println(result);
	}
}

1.6观察者模式

观察者模式很好理解，类似于邮件订阅和RSS订阅，当我们浏览一些博客或wiki时，经常会看到RSS图标，意思是：当你订阅了该文章，如果后续有更新，会及时通知你。简单来说就一句话：当一个对象变化时，其他依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。

public interface Observer {
	public void update();
}

public class Observer1 implements Observer{

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

	
}


public class Observer2 implements Observer{

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


public interface Subject {
	/* 增加观察者 */
	public void add(Observer observer);
	/*删除观察者*/
	public void del(Observer observer);
	/*通知所有的观察者*/
	public void notifyObservers();
	/*自身的操作*/
	public void operation();
}

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> enumo = vector.elements();
		while(enumo.hasMoreElements()) {
			enumo.nextElement().update();
		}
	}

}

public class MySubject extends AbstractSubject{

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

}

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