注解：
特点:可以被其他程序读取
格式:
“@注释名”,还可以添加一些参数
内置注解：
@Override ：表示一个方法声明打算重写另一个方法声明：典型的就是toString
@Deprecated:表示不鼓励使用这样的元素(但是可以使用)
@SuppressWarnings:用来抑制编译时的警告信息(需要添加参数）
元注解:
负责注解其他注解
@Target：描述注解的使用范围
@Runtime:表示在什么级别保存该注释信息
@Document:说明该注解被包含在javadoc中
@inherited:说明子类可以继承父类中的该注解
自定义注解：
格式：public @ interface 注解名
反射（java.Reflection)
动态语言：在运行时可以改变其结构的语言
例如。c#,JavaScript,PHP,python
静态语言：运行时结构不可改变的语言就是静态语言，JAVA不是动态语言，但java可以称为准动态语言，就是利用了反射机制。
反射机制：
允许在程序运行期间借用Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法
加载完类之后，在堆内存的方法区会产生一个Class类型的对象（一个类只有一个Class对象），包含了完整的类的结构信息。我们可以通过这个对象看到类的结构，类似镜子，所以我们称之为反射。
反射方式：实例化对象->getClass()方法->获得完整的”包类“名称
优点：实现动态创建对象和编译，灵活性强
缺点：对性能有影响，慢于直接执行相同的操作
简单例子
package OOP.re;
public class student {
public static void main(String[] args) throws ClassNotFoundException {
Class c1 = Class.forName("OOP.re.user");
System.out.println(c1);
System.out.println(c1.hashCode());
}
}
class user {
private String name;
private int age;
public user() {
}
public user(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "user{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}得到Class类的几种方式：
1.若已知具体的类，通过类的class属性获取，该方法最安全
Class c1 = Person.class;2.若知道某个类的实例，调用getClass(0方法获取Class对象
Class c1 = person.getClass();3.已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFpundException
Class c1 = Class.forName("demo1.Student");4.内置基本数据类型可以直接用类名.Type
哪些类型可以有Class对象
class:外部类，成员，局部内部类，匿名内部类
interface:接口
[]：数组
enum:枚举
annotation:注解
primitive type：基本数据类型
viod
类加载内存分析
加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象(不能主动创建，只能被动的获取）
链接：将JAVA类的二进制代码合并到JVM运行状态之中的过程
初始化：执行类构造器，把所有类变量的赋值动作和静态代码中的语句合并产生，当初始化一个类的时候，如果发现其父类还没有进行初始化，则先触发其父类的初始化
整体步骤：
1.加载到内存，产生一个类对应的Class对象
2.链接结束后赋值默认为0
3.初始化
分析类的初始化：
什么时候发生：类的主动引用（一定会发生类的初始化）/类的被动引用（不会发生类的初始化）
类的被动引用：
1.当通过子类引用父类静态变量不会导致子类初始化
2.通过数组定义类引用，不会触发此类的初始化
3.引用常量不会触发类的初始化
类加载器的作用
将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口
类缓存：某个类被加载到类加载器中，它将维持加载（缓存）一段时间
package OOP.jiazai;
public class test01 {
public static void main(String[] args) throws ClassNotFoundException{
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
System.out.println(systemClassLoader);//获得系统类的加载器
ClassLoader parent = systemClassLoader.getParent();
System.out.println(parent);//获得扩展类加载器
ClassLoader parent1 = parent.getParent();
System.out.println(parent1);//根加载器、、无法直接获取
//获得当前类是什莫加载器
ClassLoader classLoader = Class.forName("OOP.jiazai.test01").getClassLoader();
System.out.println(classLoader);
}
}获取类运行时的完整结构
通过反射获取运行时类的完整结构
Field,Method,Constructor,Superclass,lnterface,Annotation
package OOP.re;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class qu {
public static void main(String[] args) throws ClassNotFoundException,NoSuchFieldException {
Class c1 = Class.forName("OOP.re.user");
System.out.println(c1.getName());//获得包名+类名
System.out.println(c1.getSimpleName());//获得类名
//user user = new user()
//c1 = user.getClass
//这表明也可以通过对象获取
Field[] fields = c1.getFields();//只能找到public 属性
fields = c1.getDeclaredFields();//找到全部的属性
for (Field field : fields) {
System.out.println(field);
}
//获得指定属性
Field name = c1.getDeclaredField("name");
System.out.println(name);
//获得类的方法
Method[] methods = c1.getMethods();//公共的
for (Method method : methods) {
System.out.println(method);
}
Method[] declaredMethods = c1.getDeclaredMethods();//全部的
for (Method declaredMethod : declaredMethods) {
System.out.println(declaredMethod);
}
Constructor[] constructors = c1.getConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);//获得构造器
}
}
}动态创建对象执行方法
有了Class对象，能做什么？
创建类的对象，调用newinstance()方法
注意：1.类必须有一个无参数的构造器
2.类的构造器访问权限需要足够
package OOP.re;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class xin {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
Class c1 = Class.forName("OOP.re.user");
// user user =(user) c1.newInstance();//本质调用了类的无参构造器
// System.out.println(user);
// //通过构造器创造对象
// Constructor constructor = c1.getConstructor(String.class, int.class);
// user xino = (user)constructor.newInstance("XINO", 18);
// System.out.println(xino);
//通过反射调用普通方法
//invoke:激活
//(对象，“方法的值”）
user user1 = (user) c1.newInstance();
Method setName = c1.getDeclaredMethod("setName", String.class);
setName.invoke(user1,"xxx");
System.out.println(user1);
//通过反射调用属性
user user2 = (user) c1.newInstance();
Field name = c1.getDeclaredField("name");
name.setAccessible(true);//关闭程序的安全检测，可以利用private属性
name.set(user2,"xxxxxxxxxxx");
System.out.println(user2.getName());
}
}性能对比分析
setAccessible：Method,Field,Constructor对象都有该方法
该方法作用：启用和禁用访问安全检测的开关
获取泛型信息
先了解一下泛型是什么
Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。
泛型的本质是参数化类型，即给类型指定一个参数，然后在使用时再指定此参数具体的值，那样这个类型就可以在使用时决定了。这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
我们通过代码看看其作用
List x = new ArrayList();
x.add("xino"); // 加入string
x.add(66666); // 加入int
//此时我们传入多个类型都可以通过，但获取的时候极有可能错报
//泛型起约束作用约束我们传入的类型
//例如：list<String> x = new ArrayList();优点：
提高了代码的可读性，一眼就能看出集合（其它泛型类）的类型
可在编译期检查类型安全
省心不需要强转（内部做了强转）
提高代码的复用率，定义好泛型，一个方法（类）可以适配所有类型
反射操作泛型
Java采用泛型擦除机制来引入泛型，一旦编译完成，所有和泛型有关的类型全部擦除
为了通过反射获取这些类型，java新增以下类型代表不能被归一到Class类中的类型但又和原始类型齐名的类型
