第十四章类型信息

时间：2019-09-08 20:34:41 阅读：114 评论：0 收藏：0 [点我收藏+]

标签：利用反射 protect end 构造方法 object 变量 str 类型转换类型检查

前言

在开始介绍类型信息之前一定要区分一些概念：

1、静态类型语言与动态类型语言

静态类型语言：在编译期进行类型检查的语言（例如，Java）。（例如 int i = 3;）

动态类型语言：在运行期进行类型检查的语言（例如，JavaScript）。最明显的特征为变量没有类型值有类型（如，var=3;）

2、类型检查与类型转换（在Java中的区别）

类型检查：发生在编译期，检查方法是不是接收到了合适类型的参数，赋值是不是有合适类型的右值。

类型转换正确性检查：发生在运行期，检查一个类型变换到另外一个类型是不是正确合法的。举个栗子：

class A {}
class B {}
public class Test {
    
    public static void main(String[] args) {
    
        Object o = new A();
        B b = (B)o;
    }

}

像这种明显偷梁换柱的不安全转换，但是，编译器却发现不了。因为编译器不知道对象o的实际类型，只知道o的编译时静态类型Object，只有当运行期A.class文件载入虚拟机，虚拟机进行类型转换正确性检查才会知道o的实际类型是A，将A赋值给B类型不正确，抛出运行时异常。

3、清楚Java的语言性质

Java是静态类型的语言，因为其在编译期接受静态的类型检查。Java是动态类型安全（动态类型安全这样断句）的语言，因为其在运行期进行类型转换正确性检查。

4、RTTI与反射的区别

RTTI：运行时类型识别，可以看出它只是用来查询Class对象的一些简单信息。

反射：功能强大，可以绕过编译器调用方法。

最本质的区别是RTTI在编译时打开和检查class文件，反射是在运行时打开和检查class文件。这和虚拟机加载class文件没有冲突。

一、代表类型信息的Class对象

简述：每一个类经过编译都会生成一个ClassName.class文件，这个.Class文件就是表示类信息的二进制字节码文件。运行时，虚拟机的类加载系统会加载这个class文件，并生成Class对象，将class文件中的常量池放入方法区的运行时常量池，Class对象就代表着类型信息，并提供访问运行时常量池的途径。

1、示例一：类的加载行为

class Candy {
    static int i = 11;
    static{
        System.out.println("Loading Candy!");
    }
}

class Cookie {
    
    static {
        System.out.println("Loading Cookie!");
    }
}

class Gum {
    static final int i = 15;
    static {
        System.out.println("Loading Gum!");
    }
}
public class Demo1 {

    public static void main(String[] args) {
        
        new Cookie();
        System.out.println("Candy.i = " + Candy.i);
        System.out.println("Cookie.i = " + Gum.i);
    }

}

View Code

输出结果：

Loading Cookie!
Loading Candy!
Candy.i = 11
Cookie.i = 15

结果分析：只有两种行为可以引起类的加载，一种创建此类及其子类的对象，另一种是引用此类的静态成员。有一种情况特殊，编译期常量不会引起类的加载行为（这样说不准确，只不过看起来像），例如 static final int i = 3；。类加载过程分为：加载，验证、准备、初始化。编译期常量在类加载过程的准备环节就已经有值可用，其他类变量要到类加载的初始化环节才会被赋予值，所以static{}不会执行。

2、示例二：Class类的基本接口

interface Pet {}

interface Color {}

class Dog implements Pet, Color {}

class Mutt extends Dog {}

public class Demo2 {
    
    static void printInfo(Class<?> c) {
        System.out.println("Class name: " + c.getName() +
                " is interface? [" + c.isInterface() + "]");
        System.out.println("Canonical name: " + c.getCanonicalName());
        System.out.println("Simple name: " + c.getSimpleName());
        System.out.println("------------------------------------------");
    }
    public static void main(String[] args) {
        Class<?> c = null;
        try {
             c = Class.forName("rtti.Mutt");
        }catch(ClassNotFoundException e) {
            e.printStackTrace();
            System.out.println("Can‘t find Mutt");
            System.exit(1);//非零状态码表示异常终止
        }
        
        printInfo(c);
        Class<?> up = c.getSuperclass();
        Object o = null;
        try {
             o = up.newInstance();
        }catch(InstantiationException|IllegalAccessException e) {
            
        }
        printInfo(o.getClass());
        for(Class<?> face : up.getInterfaces()) {
            printInfo(face);
        }
    }

}

View Code

输出结果：

Class name: rtti.Mutt is interface? [false]
Canonical name: rtti.Mutt
Simple name: Mutt
------------------------------------------
Class name: rtti.Dog is interface? [false]
Canonical name: rtti.Dog
Simple name: Dog
------------------------------------------
Class name: rtti.Pet is interface? [true]
Canonical name: rtti.Pet
Simple name: Pet
------------------------------------------
Class name: rtti.Color is interface? [true]
Canonical name: rtti.Color
Simple name: Color
------------------------------------------

结果分析：

Class.forName(String ClassName): 使用类的全限定类名来获得该类Class对象的引用，若该类尚未加载，则加载该类。

getClass(): 如果已经拥有该类对象，可使用继承自Object类的getClass()方法获得该类Class对象。

getName(): 返回此Class对象所表示类的名称。

getCanonicalName(): 返回此Class对象所表示类的全限定类名。

getSimple(): 返回简称。

getInterfaces(): 返回Class对象数组，代表此类实现了的接口。

getSuperclass(): 返回class对象数组，代表此类的基类。

newInstance(): 创建此类的实例，此类必须有默认构造方法，此方法抛出异常。

基本上所有返回class对象的方法，其返回值都是Class<?>，因为编译器是不知道这类方法返回的Class对象的具体类型的。

3、示例三：类字面常量

class B {
    static {
        System.out.println("Initializing B");
    }
}
public class Demo3 {

    class A {
        {
            System.out.println("Initializing A");
        }
    }
    
    public static void main(String[] args) {
        
        Class<A> c1 = A.class;
        System.out.println(c1.getName());
        
        Class<?> c2 = null;
        try {
            c2 = Class.forName("rtti.B");
        }catch(ClassNotFoundException e) {
            e.printStackTrace();
            System.exit(1);
        }
        System.out.println(c2.getSimpleName());
    }

}

View Code

输出结果：

rtti.Demo3$A
Initializing B
B

结果分析：

可以明显的看出“.class”形式，比forName()更加高效。前者编译时，右值已知可以接受编译期检查；后者编译时，右值未知，还抛出异常。不过，".class"创建Class对象时不会进行类的初始化（前文说过，类加载过程中的一个阶段），forName()会进行类的初始化。

二、RTTI运行时类型识别

运行时类型识别的三种表现形式：（看一下就行了，个人觉得无关紧要）

（1）RTTI确保类型转换的正确性

（2）代表对象类型的Class对象

（3）instanceof关键字

1、示例一：instanceof与“==”

class Base {}
class Derived extends Base {}
public class Demo4 {
    
    
    public static void main(String[] args) {
        Derived d = new Derived();
        System.out.println("d instanceof Base " + (d instanceof Base));
        System.out.println("d instanceof Derived " + (d instanceof Derived));
        System.out.println("Base.class.isInstance(d) " + Base.class.isInstance(d));
        System.out.println("Derived.class.isInstance(d) " + Derived.class.isInstance(d));
        System.out.println("d.getClass() == Base.class " + (d.getClass() == (Class<?>)Base.class));
        System.out.println("d.getClass() == Derived.class " + (d.getClass() == (Class<?>)Derived.class));
    }

}

View Code

输出结果：

d instanceof Base true
d instanceof Derived true
Base.class.isInstance(d) true
Derived.class.isInstance(d) true
d.getClass() == Base.class false
d.getClass() == Derived.class true

结果分析：instanceof与isInsatance()保持了类型的概念，x为子类示例结果也为true，即只要是同意类型即可。

三、功能强大的反射

1、示例一：反射基本接口的用法

import java.lang.reflect.*;
import java.util.Scanner;
import java.util.regex.*;;
public class ShowMembers {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.next();
        Pattern p = Pattern.compile("\\w+\\.");
        try {
            Class<?> c = Class.forName(s);
            System.out.println("Field:---------------------------------");
            for(Field f : c.getDeclaredFields()) {
                System.out.println(p.matcher(f.toString()).replaceAll(""));
            }
            System.out.println("Constructors:----------------------------");
            for(Constructor<?> con : c.getDeclaredConstructors()) {
                System.out.println(p.matcher(con.toString()).replaceAll(""));
            }
            System.out.println("Methods:------------------------------------------");
            for(Method m : c.getDeclaredMethods()) {
                System.out.println(p.matcher(m.toString()).replaceAll(""));
            }
        }catch(Exception e) {
            e.printStackTrace();
        }finally {
            scanner.close();
        }
        
    }
}

View Code

输出结果：

java.io.FilterOutputStream
Field:---------------------------------
protected OutputStream out
Constructors:----------------------------
public FilterOutputStream(OutputStream)
Methods:------------------------------------------
public void write(byte[],int,int) throws IOException
public void write(byte[]) throws IOException
public void write(int) throws IOException
public void close() throws IOException
public void flush() throws IOException

第一行是输入

结果分析：

这是一个可以读取指定类中的字段、构造器以及方法的小程序。

getDeclaredFields()：获取类中已经声明的字段，返回Field数组。

getDeclaredConstructors()：获取类中已经声明的构造方法，返回Constructor<?>数组。

c.getDeclaredMethods()：获取类中已经声明的方法，返回Method的数组。

Field类代表域、Constructor类代表构造方法、Method类代表方法。

这些基本的方法都属于Class类，是Class类对反射提供的支持。

2、使用反射越过编译器检查

import java.lang.reflect.*;
import java.util.*;
public class Reflect {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<Integer> l = new ArrayList<Integer>();
        l.add(1);
        Class<?> c = l.getClass();
        try {
            Method m = c.getMethod("add", Object.class);
            m.invoke(l, "test");
            System.out.println(l);
        }catch(Exception e) {
            e.printStackTrace();
        }
        
    }

}

View Code

输出结果：

[1, test]

结果分析：可以看到利用反射，能够在编译器毫无防备的情况下狸猫换太子。

getMethod(): 可以获得Class对象的指定方法所代表的Method对象。

Method.invoke()：可以调用该方法表示的对象。

第十四章类型信息

标签：利用反射 protect end 构造方法 object 变量 str 类型转换类型检查

原文地址：https://www.cnblogs.com/mgblogs/p/11478262.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行

第十四章 类型信息

前言

一、代表类型信息的Class对象

二、RTTI运行时类型识别

三、功能强大的反射

第十四章类型信息