Java，

Java，

基本知识点

/*
* @author dell
*1.Java Reflection:
* Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，
*并能直接操作任意对象的内部属性及方法
*
* 2. 反射机制提供的功能：
* 2.1在运行时判断任意一个对象所属的类
* 2.2在运行时构造任意一个类的对象
* 2.3在运行时判断任意一个类所具有的成员变量和方法
* 2.4在运行时调用任意一个对象的成员变量和方法
* 2.5生成动态代理
*
* 3.反射相关的API
* 3.1java.lang.class:代表一个类
* 3.2java.lang.reflection.Method ：代表类的方法
* 3.3java.lang.flection.Field:代表类的成员变量
* 3.4java.lang.reflection.Constructor:代表类的构造方法
*

• 4.理解Class类并实例化Class类的对象

  • 4.1在Object类中定义了一下的方法，此方法将被所有的子类继承：
    *public final Class getClass():此方法返回一个class类，此类事java反射的源头。
  • 可以通过对象的反射求出类的名称。
  • 4.2正常方式： 引入所需要的包名-new 实例化对象- 取得实例化对象

• 反射方式： 实例化对象–getclass()方法–取得完整的"包类"名称

  • 4.3Class 类
    *4.3.1 Class本身也是一个类
    *4.3.2 Class对象只能由系统建立对象
    *4.3.3一个类在JVM中只会有一个class实例
    *4.3.4 class常用方法：见API

  • 4.4实例化类Class对象的四种方法
    *4.4.1 若已知某个类，可以通过属性class属性获得，该方法最为安全，程序性效率高

• Class clazz = String…class;
  *4.4.2 已知某个类的实例，调用该实例的getClass()方法获取class对象

• Class clazz = “包名”.getClass();
  *4.4.3 已知某个类的全类名，且在该类的路径下，可以通过class的静态方法forName()获取

• 可能或抛出异常classNotFoundException
  *Class clazz =Class.getName(“java.lang.String”)

• 4.5类的加载过程

• 4.5.1 类的加载-- 类的连接–类的初始化

• 4.5.2 类的加载步骤

• step1:获取一个系统的加载器:ClassLoader classloader = ClassLoader.getSystemClassLoader();

• step2:获取系统加载器的父类加载器，即扩展加载器

• classloader = classloader.getParent();

• step3:获取扩展类加载器的父类加载器，即引导类加载器

• step4:测试当前类有哪个类加载器进行加载

• step5:测试JDK提供的Object类由哪个类加载器加载

• step*6：关于加载器的一个方法：

• getResourceAsStream(String str)获取类路径下的指定的文件的输入流

• 5.运行时创建类对象并获取类的完整结构

• 5.1通过反射调用类的完整结构：实现的接口，所继承的父类，全部的构造器，全部的方法，全部的Field
  *5.1.1 实现的全部接口：确定此对象所表示的类或接口实现的接口

• public Class<?>[] getInterface()
  *5.1.2 所继承的父类：返回此class所表示的实体(类、接口、基本类型)的父类的class

• public Class<? super T> getSuperclass()
  *5.1.3全部的构造器
  *public Constructor[] getConstructor():返回此class对象所示的所有的public构造方法

• publicConstructor[] getDeclaredConstructor():返回class对象所示的类声明的所有构造方法

• 在Constrcutor类中：public int getModifiers()取得修饰符

• 取得方法的名称：public String getName();

  • 取得参数的类型：public Class<?>[]getParameterTypes();
    *5.1.4全部的方法：
    *public Method[] getDeclaredMethods()：返回此Class对象所表示的类或接口的全部方法
    *public Method[] getMethods() ：返回此Class对象所表示的类或接口的public的方法
    *Method类中：
    *public int getModifiers() 以整数形式返回此Field的修饰符
    *public Class<?> getType() 得到Field的属性类型
    *public String getName() 返回Field的名称。

5.1.5全部的字段
* public Field[] getFields() ：返回此Class对象所表示的类或接口的public的Field。
* public Field[] getDeclaredFields() ：返回此Class对象所表示的类或接口的全部Field。
* Field方法中：
*public int getModifiers() 以整数形式返回此Field的修饰符
*public Class<?> getType() 得到Field的属性类型
*public String getName() 返回Field的名称 *
*
5.1.6 Annotation相关
*getAnnotation(classannotationClass)
*getDeclareAnnotation
*
*5.1.7泛型相关
* 获取父类泛型类型： type getGenericSuperclass()
* 泛型的类型：ParameterizedType
* 获取实际泛型类型参数数组：getActualTypeArguments()
*
*5.1.8 类所在的包
*package getPackage()

• 6.通过反射调用类的指定方法、指定属性
  • 6.1调用指定的方法：通过反射，调用类中的方法，通过methods类来完成
    *step1:通过class类的getMethod(String name,class…parameterTypes)方法获取一个method对象
  • 并设置此方法操作时所需要的参数类型。
    *step2:使用Object invoke(Object onj, Object[] args)进行调用，
  • 并向方法中传递要设置的obj对象的参数信息。
  • 说明：1.Object对应原方法的返回值，若原方法无法返回，此时返回null,
  • 2.若原方法是静态方法，此时形参Objec obj可为null
  • 3.若原方法形参列表为空，Object[] args 为null
  • 4.若原方法声明为private,则需要在调用invoke()方法前，显示调用方法对象setAccessible(true),将可访问peivate的方法。
    *class.forName 实例化class对象，getMethod()找到方法，invoke()调用方法
  • 6.2调用指定的属性
    *6.2.1 public Field getField(String name) 返回此Class对象表示的类或接口的指定的public的Field。
  • 6.2.2 public Field getDeclaredField(String name)返回此Class对象表示的类或接口的指定的Field
    *6.2.3 在Field中：
    *public Object get(Object obj) 取得指定对象obj上此Field的属性内容
  • public void set(Object obj,Objectvalue) 设置指定对象obj上此Field的属性内容
  • 6.2.4 在类中属性都设置为private的前提下，在使用set()和get()方法时，首先要使用Field类中的setAccessible(true)方法将需要操作的属性设置为可以被外部访问。
    public void setAccessible(true)访问私有属性时，让这个属性可见。

7.Java动态代理
* 7.1动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。
* 7.2 使用的场合：调试以及远程方法调用。
* 7.3 使用一个代理将对象包装起来, 然后用该代理对象取代原始对象.
*
*任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时将方法调用转到原始对象上
* 7.4 Proxy ：专门完成代理的操作类，是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类。
* 7.4.1 提供用于创建动态代理类和动态代理对象的静态方法
*
static Class<?>
getProxyClass(ClassLoader loader,
Class<?>… interfaces) 创建一个动态代理类所对应的Class对象
* static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces, InvocationHandler h) 直接创建一个动态代理对象
* 7.4.2 动态代理的步骤：
* step1:创建一个实现接口InvocationHandler的类，它必须实现invoke方法，以完成代理的具体操作。
public Object invoke(Object theProxy,
Method method, Object[] params) throws Throwable{
try
{
Object retval = method.invoke(targetObj, params);
// Print out the result
System.out.println(retval);
return retval;
}
catch (Exception exc){}
}
* step2:创建被代理的类以及接口
* RealSubject say(String name,int age) implements Subject
* step3：通过Proxy的静态代理
* newProxyInstance(ClassLoader loader,Class[] interfaces, InvocationHandler h) 创建一个Subject接口代理
RealSubjec target = new RealSubject();
// Create a proxy to wrap the original implementation
DebugProxy proxy = new DebugProxy(target);
//Get a reference to the proxy through the Subject interface
Subject sub = (Subject) Proxy.newProxyInstance(
Subject.class.getClassLoader(),
new Class[] { Subject.class }, proxy);
*step4:通过Subject代理调用RealSubject实现类的方法
* String info = sub.say(“Peter", 24);
System.out.println(info);
* 7.5动态代理与AOP(Aspect Orient Programming)
* 7.5.1 代码段1(相同的代码段)，代码段2(相同的代码段)…通过复制粘贴的部分
*/

AOP实例

public interface Dog {
 void info();
 void run();
}
public class HuntingDog implements Dog{
@Override
public void info() {
   System.out.println("我是一只猎狗");

}

@Override
public void run() {
   System.out.println("我奔跑迅速");
  }
}
 public class DogUtil {
public void method1()
{
   System.out.println("=====模拟通过方法====");
}
public void method2() {
   System.out.println("====模拟通过用方法二====");
}
}
public class MyInvocationHandler implements InvocationHandler{
private Object target;
public void setTarget(Object target) {
   this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   DogUtil du = new DogUtil();
   du.method1();
   Object result = method.invoke(target, args);
   du.method2();
   return result;   
  }
} 
   public class MyProxyFactory {
   public static Object getProxy(Object target) {
   MyInvocationHandler handler = new MyInvocationHandler();
   handler.setTarget(target);
   return Proxy.newProxyInstance(target.getClass().getClassLoader(),
          target.getClass().getInterfaces(),handler);
    }
 }
public class Test {
public static void main(String[] args) {
   Dog target = new HuntingDog();
   Dog dog = (Dog) MyProxyFactory.getProxy(target);
   dog.info();
   dog.run();
}
}