java之接口精选

Posted 2022-08-23 磊哥的Java历险记

前言：

我们上一篇聊完了抽象类，接着我们聊一下接口，接口的感觉很奇妙，后面的实战开发会反复聊到和用到，初学的兄弟们一定要多注意！可以动手跟着下面的演示代码，敲一下！ 

一．概念和介绍

    Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

两种含义：

一：Java接口，Java语言中存在的结构，有特定的语法和结构；

二：一个类所具有的方法的特征集合，是一种逻辑上的抽象。前者叫做“Java接口”，后者叫做“接口”。

接口实现和类继承的规则不同，为了数据的安全，继承时一个类只有一个直接父类，也就是单继承，但是一个类可以实现多个接口，接口弥补了类的不能多继承缺点，继承和接口的双重设计既保持了类的数据安全也变相实现了多继承。

Java接口本身没有任何实现，因为Java接口不涉及表象，而只描述public行为，所以Java接口比Java抽象类更抽象化。但是接口不是类，不能使用new 运算符实例化一个接口。如 x=new comparable（......）;//这个是错误来的。但是可以声明接口变量Comparable x; //这是允许的。

Java接口的方法只能是抽象的和公开的，Java接口不能有构造器，Java接口可以有public、static和final属性。即接口中的属性可以定义为 public static final int value=5;

接口把方法的特征和方法的实现分割开来。这种分割体现在接口常常代表一个角色，它包装与该角色相关的操作和属性，而实现这个接口的类便是扮演这个角色的演员。一个角色由不同的演员来演，而不同的演员之间除了扮演一个共同的角色之外，并不要求其它的共同之处。

二．知识点介绍

1、基本概念

2、接口使用

3、接口的实际应用

三.知识点详解

1、基本概念

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

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

代码演示：定义一个接口

interface A//定义一个接口
      
              //全局常量
              public static final String MSG = "磊哥的java历险记-@51博客";
              //抽象方法
              public abstract void print();
       

2、接口使用

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

接口的使用原则如下：

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

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

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

代码演示1：

package com.Test;

 public class Main 

       interface A//定义一个接口A
              public static final String MSG = "磊哥的java历险记-@51博客";//全局常量
              public abstract void print();//抽象方法
       
       interface B//定义一个接口B
              public abstract void get();
       
       
       static 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()");
                     //输出全局变量
                     System.out.println(MSG);
              

       

     //主方法调用执行
       static class  Test 
              public static void main(String[] args) 
                     X x = new X();//实例化子类对象
                     A a = x;//向上转型
                     B b = x;//向上转型
                     a.print();
                     b.get();

              


       

    对于子类而言，除了实现接口外，还可以继承抽象类。若既要继承抽象类，同时还要实现接口的话，使用以下语法格式：

    class 子类 [extends 父类] [implemetns 接口1,接口2,...]

代码演示2：

package com.Test;

 public class Main 
        
        //定义一个接口A
        interface A
               public static final String MSG = "磊哥的java历险记-@51博客";//全局常量
               public abstract void print();//抽象方法
        
        //定义一个接口B
        interface B
               public abstract void get();
        
        //定义一个抽象类C
        abstract class C
               public abstract void change();
        
        //X类继承C类，并实现了A和B两个接口
        class X extends C implements 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关键字同时继承多个接口（但接口不能继承抽象类）。

package com.Test;

public class Main 
       //定义接口A
       interface A
              public void funA();
       
       //定义接口B
       interface B
              public void funB();
       
       //C接口同时继承了A和B两个接口
       interface C extends A,B//使用的是extends
              public void funC();
       
       //X类实现 C，但是C继承了A和B，所以C实现了A B C三个接口
       static class X implements C
              @Override
              public void funA() 
                     System.out.println("磊哥");
              
              @Override
              public void funB() 
                     System.out.println("java历险记");
              
              @Override
              public void funC() 
                     System.out.println("@51OTC博客");
              
       
       //主方法调用
       static class Test
              public static  void main(String[] args)
                     //创建X对象
                     X x = new X();
                     //向上转型
                     A a =x;
                     B b =x;
                     C c = x;
                     //方法调用
                     a.funA();
                     b.funB();
                     c.funC();

              
       

抽象内部类：

由此可见，从继承关系来说接口的限制比抽象类少：

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

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

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

代码演示：

package com.Test;

public class Main 
    //定义A接口
       interface A
              public void funA();
              abstract class B//定义一个抽象内部类
                     public abstract void funB();
              
       
       //在接口中如果使用了static去定义一个内接口，它表示一个外部接口：
       interface C
              public void funA();
              static interface B//使用了static，是一个外部接口
                     public void funB();
              
       
       //X继承A的抽象类
       static class X extends A.B 
              @Override
              public void funB() 
                     System.out.println("磊哥的java历险记");
              
       
       //D实现C的外部接口
       static class D implements C.B 
              @Override
              public void funB() 
                     System.out.println("-@51博客");
              
       

       //主方法调用
       static class Test
              public static  void main(String[] args)
                     //创建X对象
                     D d = new D();
                     X x = new X();
                     x.funB();
                     d.funB();


              
       

3、接口的实际应用（标准定义）

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

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

    现在假设每一个USB设备只有两个功能：安装驱动程序、工作。

定义一个USB的标准：

代码演示： 

package com.Test;

        // 定义操作标准
        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("安装耳机耳麦驱动文件") ;
            
            public void work() 
                System.out.println("直播时耳机耳麦负责收声和播放") ;
            
        
        //测试主类：
        class TestDemo 
            private  final  static  String name = "磊哥的java历险记-@51博客";
            public static void main(String args[]) 
                Computer c = new Computer() ;
                //传递具体的USB设备进接口
                c.plugin(new Phone()) ;
                c.plugin(new Print()) ;
                c.plugin(new MP3());
                System.out.println("============="+name+"=============");
            
        

结语：

 每一篇文章都是有演示代码和代码截图的，每一行代码都是我动手敲出来的，目的就是想告诉初学者的兄弟们，可以放手大胆的跟着敲一敲代码！