文章目录
注解和反射
注解(Annotation)
注解入门
Annotation的作用
- 不是程序本身，可以对程序作出解释
- 可以被其他程序(编译器)读取
Annotation的格式
- 注解是以“@注释名”在代码中存在的，还可以添加一些参数值，例如：@SuppressWarnings(value=“unchecked”)
Annotation的使用位置
- 可以附加在package, class, method, field 等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元数据的访问
内置注解
- @Override：定义在 java.lang.Override 中，此注释只适用于修辞方法，表示一个方法声明发酸重写超类中的另一个方法声明（重写方法）
//@Override 重写的注解，重写 Object 中的 toString()
@Override
public String toString() {
return super.toString();
}
- @Deprecated：定义在 java.lang.Deprecated 中，此注释可以用于修饰方法，属性，类，表示不鼓励程序员使用这样的元素，通常是因为他很危险或者存在更好的选择（已废弃）
//@Deprecated 不推荐使用，但是可以使用，存在危险或有更好的选择
@Deprecated
public static void test(){
System.out.println("Deprecated");
}
- @SuppressWarnings：定义在 java.lang.SuppressWarnings 中，用来抑制编译时的警告信息
- 需要添加参数才能正确使用，这些参数都是已经定义好的，选择性的使用
- @SuppressWarnings(“all”) //抑制所有警告
- @SuppressWarnings(“unchecked”) //抑制未检查的
- @SuppressWarnings(value={“unchecked”,“deprecation”}) //传递过个参数
- 其他……
- 需要添加参数才能正确使用，这些参数都是已经定义好的，选择性的使用
//SuppressWarnings
@SuppressWarnings("all")
public void test02(){
System.out.println("SuppressWarnings");
}
自定义注解和元注解
元注解
- 元注解的作用就是负责注解其他注解，Java定义了4个表真的meta-annotaion类型，他们被用来提供对其他annotation类型做说明
4种元注解
//* Target 表示该注解可以用在什么地方，value 可以单个或使用数组{}表示多个，type类型，method方法，package包名等
//* Retention 表示注解在什么地方有效，value 有三个值，SOURCE-源码时， CLASS-编译文件时，RUNTIME-运行时 生效，等级划分：runtime > class > source
//Retention 等级高包含等级低，例，定义 value=class，则在 source 中有效，在 runtime 中无效
//Documented 表示是否将我们的注解生成在 JAVAdoc 中
//Inherited 表示子类可以继承父类的注解
@Target(value={ElementType.TYPE, ElementType.METHOD})
@Retention(value= RetentionPolicy.RUNTIME)
@Documented
@Inherited
@interface MyAnnotation{
}
重点掌握 Target 和 Retention
自定义注解
- 使用 @interface 自定义注解时，自动集成了 java.lang.annotation.Annotation 接口
- 分析：
- @interface 用来声明一个注解，格式：public @interface 注解名 {定义内容}
- 其中的每一个方法实际上是声明了一个配置参数
- 方法的名称就是参数的名称
- 返回值类型就是参数的类型（返回值只能是基本类型，Class，String，enum）
- 可以通过 default 来声明参数的默认值
- 如果只有一个参数成员，一般参数名为 value
- 注解元素必须要有值，我们定义注解元素时，经常使用空字符串或者 0 作为默认值
自定义注解样例
//自定义的注解
public class Test03 {
//若自定义注解有参数，且没有默认值，则参数不可以为空
//@MyAnnotation2(name = "kuang")
//若自定义注解有参数，且存在默认值，则可以不写参数，也可以显式赋值
@MyAnnotation2(age = 18)
public void test(){ }
//注解只有一个参数，且参数的名称是 value 时，可以直接写参数值
//@MyAnnotation3(value = "kuang")
@MyAnnotation3("kuang")
public void test2(){ }
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
//注解的参数：参数类型 + 参数名称 ();
//可以增加默认值 参数类型 + 参数名称 () + default + 默认值;
// String name();
String name() default "kong";
int age();
int id() default -1; //如果默认值为-1，代表不存在
String[] school() default {"清华","北大"};
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
String value();
}
反射
静态 VS 动态语言
动态语言
- 是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。在运行时代码可以根据某些条件改变自身结构
- 主要动态语言：Object-C、C#、JavaScript、PHP、Python 等
静态语言
- 与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++
- Java不是动态语言，但Java可以称之为”准动态语言“。即Java有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。
Java Reflection
- Reflection（反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助 Reflection API 取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
- **例：**Class c = Class.forName(“java.lang.String”)
- 加载完类之后，在堆内存的方法区中就产生了一个 Class 类型的对象（一个类只有一个 Class 对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。我们称之为：反射
- 正常方式：
-
- 引入需要的“包类”名称
- 通过 new 实例化
- 取得实例化对象
-
- 反射方式：
-
- 实例化对象
- getClass() 方法
- 得到完整的“包类”名称
-
反射方式样例：
package com.kuang.reflection;
//反射
public class Test02 {
public static void main(String[] args) throws ClassNotFoundException {
//通过反射获取类的 Class 对象
Class c1 = Class.forName("com.kuang.reflection.user");
System.out.println(c1);
Class c2 = Class.forName("com.kuang.reflection.user");
Class c3 = Class.forName("com.kuang.reflection.user");
Class c4 = Class.forName("com.kuang.reflection.user");
//一个类在内存中只有一个 Class 对象
//一个类被加载后，类的整个结构都会被封装在 Class 对象中
System.out.println(c2.hashCode());
System.out.println(c3.hashCode());
System.out.println(c4.hashCode());
//三个哈希数值相同，表示三个 Class 指向同一个实体类
}
}
//实体类
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;
}
@Override
public String toString() {
return "user{" +
"name='" + name + '\'' +
", id=" + id +
", age=" + age +
'}';
}
}
反射的优缺点
优点：
- 可以实现动态创建对象和编译，体现出灵活性
缺点：
- 对性能有影响。使用反射基本上是一种解释操作，我们可以告诉 JVM，我们希望做什么并且它满足我们的要求。这类操作慢于直接执行相同的操作。
Class类
-
在 Object 类中定义了以下的方法，此方法将被所有子类继承
- public final Class getClass()
-
以上方法返回值的类型是一个 Class 类，此类是 Java 反射的源头，实际上所谓反射从程序的运行结果来看也好理解，即：可以通过对象反射求出类的名称。
-
对象照镜子（getClass()）后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，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 newInstatnce()
- 调用缺省构造函数，返回 Class 对象的一个实例
- getName()
- 返回此 Class 对象所表示的实体（类、接口、数组或 void）的名称
- Class getSuperClass()
- 返回当前 Class 对象的父类的 Class 对象
- Class[] getinterfaces()
- 获取当前 Class 对象的接口
- ClassLoader gerClassLoader()
- 返回该类的类加载器
- Constructor[] getConstructors()
- 返回一个包含某些 Constructor 对象的数组
- Method getMothed(String name, Class… T)
- 返回一个 Method 对象，此对象的形参类型为 paramType
- Field[] getDeclaredFields()
- 返回 Field 对象的一个数组
获取 Class 类的实例
- 若已知具体的类，通过类的 class 属性获取，该方法最为安全可靠，程序性能最高
- Class clazz = Person.class;
- 已知某个类的实例，调用该实例的 getClass() 方法获取哦 Class 对象
- Class clazz = person.getClass();
- 已知一个类的全类名，且该类在类路径下，可通过 Class 类的静态方法 forName()获取，可能抛出 ClassNotFoundException
- Class clazz = Class.forName(“demo01.Student”);
- 内置基本数据类型可以直接用类名 .Type
- 可以利用 ClassLoader获取
获取 Class 类实例
//测试 Class 类的创建方式有哪些
public class Test03 {
public static void main(String[] args) throws ClassNotFoundException {
Student student = new Student();
System.out.println("这个人是："+student.name);
//通过对象获得子类 Class
Class c1 = student.getClass();
//通过 forName() 获得
Class c2 = Class.forName("com.kuang.reflection.Student");
//通过类名 .class 获得
Class c3 = Student.class;
//通过不同方法获取相同 class 类
System.out.println(c1.hashCode());
System.out.println(c2.hashCode());
System.out.println(c3.hashCode());
//通过子类获取父类 class
Class c5 = c1.getSuperclass();
System.out.println(c5);
}
}
class person{ //父类
public String name;
public person() {}
public person(String name) {
this.name = name;
}
@Override
public 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
类型的class有哪些
//所有类型的 Class
public class Test04 {
public static void main(String[] args) {
Class c1 = Object.class; //类的 class
Class c2 = Comparable.class; //接口的 class
Class c3 = String[].class; //数组的 class
Class c4 = int[][].class; //二维数组的 class
Class c5 = Override.class; //注解的 class
Class c6 = ElementType.class; //枚举类型的 class
Class c7 = Integer.class; //基本数据类型的 class
Class c8 = void.class; //空类型的 class
Class c9 = Class.class; //Class本身的 class
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
System.out.println(c5);
System.out.println(c6);
System.out.println(c7);
System.out.println(c8);
System.out.println(c9);
//结果:
//class java.lang.Object
//interface java.lang.Comparable
//class [Ljava.lang.String;
//class [[I
//interface java.lang.Override
//class java.lang.annotation.ElementType
//class java.lang.Integer
//void
//class java.lang.Class
//即使长度不同，只要元素类型与维度一样，就是同一个 class，hashCode()相同
int[] int1 = new int[10];
int[] int2 = new int[100];
System.out.println(int1.getClass().hashCode());
System.out.println(int2.getClass().hashCode());
}
}
扫一扫
566
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
