super 关键字

super关键字

super()

1. 如果一个类没有提供任何构造方法，则系统默认提供一个无参数的构造方法，其中方法体内是空语句
   如果一个类提供了构造方法，则系统就不提供一个默认的无参数的构造方法
2. 当构造方法的第一行， this()和super()都没有，会默认有一个super()，表示通过当前子类的构造方法去调用父类的无参构造方法，
   所以必须要保证父类的无参构造方法是存在的，当我们父类有构造方法时，习惯上手动写上无参构造方法
   父类构造第一句也有super()，调用Object类里面的
3. 因为this()和super()都只能出现在构造方法的第一行，所以二者不能共存

 *  执行顺序有先调用，后结束的规律，类似于栈*/
public class Super {

	public static void main(String[] args) {
		 new B();//1.调B的无参构造
	}

}
 class A{
	public A(){
	//默认存在super() 此处是Object类里面的无参构造，是空语句
		System.out.println("A类的无参构造方法");//4.
	}
}
class B extends A{
	public B(){
		this("xiao");//2.用到this(),实现用类的有参构造去给在无参构造中的属性进行初始化操作
		System.out.println("B类的无参构造方法");//6.
	}
	public B(String name){
		//3. 此处默认存在super();，再次调用父类的无参构造
		System.out.println("B类的有参构造方法");//5.
	}
}
/*A类的无参构造方法
B类的有参构造方法
B类的无参构造方法*/

super(参数列表)

public class Text {
	public static void main(String[] args) {
		//调无参构造
		CreditAccount a = new CreditAccount();
		System.out.println(a.getName()+","+a.getBalance()+","+a.getCredit());
		//调有参构造
		CreditAccount b = new CreditAccount("xiaozi",1000,0.9);
		System.out.println(b.getName()+","+b.getBalance()+","+b.getCredit());
		
	}
} 
//账户类
 class Account{
	 private String name;
	 private double balance;
	 //无参构造
	 public Account() {
		 
	 }
	 //有参构造
	public Account(String name, double balance) {
		this.name = name;
		this.balance = balance;
	}
	//封装
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getBalance() {
		return balance;
	}
	public void setBalance(double balance) {
		this.balance = balance;
	}
	 
 }
//信用户
 class CreditAccount extends Account{
	 //信用值
	 private double credit;
	 //无参构造
	 public CreditAccount() {
		 
	 }
	 //有参构造	
	 public CreditAccount(String name, double balance,double credit) {
//		this.name = name;
//		this.balance = balance;
		super(name,balance);
		this.credit = credit;
	}
//	在此处，不可以访问父类中的私有属性，
//	我们可以在子类的构造方法中调用父类中的有参构造方法，实现对其赋值要借助super(name,balance)
//	 若不显示的写出super(),则默认用super()去调用父类中的无参构造，
//	 因为父类中的无参构造也是没有对其赋值，则默认给成员变量赋初值，
//	 String name=null  double balance=0.0
	
	//封装
	public double getCredit() {
		return credit;
	}
	public void setCredit(double credit) {
		this.credit = credit;
	}
//	输出结果：
//	null,0.0,0.0
//	xiaozi,1000.0,0.9
 }

super. 何时不可以省略

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

	}
}

class Customer{//父类
	String name;
	public Customer() {
		
	}
	public Customer(String name) {
		super();//调用Object类中的无参构造
		this.name = name;
	}	
}

class Vip extends Customer{
	public Vip() {
		
	}
     public Vip(String name) {
		super(name);//调用父类的有参构造
	}
	public void shopping() {
		System.out.println(this.name+"学习中");
		System.out.println(name+"学习中");
		System.out.println(super.name+"学习中");
	}
}
//xiaozi学习中
//xiaozi学习中
//xiaozi学习中

当在子类中出现一个和父类相同的属性名或方法名时 ：(不要忘记在构造方法中没有给变量赋初值，则赋予默认值)

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

class Customer{//父类
	String name;
	public Customer() {
		
	}
	public Customer(String name) {
		super();//调用Object类中的无参构造
		this.name = name;
	}
	public void move() {
		System.out.println("move!");
	}
}

class Vip extends Customer{
	String name;
	public Vip() {
		
	}
     public Vip(String name) {
		super(name);//调用父类的有参构造
//		因为当在子类中出现一个和父类相同的属性name,在构造方法中没有赋值，则会赋予它默认值
//		this.name=null;
	}
	public void shopping() {
		System.out.println(this.name+"学习中");
		System.out.println(name+"学习中");
		System.out.println(super.name+"学习中");
	}
	public void move() {
		System.out.println(" Cat move!");
	}
	public void yidong() {
		this.move();
		move();
		super.move();
	}
//	null学习中
//	null学习中
//	xiaozi学习中
//	Cat move!
//	Cat move!
//	move!
}

总结：

在父类和子类中有同名的属性，或者相同的方法，想在子类中访问父类中的属性或者方法，super. 不可以省略

super.属性名 访问父类的属性
super.方法名（实参） 访问父类的方法
super(实参) 调用父类的构造方法

区分this 和 super

this:

1. this 可以出现实例方法和构造方法中，不能出现在静态方法中
2. this的语法有 this. this()
3. this. 大部分情况下是可以省略的
4. this 在区分局部和实例变量时不能省略
5. this()只能出现在构造方法的第一行，通过当前的构造方法去调用“本类”中的其他构造方法，目的时代码复用
   指的是无参构造中使用 this(与有参构造对应的参数)

super:

1. super 可以出现实例方法和构造方法中，不能出现在静态方法中
2. super的语法有 super. super()
3. super. 大部分情况下是可以省略的
4. super 在父类和子类中有同名的属性，或者相同的方法，想在子类中访问父类中的属性或者方法，super. 不可以省略
5. super()只能出现在构造方法的第一行，通过当前的构造方法去调用父类中的构造方法，目的是：创建子类对象时，先初始化父类型特征