Super关键字

目录

1.基本介绍

2.基本语法

 3.super给编程带来的便利/细节：                                                

4.super 和 this 的比较

---

1.基本介绍

Super代表父类引用,用于访问父类的属性,方法,构造器

2.基本语法

com.hspedu.super_包下

1. 访问父类属性(super.属性名),但不能访问父类的private属性
2. 访问父类的方法[super.方法名(参数列表)],但不能访问父类的private方法
3. 访问父类构造器super(参数列表);只能放在构造器的第一句,只能出现一句！

1. 代码实例：

public class A {                                 
	//4 个属性                                      
	public int n1 = 100;                         
	protected int n2 = 200;                      
	int n3 = 300;                                
	private int n4 = 400;                        
	                                             
                                                 
	public A() {                                 
		super();                                 
		// TODO Auto-generated constructor stub  
	}                                            
	public A(String name) {}                     
	                                             
	public A(String name,int age) {}             
	public void test100() { }                    
	                                             
    protected void test200() { }                 
    void test300() { }                           
    private void test400() { }                   
}                                                
                                                 

public class B extends A{
	//访问父类的属性 , 但不能访问父类的 private 属性
	public void hi() {
		System.out.println(super.n1 + " " + super.n2 + " " + super.n3 ); 
		}
	//访问父类的方法，不能访问父类的 private 方法 super.方法名(参数列表);
	
	public void ok() {
		super.test100(); 
		super.test200();
		super.test300();
		//super.test400();//不能访问父类 private 方法 
	}
	
	//访问父类的构造器(这点前面用过)：super(参数列表);只能放在构造器的第一句，只能出现一句！
	public B() { 
		//super(); 
		//super("jack", 10); 
		super("jack"); 
	}

 3.super给编程带来的便利/细节：                                                

1. 调用父类构造器好处,分工明确父类属性由父类初始化,子类的属性由子类初始化
2. 当子类中有和父类中的成员(属性和方法)重名时,为了访问父类成员,必须通过super.如果没有重名,使用super,this直接访问是一样的效果[类名();this.类名();super.类名();]
3. super的访问不限于直接父类,如果爷爷类和本类中有同名的成员,也可以使用super去访问爷爷类的成员；如果多个基类（上级类）中都有同名的成员,使用super访问遵循就近原则.A->B->C，当然也需要遵守访问权限的相关规则.

例子：方法

public class A {
public void cal() {
		System.out.println("A 类的 cal() 方法...");
	}

}

public class B extends A{
	
	public void sum() {
		System.out.println("B 类的 sum()");
		//希望调用父类-A 的 cal 方法
		//这时，因为子类 B 没有 cal 方法，因此我可以使用下面三种方式
		
		//找 cal 方法时(cal() 和 this.cal())，顺序是: 
		// (1)先找本类，如果有，则调用
		// (2)如果没有，则找父类(如果有，并可以调用，则调用)
		// (3)如果父类没有，则继续找父类的父类,整个规则，就是一样的,直到 Object 类 
		// 提示：如果查找方法的过程中，找到了，但是不能访问， 则报错, cannot access 
		// 如果查找方法的过程中，没有找到，则提示方法不存在
		//cal();

		this.cal(); //等价 cal
		

		//找 cal 方法(super.call()) 的顺序是直接查找父类，其他的规则一样 
		super.cal();
	}
	public void cal() {
		System.out.println("B 类的 cal() 方法...");
	}

 

 例子：属性

public class A {

    public int n1 = 100;
}

public class B extends A{
	public int n1=10;

public void sum() {
		System.out.println("B 类的 sum()");

      //演示访问属性的规则
		//n1 和 this.n1 查找的规则是
		//(1) 先找本类，如果有，则调用 
		//(2) 如果没有，则找父类(如果有，并可以调用，则调用)
		//(3) 如果父类没有，则继续找父类的父类,整个规则，就是一样的,直到 Object 类
		// 提示：如果查找属性的过程中，找到了，但是不能访问， 则报错, cannot access
		// 如果查找属性的过程中，没有找到，则提示属性不存在 
		System.out.println(n1);//10
		System.out.println(this.n1); //10
		//找 n1 (super.n1) 的顺序是直接查找父类属性，其他的规则一样 
		System.out.println(super.n1); //100
		}

}

4.super 和 this 的比较