JavaSE-07-抽象类和接口的详细解释和实现

Dear 丶 2023-10-06 10:45 53阅读 0赞

**Table of Contents**

抽象类和接口

1:抽象类

1.1：什么是抽象类

1.2：抽象类的使用

2：接口

2.1：接口概念

2.2：接口的实现类

2.2.1:实现类

2.2.2：实现类是抽象类

2.2.3：继承在前，实现在后

2.3：接口中的常量都是静态常量

2.4：接口中的方法

2.5：多实现

2.6：JDK8后加的默认方法

2.7：JDK8后加的静态方法

2.9：函数式接口

--------------------

# 抽象类和接口 #

# 1:抽象类 #

## 1.1：什么是抽象类 ##

有时在开发中，要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该行为，而是在子类中实现该方法。  
这种只给出方法定义而不具体实现的方法被称为抽象方法，抽象方法是没有方法体的，在代码的表达上就是没有“\{\}”。

使用 abstract 修饰符来表达抽象。  
abstract 修饰符可以与类和方法一起使用。被修饰的类不能被实例化，被修饰的方法必须在包含此方法的类的子类中被实现。 抽象类简单地说：使用 abstract 修饰的类就是抽象类。 示例如下：

public abstract class Test {// 抽象类定义
        public abstract void doItByHand();// 抽象方法定义
    }

## 1.2：抽象类的使用 ##

1：应用：在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但是无法准确知道子类如何实现这些方法；

2：应用：从多个具有相同特征的类中抽象出一个抽象类；以这个类作为子类模板

**在下列情况下，一个类将成为抽象类：**  
（1）当一个类的一个或多个方法是抽象方法时；  
（2）当类是一个抽象类的子类，并且不能为任何抽象方法提供任何实现细节或方法主体时；  
（3）当一个类实现一个接口，并且不能为任何抽象方法提供实现细节或方法主体时；

**总结：**

**有抽象方法的类一定是抽象类，抽象类也可以有普通方法**

**子类必须实现父类抽象类中的抽象方法**

# 2：接口 #

## 2.1：接口概念 ##

Java 可以创建一种称作接口(interface)的类，在这个类中，所有的成员方法都是抽象的，也就是说它们都只有定义而没有具体实现，**接口是抽象方法和常量值的定义的集合。**从本质上讲，接口是一种特殊的抽象类，用 interface，可以指定一个类必须做什么，而不是规定它如何去做。接口定义如下：

接口定义了一批类所要遵守的规范，接口不关心这些类的内部数据，只规定这些类必须提供的方法

访问修饰符 interface 接口名称 {
        抽象属性  //默认加public static
        抽象方法  //默认加public abstract
    }

例如，我们定义一个可以飞的接口

public interface Flyable {
        //默认是静态常量
        public String NAME="可以飞的";
        //抽象方法:飞行
        public void fly();
        //抽象方法:跳舞
        public void dance();
    }

## 2.2：接口的实现类 ##

接口不能创建类实例，只能作为类型使用。如果想要创建类实例，需要为接口编写实现类。

### 2.2.1:实现类 ###

使用implements类实现接口

/**
    * Bird类实现了Flyable接口，实现了接口中所有的抽象方法
    */
    public class Bird implements Flyable{
        @Override
        public void fly() {
            System.out.println("扇动翅膀飞行");
        }
        @Override
        public void dance() {
            System.out.println("在空中翩翩起舞");
        }
    }

使用的时候可以用接口的引用指向实现类的实现，这也是多态的一种

//接口作为类型使用，创建实现类的类实例  
**Flyable f=new Bird();**

### **2.2.2：实现类是抽象类** ###

**如果类不能提供两个抽象方法的实现，那么必须将类定义为抽象类，代码如下：**

/**
    * Bird类实现了Flyable接口的一个抽象方法，所以需要定义为抽象类
    */
    public abstract class Bird implements Flyable{
        @Override
        public void fly() {
             System.out.println("扇动翅膀飞行");
        }
    }

上述因为是因为实现类是抽象类，所以可以只实现接口的一个方法

### 2.2.3：继承在前，实现在后 ###

如果类需要继承父类，声明类时，继承父类在前，实现接口在后

/**
    * 继承父类在前，实现接口在后
    */
    public class Bird extends Animal implements Flyable{
        @Override
        public void fly() {
            System.out.println("扇动翅膀飞行");
        }
        @Override
        public void dance() {
            System.out.println("在空中翩翩起舞");
        }
    }

## 2.3：接口中的常量都是静态常量 ##

接口中声明的成员变量默认都是 **public static fina**l 修饰的，也就是静态常量，必须显示的初始化。因而在常量声明时可以省略这些修饰符。

//默认是静态常量，并且必须初始化
    public String NAME="可以飞的";

## 2.4：接口中的方法 ##

接口中的方法默认是公共的抽象方法，不能带有方法体。

接口中的方法都是默认由 public abstract 修饰的

## 2.5：多实现 ##

一个类只能继承一个父类，但是可以实现多个接口

public class Swan implements Flyable,Swimable{
        @Override
        public void swim() {
            System.out.println("摆动蹼，在水中游泳");
        }
        @Override
        public void fly() {
            System.out.println("扇动翅膀，在天空中飞行");
        }
        @Override
        public void dance() {
            System.out.println("在空中跳起了天鹅舞");
        }
    }

## 2.6：JDK8后加的默认方法 ##

从 JDK8 开始，允许我们在接口中定义 default 方法，即默认方法，并且可以有多个

/**
    * @Description: 可以飞行的接口
    */
    public interface Flyable {
        //抽象方法:飞行
        public void fly();
        //默认方法:跳舞
        public default void dance() {
            System.out.println("在空中翩翩起舞");
        }
    }

实现类在实现的时候只需要实现抽象方法即可，但是可以调用默认方法

注意：如果两个接口的默认方法具有相同的名字，也就是有冲突，那么实现类必须重写该默认方法；

## 2.7：JDK8后加的静态方法 ##

从 JDK8 开始，允许我们在接口中定义 static 方法，即静态方法

/**
    * @Description: 可以飞行的接口
    */
    public interface Flyable {
        //抽象方法:飞行
        public void fly();
        //静态方法:跳舞
        public static void dance() {
        System.out.println("在空中翩翩起舞");
        }
    }

接口中的静态方法，需要使用接口名直接调用，不能使用接口实现类的实例调用

## 2.9：函数式接口 ##

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

/**
    * @Description: 接口中只有一个抽象方法，所以可以定义为函数式接口
    */
    //使用注解表明这是函数式接口，如果该接口不符合函数式接口，会编译出错
    @FunctionalInterface
    public interface Flyable {
        //抽象方法:飞行
        public void fly();
    }

函数式接口可以被隐式转换为 lambda 表达式，lambda 表达式会在以后的课程中讲解。