• Java—接口

    目录

    1.接口

    1.1接口概述

    1.2接口的特点

    1.3接口的成员特点

    案例:猫和狗

    1.4类和接口的关系

    1.5抽象类和接口的区别

    案例:运动员和教练

    1.接口

    1.1接口概述

    接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用

    Java中的接口更多的体现在对行为的抽象

    1.2接口的特点

    接口用关键字interface修饰
            public interface接口名{}

    类实现接口用implements表示
            public class类名implements接口名{}

    接口不能实例化
            接口如何实例化呢?参照多态的方式，通过实现类对象实例化，这叫接口多态。

            多态的形式:具体类多态，抽象类多态，接口多态。
            多态的前提:有继承或者实现关系;有方法重写;有父(类/接口)引用指向(子/实现)类对象

    接口的实现类
            要么重写接口中的所有抽象方法

            要么是抽象类

    接口：

    1. package zyy03;
    2. /*定义了一个接口*/
    3. public interface Jump {
    4.     public abstract void Jumpping();
    5. }

    猫类（接口的实现类）：

    1. package zyy03;
    2.  
    3. public class Cat implements Jump{
    4.     @Override
    5.     public void Jumpping() {
    6.         System.out.println("猫可以跳高");
    7.     }
    8. }

    测试类：

    1. package zyy03;
    2.  
    3. public class Demo {
    4.     public static void main(String[] args) {
    5.         //Jump j=new Jump();//接口是对行为的抽象，所以和抽象类一样不能实例化
    6.         Jump j=new Cat();//用实现类对象进行实例化
    7.         j.Jumpping();
    8.     }
    9. }

    1.3接口的成员特点

    成员变量
            只能是常量
            默认修饰符:public static final

    构造方法
            接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在
            一个类如果没有父类，默认继承自Object类

    成员方法
            只能是抽象方法
            默认修饰符:public abstract

    案例:猫和狗

    需求:对猫和狗进行训练，他们就可以跳高了，这里加入了跳高功能。请采用抽象类和接口来实现猫狗案例，       并在测试类中进行测试

    思路:
    定义接口(Jumpping)
            成员方法:跳高();

    定义抽象动物类(Animal)
            成员变量:姓名，年龄:

            构造方法:无参，带参:

            成员方法:aet/set方法，

            吃饭{}

    定义具体猫类(Cat)，继承动物类，实现跳高接口
            构造方法:无参，带参;

            成员方法:重写吃饭（）{..}，重写跳高方法（）{...}

    定义狗类(Dog)，继承动物类，实现跳高接口
            构造方法:无参，带参;

            成员方法:重写吃饭(){….}，重写跳高方法(){...)

    定义测试类(AnimalDemo)，写代码测试5

     接口：

    1. package zyy03;
    2. /*定义了一个接口*/
    3. public interface Jump {
    4.      void Jumpping();
    5. }

    抽象动物类：

    1. package zyy03;
    2.  
    3. public abstract class Animal {
    4.     private String name;
    5.     private int age;
    6.  
    7.     public Animal() {
    8.     }
    9.     public Animal(String name, int age) {
    10.         this.name = name;
    11.         this.age = age;
    12.     }
    13.  
    14.     public String getName() {
    15.         return name;
    16.     }
    17.  
    18.     public void setName(String name) {
    19.         this.name = name;
    20.     }
    21.  
    22.     public int getAge() {
    23.         return age;
    24.     }
    25.  
    26.     public void setAge(int age) {
    27.         this.age = age;
    28.     }
    29.     public abstract void eat();
    30.  
    31. }

    猫类：

    1. package zyy03;
    2.  
    3. public class Cat extends Animal implements Jump{
    4.     @Override
    5.     public void eat() {
    6.         System.out.println("猫吃鱼");
    7.     }
    8.     @Override
    9.     public void Jumpping() {
    10.         System.out.println("猫可以跳高");
    11.     }
    12.  
    13.     public Cat() {
    14.     }
    15.     public Cat(String name, int age) {
    16.         super(name, age);
    17.     }
    18. }

    狗类：

    1. package zyy03;
    2.  
    3. public class Dog extends Animal implements Jump{
    4.     @Override
    5.     public void eat() {
    6.         System.out.println("狗吃骨头");
    7.     }
    8.  
    9.     @Override
    10.     public void Jumpping() {
    11.         System.out.println("狗可以跳高");
    12.     }
    13.  
    14.     public Dog() {
    15.     }
    16.  
    17.     public Dog(String name, int age) {
    18.         super(name, age);
    19.     }
    20. }

    测试类：

    1. package zyy03;
    2.  
    3. public class Demo {
    4.     public static void main(String[] args) {
    5.         //Jump j=new Jump();//接口是对行为的抽象，所以和抽象类一样不能实例化
    6.         Jump j=new Cat();//用实现类对象进行实例化
    7.         j.Jumpping();
    8.         Animal a=new Cat();
    9.         a.setName("zyy");
    10.         a.setAge(14);
    11.         System.out.println(a.getName()+","+a.getAge());
    12.         a.eat();
    13.         //a.Jumpping;
    14.         System.out.println("************");
    15.         Jump j1=new Dog();//用实现类对象进行实例化
    16.         j.Jumpping();
    17.         Animal b=new Dog();
    18.         b.setName("jw");
    19.         b.setAge(18);
    20.         System.out.println(b.getName()+","+b.getAge());
    21.         b.eat();
    22.         //b.Jumpping;
    23.     }
    24. }

    1.4类和接口的关系

    类和类的关系
            继承关系，只能单继承，但是可以多层继承

    类和接口的关系
            实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

    接口和接口的关系
            继承关系，可以单继承，也可以多继承

    1.5抽象类和接口的区别

    成员区别
            抽象类：         变量，常量；有构造方法;有抽象方法，也有非抽象方法 
            接口：             常量;抽象方法 

    关系区别
            类与类 ：            继承，单继承 
            类与接口：         实现，可以单实现，也可以多实现 
            接口与接口：     继承，单继承，多继承 

    设计理念区别
            抽象类 ：        对类抽象，包括属性、行为 
            接口  ：          对行为抽象，主要是行为

    🔺抽象类是对事物的抽象，而接口是对行为的抽象

    案例:运动员和教练

    需求:我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。为了出国交流，跟乒乓球相关的人员都需要学习英语，请用所学知识分析，这个室例中有哪些具体类，哪些抽象类，哪些接口，并用代码实现

    分析:从具体到抽象
    乒乓球运动员

    篮球运动员

    乒乓球教练

    篮球教练

    实现:从抽象到具体

    使用:使用的是具体的类的对象

    思路:

    ①定义说英语接口         成员方法:说英语; 
    ②定义抽象人类      成员变量:姓名，年龄:构造方法:无参，带参:成员方法:get/set方法，吃饭; 
    ③定义抽象教练类，继承人类         构造方法:无参，带参;成员方法:教0; 
    ④定义抽象运动员类，继承人类         构造方法:无参，带参;成员方法:学习0; 
    ⑤ 定义具体篮球教练类，继承教练类         构造方法:无参，带参:成员方法:重写吃饭，重写教
    ⑥定义具体乒乓球教练类，继承教练类，实现说英语接口
            构造方法:无参，带参;        成员方法:重写吃饭，重写教，重写说英语
    ⑦定义具体篮球运动员类，继承运动员类        

            构造方法:无参，带参;

            成员方法:重写吃饭，重写学习

    ⑧定义具体乒乓球运动员类，继承运动员类，实现说英语接口
            构造方法:无参，带参

            成员方法:重写吃饭，重写学习，重写说英语
    ⑨ 定义测试类，写代码测试

      接口：

    1. package zyy05;
    2.  
    3. public interface Inter {
    4.     void English();
    5. }

    抽象运动员：

    1. package zyy05;
    2.  
    3. public abstract class Athlete extends Person{
    4.     public Athlete() {
    5.     }
    6.  
    7.     public Athlete(String name, int age) {
    8.         super(name, age);
    9.     }
    10.     public abstract void study();
    11. }

    抽象类教练：

    1. package zyy05;
    2.  
    3. public abstract class Coach extends Person {
    4.     public Coach() {
    5.     }
    6.  
    7.     public Coach(String name, int age) {
    8.         super(name, age);
    9.     }
    10.     public abstract void teach();
    11. }

    抽象类人：

    1. package zyy05;
    2.  
    3. public abstract class Person {
    4.     private String name;
    5.     private int age;
    6.     public abstract void eat();
    7.  
    8.     public Person() {
    9.     }
    10.  
    11.     public Person(String name, int age) {
    12.         this.name = name;
    13.         this.age = age;
    14.     }
    15.  
    16.     public String getName() {
    17.         return name;
    18.     }
    19.  
    20.     public void setName(String name) {
    21.         this.name = name;
    22.     }
    23.  
    24.     public int getAge() {
    25.         return age;
    26.     }
    27.  
    28.     public void setAge(int age) {
    29.         this.age = age;
    30.     }
    31. }

    具体乒乓球运动员：

    1. package zyy05;
    2.  
    3. public class TennisAthlete extends Athlete implements Inter{
    4.     @Override
    5.     public void eat() {
    6.         System.out.println("乒乓球餐");
    7.     }
    8.  
    9.     @Override
    10.     public void study() {
    11.         System.out.println("学习打乒乓球");
    12.     }
    13.  
    14.     @Override
    15.     public void English() {
    16.         System.out.println("乒乓球员学习英语");
    17.     }
    18. }

    具体篮球运动员：

    1. package zyy05;
    2.  
    3. public class BasketballAthlete extends Athlete{
    4.     @Override
    5.     public void eat() {
    6.         System.out.println("篮球餐");
    7.     }
    8.  
    9.     @Override
    10.     public void study() {
    11.         System.out.println("学习打篮球");
    12.     }
    13.  
    14.     public BasketballAthlete() {
    15.     }
    16.  
    17.     public BasketballAthlete(String name, int age) {
    18.         super(name, age);
    19.     }
    20. }

    具体乒乓球教练：

    1. package zyy05;
    2.  
    3. public class TennisCoach extends Coach implements Inter{
    4.     @Override
    5.     public void eat() {
    6.         System.out.println("乒乓球餐");
    7.     }
    8.  
    9.     @Override
    10.     public void teach() {
    11.         System.out.println("教乒乓球");
    12.     }
    13.  
    14.     @Override
    15.     public void English() {
    16.         System.out.println("乒乓球教练学习英语");
    17.     }
    18.  
    19.     public TennisCoach() {
    20.     }
    21.  
    22.     public TennisCoach(String name, int age) {
    23.         super(name, age);
    24.     }
    25. }

    具体篮球教练：

    1. package zyy05;
    2.  
    3. public class BasketballCoach extends Coach{
    4.     @Override
    5.     public void teach() {
    6.         System.out.println("教篮球");
    7.     }
    8.  
    9.     @Override
    10.     public void eat() {
    11.         System.out.println("篮球餐");
    12.     }
    13.  
    14.     public BasketballCoach() {
    15.     }
    16.  
    17.     public BasketballCoach(String name, int age) {
    18.         super(name, age);
    19.     }
    20. }

    测试类：

    1. package zyy05;
    2.  
    3. public class Demo {
    4.     public static void main(String[] args) {
    5.         //创建对象
    6.         TennisAthlete p=new TennisAthlete();
    7.         p.setName("jw");
    8.         p.setAge(18);
    9.         System.out.println(p.getName()+","+p.getAge());
    10.         p.eat();
    11.         p.study();
    12.         p.English();
    13.         System.out.println("************");
    14.         BasketballAthlete b=new BasketballAthlete();
    15.         b.setName("zyy");
    16.         b.setAge(14);
    17.         System.out.println(b.getName()+","+b.getAge());
    18.         b.eat();
    19.         b.study();
    20.         System.out.println("*************");
    21.         TennisCoach t=new TennisCoach();
    22.         t.setName("jw");
    23.         t.setAge(18);
    24.         System.out.println(t.getName()+","+t.getAge());
    25.         t.eat();
    26.         t.teach();
    27.         t.English();
    28.         System.out.println("************");
    29.         BasketballCoach b1=new BasketballCoach();
    30.         b1.setName("zyy");
    31.         b1.setAge(14);
    32.         System.out.println(b1.getName()+","+b1.getAge());
    33.         b1.eat();
    34.         b1.teach();
    35.         System.out.println("*************");
    36.     }
    37. }

  • 相关阅读:
    关于我的博客~ （2022.8.25 -＞ 在csdn三岁啦）
    LeetCode530. Minimum Absolute Difference in BST
    python库-dotenv包 | .env配置文件
    DSPE-PEG-FSHB，FSHB-PEG-DSPE，磷脂-聚乙二醇-卵泡刺激素多肽FSHB
    Linux之Redis 缓存雪崩，击穿，穿透
    sysbench--实践--07--mysql全面压测
    【数据结构】笔试面试中常用的数据结构操作
    MySQL驱动扯后腿？Spring Boot用虚拟线程可能比用物理线程还差
    11.22二叉树相关OJ
    Flink之Window窗口机制
  • 原文地址：https://blog.csdn.net/qq_62799214/article/details/126082719