Java面向对象篇:封装、继承、多态(三)

简介: Java面向对象篇:封装、继承、多态

10.5 多态的案例


案例需求

  • 请采用多态的思想实现猫和狗的案例,并在测试类中进行测试

代码实现

  • 动物类


public class Animal {
    private String name;
    private int age;
    public Animal() {
    }
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void eat() {
        System.out.println("动物吃东西");
    }
}


猫类


public class Cat extends Animal {
    public Cat() {
    }
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}


狗类

public class Dog extends Animal {
    public Dog() {
    }
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}


测试类

public class AnimalDemo {
    public static void main(String[] args) {
        //创建猫类对象进行测试
        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();
        a = new Cat("加菲", 5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();
    }
}


11. 抽象类


11.1 抽象类的概述

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

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


11.2 抽象类的特点


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


//抽象类的定义
public abstract class 类名 {}
//抽象方法的定义
public abstract void eat();



  • 抽象类中不一定有抽象方法,有抽象方法的类一定是抽象类
  • 抽象类不能实例化
    抽象类如何实例化呢?参照多态的方式,通过子类对象实例化,这叫抽象类多态
  • 抽象类的子类
    要么重写抽象类中的所有抽象方法
    要么是抽象类


11.3 抽象类的成员特点


  • 成员的特点
  • 成员变量
  • 既可以是变量
  • 也可以是常量
  • 构造方法
  • 空参构造
  • 有参构造
  • 成员方法
  • 抽象方法
  • 普通方法
  • 代码演示
  • 动物类
public abstract class Animal {
      private int age = 20;
      private final String city = "北京";
      public Animal() {}
      public Animal(int age) {
          this.age = age;
      }
      public void show() {
          age = 40;
          System.out.println(age);
          //        city = "上海";
          System.out.println(city);
      }
      public abstract void eat();
  }


猫类

  public class Cat extends Animal {
      @Override
      public void eat() {
          System.out.println("猫吃鱼");
      }
  }


测试类


  public class AnimalDemo {
      public static void main(String[] args) {
          Animal a = new Cat();
          a.eat();
          a.show();
      }
  }


11.4 抽象类的案例

  • 案例需求
    请采用抽象类的思想实现猫和狗的案例,并在测试类中进行测试
  • 代码实现
  • 动物类



  public abstract class Animal {
      private String name;
      private int age;
      public Animal() {
      }
      public Animal(String name, int age) {
          this.name = name;
          this.age = age;
      }
      public String getName() {
          return name;
      }
      public void setName(String name) {
          this.name = name;
      }
      public int getAge() {
          return age;
      }
      public void setAge(int age) {
          this.age = age;
      }
      public abstract void eat();
  }



猫类


  public class Cat extends Animal {
      public Cat() {
      }
      public Cat(String name, int age) {
          super(name, age);
      }
      @Override
      public void eat() {
          System.out.println("猫吃鱼");
      }
  }

狗类

  public class Dog extends Animal {
      public Dog() {
      }
      public Dog(String name, int age) {
          super(name, age);
      }
      @Override
      public void eat() {
          System.out.println("狗吃骨头");
      }
  }


测试类

  public class AnimalDemo {
      public static void main(String[] args) {
          //创建对象,按照多态的方式
          Animal a = new Cat();
          a.setName("加菲");
          a.setAge(5);
          System.out.println(a.getName()+","+a.getAge());
          a.eat();
          System.out.println("--------");
          a = new Cat("加菲",5);
          System.out.println(a.getName()+","+a.getAge());
          a.eat();
      }
  }


12. 接口


12.1 接口的概述


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

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


12.2 接口的特点


接口用关键字interface修饰


public interface 接口名 {} 

类实现接口用implements表示



public class 类名 implements 接口名 {}


  • 接口不能实例化
    接口如何实例化呢?参照多态的方式,通过实现类对象实例化,这叫接口多态。
    多态的形式:具体类多态,抽象类多态,接口多态。
  • 接口的子类
    要么重写接口中的所有抽象方法
    要么子类也是抽象类


12.3 接口的成员特点


成员特点


成员变量


只能是常量

默认修饰符:public static final


构造方法


没有,因为接口主要是扩展功能的,而没有具体存在


成员方法


只能是抽象方法


默认修饰符:public abstract


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


代码演示


接口



  public interface Inter {
      public int num = 10;
      public final int num2 = 20;
  //    public static final int num3 = 30;
      int num3 = 30;
  //    public Inter() {}
  //    public void show() {}
      public abstract void method();
      void show();
  }


实现类


  public class InterImpl extends Object implements Inter {
      public InterImpl() {
          super();
      }
      @Override
      public void method() {
          System.out.println("method");
      }
      @Override
      public void show() {
          System.out.println("show");
      }
  }


测试类


  public class InterfaceDemo {
      public static void main(String[] args) {
          Inter i = new InterImpl();
  //        i.num = 20;
          System.out.println(i.num);
  //        i.num2 = 40;
          System.out.println(i.num2);
          System.out.println(Inter.num);
      }
  }


12.4 接口的案例


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


  public abstract class Animal {
      private String name;
      private int age;
      public Animal() {
      }
      public Animal(String name, int age) {
          this.name = name;
          this.age = age;
      }
      public String getName() {
          return name;
      }
      public void setName(String name) {
          this.name = name;
      }
      public int getAge() {
          return age;
      }
      public void setAge(int age) {
          this.age = age;
      }
      public abstract void eat();
  }


跳高接口


  public interface Jumpping {
      public abstract void jump();
  }


猫类


  public class Cat extends Animal implements Jumpping {
      public Cat() {
      }
      public Cat(String name, int age) {
          super(name, age);
      }
      @Override
      public void eat() {
          System.out.println("猫吃鱼");
      }
      @Override
      public void jump() {
          System.out.println("猫可以跳高了");
      }
  }


测试类


  public class AnimalDemo {
      public static void main(String[] args) {
          //创建对象,调用方法
          Jumpping j = new Cat();
          j.jump();
          System.out.println("--------");
          Animal a = new Cat();
          a.setName("加菲");
          a.setAge(5);
          System.out.println(a.getName()+","+a.getAge());
          a.eat();
  //        a.jump();
          a = new Cat("加菲",5);
          System.out.println(a.getName()+","+a.getAge());
          a.eat();
          System.out.println("--------");
          Cat c = new Cat();
          c.setName("加菲");
          c.setAge(5);
          System.out.println(c.getName()+","+c.getAge());
          c.eat();
          c.jump();
      }
  }


12.5 类和接口的关系


  • 类与类的关系
    继承关系,只能单继承,但是可以多层继承
  • 类与接口的关系
    实现关系,可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口
  • 接口与接口的关系
    继承关系,可以单继承,也可以多继承


12.6 抽象类和接口的区别


成员区别


抽象类


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


接口


常量;抽象方法


关系区别


类与类


继承,单继承


类与接口


实现,可以单实现,也可以多实现


接口与接口


继承,单继承,多继承


设计理念区别


抽象类


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


接口

对行为抽象,主要是行为



13. 综合案例


13.1 案例需求


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

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

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


48.png


13.2 代码实现


  • 抽象人类
public abstract class Person {
    private String name;
    private int age;
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public abstract void eat();
}

抽象运动员类


public abstract class Player extends Person {
    public Player() {
    }
    public Player(String name, int age) {
        super(name, age);
    }
    public abstract void study();
}

抽象教练类


public abstract class Coach extends Person {
    public Coach() {
    }
    public Coach(String name, int age) {
        super(name, age);
    }
    public abstract void teach();
}

学英语接口


public interface SpeakEnglish {
    public abstract void speak();
}


蓝球教练


public class BasketballCoach extends Coach {
    public BasketballCoach() {
    }
    public BasketballCoach(String name, int age) {
        super(name, age);
    }
    @Override
    public void teach() {
        System.out.println("篮球教练教如何运球和投篮");
    }
    @Override
    public void eat() {
        System.out.println("篮球教练吃羊肉,喝羊奶");
    }
}


乒乓球教练


public class PingPangCoach extends Coach implements SpeakEnglish {
    public PingPangCoach() {
    }
    public PingPangCoach(String name, int age) {
        super(name, age);
    }
    @Override
    public void teach() {
        System.out.println("乒乓球教练教如何发球和接球");
    }
    @Override
    public void eat() {
        System.out.println("乒乓球教练吃小白菜,喝大米粥");
    }
    @Override
    public void speak() {
        System.out.println("乒乓球教练说英语");
    }
}

乒乓球运动员


public class PingPangPlayer extends Player implements SpeakEnglish {
    public PingPangPlayer() {
    }
    public PingPangPlayer(String name, int age) {
        super(name, age);
    }
    @Override
    public void study() {
        System.out.println("乒乓球运动员学习如何发球和接球");
    }
    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃大白菜,喝小米粥");
    }
    @Override
    public void speak() {
        System.out.println("乒乓球运动员说英语");
    }
}


篮球运动员

public class BasketballPlayer extends Player {
    public BasketballPlayer() {
    }
    public BasketballPlayer(String name, int age) {
        super(name, age);
    }
    @Override
    public void study() {
        System.out.println("篮球运动员学习如何运球和投篮");
    }
    @Override
    public void eat() {
        System.out.println("篮球运动员吃牛肉,喝牛奶");
    }
}
目录
打赏
0
0
0
0
12
分享
相关文章
【JAVA】封装多线程原理
Java 中的多线程封装旨在简化使用、提高安全性和增强可维护性。通过抽象和隐藏底层细节,提供简洁接口。常见封装方式包括基于 Runnable 和 Callable 接口的任务封装,以及线程池的封装。Runnable 适用于无返回值任务,Callable 支持有返回值任务。线程池(如 ExecutorService)则用于管理和复用线程,减少性能开销。示例代码展示了如何实现这些封装,使多线程编程更加高效和安全。
Java网络编程封装
Java网络编程封装原理旨在隐藏底层通信细节,提供简洁、安全的高层接口。通过简化开发、提高安全性和增强可维护性,封装使开发者能更高效地进行网络应用开发。常见的封装层次包括套接字层(如Socket和ServerSocket类),以及更高层次的HTTP请求封装(如RestTemplate)。示例代码展示了如何使用RestTemplate简化HTTP请求的发送与处理,确保代码清晰易维护。
|
2月前
|
Java 面向对象编程的三大法宝:封装、继承与多态
本文介绍了Java面向对象编程中的三大核心概念:封装、继承和多态。
155 15
|
4月前
|
在Java中,接口之间可以继承吗?
接口继承是一种重要的机制,它允许一个接口从另一个或多个接口继承方法和常量。
353 60
|
5月前
|
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
76 3
|
5月前
|
在Java多线程编程中,实现Runnable接口通常优于继承Thread类
【10月更文挑战第20天】在Java多线程编程中,实现Runnable接口通常优于继承Thread类。原因包括:1) Java只支持单继承,实现接口不受此限制;2) Runnable接口便于代码复用和线程池管理;3) 分离任务与线程,提高灵活性。因此,实现Runnable接口是更佳选择。
103 2
|
5月前
|
Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口
【10月更文挑战第20天】《JAVA多线程深度解析:线程的创建之路》介绍了Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口。文章详细讲解了每种方式的实现方法、优缺点及适用场景,帮助读者更好地理解和掌握多线程编程技术,为复杂任务的高效处理奠定基础。
87 2
|
5月前
|
Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点
【10月更文挑战第20天】Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点,重点解析为何实现Runnable接口更具灵活性、资源共享及易于管理的优势。
84 1
Java 面向对象新视界:揭秘子类如何“继承”父类精华,再添“创新”之笔
【6月更文挑战第16天】在Java的面向对象世界,子类继承父类的特性,如`Circle`继承`Shape`,展示“is-a”关系。子类不仅保留父类的`color`和`display`方法,还添加了`radius`属性及定制的显示逻辑。这种继承与创新允许代码复用,增强灵活性和可扩展性,使得构建复杂系统变得更加高效和模块化。通过持续的继承与定制,开发者能构建出一系列独具特色的类,充分展现面向对象编程的力量。
172 57
Java面向对象(三)详解: 封装 | 继承 | 方法重写 | 抽象类
Java面向对象(三)详解: 封装 | 继承 | 方法重写 | 抽象类
111 2

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等