this是java使用的特定含义的引用，指向当前对象本身。 (用于指向包含该关键字的类，然后引用、以及自己所在类的成员变量或方法。 ）
super关键字是指该关键字所在类的父类，并引用父类中的成员变量或方法。
在super.someMethod([paramlist] )中，调用父类的somemethod )方法。
方法不必在当前类的直接父类中定义，直接父类可以由类的层次结构继承。
Super超类(Java编程语言)
超类：在java术语中，继承的类称为超类，继承的类称为子类。
面向对象编程最重要的特色之一是可以使用以前创建的类的方法和域。 通过用简单的类创建强大的类，可以显著节省编程时间。 更重要的是减少代码
犯错误的机会。 要在以前的类中构建新的类，必须在类声明中扩展类。
可以通过扩展超类来获取此类的新副本，并向其中添加其他功能。 如果不对此新类执行任何附加工作，则其工作情况与超类完全相同，新类将包含以下内容
由超类声明、继承并具有访问权限的所有方法和域。
超类需要准确理解this和super关键字的使用。 下图显示了这两个关键字的使用。
import java.awt.*；
publicclasstesthissuperextendsframe
{
int b；
Publictestthissuper(stringa )。
{
this(a，0；
}
publictestthissuper(stringa，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 (； 返回包含通用参数信息的类的父类
isAssignableFormcls
确定此class对象表示的类或接口是否与指定class参数表示的类或接口相同，或者是否为超类或超接口
package com.kettas.haofeng.test；
公共类类类a {
private T obj；
Publicvoidsetobject(tobj ) {
this.obj=obj；
}
公共获取() {
返回对象；
}
}
package com.kettas.haofeng.test；
import Java.lang.reflect.parameterized type；
import java.lang.reflect.Type；
公共类测试扩展类a {
//*
* @param args
*/
publicstaticvoidmain (string [ ] args ) {
//todo自动生成方法stub
system.out.print ln ('========gets
uperClass=====================");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------------->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的用法也不过这些，只有理解了其中的原理，才不会跌入陷阱！