java---接口

用户10787181

发布于 2023-10-17 09:12:06

1670

发布于 2023-10-17 09:12:06

文章被收录于专栏：小龙学编程

10.1 基础语法及概念

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。(Java中的继承：一个类只能有一个父类 B 继承 A C 继承B D 继承C 不能多继承意思是D 不能同时继承A,B,C。Java为了解决单继承的缺陷，出现了接口，一个类可以实现多个接口，多个之间用逗号分隔） B实现A A（接口） B(实现类)

接口是抽象方法的集合,接口中的抽象方法不需要使用abstract来进行修饰

语法

public interface 接口名{

方法的定义

public void show(); //定义出来的方法一定是抽象方法不能有实现

}

对于接口而言不叫继承，叫实现，哪个类要继承接口，叫做实现接口，也称为这个接口的实现类

实现语法

public class 类名 implements 接口名,接口名1,接口名2{

}

实现类实现的接口中的方法必须要重写,这个重写过程就是实现，因为接口中只有方法的定义，实现类中必须对这些方法实现具体的代码。

java面向对象编程，java面向接口编程， java面向Spring编程。

接口拥有用于对原来的程序进行功能扩充的能力,必须要注意，以后的框架很多都要求以接口的形式出现。OOP设计模式。

基础语法案例:

package com.qf.interface1;

public interface StudentInterface {
    public void show();
    public void study();
}

package com.qf.entitys;

import com.qf.interface1.StudentInterface;

public class Student implements StudentInterface {

    private String name;
    private String phone;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public void show() {
        System.out.printf("姓名:%s,电话:%s\n",this.name,this.phone);
    }

    public void study() {
        System.out.printf("%s同学在认真的学习",this.name);
    }
}

public class Start {
    public static void main(String[] args) {
        Student student=new Student();
        student.setName("张三");
        student.setPhone("13321345678");
        student.show();
        student.study();

    }
}

接口也能实现多态，用接口对象去存放实现类的实例。例如:

StudentInterface stu=new Student();

stu.show();

stu.study();

基础案例:

Java模拟电脑。电脑开机，关机，USB接口 --> 键盘，鼠标(输入设备)， U盘 , 移动硬盘(输入输出设备)，显示器，音响(输出设备)

package com.qf.interface1;

//USB接口
public interface USB {

    //传入
    public void input();
    //传出
    public void output();

}

package com.qf.entitys;

import com.qf.interface1.USB;

//电脑
public class Computer {
    private USB usb1;
    private USB usb2;
    private USB usb3;

    public USB getUsb1() {
        return usb1;
    }

    public void setUsb1(USB usb1) {
        this.usb1 = usb1;
        System.out.println("usb1已接入，驱动安装完成");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public USB getUsb2() {
        return usb2;
    }

    public void setUsb2(USB usb2) {
        this.usb2 = usb2;
        System.out.println("usb2已接入，驱动安装完成");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public USB getUsb3() {
        return usb3;
    }

    public void setUsb3(USB usb3) {
        this.usb3 = usb3;
        System.out.println("usb3已接入，驱动安装完成");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //表示电脑是否打开
    private boolean isopen=false;

    //开机
    public void start()  {
        System.out.print("正在开机");
        for (int i = 1; i <=5 ; i++) {
            System.out.print(".");
            try {
                Thread.sleep(1000);//程序在这里会暂停1秒钟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("进入系统");
        isopen=true;
    }

    //电脑的操作，电脑的操作一定要在开机状态下完成
    public void ctrl(){
        if(isopen){
            if(usb1!=null) {
                usb1.output();
                usb1.input();
            }
            System.out.println("=====================================");
            if(usb2!=null) {
                usb2.output();
                usb2.input();
            }
            System.out.println("=====================================");
            if(usb3!=null) {

                usb3.output();
                usb3.input();
            }
        }
    }

    //关机
    public void close(){
        System.out.println("关闭系统");
        isopen=false;
    }

}

package com.qf.entitys;

import com.qf.interface1.USB;

public class KeyBoard implements USB {
    public void input() {
        System.out.println("键盘开始输入...");
    }

    public void output() {
        System.out.println("键盘灯亮...");
    }
}

package com.qf.entitys;

import com.qf.interface1.USB;

public class Mouse implements USB {
    public void input() {
        System.out.println("鼠标开始操作");
    }

    public void output() {
        System.out.println("鼠标灯亮了...");
    }
}

package com.qf.entitys;

import com.qf.interface1.USB;

public class UBoard implements USB {
    public void input() {
        System.out.println("将U盘中的文件传入电脑中");
    }

    public void output() {
        System.out.println("将电脑中的文件传入U盘中");
    }
}

package com.qf.com.qf.Main;

import com.qf.entitys.Computer;
import com.qf.entitys.KeyBoard;
import com.qf.entitys.Mouse;
import com.qf.entitys.UBoard;

public class Start {
    public static void main(String[] args) {
        Computer computer=new Computer();

        KeyBoard keyBoard=new KeyBoard();
        Mouse mouse=new Mouse();
        UBoard uBoard=new UBoard();

        computer.start();
        computer.setUsb1(keyBoard);
        computer.setUsb2(mouse);
        computer.setUsb3(uBoard);

        computer.ctrl();
        computer.close();

    }
}

10.2 多态

计算案例1、

package com.qf.clac;

public interface Calculation {
    //定义计算接口
    public int clac(int num1,int num2); 

}

加，减，乘，除，取余五个实现类来实现这个接口

package com.qf.clac.impl;

import com.qf.clac.Calculation;

public class Addition implements Calculation {

    public int clac(int num1, int num2) {
        return num1+num2;
    }
}

package com.qf.clac.impl;

import com.qf.clac.Calculation;

public class Division implements Calculation {
    public int clac(int num1, int num2) {
        if(num2==0){
            //人为的抛出一个异常
            throw new RuntimeException("除数不能为0");
        }
        return num1/num2;
    }
}

package com.qf.clac.impl;

import com.qf.clac.Calculation;

public class Multiplication implements Calculation {
    public int clac(int num1, int num2) {
        return num1*num2;
    }
}

package com.qf.clac.impl;

import com.qf.clac.Calculation;

public class Residual implements Calculation {
    public int clac(int num1, int num2) {
            if(num2==0){
                //人为的抛出一个异常
                throw new RuntimeException("除数不能为0");
            }
            return num1%num2;
    }
}

package com.qf.clac.impl;

import com.qf.clac.Calculation;

public class Subtraction implements Calculation {
    public int clac(int num1, int num2) {
        return num1-num2;
    }
}

package com.qf.start;

import com.qf.clac.Calculation;
import com.qf.clac.impl.*;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入第一个数:");
        int num1=input.nextInt();
        System.out.println("请输入一个符号:");
        char f=input.next().charAt(0);
        System.out.println("请输入第二个数:");
        int num2=input.nextInt();
        Calculation calculation=null;
        switch (f){
            case '+':
                calculation=new Addition();
                break;
            case '-':
                calculation=new Subtraction();
                break;
            case '*':
                calculation=new Multiplication();
                break;
            case '/':
                calculation=new Division();
                break;
            case '%':
                calculation=new Residual();
                break;

        }
        int clac = calculation.clac(num1, num2);
        System.out.println(clac);
    }
}

加入了设计模式的案例,接口现实在上面:

package com.qf.start;

import com.qf.service.CalcService;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入第一个数:");
        int num1=input.nextInt();
        System.out.println("请输入一个符号:");
        char f=input.next().charAt(0);
        System.out.println("请输入第二个数:");
        int num2=input.nextInt();

        CalcService calcService = new CalcService();
        int calc = calcService.Calc(num1, f, num2);

        System.out.println(calc);
    }
}

package com.qf.service;

import com.qf.clac.Calculation;
import com.qf.clac.entitys.CalcMap;
import com.qf.clac.impl.*;

public class CalcService {


    //这里做计算功能,但是不是具体的计算，只是根据符号去调用上体计算类里的计算功能
    public int Calc(int num1,char f,int num2){

        Calculation calculation=getCalculation(f); //factoryBean(f); //调用获取计算类对象的方法

        if(calculation!=null) {
            int clac = calculation.clac(num1, num2);
            return clac;
        }else{
            //抛出一个异常  返回一个具体的值是不对的，有可能人家的计算结果就是这个值呢  0 -1
            throw new RuntimeException("输入的符号错误");
        }
    }

    /**
     * 根据输入的符号获取对应的计算类对象  策略模式
     * @param f  符号
     * @return   计算类的对象
     */
    private Calculation getCalculation(char f){
        //循环这个所有可能性的数组
        for (CalcMap c: calcUtilsArr) {
            //用户输入的符号与数组哪一个匹配
            if(c.getF()==f){
                //如果匹配就将对应的具体的计算类的对象返回
                return c.getCalculation();
            }
        }
        //如果没有找到返回一个null
        return null;
    }
    //将用于存放所有计算的可能性, CalcMap  有两个属性 一个符号，一个具体的计算操作类
    private CalcMap[] calcUtilsArr=new CalcMap[5];

    /*
        设计模式策略模式  Map HashMap()
     */
    public CalcService(){
        /*Calculation add=new Addition();
        CalcMap addMap=new CalcMap('+',add);*/
        //在CalcService 这里创建的时候就将这个数组初始化好
        calcUtilsArr[0]=new CalcMap('+',new Addition());
        calcUtilsArr[1]=new CalcMap('-',new Subtraction());
        calcUtilsArr[2]=new CalcMap('*',new Multiplication());
        calcUtilsArr[3]=new CalcMap('/',new Division());
        calcUtilsArr[4]=new CalcMap('%',new Residual());
    }


    //简单工厂
    private Calculation factoryBean(char f){
        Calculation calculation=null;
        switch (f){
            case '+':
                calculation=new Addition();
                break;
            case '-':
                calculation=new Subtraction();
                break;
            case '*':
                calculation=new Multiplication();
                break;
            case '/':
                calculation=new Division();
                break;
            case '%':
                calculation=new Residual();
                break;

        }
        return calculation;
    }
}

package com.qf.clac.entitys;

import com.qf.clac.Calculation;

public class CalcMap {
    public CalcMap(char f, Calculation calculation) {
        this.f = f;
        this.calculation = calculation;
    }

    private char f;  //键  key         //  代号     我要根据这里的键这取值  k-v 键值对
    private Calculation calculation;  //具体的人    这里是我具体要用的内容

    public char getF() {
        return f;
    }

    public void setF(char f) {
        this.f = f;
    }

    public Calculation getCalculation() {
        return calculation;
    }

    public void setCalculation(Calculation calculation) {
        this.calculation = calculation;
    }
}

10.3 接口中的静态常量

接口中可以定义成员属性，但是接口中定义出来的成员属性有两个默认修饰 static final ，所以接口中的成员属性默认就是静态和终态变量。静态常量。

package com.qf.interface2;

public interface StudentInterface {
    //public static final String name="张三";
    String name="张三";//默认自带 static final
    public void study();

}

10.4 接口的规范

1、一个类可以同时实现多个接口，多个接口这间用逗号分隔(掌握)

public class Student implements StudentInterface, PeopleInterface {
    //这是来自学生接口中
    public void study() {
        System.out.println(StudentInterface.name+"在学习");
    }

    //下面这两个方法是实现人类接口中的
    public void eat() {
        System.out.println("吃饭");
    }

    public void sleep() {
        System.out.println("睡觉");
    }
}

2、接口不能直接被接口自己实例化，它与抽象类同理，接口对象只能被实现类实例化。(掌握)

public class Main {
    public static void main(String[] args) {
        
        //   StudentInterface studentInterface=new StudentInterface();这样对接口创建接口对象是不对的,语法通不过
        
        //很少会在同一地方去同时调用不同接口中的方法 ，一般都是在不同的地方调用实现类中的接口方法
        PeopleInterface student=new Student();
        student.sleep();
        student.eat();
        //如果你真的要在同一地方调用所有接口中的方法时，请进行拆箱操作
        StudentInterface stu=(StudentInterface) student;
        stu.study();
    }
}

3、一个接口可以去继承另一个接口,继承之后子接口中就拥有了父接口中定义的方法(掌握)

public interface StudentInterface extends PeopleInterface {
    public static final String name="张三";
    public void study();

}
package com.qf.interface2.impl;

import com.qf.interface2.PeopleInterface;
import com.qf.interface2.StudentInterface;

//这里Student只实现了StudentInterface接口，但是实现的方法必须把PeopleInterface中定义的方法一起实现
//因为StudentInterface和PeopleInterface是父子关系。
public class Student implements StudentInterface {
    //这是来自学生接口中
    public void study() {
        System.out.println(StudentInterface.name+"在学习");
    }

    public void eat() {
        System.out.println("吃饭");
    }

    public void sleep() {
        System.out.println("睡觉");
    }
}

4、一个类不能实现多继承，但是接口可以多继承（了解）

父接口
package com.qf.interface2;

public interface PeopleInterface {
    public void eat();
    public void sleep();
}

package com.qf.interface2;

public interface TeacherInterface {
    public void subject();
}

子接口
//StudentInterface extends PeopleInterface,TeacherInterface  这里学生接口继承了多个父接口
public interface StudentInterface extends PeopleInterface,TeacherInterface {
    public static final String name="张三";
    public void study();

}

实现类

//必须实现这个接口中所有的父接口定义的方法
public class Student implements StudentInterface {
    //这是来自学生接口中
    public void study() {
        System.out.println(StudentInterface.name+"在学习");
    }
    //这是父接口People中的两个方法
    public void eat() {

    }

    public void sleep() {

    }
    //这是父接口Teacher中的一个方法
    public void subject() {

    }
}

5、接口中的方法不能有具体的实现,但是默认方法和静态方法可以有具体的实现（了解）

package com.qf.interface2;

public interface StudentInterface {
    public static final String name="张三";
    //接口定义的方法
    public void study();
    //默认方法，可以有实现
    default void eat(){
        System.out.println(name+"吃饭");
    }
    //静态方法，可以有实现
    static void sleep(){
        System.out.println(name+"睡觉");
    }
}

public class Main {
    public static void main(String[] args) {
        //接口中静态方法的调用
       StudentInterface.sleep();

       StudentInterface stu=new Student();
       stu.eat(); //接口默认方法的调用
    }
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2023-09-21，如有侵权请联系 cloudcommunity@tencent.com 删除

java