Java 23种设计模式

public class Data {
    public static void main(String[] args) {
        CloneComply cloneComply = new CloneComply();
        CloneComply cloneComply2 = cloneComply.clone();
    }
}
/**Cloneable实现类
 */
class CloneComply implements Cloneable {
    public CloneComply(){
        System.out.println("我来了......");
    }
    public void setName(String name) {
        this.setName(name);
    }

    public String getName() {
        return this.getName();
    }

    @Override
    protected CloneComply clone(){
        CloneComply cloneComply = null;
        try {
            cloneComply = (CloneComply) super.clone();
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
        return cloneComply;
    }
}

public class Test{
    public static void main(String[] args) {
        CloneComply cloneComply = new CloneComply();
        cloneComply.setName("我来了......");
        System.out.println(cloneComply.getName());

        CloneComply cloneComply2 = cloneComply.clone();
        System.out.println(cloneComply2.getName());
    }
}
/**产品类Product
 */
class Product{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
/**Cloneable实现类
 */
class CloneComply implements Cloneable {
    private Product product = new Product();

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

    public String getName() {
        return this.product.getName();
    }

    @Override
    protected CloneComply clone(){
        CloneComply cloneComply = null;
        try {
            cloneComply = (CloneComply) super.clone();
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
        return cloneComply;
    }
}

public class Data {
    public static void main(String[] args) {
        CloneComply cloneComply = new CloneComply();
        cloneComply.setName("我来了......");
        System.out.println(cloneComply.getName());

        CloneComply cloneComply2 = cloneComply.clone();
        System.out.println(cloneComply2.getName());
    }
}
/**产品类Product
 */
class Product{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
/**Cloneable实现类
 */
class CloneComply implements Cloneable {
    private Product product = new Product();

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

    public String getName() {
        return this.product.getName();
    }

    @Override
    protected CloneComply clone(){
        CloneComply cloneComply = null;
        try {
            cloneComply = (CloneComply) super.clone();
            cloneComply.product = new Product();
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
        return cloneComply;
    }
}

public class Test{
    public static void main(String[] args) {
        // 使用普通功能类
        Target concreteTarget = new ConcreteTarget();// 实例化一个普通类
        concreteTarget.request();

        // 使用特殊功能类，即适配类
        Target adapter = new Adapter();
        adapter.request();
    }
}
// 已存在的、具有特殊功能、但不符合我们既有的标准接口的类
class Adaptee {
    public void specificRequest() {
        System.out.println("被适配类 具有特殊功能...");
    }
}
// 目标接口，或称为标准接口
interface Target {
    public void request();
}
// 具体目标类，只提供普通功能
class ConcreteTarget implements Target {
    public void request() {
        System.out.println("普通类 具有普通功能...");
    }
}
// 适配器类，继承了被适配类，同时实现标准接口
class Adapter extends Adaptee implements Target {
    public void request() {
        super.specificRequest();
    }
}

public class Test{
    public static void main(String[] args) {
        // 使用普通功能类
        Target concreteTarget = new ConcreteTarget();
        concreteTarget.request();

        // 使用特殊功能类，即适配类，
        // 需要先创建一个被适配类的对象作为参数
        Target adapter = new Adapter(new Adaptee());
        adapter.request();
    }
}
// 已存在的、具有特殊功能、但不符合我们既有的标准接口的类
class Adaptee {
    public void specificRequest() {
        System.out.println("被适配类 具有特殊功能...");
    }
}
// 目标接口，或称为标准接口
interface Target {
    public void request();
}
// 具体目标类，只提供普通功能
class ConcreteTarget implements Target {
    public void request() {
        System.out.println("普通类 具有普通功能...");
    }
}
// 适配器类，直接关联被适配类，同时实现标准接口
class Adapter implements Target {
    // 直接关联被适配类
    private Adaptee adaptee;

    // 可以通过构造函数传入具体需要适配的被适配类对象
    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    public void request() {
        // 这里是使用委托的方式完成特殊功能
        this.adaptee.specificRequest();
    }
}

public class Test{
    public static void main(String[] args) {
        // 大杯咖啡：原味
        new LargeCoffee(new PlainFlavor()).makeCoffee();
        // 大杯咖啡：加糖
        new LargeCoffee(new SugarFlavor()).makeCoffee();
        // 小杯咖啡：原味
        new SmallCoffee(new PlainFlavor()).makeCoffee();
        // 小杯咖啡：加糖
        new SmallCoffee(new SugarFlavor()).makeCoffee();
    }
}
// Implementor:有无糖
interface ICoffeeFlavor {
    String addWhat();
}
// ConcreteImplementor：原味
class PlainFlavor implements ICoffeeFlavor {
    @Override
    public String addWhat() {
        return "原味";
    }
}
// ConcreteImplementor：加糖
class SugarFlavor implements ICoffeeFlavor {
    @Override
    public String addWhat() {
        return "加糖";
    }
}
// Abstraction：咖啡
abstract class Coffee {
    protected ICoffeeFlavor mFlavor;

    public Coffee(ICoffeeFlavor flavor) {
        this.mFlavor = flavor;
    }

    public abstract void makeCoffee();
}
// RefinedAbstraction：大杯咖啡
class LargeCoffee extends Coffee {
    public LargeCoffee(ICoffeeFlavor flavor) {
        super(flavor);
    }

    @Override
    public void makeCoffee() {
        System.out.println("大杯咖啡: " + this.mFlavor.addWhat());
    }
}
// RefinedAbstraction：小杯咖啡
class SmallCoffee extends Coffee {
    public SmallCoffee(ICoffeeFlavor flavor) {
        super(flavor);
    }

    @Override
    public void makeCoffee() {
        System.out.println("小杯咖啡：" + this.mFlavor.addWhat());
    }
}

public class Test{
    public static void main(String[] args) {
        // 创建根节点
        Component root = new Composite("root");
        // 创建树枝节点
        Component branchA = new Composite("---branchA");
        Component branchB = new Composite("------branchB");
        // 创建叶子节点
        Component leafA = new Leaf("------leafA");
        Component leafB = new Leaf("---------leafB");
        Component leafC = new Leaf("---leafC");

        root.addChild(branchA);
        root.addChild(leafC);
        branchA.addChild(leafA);
        branchA.addChild(branchB);
        branchB.addChild(leafB);

        String result = root.operation();
        System.out.println(result);
    }
}
// 抽象根节点
abstract class Component {
    protected String name;

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

    public abstract String operation();

    public boolean addChild(Component component) {
        throw new UnsupportedOperationException("addChild not supported!");
    }

    public boolean removeChild(Component component) {
        throw new UnsupportedOperationException("removeChild not supported!");
    }

    public Component getChild(int index) {
        throw new UnsupportedOperationException("getChild not supported!");
    }
}
// 树节点
class Composite extends Component {
    private List<Component> mComponents;

    public Composite(String name) {
        super(name);
        this.mComponents = new ArrayList<>();
    }

    @Override
    public String operation() {
        StringBuilder builder = new StringBuilder(this.name);
        for (Component component : this.mComponents) {
            builder.append("\n");
            builder.append(component.operation());
        }
        return builder.toString();
    }

    @Override
    public boolean addChild(Component component) {
        return this.mComponents.add(component);
    }

    @Override
    public boolean removeChild(Component component) {
        return this.mComponents.remove(component);
    }

    @Override
    public Component getChild(int index) {
        return this.mComponents.get(index);
    }
}
// 叶子节点
class Leaf extends Component {

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

    @Override
    public String operation() {
        return this.name;
    }
}

public class Test{
    public static void main(String[] args) {
        IPerson person = new Man();
        person.dress();

        System.out.println("----------------------");
        System.out.println("增加裤子适配器");
        person = new TrousersDecorator(person);
        person.dress();
    }
}
// 抽象组件（Component）
interface IPerson {
    void dress();
}
// 具体组件（ConcreteComponent）,即被修饰者
class Man implements IPerson {

    @Override
    public void dress() {
        System.out.println("穿了内裤!");
    }
}
// 抽象适配器（Decorator）,接收一个具体的Component，本身也是一个Component
abstract class ClothesDecorator implements IPerson {
    protected IPerson mPerson;

    // 构造方法强制子类构造必须传入一个IPerson
    public ClothesDecorator(IPerson person) {
        this.mPerson = person;
    }

    @Override
    public void dress() {
        this.mPerson.dress();
    }
}
// 具体装饰器（ConcreteDecorator）：裤子装饰器
class TrousersDecorator extends ClothesDecorator {

    public TrousersDecorator(IPerson person) {
        super(person);
    }

    @Override
    public void dress() {
        super.dress();
        this.dressTrousers();
    }

    private void dressTrousers() {
        System.out.println("穿上裤子了!");
    }
}

public class Test{
    public static void main(String[] args) {
        IPerson person = new TrousersDecorator(new Man());
        person.dress();
    }
}
// 抽象组件（Component）
interface IPerson {
    void dress();
}
// 具体组件（ConcreteComponent）,即被修饰者
class Man implements IPerson {

    @Override
    public void dress() {
        System.out.println("穿了内裤!");
    }
}
// 抽象适配器（Decorator）,接收一个具体的Component，本身也是一个Component
abstract class ClothesDecorator implements IPerson {
    protected IPerson mPerson;

    // 构造方法强制子类构造必须传入一个IPerson
    public ClothesDecorator(IPerson person) {
        this.mPerson = person;
    }

    @Override
    public void dress() {
        this.mPerson.dress();
    }
}
// 具体装饰器（ConcreteDecorator）：裤子装饰器
class TrousersDecorator extends ClothesDecorator {

    public TrousersDecorator(IPerson person) {
        super(person);
    }

    @Override
    public void dress() {
        super.dress();
        this.dressTrousers();
    }

    private void dressTrousers() {
        System.out.println("穿上裤子了!");
    }
}

public class Test{
    public static void main(String[] args) {
        MobilePhone s10 = new MobilePhone();
        s10.deil();
        s10.takePicture();
    }
}
/**
 * 外观类
 */
class MobilePhone {
    private Phone mPhone = new phoneImpl();
    private Camera mCamera = new CameraImpl();

    public void deil() {
        mPhone.dail();
    }

    public void close() {
        mPhone.hangup();
    }

    public void takePicture() {
        mCamera.takePicture();
    }
}
/**
 * 电话抽象接口
 */
interface Phone {
    // 打电话
    void dail();

    // 挂电话
    void hangup();
}
/**相机抽象接口
 */
interface Camera {
    // 拍照片
    void takePicture();
}
/**电话实现类
 */
class phoneImpl implements Phone {

    @Override
    public void dail() {
        System.out.println("打电话");
    }

    @Override
    public void hangup() {
        System.out.println("挂电话");
    }
}
/**相机实现类
 */
class CameraImpl implements Camera {

    @Override
    public void takePicture() {
        System.out.println("拍照片");
    }
}

public class Test{
    public static void main(String[] args) {
        for (int i = 0; i < 4; i++) {
            String key = "test" + i;
            FlyweightFactory.getFlyweight(key);
        }
        Flyweight flyweight = FlyweightFactory.getFlyweight("test0");
        flyweight.operate();
    }
}
/**抽象享元角色
 */
abstract class Flyweight {
    private String intrinsic;
    // 外部状态
    protected final String Extrinsic;

    // 要求享元角色必须接受外部状态
    public Flyweight(String extrinsic) {
        Extrinsic = extrinsic;
    }

    // 定义业务操作
    public abstract void operate();

    // 内部状态的getter/setter
    public String getIntrinsic() {
        return intrinsic;
    }

    public void setIntrinsic(String intrinsic) {
        this.intrinsic = intrinsic;
    }
}
/**具体享元角色A
 */
class ConcreteFlyweightA extends Flyweight {
    // 接受外部状态
    public ConcreteFlyweightA(String extrinsic) {
        super(extrinsic);
    }

    // 根据外部状态进行逻辑处理
    @Override
    public void operate() {
        System.out.println("ConcreteFlyweightA");
    }
}
/**具体享元角色B
 */
class ConcreteFlyweightB extends Flyweight {
    // 接受外部状态
    public ConcreteFlyweightB(String extrinsic) {
        super(extrinsic);
    }

    // 根据外部状态进行逻辑处理
    @Override
    public void operate() {
        System.out.println("ConcreteFlyweightB");
    }
}
/**享元工厂
 */
class FlyweightFactory {
    // 定义一个池容器
    private static Map<String, Flyweight> pool = new HashMap<String, Flyweight>();

    public static Flyweight getFlyweight(String Extrinsic) {
        // 需要返回的对象
        Flyweight flyweight = null;

        // 在池中没有该对象
        if (pool.containsKey(Extrinsic)) {
            flyweight = pool.get(Extrinsic);
        } else {
            // 根据外部状态创建享元对象
            flyweight = new ConcreteFlyweightA(Extrinsic);
            // 放置到池中
            pool.put(Extrinsic, flyweight);
        }
        return flyweight;
    }
}

public class Test{
    public static void main(String[] args) {
        Proxy proxy = new Proxy();
        proxy.request();
    }
}
/**抽象接口
 */
interface Subject {
    void request();
}
/**抽象接口实现类
 */
class RealSubject implements Subject{
    @Override
    public void request() {
        System.out.println("真实请求");
    }
}
/**代理实现类
 */
class Proxy implements Subject{

    private RealSubject realSubject;

    @Override
    public void request() {
        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        realSubject.request();
        System.out.println("代理请求");
    }
}

public class Test{
    public static void main(String[] args) {
        // 目标对象
        Subject target = new RealSubject();
        Subject proxy = (Subject)new ProxyFactory(target).getProxyInstance();
        proxy.request();
    }
}
/**抽象接口
 */
interface Subject {
    void request();
}
/**抽象接口实现类
 */
class RealSubject implements Subject{
    @Override
    public void request() {
        System.out.println("真实请求");
    }
}
/**
 * 创建动态代理对象
 * 动态代理不需要实现接口,但是需要指定接口类型
 */
class ProxyFactory{
    //维护一个目标对象
    private Object target;
    public ProxyFactory(Object target){
        this.target=target;
    }
 
   //给目标对象生成代理对象
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), // 此处可不知道代理对象是什么接口
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("请求前...");
                        //执行目标对象方法
                        Object returnValue = method.invoke(target, args);
                        System.out.println("请求后...");
                        return returnValue;
                    }
                }
        );
    }
}

/**测试类
 */
public class Test{
    public static void main(String[] args) {
        List<Person> list = Allperson.getList();
        System.out.println("得到名字:");
        for(Person e: list){
            e.accept(new VisitorName());
        }
        System.out.println("得到年龄:");
        for(Person e: list){
            e.accept(new VisitorAge());
        }
    }
}
/**抽象类
 */
abstract class Person {
    public abstract void accept(IVisitor visitor);
}
/**学生类
 */
class Student extends Person {
    private String name;
    private int age;
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void accept(IVisitor visitor) {
        visitor.visit(this);
    }
}
/**教师类
 */
class Teacher extends Person {
    private String name;
    private int age;
    public Teacher(String name,int age){
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public void accept(IVisitor visitor) {
        visitor.visit(this);
    }
}
/**访问者接口
 */
interface IVisitor {
    public void visit(Student student);
    public void visit(Teacher teacher);
}
/**访问者名称实现类
 */
class VisitorName implements IVisitor {

    public void visit(Student student) {
        System.out.println(student.getName());
    }

    public void visit(Teacher teacher) {
        System.out.println(teacher.getName());
    }
}
/**访问者年龄实现类
 */
class VisitorAge implements IVisitor {

    public void visit(Student student) {
        System.out.println(student.getAge());
    }

    public void visit(Teacher teacher) {
        System.out.println(teacher.getAge());
    }
}
/**人员类
 */
class Allperson {
    public static List<Person> getList(){
        List<Person> list = new ArrayList<Person>();
        Student s1 = new Student("路飞",20);
        Student s2 = new Student("索隆",19);
        Teacher t1 = new Teacher("红发",44);
        Teacher t2 = new Teacher("雷利",59);
        list.add(s1);
        list.add(s2);
        list.add(t1);
        list.add(t2);
        return list;
    }
}

/**测试类
 */
public class Test{
    public static void main(String[] args) {
        AbstractClass abstractClass;
        abstractClass = new ConcreteClassA();
        abstractClass.TemplateMethod();

        abstractClass = new ConcreteClassB();
        abstractClass.TemplateMethod();
    }
}
/**抽象模板类
 */
abstract class AbstractClass {
    public abstract void PrimitiveOperation1();
    public abstract void PrimitiveOperation2();

    public void TemplateMethod() {
        PrimitiveOperation1();
        PrimitiveOperation2();
    }
}
/**具体模板类A
 */
class ConcreteClassA extends AbstractClass {

    @Override
    public void PrimitiveOperation1() {
        System.out.println("具体方法A方法1实现");
    }

    @Override
    public void PrimitiveOperation2() {
        System.out.println("具体方法A方法2实现");
    }
}
/**具体模板类B
 */
class ConcreteClassB extends AbstractClass {

    @Override
    public void PrimitiveOperation1() {
        System.out.println("具体方法B方法1实现");
    }

    @Override
    public void PrimitiveOperation2() {
        System.out.println("具体方法B方法2实现");
    }
}

/**测试类
 */
public class Test{
    public static void main(String[] args) {
        Context context = new Context(new OperationAdd());    
        System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
        
        context = new Context(new OperationSubtract());      
        System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
     
        context = new Context(new OperationMultiply());    
        System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
    }
}
/**策略接口
 */
interface Strategy {
   //算法方法
   public int doOperation(int num1, int num2);
}
/**加法具体策略类
 */
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;
   }
}
/**Context上下文
 */
class Context {
   private Strategy strategy;
 
   public Context(Strategy strategy){
      this.strategy = strategy;
   }
 
   public int executeStrategy(int num1, int num2){
      return strategy.doOperation(num1, num2);
   }
}

/**测试类
 */
public class Test{
    public static void main(String[] args) {
        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());
    }
}
/**状态接口
 */
interface State {
   public void doAction(Context context);
}
/**开始状态实现类
 */
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";
   }
}
/**状态类
 */
class Context {
   private State state;
 
   public Context(){
      state = null;
   }
 
   public void setState(State state){
      this.state = state;     
   }
 
   public State getState(){
      return state;
   }
}

/**测试类
 */
public class Test{
    public static void main(String[] args) {
        //前台为通知者
        Secretary secretary = new Secretary();

        StockObserver observer = new StockObserver("adam", secretary);
        StockObserver observer2 = new StockObserver("tom", secretary);

        //前台通知
        secretary.attach(observer);
        secretary.attach(observer2);

        //adam没被前台通知到，所以被老板抓了个现行
        secretary.detach(observer);

        //老板回来了
        secretary.setAction("小心！Boss回来了！");
        //发通知
        secretary.notifyObservers();
    }
}
/**观察者抽象类
 */
abstract class Observer {
    protected String name;
    protected Subject subject;

    public Observer(String name, Subject subject) {
        this.name = name;
        this.subject = subject;
    }

    public abstract void update();
}
/**通知者接口
 */
interface Subject {
    //增加
    public void attach(Observer observer);
    //删除
    public void detach(Observer observer);
    //通知
    public void notifyObservers();

    //状态
    public void setAction(String action);
    public String getAction();
}
/**具体通知者实现类
 */
class Secretary implements Subject {
    //同事列表
    private List<Observer> observers = new LinkedList<>();
    private String action;

    //添加
    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }

    //删除
    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }

    //通知
    @Override
    public void notifyObservers() {
        for(Observer observer : observers) {
            observer.update();
        }
    }

    //前台状态
    @Override
    public String getAction() {
        return action;
    }

    @Override
    public void setAction(String action) {
        this.action = action;
    }
}
/**具体观察者实现类
 */
class StockObserver extends Observer {
    public StockObserver(String name, Subject subject) {
        super(name, subject);
    }

    @Override
    public void update() {
        System.out.println(subject.getAction() + "\n" + name + "关闭股票行情，继续工作");
    }
}

/**测试类
 */
public class Test{
    public static void main(String[] args) {
        Game game = new Game();
        game.playGame();
        try {
            //玩了一会
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //暂停游戏
        game.exitGame();
        GameManager.getGameManager().saveGameInfo(game.saveGameInfo());

        //恢复游戏
        game.resetGame(GameManager.getGameManager().getGameInfo());
    }
}
/**备忘录类
 */
class GameInfo {
    //开始的总时长
    private int time;
    // 当前的等级
    private int level;

    public GameInfo(int time, int level) {
        this.time = time;
        this.level = level;
    }

    public int getTime() {
        return time;
    }

    public void setTime(int time) {
        this.time = time;
    }

    public int getLevel() {
        return level;
    }

    public void setLevel(int level) {
        this.level = level;
    }
}
/**备忘录管理者类
 */
class GameManager {
    private GameInfo mGameInfo;

    private static volatile GameManager instance;

    private GameManager() {
    }

    public static GameManager getGameManager() {
        if (instance == null) {
            synchronized (GameManager.class) {
                if (instance == null) {
                    instance = new GameManager();
                }
            }
        }
        return instance;
    }

    /**保存游戏信息
     */
    public void saveGameInfo(GameInfo gameInfo) {
        mGameInfo = gameInfo;
    }

    /**读取游戏信息
     */
    public GameInfo getGameInfo() {
        return mGameInfo;
    }
}
/**游戏类
 */
class Game {
    //开始的总时长
    private int time;

    // 当前的等级
    private int level;

    // 是否退出
    private boolean isExit = false;

    /**
     * 开始一把排位
     */
    public void playGame() {
        new Thread(new Runnable() {

            @Override
            public void run() {
                while (!isExit) {
                    System.out.println("游戏开始了：" + time + "分钟，等级：" + level);
                    time++;
                    level++;
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }

    /**来电话了，退出当前游戏
     */
    public void exitGame() {
        isExit = true;
        System.out.println("=====来电话了，退出当前游戏=====");
        System.out.println("游戏开始了：" + time + "分钟，等级：" + level);
    }

    /**保存获取当前游戏信息
     */
    public GameInfo saveGameInfo() {
        return new GameInfo(time, level);
    }

    /**重新加载游戏
     */
    public void resetGame(GameInfo gameInfo) {
        time = gameInfo.getTime();
        level = gameInfo.getLevel();
        System.out.println("=====恢复游戏=====");
        System.out.println("游戏开始了：" + time + "分钟，等级：" + level);
    }
}

/**测试类
 */
public class Test{
    public static void main(String[] args) {
        User robert = new User("Robert");
        User john = new User("John");
         
        robert.sendMessage("Hi! John!");
        john.sendMessage("Hello! Robert!");
    }
}
/**用户实体类
 */
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);
   }
}
/**中介类
 */
class ChatRoom {
   public static void showMessage(User user, String message){
      System.out.println(new Date().toString()
         + " [" + user.getName() +"] : " + message);
   }
}

/**测试类
 */
public class Test{
    public static void main(String[] args) {
        NameRepository namesRepository = new NameRepository();
        for(Iterator iter = namesRepository.getIterator(); iter.hasNext();){
            String name = (String)iter.next();
            System.out.println("Name : " + name);
        }
    }
}
/**迭代器接口
 */
interface Iterator {
   public boolean hasNext();//是否存在下一个元素
   public Object next();//下个元素
}
/**返回迭代器接口
 */
interface Container {
   public Iterator getIterator();
}
/**迭代器实现类
 */
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;
      public boolean hasNext() {
         if(index < names.length){
            return true;
         }
         return false;
      }
 
      public Object next() {
         if(this.hasNext()){
            return names[index++];
         }
         return null;
      }     
   }
}

/**测试类
 */
public class Test{
    public static void main(String[] args) {
        String expStr = "a + b - c";
        System.out.println("输入表达式："+expStr);
        HashMap<String, Integer> var = new HashMap<>();
        var.put("a", 10);
        var.put("b", 5);
        var.put("c", 3);
        System.out.println("a的值："+var.get("a"));
        System.out.println("b的值："+var.get("b"));
        System.out.println("c的值："+var.get("c"));
        Calculator calculator = new Calculator(expStr);
        System.out.println("运算结果：" + expStr + " = " + calculator.run(var));
    }
}
/**表达式接口
 */
interface Expression {
    //解析公式和数值，key是公式中的参数，value是具体的数值
   public int interpreter(HashMap<String, Integer> var);
}
/**变量解析器
 */
class VarExpression implements Expression {
    private String key;
    public VarExpression(String key) {
        this.key = key;
    }
    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return var.get(this.key);
    }
}
/**运算符号解析器
 */
class SymbolExpression implements Expression {
    protected Expression left;
    protected Expression right;

    public SymbolExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    public int interpreter(HashMap<String, Integer> var) {
        return 0;
    }
}
/**加法解析器
 */
class AddExpression extends SymbolExpression {
    public AddExpression(Expression left, Expression right) {
        super(left, right);
    }

    public int interpreter(HashMap<String, Integer> var) {
        return super.left.interpreter(var) + super.right.interpreter(var);
    }
}
/**减法解析器
 */
class SubExpression extends SymbolExpression {
    public SubExpression(Expression left, Expression right) {
        super(left, right);
    }

    public int interpreter(HashMap<String, Integer> var) {
        return super.left.interpreter(var) - super.right.interpreter(var);
    }
}
/**解析器封装类
 */
class Calculator {

    //定义表达式
    private Expression expression;

    //构造函数传参，并解析
    public Calculator(String expStr) {
        //安排运算先后顺序
        Stack<Expression> stack = new Stack<>();
        //表达式拆分为字符数组
        char[] charArray = expStr.replace(" ", "").toCharArray();

        Expression left = null;
        Expression right = null;
        for(int i=0; i<charArray.length; i++) {
            switch (charArray[i]) {
            case ‘+‘:    //加法
                left = stack.pop();
                right = new VarExpression(String.valueOf(charArray[++i]));
                stack.push(new AddExpression(left, right));
                break;
            case ‘-‘:    //减法
                left = stack.pop();
                right = new VarExpression(String.valueOf(charArray[++i]));
                stack.push(new SubExpression(left, right));
                break;
            default:    //公式中的变量
                stack.push(new VarExpression(String.valueOf(charArray[i])));
                break;
            }
        }
        this.expression = stack.pop();
    }

    //计算
    public int run(HashMap<String, Integer> var) {
        return this.expression.interpreter(var);
    }
}

/**测试类
 */
public class Test{
    public static void main(String[] args) {
        Light light = new Light();//灯泡
        TV tv = new TV();//电视机
        LoudspeakerBox loudspeakerBox = new LoudspeakerBox();//音响
        Command lightOn = new LightOnCommand(light);//开启灯泡
        Command lightOff = new LightOffCommand(light);//关闭灯泡
        Command TVOn = new TVOnCommand(tv);//开启电视
        Command TVOff = new TVOffCommand(tv);//关闭电视
        Command LoudspeakerBoxOn = new LoudspeakerBoxOnCommand(loudspeakerBox);//开启音响
        Command LoudspeakerBoxOff = new LoudspeakerBoxOffCommand(loudspeakerBox);//关闭音响

        RemoteController remoteController = new RemoteController(3);
        remoteController.setCommand(0, lightOn, lightOff);
        remoteController.setCommand(1, TVOn, TVOff);
        remoteController.setCommand(2, LoudspeakerBoxOn, LoudspeakerBoxOff);

        remoteController.onButtonPressed(0);
        remoteController.offButtonPressed(0);
        remoteController.onButtonPressed(1);
        remoteController.offButtonPressed(1);
        remoteController.onButtonPressed(2);
        remoteController.offButtonPressed(2);
    }
}
/**命令接口
 */
interface Command {
   void execute();
}
/**灯泡实体类
 */
class Light {
    public void on(){
        System.out.println("打开电灯。。。");
    }
    
    public void off(){
        System.out.println("关闭电灯。。。");
    }
}
/**电视实体类
 */
class TV {
    public void on(){
        System.out.println("打开电视。。。");
    }
    
    public void off(){
        System.out.println("关闭电视。。。");
    }
}
/**音箱实体类
 */
class LoudspeakerBox {
    public void on(){
        System.out.println("打开音箱。。。");
    }
    
    public void off(){
        System.out.println("关闭音箱。。。");
    }
}
/**灯泡开启命令实现类
 */
class LightOnCommand implements Command{
    Light light;
    public LightOnCommand(Light light){
        this.light = light;
    }
    
    public void execute() {
        light.on();
    }
}
/**灯泡关闭命令实现类
 */
class LightOffCommand implements Command{
    Light light;
    public LightOffCommand(Light light){
        this.light = light;
    }
    
    public void execute() {
        light.off();
    }
}
/**电视开启命令实现类
 */
class TVOnCommand implements Command{
    TV tv;
    public TVOnCommand(TV tv){
        this.tv = tv;
    }
    
    public void execute() {
        tv.on();
    }
}
/**电视关闭命令实现类
 */
class TVOffCommand implements Command{
    TV tv;
    public TVOffCommand(TV tv){
        this.tv = tv;
    }
    
    public void execute() {
        tv.off();
    }
}
/**音箱开启命令实现类
 */
class LoudspeakerBoxOnCommand implements Command{
    LoudspeakerBox loudspeakerBox;
    public LoudspeakerBoxOnCommand(LoudspeakerBox loudspeakerBox){
        this.loudspeakerBox = loudspeakerBox;
    }
    
    public void execute() {
        loudspeakerBox.on();
    }
}
/**音箱关闭命令实现类
 */
class LoudspeakerBoxOffCommand implements Command{
    LoudspeakerBox loudspeakerBox;
    public LoudspeakerBoxOffCommand(LoudspeakerBox loudspeakerBox){
        this.loudspeakerBox = loudspeakerBox;
    }
    
    public void execute() {
        loudspeakerBox.off();
    }
}
/**遥控器类
 */
class RemoteController {
    Command[] onCommands;
    Command[] offCommands;

    public RemoteController(int commandSize) {
        this.onCommands = new Command[commandSize];
        this.offCommands = new Command[commandSize];
    }

    public void setCommand(int i, Command onCommand, Command offCommand) {
        onCommands[i] = onCommand;
        offCommands[i] = offCommand;
    }

    // 按下开按钮
    public void onButtonPressed(int i) {
        onCommands[i].execute();
    }

    // 按下关按钮
    public void offButtonPressed(int i) {
        offCommands[i].execute();
    }
}

/**测试类
 */
public class Test{
    public static void main(String[] args) {
        ApprovalChainHandler h1 = new GroupLeaderChainHandler();
        ApprovalChainHandler h2 = new ExecutiveChainHandler();
        ApprovalChainHandler h3 = new CEOChainHandler();
        h1.setNext(h2);
        h2.setNext(h3);
        String staff1 = "张三";
        String staff2 = "李四";
        String staff3 = "王五";
        System.out.println(staff1+"请假结果:"+h1.handler(staff1));
        System.out.println(staff2+"请假结果:"+h1.handler(staff2));
        System.out.println(staff3+"请假结果:"+h1.handler(staff3));
    }
}
/**请假审批任链抽象类
 */
abstract class ApprovalChainHandler {
    private ApprovalChainHandler next;
    protected abstract  boolean doHandler(String name);
    public boolean handler(String name) {
        boolean result = doHandler(name);
        if (isAccordWith(result) && next != null) {
            return next.handler(name);
        } else {
            return result;
        }
    }

    public void setNext(ApprovalChainHandler next){
        this.next = next;
    }

    /**判断审批是否同意
     */
    protected boolean isAccordWith(boolean t) {
        return t;
    }
}
/**组长审批类
 */
class GroupLeaderChainHandler extends ApprovalChainHandler {
    protected boolean doHandler(String name) {
        boolean result= new Random().nextBoolean();
        System.out.println("组长审批["+ name +"]结果::"+result);
        return result;
    }
}
/**主管审批类
 */
class ExecutiveChainHandler extends ApprovalChainHandler {
   protected boolean doHandler(String name) {
      boolean result= new Random().nextBoolean();
      System.out.println("主管审批["+ name +"]结果: "+result);
      return result;
   }
}
/**老板审批类
 */
class CEOChainHandler extends ApprovalChainHandler {
    protected boolean doHandler(String name) {
        boolean result= new Random().nextBoolean();
        System.out.println("CEO审批["+ name +"]结果:: "+result);
        return result;
    }
}