：Java之接口基本概念和接口实现多继承

Posted 2022-08-03 快乐江湖

• 注意：本文中会多次使用上一节（第九章：Java多态理解、多态实现、重写、转型和抽象类）中的抽象类

文章目录

• 一：接口基本概念
• • （1）接口是什么
  • （2）语法规则
  • （3）接口使用及其特性
• 二：使用多个接口完成多继承
• • （1）Java无法像C++那样直接实现多继承
  • （2）接口实现多继承
  • （3）多继承使用
• 三：接口之间的继承
• 四：接口使用示例
• • （1）实现自定义类型比较

一：接口基本概念

（1）接口是什么

接口：接口就是公共的行为准则，实现时只要符合规范准则，就可以通用。在Java中，接口被看做是多个类的公共规范，是一种引用数据类型

（2）语法规则

语法规则：与定义类的格式一致，只需要将关键字class换成interface即可

interface Shape 
    void draw();

（3）接口使用及其特性

接口的使用：接口不可以直接使用，必须要有一个“实现类”来实现该接口的所有抽象方法，需要借助关键字implements。注意以下特性

• 接口中的成员变量，默认会被public static final修饰
• 接口中的成员方法，默认为抽象方法，也即被public abstract修饰
• 接口中的普通成员方法，是不能有具体实现的（在jdk 8之后，加上default后可以有具体实现）
• 接口中可以有静态成员方法
• 接口中不可以有静态代码块和构造方法
• 接口不可以被实例化
• 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
• 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

interface Shape 
    void draw();


class Rectangle implements Shape
    @Override
    public void draw()
        System.out.println("画一个矩形");
    


class Triangle implements Shape
    @Override
    public void draw()
        System.out.println("画一个三角形");
    

class Circle implements Shape
    @Override
    public void draw()
        System.out.println("画一个三角形");
    

public class TestDemo 

    public static void drawing(Shape input)
        input.draw();
    

    public static void main(String[] args) 
        drawing(new Circle());
    

二：使用多个接口完成多继承

如下是一个多态体系

• Animal为父类（抽象类），内含抽象方法eat()
• Dog和Bird分别继承自Animal

abstract class Animal
    public String name;
    public int age;
    public Animal(String name, int age)
        this.name = name;
        this.age = age;
    
    public abstract void eat();


class Dog extends Animal
    public Dog(String name, int age)
        super(name, age);
    
    @Override
    public void eat()
        System.out.println(name + "正在吃狗粮");
    


class Bird extends Animal
    public Bird(String name, int age)
        super(name, age);
    
    @Override
    public void eat()
        System.out.println(name + "正在吃鸟食");
    


public class TestDemo 
    public static void eating(Animal animal)
        animal.eat();
    
    public static void main(String[] args) 
        eating(new Dog("旺财", 2));
        eating(new Bird("啾啾", 3));
    

这里我们加入一个新的抽象方法fly()，用于描述“飞翔”这种行为。但是这里就会出现一个很难受的地方，所有的动物都会eat()，但不一定都会fly()，比如狗就不会飞翔。所以这个抽象方法fly()放到Animal中并不合适，那应该怎么解决呢？

（1）Java无法像C++那样直接实现多继承

由于C++中是支持多继承语法的，所以我们可以再建立一个新的类AnimlFly用于描述某些动物具有的飞翔行为

• 注意：多继承是有很大弊端的，而且会使整个继承体系变得混乱不堪，所以Java中直接取消了这种语法

class Animal
public:
	eat()
private:
	name;
	age;


class AnimalFly()
public:
	fly();
private:
	name;
	age;


class Dog:public Animal
	eat();


//多继承
class Bird:public Animal, public AnimalFly
	eat();
	fly();

但这样的写法在Java中是会报错的

• 纠错：下方的AnimalSpecial应该是AnimalFly

（2）接口实现多继承

在Java中，可以用接口完成这样的需求。建立一个接口AnimalFly，需要这种行为的类重写接口下的方法即可

abstract class Animal
    public String name;
    public int age;
    public Animal(String name, int age)
        this.name = name;
        this.age = age;
    
    public abstract void eat();


interface AnimalFly
    void fly();


class Dog extends Animal
    public Dog(String name, int age)
        super(name, age);
    
    @Override
    public void eat()
        System.out.println(name + "正在吃狗粮");
    


class Bird extends Animal implements AnimalFly
    public Bird(String name, int age)
        super(name, age);
    
    @Override
    public void eat()
        System.out.println(name + "正在吃鸟食");
    

    @Override
    public void fly() 
        System.out.println(name + "正在天上飞");

    

再比如Dog和Bird都可以跑，所以可以建立一个接口AnimalRun

abstract class Animal
    public String name;
    public int age;
    public Animal(String name, int age)
        this.name = name;
        this.age = age;
    
    public abstract void eat();

//飞的行为
interface AnimalFly
    void fly();

//跑的行为
interface AnimalRun
    void run();


class Dog extends Animal implements AnimalRun
    public Dog(String name, int age)
        super(name, age);
    
    @Override
    public void eat()
        System.out.println(name + "正在吃狗粮");
    
    @Override
    public void run()
        System.out.println(name + "正在用四条腿跑路");
    


class Bird extends Animal implements AnimalFly, AnimalRun
    public Bird(String name, int age)
        super(name, age);
    
    @Override
    public void eat()
        System.out.println(name + "正在吃鸟食");
    

    @Override
    public void fly() 
        System.out.println(name + "正在天上飞");

    
    @Override
    public void run()
        System.out.println(name + "正在用两个脚丫跑路");
    

（3）多继承使用

使用时，直接用接口作为形参接受对象即可，也即向上转型

abstract class Animal
    public String name;
    public int age;
    public Animal(String name, int age)
        this.name = name;
        this.age = age;
    
    public abstract void eat();

//飞的行为
interface AnimalFly
    void fly();

//跑的行为
interface AnimalRun
    void run();


class Dog extends Animal implements AnimalRun
    public Dog(String name, int age)
        super(name, age);
    
    @Override
    public void eat()
        System.out.println(name + "正在吃狗粮");
    
    @Override
    public void run()
        System.out.println(name + "正在用四条腿跑路");
    


class Bird extends Animal implements AnimalFly, AnimalRun
    public Bird(String name, int age)
        super(name, age);
    
    @Override
    public void eat()
        System.out.println(name + "正在吃鸟食");
    

    @Override
    public void fly() 
        System.out.println(name + "正在天上飞");

    
    @Override
    public void run()
        System.out.println(name + "正在用两个脚丫跑路");
    


public class TestDemo 
    //通用行为
    public static void eating(Animal animal)
        animal.eat();
    
    //飞翔行为
    public static void flying(AnimalFly animalFly)
        animalFly.fly();
    
    //跑路行为
    public static void running(AnimalRun animalRun)
        animalRun.run();
    
    public static void main(String[] args) 
        Dog dog = new Dog("旺财", 2);
        Bird bird = new Bird("啾啾", 3);
        eating(dog);
        eating(bird);
        System.out.println("----------------------------");
        flying(bird);
        System.out.println("----------------------------");
        running(dog);
        running(bird);
    

三：接口之间的继承

在Java中，接口也可以继承一个接口，达到复用的效果。接口之间的继承相当于把多个接口合并在一起

interface A
    void A_method();

interface B
    void B_method();

interface C extends A, B
    


class D implements C
    @Override
    public void A_method()
        
    
    @Override
    public void B_method()

    

四：接口使用示例

Java中为我们提供了很多的接口，大大简化了我们编写程序的困难，这里举两个例子，展示一下它们的基本使用方法

（1）实现自定义类型比较

如下是一个Student类，内含成员变量name、age和score，实例化两个对象student1和student2

class Student
    public String name;
    public int age;
    public double score;

    public Student(String name, int age, double score)
        this.name = name;
        this.age = age;
        this.score = score;
    


public class TestDemo 
    public static void main(String[] args) 
        Student student1 = new Student("张三", 27, 92.3);
        Student student2 = new Student("李四", 25, 96.3);
    

对于基本数据类型，例如int a = 10，int b = 20的大小比较，Java是很容易做到的。但是对于自定义类型，例如上面的student1和student2是不能直接比较的，因为Java对于它们的比较“无从下手”（是比较age呢还是比较score呢？）。在C++中可以通过运算符重载达到，但是这个机制会显得代码十分臃肿，比如下面

bool operator==(Date& d1,Date& d2)//运算符重载函数

	return d1._year==d2.year
	&&d1.month==d2.month
	&&d3.day=d3.day;

而在Java则可以通过相关接口实现。在这里例子中需要借助接口Comparable，让Student类实现该接口

其中Comparable<T>中的<T>在Java泛型中会讲到，这里在<T>中填入你想要比较的类型即可，所以我们填入Student。接着在Student类中重写该接口的抽象方法compareTo

class Student implements Comparable<Student>
    public String name;
    public int age;
    public double score;

    public Student(String name, int age, double score)
        this.name = name;
        this.age = age;
        this.score = score;
    
    @Override
    public int compareTo(Student student)
        if(this.age > student.age)
            return 1;
        else if(this.age == student.age)
            return 0;
        else
            return -1;
        
    


public class TestDemo 
    public static void main(String[] args) 
        Student student1 = new Student("张三", 27, 92.3);
        Student student2 = new Student("李四", 25, 96.3);
        if(student1.compareTo(student2) > 0)
            System.out.println(student1.name + "的年龄大");
        else if(student1.compareTo(student2) == 0)
            System.out.println(student1.name + "和" +student2.name + "的年龄一样的");
        else
            System.out.println(student2.name + "的年龄大");
        
    

java基础之十四：接口

从Java线程到kotlin协程之线程的基本使用

测试必备之Java知识———— 线程相关

Java 多线程之 Thread 类 和 Runnable 接口初步使用

Python全栈之路系列----之-----面向对象4接口与抽象,多继承与多态)

API的概念与使用