黑马Java第十一讲笔记—多态&抽象类&接口

最新推荐文章于 2024-07-19 17:37:28 发布
最新推荐文章于 2024-07-19 17:37:28 发布
阅读量492 收藏 3
点赞数 3
分类专栏： 初学java 文章标签： java 开发语言 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46213083/article/details/126590048
版权

🎨 个人介绍

👉大家好，我是：知识的搬运工旺仔

👉认真分享技术，记录学习过程的点滴，如果我的分享能为你带来帮助，请支持我奥🍻

👉你的支持，是我每天更新的动力。

👉赞点：👍 留言：✍ 收藏：⭐

👉个人格言：想法一步一步的落实，才是你我前进最佳选择。

黑马Java第十一讲笔记—多态&抽象类&接口

1. 多态

1.1 多态的概述

1 ）什么是多态

  1. 同一个对象，在不同时刻表现出来的不同形态

2 ）多态的前提

  1. 要有继承或实现关系
  2. 要有方法重写
  3. 要有父类引用指向子类对象

1.2 多态中的成员访问特点

1 ）成员访问特点

  1. 成员变量：编译看父类，运行看父类
  2. 成员方法：编译看父类，运行看子类

2 ）代码实例

  1. 动物类
public class Animal {
    public int age = 40;
    
    public void eat() {
        System.out.println("动物吃东西");
    }
}
  1. 猫类
public class Cat extends Animal {
    public int age = 20;
    public int weight = 10;
    
    @Override 
    public void eat() {
        System.out.println("猫吃鱼");
    }
    
    public void playGame()  {
        System.out.prinln("猫捉鱼");
    }
}
  1. 测试类
public static AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();
        
        System.out.println(a.age);
        // 下面这个使用会报错，因为父类引用指向子类，只能使用父类的所有成员变量，子类新增的不能使用
        System.out.println(a.weight); 
        
       a.eat();
       
       // 这个方法会报错，因为父类引用指向子类，只能使用父类的所有方法，子类新增的不能使用
       a.playGame();
        
    }
}

1.3 多态的好处与弊端

1 ）好处

  1. 提高程序的扩展性。定义方法时候，使用父类型作为参数，使用具体的子类型参与操作

2 ）弊端

  1. 不能使用子类特有成员

1.4 多态中的转型

1 ）向上转型

  1. 父类引用指向子类对象是向上转型

2 ）向下转型

  1. 格式： 子类型 对象名 = (子类型) 父类引用;

3 ）代码演示

  1. 动物类
public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}
  1. 猫类
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    
    public void playGame() {
        System.out.prinln("猫捉迷藏");
    }
}
  1. 测试类
public class AnimalDemo {
    public static void main(String[] args) {
        // 上转型
        Animal a = new Cat();
        a.eat();
        // 边下的方法会报错
        a.palyGame();
        
       //向下转型
        Cat c = (Cat) a;
        // 下边的d
        a.eat();
        a.palyGame();
    }
}

1.5 多态的案例

1 ）案例需求

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

2 ）代码实现

  1. 动物实现类
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() {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void eat() {
        this.age = age;
    }
    
    public void est() {
        System.out.println("动物吃东西");
    }
}
  1. 猫类
public class Cat extends Animal {
    public Cat() {
        
    }
    
    public Cat(String name,int age) {
        super(name,age);
    }
​
    @Override
    public void eat() {
        System.println.out("猫吃鱼");
    }
}
  1. 狗类
public class Dog extends Animal {
    public Dog() {
        
    }
    
    public Dog (String name,int age) {
        super(name,age);
    }
    
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
  1. 测试类
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());
        e.eat();
        
        a = new Cat("加菲",5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();
    }
}

2. 抽象类

2.1 抽象类的 概述

  1. 当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！
  2. 在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象！

2.2 抽象类的特点

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

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

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

3 ）抽象类不能实例化

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

4 ）抽象类的子类

  1. 要么重写抽象类中的所有方法
  2. 要么是抽象类

2.3 抽象类的成员特点

1 ）成员的特点

  1. 成员变量

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

  2. 构造方法

    • 空参构造
    • 有参构造

  3. 成员方法

    • 抽象方法
    • 普通方法

2 ）代码实例

  1. 动物类
public abstract class Animal {
    private int age = 20;
    private final String city = "北京";
    
    public Aniaml() {}
    
    public Animal(int age) {
        this.age = age;
    }
    
    public void show() {
        age = 40;
        System.out.println
        city = "上海";  // 这句话会报错，因为 city 是常量
        System.out.println(city);
    }
    
    public abstract void eat();
}
  1. 猫类
public class Cat extends Animal {
    @Override
    public void eat() {
    	System.out.println("猫吃鱼");   
    }
}
  1. 测试类
public class AnimalDemo  {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        a.show();
    }
}

2.4 抽象类的案例

1 ）案例需求

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

2 ）代码实现

  1. 动物类
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();
}
  1. 猫类
public class Cat extends Animal {
    public Cat() {
        
    }
    
    public Cat(String name,int age) {
        super(name,age);
    }
    
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
  1. 狗类
public class Dog extends Animal {
    public Dog() {}
    
    public Dog (String name , int age) {
        super(name,age);
    }
}
  1. 测试类
public class AnimalDemo {
    publci 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();
    }
}

3. 接口

3.1 接口的概述

  1. 接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用
  2. java中的接口更多的体现在对行为的抽象

3.2 接口的特点

1 ）接口用关键字interface修饰

public interface 接口名 {}

2 ）类实现接口用implements 表示

public class 类名 implements 接口名 {}

3 ）接口 不能实例化

  1. 接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态
  2. 多态的形态，具体类多态，抽象类多态，接口多态

4 ）接口的子类

  1. 要么重写接口中的所有抽象方法
  2. 要么子类也是抽象类

3.3 接口的成员特点

1 ）成员特点

  1. 成员变量：只能是常量，默认修饰符 ：public static fianl

  2. 构造方法：没有，因为接口主要是拓展功能，而没有具体存在

  3. 成员方法：

    • 只能是抽象方法
    • 默认修饰符： public abstract
    • 关于接口中的方法，JDK8,JDK9中有一些新的特性

2 ）代码演示

  1. 接口：
public interface Inter {
    public int num = 10;
    public final int num2 =20;
    
    int num3;
    
    // 下面这行代码是会报错的，因为接口没有构造方法
    public Inter() {}
    
    public abstract void method();
    
}
  1. 实现类
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");
    }
}
  1. 测试类
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);
    }
}

3.4 接口的案例

1 ）案例需求

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

2 ）代码实现

  1. 动物类
public abstract class Animal {
    private String name;
    private int sge;
    
    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 getName() {
        return age;
    }
    
    public void setName(int age) {
        this.age = age;
    }
    
    public abstract void eat();
}
  1. 跳高接口
public interface Jumpping {
    public abstract void jump();
}
  1. 猫类
public class Cat extends Animal implements JUmpping {
     public Cat() {
         
     }
    
    public Cat (String name , int age) {
        super(name,age);
    }
    
	@Override
    public void jump() {
        System.out.println("猫可以跳高了")
    }
}
  1. 测试类
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.junp();
        
    }
}

3.5 类和接口的关系

1 ）类与类的关系

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

2 ）类与接口的关系

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

3 ）接口与接口的关系

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

3.6 抽象类和接口的区别

1 ）成员区别

  1. 抽象类

    • 变量，常量，构造方法，有抽象方法，也有非抽象方法

  2. 接口

    • 变量；抽象方法

2 ）关系区别

  1. 类与类

    • 继承，单继承

  2. 类与接口

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

  3. 接口与接口

    • 继承，单继承，多继承

3 ）设计理念区别

  1. 抽象类

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

  2. 接口

    • 对行为抽象，主要是行为

4. 综合案例

4.1 案例需求

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

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

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

4.2 代码实现

  1. 抽象人类
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();
}
  1. 抽象运动员
public abstract class Player extends Person {
    public Player() {}
    
    public Player(String name, int age) {
        super(name,age);
    }
    
    public abstract void study();
}
  1. 抽象教练类
public abstract class Coach extends Person {
    public Coach() {}
    
    public Coach(String name,int age) {
        super(name,age);
    }
    
    public abstract void teach();
}
  1. 学习英语接口
public interface SpeakEnglish {
    public abstract void apeack();
}
  1. 篮球教练
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("篮球教练吃羊肉，喝羊奶");
    }
}
  1. 乒乓球教练
public class PingpangCoach extends 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("乒乓球教练说英语");
    }
}
  1. 乒乓球运动员
public class PingpangPlayer extends Player implements SpeackEnglish {
    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("乒乓球运动员说英语");
    }
}
  1. 篮球运动员
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("篮球远动员吃牛肉h");
    }
    
}

🎈看完了不妨给我点个赞吧，👉你的支持，是我每天更新的动力…

知识的搬运工旺仔
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
Java笔记 - 黑马程序员_03（继承，修饰符，多态，抽象类，接口，内部类）
逸乐的博客
04-22 2424
1. 继承 1.1 继承的概述 继承是面向对象三大特征之一。可以使得子类具有父类元素的属性和方法，还可以在子类中重新定义，追加属性和方法。 继承的格式： 格式：public class 子类名 extends 父类名 案例：public class ZI extends FU{} FU类为父类（superclass），超类，基类 ZI类为子类（subclass），派生类，扩展类 继承中子类的特点： 子类可以有父类的内容 子类也可以有自己特有的内容
学习黑马教程java笔记之抽象类和接口
qq_57039493的博客
11-26 144
抽象类和接口 抽象类 什么是抽象类？ 抽象类简单理解，就是这个对象是什么。人和狗的抽象类都是动物。抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。 由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。 抽象类的规则 1 抽象类必须使用abstract修饰符来修饰，抽象方法也必须使用abstract修饰符来修饰，抽象方法不能有方法体。 2 抽象类不能被实例化，无法使用new关键字来调用抽象类的
黑马程序员Java笔记——抽象类、接口、内部类（拾遗补录）
晴耕雨读
08-15 548
----------- android培训、java培训、java学习型技术博客、期待与您交流！ --------- 拾遗补录： 面向对象与面向过程： （1）面向对象与面向过程的区别，以及有哪些编程语言为代表？ A、面向对象是以对象为基础，强调对象能完成什么功能（What）；代表语言有JAVA、C++、Python、 B、面向过程是以函数为基础，强调函数怎么实现此功能（How）；代表
黑马程序员Java课程笔记010接口和多态
qq_44005101的博客
03-18 475
黑马程序员Java课程笔记010第一章 接口1.1 接口概述与生活举例1.2 接口的定义基本格式1.3 接口的抽象方法定义1.4 接口的抽象方法使用1.5 接口的默认方法定义1.6 接口的默认方法使用1.7 接口的静态方法定义1.8 接口的静态方法使用1.9 接口的私有方法定义1.10 接口的私有方法使用1.11 接口的常量定义和使用1.12 接口的内容小结1.13 继承父类并实现多个接口1.14 接口之间的多继承第二章 多态2.1 多态的概述2.2 多态的格式与使用2.3 多态中成员变量的使用特点2.4
黑马程序员Java课程笔记009继承与抽象类
qq_44005101的博客
03-18 431
Java课程笔记009第一章 继承1.1 继承的概述1.2 继承的格式1.3 继承中成员变量的访问特点1.4 区分子类方法中重名的三种变量1.5 继承中成员方法的访问特点1.6 继承中方法的覆盖重写_概念与特点1.7 继承中方法的覆盖重写_注意事项1.8 继承中方法的覆盖重写_应用场景'1.9 继承中构造方法的访问特点1.10 super关键字的三种用法1.11 this关键字的三种用法1.12 Java继承的三个特点第二章 抽象类2.1 抽象的概念2.2 抽象方法和抽象类的格式2.3 抽象方法和抽象类的注
JavaSE笔记总结01（封装继承多态，抽象类接口，匿名内部类）
m0_46507516的博客
01-07 620
JavaSE封装、继承、多态、构造器、抽象类、接口、匿名内部类等前期笔记整理
【黑马程序员】多态、抽象类、接口——Java复习笔记
u014461902的博客
11-04 332
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-final关键字 A:它修饰的类，不能被继承。 B:它修饰的方法，不能被重写。 C:它修饰的变量，是一个常量(自定义常量 )，不能被重新赋值(基本类型：值。引用类型：地址值)。 面试相关： A:final修饰局部变量 a:基本类型 值不能发生改变 b:引
黑马程序员-Java学习笔记之抽象类，接口，多态和内部类
newxuyangcao
03-28 471
一 抽象类 1 抽象的定义 抽象：不具体，看不明白。抽象类表象体现。 在不断抽取过程中，将共性内容中的方法声明抽取，但是方法不一样，没有抽取，这时抽取到的方法，并不具体，需要被指定关键字abstract所标示，声明为抽象方法     抽象就是从多个事物中将共性的，本质的内容抽取出来。     例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。  
黑马程序员Java上篇笔记
2301_79860963的博客
04-30 938
对于该用法的解释：当子类继承父类时，父类所有的成员变量子类都会有，那么父类的构造方法就适用于子类，所以子类不用将父类的构造方法照搬，可以直接在构造方法的中括号中写一个super（）；对他的父类进行构造，父类的成员变量被赋值后（如果有带参构造的情况下）子类的成员变量也对应的改变，这样就相当于对子类进行了构造，这样处理可以简化代码。空参构造一个字符串容器的类。
黑马java教程知识点笔记整理
02-04
【Java编程基础】 ...以上是黑马Java教程知识点笔记的主要内容，涵盖了Java编程的基础到进阶知识，是学习和巩固Java技能的重要参考资料。通过深入理解和实践这些知识点，开发者可以逐步提升Java编程能力。
java黑马笔记.rar
10-08
- **多态**：同一种行为在不同对象上有不同的表现形式，通过接口、抽象类和方法重写实现。 4. **异常处理**： Java使用try-catch-finally结构来捕获和处理程序运行时可能出现的错误，提供了一种系统化的异常处理...
Java基础最全笔记文档
07-29
Java加强篇则进一步深入，如静态关键字`static`、单例设计模式、权限修饰符、枚举、抽象类、多态、内部类，以及更复杂的集合框架（如List、Set、Map）和泛型。除此之外，还有日期时间处理、正则表达式、异常处理、IO...
黑马程序员Java基础视频辅导班课堂笔记总结Day09
05-14
在Java编程语言中，面向对象、多态、抽象类和接口是核心概念，它们对于构建高效、可扩展的代码至关重要。下面将详细解释这些概念及其特点。 **面向对象**是Java编程的基础，它允许我们将复杂的问题分解为独立的实体...
java黑马笔记.rar.rar
10-09
"java黑马笔记.rar.rar"很可能是一个包含详细Java学习资料的压缩文件，由知名的黑马程序员培训机构提供。这样的笔记通常涵盖Java基础、进阶特性、面向对象编程、异常处理、集合框架、多线程、IO流、网络编程、JVM...
Java内存模型
最新发布
weixin_44267758的博客
07-19 314
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 584
JVM-垃圾回收与内存分配
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 847
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【Java算法】前缀和 下
2302_79806056的博客
07-18 898
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java面向对象与接口：多态、抽象类和接口解析
Java的面向对象特性，如多态、抽象类和接口，提供了强大的设计和实现工具，使得代码更具灵活性、可扩展性和可维护性。通过理解和熟练运用这些概念，开发者能够构建出更加健壮和模块化的软件系统。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

知识的搬运工旺仔

希望能帮助到大家学习

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值