java中超类(父类)的概念

this是java使用的一个特定意义的引用，它指向当前对象自身。(指向该关键词所在的类,，用来引用自己所在的类中的成员变量或方法。)
super关键词指向该关键词所在类的父类，用来引用父类中的成员变量或方法。
 通过 super.someMethod([paramlist])将调用父类中的 someMethod()方法。
 该方法不一定是在当前类的直接父类中定义的，可以是直接父类在类的层次体系中继承而来。
Super 超类 (Java编程语言)
超类 ：用java术语来讲,被继承的类称为超类，继承的类称为子类。
面向对象编程的最重要的特色之一就是能够使用以前创建的类的方法和域。通过简单的类来创建功能强大的类，可以大幅地节省编程时间，更重要的是，这样做可以减少代码
出错的机会。要在以前的类上构造新类，就必须在类声明中扩展这个类。
通过扩展一个超类，可以得到这个类的一个新副本，并且可以在其上添加其他功能。如果对这个新类并不做任何添加工作，那么，它的工作情况与超类完全相同，新类中会含
有超类所声明和继承的、具有访问权限的所有方法和域。
对于超类，应该确切地理解this和super关键字的使用，下图演示了这两个关键字的使用。
import java.awt.*;
public class TestThisSuper extends Frame
{
int b;
public TestThisSuper(String a)
{
this (a,0);
}
public TestThisSuper(String a, int b)
{
super(a);
this.b= b;
}
}
super是调用父类的构造函数 使用super调用有一些限制条件,不能在super调用中使用实例变量作为参数. 而且在构造函数中,调用必须写在继承类的构造函数定义的第一行,不能在
构造函数的后面使用. this调用的同类的构造函数. super的限制条件同样适用于this函数 一个构造函数定义中不能同时包括this调用和super调用,如果想同时包括的话,可以在
this中首先进行super调用. this是对当前对象的引用 super是调用父类的构造函数.this一般是指你当前这个类的对象 super是自类调用父类的构造函数.

超类（父类）包含继承自该类的所有子类共同的属性和行为，例如，对于animal类而言，所有的哺乳动物都有类似的属性，如有眼睛的颜色，haircolor,另外有一些共同的行为，
所有的哺乳动物都有这些属性和行为，所有没有必要在继承树中对每一种哺乳动物都重复定义这些属性和行为，重复不仅需要做更多工作，可能更麻烦，而且还可能招致错误和不
一致因此，dog和cat从animal种继承了所有这些个共同的属性和方法。Animal类则认为是dog和cat的超类

继承可以带来很多设计上的好处，设计一个cat类时，Animal类提供了很多所需要的功能，通过继承Animal对象cat已经具备成为一个真正哺乳动物的所有属性和行为，为了使它成
为更具体的cat cat类必须包含所特有的属性和行为

Class <? super T > getSuperClass():返回本类的父类
Type getGenericSuperClass();返回本类的父类，包含泛型参数信息
isAssignableForm<Class<?> cls>
判定此class对象所表示的类或接口与指定的class参数所表示的类或接口是否相同，或是否是其超类或超接口
package com.kettas.haofeng.test;
public class ClassA<T> {
private T obj;
public void setObject(T obj) {
this.obj = obj;
}
public T getObject() {
return obj;
}
}

package com.kettas.haofeng.test;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
public class Test <T> extends ClassA <T> {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("==============getSuperClass=====================");
System.out.println(Test.class.getSuperclass().getName());
System.out.println("====================getGenericSuperClass=============");
Type type=Test.class.getGenericSuperclass();
System.out.println(type);
if(ParameterizedType.class.isAssignableFrom(type.getClass())){
System.out.println("------------->getActualTypeArguments:");
for(Type t1:((ParameterizedType)type).getActualTypeArguments()){
System.out.println(t1+",");
}
System.out.println();
}
}
}
==============getSuperClass=====================
com.kettas.haofen.test.ClassA
====================getGenericSuperClass=============
com.kettas.haofen.test.ClassA<T>
------------->getActualTypeArguments:
super关键和this作用类似，是被屏蔽的成员变量或者成员方法或变为可见，或者说用来引用被屏蔽的成员变量和成员成员方法。
不过super是用在子类中，目的是访问直接父类中被屏蔽的成员，注意是直接父类（就是类之上最近的超类）。下面是一个综合运用super的例子，有两个类：一个Father类，一个
Father类的子类Son，通过这两个类完全演示了super的用法，一下是代码：
package org.leizhimin;
public class Father {
public String v="Father";
public String x="输出了Father类的public成员变量x!!!";
public Father() {
 System.out.println("Father构造方法被调用!");
}
public Father(String v){
 this.v="Father类的带参数构造方法!运行了.";
}
public void outinfo(){
 System.out.println("Father的outinfo方法被调用");
}
public static void main(String[] args) {
 // TODO 自动生成方法存根
}
}
package org.leizhimin;
public class Son extends Father{
public String v="Son";
public Son() {
 super(); //调用超类的构造方法,只能放到第一行.
 System.out.println("Son无参数构造方法被调用!");
 //super(); //错误的,必须放到构造方法体的最前面.
}
public Son(String str){
 super(str);
 System.out.println("Son带参数构造方法被调用!");
}
//覆盖了超类成员方法outinfo()
public void outinfo(){
 System.out.println("Son的outinfo()方法被调用");
}
public void test(){

 String v="哈哈哈哈!"; //局部变量v覆盖了成员变量v和超类变量v

 System.out.println("------1-----");
 System.out.println(v); //输出局部变量v
 System.out.println(this.v); //输出(子类)成员变量v
 System.out.println(super.v); //输出超类成员变量v

 System.out.println("------2-----");
 System.out.println(x); //输出超类成员变量v,子类继承而来
 System.out.println(super.x); //输出超类成员变量v

 System.out.println("------3-----");
 outinfo(); //调用子类的outinfo()方法
 this.outinfo(); //调用子类的outinfo()方法
 super.outinfo(); //调用父类的outinfo()方法
}
public static void main(String[] args) {
 new Son().test();

}
}
子类Son运行结果：
Father构造方法被调用!
Son无参数构造方法被调用!
------1-----
哈哈哈哈!
Son
Father
------2-----
输出了Father类的public成员变量x!!!
输出了Father类的public成员变量x!!!
------3-----
Son的outinfo()方法被调用
Son的outinfo()方法被调用
Father的outinfo方法被调用
说明：次例子仅仅为了说明super的用法，实际在设计类的时候一般都尽可能私有(private)化。
通过上面的例子，下面总结一下super的用法：
 第一、在子类构造方法中要调用父类的构造方法，用“super(参数列表)”的方式调用，参数不是必须的。同时还要注意的一点是：“super(参数列表)”这条语句只能用
在子类构造方法体中的第一行。
 第二、当子类方法中的局部变量或者子类的成员变量与父类成员变量同名时，也就是子类局部变量覆盖父类成员变量时，用“super.成员变量名”来引用父类成员变量。
当然，如果父类的成员变量没有被覆盖，也可以用“super.成员变量名”来引用父类成员变量，不过这是不必要的。
 第三、当子类的成员方法覆盖了父类的成员方法时，也就是子类和父类有完全相同的方法定义（但方法体可以不同），此时，用“super.方法名(参数列表)”的方式访问
父类的方法。
 this、super的用法也不过这些，只有理解了其中的原理，才不会跌入陷阱！