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

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

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

5、注意:
this()和super()不能共存，它们都是只能出现在构造方法第一行。
6、super不仅可以访问属性还可以访问方法

1、分析以下代码：

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

class A
{
	// 构造方法
	public A(){
		System.out.println("A类的无参数构造方法开始执行");
	}
}

class B extends A
{	
	// 构造方法
	public B(){
        // super(); 
		System.out.println("B类的无参数构造方法开始执行");
	}
}

思考：构造方法不能被继承 但为什么调用子类B的时候还能输出父类A的A()方法呢？

原因子类B()的无参数构造方法中实际默认有super();来进行调用父类的无参数构造方法方法

2、 

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

class A
{
	
		// 一个类如果没有手动提供任何构造方法,那么系统就会默认提供一个无参数构造方法[默认结果null]
	
}

class B extends A
{	
	// 构造方法
	public B(){
		super(); //同样默认调用父类的无参数构造方法
		System.out.println("B类的无参数构造方法开始执行");
	}
}

 3、

public class SuperTest01
{
	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();
		System.out.println("B类的无参数构造方法开始执行");
	}
}

 思考：为什么运行结果报错呢？[因为父类A当中是有参数构造方法]

要想不报错就需要进行代码修改如下:

public class SuperTest01
{
	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(123);
		System.out.println("B类的无参数构造方法开始执行");
	}
}

 

4、

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

class A
{
	// 构造方法
	// 有参数构造方法
	public A(int i){
		System.out.println("A类的有参数构造方法开始执行");
	}
	public A(){
		System.out.println("A类的无参数构造方法开始执行");
	}
	
}

class B extends A
{	
	// 构造方法
	public B(){
		// 当super();括号里面添加int参数 表示调用了父类的有参数构造方法
		super(123);
		System.out.println("B类的无参数构造方法开始执行");
	}
}

 5、

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

class A
{
	// 构造方法
	// 有参数构造方法
	public A(int i){
		System.out.println("A类的有参数构造方法开始执行");
	}
	public A(){
		// super(); 这里也是默认有一行super();代码的 只不过调用的是object类的无参数构造方法
		System.out.println("A类的无参数构造方法开始执行");
	}
	
}

class B extends A
{	
	// 构造方法
	public B(){
		this("junker");
		System.out.println("B类的无参数构造方法开始执行");
	}
	// 有参数构造方法
	public B(String b){
		// 默认的有一个super(); 
		// this("junker"); 先进入B的有参数构造方法中 然后其实默认有super();即先执行A的无参数构造 然后执行B的有参数构造方法 最后执行B的无参数构造方法
		
		System.out.println("B的有参数构造方法开始执行");
	}
}

一、super(实参)的用法

// 程序测试
public class SuperTest02
{
	public static void main(String[] args){
		CreditAccount c1 =new CreditAccount();
		System.out.println(c1.getActno());
		System.out.println(c1.getActno()+","+c1.getBalance()+","+c1.getCredit());

		CreditAccount c2 =new CreditAccount("junker",1000.0,0.999);
		System.out.println(c2.getActno()+","+c2.getBalance()+","+c2.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 double credit;

	// 构造方法
	public CreditAccount(){
		// 默认有一个无参数super();去调用父类的无参数构造方法进行初始化属性
	}
	public CreditAccount(String actno,double balance,double credit){
		/*
		// 此处能继承父类的私有属性 但是不能访问父类的私有属性 私有属性只能在本类访问
		this.actno =actno;
		this.balance =balance;
		this.credit =credit;
		*/
	// super();构造方法构造完成后第一行默认有一个super();去调用父类的无参构造方法 将父类的属性初始化即actno =null
		// 所以我们想访问父类的有参构造方法代码如下：
		super(actno,balance); //调用有参构造方法然后进行修改读取属性
		this.credit =credit;
	}
	// 关卡
	public double getCredit(){
		return credit;
	}
	public void setCredit(double credit){
		this.credit =credit;
	}
}

代码结果：

 二、内存图描述代码执行原理

object先执行

三、代码执行内存图

public class SuperTest03
{
	public static void main(String[] args){
		Vip v =new Vip("junker");
		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+"正在购物");
		System.out.println(name+"正在购物");
		
	}
}

 

 

 四、super()什么时候不能省略

 父中有,子中也有,如果想在子中访问"父的特征(属性)",super不能省略

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

class Customer
{
	String name;
	public Customer(){}
	public Customer(String name){
		this.name =name;
	}
}

class Vip extends Customer
{    
    // 假如子类中也有一个同名的属性
	String name;

	public Vip(){}
	public Vip(String name){
		super(name);
		// 默认 this.name =null;
	}
	
	// super和this不能出现在静态方法中
	public void shopping(){
		/*
			 java是怎么来区分子类和父类的同名属性？
			 this.name: 当前对象的name属性
			 super.name: 当前对象的父类特征属性
		*/
		
		System.out.println(this.name+"正在购物");
		System.out.println(super.name+"正在购物");
		System.out.println(name+"正在购物");
		
	}
}

执行内存图：