Java设计模式总结篇：七大原则以及23种设计模式简单介绍

最新推荐文章于 2024-06-05 16:10:48 发布

码农_小庄

最新推荐文章于 2024-06-05 16:10:48 发布

阅读量3.1k

点赞数 32

分类专栏：笔记文章标签： java 设计模式

本文链接：https://blog.csdn.net/weixin_44715643/article/details/120146342

版权

笔记专栏收录该内容

1 篇文章 0 订阅

订阅专栏

java设计模式

一、前言
二、七大原则
三、23种设计模式

一、前言

Java设计模式在平时的开发中起到了至关重要的作用。设计模式的主要目的是：
1、降低耦合度，使得类的修改不至于“牵一发而动全身”。
2、提高可扩展性，新增功能对原有的代码没什么影响
3、提高可复用性，降低过多的使用类时，导致类爆炸的情况
4、提高灵活性，代码能够通过接口灵活调用
5、提高可维护性，修改的地方越少

二、七大原则

1、单一原则：一个类只负责一个职责
2、开闭原则：对修改关闭，对扩展开放
3、里氏替换原则：不要破坏继承关系
4、接口隔离原则：暴露最小接口，避免接口过于臃肿
5、依赖倒置原则：面向抽象编程
6、迪米特法则：尽量不跟陌生人讲话
7、合成复用原则：多使用组合、聚合、少用继承

1、单一原则

一个方法一个类只负责一个职责，各个职责的程序改动，不影响其它程序，实现 高内聚，低耦合

优点：降低耦合，提高可维护性，对一个类进行单独处理并且不影响其他类

2、开闭原则

对修改关闭，对扩展开放，核心是：抽象化，多态使用
优点：提高可扩展性，提高可维护性，提高可复用性

3、里氏替换原则

所有使用父类的地方，必须能够透明的使用子类对象

例如：父类Animal;子类Dog继承父类Animal，子类Cat继承父类Animal。

Animal animal=new Dog();
//同样可以透明的使用
Animal animal=new Cat();

当子类重写父类的方法时，则不适合使用里氏替换原则。

4、接口隔离原则

每一个接口承担独立的角色，只干自己该干的事情。
只暴露最小接口，实现类不需要用到实现的方法不要放在接口。

5、依赖倒置原则

指的是面向抽象编程，对抽象类或接口进行依赖，比较灵活。
比如：有抽象类Animal，子类Dog继承父类Animal，子类Cat继承父类Animal。在依赖的时候用抽象类，在使用的时候指定子类

//抽象类和子类
abstract class  Animal{
	abstract void hello();
}
class Dog extends Animal{
	@Override
	void hello() {
		System.out.println("hello ,I am dog");
	}
}
class Cat extends Animal{
	@Override
	void hello() {
		System.out.println("hello ,I am cat");	
	}
}	

//依赖到抽象类
class Client{
Animal a;
	public Client(Animal a){
		this.a=a;
	}
	public void hello(){
		a.hello();
	}
}
//测试类进行使用
public class Test {

    public static void main(String args[]) {
   //在使用到Animal的使用，需要定义它的子类
   	Client c=new Client(new Dog());
    c.hello();//打印指定的方法
    }
}

6、迪米特法则

尽量不要跟陌生人说话。
不是陌生人的情况：

当前对象本身（this)
方法参数
对象的成员对象
对象所创建的对象

目的：降低耦合，高内聚

7、合成复用原则

尽量使用组合、聚合的方式，少使用继承。
原因：继承会导致耦合度变高。
聚合方式的使用案例：

class A{}	
class Test{
A a;
	public void useA(A a){
		this.a=a;
	}
}

组合方式的使用案例：

class A{}	
class Test{
	A a=new A();
}

组合和聚合的区别 ：组合方式在使用Test对象的时候会立即开辟A对象的空间，而聚合的方式是在使用到A对象的时候才会开辟A对象的空间。

三、23种设计模式

23种设计模式
创建型模式：主要关注点是“怎样创建对象”

1、单例模式(Singleton)

特点：当需求是一个类只需要一个实例
单例模式有：1、饿汉模式；2、懒汉模式；3、双重检查模式；4、枚举模式

饿汉模式（推荐使用）

特点： 当类加载时创建好对象，并且在外部不能通过new创建该对象，只能调用这个类的的方法进行调用。线程安全，在实际开发中用的最多
案例：
方式一

/**
 * 饿汉方式一
 * @Author:小庄
 */
public class Singleton {
    //private不允许外部调用new创建对象
    private Singleton(){}
    //使用静态关键字”static“保证只有一次
    private static Singleton instance=new Singleton();
    //外部可直接通过类进行调用静态方法
    public static Singleton getInstance(){
        return instance;
    }
}
/**
 * 饿汉方式二
 * @Author:小庄
 */
class Singleton2 {
    private static Singleton2 instance;
    private Singleton2(){
        instance=new Singleton2();
    }
/**
 * 饿汉方式二
 * @Author:小庄
 */
class Singleton2 {
    private static Singleton2 instance;
    static {
        instance=new Singleton2();
    }
    private Singleton2(){}
    //外部可直接通过类进行调用静态方法
    public static Singleton2 getInstance(){
        return instance;
    }
}

懒汉模式（不推荐使用）

特点： 等需要该类的时候再加载，会考虑线程安全问题
1、不安全的懒汉模式

/**
 * 线程不安全的懒汉模式
 * @Author:小庄
 */
class Singleton{
    private static Singleton instance;
    private Singleton(){}
    public static Singleton getInstance(){
    	instance=new Singleton();
        return instance;
    }
}
class Singleton2{
    private static Singleton2 instance;
    private Singleton2(){}
    public static  Singleton2 getInstance(){
    	if(instance==null){
	    	synchronized(Singleton2.class){
	    		instance=new Singleton2();
	    	}	
    	}
        return instance;
    }
}

以上代码线程不安全的原因：当几个线程同时访问的时候，就有可能创建多个对象实例。

2、线程安全的懒汉模式

/**
 * 线程安全的懒汉模式
 * @Author:小庄
 */
class Singleton{
    private static Singleton instance;
    private Singleton(){}
    public static synchronized Singleton getInstance(){
    	if(instance==null){
    		instance=new Singleton();
    	}
        return instance;
    }
}

以上代码缺点：当getInstance()方法里面的逻辑代码很复杂时，所有的代码都被加锁，会大大的消耗性能

双重检查懒汉模式（线程安全）

/**
 * 线程安全的懒汉模式
 * @Author:小庄
 */
class Singleton{
    private static Singleton instance;
    private Singleton(){}
    public static  Singleton getInstance(){
    	if(instance==null){
    		//进行加锁
    		synchronized(Singleton.class){
    		//再进行一次判断类是否为空
				if(instance==null){
					instance=new Singleton();
				}
			}
    	}
        return instance;
    }
}

静态内部类实现单例

/**
 *内部类实现单例
 * @Author:小庄
 */
class Singleton{
    //设置为private
    private Singleton(){}
    //内部类的特性，外部类不能直接访问
    private static class GetSingleton{
       private static final Singleton instance=new Singleton();
    }
    public Singleton getInstance(){
        return GetSingleton.instance;
    }
}

运用枚举实现单例(推荐使用)

enum Singleton2{
    ONE,TWO,THREE;//一个属性代表一个实例，这里有三个实例
}

小结

推荐使用饿汉模式和枚举模式实现单例的原因是线程安全，而且简单明了
不推荐使用懒汉模式的原因是：1、部分的懒汉模式不安全；2、过于繁琐；3、有可能会对性能造成额外消耗

2、工厂模式(Factoy)

特点：对类的创建用一个工厂类进行管理。

工厂模式分为：简单工厂，工厂方法和抽象工厂，这节内容主要讲简单工厂和工厂方法。

简单工厂

由一个工厂对象决定创建出哪一种产品类的实例
代替构造函数创建对象，方法名比构造函数清晰。
简单工厂的类图：

简单工厂
具体代码实现：

public class SimpleFactory{
	public createProduct(int i){
		switch (i){
            case 0: new Product1();break;
            case 1: new Product2();break;
            case 2: new Product3();break;
            default: System.out.println("没有该产品");
        }
	}
	//具体的使用者
	public static void main(String[] args){
		SimpleFactory factory=new SimpleFactory();
		//通过工厂进行创建类
		factory.createProduct(1);
	}
}
class Product1{}
class Product2{}
class Product3{}

工厂方法

工厂方法

//抽象类
abstract class FactoryMethod {
		//生产方法
		public abstract void production(String productName);
}
class Product1 extends FactoryMethod {
	//实现抽象方法
	@Override
	public void production(String productName) {
		System.out.println("Product1生产了"+productName+"产品");
		
	}
}
class Product2 extends FactoryMethod {
	//实现抽象方法
	@Override
	public void production(String productName) {
		System.out.println("Product2生产了"+productName+"产品");
		
	}
}
//使用者
public class Client{
	public static void main(String[] args) {
		FactoryMethod factory=new Product1();
		factory.production("x");
	}
}

3、抽象工厂模式(AbstractFactory)

创建一组有关联的对象实例

角色：

AbstractProduct (抽象产品)
AbstractFactory (抽象工厂)
Client (委托者)

抽象工厂
具体实现如下，为了保证代码的阅读，这里不对类的具体操作进行展开

//定义抽象工厂类
abstract class AbstractFactory {
	//定义抽象方法，返回值是抽象产品类对象
	abstract AbstractClass1 createClass1();
	abstract AbstractClass2 createClass2();
	abstract AbstractClass3 createClass3();
}
//把抽象产品类全部定义完
abstract class AbstractClass1 {}
abstract class AbstractClass2 {}
abstract class AbstractClass3 {}
//定义具体产品类，分别继承对应的抽象产品类
class Class1 extends AbstractClass1{}
class Class2 extends AbstractClass2{}
class Class3 extends AbstractClass3{}
//定义具体工厂类，实现抽象方法，具体工厂类1
class Factory1 extends AbstractFactory{
	@Override
	AbstractClass1 createClass1() {
		// TODO Auto-generated method stub
		return new Class1();
	}
	@Override
	AbstractClass2 createClass2() {
		// TODO Auto-generated method stub
		return new Class2();
	}
	@Override
	AbstractClass3 createClass3() {
		// TODO Auto-generated method stub
		return new Class3();
	}
}
//具体工厂类2
class Factory2 extends AbstractFactory{
	@Override
	AbstractClass1 createClass1() {
		// TODO Auto-generated method stub
		return new Class1();
	}
	@Override
	AbstractClass2 createClass2() {
		// TODO Auto-generated method stub
		return new Class2();
	}
	@Override
	AbstractClass3 createClass3() {
		// TODO Auto-generated method stub
		return new Class3();
	}
}

分析

从上面代码中，我们可以发现，抽象工厂处理的是产品一族，它们和工厂方法的区别在于：工厂方法有利于处理一个产品的部件扩展维度，而抽象工厂有利于扩展产品一族维度。

4、原型模式(Prototype)

特点：必须实现Cloneable接口，并且重写clone方法，否则会报错
应用场景：一个对象属性特别多，同时指定很麻烦，实际工作中用的很少

角色：

Prototype(原型)
ConcretePrototype(具体原型)
Client(使用者)

浅克隆

//原型接口继承Cloneable接口，或者抽象类实现Cloneable接口
interface Prototype extends Cloneable{
}
//具体原型类实现原型接口，重写方法
public class ConcretePrototype implements Prototype {
    @Override
    protected Object clone() throws CloneNotSupportedException {
       //通过克隆自身对象
        ConcretePrototype p=(ConcretePrototype)this.clone();
        //返回克隆后的值
        return p;
    }
}

通过clone实现深拷贝

//原型接口继承Cloneable接口，或者抽象类实现Cloneable接口
interface Prototype extends Cloneable{
}
//具体原型类实现原型接口，重写方法
public class ConcretePrototype implements Prototype {
    //假设有一个对象属性，需要克隆这个对象属性
    public Book book;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        //对基本属性进行克隆
        Object deep=null;
        deep=super.clone();
        //对引用类型的数据进行单独处理
        ConcretePrototype c=(ConcretePrototype )deep;
        c.book= (Book)book.clone();
        //返回克隆后的值
        return deep;
    }
}

缺点：繁琐
通过序列化实现深拷贝

public class Book implements Serializable{
  
    //浅克隆，使用默认的clone方法
    public Object deepClone() {

        ByteArrayInputStream bis=null;
        ByteArrayOutputStream bos=null;
        ObjectOutputStream oos=null;
        ObjectInputStream ois=null;
        try{
            bos=new ByteArrayOutputStream();
            oos=new ObjectOutputStream(bos);
            oos.writeObject(this);
            //反序列化
            bis=new ByteArrayInputStream(bos.toByteArray());
            ois=new ObjectInputStream(bis);
             Book book=(Book)ois.readObject();
            return book;
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }finally {
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

5、建造者模式（Builder）

特点：处理复杂对象的创建，在使用时只需要用想要的属性时，不需要设置所有参数；这个建造者模式和模板方法特别像

角色：

Builder(建造者)
ConcreteBuilder(具体建造者)
Director(监工)
Client(使用者)

//建造者接口或抽象类
interface Builder {
	//具体步骤
	Builder creteBuilder();
	Builder creteBuilder2();
	Builder creteBuilder3();
}
//具体建造类
class ConcreteBuilder implements Builder{
	//实现具体步骤，返回值为当前对象，便于链式编程
	@Override
	public Builder creteBuilder() {
		System.out.println("建造第一层");
		return this;
	}
	@Override
	public Builder creteBuilder2() {
		System.out.println("建造第二层");
		return this;
	}
	@Override
	public Builder creteBuilder3() {
		System.out.println("建造第三层");
		return this;
	}
}
//监工
class Director {
	//将抽象类（接口）聚合，然后对抽象方法进行调用，会指向子类实现的方法
	Builder builder;
	public Director(Builder builder) {
		this.builder=builder;
	}
	public void toBuilder() {
		builder.creteBuilder().creteBuilder2().creteBuilder3();
	}
}
//使用者
public class Client {
	public static void main(String[] args) {
		//通过监工直接建造
		Director d=new Director(new ConcreteBuilder());
		d.toBuilder();
	}
}

比较常用的使用方式

//模拟建造者模式的具体使用
public class Person {
	//这里定义了很多的属性，但是有时候只需要部分的属性
	int id;
	String name;
	int age;
	double weight;
	int score;
	//将构造函数设置为私有属性，不让外部进行访问
	private Person() {}
	//定义内部类，通过内部类对类的成员变量进行操作，可以叫它为静态工厂
	public static class PersonBuilder{
		Person p=new Person();
		//每次方法返回值不为void,而是直接返回当前的对象，有利于链式方程
		public PersonBuilder basicInfo(int id,String name,int age) {
			p.id=id;
			p.name=name;
			p.age=age;
			return this;
		}
		public PersonBuilder weight(double weight) {
			p.weight=weight;
			return this;
		}
		public PersonBuilder score(int score) {
			p.score=score;
			return this;
		}
		//通过下面方法返回外部类对象
		public Person build() {return p;}
	}
	//打印
	public static void main(String[] args) {
		//采用链式编程，直观
		Person p=new Person.PersonBuilder().basicInfo(1, "张三", 18).weight(65.0).build();
	}
}

6、适配器模式(Adapte)

使不兼容的接口相融

角色：

Target(对象)
Adaptee(被适配)
Adapter(适配)

1、类适配器模式

//目标接口
interface Target {
	public int open110V();
}
//被适配类
class ClassAdaptee{
	public int open220V(){
		return 200;
	}
}
//适配类
public class ClassAdapte extends ClassAdapteeimplements Target{
	@Override
	public int open110V() {
		int voltage=open220V();
		return voltage/2;
	}
}

2、对象适配器

对象适配器
和类适配器的区别，适配器和被适配者之间没有继承关系，通过聚合实现（合成复用）

//目标类，可以用抽象类代替
abstract Target {
	public abstract int open110V();
}
//被适配类
class ClassAdaptee{
	public int open220V(){
		return 200;
	}
}
//适配类
public class ClassAdapte extends Target{
	public ClassAdaptee adaptee;
	public ClassAdapte(ClassAdaptee e){
		this.adaptee=e;
	}
	@Override
	public int open110V() {
		int voltage=e.open220V();
		return voltage/2;
	}
}

7、桥连模式(Bridge)了解

特点：
双维度扩展
分离抽象和具体
用聚合的方式连接抽象和具体

类图
在这里插入图片描述

abstract class AbstractBridge {
	//聚合实现者
	Implementor imt;
}
//具体桥连者
class ConcreteBride extends AbstractBridge{
	//把实现者作为参数
	public ConcreteBride(Implementor imt) {
		this.imt=imt;
	}
}
//抽象化实现者
interface Implementor {
}
//具体实现者
public class ConcreteImplementor implements Implementor{
}

8、装饰者模式(Decorator)

特点：对类进行扩展时不修改原有的代码，为类添加新的功能，防止类继承带来的爆炸性增长

类图：
装饰者模式

案例应用：
装饰者模式

//定义Drink抽象类，并设定好抽象方法
 abstract class Drink {
	private String des;//描述
	private float price=0.0f;//价格
	public String getDes() {
		return des+"价格："+price;
	}
	public void setDes(String des) {
		this.des = des;
	}
	public float getPrice() {
		return price;
	}
	public void setPrice(float price) {
		this.price = price;
	}
	//计算费用的抽象方法
	protected abstract float cost();
}

//Coffee类继承Drink抽象类，因为Coffee只是一种饮料
abstract class Coffee extends Drink{
}
//定义具体咖啡，并设置好属性
class Cafe_Latte extends Coffee{

	public Cafe_Latte() {
		super.setDes("拿铁咖啡");
		super.setPrice(18.80f);
	}
	@Override
	protected float cost() {
		//获取价格
		return super.getPrice();
	}
}
//咖啡的具体实现类
class Instant_Coffee extends Coffee{
	
	public Instant_Coffee(int shuliang) {
		super.setDes("速溶咖啡");
		super.setPrice(14.00f);
	}
	@Override
	protected float cost() {
		return super.getPrice();
	}
}
class Cafe_Latte extends Coffee{

	public Cafe_Latte() {
		super.setDes("拿铁咖啡");
		super.setPrice(18.80f);
	}
	@Override
	protected float cost() {
		return super.getPrice();
	}
}
//通过继承Drink方便进行装饰类
 class DeCorator extends Drink{
	private Drink drink;
	private String des;//描述
	private float price=0.0f;//价格
	private int shuliang=1;//数量
	public DeCorator(Drink drink) {
		this.drink=drink;
	}
	public DeCorator(Drink drink,int shuliang) {
		this.drink=drink;
		this.shuliang=shuliang;
	}
	public String getDes() {
		return drink.getDes()+" "+" 加入"+shuliang+"份"+des+" "+des+"单价："+price;
	}
	public void setDes(String des) {
		this.des = des;
	}
	public float getPrice() {
		return price;
	}
	public void setPrice(float price) {
		this.price = price;
	}
	protected float cost() {
		float material_price=this.price*this.shuliang;
		return material_price+drink.cost();
	}
}
//装饰者的具体实现类
class Milk extends DeCorator{
	public Milk(Drink drink) {
		super(drink);
		super.setDes("牛奶");
		super.setPrice(2f);
	}
	public Milk(Drink drink, int shuliang) {
		super(drink, shuliang);
		super.setDes("牛奶");
		super.setPrice(2f);
	}
}
//装饰者的具体实现类
class Sugar extends DeCorator{
	public Sugar(Drink drink) {
		super(drink);
		super.setDes("糖");
		super.setPrice(1f);
	}
	public Sugar(Drink drink, int shuliang) {
		super(drink, shuliang);
		super.setDes("糖");
		super.setPrice(1f);
	}
}
//使用者测试类
public class Client {
	public static void main(String[] args) {
		Drink order=new Cafe_Latte();
		System.out.println("费用："+order.cost());
		System.out.println(order.getDes());
		order=new Milk(order);
		System.out.println("加入一份牛奶的费用："+order.cost());
		System.out.println(order.getDes());
	}
}

9、享元模式(Flyweight）

特点：共享数据,重复利用对象

应用场景：数据库连接池

类图：
享元模式
角色：

抽象化享元对象
享元对象
享元池

下面是图书馆案例，图书馆作为享元池，书架作为抽象化享元对象，书籍作为享元对象。

来看类图
享元模式

//抽象化享元对象
abstract class Book {
	HashMap<String,Boolean> start=new HashMap<>();
	abstract void borrow(Lender lender);
	abstract void setBookStart(String bookName,boolean bookStart);
	abstract boolean getBookStart(String bookName);
}
//具体享元对象
class MixBook extends Book{
	private String bookName="";//书名
	private boolean bookStart;
	public MixBook(String bookName) {
		this.bookName=bookName;
	}
	@Override
	public void borrow(Lender lender) {
		System.out.println(lender.getName()+"向图书馆借出一本"+bookName);
	}
	public String getBookName() {
		return bookName;
	}
	public void setBookName(String bookName) {
		this.bookName = bookName;
	}
	public boolean getBookStart(String bookName) {
		if(start.get(bookName)) return true;
		else return false;
	}
	public void setBookStart(String bookName,boolean bookStart) {
		start.put(bookName, bookStart);
	}
}
//外部状态
class Lender {
	private String name;
	public Lender(String name) {
		this.name = name;
		
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
}
import java.util.HashMap;
//享元池
class Library {
	//设置图书馆为单例，只能生成一个实例对象
	private static Library library=new Library();
	//防止外部通过new生成实例
	private Library(){};
	//书架
	HashMap<String,Book> pool=new HashMap<>();
	
	public static Library getInstance() {
		return library;
	}
	public Book toBorrow(String bookName,Lender lender) {
		Book book=null;
		if(pool.isEmpty()) {
			System.out.println("图书馆目前没有书，请添加书籍");
		}
		else if(!pool.containsKey(bookName)) {
			//如果没有，提示图书馆没有这本书，请联系图书管理员
			System.out.println("图书馆没有"+bookName+"，请联系图书管理员");
			
		}else {
			book=pool.get(bookName);
			if(!book.getBookStart(bookName)){
				System.out.println("你好"+lender.getName()+":"+bookName+"已经被借走了");
				book=null;
			}
			else {
				book.start.put(bookName, false);
				book.borrow(lender);
			}
		}
		return book;
	}
	public void shelveBook(String bookName,Book book) {
		book.setBookStart(bookName,true);
		pool.put(bookName, book);
	}
	public int poolSize() {
		return pool.size();
	}
}
//使用享元池
public class Student {
	public static void main(String[] args) {
		//通过单例模式进行创建图书馆享元池
		Library library=Library.getInstance();
		library.shelveBook("《Java编程思想》", new MixBook("《Java编程思想》"));
		library.shelveBook("《Mysql必会知识》", new MixBook("《Mysql必会知识》"));
		//设置借阅人
		Lender lender=new Lender("小庄");
		Book book1=library.toBorrow("《Java编程思想》",lender);
		Book book2=library.toBorrow("《Java编程思想》",lender);
		Book book3=library.toBorrow("《Mysql必会知识》",lender);
		//查看享元池借出的书籍
		System.out.println("图书馆借出书籍共："+library.poolSize()+"个");
	}
}

10、代理模式(Proxy)

作用：在程序运行期间，在不修改源代码的情况下对方法进行功能增强

优势：减少重复代码，提高开发效率，并且便于维护

底层实现：在运行期间，通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。

代理模式分为：静态代理，动态代理
本篇内容的动态代理只对jdk代理和cglib代理介绍

静态代理

静态代理
角色：

代理类
被代理类
抽象化被代理类
使用者

//抽象化被代理类
interface IBoard {
	void draw();
}
//具体被代理类
class Board implements IBoard{
	@Override
	public void draw() {
		System.out.println("被代理类画画操作执行");
	}
}
//静态代理类
class StaticProxy implements IBoard{
	//聚合抽象化被代理类
	private IBoard board;
	public StaticProxy(IBoard board) {
		this.board=board;
	}
	//通过代理类执行被代理类的方法
	@Override
	public void draw() {
		System.out.println("代理类执行自己操作");
		System.out.print("============");
		board.draw();//调用被代理类执行的方法
		System.out.print("============");
		System.out.println("代理类执行结束");
	}
}
//使用者
public class Client {
	public static void main(String[] args) {
		//通过静态代理类进行调用被代理类的方法
		new StaticProxy(new Board()).draw();
	}
}

动态代理模式之JDK代理

jdk代理主要通过反射的方式进行代理，JDK代理本身就继承了Proxy类，由于Java不支持多继承，所以不支持对类的代理，只支持对接口的代理。
具体案例如下：

//接口1
interface IBoard {
	void draw();
}
//接口2
interface IComputer {
	void open();
	void complete();
}
//接口1的实现类
class Board implements IBoard{
	@Override
	public void draw() {
		System.out.println("被代理类画画操作执行");
	}
}
//接口2的实现类
class Computer implements IComputer{
	@Override
	public void open() {
		System.out.println("电脑正在启动....");	
	}
	@Override
	public void complete() {
		System.out.println("电脑启动完成");
	}
}
//代理类
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

class JDKProxy {
	//设置被代理对象
	private Object target;
	//通过构造函数设置被代理对象
	public JDKProxy(Object target) {
	 this.target=target;
	}
	//被代理对象生成
	public Object getProxyInstance() {
		//返回一个JDK代理类对象
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),new InvocationHandler() {

			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				System.out.println("=================");
				System.out.println("代理开始");
				Object object=method.invoke(target, args);
				System.out.println("被代理的方法名："+method.getName());
				if("open"==method.getName()) {
					Method complete=target.getClass().getMethod("complete");
					if(null!=complete){
						System.out.println("complete方法被代理对象自动调用");
						Thread.sleep(1000);
						complete.invoke(target, args);
					}
				}
				System.out.println("代理结束");
				System.out.println("=================");
				System.out.println();
				return object;
			}
		});
	}
}
//使用者
public class Client {
	public static void main(String[] args) {
		//代理画板对象
		JDKProxy board=new JDKProxy(new Board());
		IBoard iBoard=(IBoard)board.getProxyInstance();
		//调用画板的draw()方法
		iBoard.draw();
		//代理电脑对象
		JDKProxy computer=new JDKProxy(new Computer());
		IComputer iComputer=(IComputer) computer.getProxyInstance();
		//这里只调用了open()方法，但是complete会被代理对象自动调用
		iComputer.open();
	}
}

动态代理之cglib代理

Cgilb代理
我们知道，使用Jdk代理的不足之处是不能对类进行代理，而Cglib代理刚好解决了这个问题。
Cglib可以对无接口的类进行代理，需要实现MethodInterceptor接口

具体案例：

//没有实现接口的类1
class Board{
	public void draw() {
		System.out.println("被代理类画画操作执行");
	}
}
//没有实现接口的类2
class Computer{
	public void open() {
		System.out.println("电脑正在启动....");
	}
	public void complete() {
		System.out.println("电脑启动完成");	
	}
}
//Cglib代理
import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
//实现MethodInterceptor接口，重写intercept方法（实现代理功能）
class CglibProxy implements MethodInterceptor{
	//设置被代理类
	public Object target;
	//通过构造函数进行设置
	public CglibProxy(Object target) {
		this.target=target;
	}
	/**
	*实现代理的关键:
	*1.创建工具类Enhancer
	*2.设置它的父类，会在虚拟机生成一个父类
	*3.设置回调函数
	*4.创建子类对象，作为代理对象
	*/
	public Object getProxyInstance() {
		//创建工具类
		Enhancer e=new Enhancer();
		//设置父类
		e.setSuperclass(target.getClass());
		//设置回调函数
		e.setCallback(this);
		//创建子类对象，作为代理对象
		return e.create();
	}
	@Override
	public Object intercept(Object arg0, Method method, Object[] args, MethodProxy arg3) throws Throwable {
		System.out.println("===============");
		//代理模式底层使用反射
		System.out.println("Cglib代理模式开始");
		//invoke激活，和jdk代理功能类似
		Object object=method.invoke(target, args);
		System.out.println("被代理的方法名："+method.getName());
		//在代理类实现自己的功能
		if("open"==method.getName()) {
			Method complete=target.getClass().getMethod("complete");
			if(null!=complete){
				System.out.println("complete方法被代理对象自动调用");
				Thread.sleep(1000);
				complete.invoke(target, args);
			}
		}
		System.out.println("代理结束");
		System.out.println("=================");
		System.out.println();
		return object;
	}
}

另一种方式：不需要类去实现MethodInterceptor接口，是在回调函数的实现这个接口

//没有实现接口的类1
class Board{
	public void draw() {
		System.out.println("被代理类画画操作执行");
	}
}
//没有实现接口的类2
class Computer{
	public void open() {
		System.out.println("电脑正在启动....");
	}
	public void complete() {
		System.out.println("电脑启动完成");	
	}
}
//Cglib代理
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
//实现MethodInterceptor接口，重写intercept方法（实现代理功能）
class CglibProxy2{
	//设置被代理类
	public Object target;
	//通过构造函数进行设置
	public CglibProxy2(Object target) {
		this.target=target;
	}
	/**
	*实现代理的关键:
	*1.创建工具类Enhancer
	*2.设置它的父类，会在虚拟机生成一个父类
	*3.设置回调函数
	*4.创建子类对象，作为代理对象
	*/
	public Object getProxyInstance() {
		//创建工具类
		Enhancer e=new Enhancer();
		//设置父类
		e.setSuperclass(target.getClass());
		//设置回调函数
		e.setCallback(new MethodInterceptor() {

			@Override
			public Object intercept(Object arg0, Method method, Object[] args, MethodProxy proxy) throws Throwable {
				System.out.println("===============");
				//代理模式底层使用反射
				System.out.println("Cglib代理模式开始");
				//invoke激活，和jdk代理功能类似
				Object object=method.invoke(target, args);
				System.out.println("被代理的方法名："+method.getName());
				//在代理类实现自己的功能
				if("open"==method.getName()) {
					Method complete=target.getClass().getMethod("complete");
					if(null!=complete){
						System.out.println("complete方法被代理对象自动调用");
						Thread.sleep(1000);
						complete.invoke(target, args);
					}
				}
				System.out.println("代理结束");
				System.out.println("=================");
				System.out.println();
				return object;
			}
		});
		//创建子类对象，作为代理对象
		return e.create();
	}
}

11、组合模式(Composite)

一般适用于树状结构的场景，比如文件结构，比如层级结构
组合模式

实现代码如下：

//结点
abstract class Node {
	public abstract void printNode();
}
//导入相关的包
import java.util.ArrayList;
import java.util.List;
//根结点/子结点
class BranchNode extends Node{
	//给结点起个名字
	String nodeName;
	//将它以下结点进行收集
	public List<Node> nodes=new ArrayList<>();
	public BranchNode(String nodeName) {
		this.nodeName=nodeName;
	}
	public void addNode(Node node) {
		nodes.add(node);
	}
	//打印结点
	@Override
	public void printNode() {
		System.out.println(nodeName);
	}
}
//叶子结点
class LeafNode extends Node{
	//给结点起个名字
	String nodeName;
	public LeafNode(String nodeName) {
		this.nodeName=nodeName;
	}
	//打印叶子结点信息
	@Override
	public void printNode() {
		System.out.println(nodeName);
	}
}
//使用者
public class Client {
	public static void main(String[] args) {
		BranchNode root=new BranchNode("根结点");
		BranchNode node1=new BranchNode("结点1");
		Node c1=new LeafNode("叶子结点1");
		Node c2=new LeafNode("叶子结点2");
		//添加结点
		root.addNode(node1);
		//添加叶子结点
		node1.addNode(c1);
		node1.addNode(c2);
		//使用递归遍历	
		tree(root,0);
	}
	public static void tree(Node node,int depth) {
		for(int i=0;i<depth;i++) {
			System.out.print("--");
		}
		node.printNode();
		//判断是否是根结点
		if(node instanceof BranchNode) {
			//递归遍历结点
			for(Node n:((BranchNode) node).nodes){
				tree(n,depth+1);
			}
		}
	}
}

生活中用到组合模式的例子：学校，学院(系)和专业
组合模式的应用

//结点
abstract class Composite {
	private String des;
	private String name;
	public Composite(String name,String des) {
		this.name=name;
		this.des=des;
	}
	protected void add(Composite composite) {
	}
	protected void remove(Composite composite) {}
	protected abstract void print();
	public String getDes() {
		return des;
	}
	public void setDes(String des) {
		this.des = des;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}
//学院（系）
import java.util.HashSet;

class College extends Composite{
	HashSet<Major> majors=new HashSet<>();
	public College(String name,String des) {
		super(name,des);
	}
	@Override
	protected void add(Composite composite) {
		majors.add((Major)composite);
	}
	@Override
	protected void remove(Composite composite) {
		majors.remove((Major)composite);
	}
	@Override
	public String getName() {
		return super.getName();
	}
	@Override
	public String getDes() {
		return super.getDes();
	}
	@Override
	protected void print() {
		System.out.println("学院："+getName());
		System.out.println();
		for(Major major:majors) {
		System.out.println("专业："+major.getName()+"\t专业详情:"+major.getDes());
		}
		System.out.println("=====================");
	}
}
//导入相关包

import java.util.Set;
//学校
class University extends Composite{
	//学校由多个学院(系)组成
	Set<College> colleges=new HashSet<>();
	
	public University(String name,String des) {
		super(name,des);
	}
	@Override
	protected void add(Composite composite) {
		colleges.add((College)composite);
	}
	@Override
	protected void remove(Composite composite) {
		colleges.remove((College)composite);
	}
	@Override
	public String getName() {
		return super.getName();
	}
	@Override
	public String getDes() {
		return super.getDes();
	}
	@Override
	protected void print() {
		System.out.println("========"+getName()+"========");
		System.out.println("简介："+getDes());
		System.out.println();
		for(College college:colleges) {
		System.out.println("学院："+college.getName()+"\t学院详情："+college.getDes());
		}
		System.out.println("=====================");
	}
}
//专业，对于叶子结点
public class Major extends Composite{
	public Major(String name,String des) {
		super(name,des);
	}
	@Override
	protected void print() {
		System.out.println(super.getName()+super.getDes());
	}
}
//使用者
public class Client {
public static void main(String[] args) {
	University university=new University("清华大学", "中国顶尖学府");
	College c=new College("计算机学院","培养软件+硬件高级人才");
	university.add(c);
	university.add(new College("金融学院", "培养金融行业高级人才"));
	university.print();
	c.add(new Major("计算机科学与技术","老牌的计算机专业"));
	c.print();
	}
}

12、外观模式(Facade)

外观模式又称为门面模式，通常和责任链模式结合使用
使用场景：解决多个类之间的复杂关系，只需要通过一个类就可以直接和其他类进行交互，具体使用：中间件

通过案例进行讲解：
外观模式

//经纪人，门面
class Agent {
	private static Agent agent=new Agent();
	//通过单例模式获取类对象
	protected Star star=Star.getInstance();;
	protected Fans fans=Fans.getInstance();
	protected Company company=Company.getInstance();
	private Agent() {}
	//见面机会方法
	protected void meeting() {
		System.out.println("粉丝"+fans.getName()+"与"+star.getName()+"获得一次见面机会");
	}
	//签约方法
	protected void contract() {
		System.out.println("明星"+star.getName()+"与"+company.getName()+"进行了签约");
	}
	public static Agent getInstance() {
		return agent;
	}
}
//明星类
class Star {
	private static Star star=new Star();
	protected volatile String name="";
	private Star() {}
	public String getName() {
		return name;
	}
	public synchronized void setName(String name) {
		this.name = name;
	}
	protected static Star getInstance() {
		return star;
	}
}
//粉丝
class Fans {
	private static Fans fans=new Fans();
	private volatile String name="";
	private Fans() {}
	public String getName() {
		return name;
	}

	public synchronized void setName(String name) {
		this.name = name;
	}
	public static Fans getInstance() {
		return fans;
	}
}
//签约公司
class Company {
	private volatile String  name="";
	private static Company company=new Company();
	private Company() {}
	public String getName() {
		return name;
	}
	public synchronized void setName(String name) {
		this.name = name;
	}
	public static Company getInstance() {
		return  company;
	}
}
//用户测试
public class Client {
	public static void main(String[] args) {
		//直接跟经纪人打交道
		Agent agent=Agent.getInstance();
		agent.company.setName("公司x");
		agent.fans.setName("张三");
		agent.star.setName("吴签");
		agent.meeting();
		agent.contract();
		System.out.println("============");
		agent.fans.setName("李四");
		agent.meeting();
		agent.contract();
	}
}

我们可以看到，经纪人就是一个门面，其他人都是通过经纪人来处理事情。粉丝想要见明星，首先要通过经纪人。再由经纪人和明星打交道。

13、状态模式(State)

如果一个类有很多个复杂状态的时候，可以把状态抽象出来，具体状态实现这个抽象类,

角色：

State(状态)
ConcreteState(具体状态)
Context(状况)

//设置抽象化状态类
abstract class State {
	public abstract void simle();
	public abstract void cry();
}
//开心状态
class HappyState extends State{
	@Override
	public void simle() {
		System.out.println("开心的笑");
	}
	@Override
	public void cry() {
		System.out.println("开心的哭了");
	}
}
//不开心状态
class SadState extends State{
	@Override
	public void simle() {
		System.out.println("沮丧的笑着");
	}
	@Override
	public void cry() {
		System.out.println("笑哭了");
	}
}
//状况
public class Context{
	//聚合状态
	private State state;
	//设置状态
	public Context(State state) {
		this.state=state;
	}
	//根据状态判断
	public void simle() {
		state.simle();
	}
	//根据状态判断
	public void cry() {
		state.cry();
	}
}

我们不难发现，抽象类的状态（抽象方法）是固定的，具体是怎样的状态，由子类实现。如果抽象类的状态(抽象方法)变化的很频繁，会对所有子类产生影响，那么就不建议使用这个模式

14、责任链模式(Responsibility)

是一种链式的结构的模式，通常使用在审批流，过滤器

责任链模式

//设置责任链的抽象类（接口）
abstract class Approve {
	private Approve approve;
	//设置下一个审批人
	public void setApprove(Approve approve) {
		this.approve=approve;
	}
	//审批人的具体审批内容
	public abstract void toApprove();
	public abstract void chain(Approve approve);
}
//责任链的内容
//审批人1
class Approve1 extends Approve{
	//写入审批人的审批内容
	@Override
	public void toApprove() {
		System.out.println("我是审批人1，我审批完之后交给审批人2");
		//设置它的下一个审批人
		chain(new Approve2());
	}
	//设置它的下一个审批人
	@Override
	public void chain(Approve approve) {
		approve.toApprove();
	}
}
class Approve2 extends Approve {
	@Override
	public void toApprove() {
		System.out.println("我是审批人2，我审批完之后交给审批人3");
		chain(new Approve3());
	}
	@Override
	public void chain(Approve approve) {
		approve.toApprove();
	}
}
class Approve3 extends Approve {
	@Override
	public void toApprove() {
		System.out.println("我是审批人3，审批完成");
		
	}
	@Override
	public void chain(Approve approve) {
		approve.toApprove();
	}
}
//请求访问责任链
public class Request {
	public static void main(String[] args) {
		Approve approve=new Approve1();
		approve.toApprove();
	}
}

换一种思路，我们把每一个子类存到容器中，然后对容器进行遍历，然后执行方法，也类似这种链式的执行流程。
我们来通过代码来看看

abstract class Approve {
	//审批人的具体审批内容
	public abstract void toApprove();
}
//审批人1
class Approve1 extends Approve{
	//写入审批人的审批内容
	@Override
	public void toApprove() {
		System.out.println("我是审批人1，我审批完之后交给审批人2");
	}
}
//审批人2
class Approve2 extends Approve {
	@Override
	public void toApprove() {
		System.out.println("我是审批人2，我审批完之后交给审批人3");
	}
}
//审批人3
class Approve3 extends Approve {
	@Override
	public void toApprove() {
		System.out.println("我是审批人3，审批完成");
	}
}
//导入集合
import java.util.ArrayList;
//责任链管理类
class ApproveChain {
	//聚合了内容
	ArrayList<Approve> approves=new ArrayList<>();
	public ApproveChain addChain(Approve approve) {
		approves.add(approve);
		return this;
	}
	//通过调用这个方法，遍历容器中的类执行方法
	public void chain() {
		for(Approve a:approves) {
			a.toApprove();
		}
	}
}
//请求着使用
public class Request {
	public static void main(String[] args) {
		//定义责任链管理类
		ApproveChain ac=new ApproveChain();
		//需要设置它的下一个
		ac.addChain(new Approve1()).addChain(new Approve2()).addChain(new Approve3());
		ac.chain();
	}
}

上面代码很类似享元模式吧，哈哈。

15、迭代器模式(Iterator)

角色：

Iterator(迭代器)
ConcreteIterator(具体的迭代器)
Aggregate(集合)
CocreteAggreagete(具体集合)

类图：
迭代器模式
Iterator(迭代器)

public interface Iterator_ {
	boolean hashNext();
	Object next();
}

ConcreteIterator(具体的迭代器)

public class ArrayListIterator implements Iterator_{
	//单例模式创建类
	private static ArrayListAggregate alat=new ArrayListAggregate();
	@Override
	public boolean hashNext() {
		if(alat.currentIndex>=alat.size()) return true;
		return false;
	}
	@Override
	public Object next() {
		Object o=alat.list.get(alat.currentIndex);
		alat.currentIndex++;
		return o;
	}
}

Aggregate(集合接口)

public interface Aggregate {
	public abstract Iterator_ iterator();
}

CocreteAggreagete(具体集合)

import java.util.ArrayList;

public class ArrayListAggregate implements Aggregate{
	ArrayList<Object> list=new ArrayList<>();
	int index=0;
	int currentIndex=0;
	@Override
	public Iterator_ iterator() {
		// TODO Auto-generated method stub
		return new ArrayListIterator();
	}
	public int size() {
		
		return index;
	}
	public void add(Object o) {
		list.add(o);
		index++;
	}
}

16、观察者模式(Observer)重要

我们开发中，使用到观察者模式很多，这个知识点要重点把握

通知对象状态改变，允许一个对象向所有侦听对象广播自己的消息或事件

角色：

Source：事件源对象
Observer：观察者
Event：事件

观察者

//事件，可定义为抽象化类（接口）
class Event {
	String loc;
	public Event(String loc) {
		this.loc=loc;
	}
}
//抽象化观察者
abstract class Observer {
	public abstract void actionEvent(Event event);
}
//具体观察者1
class Observer1 extends Observer{
	@Override
	public void actionEvent(Event event) {
		//打印
		System.out.println(event.loc);
		System.out.println("观察者1做出了行为");
		//执行相关的方法
	}
}
//具体观察者2
class Observer2 extends Observer{
	@Override
	public void actionEvent(Event event) {
		System.out.println("============");
		System.out.println("观察者2做出了行为");
		//执行相关的操作
	}
}

import java.util.ArrayList;
import java.util.List;
//由事件源发出事件，观察者进行处理事件
public class Source {
	private List<Observer> observers=new ArrayList<>();
	{	
		//注册观察者
		observers.add(new Observer1());
		observers.add(new Observer2());
	}
	//执行这个方法会触发所有观察者
	public void wakeUp() {
		for(Observer o:observers) {
			o.actionEvent(new Event("bed"));
		}
	}
}
//测试
class Test {
	public static void main(String[] args) {
		new Source().wakeUp();
	}
}

17、策略模式(Strategy)

策略模式
角色：

抽象化策略
具体策略
聚合策略类
使用者

封装的是不同的执行方式，比如对排序选择不同的排序算法（策略）
代码如下

//抽象化策略类（接口）
interface Sorter{
	public abstract void sort(Comparable[] data);
}
//具体策略，这里采用选择排序算法
class SelectSorter implements Sorter{
	@Override
	public void sort(Comparable[] data) {
		for(int i=0;i<data.length-1;i++) {
			int min=i;
			for(int j=i+1;j<data.length;j++) {
				if(data[min].compareTo(data[j])>0) {
					min=j;
				}
			}
			swap(data,i,min);
		}
	}
	public void swap(Comparable[] data,int i,int min) {
		Comparable temp=data[i];
		data[i]=data[min];
		data[min]=temp;
	}
}
//具体策略类，这里采用冒泡排序
class BubbleSorter implements Sorter{
	@Override
	public void sort(Comparable[] data) {
		//进行排序
		for(int i=1;i<data.length;i++) {
			for(int j=0;j<data.length-i;j++) {
				if(data[j].compareTo(data[j+1])>0) {
					Comparable temp=data[j+1];
					data[j+1]=data[j];
					data[j]=temp;
				}
			}
		}
	}
}
//聚合策略类,可以选择不同的策略
class SortAndPrint{
	Comparable[] data;
	Sorter sorter;
	public SortAndPrint(Comparable[] data,Sorter sorter) {
		this.data=data;
		this.sorter=sorter;
	}
	public void sort() {
		System.out.println("====排序前====");
		print();
		sorter.sort(data);
		System.out.println();
		System.out.println("====排序后====");
		print();
	}
	public void print() {
		for(int i=0;i<data.length;i++) {
			System.out.print(data[i]+",");
		}
		System.out.println(" ");
	}
}
//测试
public class Client {

	public static void main(String[] args) {
		//定义一个需要排序的数据
		String[] data= {"Dumpty","Bowman","Carroll"};
		SortAndPrint sap=new SortAndPrint(data, new BubbleSorter());
		sap.sort();
	}
}

18、模板方法模式(Temlapte Method)

具体实现交给子类
角色：

AbstractClass
concreteClass

类图：
模板方法模式

具体使用：

public abstract class AbstractDisplay {
	//定义抽象方法，由子类去实现
	public abstract void open();
	public abstract void print();
	public abstract void close();
	//对这个方法设定为final类型。表示子类不能重写
	public final void display() {
		open();
		print();
		close();
	}
	//使用
	public static void main(String[] args){
		CharDisplay chars=new CharDisplay();
		chars.display();
	}
}
//子类继承
class CharDisplay extends AbstractDisplay{
	@Override
	public void open() {
		System.out.println("打开CharDisplay");	
	}
	@Override
	public void print() {
		System.out.println("在CharDisplay进行打印");
	}
	@Override
	public void close() {
		System.out.println("关闭CharDisplay");
	}
}
//子类继承
class StringDisplay extends AbstractDisplay{

	@Override
	public void open() {
		System.out.println("打开StringDisplay");	
	}

	@Override
	public void print() {
		System.out.println("在StringDisplay进行打印");
	}

	@Override
	public void close() {
		System.out.println("关闭StringDisplay");
	}
 	public void printLine() {
		System.out.println("StringDisplay自定义的方法");
	}
}

应用场景：

算法的整体步骤很固定，但其中个别部分易变，将易变部分交给子类实现。
多个子类存在公共行为，可以将其提取出并集中到一个公共父类以避免代码重复
需要控制子类的扩展时，模板方法只在特定点调用钩子函数操作，这样就只允许在这些点进行扩展。

19、中介者模式(Mediator)

中介这个角色在生活中的理解是：比如租房者找中介，再由中介跟相关的房东沟通，房东也是通过中介和租房者沟通。中介是中间的桥梁。
在中介者模式中的理解和生活中的理解基本一致

角色：

Mediator 抽象化中介者
ConcentrateMediator 具体中介者
College 抽象化同事类
ConcentrateCollege 具体同事类（租房者、房东）

中介者模式（小庄）

//抽象化中介者
pabstract class Mediator {
	//沟通的方法
	public abstract void constact(String msg,Colleague c);
}
//具体中介类
class ConcreteMediator extends Mediator{
	//聚合同事类
	private ConcreteColleague1 c1;
	private ConcreteColleague2 c2;
	//设置get和set方法
	public ConcreteColleague1 getC1() {
		return c1;
	}
	public void setC1(ConcreteColleague1 c1) {
		this.c1 = c1;
	}
	public ConcreteColleague2 getC2() {
		return c2;
	}
	public void setC2(ConcreteColleague2 c2) {
		this.c2 = c2;
	}
	//具体的沟通方法，核心
	@Override
	public void constact(String msg, Colleague c) {
		//判断是哪个同事，进行处理事件
		if(c==c1) {
			c2.getMessage(msg);
		}else {
			c1.getMessage(msg);
		}
	}
}
//同事类
abstract class Colleague {
	//给同事类命名
	protected String name;
	//设置中介
	protected Mediator mediator;
	public Colleague(String name,Mediator mediator) {
		this.name=name;
		this.mediator=mediator;
	}
	//沟通的方法
	public abstract void constact(String msg);
	//获取信息
	public abstract void getMessage(String msg);
}
//具体的同事类，这个类表示租房
class ConcreteColleague1 extends Colleague{
	
	//在构造函数让该类被创建的时候同时命名
	public ConcreteColleague1(String name,Mediator mediator) {
		super(name, mediator);
	}
	@Override
	public void constact(String msg) {
		mediator.constact(msg, this);
	}
	@Override
	public void getMessage(String msg) {
		System.out.println();
		System.out.println("租房者姓名："+name+"。收到的信息："+msg);
	}
}
//具体的同事类，这里表示房东
class ConcreteColleague2 extends Colleague{

	//在构造函数让该类被创建的时候同时命名
	public ConcreteColleague2(String name,Mediator mediator) {
		super(name,mediator);
	}
	@Override
	public void constact(String msg) {
		mediator.constact(msg, this);
	}
	@Override
	public void getMessage(String msg) {
		System.out.println("房东姓名："+name+"。收到的信息："+msg);
	}
}
//测试类
public class Client {
	public static void main(String[] args) {
		//创建中介者
		ConcreteMediator cm=new ConcreteMediator();
		//创建同事类
		ConcreteColleague1 c1=new ConcreteColleague1("张三",cm);
		ConcreteColleague2 c2=new ConcreteColleague2("李四",cm);
		//房东需要知道具体的租房者和房东
		cm.setC1(c1);
		cm.setC2(c2);
		c1.constact("我想租两房一厅的房子");
		c2.constact("我这有，而且非常便宜");
	}
}

20、备忘录模式(Memento)

记录状态，便于回滚，经常和命令模式结合使用
备忘录模式（小庄）
角色：

Memento 备忘录，记录状态
Originator 创建者：创建备忘录
Caretaker 管理者：管理备忘录

//备忘录，需要存的内容
class Memento {
	private String state;
	public Memento(String state) {
		this.state=state;
	}
	public String getState() {
		return state;
	}
}
//创建者，创建备忘录
class Originator {
	private String state;
	public void setState(String state) {
		this.state=state;
		//打印状态
		System.out.println("现在的状态为："+state);
	}
	public String getState() {
		return state;
	}
	//创建备忘录，并存储数据
	public Memento saveMemento() {
		return new Memento(state);
	}
	//获取备忘录的数据，恢复备忘录时的状态
	public void getStateFromMemento(Memento memento) {
		this.state=memento.getState();
	}
}
//管理者,备忘录的管理
import java.util.ArrayList;
class Caretaker {
	//聚合备忘录
	private ArrayList<Memento> mementos=new ArrayList<>();
	//添加备忘录
	public void addMemento(Memento memento) {
		mementos.add(memento);
	}
	public Memento getMemento(int index) {
		return mementos.get(index);
	}
}
//测试类
public class Client {
	public static void main(String[] args) {
		//定义创建类，管理类
		Originator o=new Originator();
		Caretaker c=new Caretaker();
		//设置当时的状态
		o.setState("状态1：攻击力：1000");
		c.addMemento(o.saveMemento());
		o.setState("状态2：攻击力：800");
		c.addMemento(o.saveMemento());
		String state=c.getMemento(0).getState();
		System.out.println("恢复后的状态为："+state);
	}
}

备忘录模式能够随时恢复到备忘录保存的状态，而命令模式需要多个撤销恢复上一个状态。备忘录模也会用在存盘功能，将会使用到序列化和反序化，对于序列化和反序列化的相关使用可以查看这里：

序列化和反序列化的相关知识

可以尝试实现这个功能，这里就不展开介绍了。

21、命令模式(Command)

需要回退（撤销，Undo）状态的时候通常会使用到命令模式
多次撤销，需要结合责任链模式
宏命令，需要树状结构的组合模式结合使用

命令的调用者和命令的接收者进行了解耦

角色：

invok 调用者
Command 命令
Receive 接收者

命令者模式（小庄）
下面代码是对单个命令的执行和撤销作用

//抽象化命令接口
interface Command {
	void execute();
	void undo();
}
//具体命令
class Command1 implements Command{
	private Receive receive; 
	String str="https://blog.csdn.net/weixin_44715643?spm=1000.2115.3001.5343";
	public Command1(Receive receive) {
		this.receive=receive;
	}
	@Override
	public void execute() {
		System.out.println("接收者的内容："+receive.msg);
		receive.msg+=str;
		System.out.println("接收者的内容发生了改变："+receive.msg);
	}
	@Override
	public void undo() {
		//回退到原来的状态
		receive.msg=receive.msg.substring(0, receive.msg.length()-str.length());
		System.out.println("恢复回上一步的操作时的接收者的内容："+receive.msg);
	}
}
//接收者，对命令做出相应的动作
class Receive {
	 String msg=new String("hello everybody ");
}
//调用者，聚合了命令
class Invok {
	private Command command;
	public Invok(Command command) {
		this.command=command;
	}
	public void executeCommand() {
		command.execute();
	}
	public void undoCommand() {
		command.undo();
	}
}
//使用命令者
public class Client {
	public static void main(String[] args) {
		Invok invok=new Invok(new Command1(new Receive()));
		//执行操作
		invok.executeCommand();
		//撤销操作
		System.out.println("下面进行撤销操作");
		invok.undoCommand();
	}
}

多个命令的执行和撤销

//抽象化命令接口
abstract class Command {
	abstract int getIndex();
	abstract void execute();
	abstract Command undo();
}
//命令1
import java.util.ArrayList;
class Command1 extends Command{
	private ArrayList<String> alist=new ArrayList<>();
	private int index=-1;
	private Receive receive; 
	//增加的内容
	String str="xxx ";
	public Command1(Receive receive) {
		this.receive=receive;
	}
	@Override
	public void execute() {	
		System.out.println("接收者的内容："+receive.msg);
		receive.msg+=str;
		System.out.println("接收者的内容发生了改变："+receive.msg);
		alist.add(receive.msg);
		index++;
	}
	@Override
	public Command1 undo() {
		if(index>=0) {
			if(index==0) {
				receive.msg=receive.msg.substring(0,receive.chushizhi.length());
				alist.remove(index);
				index--;
				System.out.println("初始值为："+receive.msg);
			}else {
				//回退到上一步的状态
				alist.remove(index);
				//下标往前面移动一位
				String s=alist.get(--index);
				receive.msg=receive.msg.substring(0, s.length());
				System.out.println("恢复回上一步的操作时的接收者的内容："+receive.msg);
			}
		}else {
			System.out.println("到底了，不能再撤销了");
		}
		return this;
	}
	//记录当前的状态
	@Override
	public int getIndex() {
		// TODO Auto-generated method stub
		return index;
	}
}
//接收者，对命令做出相应的动作
class Receive {
	 String msg="hello everybody ";
	//记录初始值
	String chushizhi=msg;
}
//调用者，可以作为使用者Client
class Invok {
	private Command command;
	public Invok(Command command) {
		this.command=command;
	}
	public void executeCommand() {
		command.execute();
	}
	public Invok undoCommand() {
		command.undo();
		return this;
	}
}
//使用命令者
public class Client {
	public static void main(String[] args) {
		Invok invok=new Invok(new Command1(new Receive()));
		//执行操作
		invok.executeCommand();
		invok.executeCommand();
		invok.executeCommand();
		//撤销操作
		System.out.println("下面进行撤销操作");
		invok.undoCommand();
		invok.undoCommand();
		invok.undoCommand();
		invok.undoCommand();
	}
}

22、访问者模式(Visitor)

数据结构和数据分离

角色：

Visitor 访问者抽象类 - Element 具体元素
Struct 结构，由多个元素组成
具体元素

访问者模式

//抽象化接口
interface Visitor {
	void visitCpu(Cpu cpu);
	void visitMemory(Memory memory);
	void visitBoard(Board board);
}
//具体访问者
class Woman implements Visitor{
	//全程七折半
	double totalPrice=0.0;
	@Override
	public void visitCpu(Cpu cpu) {
		//打折活动
		totalPrice+=cpu.getPrice()*0.75;
	}
	@Override
	public void visitMemory(Memory memory) {
		//打折活动
		totalPrice+=memory.getPrice()*0.75;
	}

	@Override
	public void visitBoard(Board board) {
		//打折活动
		totalPrice+=board.getPrice()*0.75;
	}
	//获取价钱
	public double getPrice() {
		return totalPrice;
	}
}
//具体访问者
class Man implements Visitor{
	//购买需要花费的总价钱,全场八折！
	double totalPrice=0.0;
	@Override
	public void visitCpu(Cpu cpu) {
		//打折活动
		totalPrice+=cpu.getPrice()*0.8;
	}
	@Override
	public void visitMemory(Memory memory) {
		totalPrice+=memory.getPrice()*0.8;
	}
	@Override
	public void visitBoard(Board board) {
		totalPrice+=board.getPrice()*0.8;
	}
	//获取价钱
	public double getPrice() {
		return totalPrice;
	}
}
//结构
interface ComputerPart {
	void accept(Visitor visitor);
}
class Board implements ComputerPart{
	//接待指定的访问人，调用指定的方法
	@Override
	public void accept(Visitor visitor) {
		visitor.visitBoard(this);
	}
	//设置Board的单价
	public double getPrice() {
		return 1000.00;
	}
}
class Cpu implements ComputerPart{
	//接待指定的访问人，调用指定的方法
	@Override
	public void accept(Visitor visitor) {
		visitor.visitCpu(this);
	}
	//设置Cpu的单价
	public double getPrice() {
		return 800.0;
	}
}
class Memory implements ComputerPart{
	//接待指定的访问人，调用指定的方法
	@Override
	public void accept(Visitor visitor) {
		visitor.visitMemory(this);
	}
	//设置Memory的单价
	public double getPrice() {
		return 400.00;
	}
}
//结构类，根据不同的访问者设定标配的电脑配件
public class Computer {
	Cpu cpu=new Cpu();
	Memory memory=new Memory();
	Board board=new Board();
	//给访问者设置标配
	public void accept(Visitor visitor) {
		this.cpu.accept(visitor);
		this.memory.accept(visitor);
		this.board.accept(visitor);
	}
}
//测试类
public class Test {
	public static void main(String[] args) {
		//定义相关类
		Computer computer=new Computer();
		Man man=new Man();
		Woman woman=new Woman();
		//通过访问者模式进行使用
		//一个男人过来购买电脑
		computer.accept(man);
		System.out.println("男人过来买需要花费:"+man.getPrice());
		//一个女人过来购买电脑
		computer.accept(woman);
		System.out.println("女人过来买需要花费:"+woman.getPrice());		
	}
}

23、解释器模式(Interpreter)

对于一些固定文法构建一个解释句子的解释器。在实际开发中，我们很少会去开发一个解释器，因为涉及到的知识点比较复杂。所以我们只需要了解即可,我们通过加减法的例子去了解它

角色：

Expression 抽象化解释器
Context 上下文，用于存放变量和值
Addition 加法解释器（具体解释器）
Minus 减法解释器（具体解释器）
Variable 变量解释器（具体解释器），它主要和上下文打交道（获取变量指定的值）

解释器模式（小庄）

//抽象化解释器
abstract class Expression {
	//解释方法
	public abstract int interpret(Context context);
}
//导入相关的包
import java.util.HashMap;
//上下文
class Context {
	//定义一个键值对的容器
	private HashMap<Variable,Integer> map=new HashMap<>();
	//把变量名和值存放到容器中
	public void addVariable(Variable v,Integer x) {
		map.put(v, x);
	}
	//通过变量名获取值
	public int getVlaue(Variable v) {
		return map.get(v);
	}
}
//变量类，继承解释器
class Variable extends Expression{
	//给每个变量定义一个名字
	String name;
	//通过构造方法给变量名赋值
	public Variable(String name) {
		this.name=name;
	}
	//变量解释方法，通过变量获取值
	@Override
	public int interpret(Context context) {
		//通过变量名获取上下文的容器中对应的值
		return context.getVlaue(this);
	}
	//重写toString()方法
	@Override
	public String toString() {
		return name;
	}
}
//具体解释器，加法器
class Addition extends Expression{
	//定义两个解释器的类，表示传进来的变量
	private Expression left;
	private Expression right;
	//存放进去的是变量
	public Addition(Expression left,Expression right) {
		this.left=left;
		this.right=right;
	}
	//进行加法运算
	@Override
	public int interpret(Context context) {
		//通过变量的解释器，获取对于的值，进行运算
		return left.interpret(context)+right.interpret(context);
	}
	@Override
	public String toString() {
		//重写toString方法
		return "("+left.toString()+"+"+right.toString()+")";
	}
}
//具体解释器，模拟减法器
class Minus extends Expression{
	//定义两个解释器变量
	private Expression left;
	private Expression right;
	//通过构造函数的方式传入两个变量
	public Minus(Expression left,Expression right) {
		this.left=left;
		this.right=right;
	}
	//解释方法
	@Override
	public int interpret(Context context) {
		//通过变量的解释器，获取对于的值，进行运算
		return left.interpret(context)-right.interpret(context);
	}
	@Override
	public String toString() {
		//重写toString()方法
		return "("+left.toString()+"-"+right.toString()+")";
	}
}
//测试类
public class Client {
	public static void main(String[] args) {
		//创建上下文
		Context context=new Context();
		//创建变量
		Variable a=new Variable("a");
		Variable b=new Variable("b");
		Variable c=new Variable("c");
		Variable d=new Variable("d");
		//将变量赋予值，并保存到上下文
		context.addVariable(a, 1);
		context.addVariable(b, 2);
		context.addVariable(c, 3);
		context.addVariable(d, 4);
		//设置表达式
		Expression expression=new Addition(a,new Minus(b,new Addition(c,d)));
		//对表达式进行解释
		int result=expression.interpret(context);
		//打印输出结果
		System.out.println(expression.toString()+"="+result);
	}
}

结语

通过上面的学习，我们发现很多设计模式都十分相似，其实这很正常，因为这些设计模式都是基于Java的继承、多态、聚合、组合等方式完成的。我们应该学习这些模式的设计思想，它们适合在什么场景，并且我们不需要归根到底是哪个设计模式，只要我们类的设计的合理，达到我们的需求即可。通过学习这个知识点，我们能够更加深入的理解开发框架的底层设计原理，有助于我们后面的学习。
我是小庄，欢迎大家和我一起成长。

码农_小庄

关注

32
点赞
踩
173

收藏

觉得还不错? 一键收藏
13
评论
Java设计模式总结篇：七大原则以及23种设计模式简单介绍

主要介绍七大原则和23种设计模式原则：1、单一原则2、开闭原则3、里氏替换原则4、接口隔离原则5、依赖倒置原则6、迪米特法则7、合成复用原则设计模式：1、单例模式2、工厂模式3、抽象工厂模式4、原型模式5、建造者模式6、适配者模式7、桥连模式8、装饰者模式9、享元模式10、代理模式11、组合模式12、外观模式13、状态模式14、责任链模式15、迭代器模式16、观察者模式17、策略模式18、模板方法模式19、解释器模式20、中介者模式21、备忘录模式22、命令模式23、访问者模式
复制链接

扫一扫

专栏目录