Java-接口(上)

简介: Java-接口(上)

1.接口的概念


a51da3bce6e546a3ac09c4ff24d07888.png


电脑的USB口上,可以插:U盘、鼠标、键盘等所有符合USB协议的设备;数据线的type-c口上,可以插手机,蓝牙耳机充电盒等所有符合规范的设备。由此可以看出:接口就是公共行为的规范表准,在使用时,只要符合规范就可以使用,在Java中,接口可以看成是多个类的公共规范,是一种引用数据类型。


2.语法规则



       接口的定义格式与定义类的格式基本相同,将class关键字换成 interface 关键字,就定义了一个接口。


public interface 接口名{
        //抽象方法
        public abstract void method1(); //在接口中public abstract是固定搭配,可以省略不写         public void method2();
        abstract void method3();
        void method4();   //以上几种定义方法的方式都可以
}


提示:创建接口时,一般以大写字母I开头来命名,命名一般用“形容词”词性的单词,接口中的方法和属性不要加任何修饰符号,保持代码简洁


3.接口使用



      接口不能直接使用,必须要有一个"实现类"来"实现"该接口,实现接口中的所有抽象方法。


public class 类名 implements 接口名{
        //...
}


注意:子类和父类之间是extends 继承关系,类与接口之间是 implements 实现关系。


请实现笔记本电脑使用USB鼠标、USB键盘的例子

1. USB接口:包含打开设备、关闭设备功能

2. 笔记本类:包含开机功能、关机功能、使用USB设备功能

3. 鼠标类:实现USB接口,并具备点击功能

4. 键盘类:实现USB接口,并具备输入功能


//USB接口
public interface USB {
    //打开设备
    void openDevicce();
    //关闭设备
    void offDevicce();
}
//鼠标类,实现USB接口
public class Mouse implements USB{
    @Override
    public void openDevicce() {
        System.out.println("连接鼠标设备成功");
    }
    @Override
    public void offDevicce() {
        System.out.println("鼠标设备断开连接");
    }
    //鼠标点击
    public void click(){
        System.out.println("鼠标点击成功~");
    }
}


//键盘类,实现USB接口
public class KeyBoard implements USB{
    @Override
    public void openDevicce() {
        System.out.println("连接键盘设备成功");
    }
    @Override
    public void offDevicce() {
        System.out.println("键盘设备断开连接");
    }
    //输入功能
    public void input(){
        System.out.println("键盘输入");
    }
}


//电脑类,
public class Computer {
    //开机
    public void openComputer(){
        System.out.println("打开电脑");
    }
    //关机
    public void offComputer(){
        System.out.println("关闭电脑");
    }
    //使用USB接口设备
    public void useDevicce(USB usb){
        usb.openDevicce();
        if (usb instanceof Mouse){
            Mouse mouse= (Mouse)usb;
            mouse.click();
        }
        if (usb instanceof KeyBoard){
            KeyBoard keyBoard=(KeyBoard)usb;
            keyBoard.input();
        }
        usb.offDevicce();
    }
}
//测试类
public class Text {
    public static void main(String[] args) {
        //实例化电脑
        Computer computer=new Computer();
        //打开电脑
        computer.openComputer();
        System.out.println("====");
        //使用鼠标设备
        computer.useDevicce(new Mouse());
        System.out.println("====");
        //使用键盘设备
        computer.useDevicce(new KeyBoard());
        //关闭电脑
        computer.offComputer();
    }
}

e62771387c7c4e289b801656122a9029.png


4.接口特性



       1. 接口类型是一种引用类型,但不能直接new接口的对象。


public class TestUSB {
        public static void main(String[] args) {
                USB usb = new USB();
        }
}  //编译报错,USB是抽象类型,无法实例化


2.接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract(只能是public abstract,其他修饰符都会报错)。


public interface USB {
        private void openDevice(); // 编译 报错,不允许使用修饰符private
        void closeDevice();
}


 3.接口中的方法是不能在接口中实现的,只能由实现接口的类来实现


public interface USB {
       void openDevice();
         void closeDevice(){
                System.out.println("关闭USB设备");
         }// 编译报错,因为接口中的方法默认为抽象方法,不能带有方法体
}


4. 重写接口中方法时,不能使用默认的访问权限


public interface USB {
        //打开设备
        void openDevicce();
        //关闭设备
        void offDevicce();
}
public class Mouse implements USB{
        @Override
        void openDevicce() {
        System.out.println("连接鼠标设备成功");
}        //编译报错,重写时不能使用默认修饰符


5. 接口中可以含有变量,但是接口中的变量会被隐式的指定为 public static final 变量


public interface USB {
     int a=1;//默认被 final public static 修饰
    //打开设备
    void openDevicce();
    //关闭设备
    void offDevicce();
}
public class Text {
    public static void main(String[] args) {
        System.out.println(USB.a); //可以通过接口访问,说明是静态的
        System.out.println(a); //可以直接访问,说明是公开的
        USB a=10; //编译报错,说明a具有final属性
    }
}


 6. 接口中不能有静态、动态代码块和构造方法。


public interface USB {
        public USB(){
        } //编译报错
        {
        } // 编译报错
        static{
        }  //编译报错
        void openDevice();
        void offDevice();
}


7. 接口虽然不是类,但接口编译完成后字节码文件的后缀格式也是.class

       8. 如果类没有实现接口中的所有抽象方法,则类必须设为抽象类

       9.jdk8中:接口中还可以包含default方法

目录
相关文章
|
28天前
|
设计模式 Java
Java基础—笔记—多态、final、抽象类、接口篇
该文介绍了编程中的多态、final和抽象类、接口相关概念。多态允许子类重写父类方法,通过父类引用调用子类方法,实现解耦和提高代码灵活性,但也可能导致无法使用子类特有功能,需通过强制类型转换解决。final用于修饰不可变的类、方法或变量,防止继承、重写和多次赋值。抽象类是一种包含抽象方法的类,用于强制子类重写特定方法,实现多态,适用于模板方法设计模式,解决代码重复问题。
17 0
|
28天前
|
Java
Java基础—笔记—接口篇
接口是Java中的一个抽象概念,用于创建数据结构,类似于更纯粹的抽象类。定义包括常量(默认public static final)和抽象方法(默认public abstract)。接口通过子类实现,如`public class 子类 implements 接口1, 接口2...`。JDK8后增加了默认方法(通过子类对象调用)和静态方法(通过接口名调用)。JDK9引入了私有方法,仅在接口默认方法中调用。目的是在不修改子类的情况下扩展功能。一个类可以继承一个父类并实现多个接口,一个接口可继承多个接口。
12 0
|
1天前
|
Java 开发者
在Java中,接口和超类在多态性中扮演着重要的角色
Java中的接口和超类支持多态性,接口作为规范,允许多继承和回调机制;超类提供基类,实现代码重用和方法重写,两者共同促进代码的灵活性和可维护性。
23 10
|
1天前
|
Java
接口在增强Java代码的灵活性方面起着关键作用
Java接口增强代码灵活性,实现多态性、解耦、多继承和扩展性。通过接口,类可隐藏实现细节,实现抽象化,促进模块化和维护性。接口定义方法,允许不同类实现,减少依赖,便于测试和修改。同时,接口提供多继承解决方案,使代码更具扩展性,易于添加新功能。
13 4
|
7天前
|
存储 Java
java IO接口(Input)用法
【5月更文挑战第1天】Java的`java.io`包包含多种输入输出类。此示例展示了如何使用`FileInputStream`从`input.txt`读取数据。首先创建`FileInputStream`对象,接着创建一个字节数组存储读取的数据,调用`read()`方法将文件内容填充至数组。然后将字节数组转换为字符串并打印,最后关闭输入流。注意,`InputStream`是抽象类,此处使用其子类`FileInputStream`。其他子类如`ByteArrayInputStream`、`ObjectInputStream`和`BufferedInputStream`各有特定用途。
19 2
|
8天前
|
NoSQL Java API
java一行代码实现RESTFul接口
Spring Data REST是构建在Spring Data之上的库,可自动将repository转换为REST服务,支持JPA、MongoDB、Neo4j、GemFire和Cassandra。无需手动创建Service和Controller层。要开始,需配置JPA数据源,创建实体类和Repository接口。快速实现REST接口,只需引入spring-boot-starter-data-rest Maven依赖,并在Repository接口上添加@RepositoryRestResource注解。
|
9天前
|
Java 程序员 数据格式
关于Java抽象类和接口的总结和一点个人的看法
关于Java抽象类和接口的总结和一点个人的看法
|
14天前
|
存储 安全 Java
[Java基础面试题] Map 接口相关
[Java基础面试题] Map 接口相关
|
15天前
|
Java
一文搞清楚Java中的包、类、接口
包、类、接口、方法、变量、参数、代码块,这些都是构成Java程序的核心部分,即便最简单的一段代码里都至少要包含里面的三四个内容,这两天花点时间梳理了一下,理解又深刻了几分。
32 10
|
19天前
|
Java 开发者
探索 Java 的函数式接口和 Lambda 表达式
【4月更文挑战第19天】Java 中的函数式接口和 Lambda 表达式提供了简洁、灵活的编程方式。函数式接口有且仅有一个抽象方法,用于与 Lambda(一种匿名函数语法)配合,简化代码并增强可读性。Lambda 表达式的优点在于其简洁性和灵活性,常用于事件处理、过滤和排序等场景。使用时注意兼容性和变量作用域,它们能提高代码效率和可维护性。