java中接口的使用(默认方法和静态方法)

由于最近在学习接口这一部分，就想着记下来，以便以后的复习。如果那里有写的不对的请指正！

1什么是接口（接口概述）

既然要用接口首先要明确什么是接口，它能帮助我们实现什么哪些事儿。
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。 比如如果你是汽车，则必须能跑；如果你是坏人，则必须欺负好人等。

1. 接口是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。
2. 接口是Java语言中的一种引用类型，是方法的"集合"，所以接口的内部主要就是定义方法，包含常量,抽象方法（JDK 7及以前）。

2. 接口声明和使用

[访问修饰符] interface 接口名 [extends 父接口1，父接口2…] {
// 常量
// 抽象方法
// 默认方法(jdk8)
// 静态方法(jdk8)
// 私有方法(jdk9)
}
[]中的内容都是非必须的。访问修饰符只能是public或者默认，接口与接口之间可以实现继承。

 public interface InterfaceDemo {
    public int age = 18;
    String name = "小红";

    public void getMax();

    int setAge();

    public class TestInterface implements InterfaceDemo {
        public static void main(String[] args) {
        //创建一个接口类型的对象，即可调用方法
      		InterfaceDemo ifd = new TestInterface();
            ifd.getMax();
            ifd.setAge();
        }

        @Override
        public void getMax() {
            System.out.println("实现类重写了getMax()方法");
        }

        @Override
        public int setAge() {
            System.out.println("实现类重写了getAge)方法");
            return 0;
        }
    }
}

在调用接口中的属性和方法的时候有两种方式：

1. 接口名 变量名 = new 实现类();
2. 实现类 变量名 = new 实现类();

但是我们使用那种方法创建对象呢？
一般来说，我们选择第一种，但是这样创建对象有一个问题就是，接口类型的变量只能调用接口内部的属性或者方法，但是对于其实现类中特有的方法就无法调用(编译出错)。、

3.接口的特点

1. JDK7及之前：接口中所有的方法隐含都是抽象的，而抽象类则可以同时包含抽象和非抽象的方法；
2. 类可以实现很多个接口，但是只能继承一个抽象类；
3. 类可以不实现抽象类和接口声明的所有方法，在这种情况下，类也必须得声明成是抽象的；
4. 接口是绝对抽象的，不可以被实例化，只能被实现类实现之后使用(注意这里的实现和继承是不一样的)，而且在接口中不能有构造器。
5. java接口中声明的变量默认都是public final的(不用写系统会自动加)。

4.java 新增特性

在JAVA JDK8中新增了默认方法(default)和静态方法(static),JDK 9后又增加了私有方法。下面我们将分别来简单来介绍一下：
4.1 JDK8新增的默认方法：
java8开始允许接口中可以定义默认方法—public default void getMax(){ 方法体 } 注意这里的访问修饰符只能使用public。
1. 为什么要出现默认方法：
当一个接口添加新方法时，需要所有的实现类都重写新方法，影响到了已有的实现类，可能导致应用崩溃；因此为了避免这种问题的出现我们可以使用默认方法来解决。
2. 默认方法的特点：
1.默认方法可以被实现类继承；
2.默认方法可以被子类重写，也可以不重写；
3.子接口中如有同名默认方法，父接口中的默认方法会被覆盖
3.如何使用默认方法（default）
1.当一个实现类实现了多个接口，多个接口里都有相同的默认方法时，实现类必须重写该默认方法，否则编译错误；
2.调用形式：对象名.默认方法名()

interface Penguin {

    default void defaultMethod() {
        getMax();
        System.out.println("定义一个默认方法  其实现类中可以不同重写该方法");
    }

   default String staticMethod() {
        System.out.println("这是一个默认方法);
        getMax();
        return "fsd";
    }
    public void tetsMethod();
}

**实现类：**

public class TestInterface extends TestMrthod implements Penguin {

    public void showInfo() {
        System.out.println("这个是实现类中特有的方法");
    }

    public static void main(String[] args) {
      /*  Penguin p = new TestInterface();
        System.out.println(Penguin.getMax2());
        p.getInfo();

        TestInterface test=new TestInterface();*/

        TestInterface ti = new TestInterface();

        Penguin p = new TestInterface();
        ti.defaultMethod();
        Penguin p = new TestInterface();
        p.defaultMethod();
    }

    @Override
    public void tetsMethod() {
        System.out.println("实现类要重写接口中的抽象方法");
    }
}

4.2 JDK8 静态方法
1. 静态方法特点：(专指接口的)
1.接口中的静态方法不能被子接口继承
2.静态方法不能被实现该接口的实现类继承—无论是创建接口类型的对象还是直接 创建实现类的对象都不能通过 对象.静态方法名来调用;
3.调用形式 只能通过： 接口名.静态方法名()。
2.如何使用静态方法
由于静态方法不能被实现类所继承，因此使用时必须要通过 接口名称.静态方法名

4.3 JDK9 私有方法
1. 为什么要出现私有方法：
*问题描述：*在接口中我们需要抽取一个公共方法，用来解决两个默认方法之间重复代码 的问题，但是这个共有方法不应该让实现类使用，应该是私有化的。因此要解决这个问题就要考虑使用私有方法。
因此，接口中出现私有方法的目的就是解决多个默认方法之间的重复代码问题。
1.普通私有方法是解决多个默认方法之间重复代码的问题；private void method();
2.静态私有方法是解决多个静态方法之间的代码重复问题。 private static void method()
2. 如何使用私有方法
使用过程的话其实和普通类中声明一个私有方法然后使用时一样的，在接口中创建一个私有方法当然只能在本接口内部使用。这里要说的是由于JDK8中出现了默认的方法和静态方法，因此此时的私有方法就可以使用了。

interface Penguin {

    default void defaultMethod() {
        getMax();
        System.out.println("定义一个默认方法  其实现类中可以不同重写该方法");
    }

   default  String staticMethod() {
        System.out.println("分得的点多");
        getMax();  //调用接口内部的私有方法
        return "fsd";
    }

//接口中定义私有的方法，只能在接口内部使用   
    private static void getMax() {
        System.out.println("fsdfsdf");
    }
}

5. 总结

1. 接口是方法的集合，接口的内部主要就是定义方法，包括常量何抽象方法( JDK7及之前)，还可以增加默认方法和静态方法( JDK8) 私有方法( JDK9)。 接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。
2. 实现类在重写接口中的抽象方法时，其方法的访问修饰符只能是public。因为实现类在重写的时候，方法的访问权限不能小于接口中抽象方法的访问权限，而接口中的方法是public因此就决定了实现类重写的方法只能是public。
3. 创建对象时，一般情况下我们使用 接口名 对象名 = new 实现类();去创建 。
4. 抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。
5. 接口中成员的访问特点:
   接口中的常量: 主要是供接口直接使用
   接口中的抽象方法: 供实现类重写的
   接口中的默认方法: 供实现类继承的(实现类中可以直接调用,实现类对象也可以直接调用)
   接口中的静态方法: 只供接口直接调用,实现类继承不了
   接口中的私有方法: 只能在接口中直接调用,实现类继承不了

public interface IA {
    //  接口中的常量: 主要是供接口直接使用
    public static final int NUM = 10;

    // 接口中的抽象方法: 供实现类重写的
    public abstract void method1();

    // 接口中的默认方法: 供实现类继承使用(实现类中可以直接调用,实现类对象也可以直接调用)
    public default void method2(){
        System.out.println("默认方法method2");
        method4();
        method5();
    }

    // 接口中的静态方法: 只供接口直接调用,实现类继承不了
    public static void method3(){
        System.out.println("静态方法method3");
        method5();
    }

    // 接口中的私有方法: 只能在接口中直接调用,实现类继承不了
    private void method4(){// 只能在接口的默认方法中调用
        // 方法体
        method5();
    }

    private static void method5(){//
        // 方法体
    }
}

实现类:

public class ImpA implements IA{

   /* @Override
    public void method2() {

    }*/

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


测试类:

public class Test {
    public static void main(String[] args) {
      
        System.out.println(IA.NUM);// 10

        // 创建实现类对象,访问NUM常量
        ImpA ia = new ImpA();
        System.out.println(ia.NUM);// 10

        // 调用method2方法
        ia.method2();

        // 通过接口名调用接口中的静态方法
        IA.method3();
        //ia.method3();// 编译报错,
    }
}

参考文章：https://juejin.im/post/5f17dd655188252e7e2be00f