尚硅谷JAVA学习视频整理笔记
注意：自定义注解必须配上注解的信息处理流程（使用反射）才有意义
案例：创建自定义注解，并选择注解类型 public @interface MyAnnotation { String value(); }Retention：指定所修饰的Annotation的生命周期
SOURCE\CALSS(默认行为)\RUNTIOME只有声明为RUNTIME时，程序可以通过反射获取该注释Target：用于修饰 Annotation 定义, 用于指定被修饰的 Annotation 能用于 修饰哪些程序元素。 @Target 也包含一个名为 value 的成员变量。
CONSTRUCTOR:用于描述构造器FIELD:用于描述域LOCAL_VARIABLE:用于描述局部变量METHOD:用于描述方法PACKAGE:用于描述包PARAMETER:用于描述参数TYPE:用于描述类、接口（包括注解类型）或enum声明Documented：表示所修饰的注解在被javadoc工具提取成文档
Inherited：被它修饰的注解将具有继承性。如果某个类使用了被@Inherited修饰的注解，则其子类将自动具有该注解
@Retention和@Target多用于自定义注解中
将在反射中详细讲述
包括泛型类、泛型接口;泛型方法
泛型类与泛型接口的区别，就是类与接口的区别
注意
1.泛型不同的引用不能相互赋值2.泛型类的构造器如下：public GenericClass(){}。 而下面是错误的：public GenericClass(){}3.泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价 于Object。泛型要使用一路都用。要不用，一路都不要用。4.泛型的指定中不能使用基本数据类型，可以使用包装类替换。5.在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态 属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法 中不能使用类的泛型6.子类除了指定或保留父类的泛型，还可以增加自 己的泛型方法，也可以被泛型化，不管此时定义在其中的类是不是泛型类。在泛型 方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。
格式：[访问权限] <泛型> 返回类型 方法名([泛型标识 参数名称]) 抛出的异常
案例： //泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系 //泛型方法所属的类是不是泛型类都没有关系 //泛型方法，可以声明为静态的，原因：泛型参数是在调用方法时确定的，并非实例化类时确定 public <E> List<E> copyFromArrayToList(E[] arr){ ArrayList<E> list = new ArrayList<>(); for(E e:arr){ list.add(e); } return list; } 测试 //测试泛型方法 @Test public void test2(){ Order<String> order = new Order<>(); Integer[] arr = new Integer[]{1,2,3,4,5}; //泛型方法在调用时，指明泛型的类型 List<Integer> list = order.copyFromArrayToList(arr); System.out.println(list); }注意点： 1.编译错误：不能用在泛型方法声明上，返回值类型前面<>不能使用? 2.编译错误：不能用在泛型类的声明上 3.编译错误：不能用在创建对象上，右边属于创建集合对象
案例
//Student继承自Person类 List<? extends Person> list1 = null; List<? super PErson> list2 =null; List<Student> list3 = null; List<Person> list4 = null; List<Object> list5 = null; //? extends A: //G<? extends A> 可以作为G<A>和G<B>的父类，其中，B是A的子类 list1 = list3; list1 = list4; //list1 = list5; 编译不通过 //? super A: //G<? super A> 可以作为G<A>和G<B>的父类，其中，B是A的父类 //list2 = list3; 编译不通过 list2 = list4; list2 = list5;动态语言：是一类在运行时可以改变其机构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或其他结构上的变化。也就是在运行时代码可以根据某些条件改变自身结构，例如Object-C、C#,JavaScript,PHP,Python
静态语言：运行时结构不可变的语言就是静态语言，如Java，C
java不是动态语言，但java可以称之为“准动态语言”。即Java有一定的动 态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。
关于java.lang.Class类的理解
1.类的加载过程
程序经过javac.exe命令以后，会生成一个或多个字节码文件（.class结尾）。接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，就称为运行时类，此运行时类，就作为Class的一个实例2.也就是说，class的实例就对应着一个运行时类
3.加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式类获取此运行时类
4.获取的实例是同一个
5.可以获取Class对象的类型
class:外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类interface：接口[]：数组enum：枚举annotation：注解@interfaceprimitive type：基本数据类型void实例：
//获取class的实例的方式 @Test public void test3() throws ClassNotFoundException { //方式一：调用运行时类的属性：.class Class<Person> class1 = Person.class; System.out.println(class1);//输出：class reflect.Person //方式二：通过运行时类的对象,调用getClass() Person p1 = new Person(); Class clazz2 = p1.getClass(); System.out.println(clazz2);//输出：class reflect.Person //方式三：调用Class的静态方法：forName(String classPath)(常用） Class clazz3 = Class.forName("reflect.Person"); System.out.println(clazz3);//输出：class reflect.Person //方式四：使用类加载器ClassLoader(了解) ClassLoader classLoader = ReflectionTest.class.getClassLoader(); Class clazz4 = classLoader.loadClass("reflect.Person"); System.out.println(clazz4);//输出：class reflect.Person //Class的类型 Class c1 = Object.class; Class c2 = Comparable.class; Class c3 = String[].class; Class c4 = int[][].class; Class c5 = ElementType.class; Class c6 = Override.class; Class c7 = int.class; Class c8 = void.class; Class c9 = Class.class }1.调用Class对象的newInstance()方法
Class<Person> clazz = Class.forName("reflect.Person"); /** * newInstance():调用 * 要想此方法正常的创建运行时类的对象，要求： * 1.运行时类必须提供空参的构造器 * 2.空参的构造器的访问权限得够。通常，设置为public * * 在javabean中要求提供一个public的空参构造器，原因： * 1.便于通过反射，创建运行时类的对象 * 2.便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器 */ Person obj = clazz.newInstance(); System.out.println(obj);2.没有无参构造器时，可以通过Class类的getDeclaredConstructor(Class … prarmeterTypes)取得本类的指定形参类型的构造器，想构造器的形参中传递一个对象数组进去，里面包含了构造器所需的各个参数，通过Constructor实例化对象
Class<Person> clazz = Class.forName("reflect.Person") Constructor cons = clazz.getDeclaredConstructor(int.class); cons1.setAccessible(true); Person p1 = (Person) cons1.newInstance(3);实现的全部接口，所继承的父类，全部的构造器，全部的方法，全部的Field
1.准备完整的工具类等 创建父类Creature public class Creature<T> implements Serializable { private char gender; public double weight; private void breath(){ System.out.println("呼吸"); } public void eat(){ System.out.println("吃饭"); } } 创建自定义接口MyInterface public interface MyInterface { void info(); } 创建自定义注解MyAnnotation @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE}) @Retention(RetentionPolicy.RUNTIME) public @interface MyAnnotation { String value() default "hello"; } 继承父类Creature的Person子类 @MyAnnotation(value = "hello") public class Person extends Creature<String> implements Comparable<String>,MyInterface{ private String name; int age; public int id; public Person(){} private Person(String name){ this.name =name; } Person(String name,int age){ this.name =name; this.age =age; } @MyAnnotation(value = "world") private String show(String info){ System.out.println("你好,"+info); return info; } public String display(String intst){ return intst; } @Override public int compareTo(String o) { return 0; } @Override public void info() { System.out.println("人类"); } } 2.获取运行时类的属性结构及其内部结构（了解） Class clazz =Class.forName("reflact.Person"); //获取属性结构 //getFields():获取当前类及其父类中声明为public访问权限的属性 Field[] fields = clazz.getFields(); for(Field f :fields){ System.out.println(f);//输出：public int cn.aixuxi.reflact.Person.id public double cn.aixuxi.reflact.Creature.weight } System.out.println(); //getDeclaredFields():获取当前运行时类中声明的所有属性（不包括父类中声明的属性） Field[] declaredFields = clazz.getDeclaredFields(); for (Field f:declaredFields){ System.out.println(f); } //获取权限修饰符、数据类型、变量名 Field[] declaredFields1 = clazz.getDeclaredFields(); for (Field f:declaredFields1){ //获取权限修饰符 int modifier=f.getModifiers(); System.out.println(Modifier.toString(modifier)); //获取数据类型 Class type = f.getType(); System.out.println(type); //获取变量名 String fname =f.getName(); System.out.println(fname); } 3.获取运行时类的方法结构及其内部结构（了解） Class clazz =Class.forName("reflact.Person"); //getMethods():获取当前运行时类及其所有父类中声明为public权限的方法 Method[] methods = clazz.getMethods(); for (Method m :methods){ System.out.println(m); } System.out.println("===================="); //getDeclaredMethods():获取当前运行时类声明的所有方法（不包括父类中声明的方法） Method[] declaredMethods = clazz.getDeclaredMethods(); for (Method m:declaredMethods){ System.out.println(m); } //获取方法权限修饰符、返回值类型、方法名(参数类型1 形参名1,........) throws xxxxxx{} Method[] declaredMethods1 = clazz.getDeclaredMethods(); for (Method m:declaredMethods1){ //1.获得方法的注解 Annotation[] annos = m.getAnnotations(); for (Annotation a:annos){ System.out.println(a); } //2.获得每一个方法的权限修饰符 System.out.println(Modifier.toString(m.getModifiers())); //3.获得返回值类型 System.out.println(m.getReturnType().getName()); //4.获得方法名 System.out.println(m.getName()); System.out.println("("); //5.获得形参列表 Class[] parameterTypes = m.getParameterTypes(); if(!(parameterTypes ==null && parameterTypes.length ==0)) { for (int i=0;i<parameterTypes.length;i++){ System.out.println(parameterTypes[i].getName()+"args_"+i); } } System.out.println(")"); //6.获得抛出的异常 Class<?>[] exceptionTypes = m.getExceptionTypes(); if (!(exceptionTypes==null && exceptionTypes.length==0)){ System.out.println("throws"); for (int i = 0; i <exceptionTypes.length ; i++) { if (i == exceptionTypes.length-1){ System.out.println(exceptionTypes[i].getName()); break; } System.out.println(exceptionTypes[i].getName()+","); } } } 4.获取运行时类的构造器 Class clazz =Class.forName("reflact.Person"); //getConstructors():获取当前运行时类声明为public的构造器 Constructor[] constructors = clazz.getConstructors(); for(Constructor c:constructors){ System.out.println(c); } //getDeclaredConstructors():获取当前运行时类中声明的所有的构造器 Constructor[] declaredConstructors=clazz.getDeclaredConstructors(); for (Constructor c:declaredConstructors){ System.out.println(c); } 5.获取运行时类的完整结构 Class clazz =Class.forName("reflact.Person"); //获取运行时类的父类 Class superClass = clazz.getSuperclass(); System.out.println(superClass); //获取运行时类的带泛型的父类 Type genericSuperclass = clazz.getGenericSuperclass(); System.out.println(genericSuperclass); //获取运行时类的带泛型的父类的泛型 ParameterizedType type = (ParameterizedType) genericSuperclass; //获取泛型类型 Type[] actualTypeArguments = type.getActualTypeArguments(); for(Type t:actualTypeArguments){ System.out.println(t.getTypeName()); } //获取运行时类实现的接口 Class[] interfaces = clazz.getInterfaces(); for (Class c:interfaces){ System.out.println(c); } //获取运行时类的父类实现的接口 Class[] interfaces1 = clazz.getSuperclass().getInterfaces(); for (Class c:interfaces1){ System.out.println(c); } //获取运行时类所在的包 Package aPackage = clazz.getPackage(); System.out.println(aPackage); //获取运行时类的注解 Annotation[] annotations = clazz.getAnnotations(); for (Annotation a:annotations){ System.out.println(a);//输出@reflact.MyAnnotation(value=hello) }调用运行时类的属性、方法、构造器
1.调用运行时类的属性
方式一：只能获取运行时类中声明为public的属性，不建议使用
//调用运行时类中指定的属性 Class clazz =Class.forName("reflact.Person"); //创建运行时类的对象 Person p = (Person)clazz.newInstance(); //获取指定的属性:要求运行时类中声明为public Field id = clazz.getField("id"); /** * 设置当前属性的值 * set():参数1：指明设置哪个属性的对象 参数2：将此属性值设为多少 */ id.set(p,1001); /** * 获取当前属性的值 * get():参数1：获取哪个对象的当前属性值 */ int pid = (int) id.get(p); System.out.println(pid);方式二：重要，建议掌握
//调用运行时类中指定的属性 Class clazz =Class.forName("reflact.Person"); //创建运行时类的对象 Person p = (Person)clazz.newInstance(); //getDeclaredField(String name):获取运行时类指定的变量名的属性 Field name = clazz.getDeclaredField("name"); //保证当前属性时可访问的 name.setAccessible(true); //获取设置指定对象的此属性值 name.set(p,"Tom"); System.out.println(name.get(p));2.调用运行时类指定的方法
//操作运行时类的指定方法 Class clazz =Class.forName("reflact.Person"); //创建运行时类的对象 Person p = (Person)clazz.newInstance(); /**获取指定的方法 * getDeclaredMethod():参数1：指明获取的方法名称 参数2：指明获取的方法的形参列表 */ Method show = clazz.getDeclaredMethod("show", String.class); //保证当前方法是可访问的 show.setAccessible(true); /** * 调用方法 * invoke():参数1：方法的调用者 参数2：给方法形参赋值的实参 * invoke()的返回值即视为对应类中调用方法的方绘制 */ Object object=show.invoke(p,"JAVA");//输出：你好,JAVA System.out.println(object); System.out.println("============="); //调用静态方法 Method showDesc = clazz.getDeclaredMethod("showDesc"); showDesc.setAccessible(true); //如果调用的运行时类中的方法没有返回值，则此invoke()返回null Object invoke = showDesc.invoke(Person.class); System.out.println(invoke);//null3.调用运行时类的指定构造器
Class clazz =Class.forName("reflact.Person"); //private Person(String name) /**获取指定的构造器 * getDeclaredConstructor():参数：指明构造器的参数列表 */ Constructor constructor = clazz.getDeclaredConstructor(String.class); //保证此构造器是可以访问的 constructor.setAccessible(true); //调用此构造器创建运行时类的对象 Person p = (Person) constructor.newInstance("Tom"); System.out.println(p);