什么是结构型模式

本篇内容主要讲解“什么是结构型模式”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“什么是结构型模式”吧!

10年积累的成都做网站、网站制作经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先做网站设计后付款的网站建设流程，更有绥宁免费网站建设让你可以放心的选择与我们合作。

桥接模式

桥接模式的目标是将抽象与实现解耦，使得两者可以独立地变化。桥接模式通过在公共接口和实现中使用继承来达到目的。

比如手机可以有多个品牌，那么可以把手机抽象出来；每个手机可以有多种实现，比如颜色不同、尺寸不同、性能不同和系统不同等等。

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 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 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
    }
}

到此，相信大家对“什么是结构型模式”有了更深的了解，不妨来实际操作一番吧！这里是创新互联网站，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！