您现在的位置是：首页 > Java

当前栏目

java的接口

JAVA 接口抽象

2023-03-02 10:31:41 时间

[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

猜你喜欢

最长无重复子串
写技术博客的一些心得分享
Java 多线程（七）：线程池
Java 多线程（五）：锁（三）
Java 多线程（四）：锁（二）
Java 多线程（三）：锁（一）
Java 多线程（二）：并发编程的三大特性
线性时间非比较类排序
Java 多线程（一）：基础
合并k个已排序的链表
HDFS 高可用分布式环境搭建
合并两个有序数组
连续子数组的最大和
HDFS 分布式环境搭建
容器盛水问题
大数加法
HDFS 伪分布式环境搭建
设计LRU缓存结构
两数之和
使用单调栈来解决的一些问题

zl程序教程

当前栏目

java的接口

相关文章