设计模式（Java）

---

单例模式

饿汉式

package singleton;

/**
 * 测试饿汉式单例模式
 */
public class SingletonDemo01 {
    // 类初始化时,立即加载这个对象(没有延时加载的优势).加载类时,天然的是线程安全的
    private static SingletonDemo01 instance = new SingletonDemo01();

    private SingletonDemo01(){

    }

    // 没有同步方法,调用效率高
    public static SingletonDemo01 getInstance(){
        return instance;
    }
}

懒汉式

package singleton;

/**
 * 测试懒汉式单例模式
 */
public class SingletonDemo02 {
    // 类初始化时,不初始化这个对象(延时加载,真正用的时候再创建)
    private static SingletonDemo02 instance;

    private SingletonDemo02(){  // 私有化构造器

    }

    // 方法同步,调用效率低
    public static synchronized SingletonDemo02 getInstance(){
        if (instance==null){
            instance = new SingletonDemo02();
        }
        return instance;
    }
}

package singleton;

/**
 * 测试静态内部类实现单例模式
 * 这种方式: 线程安全,调用效率高,并且实现了延时加载
 */
public class SingletonDemo03 {

    private static class SingletonClassInstance{
        private static final SingletonDemo03 instance = new SingletonDemo03();
    }

    private SingletonDemo03(){  // 私有化构造器
    }

    public static synchronized SingletonDemo03 getInstance(){
        return SingletonClassInstance.instance;
    }
}

package singleton;

/**
 * 测试枚举实现单例模式(没有延时加载)
 */
public enum  SingletonDemo04 {

    // 这个枚举元素本身就是单例
    INSTANCE;

    // 添加自己需要的操作
    public void singletonOperation(){
    }
}

测试

package singleton;

public class Client {

    public static void main(String[] args) {

        SingletonDemo01 s1 = SingletonDemo01.getInstance();
        SingletonDemo01 s2 = SingletonDemo01.getInstance();
        System.out.println(s1==s2);

        SingletonDemo02 s3 = SingletonDemo02.getInstance();
        SingletonDemo02 s4 = SingletonDemo02.getInstance();
        System.out.println(s3==s4);

        SingletonDemo03 s5 = SingletonDemo03.getInstance();
        SingletonDemo03 s6 = SingletonDemo03.getInstance();
        System.out.println(s5==s6);


        System.out.println(SingletonDemo04.INSTANCE==SingletonDemo04.INSTANCE);
    }
}

package singleton;

import java.io.ObjectStreamException;
import java.io.Serializable;

/**
 * 测试饿汉式单例模式(如何防止反射和反序列化漏洞)
 */
public class SingletonDemo06 implements Serializable {

    // 类初始化时,立即加载这个对象(没有延时加载的优势).加载类时,天然的是线程安全的
    private static SingletonDemo06 instance = new SingletonDemo06();

    private SingletonDemo06(){
        // 防止反射多次调用进行初始化
        if (instance!=null){
            throw new RuntimeException();
        }

    }

    // 反序列化时,如果定义了readResolve()则直接返回此方法指定的对象,而不需要再单独创建对象!
    private Object readResolve() throws ObjectStreamException{
        return instance;
    }

    // 没有同步方法,调用效率高
    public static SingletonDemo06 getInstance(){
        return instance;
    }
}

package singleton;

import java.io.*;
import java.lang.reflect.Constructor;

/**
 * 测试反射和反序列化破解单例模式
 */
public class Client2 {

    public static void main(String[] args) throws Exception{

        SingletonDemo06 s1 = SingletonDemo06.getInstance();
        SingletonDemo06 s2 = SingletonDemo06.getInstance();
        System.out.println(s1);
        System.out.println(s2);

        // 通过反射的方式直接调用私有构造器
        /*Class clz = Class.forName("singleton.SingletonDemo06");

        Constructor c = clz.getDeclaredConstructor();
        c.setAccessible(true);

        SingletonDemo06 s3 = (SingletonDemo06) c.newInstance();
        SingletonDemo06 s4 = (SingletonDemo06) c.newInstance();

        System.out.println(s3);
        System.out.println(s4);
        */
        // 通过反序列化的方式构造多个对象
        FileOutputStream fos = new FileOutputStream("./a.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(s1);
        oos.close();
        fos.close();

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(("./a.txt")));
        SingletonDemo06 s3 = (SingletonDemo06) ois.readObject();
        System.out.println(s3);
    }
}

package singleton;

import java.util.concurrent.CountDownLatch;

/**
 * 测试多线程环境下创建单例模式的效率
 */
public class Client3 {

    public static void main(String[] args) throws Exception{
        int threadNum = 10;
        final CountDownLatch countDownLatch = new CountDownLatch(threadNum);
        long start = System.currentTimeMillis();

        for (int i = 0; i < threadNum; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 100000; i++) {
                        Object o = SingletonDemo01.getInstance();
                    }
                    countDownLatch.countDown();
                }
            }).start();
        }

        countDownLatch.await();  // main线程阻塞, 直到计数器变为0,才会继续往下执行

        long end = System.currentTimeMillis();
        System.out.println("总耗时:" + (end-start));

    }
}

工厂模式

Car

package simplefactory;

public interface Car {
    void run();
}

Audi

package simplefactory;

public class Audi implements Car{

    @Override
    public void run() {
        System.out.println("奥迪在跑!!");
    }
}

Byd

package simplefactory;

public class Byd implements Car{

    @Override
    public void run() {
        System.out.println("比亚迪在跑!!");
    }
}

CarFactory

package simplefactory;

public class CarFactory {

    public static Car createCar(String type){
        if ("奥迪".equals(type)){
            return new Audi();
        }else if ("比亚迪".equals(type)){
            return new Byd();
        }else {
            return null;
        }
    }
}

CarFactory02

package simplefactory;

/**
 * 简单工厂类
 */
public class CarFactory02 {

    public static Car createAudi(){
        return new Audi();
    }

    public static Car createByd(){
        return new Byd();
    }
}

调用

package simplefactory;

/**
 * 简单工厂条件下
 */
public class Client02 {

    public static void main(String[] args) {

        Car c1 = CarFactory.createCar("奥迪");
        Car c2 = CarFactory.createCar("比亚迪");

        c1.run();
        c2.run();
    }
}

Engine

package factory.abstractFactory;

public interface Engine {
    void run();
    void start();
}

class LuxuryEngine implements Engine{

    @Override
    public void run() {
        System.out.println("转的快!");
    }

    @Override
    public void start() {
        System.out.println("启动快!可以自动启停!");
    }
}

class LowerEngine implements Engine{

    @Override
    public void run() {
        System.out.println("转的慢!");
    }

    @Override
    public void start() {
        System.out.println("启动慢!");
    }
}

Seat

package factory.abstractFactory;

public interface Seat {
    void massage();
}

class LuxurySeat implements Seat{

    @Override
    public void massage() {
        System.out.println("可以自动按摩!");
    }
}

class LowerSeat implements Seat{

    @Override
    public void massage() {
        System.out.println("不可以自动按摩!");
    }
}

Tyre

package factory.abstractFactory;

public interface Tyre {
    void revolve();
}

class LuxuryTyre implements Tyre{

    @Override
    public void revolve() {
        System.out.println("旋转不磨损!");
    }
}

class LowerTyre implements Tyre{

    @Override
    public void revolve() {
        System.out.println("旋转磨损快!");
    }
}

CarFactory

package factory.abstractFactory;

public interface CarFactory {
    Engine createEngine();
    Seat createSeat();
    Tyre createTyre();
}

LowerCarFactory

package factory.abstractFactory;

public class LowerCarFactory implements CarFactory {

    @Override
    public Engine createEngine() {
        return new LowerEngine();
    }

    @Override
    public Seat createSeat() {
        return new LowerSeat();
    }

    @Override
    public Tyre createTyre() {
        return new LowerTyre();
    }
}

LuxuryCarFactory

package factory.abstractFactory;

public class LuxuryCarFactory implements CarFactory {

    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }

    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }

    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }
}

Client

package factory.abstractFactory;

public class Client {

    public static void main(String[] args) {
        CarFactory factory = new LuxuryCarFactory();
        Engine e = factory.createEngine();
        e.run();
        e.start();
    }
}

建造者模式

AirShip

package builder;

public class AirShip {
    private OrbitalModule orbitalModule;
    private Engine engine;
    private EscapeTower escapeTower;

    public void lanuch(){
        System.out.println("发射");
    }

    public OrbitalModule getOrbitalModule() {
        return orbitalModule;
    }

    public void setOrbitalModule(OrbitalModule orbitalModule) {
        this.orbitalModule = orbitalModule;
    }

    public Engine getEngine() {
        return engine;
    }

    public void setEngine(Engine engine) {
        this.engine = engine;
    }

    public EscapeTower getEscapeTower() {
        return escapeTower;
    }

    public void setEscapeTower(EscapeTower escapeTower) {
        this.escapeTower = escapeTower;
    }
}

class OrbitalModule{
    private String name;

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

    public String getName() {
        return name;
    }

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

class Engine{
    private String name;

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

    public String getName() {
        return name;
    }

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

class EscapeTower{
    private String name;

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

    public String getName() {
        return name;
    }

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

AirshipBuilder

package builder;

public interface AirshipBuilder {
    Engine builderEngine();
    OrbitalModule builderOrbitalModule();
    EscapeTower builderEscapeTower();

}

AirShipDirector

package builder;

public interface AirShipDirector {

    AirShip direAirShip();
}

TestAirShipBuilder

package builder;

// StringBuilder,XML解析中--DomBuilder,SaxBuilder
public class TestAirShipBuilder implements AirshipBuilder{
    @Override
    public Engine builderEngine() {
        System.out.println("构造发动机");
        return new Engine("发动机");
    }

    @Override
    public OrbitalModule builderOrbitalModule() {
        System.out.println("构建轨道舱");
        return new OrbitalModule("轨道舱");
    }

    @Override
    public EscapeTower builderEscapeTower() {
        System.out.println("构建逃逸舱");
        return new EscapeTower("逃逸舱");
    }
}

TestAirShipDirector

package builder;

public class TestAirShipDirector implements AirShipDirector {
    private AirshipBuilder builder;

    public TestAirShipDirector(AirshipBuilder builder) {
        this.builder = builder;
    }

    @Override
    public AirShip direAirShip() {
        Engine e = builder.builderEngine();
        OrbitalModule o = builder.builderOrbitalModule();
        EscapeTower et = builder.builderEscapeTower();

        // 装配成飞船对象
        AirShip ship = new AirShip();
        ship.setEngine(e);
        ship.setEscapeTower(et);
        ship.setOrbitalModule(o);

        return ship;
    }
}

Client

package builder;

public class Client {

    public static void main(String[] args) {

        AirShipDirector director = new TestAirShipDirector(new TestAirShipBuilder());
        AirShip ship = director.direAirShip();

        System.out.println(ship.getEngine().getName());
        ship.lanuch();
    }
}

原型模式

package prototype;

import java.util.Date;

public class Sheep implements Cloneable{

    private String sname;
    private Date birthday;

    public Sheep(String sname, Date birthday) {
        this.sname = sname;
        this.birthday = birthday;
    }

    public Sheep() {
    }

    // 浅拷贝
//    @Override
//    protected Object clone() throws CloneNotSupportedException {
//        Object obj = super.clone();
//        return obj;
//    }

    // 深拷贝
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj = super.clone();

        // 深复制
        Sheep s = (Sheep)obj;
        s.birthday = (Date) this.birthday.clone();

        return obj;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
}

package prototype;
/**
 * 测试原型模型(浅拷贝/深拷贝)
 */

import java.util.Date;

public class Client {

    public static void main(String[] args) throws Exception {

        Date date = new Date();

        Sheep s1 = new Sheep("少利", date);
        Sheep s2 = (Sheep) s1.clone();

        System.out.println(s1);
        System.out.println(s1.getSname());

        date.setTime(123123123);
        System.out.println(s1.getBirthday());


        System.out.println(s2);
        s2.setSname("多利");
        System.out.println(s2.getSname());
        System.out.println(s2.getBirthday());
    }
}

浅拷贝

深拷贝


Sheep 要实现Serializable接口

package prototype;
/**
 * 测试原型模型(深复制，使用序列化和反序列化的方式实现深复制)
 */

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;

public class Client3 {

    public static void main(String[] args) throws Exception {

        Date date = new Date();

        Sheep s1 = new Sheep("少利", date);

//        Sheep s2 = (Sheep) s1.clone();

        // 使用序列化和反序列化的方式实现深复制
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(s1);
        byte[] bytes = bos.toByteArray();

        ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
        ObjectInputStream ois = new ObjectInputStream(bis);
        Sheep s2 = (Sheep)ois.readObject();

        System.out.println(s1);
        System.out.println(s1.getSname());

        date.setTime(123123123);
        System.out.println(s1.getBirthday());


        System.out.println(s2);
        s2.setSname("多利");
        System.out.println(s2.getSname());
        System.out.println(s2.getBirthday());
    }
}

---

适配器模式

Target

package adapter;

public interface Target {
    void hadleReq();
}

Adapatee

package adapter;

/**
 * 被适配的类
 */
public class Adapatee {

    public void request(){
        System.out.println("可以完成客户请求的需求功能!");
    }

}

Adapter

package adapter;

/**
 * 适配器(类适配器方式)
 */
public class Adapter extends Adapatee implements Target{


    @Override
    public void hadleReq() {
        super.request();
    }
}

Adapter2

package adapter;

/**
 * 适配器(对象适配器方式,使用了组合的方式跟被适配对象整合)
 */
public class Adapter2 implements Target{

    private Adapatee adapatee;


    public Adapter2(Adapatee adapatee) {
        this.adapatee = adapatee;
    }

    @Override
    public void hadleReq() {
        adapatee.request();
    }
}

Client

package adapter;

/**
 * 客户端类
 */
public class Client {

    public void test1(Target t){
        t.hadleReq();
    }

    public static void main(String[] args) {
        Client c = new Client();
        Adapatee a = new Adapatee();

//        Target t = new Adapter();
        Target t = new Adapter2(a);

        c.test1(t);
    }
}

代理模式

静态代理

Star

package staticProxy;

public interface Star {

    void confer();
    void signContract();
    void bookTicket();
    void sing();
    void collectMoney();
}

RealStar

package staticProxy;

public class RealStar implements Star{

    @Override
    public void confer() {
        System.out.println("RealStar.confer()");
    }

    @Override
    public void signContract() {
        System.out.println("RealStar.signContract()");
    }

    @Override
    public void bookTicket() {
        System.out.println("RealStar.bookTicket()");
    }

    @Override
    public void sing() {
        System.out.println("RealStar(本人).sing()");
    }

    @Override
    public void collectMoney() {
        System.out.println("RealStar.collectMoney()");
    }
}

ProxyStar

package staticProxy;

public class ProxyStar implements Star{

    private Star star;

    public ProxyStar(Star star) {
        this.star = star;
    }

    @Override
    public void confer() {
        System.out.println("ProxyStar.confer()");
    }

    @Override
    public void signContract() {
        System.out.println("ProxyStar.signContract()");
    }

    @Override
    public void bookTicket() {
        System.out.println("ProxyStar.bookTicket()");
    }

    @Override
    public void sing() {
        star.sing();
    }

    @Override
    public void collectMoney() {
        System.out.println("ProxyStar.collectMoney()");
    }
}

Client

package staticProxy;

public class Client {

    public static void main(String[] args) {
        Star real = new RealStar();
        Star proxy = new ProxyStar(real);

        proxy.confer();
        proxy.signContract();
        proxy.bookTicket();
        proxy.sing();

        proxy.collectMoney();
    }
}

动态代理

StarHandler

package proxy.dynamicProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class StarHandler implements InvocationHandler {
    Star realStar;

    public StarHandler(Star realStar) {
        this.realStar = realStar;
    }

    @Override
    public Object invoke(Object o, Method method, Object[] args) throws Throwable {

        Object obj = null;

        System.out.println("真正的方法执行前");
        System.out.println("面谈，签合同，转付款...");
        if (method.getName().equals("sing")){

            obj = method.invoke(realStar, args);
        }

        System.out.println("真正的方法执行后!");
        System.out.println("收尾款");

        return obj;
    }
}

Client

package proxy.dynamicProxy;

import java.lang.reflect.Proxy;

public class Client {

    public static void main(String[] args) {
        Star realStar = new RealStar();

        StarHandler handler = new StarHandler(realStar);

        Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Star.class}, handler);

        proxy.sing();
    }
}

桥接模式

Brand

package bridge;

/**
 * 品牌
 */
public interface Brand {
    void sale();
}


class Lenovo implements Brand{

    @Override
    public void sale() {
        System.out.println("销售联想电脑");
    }
}

class Dell implements Brand{

    @Override
    public void sale() {
        System.out.println("销售戴尔电脑");
    }
}

class Shenzhou implements Brand{

    @Override
    public void sale() {
        System.out.println("销售神州电脑");
    }
}

Computer

package bridge;

/**
 * 电脑类型
 */
public class Computer {
    protected Brand brand;

    public Computer(Brand brand){
        this.brand = brand;
    }

    public void sale(){
        brand.sale();
    }
}

class Desktop extends Computer{

    public Desktop(Brand brand) {
        super(brand);
    }

    @Override
    public void sale() {
        super.sale();
        System.out.println("销售台式机");
    }
}

class Laptop extends Computer{

    public Laptop(Brand brand) {
        super(brand);
    }

    @Override
    public void sale() {
        super.sale();
        System.out.println("销售笔记本");
    }
}

Client

package bridge;

public class Client {

    public static void main(String[] args) {
        // 销售联想笔记本
        Computer c = new Laptop(new Lenovo());
        c.sale();

        // 销售神州台式机
        Computer c2 = new Desktop(new Shenzhou());
        c2.sale();
    }
}

组合模式

AbstractFile

package composite;

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

// 抽象构建
public interface AbstractFile {
    void killVirus();  // 杀毒
}

class ImageFile implements AbstractFile{
    private String name;

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

    @Override
    public void killVirus() {
        System.out.println("--图像文件:"+name+",进行查杀");
    }
}

class TextFile implements AbstractFile{
    private String name;

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

    @Override
    public void killVirus() {
        System.out.println("--文本文件:"+name+",进行查杀");
    }
}

class VideoFile implements AbstractFile{
    private String name;

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

    @Override
    public void killVirus() {
        System.out.println("--视频文件:"+name+",进行查杀");
    }
}

class Folder implements AbstractFile{
    private String name;
    // 定义容器,用来存放容器构建下的子节点
    private List<AbstractFile> list = new ArrayList<>();

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

    public void add(AbstractFile file){
        list.add(file);
    }

    public void remove(AbstractFile file){
        list.remove(file);
    }

    public AbstractFile getChild(int index){
        return list.get(index);
    }

    @Override
    public void killVirus() {
        System.out.println("--文件夹:"+name+",进行查杀");

        for (AbstractFile file: list) {
            file.killVirus();
        }
    }
}

Client

package composite;

public class Client {

    public static void main(String[] args) {
        AbstractFile f2,f3,f4,f5,f6;

        Folder f1;
        f1 = new Folder("我的收藏");
        f2 = new ImageFile("图片123.jpg");
        f3 = new TextFile("Hello.txt");


        f1.add(f2);
        f1.add(f3);

        Folder f11 = new Folder("电影");
        f4 = new VideoFile("1.mp4");
        f5 = new VideoFile("2.mp4");
        f11.add(f4);
        f11.add(f5);

        f1.add(f11);

        f1.killVirus();
    }
}

装饰模式

ICar

package decorator;

/**
 * 抽象构建
 */
public interface ICar {
    void move();
}

// 具体构建对象(真实对象)
class Car implements ICar{

    @Override
    public void move() {
        System.out.println("陆地上跑");
    }
}

class SuperCar implements ICar{
    private ICar car;

    public SuperCar(ICar car) {
        this.car = car;
    }

    @Override
    public void move() {
        car.move();
    }
}

// 具体装饰对象
class FlyCar extends SuperCar{


    public FlyCar(ICar car) {
        super(car);
    }

    public void fly(){
        System.out.println("天上飞!");
    }

    @Override
    public void move() {
        super.move();
        fly();
    }
}

// 具体装饰对象
class WaterCar extends SuperCar{


    public WaterCar(ICar car) {
        super(car);
    }

    public void swim(){
        System.out.println("水上游!");
    }

    @Override
    public void move() {
        super.move();
        swim();
    }
}

// 具体装饰对象
class AICar extends SuperCar{


    public AICar(ICar car) {
        super(car);
    }

    public void autoMove(){
        System.out.println("自动驾驶!");
    }

    @Override
    public void move() {
        super.move();
        autoMove();
    }
}

Client

package decorator;

public class Client {

    public static void main(String[] args) {

        Car car = new Car();
        car.move();

        System.out.println("------加功能--------");
        FlyCar flyCar = new FlyCar(car);
        flyCar.move();

        System.out.println("-----------");
        WaterCar waterCar = new WaterCar(flyCar);
        waterCar.move();
    }
}

外观模式

享元模式

ChessFlyWeight

package flyweight;

/**
 * 享元类
 */
public interface ChessFlyWeight {
    void setColor(String c);
    String getColor();
    void display(Corrdinate c);
}

class ConcreteChess implements ChessFlyWeight{

    private String color;

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

    @Override
    public void setColor(String c) {
        this.color = c;
    }

    @Override
    public String getColor() {
        return color;
    }

    @Override
    public void display(Corrdinate c) {
        System.out.println("棋子颜色:"+color);
        System.out.println("棋子位置:"+c.getX()+"------"+c.getY());

    }
}

Corrdinate

package flyweight;

/**
 * 外部状态UnSharedConcreteFlyWeight
 */
public class Corrdinate {
    private int x,y;

    public int getX() {
        return x;
    }

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

    public int getY() {
        return y;
    }

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

    public Corrdinate(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

ChessFlyWeightFactory

package flyweight;

import java.util.HashMap;
import java.util.Map;

public class ChessFlyWeightFactory {

    // 享元池
    private static Map<String, ChessFlyWeight> map = new HashMap<>();

    public static ChessFlyWeight getChess(String color){
        if (map.get(color)!=null){
            return map.get(color);
        }else {
            ChessFlyWeight cfw = new ConcreteChess(color);
            map.put(color,cfw);
            return cfw;
        }
    }
}

Client

package flyweight;

public class Client {

    public static void main(String[] args) {

        ChessFlyWeight chess1 = ChessFlyWeightFactory.getChess("黑色");
        ChessFlyWeight chess2 = ChessFlyWeightFactory.getChess("黑色");

        System.out.println(chess1);
        System.out.println(chess2);

        chess1.display(new Corrdinate(10, 10));
        chess2.display(new Corrdinate(20, 20));

    }
}

责任链模式

LeaveRequest

package chainOfResp;

/**
 * 封装请假的基本信息
 */
public class LeaveRequest {
    private String empName;
    private int leaveDays;
    private String reason;

    public LeaveRequest(String empName, int leaveDays, String reason) {
        this.empName = empName;
        this.leaveDays = leaveDays;
        this.reason = reason;
    }

    public String getEmpName() {
        return empName;
    }

    public void setEmpName(String empName) {
        this.empName = empName;
    }

    public int getLeaveDays() {
        return leaveDays;
    }

    public void setLeaveDays(int leaveDays) {
        this.leaveDays = leaveDays;
    }

    public String getReason() {
        return reason;
    }

    public void setReason(String reason) {
        this.reason = reason;
    }
}

Leader

package chainOfResp;

public abstract class Leader {
    protected String name;
    protected Leader nextLeader;

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

    // 设置后继对象
    public void setNextLeader(Leader nextLeader) {
        this.nextLeader = nextLeader;
    }

    /**
     * 处理请求的核心业务的方法
     * @param request
     */
    public abstract void handleRequest(LeaveRequest request);
}

Director

package chainOfResp;

public class Director extends Leader {

    public Director(String name){
        super(name);
    }

    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getLeaveDays()<3){
            System.out.println("员工:"+request.getEmpName()+" 天数:"+request.getLeaveDays()+" 理由:"+request.getReason());
            System.out.println("主任:"+this.name+",审批通过!");
        }else {
            if (this.nextLeader!=null){
                this.nextLeader.handleRequest(request);
            }
        }
    }
}

Manager

package chainOfResp;

public class Manager extends Leader {

    public Manager(String name){
        super(name);
    }

    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getLeaveDays()<10){
            System.out.println("员工:"+request.getEmpName()+" 天数:"+request.getLeaveDays()+" 理由:"+request.getReason());
            System.out.println("经理:"+this.name+",审批通过!");
        }else {
            if (this.nextLeader!=null){
                this.nextLeader.handleRequest(request);
            }
        }
    }
}

GeneraManager

package chainOfResp;

public class GeneraManager extends Leader {

    public GeneraManager(String name){
        super(name);
    }

    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getLeaveDays()<30){
            System.out.println("员工:"+request.getEmpName()+" 天数:"+request.getLeaveDays()+" 理由:"+request.getReason());
            System.out.println("总经理:"+this.name+",审批通过!");
        }else {
            System.out.println("莫非"+request.getEmpName()+"想辞职,居然请假"+request.getLeaveDays()+"天");
        }
    }
}

Client

package chainOfResp;

public class Client {

    public static void main(String[] args) {
        Leader a = new Director("张三");
        Leader b = new Manager("李四");
        Leader c = new GeneraManager("王五");

        // 组织责任链对象的关系
        a.setNextLeader(b);
        b.setNextLeader(c);

        // 开始请假操作
        LeaveRequest req1 = new LeaveRequest("TOM",1,"回家探亲");
        a.handleRequest(req1);
    }
}

迭代器模式

MyIterator

package iterator;

/**
 * 迭代器接口
 */
public interface MyIterator {
    void first();
    void next();
    boolean hasNext();

    boolean isFirst();
    boolean isLast();

    Object getCurrentObj();
}

ConcreteMyAggregate

package iterator;

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

/**
 * 自定义的集合类
 */
public class ConcreteMyAggregate {
    private List<Object> list = new ArrayList<>();

    public void addObject(Object obj){
        this.list.add(obj);
    }

    public void removeObject(Object obj){
        this.list.remove(obj);
    }

    // 获得迭代器
    public MyIterator createIterator(){
        return new ConcreteIterator();
    }


    // 使用内部类定义迭代器,可以直接使用外部类的属性
    private class ConcreteIterator 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()-1;
        }

        @Override
        public Object getCurrentObj() {
            return list.get(cursor);
        }
    }
}

中介模式

Mediator

package mediator;

public interface Mediator {

    void regesiter(String dname, Depaterment d);
    void command(String name);
}

President

package mediator;

import java.util.HashMap;
import java.util.Map;

public class President implements Mediator {

    private Map<String, Depaterment> map = new HashMap<>();

    @Override
    public void regesiter(String dname, Depaterment d) {
        map.put(dname, d);
    }

    @Override
    public void command(String dname) {
        map.get(dname).selfAction();
    }
}

Depaterment

package mediator;

public interface Depaterment {

    void selfAction();
    void outAction();
}

Development

package mediator;

public class Development implements Depaterment {

    public Development(Mediator m) {
        this.m = m;
        m.regesiter("development", this);
    }

    private Mediator m;  // 中介者的引用

    @Override
    public void selfAction() {
        System.out.println("专心科研,开发项目!");
    }

    @Override
    public void outAction() {
        System.out.println("汇报工作!无钱,需支持!");
    }
}

Finacial

package mediator;

public class Finacial implements Depaterment {

    public Finacial(Mediator m) {
        this.m = m;
        m.regesiter("finacial", this);
    }

    private Mediator m;  // 中介者的引用

    @Override
    public void selfAction() {
        System.out.println("数钱!");
    }

    @Override
    public void outAction() {
        System.out.println("汇报工作!钱多,数不过来!");
    }
}

Market

package mediator;

public class Market implements Depaterment {

    public Market(Mediator m) {
        this.m = m;
        m.regesiter("market", this);
    }

    private Mediator m;  // 中介者的引用

    @Override
    public void selfAction() {
        System.out.println("跑去接项目!");
    }

    @Override
    public void outAction() {
        System.out.println("汇报工作!项目进度,需钱支持!");
        m.command("finacial");
    }
}

Client

package mediator;

public class Client {

    public static void main(String[] args) {
        Mediator m = new President();

        Market market = new Market(m);
        Development devp = new Development(m);
        Finacial f = new Finacial(m);

        market.selfAction();
        market.outAction();
    }
}

命令模式

解释器模式

访问者模式

策略模式

Strategy

package strategy;

public interface Strategy {
    public double getPrice(double standardPrice);
}

NewCustomFewStrategy

package strategy;

public class NewCustomFewStrategy implements Strategy{

    @Override
    public double getPrice(double standardPrice) {
        System.out.println("不打折,原价!");
        return standardPrice;
    }
}

OldCustomFewStrategy

package strategy;

public class OldCustomFewStrategy implements Strategy{

    @Override
    public double getPrice(double standardPrice) {
        System.out.println("打85折");
        return standardPrice * 0.85;
    }
}

OldCustomManyStrategy

package strategy;

public class OldCustomManyStrategy implements Strategy{

    @Override
    public double getPrice(double standardPrice) {
        System.out.println("打8折");
        return standardPrice * 0.8;
    }
}

Context

package strategy;

/**
 * 负责和具体的策略类交互
 * 这样的话,具体的算法和直接的客户端调用分离了,使得算法可以独立于客户端变化
 * 如果使用Spring的依赖注入功能,还可以通过配置文件,动态注入不同的策略对象,动态的切换算法
 */
public class Context {
    private Strategy strategy;

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

    public Strategy getStrategy() {
        return strategy;
    }

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void printPrice(double s){
        System.out.println("您该报价: "+strategy.getPrice(s));
    }
}

Client

package strategy;

public class Client {

    public static void main(String[] args) {
        Strategy s1 = new OldCustomManyStrategy();
        Context ctx = new Context(s1);

        ctx.printPrice(998);
    }
}

模板方法模式

transact()是抽象方法,需要在子类实现,可以进行不同的实现办理不同的业务

状态模式

观察者模式

Observer

package observer;

public interface Observer {
    void update(Subject subject);
}

ObserverA

package observer;

public class ObserverA implements Observer {

    private int myState;   // myState需要跟目标对象的state值保持一致!

    @Override
    public void update(Subject subject) {
        myState = ((ConcreteSubject)subject).getState();
    }

    public int getMyState() {
        return myState;
    }

    public void setMyState(int myState) {
        this.myState = myState;
    }
}

Subject

package observer;

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

public class Subject {

    protected List<Observer> list = new ArrayList<>();

    public void registerObserver(Observer obs){
        list.add(obs);
    }

    public void removeObserver(Observer obs){
        list.remove(obs);
    }

    // 通知所有的观察者更新状态
    public void notifyAllObserver(){
        for (Observer obs: list) {
            obs.update(this);
        }
    }
}

ConcreteSubject

package observer;

public class ConcreteSubject extends Subject {

    private int state;

    public int getState(){
        return state;
    }

    public void setState(int state){
        this.state = state;
        // 主题对象(目标对象)值发生了变化,请通知所有的观察者
        this.notifyAllObserver();
    }

}

Client

package observer;

public class Client {

    public static void main(String[] args) {

        // 目标对象
        ConcreteSubject subject = new ConcreteSubject();

        // 创建多个观察者
        ObserverA obs1 = new ObserverA();
        ObserverA obs2 = new ObserverA();
        ObserverA obs3 = new ObserverA();

        // 让这三个观察者添加到subject对象的观察者队伍中
        subject.registerObserver(obs1);
        subject.registerObserver(obs2);
        subject.registerObserver(obs3);

        // 改变状态态
        subject.setState(3000);

        System.out.println(obs1.getMyState());
        System.out.println(obs2.getMyState());
        System.out.println(obs3.getMyState());
    }
}

ConcreteSubject

package observer2;

import java.util.Observable;

public class ConcreteSubject extends Observable {

    private int state;

    public void set(int s){
        state = s;

        setChanged(); // 表示目标对象已经做了更改
        notifyObservers(state);  // 通知所有观察者
    }

    public int getState() {
        return state;
    }

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

ObserverA

package observer2;


import java.util.Observable;
import java.util.Observer;

public class ObserverA implements Observer {
    private int myState;


    @Override
    public void update(Observable o, Object arg) {
        myState = ((ConcreteSubject)o).getState();
    }

    public int getMyState() {
        return myState;
    }

    public void setMyState(int myState) {
        this.myState = myState;
    }
}

Client

package observer2;

public class Client {

    public static void main(String[] args) {

        // 创建目标对象Obserable
        ConcreteSubject subject = new ConcreteSubject();

        // 创建观察者
        ObserverA obs1 = new ObserverA();
        ObserverA obs2 = new ObserverA();
        ObserverA obs3 = new ObserverA();

        // 添加到容器中
        subject.addObserver(obs1);
        subject.addObserver(obs2);
        subject.addObserver(obs3);

        // 改变状态
        subject.set(3000);

        System.out.println(obs1.getMyState());
        System.out.println(obs2.getMyState());
        System.out.println(obs3.getMyState());
    }
}

备忘录模式

Emp

package memento;

/**
 * 源发器类
 */
public class Emp {

    private String ename;
    private int age;
    private double salary;

    public Emp(String ename, int age, double salary) {
        this.ename = ename;
        this.age = age;
        this.salary = salary;
    }

    // 进行备忘录操作,并返回备忘录对象
    public EmpMemento memento(){
        return new EmpMemento(this);
    }

    // 进行数据恢复,恢复为指定备忘录对象的值
    public void recovery(EmpMemento mmt){
        this.ename = mmt.getEname();
        this.age = mmt.getAge();
        this.salary = mmt.getSalary();
    }

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

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

EmpMemento

package memento;

/**
 * 备忘录类
 */
public class EmpMemento {

    private String ename;
    private int age;
    private double salary;

    public EmpMemento(Emp e){
        this.ename = e.getEname();
        this.age = e.getAge();
        this.salary = e.getSalary();
    }

    public String getEname() {
        return ename;
    }


    public int getAge() {
        return age;
    }

    public double getSalary() {
        return salary;
    }
}

CareTaker

package memento;

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

/**
 * 负责人类
 * 负责管理备忘录对象
 */
public class CareTaker {

    private EmpMemento memento;
//    private List<EmpMemento> list = new ArrayList<>();

    public EmpMemento getMemento() {
        return memento;
    }

    public void setMemento(EmpMemento memento) {
        this.memento = memento;
    }
}

Client

package memento;

public class Client {

    public static void main(String[] args) {

        CareTaker taker = new CareTaker();

        Emp emp = new Emp("wxb", 18, 30000);

        System.out.println("第一次打印对象: "+ emp.getEname()+"----"+emp.getAge()+"--"+emp.getSalary());

        taker.setMemento(emp.memento());  // 备忘一次

        emp.setAge(20);
        emp.setEname("xiaoli");
        emp.setSalary(500000);

        System.out.println("第二次打印对象: "+ emp.getEname()+"----"+emp.getAge()+"--"+emp.getSalary());

        emp.recovery(taker.getMemento());  // 恢复到备忘录对象保存的状态

        System.out.println("第三次打印对象: "+ emp.getEname()+"----"+emp.getAge()+"--"+emp.getSalary());
    }
}