《Java编程思想》笔记第十四章类型信息

1.RTTI：在运行时识别一个对象类型

JAVA在运行时有时要识别对象和类的信息这个机制叫RTTI。Java提供了两种机制去做这件事。传统的RTTI 和反射。
传统的RTTI 假定编译时就已经知道了所有的类型。
反射允许在运行时发现和使用类型信息
传统的RTTI 在编译期通过Class文件识别类型信息，反射在运行期通过Class文件识别类型信息。

Java类型转换都发生在运行时期。

2.Class对象

Class对象是由Class这个类产生的，它包含了与某个类有关的信息。

每个类都有Class对象，即编译了一个新类就会产生一个该类的Class对象，并且保存在.class文件中。Class对象就是用来产生“常规”对象的。
Java使用Class对象来执行RTTI。
所有类都是第一次使用时动态加载到jvm中。动态加载就是需要时再加载不使用不加载。
只要创建了对一个类的静态成员的引用就会加载该类。new 的时候加载类说明类的构造器虽然没写static但也是静态方法。
一个类的Class对象载入内存后，他就会用来创建该类的对象。

2.1 获得Class对象

Class类的静态方法forName（）可以通过传入一个全限定类名(包含包名)返回一个该类的Class类对象引用，此时该类会被加载到内存。
```
Class.forName("thinking14class.Test")
```
运行时要获得一个类的信息（类型信息）可以通过一个该类的Class对象获得，使用Class.forName()就可以做到，而不必持有该类型的对象通过该对象获得。
如果有了一个实例对象可以调用getClass()方法来获得Class对象。

2.2 Class类的一些方法

getName() 获得全限定类名， getCanonicalName()也是获得全限定类名。对于普通类来说,二者没什么区别,只是对于特殊的类型上有点表示差异。
getSimpleName()只获得类名，没有包名。
isInterface()判断是否为接口。
getInterfaces() 返回一个Class对象数组，数组元素是该类实现的接口，元素顺序和实现顺序一致。
getSuperclass() 返回直接基类（不是接口）的Class对象，可以用来发现对象完整的类继续结构。
newInstance()创建该类实例对象并返回，但该类必须要有默认构造器，这个方法相当于一个虚拟构造器。

3.类字面常量

类名.class 就是字面常量，代表的就是该类的Class对象引用。常量需要赋值给变量

简单，安全。编译期接受检查，不需要像forName一样至于try/catch块中。
加载后不会进行初始化，初始化被延迟到静态方法静态域首次使用时。
类字面常量可用于类接口数组基本数据类型

基本数据类型也有类字面常量如int.class, 对应的包装器的 Integer.TYPE。

        System.out.println(int.class); //int 
        System.out.println(Integer.TYPE); //int
        System.out.println(Integer.class); //class java.lang.Integer

Integer继承自Number 但 Integer Class 对象不是 Number Class对象的子对象，也就是说Class<Number> cn = int.class; 是错误的。

4 泛化的class引用

Class引用指向Class对象，该Class对象是Class类的实例，该对象可以制造一个类的实例，并包含一个类的各种信息。
Class引用表示的就是Class对象的确切类型。
Class<?> 优于Class 因为Class在编译期不会产生警告，而Class<?>当指向一个非具体的类引用时会产生警告。

a.newInstance()如果Class引用a不是泛型引用，在编译期就不知道它会返回什么类型那么只能返回Object。

        Class a = A.class;
        Object t = a.newInstance();
        //A t =  (A) a.newInstance();//无法确定类型需要强制转换
        System.out.println(t.getClass().getName());//thinking14class.A

a.newInstance() a 是泛型引用并且能确定类型则会返回确切的类型。

        Class <A> a= A.class; 
        Class <? extends C> c= C.class; //上界
        Class <? super A> d= A.class; 
        A ta =  a.newInstance(); // 可以确定
        A tc =  c.newInstance(); // 上界至少它是一个C可以确定

a.newInstance() a 是泛型引用但不能确定类型则只能返回Object。

        Class <A> a= A.class; 
        Class <? extends C> c= C.class; //上界
        Class <? super A> d= A.class; //下界
        //A ta =  a.newInstance(); // 通配符无法确定
        
        A tc =  c.newInstance(); // 上界至少它是一个C可以确定
        
        //A td =  d.newInstance();//  下界无法确定

利用Class类的cast()方法来转换类型

        A a  = new C();
        Class<C> cType = C.class;
        C c = cType.cast(a);
          c = (C) a; //与上一步一样的效果

6.类型转换前先做检查

传统的类型转换由RTTI确保正确性。
instanceof关键字（二元操作符），返回一个Boolean值，告诉我们对象是不是某个类或该类派生类的实例，他判断的是类型。
```
if (a instanceof A) //对象a是不是属于A类型，A可能是a父类的父类,如果是这样也返回true
```

instanceof 不能比较Class对象，对于Class对象使用isAssignableFrom()判断

if (as.isAssignableFrom(cs))// Class对象cs所在类是不是属于Class对象as所在类或者派生类

动态的instanceof ：Class对象的isInstance(Object o)方法判断该Class对象是不是o类的（如果o是class对象所在类则返回true，否则返回false哪怕o是所在类的父类）。
```
if (cs.isInstance(c)) //如果c是class对象所在类则返回true，否则返回false,哪怕c是所在类的父类
```

7.反射

反射机制：用来检查可用方法，并返回方法名。
Class类和java.lang.reflect类库对反射提供了支持点击查看

reflect包中有Field类，Method类，Constructor类,这些类对象由jvm在运行时创建，用来表示未知类里的字段，方法，构造器。
使用Constructor创建新对象，Filed的get() set()方法修改Filed对象关联的字段，Class类的invoke()调用Method关联的方法。
调用Class类的getFileds()返回表示字段的Filed数组，getMethods()返回表示方法的Method数组，getConstructor()返回表示构造器的Constructor数组。
通过以上方法一个匿名对象的类信息便可在运行时被确定下来，再在运行时通过.class文件获得相关信息构造该类。
没有任何方法可以阻止反射调用那些非公共访问权限的方法，哪怕是private方法或者private域。

package thinking14class;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectDemo {

    public static void main(String[] args) {
        
        Class<Student> class1 = Student.class;
        Field[] field = class1.getFields(); //所有公共字段包括继承的，不包含 private 默认 权限的字段
        Field[] fields = class1.getDeclaredFields();//所有字段，但不包括继承的方法
        
        for (Field field2 : field) {
            System.out.println(field2.getName());
        }
        
        System.out.println("-------分割线1-------");
        
        for (Field field2 : fields) {
            System.out.println(field2.getName());
        }
        System.out.println("-------分割线2-------");
        Method[] method  = class1.getMethods(); //所有公共方法包括继承下来的
        
        Method[] methods = class1.getDeclaredMethods();//包括公共，保护，默认（包）访问和私有方法，但不包括继承的方法
        
        for (Method method2 : method) {
            
            System.out.println(method2.getName());
        }
        
        System.out.println("-------分割线3-------");
        
        for (Method method2 : methods) {
            System.out.println(method2.getName());
        }
        
    }

}

class Student extends People{
    public int id;
    public String name;
    private String sex;
    
    public String getSex() {
        return sex;
    }
    private void setSex(String sex) {
        this.sex = sex;
    }
        
}

class People{
    
    public String birthday;
    
}

ReflectDemo

id
name
birthday
-------分割线1-------
id
name
sex
-------分割线2-------
getSex
wait
wait
wait
equals
toString
hashCode
getClass
notify
notifyAll
-------分割线3-------
getSex
setSex

输出结果

8.动态代理

设计模式一种

9.空对象

设计模式一种

知识点：

如果某个对象出现在字符串表达式（涉及 + 和字符串对象的表达式）中，对象的toStrin()方法会自动调用，以生成对象的string。
接收常量要用变量，接收方法返回值也需要变量，但有时只需要方法调用的副作用，不用接收方法返回的结果。
若一个值是 static final 那么他就是编译期常量，该值不用初始化就可以通过类访问，访问时也不会引起初始化，如果是 static final 域则会初始化。
final域绝对安全，虽然会接受任何修改的尝试，但实际上不会发生任何修改。

posted @ 2018-06-19 19:49 Mibloom 阅读(670) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Mibloom

《Java编程思想》笔记 第十四章 类型信息