当前位置 : 主页 > 编程语言 > java >

Java中的接口及其应用场景解读

来源:互联网 收集:自由互联 发布时间:2023-05-14
目录 一、接口的特点 二、定义接口 1.interface关键字 2.implements关键字 三、应用场景 1.接口表示规范 2.接口表示能力/行为 四、接口和类之间的关系 五、接口的命名规范 总结 一、接口的
目录
  • 一、接口的特点
  • 二、定义接口
    • 1.interface关键字
    • 2.implements关键字
  • 三、应用场景
    • 1.接口表示规范
    • 2.接口表示能力/行为
  • 四、接口和类之间的关系
    • 五、接口的命名规范
      • 总结

        一、接口的特点

        1.如果一个抽象类中的所有方法都是抽象的,则可以将这个类定义为Java中的另一种形式——接口。接口是一种特殊的抽象类,接口中只有全局常量和抽象方法,是一种更纯粹的抽象概念。

        2.在JDK8中,对接口进行了重新定义,接口中除了有抽象方法外,还可以有默认方法和静态方法;默认方法可以被继承和覆写,静态方法不能被继承和覆写。

        3.一般来说,接口的使用表示两种场景:

        • ①接口表示具备某种能力/行为,子类实现接口是并不是is a关系,而是具备这种能力或行为
        • ②接口表示一种规范或者标准。

        4.在接口中,定义抽象方法时 public abstract关键字可以省略,定义全局常量时 static final可以省略。

        5.接口的子类可以实现多个父接口,接口也不能直接实例化对象,需要通过子类(普通类)向上转型。

        6.接口和接口之间也可以是继承关系,但是接口绝对不能继承一个类。

        二、定义接口

        1.interface关键字

        与定义类不同的是,在定义接口的时候,不再使用class关键字,而是使用interface关键字来声明。

        语法格式:修饰符 interface 接口名 { }

        创建一个USB接口,里面有两个抽象方法

        代码如下:

        public interface USB{
        //表示插入
        	public abstract void plugIn();
        //表示工作
        	public abstract void work();
        }

        2.implements关键字

        子类使用implements关键字来实现接口,必须覆写接口中所有的抽象方法

        代码如下:

        public class KeyBoard implements USB {
        	@Override
            public void plugIn() {
                System.out.println("安装键盘驱动");
            }
            @Override
            public void work() {
                System.out.println("键盘正常工作");
            }
        }

        三、应用场景

        1.接口表示规范

        USB接口表示一种规范,鼠标键盘耳机等等这些外设都属于USB接口的子类,我们在日常生活中使用电脑的时候,我们并不关心到底哪个具体设备插入了我们的电脑,只要这个设备满足了USB接口,就都能被电脑识别并使用。

        就是说,一个接口,可以接受无数种设备,只要这个设备满足USB接口,都可以插入电脑并被电脑识别。

        兼容所有的USB子类对象。

        public interface USB{
        //表示插入
        	public abstract void plugIn();
        //表示工作
        	public abstract void work();
        }
        public class Mouse implements USB{
            @Override
            public void plugIn() {
                System.out.println("安装鼠标驱动");
            }
            @Override
            public void work() {
                System.out.println("鼠标正常工作");
            }
        }
        public class KeyBoard implements USB {
        	@Override
            public void plugIn() {
                System.out.println("安装键盘驱动");
            }
            @Override
            public void work() {
                System.out.println("键盘正常工作");
            }
        }
        public class Camera implements USB{
            @Override
            public void plugIn() {
                System.out.println("安装相机驱动中");
            }
            @Override
            public void work() {
                System.out.println("相机开始正常工作");
            }
        }
        //电脑这个类不是USB接口的子类,他是USB规范的使用者
        public class Computer {
            public static void main(String[] args) {
                Computer computer = new Computer();
                Mouse mouse = new Mouse();
                Keyboard keyboard = new Keyboard();
                Camera camera = new Camera();
                computer.fun(mouse);
                computer.fun(keyboard);
                computer.fun(camera);
            }
            /**
            *为什么此时fun方法的参数是USB usb呢?如果我们写成fun(Mouse mouse),那么这个fun只能识别鼠标,其他的根本识别不了,我们得写好多个方法去实现。
            *我们这里用他们共同的接口当做参数,这样不管传进来的是什么设备,只要你实现了USB这个接口,那你就可以被识别
            *假设我们现在多了一个子类Earphone(耳机)类,实现了USB接口,那我们的fun方法里一行多的代码都不用写,直接实例化对象,将引用名传进去就行。
            */
            public void fun(USB usb) {
                usb.plugIn();
                usb.work();
            }
        }

        2.接口表示能力/行为

        接口允许多实现,一个类可以具备多个能力,同时实现多个父接口,若实现多个父接口,子类(普通类),必须覆写所有的抽象方法。

        代码如下:

        //游泳接口,表示具备游泳这个行为
        public interface ISwim {
            //可以省略public abstrac
        //public abstract void swim();
            void swim();
        }
        //具备跑这个行为
        public interface IRun {
        //可以省略public abstrac
            void run();
        //public abstract void run();
        }
        //表示能飞
        public interface IFly {
        //public abstract void fly();
        //可以省略public abstrac
            void fly();
        }
        //只具备跑的行为
        public class Rabbit implements IRun{
            @Override
            public void run() {
                System.out.println("兔子在跑~");
            }
        }
        //具备跑和游泳的能力
        public class Dog implements IRun,ISwim{
            @Override
            public void run() {
                System.out.println("狗子在跑~");
            }
            @Override
            public void swim() {
                System.out.println("狗子在游泳~");
            }
        }
        //三种能力都具备
        public class Duck implements IRun,ISwim,IFly{
            @Override
            public void fly() {
                System.out.println("鸭子在飞~");
            }
            @Override
            public void run() {
                System.out.println("鸭子在跑~");
            }
            @Override
            public void swim() {
                System.out.println("鸭子在游泳~");
            }
        }
        //定义一个测试类进行测试
        public class Test {
            public static void main(String[] args) {
                IRun run = new Rabbit();
                IRun run1 = new Dog();
                ISwim swim = new Dog();
                IFly fly = new Duck();
                run.run();
                run1.run();
                swim.swim();
                fly.fly();
            }
        }

        运行结果如下:

        四、接口和类之间的关系

        接口和子类之间是一种混合关系,不具备is a关系。上面的Dog和Rabbit都具备跑的能力,但是这两个类彼此之间没啥关系。

        1.当一个类实现接口时,如果这个类是抽象类,只需要实现接口种的部分抽象方法,如果是一个普通类,则需要覆写接口中所有的抽象方法。

        2.一个类可以实现多个接口,接口之间用英文逗号隔开。

        3.接口之间可以通过extends关键字实现继承,并且一个接口可以同时继承多个接口,接口之间用英文逗号隔开。

        4.一个类在继承一个类的同时,还可以实现多个接口,此时,extends关键字必须位于implements关键字之前。

        语法如下:

        修饰符 class 类名 extends 父类名 implements 接口1,接口2{} 

        public class Test {
        }
        interface IA{
        //接口中抽象方法可以省略public abstract
            void testA();
        }
        interface IB{
            void testB();
        }
        //接口之间存在继承关系,可以多继承。
        //接口坚决不能继承一个类
        interface IC extends IA,IB{
        //IC接口同时继承多个父接口,继承了所有的抽象方法
        //子类实现IC接口时,必须覆写所有的抽象方法
        }
        class CImpl implements IC{
            @Override
            public void testA() {
            }
            @Override
            public void testB() {
            }
        }
        abstract class Person{
        }
        //一个类继承一个类,同时实现多个接口
        //修饰符 class 类名 extends 父类名 implements 接口1,接口2{}
        class China extends Person implements IA,IB{
            @Override
            public void testA() {
            }
            @Override
            public void testB() {
            }
        }

        五、接口的命名规范

        为了区分接口和类,命名使用 I 开头,IRun,ISwim等等,子类实现一个接口时,命名以相应的接口开头,以impl结尾。

        例如:如果是IRun的子类,Runimpl(不是强制要求,但尽量做到)。

        如果子类实现多个父接口,不需要使用此规范来命名

        总结

        以上为个人经验,希望能给大家一个参考,也希望大家多多支持自由互联。

        上一篇:一文带你掌握Java中的HashSet
        下一篇:没有了
        网友评论