Java：继承

格式：public class 子类名 extends父类名（）；

public class zi extends fu（）;

父类：也被称为基类、超类；

子类：也被称为派生类；

public class Zi extends fu {
    public void show(){
        System.out.println("好好学习");
    }
}
class fu{
    public void mention(){
        System.out.println("天天向上");
    }
}
class Test{
    public static void main(String[] args) {
        fu f=new fu();
        f.mention();
//        天天向上
        Zi z=new Zi();
        z.show();
        z.mention();
//        好好学习
//        天天向上
    }
}

继承的好处与弊端：

好处：

1、提高了代码的复用性（多个类相同的成员可以放到同一个类中）

2、提高了代码的维护性（如果代码需要修改，只改一处就可以）

弊端：

1.继承让类与类之间发生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了类的独立性；

什么时候使用继承：

比如说苹果和香蕉，是属于同级关系，这个时候不需要使用继承，水果和苹果就属于上下级的关系，此时就可以使用继承；

继承中变量访问的特点：

在子类方法中访问一个变量：

子类局部范围内找；

子类成员范围内找；

父类成员范围内找；

如果都没有就报错；

public class Zi extends fu {
    public int weight = 75;
    public int age = 18;
    public void show() {
        System.out.println(age + "," + weight);
    }
}

class fu {
    public int age = 20;
    public void mention() {
        System.out.println(age);
    }
}
class Test{
    public static void main(String[] args) {
        Zi z=new Zi();
        z.show();
//        18,75
        z.mention();
//        20
    }
}

当子类成员变量名字与父类成员变量名字不一样的时候，使用什么变量名就访问谁：

public class Extends1 {
    public static void main(String[] args) {
        Son son = new Son();
       son.show();
    }
}
class Father{
    int num1=11;
    int num2=21;
    public void show(){
        int num1=11;
        int num2=21;
    }
}
class Son extends Father {
    int num1 = 30;
    int num3 = 40;
    public void show() {
        System.out.println(num1);
//        30
        System.out.println(num2);
//        21
        System.out.println(num3);
//        40
    }
}

super关键字：

super与this关键字的区别

this代表的是调用该类当前的对象

super代表的是父类存储空间的标识；

访问成员变量：

this访问的是本类中的成员变量，

super访问的是父类中的成员变量

访问的构造方法；

this(.....);

super(......);

访问成员方法：

this.成员方法（）；

super.成员方法（）；

public class Extends2 {
    public static void main(String[] args) {
        Son1 son=new Son1();
        son.show();
    }
}
class Father1{
    int num1=10;
    public void show2(){
        System.out.println("这是父亲中show2的方法");

    }
}
class Son1 extends Father1{
    int num1=20;
    public void show(){
        int num1=30;
        System.out.println(num1);
//        30
        System.out.println(this.num1);
//        20
        System.out.println(super.num1);
//        10
        show2();
//        这是父亲中show2的方法
        super.show2();
//        这是父亲中show2的方法
        show1();
//        这是儿子中show1的方法
        this.show1();
//        这是儿子中show1的方法
    }
    public void show1(){
        System.out.println("这是儿子中show1的方法");
    }

}

继承与构造方法的关系：

1、想要初始化子类，必须先初始化父类

原因：因为子类会继承父类的所有数据，甚至可能会使用父类的数据，所以在子类初始化之前一定要先初始化父类；

每个子类的第一个构造方法都会默认super();

public class Extends3 {
    public static void main(String[] args) {
        Son3 son3=new Son3("小飞");
//        父类中的无参构造方法
//子类中带参构造方法
    }
}
class Father3{
    int age;
    Father3(){
        System.out.println("父类中的无参构造方法");
    }
    Father3(String s){
        System.out.println("父类中的带参构造方法");
    }
}
class Son3 extends Father3{
    Son3(){
        System.out.println("子类中的无参构造方法");
    }
    Son3(String s){
        System.out.println("子类中带参构造方法");
    }
}

当父类中没有带参的构造方法时：

使用super关键字带参的形式访问父类中的带参构造方法；

使用this关键字调用本类中其他的构造带参方法；

注意：本类中其它地构造方法也必须可以访问父类中的构造方法，使用this关键字间接调用父类的构造方法，无论在哪里调用父类中的方法。只要保证子类构造方法执行之前，完成父类的初始化即可。

super（..）和this（...）必须出现在第一条语句，否则的话会出现父类中的数据多次初始化；

public class Extends4 {
    public static void main(String[] args) {
        Son4 son4=new Son4("你好");
//这是父类带参数的构造方法hallo
//子类的无参构造方法
//子类带参数的构造方法你好
    }
}
class Father4{
    int age;
    Father4(String s){
        System.out.println("这是父类带参数的构造方法" + s);
    }
}
class Son4 extends Father4{
    Son4(){
        super("hallo");
        System.out.println("子类的无参构造方法");
    }
    Son4(String s){
        this();

        System.out.println("子类带参数的构造方法" + s);
    }
}

继承与成员方法的关系：

1、当子类成员方法名与父类成员方法名不一样的时候，该调用谁的就调用谁的：

2、当子类成员方法名与父类成员方法名一样的时候，就近原则

1、先在本类中调用，如果有就调用，没有就去父类中调用；

2、如果父类中有方法就调用父亲的；

3、如果父类中也没有，就报错。

public class Extends5 {
    public static void main(String[] args) {
        Son5 son5=new Son5();
        son5.show2();
//        这里调用的是子类中show2方法
        son5.show1();
//       这里调用的是父类中的show1方法 
    }
}
class Father5{
    public void show1(){
        System.out.println("这里调用的是父类中的show1方法");
    }
}
class Son5 extends Father5{
    public void show2(){
        System.out.println("这里调用的是子类中show2方法");
    }
}