【Java笔记】17 接口

一、基本介绍

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来

interface 接口名{

  1. //属性
  3. //方法：抽象方法、默认实现方法或静态方法

}

class 类名 implements 接口{

  1. // 自己的属性
  3. // 自己的方法
  5. // 必须实现的接口的抽象方法

}

jdk7前，接口的所有方法都没有方法体，即都是抽象方法；jdK8后接口可以有静态方法，默认方法，即接口中可以有方法的具体实现

  1. public interface Inter {
  2.     // 属性
  3.     public int n1 = 10;
  4.     // 方法
  5.     // 接口中抽象方法可以省略abstract
  6.     public void hi();
  7.     // jdk8后，可以有默认实现方法，使用default关键字实现
  8.     default public void ok(){
  9.         System.out.println("ok...");
  10.     }
  11.     // jdk8后，可以有静态方法
  12.     public static void cry(){
  13.         System.out.println("cry..");
  14.     }
  15. }
  1. // 类实现一个接口，需要将该接口的所有抽象方法都实现
  2. class A implements Inter{
  3.     @Override
  4.     public void hi() {
  5.         System.out.println("hi..");
  6.     }
  7. }

二、例

3个程序员，编写3个类，分别完成对MySQL、Oracle、DB2数据库的connect、close

  1. public interface DBInterface {
  2.     void connect(); // 连接
  3.     void close(); // 关闭连接
  4. }
  1. public class MySQLDB implements DBInterface{
  2.     @Override
  3.     public void connect() {
  4.         System.out.println("连接MySQL");
  5.     }
  7.     @Override
  8.     public void close() {
  9.         System.out.println("关闭MySQL");
  10.     }
  11. }
  1. public class OracleDB implements DBInterface{
  2.     @Override
  3.     public void connect() {
  4.         System.out.println("Oracle连接");
  5.     }
  7.     @Override
  8.     public void close() {
  9.         System.out.println("Oracle关闭");
  10.     }
  11. }
  1. public class Interface02 {
  2.     public static void main(String[] args) {
  3.         MySQLDB mySQLDB = new MySQLDB();
  4.         test(mySQLDB);
  5.         OracleDB oracleDB = new OracleDB();
  6.         test(oracleDB);
  7.     }
  8.     public static void test(DBInterface dbInterface){
  9.         dbInterface.connect();
  10.         dbInterface.close();
  11.     }
  12. }

三、注意事项

  1. 接口不能被实例化
  2. 接口中所有的方法是public，抽象方法，可以不用abstract修饰

【Java笔记】17 接口 - 图1

  1. 一个普通类实现接口，必须将该接口的所有方法都实现
    普通类alt+enter提示待实现方法
  2. 抽象类实现接口，可以不实现接口的抽象方法 
  1. interface IA{
  2.     public abstract void say();
  3.     public abstract void hi();
  4. }
  6. abstract class T implements IA{
  8. }
  1. 一个类可以同时实现多个接口
  1. interface IB{
  2.     void hi();
  3. }
  4. interface IC{
  5.     void say();
  6. }
  8. // 一个类可以同时实现多个接口
  9. class P implements IB,IA{
  11.     @Override
  12.     public void say() {
  14.     }
  16.     @Override
  17.     public void hi() {
  19.     }
  20. }
  1. 接口中的属性只能是final，且是public static final（必须初始化）
  2. 接口中属性的访问形式：接口名.属性名
  3. 接口不能继承其它的类，但是可以继承多个别的接口 
  1. interface ID extends IC,IB{
  3. }
  1. 接口的修饰符只能是public和默认的，和类的修饰符一样

四、接口和继承比较

子类继承了父类，就自动拥有父类的功能；如果子类需要扩展功能，可以通过实现接口的方式扩展

可以理解为实现接口是对java单继承机制的一种补充

  1. public class ExtendsVsInterface {
  2.     public static void main(String[] args) {
  3.         LittleMonkey littleMonkey = new LittleMonkey("悟空");
  4.         littleMonkey.climb();
  5.         littleMonkey.swimming();
  6.     }
  7. }
  8. interface Fish{
  9.     void swimming();
  10. }
  11. class Monkey{
  12.     private String name;
  13.     public void climb(){
  14.         System.out.println(name + "爬树");
  15.     }
  17.     public Monkey(String name) {
  18.         this.name = name;
  19.     }
  21.     public String getName() {
  22.         return name;
  23.     }
  25.     public void setName(String name) {
  26.         this.name = name;
  27.     }
  28. }
  30. class LittleMonkey extends Monkey implements Fish{
  32.     public LittleMonkey(String name) {
  33.         super(name);
  34.     }
  36.     @Override
  37.     public void swimming() {
  38.         System.out.println(getName()+"通过学习会游泳");
  39.     }
  40. }
  1. 解决问题
    继承：代码复用和可维护性
    接口：设计好方法，让其他类实现
  2. 接口比继承灵活，继承满足is-a的关系，接口满足like-a关系
  3. 接口一定程度上实现代码解耦[接口规范性+动态绑定]

五、接口的多态特性

  1. 多态参数
    接口引用可以指向实现了接口的类的对象 
  1. public class InterfacePolyParameter {
  2.     public static void main(String[] args) {
  3.         // 接口类型的变量可以指向实现了IF接口的对象实例
  4.         IF if01 = new M();
  5.         if01 = new Ca();
  6.     }
  7. }
  9. interface IF{}
  10. class M implements IF{}
  11. class Ca implements IF{}
  1. 多态数组
  1. public class InterfacePolyArr {
  2.     public static void main(String[] args) {
  3.         // 多态数组 接口类型数组
  4.         Usb[] usbs = new Usb[2];
  5.         usbs[0] = new Phone();
  6.         usbs[1] = new Camera();
  7.         for (int i = 0; i < usbs.length; i++) {
  8.             usbs[i].work();
  9.             // 向下转型
  10.             // instanceof判断运行类型
  11.             if(usbs[i] instanceof Phone){
  12.                 ((Phone)usbs[i]).call();
  13.             }
  14.         }
  15.     }
  16. }
  18. interface Usb{
  19.     void work();
  20. }
  21. class Phone implements Usb{
  22.     public void call(){
  23.         System.out.println("打电话");
  24.     }
  26.     @Override
  27.     public void work() {
  28.         System.out.println("手机工作中");
  29.     }
  30. }
  31. class Camera implements Usb{
  32.     @Override
  33.     public void work() {
  34.         System.out.println("相机工作中");
  35.     }
  36. }
  1. 多态传递
  1. public class InterfacePolyPass {
  2.     public static void main(String[] args) {
  3.         IG ig = new Te();
  4.         //如果 IG 继承了 IH 接口，而 Te 类实现了 IG 接口
  5.         //实际上就相当于 Te 类也实现了 IH 接口
  6.         IH ih = new Te();
  7.     }
  8. }
  10. interface IH{}
  11. interface IG extends IH{}
  12. class Te implements IG{}