【Java基础】抽象类和接口的使用

个人主页：兜里有颗棉花糖
欢迎点赞👍 收藏✨ 留言✉ 加关注💓本文由兜里有颗棉花糖原创
收录于专栏【JavaSE_primary】
本专栏旨在分享学习JavaSE的一点学习心得，欢迎大家在评论区讨论💌

一、抽象类

抽象类概念

抽象类：我们通过前面面向对象的学习已经了解到：所有的对象都是通过类来描述的，但是如果反过来，并不是所有的类都是用来描述对象的。如果一个类中没有足够的信息来描述一个完整的对象，那么这个类我们称它为抽象类。

抽象类语法

抽象类语法：

抽象类使用abstract修饰
抽象类包含普通类所能包含的成员
抽象类之所以和普通类有所区别是因为抽象类中包含抽象方法
抽象方法同样使用abstract进行修饰
抽象类无法进行实例化
抽象类存在的最大意义就是为了被继承
如果一个普通类继承了抽象类，那么这个普通类必须对抽象类中的抽象方法进行重写
如果抽象类A继承了抽象类B，则抽象类A不需要重写抽象类B中的抽象方法，但是如果抽象类A被普通类C继承，那么普通类C需要重写抽象类B的抽象方法
抽象方法是不能私有的
抽象方法没有加访问限定符时，默认是被public修饰的
抽象方法无法被final和static修饰，因为抽象方法是要被重写的
抽象类必须被继承，且子类必须重写抽象类的抽象方法，否则，这个子类必须也是一个抽象类。
抽象类不一定要包含抽象方法，但是有抽象方法的类一定是抽象类
抽象类中可以有构造方法，以便子类创建对象时可以初始化父类的成员变量（不要忘记抽象类是无法实例化的，之所以抽象类可以存在构造方法就是为了子类可以调用抽象类的构造方法来完成抽象类成员变量的初始化操作）

这里解释下为什么抽象方法无法被static修饰：当一个方法被声明为抽象方法时，它要求子类必须提供具体的实现。而静态方法是属于类的一部分，不涉及对象的实例化和继承，因此不能被重写。如果抽象方法允许被static修饰，那么就会导致无法在子类中重写或实现这个方法。

为什么抽象方法无法被final修饰：final修饰的方法无法被子类重写，而抽象方法又要求子类必须对齐（抽象方法）进行重写，二者相互冲突，所以抽象方法当然无法被final修饰了。

我们举一个简单的抽象类，请看：

abstract class Shape {
   private String color;
   
   public Shape(String color) {
      this.color = color;
   }
   
   // 抽象方法，需要子类实现
   public abstract double getArea();
   
   // 普通方法
   public String getColor() {
      return color;
   }
}

抽象类作用

我们已经知道抽象类是无法进行实例化的，如果想要使用抽象类必须在子类中重写抽象类的抽象方法才可以使用。

但是普通类中的方法也可以被重写啊，那为什么还要整个抽象类那么麻烦呢？原因是因为抽象类在在编译器角度来说相当于多了一重检查。
举个例子，如果我们写了一个普通类A，同时子类B继承了这个普通类A，那么无论我们在子类中是否重写普通类A中的成员方法编译器都不会进行报错的。相反如果是抽象类的话，如果我们没有在子类中实现抽象类的抽象方法的话编译器是会报错的。

所以，充分利用编译器的校检能力对于实际开发中是十分有必要的，可以让我们更早的检查到我们犯下的错误。

二、接口

在Java中，接口是一种抽象类型，它定义了一组方法的规范，但没有提供这些方法的具体实现。接口可以看作是一种约定，它规定了实现该接口的类必须实现接口中声明的所有方法。

我们先来简单实现一个接口再回来讲解接口的语法，请看：

interface Myinterface{
    public static final int value = 10;

    // method1和method2均为抽象方法，实现这个接口的类需要提供具体的方法来实现
    // 接口中的方法均为抽象方法
    void method1();
    void method2(String str);

    // 如果非要在接口中具体实现一个方法的话需要用default来修饰此方法
    default public void func1(){
        System.out.println("default public void func1()");
    }

    // 接口中也可以存在静态方法
    public static void func2(){
        System.out.println("public static void func2");
    }
}

class Myclass implements Myinterface{
    public void method1(){
        System.out.println("method1方法必须进行重写");
    }

    public void method2(String str){
        System.out.println("method2方法必须进行重写");
    }

    public void fun1(){
        System.out.println("此方法的重写可以进行选择，既可以重写也可以不重写");
    }
}

接口语法

接口语法如下：

使用interface来修饰接口
接口中的方法不能有具体的实现（即接口中的方法必须为抽象方法），接口中的方法默认是public abstract修饰；从JDK1.8开始允许有可以有具体实现的方法，但是此方法必须由default修饰；接口中可以存在静态方法
接口中的成员变量默认由public static final修饰
接口无法实例化
类和接口之间使用implements来实现多个接口。
我们可以选择性的重写接口中由default修饰的方法。

下面来举一个例子以便大家理解：

interface Animal{
    void whichAnimal();
}
class Cat implements Animal{

    @Override
    public void whichAnimal() {
        System.out.println("我是一只猫咪");
    }
}
class Dog implements Animal{

    @Override
    public void whichAnimal() {
        System.out.println("我是哈士奇");
    }
}
class Sheep implements Animal{

    @Override
    public void whichAnimal() {
        System.out.println("我是喜羊羊");
    }
}
public class Test2 {
    public static void whoAnimal(Animal animal){
        animal.whichAnimal();
    }
    public static void main(String[] args) {
        Cat cat = new Cat();
        whoAnimal(cat);
        whoAnimal(new Dog());
        whoAnimal(new Sheep());
    }
}

结果演示：
在这里插入图片描述

多接口

在Java中，一个类可以继承多个接口，使用implements修饰，并用逗号,隔开。（这样可以解决Java多继承的问题）

请看多接口继承的例子：

interface Engine {
    void start();
    void stop();
}
interface Navigation {
    void navigate();
}
interface MusicPlayer {
    void playMusic();
}
// 定义 Car 类实现 Engine、Navigation 和 MusicPlayer 接口
class Car implements Engine, Navigation, MusicPlayer {
    @Override
    public void start() {
        System.out.println("启动发动机");
    }

    @Override
    public void stop() {
        System.out.println("停止发动机");
    }

    @Override
    public void navigate() {
        System.out.println("导航中");
    }

    @Override
    public void playMusic() {
        System.out.println("播放音乐");
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        car.start();
        car.stop();
        car.navigate();
        car.playMusic();
    }
}

接口间的继承

java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承，所以接口间的继承解决了多继承的目的。

接口继承的优势在于，它可以通过组合不同的接口来实现一种类似多继承的行为。一个类可以实现多个接口，从而获得多个接口中定义的方法和常量，将多个不同接口的特性组合到一个类中。

下面是一个多接口继承的例子，请看：

interface A {
    void methodA();
}

interface B extends A {
    void methodB();
}

interface C {
    void methodC();
}

interface D extends B, C {
    void methodD();
}

class MyClass implements D {
    @Override
    public void methodA() {
        System.out.println("方法A");
    }

    @Override
    public void methodB() {
        System.out.println("方法B");
    }

    @Override
    public void methodC() {
        System.out.println("方法C");
    }

    @Override
    public void methodD() {
        System.out.println("方法D");
    }
}