Java基础13-super

L-FHy

于 2021-12-02 11:13:05 发布

阅读量111

点赞数

分类专栏： JavaSE 文章标签： java 开发语言 eclipse

本文链接：https://blog.csdn.net/weixin_43636084/article/details/121648452

版权

JavaSE 专栏收录该内容

32 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的super关键字的使用，包括在实例方法和构造方法中的应用，以及super关键字如何访问父类的属性和方法，调用父类构造器。强调了super在处理同名属性或方法时的作用，并通过实例展示了super的使用场景和规则。

摘要由CSDN通过智能技术生成

super

super总述

super能出现在实例方法和构造方法中。
super的语法是：“super.”、“super()”。
super不能使用在静态方法中。
super.大部分情况下是可以省略的。
super.什么时候不能省略呢？
- 在父和子中有同名的属性，或者说有同名的方法，如果此时想在子类中访问父类的数据，不能省略。
super()只能出现在构造方法第一行，通过当前构造方法去调用“父类”中的构造方法，目的是：创建子类对象的时候，先初始化父类型特征。
super的使用方法：
- super.属性【访问父类的属性】
- super.方法名(实参)【访问父类的方法】
- super(实参) 【调用父类的构造方法】

第一部分

/*
1、super是一个关键字，全部小写
2、super和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.方法名(实参)【访问父类的方法】
			super(实参) 【调用父类的构造方法】

3、super()
	表示通过子类的构造方法调用父类的构造方法。
	模拟现实世界中的这种场景：要想有儿子，需要先有父亲。
4、重要结论：
   当一个构造方法第一行：
        既没有this()又没有super()的话，默认会有一个super();
		表示通过当前子类的构造方法调用父类的无参数构造方法。
		所以必须保证父类的无参数构造方法是存在的。
5、注意：
	this()和super()不能共存，它们都是只能出现在构造方法第一行。

6、无论是怎样折腾，父类的构造方法是一定会执行的。（百分百）
		
		
*/

public class SuperTest01
{
	public static void main(String[] args){
		new B();
	}
}

class A extends Object
{
	//建议手动的将一个类的无参数构造方法写出来
	public A(){
		//super();
		System.out.println("A类的无参数构造方法！");
	}
	//一个类如果没有手动提供任何构造方法，系统会默认提供一个无参数构造方法。
	//一个类如果手动提供了一个构造方法，那么无参数构造系统将不再提供。
	public A(int i){
		//super();
		System.out.println("A类的有参数构造方法（int）！");
	}
}

class B extends A
{
	public B(){
		//super();

		//调用A类当中的有参数构造方法
		//super(100);

		this("zhangsan");
		System.out.println("B类的无参数构造方法！");
	}

	public B(String name){
		super();//默认第一行是super()
		System.out.println("B类的有参数构造方法(String)!");
	}
}

第二部分



/*
	在java语言当中，不管是new什么对象，最后老祖宗的Object类的无参数构造方法一定会执行的.
	Object类的无参数构造方法是处于"栈顶部"

	栈顶的特点：
		最后调用，但是最先执行结束。
		后进先出原则。

*/
public class SuperTest02
{
	public static void main(String[] args){
		new C();
		/*
		A的无参数构造执行
		B的有参数构造执行(String)
		C的有参数构造执行(String,int)
		C的有参数构造执行(String)
		C的无参数构造执行
		*/
	}
}

class A
{
	public A(){
		System.out.println("A的无参数构造执行");
	}
}

class B extends A
{
	public B(){
		System.out.println("B的无参数构造执行");
	}
	public B(String name){
		//super();
		System.out.println("B的有参数构造执行(String)");
	}
}

class C extends B
{
	public C(){
		this("zhangsan");
		System.out.println("C的无参数构造执行");
	}

	public C(String name){
		this(name,20);
		System.out.println("C的有参数构造执行(String)");
	}

	public C(String name,int age){
		super(name);
		System.out.println("C的有参数构造执行(String,int)");
	}
}

第三部分

/*
	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());
		CreditAccount ca2 = new CreditAccount("1111",9999.0,10.0);
		System.out.println(ca2.getActno() + "," + ca2.getBalance() + "," + ca2.getCredit());
	}
}

//账户类
class Account {
	
	private String actno;//账户
	private double balance;//余额
	
	public Account() {
		//以下系统默认
		//super();
		//this.actno = null;
		//this.balance = 0.0;
	}

	public Account(String actno, double balance) {
		this.actno = actno;
		this.balance = balance;
	}
	
	//setter and getter方法
	public String getActno() {
		return actno;
	}
	public void setActno(String actno) {
		this.actno = actno;
	}
	public double getBalance() {
		return balance;
	}
	public void setBalance(double balance) {
		this.balance = balance;
	}
	
}

//信用账户类
class CreditAccount extends Account{
	
	private double credit;//信誉度
	
	public CreditAccount() {
		//super();
		//this.credit = 0.0;
	}

	//提供有参数的构造方法
	//分析以下程序编译是否存在错误？？？？
	public CreditAccount(String actno,double balance,double credit){
		
		//私有的属性只能在本类中访问
		/*
		this.actno = actno;
		this.balance = balance;
		*/

		//以上两行代码在恰当的位置，正好可以使用：super(actno,balance)
		//通过子类的构造方法调用父类的构造方法
		super(actno,balance);
		this.credit = credit;
	}
	

	//setter() and getter()方法
	public double getCredit() {
		return credit;
	}

	public void setCredit(double credit) {
		this.credit = credit;
	}
	
	
}

在这里插入图片描述

第四部分

public class SuperTest04
{
	public static void main(String[] args){
		Vip v = new Vip("zhangsan");
		v.shopping();
	}
}

class Customer
{
	String name;

	public Customer(){
		
	}

	public Customer(String name){
		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 + "正在购物！");
		//name前面什么都没有的话，默认为引用.name，为this.name
		System.out.println(name + "正在购物！");
	}
}

在这里插入图片描述

第五部分


/*
	1、"this."和"super."大部分情况下都是可以省略的
	2、this.什么时候不能省略？
		public void setName(String name){
			this.name = name;
		}
	3、super.什么时候不能省略？
		如果父类和子类有同名属性/相同特征，并且想在子类中访问父类属性，super.不能省略。
*/

public class SuperTest05
{
	public static void main(String[] args){
		Vip v = new Vip("zhangsan");
		v.shopping();
	}
}

class Customer
{
	String name;

	public Customer(){
		
	}

	public Customer(String name){
		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;
	}
	
	/*
		java是怎么区分子类和父类的同名属性的？
			this.name：当前对象的name属性。
			super.name：当前对象的父类型特征中的name属性。
	*/
	public void shopping(){
		System.out.println(this.name + "正在购物！");//null正在购物
		System.out.println(super.name + "正在购物！");//zhangsan正在购物
		System.out.println(name + "正在购物！");//null正在购物
	}
}

第六部分

/*
	通过这个测试得出的结论：
		super 不是引用，super也不保存内存地址，super也不指向任何对象。
		super 只是代表当前对象内部的那一块父类型的特征。
*/

public class SuperTest06
{
	//实例方法
	public void doSome(){
		//SuperTest06@15db9742
		System.out.println(this);
		//输出"引用"的时候，会自动调用引用的toString()方法
		//System.out.println(this.toString());

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

	//this和super不能用在静态方法中
	/*
	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();

		//this和super不能用在静态方法中
		//System.out.println(this);
		//System.out.println(super.xxx);
	}
}

第七部分

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

	super的使用方法：
		super.属性 【访问父类的属性】
		super.方法名(实参)【访问父类的方法】
		super(实参) 【调用父类的构造方法】
*/

public class SuperTest07
{
	public static void main(String[] args){
		Cat c = new Cat();
		c.yiDong();
		//如果注释Cat对象中的move()方法，三个运行结果：都是Animal move!
	}
}

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();//Cat move!
		move();//Cat move!
		//super.不仅可以访问属性，还可以访问方法
		super.move();//Animal move!
	


	}
}