注解不是程序本身, 可以对程序做出解释, 可以别其他程序读取,注解是可以带有参数的。可以使用在类、方法、字段上面, 相当于是添加了一些额外的信息, 我们可以通过反射机制来实现对这些数据的访问。
内置注解:重写、废弃、警告等。
元注解:元注解的作用就是负责解释其他的注解。
1、@target:用来描述当前注解的作用范围
2、@document :用来产生当前注解的文档信息
3、@inherited:表明子类可以继承父类的该注解
4、@retention:表明需要在什么级别保存该注解,用于描述注解的生命周期
自定义注解:
1、使用关键字 @interface
2、格式:
public @interface{ }
3、可以带有参数, 只有一个参数的时候, 建议名为 : value
4、实例参数:String name()
测试
// 测试元注解、自定义注解
@my1(value = "1", age = 2)
public class Test {
@my1(age = 2)
int age;
@SuppressWarnings("all")
@my1(value = "1", age = 2, id = 9)
public void testmethod() {
System.out.println(age);
}
public static void main(String[] args) {
new Test().testmethod();
}
}
// 标记运行时候的注解
@Retention(value = RetentionPolicy.RUNTIME)
// 标记产生文档
@Documented
// 标记作用的范围
@Target({ElementType.METHOD, ElementType.TYPE, ElementType.FIELD})
@interface my1 {
// 使用 value的时候, 注解的参数可以直接写
String value() default "";
int age();
// 可以设置默认值
int id() default 1;
// 数组类型
String[] school() default {"洛阳师范学院", "北大"};
}
反射机制允许程序在执行的时候借助反射的API来获取类的基本信息。 并且能够操作类的内部属性以及方法。
每当类加载完毕后, 在堆中都会产生一个Class类型的对象, 这个对象包含了完整的类信息, 这个对象就是一面镜子一样,通过它我们能够得类的完成结构信息。
反射来获取对象:
实例化对象->getclass方法->得到完整的包类名称
java的反射能够动态的创建对象,很灵活。但是对性能有影响
Object类中定义了getClass()方法, 即所有的类也就拥有了此方法。
从代码上来看, java的反射就是通过对象的名字得到(反射)出类的名称。
获取Class对象的方法
1、通过类的名称, 直接调用.class
Person.class
2、以知类的实例后, 通过getclass()方法
3、知道类的全路径。通过Clas类的方法
Class.forName(path)
4、内置基本类型可以用:类名.Type
测试
public class Test01 {
/**
* 获得 对象的 Class
* @param args
* @throws ClassNotFoundException
*/
public static void main(String[] args) throws ClassNotFoundException {
Person p1 = new Stu();
System.out.println("这个人是" + p1.name);
// 1 getClass();
Class p1Class = p1.getClass();
System.out.println(p1Class.hashCode());
// 2 Class.forName
Class p2 = Class.forName("com.Reflaction.Stu");
System.out.println(p2.hashCode());
// 3 Stu.class
Class<Stu> aClass = Stu.class;
System.out.println(aClass.hashCode());
// 4 Integer.TYPE;
Class<Integer> type = Integer.TYPE;
System.out.println(type);
// 5 getSuperclass();
Class<? super Stu> superclass = aClass.getSuperclass();
System.out.println(superclass);
}
}
class Person {
public String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
}
class Stu extends Person {
public Stu() {
this.name = "学生";
}
}
class Tea extends Person {
public Tea() {
this.name = "教师";
}
}
当程序准备主动使用一个类的时候,如果该类还没加载到内存中,系统会通过下面三个步骤加载:
1、类的加载:将类的class文件读入到内存中, 并为之创建一个java.lang.Class对象,此过程由类加载器来完成。
2、类的链接:将类的二进制文件链接到jre中
3、类的初始化:jvm来操作
什么时候开始类的初始化?
一、主动引用
1、new 一个类的对象
2、调用类的静态成员、方法
3、使用反射方法进行反射的调用
4、初始化子类的时候, 会先初始化父类
二、被动引用
1、定义类的数组
2、引用常量的时候(链接的时候就加载到类的常量池中了)
解释:类在加载完毕的时候就会把类的Class对象放到堆内存中,一个Class对象代表一个类,加载的时候同时也会把类的数据信息(静态方法和变量、常量池)放到方法区中,方法区中的类数据和堆中Class对象是对应的。实例化类的时候是在栈中开辟空间来存放堆中对象(类的Class)的引用。
测试
spublic class Test04 {
static {
System.out.println("加载Main");
}
public static void main(String[] args) throws ClassNotFoundException {
// 主动引用
// B b = new B();
// Class.forName("com.Reflaction.B");
// 不会产生子类的引用
// System.out.println(B.n);
// System.out.println(B.m);
// 什么都不引用
B[] arr = new B[5];
}
}
class A {
static int n = 10;
static {
System.out.println("父类的静态代码加载");
}
public A() {
System.out.println("加载父类");
}
}
class B extends A {
static final int m = 100;
static {
System.out.println("子类的静态代码加载");
}
public B() {
System.out.println("加载子类");
}
}
测试
public class Test07 {
/**
* 类加载器
*
* @param args
*/
public static void main(String[] args) throws ClassNotFoundException {
// 通过反射得到这类
Class<?> aClass = Class.forName("com.Reflaction.Test07");
// 得到用户的类加载器
ClassLoader loader = aClass.getClassLoader();
System.out.println(loader);
// 得到系统加载器
ClassLoader parent = loader.getParent();
System.out.println(parent);
// 得到根加载器
ClassLoader parent1 = parent.getParent();
System.out.println(parent1);
// 双亲委派机制
// 运行时候java可以加载的目录
String property = System.getProperty("java.class.path");
System.out.println(property);
}
}
获取类的结构, 简单的说,就是先通过对象, 或者直接得到堆中的这个类的Class对象, 然后调用Class对象的API。
测试
public class Test08 {
/**
* 获取类的全部属性
*
* @param args
*/
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
// 先得到类得信息
Class<?> name = Class.forName("com.Reflaction.User");
System.out.println(name);
System.out.println("==============================");
// 得到类的公有属性
Field[] fields = name.getFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("==============================");
//得到全部的属性
fields = name.getDeclaredFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("==============================");
// 得到类的共有方法
Method[] methods = name.getMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println("==============================");
// 全部方法
methods = name.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method);
}
// 获得指定的方法, 为了避免重载, 需要添加额外的传参数, 区分
System.out.println("================================");
Method method = name.getMethod(String.valueOf(name), String.class);
System.out.println(method);
// 获取构造器, 方法同上
Constructor<?>[] constructors = name.getConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println(constructor);
}
}
}
在上一步得到类的信息之后, 便可以开始调用了
public class Test09 {
// 通过反射创建对象, 并且操作属性和方法
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
// 通过反射来创建对象, 默认调用无参构造器, 无参构造必须为公有
Class<?> name = Class.forName("com.Reflaction.User");
Object instance = name.newInstance();
System.out.println(instance);
Constructor<?>[] constructors = name.getConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println(constructor);
}
constructors = name.getDeclaredConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println(constructor);
}
// 指定调用有参构造器
Constructor<?> constructor = name.getDeclaredConstructor(Integer.class, String.class, Integer.class);
Object c = constructor.newInstance(1, "c", 1);
System.out.println(c);
// 操作方法
Object user = (User) name.newInstance();
Method setName = name.getDeclaredMethod("setName", String.class);
// 使用 invoke 表示激活的意思,后面带上参数
setName.invoke(user,"cyt");
System.out.println(user);
// 操作属性, 需要开启权限
Field field = name.getDeclaredField("name");
field.setAccessible(true);
field.set(user, "崔雨田");
System.out.println(user);
}
}
使用的对象
public class User {
private Integer id;
private String name;
private Integer age;
// get、set
// 有参、无参构造器
}
测试
// 通过反射来创建对象, 默认调用无参构造器, 无参构造必须为公有
Class<?> name = Class.forName("com.Reflaction.User");
Object instance = name.newInstance();
System.out.println(instance);
// 指定调用有参构造器
Constructor<?> constructor = name.getDeclaredConstructor(Integer.class, String.class, Integer.class);
Object c = constructor.newInstance(1, "c", 1);
System.out.println(c);
7、获得泛型信息
public class Test11 {
public Map<String, String> test1() {
System.out.println("test1");
return null;
}
public void test2(Map<String, String> map, List<Integer> list) {
System.out.println("test2");
}
/**
* 通过反射来获得泛型的信息
*
* @param args
*/
public static void main(String[] args) throws NoSuchMethodException {
Method method = Test11.class.getDeclaredMethod("test2", Map.class, List.class);
Type[] parameterTypes = method.getGenericParameterTypes();
for (Type type : parameterTypes) {
System.out.println(type);
if (type instanceof ParameterizedType) {
Type[] types = ((ParameterizedType) type).getActualTypeArguments();
for (Type type1 : types) {
System.out.println(type1);
}
}
}
method = Test11.class.getDeclaredMethod("test1", null);
Type returnType = method.getGenericReturnType();
System.out.println(returnType);
if (returnType instanceof ParameterizedType) {
Type[] types = ((ParameterizedType) returnType).getActualTypeArguments();
for (Type type1 : types) {
System.out.println(type1);
}
}
}
}
学习自:狂神教程
https://www.bilibili.com/video/BV1p4411P7V3?from=search&seid=4017859439455063941
因篇幅问题不能全部显示,请点此查看更多更全内容
Copyright © 2019- igat.cn 版权所有 赣ICP备2024042791号-1
违法及侵权请联系:TEL:199 1889 7713 E-MAIL:2724546146@qq.com
本站由北京市万商天勤律师事务所王兴未律师提供法律服务