注解与反射

注解

1.Annotation是从JDK5.0开始引入的新技术

2.Annotation的作用：

不是程序本身，可以对程序做出解释（这一点和注释（comment）没什么却别）
可以被其他程序（比如：编译器等）读取

3.Annotation的格式：

注解是以”@注释名“在代码中存在的，还可以添加一些参数值，例如

@Override/@SuppressWarning(value=“unchecked”)

4.Annotaion在哪里使用？

可以附加在packege，class，method field等上面，相当于给他们添加了额外的辅助信息
我们可以通过反射机制编程实现对这些元数据的访问

内置注解

1.@Override：定义在java.lang.Override中，此注释只适用于修辞方法，表示一个方法声明打算重写超类中的另一个方法声明

2.@Deprecated：定义在java.lang.Deprecated中，此注释可以用于修辞方法，属性，类，表示鼓励程序员使用这样的元素，通常是因为它很危险或者存在更好的选择

3.@SuppressWarings：定义在java.lang.SuppressWaring中，用来抑制编译时的警告信息

与前两个注释有所不同，需要添加一个参数才能正确使用，这些参数都是已经定义好了的
选择性使用即可
@SuppreWaring(“all”)
@SuppreWaring(“unchecked”)
@SuppreWaring(value={“unchecked”,“deprecation”})
等等…

代码示例：

package Demo01;import java.awt.*;//什么是注解
public class Test01 extends Object {// @Override 重写的注解@Overridepublic String toString() {return super.toString();}//不推荐程序员使用，但是可以使用   或者存在更好的方式@Deprecatedpublic static void test(){System.out.println("@Deprecated");}@SuppressWarnings("all")public void test02(){List list=new List();}public static void main(String[] args) {test();}
}

元注解

1.元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他annotation类型作说明.

2.这些类型和他们所支持的类在java.lang.annottation包中可以找到（@Target，@Retention，@Documented，@Inherited）

3.@Target：用于描述注解的使用范围（即：被描述的注解可以用在什么地方）

4.@Retention：表示需要在什么级别保存改注释的信息，用于描述注解的生命周期

（SOURCE<CLASS<RUNTIME)

5.@Documented:说明该注解将被包含在javadoc中

6.@Inherited：说明子类可以继承父类中的该注解

代码示例：

package Demo01;import java.lang.annotation.*;//测试元注解
@MyAnnotation
public class Test02 {public void test(){}
}//定义一个元注解
//Target 表示我们的注解可以用在哪些地方
@Target(value ={ElementType.METHOD,ElementType.TYPE})
//@Retention 表示我们的注解在哪些地方有效
//（SOURCE<CLASS<RUNTIME)
@Retention(value = RetentionPolicy.RUNTIME)
//@Documented 表示我们的注解是否生成在Javadoc中
@Documented
//@Inherited 表示子类可以继承父类的注解
@Inherited@interface MyAnnotation{}

自定义注解

用@Interface自定义注解时，自动继承了java.lang.annotation.Annotation接口

分析:

@Interface用来声明一个注解，格式：public @Interface 注解名{定义内容}
其中的每一个方法实际上是声明了一个配置参数
方法的名称就是参数的名称
返回值类型就是参数的类型（返回值只能时基本类型，Class String，enum）
可以通过default来声明参数的默认值
如果只有一个参数成员，一般参数名为value
注解元素必须要有值，我们定义注解元素时，经常使用空字符串，0作为默认值

代码示例：

package Demo01;import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;//测试自定义注解
public class Test03 {//注解可以显示定义，如果没有默认值，我们就必须给注解赋值@MyAnnotation2(schools = {"华商大学"}) //若有默认值default 可以不加name="你好"public void test(){ }@MyAnnotation3("你好")  //只有一个值的情况public  void test2(){}
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{//注解的参数：参数类型+参数名（）String name() default "";int age() default 0;int id() default -1;//如果默认值为-1  代表不存在。indexof--如果找不到就返回-1String[] schools() default {"北华"};
}@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{String value(); //只有一个值的情况}

反射机制（Java Reflection）

动态语言

是一类在运行时可以改变其结构的语言：列如新的函数，对象，甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点就是在运行时代码可以根据某些条件改变自身结构.

主要动态语言：Object—C、C#、JavaScrit、PHP、Python等.

静态语言

与动态语言相对应，运行时结构不可变的语言就是静态语言。例如Java、C、C++

Java不是动态语言，但Java可以称之为”准动态语言“。即Java具有一定的动态性、我们可以利用反射机制获得类似动态语言的特性。Java的动态性让编程的时候更加灵活！

Java Reflection

1.Reflection（反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

Class c=Class.forName(“Java.lang.String”)

2.加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个对象只有一个Class类对象），这个对象就包含了完整的类的结构信息。可以通过这个对象看到类的结构，这个对象就像一面镜子，透过这个镜子看到类的结构，所以，形象的称之为：反射

正常方式：引入需要的”包类“的=名称——>通过new实例化——>取得实例化对象
反射方式：实例化对象——>getClass()方法——>得到完整的”包类“名称

3.反射机制提供的功能

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时获取泛型信息
在运行时调用任意一个对象的成员变量和方法
在运行时处理注解
生成动态代理
…

4.优点：可以实现动态创建对象和编译，体现出很大的灵活性

5.缺点：对性能有影响。使用反射基本上是一种解释操作，可以告诉JVM，

希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作.

6.反射相关的主要API

java.lang.Class：代表一个类
java.lang.reflect.Method：代表类的方法
java.lang.reflect.Field：代表类的成员变量
java.lang.reflect.Constructor:代表类的构造器
…

什么是放射代码示例：

package reflect;//什么叫反射
public class Test02 extends Object{public static void main(String[] args) throws ClassNotFoundException {//通过反射获取类的Class对象Class c1 = Class.forName("reflect.User");System.out.println(c1);//输出结果相同，说明一个类在内存中只有一个Class对象//一个类被加载后，类的整个结构都会被封装在Class对象中Class c2 = Class.forName("reflect.User");Class c3 = Class.forName("reflect.User");Class c4  = Class.forName("reflect.User");System.out.println(c2.hashCode());System.out.println(c3.hashCode());System.out.println(c4.hashCode());}
}//实体类：pojo、entity
class User{private String name;private int id;private int age;public User() {}public User(String name, int id, int age) {this.name = name;this.id = id;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getId() {return id;}public void setId(int id) {this.id = id;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +", id=" + id +", age=" + age +'}';}
}

Class类

在Object类中定义了以下的方法，此方法将被所有子类继承
public final Class getClass()
以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称.

对象照镜子后可以得到的信息：某个类的属性，方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE都为其保留一个不变的Class类型的对象.一个Class对象包含了特定某个结构（class/interface/enum/annotation/primitive type/void[]）的有关信息

Class本身也是一个类
Class对象只能由系统建立对象
一个加载的类在JVM中只会有一个Class实例
一个Class对象对应的是一个加载到JVM中的一个.class文件
每个类的实例都会记得自己是由哪个Class实例所生成
通过Class可以完整地得到一个类中所有被加载的结构
Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

Class类常用的方法

方法名	功能说明
static ClassforName(String name)	返回指定类名name的Class对象
Object newInstance	调用却省构造函数，返回Class对象的一个实例
getName()	返回此Class对象所表示的实体（类、接口、数组类或void）的名称
Class getSuperClass()	返回当前Class对象的父类的Class对象
Class[] gettinterfaces()	获取当前Class对象的接口
ClassLoader getClassLoader()	返回该类的类加载器
Constructor getConstructors	返回一个包含某些Contructor对象的数组
Method getMothed(String name,Class…T)	返回一个Method对象，，此对象的形参类型为param Type
Field getDeclareFields()	返回Field对象的一个数组

获取Class类的实例：

若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高.
若已知谋个类的实例，调用该实例的getClass()方法获取Class对象
已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取
可能抛出ClassNotFoundException
内置基本数据类型可以直接用类名：Type
还可以利用ClassLoader

代码示例：

package reflect;//测试Class类的创建方式有哪些
public class Test03 {public static void main(String[] args) throws ClassNotFoundException {Person person = new Student();System.out.println("这个人是:"+person.name);//方式一：通过对象获得Class c1 = person.getClass();System.out.println(c1.hashCode());System.out.println(c1);//class reflect.Student//方式二：forname获得Class c2 = Class.forName("reflect.Student");System.out.println(c2.hashCode());//方式三：通过类名.class获得Class c3 = Student.class;System.out.println(c3.hashCode());//方式四：基本内置类型的包装类都有一个Type属性Class c4 = Integer.TYPE;System.out.println(c4);  //默认的int类型//获得父类类型Class c5 = c1.getSuperclass();System.out.println(c5);//class reflect.Person}
}class Person{public String name;public Person() {}public Person(String name) {this.name = name;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +'}';}
}class Student extends Person{public Student(){this.name="学生";}
}class Teacher extends Person{public Teacher(){this.name="老师";}
}

哪些类型可以有Class对象？

class:外部类，成员（成员内部类、静态内部类）、局部内部类、匿名内部类.
interface：接口
[]：数组
enum：枚举
annotation：注解@interface
primitive type：基本数据类型
void

Java内存分析

类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。

1、类的加载(Load)：将类的class文件读入内存，并为之创建一内存，并为之创建一java.lang.Class对象，此过程由类加载器完成

2、类的链接(Link)：将类的二进制数据合并到JRE中

3、类的初始化(Initialize)：JVM负责对类的初始化

代码示例：

package reflect;public class Test05 {public static void main(String[] args) {A a=new A();System.out.println(A.m);/*1.加载到内存，会产生一个类对象的Class对象2.链接，链接结束后m=03.初始化<clint>(){System.out.println("A类静态代码类初始化");m=300;m=100;}m=100*/}
}class A{static {System.out.println("A类静态代码类初始化");m=300;}/*第一次给m赋值300第二次给m赋值100此时m100将m300覆盖了*/static  int m=100;public A() {System.out.println("A类无参构造初始化");}
}

类的加载与ClassLoader的理解

➢加载:将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构,
然后生成一个代表这个类的java.lang.Class对象.
➢链接:将Java类的二进制代码合并到JVM的运行状态之中的过程。
➢验证: 确保加载的类信息符合JVM规范，没有安全方面的问题
➢准备:正式为类变量(static) 分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
➢解析:虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程。
➢初始化:
➢执行类构造器 ()方法的过程。类构造器< clinit> ()方法是由编译期自动收集类中所有类变量的赋值动作和静态
代码块中的语句合并产生的。(类构造器是构造类信息的，不是构造该类对象的构造器)。
➢当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
➢虚拟机会保证-个类的 ()方法在多线程环境中被正确加锁和同步。

什么时候初始化？

➢类的主动引用(- -定会发生类的初始化)
➢当虚拟机启动,先初始化main方法所在的类
➢new一个类的对象
➢调用类的静态成员(除了final常量)和静态方法
➢使用java.lang.reflect包的方法对类进行反射调用
➢当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类
➢类的被动引用(不会发生类的初始化)
➢当访问-个静态域时，只有真正声明这个域的类才会被初始化。如:当通过子类引用父类的静态变量，不会导
致子类初始化
➢通过数组定义类引用，不会触发此类的初始化
➢引用常量不会触发此类的初始化(常量在链接阶段就存入调用类的常量池中了)

代码示例：

package reflect;//测试类什么时候会初始化
public class Test06 {static {System.out.println("Main被加载");}public static void main(String[] args) throws ClassNotFoundException {//1.主动引用//Son son=new Son();//反射也会产生主动引用//Class.forName("reflect.Son");//不会产生类的引用的方法//System.out.println(Son.b);//通过子类调用父类的方法//这里不会执行子类//Son[] array=new Son[5];//常量不会引起父类和子类的初始化System.out.println(Son.M);}
}class Father{static int b=2;static {System.out.println("父类被加载");}
}
class  Son extends Father{static {System.out.println("子类被加载");m=300;}static int m=100;static final int M=1;  //常量池
}

类加载器的作用

➢类加载的作用:将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时
数据结构，然后在堆中生成-一个代表这个类的java.lang.Class对象,作为方法区中类数据的访问
入口。.
➢类缓存:标准的JavaSE类加载器可以按要求查找类,但一旦某个类被加载到类加载器中，它将维
持加载(缓存)一段时间。不过JVM垃圾回收机制可以回收这些Class对象

代码示例：

package reflect;public class Test07 {public static void main(String[] args) throws ClassNotFoundException {//获取系统类的加载器ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();System.out.println(systemClassLoader);//获取系统类加载器的父类加载器-->扩展类ClassLoader parent = systemClassLoader.getParent();System.out.println(parent);//获取扩展类加载器的父类加载器--->根加载器（c/c++）ClassLoader parent1 = parent.getParent();System.out.println(parent1);//测试当前类是那个加载器加载的ClassLoader classLoader = Class.forName("reflect.Test07").getClassLoader();System.out.println(classLoader);//用户自定义的类//测试JDK内置的类是谁加载的classLoader = Class.forName("java.lang.Object").getClassLoader();System.out.println(classLoader);//如何获得系统类加载器可以加载的路径System.out.println(System.getProperty("java.class.path"));}
}

获取类的运行时结构

通过反射获取运行时类的完整结构

Field、Method、Constructor、Superclass、Interface、Annotation

实现的全部接口
所继承的父类
全部的构造器
全部的方法
全部的Field

注解

…

代码示例：

package reflect;import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;//获得类的信息
public class Test08 {public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {Class c1= Class.forName("reflect.User");//User user=new User();// c1= user.getClass();  //添加了这个之后 Class.forName("reflect.User");无效//获得类的名字System.out.println(c1.getName());  //获得包名+类名System.out.println(c1.getSimpleName());//获得类名//获得类的属性System.out.println("====================================");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);//获得类的方法System.out.println("====================================");Method[] methods = c1.getMethods(); //获得本类及其父类的全部public方法for (Method method : methods) {System.out.println("正常的:"+method);}Method[] declaredMethods = c1.getDeclaredMethods();  //获得本类的所有方法for (Method method : methods) {System.out.println("getDeclaredMethods"+method);}//获得指定的方法Method getName = c1.getMethod("getName", null);Method setName = c1.getMethod("setName", String.class);System.out.println(getName);System.out.println(setName);//获得指定的构造器System.out.println("====================================");Constructor[] constructors = c1.getConstructors();for (Constructor constructor : constructors) {System.out.println(constructor);}constructors = c1.getDeclaredConstructors();for (Constructor constructor : constructors) {System.out.println("getDeclaredConstructors"+constructor);}Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);System.out.println("执指定:"+ declaredConstructor );}
}

创建类的对象:调用Class对象的newInstance()方法

➢ 类必须有一个无参数的构造器5
➢类的构造器的访问权限需要足够
思考?难道没有无参的构造器就不能创建对象了吗?只要在操作的时候明确的调用类中的构造器
并将参数传递进去之后，才可以实例化操作。
➢步骤如下:
1)通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构
造器
2)向构造器的形参中传递一一个对象数组进去，里面包含了构造器中所需的各个参数。
3)通过Constructor实例化对象

调用指定的方法

通过反射，调用类中的方法，通过Method类完成。
①通过Class类的getMethod(String name,Clas…parameterTypes)方法取得
一个Method对象，并设置此方法操作时所需要的参数类型。
②之后使用Object invoke(Object obj, Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息。

Object invoke(Object obj, Object … args)
➢Object 对应原方法的返回值，若原方法无返回值，此时返回null
➢若原方法若为静态方法，此时形参Object obj可为null
➢若原方法形参列表为空，则Object[] args为null
➢若原方法声明为private,则需要在调用此invoke()方法前，显式调用方法对象的
setAccessible(true)方法，将可访问private的方法。

setAccessible

➢Method和Field、 Constructor对象都有setAccessible()方法。
➢setAccessible作用是启动和禁用访问安全检查的开关。
➢参数值为true则指示反射的对象在使用时应该取消Java语言访问检查。
➢提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为true。
➢使得原本无法访问的私有成员也可以访问
➢参数值为false则指示反射的对象应该实施Java语言访问检查

代码示例：

package reflect;import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;//动态的创建对象，通过反射
public class Test09 {public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {//获得Class对象Class c1 = Class.forName("reflect.User");//构造一个对象//User user =(User)c1.newInstance();//本质是调用了类的无参构造器//System.out.println(user);//通过构造器创建对象//Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);//User user2 =(User)constructor.newInstance("花花", 007, 19);//System.out.println(user2);//将User删除，也可以构建//通过反射调用普通方法User user3 =(User)c1.newInstance();//通过反射调用方法//invoke激活 执行的意思//(对象，“方法的值”)Method setName = c1.getDeclaredMethod("setName", String.class);setName.invoke(user3,"花花");System.out.println(user3.getName());//通过方式操作属性System.out.println("================================");User user4 =(User)c1.newInstance();Field name = c1.getDeclaredField("name");//不能直接操作私有属性，需要关闭程序的安全检测，属性或方法的setAccessible(true)name.setAccessible(true);//关闭name.set(user4,"花花007");System.out.println(user4.getName());}
}

反射操作泛型

➢Java采用泛型擦除的机制来弓|入泛型, Java中的泛型仅仅是给编译器javac使用的，确保数据.
的安全性和免去强制类型转换问题,但是,一旦编译完成,所有和泛型有关的类型全部擦除
➢为了通过反射操作这些类型, Java新增了ParameterizedType , GenericArrayType，
TypeVariable和WildcardType几种类型来代表不能被归一-到Class类中的类型但是又和原
始类型齐名的类型.
➢ParameterizedType : 表示-种参数化类型,比如Collection
➢GenericArrayType :表示一种元素类型是参数化类型或者类型变量的数组类型
➢TypeVariable :是各种类型变量的公共父接口
➢WildcardType :代表一种通配符类型表达式

代码示例：

package reflect;import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;//通过反射获取泛型
public class Test11 {public void test01(Map<String,User>map, List<User>list){System.out.println("Test01");}public  Map<String,User> test02(){System.out.println("Test02");return null;}public static void main(String[] args) throws NoSuchMethodException {Method method = Test11.class.getMethod("test01", Map.class, List.class);Type[] genericParameterTypes = method.getGenericParameterTypes();for (Type genericParameterType : genericParameterTypes) {System.out.println("#"+ genericParameterType );if (genericParameterType instanceof ParameterizedType){Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();for (Type actualTypeArgument : actualTypeArguments) {System.out.println(actualTypeArgument);}}}method = Test11.class.getMethod("test02", null);Type genericReturnType = method.getGenericReturnType();}
}

反射操作注解

➢getAnnotations

➢getAnnotation

代码示例：

package reflect;import java.lang.annotation.*;
import java.lang.reflect.Field;//练习反射操作注解
public class Test12 {public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {Class c1 = Class.forName("reflect.Student2");//通过反射获得注解Annotation[] annotations = c1.getAnnotations();for (Annotation annotation : annotations) {System.out.println(annotation);}//获得注解value的值Tablehua tablehua =(Tablehua)c1.getAnnotation(Tablehua.class);String value = tablehua.value();System.out.println(value);//获得类指定的注解Field f = c1.getDeclaredField("id");Fieldhua annotation = f.getAnnotation(Fieldhua.class);System.out.println(annotation.columName());System.out.println(annotation.type());System.out.println(annotation.length());}
}@Tablehua("db_student")
class Student2{@Fieldhua(columName = "db_id",type = "int",length = 10)private int id;@Fieldhua(columName = "db_age",type = "int",length = 10)private int age;@Fieldhua(columName = "db_name",type = "varchar",length = 3)private String name;public Student2() {}public Student2(int id, int age, String name) {this.id = id;this.age = age;this.name = name;}public int getId() {return id;}public int getAge() {return age;}public String getName() {return name;}public void setId(int id) {this.id = id;}public void setAge(int age) {this.age = age;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Student2{" +"id=" + id +", age=" + age +", name='" + name + '\'' +'}';}
}//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Tablehua{String value();
}//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Fieldhua{String columName();String type();int length();
}
tring name) {this.id = id;this.age = age;this.name = name;}public int getId() {return id;}public int getAge() {return age;}public String getName() {return name;}public void setId(int id) {this.id = id;}public void setAge(int age) {this.age = age;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Student2{" +"id=" + id +", age=" + age +", name='" + name + '\'' +'}';}
}//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Tablehua{String value();
}//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Fieldhua{String columName();String type();int length();
}

❤️Java面试高频《注解与反射》（建议收藏）❤️相关推荐

❤️Mybatis编程界的能手—使用注解开发（建议收藏）
❤️Mybatis编程界的能手-使用注解开发(建议收藏) ❤️1.面向对象编程大家之前都学过面向对象编程,也学习过接口,但在真正的开发中,很多时候我们会选择面向接口编程根本原因:解耦,可拓展, 提 ...
Java类的加载过程详解面试高频！！！值得收藏！！！
受多种情况的影响,又开始看JVM 方面的知识. 1.Java 实在过于内卷,没法不往深了学. 2.面试题问的多,被迫学习. 3.纯粹的好奇. 很喜欢一句话: 八小时内谋生活,八小时外谋发展. 望别日与 ...
Spring——事务注解@Transactional【建议收藏】
在某些业务场景下,如果一个请求中,需要同时写入多张表的数据或者执行多条sql,为了保证操作的原子性(要么同时成功,要么同时失败),避免数据不一致的情况,我们一般都会用到事务:Spring框架下,我们经 ...
菜鸟学习笔记：Java提升篇11（Java动态性1——注解与反射）
Java提升篇11(Java其它高级特性--注解与反射) 注解(Annotation) JDK内置注解自定义注解元注解(meta-annotation) 反射(reflection) 动态语言反 ...
flex布局练习题，面试必备，持续更新建议收藏~
先言: 现在网页布局大多都是flex布局,像浮动这些用得比较少,在面试中flex也是被经常问到的.而有些同学学完flex后,又不懂怎么练习巩固,所以,所以,所以,我汇聚了一些常见的flex的练习题案 ...
B站【狂神说Java笔记】-注解和反射
目录狂神视频地址 1.什么是注解? 2.内置注解 3.元注解 4.自定义注解 5.Java反射概述 6.Class 类 7.哪些类型可以有Class 对象? 8.类加载与内存分析 9.什么时候会发生 ...
Java接口、注解、反射
写在前面你们好,我是小庄.很高兴能和你们一起学习Java.如果您对Java感兴趣的话可关注我的动态. 写博文是一种习惯,在这过程中能够梳理和巩固知识. 一.接口什么是接口? 接口( ...
❤️Java面试高频词《多线程》（建议收藏）❤️
Java多线程(详解+示例) 目录: 01.线程简介任务.进程.线程.多线程 02.线程实现(重点) 继承Thread类.实现Runnable接口.实现Callable接口 03.线程状态 04.线 ...
超详细——Java面试高频
目录 1.基础题 1.1面向对象和面向过程的区别 1.2 Java 语言有哪些特点 1.3 Java 和 C++的区别 1.6 字符型常量和字符串常量的区别 1.7 基本类型 1.8 构造器 Cons ...

❤️Java面试高频《注解与反射》（建议收藏）❤️

注解与反射

注解

内置注解

元注解

自定义注解

反射机制（Java Reflection）

动态语言

静态语言

Java Reflection

Class类

Class类常用的方法

获取Class类的实例：

哪些类型可以有Class对象？

Java内存分析

类的加载过程

类的加载与ClassLoader的理解

什么时候初始化？

类加载器的作用

获取类的运行时结构

通过反射获取运行时类的完整结构

创建类的对象:调用Class对象的newInstance()方法

调用指定的方法

setAccessible

反射操作泛型

反射操作注解

❤️Java面试高频《注解与反射》（建议收藏）❤️相关推荐

最新文章

热门文章