Java 编程思想 Chapter_14 类型信息

Posted 2020-10-08

本章内容绕不开一个名词:RTTI(Run-time Type Identification) 运行时期的类型识别

知乎上有人推断作者是从C++中引入这个概念的,反正也无所谓,理解并能串联本章知识才是最重要的

本章的内容其实都是为类型信息服务的，主要内容有

一.Class对象

问题:

1.Class对象的创建过程是怎么样的

2.Class对象有哪几种创建方式，之间有什么差异

3.使用泛型

在了解类型信息之前，需要了解class对象

创建class对象，需要先查找这个这个类的.class文件, 查找到的class文件会以字节码的形式加载到内存, 这时便可以通过内存中的Class对象 创建这个类的所有对象

本章中创建对象的方式有三种

第一种: 通过new 构造器 的方式

第二种: Class cls = Class.forName(“全限定名”); cls.newInstance();

第三种 Class cls = 类:.class; cls.newInstance();

说3种比较牵强，第二种和第三种通过虚拟构造器newInstance()的方式创建了对象, newInstance()有2点需要注意: ①接口不能newInstance;②类必须有的空构造器

这三种方式有什么差别呢，在这里会牵涉到其他的知识点

1.调用一个类的静态方法，有没有创建了一个对象

答案是没有的，因为没有涉及到以上3种创建对象的方式，只是将.class文件载入到了内存，对类进行了初始化, 并没有去创建对象

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        A.print();
    }
}
class A{
    static{
        System.out.println("static 静态块");
    }
    
    public A(){
        System.out.println("构造方法");
    }
    
    public static void print(){
        System.out.println("打印class A");
    }
}

打印的结果如下:

static 静态块
打印class A

2. Class.forName(“全限定名”) 和 .class有没有差别

有差别, Class.forName会主动去在加载静态方法块, 而.class不会, .class对静态方法或非常数静态域首次引用后才进行初始化

public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            Class.forName("chapter_14.A");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

打印: static 静态块

public static void main(String[] args) {
        // TODO Auto-generated method stub
        Class cls = A.class;
}

没打印

提一点题外话, 为什么我们平时看到的被访问的静态常量通常是这样的

public static final int CONSTANT = 5;

而不是

public static int CONSTANT = 5;

原因在于static final 是编译期常量, 类.CONSTANT 不需要对类进行初始化就可以被读取

 

引入泛型的意义仅仅是为了提供编译期检查，第15章会着重讲讲泛型，在这里提供了几个概念

和平凡.class不一样, 泛型newInstance()返回该对象的确切类型

class A{}

class B extends A{}

Class<A> clsA = A.class;
A objA = clsA.newInstance();

那么超类呢?

Class<? super B> clsA = B.class.getSuperclass();
Object objA = clsA.newInstance();

超类得到不是精确类型，而只是Object

那继承类呢?

Class<? extends A> clsB = B.class;
A objA = clsB.newInstance();

此时得到的是父类的类型，在接下来的学习中，我们会经常用这种方式来创建对象，说白了这属于多态，属于类型信息

二.类型转换前先做检查

问题:

1.类型转换前先做的检查的意义和检查的方式

通过显式的向下转型，避免出现ClassCastException

常见的检查方式有3种，instanceof, isInstance, isAssignableFrom

举个例子:

class A implements Iface{}

class B extends A{}

interface Iface{}

第一种 instanceof

//类检查 本身类实例化对象的类型
Class<? super B> clsA = B.class.getSuperclass();
Object objA = clsA.newInstance();
System.out.println(objA instanceof A);//true

//类检查 子类实例化对象的类型
Class clsB = B.class;
Object objB = clsB.newInstance();
System.out.println(objB instanceof A);//true

//接口检查 实现类实例化对象的类型
System.out.println(objA instanceof Iface);//true
System.out.println(objB instanceof Iface);//true

第二种:isInstance

Class<? super B> clsA = B.class.getSuperclass();
Object objA = clsA.newInstance();
            
Class clsB = B.class;
Object objB = clsB.newInstance();
//类的Class对象检查 类本身的实例化对象
System.out.println(clsA.isInstance(objA));//true
System.out.println(clsB.isInstance(objB));//true
//类的Class对象检查 子类的实例化对象
System.out.println(clsA.isInstance(objB));//true
            
            
//接口的Class对象检查 实现类的实例化对象
Class clsIface = Iface.class;
System.out.println(clsIface.isInstance(objA));//true
System.out.println(clsIface.isInstance(objB));//true

第三种 isAssignableFrom

Class<? super B> clsA = B.class.getSuperclass();
Object objA = clsA.newInstance();
            
Class clsB = B.class;
Object objB = clsB.newInstance();
//类的Class对象检查 类本身的Class对象
System.out.println(clsA.isAssignableFrom(clsA));//true
            
//类的Class对象检查 子类的Class对象
System.out.println(clsA.isAssignableFrom(clsB));//true
            
//接口的Class对象检查 实现类的Class对象
Class clsIface = Iface.class;
System.out.println(clsIface.isAssignableFrom(clsA));//true
System.out.println(clsIface.isAssignableFrom(clsB));//true

对以上3种方式进行总结，便是以下这张图了

类型检查在另一方面也说明了 类与类的关系，类与接口的关系。

三.注册工厂

问题:

1.注册工厂有什么用

注册工厂是将工厂方法设计模式和添加融合在一起，在本章中，还是和类型信息有关系，在基类中添加实现类的对象，不过都是根据工厂设计模式去实现的，这样做的好处在于“避免新添加的数据对结构产生破坏”。本章中的例子很形象，也非常好，如果我有好的例子，也一定会放上链接

四.空对象

问题:

1.什么是空对象

2.使用空对象的意义

通常，空对象是一个单例，它具有无法修改的特性

假设一个类的 某个变量默认情况下是空对象，那么想要改变这个变量的属性，就需要重新创建一个对象来代替这个空对象，感觉我说的是废话，不过这是空对象的本质了，结合下以下代码，好好考虑下

interface Null{}

class Person{
    
    private final String first;
    private final String last;
    private final String address;
    public Person(String first, String last, String address) {
        super();
        this.first = first;
        this.last = last;
        this.address = address;
    }
    @Override
    public String toString() {
        return "Person [first=" + first + ", last=" + last + ", address=" + address + "]";
    }
    
    static class NullPerson extends Person implements Null{

        private NullPerson(){
            super("None", "None", "None");
        }
        
        @Override
        public String toString() {
            return "NullPerson";
        }
    
    }
    
    public static final Person NULL = new NullPerson();
}

这段代码抄自Java编程思想的空对象一节，另外有个知识点：不是每个类都会有默认的空构造器，像上面的Person类其实是没有空构造器的，问题在于构造器的参数用final修饰，可以去探究下。

五.反射

1.反射机制是怎么样的

2.如何通过动态代理的方式使用反射机制

反射是程序在运行时打开和检查.class文件，因此反射是动态的,JDK中使用Class类和java.lang.reflect类库对反射的概念进行了支持

使用反射是由于 某些类的属性，方法对外 没有包访问权限，而我们不得不进行访问，才能完成一些事情

可想而知，包访问权限对反射而言起不了作用，这里包括了private修饰, 私有内部类和匿名内部方法

应用到反射的例子有android中组件通信的EventBus，可以下载下来看源码

反射也可以用于动态代理（多说一句，动态代理本质还是类型信息）主要代码抄自书上

public class Test {

    public static void main(String[] args) {
        A objA = new A();
        
        Iface iface = (Iface) Proxy.newProxyInstance(Iface.class.getClassLoader(), 
                new Class[]{Iface.class}, new DynamicProxyHandler(objA));
        doSomething(iface);
    }
    
    public static void doSomething(Iface iface){
        iface.doSomething();
    }
}

class A implements Iface{
    @Override
    public void doSomething() {
        System.out.println("A doSomething");
    }
}

interface Iface{
    
    public void doSomething();
    
}

//所有的调用都会重定向到这个单一的处理器上
class DynamicProxyHandler implements InvocationHandler{

    private Object proxied;
    
    public DynamicProxyHandler(Object proxy){
        proxied = proxy;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // TODO Auto-generated method stub
        return method.invoke(proxied, args);
    }
}

这里有3点需要注意的：1..重定向单一的处理器,调用的对象是什么； 2.创建的iface必须是接口对象，创建接口对象要传递的第二个参数是Class数组, 它包含了所有proxied的接口名称.class ; 3.动态代理与类型信息之间的关系

总结: 类型信息本质上还是关于 向上转型或者向下转型