JavaSE进阶3之接口

接口

接口概述、特点

1. 接口用关键字interface来定义

public interface 接口名{
	//常量
	//抽象方法
}

JDK8之前接口中只能是抽象方法和常量，没有其他成分了

2. 接口也是一种规范，规范一定是公开的，所以都是public
   由于接口体现规范思想，规范默认都是公开的，所以代码层面，public abstract可以省略不写

public interface InterfaceDemo {
    //1.常量
    public static final String SCHOOL_NAME="西安中学";
    //也可以写成
    String USER_NAME="root";

    //2.抽象方法
    public abstract void run();
    //也可以写成
    void eat();
}

接口的基本使用：被实现

接口的用法

接口是用来被类实现的，实现接口的类被称为实现类，实现类可以理解成所谓的子类
实现的关键字 implements

快捷键
重写的快捷键
alt+回车

从上面可以看出：接口可以被类单实现，也可以被类多实现

接口实现的注意事项

一个类实现接口，必须重写完全部接口的全部抽象方法，否则这个类需要定义成抽象类

public interface Person {
    void eat();
    void sleep();
}

public interface Dance {
    void dance();
}

public class Girl implements Person,Dance{
    @Override
    public void eat() {
        System.out.println("女孩可以吃");
    }

    @Override
    public void sleep() {
        System.out.println("女孩可以睡");
    }


    @Override
    public void dance() {
        System.out.println("有的女孩会跳舞");
    }
}

public class demo1 {
    public static void main(String[] args) {
        Girl g = new Girl();
        g.eat();
        g.sleep();
        g.dance();
    }
}

基本小结

1. 类和类的关系：单继承
2. 类和接口的关系：多实现
3. 接口和接口的关系：多继承，一个接口可以同时继承多个接口

接口与接口的关系：多继承

规范合并，整合多个接口为同一个接口，便于子类实现

public interface Law {
    void law();
}

public interface Person {
    void eat();
    void sleep();
}

public interface SportMan extends Law,Person{  //接口多继承
    void run();
    void competition();
}

实现类

public class Member implements SportMan{

    @Override
    public void law() {
        System.out.println("运动员遵守法律");
    }

    @Override
    public void eat() {
        System.out.println("运动员要吃东西");
    }

    @Override
    public void sleep() {
        System.out.println("运动员要睡觉");
    }

    @Override
    public void run() {
        System.out.println("运动员能跑步");
    }

    @Override
    public void competition() {
        System.out.println("运动员要比赛");
    }
}

public class Test {
    public static void main(String[] args) {
        Member m = new Member();
        //SportMan接口的方法
        m.run();
        m.competition();
        //Law接口方法
        m.law();
        //Person接口方法
        m.eat();
        m.sleep();
    }
}

JDK8开始接口新增方法

第一种 默认方法

1. 类似之前写的普通实例方法，必须用default修饰
2. 默认会public修饰，需要用接口的实现类的对象来调用

第二种 静态方法

1. 默认会public修饰，必须static修饰
2. 注意：接口的静态方法必须用本身的接口名来调用

第三种：私有方法

1. 就是私有的实例方法，必须使用private修饰，从JDK1.9才开始有的
2. 只能在本类中被其他的默认方法或者私有方法访问。

public interface Animal {
    //1.默认方法
    default void eat(){
        System.out.println("default的默认eat方法：动物都能吃~");
        run();//私有方法只能在接口内部调用
    }

    //2.静态方法
    static void sleep(){
        System.out.println("static的静态sleep方法：动物都能睡~");
    }
    //3.私有方法
    private void run(){
        System.out.println("private的私有run方法：有些动物能跑");
    }
}

class Dog implements Animal{
}

class Test{
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();   //实例对象调用默认方法
        Animal.sleep();  //静态方法用 接口.方法名 调用
        //dog.sleep(); 静态方法不能用对象调用
        //dog.run();   私有方法不能用对象调用
    }
}

接口的注意事项

1. 接口不能创建对象
2. 一个类实现多个接口，多个接口中有同样的静态方法不冲突。原因就是接口的静态方法不能类去调用，只能用接口调用
3. 一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的
4. 一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可
5. 一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承

public class demo {
    public static void main(String[] args) {
        //2
        A.say();
        B.say();
        //3
        E e = new E();
        e.eat();  //子类优先调用父类的eat而不是接口B的eat
        //4
        H h = new H();
        h.sleep();

    }
}

interface A{
    static void say(){
        System.out.println("A");
    }
}
interface B{
    static void say(){
        System.out.println("B");
    }
    default void eat(){
        System.out.println("interface B的eat");
    }
}

class C implements A,B{
    //一个类实现多个接口，多个接口有同样的静态方法不冲突
}



class D{
    public void eat(){
        System.out.println("class D的eat");
    }
}

class E extends D implements B{
}


interface F{
    default void sleep(){
        System.out.println("F的sleep");
    }
}
interface G{
    default void sleep(){
        System.out.println("G的sleep");
    }
}

class H implements F,G{
    @Override
    public void sleep() {
        System.out.println("H重写的sleep");
    }
}


//5 接口多继承，但是规范冲突则不可继承
interface I{
    int num();
}
interface J{
    void num();
}
/*
interface K extends I,J{
    @Override
    int num();
}
 */