• 抽象类和接口

    1.抽象类

    1.1抽象类的概述（理解）

    当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！

    在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！

    1.2抽象类的特点（记忆）

    • 抽象类和抽象方法必须使用 abstract 关键字修饰

      1. //抽象类的定义
      2. public abstract class 类名 {}
      3.  
      4. //抽象方法的定义
      5. public abstract void eat();

    • 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

    • 抽象类不能实例化

      抽象类如何实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态

    • 抽象类的子类

      要么重写抽象类中的所有抽象方法

      要么是抽象类

    1.3抽象类的成员特点（记忆）

    • 成员的特点

      • 成员变量

        • 既可以是变量

        • 也可以是常量

      • 构造方法

        • 空参构造

        • 有参构造

      • 成员方法

        • 抽象方法

        • 普通方法

    抽象类的成员特点

    成员变量

    • 可以是变量也可以是常量

    构造方法

    有构造方法，但是不能实例化

    那么，构造方法的作用是什么呢?用于子类访问父类数据的初始化成员方法

    成员方法

    • 可以有抽象方法:限定子类必须完成某些动作

    • 也可以有非抽象方法:提高代码复用性（由继承来实现）

    • 代码演示

      1. package com.object_03;
      2. //抽象类
      3. public abstract class Animal1 {
      4.     private int age = 20;
      5.     private final String city = "北京";
      6.  
      7.     public Animal1() {}
      8.  
      9.     public  Animal1(int age) {
      10.         this.age = age;
      11.     }
      12.  
      13.  
      14.     public void show() {
      15.         age = 40;
      16.         System.out.println(age);
      17.         System.out.println(city);
      18.     }
      19.  
      20.     //抽象方法
      21.     public abstract void eat();
      22. }
      23.  
      24. package com.object_03;
      25.  
      26. public class Cat1 extends Animal1{
      27.     @Override
      28.     public void eat() {
      29.         System.out.println("猫咪吃鱼");
      30.     }
      31. }
      32.  
      33.  
      34. package com.object_03;
      35. //抽象类
      36. public abstract class Animal1 {
      37.     private int age = 20;
      38.     private final String city = "北京";
      39.  
      40.     public Animal1() {}
      41.  
      42.     public  Animal1(int age) {
      43.         this.age = age;
      44.     }
      45.  
      46.  
      47.     public void show() {
      48.         age = 40;
      49.         System.out.println(age);
      50.         System.out.println(city);
      51.     }
      52.  
      53.     //抽象方法
      54.     public abstract void eat();
      55. }
      56.

    1.4抽象类的案例（应用）

    • 案例需求

      请采用抽象类的思想实现猫和狗的案例，并在测试类中进行测试

    • 思路:
      1.定义动物类(Animal)
      成员变量:姓名，年龄构造方法:无参，带参
      成员方法: get/set方法，吃饭;

           2.定义猫类(Cat)，继承动物类
    构造方法:无参，带参成员

           方法:重写吃饭(){.….}

           3.定义狗类(Dog)，继承动物类
            构造方法:无参，带参

            成员方法:重写吃饭({.….}
            4.定义测试类(AnimalDemo)，写代码测试

    • 代码实现

      1. package com.object_03;
      2. //抽象类的案例
      3. public abstract class Animal2 {
      4.     private String name;
      5.     private int age;
      6.  
      7.     public Animal2() {
      8.     }
      9.  
      10.     public Animal2(String name, int age) {
      11.         this.name = name;
      12.         this.age = age;
      13.     }
      14.  
      15.     public String getName() {
      16.         return name;
      17.     }
      18.  
      19.     public void setName(String name) {
      20.         this.name = name;
      21.     }
      22.  
      23.     public int getAge() {
      24.         return age;
      25.     }
      26.  
      27.     public void setAge(int age) {
      28.         this.age = age;
      29.     }
      30.  
      31.     public abstract void eat();
      32. }
      33.  
      34. package com.object_03;
      35.  
      36. public class Dog2 extends Animal2 {
      37.     public Dog2() {
      38.     }
      39.  
      40.     public Dog2(String name, int age) {
      41.         super(name, age);
      42.     }
      43.  
      44.     @Override
      45.     public void eat() {
      46.         System.out.println("狗吃骨头");
      47.     }
      48. }
      49.  
      50.  
      51.  
      52. package com.object_03;
      53.  
      54. public class Cat2 extends Animal2 {
      55.     public Cat2() {
      56.     }
      57.  
      58.     public Cat2(String name, int age) {
      59.         super(name, age);
      60.     }
      61.  
      62.     @Override
      63.     public void eat() {
      64.         System.out.println("猫吃鱼");
      65.     }
      66. }
      67.  
      68.  
      69.  
      70. package com.object_03;
      71.  
      72. public class AnimalDemo2 {
      73.     public static void main(String[] args) {
      74.         //创建对象，按照多态的方式
      75.         Animal2 a = new Cat2();
      76.         a.setName("暹罗");
      77.         a.setAge(6);
      78.         System.out.println(a.getName()+","+a.getAge());
      79.         a.eat();
      80.         System.out.println("*****************");
      81.  
      82.         a =new Cat2("中华田园猫",5);
      83.         System.out.println(a.getName()+","+a.getAge());
      84.         a.eat();
      85.     }
      86. }
      87.  
      88.

    • 1.5抽象类和接口的区别
      门和警报的例子
      门:都有open)和close()两个动作，这个时候，我们可以分别使用抽象类和接口来定义这个抽象概念

    抽象类

    1. //抽象类
    2. public abstract class Door {
    3. public abstract void open ( ) ;
    4.  
    5. public abstract void close ( ) ;
    6. public abstract void alarm ( ) ;  //但是有的门没有报警功能
    7. }

    接口

    1. //接口
    2. public interface Door {
    3. void open ( ) ;
    4. void close () ;
    5. void alarm();   //但是接入接口还会实现open和close
    6. }

    进行改进:

    1. public interface Alram {void alarm () ;
    2. }
    3. public abstract class Door {
    4. public abstract void open ( ) ;public abstract void close ( );}
    5. public class AlarmDoor extends Door implements Alarm {
    6. public void oepn () {
    7. // ....
    8. }
    9. public void close (o) {l l ....
    10. }
    11. public void alarm () {
    12. // ....
    13. }
    14. }

    这里我们将alarm单独作为接口来实现，需要的时候写入，各自独立开来就好

    在这里，我们再次强调抽象类是对事物的抽象，而接口是对行为的抽象

    2.接口

    2.1接口的概述（理解）

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

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

    2.2接口的特点（记忆）

    • 接口用关键字interface修饰

      public interface 接口名 {}

    • 类实现接口用implements表示（类和接口之间不能用继承，需要implements（实现）来连接）

      public class 类名 implements 接口名 {}

    • 接口不能实例化

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

      1. package com.itheima_o1;
      2. /*测试类*/
      3. public class JumppingDemo i
      4. public static void main( String[] args) {
      5. //Jumpping j = new Jumpping();  //失败了，接口不能实例化
      6.  
      7. //接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态
      8. Jumpping j = new Cat();
      9. j.jump();
      10. }
      11. }

      多态的形式：具体类多态，抽象类多态，接口多态。

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

    • 接口的实现类

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

      要么子类也是抽象类

    2.3接口的成员特点（记忆）

    • 成员特点

      • 成员变量

        只能是常量 ​ 默认修饰符：public static final

      • 构造方法

        接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在

                   一个类如果没有父类，默认继承自Object类

    • 成员方法

      只能是抽象方法

      默认修饰符：public abstract

      关于接口中的方法，JDK8和JDK9中有一些新特性，后面再讲解

    • 代码演示

      1. public interface Inter {
      2.     public int num = 10;  //有成员变量
      3.     public final int num2 = 20;   //可以是个常量
      4. //    public static final int num3 = 30;
      5.     int num3 = 30;
      6. ​
      7. //    public Inter() {}
      8. ​
      9. //    public void show() {}  //接口为抽象方法，不能有方法体{}
      10. ​
      11.     public abstract void method();
      12.     void show();
      13. }
      14. public class InterImpl extends Object implements Inter {  //接口实现类命名，类名+Impl
      15.     public InterImpl() {
      16.         super();
      17.     }
      18. ​
      19.     @Override
      20.     public void method() {
      21.         System.out.println("method");
      22.     }
      23. ​
      24.     @Override
      25.     public void show() {
      26.         System.out.println("show");
      27.     }
      28. }
      29. public class InterfaceDemo {
      30.     public static void main(String[] args) {
      31.         Inter i = new InterImpl();    //通过创建对象
      32. //        i.num = 20;
      33.         System.out.println(i.num);
      34. //        i.num2 = 40;
      35.         System.out.println(i.num2);
      36.         System.out.println(Inter.num);
      37.     }
      38. }

      • 接口

      • 实现类

      • 测试类

    2.4接口的案例（应用）

    • 案例需求

      对猫和狗进行训练，他们就可以跳高了，这里加入跳高功能。

      请采用抽象类和接口来实现猫狗案例，并在测试类中进行测试。

    • 代码实现

      • 动物类

        1. package com.object_04.interface_01;
        2.  
        3. public abstract class Animal {
        4.     private String name;
        5.     private int age;
        6.  
        7.     public Animal() {
        8.     }
        9.  
        10.     public Animal(String name, int age) {
        11.         this.name = name;
        12.         this.age = age;
        13.     }
        14.  
        15.     public String getName() {
        16.         return name;
        17.     }
        18.  
        19.     public void setName(String name) {
        20.         this.name = name;
        21.     }
        22.  
        23.     public int getAge() {
        24.         return age;
        25.     }
        26.  
        27. //    public void setAge(int age) {
        28. //        this.age = age;
        29. //    }
        30.  
        31. //    public abstract void eat();
        32.  
        33.  
        34.     public void setAge(int age) {
        35.         this.age = age;
        36.     }
        37.  
        38.  
        39.     public abstract void eat();
        40. }
        41.  
        42.

      • 跳高接口

      1. package com.object_04.interface_01;
      2. //跳高接口
      3. public interface Jumpping {
      4.     public abstract void jump();
      5. }

      • 猫类

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

      • 测试类

        1. package com.object_04.interface_01;
        2.  
        3. public class AnimalDemo {
        4.  public static void main(String[] args) {
        5.   //创建对象，调用方法
        6.   Jumpping j = new Cat();
        7.   j.jump();
        8.   System.out.println("--------");
        9.  
        10.   Animal a = new Cat();
        11.   a.setName("加菲");
        12.   a.setAge(5);
        13.   System.out.println(a.getName()+","+a.getAge());
        14.   a.eat();
        15. //        a.jump();
        16.  
        17.   a = new Cat("加菲",5);
        18.   System.out.println(a.getName()+","+a.getAge());
        19.   a.eat();
        20.   System.out.println("--------");
        21.  
        22.   Cat c = new Cat();
        23.   c.setName("加菲");
        24.   c.setAge(5);
        25.   System.out.println(c.getName()+","+c.getAge());
        26.   c.eat();
        27.   c.jump();
        28.  }
        29. }
        30. package com.object_04.interface_01;
        31.

        结果：

        1. 猫可以跳高了
        2. --------
        3. 加菲,5
        4. 猫吃鱼
        5. 加菲,5
        6. 猫吃鱼
        7. --------
        8. 加菲,5
        9. 猫吃鱼
        10. 猫可以跳高了

    2.5类和接口的关系（记忆）

    • 类与类的关系

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

    • 类与接口的关系

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

    • 接口与接口的关系

      继承关系，可以单继承，也可以多继承

    2.6抽象类和接口的区别（记忆）

    • 成员区别

      • 抽象类

        变量,常量；有构造方法；有抽象方法,也有非抽象方法

      • 接口

        常量；抽象方法

    • 关系区别

      • 类与类

        继承，单继承

      • 类与接口

        实现，可以单实现，也可以多实现

      • 接口与接口

        继承，单继承，多继承

    • 设计理念区别

      • 抽象类

        对类抽象，包括属性、行为

      • 接口

        对行为抽象，主要是行为

    3.综合案例

    3.1案例需求（理解）

    我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。

    为了出国交流，跟乒乓球相关的人员都需要学习英语。

    请用所学知识分析，这个案例中有哪些具体类，哪些抽象类，哪些接口，并用代码实现。

    3.2代码实现（应用）

    • 抽象人类

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

    • 抽象运动员类

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

    • 抽象教练类

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

    • 学英语接口

    1. public interface SpeakEnglish {
    2.     public abstract void speak();
    3. }

    • 蓝球教练

    1. public class BasketballCoach extends Coach {
    2.     public BasketballCoach() {
    3.     }
    4. ​
    5.     public BasketballCoach(String name, int age) {
    6.         super(name, age);
    7.     }
    8. ​
    9.     @Override
    10.     public void teach() {
    11.         System.out.println("篮球教练教如何运球和投篮");
    12.     }
    13. ​
    14.     @Override
    15.     public void eat() {
    16.         System.out.println("篮球教练吃羊肉，喝羊奶");
    17.     }
    18. }

    • 乒乓球教练

    1. public class PingPangCoach extends Coach implements SpeakEnglish {
    2. ​
    3.     public PingPangCoach() {
    4.     }
    5. ​
    6.     public PingPangCoach(String name, int age) {
    7.         super(name, age);
    8.     }
    9. ​
    10.     @Override
    11.     public void teach() {
    12.         System.out.println("乒乓球教练教如何发球和接球");
    13.     }
    14. ​
    15.     @Override
    16.     public void eat() {
    17.         System.out.println("乒乓球教练吃小白菜，喝大米粥");
    18.     }
    19. ​
    20.     @Override
    21.     public void speak() {
    22.         System.out.println("乒乓球教练说英语");
    23.     }
    24. }

    • 乒乓球运动员

    1. public class PingPangPlayer extends Player implements SpeakEnglish {
    2. ​
    3.     public PingPangPlayer() {
    4.     }
    5. ​
    6.     public PingPangPlayer(String name, int age) {
    7.         super(name, age);
    8.     }
    9. ​
    10.     @Override
    11.     public void study() {
    12.         System.out.println("乒乓球运动员学习如何发球和接球");
    13.     }
    14. ​
    15.     @Override
    16.     public void eat() {
    17.         System.out.println("乒乓球运动员吃大白菜，喝小米粥");
    18.     }
    19. ​
    20.     @Override
    21.     public void speak() {
    22.         System.out.println("乒乓球运动员说英语");
    23.     }
    24. }

    • 篮球运动员

    1. public class BasketballPlayer extends Player {
    2. ​
    3.     public BasketballPlayer() {
    4.     }
    5. ​
    6.     public BasketballPlayer(String name, int age) {
    7.         super(name, age);
    8.     }
    9. ​
    10.     @Override
    11.     public void study() {
    12.         System.out.println("篮球运动员学习如何运球和投篮");
    13.     }
    14. ​
    15.     @Override
    16.     public void eat() {
    17.         System.out.println("篮球运动员吃牛肉，喝牛奶");
    18.     }
    19. }

    4. 参数传递

    4.1 类名作为形参和返回值（应用）

    • 1、类名作为方法的形参

      方法的形参是类名，其实需要的是该类的对象

      实际传递的是该对象的【地址值】

    • 2、类名作为方法的返回值

      方法的返回值是类名，其实返回的是该类的对象

      实际传递的，也是该对象的【地址值】

    • 示例代码：

      1. class Cat {
      2.     public void eat() {
      3.         System.out.println("猫吃鱼");
      4.     }
      5. }
      6. class CatOperator {
      7.     public void useCat(Cat c) { //Cat c = new Cat();
      8.         c.eat();
      9.     }
      10.     public Cat getCat() {
      11.         Cat c = new Cat();
      12.         return c;
      13.     }
      14. }
      15. public class CatDemo {
      16.     public static void main(String[] args) {
      17.         //创建操作类对象，并调用方法
      18.         CatOperator co = new CatOperator();
      19.         Cat c = new Cat();
      20.         co.useCat(c);
      21. ​
      22.         Cat c2 = co.getCat(); //new Cat()
      23.         c2.eat();
      24.     }
      25. }

    4.2 抽象类作为形参和返回值（理解）

    • 抽象类作为形参和返回值

      • 方法的形参是抽象类名，其实需要的是该抽象类的子类对象

      • 方法的返回值是抽象类名，其实返回的是该抽象类的子类对象

    • 示例代码：

      1. abstract class Animal {
      2.     public abstract void eat();
      3. }
      4. class Cat extends Animal {
      5.     @Override
      6.     public void eat() {
      7.         System.out.println("猫吃鱼");
      8.     }
      9. }
      10. class AnimalOperator {
      11.     public void useAnimal(Animal a) { //Animal a = new Cat();
      12.         a.eat();
      13.     }
      14.     public Animal getAnimal() {
      15.         Animal a = new Cat();
      16.         return a;
      17.     }
      18. }
      19. public class AnimalDemo {
      20.     public static void main(String[] args) {
      21.         //创建操作类对象，并调用方法
      22.         AnimalOperator ao = new AnimalOperator();
      23.         Animal a = new Cat();
      24.         ao.useAnimal(a);
      25. ​
      26.         Animal a2 = ao.getAnimal(); //new Cat()
      27.         a2.eat();
      28.     }
      29. }

    4.3 接口名作为形参和返回值（理解）

    • 接口作为形参和返回值

      • 方法的形参是接口名，其实需要的是该接口的实现类对象

      • 方法的返回值是接口名，其实返回的是该接口的实现类对象

    • 示例代码：

      1. interface Jumpping {
      2.     void jump();
      3. }
      4. class JumppingOperator {
      5.     public void useJumpping(Jumpping j) { //Jumpping j = new Cat();
      6.         j.jump();
      7.     }
      8.     public Jumpping getJumpping() {
      9.         Jumpping j = new Cat();
      10.         return j;
      11.     }
      12. }
      13. class Cat implements Jumpping {
      14.     @Override
      15.     public void jump() {
      16.         System.out.println("猫可以跳高了");
      17.     }
      18. }
      19. public class JumppingDemo {
      20.     public static void main(String[] args) {
      21.         //创建操作类对象，并调用方法
      22.         JumppingOperator jo = new JumppingOperator();
      23.         Jumpping j = new Cat();
      24.         jo.useJumpping(j);
      25. ​
      26.         Jumpping j2 = jo.getJumpping(); //new Cat()
      27.         j2.jump();
      28.     }
      29. }
      30. ​

  • 相关阅读:
    家庭的破碎与人性的考验
    【华为机试真题 Python实现】喊 7 的次数重排
    小白系统初始化配置资源失败怎么办
    GPU如何成为AI的加速器
    【示波器专题】示波器触发电路原理
    二维矩阵子集的最大值
    python使用字典暴力解析wifi密码
    Linux下gcc编译器和gdb调试
    Linux文件与文件系统的压缩
    SpringCloud-06-Config
  • 原文地址：https://blog.csdn.net/clover_oreo/article/details/125478526