适配器
把一个类接口转换成另一个用户需要的接口。
实现方式
鸭子(Duck)和火鸡(Turkey)拥有不同的叫声,Duck 的叫声调用 quack() 方法,而 Turkey 调用 gobble() 方法。
要求将 Turkey 的 gobble() 方法适配成 Duck 的 quack() 方法,从而让火鸡冒充鸭子!
public interface Duck {
void quack();
}
public interface Turkey {
void gobble();
}
public class WildTurkey implements Turkey {
@Override
public void gobble() {
System.out.println("gobble!");
}
}
public class TurkeyAdapter implements Duck {
Turkey turkey;
public TurkeyAdapter(Turkey turkey) {
this.turkey = turkey;
}
@Override
public void quack() {
turkey.gobble();
}
}
public class Client {
public static void main(String[] args) {
Turkey turkey = new WildTurkey();
Duck duck = new TurkeyAdapter(turkey);
duck.quack();
}
}
桥接
将抽象与实现分离开来,使它们可以独立变化。
定义
- Abstraction:定义抽象类的接口
- Implementor:定义实现类接口
实现方式
桥接模式将品牌和内存两个维度分离开来,从而可以独立改变品牌或者内存的实现。
interface Memory {
public void addMemory();
}
class Memory6G implements Memory{
@Override
public void addMemory() {
System.out.println("6G");
}
}
class Memory8G implements Memory{
@Override
public void addMemory() {
System.out.println("8G");
}
}
abstract class Phone{
public Memory phoneMemory;
public void setPhoneMemory(Memory phoneMemory) {
this.phoneMemory = phoneMemory;
}
public abstract void buyPhone();
}
class HuaWei extends Phone{
@Override
public void buyPhone() {
phoneMemory.addMemory();
System.out.println("华为");
}
}
class Mi extends Phone{
@Override
public void buyPhone() {
phoneMemory.addMemory();
System.out.println("小米");
}
}
public class Test {
public static void main(String[] args) {
Phone huawei = new HuaWei();
huawei.setPhoneMemory(new Memory6G());
huawei.buyPhone();
Phone mi = new Mi();
mi.setPhoneMemory(new Memory8G());
mi.buyPhone();
}
}
为什么使用桥接模式不使用继承呢?
继承是一种强耦合关系,子类与父类有非常紧密的依赖关系,父类的任何变化 都会导致子类发生变化。因此才使用桥接模式,使用了桥接模式之后,我们的两个维度就像桥梁一样被链接了起来。体现了松耦合的特性。
装饰
为对象动态添加功能。
实现方式
设计不同种类的饮料,饮料可以添加配料,比如可以添加牛奶,并且支持动态添加新配料。每增加一种配料,该饮料的价格就会增加,要求计算一种饮料的价格。
public interface Beverage {
double cost();
}
public class HouseBlend implements Beverage {
@Override
public double cost() {
return 1;
}
}
public abstract class CondimentDecorator implements Beverage {
protected Beverage beverage;
}
public class Milk extends CondimentDecorator {
public Milk(Beverage beverage) {
this.beverage = beverage;
}
@Override
public double cost() {
return 1 + beverage.cost();
}
}
public class Mocha extends CondimentDecorator {
public Mocha(Beverage beverage) {
this.beverage = beverage;
}
@Override
public double cost() {
return 1 + beverage.cost();
}
}
public class Client {
public static void main(String[] args) {
Beverage beverage = new HouseBlend();
beverage = new Mocha(beverage);
beverage = new Milk(beverage);
System.out.println(beverage.cost());
}
}
设计原则
类应该对扩展开放,对修改关闭:也就是添加新功能时不需要修改代码。饮料可以动态添加新的配料,而不需要去修改饮料的代码。
不可能把所有的类设计成都满足这一原则,应当把该原则应用于最有可能发生改变的地方。
享元
利用共享的方式来支持大量细粒度的对象,这些对象一部分内部状态是相同的。
定义
说到享元模式,第一个想到的应该就是池技术了,String常量池、数据库连接池、缓冲池等等都是享元模式的应用,所以说享元模式是池技术的重要实现方式。
比如我们每次创建字符串对象时,都需要创建一个新的字符串对象的话,内存开销会很大,所以如果第一次创建了字符串对象“adam“,下次再创建相同的字符串”adam“时,只是把它的引用指向”adam“,这样就实现了”adam“字符串再内存中的共享。
举个最简单的例子,网络联机下棋的时候,一台服务器连接了多个客户端(玩家),如果我们每个棋子都要创建对象,那一盘棋可能就有上百个对象产生,玩家多点的话,因为内存空间有限,一台服务器就难以支持了,所以这里要使用享元模式,将棋子对象减少到几个实例。下面给出享元模式的定义。
实现方式
public interface Flyweight {
void doOperation(String extrinsicState);
}
public class ConcreteFlyweight implements Flyweight {
private String intrinsicState;
public ConcreteFlyweight(String intrinsicState) {
this.intrinsicState = intrinsicState;
}
@Override
public void doOperation(String extrinsicState) {
System.out.println("Object address: " + System.identityHashCode(this));
System.out.println("IntrinsicState: " + intrinsicState);
System.out.println("ExtrinsicState: " + extrinsicState);
}
}
public class FlyweightFactory {
private HashMap<String, Flyweight> flyweights = new HashMap<>();
Flyweight getFlyweight(String intrinsicState) {
if (!flyweights.containsKey(intrinsicState)) {
Flyweight flyweight = new ConcreteFlyweight(intrinsicState);
flyweights.put(intrinsicState, flyweight);
}
return flyweights.get(intrinsicState);
}
}
public class Client {
public static void main(String[] args) {
FlyweightFactory factory = new FlyweightFactory();
Flyweight flyweight1 = factory.getFlyweight("aa");
Flyweight flyweight2 = factory.getFlyweight("aa");
flyweight1.doOperation("x");
flyweight2.doOperation("y");
}
}
Object address: 1163157884
IntrinsicState: aa
ExtrinsicState: x
Object address: 1163157884
IntrinsicState: aa
ExtrinsicState: y
从这个结果我们可以看出来,第一次创建 aa 时,都是先创建再从池中取出,而第二次创建 aa 时,因为池中已经存在了,所以直接从池中取出,这就是享元模式。
本文参考CS-Note、简说设计模式——享元模式