小结：
创建型模式（5种）：单例模式、简单工厂模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式
结构型模式（7种）：适配器模式、代理模式、桥接模式、组合模式、装饰器模式、外观模式、亨元模式
行为型模式（11种）：责任链模式、迭代器模式、中介者模式、命令模式、解释器模式、访问者模式、策略模式、模板方法模式、状态模式、观察者模式、备忘录模式
一：创建型模式（都是用来帮助创建对象滴！！关注对象的创建）
1：单例模式(Singleton pattern):确保一个类只有一个实例对象, 并提供一个访问该实例的全局访问点
核心代码（以恶汉式为例）---------------------创建一个对象实例
public class SingletonOfHungry {
//2:创建类的私有静态成员对象，并直接调用私有构造器传值初始化
private static SingletonOfHungry singleton = new SingletonOfHungry();
//1:创建类的私有构造器 在私有构造方法中加入判断
private SingletonOfHungry(){
//防止反射的暴力破解
if(singleton != null){
throw new RuntimeException("创建失败");
}
}
//3:创建类的公有方法，返回该静态成员对象的实例
public static SingletonOfHungry getInstance(){
return singleton;
}
//防止序列化与反序列化的漏洞
private Object readResolve() throws ObjectStreamException{
return singleton;
}
}
2：简单工厂模式(Simple factory pattern)：工厂类一般是静态方法，通过接收的参数不同来返回不同的对象实例
核心代码---------------------创建多个对象实例，对于增加新的产品，需要修改已有代码（一个工厂类）
public class CarFactory {
//创建奥迪类
public static Audi createAudi(){
return new Audi();
}
//创建宝马类
public static Bwm createBwm(){
return new Bwm();
}
//.....
}
3：工厂方法模式(Factory method pattern): 简单工厂模式只有一个工厂类，而工厂方法模式有一组实现了相同接口的工厂类
核心代码---------------------创建多个对象实例，但是增加新的产品需要增加大量类实现接口（一个共有工厂接口）
public interface CarFactory {
public abstract Car createCar();
}
4：抽象工厂模式(Abstract factory pattern): 用来生产不同产品族的全部产品，可以看做是工厂方法模式的升级版（一条产品族！）
核心代码---------------------创建多个对象实例，用来构建整条产品族，对于增加新品无能为力（一个产品族接口）
public interface CarFactory {
// 创建引擎对象
public abstract Engine createEngine();
// 创建座椅对象
public abstract Seat createSeat();
// 创建轮胎对象
public abstract Tyre createTyre();
}
5：建造者模式(Builder pattern): 当我们需要构造一个复杂的产品，比如：手机，汽车等。我们不仅需要构建各个零件，还有将这些零件组装在一起。分离了对象子组件的单独构造（由Bulider负责）和装配（由Director负责）,实现了构建和装配的解耦（手机各种零件组装！！）
核心代码---------------------创建多个对象实例，构建复杂产品，将构造和装配分离（一个构造器接口，一个装配器接口）
public interface IphoneBuilder {
//各个部件构造器
public abstract Battery builderBattery();
public abstract Processor builderProcessor();
public abstract Shell Shell();
}
public interface IphoneDirectory {
//手机组装器
public abstract Iphone directIphone();
}
6：原型模式(Prototype pattern):短时间内需要创建大量对象，并且new的过程比较耗时，可以考虑原型模式（克隆羊！！）
核心代码---------------------创建多个对象实例，克隆！拷贝！（实现一个Cloneable接口，引入一个clone方法）
//加入clone方法
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
二：结构型模式（都是用来实现程序结构上的松耦合！！关注类和对象的组织）
1：适配器模式(Adapter pattern):将一个类的接口转换成客户希望的另外一个接口（网线转换头，用过没！插usb上滴！！就是它！）
核心代码---------------------使得原本由于接口不兼容而不能一起工作的那些类可以一起工作
/*
* 相当于电脑和键盘的转换器
* 实现usb接口，在usb接口中重写解决方法调用键盘的需求方法
*/
//适配器
public class Adapter implements Target{
private Adaptee adaptee;
public Adapter() {
}
public Adapter(Adaptee adaptee) {
super();
this.adaptee = adaptee;
}
@Override
public void handle() {
adaptee.request();
}
}
2：代理模式(Proxy pattern): 通过代理，控制对对象的访问！（张学友代理人！除了唱歌外，啥都干！！）
核心代码（以动态代理为例）---------------------将统一的流程控制放到代理角色中处理！
/*
* 动态代理
*/
public class StarHandler implements InvocationHandler{
private Star star;
public StarHandler(Star star) {
super();
this.star = star;
}
//核心方法
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
method.invoke(star, args);
return null;
}
}
客户端调用
public class Client {
public static void main(String[] args) {
Star star = new RealStar();
StarHandler handler = new StarHandler(star);
Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Star.class}, handler);
proxy.confer();
proxy.contract();
proxy.book();
proxy.sing();
proxy.collect();
}
}
3：桥接模式(Bridge pattern): 将两个变化维度连接起来，使得各个维度都可以独立的变化（一座桥，连接两个村庄）
核心代码---------------------在一个维度中引用另一个维度，当做桥，连接两个维度
/*
* 品牌维度
*/
public interface Brand {
public abstract void sale();
}
/*
* 具体品牌
*/
class Lenovo implements Brand{
public void sale() {
System.out.println("销售联想笔记本");
}
}
class Apple implements Brand{
public void sale() {
System.out.println("销售苹果笔记本");
}
}
/*
* 电脑种类维度
*/
public class ComputerClass {
private Brand brand;
public ComputerClass(Brand brand) {
super();
this.brand = brand;
}
public void sale(){
brand.sale();
}
}
/*
* 具体电脑种类
*/
//台式机
class DeskTops extends ComputerClass{
public DeskTops(Brand brand) {
super(brand);
}
public void sale(){
super.sale();
System.out.println("销售台式机");
}
}
//笔记本
class LapTops extends ComputerClass{
public LapTops(Brand brand) {
super(brand);
}
public void sale(){
super.sale();
System.out.println("销售笔记本");
}
}
4：组合模式(Composite pattern): 把部分和整体的关系用树形结构来表示，从而使客户端可以使用同一的方式处理部分对象和整体对象
核心代码---------------------三个接口（抽象（Component），叶子（Leaf），容器（Composite））
/*
* 抽象组件
*/
public interface Component {
public abstract void operation();
}
/*
* 叶子组件
*/
interface Leaf extends Component{
}
/*
* 容器组件
*/
interface Composite extends Component{
//添加组件
public abstract void add(Component c);
//删除组件
public abstract void remove(Component c);
//返回组件
public abstract Component getChild(int index);
}
5：装饰器模式(Decorator pattern): 动态的为一个对象增加新的功能(刮腻子！！刮大白！！墙就具有了光滑特性)
核心代码---------------------抽象构件，具体构件角色，装饰器，具体装饰对象
/*
* 抽象构件 --军用战车
*/
public interface ICar {
public abstract void move();
}
/*
* 具体构件角色，即真实对象（ConcreteComponent）
*/
class Car implements ICar{
public void move() {
System.out.println("陆地作战!");
}
}
/*
* 装饰器
*/
class SuperCar implements ICar{
//持有具体构件引用
protected ICar car;
public SuperCar(ICar car) {
super();
this.car = car;
}
public void move() {
car.move();
}
}
/*
* 具体装饰对象1(ConcreteDecorator)
*/
class FlyCar extends SuperCar{
public FlyCar(ICar car) {
super(car);
}
//新增方法
public void fly(){
System.out.println("空中作战!");
}
public void move() {
car.move();
fly();
}
}
/*
* 具体装饰对象2(ConcreteDecorator)
*/
class WaterCar extends SuperCar{
public WaterCar(ICar car) {
super(car);
}
//新增方法
public void swim(){
System.out.println("水中作战!");
}
public void move() {
car.move();
swim();
}
}
6：外观模式(Facade pattern): 为子系统提供统一的入口，封装子系统的复杂性，便于客户端调用（酒店服务台买单！！）
核心代码---------------------提供一个门面
/*
* 门面，外观模式之代理人
*/
public class Register {
public void regist(){
//税务局登记
Tax tax = new XuzhouTax();
tax.sign();
//质检局检测
Check check = new XuzhouCheck();
check.check();
//银行开户
Bank bank = new PostBank();
bank.open();
}
}
7：亨元模式(Flyweight Pattern): 内存属于稀缺资源，不要随便浪费，如果有很多个完全相同或相似的对象，我们可以通过享元模式，节省内存（围棋中的黑白棋，没有必要定义几百个对象！！！）
核心代码---------------------抽象享元类，具体享元类，享元工厂类，外部状态类
/*
* 享元工厂类
*/
import java.util.HashMap;
public class ChessFlyWeightFactory {
private static HashMap<String, ChessFlyWeight> map = new HashMap<String, ChessFlyWeight>();
public static ChessFlyWeight getChess(String color){
if(map.get(color) != null){
return map.get(color);
}else {
ChessFlyWeight cf = new ConcreteChess(color);
map.put(color, cf) ;
return cf;
}
}
}
三：行为型模式（关注对象之间的相互交互，相互通信与相互协作）
1：责任链模式(Chain of responsibility pattern): 将能够处理同一类请求的对象连成一条链，所提交的请求沿着链传递，链上的对象逐个判断是否有能力处理该请求，如果能则处理，如果不能，则传递给下一个对象（多套if else 的完美替代！！！）
核心代码---------------------抽象责任人
/*
* 抽象领导类
*/
public abstract class AbstractLeader {
protected String name;
protected AbstractLeader nextLeader; //责任链上的后继对象
public AbstractLeader(String name) {
super();
this.name = name;
}
//设定责任链上的后继对象
public void setNextLeader(AbstractLeader nextLeader) {
this.nextLeader = nextLeader;
}
/*
* 抽象方法，处理请求
*/
public abstract void handleRequest(HomeRequest request);
}
2：迭代器模式(Iterator pattern): 提供一种方法顺序访问一个聚合对象中的各个元素, 而又不暴露其内部的表示（集合中Iterator！！）
核心代码---------------------迭代器接口，聚合类对象
/*
* 自定义聚合类
*/
public class ConcreteAggregate {
private List<Object> list = new ArrayList<Object>();
public void addObject(Object obj){
this.list.add(obj);
}
public void removeObject(Object obj){
this.list.remove(obj);
}
public List<Object> getList(){
return list;
}
public void setList(List<Object> list){
this.list = list;
}
//获得迭代器
public MyIterator creareIterator(){
return new ConcreterIterator();
}
/*
* 定义一个内部类，实现迭代器接口,内部类可以直接访问外部类成员变量
*/
private class ConcreterIterator implements MyIterator{
private int cursor; //定义游标用于记录遍历时的位置
@Override
public void first() {
cursor = 0;
}
@Override
public void next() {
if(cursor < list.size()){
cursor++;
}
}
@Override
public boolean hasNext() {
if(cursor < list.size()){
return true;
}
return false;
}
@Override
public boolean isFirst() {
return cursor == 0;
}
@Override
public boolean isLast() {
return cursor == list.size();
}
@Override
public Object getCurrentObj() {
return list.get(cursor);
}
}
}
3：中介者模式(Mediator pattern) : 解耦多个同事对象之间的交互关系（总经理协调各部门！！）
核心代码---------------------各部门抽象，中介者抽象
/*
* 各个部门抽象
*/
public interface Department {
void selfAction();//本部门事物
void outAction(); //向中介者发出申请
}
/*
* 中介者---总经理抽象
*/
public interface Mediator {
void register(String name,Department d);
void commond(String name);
}
4：命令模式(Command pattern): 将"请求"封闭成对象，以便使用不同的请求,队列或者日志来参数化其他对象， 命令模式也支持可撤销的操作
核心代码---------------------抽象命令类，具体命令类，调用者/请求者，接受者
/*
* 命令
*/
public interface Command {
void execute();
}
/*
* 具体命令实现类
*/
class ConcreteCommand implements Command{
//持有命令执行者的引用
private Receiver receiver;
public ConcreteCommand(Receiver receiver) {
super();
this.receiver = receiver;
}
public void execute() {
//执行前可以做一些处理
receiver.action();
//执行后也可以做一些处理
}
}
/*
* 调用者，发起者
*/
public class Invoke {
private Command command;
public Invoke(Command command) {
super();
this.command = command;
}
//业务方法，调用命令类的方法
public void call(){
//执行前可以做一些处理
command.execute();
//执行后也可以做一些处理
}
}
/*
* 真正的命令执行者
*/
public class Receiver {
public void action(){
System.out.println("命令已经被我执行!");
}
}
5：解释器模式(Interpreter pattern): 使用解释器模式为语言创建解释器
6：访问者模式(Strategy pattern): 我们使用了一个访问者类，它改变了元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变
7：策略模式(Strategy pattern): 分离算法，选择实现
核心代码---------------------策略交互类
/*
* 负责和具体策略交互---使得具体算法和客户端分离
*/
public class Context {
private Strategy strategy;
public Context(Strategy strategy) {
super();
this.strategy = strategy;
}
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
//调度方法
public void getPrice(double price){
System.out.println("您的价格为:" + strategy.getPrice(price) + "元!");
}
}
8：模板方法模式(Template method pattern): 处理步骤父类中定义好，具体实现延迟到子类中定义（方法回调！钩子方法！）
核心代码---------------------模块方法类
public abstract class BankTemplateMethod {
//具体方法
public void takeNumber(){
System.out.println("排队取号!");
}
//办理具体业务，钩子方法
public abstract void transact();
//具体方法
public void evaluate() {
System.out.println("反馈评分!");
}
//模板方法
public final void process(){
this.takeNumber();
this.transact();
this.evaluate();
}
}
9：状态模式(State pattern): 解决系统中复杂对象的状态转换以及不同状态下行为的封装问题（红灯停，绿灯行，黄灯亮了等一等！）
核心代码---------------------环境类
/*
* 环境类，表示当前房间状态,根据条件做状态切换
*/
public class HouseContext {
private State state;
public void setState(State state) {
this.state = state;
System.out.println("状态切换!");
state.handle();
}
}
10：观察者模式(Observer pattern): 在对象之间定义一对多的依赖，这样一来， 当一个对象改变状态，依赖它的对象都会收到通知, 并自动更新（广播机制！！）
核心代码---------------------主题类---加入，删除，通知观察者
/*
* 主题类---加入，删除，通知观察者
*/
import java.util.ArrayList;
public class Subject {
//定义一个集合存放，观察者对象
private ArrayList<Observer> list = new ArrayList<Observer>();
//注册新的观察者
public void registerObserver(Observer observer){
list.add(observer);
}
//删除观察者
public void removeObserver(Observer observer){
list.remove(observer);
}
//通知所有观察者,更新状态
public void notifyAllObserver(){
for (Observer observer : list) {
observer.update(this);
}
}
}
11：备忘录模式(Memento pattern): 保存某个对象内部状态的拷贝，这样以后就可以将该对象恢复到原先的状态（备忘录！）
核心代码---------------------源发器类、备忘录类、负责人类
/*
* 源发器类
*/
public class Employee {
private String name;
private int age;
private double salary;
//进行备忘操作,并返回备忘录对象
public EmployeeMemento memento(){
return new EmployeeMemento(this);
}
//进行数据恢复,恢复成制定备忘录对象的值
public void recovery(EmployeeMemento e){
this.name = e.getName();
this.age = e.getAge();
this.salary = e.getSalary();
}
public Employee(String name, int age, double salary) {
super();
this.name = name;
this.age = age;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
/*
* 备忘录类
*/
public class EmployeeMemento {
private String name;
private int age;
private double salary;
public EmployeeMemento(Employee e) {
this.name = e.getName();
this.age = e.getAge();
this.salary = e.getSalary();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
/*
* 负责人类,负责管理备忘录对象
*/
public class CareTaker {
private EmployeeMemento memento;
public EmployeeMemento getMemento() {
return memento;
}
public void setMemento(EmployeeMemento memento) {
this.memento = memento;
}
}