JavaSE 基础 - 第十四章 super关键字
JavaSE 基础 - 第十四章 super关键字
- 1、super是一个关键字，全部小写
- 2、super和this对比着学习
- 3、super()
- 4、重要的结论：
- 5、注意：this()和super() 不能共存，它们都是只能出现在构造方法第一行。
- 6、无论是怎样折腾，父类的构造方法是一定会执行的【super()是一定存在的】。（百分百的。）
- 7、在java语言中不管是是new什么对象，最后老祖宗的Object类的无参数构造方法一定会执行
- 8、要注意：建议手写一个类的无参构造方法
- 9、super使用时，后面必须有.或者()，不能像this一样还可以单独输出！
- 10、super的3种使用：super.属性名，super.方法名(实参) ，super(实参)
- 【实例1】判断程序的执行过程1
- 【实例2】判断程序的执行过程2
- 【实例3】super关键字代表的就是“当前对象”的那部分父类型特征。
- 【实例4】super. 什么时候不能省略？
- 【实例5】 如果想在子类中访问父中的数据，必须使用“super.”加以区分
- 【总结super关键字】：
- 传送门
1、super是一个关键字，全部小写
2、super和this对比着学习
（this在第十一章学过）
this:
this能出现在实例方法【this.】和构造方法【this()】中。
this的语法是：“this.”、“this()”
this不能使用在静态方法中。
this. 大部分情况下是可以省略的。
this.什么时候不能省略呢？ 在区分局部变量和实例变量的时候不能省略。
public void setName(String name){
this.name = name;
}
this() 只能出现在构造方法第一行，通过当前的构造方法去调用“本类”中其它的构造方法，
目的是：代码复用。
super:
super能出现在实例方法【super.】和构造方法【super()】中。
super的语法是：“super.”、“super()”
super不能使用在静态方法中。
super. 大部分情况下是可以省略的。
super.什么时候不能省略呢？
父类和子类中有同名属性，或者说有同样的方法，
想在子类中访问父类的，super. 不能省略。
super() 只能出现在构造方法第一行，通过当前的构造方法去调用“父类”中的构造方法，
目的是：创建子类对象的时候，先初始化父类型特征。
3、super()
表示通过子类的构造方法调用父类的构造方法。
模拟现实世界中的这种场景：要想有儿子，需要先有父亲。
4、重要的结论：
当一个构造方法第一行：
既没有this()又没有super()的话，默认会有一个super();
表示通过当前子类的构造方法调用父类的无参数构造方法。
所以必须保证父类的无参数构造方法是存在的。
也就是说一个构造方法的第一行，必定存在this()或者super() ！！
(即使你看不见，但也有默认的super())
5、注意：this()和super() 不能共存，它们都是只能出现在构造方法第一行。
6、无论是怎样折腾，父类的构造方法是一定会执行的【super()是一定存在的】。（百分百的。）
7、在java语言中不管是是new什么对象，最后老祖宗的Object类的无参数构造方法一定会执行
Object类的无参数构造方法是处于“栈顶部”
栈顶的特点：
最后调用，但是最先执行结束。
后进先出原则。
8、要注意：建议手写一个类的无参构造方法
以后写代码的时候，一个类的无参数构造方法还是建议大家手动的写出来。
如果无参数构造方法丢失的话，可能会影响到“子类对象的构建”。
9、super使用时，后面必须有.或者()，不能像this一样还可以单独输出！
super 不是引用。super也不保存内存地址，super也不指向任何对象。
super 只是代表当前对象内部的那一块父类型的特征。
super使用时，后面必须有.或者()，不能像this一样还可以单独输出！
10、super的3种使用：super.属性名，super.方法名(实参) ，super(实参)
| 用法 | 介绍 |
|---|---|
| super.属性名 | 【访问父类的属性】 |
| super.方法名(实参) | 【访问父类的方法】 |
| super(实参) | 【调用父类的构造方法】 |
【实例1】判断程序的执行过程1
public class SuperTest01{
public static void main(String[] args){
new B();
}
}
class A { //任何类都是默认继承老祖宗Object类的
// 建议手动的将一个类的无参数构造方法写出来。
public A(){ //第 5 步
//super(); // 这里也是默认有这一行代码的。
System.out.println("A类的无参数构造方法！"); //第 6 步
}
// 一个类如果没有手动提供任何构造方法，系统会默认提供一个无参数构造方法。
// 一个类如果手动提供了一个构造方法，那么无参数构造系统将不再提供。
public A(int i){
//super();
System.out.println("A类的有参数构造方法(int)");
}
}
class B extends A{
public B(){ //第 1 步
this("zhangsan"); //第 2 步
System.out.println("B类的无参数构造方法！"); //第 8 步
}
public B(String name){ //第 3 步
super(); //第 4 步
System.out.println("B类的有参数构造方法(String)"); //第 7 步
}
}
/*输出结果：
A类的无参数构造方法！
B类的有参数构造方法(String)
B类的无参数构造方法！
*/
【实例2】判断程序的执行过程2
public class SuperTest02{
public static void main(String[] args){
new C();
}
}
class A {
public A(){ //第 9 步
System.out.println("1");
}
}
class B extends A{
public B(){
System.out.println("2");
}
public B(String name){ //第 7 步
super(); //第 8 步
System.out.println("3"); //第 10 步
}
}
class C extends B{
public C(){ // 这个是最先调用的。但是最后结束。//第 1 步
this("zhangsan"); //第 2 步
System.out.println("4"); //第 13 步
}
public C(String name){ //第 3 步
this(name, 20); //第 4 步
System.out.println("5"); //第 12 步
}
public C(String name, int age){ //第 5 步
super(name); //第 6 步
System.out.println("6"); //第 11 步
}
}
/*输出结果：
1
3
6
5
4
*/
【实例3】super关键字代表的就是“当前对象”的那部分父类型特征。
/*
1、举个例子：在恰当的时间使用：super(实际参数列表);
2、注意：在构造方法执行过程中一连串调用了父类的构造方法，
父类的构造方法又继续向下调用它的父类的构造方法，但是实际上
对象只创建了一个。
3、思考：“super(实参)”到底是干啥的？
super(实参)的作用是：初始化当前对象的父类型特征。
并不是创建新对象。实际上对象只创建了1个。
4、super关键字代表什么呀？
super关键字代表的就是“当前对象”的那部分父类型特征。
我继承了我父亲的一部分特征：
例如：眼睛、皮肤等.
super代表的就是“眼睛、皮肤等”。
“眼睛、皮肤等”虽然是继承了父亲的，但这部分是在我身上呢。
*/
// 测试程序
public class SuperTest03{
public static void main(String[] args){
CreditAccount ca1 = new CreditAccount(); //调无参的构造方法
System.out.println(ca1.getActno() + "," + ca1.getBalance() + "," + ca1.getCredit()); // null,0.0,0.0
CreditAccount ca2 = new CreditAccount("1111", 10000.0, 0.999); //调有参的构造方法
System.out.println(ca2.getActno() + "," + ca2.getBalance() + "," + ca2.getCredit()); //1111,10000.0,0.999
}
}
// 账户
class Account{
// 属性
private String actno;
private double balance;
// 构造方法
public Account(){
//super(); 这三行代码都是默认存在的
//this.actno = null;
//this.balance = 0.0;
}
public Account(String actno, double balance){
// super();
this.actno = actno;
this.balance = balance;
}
// setter and getter
public void setActno(String actno){
this.actno = actno;
}
public String getActno(){
return actno;
}
public void setBalance(double balance){
this.balance = balance;
}
public double getBalance(){
return balance;
}
}
// 信用账户
class CreditAccount extends Account{
// 属性：信誉度（诚信值）
// 子类特有的一个特征，父类没有。
private double credit;
// 构造方法
// 分析以下程序是否存在编译错误？？？？
public CreditAccount(String actno, double balance, double credit){
// 私有的属性，只能在本类中访问。
/* 报错
this.actno = actno;
this.balance = balance;
*/
// 以上两行代码在恰当的位置，正好可以使用：super(actno, balance);
// 通过子类的构造方法调用父类的构造方法。
super(actno, balance);
this.credit = credit;
}
// 提供无参数的构造方法
public CreditAccount(){
//super(); //这两行都是默认存在的
//this.credit = 0.0;
}
// setter and getter方法
public void setCredit(double credit){
this.credit = credit;
}
public double getCredit(){
return credit;
}
}
【实例4】super. 什么时候不能省略？
1、“this.”和“super.”大部分情况下都是可以省略的。
2、this. 什么时候不能省略？
public void setName(String name){
this.name = name;
}
3、super. 什么时候不能省略？
父中有，子中又有，如果想在子中访问“父的特征”，super. 不能省略。
4、java中允许在子类中出现和父类一样的同名变量/同名属性。
5、java是怎么来区分子类和父类的同名属性的？
this.name：当前对象的name属性
super.name：当前对象的父类型特征中的name属性。
public class SuperTest04{
public static void main(String[] args){
Vip v = new Vip("张三");
v.shopping();
}
}
/*结果：
张三正在购物!
张三正在购物!
张三正在购物!
*/
class Customer{
String name;
public Customer(){}
public Customer(String name){
super();
this.name = name;
}
}
class Vip extends Customer{
public Vip(){}
public Vip(String name){
super(name);
}
// super和this都不能出现在静态方法中。
public void shopping(){
// this表示当前对象。
System.out.println(this.name + "正在购物!");
// super表示的是当前对象的父类型特征。（super是this指向的那个对象中的一块空间。）
System.out.println(super.name + "正在购物!");
System.out.println(name + "正在购物!");
}
}
public class SuperTest05{
public static void main(String[] args){
Vip v = new Vip("张三");
v.shopping();
}
}
/*结果：
null正在购物!
张三正在购物!
null正在购物!
*/
class Customer {
String name;
public Customer(){}
public Customer(String name){
super();
this.name = name;
}
public void doSome(){
System.out.println(this.name + " do some!");
System.out.println(name + " do some!");
//错误: 找不到符号
//System.out.println(super.name + " do some!");
}
}
class Vip extends Customer{
// 假设子类也有一个同名属性
// java中允许在子类中出现和父类一样的同名变量/同名属性。
String name; // 实例变量
public Vip(){
}
public Vip(String name){
super(name);
// this.name = null;
}
public void shopping(){
/*
java是怎么来区分子类和父类的同名属性的？
this.name：当前对象的name属性
super.name：当前对象的父类型特征中的name属性。
*/
System.out.println(this.name + "正在购物!"); // null 正在购物
System.out.println(super.name + "正在购物!"); // 张三正在购物
System.out.println(name + "正在购物!"); //null 正在购物
}
}
【实例5】 如果想在子类中访问父中的数据，必须使用“super.”加以区分
/*
在父和子中有同名的属性，或者说有相同的方法，
如果此时想在子类中访问父中的数据，必须使用“super.”加以区分。
super.属性名 【访问父类的属性】
super.方法名(实参) 【访问父类的方法】
super(实参) 【调用父类的构造方法】
*/
public class SuperTest07{
public static void main(String[] args){
/*结果：
Cat move!
Cat move!
Animal move!
*/
Cat c = new Cat();
c.yiDong();
}
}
class Animal{
public void move(){
System.out.println("Animal move!");
}
}
class Cat extends Animal{
// 对move进行重写。
public void move(){
System.out.println("Cat move!");
}
// 单独编写一个子类特有的方法。
public void yiDong(){
this.move();
move();
// super. 不仅可以访问属性，也可以访问方法。
super.move();
}
}
【总结super关键字】：
super能出现在实例方法和构造方法中。
super的语法是：super. 和 super()
super不能使用在静态方法中。
super. 大部分情况下是可以省略的。
super.什么时候不能省略呢？
父类和子类中有同名属性，或者说有同样的方法，
想在子类中访问父类的，super. 不能省略。
super() 只能出现在构造方法第一行，通过当前的构造方法去调用“父类”中的构造方法，
目的是：创建子类对象的时候，先初始化父类型特征。
super的使用：
super.属性名 【访问父类的属性】
super.方法名(实参) 【访问父类的方法】
super(实参) 【调用父类的构造方法】
传送门
上一章：JavaSE 基础 - 第十三章 方法覆盖和多态
下一章：JavaSE 基础 - 【零基础（1-14章）总结】