java的接口

拼搏现实的明天。 2022-10-15 00:46 140阅读 0赞

[java的抽象类][java]

### 文章目录 ###

*  java的接口
 *   *   *  认识接口
         *  接口初体验
         *  面向接口编程
         *   *   *  抽象类和接口的关系和异同

# java的接口 #

### 认识接口 ###

接口在计算机中指的是系统对外提供的所有服务，在java中，接口是通过interface定义的实实在在的接口，也就是接口类型

*  接口的定义:

[访问修饰] interface 接口名称 [extends 其他接口名称]{ 
    	//声明变量
    	//声明方法
    }
    public interface MyInterface{ 
    	public void foo();
    	//其他方法
    }

*  JDK8之前的接口特性:

> 接口中的变量都应该是静态常量(public static final),必须要显式初始化  
> 接口中所有的方法默认都是public abstract  
> 接口中没有构造方法，不可以被实例化，但是可以被实现(常作为类型使用)  
> 实现类必须实现接口中的所有方法  
> 实现类可以实现多个接口，implement多个接口之间用逗号隔开

*  JDK8新增的接口特性

> JDK1.8之后，接口里就可以有默认方法了  
> default关键字 默认方法  
> 如果一个类实现了多个接口，多个接口都定义了多个同样的默认方法，第一种：实现类需要覆盖重写接口中的默认方法不然会进行报错，第二种：可以使用super来调用指定接口中的默认方法  
> 如果一个类继承了一个抽象类，实现了一个接口，抽象类和接口存在相同的方法，采取类优先原则，优先继承抽象类的方法  
> 接口的默认方法可以有多个

package Interface;
    
    public interface MyInterface1 extends MyInterface2 { 
        //接口不可以有构造方法，不可以被实例化
    // public MyInterface1(){ 
    //
    // }
        //静态常量:接口中的变量必须是public static final，且要显式初始化
        public static final double PI = 3.14;//等同于double PI = 3.14;
    
        //在JDK8之前，接口中只可以有public abstract方法
        public abstract void m1();
    
        //等同于public abstract int m2();
        int m2();
    }

package Interface;
    
    public interface MyInterface2 { 
        public abstract void m3();
    }

package Kind;
    
    import Interface.MyInterface1;
    import Interface.MyInterface2;
    
    //实现类必须实现接口中的全部抽象方法，除非实现类也是一个抽象类
    public class Sub1 implements MyInterface1, MyInterface2 { 
        @Override
        public void m1() { 
            System.out.println("实现类实现了接口中m1的方法");
        }
    
        @Override
        public int m2() { 
            return 0;
        }
    
        @Override
        public void m3() { 
            System.out.println("实现类实现了第二个父类接口中的m3方法");
        }
    }

package Test;
    
    import Interface.MyInterface1;
    import Interface.MyInterface2;
    import Kind.Sub1;
    
    public class Test01 { 
        public static void main(String[] args) { 
            //接口可以被当做类型使用
            System.out.println(MyInterface1.PI);
            //相当于父类引用指向子类对象
            MyInterface1 m = new Sub1();
            m.m1();
            MyInterface2 m2 = new Sub1();
            m2.m3();
        }
    }

接口，在java中就是一个抽象的类型，在jdk8之前接口是抽象方法的集合  
一个类通过实现接口的方式，从而来继承接口的抽象方法  
一个类只可以继承一个类，但是可以实现多个接口  
一个接口不能实现另一个接口，但是可以继承多个其他接口

### 接口初体验 ###

上面提到过，接口代表的是一种能力的体现，就像显示中的USB接口一样，可以连接计算机和外部设备，接下来就拿USB接口举一个具体的栗子：

package cn.zhz.Interface;
    
    //USB接口:描述连接计算机和外部设备的串口总线标准，定义一种输入输出的技术规范
    public interface USB { 
        //USB接口并不实现具体的功能，通过抽象的方法来定义一种数据输入和输出的规范和标准
        void service();
    }

package cn.zhz.Kind;
    
    import cn.zhz.Interface.USB;
    
    public class USBFan implements USB { 
        public void service() { 
            System.out.println("连接USB口，获得电流，风扇开始转动");
        }
    }

package cn.zhz.Kind;
    
    import cn.zhz.Interface.USB;
    
    public class USBDisk implements USB { 
        public void service() { 
            System.out.println("连接USB接口，开始用来传输数据");
        }
    }

package cn.zhz.Test;
    
    import cn.zhz.Interface.USB;
    import cn.zhz.Kind.USBDisk;
    import cn.zhz.Kind.USBFan;
    
    public class USBTest { 
        public static void main(String[] args) { 
            //USB风扇
            USB uFan = new USBFan();
            uFan.service();
            //USB标准的U盘
            USB uDisk = new USBDisk();
            uDisk.service();
        }
    }

### 面向接口编程 ###

##### 抽象类和接口的关系和异同 #####

在前面了解到了抽象类，在本节中知道了接口。其实，在java中抽象类和接口都是支持抽象定义的两种机制，由于抽象类和接口的存在，才赋予了java的强大的面向对象的能力，但是两者也是有很大的异同的:

*  抽象类和接口的相同点

> 抽象类和接口都代表系统的抽象层  
> 都不可以被实例化  
> 都可以包含抽象方法–>用于描述系统提供的服务，不必提供具体的实现

*  抽象类和接口的不同点

> 在抽象类中可以为部分普通方法提供默认实现，JDK8之前接口中只能包含抽象方法，JDK8之后接口可以包含默认方法  
> 一个类只可以继承一个直接的父类，但是可以实现多个接口

*  抽象类和接口的使用原则

> 代码满足is a的关系就是抽象类 满足has a的关系就是接口  
> 接口是用来做系统和外界交互的窗口，是用来提供服务的  
> 接口本身一旦制定，就不允许随意的修改  
> 抽象类可以完成部分功能实现，还有部分功能可以作为系统的扩展点  
> 抽象类便于复用，接口便于功能扩展和维护

下面给出一个具体的栗子:

> 现在想实现一个防盗门的功能，防盗门有开门和关门的功能；同时呢也具备开锁和上锁的功能；为了防盗，如果有客人开拜访，按下门铃，防盗门会自动拍照存储客人的图片

*  第一步:由于门这个类和开门关门这个方法都是抽象的，所以可以声明一个Door类作为抽象父类

package cn.zhz.Kind;
    
    public abstract class Door { 
    	//开门
        public abstract void open();
    	//关门
        public abstract void close();
    }

*  第二步:开始定义接口

使防盗门具有锁的功能，也就是开锁和上锁的功能，这里声明的是Lock接口:

package cn.zhz.Interface;
    
    public interface Lock { 
        //这里也可以加public abstract
        //上锁
        void lockUp();
    	//开锁
        void openLock();
    }

同时定义一个门铃，可以对来访者进行拍照存储

package cn.zhz.Interface;
    
    public interface DoorBell { 
    	//门铃接口，如果有客人拜访进行拍照存储
        void takePicture();
    }

*  第三步:定义防盗门TheftproofDoor类，由于是防盗门，肯定是门，也就是防盗门is a门(两者满足is a的关系)，用extends继承；防盗门有具备上锁、开锁和按门铃拍照存储的能力(两者满足has a的关系)用implements接口

package cn.zhz.Kind;
    
    import cn.zhz.Interface.DoorBell;
    import cn.zhz.Interface.Lock;
    
    public class TheftproofDoor extends Door implements Lock, DoorBell { 
        //上锁功能
        @Override
        public void lockUp() { 
            System.out.println("插进钥匙，向左转三圈，锁上了，拔出钥匙");
        }
    
        //开锁功能
        @Override
        public void openLock() { 
            System.out.println("插进钥匙，向右转三圈，锁开了，拔出钥匙");
        }
    	
    	//开门功能
        @Override
        public void open() { 
            System.out.println("用力推，门开了");
        }
    	
    	//关门功能
        @Override
        public void close() { 
            System.out.println("轻轻拉门，门关上了");
        }
    
        @Override
        public void takePicture() { 
            System.out.println("拍照存储");
        }
    }

*  第四步:将防盗门这个类实例化，调用方法，是否满足预期的需求

package cn.zhz.Test;
    
    import cn.zhz.Kind.TheftproofDoor;
    
    public class TheftproofDoorTest { 
        public static void main(String[] args) { 
            TheftproofDoor door = new TheftproofDoor();
            //关门上锁
            door.close();
            door.lockUp();
            //有客人拜访
            door.takePicture();
            //开锁开门
            door.openLock();
            door.open();
        }
    }

> 现在要购买两种手机，第一种手机是普通手机，可以发音频，发文字消息，打电话；但是随着时代的发展，出现了第二种智能手机，可以看视频，联网，拍照存储，视频通话等等，写出这两种手机，并测试

*  声明一个手机类Phone作为抽象父类，其中包含了手机的成员变量:品牌 型号和抽象方法，打电话和发短信

package cn.zhz.Kind;
    
    public abstract class Phone { 
        private String brand;//品牌
        private String type;//型号
    
        public Phone() { 
    
        }
    
        public Phone(String brand, String type) { 
            this.type = type;
            this.brand = brand;
        }
    
        public String getBrand() { 
            return brand;
        }
    
        public void setBrand(String brand) { 
            this.brand = brand;
        }
    
        public String getType() { 
            return type;
        }
    
        public void setType(String type) { 
            this.type = type;
        }
    
        public void showInfo() { 
            System.out.println("这是一台" + brand + type + "的手机");
        }
    
        //打电话
        public abstract void call();
    
        //发信息
        public abstract void sendMsg();
    }

*  定义接口:  
    实现连接网络的功能

package cn.zhz.Interface;
    
    public interface NetWork { 
        void netWorkConn();
    }

拍照存储的功能

package cn.zhz.Interface;
    
    public interface TakePhoto { 
        void takePhoto();
    }

播放视频或者音频的功能

package cn.zhz.Interface;
    
    public interface PlaySth { 
        void play(String content);
    }

*  普通手机CommonPhone的声明

package cn.zhz.Kind;
    
    import cn.zhz.Interface.PlaySth;
    
    public class CommonPhone extends Phone implements PlaySth { 
        public CommonPhone() { 
    
        }
    
        public CommonPhone(String brand, String type) { 
            super(brand, type);
        }
    
        @Override
        public void play(String content) { 
            System.out.println("正在播放音频<" + content + ">.....");
        }
    
        @Override
        public void call() { 
            System.out.println("正在语音通话中.......");
        }
    
        @Override
        public void sendMsg() { 
            System.out.println("正在发送文字信息......");
        }
    }

*  智能手机的声明

package cn.zhz.Kind;
    
    import cn.zhz.Interface.NetWork;
    import cn.zhz.Interface.PlaySth;
    import cn.zhz.Interface.TakePhoto;
    
    public class SmartPhone extends Phone implements NetWork, TakePhoto, PlaySth { 
        public SmartPhone() { 
    
        }
    
        public SmartPhone(String brand, String type) { 
            super(brand, type);
        }
    
        @Override
        public void netWorkConn() { 
            System.out.println("连接上了wifi网络");
        }
    
        @Override
        public void play(String content) { 
            System.out.println("正在播放视频<" + content + ">.....");
        }
    
        @Override
        public void takePhoto() { 
            System.out.println("拍照存储");
        }
    
        @Override
        public void call() { 
            System.out.println("正在视频通话中");
        }
    
        @Override
        public void sendMsg() { 
            System.out.println("正在发送文字+图片+音频信息");
        }
    }

*  对两种手机进行测试

package cn.zhz.Test;
    
    import cn.zhz.Kind.CommonPhone;
    import cn.zhz.Kind.SmartPhone;
    
    public class PhoneTest { 
        public static void main(String[] args) { 
            CommonPhone commonPhone = new CommonPhone("诺基亚", "T5");
            commonPhone.call();
            commonPhone.sendMsg();
            commonPhone.play("探清水河");
            System.out.println("*********************");
            SmartPhone smartPhone = new SmartPhone("iphone", "XS MAX");
            smartPhone.sendMsg();
            smartPhone.call();
            smartPhone.play("万梦星");
            smartPhone.netWorkConn();
            smartPhone.takePhoto();
        }
    }

[java集合概述][java 1]

[java]: https://blog.csdn.net/qq_45671732/article/details/117039725
[java 1]: https://blog.csdn.net/qq_45671732/article/details/117856724