经典案例模块——20200404

Arrays.binarySearch(arr[] ,target)

public static int binarySearch(Object[] a, Object key) {
         return binarySearch0(a, 0, a.length, key);
     }

private static int binarySearch0(Object[] a, int fromIndex, int toIndex,
                                      Object key) {
         int low = fromIndex;
         int high = toIndex - 1;

        while (low <= high) {
             int mid = (low + high) >>> 1;
             @SuppressWarnings("rawtypes")
             Comparable midVal = (Comparable)a[mid];
             @SuppressWarnings("unchecked")
             int cmp = midVal.compareTo(key);

            if (cmp < 0)
                 low = mid + 1;
             else if (cmp > 0)
                 high = mid - 1;
             else
                 return mid; // key found
         }
         return -(low + 1);  // key not found.
     }

//

【！】Java中基本数据类型、包装类、String等都实现了Comparable接口

【！】更体现了面向对象、面向接口的特征

【3】Arrays工具类的静态方法。

//赋值操作

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
         @SuppressWarnings("unchecked")
         T[] copy = ((Object)newType == (Object)Object[].class)
             ? (T[]) new Object[newLength]
             : (T[]) Array.newInstance(newType.getComponentType(), newLength);
         System.arraycopy(original, 0, copy, 0,
                          Math.min(original.length, newLength));
         return copy;
     }

动态代理——调用处理器

【1】Proxy的静态方法——newProxyInstance()创建动态代理类实例

【2】InvocationHandler接口——对动态代理对象的调用通过invoke()方法

//接口

public interface Shopping {
     public void buy();
}

Proxy.newProxyInstance(Shopping.class.getClassLoader(), new Class[]{Shopping.class}, dyProxy)

//类加载器：？？具体对象好像没关系

//类实现的全部接口：必须是要代理对象的

//dyProxy——实现Invocationhandler接口的类

Shopping shopping = (Shopping)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), dynaProxy);

--强转之后，调用接口方法实现动态代理。

====改进====将方法放入调用处理器中

public Object bind(Object shopping) {
     this.shopping = (Shopping) shopping;
     return Proxy.newProxyInstance(shopping.getClass().getClassLoader(), this.shopping.getClass().getInterfaces(), this);
}

进一步深入：拦截器【靠动态代理实现，它可以简化动态代理的使用】

---通过设置interceptor接口，拦截Shopping接口中方法调用

public interface Interceptor {
     public void run(Object proxy,Object target,Method method,Object[] args);
}

通过在调用处理器中判断 拦截器是否为null:

public class InterceptorProxy implements InvocationHandler{
     private Object target;
     private Interceptor interceptor;
    
     /**
      * @param target
      */
     public InterceptorProxy(Object target) {
         super();
         this.target = target;
     }

     public Object bind(Interceptor interceptor) {
         this.interceptor = interceptor;
         return Proxy.newProxyInstance(this.interceptor.getClass().getClassLoader(), this.target.getClass().getInterfaces(), this);
        
     }

    @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         // TODO Auto-generated method stub
         if (interceptor==null) {
             method.invoke(target, args);
         }
         interceptor.run(proxy, target, method, args);
         return null;
     }

}

Cglib--应用JDK自带

属性的getType()返回的是：参数类的类对象

经典案例模块——20200404

原文：https://www.cnblogs.com/macro-renzhansheng/p/12637871.html