Java注解和反射

最新推荐文章于 2024-09-23 15:50:28 发布

2301_79098686

最新推荐文章于 2024-09-23 15:50:28 发布

阅读量527

点赞数 23

分类专栏：程序员文章标签： java 学习经验分享

本文链接：https://blog.csdn.net/2301_79098686/article/details/139155721

版权

程序员专栏收录该内容

202 篇文章 0 订阅

订阅专栏

@MyAnnotation3(“mianmianmi”)

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，代表不存在

String[] schools() default {“西北”,“西南”,“东北”};

}

@Target({ElementType.TYPE,ElementType.METHOD})

@Retention(RetentionPolicy.RUNTIME)

@interface MyAnnotation3{

String value();//只有一个参数，使用value命名

}

2.反射

静态语言（java,c,c++)和动态语言(C#,JavaScript,PHP):根据运行时结构是否可变区分，如引入新的函数、对象，删除已有的函数等，即代码运行时可以根据某些条件改变自身结构。java利用反射机制获得类似动态语言的特性。

Reflection（反射）机制允许程序在执行期间借助Reflection API 获得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
加载完类之后，堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象包含了完整的类结构信息，通过这个对象看到类的结构，类似镜子，称之为：反射。
反射优点:实现动态创建对象和编译，灵活性大。缺点：影响性能，使用反射是一种解释操作，是在告诉JVM希望它完成什么，慢于直接执行相同操作。

//反射机制演示

public class ReflectionDemo01 {

public static void main(String[] args) throws ClassNotFoundException {

//通过反射获取类的Class对象

Class c1 = Class.forName(“com.jayz.annotationDemo.User”);

System.out.println(c1);

Class c2 = Class.forName(“com.jayz.annotationDemo.User”);

Class c3 = Class.forName(“com.jayz.annotationDemo.User”);

//一个类在内存中只有一个Class对象，一个类被加载后，类的整个结构都会封装在Class对象中

System.out.println(c2.hashCode());

System.out.println(c3.hashCode());//二者结果相等，指向同一对象

}

//实体类

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;

}

Class类：一个Class对象宝华了特定某个结构的有关信息

Class对象只能由系统建立
一个加载的类在JVM中只会有一个Class实例，一个Class对象对应的是一个加载到JVM中的.class文件
Class类是Reflection的根源，针对任何想动态加载的类，必须获得Class对象

2.1 获取Class类的实例

已知具体类，通过类的class属性获取，最安全，性能最高（Class c = Person.class;)
已知某个类的实例，调用该实例的getClass()方法获取Class对象（Class c = person.getClass()😉
已知一个类的全类名，且该类在类路径下，通过Class类的静态方法forName() 获取，需要抛出异常
内置基本数据类型直接使用类名.Type
利用ClassLoader

数组只要元素类型与维度一样，就是同一个class

2.2 Java 内存

堆：存放new出来的对象和数组；可以被所有线程共享，不存放别的对象引用
栈：存放基本变量类型；存放引用对象的变量（此引用在堆的具体地址）
方法区：可以被所有线程共享；包含所有的class和static变量

类的加载过程：

类的加载(Load)

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表该类的java.lang.Class对象
类加载器把类(class)装载进内存。有引导类加载器（Bootstap Classloader)(JVM自带，C++编写，负责Java平台核心库，无法直接获取），扩展类加载器(Extension Classloader)（负责jre/lib/ext目录下的jar包装入工作库），系统类加载器(System Classloader)（负责java -classpath所指的目录下的类与jar包装入，最常用的加载器）
双亲委派机制确保类的正确加载

//类加载器演示

public class ClassLoaderDemo {

public static void main(String[] args) throws ClassNotFoundException {

//获取系统类的加载器

ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();

System.out.println(systemClassLoader);

//获取系统类加载器的父类加载器—>扩展类加载器

ClassLoader parent = systemClassLoader.getParent();

System.out.println(parent);

//获取扩展类加载器的父类加载器–>根加载器

ClassLoader parent1 = parent.getParent();

System.out.println(parent1);

//测试当前类是哪个加载器加载的

ClassLoader classLoader = Class.forName(“com.jayz.annotationDemo.ClassLoaderDemo”).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”));

}

类的链接(Link)

将Java类的二进制代码合并到JVM运行环境中
验证：确保加载的类信息符合JVM规范，没有安全问题
准备：正式为类变量(static)分配内存并设置类变量默认初始值，内存都将在方法区中分配。
解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程

类的初始化(Initialize)

执行类构造器()方法的过程。类构造器方法是由编译器自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生（不是类对象的构造器）
初始化一个类时，若发现其父类还没有初始化，先触发其父类的初始化
虚拟机保证一个类的()方法在多线程环境中被正确加锁和同步。
发生类的初始化（类的主动应用），被动引用不会。

主动引用：当虚拟机启动时，先初始化main方法所在

必看视频！获取2024年最新Java开发全套学习资料备注Java

的类

new 一个类的对象
调用类的静态方法和静态成员
使用java.lang.reflect包中的方法对类进行反射调用
初始化一个类，若其父类没有被初始化，先初始化父类

被动引用

访问一个静态域时，只有真正声明这个域的类才会被初始化（如子类引用父类的静态变量，不会导致子类初始化）
通过数组定义类引用，不会触发此类的初始化
引用常量不会触发初始化（常量在链接阶段存入常量池）

public class InitiDemo {

static {

System.out.println(“Main所在类加载”);

}

public static void main(String[] args) throws ClassNotFoundException {

//1.主动引用

//Son son = new Son(); //Main所在类加载父类被加载子类被加载

// 反射

//Class.forName(“com.jayz.annotationDemo.Son”);//Main所在类加载父类被加载子类被加载

//被动引用

//System.out.println(Son.b);//Main所在类加载父类被加载 2

Son[] sons = new Son[5]; //Main所在类加载

}

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;

}

2.3 类信息

示例：获取类相关信息（方法，属性，构造器，父类，接口，注解）

//获取类的信息

public class ClassInformation {

public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {

Class c1 = Class.forName(“com.jayz.annotationDemo.User”);

//获得类的名字

System.out.println(c1.getName()); //获得包名+类名

System.out.println(c1.getSimpleName()); //获得类名

//获得类的属性

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);

//获得类的方法

Method[] methods = c1.getMethods(); //获得本类及父类的所有public方法

for(Method method:methods) {

System.out.println(method);

}

methods = c1.getDeclaredMethods(); //获得本类的所有方法

for(Method method:methods) {

System.out.println(method);

}

//获得构造器方法

Constructor constructor = c1.getConstructor();

Constructor[] constructors = c1.getConstructors();

}

示例：**通过反射构造对象，调用方法和属性（私有的，setAccessible(true))。**使用反射会影响程序效率。

//反射操作

public class ReflectionDemo02 {

public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {

//获得Class对象

Class c1 = Class.forName(“com.jayz.annotationDemo.User”);

//构造对象

User u1 = (User)c1.newInstance(); //调用类的无参构造器，若定义了有参构造，没有定义无参构造，无法使用此方法

System.out.println(u1);

//通过构造器创建对象

Constructor constructor = c1.getConstructor(String.class, int.class, int.class);

User u2 = (User)constructor.newInstance(“jay”, 01, 18);

System.out.println(u2);

//通过反射调用普通方法

User u3 = (User)c1.newInstance();

Method setName = c1.getDeclaredMethod(“setName”, String.class);

//invoke 激活方法

setName.invoke(u3,“jay2”);

System.out.println(u3.getName());

//反射操作属性

User u4 = (User)c1.newInstance();

Field name = c1.getDeclaredField(“name”);//访问私有属性，权限不够

//关闭权限

name.setAccessible(true);

name.set(u4,“jay3”);

System.out.println(u4.getName());

}

2.4 ORM （Object relation Mapping):利用注解和反射完成类和表结构的映射关系

public class ORM_Demo {

public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {

Class c1 = Class.forName(“com.jayz.annotationDemo.Student01”);

最后

权威指南-第一本Docker书

引领完成Docker的安装、部署、管理和扩展，让其经历从测试到生产的整个开发生命周期，深入了解Docker适用于什么场景。并且这本Docker的学习权威指南介绍了其组件的基础知识，然后用Docker构建容器和服务来完成各种任务：利用Docker为新项目建立测试环境，演示如何使用持续集成的工作流集成Docker，如何构建应用程序服务和平台，如何使用Docker的API，如何扩展Docker。

总共包含了：简介、安装Docker、Docker入门、使用Docker镜像和仓库、在测试中使用Docker、使用Docker构建服务、使用Fig编配Docke、使用Docker API、获得帮助和对Docker进行改进等9个章节的知识。