“Class”类
众所周知Java有个Object 类，是所有Java
classes的继承根源，其内声明了数个应该在所有Java
class中被改写的methods：hashCode()、equals()、clone()、toString()、getClass()等。其中getClass()返回一个Class
object。
Class
class十分特殊。它和一般classes一样继承自Object，其实体用以表达Java程序运行时的classes和interfaces，也用来表达enum、array、primitive
Java types(boolean, byte, char, short, int, long, float,
double)以及关键词void。当一个class被加载，或当加载器(class
loader)的defineClass()被JVM调用，JVM 便自动产生一个Class object。
“Class” object的取得途径
Java允许我们从多种管道为一个class生成对应的Class object。下图是一份整理。
Class object 诞生管道
示例
运用getClass()
注：每个class 都有此函数
String str = "abc";
Class c1 = str.getClass();
运用
Class.getSuperclass()
Button b = new Button();
Class c1 = b.getClass();
Class c2 = c1.getSuperclass();
运用static method
Class.forName()
(最常被使用)
Class c1 = Class.forName ("java.lang.String");
Class c2 = Class.forName ("java.awt.Button");
Class c3 = Class.forName ("java.util.LinkedList$Entry");
Class c4 = Class.forName ("I");
运用
.class 语法
Class c1 = String.class;
Class c2 = java.awt.Button.class;
Class c3 = Main.InnerClass.class;
Class c4 = int.class;
Class c5 = int[].class;
运用
primitive wrapper classes
的TYPE 语法
Class c1 = Boolean.TYPE;
Class c2 = Byte.TYPE;
Class c3 = Character.TYPE;
Class c4 = Short.TYPE;
Class c5 = Integer.TYPE;
Class c6 = Long.TYPE;
Class c7 = Float.TYPE;
Class c8 = Double.TYPE;
Class c9 = Void.TYPE;

首先知道：
Class clzz=getClass().getSuperclass();
Type type=getClass().getGenericSuperclass();
而Type是JAVA语言中所有类型的公共父接口，Class类是其直接实现类。
获取父类泛型类型：
Type type=getClass().getGenericSuperclass();
ParameterizedType pt = (ParameterizedType) type;//参数化
Type[] types=pt.getActualTypeArguments();
Class entityClass=(Class)types[0];
......
以下为 Type直接子接口
ParameterizedType，GenericArrayType，TypeVariable和WildcardType四种类型的接口
ParameterizedType: 表示一种参数化的类型，比如Collection
GenericArrayType: 表示一种元素类型是参数化类型或者类型变量的数组类型
TypeVariable: 是各种类型变量的公共父接口
WildcardType: 代表一种通配符类型表达式，比如?, ? extends Number, ? super Integer【wildcard是一个单词：就是“通配符”】

Java继承的概念与实现

继承是Java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。 继承是类与类之间的关系，是一个很简单很直观的概念，与现实世界中的继承（例如儿子继承父亲财产）类似。继承可以理解为一个类从另一个类获取方法和属性的过程。如果类B继承于类A，那么B就拥有A的方法和属性。 继承使用extends 关键字。
类的继承（ extends ）格式：

class 父类 {

}

class 子类 extends 父类 {

}
例子：



注意：由于Student类继承 People类，虽然name 和 age 变量没有在 Student 中定义，但是已在 People 中定义，可以直接拿来用。Student 是 People 的子类，People 是Teacher 类的父类。
构造方法不能被继承：

注意：构造方法不能被继承。一个类的构造方法只有两种方式获得：

自己编写构造方法。
当类中没有构造方法时，类会自动生成不带参数的默认构造方法。

单继承性：

Java 允许一个类仅能继承一个其它类，即一个类只能有一个父类，这个限制被称做单继承性。

Java继承中的方法重写：

方法重写又称方法覆盖，方法重写是子类与父类的一种多态性表现

子类可以重写所继承父类除private以为的方法与成员。	

在类继承中，子类可以修改从父类继承来的方法，也就是说子类能创建一个与父类方法有不同功能的方法，但具有相同的名称、返回值类型、参数列表。

如果在新类中定义一个方法，其名称、返回值类型和参数列表正好与父类中的相同，那么，新方法被称做重写旧方法。

被重写的方法在子类中只能通过super调用。
注意：重写不会删除父类中的方法，而是对子类的实例隐藏，暂时不使用。

例子：

方法重写的原则：

重写方法的返回类型、方法名称、参数列表必须与原方法的相同。

重写方法不能比原方法访问性差（即访问权限不允许缩小）。

重写方法不能比原方法抛出更多的异常。

被重写的方法不能是final类型，因为final修饰的方法是无法重写的。

被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行重写。

被重写的方法不能为static。如果父类中的方法为静态的，而子类中的方法不是静态的，但是两个方法除了这一点外其他都满足重写条件，那么会发生编译错误；反之亦然。即使父类和子类中的方法都是静态的，并且满足重写条件，但是仍然不会发生重写，因为静态方法是在编译的时候把静态方法和类的引用类型进行匹配。
方法的重载：

方法重载是一个类的多态性表现,

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。只能重载构造函数

例子：

重载规则：

被重载的方法必须改变参数列表；

被重载的方法可以改变返回类型；

被重载的方法可以改变访问修饰符；

被重载的方法可以声明新的或更广的检查异常；

方法能够在同一个类中或者在一个子类中被重载。

重写和重载的区别：



this关键字：

this关键字：指向自己的引用

this 与super 关键字类似，this 用来表示当前类的实例，super 用来表示父类。
super 关键字：

我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

1.通过 super 调用父类的变量以及父类的隐藏变量：

当调用父类的隐藏变量时，必须要在父类中声明 getter 方法，因为声明为 private 的数据成员对子类是不可见的。
2.通过 super 调用父类的方法和父类被重写了的方法和父类的构造方法：

super 也可以用在子类的子类中调用父类方法，Java 能自动向上层类追溯。直到找到该方法为止，父类行为被调用，就好像该行为是本类的行为一样，而且调用行为不必发生在父类中，它能自动向上层类追溯。

在许多情况下，使用默认构造方法来对父类对象进行初始化。当然也可以使用 super 来显示调用父类的构造方法。

例子：

从执行结果可看出构造方法基本初始化运行顺序是：

1.初始化子类必先初始化父类。

2.要先初始化父类，必须先初始化它的属性再初始化它的方法。

3.再回到子类，初始化子类属性，再回到子类的构造方法，才算是完成一个类的实例化
在构造方法中要注意：

无论是 super() 还是 this()，都必须放在构造方法的第一行。

在构造方法中调用另一个构造方法，调用动作必须置于最起始的位置。

不能在构造方法以外的任何方法内调用构造方法。

在一个构造方法内只能调用一个构造方法。

如果编写一个构造方法，既没有调用 super() 也没有调用 this()，编译器会自动插入一个调用到父类构造方法中，而且不带参数。
super 与 this 的区别：

super 不是一个对象的引用，不能将 super 赋值给另一个对象变量，它只是一个指示编译器调用父类方法的特殊关键字。

this是指向自己的引用，this 用来表示当前类的实例，可在当前类中调用。

四种创建class对象的方法

先创建三个类，Person，Student，Teacher。其中Student和Teacher继承Person类

class Person{
    public String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

class Student extends Person{
    public Student(){
        this.name = "学生";
    }
}

class Teacher extends Person{
    public Teacher(){
        this.name= "老师";
    }
}


四种获取class对象的方法

public class Test03 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("这个人是："+person.name);

  	    //方式一：通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1);
        System.out.println(c1.hashCode());

        //方式二：forname获取
        Class c2 = Class.forName("com.lixv.reflection.Student");
        System.out.println(c2);
        System.out.println(c2.hashCode());

        //方式三：通过类名.class获取
        Class c3 = Student.class;
        System.out.println(c3);
        System.out.println(c3.hashCode());

        //方式四：基本内置类型的包装类都有一个Type属性
        Class c4 = Integer.TYPE;
        System.out.println(c4);
    }
}

运行结果：



hashcode是同一个值，说明，获取的是同一个对象

获取class的父类class对象

//测试创建class类的创建方式有哪些
public class Test03 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("这个人是："+person.name);

        //方式一：通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1);
        System.out.println(c1.hashCode());

        //获得父类class对象
        Class c5 = c1.getSuperclass();
        System.out.println(c5);	

    }
}

运行结果：