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的用法也不過這些，只有理解了其中的原理，纔不會跌入陷阱！