什么是接口 | 接口的特点 | 抽象类和接口的区别 | 接口之间的多继承

原创于 2024-09-23 09:36:21 发布 · 1k 阅读

11 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

Java基础知识

接口

接口基本概述及格式

接口概述

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法（功能），包含抽象方法 (JDK7及以前) , 默认方法和静态方法（JDK8）私有方法（JDK9）。

总结

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。

Java中的接口更多的体现在对行为的抽象！

接口定义格式

接口用关键字interface修饰

public interface 接口名 {}

接口的使用

接口是不能创建对象，必须有实现类才能使用，类实现接口用implements表示

public class 类名 implements 接口名 {}

注意: 接口的实现类必须重写接口中的所有的抽象方法，要么该类是一个抽象类

接口成员的特点

成员变量

只能是常量，默认修饰符：public static final

成员方法

只能是抽象方法，默认修饰符：public abstract

构造方法

没有，因为接口主要是扩展功能的，而没有具体存在

代码演示

接口

public interface Inter {

    //接口只能是常量
    //默认修饰符：public static final
    public int num1 = 10;
    public final  int num2 = 20;
    public static final int num3 = 30;
    int num4 = 40;

    //接口没有构造方法
    // public Inter() {}

    //接口中不能有方法主体
    // public void show() {}

    //默认修饰符：public abstract 
    public abstract void method1();

    public void method2();

    void show();

}

实现类

//子类可以是抽象类。但是意义不大
public abstract class InterImpl extends Object implements  Inter {}

/**
 *   字类是具体类，要实现接口中所有的抽象方法
 *   所有类都默认继承Object类，Object类是所有类的超类
 */
public class InterImpl extends Object implements  Inter {
    public InterImpl(){
        super();//所有super走得是object类
    }
 
    @Override
    public void method1() {
        System.out.println("实现类中的method1");

    }

    @Override
    public void method2() {
        System.out.println("实现类中的method2");

    }

    @Override
    public void show() {
        System.out.println("实现类中的show");
    }
}

测试类

public class Test {
    public static void main(String[] args) {

        //接口不能实例化
        // Inter i = new Inter();

        //通过多态的方法实
        Inter i = new InterImpl();

        //访问成员变量
        System.out.println(i.num1);

        //接口的常量是不能修改的
        // i.num1 = 100;

        i.method1();
        i.method2();
        i.show();
    }
}

类与类的关系

类与类：
    继承关系,只能单继承,不能多继承,可以多层继承。
        
接口与接口：
    继承关系，可以单继承也可以多继承。public interface Sister extends Father,Mother 
    
类与接口：
    实现关系,可以单实现,也可以多实现。 public class Son extends Object implements Father,Mother
    并且还可以在继承一个类的同时实现多个接口。

抽象类和接口的区别

A:成员区别
    抽象类：
        成员变量：可以变量，也可以常量
        构造方法：有
        抽象类不能实现化
        成员方法：可以抽象，也可以非抽象
    接口：
        成员变量：只可以静态常量  可以省略 static final
        构造方法：无
        接口不能实例化
        成员方法：只可以抽象      可以省略abstract
B:关系区别
    类与类
        继承，单继承， 多层继承
    类与接口
        实现，单实现，多实现
    接口与接口
        继承，单继承，多继承

C:设计理念区别
    抽象类【共性功能】。
    接口【扩展功能】。

继承父类并实现多个接口

之前学过，在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

多实现格式

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {    
    // 重写接口中抽象方法【必须】
    // 重写接口中默认方法【不重名时可选】
}

代码演示

定义接口

interface A {
    public abstract void showA();   
    public abstract void show();
}

interface B {
    public abstract void showB();   
    public abstract void show();
}

定义父类
```
public class Fu{}
```

定义实现类

public class C extends Fu implements A,B{
    @Override
    public void showA() {
        System.out.println("showA");    }

    @Override
    public void showB() {
        System.out.println("showB");    }

    @Override
    public void show() {
        System.out.println("show");    }
}

注意事项

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次即可！如果实现类继承了父类，这个父类是一个抽象类时，我们还需要再重写抽象类中的所有抽象方法。

接口之间的多继承

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用extends关键字，子接口继承父接口的方法。如果父接口中的默认方法有重名的，那么子接口需要重写一次。

定义父接口

interface A {
    public void method1();
}

interface B {
    public void method2();
}

定义子接口

interface D extends A,B{
     public void method2();
}

注意

接口多继承之后，如果想使用，我们还必须定义实现类，才能使用

接口小结

接口中只有常量和抽象方法
接口是没有静态代码块和构造方法的。

一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。单继承多实现

public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {
    // 覆盖重写所有抽象方法
}

如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。

接口案例-TODO

需求

对猫和狗进行训练，他们就可以跳高了，这里加入跳高功能。

请采用抽象类和接口来实现猫狗案例，并在测试类中进行测试。

代码实现

Animal类

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

    public Animal() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public abstract void eat();
}

跳高接口Jumping

public interface Jumpping {
    public abstract void jump();
}

猫类(Cat)

//子类继承 抽象类，实现接口
public class Cat extends Animal implements Jumpping {

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

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

    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

测试类

public class AnimalDemo {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.setName("加菲");
        c.setAge(5);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.jump();
    }
}

标签

#java #开发语言 #idea