Java面向对象3-接口

接口知识点

1、类是类，接口是接口，它们是同一层面的概念

2、接口中没有构造器

3、接口如何声明：interface

4、在JDK1.8之前，接口中只有两部分内容
(1) 常量：public static final
(2) 抽象方法：public abstract
注意：修饰符可以省略不写

5、类和接口的关系是：实现关系 类实现接口（implements）

6、一旦实现一个接口，类要重写接口中的全部抽象方法

7、如果没有全部重写抽象方法，那么这个类可以变成一个抽象类

package yes.javase.oop.javase_220225_b_interface_test;

public interface TestInterface {
    public static final int NUM = 0;
    public abstract void a(String b);
    double f = 0.0;
    void say();
}

class A implements TestInterface{
    @Override
    public void a(String b) {
        System.out.println(b);
    }

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

abstract class B implements TestInterface{
    @Override
    public void say() {
        System.out.println("saying");
    }
}

8、java只有单继承，但java还有多实现
一个类继承其他类，只能直接继承一个父类
但是实现类实现接口的话，可以实现多个接口

package yes.javase.oop.javase_220225_b_interface_test;

public interface TestInterface2 {
    public static final int NUM2 = 0;
    public abstract void a2(String b);
    double f2 = 0.0;
    void say2();
}

package yes.javase.oop.javase_220225_b_interface_test;

public class Test implements TestInterface,TestInterface2 {
    @Override
    public void a(String b) {
        System.out.println();
    }

    @Override
    public void a2(String b) {
        System.out.println();
    }

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

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

9、写法：先继承，再实现
Student Extends Person implements TestInterface01,TestInterface02

10、接口不能创建对象
TestInterface01 t = new TestInterface01(); //错误
TestInterface01 t = new Student() //可以，接口指向了实现类 --》多态
比如，定义一个方法，接口为形参，传值时传一个实现类，就是多态了
或者，方法的返回值是一个接口，具体返回时传一个实现类，也是多态的一种

11、接口中的常量如何访问

    System.out.println(TestInterface.NUM);//通过接口名称访问
    System.out.println(Test.NUM);//通过实现类访问
    Test t = new Test();
    System.out.println(t.NUM);//通过对象访问
    TestInterface ti = new Test();
    System.out.println(ti.NUM);//通过指向实现类的接口名访问

接口的作用
定义规则，只是跟抽象类不同，它是接口，不是类
接口定义好规则之后，实现类负责实现即可

继承和实现的区别
继承：子类对父类的继承，使用场景为代码的重用
实现：实现类对接口的实现，使用场景为具备一个能力

例如，手机 是不是 照相机
继承：手机 extends 照相机 "is-a"的关系，手机是一个照相机 //说不太通
上面的写法不好
实现：手机 implements 拍照功能 "has-a"的关系，手机具备照相的能力

例如：飞机，小鸟，风筝 定义一个接口：Flyable

多态的应用场合
（1）父类当方法的形参，传入具体子类的对象
（2）父类当作方法的返回值，返回具体子类对象
（3）接口当方法的形参，传入具体实现类的对象
（4）接口当作方法的返回值，返回具体实现类对象

接口和抽象类的区别

（百度一下）

在JDK1.8之前，接口中只有两部分内容
(1) 常量：public static final
(2) 抽象方法：public abstract

但是。。。

JDK1.8之后

在JDK1.8之后，接口中新增非抽象方法
(1) 常量：public static final
(2) 抽象方法：public abstract
(3) 非抽象方法：public default / 静态方法

public default

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

package yes.javase.oop.javase_220225_b_interface_test;

public interface TestInterface3 {
    public static final int NUM = 3;
    public abstract void eat();

    //此处default 和 static 必须加，不能省略
    public default void go(){
        System.out.println("go");
    }
    public static void run(){
        System.out.println("run");
    }
}
class Test2 implements TestInterface3{
    @Override
    public void eat() {

    }
    //实现类中要是想重写接口中的非抽象方法，那么default修饰符必须不能加，否则报错
    @Override
    public void go() {

    }
}

调用default非抽象方法：

package yes.javase.oop.javase_220225_b_interface_test;

public interface TestInterface3 {
    public static final int NUM = 3;
    public default void go(){
        System.out.println("go");
    }
}
class Test2 implements TestInterface3{
    public void c(){
        go();//可以直接调用
        //不可以super.go();
        TestInterface3.super.go();//这样也可以
    }
}

静态方法

注意1: static 不可以省略
注意2: 静态方法不能重写，接口和实现类调用各自的静态方法

package yes.javase.oop.javase_220226_interface_test2;

public interface TestInterface4 {
    //常量
    public final int NUM = 0;
    //抽象方法
    public abstract void a();
    //非抽象方法
    //default 不可以省略
    public default void b(){
        System.out.println("test interface4 : b");
    }
    //static 不可以省略
    public static void c(){
        System.out.println("test interface4 : c");
    }
}
class TestClass implements TestInterface4{
    @Override
    public void a() {
        System.out.println("test class : a");
    }
    public static void c(){
        System.out.println("test class : c");
    }
}

package yes.javase.oop.javase_220226_interface_test2;

public class Test {
    public static void main(String[] args) {
        TestClass tc = new TestClass();
        tc.a();
        tc.b();
        //静态方法不能重写，接口和实现类调用各自的静态方法
        TestClass.c();
        TestInterface4.c();

        TestInterface4 ti = new TestClass();
        ti.a();
        ti.b();
    }
}