接口（interface）、实现（inplements）

哆啦A梦的_梦

已于 2022-09-19 13:59:08 修改

阅读量542

点赞数

分类专栏： JavaSE 文章标签： java

于 2022-09-15 18:12:00 首次发布

本文链接：https://blog.csdn.net/zhoulizhengZ/article/details/126874731

版权

JavaSE 专栏收录该内容

56 篇文章 0 订阅

订阅专栏

1、接口声明格式

[访问修饰符] interface 接口名 [extends 父接口1，父接口2…] {

常量定义；

方法定义；

}

2、代码示例

（相关概念见代码）

package Package8_face_the_object.test_interface;
/**
 * 1.类是类，接口是接口，它们是同一层次的概念。
 * 2.接口中没有构造器
 * 3.接口如何声明：interface
 * 4.在JDK1.8之前，接口中只有两部分内容：
   * （1）常量：固定修饰符：public static final
   * （2）抽象方法：固定修饰符：public abstract
 * 注意：修饰符可以省略不写，IDE会帮你自动补全，但是初学者建议写上，防止遗忘。
 */
public interface TestInterface01 {
    //常量
    //int NUM =10;
    /*public static final*/ int NUM = 10;

    //抽象方法  —— 只有抽象方法
    /*public abstract*/ void a();
    public abstract void b(int num);  //注意前面修饰符的颜色
    public abstract int c(String name);
}
interface TestInterface02{
    void e();
    void f();
}
//父类
class Person{
    int a1;
    int a2;
        }
/*
5.类和接口的关系是什么？ 实现关系  类实现接口：
6.一旦实现一个接口，那么实现类要重写接口中的全部的抽象方法：
7.如果没有全部重写抽象方法，那么这个类可以变成一个抽象类。
8.java只有单继承(extends)，java还有多实现(implements),即：
    一个类继承其他类，只能继承一个父类，
    但是类实现接口的话，可以实现多个接口
9.写法：先继承——>再实现：class 子类 extends 父类 implements 接口1 接口2 …… {}
 */

//子类
class Student extends Person implements TestInterface01, TestInterface02 {
   //接口TestInterface01中抽象方法的重写
    @Override
    public void a() {
        System.out.println("-------a");
    }

    @Override
    public void b(int num) {
        System.out.println("-----b");
    }

    @Override
    public int c(String name) {
        return 100;
    }

    //接口TestInterface02中抽象方法的重写
    @Override
    public void e() {
        System.out.println("------e");
    }

    @Override
    public void f() {
        System.out.println("------f");
    }
}
//创建一个测试类(包含main()方法)
class Test{
    public static void main(String[] args) {
        //10、接口(不是类)不能够创建对象（对应：因为接口中没有构造方法？）
        //TestInterface02 t1 = new TestInterface02(); //报错
        //真要想写的话，可以这么写：
        //(因为Student类是该接口的一个具体实现类)
        TestInterface02 t1 = new Student(); // 接口指向实现类
                                            //父类引用子类对象的写法 ——>多态
        //11、接口中的常量如何访问
        //方式很多：
        System.out.println(TestInterface01.NUM);
        System.out.println(Student.NUM);
        Student s = new Student();
        System.out.println(s.NUM);
        TestInterface01 t2 = new Student();
        System.out.println(t2.NUM);
    }
}

3、接口的作用是什么？

定义规则，只是跟抽象类不同地方在哪？它是接口不是类。

接口定义好规则之后，实现类负责实现即可。

4、继承和实现的应用场景

继承：子类对父类的继承

实现：实现类对接口的实现

如：

手机是不是照相机

继承：手机 extends 照相机 “is-a”的关系，手机是一个照相机

上面的写法不好：

实现：手机 implements 拍照功能 “has-a”的关系，手机具备照相的能力

案例：飞机，小鸟，风筝

定义一个接口： Flyable

5、多态的应用场合

（1）父类当做方法的形参，传入具体的子类的对象

（2）父类当做方法的返回值，返回的是具体的子类的对象

（3）接口当做方法的形参，传入具体的实现类的对象

（4）接口当做方法的返回值，返回的是具体的实现类的对象

（两者是类似的）

6、接口和抽象类的区别

7、JDK1.8前后的接口内容对比（新增）

（1）在JDK1.8之前，接口中只有两部分内容：（见上）
1）常量：固定修饰符：public static final
2）抽象方法：固定修饰符：public abstract

（2）在JDK1.8之后，新增非抽象方法:

1）被public default修饰的非抽象方法；

2）静态方法。

1）被public default修饰的非抽象方法：

注意1：default修饰符必须要加上，否则出错；

注意2：实现类中要是想重写接口中的非抽象方法，那么default修饰符必须不能加，否则出错。

代码示例：

package Package8_face_the_object.test_interface;
/*
在JDK1.8之后，新增非抽象方法:
 （1）被public default修饰的非抽象方法(示例：本代码)
 （2）静态方法
*/
public interface TestInterface001 {
    //常量
    public static final int num = 10;
    //抽象方法
    public abstract void a();

    //public default 修饰的非抽象方法  ——  非抽象方法是要有方法体的（不然会报错）
    public default void b(){     //public是有阴影的(代表可以省略不写)，而default必须要写，不可省略
        System.out.println("------TestInterface001---b()---");
    }
}
class Test001 implements TestInterface001{
    //自己的方法
    public void c(){
        //要用一下接口中的b方法
        b();//可以
        //super.b(); //不可以
        TestInterface001.super.b(); //可以
    }
    @Override
    public void a() {
        System.out.println("重写了a方法" );
    }
    //也可以重写b方法，也可以不重写 —— 但是重写的话必须不能再加default了！！！
    @Override
    public void b() {
        //TestInterface001.super.b(); //这行代码是自动生成的？可以省略？
    }
}

2）静态方法：

注意1：static不可以省略不写

注意2：静态方法不能重写

代码示例：

package Package8_face_the_object.test_interface;
/*
在JDK1.8之后，新增非抽象方法:
 （1）被public default修饰的非抽象方法
 （2）静态方法(示例：本代码)
*/
public interface TestInterface002 {
    //常量
    public static final int num = 10;
    //抽象方法
    public abstract void a();
    //public default 非抽象方法
    public default void b(){
        System.out.println("----TestInterface002----b()");
    }
    //静态方法
    public static void c(){   //static不可以省略不写
        System.out.println("TestInterface002中的静态方法");
    }
}
class Demo implements TestInterface002{
    @Override
    public void a() {
        System.out.println("---重写了a方法");
    }

    //public default 非抽象方法-b()也可以重写，这里省略

    //c —— 输入c 不会自动生成c()方法的重写
    //手动重写
    public static void c(){
        System.out.println("Demo中的静态方法(重写后的)");
    }//但其实这里并不是重写，是各自的c()方法
    //因为：静态方法不涉及重写
}
class A{
    public static void main(String[] args) {
        Demo d = new Demo();
        d.c();
        Demo.c();

        TestInterface002.c();
    }
}

疑问：为什么要在接口中加入非抽象方法？？？