增强方法功能的几种方式（应用于自定义数据库连接池等）

方式一：继承/实现父类/接口的方式

特点：

• 必须至少有一个接口或者抽象父类
• 必须实现或者继承这个抽象父类

/*
	通过继承的方式
*/

public interface Phone {
     void call();//打电话
     void sendMessage();//发短信
     void photo();//拍照片
}

public class HuaWei implements Phone{

    @Override
    public void call() {
        System.out.println("打电话");
    }

    @Override
    public void sendMessage() {
        System.out.println("发短信");
    }

    @Override
    //增强
    public void photo() {
        System.out.println("华为手机美颜一下");
        System.out.println("拍照片");
    }
}

public class Vivo implements Phone {

    @Override
    public void call() {
        System.out.println("打电话");
    }

    @Override
    public void sendMessage() {
        System.out.println("发短信");
    }

    @Override
    //增强
    public void photo() {
        System.out.println("Vivo手机美颜一下");
        System.out.println("拍照片");
    }
}

//测试类
public class TestDemo {
    public static void main(String[] args) {
        HuaWei huaWei = new HuaWei();
        huaWei.photo();
        Vivo vivo = new Vivo();
        vivo.photo();
    }
}

缺点

• 耦合度较高，且灵活度很低
• 必须重写所有的父类方法，如果我只想增强某一个方法，但是必须重写所有的方法

方式二：装饰者设计模式

特点

• 必须提供至少一个接口
• 设计一个目标类（被增强类），且必须实现这个接口
• 设计一个装饰类（增强类），且必须实现同一个接口

/*
    顶层接口
 */
public interface PhoneInter {
    void call();//打电话
    void sendMessage();//发短信
    void photo();//拍照片
}

/*
    目标类（被增强类）
 */
public class HuaWei implements PhoneInter{
    @Override
    public void call() {
        System.out.println("打电话");
    }

    @Override
    public void sendMessage() {
        System.out.println("发短信");
    }

    //需要被增强的类
    @Override
    public void photo() {
        System.out.println("拍照片");
    }
}

/*
    装饰类（增强类）
 */
public class HuaWeiWrapper implements PhoneInter {

    //1.引入目标类
    private PhoneInter phone;//这里引入接口（多态）,这样就算目标类再多也没事
    //2.通过有参数构造方法的方式，为其赋值
    public HuaWeiWrapper(PhoneInter phone){
        this.phone = phone;
    }

    @Override
    public void call() {
        System.out.println("打电话");
    }

    @Override
    public void sendMessage() {
        System.out.println("发短信");
    }

    //需要被增强的方法
    @Override
    public void photo() {
        System.out.println("华为手机美颜一下");//增强效果
        phone.photo();
    }
}

/*
    测试类
 */
public class TestDemo {
    public static void main(String[] args) {
        //创建目标类对象
        HuaWei huaWei = new HuaWei();
        huaWei.photo();//拍照片
        //创建装饰类对象
        HuaWeiWrapper huaWeiWrapper = new HuaWeiWrapper(huaWei);
        huaWeiWrapper.photo();//华为手机美颜一下
                             //拍照片
    }
}

缺点：

• 虽然解决了一些灵活度的问题，但是缺点还是很明显的。我只想要增强一个方法，但是他重写了所有的方法，还是不大行。

方式三：适配器设计模式

特点：

• 必须提供至少一个接口
• 提供一个适配器的抽象类，并实现这个接口
• 设计一个目标类（被增强类），继承这个适配器类
• 设计一个装饰类（增强类），也继承这个适配器类

/*
    顶层接口
 */
public interface PhoneInter {
    void call();//打电话
    void sendMessage();//发短信
    void photo();//拍照片
}

/*
    适配器类
 */
public class PhoneAdapter implements PhoneInter {
    @Override
    public void call() {

    }

    @Override
    public void sendMessage() {

    }

    @Override
    public void photo() {

    }
}

/*
    目标类
 */
public class Vivo extends PhoneAdapter{
    @Override
    public void call() {
        System.out.println("打电话");
    }

    @Override
    public void sendMessage() {
        System.out.println("打电话");
    }

    @Override
    public void photo() {
        System.out.println("拍照片");
    }
}

/*
    装饰类
 */
public class VivoWrapper extends PhoneAdapter{
    //引入目标类
    private Vivo vivo;
    //通过有参构造的方式，为其赋值
    public VivoWrapper(Vivo vivo){
        this.vivo = vivo;
    }

    //增强类
    @Override
    public void photo() {
        System.out.println("vivo手机美颜一下");//增强效果
        vivo.photo();
    }
}

缺点：

• 好处是解决了代码全部重写的问题，如果只想增强某一个方法，就只增强它即可。
• 缺点是无论怎么适配，都需要去实现接口，重写里面的方法，相对来说，代码比较繁琐。

方式四：通过动态代理的方式

特点：

• 至少提供一个接口即可，通过基于jdk动态代理的方式增强其方法

/*
    提供一个接口
 */
public interface SellComputer {
    Double sellPc(double money);
    Double sellData(double money);
}

/*
    目标类（被增强类）
 */
public class Lenovo implements SellComputer{
    @Override
    public Double sellPc(double money) {
        System.out.println("从联想公司拿货价："+money);
        return money;
    }

    @Override
    public Double sellData(double money) {
        return null;
    }
}

/*
    代理类（增强类）
 */
public class Proxy_Demo {
    public static void main(String[] args) {
        //1.创建一个目标类对象
        Lenovo lenovo = new Lenovo();
        //2.对目标类对象进行代理
        ClassLoader cl = Proxy_Demo.class.getClassLoader();//应用类加载器
        Class[] cs = {SellComputer.class};//目标类的接口数组
         SellComputer proxy = (SellComputer) Proxy.newProxyInstance(cl, cs, new InvocationHandler() {
            @Override
           public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                /*
                  参数一：proxy就是代理对象
                  参数二: method 指的目标类的方法对象
                  参数三：args: 指的目标类的方法参数
             */
                System.out.println("买家花了："+args[0]);
                //增强效果，这里只演示下对参数进行增强
                System.out.println("代理商扣除代理费："+Double.parseDouble(String.valueOf(args[0]))*0.2);
                return   method.invoke(lenovo,Double.parseDouble(String.valueOf(args[0]))*0.8);//通过反射机制：去执行目标类的方法
            }
        });
        //测试：
        proxy.sellPc(8000.00);
        /*
                买家花了：8000.0
                代理商扣除代理费：1600.0
                从联想公司拿货价：6400.0
         */
    }
}

方式二、三、四可以实现比如自定义数据库连接池对close()方法的增强，让其并非销毁，而是回归到池中。