java 抽象类泛型方法继承实现

final关键字
1、之前有记录过能把变量变成常量，无法修改。
2、在类前使用final关键字，会使得类无法作为父类，即无法被继承了（就是最后一代了呗）。
3、方法前使用final，子类无法改修该方法了。
4、类的成员属性被声明为final， 跟局部变量赋值一样，不能再改了。

学习玩封装和多态后，我们推荐在不会再发生改变的成员属性上添加final关键字，JVM会对添加了final关键字的属性进行优化。

抽象类
类本身就是一种抽象，而抽象类，把类还要抽象，也就是说抽象类只保留特征，而不保留具体呈现形态，比如方法可以定义好，但是不去实现它，而是交由子类来实现。（打个比方，就是父亲说你要学rap了，定义好输入是嘴，那儿子就要用嘴自己去实现rap，而且必须要学会！）
通过abstract关键字来表明一个类是抽象类，抽象类可以使用abstract关键字来表明一个方法为抽象方法，也可以定义普通方法，抽象方法不需要编写具体实现，但是必修由子类实现（除非子类也是抽象类）

抽象类由于不是具体的类定义，因此无法通过new关键字创建对象。
实例：
我们把上一章的Student类改成抽象类：
Student类

package student;

public abstract class Student {
    private String name;
    private int age;

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

    public int getAge(){
        return age;
    }

    public String getName(){
        return name;
    }

    public void setAge(int age){
        this.age = age;
    }

    public void setName(String name){
        this.name = name;
    }

    public abstract void study();

}

Sport类

package student;

public class SportStudent extends Student{

    public SportStudent(String name, int age){                  //子类一定要先实现父类的构造方法
        super(name, age);                                       //super代表父类, this代表自身类
    }

    public void execrise(){
        System.out.println("我锻炼呢");
    }

    //子类中的study
    @Override   //注解：声明这个方法是重写的，但是可以不要
    public void study(){                                        //重写后，父类的定义就消失了，改为子类自己的定义
        System.out.println("体育生的学习就是锻炼！");
    }
}

package student;

public class ArtStudent extends Student{
    public ArtStudent(String name, int age){        //子类一定要先实现父类的构造方法
        super(name, age);                           //super代表父类, this代表自身类

    }

    public void draw(){
        System.out.println("我画画呢");
    }

    @Override
    public void study(){
        System.out.printf("艺术生的学习就是画画");
    }
}

import student.ArtStudent;
import student.SportStudent;
import student.Student;

public class Main {
    public static void main(String[] args) {
        SportStudent s = new SportStudent("sj", 24);
        s.study();

        ArtStudent a = new ArtStudent("sj", 24);
        a.study();
    }
    

}

因此，抽象类一般只用作继承使用，抽象类使得继承关系之间更加明确。

接口

接口甚至比抽象类还要抽象，他只代表某个确切的功能，也就是只包含方法的定义，甚至都不是一个类！接口包含了一些类方法的具体定义，类可以实现这个接口，表示类支持接口代表的功能（类似一个插件，只能作为附属功能加再主体上，同时具体实现还需要由主体来实现）

通过interface关键字来表明是一个接口(这里使用class替换成interface，不是再前面加)，接口只能包含public权限的抽象方法。

生成接口

public interface Eat {
    void eat();            //前面默认public abstract
}

（JAVA8以后可以有default实现，也就是可以通过声明default关键字来给抽象方法一个默认实现）

public interface Eat {
    void eat();            //前面默认public abstract

    default void eat_two(){
        
    }
}

接口中定义的变量，默认为public static final

public interface Eat {
    public static final int a = 10;
    void eat();            //前面默认public abstract
}

一个类可以实现多个接口，但是不能理解为多继承

使用implements 关键字

package student;
import Behavior.Eat;

public class SportStudent extends Student implements Eat{

    public SportStudent(String name, int age){                  //子类一定要先实现父类的构造方法
        super(name, age);                                       //super代表父类, this代表自身类
    }

    //@Override
    public void eat() {
        System.out.println("吃饭吃饭");
    }
}

import student.ArtStudent;
import student.SportStudent;
import student.Student;
import Behavior.Eat;
public class Main {
    public static void main(String[] args) {
        Eat eat = new SportStudent("sj", 24);
        eat.eat();
    }
    

}