代码精进之路-设计模式-（三）行为型模式

三、行为模式（11个）

1、责任链模式

//保存凭证之前的规则检查
public class Client {
    public static void main(String[] args) {
        //凭证信息
        GlCertificate glCertificate = new GlCertificate();


        //检查规则
        Node f1Node = new Node1();
        Node f2Node = new Node2();
        Node f3Node = new Node3();
        f1Node.setNext(f2Node);
        f2Node.setNext(f3Node);


        //组装检查链
        MyNodeChain myNodeChain = new MyNodeChain();
        //目标服务
        myNodeChain.setGlCertificateService(new GlCertificateService());
        //头节点
        myNodeChain.setNode(f1Node);
        //保存凭证
        myNodeChain.doSave(glCertificate);
    }


}


//要保存的凭证信息
public class GlCertificate {
}
//保存接口
public class GlCertificateService {


     void save(GlCertificate glCertificate){
          System.out.println("凭证保存成功");
     }
}
//检查节点
public interface Node {
    Node getNext();
    void setNext(Node node) ;
    void check(GlCertificate glCertificate);
}
public abstract class BaseNode implements Node {
    private Node node;
    @Override
    public Node getNext() {
        return node;
    }
    @Override
    public void setNext(Node node) {
        this.node = node;
    }


    @Override
    public abstract void check(GlCertificate glCertificate);
}
public class Node1 extends BaseNode {
    @Override
    public void check(GlCertificate glCertificate) {
        System.out.println("凭证合法性检查规则1");
        if (getNext()!=null) {
            getNext().check(glCertificate);
        }
    }
}
public class Node2 extends BaseNode {
    @Override
    public void check(GlCertificate glCertificate) {
        System.out.println("凭证合法性检查规则2");
        if (getNext()!=null) {
            getNext().check(glCertificate);
        }
    }
}
public class Node3 extends BaseNode {
    @Override
    public void check(GlCertificate glCertificate) {
        System.out.println("凭证合法性检查规则3");
        if (getNext()!=null) {
            getNext().check(glCertificate);
        }
    }
}


public interface NodeChain {
    void doSave(GlCertificate glCertificate);
}


public class MyNodeChain implements NodeChain {
    private GlCertificateService glCertificateService;
    private Node node;
    @Override
    public void doSave(GlCertificate glCertificate) {
        if (node!=null) {
            node.check(glCertificate);
        }
        glCertificateService.save(glCertificate);
    }
    public Node getNode() {
        return node;
    }
    public void setNode(Node node) {
        this.node = node;
    }
    public GlCertificateService getGlCertificateService() {
        return glCertificateService;
    }
    public void setGlCertificateService(GlCertificateService glCertificateService) {
        this.glCertificateService = glCertificateService;
    }
}

2、命令模式

//将命令参数对象和命令处理者组合起来
//执行时可延迟、可排队、可撤销
public class Client {
    public static void main(String[] args) {
        ICommand commandSave = new CommandSave("user1",new ReceiveSave());
        Invoker invoker1 = new Invoker(commandSave);
        invoker1.invoke();


        ICommand commandDelete = new CommandDelete("user1", new ReceiveDelete());
        Invoker invoker2 = new Invoker(commandDelete);
        invoker2.invoke();
    }
}


public interface ICommand {
    void execute();
}


public class CommandDelete implements ICommand {
    private String commandContext;
    private IReceiver receiver;


    public CommandDelete(String commandContext,IReceiver receiver){
        this.commandContext = commandContext;
        this.receiver = receiver;
    }
    @Override
    public void execute() {
        receiver.call(commandContext);
    }
}


public class CommandSave implements ICommand {
    private IReceiver receiver;
    private String commandContext;
    public CommandSave(String commandContext,IReceiver receiver){
        this.commandContext = commandContext;
        this.receiver = receiver;
    }


    @Override
    public void execute() {
            receiver.call(commandContext);
    }
}


public interface IReceiver {
    void call(String commandContext);
}
public class ReceiveDelete implements IReceiver{
    @Override
    public void call(String commandContext) {
        System.out.println(commandContext+"删除成功");
    }
}
public class ReceiveSave implements IReceiver{
    @Override
    public void call(String commandContext) {
        System.out.println(commandContext+"保存成功");
    }
}


public class Invoker {
    //要发送的命令
    private ICommand command;
    public Invoker(ICommand command){
        this.command = command;
    }
    public void invoke(){
        command.execute();
    }
}

3、解释器模式

正则表达式的解析
SQL的解析
任何你自定义的语言，都要写自己的解释器

4、迭代器模式

/**
 * 迭代器模式核心思路：
 * 1、定义容器接口MyCollection，里面除了容器本身的增删方法外，还有一个获取迭代器的方法 iterator()
 * 2、定义一个迭代器接口MyIterator，里面至少有  hasNext()和 next() 方法
 * 3、定义容器实现类 MyList
 * 4、在容器实现类内部定义 迭代器实现类（内部类） MyListIterator 实现 MyIterator 接口
 */
public class Client {


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


        MyCollection myList = new MyList();
        myList.add("a");
        myList.add("b");
        myList.add("c");
        myList.add("d");
        myList.add("e");


        //可并发遍历
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @SneakyThrows
                @Override
                public void run() {
                    MyIterator iterator1 = myList.iterator();
                    while (iterator1.hasNext()) {
                        TimeUnit.SECONDS.sleep( ThreadLocalRandom.current().nextInt(3));
                        Object next = iterator1.next();
                        System.out.println(Thread.currentThread().getName()+next);
                    }
                }
            }).start();
        }
        new CountDownLatch(1).await();
    }
}


public interface MyCollection {
    void add(Object o);
    boolean remove(Object o);
    int size();
    Object get(int index);
    MyIterator iterator();
}
public interface MyIterator {
    boolean hasNext();
    Object next();
}


public class MyList implements  MyCollection{


    private List list = new ArrayList();
    @Override
    public void add(Object o) {
         list.add(o);
    }


    @Override
    public boolean remove(Object o) {
        return list.remove(o);
    }


    @Override
    public int size() {
        return list.size();
    }


    @Override
    public Object get(int index) {
        return list.get(index);
    }




    @Override
    public MyIterator iterator() {
        return new MyListIterator(this);
    }


    class MyListIterator implements MyIterator{


        private MyList list;
        private int currentIndex = 0;
        public MyListIterator( MyList list){
            this.list = list;
        }
        @Override
        public boolean hasNext() {
            return list.size()>0&&currentIndex<list.size();
        }


        @Override
        public Object next() {
            return list.get(currentIndex++);
        }
    }
}

5、中介者模式

MVC中的C
ESB企业服务总线，网状变星状
红路灯
消息队列


塔台协调飞机跑道


public class Client {
    public static void main(String[] args) {
        //塔台
        IControlTower ct = new ControlTowerImpl();


        //110号航班
        IAirplane airplane110 = new Airplane110(ct);
        //111号航班
        IAirplane airplane111 = new Airplane111(ct);
        //112号航班
        IAirplane airplane112 = new Airplane112(ct);
        //向塔台注册飞机
        ct.add(airplane110);
        ct.add(airplane111);
        ct.add(airplane112);


        //起飞 申请跑道
        System.out.println(airplane110.call("申请起飞"));
        System.out.println(airplane111.call("申请起飞"));
        System.out.println(airplane112.call("申请起飞"));


    }
}


public interface IControlTower {
    void add(IAirplane airplane);


    void remove(IAirplane airplane);


    String call(IAirplane airplane, String event);
}
public class ControlTowerImpl implements IControlTower {
    //注册的飞机
    private List<IAirplane> airplaneList=new CopyOnWriteArrayList<>();


    //跑到与飞机映射关系
    private Map<String,IAirplane> map = new HashMap<>();
    {
        map.put("1号跑道",null);
        map.put("2号跑道",null);
    }
    @Override
    public void add(IAirplane airplane){
        airplaneList.add(airplane);
    }
    @Override
    public void remove(IAirplane airplane){
        airplaneList.remove(airplane);
    }


    @Override
    public String call(IAirplane airplane, String event) {
        if (!airplaneList.contains(airplane)) {
            throw new RuntimeException("未注册");
        }
        Iterator<Map.Entry<String, IAirplane>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, IAirplane> next = iterator.next();
            if (next.getValue()==null) {
                next.setValue(airplane);
                return next.getKey();
            }
        }


        throw new RuntimeException("无空闲跑道");
    }
}


public interface IAirplane {
    //呼叫塔台
    String call (String event);
}
public class Airplane110 implements IAirplane{


    private IControlTower controlTower;
    public Airplane110(IControlTower controlTower){
        this.controlTower = controlTower;
    }
    @Override
    public String call(String event) {
        return controlTower.call(this,event);
    }
}


public class Airplane111 implements IAirplane{


    private IControlTower controlTower;
    public Airplane111(IControlTower controlTower){
        this.controlTower = controlTower;
    }
    @Override
    public String call(String event) {
        return controlTower.call(this,event);
    }
}


public class Airplane112 implements IAirplane{


    private IControlTower controlTower;
    public Airplane112(IControlTower controlTower){
        this.controlTower = controlTower;
    }
    @Override
    public String call(String event) {
        return controlTower.call(this,event);
    }
}

6、备忘录模式

//备份与恢复
//白盒模式实现
public class Client {


    //发起人（待备份对象）
    private static Originator o = new Originator();
    //负责人（保管备份介质）
    private static Caretaker c = new Caretaker();




    public static void main(String[] args) {
        System.out.println("白盒测试");
        //改变发起人对象的状态
        o.setState("1");
        //创建备忘录对象，并将发起人对象的状态存储起来
        System.out.println("对象快照："+o.getState());
        c.saveMemento(o.createMemento());
        //修改发起人对象的状态
        o.setState("2");
        System.out.println("最新对象状态："+o.getState());
        //恢复发起人对象的状态
        o.restoreMemento(c.retrieveMemento());
        System.out.println("恢复快照后对象状态："+o.getState());
        
    }
}


/**
 *  快照对象，备忘录对象，记录了某个对象的一个瞬时状态
 */
public class Memento {


    private String state;
    
    public Memento(String state){
        this.state = state;
    }
    
    public String getState(){
        return this.state;
    }
    public void setState(String state){
        this.state = state;
    }
}


/**
 * 发起人角色：创建快照（备忘录）对象；恢复快照（备忘录）对象；
 *
 */
public class Originator {


    private String state;
    /**
     * 创建一个瞬时快照对象（数据备份）
     * @return
     */
    public Memento createMemento(){
        return new Memento(state);
    }
    /**
     * 从某一个快照 进行恢复 （数据还原）
     * @param memento
     */
    public void restoreMemento(Memento memento){
        this.state = memento.getState();
    }
    
    public String getState(){
        return this.state;
    }
    public void setState(String state){
        this.state = state;
    }
}


/**
 * 负责人角色：用来保管 快照
 */
public class Caretaker {


    private Memento memento;
    /**
     * 获取快照
     * @return
     */
    public Memento retrieveMemento(){
        return this.memento;
    }
    /**
     * 保存快照
     * @param memento
     */
    public void saveMemento(Memento memento){
        this.memento = memento;
    }
}

7、观察者模式

//注册、广播器、广播事件
//服务内部实现为事件机制，服务之间实现为消息队列
/**
 * 模拟spring容器 启动流程 产生事件
 */
public class Client {


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


        //注册监听者
         ArrayList<EventProcessor> eventProcessors = new ArrayList<>();
        {
            eventProcessors.add(new MyObserver1());
            eventProcessors.add(new MyObserver2());
        }
        //异步广播：事件
        EventBroadcast.broadcast(eventProcessors,MyEvent.starting);
        EventBroadcast.broadcast(eventProcessors,MyEvent.started);
        EventBroadcast.broadcast(eventProcessors,MyEvent.stoping);
        EventBroadcast.broadcast(eventProcessors,MyEvent.stoped);


        new CountDownLatch(1).await();
    }


}


/**
 * 事件处理接口
 */
public interface EventProcessor {
    public void process(MyEvent myEvent);
}
/**
 * 事件广播器
 */
public class EventBroadcast {
    public  static void broadcast(List<EventProcessor> list,MyEvent event){


        CompletableFuture.runAsync(new Runnable() {
            @Override
            public void run() {
                for (EventProcessor eventProcessor : list) {
                    eventProcessor.process(event);
                }
            }
        }).thenRunAsync(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"=广播完毕="+event.name());
            }
        });
    }
}


/**
 * 事件枚举
 */
public enum  MyEvent {
    starting,
    started,
    stoping,
    stoped
}


/**
 * 观察者1
 */
public class MyObserver1 implements EventProcessor {
    @Override
    public void process(MyEvent myEvent) {
        System.out.println("MyObserver1:"+myEvent.toString());
    }
}


/**
 * 观察者2
 */
public class MyObserver2 implements EventProcessor {
    @Override
    public void process(MyEvent myEvent) {
        System.out.println("MyObserver2:"+myEvent.toString());
    }
}

8、状态模式

//状态的转变带动行为的转变


public class Client {


    public static void main(String[] args) {
        //订单状态上下文，初始状态
        OrderStateManager orderStateManager = new OrderStateManager();
        orderStateManager.setCurrentState(OrderStateManager.initState);


        //订单信息
        Order order = new Order();
        order.setOrderId("202202020001");
        order.setCreateTime(new Date());
        order.setPayType("在线支付");
        order.setAggregateAmount(new BigDecimal(100));
        //给这个订单一个状态管理器
        order.setOrderStateManager(orderStateManager);


        //订单进行提交操作
        orderStateManager.submit();
        orderStateManager.cancel();
        orderStateManager.pay();
        orderStateManager.deliver();
        orderStateManager.receive();
        orderStateManager.cancel();
        orderStateManager.delete();


    }
}


已提交，由初始态进入到提交态
取消成功，由提交态进入到取消态
取消态下不能支付
取消态下不能发货
取消态下不能确认收货
取消态下不能重复取消
订单已删除，由取消态转到删除态




@Data
public class Order {
    private String orderId;
    private Date createTime;
    private BigDecimal aggregateAmount;
    private String payType;
    private List<String> details = new ArrayList<String>();
    private OrderStateManager orderStateManager;
}


@Data
public abstract class OrderState {
    private OrderStateManager orderStateManager;
    /**
     * 删除订单
     */
    abstract void delete();
    /**
     * 取消订单
     */
    abstract void cancel();
    /**
     * 提交订单
     */
    abstract void submit();
    /**
     * 支付订单
     */
    abstract void pay();
    /**
     * 发货
     */
    abstract void deliver();
    /**
     * 收货确认
     */
    abstract void receive();
}


public class OrderStateManager extends OrderState {


    public static final OrderState initState = new OrderInitState();
    public static final OrderState submittedState = new OrderSubmittedState();
    public static final OrderState payedState = new OrderPayedState();
    public static final OrderState deliveredState = new OrderDeliveredState();
    public static final OrderState receivedState = new OrderReceivedState();
    public static final OrderState canceledState = new OrderCanceledState();
    public static final OrderState deletedState = new OrderDeletedState();


    //会在上面四种状态中流转
    private OrderState currentState ;


//    {
//        //初始状态
//        currentState = submittedState;
//        currentState.setOrderContext(this);
//    }
    public OrderState getCurrentState() {
        return currentState;
    }
    public void setCurrentState(OrderState currentState) {
        this.currentState = currentState;
        this.currentState.setOrderStateManager(this);
    }
    @Override
    void delete() {
        currentState.delete();
    }
    @Override
    void cancel() {
        currentState.cancel();
    }
    @Override
    void submit() {
        currentState.submit();
    }
    @Override
    void pay() {
        currentState.pay();
    }
    @Override
    void deliver() {
        currentState.deliver();
    }
    @Override
    void receive() {
        currentState.receive();
    }
}


public class OrderInitState extends OrderState {
    @Override
    void submit() {
        System.out.println("已提交，由初始态进入到提交态");
        getOrderStateManager().setCurrentState(OrderStateManager.submittedState);
    }
    @Override
    void delete() {
        System.out.println("初始态下不能删除");
    }
    @Override
    void cancel() {
        System.out.println("初始态下不能重复取消");
    }
    @Override
    void pay() {
        System.out.println("初始态下不能支付");
    }
    @Override
    void deliver() {
        System.out.println("初始态下不能发货");
    }
    @Override
    void receive() {
        System.out.println("初始态下不能确认收货");
    }
}


public class OrderSubmittedState extends OrderState {
    @Override
    void submit() {
        System.out.println("提交态下不能提交");
    }
    @Override
    void delete() {
        System.out.println("提交态下不能删除");
    }
    @Override
    void cancel() {
        System.out.println("取消成功，由提交态进入到取消态");
        getOrderStateManager().setCurrentState(OrderStateManager.canceledState);
    }
    @Override
    void pay() {
        System.out.println("支付成功，由提交态进入到支付态");
        getOrderStateManager().setCurrentState(OrderStateManager.payedState);
    }
    @Override
    void deliver() {
        System.out.println("提交态下不能发货");
    }
    @Override
    void receive() {
        System.out.println("提交态下不能确认收货");
    }
}


public class OrderPayedState extends OrderState {
    @Override
    void submit() {
        System.out.println("支付态下不能提交");
    }
    @Override
    void delete() {
        System.out.println("支付态下不能删除");
    }
    @Override
    void cancel() {
        System.out.println("支付态下不能取消");
    }
    @Override
    void pay() {
        System.out.println("支付态下不能支付");
    }
    @Override
    void deliver() {
        System.out.println("已发货，由支付态进入到发货态");
        getOrderStateManager().setCurrentState(OrderStateManager.deliveredState);
    }
    @Override
    void receive() {
        System.out.println("支付态下不能确认收货");
    }
}


public class OrderDeliveredState extends OrderState {
    @Override
    void submit() {
        System.out.println("发货态下不能提交");
    }
    @Override
    void delete() {
        System.out.println("发货态下不能删除");
    }
    @Override
    void cancel() {
        System.out.println("发货态下不能取消");
    }
    @Override
    void pay() {
        System.out.println("发货态下不能支付");
    }
    @Override
    void deliver() {
        System.out.println("发货态下不能发货");
    }
    @Override
    void receive() {
        System.out.println("确认收货,由发货态进入确认收货态");
        getOrderStateManager().setCurrentState(OrderStateManager.receivedState);
    }
}


public class OrderReceivedState extends OrderState {
    @Override
    void submit() {
        System.out.println("收货确认态下不能提交");
    }
    @Override
    void delete() {
        System.out.println("收货确认态下不能删除");
    }
    @Override
    void cancel() {
        System.out.println("收货确认态下不能取消");
    }
    @Override
    void pay() {
        System.out.println("收货确认态下不能支付");
    }
    @Override
    void deliver() {
        System.out.println("收货确认态下不能发货");
    }
    @Override
    void receive() {
        System.out.println("收货确认态下不能确认收货");
    }
}


public class OrderCanceledState extends OrderState {
    @Override
    void submit() {
        System.out.println("取消态下不能提交");
    }
    @Override
    void delete() {
        System.out.println("订单已删除，由取消态转到删除态");
        getOrderStateManager().setCurrentState(OrderStateManager.deletedState);
    }
    @Override
    void cancel() {
        System.out.println("取消态下不能重复取消");
    }
    @Override
    void pay() {
        System.out.println("取消态下不能支付");
    }
    @Override
    void deliver() {
        System.out.println("取消态下不能发货");
    }
    @Override
    void receive() {
        System.out.println("取消态下不能确认收货");
    }
}


public class OrderDeletedState extends OrderState {
    @Override
    void submit() {
        System.out.println("删除态下不能提交");
    }
    @Override
    void delete() {
        System.out.println("删除态下不能删除");
    }
    @Override
    void cancel() {
        System.out.println("删除态下不能取消");
    }
    @Override
    void pay() {
        System.out.println("删除态下不能支付");
    }
    @Override
    void deliver() {
        System.out.println("删除态下不能发货");
    }
    @Override
    void receive() {
        System.out.println("删除态下不能确认收货");
    }
}

9、策略模式

//这个可能是最容易理解的一个设计模式了
//地图导航策略
public class Client {
    public static void main(String[] args) {
        //策略上下文
        RouteStrategyContext routeStrategyContext = new RouteStrategyContext();
        
        //切换到：距离最短策略
        routeStrategyContext.setRouteStrategy(new ShortestRouteStrategy());
        List<String> routes = routeStrategyContext.buildRoute("a", "e");
        routes.stream().forEach((route)->System.out.println(route));


        //切换到：花费时间最少策略
        routeStrategyContext.setRouteStrategy(new FastestRouteStrategy());
        routes = routeStrategyContext.buildRoute("a", "e");
        routes.stream().forEach((route)->System.out.println(route));
    }
}
@Data
public class RouteStrategyContext {
     private RouteStrategy routeStrategy;
     public RouteStrategyContext(){
     }
     public RouteStrategyContext(RouteStrategy routeStrategy){
         this.routeStrategy = routeStrategy;
     }
     public List<String> buildRoute(String from,String to){
         if (routeStrategy==null) {
             throw new RuntimeException("没有设置策略");
         }
         return routeStrategy.buildRoute(from,to);
     }
}


public interface RouteStrategy {
       List<String> buildRoute(String from, String to);
}


public class FastestRouteStrategy implements RouteStrategy {
    @Override
    public List<String> buildRoute(String from, String to) {
        LinkedList<String> strings = new LinkedList<>();
        strings.add("a");
        strings.add("d");
        strings.add("f");
        strings.add("e");
        return strings;
    }
}


public class ShortestRouteStrategy implements RouteStrategy {
    @Override
    public List<String> buildRoute(String from, String to) {
        LinkedList<String> strings = new LinkedList<>();
        strings.add("a");
        strings.add("b");
        strings.add("e");
        return strings;
    }
}

10、模板方法模式

//好理解
public class Main {
    public static void main(String[] args) {
        ServiceTemplate template1 = new MyService1();
        template1.templateMethod();


        ServiceTemplate template2 = new MyService2();
        template2.templateMethod();
    }
}


abstract class ServiceTemplate {
    //不让子类覆盖这个模板方法
    final void templateMethod(){
        m1();
        m2();
        m3();
    }


    private void m1(){
        System.out.println("第一步");
    }
    abstract void m2();
    private void m3(){
        System.out.println("第三步");
    }
}


class MyService1 extends ServiceTemplate {
    @Override
    void m2() {
        System.out.println("MyService1 第二步实现");
    }
}


class MyService2 extends ServiceTemplate {
    @Override
    void m2() {
        System.out.println("MyService2 第二步实现");
    }
}

11、访问者模式

//比较奇特的一种模式，广泛用在 AST（编译器、正则、SQL） 等领域
//将目标对象的一些行为放到了 访问者对象中
//有一些对象不想被某些行为污染可以用这种模式
public class Client {
    public static void main(String[] args) {
        ITagetObject tagetObject = new TargetObjectImpl1();
        System.out.println(tagetObject.accept(new VisitorImpl()));


        tagetObject = new TargetObjectImpl2();
        System.out.println(tagetObject.accept(new VisitorImpl()));


        tagetObject = new TargetObjectImpl3();
        System.out.println(tagetObject.accept(new VisitorImpl()));


    }
}


/**
 * @Title ITagetObject
 * @Description  一个对象，必须待 accept方法 来接收 IVisitor对象
 * @Author lvaolin
 * @Date 2022/2/12 19:38
 **/
public interface ITagetObject {
    String accept(IVisitor visitor);
}


/**
 * @Title IVisitor
 * @Description 访问者需要实现的接口，实际上和具体的对象类耦合了
 *
 * @Author lvaolin
 * @Date 2022/2/12 19:40
 **/
public interface IVisitor {
    String visitor(TargetObjectImpl1 t);
    String visitor(TargetObjectImpl2 t);
    String visitor(TargetObjectImpl3 t);
}
public class TargetObjectImpl1 implements ITagetObject {
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    private String name="dhy1";
    @Override
    public String accept(IVisitor visitor) {
        //必须将自身对象传进去
        return visitor.visitor(this);
    }
}
public class TargetObjectImpl2 implements ITagetObject {
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    private String name="dhy2";
    @Override
    public String accept(IVisitor visitor) {
        //必须将自身对象传进去
        return visitor.visitor(this);
    }
}


public class TargetObjectImpl3 implements ITagetObject {
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    private String name="dhy3";
    @Override
    public String accept(IVisitor visitor) {
        //必须将自身对象传进去
        return visitor.visitor(this);
    }
}

四、其它模式

简单工厂模式

//工厂类不需要抽象，没有工厂接口，够简单
public class Client {
    public static void main(String[] args) {
        MobileFactory mobileFactory = new MobileFactory();
        Mobile appleMobile = mobileFactory.getMobile("apple");
        System.out.println(appleMobile.getBrand());


        Mobile huaweiMobile = mobileFactory.getMobile("huawei");
        System.out.println(huaweiMobile.getBrand());


        Mobile xiaomiMobile = mobileFactory.getMobile("xiaomi");
        System.out.println(xiaomiMobile.getBrand());


        Mobile oppoMobile = mobileFactory.getMobile("oppo");
        System.out.println(oppoMobile.getBrand());


    }
}


public class MobileFactory {


    Mobile getMobile(String brand){
        switch (brand){
            case "apple":
                return new AppleMobile();
            case "huawei":
                return new HuaweiMobile();
            case "xiaomi":
                return new XiaomiMobile();
            default:return new OppoMobile();
        }
    }
}


public class AppleMobile implements Mobile {
    @Override
    public String getBrand() {
        return "apple";
    }
}


public class HuaweiMobile implements Mobile {
    @Override
    public String getBrand() {
        return "huawei";
    }
}


public class XiaomiMobile implements Mobile {
    @Override
    public String getBrand() {
        return "xiaomi";
    }
}