java基础-super(实参)的用法-子类调用父类的构造方法

super的用法

• 一.使用super进行子类调用父类的构造方法
• 二.子类中出现和父类一样的同名变量/同名属性
• 三.super使用的时候后面必须需要有个点"."
• 总结

一.使用super进行子类调用父类的构造方法

1.1案例一

/*
	1.举个例子:在恰当的时间使用:super(实际参数列表)
	
	2.注意:虽然调用构造方法,在构造方法执行过程中一连串调用了父类的构造方法,
父类的构造方法又继续向下调用它的父类的构造方法,但是实际上对象只创建了一个

	3.思考:super()到底是干啥的?
	super(实参)的作用是:初始化当前对象的父类型特征.
	并不是创建新对象。实际上对象只创建了1个。
	
	4.super关键字代表的是什么？
	super关键字代表的就是“当前对象”的那部分父类型特征。
	
	我继承了我父亲的一部分特征：
		例如：眼睛，皮肤等
		super代表的就是眼睛，皮肤等
		"眼睛","皮肤等"虽然是继承了父亲的,但是这部分是在我身上的
*/
//测试程序
public class SuperTest03{
	public static void main(String[] args){
		CreditAccount c = new CreditAccount();
		System.out.println(c.getActno() +  "," +c.getBalance() + "," +c.getCredit());
		CreditAccount c1 = new CreditAccount("11",22,33);
		System.out.println(c1.getActno() +  "," +c1.getBalance() + "," +c1.getCredit());
	}
}

//账户
class Account{
	private String actno;
	private double balance;
	
	//构造方法
	public Account(){

	}
	public Account(String actno,double balance){
		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);
		//通过子类的构造方法调用父类的构造方法
		 //方法一
		// this.setActno(actno);
		// this.setBalance(balance);
		 //方法二
		super(actno,balance);
		this.credit = credit;
		System.out.println("123");
	}

	//提供有参构造方法
	public CreditAccount(){

	}

	//setter and getter方法
	public void setCredit(double credit){
		this.credit = credit;
	}
	public double getCredit(){
		return credit;
	}
}

输出结果:

1.2内存图描述super

2.注意:虽然调用构造方法,在构造方法执行过程中一连串调用了父类的构造方法,
父类的构造方法又继续向下调用它的父类的构造方法,但是实际上对象只创建了一个

3.思考:super()到底是干啥的?
super(实参)的作用是:初始化当前对象的父类型特征.
并不是创建新对象。实际上对象只创建了1个。

4.super关键字代表的是什么？
super关键字代表的就是“当前对象”的那部分父类型特征。

我继承了我父亲的一部分特征：
	例如：眼睛，皮肤等
	super代表的就是眼睛，皮肤等
	"眼睛","皮肤等"虽然是继承了父亲的,但是这部分是在我身上的

2.1案例二

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){
		this.name = name;
	}
}
class Vip extends Customer{
	public Vip(){}
	public Vip shopping(String name){
		super(name);
	}
	public void shopping(){
		System.out.println(this.name + "正在购物!");
		System.out.println(super.name + "正在购物!");
		System.out.println(name + "正在购物!");
	}
}

输出结果:

2.2内存图描述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();
	}
}

二.子类中出现和父类一样的同名变量/同名属性

案例

/*
	1."this"和"super"大部分情况下是可以省略的
	2.什么时候不能省略?
		public void setName(String name){
			this.name = name;
		}
	3.super. 什么时候不能省略?
		父中有(的属性),子中又有,如果想在子中访问父的特征,super.不能省略
*/
public class SuperTest05{
	public static void main(String[] args){
		Vip v = new Vip("张三");
		v.shopping();
		v.doSome();
	}
}

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!");
		//错误:找不到符号(Object类里没有name属性)
		// 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;
	}
	//super和this都不能出现在静态方法中
	public void shopping(){
		//this表示当前对象
		System.out.println(this.name + "正在购物!"); //null 正在购物
		//super表示的是当前对象的父类型特征(super是this指向的那个对象中的一块空间)
		System.out.println(super.name + "正在购物!");//张三 正在购物
		//属性name前什么也不加,默认回调用"引用.属性"
		System.out.println(name + "正在购物!");//null 正在购物
	}
}

打印结果:

内存图分析

三.super使用的时候后面必须需要有个点"."

案例

/*
	在父和子中有同名的属性,或者说有相同的方法,
	如果此时想在子类中访问父中的数据,必须使用"super"加以区分

	super.属性名 【访问父类的属性】
	super.方法名(实参) 【访问父类的方法】
	super(实参) 【调用父类的构造方法】
*/
public class SuperTest06{
	
	//实例方法
	public void doSome(){
		//SuperTest06@1db9742
		System.out.println(this);
		//输出引用的时候,会自动调用引用的toString方法
		// System.out.println(this.toString());

		//编译错误:需要'.'
		//System.out.println(super);
	}

	//this和super不能使用在static静态方法中
	/*
		public static void doOther(){
			System.out.println(this);
			System.out.println(super.xxx);
		}
	*/
	//静态方法,主方法
	public static void main(String[] args){
		SuperTest06 st = new SuperTest06();
		st.doSome();
	}
}

总结

super关键字

• super能出现在实例方法和构造方法中

• super的语法是:“super.”、“super()”

• super不能使用在静态方法中

• super. 大部分情况下是可以省略的

• super. 什么时候不能省略呢?
  -父类和子类中有同名属性,或者说有同样的方法
  想在子类中访问父类的,super. 不能省略。

• super() 只能出现在构造方法第一行,通过当前的构造方法去调用"父类"中的构造方法,目的是:创建子类对象的时候,先初始化父类型特征

• super的使用:

  • super. 属性名 [访问父类的属性]
  • super() 属性名 [访问父类的方法]
  • super(实参) 属性名 [调用父类的构造方法]

本文地址：https://blog.csdn.net/qq_36697196/article/details/109843800