继承、super、方法的重写、final

一、继承

继承是什么？在现实中继承财产，古代继承皇位等等，都是继承，由此可以看出继承是，下一代得到上一代的东西，并且继承之后就属于了自己，这就是继承。在Java中，我们要用到继承的话，需要用到extends关键字，通过extends关键字来完成类与类的继承，那么说到继承是不是就涉及到了两个类，一个类就叫超类/父类，另一个就是派生类/子类。

那么父类里有什么呢？父类里其实想怎么设计就怎么去设计，但是我们要知道父类里的东西是子类所共有的，只要子类继承的是同一个类，那么它们就共同拥有了父类的所有，除了父类的构造方法。

作用：代码复用

通过extends实现继承

超类/基类/父类：共有的属性和行为

派生类/子类：特有的属性和行为

派生类可以访问：超类的+派生类的，超类不能访问派生类的

一个超类可以有多个派生类，一个派生类只能有一个超类---------单一继承

具有传递性

java规定：构造派生类之前必须先构造超类

                  在派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法

                  在派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供

        注意：super()调用超类构造方法，必须位于派生类构造方法中的第一行(意思就是只能在子类构造方法的第一行，不能在子类构造方法其他语句之下，不然就报错）（还不懂下面会提到）

继承的一个例子：

父类：Person

public class Person {
    String name;
    int age;
    String address;
    Person(){
    }
    Person(String name,int age,String address){
        this.name = name;
        this.age = age;
        this.address = address;
    }

    void eat(){
        System.out.println(name+"正在吃饭...");
    }
    void sleep(){
        System.out.println(name+"正在睡觉...");
    }
    void sayHi(){
        System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
    }
}

子类：Student 

public class Student extends Person{
    String className;
    String stuId;
    Student(){
    }
    Student(String name,int age,String address,String className,String stuId){
        super(name,age,address);
        this.className = className;
        this.stuId = stuId;
    }

    void study(){
        System.out.println(name+"正在学习...");
    }
}

Test类：做测试 

public class ExtendsTest {
    public static void main(String[] args) {
        Student zs = new Student("张三",25,"廊坊","jsd2302","001");
        zs.eat();
        zs.sleep();
        zs.sayHi();
        zs.study();
     }
}

二、super 

super：指代当前对象的超类对象(就是指向子类的父类，所以一般用在子类，一般不在父类）

super.成员变量名-------------------------访问超类的成员变量

super.方法名()------------------------------调用超类的方法

super()----------------------------------------调用超类的构造方法

注意：当我们父类的成员变量与子类的成员变量同名的时候，super指向的就是父类的成员变量，this指向的就是子类的成员变量（当前类），如果父类与子类成员变量不同名，那么super与this是一样的。

1)、 在派生类的构造方法中若没有调用超类的构造方法，则默认super() 调用超类的无参构造方法

class Aoo{
    Aoo(){
        System.out.println("超类构造方法");
    }
}
class Boo extends Aoo{
    Boo(){
        super(); //默认的，调用超类的构造方法
        System.out.println("派生类构造方法");
    }
}

2) 在派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供

class Coo{
    Coo(int a){
    }
}
class Doo extends Coo{
    Doo(){
        super(5); //调用超类的有参构造
    }
    /*
    //如下代码为默认的:
    Doo(){
        super();
    }
     */
}

    在调用了以后系统就不会默认即自动的生成super（）方法，即访问父类的默认构造方法。

三、方法的重写

方法的重写 (override/overriding) ：重新写、覆盖

发生在父子类中，方法名相同，参数列表相同

重写方法被调用时，看对象的类型 ---------------new 谁就调谁的，这是规定

class 餐馆{
    void 做餐(){ 做中餐 }
}
//1)我继承餐馆后还是想做中餐---------------不需要重写
class Aoo extends 餐馆{
}
//2)我继承餐馆后想改做西餐-----------------需要重写
class Boo extends 餐馆{
    void 做餐(){ 做西餐 }
}
//3)我继承餐馆后想在中餐基础之上加入西餐------需要重写(先super中餐，再加入西餐)
class Coo extends 餐馆{
    void 做餐(){
        super.做餐();
        做西餐
    }
}

四、final 

final关键字在小白看来只需要记住它表示最后的意思，既然是最后的、最终的，是不是就不能去修改了，已经是最终的，肯定不能修改了。

1.final修饰变量时，变量不能被改变

class Eoo{
    final int a = 5;
    int b = 6;
    void test(){
        //a = 55; //编译错误，final修饰的变量不能被改变
        b = 66;
        final int c = 8;
        //c = 88; //编译错误，final修饰的变量不能被改变
    }
}

2.final修饰方法时，方法不能被重写

class Foo{
    final void show(){}
    void test(){}
}
class Goo extends Foo{
    //void show(){} //编译错误，final修饰的方法不能被重写
    void test(){}
}

3.final修饰类时，类就不能被继承了，但是final修饰的类可以去继承别的类。

final class Hoo{}
//class Ioo extends Hoo{} //编译错误，final修饰的类不能被继承
class Joo{}
final class Koo extends Joo{} //正确，不能当老爸，但能当儿子

五、综合练习

    Person、Student、Teacher、Doctor类和Test类

   1)Person类：name、age、address、Person(参)、eat()、sleep()，sayHi()

   2)Student类：继承Person、className、stuId，Student(参)、study()，重写sayHi()方法

   3)Teacher类：继承Person、salary，Teacher(参)、teach()，重写sayHi()方法

   4)Doctor类：继承Person、title，Doctor(参)、cut()

   5)Test：创建对象、调用方法测试

1.Person类：

package ooday02_homework;

public class Person {
    String name;
    int age;
    String address;

    Person(){}
    Person(String name,int age,String address){
        this.name=name;
        this.address=address;
        this.age=age;
    }

    void eat(){
        System.out.println("我叫"+name+"，今年"+age+"岁了，家住"+address+"现在正在吃饭");
    }

    void sleep(){
        System.out.println("我叫"+name+"，今年"+age+"岁了，家住"+address+"现在正在睡觉");
    }

    void sayHi(){
        System.out.println("我叫"+name+"，今年"+age+"岁了，家住"+address+"现在正在打招呼");
    }
}

2.Student类：

package ooday02_homework;

public class Student extends Person{
    String className;
    String stuId;

    Student(){}
    Student(String name,int age,String address,String className,String stuId){
        super(name,age,address);
        this.className=className;
        this.stuId=stuId;
    }

    void study(){
        System.out.println(name+"正在学习！");
    }

    void sayHi(){
        System.out.println("大家好我叫"+name+"今年"+age+"岁了，在"+className+"班级"+",学号为"+stuId+",家住"+address);
    }
}

3.Teacher类：

package ooday02_homework;

public class Teacher extends Person{
    double salary;

    Teacher(){
    }
    Teacher(String name,int age,String address,double salary){
        super(name,age,address);
        this.salary=salary;
    }

    void  teach(){
        System.out.println(name+"正在教课!");
    }

    void sayHi(){
        System.out.println("大家好我叫"+name+"今年"+age+"岁了"+",家住"+address+"每个月工资为："+salary);
    }
}

4.Doctor类：

package ooday02_homework;

public class Doctor extends Person{
    String title;

    Doctor(){}

    Doctor(String name,int age,String address,String title){
        super(name,age,address);
        this.title=title;
    }

    void cut(){
        System.out.println(name+"正在进行"+title);
    }

}

5.test类：

package ooday02_homework;

public class Test {
    public static void main(String[] args) {
        Student student = new Student("zs",18,"湖南","jsd2307","001");
        student.eat();
        student.sleep();
        student.sayHi();
        student.study();

        Teacher teacher = new Teacher("ls",48,"北京",12000.0);
        teacher.teach();
        teacher.sayHi();
        teacher.eat();

        Doctor doctor = new Doctor("ww",35,"上海","开颅");
        doctor.cut();
        doctor.sayHi();
        doctor.sleep();

    }
}

六、补充

1. 泛化：从程序设计角度而言叫泛化，从代码实现角度而言叫继承，泛化就是继承

2. 继承要符合 is( 是 ) 的关系

3. 继承的是父类的成员变量和普通方法，不包括构造方法，父类的构造方法是被子类通过 super 来调用的

 

class Aoo{
    int a;
    Aoo(){
    }
    void show(){
    }
}
class Boo extends Aoo{
    继承了Aoo类的a+show()，并没有继承Aoo类的构造方法
}

4. 重写与重载的区别： ------------------- 常见面试题

重写 (overriding) ：发生在父子类中，方法名相同，参数列表相同

重载 (overloading) ：发生在同一类中，方法名相同，参数列表不同

5. 重载特例情况：

class Aoo{
    void show(){
    }
}
class Boo extends Aoo{ //在此类中发生在show()的重载
    void show(String name){
    }
}

     虽然在子类中明面上只有一个show的有参方法，但是还继承了父类的无参的show（）方法，所以发生了重载。