接口

小灰灰 2021-09-22 22:58 955阅读 0赞

接口的基本概念


 Java接口是一系列方法的声明,是一些方法特征的集合。一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)。接口是解决Java无法使用多继承的一种手段,但是接口在实际中更多的作用是制定标准的。一个类通过实现(implements)接口的方式,从而来继承接口中的抽象方法。接口中的访问权限只有public,即使省略不写也会默认为public。
 接口与其说是描述一个类的行为特征,还不如说是描述多个类的行为共性。比如, 每一种动物都有一些共同的行为特征,定义两个行为特征——叫、吃。但是每种动物的叫法和吃法是不一样的,所以我们在这里定义一个接口,里面涵盖了叫和吃两个抽象方法,等待实体动物类去自我实现。

接口的定义


 用interface修饰

  1. interface A{ //定义一个接口
  2. public static final String MSG = "Hello"; //全局常量
  3. public abstract void print(); //抽象方法
  4. }

注意事项:

  1. 定义变量时,一定要直接赋值。
  2. 接口中不能使用static代码块。

接口的使用方法


一、接口中存在抽象方法,所以接口对象不能直接用关键字new进行实例化。
(1)接口必须要有子类,但此时一个子类可以使用implements关键字实现多个接口;
(2)接口的子类(如果不是抽象类),那么必须要覆写接口中的全部抽象方法; 如果子类是抽象类则可以不用在该子类中实现接口中的抽象方法。
(3)接口的对象可以利用子类对象的向上转型进行实例化

不能使用new操作符实例化一个接口,但可以声明一个接口变量,该变量必须引用一个实现该接口的类的对象。可以使用 instanceof 检查一个对象是否实现了某个特定的接口。

  1. interface A{ //定义一个接口A
  2. public static final String MSG = "Hello"; //全局常量
  3. public abstract void print(); //抽象方法
  4. }
  5. interface B{ //定义一个接口B
  6. public abstract void get();
  7. }
  8. class X implements A,B{ //X类实现了A和B两个接口,两个接口没有任何直接联系,却拥有同一个子类X
  9. @Override
  10. public void print() {
  11. System.out.println("接口A的抽象方法print()");
  12. }
  13. @Override
  14. public void get() {
  15. System.out.println("接口B的抽象方法get()");
  16. }
  17. }
  18. public class Test {
  19. public static void main(String[] args){
  20. X x = new X(); //实例化子类对象
  21. A a = x; //向上转型
  22. B b = x; //向上转型
  23. a.print();
  24. b.get();
  25. }
  26. }
  27. Output
  28. 接口A的抽象方法print()
  29. 接口B的抽象方法get()

以上代码实例化了X类的对象,由于X类是A和B的子类,那么X类的对象可以转换为A接口或B接口的对象。
修改公有类代码如下:

  1. public class Test {
  2. public static void main(String[] args){
  3. A a = new X();
  4. B b = (B) a; //向上转型
  5. b.get();
  6. }
  7. }
  8. Output
  9. 接口B的抽象方法get()

修改公有类代码如下:

  1. public class Test {
  2. public static void main(String[] args){
  3. A a = new X();
  4. B b = (B) a;
  5. b.get();
  6. System.out.println(a instanceof A);
  7. System.out.println(a instanceof B);
  8. }
  9. }
  10. Output
  11. 接口B的抽象方法get()
  12. true
  13. true

二、子类除了实现接口外,还可以继承抽象类。若既要继承抽象类,同时还要实现接口的话,语法格式:

class 子类 [extends 父类] [implemetns 接口1,接口2,…] { }

三、在Java中,一个抽象类只能继承一个抽象类,但一个接口却可以使用extends关键字同时继承多个接口,但接口不能继承抽象类(没必要用接口去继承抽象类,还不如把接口改成子类)。

 从继承关系上来说接口的限制比抽象类少:

  1. 一个抽象类只能继承一个父类,而接口可以继承多个接口。
  2. 一个子类只能继承一个抽象类,却可以实现多个接口(在Java中,接口的主要功能是解决单继承局限问题)。

    interface A{

    1. public abstract void funA();

    }
    interface B{

    1. public abstract void funB();

    }
    interface C extends A,B{//使用extends使C接口同时继承了接口A和B

    1. public abstract void funC();

    }
    class X implements C{ //实现继承链上所有接口

    1. @Override
    2. public void funA() {
    3. System.out.println("funA");
    4. }
    5. @Override
    6. public void funB() {
    7. System.out.println("funB");
    8. }
    9. @Override
    10. public void funC() {
    11. System.out.println("funC");
    12. }

    }
    public class Test {

    1. public static void main(String[] args){
    2. X x = new X(); //实例化子类对象
    3. A a = x; //向上转型
    4. B b = x;
    5. C c = x;
    6. a.funA();
    7. b.funB();
    8. c.funA();c.funB();c.funC();
    9. }

    }
    Output:
    funA
    funB
    funA
    funB
    funC

四、正如抽象类中可以定义抽象内部类(static abstract),抽象内部类的子类一样,在接口中也可以定义普通内部类(public static)、抽象内部类(public abstract)和内部接口(public static)。权限见访问权限

在接口中定义一个抽象内部类:

  1. interface A{
  2. public abstract void funA();
  3. abstract class B{ //定义一个抽象内部类,默认 public 权限
  4. public abstract void funB();
  5. }
  6. }
  7. class C extends A.B implements A{
  8. @Override
  9. public void funA() {
  10. System.out.println("funA");
  11. }
  12. @Override
  13. public void funB() {
  14. System.out.println("funB");
  15. }
  16. }
  17. public class Test {
  18. public static void main(String[] args){
  19. C c = new C();
  20. c.funA();
  21. c.funB();
  22. A a = c;
  23. a.funA();
  24. }
  25. }
  26. Output
  27. funA
  28. funB
  29. funA

在接口中使用static去定义一个内接口,它表示一个外部接口:

  1. interface A{
  2. public abstract void funA();
  3. static interface B{ //使用了static,是一个外部接口,默认 public 权限
  4. public abstract void funB();
  5. }
  6. }
  7. class C implements A.B{
  8. @Override
  9. public void funB() {
  10. System.out.println("funB");
  11. }
  12. }
  13. public class Test {
  14. public static void main(String[] args){
  15. C c = new C();
  16. c.funB();
  17. A.B ab = c;
  18. ab.funB();
  19. }
  20. }
  21. Output
  22. funB
  23. funB

五、接口可以用来实现解耦。
六、接口的标识用法
 虽然接口内部定义了一些抽象方法,但是并不是所有的接口内部都必须要有方法,比如Serializable接口。Serializable接口的作用是使对象能够“序列化”,但是Serializable接口中却没有任何内容。也就是说,如果有一个类需要实现“序列化”的功能,则这个类必须去实现Serializable接口,但是它却并不用实现接口中的方法(因为接口中没有方法)。此时,这个Serializable接口仅仅是一个“标识”接口,是用来标志一个类的,标志(表示)这个类具有“序列化”功能。

常见问题


一、为什么接口中的常量必须使用public static final修饰?
 public: 使接口的实现类可以使用这个常量。
 static:用static修饰表示它(常量)是属于类的,随的类的加载而存在;如果是非static的话,就表示它是属于对象的,只有建立对象时才有它;而接口是不能去建立对象的,所以接口的常量必须定义为static
 final:用final修饰是保证接口中定义的常量不能被实现接口的类修改,如果没有final的话,由子类随意去修改的话,接口建立这个常量就没有意义了。
 同时,Java是不支持多继承的。
 如果多个父类中含有同名变量或相同的函数,那么子类在调用父类的这些(非static修饰)同名变量或相同函数时就会出现分歧,(比如用super调用时)不知道到底要调用哪一个,所以不支持多继承;但为了弥补只支持单继承带来的缺点,Java可以只继承一个类,但却可以同时实现多个接口,而接口中的成员变量都用static和final修饰,使其成为一个常量(调用时直接接口名.变量名),如果不这么做,那就又会出现上面的分歧(除非java成员变量永远都是static)。

在设计模式中的应用


 工厂设计模式,代理设计模式。

接口的实际应用(标准定义)


例一

要先开发出USB接口标准,然后设备厂商才可以设计出USB设备。

  1. interface USB { // 定义一个USB的标准
  2. public abstract void install() ;
  3. public abstract void work() ;
  4. }
  5. class Computer { //在电脑上应用此接口
  6. public void plugin(USB usb) {
  7. usb.install() ;
  8. usb.work() ;
  9. }
  10. }
  11. class Phone implements USB { //定义USB设备----手机
  12. public void install() {
  13. System.out.println("安装手机驱动程序。") ;
  14. }
  15. public void work() {
  16. System.out.println("手机与电脑进行工作。") ;
  17. }
  18. }
  19. class Print implements USB { //定义USB设备----打印机
  20. public void install() {
  21. System.out.println("安装打印机驱动程序。") ;
  22. }
  23. public void work() {
  24. System.out.println("进行文件打印。") ;
  25. }
  26. }
  27. class MP3 implements USB { //定义USB设备----MP3
  28. public void install() {
  29. System.out.println("安装MP3驱动程序。") ;
  30. }
  31. public void work() {
  32. System.out.println("进行MP3拷贝。") ;
  33. }
  34. }
  35. public class K {
  36. public static void main(String args[]) {
  37. Computer c = new Computer() ;
  38. c.plugin(new Phone()) ;
  39. c.plugin(new Print()) ;
  40. c.plugin(new MP3()) ;
  41. }
  42. }
  43. Output
  44. 安装手机驱动程序。
  45. 手机与电脑进行工作。
  46. 安装打印机驱动程序。
  47. 进行文件打印。
  48. 安装MP3驱动程序。
  49. 进行MP3拷贝。

发表评论

表情:
评论列表 (有 0 条评论,955人围观)

还没有评论,来说两句吧...

相关阅读

    相关 接口

      接口是JAVA实现多继承的一种机制,一个类只能继承一个类,但是可以实现多个接口。   接口与一般类一样,也可以继承父类(接口),但是接口可以继承多个父接口。 p

    相关 接口

    接口的基本概念 --------------------  Java接口是一系列方法的声明,是一些方法特征的集合。一个接口只有方法的特征没有方法的实现,因此这些方法可以

    相关 接口

    接口 interface 接口的定义:常量、抽象方法 常量:public static final 方法:public abstract Interface