接口的应用

97次阅读

共计 3310 个字符，预计需要花费 9 分钟才能阅读完成。

接口（Interface），在 JAVA 编程语言中是一个抽象类型，是抽象方法的集合。接口通常以 interface 来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

如果一个类只由抽象方法和全局常量组成，那么这种情况下不会将其定义为一个抽象类。只会定义为一个接口，所以接口严格的来讲属于一个特殊的类，而这个类里面只有抽象方法和全局常量，就连构造方法也没有。

interface A{// 定义一个接口 
    	public static final String MSG = "hello";// 全局常量 
    	public abstract void print();// 抽象方法，abstract 可以省略 
}

由于接口里面存在抽象方法，所以接口对象不能直接使用关键字 new 进行实例化。

（1）接口必须要有子类，但此时一个子类可以使用 implements 关键字实现多个接口；

（2）接口的子类（如果不是抽象类），那么必须要重写接口中的全部抽象方法；

（3）接口的对象可以利用子类对象的向上转型进行实例化。

interface A{// 定义一个接口 A 
    public static final String MSG = "hello";// 全局常量 
    public abstract void print();// 抽象方法 
}
interface B{// 定义一个接口 B 
    public abstract void get();
}
class X implements A,B{// X 类实现了 A 和 B 两个接口 
    @Override
    public void print() {System.out.println("接口 A 的抽象方法 print()");
    }
    @Override
    public void get() {System.out.println("接口 B 的抽象方法 get()");
    }

}
public class TestDemo {public static void main(String[] args){X x = new X();// 实例化子类对象 
        A a = x;// 向上转型 
        B b = x;// 向上转型 
        a.print();
        b.get();}
}

运行结果：

接口的应用

对于子类而言，除了实现接口外，还可以继承抽象类。若既要继承抽象类，同时还要实现接口

interface A{// 定义一个接口 A 
    public static final String MSG = "hello";// 全局常量 
    public abstract void print();// 抽象方法 
}
interface B{// 定义一个接口 B 
    public abstract void get();
}
abstract class C{// 定义一个抽象类 C 
    public abstract void change();
}
class X extends C implements A,B{// X 类继承 C 类，并实现了 A 和 B 两个接口 
    @Override
    public void print() {System.out.println("接口 A 的抽象方法 print()");
    }
    @Override
    public void get() {System.out.println("接口 B 的抽象方法 get()");
    }
    @Override
    public void change() {System.out.println("抽象类 C 的抽象方法 change()");
    }
}

在 Java 中，一个抽象类只能继承一个抽象类，但一个接口却可以使用 extends 关键字同时继承多个接口（但接口不能继承抽象类）。

interface A{public void funA();
}
interface B{public void funB();
}
// C 接口同时继承了 A 和 B 两个接口 
interface C extends A,B{// 使用的是 extends
    public void funC();
}
class X implements C{@Override
    public void funA() { }
    @Override
    public void funB() { }
    @Override
    public void funC() {}}

（1）一个抽象类只能继承一个抽象父类，而接口可以继承多个接口；

abstract class A{}
abstract class B extends A{}

interface A{}
interface B{}
interface X extends A,B{}

（2）一个子类只能继承一个抽象类，却可以实现多个接口（在 Java 中，接口的主要功能是解决单继承局限问题）

interface A{}
interface B{}
abstract class C{}

class X extends C implements A,B{}

（3）从接口的概念上来讲，接口只能由抽象方法和全局常量组成，但是内部结构是不受概念限制的，正如抽象类中可以定义抽象内部类一样，在接口中也可以定义普通内部类、抽象内部类和内部接口（但从实际的开发来讲，用户自己去定义内部抽象类或内部接口的时候是比较少见的），范例如下，在接口中定义一个抽象内部类：

interface A{public void funA();
    abstract class B{// 定义一个抽象内部类 
        public abstract void funB();
    }
}
class X extends A.B {@Override
    public void funB() {}}

// 在接口中如果使用了 static 去定义一个内接口，它表示一个外部接口：
interface A{public void funA();
    static interface B{// 使用了 static，是一个外部接口 
        public void funB();
    }
}
class X implements A.B {@Override
    public void funB() {}}

在日常的生活之中，接口这一名词经常听到的，例如：USB 接口、打印接口、充电接口等等。

如果要进行开发，要先开发出 USB 接口标准，然后设备厂商才可以设计出 USB 设备。

接口的应用

需求：现在假设每一个 USB 设备只有两个功能：安装驱动程序、工作。定义一个 USB 的标准：

interface USB {// 操作标准       
    public void install() ;
    public void work() ;
}
// 在电脑上应用此接口：
class Computer {public void plugin(USB usb) {usb.install() ;
          usb.work() ;}
}
// 定义 USB 设备—手机：
class Phone implements USB {public void install() {System.out.println("安装手机驱动程序。") ;
     }
     public void work() {System.out.println("手机与电脑进行工作。") ;
     }
}
// 定义 USB 设备—打印机：
class Print implements USB {public void install() {System.out.println("安装打印机驱动程序。") ;
      }
      public void work() {System.out.println("进行文件打印。") ;
      }
}
// 定义 USB 设备—MP3:
class MP3 implements USB {public void install() {System.out.println("安装 MP3 驱动程序。") ;
      }
      public void work() {System.out.println("进行 MP3 拷贝。") ;
      }
}

// 测试主类：
public class TestDemo {public static void main(String args[]) {Computer c = new Computer() ;
        // 传递具体的 USB 设备进接口 
        c.plugin(new Phone()) ;
        c.plugin(new Print()) ;
        c.plugin(new MP3());
    }
}