【第21期】观点:人工智能到底用 GPU?还是用 FPGA?

类型信息:反射-Class

原创 2016年08月30日 14:38:33

在说反射前提一个概念: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());
    }

}









版权声明:本文为博主原创文章,未经博主允许不得转载。 举报

相关文章推荐

Java中Class类与反射机制的用法总结

Java中Class类与反射机制的用法总结 Java的Class类是java反射机制的基础,通过Class类我们可以获得关于一个类的相关信息,下面我们来了解一下有关java中Class类的相...

深入理解Java类型信息(Class对象)与反射机制

本篇主要是深入对Java中的Class对象进行分析,这对后续深入理解反射技术非常重要,这篇有点偏向内功类文章,主要内容如下: 深入理解Class对象 RRTI的概念以及Class对象作用 Class...

JAVA之Class类与反射总结

JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反...

JAVA反射(一)获取Class对象的三种方式及其区别

JAVA有三种方式可以获得Class对象 1、通过类名.class方式获得,Class  cType = ClassName.class; public class Client { public s...

深入理解 Java 反射:Class (反射的入口)

什么是 Reflection 反射,为什么要用它Java 强类型语言,但是我们在运行时有了解、修改信息的需求,包括类信息、成员信息以及数组信息。Java 中 Reflection 和 Introspe...

【类反射】类反射原理和获取Class对象的三种方式

什么是类反射?☆什么是反射Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法...

Class类---反射学习笔记(一)

Class类:在面向对象的世界里,万事万物皆对象。 注意:Java中,有两种不是面向对象的: (1)基本数据类型 (2)静态的成员 但是基本类型都有其对应的包装类,包装类是面向对象的。 类是...

java 反射之获取class对象的三种方式

获取Class文件对象有3种方法:     1.Object类的getClass()方法     2.数据类型中的静态变量 类名.Class     3.Class类中的静态方法         pu...

JAVA反射(一):获取Class对象的三种方式及其区别

CLASS 在Java中,每个class都有一个相应的Class对象。也就是说,当我们编写一个类,编译完成后,在生成的.class文件中,就会产生一个Class对象,用于表示这个类的类型信息 ...

java中的integer的反射计算机制

今天上班看到一个2+2=5的程序实例: package play; import java.lang.reflect.Field; public class testInteger { pub...
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)