JDK1.8_接口

接口组成:

1.变量 public static final

1.定义格式:不写static final 默认也有
    public static final 数据类型 变量名 = 值
    
2.使用:
    接口名直接调用
3.注意事项:
   a.不能被二次赋值
   b.需要我们手动赋值
   c.不写static final 默认也有
   d.在接口中,一般定义变量,变量名需要大写(习惯)

public interface USB {
    public static final int NUM = 10;
    int i = 20;
}
public class Test {
    public static void main(String[] args) {
        System.out.println(USB.NUM);
    }
}

2. 抽象方法

1.定义格式:即使不写abstract 默认也有
  public abstract 返回值类型 方法名(参数);
2.使用:
  a.定义一个实现类,实现接口-->   类名 implements 接口名
  b.重写接口中的所有抽象方法
  c.创建实现类对象(接口不能直接new对象),调用重写的方法

public interface USB {
    public abstract void open();
    public void close();
    void method();

}
public class Mouse implements USB{
    @Override
    public void open() {
        System.out.println("我要打开了");
    }

    @Override
    public void close() {
        System.out.println("我要关闭了");
    }

    @Override
    public void method() {
        System.out.println("我是个method方法");
    }
}
public class Test {
    public static void main(String[] args) {
        Mouse mouse = new Mouse();
        mouse.open();
        mouse.close();
        mouse.method();
    }
}

3.默认方法 jdk1.8

当你不想重写接口中的一部分方法,那就把该部分的方法设置为默认方法即可

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

//接口中默认方法
public interface USB {
    public default void open(){
        System.out.println("人家要开启了,进来吧!");
    }
}
//实现类实现接口后,可以重写默认方法,也可以不重写默认方法
public class KeyBorad implements USB{
    @Override
    public void open(){
        System.out.println("人家要开启了,进来吧!啊~");
    }
}
public class Test {
    public static void main(String[] args) {
        KeyBorad keyBorad = new KeyBorad();
        keyBorad.open();
    }
}

4.静态方法 jdk1.8

防止多继承接口的时候,不知道谁去调用对应的方法,所以引入静态方法,只能通过接口去调用对应的静态方法.

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

public interface USB {
    public static void open(){
        System.out.println("我打开了,进来吧!啊~");
    }
}
public class Test {
    public static void main(String[] args) {
        USB.open();
    }
}

5.私有方法 jdk1.9

public interface Eat {
    default void defMethod() {//默认方法可以调用私有的静态和非静态方法
        priMethod();
    }
    static void staticMethod() { //静态方法必须调用私有的静态方法
        priMethod();
    }
    static void priMethod() {  //私有静态方法  没有加private关键字
        System.out.println("东方大道多多多");
    }
}

    public static void main(String[] args) {

            Eat.staticMethod();//静态方法,直接由接口调用即可
        System.out.println("==============");
            EatImpl eat = new EatImpl();
            eat.defMethod();//默认方法,用对象直接调用即可

        }

6.接口的特点

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

7.接口和抽象类的区别

在这里插入代码片抽象类:
   一般作为父类来使用,什么都可以有  构造 成员变量 普通方法 静态方法 抽象方法
接口:功能的集合
   都是作为标准-->抽取的都是方法

**相同点:**

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

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

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

**区别:**

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

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

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

- 成员区别

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

- 关系区别

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

- 设计理念区别

  - 抽象类

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

  - 接口

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

讲完抽象类和接口后,相信有许多同学会存有疑惑,两者的共性那么多,只留其中一种不就行了,这里就得知道抽象类和接口从根本上解决了哪些问题.

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

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

	接口还是后面一个知识点的基础(lambada)