Java基础|1-04-继承与抽象 @面向对象篇

最新推荐文章于 2023-04-23 19:44:22 发布
最新推荐文章于 2023-04-23 19:44:22 发布
阅读量202 收藏 1
点赞数
分类专栏： Java后端系列笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ThisAmy/article/details/113232762
版权

写在前面：
此文是笔者在学习Java系列课程的过程中，参考相关课件、视频讲解、课程代码，并结合一些文档、思维导图及个人理解，对所学内容做的阶段性梳理与总结。

  • 写于：2021年1月27日
  • 内容：Java后端系列笔记004（Java基础-继承与抽象）
  • 全文：5850字
    文章框架-04

一、继承

1. 1 基本概念

继承的基本概念

  • 继承性：面向对象的三大特征之一，继承描述的是事物之间的所属关系
  • 主要解决的问题：共性抽取
    • 多个类（子类 - 具体）中存在相同属性和行为时，将这些内容抽取到单独一个类（父类 - 通用）中
    • 那么多个类无需再定义这些属性和行为，只要继承那一个类即可
  • 继承关系中的特点
    • 子类可以拥有父类的内容（子类继承父类的属性和行为）
    • 子类还可以拥有自己专有的内容
  • 好处
    • 提高代码的复用性
    • 类与类之间产生了关系，是多态的前提（没有继承就没有多态）

小贴士：子类也可叫【派生类】；父类也可叫【基类、超类】

1. 2 继承的格式

  • 在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待
    例如：父类是员工，子类是讲师，那么“讲师就是一个员工”。关系：is-a
  • 定义父类的格式：（一个普通的类定义）
public class 父类名称 {
    // ...
}
  • 定义子类的格式：（使用 extends 关键字）
public class 子类名称 extends 父类名称 {
    // ...
}
  • 代码演示：
// 定义一个父类：员工
public class Employee {
    public void method() {
        System.out.println("我是一名员工！");
    }
}

// 定义了一个员工的子类：讲师
public class Teacher extends Employee {
}

// 定义了员工的另一个子类：助教
public class Assistant extends Employee {
}

// 定义测试类
public class Demo01Extends {
    public static void main(String[] args) {
        // 创建了一个子类对象
        Teacher teacher = new Teacher();
        // Teacher类中虽然什么都没写，但会继承来自父类的method方法
        teacher.method(); //我是一名员工！

        // 创建另一个子类助教的对象
        Assistant assistant = new Assistant();
        assistant.method(); //我是一名员工！
    }
}

1. 3 继承后的特点 - 成员变量

继承中成员变量的访问特点

  • 在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：
    • 直接通过子类对象访问成员变量： 等号左边是谁，就优先用谁，没有则向上找
    • 间接通过成员方法访问成员变量： 该方法属于谁，就优先用谁，没有则向上找
//父类
public class Fu {
    int numFu = 10;
    int num = 100;
    
    public void methodFu() {
        // 使用的是本类当中的，不会向下找子类的
        System.out.println(num);
    }
}

//子类
public class Zi extends Fu {
    int numZi = 20;
    int num = 200;

    public void methodZi() {
        // 因为本类当中有num，所以这里用的是本类的num
        System.out.println(num);
    }
}

//测试类
public class Demo02ExtendsField {
    public static void main(String[] args) {
        Fu fu = new Fu(); // 创建父类对象
        System.out.println(fu.numFu); // 只能使用父类的东西，没有任何子类内容
        System.out.println("===========");

        Zi zi = new Zi();

        System.out.println(zi.numFu); // 10
        System.out.println(zi.numZi); // 20
        System.out.println("===========");

        // 等号左边是谁，就优先用谁
        System.out.println(zi.num); // 优先子类，200
//        System.out.println(zi.abc); // 到处都没有，编译报错！
        System.out.println("===========");

        // 这个方法是子类的，优先用子类的，没有再向上找
        zi.methodZi(); // 200
        // 这个方法是在父类中定义的，向上查找，使用父类
        zi.methodFu(); // 100
    }
}

区分三种变量重名问题

  1. 局部变量：直接写成员变量名
  2. 本类的成员变量：this.成员变量名
  3. 父类的成员变量：super.成员变量名
public class Fu {
    int num = 10;
}

public class Zi extends Fu {
    int num = 20;
    
    public void method() {
        int num = 30;
        System.out.println(num); // 30，局部变量
        System.out.println(this.num); // 20，本类的成员变量
        System.out.println(super.num); // 10，父类的成员变量
    }
}

public class Demo03ExtendsField {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }
}
/* 输出结果
	30
	20
	10
*/

1. 4 继承后的特点 - 成员方法

继承中成员方法的访问特点

  • 在父子类的继承关系当中，创建子类对象，访问成员方法的规则：
    • 创建的对象是谁，就优先用谁，如果没有则向上找
  • 注意事项：无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类

方法的覆盖重写

  • 重写（Override）：在继承关系当中，方法的名称一样，参数列表也一样
  • 特点：创建的是子类对象，则优先用子类方法
  • 应用场景

应用场景

// 本来的老款手机
public class Phone {
    public void call() {
        System.out.println("打电话");
    }

    public void send() {
        System.out.println("发短信");
    }

    public void show() {
        System.out.println("显示号码");
    }

}

// 定义一个新手机，使用老手机作为父类
public class NewPhone extends Phone {

    @Override   //也可不写
    public void show() {
        super.show(); // 把父类的show方法拿过来重复利用
        // 自己子类再来添加更多内容
        System.out.println("显示姓名");
        System.out.println("显示头像");
    }
}

//测试类
public class Demo04Phone {
    public static void main(String[] args) {
        Phone phone = new Phone();  // 创建父类对象
        phone.call();  //打电话
        phone.send();  //发短信
        phone.show();   //显示号码
        System.out.println("==========");

        // 创建子类对象
        NewPhone newPhone = new NewPhone();
        // 调用父类继承而来的方法
        newPhone.call(); //打电话
        newPhone.send(); //发短信
        // 调用子类重写的方法
        newPhone.show(); //显示号码 显示姓名 显示头像
    }
}

方法覆盖重写的注意事项

  • 必须保证父子类之间方法的名称相同，参数列表也相同
    • @Override：写在方法前面，用来检测是不是有效的正确覆盖重写
    • 这个注解就算不写，只要满足要求，也是正确的方法覆盖重写
  • 子类方法的返回值必须【小于等于】父类方法的返回值范围
    • 扩展：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类
  • 子类方法的权限必须【大于等于】父类方法的权限修饰符
    • 提示：public > protected > (default) > private
    • 备注：(default)不是关键字default，而是什么都不写，留空

重写（Override）：方法的名称一样，参数列表【也一样】。覆盖、覆写。
重载（Overload）：方法的名称一样，参数列表【不一样】。

1. 5 继承后的特点 - 构造方法

继承中构造方法的访问特点

  1. 子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造
  2. 子类构造可以通过super关键字来调用父类重载构造
  3. super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造
public class Fu {
    public Fu() {
        System.out.println("父类无参构造");
    }

    public Fu(int num) {
        System.out.println("父类有参构造！");
    }
}

public class Zi extends Fu {
    public Zi() {
        super(); // 在调用父类无参构造方法
//        super(20); // 在调用父类重载的构造方法
        System.out.println("子类构造方法！");
    }

    public void method() {
//        super(); // 错误写法！只有子类构造方法，才能调用父类构造方法。
    }
}

public class Demo05Constructor {
    public static void main(String[] args) {
        Zi zi = new Zi();
    }
}
/*
输出结果：
父类无参构造
子类构造方法！
*/

总结：子类必须调用父类构造方法，不写则赠送super()；写了则用写的指定的super调用，super只能有一个，且必须是第一个。

1. 6 super和this

super关键字的用法（三种）

  1. 在子类的成员方法中，访问父类的成员变量
  2. 在子类的成员方法中，访问父类的成员方法
  3. 在子类的构造方法中，访问父类的构造方法

this关键字的用法（三种）

  1. 在本类的成员方法中，访问本类的成员变量
  2. 在本类的成员方法中，访问本类的另一个成员方法
  3. 在本类的构造方法中，访问本类的另一个构造方法

注意事项

  1. this(…)调用构造方法时，也必须是构造方法的第一个语句，唯一一个
  2. super和this两种构造调用，不能同时使用（因为都必须在构造方法的第一行）

小贴士：super关键字用来访问父类内容，this关键字用来访问本类内容

super和this关键字图解

super与this的内存图

  • 代码演示
public class Fu {
    int num = 10;
    
    public void method() {
        System.out.println("父类方法");
    }
}

public class Zi extends Fu {
    int num = 20;

    @Override
    public void method() {
        super.method(); // 调用了父类方法
        System.out.println("子类方法");
    }

    public void show() {
        int num = 30;
        System.out.println(num); // 30（局部变量）
        System.out.println(this.num); // 20（本类成员变量）
        System.out.println(super.num); // 10（分类成员变量）
    }
}

public class Demo {
    public static void main(String[] args) {
        Zi zi = new Zi();

        zi.show();
        zi.method();
    }
}
/* 
执行结果：
30
20
10
父类方法
子类方法
*/

1. 7 继承的特点

Java继承的三个特点

  1. Java只支持单继承，不支持多继承
  2. Java支持多层继承（承体系）
  3. 子类的父类唯一 ，但父类可拥有多个子类

二、抽象类

2. 1 抽象的概念

抽象的概念
由来

  • 父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。
  • 我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

2.2 abstract的使用

定义格式

  • 抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束
修饰符 abstract 返回值类型 方法名 (参数列表)；

//示例
public abstract void eat();
  • 抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可
abstract class 类名字 {
}

//示例
public abstract class Animal {
	// 这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定
	public abstract void eat();
}

如何使用抽象类和抽象方法

  1. 不能直接创建new抽象类对象
  2. 必须用一个子类来继承抽象父类
  3. 子类必须覆盖重写抽象父类当中所有的抽象方法
    覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号
  4. 创建子类对象进行使用
public class Cat extends Animal {

    @Override  //重写父类抽象方法
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class DemoMain {
    public static void main(String[] args) {
//        Animal animal = new Animal(); // 错误写法！不能直接创建抽象类对象

        Cat cat = new Cat(); // 创建子类对象
        cat.eat(); // 调用eat方法
    }
}
//输出：猫吃鱼

2. 3 注意事项

  1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象

理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义

  1. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的

理解：子类的构造方法中，有默认的super()，需要访问父类构造方法

  1. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计

  1. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类

理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义

艾伦！
关注
专栏目录
7-1 jmu-Java-03面向对象基础-04-形状-继承 (15 分)
qq_45798109的博客
10-26 5800
前言 前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。 本题描述： 定义抽象类Shape 属性：不可变静态常量double PI，值为3.14， 抽象方法:*public double getPerimeter(),public double getArea() Rectangle与Circle类均继承自Shape类。 R...
jmu-Java-03面向对象基础-04-形状-继承 PTA
qq_43427314的博客
10-31 3583
jmu-Java-03面向对象基础-04-形状-继承 PTA题目本题描述：思考分析答案 题目 前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。 本题描述： 1.定义抽象类Shape 属性：不可变静态常量double PI，值为3.14， 抽象方法:public double getPerimeter(),public double getArea() 2.Rectangle与Circle类均继承自Shape类。 Rectangle类
7-1 jmu-Java-03面向对象基础-04-形状-继承 （10 分）
qq_41047552的博客
12-04 1万+
前言 前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。 本题描述： 定义抽象类Shape属性：不可变静态常量double PI，值为3.14，抽象方法:public double getPerimeter(),public double getArea() Rectangle与Circle类均继承自Shape类。 ...
jmu-Java-03面向对象基础-04-形状-继承
黑白的黒's Blog
10-01 3107
前言 前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。 本题描述： 定义抽象类Shape 属性： 不可变静态常量double PI，值为3.14， 抽象方法: public double getPerimeter(),public double getArea() Rectangle与Circle类均继承自Shape类。 Rectangle类(属性： int width,length)、Circle类(属性： int radius
7-1 jmu-Java-03面向对象基础-04-形状-继承
一个恶意卖萌的博客
05-09 3020
本题描述： 定义抽象类Shape 属性：不可变静态常量double PI，值为3.14， 抽象方法:public double getPerimeter(),public double getArea() Rectangle与Circle类均继承自Shape类。 Rectangle类(属性：int width,length)、Circle类(属性：int radius)。 带参构造函数为Recta...
7-1 jmu-Java-03面向对象基础-04-形状-继承 (10 分)
bless_my_head的博客
06-26 1005
7-1 jmu-Java-03面向对象基础-04-形状-继承 (10 分) 前言 前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。 本题描述： 定义抽象类Shape 属性：不可变静态常量double PI，值为3.14，抽象方法:public double getPerimeter(),public double getArea()2.Rectangle与Circle类均继承自Shape类。 Rectangle类(属...
Java面向对象（高级）- 抽象类与抽象方法(或abstract关键字)
最新发布
11-25
【Java面向对象（高级）- 抽象类与抽象方法(或abstract关键字)】 在Java编程语言中，面向对象编程是其核心特性之一。抽象类和抽象方法是面向对象编程中的重要概念，它们允许程序员创建一种通用的模板，用于定义一...
7-4 jmu-Java-03面向对象基础-04-形状-继承 (25分)
sddfnsff的博客
06-15 2268
前言 前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。 本题描述： 定义抽象类Shape 属性：不可变静态常量double PI，值为3.14， 抽象方法:public double getPerimeter(),public double getArea() Rectangle与Circle类均继承自Shape类。 Rectangle类(属性：int width,length)、Circle类(属性：int radius)。 带参
（Java）7-1 jmu-Java-03面向对象基础-04-形状-继承
wxw1920的博客
07-25 2236
代码】（Java）7-1jmu-Java-03面向对象基础-04-形状-继承。
（java）7-1 jmu-Java-03面向对象基础-04-形状-继承 (12分)
Chenan12345的博客
05-13 782
前言 前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。 本题描述： 定义抽象类Shape 属性：不可变静态常量double PI，值为3.14， 抽象方法:public double getPerimeter(),public double getArea() Rectangle与Circle类均继承自Shape类。 Rectangle类(属性：int width,length)、Circle类(属性：int radius)。 带参
7-1 jmu-Java-03面向对象基础-04-形状-继承 (15分)
优秀的亮亮
10-17 8357
7-1 jmu-Java-03面向对象基础-04-形状-继承 (15分) 文章目录7-1 jmu-Java-03面向对象基础-04-形状-继承 (15分)前言本题描述：思考输入样例:输出样例:参考答案 前言 前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。 本题描述： 定义抽象类Shape 属性： 不可变静态常量doub...
7-1 jmu-Java-03面向对象基础-04-形状-继承 （10 分）计科其他班的题
markconca的博客
12-19 6650
前言 前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。 本题描述： 定义抽象类Shape 属性：不可变静态常量double PI，值为3.14， 抽象方法:public double getPerimeter(),public double getArea() Rectangle与Circle类均继承自Shape...
JAVA-jmu-Java-03面向对象基础-04-形状-继承
Old_Lynx的博客
05-05 562
jmu-Java-03面向对象基础-04-形状-继承 前言 前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。 本题描述 1.定义抽象类Shape 属性：不可变静态常量double PI，值为3.14， 抽象方法:public double getPerimeter(),public double getArea() 2.Rectangle与Circle类均继承自Shape类。 Rectangle类(属性：int width,leng
Java-03面向对象基础-04-形状-继承
zc_no的博客
04-07 2791
本题描述：定义抽象类Shape 属性：不可变静态常量double PI，值为3.14， 抽象方法:public double getPerimeter(),public double getArea()Rectangle与Circle类均继承自Shape类。 Rectangle类(属性：int width,length)、Circle类(属性：int radius)。 带参构造函数为Rectang...
笔记整理（java基础四-----面向对象---继承）
李保成(Net)
05-20 530
---------------------- android培训、java培训、期待与您交流！ ----------------------   面向对象---继承                      1.1 特点                       1.2 重写(Override)                       1.3注意：静态只能覆盖静态
(10)Java学习笔记——面向对象04——继承
xiexiecm的博客
01-16 401
继承 继承的好处： 1/提高了代码的复用性 2/让类与类之间产生了联系，给第三个特征多态提供了前提。 class ExtendsDemo { public static void main(String[] args) { Student s = new Student(); s.name="zhangsan"; s.age=20; s.study();
day07_继承&抽象
Cream336的博客
04-23 129
关于类的继承和抽象的详细代码演示
jmu-Java-03面向对象基础-05-覆盖
热门推荐
qq_33965121的博客
12-05 1万+
7-1 jmu-Java-03面向对象基础-05-覆盖 （3 分） Java每个对象都继承自Object,都有equals、toString等方法。 现在需要定义PersonOverride类并覆盖其toString与equals方法。 新建PersonOverride类 a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值