第八章_Java中的接口

第八章_Java中的接口

1.什么是接口

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

Java中接口存在的两个意义

1. 用来定义规范
2. 用来做功能的拓展

2.接口的定义

接口使用关键字interface修饰

public interface 接口名 {} 

接口中的抽象方法

public interface TestInterface {
    //接口中的方法默认使用public abstract修饰
    /*public abstract（可以省略不写）*/ void method();
}

接口的实现

//接口的实现类需要重写接口中所有的抽象方法
public class 类名 implements 接口名 {}

接口不能实例化

​ 我们可以创建接口的实现类对象使用

接口的子类

​ 1.子类直接重写接口中所有的抽象方法

​ 2.子类也是抽象类，就不用重写抽象方法了，最后由子类的子类去实现接口的方法

3.接口的成员特点

3.1成员的发展历程

成员:
     jdk7:
        抽象方法:即使不写abstract 默认也有
           public abstract 返回值类型 方法名(参数);
           
        常量:即使不写static final默认也有
           public static final 数据类型 变量名 = 值
           
     jdk8:
         默认方法
         静态方法
     jdk9:
         私有方法

3.2成员变量

特点

​ 只能是常量

​ 默认修饰符：public static final，不写默认也有

使用

​ 接口名直接调用 – > 接口名.变量名

注意事项
a.不能被二次赋值
b.需要我们手动赋值
c.不写public static final 默认也有
d.在接口中,一般定义变量,变量名需要大写(习惯)

3.3成员方法

特点

​ 只能是抽象方法

​ 默认修饰符：public abstract，不写默认也有

使用

a.定义一个实现类,实现接口–> 类名 implements 接口名
b.重写接口中的所有抽象方法
c.创建实现类对象(接口不能直接new对象),调用重写的方法

3.4构造方法

没有构造方法，因为接口主要是扩展功能的，而没有具体存在，所以不能使用接口直接new对象

代码演示：

1.定义接口和实现类

public interface TestInterface {
    public static final int NUM = 10;
    public abstract void show();
}
class implInterface implements  TestInterface{
    @Override
    public void show() {
        System.out.println("接口中的NUM是："+NUM);
    }
}

2.测试类测试

public class Test {
    public static void main(String[] args) {
        TestInterface testInterface = new implInterface();
        testInterface.show();
    }
}

执行效果：

3.5默认方法

1.定义格式:
修饰符 default 返回值类型 方法名(参数){
方法体
return 结果;
}
2.使用:(与普通的方法一样)
a.定义实现类 实现 接口 implements
b.实现类中可以重写(在增强接口中的功能时),也可以不重写
c.创建实现类对象,去调用方法

3.作用

​ 解决接口升级的问题

4.注意事项

• 默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字
• public可以省略，default不能省略
• 如果实现了多个接口，多个接口中存在相同的方法声明，子类就必须对该方法进行重写

​ 代码演示：

public interface InterfaceA {
    public default void show(){
        System.out.println("我是接口A中的默认方法");
    }
}
class Impl_A implements InterfaceA{
    @Override
    public void show() {
        //实现类中保留接口中的方法，并在原来的基础上进行增强
        InterfaceA.super.show();
        System.out.println("----------------------------");
        System.out.println("实现类中重写了接口A的默认方法");
    }
}
class Test{
    public static void main(String[] args) {
        Impl_A implA = new Impl_A();
        implA.show();
    }
}

执行效果：

3.6静态方法

1.定义格式:
修饰符 static 返回值类型 方法名(参数){
方法体
return 结果
}
2.使用:（与普通静态方法一样）
接口名直接调用

3.注意事项

• 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
• public可以省略，static不能省略

代码演示：

public interface InterfaceA {
    public static void method(){
        System.out.println("接口A的静态方法");
    }
}

class Test{
    public static void main(String[] args) {
        InterfaceA.method();
    }
}

执行效果：

3.7私有方法

私有方法产生原因

​ Java 9中新增了带方法体的私有方法，这其实在Java 8中就埋下了伏笔：Java 8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是Java 9增加私有方法的必然性

• 定义格式

  • 格式1

    private 返回值类型 方法名(参数列表) { }

  • 范例1

    private void show() {  
    }
    

  • 格式2

    private static 返回值类型 方法名(参数列表) { }

  • 范例2

    private static void method() {  
    }
    

• 注意事项

  • 默认方法可以调用私有的静态方法和非静态方法
  • 静态方法只能调用私有的静态方法

4.接口和类的关系

• 类与类的关系

  ​ 继承关系，只能单继承，但是可以多层继承

• 类与接口的关系

  ​ 实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

• 接口与接口的关系

  ​ 继承关系，可以单继承，也可以多继承

5.接口和抽象类的区别

抽象类:
一般作为父类来使用,什么都可以有 构造 成员变量 普通方法 静态方法 抽象方法
接口:

​ 功能的集合
都是作为标准–>抽取的都是方法

相同点:

1.都位于继承的顶端,用于被其他类实现或继承;

​ 2.都不能直接实例化对象;

​ 3.都包含抽象方法,其子类都必须覆写这些抽象方法;

区别:

1.抽象类为部分方法提供实现,避免子类重复实现这些方法,提高代码重用性;接口只能包含抽象方法;

2.一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)

3.抽象类为继承体系中的共性内容,接口为继承体系中的扩展功能

• 成员区别

  • 抽象类
    • 变量,常量；有构造方法；有抽象方法,也有非抽象方法
  • 接口
    • 常量；抽象方法

• 关系区别

  • 类与类
    • 继承，单继承
  • 类与接口
    • 实现，可以单实现，也可以多实现
  • 接口与接口
    • 继承，单继承，多继承

• 设计理念区别

  • 抽象类

    • 对类抽象，包括属性、行为

  • 接口

    • 对行为抽象，主要是行为

6.接口特点

1.接口可以多实现(一个实现类可以同时实现多个接口)–>必须要重写所有接口中的所有抽象方法
类 implements 接口1,接口2
2.接口可以多继承(一个接口可以同时继承一个或者多个接口)
接口 extends 接口1,接口2…
3.一个类可以继承一个父类的同时实现一个或者多个接口
类 extends 父类 implements 接口1,接口2

7.总结注意事项

1.一个类继承一个父类的同时实现一个或者多个接口,要重写所有的抽象方法
2.如果两个接口中有重名的抽象方法,那么我们就可以重写一个
3.如果两个接口中有重名的默认方法,那么我们必须重写一个
4.如果接口中有和父类的方法一样的默认方法,那么我们先执行父类的
5.父接口中如果有重名的默认方法,那么子接口中要重写一次