JAVA接口

最新推荐文章于 2024-10-27 15:49:02 发布

昱晟168

最新推荐文章于 2024-10-27 15:49:02 发布

阅读量434

点赞数

分类专栏： JAVA编程高级部分文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_47267628/article/details/122790317

版权

JAVA编程高级部分专栏收录该内容

11 篇文章 0 订阅

订阅专栏

接口

接口的引出：USB插槽是现实中的接口，可以把手机，相机，U盘都插入USB插槽中，而不用担心那个插槽是专门插哪个的，原因是做了USB插槽的厂家和做各种设备的厂家都遵守了统一的规定包括尺寸，排线等等。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eQiQbBFg-1644043206743)(E:\Typora笔记\java笔记\img\image-20220127170403823.png)]$

接口的快速入门：

package JAVA面向对象高级部分.interface_;

public interface USBInterface {
    //开始工作的方法
    public abstract void start();
    //结束工作方法
    public abstract void stop();
}

package JAVA面向对象高级部分.interface_;

public class Phone implements USBInterface{//手机类
    @Override
    public void start() {
        System.out.println("呵呵可以玩手机了。。。");
    }

    @Override
    public void stop() {
        System.out.println("想想就生气手机关机了。。。");
    }
}


package JAVA面向对象高级部分.interface_;

public class Camera implements USBInterface{//相机类

    @Override
    public void start() {
        System.out.println("相机开始工作了。。。");
    }

    @Override
    public void stop() {
        System.out.println("相机关机了。。。");
    }
}


package JAVA面向对象高级部分.interface_;

public class Computer {//电脑类

    public void work(USBInterface usbInterface){
        usbInterface.start();
        usbInterface.stop();
    }
}

接口的基本介绍

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来。

接口定义语法：

interface 接口名{ //属性 //方法【1.抽象方法 2.默认实现方法 3.静态方法】 }

接口实现语法：

class 类名 implements 接口{
	自己属性
	自己方法
	必须实现的接口的抽象方法
}

小结：（必须记住）

在jdk7.0前接口里的所有方法都没有方法体，即都是抽象方法
在jdk8.0后接口可以有静态方法，默认方法default修饰，也就是说接口中可以有方法具体实现

package JAVA面向对象高级部分.interface_.intterface01;

public class TestInterface01 {
    public static void main(String[] args) {

    }
}

interface A {
    //在接口中可以有自己的属性和抽象方法
    //属性
    public int num = 10;
    //抽象方法,在接口中抽象方法的abstract可以省略
    public void show();

    //在jdk8.0后接口可以有静态方法，默认方法，也就是说接口中可以有方法具体实现
    //在jdk8.0后接口可以有静态方法或默认方法（默认方法要用default修饰）
    //静态方法
    public static void print(){
        System.out.println("我是中国人！！！");
    }
    
    //默认方法
    default public void hi(){
        System.out.println("您好吗？");
    }
}

注意事项和细节说明：(九点细节必须记住)

1.接口不能被实例化

2.接口中所有方法是public修饰的可以省略，接口中的抽象方法，可以不用abstract修饰

3.一个普通类实现接口，就必须将该接口的所有方法都实现

4.抽象类实现接口，可以不用实现接口的方法

5.一个类同时可以实现多个接口

6.接口中的属性，只能是final的，而且是public static final 修饰符的。比如：int a = 1;实际上是public static final int a = 1;[必须初始化]

7.接口中属性的访问形式：接口名.属性名

8.接口不能继承其它的类，但是可以继承多个别的接口，接口可以是多继承关系

interface X extends Animal,Usb, USBInterface{}

类与类是继承关系，类与类是单继承关系
类与接口是实现关系，类可以实现多个接口
接口与接口是继承关系，接口与接口可以是多继承关系

9.接口的修饰符，只能是public和默认的，这和类的修饰符是一样的

package JAVA面向对象高级部分.interface_;

//细节说明
//1.接口是不能实例化的【不能创建对象和抽象类一样】
//2.接口中所有的方法都是public修饰的，接口中的抽象方法，可以不用abstract修饰
//3.普通类实现接口，就要必须实现接口中所有方法
//4.抽象类实现接口，可以不用实现接口的方法
public interface Animal {

    //接口中所有方法都是用public修饰的，接口中的抽象方法可以不用abstract修饰【意思是public和abstract可以省略】
    void soy();//注意可以省略public 和 abstract

    //接口中的属性，只能是final的，而且是public static final的
    //下面的语句其实是：public static final int a = 1;
    int a = 1;
}

abstract class Cat implements Animal {}//4.说明抽象实现接口可以不用实现接口中的方法

练习题目：

interface A {
	int a = 23;
}
class B implements A {}

在main方法中
B b = new B();
System.out.println("b.a");
System.out.println("A.a");
System.out.println("B.a");
语法是否正确，如果正确，输出什么？
全部正确，都是输出：23

实现接口VS继承类

可以将接口理解为一种规范的制定和继承的补充机制

接口和继承解决的问题不同

继承的价值主要在于：解决代码的复用性和可维护性

接口的价值主要在于：设计，设计好各种规范（方法），让其它类去实现这些方法。即更加的灵活

接口比继承更加灵活

接口比继承更加灵活，继承是满足is - a的关系，而接口只需要满足like - a的关系

接口在一定程度上实现代码解耦【即：接口规范性+动态绑定机制】

package JAVA面向对象高级部分.interface_.interface02;

public class ExtendsVSInterface {
    public static void main(String[] args) {
        LittleMonkey li = new LittleMonkey("孙悟空");
        li.flying();
        li.swimming();
        li.climbing();
    }
}

/**
 * 小结 ：当子类继承了父类，就自动的拥有了父类的功能
 *       如果子类需要扩展功能，可以通过实现接口的方式扩展
 *       可以理解实现接口 是对java单继承机制的一种补充
 */

class Monkey {//猴子
    private String name;

    public Monkey() {
    }

    public Monkey(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public void climbing(){
        System.out.println(getName()+"会上树");
    }
}

//鱼
interface Fish {
    void swimming();//游泳
}

//鸟
interface Bird {
    void flying();//飞翔
}

//小猴子
class LittleMonkey extends Monkey implements Bird,Fish{
    public LittleMonkey() {
    }

    public LittleMonkey(String name) {
        super(name);
    }


    @Override
    public void swimming() {
        System.out.println("猴子会游泳了。。。");
    }

    @Override
    public void flying() {
        System.out.println("猴子会飞翔了。。。");
    }
}

接口的多态特性

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TvJBbZrG-1644043272147)(E:\Typora笔记\java笔记\img\image-20220127220717126.png)]$

多态参数【前面案例体现】，在前面的USB接口案例，USBInterface usb，即可以接收手机对象，又可以接收相机对象，就体现了接口多态【接口引用可以指向实现了接口的类对象】

package JAVA面向对象高级部分.interface_;

public class InterfacePolyParameter {
    public static void main(String[] args) {
        //接口的多态体现，接口类型的变量myInterface可以指向 实现了myClass接口类的对象实例
        //就是父类引用指向子类对象【多态的参数的体现和前面Usb接口案例一样】
        myInterface myInterface = new myClass();
    }
}

//接口的多态体现
interface myInterface{}
//具体类实现接口
class myClass implements myInterface{}

多态数组InterfacePolyArr.java

演示一个案例，给Usb数组中，存入Phone和相机对象，Phone类还有一个特有的方法call()，请遍历Usb数组，如果是Phone对象，除了调用Usb接口定义方法外，还需要调用Phone特有方法call()

package JAVA面向对象高级部分.interface_.interface03;

public class InterfacePolyArr {
    public static void main(String[] args) {
        //多态数组
        Usb[] usb = new Usb[2];
        usb[0] = new Phone();
        usb[1] = new Camera();
        for (int i = 0; i < usb.length; i++) {
            //调用Usb接口中的work方法
            usb[i].work();
            
            //调用手机特有方法
            if (usb[i] instanceof Phone){
                Phone phone = (Phone) usb[i];
                phone.call();
            }
        }
    }
}

//Usb接口
interface Usb{
    //省略了public和static关键字
    void work();
}

//Phone类
class Phone implements Usb {
    @Override
    public void work() {
        System.out.println("手机工作");
    }

    //手机类特有的方法
    public void call(){
        System.out.println("手机可以打电话。。。");
    }
}

//Camera相机类
class Camera implements Usb {

    @Override
    public void work() {
        System.out.println("相机可以拍照了。。。呵呵！！！");
    }
}

接口存在多态传递现象InterfacePolyPass.java

package JAVA面向对象高级部分.interface_.interface04;

/**
 * 接口的多态传递现象
 */
public class InterfacePolyPass {
    public static void main(String[] args) {
        //接口类型的变量可以指向，实现了该接口的类对象的引用实例【相当于父类指向子类引用】
        Father father = new Son();
        //如果Father继了GrandPa接口，而Son实现了Father接口
        //那么，实际上就相当于Son类也实现了GrandPa接口
        //下面就是所谓的接口多态传递现象
        Grandpa grandpa = new Son();
    }
}

interface Grandpa { }
interface Father extends Grandpa{ }
class Son implements Father{ }

练习题目 (必须重点理解下面练习题目)

interface A {
	int x = 0;
}
class B {
	int x =1;
}
class C extends B implements A {
	public void pX(){
		//System.out.println("x");//错误，原因是不明确x
		//可以明确指定x
		//访问接口的 X 就使用A.X
		//访问父类的 X 就使用super.X
		System.out.println(A.x+"  "+super.x)
	}
	
	public static void main(String[] args){
		new C().pX();
	}
}

代码有没有错误，有错误就改正，看看输出结果？
有错误，接口也父类都有一个同名的X，造成了不知道使用是接口的还是父类的X
改正如上面：