Java进阶——super关键字

最新推荐文章于 2021-07-20 15:45:40 发布
最新推荐文章于 2021-07-20 15:45:40 发布
阅读量308 收藏 1
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42588990/article/details/109706032
版权

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只能出现在构造方法第一行，通过当前的构造方法去调用”父类“中的构造方法，目的是：创建子类对象的时候，先初始化父类型特征。

3 super（）
表示通过子类的构造方法调用父类的构造方法
模拟现实世界中这种场景，想要有儿子，需要先有父亲

4 重要的结论：
当一个构造方法第一行：
既没有this()又没有super()的话，默认会有一个super();
表示通过当前子类的构造方法调用父类的无参数构造方法
所以必须保证父类的无参数构造方法是存在的

5 注意：
this()和super()不能共存，它们都是只能出现在构造方法的第一行

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

public class SuperTest01{
	public static void main(String[] args){
		// 创建子类对象
		/*
			A类的无参数构造方法！
			B类的无参数构造方法！
		*/
		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();
		System.out.println("B类的无参数构造方法！");
	}
	*/

	public B(){
		this("zhangsan");
		// 调用父类中有参数的构造方法
		//super(123);
		System.out.println("B类的无参数构造方法！");
	}

	public B(String name){
		super();
		System.out.println("B类的有参数构造方法(String)");
	}
}

判断程序的输出结果
1
3
6
5
4
在java语言中不管是new什么对象，最后老祖宗的Object类的无参构造方法一定会执行。（Object类的的无参数构造方法是处于”栈顶部“）

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

大家要注意：
以后写代码的时候，一个类的无参数构造方法还是建议大家手动的写出来
如果无参数构造方法丢失的话，可能会影响到”子类对象的构建“

	public static void main(String[] args){
		new C();

	}
}

/*
class Object{
	public Object(){	
	}
}
*/

class A extends Object{
	public A(){
		System.out.println("1"); //1
	}
}

class B extends A{
	public B(){
		System.out.println("2"); //2
	}
	public B(String name){
		super();
		System.out.println("3"); // 3
	}
}

class C extends B{
	public C(){ // 这个是最先调用的。但是最后结束。
		this("zhangsan");
		System.out.println("4");//4
	}
	public C(String name){
		this(name, 20);
		System.out.println("5");//5
	}
	public C(String name, int age){
		super(name);
		System.out.println("6");//6
	}
}

  • 举个栗子：在恰当的时间使用：super（实际参数列表）;

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

  • 思考：”super(实参)“到底是干啥的？
    super（实参）的作用是：初始化当前对象的父类型特证
    并不是创建对象，实际上对象只创建了1个

  • 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", 10000.0, 0.999);
		System.out.println(ca2.getActno() + "," + ca2.getBalance() + "," + ca2.getCredit());

	}
}

// 账户
class Account extends Object{
	// 属性
	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;
	}
	
}

super的原理
在这里插入图片描述

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 + "正在购物!");
	}
}

super关键字的理解
在这里插入图片描述

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("张三");
		v.shopping();
	}
}
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 正在购物
	}
}

superTest05内存图
在这里插入图片描述

通过以下这个测试得出结论：

super不是引用。super也不不保存内存地址，super也不指向任何对象

super只是代表当前内部的那一块父类型的特征

public class SuperTest06 {

	// 实例方法
	public void doSome(){
		// SuperTest06@2f92e0f4
		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();

		// main方法是静态的
		// 错误的。
		/*
		System.out.println(this);
		System.out.println(super.xxxx);
		*/
	}
}

在父和子中有同名的属性，或者说有相同的方法

如果此时想在子类中访问父中的数据，必须使用”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()是干啥的：是通过子类的构造方法调用父类的构造方法。

下一篇：final

脑袋不灵光的小白羊
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
115个Java面试题和答案——终极（下）(1).rar
07-16
- **继承**：单继承和多层继承的概念，以及super关键字的使用。 - **多态**：包括方法重写（Override）和方法重载（Overload），以及动态绑定的原理。 - **接口**：接口的作用、实现方式，以及接口与抽象类的区别...
传至播客JAVA
04-29
这部分会讲解单继承与多层继承，super关键字的使用，以及方法覆盖和方法隐藏的概念。 9. **GUI**：Java提供了丰富的图形用户界面（GUI）组件库Swing和JavaFX，可以帮助开发者创建桌面应用。这部分会介绍窗口组件...
java基础学习总结——super关键字
weixin_33908217的博客
04-01 157
一、super关键字 　　 　　在JAVA类中使用super来引用父类的成分，用this来引用当前对象，如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。怎么去引用里面的父类对象呢？使用super来引用，this指的是当前对象的引用，super是当前对象里面的父对象的引用。 1.1.super关键字测试 1 package cn.gal...
super 关键字
小草莓的博客
07-20 278
super和this很类似，可以对比着学习 1、先复习一下this关键字的使用 this指向的是当前对象自己 this能出现在实例方法和构造方法中； this的语法是“this.”和“this()”； this不能出现在静态方法中； this大部分情况下是可以省略的； this.什么时候不能省略呢？ 在区分局部变量和实例变量时不能省略 this()只能出现在构造方法的第一行，通过当前的构造方法去调用“本类”中的对应的构造方法，目的是：代码复用。 Public void setName(String n
super关键字
chen404897439的博客
06-09 278
在成员方法中调用成员变量规则： 局部变量：直接写变量名 成员变量：this.变量名 父类变量：super.变量名 参考子类line 8 -10 父类程序： package cn.dali.code14; public class Fulei { int num = 1; public void Fu(){ System.out.println(""); }...
Programmation_Orientée_Objet_Java_2020-2021_java_Java_OOP_
10-02
理解super关键字的使用，以及重写父类方法（Override）。 7. **多态**：学习多态的概念，包括向上转型和向下转型，以及抽象类和接口在实现多态中的应用。 8. **集合框架**：介绍ArrayList, LinkedList, HashSet, ...
[网盘]java程序员由菜鸟到笨鸟.pdf
03-20
3. **继承性**：介绍继承的概念及其在Java中的应用，包括super关键字的用法。 4. **多态性**：探讨多态性的含义以及接口和抽象类的使用。 5. **异常处理**：学习如何通过try-catch-finally语句块处理程序运行时可能...
JNI_HelloWorld.rar_android开发_Java_
08-11
在Java类中，我们需要使用`native`关键字声明将要实现的JNI函数。例如： ```java public class HelloWorld { static { System.loadLibrary("hello-world"); // 加载动态链接库 } public native void sayHello...
Super关键字
weixin_55782195的博客
03-05 7540
Super关键字的使用 1. Super关键字 1.1 super可以理解为父类的，super可以用来调用属性、方法、构造器 2. Super关键字的使用 2.1 我们可以在子类的方法或构造器中，通过使用“super.属性”或“super.方法”的方式，显示调用父类中声明的属性和方法，但通常情况下，我们习惯省略super 2.2 特殊情况： （1） 当父类与子类定义了同名属性时，我们想调用父类生命的属性时，则必须显示使用“super.属性”的方式，表明调用的是父类中声明的属性 （2）当子类重写了父类的方法
super关键字详解
淮宁湾的博客
01-26 4104
super关键字详解 由于子类不能继承父类的构造方法，因此，如果要调用父类的构造方法，可以使用super关键字。 super可以用来访问父类的构造方法，普通方法和属性。 super关键字的功能： 在子类的构造方法中显式的调用父类构造方法 访问父类的成员方法和变量。 super调用父类构造方法 super关键字可以在子类中的构造方法中显示地调用父类的构造方法，基本格式如下： super(argument-list); 其中，argument-list指父类构造方法中的参数列表。super()必须是在子类
Super关键字详解
子冉冰清的博客
10-30 5846
super关键字的用法如下： super可以用来引用直接父类的实例变量。 super可以用来调用直接父类方法。 super()可以用于调用直接父类构造函数 1.super用于引用直接父类实例变量 可以使用super关键字来访问父类的数据成员或字段。 如果父类和子类具有相同的字段，则使用super来指定为父类数据成员或字段。 Animal和Dog都有一个共同的属性：color。 如果我们打印color属性，它将默认打印当前类的颜色。 要访问父属性，需要使用super关键字指定 class An
Java基础——super关键字
Joshua Lee的博客
09-22 3572
super关键字的概念 super不是引用类型，存储的不是内存地址，指向不是父类对象 super代表的市当前子类对象中的父类型特征 super什么时候用？ 子类和父类都有某个数据 在子类中访问父类属性时 super可以用在什么地方？ 可以用在成员方法中，不能用在静态方法中 可以用在构造方法中 super();用在构造方法中        语法：super(实参); 如果第一行没有s...
super 关键字详解
明月燃雨
10-07 1286
super 关键字主要有三个作用： 从子类访问父类的成员变量 从子类访问父类的成员方法 从子类构造器访问父类的构造器 下面我将从这三个方面做一些细节说明和注意事项。 从子类访问父类的成员变量 使用 super 关键字从子类访问父类的成员变量我们需要注意以下两点： 需要遵循访问修饰符的限制。如下图所示，父类的私有变量子类是无法访问到的，其他类型的变量也都有一定的作用域。 super 关键字无法访问父类的静态成员变量。 从子类访问父类的成员方法 使用 super 关键字从子类访问父类的成员方法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值