最新JavaSE基础篇 super关键字_頎卷祬(2)，2024年最新为什么大数据开发能最好地改变大数据开发

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

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

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

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

🥅super初步理解

❤️例1：父类和子类都是无参构造

一个子类继承父类，要想创建子类对象，会通过super关键字先默认创建父类对象（通过无参数构造方法）。

public class Test01{
	public static void main(String[] args){
		//根据无参构造方法创建对象，肯定会调用无参构造方法！
        //只要对象创建出来就会调用构造方法，并且先调用父类的构造方法，在调用子类的构造方法
		new B(); 
	}
}

class A{
	public A(){ //无参构造方法
		System.out.println("调用A的无参构造方法！");
	}
}
class B extends A{
	public B(){ //无参构造方法
		//super();//默认这里有一个super()通过子类调用父类的无参构造方法；可省略！
		System.out.println("调用B的无参构造方法！");
	}
}
//结果：我们只创建B对象；结果确实先调用A类的构造方法，才调用B类的构造方法
/*
	调用A的无参构造方法！
	调用B的无参构造方法！
*/

❤️例2：父类是有参构造、子类是无参构造

对父类是有参构造、子类是无参构造；要想子类调用父类的构造方法，必须写上super关键字，并带上对应参数；这样才会调用父类的有参构造方法！

public class Test01{
	public static void main(String[] args){
		//根据无参构造方法创建对象，肯定会调用无参构造方法！
		new B();
	}
}

class A{
	// 一个类如果没有手动提供任何构造方法，系统会默认提供一个无参数构造方法。
	// 一个类如果手动提供了一个构造方法，那么无参数构造系统将不再提供。
	public A(int i){ //有参构造方法
		System.out.println("调用A的有参构造方法！");
	}
}
class B extends A{
	public B(){ //无参构造方法
		// 父类是有参构造方法，此时默认是是super()就会有问题，
        // 因为super()只能调用父类无参的无参构造方法
		// 所以此时的super就不能省略；并且写上时要写上参数，
       //  调用父类的有参构造方法，例如：super(100)
		super(100);
		System.out.println("调用B的无参构造方法！");
	}
}
//结果：我们只创建B对象；结果确实先调用A类的构造方法，才调用B类的构造方法
/*
	调用A的有参构造方法！
	调用B的无参构造方法！
*/

❤️例3：this()和super()不能共存(重点理解)

对于一个类的有参构造方法和无参构造方法，默认都会有一个super()去调用父类的无参构造；有父才有子！

public class Test01{
	public static void main(String[] args){
		//根据无参构造方法创建对象，肯定会调用无参构造方法！
		new B();
	}
}

class A{ //默认继承Object类，class A extends Object
	// 建议手动的将一个类的无参数构造方法写出来。
	public A(){ //无参构造方法
		//这里也默认有super()，调用的是Object的无参构造方法
		System.out.println("调用A的无参构造方法！");
	}
	public A(int i){ //有参构造方法
		//这里也默认有super()，调用的是Object的无参构造方法
		System.out.println("调用A的有参构造方法！");
	}
}
class B extends A{
	public B(){ //无参构造方法
        //通过this去调用B的有参构造方法；而B的有参构造方法默认也有super()!
		this("张三"); 
		System.out.println("调用B的无参构造方法！");
	}
	public B(String name){ //有参构造方法
		//默认也有super()，去调用A的无参构造
		System.out.println("调用B的有参构造方法！");
	}
}
//最终结果
/*
调用A的无参构造方法！
调用B的有参构造方法！
调用B的无参构造方法！
*/

❤️例4：套娃例题理解

⭐️在java语言中不管是是new什么对象，最后老祖宗的Object类的无参数构造方法一定会执行（Object类的无参数构造方法是处于“栈顶部”）

⭐️栈顶的特点：最后调用，但是最先执行结束；后进先出原则。
⭐️注意：以后写代码的时候，一个类的无参数构造方法还是建议手动的写出来。如果无参数构造方法丢失的话，可能会影响到“子类对象的构建”。

⭐️压栈弹栈的过程：最先进去的方法会压到栈底部，最后出来；最后进去的会被压栈到最顶部，最先出来；并且因为super()关键字的原因，最终父类一定是栈的顶部，最先出来。

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

	}
}
//----------对于父类A实际上也会调用老祖宗Object类的无参构造
/*
class Object{
	public Object(){	
	}
}
*/

class A { //class A extends Object
	public A(){ //-------最后调用的；最先结束！
		System.out.println("1"); //1
	}
}

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

class C extends B{
	public C(){ // -------最先调用的；最后结束！
		this("zhangsan");
		System.out.println("4");//5
	}
	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指向当前对象的父类特征！

🥅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更不能！

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

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

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

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

[外链图片转存中…(img-TfK07vCo-1715496591048)]
[外链图片转存中…(img-SbMdhCSc-1715496591048)]
[外链图片转存中…(img-kHq7JIa4-1715496591048)]

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

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

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