每日心得
前面两天的内容有点多，还没整合好，所以先把今天的完成了，二十二就放假了，会放一个月，放得有点早了，时间也久了，所以本来几个月的学习时间变得更加紧张了，老师都说应该很难讲完了，老师还说年后可能会辞职，原因有很多吧，真不希望他走，最少也要带完我们这一届吧。。。
Reflection API（反射）
一般用于框架里，较为高级的api，一般增删改查用不到。
java.lang.reflect(反射包)
在类名等未知的情况下，也能够去调用类的方法，构造方法，属性。
其优点是，当类符合某种规范，都能统一进行调用。
java.lang.Class
这个类的实例是一个类在java中运行的信息的包装，可以通过class获取很多信息，注解，类名泛型等。当类是别人传过来的，你未知的，不知道里面的属性内容，就可以使用这个类来进行信息的获取。
枚举-->类
数组-->类
注解-->接口
void-->class object
基本数据类型-->类
Class没有具体的构造方法，由JVM虚拟机自动生成，当这个类加载到JVM时通过类加载器（类加载器，把你预定好的class类加载到内存里，正常情况下放在硬盘（副存）中无法与cpu进行运算，需要内存作媒介；通过类加载器加载的过程中，会调用一个defineClass(定义类)方法，调用后就会在内存形成这个类，这里要注意一点，当你第一次调用一个x类，将类加载到内存中之后，如果你第二次又调用这一个x类，这个时候不会在加载到内存中了，因为内存中已经有了，这个与JVM中的方法区相关，这里不深究。）
都有getClass这个方法，因为时定义在Object类里面的。
.getClass();//final,返回一个运行时的class
使用类的全名再.getClass()，也能获取到这个对象
Student stu=new Student();
Class clazz=stu.getClass();
System.out.println(clazz.getName());//输出类的全名
print("abc");
void print(Object obj){
Class clazz = obj.getClass();
System.out.println(clazz.getName());//输出类的全名java.lang.String
}
Class clazz2=stu.getClass();
Class clazz=Student.class;
System.out.println(clazz==clazz2);//结果为true,为同一个类
int[]array=new int[5];
int[]array2=new int[6];
double[] array3=new double[3];
System.out.println(array==array2);//结果为true,都为整形数组int[]
System.out.println(array==array3);//括号中会报错，编译不通过，无法比较
//Class clazz3=int[].class;
Class clazz=int.class;
System.out.println(clazz.getName());//结果为int，基本数据类型的class为本身
.forName(类的全名);加载类，手动使用类加载器
Class clazz2=Class.forName("java.lang.String");//会需要捕获一个类名找不到的异常
Class clazz=String.class;
System.out.println(clazz==clazz2);//true
获取属性
Class clazz=Student.class;
Field[]fs1=clazz.getFields();//返回所有的包括父类的public属性
clazz.getField("");//范围是所有的包括父类的public属性，通过名称指定获取
Field[]fs2=clazz.getDeclaredFields();//返回当前类所以声明的属性
clazz.getDeclaredField("");//范围是当前类所以声明的属性，通过名称指定获取
//通过属性名称拿到其所用注解与注解的值
Fild name=clazz.getDeclaredFied("name");
MyAnnotation my = (MyAnnotation)name.getAnnotation(MyAnnotation.class);
Systm.out.println(my.aa());
//根据属性获取其类型
Field name=clazz.getDeclaredField("gender");
System.out.println(name.getType());//获取属性类型
//获取修饰符
int mod =name.getModifiers();//该方法内部通过位运算获得一个整形表示类型
System.out.println(Modifier.isPrivate(mod));//结果为ture
获取方法，构造方法
Class clazz=Student.class;
//普通获取一个方法需要获取类名，方法名，形参列表
clazz.getMethods();//获取所有public方法
clazz.getMethod("setName",parameterTypes);//parameterTypes可变长度参数，放最后,形参或者形参列表
Method m =clazz.getMethod("setName",String.class);//获取单个方法
Method[] m =clazz.getMethods();
clazz.getDeclaredMethods()//获取所以有的方法
m.getReturnType().getName();//获得返回类型
System.out.println(m.getReturnType()==void.class);//判断是不是方法，没有返回类型的即void的
//获取构造方法
clazz.getConstructors();//获取全部的构造方法
Constructor c=clazz.getConstructor(String.class,int.class);//直接传形参，不需要传名称
Student stu=(Student)c.newInstance("xxxx",123);//实例化
获取注解
Class clazz=Studnet.class;
Annotation[] annos=clazz.getAnnotations();
System.out.println(annos.length);//1
Annotation myanno =annos[0];
System.out.println(myanno.getClass().getName());//返回的并不是注解名，而是动态代理的类，因为注解是接口，不能直接拿来使用，所以虚拟机会生成一个动态代理的类
if(myanno.instanceof MyAnnotation){//拿到的这个实例其实是MyAnnotation的一个实现类，所以可以使用这种方法间接判断
System.out.println("myanno is a MyAnnotation...")
MyAnnotation my =(MyAnnotation)myanno;//进行强转
System.out.println(my.属性名)//可以拿到注解中的属性值
}
System.out.println(myanno.annotationType()==MyAnnotation.class);//结果为true
myanno.annotationType().getAnnotations();//获取这个注解上面的注解
//如果要更直接一点的获取注解与里面的属性值
MyAnnotation my =(MyAnnotation)clazz.getAnnotations(MyAnnotation.class);
System.out.println(my.属性名)
获取接口，父类，泛型
clazz.getSuperClass();//父类只有一个，若是没有父类，默认为object类
class[] inter=clazz.getIntrerfaces();//接口有多个
//获取<>泛型必须固定其类型，不能获取类似<T>这种不确定的
TypeVariable[] tvs=clazz.getTypeParameters();
System.out.println(tvs[0].getNames);
反射（很强大的工具）
通过反射使用属性
Student stu1 = new Student();
stu1.setName("xxxx");
name.setAccessible(true);//因为设置为private私有的，所以默认没有访问权限，临时强行转为可访问
name.set(stu1,"ww");//设值
System.out.println(name.get(stu1));//不能直接访问私有属性，但是能通过第三行代码将权限改为可访问,获得这个name
通过反射使用方法，静态方法
Method m =clazz.getMethod("setName",String.class);
m.invoke(stu,"xxxx");//使用stu的setName()方法
System.out.println(stu.getName());//输出xxxx
Menthod getMethod = clazz.getMethod("getName",null);
Object retobj = getMethod.invoke(stu,null);//使用stu的getName方法，没有形参，但是有返回值，因为接收不确定，所以用object来接收
//静态方法
Class clazz=Student.class;
Method m =clazz.getMethod("test",null);
m.invoke(clazz,null);
Modifier.isStatic(m.getModifiers());//可通过这个判断决定是在invoke方法中放入类名还是实例
反射会对OOP造成破坏，因为可以突破各种规则，也可以破坏泛型
原理，绕过了编译器，所以没有被约束，运行时泛型会被擦除，反射是在运行时插入；
List<Stirng>list= new ArrayList<>();
list.add("abc");
//list.add(111);编译器不会通过
Class clazz=list.getClass;
Method addMethod = clazz.getMethod("add",Object.class);
addMethod.invoke(list,1111);
for(Obejct obj:list){
System.out.println(obj);//结果为abc，111
}
类为什么没有地址，只通过类名称就可以加载类，是因为类加载器通过工程自动生成的classpath文件去加载的class
java.lang包下的不用import的，因为比较常用，默认加载。
Class Loader类加载器类，与JVM相关，可以自定义类加载器。（后期才学）
注解（Annotation）
XML ==>HTML 标记数据 在表现层
==>配置文件，数据传输
XML局限性，有开始标签与结束标签，需要缩进，不直观；
java中.properties 基于key与value,但没有XML灵活，后面又演化有了.yml；
这个时候就有了Annotation注解；
声明一个注解
@Target(ElementType.TYPE)//传入一个枚举，表示应用范围,多个范围使用({ElementType.x,ElementType.y,......})
@Rentention(@RententionPolicy.RUNTIME)//保留机制
//注解必须有上面两个标明，不然无法使用，或者没有效果
public @interface MyAnnotation{
String value() default "sss";//deafult设置默认值，如果注解中没有设置默认值，需要在调用时给一个默认值
int aa();
}
@MyAnnotation(aa=123)
public class Student{
@MyAnnotation
private String name;
public void setName(@MyAnnotation String name){
}
}
枚举-->常量的集合，默认类型为int
@Target（应用范围）
TYPE:类，接口（包括注解类型），枚举类型；
FIELD:属性（包括枚举的常量）；
METHOD:方法；
PARAMETER:形参；-->在AOP中十分有用，AOP弥补OOP的短板。
CONSTRUCTOR:构造方法；
LOCAL_VARIABLE:本地变量；
。。。。。。
@Rentention（保留机制）
SOURCE:编译器编译后，将会将注解的信息丢失，我们写的注解加这个没有用，重写编译器才有用；
CLASS:编译后，注解信息会记录在class文件中，但是JVM运行后，不会保留，默认的行为，也没有用；
RUNTIME:编译后，注解信息会记录在class文件中，是JVM运行后，将会保留，它们是可读的，通过反射。
注解的属性
String aa() default "abc";default表示默认值；
如果使用的注解有属性，每个属性必须都有默认值，可以在注解中使用default设置，也可以在使用时用括号设置：@MyAnnotation(aa="abc")；
如果属性名为value，则在使用时可以不用写属性名，如下
String value()；
@MyAnnotation("abc")与@MyAnnotation(value="abc")效果相同，因为value是默认值。
但如果有多个，就要加上属性名了。
题目：找出包中所以被注解标记过的类，类中被注解标记的方法；
package test1.copy;
import java.io.File;
import java.lang.reflect.Method;
import java.net.URL;
public class PackageScan {
public static void main(String[] args) {
Class clazz = PackageScan.class;
// URL url=clazz.getResource("/test1");寻找路径
// System.out.println(url);
Package pkg=clazz.getPackage();
System.out.println(pkg);
String rootpkg = pkg.getName().split("\.")[0];//包名
System.out.println(rootpkg);
URL url=clazz.getResource("/"+rootpkg);
if(url.getProtocol().equals("file")){//判断协议是否符合
String filePath=url.getFile().substring(1);//去除斜杠，获得该扫描的路径
System.out.println("filePath:"+filePath);
File file=new File(filePath);
System.out.println(url);//结果为file:/D:/project2/HighMS/bin/test1，file：这个是协议
System.out.println(url.getFile());//协议后的文件路径
System.out.println("有注解的类为");
selectfile(file,rootpkg);
System.out.println("有注解的方法为");
selectMe(file,rootpkg);
}
}
public static void selectfile(File file,String rootpkg){
File[]files =file.listFiles();
for(File f:files){
if(f.isDirectory()){
selectfile(f,rootpkg+"."+f.getName());
}else if(f.isFile()){
if(f.getName().endsWith(".class")){
String clazzName=f.getName().substring(0,f.getName().lastIndexOf("."));//获取类名
try {
Class targetClazz=Class.forName(rootpkg+"."+clazzName);//将包名与类名进行拼接
//targetClazz.getAnnotation(Component.class);通过全名获取注解
if(targetClazz.isAnnotationPresent(Component.class)){//判断是不是这个注解类型
System.out.println(targetClazz.getName());
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
}
public static void selectMe(File file,String rootpkg){
File[]files =file.listFiles();
for(File f:files){
if(f.isDirectory()){
selectMe(f,rootpkg+"."+f.getName());
}else if(f.isFile()){
if(f.getName().endsWith(".class")){
String clazzName=f.getName().substring(0,f.getName().lastIndexOf("."));
try {
Class targetClazz=Class.forName(rootpkg+"."+clazzName);
Method[] m=targetClazz.getDeclaredMethods();//通过类名获取方法
for(Method m2:m){
if(m2.isAnnotationPresent(Auth.class)){//查找含有该注解的方法
System.out.println(m2.getName());
}
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
}
}