继承，装饰模式，动态代理

继承，装饰模式，动态代理都是实现了对方法得扩展。

1.猫

定义接口：

public interface Cat {
    public void run();
    public void eat();
}

实现普通得猫：

public class Mycat implements Cat {
    @Override
    public void run() {
        System.out.println("cat is running...");
    }

    @Override
    public void eat() {
        System.out.println("cat is eating...");
    }
}

2.使用继承来增强猫的run方法

public class MycatExtends extends Mycat{
    public void run() {
        System.out.println("cat run method extends...");
        super.run();
    }

    public void eat() {
        System.out.println("cat eat method extends...");
        super.eat();
    }
}

测试使用

 System.out.println("====================extends猫====================");
        //extends猫
        MycatExtends mycatExtends = new MycatExtends();
        mycatExtends.run();
        mycatExtends.eat();

控制台输出：

====================extends猫====================
cat run method extends...
cat is running...
cat eat method extends...
cat is eating...

继承相对爱说较为冗余：不同类型的Mycat（假设：跑得快的一种猫叫做Mycat1和特别能吃的一种猫叫做Mycat2）的在被使用的时候，都需要分别继承Mycat来重写他们的Mycat1.run()或者Mycat2.eat()方法。

3.装饰模式

/*装饰设计模式 :装饰者和被装饰者
 *用的时候, 要满足两个条件:
 *第一个:装饰者和被装饰者必须要实现同样的接口或者有共同父类
 *第二个:被装饰者必须要传递给装饰者，即：装饰者持有对被装饰者的引用
 */
public class MycatDecorator implements Cat {
    private Cat cat;//被装饰者

    public MycatDecorator(Cat cat){
        this.cat=cat;
    }

    public void run() {
        //添加加强的内容
        System.out.println("cat run method decorator...");
        //调用 原有的方法
        cat.run();
    }

    @Override
    public void eat() {
        //添加加强的内容
        System.out.println("cat eat method decorator...");
        //调用 原有的方法
        cat.run();
    }
}

测试使用：

System.out.println("====================decorator猫====================");
        MycatDecorator mycatDecorator = new MycatDecorator(new Mycat());
        mycatDecorator.run();
        mycatDecorator.eat();

控制台输出：

====================decorator猫====================
cat run method decorator...
cat is running...
cat eat method decorator...
cat is running...

装饰模式解决了一个问题，MycatDecorator可以对所有实现了Cat接口的类进行增强操作。Mycat类实现了Cat接口，MycatDecorator可以对Mycat增强run，eat方法，并且必须同时重写run和eat方法。当然，如果此时，HerCat也实现了Cat接口，我们也可以对HerCat的run和eat方法增强。

4.代理模式

import org.junit.Test;
/*
 * @author qianliu on 2019/1/27 17:05
 * @Discription:对猫的run方法进行加强
 */
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class MycatProxy {
    @Test
    public Object getProxyInstance(){
        final Cat cat=new Mycat();//要代理的猫对象【代理】

        //获取需要代理的类加载器，和被代理类实现的接口
        ClassLoader loader = MycatProxy.class.getClassLoader();
        Class<?>[] interfaces = cat.getClass().getInterfaces();

        //代理猫对象
        //loader:任意的类加载器都行
        //interfaces:要的是真是的要产生是哪个类的代理对象
        Cat proxyCat=(Cat) Proxy.newProxyInstance(loader, interfaces, new InvocationHandler(){

            /*解释：本代码作用---调用了，代理对象的一个方法，其中：方法里面的参数是什么也在这里说明了
             *
             * @param proxy---代理对象
             * @param method---调用的方法的对象（将调用方法当作一个method对象传递进来）
             * @param args---将调用方法的时候，传递的参数封装到一个Object[]中传递进来
             * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {

                //当调用了代理对象ProxyCat的run（）方法时，执行此段代码
                if(method.getName().equals("run")){

                    //结果：加强run方法+原有run方法

                    //加强原来的run方法
                    System.out.println("cat run method proxy...");
                    //调用原来的run方法
                    return method.invoke(cat, args);//cat对象的原有的方法
                }
                else{
                    System.out.println("方法名:"+method.getName());
                    //当代理猫(ProxyCat)调用普通猫（Cat）的除了run方法以外的方法时，直接返回普通猫的该方法
                    return method.invoke(cat, args);//cat对象的原有的方法
                }
            }

        });
        return proxyCat;
    }
}

测试使用：

System.out.println("====================MycatProxy猫====================");
        Cat proxyCat = (Cat) new MycatProxy().getProxyInstance();
        proxyCat.run();
        proxyCat.eat();

控制台输出：

====================MycatProxy猫====================
cat run method proxy...
cat is running...
方法名:eat
cat is eating...

代理模式相比于装饰模式的优势是，我们可以指定需要增强的方法是哪一个，其他的方法可以不用重写。

参考文献：
https://blog.csdn.net/a15920804969/article/details/78512386
https://blog.csdn.net/wang1171405487/article/details/80632060#commentBox
https://blog.csdn.net/qq_32101859/article/details/50733543