Java基础super关键字详解

た入场券 2023-10-08 05:01 53阅读 0赞

#### 文章目录 ####

*   *  —：super概述:
     *   *  示例代码01：
         *   *  运行结果：
     *  二：super的子类构造方法执行时必然调用父类构造方法
     *   *  示例代码02：
         *   *  运行结果：
     *  三：super实参的用法
     *   *  示例代码03：
         *   *  运行结果：
             *  内存分析图一：
         *  示例代码04：
         *   *  运行结果：
             *   *  内存分析图二：
                 *  内存分析图三：
     *  四：super什么时候不能省略
     *   *  示例代码05:
         *   *  运行结果：
     *  五：super使用后后面必须有个点
     *   *  示例代码06：
         *   *  运行结果：
     *  六：使用super调用父类方法
     *   *  示例代码07：
         *   *  运行结果：

### —：super概述: ###

**1.super能出现在实例方法和构造方法中。**

*  super的语法是：“super.”,“super()”
 *  super不能使用在静态方法中
 *  super. 大部分情况下是可以省略的

**2.super();**

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

**2.重要结论：**

当一个构造方法第一行：

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

**3.注意**

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

#### 示例代码01： ####

public class SuperTest01{
        
    	
    	public static void main(String[] args){
        
    		  new B();
    	}
    }
    
    class A{
        
    	
    	//建议手动的将一个类的无参数构造方法写出来
    	public A(){
        
    		System.out.println("A类的无参构造方法！");
    	}
    	
    	//一个类中如果没有手动提供任何构造方法，系统会默认提供一个无参数构造方法
    	//一个类如果手动提供了一个构造方法，那么无参数构造系统将不再提供
    	public A(int n){
        
    		System.out.println("A类的有参构造方法！(int n)");
    	}
    	
    }
    
    class B extends A{
        
    	
    	/* public B(){
    		super(123);
    		System.out.println("B类的无参数构造方法");
    	} */
    	
    	public B(){
        
    		super();//调用父类中有参数的构造方法
    		//super(100);
    		this("zhangsan");
    		System.out.println("B类的无参构造方法！");
    	}
    	
    	public B(String name){
        
    		super(100);
    		System.out.println("B类的有参构造方法！(String name)");
    	}
    }

##### 运行结果： #####

![SuperTest01][]

### 二：super的子类构造方法执行时必然调用父类构造方法 ###

> 在java语言中不管是new什么对象，最后老祖宗的Object类的无参数构造方法

#### 示例代码02： ####

public class SuperTest02{
        
    	
    	public static void main(String[] args){
        
    		new C();
    	}
    }
    
    //老祖宗
    /* class Object(){
    	public Object(){
    		
    	}
    } */
    
    class A{
        
    	
    	public A(){
        
    		System.out.println(1);
    	}
    }
    
    class B extends A{
        
    	
    	public B(){
        
    		this("zhangsan");
    	  System.out.println(2);
    	}
    	
    	public B(String name){
        
    		System.out.println(3);
    	}
    }
    
    class C extends B{
        
    	
        public C(){
        
    		this("lisi");
    		System.out.println(4);
    	}
    	
    	public C(String name){
        
    		this("lisi",5);
    		System.out.println(5);
    	}
    	
    	public C(String name,int a){
        
    		super(name);
    		System.out.println(6);
    	}
    }

##### 运行结果： #####

![在这里插入图片描述][34ceceb6c8fa49ffad886725d52ef8cb.png_pic_center]

### 三：super实参的用法 ###

**1、举个例子：在恰当的时间使用：super(实际参数列表);**

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

**3、思考：“super(实参)”到底是干啥的？**

*  super(实参)的作用是：初始化当前对象的父类型特征。
 *  并不是创建新对象。实际上对象只创建了1个。

**4、super关键字代表什么呀？**

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

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

#### 示例代码03： ####

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("123456",500000.0,"123556");
    		System.out.println(ca2.getActno() + " " + ca2.getBalance() + " " + ca2.getCredit() + " ");
    	}
    }
    
    class Account{
        
        
    	private String actno;
    	private double balance;
    	
    	public Account(){
        
    		
    	}
    	
    	public Account(String actno,double balance){
        
    		this.actno = actno;
    		this.balance = balance;
    	}
    
    	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 String credit;
    	
    	public CreditAccount(){
        
    		
    	}
    	
    	//提供有参数的构造方法
    	public CreditAccount(String actno,double balance,String credit){
        
    		//私有的属性，只能在本类中访问
    		/* this.actno = actno;
    		this.balance = balance; */
    		
    		//以上两行代码在恰当的位置，正好可以使用：super(actno,balance);
    		//通过子类的构造方法调用父类的构造方法
    		super(actno,balance);
    		this.credit = credit;
    	}
    	
        public String getCredit() {
        
    		return credit;
    	}
    
    	public void setCredit(String credit) {
        
    		this.credit = credit;
    	}
         
        public CreditAccount(String credit){
        
        	this.credit = credit;
        }
    }

##### 运行结果： #####

![在这里插入图片描述][dc83dc41f624409987f1278cd04c4f72.png_pic_center]

##### 内存分析图一： #####

![在这里插入图片描述][65ce30207e81478991be583b4ff35caa.png_pic_center]

#### 示例代码04： ####

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;
    	}
    	
    	public String getName(){
        
    		return name;
    	}
    	
    	public void SetName(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 + "在购物！");
    		System.out.println(name + "在购物！");
    	}
    }

##### 运行结果： #####

![在这里插入图片描述][d1fe46ffb9e44c769a98078028b656ff.png_pic_center]

###### 内存分析图二： ######

![在这里插入图片描述][7985f42c3b8a4cc6992212430523ee6b.png_pic_center]

###### 内存分析图三： ######

![在这里插入图片描述][484f83490ec640efa45e81a56a4da426.png_pic_center]

### 四：super什么时候不能省略 ###

**1."this."和“super.”大部分情况下都是可以省略的**

**2.this.什么时候不能省略？**

public void setName(String name){
        
      	  this.name = name;
        }

**3.super.什么时候不能省略？**

*  父中有，子中又有，如果想在子中访问“父的特征”，super.不能省略

#### 示例代码05: ####

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 String getName(){
        
    		return name;
    	}
    	
    	public void SetName(String name){
        
    		this.name = name;
    	}
    	
    	public void doSome(){
        
    		System.out.println(this.name + "在购物！");	//张三在购物
    		System.out.println(name + "在购物！");//张三在购物
    		//super表示的是当前对象的父类型特征。(super是this指向的那个对象中的一块空间)
    		// System.out.println(super.name + "在购物！");//编译报错：找不到符号
    	
    	}
    }
    
    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 + "在购物！");//张三在购物
    		System.out.println(name + "在购物！");//null在购物
    	}
    }

##### 运行结果： #####

![在这里插入图片描述][4d410e3408fd4c0694d643b562d7f13d.png_pic_center]

### 五：super使用后后面必须有个点 ###

> super 不是引用。super也不保存内存地址，super也不指向任何对象  
> super 只是代表当前对象内部的那一块父类型的特征。

#### 示例代码06： ####

public class SuperTest06{
        
    	
        //实例方法
    	public void doSome(){
        
    		//输出“引用.”的时候，会自动调用引用的toString()方法
    		System.out.println(this.toString());
    		//SuperTest06@15db9742
    		System.out.println(this);
    		// System.out.println(super);//编译错误：需要“.”
    	}
    	
    	//this和super不能使用在static静态方法中
    	/* public Static void doOther(){
    		System.out.println(this);
    		System.out.println(super);
    	}
    	 */
    	 //静态方法 主方法
    	public static void main(String[] args){
        
    		
    		SuperTest06 st = new SuperTest06();
    		st.doSome();
    	}
    
    }

##### 运行结果： #####

![在这里插入图片描述][d606a0bebd584bd7bb046fff1d4284b2.png_pic_center]

### 六：使用super调用父类方法 ###

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

①super.属性名 【访问父类中的属性】  
②super.方法名(实参) 【访问父类的方法】  
③super(实参) 【调用父类的构造方法】

#### 示例代码07： ####

public class SuperTest07{
        
    	
    	public static void main(String[] args){
        
    		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();
    	}
    
    }

##### 运行结果： #####

![在这里插入图片描述][61119b958e604dcd942535461e1888ab.png_pic_center]

[SuperTest01]: https://img-blog.csdnimg.cn/6467ef6daf7f4a878fccdf46a3778ad7.png#pic_center
[34ceceb6c8fa49ffad886725d52ef8cb.png_pic_center]: https://img-blog.csdnimg.cn/34ceceb6c8fa49ffad886725d52ef8cb.png#pic_center
[dc83dc41f624409987f1278cd04c4f72.png_pic_center]: https://img-blog.csdnimg.cn/dc83dc41f624409987f1278cd04c4f72.png#pic_center
[65ce30207e81478991be583b4ff35caa.png_pic_center]: https://img-blog.csdnimg.cn/65ce30207e81478991be583b4ff35caa.png#pic_center
[d1fe46ffb9e44c769a98078028b656ff.png_pic_center]: https://img-blog.csdnimg.cn/d1fe46ffb9e44c769a98078028b656ff.png#pic_center
[7985f42c3b8a4cc6992212430523ee6b.png_pic_center]: https://img-blog.csdnimg.cn/7985f42c3b8a4cc6992212430523ee6b.png#pic_center
[484f83490ec640efa45e81a56a4da426.png_pic_center]: https://img-blog.csdnimg.cn/484f83490ec640efa45e81a56a4da426.png#pic_center
[4d410e3408fd4c0694d643b562d7f13d.png_pic_center]: https://img-blog.csdnimg.cn/4d410e3408fd4c0694d643b562d7f13d.png#pic_center
[d606a0bebd584bd7bb046fff1d4284b2.png_pic_center]: https://img-blog.csdnimg.cn/d606a0bebd584bd7bb046fff1d4284b2.png#pic_center
[61119b958e604dcd942535461e1888ab.png_pic_center]: https://img-blog.csdnimg.cn/61119b958e604dcd942535461e1888ab.png#pic_center