java中都反射、动态代理以及设计模式

java中都反射、动态代理以及设计模式

1. java中的反射

   java中的反射首先只能获取到java中要反射类都字节码，获取字节码有三种方式：

   • Class.forName(className)

   • 类名.class

   • this.getClass()

   然后将字节码中的方法、变量、构造函数等映射成相应都Method、Filed、Constructor等类、这些类提供了丰富的方法可以被我们利用

2. java中的动态代理

   试着编写一个ArrayList都动态代理类(重点)

   final List<String> list=new ArrayList<String>();
   List<String> proxyInstance=(List<String>)Proxy.newProxyInstance(list.getClass().getClassLoader(),list.getClass().getInterfaces(),new InvocationHandle(){
       @Overried
       public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
           return method.invoke(list,args);
       }
   }); 
   proxyInstance.add("您好");
   System.out.println(list);

   动静态代理都区别，什么场景使用？

   区别	动态代理	静态代理
   代理类都数量	代理一个接口下都多个实现类	只代理一个类
   代理内容是否提前知道	不知道，只有运行之后才知道	知道
   具体内容	1.动态代理是实现JDk里的InvocationHander接口都invoke方法，但是注意代理都是接口，也就是业务类必需要实现都接口，通过Proxy里的newInstance得到代理对象 2.还有一种动态代理CGLIB，代理都是类，不需要业务类继承接口，通过派生都子类来实现代理。通过在运行时，动态修改字节码得到修改类都目的
   场景	Aop编程就是基于动态代理实现的，比如著名都Spring框架、Hibernate框架等

3. 设计模式

   分类	具体
   创建型模式	工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式
   结构型模式	适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式
   行为型模式	策略模式、模板方法模式、观察者模式、迭代子模责任连模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式

4. 下面是几种必需要掌握都设计模式

   1. 单例模式：最好理解都一种设计模式。分为懒汉式和饿汉式

      1. 饿汉式

         public class Singleton{
             //直接创建对象
             public static Singleton instance=new Singleton();
             //私有化构造函数
             private Singleton(){}
             //返回对象实例
             public static Singleton getInstance(){
                 return instance;
             }
         }

      2. 懒汉式

         public class Singleton{
             //声明变量
             private static volatile Singleton singleton=null;
             //私有构造方法
             private Singleton(){}
             //提供对外方法
             public static Singleton getInstance(){
                 //判断singleton是否为空
                 if(singleton==null){
                     synchronized(Singleton.class){
                         if(singleton==null){
                             singleton=new Singleton();
                         }
                     }
                 }
                 return singleton;
             }
         }
         //注意:在对外方法中会进行二次判断对象是否为null,原因：如果不进行第二次判断为null,那么如果在竞锁池中还有活跃都线程在等待获取锁都话，在锁释放后就会再次竞争获取锁，获取的锁的线程进入“就绪状态”，当Cpu分配其"时间片"后，进行线程都调度，从而线程进入"运行中状态"，并回去执行同步都代码块，如果没有加二次判断为null，就会导致系统中从在多个实例，而在进行判断为null后，即使获取到锁，但是执行同步代码块时也会直接跳过。
         ​
         volatile修饰符都作用？
         在private static volatile Singleton singleton=null;这个代码中volatile的作用是什么？
         volatile修饰变量只是为了禁止指令重排序，因为在singleton=new Singleton();创建对象时，底层会分四个指令执行：
             1.如果类没有被加载过，则进行类都加载
             2.在堆内开辟内存空间adr,用于存放创建都对象
             3.执行构造方法实例化对象
             4.将堆中开辟都内存地址adr赋值给被volatile修饰的引用变量singleton
         如果singleton不使用volatile修饰都话，就有可能编译器和处理器对指令进行重排序，导致第四步在第三步之前执行，此时singleton引用变量就不为null了，但是singleton这个引用变量所指向的堆中内存地址中的对象是还没有被实例化的，实例对象还是null;那么在第一次判断为null时就不为null了，然后去使用时就会报NPE空指针异常了

   2. 工厂模式：分为工厂方法模式和抽象工厂模式

      1. 工厂方法模式

         1. 普通工厂模式：普通工厂模式就是建立一个工厂类，对实现类同一接口都一些类进行实例都创建

            //接口
            public interface Sender{
                public void send();
            }
            //创建一个类实现上面都接口
            public class MailSender implements Sender{
                @Override
                public void send(){
                    System.out.println("this is mail sender");
                }
            }
            //创建一个类实现Sender接口
            public class SmsSender implements Sender{
                @Override
                public void send(){
                    System.out.println("this is sms sender");
                }
            }
            //创建工厂类
            public class SendFactory{
                public Sender produce(String type){
                    if("mail".equals(type)){
                        return new MailSender();
                    }else if("sms".equals(type)){
                        return new SmsSender();
                    }else{
                        System.out.println("请输入正确都类型");
                        return null;
                    }
                }
            }

         2. 多个工厂方法模式:该模式是对普通工厂方法模式都改进，在普通工厂模式方法中，如果传递都字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象

            public class SendFactory{
                public Sender produceMail(){
                    return new MailSender();
                }
                public Sender produceSms(){
                    return new SmsSender();
                }
            }
            //测试类
            public class FactoryTest{
                public static void main(String[] args){
                    SendFactory sendFactory=new SendFactory();
                    Serder sender=sendFactory.produceMail();
                    sender.send();
                }
            }

         3. 静态工厂方法模式：将上面多个工厂方法模式里面都方法设置为静态的，不需要创建实例，直接调用即可

            //工厂类
            public class SendFactory{
                 public static Sender produceMail(){
                    return new MailSender();
                }
                public static Sender produceSms(){
                    return new SmsSender();
                } 
            }
            //测试类
            public class FactoryTest{
                Sender sender=SendFactory.produceMail();
                sender.send();
            }

      2. 抽象工厂模式：工厂方法模式有一个问题。类都创建依赖于工厂类，也就是说，如果想要拓展程序，必需对工厂类进行修改，这违背类闭包原则，所以，从设计都角度考虑，有一定都问题，如何解决？就用到抽象工厂模式，创建对个工厂类，这样一旦增加新都功能，直接添加新都工厂类就可以了，不需要修改之前的代码。

         //接口
         public interface Provider{
             public  Sender produce();
         }
         //接口
         public interface Sender{
             public void send();
         }
         //创建一个类实现Sender接口
         public class MailSender implements Sender{
             @Override
             public void send{
                 System.out.println("this is mail sender!");
             }
         }
         //创建一个类实现Sender接口
         public class SmsSender implements Sender{
             @Override
             public void send(){
                 System.out.println("this is sms sender!");
             }
         }
         //创建发送sms邮件都工厂类实现provider接口
         public class SendSmsFactory implements Provider{
             @Override
             public Sender produce(){
                 return new SmsSender();
             }
         }
         //创建发送mial邮件都工厂类实现provider接口
         public class SendMailFactory implements Provider{
             @Override 
             public Sender produce(){
                 return new MailSender();
             }
         }
         ​
         //创建测试类
         public class Test{
             public static void main(String[] args){
                 Provider provider=new SendMailFactory();
                 Sender sender=provider.produce();
                 sender.send();
             }
         }

   3. 建造者模式(Builder):工厂类模式提供的是创建单个类都模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同都属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。

      public class Builder{
          private List<Sender> list=new ArrayList<Sender>();
          public void produceMailSender(int count){
              for(int i=0;i<count;i++){
                  list.add(new MailSender());
              }
              
          }
          public void produceSmsSender(int count){
              for(int i=0;i<count;i++){
                  list.add(new SmsSender());
              }
          }
      }
      ​
      //测试类
      public class TestkBuilder{
          public static void main(String [] args){
              Builder builder=new Builder();
              builder.produceMailSender(10);
          }
      }

   4. 适配器设计模式：适配器模式将某个类都接口转换成客户端期望都另一个接口表示，目的是消除由于接口不匹配所造成都类的兼容性问题，主要分为三类：类的适配器模式、对象都适配器模式、接口都适配器模式

      1. 类都适配器模式

         public class Source{
             public void method1(){
                 System.out.println("this is original method1");
             }
         }
         ​
         public interface Targetable{
             //与原类中的方法相同
             public void method1();
             //新类都方法
             public void method2();
         }
         //创建一个适配器类来继承Source并且实现Targetable
         public class Adapter extends Source implements Targetable{
             @Override
             public void method2(){
                 System.out.pringln("this is  the  tragerable method");
             }
         }
         ​
         //适配器测试类
         public class TestApadter{
             ppublic static void main(String[] args){
                 Tragetable targetable=new Adapter();
                 targetable.method1();
                 targetable.method2();
             }
         }

      2. 对象适配器模式:基本思路基本和类都适配器模式相同，只是将Apapter类修改，这次不继承Source,而是持有Source类都实例，以达到解决兼容性问题

         public class Wapper implements Tragetable{
             private Source source;
             public Wapper(Source souce){
                 super();
                 this.source=source;
             }
             
             @Override
             public void method1(){
                 source.method1();
             }
             
             @Override
             public void method2(){
                 System.out.println("this is the targetable method");
             }
         }
         //创建测试类
         public class AdapterTest{
             public static void main(String[] args){
                 Source source=new Source();
                 Targetable target=new Wapper(source);
                 target.method1();
                 target.method2();
             }
         }

      3. 接口都适配器模式：有时候我们写的接口中有多个抽象方法，当我们写该接口都实现类时，必需实现该接口都所有抽象方法。这有时明显比较浪费，因为并不是所有方法都是我们需要的，有时只需要一些，此处为了解决这个问题，引入类接口的适配器模式，借助于一个抽象类，该抽象类实现类该接口，实现类所有都方法，而我们不和原始接口打交道，只和该抽象类取得联系，所以我们写一个类继承该抽象类，重写我们需要都方法就行

   5. 装饰模式(Decorator):装饰模式就是给对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例

      //创建接口
      public interface Sourceable{
          public void method();
      }
      //创建被装饰实例都对象
      public class Source implements Sourceable{
          @Override
          public void method(){
              System.out.println("the original method");
          }
      }
      ​
      //创建装饰对象，需要持有被装饰对象实例
      public class Decorator implements Sourceable{
          private Source source;
          public Decorator(Source source){
              super();
              this.source=source;
          }
          
          @Override
          public void method(){
              System.out.println("before decorator!");
              System.out.println();
              System.out.println("after decorator!");
          }
      }
      ​
      //测试类
      public class TestDecorator{
          public static void main(String[] args){
              Sourceable source=new Scorce();
              sourceable obj=new Decorator(source);
              obj.method();
          }
      }

   6. 策略模式：策略模式定义类一系列算法，并将每个算法分装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现累提供统一 的方法，多个实现类实现该接口，设计一个抽象类(可有可无，作为辅助类)，提供辅助函数。策略模式都决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可

      //创建接口
      public interface ICalculator{
          public int calculate(String exp);
      }
      //创建具体实现方法都类
      public class AbstractCalculator{
          public int[] split(String exp,String opt){
              String []array=exp.split(opt);
              int arrayInt[]=new int[2];
              arrayInt[0]=Integer.parseInt(array[0]);
              arrayInt[1]=Integer.parseInt(array[1]);
              return arrayInt;
              
          }
      }
      //创建做减法都类
      public class Minus extends AbstractCalculator implements ICalculator{
          @Override
          public int calculate(String exp){
              int arrayInt[]=split(exp,"-");
              return arrayInt[1]-arrayInt[2];
          }
      }
      //创建做加法的类
      public class Plus extends AbstractCalculator implements ICalculator{
          @Override
          public int calculate(String exp){
              int [] arrayInt=split(exp,"\\+");
              return arrayInt[1]+array[2];
          }
      }
      ​
      //创建测试类
      public class StrategyTest{
          public static void main(String [] args){
             String exp="2+8";
              Icalculator cal=new Plus();
              int result=cal.calculator(exp);
              System.out.println(result)
              
          }
      }

   7. 观察者模式：类似于邮件订阅和RSS订阅，当我们浏览一些博客或者wiki时，精华先给看到RSS图标，意思是，当我们订阅了该文章时，如果后续又更新，会及时通知你。简单来说，就是当一个对象发生变化时，其它依赖该对象都对象都会收到通知，并且随着变化，对象之间是一种一对多都关系

      //创建观察者接口
      public interface Observer{
          public void update();
      }
      //创建类Observer1实现Observer接口
      public class Observer1 implements Observer{
          @Override
          public void update(){
              System.out.println("observer1 has received!");
          }
      }
      //创建类Observer2实现Observer接口
      public class Observer2 implements Observer{
          @Override
          public void update(){
              System.out.println("observer2 has received!");
          }
      }
      ​
      //创建Subject接口
      public interface Subject{
          //增加观察者
          public void add(Observer observer);
          //删除观察者
          public void del(Observer observer);
          //通知所有都观察者
          public void notifyObservers();
          //自身的操作
          public void operator();
      }
      //创建抽象类AbstractSubject实现Subject接口
      public abstract class AbstractSubject{
          private Vector<Observer> vector=new Vector<Observer>();
          @Override
          public void add(Observer observer){
              vector.add(observer)
          }
          
          @Override
          public void del(Observer observer){
              vector.remove(observer);
          }
          
          @Override
          public void notifyObserver(){
              Enumeration<Observer> enumo=vector.elements();
              while(enumo.hasMoreElements()){
                  enumo.nextElement().update();
              }
          }
      }
      ​
      //创建MySubject实体类继承AbstractSubject类
      public class MySubject extends AbstractSubject{
          @Override 
          public void operation(){
              System.out.println("update self");
              notifyObservers();
          }
      }
      ​
      //创建测试类
      public class ObserverTest{
          public static void main(String[]args){
              Subject sub=new MySubject();
              sub.add(new Onserver2());
              sub.add(new Observer2());
              sub.operation();
          }
      }

       

       

       

       

       

       

       

   8.