首页
登录 | 注册

Java设计模式——装饰器模式、适配器模式、外观模式

什么是装饰器模式

装饰器模式,动态的将责任附加到对象上,若要扩展功能,装饰器提供了比继承更有弹性的替代方案。

举例说明

我们定义一种饮料,它有描述信息,还有价格,如下

public abstract class Drink {

    String desc = "nothing";

    public String getDesc() {
        return desc;
    }

    public abstract double cost();
}

然后定义咖啡,是一种饮料,它有自己的描述和价格

public class Coffee extends Drink {

    public Coffee() {
        this.desc = "Coffee";
    }

    public double cost() {
        return 1.2;
    }
}

咖啡可以有不同的口味,而且不同的口味所需要的额外价格不同,这时可以用装饰器方法来实现口味对饮料的装饰,如下:

public class Milk extends Drink {

    private Drink drink;

    public Milk(Drink water) {
        this.drink = water;
    }

    public double cost() {
        return drink.cost() + 1;
    }

    @Override
    public String getDesc() {
        return drink.getDesc() + ", Milk";
    }
}

下面我们创建一个测试类,要演示如何动态的装饰。如下:

class Test {
    public static void main(String[] args){
        Drink drink = new Coffee();
        System.out.println(drink.getDesc() + ", cost " + drink.cost());
        drink = new Milk(drink);
        System.out.println(drink.getDesc() + ", cost " + drink.cost());
        drink = new Milk(drink);
        System.out.println(drink.getDesc() + ", cost " + drink.cost());
    }
}

输出结果为:

Coffee, cost 1.2
Coffee, Milk, cost 2.2
Coffee, Milk, Milk, cost 3.2

适配器模式

将一个类的接口,转换成客户期望的另一个接口。适配器让原本接口不兼容的类可以合作无间。
比如我们鸭子类,鹅类,他们有自己的叫的方法和飞行的方法如下:

public interface Duck {

    void quack();

    void fly();
}


public class AKindDuck implements Duck {

    public void quack() {
        System.out.println("A kind duck quack");
    }

    public void fly() {
        System.out.println("A kind duck fly");
    }
}

鹅类

public interface Turkey {

    void gobble();

    void fly();
}


public class WildTurkey implements Turkey {

    public void gobble() {
        System.out.println("wild gobble");
    }

    public void fly() {
        System.out.println("wild run");
    }
}

为了让鹅类能适配成鸭子类,我们制作一个适配器

public class TurkeyAdapter implements Duck {

    private Turkey turkey;

    public TurkeyAdapter(Turkey turkey) {
        this.turkey = turkey;
    }

    public void quack() {
        turkey.gobble();
    }

    public void fly() {
        turkey.fly();
        turkey.fly();
    }
}

我们创建一个测试类来说明适配的结果:

class Test {

    public static void main(String[] args){
        Duck duck = new AKindDuck();
        Turkey turkey = new WildTurkey();

        Duck duckAdapter = new TurkeyAdapter(turkey);
        duck.quack();
        duck.fly();
        System.out.println();

        turkey.gobble();
        turkey.fly();
        System.out.println();

        duckAdapter.quack();
        duckAdapter.fly();
    }
}

输出结果为:

A kind duck quack
A kind duck fly

wild gobble
wild run

wild gobble
wild run
wild run

外观模式

提供了一个统一的接口,用来访问子系统中的一群接口。外观定义了一个高层接口,让子系统更容易使用。
比如看电影需要很多步骤,而我们可以把这很多种步骤封装在一个接口中叫做watchMovie()提供给外界。结束电影封装为endMovie()提供给外界。如下所示:

public class Movie {

    public void watchMovie() {
        ActionA();
        ActionC();
    }

    public void endMovie() {
        ActionB();
        ActionD();
    }

    private void ActionA(){}
    private void ActionB(){}
    private void ActionC(){}
    private void ActionD(){}
}


2020 jeepxie.net webmaster#jeepxie.net
10 q. 0.009 s.
京ICP备10005923号