什么是行為型模式

本篇內容介紹了“什么是行為型模式”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

空對象模式

這個模式可以說用得比較少，至少再我真正學習之前是沒有用過的，甚至沒有聽過的。在空對象模式中，一個空對象取代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);

    }
}

“什么是行為型模式”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！