super和this,superthis
關於super和this有一個奇怪的現象:
例1:
class grandfather{
String name="grandfather";
}
class father extends grandfather{
String name="father";
void show(){
System.out.println("father.show-->"+this.name+"--"+super.name);
}
}
class son extends father{
void rs(){
super.show();
this.show();
}
}
public class super_this2 {
public static void main(String[] args) {
son s=new son();
s.rs();
}
}
運行結果:
father.show-->father--grandfather
father.show-->father--grandfather
使用super.show()和使用this.show()輸出的結果是一樣的。存在這種現象的還有這種現象還有super.getClass()和this.getClass()等。
例2:
public class super_this2{
public static void main(String[] args) {
new super_this2().test();
}
public void test(){
System.out.println(super.getClass());
System.out.println(this.getClass());
}
}
運行結果:
class super_this2
class super_this2
現在我們分析這個現象。
1.在例1的子類中覆蓋show()
例3:
class grandfather{
String name="grandfather";
}
class father extends grandfather{
String name="father";
void show(){
System.out.println("father.show-->"+this.name+"--"+super.name);
}
}
class son extends father{
void show(){
System.out.println("son.show-->"+this.name+"--"+super.name);
}
void rs(){
super.show();
this.show();
}
}
public class super_this2{
public static void main(String[] args) {
son s=new son();
s.rs();
}
}
運行結果:
father.show-->father--grandfather
son.show-->father--father
這說明
A.super
.方法/變量調用的確實是父類的方法/變量;this
.方法/變量調用的確實是當前對象的方法/變量
2.而如果子類沒有覆蓋show()時,子類輸出結果和父類一樣,比如例1,再比如下面的例子:
例4:
public class Test2 {
public static void main(String[] args) {
ch c=new ch();
c.m6();
c.m7();
c.m8();
}
static class fa{
final void m6(){
System.out.println("father's m6");
}
static void m7(){
System.out.println("father's m7");
}
void m8(){
System.out.println("father's m8");
}
}
static class ch extends fa{
void m8(){
System.out.println("child's m8");
}
}
}
運行結果:
father's m6
father's m7
child's m8
這裡,m6,m7,m8都被繼承了,然後m6,m7沒有被覆蓋,輸出的是父類的結果。m8被重寫輸出子類的結果。
這說明:
B.如果子類沒有重寫或隱藏父類的某個方法和變量,那麼子類調用繼承的方法或變量來自父類。
所以A和B綜合的結果是:AB.super
.方法/變量調用的確實是父類的方法/變量;this
.方法/變量調用的確實是當前對象的方法/變量,但如果this所在對象沒有重寫或隱藏父類的方法或變量,那麼它調用的繼承來的方法或變量來自父類
3.如果在例1的son類中添加 String name="son";
例5:
class grandfather{
String name="grandfather";
}
class father extends grandfather{
String name="father";
void show(){
System.out.println("father.show-->"+this.name+"--"+super.name);
}
}
class son extends father{
String name="son";//隱藏father類的name屬性
void rs(){
super.show();
this.show();
}
}
public class super_this2{
public static void main(String[] args) {
son s=new son();
s.rs();
}
}
運行結果和例1一樣:
father.show-->father--grandfather
father.show-->father--grandfather
但如果像下面這樣不隱藏而直接修改name屬性:
例6:
class grandfather{
String name="grandfather";
}
class father extends grandfather{
String name="father";//
void show(){
System.out.println("father.show-->"+this.name+"--"+super.name);
}
}
class son extends father{
// String name="son"; // 去掉
public son(){
name="son";//不隱藏父類的name , 在構造方法中直接修改
}
void rs(){
super.show();
this.show();
}
}
public class super_this2{
public static void main(String[] args) {
son s=new son();
s.rs();
}
}
運行結果:
father.show-->
son--grandfather
father.show-->
son--grandfather
這說明:
C.隱藏變量不會對父類變量產生影響,但是對繼承來的變量進行修改會對父類的變量產生直接影響。
現在你把例6的father類中的 String name="father"去掉試試:
class grandfather{
String name="grandfather";
}
class father extends grandfather{
// String name="father";// 去掉
void show(){
System.out.println("father.show-->"+this.name+"--"+super.name);
}
}
class son extends father{
// String name="son"; // 去掉
public son(){
name="son";
}
void rs(){
super.show();
this.show();
}
}
public class super_this2{
public static void main(String[] args) {
son s=new son();
s.rs();
}
}
運行結果:
father.show-->son--son
father.show-->son--son
原因正如C所說的,String name="father"隱藏了爺爺類的String name="grandfather",所以後面修改name="son"不會對爺爺類產生影響,現在去掉隱藏後,對繼承的name屬性的修改就會影響爺爺類的name屬性。
4.提2個問題:(1)方法體裡面的this和super與調用它們對象是什麼關系,(2)this和super與方法體裡面的this和super是什麼關系?
即這裡son對象調用了
super和
this,
super和
this調用了
super和
this,那麼對象
s與
super和
this是什麼關系?
super和
super,
this是什麼關系?
this和
super,
this是什麼關系?
class grandfather{
String name="grandfather";
public String toString(){
return "grandfather toString";
}
public static String toString2(){
return "grandfather static toString";
}
}
class father extends grandfather{
String name="father";
void show(){
System.out.println("father.show-->"+this.name+"--"+super.name);
System.out.println("father.show-->"+this.toString()+"--"+super.toString());
System.out.println("father.show-->"+this.toString2()+"--"+super.toString2());
}
public String toString(){
return "father toString";
}
public static String toString2(){
return "father static toString";
}
}
class son extends father{
String name="son";
void rs(){
super.show();
System.out.println("===========================");
this.show();
}
public String toString(){
return "son toString";
}
public static String toString2(){
return "son static toString";
}
}
public class super_this2{
public static void main(String[] args) {
son s=new son();
s.rs();
}
}
運行結果
father.show-->
father--grandfather
father.show-->son toString--grandfather toString
father.show-->father static toString--grandfather static toString
===========================
father.show-->father--grandfather
father.show-->son toString--grandfather toString
father.show-->father static toString--grandfather static toString
D.外部的super和this只能決定程序調用的是父類的還是子類的,不會對它們方法體裡面的super和this產生影響,super指所在類的父類,使用super將決定調用所在類的父類的方法,this則分兩種情況,1.變量和靜態方法(static),priavate方法,fianl方法,作為構造方法使用,編譯期就確定this為所在類的對象,2.其他方法this在運行期間確定為運行的對象。所以綜合AB結果是:ABD.外部的super和this只能決定程序調用的是父類的還是子類的,不會對它們方法體裡面的super和this產生影響,super指所在類的父類,使用super將決定調用所在類的父類的方法,即super
.方法/變量調用的是所在類父類的方法/變量;this則分三種情況,1.變量和靜態方法(static),priavate方法,fianl方法以及它作為構造方法使用時,編譯期就確定this所在類的對象,2.其他方法在運行期間確定為運行的對象。3.確定this所指對象後,如果該對象沒有重寫或隱藏父類的方法或變量,那麼它調用的繼承來的方法或變量來自父類。
總之super和this的法就是找到它們所指的對象,然後調用這個對象的方法,ABD說的就是super和this所指的對象,然後怎麼調用這個對象的方法。
套用在上面的例子:
1.super和
this只能決定程序調用的是父類的還是子類的show(),
super和
this不影響
super和
this。show()是普通方法,所以this確定為son對象,所以
this.show()指son的show()方法,但是son沒有覆蓋show()方法,所以這個show()來自father,然後super所在類的父類也是father,所以
super.show()也來自father。即
super和
this都調用了父類的show()方法。
2.然後this.name和this.toString2()都是編譯期間就確定this為所在的對象,所以name和toString2是fanther的屬性和方法,父類也存在name和toString2();this.String()是普通方法,確定為運行的對象son
。
所以輸出:
father.show-->
father--grandfather
father.show-->son toString--grandfather toString
father.show-->father static toString--grandfather static toString
3.在1中
super和
this都調用了父類的show()方法,2
super.show()和
this.show()都按照2裡面的方式一樣運行,所以
super.show()和
this.show()輸出結果一樣(
super和
this不影響
super和
this)。
總結:
外部的super和this只能決定程序調用的是父類的還是子類的,不會對它們方法體裡面的super和this產生影響,super指所在類的父類,使用super將決定調用所在類的父類的方法,即super
.方法/變量調用的是所在類父類的方法/變量;this則分三種情況,1.變量和靜態方法(static),priavate方法,fianl方法以及它作為構造方法使用時,編譯期就確定this所在類的對象,2.其他方法在運行期間確定為運行的對象。3.確定this所指對象後,如果該對象沒有重寫或隱藏父類的方法或變量,那麼它調用的繼承來的方法或變量來自父類。
.隱藏變量不會對父類變量產生影響,但是對繼承來的變量進行修改會對父類的變量產生直接影響。
最後看一道題:
class father{
void show(){
System.out.println("father getClass-->"+this.getClass()+"--"+super.getClass());
System.out.println("father getSuperclass-->"+this.getClass().getSuperclass()+"--"+super.getClass().getSuperclass());
}
}
class son extends father{
void rs(){
super.show();
System.out.println("===========================");
this.show();
}
}
public class super_this3{
public static void main(String[] args) {
son s=new son();
s.rs();
}
}
father getClass-->class son--class son
father getSuperclass-->class father--class father
===========================
father getClass-->class son--class son
father getSuperclass-->class father--class father
主要是因為super.getClass()返回的是son.class,然後son.class.getName()輸出son。
getClass是final方法,this.getClass肯定來自父類。getClass的源碼:
Java_java_lang_Object_getClass(JNIEnv *env, jobject this)
{
if (this == NULL) {
JNU_ThrowNullPointerException(env, NULL);
return 0;
} else {
return (*env)->GetObjectClass(env, this);
}
}
this指正在運行的對象。所以getClass返回son.class
文章原創,謝絕轉載,歡迎指正。