快捷学习1.8前后接口

JDK1.8之前

1.接口声明格式

[访问修饰符]  interface 接口名   [extends  父接口1，父接口2…]  {
         常量定义；       
         方法定义；
}

2.代码

/*
    1.类是类，接口是接口，他们是同一层级的概念
    2.接口中没有构造器
    3.接口如何声明 ： interface
    4.在JDK1.8之前，接口只有两部分内容
    （1）常量：public static final
    （2）抽象方法: public abstract
    注意：修饰符可以省略不写,IDE会默认补全，但是初学者建议都写上，增加印象
 */
public interface TestInterface {
    //常量
    /*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();
}

/*
    5.类和接口是什么关系？ 实现关系： 类实现接口
    6.一旦实现一个接口，那么实现类要重写该接口的所有抽象方法
    7.如果没有重写所有抽象方法，那么这个类可以变成一个抽象类
    8.java只有单继承，但是java有多实现
    一个类继承其他类，但是只能继承一个父类
    但是实现类实现接口的话，可以实现多个接口
    9.写法： 先继承 再实现： extends Person implements TestInterface,TestInterface02
 */

class Student extends Person implements TestInterface,TestInterface02{
    @Override
    public void a() {
        System.out.println("------1");
    }

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

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

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

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


class Test{
    public static void main(String[] args) {
        //接口无法实例化，即不能创建对象
//        TestInterface t = new TestInterface();
        TestInterface02 t = new Student(); // 接口指向实现类---》多态

        //11.接口中常量如何访问
        System.out.println(TestInterface.NUM);
        System.out.println(Student.NUM);

        Student s = new Student();
        System.out.println(s.NUM);
        TestInterface t2 = new Student();
        System.out.println(t2.NUM);
    }
}

3.接口的作用

接口的作用主要是用于定义规则，而实现类负责实现即可；
相较于抽象类不同的地方就在于，他是接口不是类

4.概念分析

继承： 子类对父类的继承
实现： 实现类对接口的实现

举例解说：
“手机” 是不是 “照相机”
继承： 手机 extends 照相机 'is-a’的关系，手机是一个照相机

上面的写法表达，可以感觉到不够好
实现： 手机 implement 照相机 'has-a’的关系， 手机具备照相机的功能

案例： 飞机 ， 小鸟 ， 风筝
定义一个接口：Flyable【他们都可以实现这个能够飞行的功能，但明显他们不能归为一类，说他们继承自一个飞行类，显然不对，这个得在实践中慢慢领会】

5.多态的应用场合

（1） 父类当做方法的形参，传入具体子类的对象
（2） 父类当做方法的返回值，返回具体子类的对象
（3） 接口当做方法的形参，传入具体实现类的对象
（4） 接口当做方法的返回值，返回具体实现类的对象

6.接口和抽象类的区别

截取百度的简要描述，可以简要理解一下，因为现在大部分都是用1.8之后的版本，会有一定的不同

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

回顾一下JDK1.8之前，接口只要两部分内容
1.常量： 固定修饰符：public static final
2.抽象方法： 固定修饰符：public abstract

被public default修饰的非抽象方法

1. default修饰符必须加上否则会报错
2. 实现类要是想重写接口中的非抽象方法，那么default必须不能加，否则报错

public interface TestInterface18 {//1.8之后的接口
    //常量
    public static final int NUM = 10;
    //抽象方法
    public abstract void a();
    //public default 修饰的非抽象方法
    public default void b(){
        System.out.println("----public default,method---");
    }
}

class  A implements TestInterface18 {

    public void c(){
        //用一下接口b方法
        b();//可以
        //super.b();//不可以，接口不能算是该类的父类
        TestInterface18.super.b();//可以，特殊的接口方法调用方式
    }

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

    @Override
    public void b() {
        
    }
}

静态方法

1. static不可以省略不写
2. 静态方法不能重写

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

class Demo implements TestInterface3{

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

    public static void c(){
        System.out.println("Demo中的静态方法");
    }
}

class C{
    public static void main(String[] args) {
        Demo d = new Demo();
        d.c();
        Demo.c();
        TestInterface3.c();
    }
}
运行结果：
Demo中的静态方法
Demo中的静态方法
-----TestInterface3静态方法

为什么接口中要加入非抽象方法？

如果接口中只能添加抽象方法，那么改动接口时，对实现类的影响太大，所有实现类都要跟着重写。
现在在接口中加入非抽象方法，对实现类影响不大，想调用就去调用即可。