【java笔记】接口的定义，接口的使用

接口声明时，如果关键字interface前面加上public->public接口，可以被任何一个类使用

如果一个接口不加public修饰->友好接口类，可以被同一个包中的类使用

java7接口中可以包含

1、常量

2、抽象方法

java8接口中额外包含：

3、默认方法

4、静态方法

java9接口额外包含：

5、私有方法

接口抽象方法：

注意：
1、接口当中的抽象方法，修饰符必须是两个固定的关键字，public abstract

2、这两个关键字修饰符，可以选择性地省略

使用：

1、接口不能直接使用。必须有一个实现类来实现接口

格式：
public  class 类名称 implements 接口名称{

//..

}

2、接口的实现类必须覆盖重写接口中所以的抽象方法

重写接口中的方法，访问权限一定时public

3、创建实现类的对象，进行调用

public interface MyInterface {

    public abstract void method();
    void method1();
}

public class a implements MyInterface{
    @Override
    public void method() {
        System.out.println("这是第一个方法");
    }

    @Override
    public void method1() {
        System.out.println("这个是第二个方法");
    }
}

public class b {
    public static void main(String[] args) {
        a aa=new a();
        aa.method();
        aa.method1();
    }
}

如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己必须是一个抽象类 

 接口的默认方法：

格式：
public default 返回值类型 方法名称（参数列表）{

 方法体

}

public可以省略

接口中的默认方法

1、可以解决 接口升级的问题

2、可以和函数式编程结合

如果一个接口有已经定义许多个子类，但是如果在接口中又新增了一个方法（这个方法如果不另加说明为抽象方法），为了让子类都覆盖了抽象方法，就不得不在每一个子类中都覆盖这个新加 的抽象方法，但是这样又会很麻烦。

所以可以把新添加的方法改为默认方法

public interface MyInterface {
void method();
public default void method1(){
    System.out.println("新添加的方法");
}

}
public class a implements MyInterface {

    @Override
    public void method() {
    }

}

public class b {
    public static void main(String[] args) {
a aa=new a();
aa.method();
aa.method1();
    }
}

接口的默认方法会被子类继承，可以由子类调用

这样就可以不用全部都重新覆盖，但子类仍然可以调用新添加的方法

注意：接口的默认方法也可以被子类覆盖重写

接口的静态方法：

public static 返回值 方法名称（参数名称）{

      方法体

}

public可以省略

 不能通过接口实现类的对象来调用接口当中的静态方法

通过接口名称，直接调用其中的静态方法:

接口名称.静态方法名（参数）

public interface MyInterface {
public static void method1(){
    System.out.println("调用静态方法");
}
}

public class b {
    public static void main(String[] args) {
    MyInterface.method1();
    }
}

接口的私有方法：

如果需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。

但是这个共有方法不应该让实现类使用，应该是私有化的。

所以，应该把这个共有方法实设为私有的

1、普通私有方法，解决多个默认方法之间重复代码问题：

private 返回值类型 方法名称（参数列表）{

    方法体}

2、静态私有方法，解决多个静态方法之间重复代码问题：

格式：
private static 返回值 方法名称（参数列表）{

方法体}

public interface MyInterface {
public default  void method1(){
    method();
}
public default void method2(){
    method();
}
private void method(){
    System.out.println("111");
}
}
public class a implements MyInterface {

}
public class b {
    public static void main(String[] args) {
    a aa=new a();
    aa.method1();
    aa.method2();
    }
}

public interface MyInterface {
public static   void method1(){
    method();
}
public static void method2(){
    method();
}
private static void method(){
    System.out.println("111");
}
}
public class a implements MyInterface {


}
public class b {
    public static void main(String[] args) {
 MyInterface.method1();
 MyInterface.method2();
    }
}

接口的常量

接口当中也可以定义”成员变量“，但是必须使用public static final 三个关键字进行修饰

从效果上看，其实是接口的【常量】

public static final 数据类型 常量名称=数据值；

注意：

（1）一旦使用final关键字进行修饰，说明不可改变

（2）接口中的常量，可以省略【public】 【static】 【final】 ，注意，不写照样也是这样

（3）接口中的常量，必须进行赋值，不能不赋值

（4）常量的命名为大写，且用下划线分割

常量的使用：

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

使用接口时候，需要注意：、

1、接口是没有静态代码块或者构造方法的

2、一个类的直接父类是唯一的，但是一个类可以同时实现多个接口

public class MyInterface implements MyInterfaceA,MyInterfaceB{
 //覆盖重写所有抽象方法
}

接口也是可以被继承的，可以通过关键字extends声明一个接口是另一个接口的子接口，（public）子接口将继承父接口中全部方法和常量

接口与接口之间是多继承的

Public interface MyInterface extends MyInterfaceA,MyinterfaceB{

}

   (1)多个父接口当中的抽象方法如果重复没有关系

（2)多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写【带default关键字】

（3）父类实现了某个接口，那么子类就自然实现了该接口，子类不必再显示地使用关键字Implements声明

3、如果实现类所实现的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一次

4、如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类

5、如果实现类所实现的多个接口当中，存在重复的默认方法，那么类一定要对冲突的默认方法进行覆盖重写

6、一个类如果直接父类当中的方法和接口当中默认方法产生了冲突，优先用父类当中的方法