對java方法進行功能增強的方法

1.通過繼承的方式

　　對哪個類中的方法進行增強，可以采用繼承那個類的方式。通過繼承該類，可以重寫方法，如果還需要老方法的一些功能，使用super調用。

1 //需要增強類的study方法
2 public class Person {
3     public void  study(){
4         System.out.println("需要擴展的方法");
5     }
6 }

1 //繼承需要增強方法的類，重寫方法
2 public class Student  extends Person{
3     @Override 
4     public
 
 void study(){
5         //方法前後可以增強
6         //有用到原先的方法 super調用父類
7         System.out.println("重寫後的方法");
8     }
9 }

2.通過裝飾者模式

　　　使用條件：需要對某接口或抽象類的實現類中重寫的方法進行功能增強可以使用裝飾者模式。

　　　使用詳解：

　　　　　　第一步：找到需要增強的實現類的接口，或者是抽象類，然後創建一個子類進行實現或者繼承；

　　　　　　第二步：添加私有屬性到創建的類，該私有屬性為接口的實現類。

　　　　　　第三步：寫一個有參構造，參數為接口的實現類，將實現類賦值給私有屬性

　　　　　　第四步：重寫需要增強的方法，這裏面就可以各種增強了

　　　　　　第五步：重寫其他的抽象方法，直接調用需要增強類的方法即可，

簡單的案例：

　　有個家貓類實現類貓科接口，它有個吃的方法，現在有需求它的吃的方法已經不能滿足了，增強它的吃的方法

1 //接口
2 public interface Cat {
3     //吃的方法
4     void eat();
5     //玩的方法
6     void play();
7 }

 1 //需要增強的類
 2 public class HomeCat  implements Cat{
 3 
 4     @Override
 
 5     public void eat() {
 6         // TODO Auto-generated method stub
 7         System.out.println("吃魚的方法");
 8     }
 9 
10     @Override
11     public void play() {
12         // TODO Auto-generated method stub
13         
14     }
15 
16 }

 1 //進行增強的類
 2 public class NewCat implements Cat{
 3     private Cat c;
 4     public  NewCat(Cat c){
 5         this.c=c;
 6     }
 7     //進行增強
 8     @Override
 9     public void eat() {
10         // TODO Auto-generated method stub
11         System.out.println("增強前");
12         c.eat();
13         System.out.println("增強後");
14     }
15 
16     @Override
17     public void play() {
18         // TODO Auto-generated method stub
19         c.play();
20     }
21 
22 }

1 //測試類
2 public class Demo1 {
3     public static void main(String[] args) {
4         NewCat newcat=new NewCat(new HomeCat());
5         newcat.eat();
6     }
7 }

3.動態代理

1 public interface TargetInterface {
2 
3     public void method1();
4     public String method2();
5     public int method3(int x);
6 }

 1 public class ProxyTest2 {
 2 
 3     public static void main(String[] args) {
 4         
 5         final Target target = new Target();
 6         
 7         //動態創建代理對象
 8         
 9         TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
10                 target.getClass().getClassLoader(), 
11                 target.getClass().getInterfaces(), 
12                 new InvocationHandler() {
13                     @Override
14                     //被執行幾次？------- 看代理對象調用方法幾次
15                     //代理對象調用接口相應方法 都是調用invoke
16                     /*
17                      * proxy:是代理對象
18                      * method:代表的是目標方法的字節碼對象
19                      * args:代表是調用目標方法時參數
20                      */
21                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
22                         //反射知識點
23                         Object invoke = method.invoke(target, args);//目標對象的相應方法
24                         //retrun返回的值給代理對象
25                         return invoke;
26                     }
27                 }
28             );
29         
30         proxy.method1();//調用invoke---Method：目標對象的method1方法  args：null  返回值null
31         String method2 = proxy.method2();//調用invoke---Method:目標對象的method2方法  args:null  返回值method2
32         int method3 = proxy.method3(100);////調用invoke-----Method:目標對象的method3方法 args:Object[]{100}  返回值100
33         
34         System.out.println(method2);
35         System.out.println(method3);
36         
37     }
38     
39 }

 1 public class Target implements TargetInterface{
 2 
 3     @Override
 4     public void method1() {
 5         System.out.println("method1 running...");
 6     }
 7 
 8     @Override
 9     public String method2() {
10         System.out.println("method2 running...");
11         return "method2";
12     }
13 
14     @Override
15     public int method3(int x) {
16         return x;
17     }
18 
19     
20     
21 }

對java方法進行功能增強的三種方法