Java基础学习笔记16——接口

目录

1、接口概述

2、接口的特点

3、接口的成员特点

4、类和接口的关系

5、抽象类与接口的区别

6、接口组成更新

6.1、接口组成更新概述

6.2、接口中默认方法

6.3、接口中静态方法

6.4、接口中私有方法

---

1、接口概述

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。Java中的接口更多的体现在对行为的抽象。

2、接口的特点

• 接口用关键字interface修饰：

  public interface 接口名{}

• 类实现接口用implements关键字：

  public class 类名 implements 接口名{}

• 接口不能被实例化，若要实例化，需要用多态的方式，通过实现类对象实例化，这叫接口多态。（多态类的形式有具体类多态、抽象类多态、接口多态。）
• 接口的实现类要么重写接口中的所有抽象方法，要么是抽象类。

代码演示：

package interfacePackage;

//定义一个接口
public interface Jumping {
    public abstract void jump();
}

package interfacePackage;

//Cat类，用类实现接口，关键字为implements
public class Cat implements Jumping{
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

package interfacePackage;

public abstract class Dog implements Jumping{
    //抽象类可以不重写接口内的方法，但子类继承Dog时还是要重写这个方法
}

package interfacePackage;

//测试类
public class test {
    public static void main(String[] args) {
        //Jumping j = new Jumping(); //Jumping接口也不能被实例化

        //多态方式实例化一个接口
        Jumping j = new Cat();
        j.jump();
    }
}

结果：
猫可以跳高了

3、接口的成员特点

1）成员变量：只能是常量，默认修饰符：public static final 。

2）构造方法：

• 接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在的；
• 一个类如果没有父类，则默认继承自Object类；

3）成员方法只能是抽象方法，默认修饰符：public abstract 。

代码演示：

package interfacePackage2;

public interface Inter {
    public  int num1 = 10;
    public final int num2 = 20;
    public static final int num3 = 30; //等价于int num3 = 30

    //public Inter(); //报错，因为接口不能有构造方法

    //public void show(){} //报错，因为接口不能有非抽象方法

    public abstract void show();
    //上面等价于：void show(); 因为接口里的方法默认修饰为public abstract
}

package interfacePackage2;

//Inter接口的实现类
public class InterImpl implements Inter{
//上面等价于：public class InterImpl extends Object implements Inter{}
    //构造方法
    public InterImpl(){
        super(); //使用的是Object类里的构造方法
    }

    //重写show方法
    @Override
    public void show() {
        System.out.println("show方法");
    }
}

package interfacePackage2;

//测试类
public class Test {
    public static void main(String[] args) {
        Inter i = new InterImpl();
        System.out.println(i.num1);
        //i.num1 = 10; //会报错，因为接口中的变量默认用static和final修饰
        System.out.println(i.num2);
        System.out.println(Inter.num3);
    }
}

结果：
10
20

4、类和接口的关系

• 类和类的关系：继承关系，只能单继承，但是可以多层继承。
• 类和接口的关系：实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。
• 接口和接口的关系：继承关系，可以单继承，也可以多继承。

5、抽象类与接口的区别

1）成员区别：

• 抽象类：变量，常量；有构造方法，有抽象方法，也有非抽象方法
• 接口：常量；抽象方法

2）关系区别：

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

3）设计理念区别：

• 抽象类：对类抽象，包括属性、行为
• 接口：对行为抽象，主要是行为

现实应用：

//实现警报功能的接口
public interface Alarm{
    void alarm(); //警报
}
//门的抽象类
public abstract class Door{
    public abstract void open(); //开门
    public abstract void close(); //关门
}
//警报门（继承自Door，实现Alarm）
public class AlarmDoor extends Door implements Alarm{
    public void open(){} //开门
    public void close(){} //关门
    public void alarm(){} //警报
}

6、接口组成更新

6.1、接口组成更新概述

接口的组成：

• 常量：public static final
• 抽象方法：public abstract
• 默认方法（Java 8）
• 静态方法（Java 8）
• 私有方法（Java 9）

6.2、接口中默认方法

接口中默认方法的定义格式：

格式：public default 返回值类型 方法名(参数列表) {}
范例：public default void show3() {}

接口中默认方法的注意事项：

• 默认方法不是抽象方法，所以不强制被重写，但是可以被重写，重写的时候去掉default关键字。
• public可以省略，default不能省略。

代码演示：

package Inter2Package;

public interface Inter {
    void show1();

    void show2();

    default void show3(){
        System.out.println("show3");
    }
}

package Inter2Package;

public interface InterNew extends Inter{
    void show3();
}

package Inter2Package;

public class InterImpl1 implements Inter{
    @Override
    public void show1() {
        System.out.println("InterImpl1 show1");
    }

    @Override
    public void show2() {
        System.out.println("InterImpl1 show2");
    }

    @Override
    public void show3() {
        System.out.println("InterImpl1 show3");
    }
}

package Inter2Package;

public class InterImpl2 implements Inter{
    @Override
    public void show1() {
        System.out.println("InterImpl2 show1");
    }

    @Override
    public void show2() {
        System.out.println("InterImpl2 show2");
    }
}

package Inter2Package;

public class Test {
    public static void main(String[] args) {
        Inter i1 = new InterImpl1();
        i1.show1();
        i1.show2();
        i1.show3();
    }
}

结果：
InterImpl1 show1
InterImpl1 show2
InterImpl1 show3

6.3、接口中静态方法

接口中静态方法的定义格式：

格式：public static 返回值类型 方法名(参数列表) {}
范例：public static void show() {}

接口中静态方法的注意事项：

• 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用。
• public可以省略，static不能省略。

代码演示：

package Inter3Package;

public interface Inter {
    //抽象方法
    void show1();

    //默认方法
    default void show2() {
        System.out.println("Inter中的默认方法执行了");
    }

    //静态方法
    static void show3() {
        System.out.println("Inter中的静态方法执行了");
    }
}

package Inter3Package;

public class InterImpl implements Inter{
    @Override
    public void show1() {
        System.out.println("show方法执行了");
    }
}

package Inter3Package;

public class Test {
    public static void main(String[] args) {
        Inter i = new InterImpl();
        i.show1();
        i.show2();
        Inter.show3(); //接口中的静态方法只能被接口调用
        //InterImpl.show3(); //错误，因为接口的实现类不能调用接口中的静态方法
    }
}

结果：
show方法执行了
Inter中的默认方法执行了
Inter中的静态方法执行了

6.4、接口中私有方法

Java 9中新增了带方法体的私有方法，这其实在Java 8中就埋下了伏笔：Java 8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法时不需要让别人使用的，因此用私有给隐藏起来，这就是Java 9增加私有方法的必然性。

接口中私有方法的定义格式：

格式1：private 返回值类型 方法名(参数列表) {}
范例1：private void show() {}

格式2：private static 返回值类型 方法名(参数列表) {}
范例：private static void show() {}

接口中私有方法的注意事项：

• 默认方法可以调用私有的静态方法和非静态方法。
• 静态方法只能调用私有的静态方法。