适配器模式：将一个现有类实现的功能接口转变为客户希望的接口
场景：你想使用一个已经存在的类，但是这个类的接口不符合需求，所以需要适配
有2中实现：一种是继承，一种是委托，先来看看继承
第一步：系统现有功能
package com.google.desginpattern.adapter;
/**
* 现有系统提供的功能
*
* @author Administrator
*
*/
public class BMWCar {
public void quickDriver() {
System.out.println("宝马太快");
}
}
第二步：客户需要的接口
package com.google.desginpattern.adapter;
/**
* 客户需要的接口
* @author Administrator
*
*/
public interface Car {
public void driver();
public void brake();
}
第三步：实现客户需要的功能
package com.google.desginpattern.adapter;
/**
* 匹配客户需求的实现
* @author Administrator
*
*/
public class CarAdapter extends BMWCar implements Car {
@Override
public void brake() {
System.out.println("刹车");
}
@Override
public void driver() {
quickDriver();
}
}
测试类：
package com.google.desginpattern.adapter;
public class Test 
{
public static void main(String[] args) {
Car car = new CarAdapter();
car.brake();
car.driver();
}
}
输出：
刹车
宝马太快
如果是委托的方式，改写adapter
package com.google.desginpattern.adapter;
/**
* 匹配客户需求的实现
*
* @author Administrator
*
*/
public class CarAdapter implements Car {
private BMWCar car;
@Override
public void brake() {
System.out.println("刹车");
}
@Override
public void driver() {
car.quickDriver();
}
public BMWCar getCar() {
return car;
}
public void setCar(BMWCar car) {
this.car = car;
}
}
装饰器：装饰器模式主要用于系统扩张功能用，在系统原有的功能上，扩展出其他的功能，JDK中IO包用到很多，比如datainputstream之类，需要用其他流进行构造的上层类，符合面向对象设计的开闭原则
下面我来写个例子：
首先，写一个Car模版，定义基本属性及行为功能driver
package com.google.desginpattern.decoration;
//其实这是个模版
public abstract class Car {
private int spreed;
public int getSpreed() {
return spreed;
}
public void setSpreed(int spreed) {
this.spreed = spreed;
}
public abstract void driver();
}
第二步：具体车比如宝马，这是目前系统中这个类能提供的功能
package com.google.desginpattern.decoration;
//目前系统中此类的功能
public class BMWCar extends Car {
@Override
public void driver() {
System.out.println("我开着宝马车");
}
}
现在我想在这个类上扩展出其他功能，比如：泡妞
第三步：定义一个装饰模板，为什么给他定义个模板呢~因为可以给这个BMWCar类装饰很不同的功能，不只泡妞一个~
继承Car父类，覆盖driver功能，调用Car引用完成driver功能
package com.google.desginpattern.decoration;
//装饰器父类
public abstract class DecorationCar extends Car {
// 引入car
private Car car;
@Override
public void driver() {
car.driver();// 调用此car来完成装饰器的功能
}
public Car getCar() {
return car;
}
public void setCar(Car car) {
this.car = car;
}
}
第四步：具体的装饰功能，添加一个构造函数，参数为Car,为装饰父类Car引用赋值，其实就是原来具体的功能类，回想下IO包里经常new的代码段就明白~~
package com.google.desginpattern.decoration;
//具体的装饰类,添加额外的泡妞功能
public class DecorationBMWCar extends DecorationCar {
public DecorationBMWCar(Car car) {
super.setCar(car);
}
@Override
public void driver() {
// TODO Auto-generated method stub
super.driver();// 调用原来的功能
System.out.println("泡妞");// 添加额外的功能
}
}
测试类：构造的方法很像IO包里的流
package com.google.desginpattern.decoration;
public class Test {
public static void main(String[] args) {
Car car = new DecorationBMWCar(new BMWCar());
car.driver();
}
}
输出：
我开着宝马车
泡妞