Class类
所有的类都是数据类型Type,每一次加载一个类,jvm就会将这个类加载进内存.
每一次加载类,jvm就会创建一个Clas类的实例,并且关联起来.这是Class,不是普通的类,类似于:
public final class Class {
private Class() {}
}
比如,创建一个String实例,就首先读取String.class文件加载道内存,然后创建一个Class实例关联起来:
Class cls = new Class(String);
这个Class实例是jvm内部创造的,构造方法都是私有的,自己是无法创建这个Class实例的.而且每个JVM创建的Class实例都是指向一个数据类型:
而且一个Class实例都包含了一个完整的类信息:
如何获取Class实例,Class实例是唯一的,以下都是获取的同一个实例:
Class cls = String.class; // class是类中的静态变量
String s = "Hello";
Class cls = s.getClass(); // 有一个实例变量,通过getClass()方法获取
Class cls = Class.forName("java.lang.String"); // 有一个完整的类名,可以通过Class的静态方法forName(String)获取
instance of和Calss实例用==比较,instance of 不仅包括自身,还包括父类都是正确的,而Class实例每一个类都有唯一确定的关系:
Integer n = new Integer(123);
boolean b1 = n instanceof Integer; // true，因为n是Integer类型
boolean b2 = n instanceof Number; // true，因为n是Number类型的子类
boolean b3 = n.getClass() == Integer.class; // true，因为n.getClass()返回Integer.class
boolean b4 = n.getClass() == Number.class; // false，因为Integer.class!=Number.class
反射
反射的目的就是获得某个实例的具体信息,每一个对象实例,都可以反射获取该对象的类信息,通过Class的类方法可以获取具体信息:
public class Main {
public static void main(String[] args) {
printClassInfo("".getClass());
printClassInfo(Runnable.class);
printClassInfo(java.time.Month.class);
printClassInfo(String[].class);
printClassInfo(int.class);
}
static void printClassInfo(Class cls) {
System.out.println("Class name: " + cls.getName()); // 获取该实例的具体类名
System.out.println("Simple name: " + cls.getSimpleName()); // 获取该实例的具体类名
if (cls.getPackage() != null) {
System.out.println("Package name: " + cls.getPackage().getName()); // 获取该实例所在的包名称
}
System.out.println("is interface: " + cls.isInterface()); // 获取该实例是否是接口
System.out.println("is enum: " + cls.isEnum()); // 获取该实例是否为枚举
System.out.println("is array: " + cls.isArray()); // 获取该实例是否为数组
System.out.println("is primitive: " + cls.isPrimitive()); // 获取该实例是否是基本类型
}
}
JVM为每一种基本类型也创建了Class实例,通过基本类型.class访问;
动态加载
JVM在执行java程序的时候,并不是一次性把所有的类加载道内存,而是第一使用的时候才会加载到内存.
例如:
public class Main {
public static void main(String[] args) {
if (1> 0) {
create("linux");
}
}
static void create(String name) {
Person p = new Person(name);
Logger logger = Logger.getGlobal();
logger.info("success");
}
static class Person{
private String name;
public Person(String name) {
this.name = name;
}
}
}
由于用到了Main，因此，JVM首先会把Main.class加载到内存。然而，并不会加载Person.class，除非程序执行到create()方法，JVM发现需要加载Person类时，才会首次加载Person.class。如果没有执行create()方法，那么Person.class根本就不会被加载。这就是动态加载.
访问字段
通过Class类的一些方法可以访问类中的字段:
import java.lang.reflect.Field;
public class Main {
public static void main(String[] args) throws Exception {
Class stdClass = Student.class;
// 获取public字段"score":
System.out.println(stdClass.getField("score"));
// 获取继承的public字段"name":
System.out.println(stdClass.getField("name"));
// 获取private字段"grade":
System.out.println(stdClass.getDeclaredField("grade"));
// Field[] getFields()：获取所有public的field（包括父类）
Field[] field1 = Student.class.getFields();
for(Field field : field1) {
System.out.print(field + " ");
}
System.out.print("\n");
// Field[] getDeclaredFields()：获取当前类的所有field（不包括父类）
Field[] field2 = stdClass.getDeclaredFields();
for(Field field : field2) {
System.out.print(field + " ");
}
}
}
class Student extends Person {
public int score;
private int grade;
}
class Person {
public String name;
}
访问结果包含字段的所有信息,字段具体名称,字段类型,字段修饰符:
还可以获得字段的值,但是一般类中的数据是封装的,不让外界访问,反射是一种非常规做法:
import java.lang.reflect.Field;
public class Main {
public static void main(String[] args) throws Exception {
Object p = new Person("Xiao Ming"); // 利用根类初始化创建对象
Class c = p.getClass();
Field f = c.getDeclaredField("name");
f.setAccessible(true); // 因为类中数据为private,需要用setAccessible得到允许
Object value = f.get(p);
System.out.println(value); // "Xiao Ming"
}
}
class Person {
private String name;
public Person(String name) {
this.name = name;
}
}
访问数据之后,自然可以设置字段值,利用Field类方法:
public class Main {
public static void main(String[] args) throws Exception {
Person p = new Person("Xiao Ming");
System.out.println(p.getName()); // "Xiao Ming"
Class c = p.getClass();
Field f = c.getDeclaredField("name");
f.setAccessible(true); // 需要获得允许
f.set(p, "Xiao Hong"); // 利用FIeld类,设置字段值
System.out.println(p.getName()); // "Xiao Hong"
}
}
class Person {
private String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}
调用方法
可以通过每个类在JVM创建的Class对象来获取类中的所有字段,也可以获取类中的方法信息,和获取字段的方法类似:
Method getMethod(name, Class...)：获取某个public的Method（包括父类）
Method getDeclaredMethod(name, Class...)：获取当前类的某个Method（不包括父类）
Method[] getMethods()：获取所有public的Method（包括父类）
Method[] getDeclaredMethods()：获取当前类的所有Method（不包括父类）
import java.lang.reflect.Method;
public class Main {
public static void main(String[] args) throws Exception {
Class stdClass = Student.class;
// 获取public方法getScore，参数为String:
System.out.println(stdClass.getMethod("getScore", String.class));
// 获取继承的public方法getName，无参数:
System.out.println(stdClass.getMethod("getName"));
// 获取private方法getGrade，参数为int:
System.out.println(stdClass.getDeclaredMethod("getGrade", int.class));
System.out.println("Method[] getMethods()：获取所有public的Method（包括父类）");
//
Method[] method1 = stdClass.getMethods();
for(Method method : method1) {
System.out.println(method);
}
System.out.println("// Method[] getDeclaredMethods()：获取当前类的所有Method（不包括父类）");
Method[] method2 = stdClass.getDeclaredMethods();
for(Method method : method2) {
System.out.println(method);
}
}
}
class Student extends Person {
public int getScore(String type) {
return 99;
}
private int getGrade(int year) {
return 1;
}
}
class Person {
public String getName() {
return "Person";
}
}
获取结果就是函数修饰符,返回值类型,具体在哪个类的方法名称,参数类型:
和访问字段类四,也可以调用方法,获取了该方法的实例之后,在用invoke方法调用:
比如:
String s = "Hello world";
String r = s.substring(6); // "world"
用反射原理实现上述表达:
import java.lang.reflect.Method;
public class Main {
public static void main(String[] args) throws Exception {
// String对象:
String s = "Hello world";
// 获取String substring(int)方法，参数为int,subString是获取子串:
Method m = String.class.getMethod("substring", int.class);
// 在s对象上调用该方法并获取结果:
String r = (String) m.invoke(s, 6);
// 打印调用结果:
System.out.println(r);
}
}
invoke方法第一个参数是代表该方法的实例对象,后面的参数是传入函数的参数.
调用静态方法就是将invoke第一个参数传入null,Integer.parseInt(String)用反射原理实现:
import java.lang.reflect.Method;
public class Main {
public static void main(String[] args) throws Exception {
// 获取Integer.parseInt(String)方法，参数为String,parseInt是将字符串解析为十进制的数:
Method m = Integer.class.getMethod("parseInt", String.class);
// 调用该静态方法并获取结果:
Integer n = (Integer) m.invoke(null, "12345");
// 打印调用结果:
System.out.println(n);
}
}
调用非public方法,和设置字段类似,需要加上setAccessible(true)来通过:
public class Main {
public static void main(String[] args) throws Exception {
Person p = new Person();
Method m = p.getClass().getDeclaredMethod("setName", String.class);
m.setAccessible(true); // 用来允许通过调用非public方法
m.invoke(p, "Bob");
System.out.println(p.name);
}
}
class Person {
String name;
private void setName(String name) {
this.name = name;
}
}
而且invoke总是调用实际类型的方法,满足多态原则:
import java.lang.reflect.Method;
public class Main {
public static void main(String[] args) throws Exception {
// 获取Person的hello方法:
Method h = Person.class.getMethod("hello");
// 对Student实例调用hello方法:
h.invoke(new Student());
}
}
class Person {
public void hello() {
System.out.println("Person:hello");
}
}
class Student extends Person {
public void hello() {
System.out.println("Student:hello");
}
}
最后打印的是Student:hello.证明满足多态原则,实际上就相当于:
Person p = new Student();
p.hello();
调用构造方法
可以通过反射原理来调用无参数的构造函数:
例如:
Person p = new Person();
转换成:
Person p = Person.class.newInstance(); // 通过jvm创建的Class类对象,来创建Person对象.
如果要调用有参数的构造函数,就要通过Constructor对象来调用,和获取Method对象类似:
import java.lang.reflect.Constructor;
public class Main {
public static void main(String[] args) throws Exception {
// 获取构造方法Integer(int):
Constructor cons1 = Integer.class.getConstructor(int.class);
// 调用构造方法:
Integer n1 = (Integer) cons1.newInstance(123);
System.out.println(n1);
// 获取构造方法Integer(String)
Constructor cons2 = Integer.class.getConstructor(String.class);
Integer n2 = (Integer) cons2.newInstance("456");
System.out.println(n2);
}
}
通过Class实例获取Constructor的方法如下：
getConstructor(Class...)：获取某个public的Constructor；
getDeclaredConstructor(Class...)：获取某个Constructor；
getConstructors()：获取所有public的Constructor；
getDeclaredConstructors()：获取所有Constructor。
Constructor总是当前类定义的构造方法，和父类无关，因此不存在多态的问题.调用非public的Constructor时，必须首先通过setAccessible(true)设置允许访问.
获取继承关系
其实获取到某个Class对象的时候,就相当于获取了一个类的类型:
Class cls = String.class; // 获取到String的Class,并且可以做到可能的操作
String s = "";
Class cls = s.getClass();
Class s = Class.forName("java.lang.String");
这是获取Class对象的三种方法.而且实际上就是同一个实例.
获取了该类的Class实例,还可以获取该类的父类:
public class Main {
public static void main(String[] args) throws Exception {
Class i = Integer.class;
Class n = i.getSuperclass();
System.out.println(n); // class java.lang.Number
Class o = n.getSuperclass();
System.out.println(o); // class java.lang.Object
System.out.println(o.getSuperclass()); // null
}
}
还可以获取接口,一个类可以实现一个或多个接口,通过Class还可以查询实现的接口类型,例如查询Integer类型的接口:
import java.lang.reflect.Method;
public class Main {
public static void main(String[] args) throws Exception {
Class s = Integer.class;
Class[] is = s.getInterfaces();
for (Class i : is) {
System.out.println(i);
// getInterfaces()只返回当前类直接实现的接口类型，并不包括其父类实现的接口类型
// interface java.lang.Comparable
// interface java.lang.constant.Constable
// interface java.lang.constant.ConstantDesc
}
}
}
对所有interface的Class调用getSuperclass()返回的是null，获取接口的父接口要用getInterfaces().
通过调用isAssignableFrom()可以判断向上转型是否成功:
// Integer i = ?
Integer.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Integer
// Number n = ?
Number.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Number
// Object o = ?
Object.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Object
// Integer i = ?
Integer.class.isAssignableFrom(Number.class); // false，因为Number不能赋值给Integer
动态代理
所有的接口不能直接实例化,而是通过向上转型实例化:
CharSequence cs = new StringBuilder(); // StringBuilder的接口就有CharSequence
省略…
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
