Java中的super关键字

简单说一下Java中的super关键字。

super关键字的用法源自于Java的三大特性之一的继承。也就是说有了继承，才有了super关键字。

super的英文基本意思是“超”。在Java中也是这么理解的，super代表的就是超类的意思。而我们习惯

上把超类叫做父类。

super主要有两种用法。

一是：调用父类构造方法

二是：调用父类的属性和一般方法

下面简单的对两种用法进行介绍

====================================================================分割线

一、调用父类的构造方法

就像上面说的，先有继承，再有super关键字的使用。所以在下面的代码中，进行了一个简单

的类的继承。

而关于调用父类的构造方法，下面说两种情况。一种是隐式调用父类无参构造方法，一种是显示

调用父类的任意构造方法。

注意一点：必须在子类的构造方法中对父类的构造方法进行调用，不能在子类的其他方法中；

注意二点：调用父类的构造方法的代码，必须写在子类构造方法的第一行。

-------------------------------------------------------------------------------------------------------------小分割线

第一种情况：隐式调用父类的无参构造方法

所谓的隐式，就是不将调用过程写出来。也就是说，我什么也不写，程序会默认的去调用父类的

无参构造方法。详情见下面代码：

<pre name="code" class="java">public class SuperTest {

	public static void main(String[] args) {
		
		new Child();		//孩子类无参构造
		new Child("我是孩子类带参构造方法");	//孩子类带参构造
	}
}

class Father{

	String money;
	
	public Father(){			//父亲类无参构造
		System.out.println("我是父亲类无参构造方法");
	}
	
	public Father(String t){	//父亲类带参构造
		System.out.println("我是父亲类带参构造方法");
	}
}

class Child extends Father{
	
	public Child(){				//孩子类无参构造
		//若方法体不显示调用父类的任何构造方法，则默认调用父类的空构造方法,也就是默认添加一句super();代码
		System.out.println("我是子类的无参构造方法");
	}
	
	public Child(String info){	//孩子类带参构造
		//若方法体不显示调用父类的任何构造方法，则默认调用父类的空构造方法,也就是默认添加一句super();代码
		System.out.println(info);
	}
	
	public void test(){
		
	}
}

在上面的代码中，写了三个类。主类SuperTest，和一个Father类，还有一个Child类。

其中，Child类继承了Father类。

其中Father类中有两个构造方法，一个是无参的，一个是有参的。Child类也有两个构造方法，

一个是有参的，一个是无参的。仔细观察，会看到，Child类中的构造方法并没有显式的去调用父

类的构造方法。那么，按照我上面说的，程序会默认的去调用父类的无参构造方法。

在主类中，我们分别实例化了两个Child的对象。第一个调用子类的无参构造，第二个调用子

类的有参构造。

按照上面所说，那么，在调用子类的无参构造方法之前会先调用父类的无参构造方法。同样，

在调用子类的带参构造方法之前会先调用子类的无参构造方法。所以上面程序的运行结果会是：

我是父类的无参构造方法

我是子类的无参构造方法

我是父类的无参构造方法

我是子类的带参构造方法

下图是运行结果：

-------------------------------------------------------------------------------------------------------------小分割线

第二种情况：显式调用父类的任何参构造方法

既然是显式的调用，那么就必须将代码写明白。

Java中通过下面两种写法去显式的调用父类的构造方法：

super();// 显式调用父类无参构造方法

super(参数1,  参数2,  ...)// 显示调用父类带参构造方法

那么，将上面Child类中的构造方法，该为显式的调用，其结果如下：

class Child extends Father{
	
	public Child(){				//孩子类无参构造
		super();				//显式调用父类的无参构造，必须写在第一行
		System.out.println("我是子类的无参构造方法");
	}
	
	public Child(String info){	//孩子类带参构造
		super("带参构造方法");				//显式调用父类的带参构造，必须写在第一行
		System.out.println(info);
	}
	
	public void test(){
		
	}
}

按照上面说的，那么修改后的运行结果会是：

我是父亲类无参构造方法
我是子类的无参构造方法
我是父亲类带参构造方法
我是孩子类带参构造方法

结果和上面的一致，就不贴图了。

-------------------------------------------------------------------------------------------------------------小分割线

以上就是关于super关键字的第一种用法的介绍，也就是调用父类构造方法。

下面再说super关键字的第二种用法，也就是调用父类的属性和一般方法。

====================================================================分割线

二：调用父类的属性和一般方法

这里说的是调用父类的属性和一般方法，但是为什么要调用呢。当子类继承了父类，那么就会

继承其属性和方法。既然已经继承了，那就可以直接用，为什么反而要去调用父类的呢。

这就涉及到了一个覆写的概念了。所谓的覆写，指的是，子类将父类的属性或者方法重新定义

了一次。属性的名字类型都一样；方法的名字，参数，返回值类型，访问权限（最好相同）都一样，

只是方法体不同。

那么，问题来了。

1、当我在子类中对覆写的属性或者方法进行调用的时候，调用的到底是父类的属性和方法还

是子类中覆写的？

2、如果我不想调用子类中覆写的方法和属性，想调用的是父类中原来的方法和属性，那么该怎么

调用？

以下就是问题的回答：

1、调用的是子类中覆写的

2、Java中通过下面的方式来调用父类的属性，或者一般方法：

super.属性; // 调用父类的属性

super.方法();// 调用父类的方法

下面通过一段代码来说面上面所说的：

public class SuperTest {

	public static void main(String[] args) {
		
		Child child = new Child();		//孩子类无参构造
		child.test();
	}
}

class Father{

	String money;
	
	public Father(){			//父亲类无参构造
		
		System.out.println("我是父亲类无参构造方法");
	}
	
	public void test(){
		this.money = "1000元";
		System.out.println("我是父类原有的方法，我有"+ this.money);
	}
	
}

class Child extends Father{
	
	String money;
	
	public Child(){				//孩子类无参构造
		super();				//显式调用父类的无参构造，必须写在第一行
		System.out.println("我是子类的无参构造方法");
	}
	
	public void test(){
		this.money = "10000元";				//此处初始化的是子类的money属性
		super.test();						//调用父类的test方法
		System.out.println("父亲有" + super.money);	//调用父类的money属性
		System.out.println("我是子类的test方法，我有" + this.money);	//调用子类的money属性
	}
}

上面的代码中，Father类中有一个test方法，Child类中将test方法覆写了。然后可以看到，

在Child类中test方法，可以通过super.test();调用父类的test方法。也可以通过super.money

调用父类的money属性。

其运行结果如下图：

以上就是关于super关键字的第二种用法。

====================================================================分割线

我害怕自己说的不够明白，在查资料的时候，摘抄了一些其他人讲的东西。附在下面，方便

理解。在此感谢网上的人们。

1、

super关键和this作用类似，使被屏蔽的成员变量或者成员方法或变为可见，或者说用来引用被
屏蔽的成员变量和成员成员方法。
不过super是用在子类中，目的是访问直接父类中被屏蔽的成员，注意是直接父类（就是类之上最
近的超类）。（注：这里所说的被屏蔽的，就是在子类中被覆写的属性和方法）

-----------------------------------------------------------------------------------------------------------------小分割线

2、

第一、在子类构造方法中要调用父类的构造方法，用“super(参数列表)”的方式调用，参数不是
必须的。同时还要注意的一点是：“super(参数列表)”这条语句只能用在子类构造方法体中的第一行。

第二、当子类方法中的局部变量或者子类的成员变量与父类成员变量同名时，也就是子类局部变
量覆盖父类成员变量时，用“super.成员变量名”来引用父类成员变量。当然，如果父类的成员
变量没有被覆盖，也可以用“super.成员变量名”来引用父类成员变量，不过这是不必要的。

第三、当子类的成员方法覆盖了父类的成员方法时，也就是子类和父类有完全相同的方法定义（
但方法体可以不同），此时，用“super.方法名(参数列表)”的方式访问父类的方法。

-----------------------------------------------------------------------------------------------------------------小分割线

3、

子类的构造函数如果要引用super的话，必须把super放在函数的首位

在Java中，有时还会遇到子类中的成员变量或方法与父类（有时也称父类）中的成员变量或方法
同名。因为子类中的成员变量或方法名优先级高，所以子类中的同名成员变量或方法就隐藏了父
类的成员变量或方法，但是我们如果想要使用父类中的这个成员变量或方法，就需要用到super.

-----------------------------------------------------------------------------------------------------------------小分割线
4、

调用父类的构造方法

操作被隐藏的成员变量和被覆盖的成员方法
-----------------------------------------------------------------------------------------------------------------小分割线
5、
super 在子类引用父类的属性或者方法的时候使用；
super 是相对于继承而言的；
super 代表的是当前类的父类，相似的，this 是代表当前类。

====================================================================分割线

以上就是关于super关键字的用法简介。