super在继承中的作用||回顾总结ava继承

继承关键字

继承是 OOP 面向对象程序设计 的关键技术之一，也是面向对象的三大特性（封装 继承 多态）

继承的关键字：extends super

在实现继承一个类时 要使用extends去继承一个类

class Parent
{
	...
}

子类
class child extends Parent
{
	...
}

super是在子类中明确调用父类公共属性或方法时 使用

super(name,age);// 一般用在构造方法传参中。

super.name=name;
super.fun();

子类调用父类属性和方法

父类

public class parent {
    public String name;
    private String wife;
    public int age;
    protected String homeadd;

    public void talk(){
        System.out.println("我的名字是"+name);
    }

    private void talk1(){
        System.out.println("此话我只对自己说");
    }

    protected void talk2(){
        System.out.println("我的继承人也可以知道");
    }

    public void out(){
        this.talk();
        this.talk1();
        this.talk2();
    }
}

上述代码块中，修饰符public、protected和默认修饰的属性和方法，该类的子类都可以调用。而private修饰的方法和属性，只能父类自己调用，或者通过一个其他修饰符的方法 间接调用如：

public void out(){
        this.talk();
        
        this.talk1();//该类只能自己调用，
        			//而通过间接的方法可以实现让子类调用。
        this.talk2();
    }

即子类在不定义任何成员的情况下，就已经有了父类所有非private定义的成员变量和全局属性。

子类通过this调用父类属性和方法

this：表示当前类，它出现在哪个类的代码中就是哪个代表哪个类，可以直接调用该类的所有属性和方法

class child extends parent{
    private String school;

    public child(String school) {
        System.out.println("************子类构造方法开始");
        this.school = school;
        this.talk();
        this.out();
        System.out.println(this.age);
        System.out.println("子类构造方法结束************");
    }
    public void talk(){
        System.out.println("我是子类，我的名字是"+name);
    }
    public void speak(){
        System.out.println("--------------子类方法开始");
        this.talk();
        this.out();
        this.age=5;
        System.out.println(this.age);
        System.out.println("子类方法结束--------------");
    }
}

主方法实现：

public class reextend01 {
    public static void main(String[] args) {
        child c=new child("中心小学");
        c.speak();
    }
}

可见，如果子类child继承了父类parent，在子类中我们可以通过this，或者直接处理父类得非私有的属性和方法。

当然，这种只适合，子类和父类属性方法不冲突的情况下，否之子类或调用它自己的，下面会讲。

子类通过super调用父类属性和方法

class child extends parent{
    private String school;
    //以下两个属性 父类中也有，且修饰符也一样
    protected String homeadd;
    public int age;

    public void talk(){
        //talk 方法父类子类都有一个修饰符+返回类型+方法名+参数都一样的方法  只是方法体不一样
        System.out.println("我是子类，我的名字是"+name);
    }

    public void super1(){
        this.talk();
        super.talk();
    }
}

public class reextend01 {
    public static void main(String[] args) {
        child c=new child();
        c.super1();
    }
}

所以，如果子类和父类都有一个相同的方法talk()（只有函数体不一样，相同的方法名、相同的参数列表、相同的返回值），

在子类中直接调用talk()，此时会覆盖父类的talk方法，调用的是子类方法

而super则是明确表示指向父类的方法，会覆盖掉子类方法。

构造方法中使用super

当父类方法没有相关参数构造方法时

class child extends parent {
    private String school;
    //以下两个属性 父类中也有，且修饰符也一样
    protected String homeadd;
    public int age;

    public child(String name,String school, String homeadd, int age) {
        super.name=name;
        this.school = school;
        this.homeadd = homeadd;
        this.age = age;
    }

    public void print(){
        super.talk();
        super.talk2();
    }
}

/*
*父类talk 中加入子类父类皆有的属性homeadd  和年龄
*/
protected void talk2(){
        System.out.println("我的继承人也可以知道"+"地址"+this.homeadd);
    }

构造方法中主要就是涉及到传参这个概念：
如果子类父类都有的属性，构造方法体中传参时：
如果没有用到super.属性=xxx
那么父类属性将不会赋值

当父类方法有相关参数构造方法时

当父类有相关参数的构造方法时

public parent(String name,int age, String homeadd) {
        this.name = name;
        this.age = age;
        this.homeadd = homeadd;
    }

在子类的构造方法中，我们就不必super.属性=xxx…一个一个赋值了

super(name,age,homeadd);;

只需在子类构造方法中根据父类构造方法的参数写super(,,…)就行

不过super() 只适合出现在构造方法中

继承的限制

限制1：没有多重继承，只有多层继承
如果C类想同时继承A 类 和 B类的功能

class A
{}
class B
{}
class C extends A B//这样是不行的
{}

上面是错的，无法实现多重继承

只能通过B 继承 A ，C再继承B 才行，也就是 一个类，一次只能继承一次
通过多层继承才能完成继承多个类

一般情况下，继承最多不建议超过3层

限制2：父类的私有成员不能直接被子类继承，只能间接调用
毕竟灰太狼和小灰灰还是不一样的 ，也有自己的私人空间。

限制3：子类进行对象实例化时，从父类继承而来的数据成员，要先通过调用父类的构造方法来初始化
限制3什么意思呢？ 切记是在构造方法时

你调用父类的数据，其数据具体值必须在父类中的构造函数生成，
也就是子类构造方法调用父类数据，此数据在父类中要先诞生

意思就是，在上述中，我要给父类属性赋值，都要通过父类那进行赋值
你可以super.age=24;
也可以super(age)——————前提 父类中有相关参数的构造方法
还可以this.s=24___________前提，子类没有相冲突的属性，用this是明确调用父类属性。

所以在实例化子类，且涉及到给父类属性传值时
必须满足以下两个条件：
1、子类构造方法中依次用super.s=xxx 赋值

class Person
{
	String name;
	int age;
}

class Student extends Person
{
	String School;
	Student(String name,int age,String School)
	{
		super.name=name;
		super.age=age;
		this.School=School;
	}

	public String talk()
	{
		//return super.talk()+"I am from:"+this.School;
		return "I am from:"+this.School;
	}

}
public class InheritFFF
{
	public static void main(String[] args)
	{
		Student S=new Student("jack",24,"zhongg");
		System.out.println(S.talk());
	}
}

2.父类的构造方法中，有相关参数a、b的构造方法，然后再子类构造方法中写super(a,b);

父类的构造方法

class parent
{
	String name;
	int age;
	parent(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
}

子类的构造方法

class Child extends parent
{
	String school;
	Child(String name,int age,String school)
	{
		super(name,age);
		this.name=name;
		this.age=age;
		this.school=school;
	}
}