RTTI与构造方法的理解

运行时类型识别(RTTI, Run-Time Type Identification)是Java中非常有用的机制，在Java运行时，RTTI维护类的相关信息。

多态(polymorphism)是基于RTTI实现的。RTTI的功能主要是由Class类实现的。

 
Class类

Class类是"类的类"(class of classes)。如果说类是对象的抽象和集合的话，那么Class类就是对类的抽象和集合。

每一个Class类的对象代表一个其他的类。比如下面的程序中，Class类的对象c1代表了Human类，c2代表了Woman类。
复制代码
public class Test{ public static void main(String[] args) { Human aPerson = new Human(); Class c1 = aPerson.getClass(); System.out.println(c1.getName()); Human anotherPerson = new Woman(); Class c2 = anotherPerson.getClass(); System.out.println(c2.getName());
}}class Human{
/** * accessor */ public int getHeight() { return this.height; } /** * mutator */ public void growHeight(int h) { this.height = this.height + h; }private int height; }class Woman extends Human{ /** * new method */ public Human giveBirth() { System.out.println("Give birth"); return (new Human()); }}
复制代码

当我们调用对象的getClass()方法时，就得到对应Class对象的引用。

在c2中，即使我们将Women对象的引用向上转换为Human对象的引用，对象所指向的Class类对象依然是Woman。

Java中每个对象都有相应的Class类对象，因此，我们随时能通过Class对象知道某个对象“真正”所属的类。无论我们对引用进行怎样的类型转换，对象本身所对应的Class对象都是同一个。当我们通过某个引用调用方法时，Java总能找到正确的Class类中所定义的方法，并执行该Class类中的代码。由于Class对象的存在，Java不会因为类型的向上转换而迷失。这就是多态的原理。

getClass: 我是谁?

 

除了getClass()方法外，我们还有其他方式调用Class类的对象。
复制代码
public class Test{ public static void main(String[] args) { Class c3 = Class.forName("Human"); System.out.println(c1.getName()); Class c4 = Woman.class System.out.println(c2.getName()); }}
复制代码

上面显示了两种方式:

    forName()方法接收一个字符串作为参数，该字符串是类的名字。这将返回相应的Class类对象。
    Woman.class方法是直接调用类的class成员。这将返回相应的Class类对象。

 
Class类的方法

Class对象记录了相应类的信息，比如类的名字，类所在的包等等。我们可以调用相应的方法，比如:

getName()         返回类的名字

getPackage()      返回类所在的包

 

可以利用Class对象的newInstance()方法来创建相应类的对象，比如:
Human newPerson = c1.newInstance();  

newInstance()调用默认的不含参数的构建方法。

 

我们可以获得类定义的成员:

getFields()       返回所有的public数据成员

getMethods()      返回所有的public方法

可以进一步使用Reflection分析类。这里不再深入。

 

Class类更多的方法可查询官方文档:

sl

 
Class类的加载

当Java创建某个类的对象，比如Human类对象时，Java会检查内存中是否有相应的Class对象。

如果内存中没有相应的Class对象，那么Java会在.class文件中寻找Human类的定义，并加载Human类的Class对象。

在Class对象加载成功后，其他Human对象的创建和相关操作都将参照该Class对象。


…………………………………………………………………………………………………………………………………………＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆

Java RTTI的思维导图：


[片]

RTTI（runtime type info）用于在运行时识别对象的类型信息。java虚拟机不能在运行时加载所有类型对象（动态加载），同时部分类型的信息是无法再编译器就获取的，需要在业务逻辑中依据类型信息进行相关逻辑的处理，这是就需要RTTIl了。

众所周知，java类在编写时会生成.class文件，那.class文件时如何使用的呢？在创建java类对应对象时，jvm虚拟机的classLoader会检测对象对应的Class对象是否已加载，如果没有加载则会依据相关途径查询对应.class文件（如 通过classPath在本地文件系统进行查找），在获取到.class文件之后会对文件进行有效验证，之后会依据Class对象进行详细类型对象的创建。使用Class.forName方法、应用类的static变量、使用构造方法创建对象时，都会对class进行加载。

使用Class的newInstance方法可以创建class对应对象，但前提是对应类有默认构造函数（无参构造函数）。

xxx.class被称为类字面常量，是对Class对象的引用，但使用".class"获取对Class对象的引用，并不会立即初始化Class对象，为初始化Class对象，需要经过三个步骤：

1）加载：由classloader查找class字节码文件，并创建Class对象。

2）链接：验证字节码文件，为静态分配存储空间，解析对其他对象的引用；

3）初始化：初始化父类，执行静态初始化器和静态是初始化快。

final static成员和static成员的在以上三个过程中就不一样，final static成员被称为“编译器常量”，在编译时已经被赋值，所以可以在类加载前就进行访问，而静态成员（非final）需要在类加载后、class对象初始化之后赋值。

 

java内存为堆（heap）、方法区域（method area）、java栈（java stack）、程序计数注册器（program counter register）、本地方法栈（native method stack）。对象的类型信息就存储在method area中，且不会有垃圾回收器进行垃圾回收。因此，如果设置的method area区域较少时，就回出现内存溢出问题（对象的error message是： java.lang.OutOfMemoryError: PermGen space），对应的JVM设置参数是：-xx:MaxPermSize=512m。



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

 总结在最后，不过没有开始的四条好理解，所以可以从四个方面来区分：１，new自动调用，每个类都有，２，它没有返回值也不需要void 3,名字与类名一样，首字母大写。４，this指向同一个类中，不同参数列表的另外一个构造器

（1）功能和作用的不同
   构造器是为了创建一个类的实例。这个过程也可以在创建一个对象的时候用到：Platypus p1 = new Platypus();
相反，方法的作用是为了执行java代码。

    （2）修饰符，返回值和命名的不同
    构造器和方法在下面三个方便的区别：修饰符，返回值，命名。和方法一样，构造器可以有任何访问的修饰： public, protected, private或者没有修饰（通常被package 和 friendly调用）. 不同于方法的是，构造器不能有以下非访问性质的修饰： abstract, final, native, static, 或者 synchronized。
    返回类型也是非常重要的。方法能返回任何类型的值或者无返回值（void），构造器没有返回值，也不需要void。
    （3）两者的命名。
     构造器使用和类相同的名字，而方法则不同。按照习惯，方法通常用小写字母开始，而构造器通常用大写字母开始。构造器通常是一个名词，因为它和类名相同；而方法通常更接近动词，因为它说明一个操作。
    （4）"this"的用法。
     构造器和方法使用关键字this有很大的区别。方法引用this指向正在执行方法的类的实例。静态方法不能使用this关键字，因为静态方法不属于类的实例，所以this也就没有什么东西去指向。构造器的this指向同一个类中，不同参数列表的另外一个构造器、例如：在我们上课做过的BirthDate类中：
public  class  BirthDate{
   private    int year;
   private    int month;
   private    int day;
   BirthDate(int   ye){
       year = ye;
   }
   BirthDate(){
      this(1987);
   }

   public static void main(String args[]) {

                   BirthDate b1 = new BirthDate(2009);

                   BirthDate b2 = new BirthDate();

   }


}
在上面的代码中，有2个不同参数列表的构造器。第一个构造器，给类的成员year赋值，第二个构造器，调用第一个构造器，给成员变量year一个初始值 1987.在构造器中，如果要使用关键字this,那么，必须放在第一行，如果不这样，将导致一个编译错误。
    (5)编译器自动加入代码
    编译器自动加入代码到构造器，当我们写一个没有构造器的类，编译的时候，编译器会自动加上一个不带参数的构造器.相信这一点大家是没有问题的啦。

    （6）继承
    构造器是不能被继承的。子类可以继承超类的任何方法。看看下面的代码：
public class Example {
            public void HelloWorld {
                        system.out.println("HelloWorld");
            }
            Example() {}
}
          public class SubClass extends Example {
}

         类 SubClass 自动继承了父类中的HelloWorld方法，但是，父类中的构造器 Example()却不能被继承

(1)带形式参数的构造器:
         构造器和其它方法一样，也可以有形式参数。构造器有了形式参数，我们就可以在初始化对象的时候提供实际参数。java为了让名字相同而形式参数不同的构造器同时存在，必须使用“方法重载”。

①区分重载方法

       在用户调用的时候区分它们的唯一方法是它们独一无二的参数列表(java中形式参数出现顺序的不同会被认为是两个方法)，除此之外，别无它法。

②涉及基本类型的重载

       实际参数的类型与形式参数的类型不符时会出现两种情况。第一种，实参类型“小于”

形参时，较小的类型会自动提升为较大类型，char类型会被提升为int类型;第二，实参“大于”形参，必须使用强制类型转换－(形参类型)实参类型。

③以返回值区分重载方法是行不通的

       int f();

       void f();

       java无法判断调用的是哪一个f()方法，因此，根据返回值来区分方法是行不通的。

(2)无参数构造器

      又称缺省构造器。它的作用是创建一个“基本对象”。如果类中没用写构造器，则编译器会自动创建一个缺省构造器。但是，如果已经定义一个构造器(无论有无参数)，编译器就不会帮你自动创建缺省构造器了。


总结：
主题       功能               修饰  
构造器：   建立一个类的实例      不能用bstract, final, native, static, or synchronized
方法 ：  java功能语句           能用。


主题       返回类型                  this
构造器 ：  没有返回值，没有void         指向同一个类中另外一个构造器，在第一行
方法  ：    有返回值，或者void           指向当前类的一个实例，不能用于静态方法

主题        继承                 编译器自动加入     
构造器 ：   构造器不能被继承     是（如果没有）
方法  ：    方法可以被继承        不支持

＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆＆
   我相信大多说人都对构造方法、方法不陌生，而且很了解，但我也相信有很多像我这样的没有一个很好很清晰很全面的认识，今天就把它整理如下，希望能给大家带来点方便与帮助，也希望大家多多讨论。
          构造方法和方法的区别：         

     构造方法要与类名相同，无返回类型，在类初始化的时候调用。
     方法最好与类名不同，对象调用，静态方法可用类名.方法（）.

     构造器和方法在下面三个方面区别：修饰符，返回值，命名。

       1。和方法一样，构造器可以有任何访问的修饰： public, protected, private或者没有修饰（通常被package 和 friendly调用）. 不同于方法的是，构造器不能有以下非访问性质的修饰： abstract, final, native, static, 或者 synchronized。
        2。返回类型也是非常重要的。方法能返回任何类型的值或者无返回值（void），构造器没有返回值，也不需要void。
        3。两者的命名。构造器使用和类相同的名字，而方法则不同。按照习惯，方法通常用小写字母开始，而构造器通常用大写字母开始。构造器通常是一个名词，因为它和类名相同；而方法通常更接近动词，因为它说明一个操作。

    构造方法和方法中this和supper的用法区别：
   
    "this"的用法
    构造器和方法使用关键字this有很大的区别。方法引用this指向正在执行方法的类的实例。静态方法不能使用this关键字，因为静态方法不属于类的实  例，所以this也就没有什么东西去指向。构造器的this指向同一个类中，不同参数列表的另外一个构造器，我们看看下面的代码：
package com.dr.gouzao;

public class Platypus {
    String name;

    Platypus(String input) {
        name = input;
    }

    Platypus() {
        this("John/Mary Doe");
    }

    public static void main(String args[]) {
        Platypus p1 = new Platypus("digger");
        Platypus p2 = new Platypus();
        System.out.println(p1.name + "----" + p2.name);
    }
}

在上面的代码中，有2个不同参数列表的构造器。第一个构造器，给类的成员name赋值，第二个构造器，调用第一个构造器，给成员变量name一个初始值 "John/Mary Doe".

在构造器中，如果要使用关键字this,那么，必须放在第一行，如果不这样，将导致一个编译错误。
在一个构造方法中只能调用一次其它的构造方法，并且调用构造方法的语句必须是第一条语句。
 

   "super"的用法

   构造器和方法，都用关键字super指向超类，但是用的方法不一样。方法用这个关键字去执行被重载的超类中的方法。看下面的例子：
package com.dr.gouzao;

class Mammal {
    void getBirthInfo() {
        System.out.println("born alive.");
    }
}

class Platypus1 extends Mammal {
    void getBirthInfo() {
        System.out.println("hatch from eggs");
        System.out.print("a mammal normally is ");
        super.getBirthInfo();
    }
    }

在上面的例子中，使用super.getBirthInfo()去调用超类Mammal中被重载的方法。


构造器使用super去调用超类中的构造器。而且这行代码必须放在第一行，否则编译将出错。看下面的例子：
public class SuperClassDemo {
    SuperClassDemo() {
    }
}

class Child extends SuperClassDemo {
    Child() {
        super();
    }
}

在上面这个没有什么实际意义的例子中，构造器 Child()包含了 super,它的作用就是将超类中的构造器SuperClassDemo实例化，并加到 Child类中。

编译器自动加入代码 ，当我们写一个没有构造器的类，编译的时候，编译器会自动加上一个不带参数的构造器。

现在具体介绍一下构造方法的几种用法：
类的继承机制使得子类可以使用父类的功能（即代码），并且子类也具有父类的类型。下面介绍类在继承关系上的初始化的顺序问题。
示例1：
class SuperClass
{
SuperClass()
{
System.out.println("SuperClass constructor");
}
}
public class SubClass extends SuperClass
{
SubClass()
{
System.out.println("SubClass constructor");
}
public static void main(String[] args)
{
SubClass sub = new SubClass();
}
}

输出结果： SuperClass constructor
            SubClass constructor
　　在子类中只实例化了一个子类对象。从输出结果上看，程序并不是一开始就运行自己的构造方法，而是先运行其父类的默认构造方法。注意：程序自动调用其父类的默认构造方法。
实例2
class SuperClass
{
SuperClass(String str)
{
System.out.println("Super with a string.");
}
}
public class SubClass extends SuperClass
{
SubClass(String str)
{
System.out.println("Sub with a string.");
}
public static void main(String[] args)
{
SubClass sub = new SubClass("sub");
}
}

 

在JDK下编译此程序不能成功。正如上例中说的：程序在初始化子类时先要寻找其父类的默认构造方法，结果没找到，那么编译自然不能通过。

　　解决这个问题有两个办法：

　　1．在父类中增加一个默认构造方法。
　　2．在子类的构造方法中增加一条语句：super(str); 且必须在第一句。

　　这两种方法都能使此程序通过编译，但就本程序来说运行结果却不相同。

　　第1种方法的运行结果是：

　　Sub with a string.

　　第2种方法的运行结果是：

    Super with a string.
    Sub with a string.
 
　　第2种解决方法实际上是指定编译器不要寻找父类的默认构造方法，而是去寻找带一个字符串为参数的构造方法。

　　下面介绍对象的初始化顺序问题。

　　示例3：
class One
{
One(String str)
{
System.out.println(str);
}
}
class Two
{
One one_1 = new One("one-1");
One one_2 = new One("one-2");
One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
}
public class Test
{
public static void main(String[] args)
{
System.out.println("Test main() start");
Two two = new Two("two");
}
}

 

输出结果：
Test main() start...
one-1
one-2
one-3
two
　　在main()方法中实例化了一个Two类的对象。但程序在初始化Two类的对象时，并非先调用Two类的构造方法，而是先初始化Two类的成员变量。这里Two类有3个成员变量，它们都是One类的对象，所以要先调用3次One类的相应的构造方法。最后在初始化Two类的对象。
 即在创建对象时，对象所在类的所有数据成员会首先进行初始化，如果其中的成员变量有对象，那么它们也会按照顺序执行初始化工作。在所有类成员初始化完成后，才调用对象所在类的构造方法创建对象。构造方法作用就是初始化。



　　示例4：
 
class One

{
One(String str)
{
System.out.println(str);
}
}
class Two
{
One one_1 = new One("one-1");
One one_2 = new One("one-2");
static One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
}
public class Test
{
public static void main(String[] args)
{
System.out.println("Test main() start");
Two two_1 = new Two("two-1");
System.out.println("------------");
Two two_2 = new Two("two-2");
}
}

输出结果：
Test main() start...
one-3
one-1
one-2
two-1
------------
one-1
one-2
two-2
　　如果一个类中有静态对象，那么它会在非静态对象前初始化，但只初始化一次。非静态对象每次调用时都要初始化。
实例5
class One
{
One(String str)
{
System.out.println(str);
}
}
class Two
{
One one_1 = new One("one-1");
One one_2 = new One("one-2");
static One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
3
}
public class Test
{
static Two two_3 = new Two("two-3");
public static void main(String[] args)
{
System.out.println("Test main() start");
Two two_1 = new Two("two-1");
System.out.println("------------");
Two two_2 = new Two("two-2");
}
}

输出结果：
one-3
one-1
one-2
two-3
Test main() start...
one-1
one-2
two-1
------------
one-1
one-2
two-2
　　程序中主类的静态变量会在main()方法执行前初始化。结果中只输出了一次one-3，这也说明：如果一个类中有静态对象，那么它会在非静态对象前初始化，但只初始化一次。非静态对象每次调用时都要初始化。

实例6
class One
{
One(String str)
{
System.out.println(str);
}
}
class Two
{
static int i = 0;
One one_1 = new One("one-1");
static One one_2 = new One("one-2");
static One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
}
public class Test
{
public static void main(String[] args)
{
System.out.println("Test main() start");
System.out.println("Two.i = "  Two.i);
}
}
输出结果：
Test main() start...
one-2
one-3
Two.i = 0
　　不仅第1次创建对象时，类中所有的静态变量要初始化，第1次访问类中的静态变量（没有创建对象）时，该类中所有的静态变量也要按照它们在类中排列的顺序初始化。
 
初始化的顺序包括构造方法调用的顺序如下：

　　1．主类的静态成员首先初始化。
　　2．主类的超类的构造方法按照从最高到最低的顺序被调用。
　　3．主类的非静态对象（变量）初始化。
　　4．调用主类的构造方法。