十九、OOP之理解《接口》

最新推荐文章于 2024-08-15 14:47:41 发布

书源丶

最新推荐文章于 2024-08-15 14:47:41 发布

阅读量1.7k

点赞数 40

分类专栏： java基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_57423018/article/details/137915993

版权

java基础专栏收录该内容

26 篇文章 2 订阅

订阅专栏

看完了面向对象的三大特性，接着我们进一步理解Java的抽象类和接口，什么是接口？
简单介绍一下OOP的精髓，是对对象的抽象，最能体现这一点的就是接口。开发最重要的一句话就是（面向接口编程~）
接下来开始步入正题~

一、接口

接口定义：
接口就是定义一组规则，提现了现实世界中“如果你是…则必须能…”的思想。
如果你是天使，则必须能飞。如果你是汽车，则必须能跑。

回顾一下之前的几种

普通类：只有具体实现
抽象类： 具体实现和规范（抽象方法）都有！
接口： 只有规范，自己无法写方法~专业的约束！ 约束和实现分离

接口的作用和注意点：
1.约束（“如果你是…则必须能…”的思想）
2.定义一些方法，让不同的人实现~ 比如10个员工——>实现1个接口，极大提升开发效率
3.方法默认public abstract
4.常量默认public static final
5.接口不能被实例化~，接口中没有构造方法！~
6.implements 可以实现多个接口
7.类中必须要重写接口中的方法

接口的再理解

1、电脑上有很多接口，接口可以插入相应的设备，这些设备能插入的原因就是按照设备生产厂商的一个规则来生产设备，如果不按照规则来，就无法插入了

2、接口的本质：就是规则、契约像法人类的法律，制定好之后大家都遵守。

3、好处:

(1) 扩展一个事物的功能

(2) 可以达到高内聚，低耦合的作用、方便后期维护

4、接口在程序中的好处：

(1) 规则的定义者和实现者分离

(2) 规则：对应的就是方法，都是抽象方法

(3) 实现者，对应的就是方法的具体实现

二、Java中的接口

1、一切的规则就是接口，在java中定义的方法名就是接口(参数列表、返回值类型、方法名称)

2、好处：

规则的定义者和实现者分离，接口的定义者只需要说明应该有什么方法，不用管谁具体实现了这些方法

3、接口定义的格式： 接口中只能定义抽象方法

声明类的关键字是Class。声明接口的关键字是interface。

interface 接口名{

 方法的声明;

 }

4、实现接口

class 类名 implements 接口名{

重写接口中定义的所有的抽象方法

}

public class Demo01 {
    public static void main(String[] args) {
        Mouse m = new Mouse();
        m.powerOff();
        m.powerOn();
        m.sendData();
    }
}
//定义一个USB接口
interface USB{
    //通电
    public abstract void powerOn();
    //断电
    public abstract void powerOff();
    //传输数据
    public abstract void sendData();
}
//鼠标   接口实现类
class Mouse implements USB{
    @Override
    public void powerOn() {
        System.out.println("通电了");
    }

    @Override
    public void powerOff() {
        System.out.println("断电了");
    }
    @Override
    public void sendData() {
        System.out.println("传递坐标");
    }
}

三、接口的特点

1、接口不能实例化

(1) 定义实现类，实现接口接口实现类创建对象，对象调用方法

2、接口的实现类，也可以看做是接口的子类，可以使用接口类型的引用指向实现类对象

3、接口实现类的分类，必然是一个类

(1) 一个类完全实现了所有的抽象方法，那么就是一个普通类

(2) 如果没有完全实现就是一个抽象类

4、接口中不能定义成员变量：

接口中定义的属性，都是静态常量属性、定义的属性前面默认会补齐 public static final

5、接口中不能定义构造方法：没有成员变量，就没有构造方法

6、成员方法jdk8之前不行

(1) 8版本下，多了默认方法，和静态方法

(2) 定义抽象方法的时候，可以只写返回值类型方法名称(参数列表) ,默认前面会补齐public abstract

public class Demo02 {
    public static void main(String[] args) {
        System.out.println(Inter1.i);//静态修饰
//        Inter1.i = 20; final修饰
        Test1 t = new Test1();
        t.test();
        t.test2();
    }
}
interface Inter1{
    //定义属性
    int i = 10;//看起来自己定义了一个变量,其实默认为我们加上了public static final
    public static final int j = 10;//效果和上面一致
    void test();//可以只写方法名称  返回值类型 参数列表，默认前面会加上public abstract
    public abstract void test2();
    //不能有成员方法
//    public void test3(){
//
//    }
    //不能有构造方法
//    public Inter1(){}
}
class Test1 implements Inter1{
    //一个类如果将接口中的抽象方法全部实现，就是一个普通类，可以创建对象使用
    @Override
    public void test() {
    }
    @Override
    public void test2() {
    }
}
//如果没有或者没有完全实现接口中的方法，就是一个抽象类
abstract class Test2 implements Inter1{
}
class Test3 extends Test2{
    @Override
    public void test() {  
    }
    @Override
    public void test2() {
    }
}

package oop.Interface;
//锻炼抽象的思维~JAVA  架构师抽象思维要牛逼！！！！！！
//定义的关键字interface，接口都需要有实现类
public interface UserService {
    //属性可以定义常量 默认public static final
    int AGE=99;
  //接口中的所有定义都是抽象的public
  //不写默认都是 public abstract
 void add(String name);//增
 void delete(String name);//删
 void update(String name);//改
 void query(String name);//查
}

然后我们在回到之前 类与类、类与接口、接口与接口

四、类与类、类与接口、接口与接口

首先

1、类与类：

(1) 继承：使用extends

(2) 支持单继承、不支持多继承、支持多层继承

其次

2、类与接口

(1) 实现的关系，使用implements关键字

(2) 可以单实现，也可以多实现

(3) 多实现的格式：

class 类名 implements 接口1，接口2，接口3....{

 重写接口中的所有的抽象方法

}

多实现没有安全隐患，即使有相同的方法，但是类中只需要提供一个实现就够了

可以继承一个类，再实现多个接口

class 类名 extends 父类 implements 接口1,接口2,接口3...{

 重写所有的抽象方法

}

最后

3、接口与接口的关系：

(1) 继承的关系：使用extends

(2) 可以是单继承、多继承、多层继承

4、父类和接口（区别）：

(1) 父类：定义的都是先天具有的属性和行为，先天

(2) 接口：定义的都是可以通过后天学习，自己拓展出来的行为

(3) 父类：狗属性姓名颜色行为吃喝睡

(4) 哈士奇：属性姓名颜色行为吃喝睡拆家

(5) 金毛：属性姓名颜色行为吃喝睡掉毛

(6) 缉毒接口：会区分毒品会报警

(7) 缉毒犬

金毛 extends 狗 implements 缉毒接口{
   金毛就成了一个缉毒犬了
}

public class Demo03 {
    public static void main(String[] args) {
    }
}
interface Inter2 {
    void test();
}
interface Inter3 {
    void test();
    void test2();
}
interface Inter4 {
    void test3();
}
//可以定义一个类实现多个接口
class Impl implements Inter2,Inter3,Inter4{
    @Override
    public void test() {
    }
    @Override
    public void test2() {
    }
    @Override
    public void test3() {
    }
}
abstract class Fu{
    public void hehe(){
        System.out.println("儿子 加油 你要实现多个接口 好累啊");
    }
    public abstract void test();
    public void test2(){
        System.out.println("我是父类的test2");
    }
}
//可以继承一个类 实现多个接口
class Zi extends Fu implements Inter4,Inter3,Inter2{
    @Override
    public void test() {
    }
    @Override
    public void test2() {
    }
    @Override
    public void test3() {
    }
}
//接口之间可以多继承   相同的方法只保留一份
interface Inter5 extends Inter2,Inter3,Inter4{
}
class Impl2 implements Inter5{
    @Override
    public void test() {
    }
    @Override
    public void test2() {
    }
    @Override
    public void test3() {
    }
}