结构类模式PK

结构类模式包括：

适配器模式，代理模式，装饰者模式，桥梁模式，组合模式，，门面模式，享元模式。共7个模式。

这些模式的pk主要集中在，适配器模式，代理模式和装饰者模式。
桥梁模式是：工厂生产产品的场景，把产品和工厂就行解藕，代替继承。
门面模式：是邮局的场景，对子系统进行封装
享元模式：是共享细粒度对象。是考试报名系统的场景。
组合模式：是公司人事架构的场景，经理，普通员工都是员工。

代理模式和装饰者模式

装饰者模式是代理模式的一个特殊应用，两者的共同点是都具有相同的接口。
不同点在于代理模式着重对代理过程的控制，
而装饰者模式是对类的功能进行增强或者减弱，它着重类的功能变化。

代理模式：一个运动员，和一个自己的代理人，代理人可以控制运动员跑不跑

public interface IRunner{

    public void run();
}

public class Runner implements IRunner{

    @Override
    public void run() {
        System.out.println("运动员跑步");
    }
}

public class RunnerAgent implements IRunner{

    private IRunner runner;
    public RunnerAgent(IRunner runner){
        this.runner=runner;
    }
    @Override
    public void run() {
        Random rand=new Random();
        if(rand.nextBoolean()){
            System.out.println("代理人同意安排运动员跑步");
            runner.run();
        }else{
            System.out.println("代理人心情不好，不安排运动员跑步");
        }
    }
}

public class Client{
    
    public static void main(String[] args){
        IRunner liu=new Runner();
        
        IRunner agent=new RunnerAgent(liu);
        System.out.println("客人要代理人安排跑步");
        agent.run();
    }
}

而装饰者是对类功能的加强，比如装饰者模式是增强运动员跑步，比如添加火箭助力设备，跑的更快。

public class RunnerWithJet implements IRunner{

    private Runner runner;
    public RunnerWithJet(IRunner runner){
        this.runner=runner;
    }
    @Override
    public void run() {
        System.out.println("火箭助力");
        runner.run();
    }
}
public class Client{

    public static void main(String[] args){
        IRunner liu=new Runner();

        liu=new RunnerWithJet(liu);
        System.out.println("增强后的运动员功能");
        liu.run();
    }
}

代理模式的极致是aop 而装饰者模式在jdk的java.io.*中有大量体现
比如 OutptuStream out=new DataOutputStream(new FileOutputStream("xx.txt"));

装饰者和适配器模式

装饰者包装的是自己的兄弟类，属于同一个接口或父类。 适配器模式则修饰非血缘关系，是把一个类伪装成另一个类。 在类图上差别就很大。
适配器模式是继承一个类，并实现一个类。
继承的类是一个源目标类 ，实现的类是要转变的目标类

用装饰者模式描述丑小鸭。

public interface Swan{
    public void fly();
    public void cry();
    public void desAppearance();
}

public class UglyDuckling implements Swan{

    @Override
    public void fly() {
        System.out.println("天鹅的叫");
    }

    @Override
    public void cry() {
        System.out.println("不会飞");
    }

    @Override
    public void desAppearance() {
        System.out.println("丑小鸭的外形");
    }
}

public class Decorator implements Swan{

    private Swan swan;

    public Decorator(Swan swan) {
        this.swan = swan;
    }

    @Override
    public void fly() {
        swan.fly();
    }

    @Override
    public void cry() {
        swan.cry();
    }

    @Override
    public void desAppearance() {
        swan.desAppearance();
    }
}

public class BeautifulAppearance extends Decorator{

    public BeautifulAppearance(Swan swan) {
        super(swan);
    }
    @Override
    public void desAppearance(){
        System.out.println("天鹅的外形");
    }
}

public class StrongBehaviour extends  Decorator{

    public StrongBehaviour(Swan swan) {
        super(swan);
    }
    
    @Override
    public void fly(){
        System.out.println("会飞了");
    }
}

public class Client{
    
    public static void main(String[] args){
        Swan duckling=new UglyDuckling();
        
        duckling.desAppearance();
        duckling.cry();
        duckling.fly();
        
        //装饰者增强变成天鹅
        duckling=new BeautifulAppearance(duckling);
        duckling=new StrongBehaviour(duckling);
        //表现的不一样了
        duckling.desAppearance();
        duckling.cry();
        duckling.fly();
    }
}

适配器实现丑小鸭，就是把一只是天鹅的小东西表现的像丑小鸭。


public interface Duck{

    public void cry();
    public void desAppearance();
    public void desBehaviour();
}

public class Duckling implements Duck{

    public void cry(){

        System.out.println("丑小鸭的叫");
    }

    public void desAppearance(){
        System.out.println("丑小鸭的外形");
    }
    public void desBehaviour(){
        System.out.println("丑小鸭的行为，游泳");
    }
}

public class WhiteSwan implements Swan{


    @Override
    public void fly() {
        System.out.println("天鹅会飞");
    }

    @Override
    public void cry() {
        System.out.println("天鹅叫的不一样");
    }

    @Override
    public void desAppearance() {
        System.out.println("天鹅外形");
    }
}

public class UglyDuckling extends WhiteSwan implements Duck{

    public void cry() {
        super.cry();
    }

    public void desAppearance(){
        super.desAppearance();
    }
    public void desBehaviour(){
        System.out.println("游泳");
        super.fly();
    }
}

装饰者和适配器的区别：

意图不同。装饰者模式意图是加强对象功能，而适配器是转换，把两个对象进行转换
施加对象不同。装饰者模式装饰的对象是有相同接口或者父类，具有相同的属性和行为。适配器模式对象是两个不同的对象，着重转换
场景不同。装饰者模式适用于想增强类功能，而适配器模式作为一个补救手段，一般在已经成熟的系统中。不可能一设计就来个适配器
扩展性不同。装饰者模式很容易扩展。

结构类模式包括：

装饰者和适配器的区别：

猜你喜欢