什么是結構型模式

本篇內容主要講解“什么是結構型模式”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“什么是結構型模式”吧!

橋接模式

橋接模式的目標是將抽象與實現解耦，使得兩者可以獨立地變化。橋接模式通過在公共接口和實現中使用繼承來達到目的。

比如手機可以有多個品牌，那么可以把手機抽象出來；每個手機可以有多種實現，比如顏色不同、尺寸不同、性能不同和系統不同等等。

Abstraction： 抽象類

Implementation： 抽象的實現類

Refined： 擴充的抽象類

Specific Implementation： 具體實現類。

橋接模式UML類圖

橋接模式

Abstraction

public abstract class AbstractionPhone {
    Implementor implementor;

    public Implementor getImplementorAppearance() {
        return implementor;
    }

    public void setImplementorAppearance(Implementor implementor) {
        this.implementor = implementor;
    }

    public abstract void operation();
}

Refined

public class RefineAbstractionOnePlus extends AbstractionPhone {

    @Override
    public void operation() {
        System.out.println("一加手機");
        implementor.operation();
    }
}

public class RefinedAbstractionPhoneApple extends AbstractionPhone {


    @Override
    public void operation() {
        System.out.println("蘋果手機");
        implementor.operation();
    }
}

Implementor

public abstract class Implementor {
    public abstract void operation();
}

Concrete Implementor

public class ConcreteImplementorColor extends Implementor {
    @Override
    public void operation() {
        System.out.println("手機有關顏色的實現");
    }
}

public class ConcreteImplementorSize extends Implementor {
    @Override
    public void operation() {
        System.out.println("有關手機尺寸大小的實現");
    }
}

Client

public class Client {
    public static void main(String[] args) {
        AbstractionPhone phone = new RefineAbstractionOnePlus();
        phone.setImplementorAppearance(new ConcreteImplementorColor());
        phone.operation();
        phone.setImplementorAppearance(new ConcreteImplementorSize());
        phone.operation();
    }
}

組合模式

組合模式顧名思義就是把一組對象組合成一個復雜的單一整體，比如把對象組合成樹形或者圖形結構。

最簡單常見的就是公司里面的人員分布，所有的員工是很復雜很多的，但是從CEO到最底層的員工會形成一個樹結構。

組合模式

Component

public abstract class ComponentEmployee {
    String name;      //名字
    String position;   //職位
    String salary;    //薪水

    //報告人員情況
    public void report() {
        String str =  "Employee{">

Composite

public class CompositeLeader extends ComponentEmployee {
    
    //這里本來應該是private，然后外部通過get獲取才合適，為了演示
    List<ComponentEmployee> subComponentEmployees;

    public CompositeLeader(String name, String position, String salary) {
        super(name, position, salary);
        //new一個下一層員工的List集合
        subComponentEmployees = new ArrayList<>();
    }

    @Override
    public void addEmployee(ComponentEmployee componentEmployee) {
        subComponentEmployees.add(componentEmployee);
    }

    @Override
    public void deleteEmployee(ComponentEmployee componentEmployee) {
        subComponentEmployees.remove(componentEmployee);
    }

    @Override
    public void report() {
        System.out.println("我的情況：");
        super.report();

        System.out.println("我手下員工的情況");

        for (ComponentEmployee e: subComponentEmployees) {
            e.report();
        }
    }
}

Leaf

public class LeafStaff extends ComponentEmployee {
    public LeafStaff(String name, String position, String salary) {
        super(name, position, salary);
    }

    //手底都沒有員工，增加和刪除操作就空實現，注意這里的空實現
    @Override
    public void addEmployee(ComponentEmployee componentEmployee) {

    }

    @Override
    public void deleteEmployee(ComponentEmployee componentEmployee) {

    }

    @Override
    public void report() {
        super.report();
    }
}

可以注意到葉子結點里面有兩個是空實現（因為最底層的員工手下沒有其它員工），這樣是不太安全的做法。很簡單，只要Component 中的兩個抽象方法刪掉即可，然后在Composite 里面是新增方法，而不是重寫方法。

外觀模式(門面模式)

門面模式的目的是為復雜的子系統提供單一的統一的接口，這樣客戶端只需要了解結果，不必了解各個子系統間是如何運作的。

比如甲方盡管給產品經理提需求，他只要成品，至于說公司的內部是如調配如何完成，客戶一概不理也沒必要知道。

Facade： 子系統接口

SubSystem： 子系統中定義的類

門面模式UML類圖

門面模式

Facade

public class FacadeLeader {
    private SubSystemArt subSystemArt = new SubSystemArt();
    private SubSystemDevelopment subSystemDevelopment = new SubSystemDevelopment();
    private SubSystemOperations subSystemOperations = new SubSystemOperations();

    //暴露給外界的方法，外界不知道具體內部是誰來干，干什么
    public void needArt() {
        subSystemArt.art();
    }

    public void needDevelop() {
        subSystemDevelopment.develop();
    }

    public void needOperation() {
        subSystemOperations.operate();
    }

}

SubSystem

public class SubSystemArt {
    public void art() {
        System.out.println("美工部門正在畫圖");
    }
}

public class SubSystemDevelopment {
    public void develop() {
        System.out.println("開發部門正在開發");
    }
}

public class SubSystemOperations {
    public void operate() {
        System.out.println("運維部門正在測試！");
    }
}

Client

public class Client {

    public static void main(String[] args) {
        FacadeLeader facadeLeader = new FacadeLeader();
        System.out.println("我們需要這個需求");
        facadeLeader.needArt();
        facadeLeader.needDevelop();
        facadeLeader.needOperation();
    }
    
}

享元模式

享元模式，聽起來很高大上，但是實際上就是共享對象的一種模式。目的是通過在相似對象間的共享狀態來減少內存占用。

比如王者里面的小兵在一定時間內攻擊、雙抗，移動速度都是一定的，那么就是通過享元模式來減少對象的生成，從而使得內存消耗較少。而對于那些打完主宰后的兵，因為不是重復的，所以可以作為非共享的狀態。

Flyweight： 抽象享元類

Concrete Flyweight： 與其同伴共享狀態的享元對象

Unshared Concrete Flyweight： 不共享其狀態的享元對象

Flyweight Factory： 享元工廠類

享元模式UML類圖

享元模式

Flyweight

public abstract class FlyweightSoldier {
    public abstract void play();
}

Concrete Flyweight

public class ConcreteFlyweightNormalSoldier extends FlyweightSoldier {
    String type;

    public ConcreteFlyweightNormalSoldier(String type) {
        this.type = type;
    }

    @Override
    public void play() {
        System.out.println("生成小兵：" + type);
    }
}

Unshared Concrete Flyweight

public class UnsharedConcreteFlyweightGeneral extends FlyweightSoldier {
    @Override
    public void play() {
        System.out.println("根據不同情況生成的龍");
    }
}

Flyweight Factory

public class FlyweightFactory {
    private Hashtable<String, FlyweightSoldier> flyweights = new Hashtable<>();

    public ConcreteFlyweightNormalSoldier getSoldier(String key) {
        if (!flyweights.contains(key)) {
            flyweights.put(key, new ConcreteFlyweightNormalSoldier(key));
        }

        return (ConcreteFlyweightNormalSoldier) flyweights.get(key);
    }

    public UnsharedConcreteFlyweightGeneral getGeneral(String key) {
        flyweights.put(key, new UnsharedConcreteFlyweightGeneral());
        return (UnsharedConcreteFlyweightGeneral) flyweights.get(key);
    }
}

這里注意了，因為普通小兵是共享的，所以當有key的時候就不用再new一個小兵，直接返回即可；而對于特殊小兵來說，不管是否有key，都會new一個兵put進去。

Client

public class Client {
    public static void main(String[] args) {
        FlyweightFactory factory = new FlyweightFactory();

        for (int i = 0; i < 3; i++) {
            System.out.println("第" + i + 1 + "波兵線");
            factory.getSoldier("近戰兵").play();
            factory.getSoldier("弓箭手").play();
            factory.getSoldier("法師兵").play();
        }
        //到這里其實只創建了三個對象

        for (int i = 0; i < 2; i++) {
            System.out.println("第" + i + "波特殊兵線");
            factory.getGeneral("減雙抗龍").play();
            factory.getGeneral("減攻速龍").play();
        }
        //到這里創建了7個對象，3 + 4
    }
}

到此，相信大家對“什么是結構型模式”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！