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权限的抽象方法。

生成接口

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

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
}

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

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

使用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();
    }
    

}