Java-接口（JDK1.8之前与JDK1.8之后）

最新推荐文章于 2023-05-07 11:52:38 发布

Rick_HHF

最新推荐文章于 2023-05-07 11:52:38 发布

阅读量878

点赞数 2

分类专栏：初学Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_52453515/article/details/127817161

版权

初学Java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

一、接口（JDK1.8之前）

二、接口（JDK1.8之后）

一、接口（JDK1.8之前）

1.接口声明格式：

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

常量定义；

方法定义；

}

2.代码演示：

package interfaceStudy;
/*
 * 1.类是类，接口是接口，它们是同一个层次的概念
 * 2.接口中没有构造器
 * 3.接口如何声明：interface
 * 4.在JDK1.8之前，接口只有两部分内容：
 *  （1）常量：固定修饰符：public static final
 *  （2）抽象方法：固定修饰符：public abstract
 *  注意：修饰符可以省略不写，IDE会自动补全
 */

public interface TestInterface01 {
    //常量：
    public static final int NUM = 10;

    //抽象方法
    public abstract void a();
    public abstract void b(int num);
    public abstract void c(String name);
}
/*
5.类和接口的关系是什么？   实现关系    类实现接口：
6.一旦实现一个接口，那么实现类要重写接口中的全部抽象方法：
7.如果没有全部重写抽象方法，那么这个类可以变成一个抽象类。
8.Java只有单继承，Java还有多实习
一个类继承其他类，只能直接继承一个父类
但是实现类实现接口的话，可以实现多个接口
9.写法：先继承 再实现：extends Person implements TestInterface01,TestInterface02
 */
class Student extends Person implements TestInterface01,TestInterface02{
    @Override
    public void a() {
        System.out.println("---1---");
    }

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

    @Override
    public void c(String name) {
        System.out.println("---3---");
    }

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

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

interface TestInterface02{
    void e();
    void f();
}

class Test{
    public static void main(String[] args) {
        //10.接口不能创建对象：
//        TestInterface02 t = new TestInterface02();--->报错
        TestInterface02 t = 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);//接口实现类.常量

    }
}

总结：

类是类，接口是接口，它们是同一个层次的概念
接口中没有构造器
接口如何声明：interface
在JDK1.8之前，接口只有两部分内容：（1）常量：固定修饰符：public static final；（2）抽象方法：固定修饰符：public abstract。注意：修饰符可以省略不写，IDE会自动补全
类和接口的关系是什么？实现关系类实现接口
一旦实现一个接口，那么实现类要重写接口中的全部抽象方法
如果没有全部重写抽象方法，那么这个类可以变成一个抽象类
Java只有单继承，Java还有多实现。一个类继承其他类，只能直接继承一个父类，但是实现类实现接口的话，可以实现多个接口
写法：先继承再实现：extends Person implements TestInterface01,TestInterface02
接口不能创建对象：

3.接口的作用是什么？

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

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

4.继承：子类对父类的继承

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

举例：

手机是不是照相机

继承：手机 extends 照相机 ————》“is-a”的关系，手机是一个照相机，很明显，这不是

实现：手机 implements 拍照功能————》“has-a”的关系，手机具备（拥有）照相的能力

5.多态的应用场合：

父类当做方法的形参，传入具体的子类的对象
父类当做方法的返回值，返回的是具体的子类的对象
接口当做方法的形参，传入具体的实现类的对象
接口当做方法的返回值，返回的是具体的实现类的对象

6.接口和抽象类的区别：

共性：都是不断抽取出来的概念

区别1：抽象类体现继承关系，一个类只能单继承；接口体现实现关系，一个类可以多实现

区别2：抽象类是继承，是“is a ”关系（是什么）；接口是实现，是“like a ”关系（像什么）

区别3：抽象类可以定义非抽象方法，供子类直接使用；接口的方法都是抽象，接口中的成员都有固定修饰符

举个例子，每个人都用过 ppt中的模板，如果用模板 A设计了 pptB和 pptC, pptB和 pptC的公共部分就是模板 A，那么只要修改模板 A即可，那么只要修改模板 A和 pptC即可。和辐射式的设计一样，例如某一部电梯已经安装了某种报警装置，一旦要更新报警，就必须更新。也就是，对于抽象类，如果需要添加新方法，可以直接在抽象类中添加具体实现，子类可以不更改；对于接口，如果接口做了更改，所有实现该接口的类都必须做相应的修改。

二、接口（JDK1.8之后）

1.在JDK1.8之前，接口中只有两部分：、

（1）常量：固定修饰符：public static final

（2）抽象方法：固定修饰符：public abstract

在JDK1..8之后，新增非抽象方法：

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

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

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

代码演示：

package com.hhf.test02;


public interface TestInterface {
    //常量：
    public static final int NUM=10;
    //抽象方法：
    public abstract void a();
    //public default 修饰的非抽象方法
    public default void b(){
        System.out.println("非抽象方法");
    }
}

class Test implements TestInterface{
    public void c(){
        //用一下接口中的b方法：
        b();//可以
        //super.b();不可以
        TestInterface.super.b();//可以
    }
    @Override
    public void a() {
        System.out.println("重写了a方法");
    }

    @Override
    public void b() {
        System.out.println("重写了b方法");
    }
}

（2）静态方法：

注意1：static不可以不写

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

package com.hhf.test02;


public interface TestInterface2 {
    //常量
    public static final int NUM=10;
    //抽象方法：
    public abstract void a();
    //public default非抽象方法
    public default void b(){
        System.out.println("非抽象方法");
    }
    //静态方法：
    public static void c(){
        System.out.println("TestInterface2中的静态方法");
    }
}

class Demo implements TestInterface2{
    @Override
    public void a() {
        System.out.println("重写了a方法");
    }
    public static void c(){
        System.out.println("Demo中的静态方法");
    }
}

class A{
    public static void main(String[] args) {
        Demo d = new Demo();
        d.c();
        Demo.c();
        TestInterface2.c();
    }
}

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

如果接口中只能定义抽象方法的话，那么我要是修改接口中的内容，那么对实现类的影响太大，所有实现类都会受到影响

现在在接口中接入非抽象方法，对实现类没有影响，想调用就去调用即可