继承简述

继承

class Student{
    String name;
    int age;
    void study({
        System.out.println("study");
    }
}
class Worker{
    String name;
    int age;
    void work(){
        System.out.println("work");
    }
}

上述代码的表述中，Student类和Worker类中都拥有共同的属性，为了提高代码的复用性，可以将共同的部分抽取出来，然后放在单独的类中。
如下：

class Student{
    void study(){
        System.out.println("study");
    }
}
class Worker{
   
    void work(){
        System.out.println("work");
    }
}
class Person{
    String name;
    int age;
}

但是如何才能让Student和Worker这两个类使用到Person类中的name和age属性呢。java中提供了关键字extends

//将学生和工人的共性抽取到Person这个类中
class Person {
    String name;
    int age;
}
//学生通过extends继承Person,即Person为Student的父类
class Student extends Person{
    //学生类中的自己特有方法
    public void study(){
        System.out.println(name+"同学正在学习。。。。");
    }
}
//工人通过extends继承Person,即Person为工人的父类
class Worker extends Person{
    //工人类中的自己特有方法
    public void work(){
        System.out.println(name+"工人正在工作。。。。");
    }
}
//测试类
public  class Test{
    public static void main(String[] args) {
        Student s = new Student();
        s.name = "小明";
        s.study();
       
        Worker w = new Worker();
        w.name = "张三";
        w.work();
    }
}

使用继承是必须是两个类之间有所属的关系，比如香蕉是水果的一种，牧马人是汽车的一种。

java只支持单继承，不支持多继承

成员变量
如果子类父类中出现不同名的成员变量，这时的访问是没有任何问题

class Fu{
    //Fu中的成员变量。
    int num = 5;
}
class Zi extends Fu{
    //Zi中的成员变量
    int num2 = 6;
    void show(){
        //访问父类中的num
        System.out.println("Fu num="+num);
        //访问子类中的num2
        System.out.println("Zi num2="+num2);
    }
}
class Demo{
    public static void main(String[] args){
        Zi z = new Zi(); //创建子类对象
        z.show(); //调用子类中的show方法
    }
}

当子父类中出现了同名成员变量时，在子类中若要访问父类中的成员变量，必须使用关
键字super来完成

class Fu{
    //Fu中的成员变量。
    int num = 5;
}
class Zi extends Fu{
    //Zi中的成员变量
    int num = 6;
    void show(){
        //子父类中出现了同名的成员变量时
        //在子类中需要访问父类中非私有成员变量时，需要使用super关键字
        //访问父类中的num
        System.out.println("Fu num="+super.num);
        //访问子类中的num2
        System.out.println("Zi num2="+this.num);
    }
}
class Demo5{
    public static void main(String[] args){
        Zi z = new Zi(); //创建子类对象
        z.show(); //调用子类中的show方法
    }
}

成员函数
当在程序中通过对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在
就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。

class Fu{
    public void show(){
        System.out.println("Fu类中的show方法执行");
    }
}
class Zi extends Fu{
    public void show2(){
        System.out.println("Zi类中的show2方法执行");
    }
}
public  class Test{
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show(); //子类中没有show方法，但是可以找到父类方法去执行
        z.show2();
    }
}

子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为override重写、复写或
者覆盖

class Fu{
    void show(){
        System.out.println("Fu show");
    }
}
class Zi extends Fu{
    //子类复写了父类的show方法
    void show(){
        System.out.println("Zi show");
    }
}

重写需要注意的细节问题

1. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限
2. 静态只能覆盖静态，或者被静态覆盖，意思就是 静态函数不存在重写！
3. 写法上稍微注意:必须一模一样:函数的返回值类型 函数名 参数列表都要一样。

子父类中构造函数的特点
在创建子类对象时，父类的构造函数会先执行，因为子类中所有构造函数的第一行有默
认的隐式super();语句，调用本类中的构造函数用this(实参列表)语句，调用父类中的构造函
数用super(实参列表)。

public class Test {
    public static void main(String[] args) {
        new Zi();
    }
}
class Fu{
    int num ;
    Fu(){
        System.out.println("Fu构造函数"+num);
        num = 4;
    }
}
class Zi extends Fu{
    Zi(){
        System.out.println("Zi构造函数"+num);
    }
}

执行结果：
Fu构造函数0
Zi构造函数4