关于java:行为型模式四

行为型模式到这篇就完结了，完了之后是结构型模式。

空对象模式

这个模式能够说用得比拟少，至多再我真正学习之前是没有用过的，甚至没有听过的。在空对象模式中，一个空对象取代 NULL 对象实例的查看。NULL 对象不是查看管制，而是反馈一个不做任何动作的关系。

AbstractClass： 形象进去的对象，具备肯定的逻辑

RealClass： 真正的对象

NullObject： 空对象

空对象 UML

空对象模式

AbstractClass

public abstract class AbstractClass {public abstract void print();
    public abstract void isNullObject();}

RealClass

public class RealClass extends AbstractClass {
    @Override
    public void print() {System.out.println("real class: hello world");
    }

    @Override
    public void isNullObject() {System.out.println("i am real object");
    }
}

NullClass

public class NullClass extends AbstractClass {
    @Override
    public void print() {System.out.println("do nothing");
    }

    @Override
    public void isNullObject() {System.out.println("do nothing");
    }
}

为了不便演示，还减少了一个工厂类用来随机生成是 RealClass 还是 NullClass

ObjectFactory

public class ObjectFactory {public static AbstractClass getObjectClass() {if (Math.random() * 10 > 4) {return new RealClass();
        }
        return new NullClass();}
}

Client

public class Client {public static void main(String[] args) {for (int i = 0; i < 10; i++) {ObjectFactory.getObjectClass().isNullObject();
            ObjectFactory.getObjectClass().print();
        }
    }
}

就是这么朴实无华，然而的确是用得比拟少，上网一搜甚至很多题目都是被遗弃的设计模式。

访问者模式

访问者模式的目标是要把解决从数据结构中分离出来，其长处是减少新的操作很容易，因为减少新的操作就认为着减少一个新的访问者。

艰深地来说，把数据抽象成一类，把操作形象成一类。 拿王者光荣举例，最典型的就是英雄算是数据，玩家就是访问者，新增一个玩家只须要新增一个具体访问者即可。

Element： 形象进去的元素，外面有个 accept 办法来承受访问者的拜访，对应例子就是英雄的抽象类

Concrete Element： 具体的元素，对应就是具体的某个英雄

Visitor： 访问者，个别须要蕴含拜访所有具体元素的形象办法，对应游戏就是玩家的抽象类

Concrete Element： 具体的访问者，对应到例子就是不同的具体的玩家

访问者 UML

访问者模式

Visitor

public abstract class VisitorPlayer {public abstract void visit(ConcreteElementGuangYu guangYu);
    public abstract void visit(ConcreteElementMaKe maKe);
}

Element

public abstract class ElementHero {public abstract void accept(VisitorPlayer visitorPlayer);

    public void normalAttack() {System.out.println("浦东公鸡");
    }
    public abstract void firstSkill();
    public abstract void secondSkill();
    public abstract void thirdSkill();}

ConcreteElement

public class ConcreteElementGuangYu extends ElementHero{
    @Override
    public void accept(VisitorPlayer visitorPlayer) {System.out.println("您已抉择英雄");
        visitorPlayer.visit(this);
    }


    @Override
    public void firstSkill() {System.out.println("单刀赴会");
    }

    @Override
    public void secondSkill() {System.out.println("青龙偃月");
    }

    @Override
    public void thirdSkill() {System.out.println("刀锋铁骑");
    }
}

public class ConcreteElementMaKe extends ElementHero{
    @Override
    public void accept(VisitorPlayer visitorPlayer) {System.out.println("您曾经抉择该英雄");
        visitorPlayer.visit(this);
    }

    @Override
    public void firstSkill() {System.out.println("富丽左轮");
    }

    @Override
    public void secondSkill() {System.out.println("漫游之枪");
    }

    @Override
    public void thirdSkill() {System.out.println("狂热弹幕");
    }
}

ConcreteVisitor

public class ConcreteVisitorPlayerA extends VisitorPlayer{

    @Override
    public void visit(ConcreteElementGuangYu guangYu) {guangYu.thirdSkill();
        guangYu.secondSkill();
        guangYu.normalAttack();
        guangYu.normalAttack();
        guangYu.normalAttack();
        guangYu.firstSkill();}

    @Override
    public void visit(ConcreteElementMaKe maKe) {maKe.secondSkill();
        maKe.firstSkill();
        maKe.normalAttack();
        maKe.normalAttack();
        maKe.thirdSkill();}
}

public class ConcreteVisitorPlayerB extends VisitorPlayer {
    @Override
    public void visit(ConcreteElementGuangYu guangYu) {guangYu.normalAttack();
        guangYu.normalAttack();
        guangYu.firstSkill();
        guangYu.normalAttack();}

    @Override
    public void visit(ConcreteElementMaKe maKe) {maKe.secondSkill();
        maKe.firstSkill();
        maKe.normalAttack();
        maKe.firstSkill();
        maKe.secondSkill();}
}

为了更方便使用，个别还有有一个 ObjectStructure 类，这个类次要是为了构建构造关系的

ObjectStructure

public class ObjectStructure {private List<ElementHero> elementHeroes = new ArrayList<>();

    public void attach(ElementHero hero) {elementHeroes.add(hero);
    }

    public void detach(ElementHero hero) {elementHeroes.remove(hero);
    }

    public void accept(VisitorPlayer player) {for (ElementHero elementHero : elementHeroes) {elementHero.accept(player);
        }
    }

}

Client

public class Client {public static void main(String[] args) {ObjectStructure objectStructure = new ObjectStructure();
        objectStructure.attach(new ConcreteElementGuangYu());
        objectStructure.attach(new ConcreteElementMaKe());

        ConcreteVisitorPlayerA concreteVisitorPlayerA = new ConcreteVisitorPlayerA();
        ConcreteVisitorPlayerB concreteVisitorPlayerB = new ConcreteVisitorPlayerB();

        System.out.println("玩家 A 开始操作");
        objectStructure.accept(concreteVisitorPlayerA);
        System.out.println("玩家 B 开始操作");
        objectStructure.accept(concreteVisitorPlayerB);

    }
}

常识就在那里，差距就是有的人学了有的人没学。