@Override（重写） @Deprecated（过时，不推荐使用） @SuppressWarnings(“all”)（镇压告警） @interface MyAnnotation {} 通过@interface关键字声明注解 通过元注解修饰这个注解
@Target(value = {ElementType.TYPE, ElementType.METHOD}) //表示注解可以用在哪个地方 @Retention(value = RetentionPolicy.RUNTIME) //表示注解在什么时候生效，一般都是runtime运行时，runtime>class>source @Documented //表示是否将我们的注解生成JavaDoc文档 @Inherited //表示子类可以继承父类的注解 注解的参数：参数类型 参数名称 (); 当注解只有一个参数时，建议使用value命名，这样调用方使用注解赋值时可以不用写参数名 @MyParamAnnotation(age = 18, schools = {"清华", "北大"})
@MyParamAnnotation2("嗯嗯")
public class ParamAnnotation {
}
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyParamAnnotation {
//注解的参数：参数类型 参数名称 (); 括号必须带，而且参数没有默认值，调用注解时必须给注解参数赋值
String name() default "";
int age();
String[] schools();
}
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyParamAnnotation2 {
//当注解只有一个参数时，建议使用value命名，这样调用方使用注解赋值时可以不用写参数名
String value();
}
反射是java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象中的内部属性和方法 加载完类后，在堆内存的方法区中产生了一个Class类的对象（一个类只有一个Class对象），这个对象包含了完整的类的结构信息，可以通过这个对象看到这个类的结构，这个对象就像一面镜子，透过镜子看到类的结构，称之为反射 优缺点：
优点：可以实现动态创建对象和编译，体现出很大的灵活性 缺点：对性能会有影响，使用反射基本是一种解释操作，我们告诉jvm，我们希望做什么，并且它会满足我们的需求，这类操作总是慢于直接执行相同的操作 public static void main(String[] args) throws ClassNotFoundException {
Student student = new Student();
System.out.println(student.name);
//方式1：通过对象.getClass获得
Class c1 = student.getClass();
System.out.println(c1.hashCode());
//方式2：通过forName获得(值为类的包路径)
Class c2 = Class.forName("com.qing.reflection.Student");
System.out.println(c2.hashCode());
//方式3：通过类型.class获得
Class c3 = Student.class;
System.out.println(c3.hashCode());
//方式4：基本内置类型会有一个属性TYPE
Class c4 = Integer.TYPE;
System.out.println(c4.hashCode());
//获得父类类型
Class superclass = c1.getSuperclass();
System.out.println(superclass);
}
public static void main(String[] args) {
Class c1 = Object.class;//类
Class c2 = void.class;//void
Class c3 = Class.class;//Class
Class c4 = ElementType.class;//枚举
Class c5 = Comparable.class;//接口
Class c6 = String[].class;//一维数组
Class c7 = String[][].class;//二维数组
Class c8 = SuppressWarnings.class;//注解
Class c9 = Integer.class;//基本数据类型
System.out.println(c1);//class java.lang.Object
System.out.println(c2);//void
System.out.println(c3);//class java.lang.Class
System.out.println(c4);//class java.lang.annotation.ElementType
System.out.println(c5);//interface java.lang.Comparable
System.out.println(c6);//class [Ljava.lang.String;
System.out.println(c7);//class [[Ljava.lang.String;
System.out.println(c8);//interface java.lang.SuppressWarnings
System.out.println(c9);//class java.lang.Integer
}
堆
存放new出来的对象或数组 可以被所有的线程共享，不会存放别的对象引用 栈
存放基本变量类型（会包含这个基本变量类型的具体数值） 引用对象的变量（会存放这个引用在堆里的具体地址） 方法区（特殊的堆）存放常量和static定义的变量
加载
将class文件加载到内存中，并将静态数据转换成方法区运行时的数据结构，然后生成一个代表这个类的java.lang.Class对象 链接（将java代码合并到jvm的运行状态之中的过程）
验证：确保加载的类信息完全符合JVM规范，没有安全方面问题 准备：正式为类变量也就是static分配内存，并设置类变量默认值的阶段，这些内存都将在方法区中进行分配 解析：虚拟机常量池的符号引用（常量名） 替换为直接引用（地址）的过程 初始化
执行类构造器()的过程，这个方法是由编译器自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器） 当初始化一个类的时候，如果父类还没有初始化，则会先初始化父类 虚拟机会保证一个类的()方法在多线程中会被正确加锁和同步 new一个类对象的时候，类会被初始化，并且父类如果没有被初始化，会先初始化父类 反射也会产生主动引用 //分析类的初始化
public class InitClass {
public static void main(String[] args) throws ClassNotFoundException {
//虚拟机启动，先初始化main方法类
System.out.println("Main方法初始化！");
//new一个类对象的时候，类会被初始化，并且父类如果没有被初始化，会先初始化父类
//Son son = new Son();
//System.out.println(Son.num);
//反射也会产生主动引用
// Class.forName("com.qing.reflection.Son");
//不会产生类应用的方法
//子类调用父类的静态变量，子类不会被加载
// System.out.println(Son.num);
//通过数组定义类引用，不会初始化这个类
// Son[] sons = new Son[6];
//调用常量不会触发父类和子类的初始化（常量在链接阶段就存入调用类的常量池中了）
System.out.println(Son.NUM);
}
}
class Father {
static int num = 10;
static {
System.out.println("父类被初始化！");
}
}
class Son extends Father {
static {
System.out.println("子类被初始化！");
}
static final int NUM = 10;
}
public static void main(String[] args) throws NoSuchFieldException, NoSuchMethodException {
User user = new User();
Class uc = user.getClass();
//获得包名 + 类名
System.out.println("========================================================================================");
System.out.println(uc.getName());
//获得类名
System.out.println("========================================================================================");
System.out.println(uc.getSimpleName());
//获取类中public类型的属性
System.out.println("========================================================================================");
Field[] ucFields = uc.getFields();
for (Field ucField : ucFields) {
System.out.println(ucField);
}
//获取类中全部类型的属性
System.out.println("========================================================================================");
Field[] declaredFields = uc.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
//获得指定属性的值（如果属性为private，则会报错）
// System.out.println(uc.getField("id"));
//获得指定属性的值，不区分属性修饰符
System.out.println("========================================================================================");
System.out.println(uc.getDeclaredField("id"));
//获得本类以及父类中所有的public修饰的方法
System.out.println("========================================================================================");
Method[] methods = uc.getMethods();
for (Method method : methods) {
System.out.println(method);
}
//获取类中所有的方法，包括private
System.out.println("========================================================================================");
Method[] declaredMethods = uc.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println(declaredMethod);
}
//获得类中指定方法
System.out.println("========================================================================================");
System.out.println(uc.getMethod("getName", null));
System.out.println(uc.getMethod("setName", String.class));
//获得public构造器
System.out.println("========================================================================================");
Constructor[] constructors = uc.getConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
//获得全部构造器
System.out.println("========================================================================================");
Constructor[] declaredConstructors = uc.getDeclaredConstructors();
for (Constructor declaredConstructor : declaredConstructors) {
System.out.println(declaredConstructor);
}
//获得指定的构造器
System.out.println("========================================================================================");
System.out.println(uc.getConstructor(String.class, String.class));
}
/**
* 通过反射，动态的创建对象
* 方法、属性、构造器都有setAccessible，当这些方法、属性为private修饰的时候，需要setAccessible设置为true，取消安全检查才可以赋值
*/
public class CreateObjectByReflection {
public static void main(String[] args) throws Exception {
Class c = Class.forName("com.qing.reflection.User");
//构造一个对象，本质就是调用的无参构造器
User o = (User) c.newInstance();
System.out.println(o);
//通过构造器创建对象
Constructor constructor = c.getConstructor(String.class, String.class);
User user1 = (User) constructor.newInstance("0001", "liuxu");
System.out.println(user1);
//通过反射调用方法赋值
User user2 = (User) c.newInstance();
Method setName = c.getMethod("setName", String.class);
//使用invoke方法激活setName并赋值
setName.invoke(user2, "huwenqing");
c.getMethod("setId", String.class).invoke(user2, "0002");
System.out.println(user2);
//通过反射操作属性
User user3 = (User) c.newInstance();
Field id = c.getDeclaredField("id");
//私有属性需要取消安全检查才能操作私有属性
id.setAccessible(true);
id.set(user3, "0003");
Field name = c.getDeclaredField("name");
name.setAccessible(true);
name.set(user3, "xiaobaobao");
System.out.println(user3);
}
}
//通过反射来操作注解
public class GetAnnotationByReflection {
public static void main(String[] args) throws Exception {
Class c = Class.forName("com.qing.reflection.People");
//获取类上的注解
Annotation[] annotations = c.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
//获取类注解上的value值
TableNameLx annotation = (TableNameLx) c.getAnnotation(TableNameLx.class);
System.out.println(annotation.value());
//获取类中指定列的注解值
Field age = c.getDeclaredField("age");
FieldLx fieldLx = age.getAnnotation(FieldLx.class);
System.out.println(fieldLx.len());
System.out.println(fieldLx.type());
System.out.println(fieldLx.name());
}
}
@TableNameLx("db_people")
class People {
@FieldLx(name = "db_people_id", type = "int", len = 10)
private int id;
@FieldLx(name = "db_people_name", type = "varchar", len = 100)
private String name;
@FieldLx(name = "db_people_age", type = "int", len = 10)
private int age;
public People() {
}
public People(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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 "People{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}
//自定义注解：用作于类上
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableNameLx {
String value();
}
//自定义注解：用作于列上
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldLx {
String name();
String type();
int len();
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
