2024年大数据最新JavaSE基础篇 super关键字_頎卷祬，你有过迷茫吗

2401_84185585

于 2024-05-13 22:38:47 发布

阅读量795

点赞数 24

分类专栏：程序员文章标签：大数据面试学习

本文链接：https://blog.csdn.net/2401_84185585/article/details/138822775

版权

程序员专栏收录该内容

112 篇文章 0 订阅

订阅专栏

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

public C(String name){
	this(name, 20);
	System.out.println("5");//4
}
public C(String name, int age){
	super(name);
	System.out.println("6");//3
}

}

// 运行结果：1 3 6 5 4



#### 🥅super(实参)的用法



> 
> **在恰当的时间使用：super(实际参数列表);**  
>    ⭐️注意：在构造方法执行过程中一连串调用了父类的构造方法，父类的构造方法又继续向下调用它的父类的构造方法，但是实际上对象只创建了一个！
> 
> 
>   ⭐️思考：“super(实参)”的作用？  
> **super(实参)的作用是**：**初始化当前对象的父类型特征，**并不是创建新对象；实际上对象只创建了1个。  
>    ⭐️super关键字代表什么？  
>          （1）super关键字代表的就是“当前对象”的那部分父类型特征！
> 
> 
>         （2）我继承了我父亲的一部分特征：  
>                  例如：眼睛、皮肤等；super代表的就是“眼睛、皮肤等”。  
>                 “眼睛、皮肤等”虽然是继承了父亲的，但这部分是在我身上呢。
> 
> 
>   ⭐️一个子类继承了父类：
> 
> 
> 对于父类中的私有属性不能直接访问，只能使用setter and getter方法。
> 
> 
> 在子类创建有参构造方法时，我们就可以使用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 extends Object{
// 属性
private String actno;
private double balance;

// 构造方法
public Account(){ //对于无参构造，默认会调用super()；并且给实列变量赋上缺省初始值
	//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){

	// 直接访问不行，继承过来的私有的属性，只能通过setter和getter方法进行访问
	/*
	this.actno = actno;
	this.balance = balance;
	*/

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


// 提供无参数的构造方法
public CreditAccount(){ //对于无参构造，默认会调用super()；并且给实列变量赋上缺省初始值

	//super();
	//this.credit = 0.0;
}

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

}


**⭐️内存图（重点掌握）**



> 
> 对于这个内存图，我们要先理解：
> 
> 
> （1）要创建CreditAccount对象，调用无参构造方法，默认有super()会调用它的父类Account；Account的无参构造又默认有super()会调用它的父类Object；
> 
> 
> （2）根据栈的特点：后进先出，先开辟Object空间、然后开辟Account空间并把里面的实例变量actno和balance进行初始化、最终才开辟CreditAccount对象的空间并把实例变量credit进行初始化；并且有this指向当前对象的地址；有super指向当前对象的父类特征！
> 
> 
> 


![](https://img-blog.csdnimg.cn/0a0ac9fb3b8c4d97ab6e47550198486d.png)



#### 🥅super.使用



> 
> ⭐️this表示当前对象。  
> ⭐️super表示的是当前对象的父类型特征（super是this指向的那个对象中的一块空间）
> 
> 
> ⭐️super和this都不能出现在静态方法中！
> 
> 
>

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


**⭐️内存图**



> 
> this实际上包含着super；this不能使用在static里，所以super更不能！
> 
> 
> 


![](https://img-blog.csdnimg.cn/1ef38f8b53f84b058ea57e1806685dcf.png)




#### 🥅super.什么时候不能省略(掌握)



> 
> ⭐️“this.”和“super.”大部分情况下都是可以省略的。  
>  ⭐️**this. 什么时候不能省略？** 
> 
> 
> 在区分局部变量和实例变量的时候不能省略    
> 
> 
> ⭐️**super. 什么时候不能省略**？  
>         java中允许在子类中出现和父类一样的同名变量/同名属性。  
>         父中有，子中又有，如果想在子中访问“父的特征”，super. 不能省略。
> 
> 
> **⭐️java是怎么来区分子类和父类的同名属性的？**  
>         this.name：当前对象的name属性  
>         super.name：当前对象的父类型特征中的name属性。
> 
> 
>

public class SuperTest05{
public static void main(String[] args){
Vip v = new Vip(“张三”);
v.shopping();
}
}

class Customer {
String name; //-----------------父类中也有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; //-----------------子类中也有name

public Vip(){
}
public Vip(String name){
	super(name); //给父类初始化了，子类并没有进行初始化是null
	// this.name = null;
    // this.name = name; 这样才是给子类进行属性的初始化
}
public void shopping(){
	
    //----默认访问的是当前对象的name；加super访问的是父类的name
	System.out.println(this.name + "正在购物!"); // null 正在购物
	System.out.println(super.name + "正在购物!"); // 张三正在购物
	System.out.println(name + "正在购物!"); //null 正在购物
}

}


 **⭐️内存图**


#### 



#### 🥅super使用时后面必须有一个.



> 
> ⭐️this输出“引用”的时候，会自动调用引用的toString()方法；而super使用后面必须跟一个.，但是super.不是引用，不会自动调用toString()方法！
> 
> 
> **⭐️super 不是引用，super也不保存内存地址，super也不指向任何对象。**  
>  ⭐️super 只是代表当前对象内部的那一块父类型的特征。
> 
> 
> ⭐️this和super都不能使用在static静态方法中。
> 
> 
>

public class SuperTest06 {

// 实例方法
public void doSome(){
	System.out.println(this);//实际上调用的是this.toString()方法
	// 输出“引用”的时候，会自动调用引用的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(实参)  【调用父类的构造方法】
> 
> 
>

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();//Cat move!---调用自己的
	move();//Cat move!---调用自己的
	// super. 不仅可以访问属性，也可以访问方法。
	super.move();//Animal move!---调用父类的
}

}


❤️**小结：super关键字**



> 
>   ⭐super能出现在实例方法和构造方法中。  
>    ⭐super的语法是：“super.”、“super()”  


![img](https://img-blog.csdnimg.cn/img_convert/928197ffa270c8a91fddd11f129189ef.png)
![img](https://img-blog.csdnimg.cn/img_convert/a46e301556fe05f5c27158e9ff6bce4b.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

}
}

❤️小结：super关键字

⭐super能出现在实例方法和构造方法中。
⭐super的语法是：“super.”、“super()”

[外链图片转存中…(img-Iy3YWDeR-1715611105168)]
[外链图片转存中…(img-XHX1QRA9-1715611105169)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_84185585

关注

24
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
2024年大数据最新JavaSE基础篇 super关键字_頎卷祬，你有过迷茫吗

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新需要这份系统化资料的朋友，可以戳这里获取}// 运行结果：1 3 6 5 4public class SuperTest03{public static void main(String[] args){}// 账户class Account ex
复制链接

扫一扫