接口[java]

chen☆

已于 2022-03-28 16:23:36 修改

阅读量630

点赞数 2

文章标签： java 开发语言

于 2022-03-07 20:43:55 首次发布

本文链接：https://blog.csdn.net/m0_58450531/article/details/123339087

版权

⛳️基本概念

接口类似于抽象类(可以看做是一个更彻底的抽象类)，体现为接口中所有的成员方法都是抽象方法。

定义接口的关键字是interface

实现接口的关键字是implements

生活中的接口：U盘、USB风扇、USB鼠标 USB 接口本身没有实现任何功能 USB 接口规定了数据传输的要求 USB 接口可以被多种USB 设备实现编写USB 接口：根据需求设计方法实现USB 接口：实现所有方法使用USB 接口：用多态的方式使用

注意:

1.接口中不能定义成员变量,只能定义常量

2.接口中只能有被public,static,final关键字共同修饰的常量

3.接口中的所有方法都是抽象方法

4.接口中的方法只能被public,abstract,static,default(jdk8之后的新特性),和strictfp修饰

⛳️面向接口编程

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAY2hlbi53eA==,size_20,color_FFFFFF,t_70,g_se,x_16

接口存在的意义：java中一个类只能有一个父类，所以用接口可以实现多继承的逻辑。

⛳️接口的定义和使用

接口的定义：使用 interface 关键字用来声明一个接口。

[访问修饰符] interface 接口名称 [extends 其他的接口名1,….其他的接口名n]
{
// 声明常量 抽象方法 静态方法 默认方法
}

接口的使用：类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。

[访问修饰符] class 类名 implements 接口名1，接口名2……{ }

结合继承：

[访问修饰符] class 类名 extends 父类名 implements 接口名1，接口名2……{ }

案例：

设计一个Fly接口：

public interface Fly {
     void fly();
}

设计一个InterFaceA接口：

public interface InterFaceA {
     void testA();
}

设计一个InterFaceB接口：

public interface InterFaceB {
     void testB();
}

设计一个动物接口：

/*
   jdk8之前 接口只能定义静态常量和抽象方法
   jdk8之后 接口增加了静态方法和默认方法

   interface 修饰的是接口
   接口中没有构造方法，不能创建对象

   接口也表示抽象(功能设计),也是需要其他类来实现的(继承)

   一个接口可以继承多个接口
   一个类可以实现多个接口
   一个类只能直接继承一个类
 */
public interface Animal extends Fly,InterFaceA{

     //public static final int num = 10;
           int num = 10; //接口中的成员变量默认是静态常量

     //public abstract void eat();
           void eat();  //接口定义抽象方法

      //静态方法直接通过接口名调用
      public  static void testStatic(){
          System.out.println("testStatic");
      }

      //默认 通过子类对象调用
      public default void testDefault(){
          System.out.println("testDefault");
      }
}

设计一个Dog类继承Object类实现Animal、InterFaceB接口：一个类实现了某个接口后必须实现该接口定义的所有方法(因为接口中的方法都为抽象方法，jdk8之前)，接口间可以存在继承关系,一个接口可以通过extends关键字继承另外一个接口,子接口继承了父接口中定义的所有方法(这里由于子接口继承了父接口的所有方法，所以当一个类实现了这个子接口时，那么这个类必须实现(重写)这个子接口与父接口中的所有方法(jdk8之前)

//public abstract class Dog  implements Animal{
public  class Dog extends Object  implements Animal,InterFaceB{

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    @Override
    public void fly() {

    }
    @Override
    public void testA() {

    }
    @Override
    public void testB() {

    }
}

设计一个Cat类实现Animal接口：

public class Cat  implements  Animal{

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

    }
    @Override
    public void testA() {

    }
}

测试：

public class Test {
    public static void main(String[] args) {
        /*
          接口名只能调用接口中静态的成员
         */
        //System.out.println(Animal.num);
        //Animal.testStatic();
        //接口类型的引用指向实现类的对象,也就是形成了多态
        //这里的Dog实现了Animal接口,那么Dog也就是Animal接口的实现类 
          Animal dog =   new Dog();
          Animal cat =   new Cat();
    }
    public  void feedAnimal(Animal animal){
           animal.eat();
    }
}