接口 Interface

一、接口

1.使用interface关键字定义接口，接口中(接口里)的访问权限都是public

声明格式：

[public 或 不写（默认）] interface TestInterface{

}

2.接口中没有普通变量，只有静态常量如果简写（只写数据类型 +变量名），会自动拼接 public static final

注意：接口中的常量可以使用引用名和接口名.调用

 int a = 2; 等价于 public static final int a = 2;

注意： static 和 final 修饰的变量为静态常量，必须声明并初始化。

3、方法：JDK8之前，接口中没有普通方法，都是抽象方法，如果简写（只写 返回值类型 方法名（[参数列表]）;），会自动拼接public abstract

例如：

void show(); 等价于 public abstract void show();

4.JDK8后，接口中可以添加使用static 或 default 修饰普通方法,此处的default 不是权限修饰符，只是修饰词，有方法体；

• 注意：接口中的静态方法只能使用接口名.方法名([参数列表])直接调用,不能使用对象.调用

   public static void show(){
        System.out.println("接口中的static方法");
    }
  public default void show2(){
        System.out.println("接口中的default方法");
    }

5.接口中没有构造方法：Interface cannot have constructors

6.使用implements关键字实现接口

[访问权限修饰符 |  abstract ]class  类名  implements 接口名1，接口名2{
	类体；
}

7、使用implements关键字实现接口，接口的实现类要么重写接口中的所有抽象方法，要么将自己定义为抽象类。

abstract class Student implements Person{
	类体；
}

package JAVA_OOP.com.huacit.day04poly;

/**
 * @author yyc
 * 接口interface：
 * 接口中的变量是静态常量，（static 和 final 省略 也是默认拼接了public static 和 final）
 *
 */
public class Test4_Interface {
    public static void main(String[] args) {
        //接口不能实例化
        //Person p = new Person();编译报错。
        //创建多态对象,接口引用指向实现类对象
        Person person = new Teacher();
        person.show2();
        person.test();
        person.test2();

        //接口中的静态方法只能使用接口名.方法名([参数列表])直接调用
        //person.show();编译报错
        System.out.println(person.a);
        //接口中的常量可以使用引用名和接口名.调用
        System.out.println(Person.a);

        //继承具有传递性。
        Person pc1 = new Child();
        pc1.show2();

    }
}
//1.使用interface关键字定义接口，接口中(接口里)的访问权限都是public
interface Person {
    /*
    * 1.接口中没有普通变量，只有静态常量
    * 如果简写，会自动拼接 public static final
    * */
    public static final int a = 1;
    int b = 2;//简写也自动拼public static final

    //2.方法：JDK8之前，接口中没有普通方法，都是抽象方法，如果简写，会自动拼接public abstract
    public abstract void test();
    void test2();
    /*
    * 3.JDK8后，接口中可以添加使用static 或 default 修饰普通方法。
    * 此处的default 不是权限修饰符，只是修饰词
    * */
    public static void show(){
        System.out.println("接口中的static方法");
    }
    public default void show2(){
        System.out.println("接口中的default方法");
    }
    //5.接口中没有构造方法：Interface cannot have constructors
    //Person(){}编译报错
}
/*
* 6.使用implements关键字实现接口
* */
class Teacher implements Person{
    /*
    * 重写仍然遵循重写规则
    * */
    @Override
    public void test(){
        System.out.println("Teacher中");
    }
    public void test2(){

    }
}
//实现接口不一定要重写接口中的所有抽象方法，因为实现类可能是一个抽象类

/*
* 7、使用implements关键字实现接口，接口的实现类要么重写接口中的所有抽象方法，要么将自己定义为抽象类。
* */
abstract class Student implements Person{

}
class Child extends Student{
    @Override
    public void test(){
        System.out.println("test() of Child ");
    }
    @Override
    public void test2(){
        System.out.println(" test2() of Child");
    }
    @Override
    public void show2(){
        System.out.println("show2() of Child");
    }
}

二、接口的多继承和多实现

1.接口中定义方法可以自动补齐 public abstract，所以接口中定义的方法均为抽象方法

interface Inter1{
    //1.接口中定义方法可以自动补齐 public abstract，所以接口中定义的方法均为抽象方法
    void show();
}
interface Inter2{
    void test();
}

2，接口可以继承接口，使用extends关键字。并且可以多继承，同时继承多个接口时，中间用 逗号 隔开。

interface  Inter3 extends Inter1,Inter2{
    void save();
}

3.类实现接口，使用implements 关键字，可以实现多个接口，实现类要重写所以接口中的所有抽象方法，实现类也可以声明为抽象类，则可以不用重写接口中的抽象方法。

abstract class Inter3Impl implements Inter1 , Inter2 ,Inter3{

}

4.类可以实现接口，并且可以多实现，实现接口时中间用逗号隔开

//类可以实现接口，并且可以多实现，实现接口时中间用逗号隔开
class Impl extends Inter3Impl{
    @Override
    public void show(){
        System.out.println("show()");
    }
    @Override
    public void test(){
        System.out.println("test()");
    }
    @Override
    public void save(){
        System.out.println("sava()");
    }
}

总代码

package JAVA_OOP.com.huacit.day04poly.moreinheritanceimplements;

/**
 * @author yyc
 * 接口的多继承和多实现
 * 多继承指的是接口和接口之间，一个接口可以继承多个接口
 * 多实现指的是类和接口之间，一个类可以实现多个接口
 *
 * 类可以继承类的同时实现多个接口
 *
 * 接口 和 抽象类的异同
 * 相同点：①都可以有抽象方法，都不能被实例化（即是不能创建对象）（但是可以声明引用）。
 * 不同点：① 定义不同，声明接口使用interface ，声明抽象类使用 abstract class，
 *       ② 接口可以多继承，抽象类只能单继承（java中的类只能单继承）
 *       ③ 接口中只能有静态常量，抽象类中可以有普通变量。
 *       ④ 接口中没有构造方法，抽象类中有构造方法
 *       ⑤接口在JDK8之前只能有抽象方法，JDK8 之后可以有static 或 default修饰的普通方法；
 *       抽象类中可以有抽象方法，也可以有普通方法
 *       ⑥ 接口中的访问权限都是public 的，抽象类中四种访问权限都可以，
 *       ⑦ 接口中可以可以简写，接口中变量省略public static final 会自动拼接识别为静态常量, 接口中的方法可以省略public abstract会自动拼接识别为抽象方法，抽象类中不可以简写。
 *
 */
public class Test5_Interface {
    public static void main(String[] args) {
        //子类实现多个接口，想用那个接口中的方法就定义那个接口的引用
        /*
        * 多态对象调用标准看左边，同时实现多个接口时，
        * 先用哪个接口的功能，左边声明就写谁
        * */
        Inter1 i1 = new Impl();
        i1.show();
        Inter2 i2 = new Impl();
        i2.test();
    }
}
interface Inter1{
    //1.接口中定义方法可以自动补齐 public abstract，所以接口中定义的方法均为抽象方法
    void show();
}
interface Inter2{
    void test();
}
//2，接口可以继承接口，使用extends关键字。并且可以多继承，同时继承多个接口时，中间用 逗号 隔开。
interface  Inter3 extends Inter1,Inter2{
    void save();
}
//3.类实现接口，使用implements 关键字，可以实现多个接口，实现类要重写所以接口中的所有抽象方法，实现类也可以声明为抽象类，则可以不用重写接口中的抽象方法。
abstract class Inter3Impl implements Inter1 , Inter2 ,Inter3{

}
//类可以实现接口，并且可以多实现，实现接口时中间用逗号隔开
class Impl extends Inter3Impl{
    @Override
    public void show(){
        System.out.println("show()");
    }
    @Override
    public void test(){
        System.out.println("test()");
    }
    @Override
    public void save(){
        System.out.println("sava()");
    }
}