类型信息：反射-Class

最新推荐文章于 2024-03-09 16:34:05 发布

认真的学生

最新推荐文章于 2024-03-09 16:34:05 发布

阅读量731

点赞数 1

分类专栏： JAVA 文章标签： class

本文链接：https://blog.csdn.net/u013473691/article/details/52366036

版权

JAVA 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

在说反射前提一个概念：RTTI（在运行时，识别一个对象的类型）

public class Shapes {
    public static void main(String[] args) {
        List<Shape> shapes = Arrays.asList(new Circle(), new Square(), new Triangle());
        for (Shape shape : shapes) {
            shape.draw();
        }
    }
}
abstract class Shape{
    void draw() {
        System.out.println(this + ".draw()");
    }
    abstract public String toString();
}
class Circle extends Shape{

    @Override
    public String toString() {
        return "circle";
    }
}
class Square extends Shape{

    @Override
    public String toString() {
        return "square";
    }
}
class Triangle extends Shape {

    @Override
    public String toString() {
        return "triangle";
    }
}

在这个例子中，RTTI类型转换并不彻底：Object被转型为Shape，而不是转型为其子类。这是因为目前我们只知道这个list<shape>保存的都是Shape。在编译时，将交由容器和java泛型系统来强制确保这一点；而在运行时，有类型转换来确保这一点。接下来就是多态机制了。

但是，假如碰到这么一个特殊的问题——我们想要找到其中一种形状图案将它全部变为某种颜色，该怎么办呢？我们通过以上代码并没有办法去获得具体的类型。这就需要RTTI了。

要理解RTTI在java中的工作原理，首先必须知道类型信息在运行时是如何表示的——Class对象。Class对象包含了与类有关信息。java是面向对象的语言，我们可以通过创建类来抽象某一对象，也可以通过Class来抽象这些类。每个类都有一个Class对象。就是每当你执行javac编译的时候，你创建的类就会产生一个Class对象（.class文件）。所有的类都是在对其第一次使用时，动态加载到JVM中的。当程序创建第一个对类的静态成员的引用时，就会加载这个类。这个也证明了构造器也是类的静态方法，虽然在构造器之前并没有使用static关键字，但是new操作符创建类的新对象也会被当作类的静态成员的引用。由此得出，java程序在它开始运行之前并非被完全加载。其各部分是在必需时才加载的。

一旦某个类的Class对象被载入内存，它就被用来创建这个类的所有对象。所以在你更改了这个类的代码时，必须重新编译，否则程序还是执行你上一次编译后的Class对象.

public class SweetShop {
    public static void main(String[] args) {
        System.out.println("inside main");
        new Candy();
        System.out.println("after creating Candy");
        try {
            Class.forName("com.test.Gum");
        } catch (ClassNotFoundException e) {
            System.out.println("Couldn't create Gum");
            e.printStackTrace();
        }
        System.out.println("after creating Gum");
        new Cookie();
        System.out.println("after creating Cookie");
    }
}
class Candy {
    static {
        System.out.println("loading Candy");
    }
}
class Cookie {
    static {
        System.out.println("loading Cookie");
    }
}
public class Gum {
    static {
        System.out.println("loading Gum");
    }
}

Note:Class.forName("必须是 classpath中（包名.类名）")。也就是说在使用Class.forName()的时候必须使用类的全名，这个全名包括类所在的包名。否则会抛出ClassNotFoundException。

public class FancyToy extends Toy implements HasBatt, Waterproof,Shoots {
    FancyToy() {
        super(1);
    }
}
class Toy {
    Toy() {}
    Toy(int i) {}
}
interface HasBatt{}
interface Waterproof{}
interface Shoots{}

public class ToyTest {
    static void printInfo(Class cc) {
        System.out.println("Class name: "+cc.getName()+"is interface?["+ cc.isInterface() +"]");
        System.out.println("Simple name: "+cc.getSimpleName());
        System.out.println("Canonical name: "+cc.getCanonicalName());
    }

    public static void main(String[] args) {
        Class c = null;
        try {
            c = Class.forName("test0830.FancyToy");
        } catch (ClassNotFoundException e) {
            System.out.println("can't find FancyToy");
        }
        printInfo(c);
        System.out.println("----------------");
        for (Class face : c.getInterfaces()) {
            printInfo(face);
        }
        System.out.println("--------------");
        Class up = c.getSuperclass();
        Object obj = null;
        try {
            obj = up.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        printInfo(obj.getClass());
    }
}

运行后的结果：

Class name: test0830.FancyToyis interface?[false]
Simple name: FancyToy
Canonical name: test0830.FancyToy
----------------
Class name: test0830.HasBattis interface?[true]
Simple name: HasBatt
Canonical name: test0830.HasBatt
Class name: test0830.Waterproofis interface?[true]
Simple name: Waterproof
Canonical name: test0830.Waterproof
Class name: test0830.Shootsis interface?[true]
Simple name: Shoots
Canonical name: test0830.Shoots
--------------
Class name: test0830.Toyis interface?[false]
Simple name: Toy
Canonical name: test0830.Toy

三种获取Class对象的方法：

public class ClassTest {
    public static void main(String[] args) throws ClassNotFoundException {
        String str = new String("abc");
        System.out.println(Class.forName("java.lang.String"));
        System.out.println(str.getClass());
        System.out.println(java.lang.String.class);
    }
}

从Class对象中获取类名：getName:类的全名（包括包名），getSimpleName:类的名称（不包括包名）

public class ClassTest {
    public static void main(String[] args) throws ClassNotFoundException {
        String str = new String("abc");
        Class aClass = Class.forName("java.lang.String");
        System.out.println("--------获取类名--------");
        String className = aClass.getName();
        System.out.println("aClass.getName():" + className);
        String classSimpleName = aClass.getSimpleName();
        System.out.println("aClass.getSimpleName():" + classSimpleName);
    }
}

运行结果：

--------获取类名--------
aClass.getName():java.lang.String
aClass.getSimpleName():String

获取修饰符：

import java.lang.reflect.Modifier;

public class ClassTest {
    public static void main(String[] args) throws ClassNotFoundException {
        String str = new String("abc");
        Class aClass = Class.forName("java.lang.String");
        System.out.println("--------获取类名--------");
        String className = aClass.getName();
        System.out.println("aClass.getName():" + className);
        String classSimpleName = aClass.getSimpleName();
        System.out.println("aClass.getSimpleName():" + classSimpleName);
        System.out.println("--------获取修饰符-------");
        int modifiers = aClass.getModifiers();
        //是否是抽象类型
        System.out.println("Modifier.isAbstract(modifiers): " + Modifier.isAbstract(modifiers));
        //是否是final
        System.out.println("Modifier.isFinal(modifiers): " + Modifier.isFinal(modifiers));
        //是否是接口
        System.out.println("Modifier.isInterface(modifiers): " + Modifier.isInterface(modifiers));
        //是否是native
        System.out.println("Modifier.isNative(modifiers): " + Modifier.isNative(modifiers));
        //是否是私有类型
        System.out.println("Modifier.isPrivate(modifiers): " + Modifier.isPrivate(modifiers));
        //是否是保护类型
        System.out.println("Modifier.isProtected(modifiers): " + Modifier.isProtected(modifiers));
        //是否是公有类型
        System.out.println("Modifier.isPublic(modifiers): " + Modifier.isPublic(modifiers));
        //是否是静态类型
        System.out.println("Modifier.isStatic(modifiers): " + Modifier.isStatic(modifiers));
        //是否是精确浮点类型
        System.out.println("Modifier.isStrict(modifiers): " + Modifier.isStrict(modifiers));
        //是否加有同步锁
        System.out.println("Modifier.isSynchronized(modifiers): " + Modifier.isSynchronized(modifiers));
        //标记为transient的变量，在对象存储时，这些变量状态不会被持久化。当对象序列化的保存在存储器上时，不希望有些字段数据被保存，为了保证安全性，可以把这些字段声明为transient
        System.out.println("Modifier.isTransient(modifiers): " + Modifier.isTransient(modifiers));
        //在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
        System.out.println("Modifier.isVolatile(modifiers): " + Modifier.isVolatile(modifiers));
    }
}

执行结果：

--------获取类名--------
aClass.getName():java.lang.String
aClass.getSimpleName():String
--------获取修饰符-------
Modifier.isAbstract(modifiers): false
Modifier.isFinal(modifiers): true
Modifier.isInterface(modifiers): false
Modifier.isNative(modifiers): false
Modifier.isPrivate(modifiers): false
Modifier.isProtected(modifiers): false
Modifier.isPublic(modifiers): true
Modifier.isStatic(modifiers): false
Modifier.isStrict(modifiers): false
Modifier.isSynchronized(modifiers): false
Modifier.isTransient(modifiers): false
Modifier.isVolatile(modifiers): false

Class的其他方法：

public class ClassTest {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Class aClass = Class.forName("java.util.HashMap");
        System.out.println("--------父类-------");
        System.out.println("getSuperclass(): " + aClass.getSuperclass());
        System.out.println("--------包名-------");
        System.out.println("getPackage(): " + aClass.getPackage());
        System.out.println("------实现的接口----");
        System.out.println("getInterfaces()" + aClass.getInterfaces());
        System.out.println("-------构造器------");
        System.out.println("getConstructors(): " + aClass.getConstructors());
        System.out.println("--------方法-------");
        System.out.println("getMethods(): " + aClass.getMethods());
        System.out.println("--------变量-------");
        System.out.println("getFields(): " + aClass.getFields());
        System.out.println("--------注解-------");
        System.out.println("getAnnotations(): " + aClass.getAnnotations());
    }
}

执行结果：

--------父类-------
getSuperclass(): class java.util.AbstractMap
--------包名-------
getPackage(): package java.util, Java Platform API Specification, version 1.8
------实现的接口----
getInterfaces()[Ljava.lang.Class;@7f31245a
-------构造器------
getConstructors(): [Ljava.lang.reflect.Constructor;@6d6f6e28
--------方法-------
getMethods(): [Ljava.lang.reflect.Method;@12a3a380
--------变量-------
getFields(): [Ljava.lang.reflect.Field;@29453f44
--------注解-------
getAnnotations(): [Ljava.lang.annotation.Annotation;@6e0be858

java提供了一种叫做类字面常量的方法来生成Class对象的引用。 类名.class。这样做不仅更简单，而且更安全。因为它在编译时就会受到检查（因此不需要置于try{}catch{}语句块中）并且根除了对 .forName()方法的调用，所以更高效。

类字面常量不仅可以应用于普通类，还可以应用到接口、数组以及基本数据类型。另外对于基本数据类型的包装类，还有一个标准字段TYPE，TYPE是一个引用，指向对应的基本数据类型的Class对象。

boolean.class->Bolean.TYPE

char.class->Character.TYPE

byte.class->Byte.TYPE

short.class->Short.TYPE

int.class->Integer.TYPE

long.class->Long.TYPE

float.class->Float.TYPE

double.class->Double.TYPE

void.class->Void.TYPE

建议使用“.class”的形式，以保持与普通类的一致性。

注意：当使用“.class”来创建对Class对象的引用时，不会自动的初始化该Class对象。为了使用类而做的准备工作实际包含3个步骤：

1、加载。这是由类加载器执行的。该步骤将查找字节码（通常在classpath所指定的路径中查找，但并非是必需的），并从这些字节码中创建一个Class对象。

2、链接。在链接阶段将验证类中的字节码，为静态域分配存储空间，并且如果必须的话，将解析这个类创建的对其他类的所有引用。

3、初始化。如果该类具有超类，则对其初始化，执行静态初始化器和静态初始化块。

初始化被延迟到了静态方法（构造器是隐式静态方法）或者非常数静态域进行首次引用才执行。

public class ClassInitialization {
    public static Random random = new Random(47);

    public static void main(String[] args) throws ClassNotFoundException {
        Class initable = Initable.class;
        System.out.println("after creating Initable ref");
        System.out.println(Initable.staticFinal);
        System.out.println(Initable.staticFinal2);
        System.out.println(Initable2.staticNonFinal);
        Class initable3 = Class.forName("test97.Initable3");
        System.out.println("after creating Initable3 ref");
        System.out.println(Initable3.staticNonsFinal);

    }
}
class Initable{
    static final int staticFinal = 47;
    static final int staticFinal2 = ClassInitialization.random.nextInt(1000);
    static {
        System.out.println("hello Initable");
    }
}

class Initable2{
    static final int staticNonFinal = 147;
    static {
        System.out.println("hello Initable2");
    }
}

class Initable3{
    static final int staticNonsFinal = 74;
    static {
        System.out.println("hello Initable3");
    }
}

执行结果：

after creating Initable ref
47
hello Initable
258
147
hello Initable3
after creating Initable3 ref
74

如上的执行结果可以看出，使用.class来获取Class类的引用不会引起类的初始化。但是使用Class.forName()会引起类的初始化。

Class类的方法的使用：

package test97;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

/**
 * Created by Ernest on 2016/9/21.
 */
@SuppressWarnings(value = "unchecked")
@Deprecated
public class ClassTest {
    public ClassTest() {}
    public ClassTest(String name) {
        System.out.println("执行有参数的构造器："+name);
    }
    public void info() {
        System.out.println("执行无参info（）方法");
    }
    public void info(String str) {
        System.out.println("执行有参info（）方法： "+str);
    }
    //定义一个测试用的内部类
    class inner{

    }

    public static void main(String[] args) throws Exception {
        Class<ClassTest> clazz = ClassTest.class;
        //获取该class对象所对应类的全部构造器
        Constructor[] cons = clazz.getDeclaredConstructors();
        System.out.println("classTest的全部构造器如下：");
        for (Constructor con : cons) {
            System.out.println(con);
        }
        System.out.println("------------------");
        //获取该class对象所对应类的全部public构造器
        Constructor[] consPublic = clazz.getConstructors();
        System.out.println("classTest的全部public构造器如下： ");
        for (Constructor con : consPublic) {
            System.out.println(con);
        }
        System.out.println("-------------------");
        //获取class对象所对应类的全部public方法
        Method[] methods = clazz.getMethods();
        System.out.println("classTest的全部public方法如下： ");
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("--------------------");
        //获取class对象所对应类的指定方法
        Method mthd = clazz.getMethod("info", String.class);
        System.out.println(mthd);
        //获取该class对象所对应类的全部注解
        Annotation[] annos = clazz.getAnnotations();
        System.out.println("classTest的全部注解如下： ");
        for (Annotation anno : annos) {
            System.out.println(anno);
        }
        System.out.println("---------------");
        //获取该class对象所对应类的指定注解
        Annotation anno = clazz.getAnnotation(SuppressWarnings.class);
        System.out.println(anno);
        //获取该class对象所对应类的全部内部类
        Class<?>[] inners = clazz.getDeclaredClasses();
        System.out.println("classTest的全部内部类如下： ");
        for (Class<?> inner : inners) {
            System.out.println(inner);
        }
        System.out.println("----------------");
        //是用Class.forName方法加载ClassTest的Inner内部类
        Class inClass = Class.forName("test97.ClassTest$inner");
        System.out.println(inClass);
        System.out.println("inClass对应类的外部类为： "+inClass.getDeclaringClass());
        System.out.println("ClassTest的包： " + clazz.getPackage());
        System.out.println("ClassTest的父类： " + clazz.getSuperclass());
    }

}