设计模式一撸到底

追Star仙

已于 2022-11-10 15:39:22 修改

阅读量108

点赞数

分类专栏：笔记 Java技术体系工作经验文章标签：设计模式 java 开发语言其他后端

于 2022-11-03 14:16:51 首次发布

本文链接：https://blog.csdn.net/sinat_27674731/article/details/127652583

版权

工作经验同时被 3 个专栏收录

18 篇文章 0 订阅

订阅专栏

笔记

9 篇文章 0 订阅

订阅专栏

Java技术体系

3 篇文章 0 订阅

订阅专栏

设计模式概述

设计模式简介

设计模式简介

设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。

设计模式分类

创建型设计模式（Creational Patterns）

定义：这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。

工厂模式（Factory Pattern）
抽象工厂模式（Abstract Factory Pattern）
单例模式（Singleton Pattern）
建造者模式（Builder Pattern）
原型模式（Prototype Pattern）

结构型设计模式（Structural Patterns）

定义:这些设计模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式

适配器模式（Adapter Pattern）
桥接模式（Bridge Pattern）
过滤器模式（Filter、Criteria Pattern）
组合模式（Composite Pattern）
装饰器模式（Decorator Pattern）
外观模式（Facade Pattern）
享元模式（Flyweight Pattern）
代理模式（Proxy Pattern）

行为型设计模式（Behavioral Patterns）

定义：这些设计模式特别关注对象之间的通信

责任链模式（Chain of Responsibility Pattern）
命令模式（Command Pattern）
解释器模式（Interpreter Pattern）
迭代器模式（Iterator Pattern）
中介者模式（Mediator Pattern）
备忘录模式（Memento Pattern）
观察者模式（Observer Pattern）
状态模式（State Pattern）
空对象模式（Null Object Pattern）
策略模式（Strategy Pattern）
模板模式（Template Pattern）
访问者模式（Visitor Pattern）

J2EE 模式

定义：这些设计模式特别关注表示层。这些模式是由 Sun Java Center 鉴定的。

MVC 模式（MVC Pattern）
业务代表模式（Business Delegate Pattern）
组合实体模式（Composite Entity Pattern）
数据访问对象模式（Data Access Object Pattern）
前端控制器模式（Front Controller Pattern）
拦截过滤器模式（Intercepting Filter Pattern）
服务定位器模式（Service Locator Pattern）
传输对象模式（Transfer Object Pattern）

设计模式的六大原则

开闭原则（Open Close Principle）
开闭原则是对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
里氏代换原则（Liskov Substitution Principle）
里氏代换原则是面向对象设计的基本原则之一。里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP 是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。
依赖倒转原则（Dependence Inversion Principle）
依赖倒转原则是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。
接口隔离原则（Interface Segregation Principle）
接口隔离原则是使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。
迪米特法则，又称最少知道原则（Demeter Principle）
迪米特法则是指一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。
合成复用原则（Composite Reuse Principle）
合成复用原则是指尽量使用合成/聚合的方式，而不是使用继承。

工厂模式（Factory Pattern）

**工厂模式（Factory Pattern）**是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

介绍

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

主要解决：主要解决接口选择的问题。

何时使用：我们明确地计划不同条件下创建不同实例时。

如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

关键代码：创建过程在其子类执行。

应用实例： 1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以。

优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

使用场景： 1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 3、设计一个连接服务器的框架，需要三个协议，“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一个接口。

注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

代码

package designPattern.creationalpatterns;

//1.创建一个接口
interface Animal{
	public void say();
}
//2.创建接口实现类
class Dog implements Animal{
	
	@Override
	public void say() {
		System.out.println("Dog wangwang!");
	}
}

class Sheep implements Animal{
	
	@Override
	public void say() {
		System.out.println("Sheep miemie!");
	}
}

class Duck implements Animal{
	
	@Override
	public void say() {
		System.out.println("Duck gaga!");
	}
}

//3.创建一个工厂，生成基于给定信息的实体类的对象。
class AnimalFactory {
	
	// 使用 getShape 方法获取形状类型的对象
	public Animal getAnimal(String animalType) {
		if (animalType == null) {
			return null;
		}
		if (animalType.equalsIgnoreCase("Dog")) {
			return new Dog();
		} else if (animalType.equalsIgnoreCase("Sheep")) {
			return new Sheep();
		} else if (animalType.equalsIgnoreCase("Duck")) {
			return new Duck();
		}
		return null;
	}
}

//4.使用该工厂，通过传递类型信息来获取实体类的对象。
/** 
 * @ClassName: FactoryPattern 
 * @Description: TODO(工厂模式) 
 * @author tirklee
 * @date 2022年11月3日 上午9:19:20 
 *  
 */
public class FactoryPattern{

	/** 
	 * @Title: main 
	 * @Description: TODO(工厂模式--使用该工厂，通过传递类型信息来获取实体类的对象)
	 * @Author tirklee 
	 * @param @param args    设定文件 
	 * @return void    返回类型 
	 * @throws 
	 */
	public static void main(String[] args){
		factoryCall1();
	}

	public static void factoryCall1() {
		AnimalFactory animalFactory = new AnimalFactory();
		Animal animal1 = animalFactory.getAnimal("Dog");
		animal1.say();
		Animal animal2 = animalFactory.getAnimal("Sheep");
		animal2.say();
		Animal animal3 = animalFactory.getAnimal("Duck");
		animal3.say();
	}
}

抽象工厂模式（Abstract Factory Pattern）

代码

package designPattern.creationalpatterns;


//1.为食物创建一个接口。
interface IFood{
	public void eat();
}
//2.创建食物接口实现类
class Noodles implements IFood{

	@Override
	public void eat() {
		System.out.println("吃面");
	}
}
class Rice implements IFood{

	@Override
	public void eat() {
		System.out.println("吃米饭");
	}
}
class Dish implements IFood{

	@Override
	public void eat() {
		System.out.println("吃菜");
	}
}
//3.创建饮料接口
interface IBeverages{
	public void drink();
}
//4.创建饮料接口实现类
class Milk implements IBeverages{

	@Override
	public void drink() {
		System.out.println("喝牛奶");
	}
}
class Liquor implements IBeverages{

	@Override
	public void drink() {
		System.out.println("喝酒");
	}
}
//5.创建抽象工厂类
abstract class AbstractFactory{
	public abstract IFood getIFood(String food);
	public abstract IBeverages getIBeverages(String beverages);
}
//6.创建食物工厂类
class FoodFactory extends AbstractFactory{

	@Override
	public IFood getIFood(String food) {
		if (food == null) {
			return null;
		}
		if (food.equalsIgnoreCase("Noodles")) {
			return new Noodles();
		} else if (food.equalsIgnoreCase("Rice")) {
			return new Rice();
		} else if (food.equalsIgnoreCase("Dish")) {
			return new Dish();
		}
		return null;
	}

	@Override
	public IBeverages getIBeverages(String beverages) {
		// TODO Auto-generated method stub
		return null;
	}
	
}
//7.创建饮料工厂类
class BeveragesFactory extends AbstractFactory{

	@Override
	public IFood getIFood(String food) {
		return null;
	}

	@Override
	public IBeverages getIBeverages(String beverages) {
		if (beverages == null) {
			return null;
		}
		if (beverages.equalsIgnoreCase("Milk")) {
			return new Milk();
		} else if (beverages.equalsIgnoreCase("Liquor")) {
			return new Liquor();
		}
		return null;
	}
	
}
//8.创建一个工厂创造器/生成器类，通过传递食物名称或饮料名称信息来获取工厂
class FactoryProducer {
	public static AbstractFactory getFactory(String choice) {
		if (choice.equalsIgnoreCase("Beverages")) {
			return new BeveragesFactory();
		} else if (choice.equalsIgnoreCase("Food")) {
			return new FoodFactory();
		}
		return null;
	}
}
//9.使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。
/**
 * @ClassName: AbstractFactoryPattern
 * @Description: TODO(抽象工厂模式)
 * @author tirklee
 * @date 2022年11月3日 上午9:20:57
 * 
 */
public class AbstractFactoryPattern {

	/**
	 * @Title: main
	 * @Description: TODO(抽象工厂模式)
	 * @Author tirklee
	 * @param @param args 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	public static void main(String[] args) {
		AbstractFactory foodFactory = FactoryProducer.getFactory("Food");
		IFood food1 = foodFactory.getIFood("Noodles");
		food1.eat();
		IFood food2 = foodFactory.getIFood("Rice");
		food2.eat();
		IFood food3 = foodFactory.getIFood("Dish");
		food3.eat();
		AbstractFactory beveragesFactory = FactoryProducer.getFactory("Beverages");
		IBeverages beveragesFactory1 = beveragesFactory.getIBeverages("Milk");
		beveragesFactory1.drink();
		IBeverages beveragesFactory2 = beveragesFactory.getIBeverages("Liquor");
		beveragesFactory2.drink();
	}

}

单例模式（Singleton Pattern）

代码

package designPattern.creationalpatterns;


class Singleton1{
	
	public static final Singleton1 instance = new Singleton1();
	
	private Singleton1() {
		
	}
	
	public Singleton1 getInstance() {
		return instance;
	}
}


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

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

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

class Singleton5{
	
	private static class SingletonHolder {
		private static final Singleton5 INSTANCE = new Singleton5();
	}

	private Singleton5 (){}

	public static final Singleton5 getInstance() {
		return SingletonHolder.INSTANCE;
	}
}

enum Singleton6{
	INSTANCE;
	public void whateverMethod() {
	}
}

/** 
 * @ClassName: SingletonPattern 
 * @Description: TODO(单例模式) 
 * @author tirklee
 * @date 2022年11月3日 上午9:32:35 
 *  
 */
public class SingletonPattern {

	/** 
	 * @Title: main 
	 * @Description: TODO(单例模式)
	 * @Author tirklee 
	 * @param @param args    设定文件 
	 * @return void    返回类型 
	 * @throws 
	 */
	public static void main(String[] args) {
		
	}
}

建造者模式（Builder Pattern）

代码

package designPattern.creationalpatterns;

import java.util.ArrayList;
import java.util.List;

//1.创建一个表示食物条目和食物包装的接口
interface Item{
	public String name();
	public Packing packing();
	public float price();
}
interface Packing{
	public String pack();
}
//2.创建实现Packing接口的实体类
class Wrapper implements Packing{

	@Override
	public String pack() {
		return "Wrapper";
	}
}
class Bottle implements Packing{

	@Override
	public String pack() {
		return "Bottle";
	}
}
//3.创建实现 Item 接口的抽象类，该类提供了默认的功能。
abstract class Burger implements Item {

	@Override
	public Packing packing() {
		return new Wrapper();
	}

	@Override
	public abstract float price();
}

abstract class ColdDrink implements Item {

	@Override
	public Packing packing() {
		return new Bottle();
	}

	@Override
	public abstract float price();
}
//4.创建扩展了 Burger 和 ColdDrink 的实体类
class VegBurger extends Burger {

	@Override
	public float price() {
		return 25.0f;
	}

	@Override
	public String name() {
		return "Veg Burger";
	}
}

class ChickenBurger extends Burger {

	@Override
	public float price() {
		return 50.5f;
	}

	@Override
	public String name() {
		return "Chicken Burger";
	}
}

class Coke extends ColdDrink {

	@Override
	public float price() {
		return 30.0f;
	}

	@Override
	public String name() {
		return "Coke";
	}
}

class Pepsi extends ColdDrink {

	@Override
	public float price() {
		return 35.0f;
	}

	@Override
	public String name() {
		return "Pepsi";
	}
}
//5.创建一个 Meal 类，带有上面定义的 Item 对象。
class Meal {
	private List<Item> items = new ArrayList<Item>();

	public void addItem(Item item) {
		items.add(item);
	}

	public float getCost() {
		float cost = 0.0f;
		for (Item item : items) {
			cost += item.price();
		}
		return cost;
	}

	public void showItems() {
		for (Item item : items) {
			System.out.print("Item : " + item.name());
			System.out.print(", Packing : " + item.packing().pack());
			System.out.println(", Price : " + item.price());
		}
	}
}
//6.创建一个 MealBuilder 类，实际的 builder 类负责创建 Meal 对象。
class MealBuilder {

	public Meal prepareVegMeal() {
		Meal meal = new Meal();
		meal.addItem(new VegBurger());
		meal.addItem(new Coke());
		return meal;
	}

	public Meal prepareNonVegMeal() {
		Meal meal = new Meal();
		meal.addItem(new ChickenBurger());
		meal.addItem(new Pepsi());
		return meal;
	}
}
//7.BuiderPatternDemo 使用 MealBuilder 来演示建造者模式（Builder Pattern）。
/**
 * @ClassName: BuilderPattern
 * @Description: TODO(建造者模式)
 * @author tirklee
 * @date 2022年11月3日 上午9:33:27
 * 
 */
public class BuilderPattern {

	/**
	 * @Title: main
	 * @Description: TODO(建造者模式)
	 * @Author tirklee
	 * @param @param args 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	public static void main(String[] args) {
		MealBuilder mealBuilder = new MealBuilder();

		Meal vegMeal = mealBuilder.prepareVegMeal();
		System.out.println("Veg Meal");
		vegMeal.showItems();
		System.out.println("Total Cost: " + vegMeal.getCost());

		Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
		System.out.println("\n\nNon-Veg Meal");
		nonVegMeal.showItems();
		System.out.println("Total Cost: " + nonVegMeal.getCost());
	}

}

原型模式（Prototype Pattern）

代码

package designPattern.creationalpatterns;

import java.util.Hashtable;

//1.创建一个实现了 Cloneable 接口的抽象类。
abstract class Shape implements Cloneable {

	private String id;
	protected String type;

	abstract void draw();

	public String getType() {
		return type;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public Object clone() {
		Object clone = null;
		try {
			clone = super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return clone;
	}
}
//2.创建扩展了上面抽象类的实体类
class Rectangle extends Shape {

	public Rectangle() {
		type = "Rectangle";
	}

	@Override
	public void draw() {
		System.out.println("Inside Rectangle::draw() method.");
	}
}

class Square extends Shape {

	public Square() {
		type = "Square";
	}

	@Override
	public void draw() {
		System.out.println("Inside Square::draw() method.");
	}
}

class Circle extends Shape {

	public Circle() {
		type = "Circle";
	}

	@Override
	public void draw() {
		System.out.println("Inside Circle::draw() method.");
	}
}

//3.创建一个类，从数据库获取实体类，并把它们存储在一个 Hashtable 中。
class ShapeCache {

	private static Hashtable<String, Shape> shapeMap = new Hashtable<String, Shape>();

	public static Shape getShape(String shapeId) {
		Shape cachedShape = shapeMap.get(shapeId);
		return (Shape) cachedShape.clone();
	}

	// 对每种形状都运行数据库查询，并创建该形状
	// shapeMap.put(shapeKey, shape);
	// 例如，我们要添加三种形状
	public static void loadCache() {
		Circle circle = new Circle();
		circle.setId("1");
		shapeMap.put(circle.getId(), circle);

		Square square = new Square();
		square.setId("2");
		shapeMap.put(square.getId(), square);

		Rectangle rectangle = new Rectangle();
		rectangle.setId("3");
		shapeMap.put(rectangle.getId(), rectangle);
	}
}
//4.PrototypePatternDemo 使用 ShapeCache 类来获取存储在 Hashtable 中的形状的克隆。
/** 
 * @ClassName: PrototypePattern 
 * @Description: TODO(原型模式) 
 * @author tirklee
 * @date 2022年11月3日 上午9:35:09 
 *  
 */
public class PrototypePattern {

	/** 
	 * @Title: main 
	 * @Description: TODO(原型模式)
	 * @Author tirklee 
	 * @param @param args    设定文件 
	 * @return void    返回类型 
	 * @throws 
	 */
	public static void main(String[] args) {
		ShapeCache.loadCache();

		Shape clonedShape = (Shape) ShapeCache.getShape("1");
		System.out.println("Shape : " + clonedShape.getType());

		Shape clonedShape2 = (Shape) ShapeCache.getShape("2");
		System.out.println("Shape : " + clonedShape2.getType());

		Shape clonedShape3 = (Shape) ShapeCache.getShape("3");
		System.out.println("Shape : " + clonedShape3.getType());
	}

}

适配器模式（Adapter Pattern）

代码

package designPattern.structuralpatterns;

//1.为媒体播放器和更高的媒体播放器创建接口
interface MediaPlayer{
	public void play(String audioType,String fileName);
}
interface AdvancedMediaPlayer {
	public void playVlc(String fileName);
	public void playMp4(String fileName);
}
//2.创建实现了 AdvancedMediaPlayer 接口的实体类。
class VlcPlayer implements AdvancedMediaPlayer {
	@Override
	public void playVlc(String fileName) {
		System.out.println("Playing vlc file. Name: " + fileName);
	}

	@Override
	public void playMp4(String fileName) {
		// 什么也不做
	}
}

class Mp4Player implements AdvancedMediaPlayer {

	@Override
	public void playVlc(String fileName) {
		// 什么也不做
	}

	@Override
	public void playMp4(String fileName) {
		System.out.println("Playing mp4 file. Name: " + fileName);
	}
}
//3.创建实现了 MediaPlayer 接口的适配器类
class MediaAdapter implements MediaPlayer {

	AdvancedMediaPlayer advancedMusicPlayer;

	public MediaAdapter(String audioType) {
		if (audioType.equalsIgnoreCase("vlc")) {
			advancedMusicPlayer = new VlcPlayer();
		} else if (audioType.equalsIgnoreCase("mp4")) {
			advancedMusicPlayer = new Mp4Player();
		}
	}

	@Override
	public void play(String audioType, String fileName) {
		if (audioType.equalsIgnoreCase("vlc")) {
			advancedMusicPlayer.playVlc(fileName);
		} else if (audioType.equalsIgnoreCase("mp4")) {
			advancedMusicPlayer.playMp4(fileName);
		}
	}
}
//4.创建实现了 MediaPlayer 接口的实体类。
class AudioPlayer implements MediaPlayer {
	MediaAdapter mediaAdapter;

	@Override
	public void play(String audioType, String fileName) {

		// 播放 mp3 音乐文件的内置支持
		if (audioType.equalsIgnoreCase("mp3")) {
			System.out.println("Playing mp3 file. Name: " + fileName);
		}
		// mediaAdapter 提供了播放其他文件格式的支持
		else if (audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")) {
			mediaAdapter = new MediaAdapter(audioType);
			mediaAdapter.play(audioType, fileName);
		} else {
			System.out.println("Invalid media. " + audioType + " format not supported");
		}
	}
}

//5.使用 AudioPlayer 来播放不同类型的音频格式。
/** 
 * @ClassName: AdapterPattern 
 * @Description: TODO(适配器模式) 
 * @author tirklee
 * @date 2022年11月3日 下午2:43:56 
 *  
 */
public class AdapterPattern {

	/** 
	 * @Title: main 
	 * @Description: TODO(适配器模式)
	 * @Author tirklee 
	 * @param @param args    设定文件 
	 * @return void    返回类型 
	 * @throws 
	 */
	public static void main(String[] args) {
		AudioPlayer audioPlayer = new AudioPlayer();

		audioPlayer.play("mp3", "beyond the horizon.mp3");
		audioPlayer.play("mp4", "alone.mp4");
		audioPlayer.play("vlc", "far far away.vlc");
		audioPlayer.play("avi", "mind me.avi");
	}

}

桥接模式（Bridge Pattern）

代码

package designPattern.structuralpatterns;

//1.创建桥接实现接口。
interface DrawAPI {
	public void drawCircle(int radius, int x, int y);
}
//2.创建实现了 DrawAPI 接口的实体桥接实现类。
class RedCircle implements DrawAPI {
	@Override
	public void drawCircle(int radius, int x, int y) {
		System.out.println("Drawing Circle[ color: red, radius: " + radius + ", x: " + x + ", " + y + "]");
	}
}

class GreenCircle implements DrawAPI {
	@Override
	public void drawCircle(int radius, int x, int y) {
		System.out.println("Drawing Circle[ color: green, radius: " + radius + ", x: " + x + ", " + y + "]");
	}
}
//3.使用 DrawAPI 接口创建抽象类 Shape。
abstract class Shape {
	protected DrawAPI drawAPI;

	protected Shape(DrawAPI drawAPI) {
		this.drawAPI = drawAPI;
	}

	public abstract void draw();
}
//4.创建实现了 Shape 抽象类的实体类
class Circle extends Shape {
	private int x, y, radius;

	public Circle(int x, int y, int radius, DrawAPI drawAPI) {
		super(drawAPI);
		this.x = x;
		this.y = y;
		this.radius = radius;
	}

	public void draw() {
		drawAPI.drawCircle(radius, x, y);
	}
}
//5.使用 Shape 和 DrawAPI 类画出不同颜色的圆。
/** 
 * @ClassName: BridgePattern 
 * @Description: TODO(桥接模式) 
 * @author tirklee
 * @date 2022年11月3日 下午2:44:16 
 *  
 */
public class BridgePattern {

	/** 
	 * @Title: main 
	 * @Description: TODO(桥接模式)
	 * @Author tirklee 
	 * @param @param args    设定文件 
	 * @return void    返回类型 
	 * @throws 
	 */
	public static void main(String[] args) {
		Shape redCircle = new Circle(100, 100, 10, new RedCircle());
		Shape greenCircle = new Circle(100, 100, 10, new GreenCircle());
		redCircle.draw();
		greenCircle.draw();
	}

}

过滤器模式（Filter、Criteria Pattern）

代码

package designPattern.structuralpatterns;

import java.util.ArrayList;
import java.util.List;

//1.创建一个类，在该类上应用标准。
class Person {

	private String name;
	private String gender;
	private String maritalStatus;

	public Person(String name, String gender, String maritalStatus) {
		this.name = name;
		this.gender = gender;
		this.maritalStatus = maritalStatus;
	}

	public String getName() {
		return name;
	}

	public String getGender() {
		return gender;
	}

	public String getMaritalStatus() {
		return maritalStatus;
	}
}
//2.为标准(Criteria)创建一个接口
interface Criteria {
	public List<Person> meetCriteria(List<Person> persons);
}
//3.创建实现了 Criteria 接口的实体类。
class CriteriaMale implements Criteria {

	@Override
	public List<Person> meetCriteria(List<Person> persons) {
		List<Person> malePersons = new ArrayList<Person>();
		for (Person person : persons) {
			if (person.getGender().equalsIgnoreCase("MALE")) {
				malePersons.add(person);
			}
		}
		return malePersons;
	}
}

class CriteriaFemale implements Criteria {

	@Override
	public List<Person> meetCriteria(List<Person> persons) {
		List<Person> femalePersons = new ArrayList<Person>();
		for (Person person : persons) {
			if (person.getGender().equalsIgnoreCase("FEMALE")) {
				femalePersons.add(person);
			}
		}
		return femalePersons;
	}
}

class CriteriaSingle implements Criteria {

	@Override
	public List<Person> meetCriteria(List<Person> persons) {
		List<Person> singlePersons = new ArrayList<Person>();
		for (Person person : persons) {
			if (person.getMaritalStatus().equalsIgnoreCase("SINGLE")) {
				singlePersons.add(person);
			}
		}
		return singlePersons;
	}
}

class AndCriteria implements Criteria {

	private Criteria criteria;
	private Criteria otherCriteria;

	public AndCriteria(Criteria criteria, Criteria otherCriteria) {
		this.criteria = criteria;
		this.otherCriteria = otherCriteria;
	}

	@Override
	public List<Person> meetCriteria(List<Person> persons) {
		List<Person> firstCriteriaPersons = criteria.meetCriteria(persons);
		return otherCriteria.meetCriteria(firstCriteriaPersons);
	}
}

class OrCriteria implements Criteria {

	private Criteria criteria;
	private Criteria otherCriteria;

	public OrCriteria(Criteria criteria, Criteria otherCriteria) {
		this.criteria = criteria;
		this.otherCriteria = otherCriteria;
	}

	@Override
	public List<Person> meetCriteria(List<Person> persons) {
		List<Person> firstCriteriaItems = criteria.meetCriteria(persons);
		List<Person> otherCriteriaItems = otherCriteria.meetCriteria(persons);

		for (Person person : otherCriteriaItems) {
			if (!firstCriteriaItems.contains(person)) {
				firstCriteriaItems.add(person);
			}
		}
		return firstCriteriaItems;
	}
}

//4.
/** 
 * @ClassName: FilterCriteriaPattern 
 * @Description: TODO(过滤器模式) 
 * @author tirklee
 * @date 2022年11月3日 下午2:44:36 
 *  
 */
public class FilterCriteriaPattern {

	/** 
	 * @Title: main 
	 * @Description: TODO(过滤器模式)
	 * @Author tirklee 
	 * @param @param args    设定文件 
	 * @return void    返回类型 
	 * @throws 
	 */
	public static void main(String[] args) {
		List<Person> persons = new ArrayList<Person>();

		persons.add(new Person("Robert", "Male", "Single"));
		persons.add(new Person("John", "Male", "Married"));
		persons.add(new Person("Laura", "Female", "Married"));
		persons.add(new Person("Diana", "Female", "Single"));
		persons.add(new Person("Mike", "Male", "Single"));
		persons.add(new Person("Bobby", "Male", "Single"));

		Criteria male = new CriteriaMale();
		Criteria female = new CriteriaFemale();
		Criteria single = new CriteriaSingle();
		Criteria singleMale = new AndCriteria(single, male);
		Criteria singleOrFemale = new OrCriteria(single, female);

		System.out.println("Males: ");
		printPersons(male.meetCriteria(persons));

		System.out.println("\nFemales: ");
		printPersons(female.meetCriteria(persons));

		System.out.println("\nSingle Males: ");
		printPersons(singleMale.meetCriteria(persons));

		System.out.println("\nSingle Or Females: ");
		printPersons(singleOrFemale.meetCriteria(persons));
	}
	
	public static void printPersons(List<Person> persons) {
		for (Person person : persons) {
			System.out.println("Person : [ Name : " + person.getName() + ", Gender : " + person.getGender()
					+ ", Marital Status : " + person.getMaritalStatus() + " ]");
		}
	}

}

组合模式（Composite Pattern）

代码

package designPattern.structuralpatterns;

import java.util.ArrayList;
import java.util.List;

//1.创建 Employee 类，该类带有 Employee 对象的列表。
class Employee {
	private String name;
	private String dept;
	private int salary;
	private List<Employee> subordinates;

	// 构造函数
	public Employee(String name, String dept, int sal) {
		this.name = name;
		this.dept = dept;
		this.salary = sal;
		subordinates = new ArrayList<Employee>();
	}

	public void add(Employee e) {
		subordinates.add(e);
	}

	public void remove(Employee e) {
		subordinates.remove(e);
	}

	public List<Employee> getSubordinates() {
		return subordinates;
	}

	public String toString() {
		return ("Employee :[ Name : " + name + ", dept : " + dept + ", salary :" + salary + " ]");
	}
}
//2.使用 Employee 类来创建和打印员工的层次结构。
/** 
 * @ClassName: CompositePattern 
 * @Description: TODO(组合模式) 
 * @author tirklee
 * @date 2022年11月3日 下午2:44:56 
 *  
 */
public class CompositePattern {

	/** 
	 * @Title: main 
	 * @Description: TODO(组合模式)
	 * @Author tirklee 
	 * @param @param args    设定文件 
	 * @return void    返回类型 
	 * @throws 
	 */
	public static void main(String[] args) {
		Employee CEO = new Employee("John", "CEO", 30000);

		Employee headSales = new Employee("Robert", "Head Sales", 20000);

		Employee headMarketing = new Employee("Michel", "Head Marketing", 20000);

		Employee clerk1 = new Employee("Laura", "Marketing", 10000);
		Employee clerk2 = new Employee("Bob", "Marketing", 10000);

		Employee salesExecutive1 = new Employee("Richard", "Sales", 10000);
		Employee salesExecutive2 = new Employee("Rob", "Sales", 10000);

		CEO.add(headSales);
		CEO.add(headMarketing);

		headSales.add(salesExecutive1);
		headSales.add(salesExecutive2);

		headMarketing.add(clerk1);
		headMarketing.add(clerk2);

		// 打印该组织的所有员工
		System.out.println(CEO);
		for (Employee headEmployee : CEO.getSubordinates()) {
			System.out.println(headEmployee);
			for (Employee employee : headEmployee.getSubordinates()) {
				System.out.println(employee);
			}
		}
	}

}

装饰器模式（Decorator Pattern）

代码

package designPattern.structuralpatterns;

//1.创建一个接口
interface Shape1 {
	void draw();
}
//2.创建实现接口的实体类。
class Rectangle1 implements Shape1 {

	@Override
	public void draw() {
		System.out.println("Shape: Rectangle");
	}
}
class Circle1 implements Shape1 {

	@Override
	public void draw() {
		System.out.println("Shape: Circle");
	}
}
//3.创建实现了 Shape1 接口的抽象装饰类。
abstract class ShapeDecorator1 implements Shape1 {
	protected Shape1 decoratedShape;

	public ShapeDecorator1(Shape1 decoratedShape) {
		this.decoratedShape = decoratedShape;
	}

	public void draw() {
		decoratedShape.draw();
	}
}
//4.创建扩展了 ShapeDecorator1 类的实体装饰类。
class RedShapeDecorator1 extends ShapeDecorator1 {

	public RedShapeDecorator1(Shape1 decoratedShape) {
		super(decoratedShape);
	}

	@Override
	public void draw() {
		decoratedShape.draw();
		setRedBorder(decoratedShape);
	}

	private void setRedBorder(Shape1 decoratedShape) {
		System.out.println("Border Color: Red");
	}
}
//5.使用 RedShapeDecorator1 来装饰 Shape1 对象。
/** 
 * @ClassName: DecoratorPattern 
 * @Description: TODO(装饰器模式) 
 * @author tirklee
 * @date 2022年11月3日 下午2:45:14 
 *  
 */
public class DecoratorPattern {

	/** 
	 * @Title: main 
	 * @Description: TODO(装饰器模式)
	 * @Author tirklee 
	 * @param @param args    设定文件 
	 * @return void    返回类型 
	 * @throws 
	 */
	public static void main(String[] args) {
		Shape1 circle = new Circle1();
		ShapeDecorator1 redCircle = new RedShapeDecorator1(new Circle1());
		ShapeDecorator1 redRectangle = new RedShapeDecorator1(new Rectangle1());
		// Shape redCircle = new RedShapeDecorator(new Circle());
		// Shape redRectangle = new RedShapeDecorator(new Rectangle());
		System.out.println("Circle with normal border");
		circle.draw();

		System.out.println("\nCircle of red border");
		redCircle.draw();

		System.out.println("\nRectangle of red border");
		redRectangle.draw();

	}

}

外观模式（Facade Pattern）

代码

package designPattern.structuralpatterns;

//1.创建一个接口
interface Shape2{
	public void draw();
}
//2.创建实现接口的实体类
class Rectangle2 implements Shape2 {

	@Override
	public void draw() {
		System.out.println("Rectangle::draw()");
	}
}

class Square2 implements Shape2 {

	@Override
	public void draw() {
		System.out.println("Square::draw()");
	}
}

class Circle2 implements Shape2 {

	@Override
	public void draw() {
		System.out.println("Circle::draw()");
	}
}
//3.创建一个外观类。
class ShapeMaker {
	private Shape2 circle;
	private Shape2 rectangle;
	private Shape2 square;

	public ShapeMaker() {
		circle = new Circle2();
		rectangle = new Rectangle2();
		square = new Square2();
	}

	public void drawCircle() {
		circle.draw();
	}

	public void drawRectangle() {
		rectangle.draw();
	}

	public void drawSquare() {
		square.draw();
	}
}
//4.使用该外观类画出各种类型的形状
/** 
 * @ClassName: FacadePattern 
 * @Description: TODO(外观模式) 
 * @author tirklee
 * @date 2022年11月3日 下午2:45:33 
 *  
 */
public class FacadePattern {

	/** 
	 * @Title: main 
	 * @Description: TODO(外观模式)
	 * @Author tirklee 
	 * @param @param args    设定文件 
	 * @return void    返回类型 
	 * @throws 
	 */
	public static void main(String[] args) {
		ShapeMaker shapeMaker = new ShapeMaker();
		shapeMaker.drawCircle();
		shapeMaker.drawRectangle();
		shapeMaker.drawSquare(); 
	}

}

享元模式（Flyweight Pattern）

代码

package designPattern.structuralpatterns;

import java.util.HashMap;

//1.创建一个接口
interface Shape3 {
	public void draw();
}
//2.创建实现接口的实体类
class Circle3 implements Shape3 {
	private String color;
	private int x;
	private int y;
	private int radius;

	public Circle3(String color){
	      this.color = color;     
	   }

	public void setX(int x) {
		this.x = x;
	}

	public void setY(int y) {
		this.y = y;
	}

	public void setRadius(int radius) {
		this.radius = radius;
	}

	@Override
	public void draw() {
		System.out.println("Circle: Draw() [Color : " + color + ", x : " + x + ", y :" + y + ", radius :" + radius);
	}
}
//3.创建一个工厂，生成基于给定信息的实体类的对象。
class ShapeFactory3 {
	private static final HashMap<String, Shape3> circleMap = new HashMap<>();

	public static Shape3 getCircle(String color) {
		Circle3 circle = (Circle3) circleMap.get(color);

		if (circle == null) {
			circle = new Circle3(color);
			circleMap.put(color, circle);
			System.out.println("Creating circle of color : " + color);
		}
		return circle;
	}
}
//4.使用该工厂，通过传递颜色信息来获取实体类的对象。
/** 
 * @ClassName: FlyweightPattern 
 * @Description: TODO(享元模式) 
 * @author tirklee
 * @date 2022年11月3日 下午2:45:49 
 *  
 */
public class FlyweightPattern {
	
	private static final String colors[] = { "Red", "Green", "Blue", "White", "Black" };
	/** 
	 * @Title: main 
	 * @Description: TODO(享元模式)
	 * @Author tirklee 
	 * @param @param args    设定文件 
	 * @return void    返回类型 
	 * @throws 
	 */
	public static void main(String[] args) {
		for (int i = 0; i < 20; ++i) {
			Circle3 circle = (Circle3) ShapeFactory3.getCircle(getRandomColor());
			circle.setX(getRandomX());
			circle.setY(getRandomY());
			circle.setRadius(100);
			circle.draw();
		}
	}

	private static String getRandomColor() {
		return colors[(int) (Math.random() * colors.length)];
	}

	private static int getRandomX() {
		return (int) (Math.random() * 100);
	}

	private static int getRandomY() {
		return (int) (Math.random() * 100);
	}
}

代理模式（Proxy Pattern）

代码

package designPattern.structuralpatterns;

//1.创建一个接口。
interface Image {
	void display();
}

//2.创建实现接口的实体类。
class RealImage implements Image {

	private String fileName;

	public RealImage(String fileName) {
		this.fileName = fileName;
		loadFromDisk(fileName);
	}

	@Override
	public void display() {
		System.out.println("Displaying " + fileName);
	}

	private void loadFromDisk(String fileName) {
		System.out.println("Loading " + fileName);
	}
}

class ProxyImage implements Image {

	private RealImage realImage;
	private String fileName;

	public ProxyImage(String fileName) {
		this.fileName = fileName;
	}

	@Override
	public void display() {
		if (realImage == null) {
			realImage = new RealImage(fileName);
		}
		realImage.display();
	}
}

//3.当被请求时，使用 ProxyImage 来获取 RealImage 类的对象。
/**
 * @ClassName: ProxyPattern
 * @Description: TODO(代理模式)
 * @author tirklee
 * @date 2022年11月3日 下午2:46:10
 * 
 */
public class ProxyPattern {

	/**
	 * @Title: main
	 * @Description: TODO(代理模式)
	 * @Author tirklee
	 * @param @param args 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	public static void main(String[] args) {
		Image image = new ProxyImage("test_10mb.jpg");
		// 图像将从磁盘加载
		image.display();
		System.out.println("");
		// 图像不需要从磁盘加载
		image.display();
	}

}

责任链模式（Chain of Responsibility Pattern）

代码

package designPattern.behavioralpatterns;

//1.创建抽象的记录器类
abstract class AbstractLogger{
	public static int INFO=1;
	public static int DEBUG=2;
	public static int ERROR=3;
	
	protected int level;
	
	//责任链中的下一个元素
	protected AbstractLogger nextLogger;

	public void setNextLogger(AbstractLogger nextLogger) {
		this.nextLogger = nextLogger;
	}

	public void logMessage(int level, String message) {
		if (this.level <= level) {
			write(message);
		}
		if (nextLogger != null) {
			nextLogger.logMessage(level, message);
		}
	}

	abstract protected void write(String message);
}

//2.创建扩展了该记录器类的实体类。
class ConsoleLogger extends AbstractLogger {

	public ConsoleLogger(int level) {
		this.level = level;
	}

	@Override
	protected void write(String message) {
		System.out.println("Standard Console::Logger: " + message);
	}
}

class ErrorLogger extends AbstractLogger {

	public ErrorLogger(int level) {
		this.level = level;
	}

	@Override
	protected void write(String message) {
		System.out.println("Error Console::Logger: " + message);
	}
}

class FileLogger extends AbstractLogger {

	public FileLogger(int level) {
		this.level = level;
	}

	@Override
	protected void write(String message) {
		System.out.println("File::Logger: " + message);
	}
}

//3.创建不同类型的记录器。赋予它们不同的错误级别，并在每个记录器中设置下一个记录器。每个记录器中的下一个记录器代表的是链的一部分。
/** 
 * @ClassName: ChainOfResponsibilityPattern 
 * @Description: TODO(责任链模式) 
 * @author tirklee
 * @date 2022年11月3日 下午2:46:51 
 *  
 */
public class ChainOfResponsibilityPattern {

	/** 
	 * @Title: main 
	 * @Description: TODO(责任链模式)
	 * @Author tirklee 
	 * @param @param args    设定文件 
	 * @return void    返回类型 
	 * @throws 
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		AbstractLogger loggerChain = getChainOfLoggers();

		loggerChain.logMessage(AbstractLogger.INFO, "This is an information.");

		loggerChain.logMessage(AbstractLogger.DEBUG, "This is a debug level information.");

		loggerChain.logMessage(AbstractLogger.ERROR, "This is an error information.");
	}

	private static AbstractLogger getChainOfLoggers() {

		AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
		AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG);
		AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);

		errorLogger.setNextLogger(fileLogger);
		fileLogger.setNextLogger(consoleLogger);

		return errorLogger;
	}
}

命令模式（Command Pattern）

代码

package designPattern.behavioralpatterns;

import java.util.ArrayList;
import java.util.List;

//1.创建一个命令接口。
interface Order {
	void execute();
}
//2.创建一个请求类。
class Stock {

	private String name = "ABC";
	private int quantity = 10;

	public void buy() {
		System.out.println("Stock [ Name: " + name + ",Quantity: " + quantity + " ] bought");
	}

	public void sell() {
		System.out.println("Stock [ Name: " + name + ",Quantity: " + quantity + " ] sold");
	}
}
//3.创建实现了 Order 接口的实体类.
class BuyStock implements Order {
	private Stock abcStock;

	public BuyStock(Stock abcStock) {
		this.abcStock = abcStock;
	}

	public void execute() {
		abcStock.buy();
	}
}

class SellStock implements Order {
	private Stock abcStock;

	public SellStock(Stock abcStock) {
		this.abcStock = abcStock;
	}

	public void execute() {
		abcStock.sell();
	}
}
//4.创建命令调用类。
class Broker {
	private List<Order> orderList = new ArrayList<Order>();

	public void takeOrder(Order order) {
		orderList.add(order);
	}

	public void placeOrders() {
		for (Order order : orderList) {
			order.execute();
		}
		orderList.clear();
	}
}
//5.使用 Broker 类来接受并执行命令。
/** 
 * @ClassName: CommandPattern 
 * @Description: TODO(命令模式) 
 * @author tirklee
 * @date 2022年11月3日 下午2:47:09 
 *  
 */
public class CommandPattern {

	/** 
	 * @Title: main 
	 * @Description: TODO(命令模式)
	 * @Author tirklee 
	 * @param @param args    设定文件 
	 * @return void    返回类型 
	 * @throws 
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Stock abcStock = new Stock();

		BuyStock buyStockOrder = new BuyStock(abcStock);
		SellStock sellStockOrder = new SellStock(abcStock);

		Broker broker = new Broker();
		broker.takeOrder(buyStockOrder);
		broker.takeOrder(sellStockOrder);

		broker.placeOrders();
	}

}

解释器模式（Interpreter Pattern）

代码

package designPattern.behavioralpatterns;

//1.创建一个表达式接口
interface Expression {
	public boolean interpret(String context);
}
//2.创建实现了上述接口的实体类
class TerminalExpression implements Expression {

	private String data;

	public TerminalExpression(String data) {
		this.data = data;
	}

	@Override
	public boolean interpret(String context) {
		if (context.contains(data)) {
			return true;
		}
		return false;
	}
}

class OrExpression implements Expression {

	private Expression expr1 = null;
	private Expression expr2 = null;

	public OrExpression(Expression expr1, Expression expr2) {
		this.expr1 = expr1;
		this.expr2 = expr2;
	}

	@Override
	public boolean interpret(String context) {
		return expr1.interpret(context) || expr2.interpret(context);
	}
}

class AndExpression implements Expression {

	private Expression expr1 = null;
	private Expression expr2 = null;

	public AndExpression(Expression expr1, Expression expr2) {
		this.expr1 = expr1;
		this.expr2 = expr2;
	}

	@Override
	public boolean interpret(String context) {
		return expr1.interpret(context) && expr2.interpret(context);
	}
}

//3.InterpreterPatternDemo 使用 Expression 类来创建规则，并解析它们。
/** 
 * @ClassName: InterpreterPattern 
 * @Description: TODO(解释器模式) 
 * @author tirklee
 * @date 2022年11月3日 下午2:47:23 
 *  
 */
public class InterpreterPattern {

	// 规则：Robert 和 John 是男性
	public static Expression getMaleExpression() {
		Expression robert = new TerminalExpression("Robert");
		Expression john = new TerminalExpression("John");
		return new OrExpression(robert, john);
	}

	// 规则：Julie 是一个已婚的女性
	public static Expression getMarriedWomanExpression() {
		Expression julie = new TerminalExpression("Julie");
		Expression married = new TerminalExpression("Married");
		return new AndExpression(julie, married);
	}
	
	/** 
	 * @Title: main 
	 * @Description: TODO(解释器模式)
	 * @Author tirklee 
	 * @param @param args    设定文件 
	 * @return void    返回类型 
	 * @throws 
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Expression isMale = getMaleExpression();
		Expression isMarriedWoman = getMarriedWomanExpression();

		System.out.println("John is male? " + isMale.interpret("John"));
		System.out.println("Julie is a married women? " + isMarriedWoman.interpret("Married Julie"));
	}

}

迭代器模式（Iterator Pattern）

代码

package designPattern.behavioralpatterns;

//1.创建接口
interface Iterator {

	public boolean hasNext();

	public Object next();

}

interface Container {
	public Iterator getIterator();
}

//2.创建实现了 Container 接口的实体类。该类有实现了 Iterator 接口的内部类 NameIterator
class NameRepository implements Container {
	public String[] names = { "Robert", "John", "Julie", "Lora" };

	@Override
	public Iterator getIterator() {
		return new NameIterator();
	}

	private class NameIterator implements Iterator {

		int index;

		@Override
		public boolean hasNext() {
			if (index < names.length) {
				return true;
			}
			return false;
		}

		@Override
		public Object next() {
			if (this.hasNext()) {
				return names[index++];
			}
			return null;
		}
	}
}
//3.使用 NameRepository 来获取迭代器，并打印名字
/** 
 * @ClassName: IteratorPattern 
 * @Description: TODO(迭代器模式) 
 * @author tirklee
 * @date 2022年11月3日 下午2:47:44 
 *  
 */
public class IteratorPattern {

	/** 
	 * @Title: main 
	 * @Description: TODO(迭代器模式)
	 * @Author tirklee 
	 * @param @param args    设定文件 
	 * @return void    返回类型 
	 * @throws 
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		NameRepository namesRepository = new NameRepository();

		for (Iterator iter = namesRepository.getIterator(); iter.hasNext();) {
			String name = (String) iter.next();
			System.out.println("Name : " + name);
		}
	}

}

中介者模式（Mediator Pattern）

代码

package designPattern.behavioralpatterns;

import java.util.Date;

//1.创建中介类
class ChatRoom {
	public static void showMessage(User user, String message) {
		System.out.println(new Date().toString() + " [" + user.getName() + "] : " + message);
	}
}
//2.创建user类
class User {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public User(String name) {
		this.name = name;
	}

	public void sendMessage(String message) {
		ChatRoom.showMessage(this, message);
	}
}
//3.使用 User 对象来显示他们之间的通信.
/** 
 * @ClassName: MediatorPattern 
 * @Description: TODO(中介模式) 
 * @author tirklee
 * @date 2022年11月3日 下午2:48:11 
 *  
 */
public class MediatorPattern {

	/** 
	 * @Title: main 
	 * @Description: TODO(中介模式)
	 * @Author tirklee 
	 * @param @param args    设定文件 
	 * @return void    返回类型 
	 * @throws 
	 */
	public static void main(String[] args) {
		User robert = new User("Robert");
		User john = new User("John");

		robert.sendMessage("Hi! John!");
		john.sendMessage("Hello! Robert!");
	}

}

备忘录模式（Memento Pattern）

代码

package designPattern.behavioralpatterns;

import java.util.ArrayList;
import java.util.List;

//1.创建 Memento 类。
class Memento {
   private String state;
 
   public Memento(String state){
      this.state = state;
   }
 
   public String getState(){
      return state;
   }  
}
//2.创建 Originator 类。
class Originator {
   private String state;
 
   public void setState(String state){
      this.state = state;
   }
 
   public String getState(){
      return state;
   }
 
   public Memento saveStateToMemento(){
      return new Memento(state);
   }
 
   public void getStateFromMemento(Memento Memento){
      state = Memento.getState();
   }
}
//3.创建 CareTaker 类。
class CareTaker {
   private List<Memento> mementoList = new ArrayList<Memento>();
 
   public void add(Memento state){
      mementoList.add(state);
   }
 
   public Memento get(int index){
      return mementoList.get(index);
   }
}
//4.使用 CareTaker 和 Originator 对象。
/** 
 * @ClassName: MementoPattern 
 * @Description: TODO(备忘录模式) 
 * @author tirklee
 * @date 2022年11月3日 下午2:48:29 
 *  
 */
public class MementoPattern {

	/** 
	 * @Title: main 
	 * @Description: TODO(备忘录模式)
	 * @Author tirklee 
	 * @param @param args    设定文件 
	 * @return void    返回类型 
	 * @throws 
	 */
	public static void main(String[] args) {
		Originator originator = new Originator();
		CareTaker careTaker = new CareTaker();
		originator.setState("State #1");
		originator.setState("State #2");
		careTaker.add(originator.saveStateToMemento());
		originator.setState("State #3");
		careTaker.add(originator.saveStateToMemento());
		originator.setState("State #4");

		System.out.println("Current State: " + originator.getState());
		originator.getStateFromMemento(careTaker.get(0));
		System.out.println("First saved State: " + originator.getState());
		originator.getStateFromMemento(careTaker.get(1));
		System.out.println("Second saved State: " + originator.getState());
	}

}

观察者模式（Observer Pattern）

代码

package designPattern.behavioralpatterns;

import java.util.ArrayList;
import java.util.List;

//1.创建 Subject 类。
class Subject {

	private List<Observer> observers = new ArrayList<Observer>();
	private int state;

	public int getState() {
		return state;
	}

	public void setState(int state) {
		this.state = state;
		notifyAllObservers();
	}

	public void attach(Observer observer) {
		observers.add(observer);
	}

	public void notifyAllObservers() {
		for (Observer observer : observers) {
			observer.update();
		}
	}
}

//2.创建 Observer 类。
abstract class Observer {
	protected Subject subject;

	public abstract void update();
}

//3.创建实体观察者类。
class BinaryObserver extends Observer {

	public BinaryObserver(Subject subject) {
		this.subject = subject;
		this.subject.attach(this);
	}

	@Override
	public void update() {
		System.out.println("Binary String: " + Integer.toBinaryString(subject.getState()));
	}
}

class OctalObserver extends Observer {

	public OctalObserver(Subject subject) {
		this.subject = subject;
		this.subject.attach(this);
	}

	@Override
	public void update() {
		System.out.println("Octal String: " + Integer.toOctalString(subject.getState()));
	}
}

class HexaObserver extends Observer {

	public HexaObserver(Subject subject) {
		this.subject = subject;
		this.subject.attach(this);
	}

	@Override
	public void update() {
		System.out.println("Hex String: " + Integer.toHexString(subject.getState()).toUpperCase());
	}
}
//4.使用 Subject 和实体观察者对象。
/** 
 * @ClassName: ObserverPattern 
 * @Description: TODO(观察者模式) 
 * @author tirklee
 * @date 2022年11月3日 下午2:48:45 
 *  
 */
public class ObserverPattern {

	/** 
	 * @Title: main 
	 * @Description: TODO(观察者模式)
	 * @Author tirklee 
	 * @param @param args    设定文件 
	 * @return void    返回类型 
	 * @throws 
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Subject subject = new Subject();

		new HexaObserver(subject);
		new OctalObserver(subject);
		new BinaryObserver(subject);

		System.out.println("First state change: 15");
		subject.setState(15);
		System.out.println("Second state change: 10");
		subject.setState(10);
	}

}

状态模式（State Pattern）

代码

package designPattern.behavioralpatterns;

//1.创建一个接口。
interface State {
	public void doAction(Context context);
}

//2.创建实现接口的实体类。
class StartState implements State {

	public void doAction(Context context) {
		System.out.println("Player is in start state");
		context.setState(this);
	}

	public String toString() {
		return "Start State";
	}
}

class StopState implements State {

	public void doAction(Context context) {
		System.out.println("Player is in stop state");
		context.setState(this);
	}

	public String toString() {
		return "Stop State";
	}
}

//3.创建 Context 类。
class Context {
	private State state;

	public Context() {
		state = null;
	}

	public void setState(State state) {
		this.state = state;
	}

	public State getState() {
		return state;
	}
}
//4.使用 Context 来查看当状态 State 改变时的行为变化。

/**
 * @ClassName: StatePattern
 * @Description: TODO(状态模式)
 * @author tirklee
 * @date 2022年11月3日 下午2:49:01
 * 
 */
public class StatePattern {

	/**
	 * @Title: main
	 * @Description: TODO(状态模式)
	 * @Author tirklee
	 * @param @param args 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Context context = new Context();

		StartState startState = new StartState();
		startState.doAction(context);

		System.out.println(context.getState().toString());

		StopState stopState = new StopState();
		stopState.doAction(context);

		System.out.println(context.getState().toString());
	}

}

空对象模式（Null Object Pattern）

代码

package designPattern.behavioralpatterns;

//1.创建一个抽象类。
abstract class AbstractCustomer {
	protected String name;

	public abstract boolean isNil();

	public abstract String getName();
}

//2.创建扩展了上述类的实体类。
class RealCustomer extends AbstractCustomer {

	public RealCustomer(String name) {
		this.name = name;
	}

	@Override
	public String getName() {
		return name;
	}

	@Override
	public boolean isNil() {
		return false;
	}
}

class NullCustomer extends AbstractCustomer {

	@Override
	public String getName() {
		return "Not Available in Customer Database";
	}

	@Override
	public boolean isNil() {
		return true;
	}
}

//3.创建 CustomerFactory 类。
class CustomerFactory {

	public static final String[] names = { "Rob", "Joe", "Julie" };

	public static AbstractCustomer getCustomer(String name) {
		for (int i = 0; i < names.length; i++) {
			if (names[i].equalsIgnoreCase(name)) {
				return new RealCustomer(name);
			}
		}
		return new NullCustomer();
	}
}
//4.使用 CustomerFactory，基于客户传递的名字，来获取 RealCustomer 或 NullCustomer 对象。

/**
 * @ClassName: NullObjectPattern
 * @Description: TODO(空对象模式)
 * @author tirklee
 * @date 2022年11月3日 下午2:49:19
 * 
 */
public class NullObjectPattern {

	/**
	 * @Title: main
	 * @Description: TODO(空对象模式)
	 * @Author tirklee
	 * @param @param args 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		AbstractCustomer customer1 = CustomerFactory.getCustomer("Rob");
		AbstractCustomer customer2 = CustomerFactory.getCustomer("Bob");
		AbstractCustomer customer3 = CustomerFactory.getCustomer("Julie");
		AbstractCustomer customer4 = CustomerFactory.getCustomer("Laura");

		System.out.println("Customers");
		System.out.println(customer1.getName());
		System.out.println(customer2.getName());
		System.out.println(customer3.getName());
		System.out.println(customer4.getName());
	}

}

策略模式（Strategy Pattern）

代码

package designPattern.behavioralpatterns;

//1.创建一个接口。
interface Strategy {
	public int doOperation(int num1, int num2);
}

//2.创建实现接口的实体类。
class OperationAdd implements Strategy {
	@Override
	public int doOperation(int num1, int num2) {
		return num1 + num2;
	}
}

class OperationSubtract implements Strategy {
	@Override
	public int doOperation(int num1, int num2) {
		return num1 - num2;
	}
}

class OperationMultiply implements Strategy {
	@Override
	public int doOperation(int num1, int num2) {
		return num1 * num2;
	}
}

//3.创建 Context 类。
class Context1 {
	private Strategy strategy;

	public Context1(Strategy strategy) {
		this.strategy = strategy;
	}

	public int executeStrategy(int num1, int num2) {
		return strategy.doOperation(num1, num2);
	}
}

//4.使用 Context 来查看当它改变策略 Strategy 时的行为变化。
/**
 * @ClassName: StrategyPattern
 * @Description: TODO(策略模式)
 * @author tirklee
 * @date 2022年11月3日 下午2:49:34
 * 
 */
public class StrategyPattern {

	/**
	 * @Title: main
	 * @Description: TODO(策略模式)
	 * @Author tirklee
	 * @param @param args 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Context1 context1 = new Context1(new OperationAdd());
		System.out.println("10 + 5 = " + context1.executeStrategy(10, 5));

		context1 = new Context1(new OperationSubtract());
		System.out.println("10 - 5 = " + context1.executeStrategy(10, 5));

		context1 = new Context1(new OperationMultiply());
		System.out.println("10 * 5 = " + context1.executeStrategy(10, 5));
	}

}

模板模式（Template Pattern）

代码

package designPattern.behavioralpatterns;

//1.创建一个抽象类，它的模板方法被设置为 final。
abstract class Game {
	
	abstract void initialize();
	abstract void startPlay();
	abstract void endPlay();
	// 模板
	public final void play() {
		// 初始化游戏
		initialize();
		// 开始游戏
		startPlay();
		// 结束游戏
		endPlay();
	}
}

//2.创建扩展了上述类的实体类。
class Cricket extends Game {

	@Override
	void endPlay() {
		System.out.println("Cricket Game Finished!");
	}

	@Override
	void initialize() {
		System.out.println("Cricket Game Initialized! Start playing.");
	}

	@Override
	void startPlay() {
		System.out.println("Cricket Game Started. Enjoy the game!");
	}
}

class Football extends Game {

	@Override
	void endPlay() {
		System.out.println("Football Game Finished!");
	}

	@Override
	void initialize() {
		System.out.println("Football Game Initialized! Start playing.");
	}

	@Override
	void startPlay() {
		System.out.println("Football Game Started. Enjoy the game!");
	}
}
//3.使用 Game 的模板方法 play() 来演示游戏的定义方式。

/**
 * @ClassName: TemplatePattern
 * @Description: TODO(模板模式)
 * @author tirklee
 * @date 2022年11月3日 下午2:49:58
 * 
 */
public class TemplatePattern {

	/**
	 * @Title: main
	 * @Description: TODO(模板模式)
	 * @Author tirklee
	 * @param @param args 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Game game = new Cricket();
		game.play();
		System.out.println();
		game = new Football();
		game.play();
	}

}

访问者模式（Visitor Pattern）

代码

package designPattern.behavioralpatterns;

//1.定义一个表示元素的接口。
interface ComputerPart {
	public void accept(ComputerPartVisitor computerPartVisitor);
}

//2.创建扩展了上述类的实体类。
class Keyboard implements ComputerPart {

	@Override
	public void accept(ComputerPartVisitor computerPartVisitor) {
		computerPartVisitor.visit(this);
	}
}

class Monitor implements ComputerPart {

	@Override
	public void accept(ComputerPartVisitor computerPartVisitor) {
		computerPartVisitor.visit(this);
	}
}

class Mouse implements ComputerPart {

	@Override
	public void accept(ComputerPartVisitor computerPartVisitor) {
		computerPartVisitor.visit(this);
	}
}

class Computer implements ComputerPart {

	ComputerPart[] parts;

	public Computer() {
		parts = new ComputerPart[] { new Mouse(), new Keyboard(), new Monitor() };
	}

	@Override
	public void accept(ComputerPartVisitor computerPartVisitor) {
		for (int i = 0; i < parts.length; i++) {
			parts[i].accept(computerPartVisitor);
		}
		computerPartVisitor.visit(this);
	}
}

//3.定义一个表示访问者的接口。
interface ComputerPartVisitor {
	public void visit(Computer computer);

	public void visit(Mouse mouse);

	public void visit(Keyboard keyboard);

	public void visit(Monitor monitor);
}

//4.创建实现了上述类的实体访问者。
class ComputerPartDisplayVisitor implements ComputerPartVisitor {

	@Override
	public void visit(Computer computer) {
		System.out.println("Displaying Computer.");
	}

	@Override
	public void visit(Mouse mouse) {
		System.out.println("Displaying Mouse.");
	}

	@Override
	public void visit(Keyboard keyboard) {
		System.out.println("Displaying Keyboard.");
	}

	@Override
	public void visit(Monitor monitor) {
		System.out.println("Displaying Monitor.");
	}
}

//5.使用 ComputerPartDisplayVisitor 来显示 Computer 的组成部分。
/**
 * @ClassName: VisitorPattern
 * @Description: TODO(访问者模式)
 * @author tirklee
 * @date 2022年11月3日 下午2:50:13
 * 
 */
public class VisitorPattern {

	/**
	 * @Title: main
	 * @Description: TODO(访问者模式)
	 * @Author tirklee
	 * @param @param args 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ComputerPart computer = new Computer();
		computer.accept(new ComputerPartDisplayVisitor());
	}
}

MVC 模式（MVC Pattern）

代码

package designPattern.j2ee;

//1.创建模型。
class Student {
	private String rollNo;
	private String name;

	public String getRollNo() {
		return rollNo;
	}

	public void setRollNo(String rollNo) {
		this.rollNo = rollNo;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

//2.创建视图。
class StudentView {
	public void printStudentDetails(String studentName, String studentRollNo) {
		System.out.println("Student: ");
		System.out.println("Name: " + studentName);
		System.out.println("Roll No: " + studentRollNo);
	}
}

//3.创建控制器。
class StudentController {
	private Student model;
	private StudentView view;

	public StudentController(Student model, StudentView view) {
		this.model = model;
		this.view = view;
	}

	public void setStudentName(String name) {
		model.setName(name);
	}

	public String getStudentName() {
		return model.getName();
	}

	public void setStudentRollNo(String rollNo) {
		model.setRollNo(rollNo);
	}

	public String getStudentRollNo() {
		return model.getRollNo();
	}

	public void updateView() {
		view.printStudentDetails(model.getName(), model.getRollNo());
	}
}

//4.使用 StudentController 方法来演示 MVC 模式的用法。
/**
 * @ClassName: MVCPattern
 * @Description: TODO(MVC模式)
 * @author tirklee
 * @date 2022年11月3日 下午2:51:07
 * 
 */
public class MVCPattern {

	/**
	 * @Title: main
	 * @Description: TODO(MVC模式)
	 * @Author tirklee
	 * @param @param args 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 从数据库获取学生记录
		Student model = retrieveStudentFromDatabase();

		// 创建一个视图：把学生详细信息输出到控制台
		StudentView view = new StudentView();

		StudentController controller = new StudentController(model, view);

		controller.updateView();

		// 更新模型数据
		controller.setStudentName("John");

		controller.updateView();
	}

	private static Student retrieveStudentFromDatabase() {
		Student student = new Student();
		student.setName("Robert");
		student.setRollNo("10");
		return student;
	}
}

业务代表模式（Business Delegate Pattern）

代码

package designPattern.j2ee;

//1.创建 BusinessService 接口。
interface BusinessService {
	public void doProcessing();
}

//2.创建实体服务类。
class EJBService implements BusinessService {

	@Override
	public void doProcessing() {
		System.out.println("Processing task by invoking EJB Service");
	}
}

class JMSService implements BusinessService {

	@Override
	public void doProcessing() {
		System.out.println("Processing task by invoking JMS Service");
	}
}

//3.创建业务查询服务。
class BusinessLookUp {
	public BusinessService getBusinessService(String serviceType) {
		if (serviceType.equalsIgnoreCase("EJB")) {
			return new EJBService();
		} else {
			return new JMSService();
		}
	}
}

//4.创建业务代表。
class BusinessDelegate {
	private BusinessLookUp lookupService = new BusinessLookUp();
	private BusinessService businessService;
	private String serviceType;

	public void setServiceType(String serviceType) {
		this.serviceType = serviceType;
	}

	public void doTask() {
		businessService = lookupService.getBusinessService(serviceType);
		businessService.doProcessing();
	}
}

//5.创建客户端。
class Client {

	BusinessDelegate businessService;

	public Client(BusinessDelegate businessService) {
		this.businessService = businessService;
	}

	public void doTask() {
		businessService.doTask();
	}
}
//6.使用 BusinessDelegate 和 Client 类来演示业务代表模式。

/**
 * @ClassName: BusinessDelegatePattern
 * @Description: TODO(业务代表模式)
 * @author tirklee
 * @date 2022年11月3日 下午2:51:31
 * 
 */
public class BusinessDelegatePattern {

	/**
	 * @Title: main
	 * @Description: TODO(业务代表模式)
	 * @Author tirklee
	 * @param @param args 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BusinessDelegate businessDelegate = new BusinessDelegate();
		businessDelegate.setServiceType("EJB");

		Client client = new Client(businessDelegate);
		client.doTask();

		businessDelegate.setServiceType("JMS");
		client.doTask();
	}

}

组合实体模式（Composite Entity Pattern）

代码

package designPattern.j2ee;

//1.创建依赖对象。
class DependentObject1 {

	private String data;

	public void setData(String data) {
		this.data = data;
	}

	public String getData() {
		return data;
	}
}

class DependentObject2 {

	private String data;

	public void setData(String data) {
		this.data = data;
	}

	public String getData() {
		return data;
	}
}

//2.创建粗粒度对象。
class CoarseGrainedObject {
	DependentObject1 do1 = new DependentObject1();
	DependentObject2 do2 = new DependentObject2();

	public void setData(String data1, String data2) {
		do1.setData(data1);
		do2.setData(data2);
	}

	public String[] getData() {
		return new String[] { do1.getData(), do2.getData() };
	}
}

//3.创建组合实体。
class CompositeEntity {
	private CoarseGrainedObject cgo = new CoarseGrainedObject();

	public void setData(String data1, String data2) {
		cgo.setData(data1, data2);
	}

	public String[] getData() {
		return cgo.getData();
	}
}

//4.创建使用组合实体的客户端类。
class Client1 {
	private CompositeEntity compositeEntity = new CompositeEntity();

	public void printData() {
		for (int i = 0; i < compositeEntity.getData().length; i++) {
			System.out.println("Data: " + compositeEntity.getData()[i]);
		}
	}

	public void setData(String data1, String data2) {
		compositeEntity.setData(data1, data2);
	}
}

//5.使用 Client 来演示组合实体模式的用法。
/**
 * @ClassName: CompositeEntityPattern
 * @Description: TODO(组合实体模式)
 * @author tirklee
 * @date 2022年11月3日 下午2:51:49
 * 
 */
public class CompositeEntityPattern {

	/**
	 * @Title: main
	 * @Description: TODO(组合实体模式)
	 * @Author tirklee
	 * @param @param args 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Client1 client = new Client1();
		client.setData("Test", "Data");
		client.printData();
		client.setData("Second Test", "Data1");
		client.printData();
	}

}

数据访问对象模式（Data Access Object Pattern）

代码

package designPattern.j2ee;

import java.util.ArrayList;
import java.util.List;

//1.创建数值对象。
class Student1 {
	private String name;
	private int rollNo;

	Student1(String name, int rollNo) {
		this.name = name;
		this.rollNo = rollNo;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getRollNo() {
		return rollNo;
	}

	public void setRollNo(int rollNo) {
		this.rollNo = rollNo;
	}
}

//2.创建数据访问对象接口。
interface StudentDao {
	public List<Student1> getAllStudents();

	public Student1 getStudent(int rollNo);

	public void updateStudent(Student1 student);

	public void deleteStudent(Student1 student);
}

//3.创建实现了上述接口的实体类。
class StudentDaoImpl implements StudentDao {

	// 列表是当作一个数据库
	List<Student1> students;

	public StudentDaoImpl() {
		students = new ArrayList<Student1>();
		Student1 student1 = new Student1("Robert", 0);
		Student1 student2 = new Student1("John", 1);
		students.add(student1);
		students.add(student2);
	}

	@Override
	public void deleteStudent(Student1 student) {
		students.remove(student.getRollNo());
		System.out.println("Student: Roll No " + student.getRollNo() + ", deleted from database");
	}

	// 从数据库中检索学生名单
	@Override
	public List<Student1> getAllStudents() {
		return students;
	}

	@Override
	public Student1 getStudent(int rollNo) {
		return students.get(rollNo);
	}

	@Override
	public void updateStudent(Student1 student) {
		students.get(student.getRollNo()).setName(student.getName());
		System.out.println("Student: Roll No " + student.getRollNo() + ", updated in the database");
	}
}

//4.使用 StudentDao 来演示数据访问对象模式的用法。
/**
 * @ClassName: DataAccessObjectPattern
 * @Description: TODO(数据访问对象模式)
 * @author tirklee
 * @date 2022年11月3日 下午2:52:09
 * 
 */
public class DataAccessObjectPattern {

	/**
	 * @Title: main
	 * @Description: TODO(数据访问对象模式)
	 * @Author tirklee
	 * @param @param args 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StudentDao studentDao = new StudentDaoImpl();

		// 输出所有的学生
		for (Student1 student : studentDao.getAllStudents()) {
			System.out.println("Student: [RollNo : " + student.getRollNo() + ", Name : " + student.getName() + " ]");
		}

		// 更新学生
		Student1 student = studentDao.getAllStudents().get(0);
		student.setName("Michael");
		studentDao.updateStudent(student);

		// 获取学生
		studentDao.getStudent(0);
		System.out.println("Student: [RollNo : " + student.getRollNo() + ", Name : " + student.getName() + " ]");
	}

}

前端控制器模式（Front Controller Pattern）

代码

package designPattern.j2ee;

//1.创建视图。
class HomeView {
	public void show() {
		System.out.println("Displaying Home Page");
	}
}

class StudentView1 {
	public void show() {
		System.out.println("Displaying Student Page");
	}
}

//2.创建调度器 Dispatcher。
class Dispatcher {
	private StudentView1 studentView;
	private HomeView homeView;

	public Dispatcher() {
		studentView = new StudentView1();
		homeView = new HomeView();
	}

	public void dispatch(String request) {
		if (request.equalsIgnoreCase("STUDENT")) {
			studentView.show();
		} else {
			homeView.show();
		}
	}
}

//3.创建前端控制器 FrontController。
class FrontController {

	private Dispatcher dispatcher;

	public FrontController() {
		dispatcher = new Dispatcher();
	}

	private boolean isAuthenticUser() {
		System.out.println("User is authenticated successfully.");
		return true;
	}

	private void trackRequest(String request) {
		System.out.println("Page requested: " + request);
	}

	public void dispatchRequest(String request) {
		// 记录每一个请求
		trackRequest(request);
		// 对用户进行身份验证
		if (isAuthenticUser()) {
			dispatcher.dispatch(request);
		}
	}
}

//4.使用 FrontController 来演示前端控制器模式。
/**
 * @ClassName: FrontControllerPattern
 * @Description: TODO(前端控制器模式)
 * @author tirklee
 * @date 2022年11月3日 下午2:52:28
 * 
 */
public class FrontControllerPattern {

	/**
	 * @Title: main
	 * @Description: TODO(前端控制器模式)
	 * @Author tirklee
	 * @param @param args 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FrontController frontController = new FrontController();
		frontController.dispatchRequest("HOME");
		frontController.dispatchRequest("STUDENT");
	}

}

拦截过滤器模式（Intercepting Filter Pattern）

代码

package designPattern.j2ee;

import java.util.ArrayList;
import java.util.List;

//1.创建过滤器接口 Filter。
interface Filter {
	public void execute(String request);
}

//2.创建实体过滤器。
class AuthenticationFilter implements Filter {
	public void execute(String request) {
		System.out.println("Authenticating request: " + request);
	}
}

class DebugFilter implements Filter {
	public void execute(String request) {
		System.out.println("request log: " + request);
	}
}

//3.创建 Target。
class Target {
	public void execute(String request) {
		System.out.println("Executing request: " + request);
	}
}

//4.创建过滤器链。
class FilterChain {
	private List<Filter> filters = new ArrayList<Filter>();
	private Target target;

	public void addFilter(Filter filter) {
		filters.add(filter);
	}

	public void execute(String request) {
		for (Filter filter : filters) {
			filter.execute(request);
		}
		target.execute(request);
	}

	public void setTarget(Target target) {
		this.target = target;
	}
}

//5.创建过滤管理器。
class FilterManager {
	FilterChain filterChain;

	public FilterManager(Target target) {
		filterChain = new FilterChain();
		filterChain.setTarget(target);
	}

	public void setFilter(Filter filter) {
		filterChain.addFilter(filter);
	}

	public void filterRequest(String request) {
		filterChain.execute(request);
	}
}

//6.创建客户端 Client。
class Client2 {
	FilterManager filterManager;

	public void setFilterManager(FilterManager filterManager) {
		this.filterManager = filterManager;
	}

	public void sendRequest(String request) {
		filterManager.filterRequest(request);
	}
}

//7.使用 Client 来演示拦截过滤器模式。
/**
 * @ClassName: InterceptingFilterPattern
 * @Description: TODO(拦截过滤器模式)
 * @author tirklee
 * @date 2022年11月3日 下午2:52:45
 * 
 */
public class InterceptingFilterPattern {

	/**
	 * @Title: main
	 * @Description: TODO(拦截过滤器模式)
	 * @Author tirklee
	 * @param @param args 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FilterManager filterManager = new FilterManager(new Target());
		filterManager.setFilter(new AuthenticationFilter());
		filterManager.setFilter(new DebugFilter());

		Client2 client = new Client2();
		client.setFilterManager(filterManager);
		client.sendRequest("HOME");
	}

}

服务定位器模式（Service Locator Pattern）

代码

package designPattern.j2ee;

import java.util.ArrayList;
import java.util.List;

//1.创建服务接口 Service。
interface Service {
	public String getName();
	public void execute();
}

//2.创建实体服务。
class Service1 implements Service {
	public void execute() {
		System.out.println("Executing Service1");
	}

	@Override
	public String getName() {
		return "Service1";
	}
}

class Service2 implements Service {
	public void execute() {
		System.out.println("Executing Service2");
	}

	@Override
	public String getName() {
		return "Service2";
	}
}

//3.为 JNDI 查询创建 InitialContext。
class InitialContext {
	public Object lookup(String jndiName) {
		if (jndiName.equalsIgnoreCase("SERVICE1")) {
			System.out.println("Looking up and creating a new Service1 object");
			return new Service1();
		} else if (jndiName.equalsIgnoreCase("SERVICE2")) {
			System.out.println("Looking up and creating a new Service2 object");
			return new Service2();
		}
		return null;
	}
}

//4.创建缓存 Cache。
class Cache {

	private List<Service> services;

	public Cache() {
		services = new ArrayList<Service>();
	}

	public Service getService(String serviceName) {
		for (Service service : services) {
			if (service.getName().equalsIgnoreCase(serviceName)) {
				System.out.println("Returning cached  " + serviceName + " object");
				return service;
			}
		}
		return null;
	}

	public void addService(Service newService) {
		boolean exists = false;
		for (Service service : services) {
			if (service.getName().equalsIgnoreCase(newService.getName())) {
				exists = true;
			}
		}
		if (!exists) {
			services.add(newService);
		}
	}
}

//5.创建服务定位器。
class ServiceLocator {
	private static Cache cache;

	static {
		cache = new Cache();
	}

	public static Service getService(String jndiName) {

		Service service = cache.getService(jndiName);

		if (service != null) {
			return service;
		}

		InitialContext context = new InitialContext();
		Service service1 = (Service) context.lookup(jndiName);
		cache.addService(service1);
		return service1;
	}
}

//6.使用 ServiceLocator 来演示服务定位器模式。
/**
 * @ClassName: ServiceLocatorPattern
 * @Description: TODO(服务定位器模式)
 * @author tirklee
 * @date 2022年11月3日 下午2:53:12
 * 
 */
public class ServiceLocatorPattern {

	/**
	 * @Title: main
	 * @Description: TODO(服务定位器模式)
	 * @Author tirklee
	 * @param @param args 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	public static void main(String[] args) {
		Service service = ServiceLocator.getService("Service1");
		service.execute();
		service = ServiceLocator.getService("Service2");
		service.execute();
		service = ServiceLocator.getService("Service1");
		service.execute();
		service = ServiceLocator.getService("Service2");
		service.execute();
	}

}

传输对象模式（Transfer Object Pattern）

代码

package designPattern.j2ee;

import java.util.ArrayList;
import java.util.List;

//1.创建传输对象。
class StudentVO {
	private String name;
	private int rollNo;

	StudentVO(String name, int rollNo) {
		this.name = name;
		this.rollNo = rollNo;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getRollNo() {
		return rollNo;
	}

	public void setRollNo(int rollNo) {
		this.rollNo = rollNo;
	}
}

//2.创建业务对象。
class StudentBO {

	// 列表是当作一个数据库
	List<StudentVO> students;

	public StudentBO() {
		students = new ArrayList<StudentVO>();
		StudentVO student1 = new StudentVO("Robert", 0);
		StudentVO student2 = new StudentVO("John", 1);
		students.add(student1);
		students.add(student2);
	}

	public void deleteStudent(StudentVO student) {
		students.remove(student.getRollNo());
		System.out.println("Student: Roll No " + student.getRollNo() + ", deleted from database");
	}

	// 从数据库中检索学生名单
	public List<StudentVO> getAllStudents() {
		return students;
	}

	public StudentVO getStudent(int rollNo) {
		return students.get(rollNo);
	}

	public void updateStudent(StudentVO student) {
		students.get(student.getRollNo()).setName(student.getName());
		System.out.println("Student: Roll No " + student.getRollNo() + ", updated in the database");
	}
}

//3.使用 StudentBO 来演示传输对象模式。
/**
 * @ClassName: TransferObjectPattern
 * @Description: TODO(传输对象模式)
 * @author tirklee
 * @date 2022年11月3日 下午2:53:32
 * 
 */
public class TransferObjectPattern {

	/**
	 * @Title: main
	 * @Description: TODO(传输对象模式)
	 * @Author tirklee
	 * @param @param args 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StudentBO studentBusinessObject = new StudentBO();

		// 输出所有的学生
		for (StudentVO student : studentBusinessObject.getAllStudents()) {
			System.out.println("Student: [RollNo : " + student.getRollNo() + ", Name : " + student.getName() + " ]");
		}

		// 更新学生
		StudentVO student = studentBusinessObject.getAllStudents().get(0);
		student.setName("Michael");
		studentBusinessObject.updateStudent(student);

		// 获取学生
		studentBusinessObject.getStudent(0);
		System.out.println("Student: [RollNo : " + student.getRollNo() + ", Name : " + student.getName() + " ]");
	}

}

追Star仙

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
设计模式一撸到底

设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。
复制链接

扫一扫