Java学习-面向对象之继承

最新推荐文章于 2023-04-04 19:54:05 发布
最新推荐文章于 2023-04-04 19:54:05 发布
阅读量262 收藏 2
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44816197/article/details/114962791
版权

面向对象之继承

1. 继承的概述

继承的概念

泛指把前人的作风、文化、知识、财产等接受过来

Java中的继承

让类与类之间产生父子关系
  被继承的类叫做父类（基类、超类）
  被继承的类叫做子类（派生类）
格式（extends）
   class 父类{
    // …
   }
   class 子类 extends 父类{
    // …
   }

子类继承负累之后有什么效果？

子类拥有了父类的非私有成员（成员变量、成员方法）

案例

  • 代码演示
// 定义一个父类：Parent
public class Parent {
    // 成员变量
    private String name;
    private  int age;

    // 快捷键：alt + insert 快速生成构造方法和get set方法
    // 构造方法

    public Parent() {
    }

    public Parent(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // get和set
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

/*
    Child:子类，派生类
    Parent:父类，基类，超类
 */
public class Child extends Parent {

}

public class Test {
    // main函数是程序的主入口，所有的代码都是从这里开始执行的
    public static void main(String[] args) {
        // 创建Child类的对象
        Child c = new Child();
        // 给对象c的姓名设置为：张三
        c.setName("张三");

        // 打印姓名的值
        System.out.println(c.getName());

        /*
            Java中，子类只能继承父类的非私有成员（成员变量，成员方法）
         */

    }
}
  • 运行结果
    在这里插入图片描述

2. 继承的使用场景

继承的使用场景

  • 多个类中存在相同的属性和行为时，可以将这些内容提取出来放到一个新类中，让这些类和新类产生父子关系，实现代码复用。

案例：定义继承关系的动物类并使用

  • 需求：分别定义Dog类、Pig类，它们共有的属性有：name、age、sex，共有的行为有：eat(),两者特有的行为分别是：watch()、snore()

1.传统做法

  • 代码演示
// 定义一个狗类
public class Dog {
    // 成员变量
    private String name;
    private int age;
    private String sex;

    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 String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    // 成员方法

    // 吃饭
    public void eat() {
        System.out.println("会吃饭");
    }
    // 看家
    public void watch() {
        System.out.println("会看家");
    }
}

// 定义一个猪类
public class Pig {
    // 成员变量
    private String name;
    private int age;
    private String sex;

    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 String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    // 成员方法

    // 吃饭
    public void eat() {
        System.out.println("会吃饭");
    }
    // 看家
    public void snore() {
        System.out.println("会看家");
    }
}

public class Test {
    public static void main(String[] args) {
        // 测试狗类
        Dog d = new Dog();
        d.eat();
        d.watch();
        System.out.println("-----------------------");

        // 测试猪类
        Pig p = new Pig();
        p.eat();
        p.snore();
    }
}

发现Dog类和Pig类有重复的代码很多，采用继承可以解决这个问题

  • 运行结果
    在这里插入图片描述

2.使用继承后的代码

  • 代码演示
// 定义一个父类（Animal：动物类），里边放的是共性内容
public class Animal {
    /*
        它们共有的属性有：name、age、sex
        共有的行为有：eat()
     */
    // 成员变量
    private String name;
    private int age;
    private String sex;

    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 String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    // 成员方法

    // 吃饭
    public void eat() {
        System.out.println("会吃饭");
    }
}

// 定义一个狗类
public class Dog extends Animal{
    // 定义看家的方法
    public void watch() {
        System.out.println("会看家");
    }
}

// 定义猪类
public class Pig extends Animal{
    // 打鼾
    public void snore() {
        System.out.println("会打鼾");
    }
}

public class Test {
    public static void main(String[] args) {
        // 测试狗类
        Dog d = new Dog();
        d.eat();
        d.watch();
        System.out.println("---------------");

        // 测试猪类
        Pig p = new Pig();
        p.eat();
        p.snore();
    }
}
  • 运行结果
    在这里插入图片描述

3. 继承的优缺点

优点

  1. 功能复用：直接将已有的属性和行为继承过来，实现了功能的复用，节省了大量的工作
  2. 便于扩展新功能：在已有功能的基础上，更容易建立、扩充新功能
  3. 结构清晰、简化认识：同属于一个继承体系的相关类，他们之间结构层次清晰，简化了人们对代码结构的认识
  4. 易维护性：不同类之间的继承关系，让这些事物之间保持一定程度的一致性，大大降低了维护成本

缺点

  1. 打破了封装性：父类向子类暴露了实现细节，打破了父类对象的封装性
  2. 高耦合性：类与类之间紧密的结合在一起，相互依赖性高

程序而设计的追求

低耦合，高内聚

  • 耦合：两个（或更多）模块相互依赖于对方
  • 内聚：模块内部结构紧密，独立性强

4. 继承关系中类成员的使用

案例1

  • 需求：子父类中定义了同名的成员变量，如何使用
  • 代码演示：
// 父类:水果类
public class Fruit {
    // 成员变量
    int price = 20;
}

// 子类：苹果类
public class Apple extends Fruit{
    // 成员变量
    int price = 10;

    public void showPrice() {
        // 局部变量
        int price = 5;

        System.out.println(price);
        System.out.println(this.price);
        System.out.println(super.price);
    }
}

public class Test {
    public static void main(String[] args) {
        // 需求：测试继承关系中，子父类间成员变量的使用
        Apple apple = new Apple();
        apple.showPrice();

        /*
            Java中使用变量的规则：
                遵循“就近原则”，局部位置有就使用，
                没有就去本类的成员位置找，有就使用
                没有就去父类的成员位置找，有就使用，没有就报错
         */
    }
}
  • 运行结果：
    在这里插入图片描述

继承关系中成员变量使用图解

在这里插入图片描述
2.
在这里插入图片描述
3.
在这里插入图片描述

继承关系中成员变量使用结论

  • 查找变量的原则：就近原则
  • 查找变量的顺序：局部变量->成员变量->父类->更高的父类…Object
  • 访问父类变量的方式：super.父类变量名;
  • super:当前对象父类的引用（父类内存空间的标识）
  • 对象初始化顺序：先初始化父类内容，再初始化子类内容

this和super的区别

this:
  本质：对象
  用法：从本类开始找
super:
  本质：父类内存空间的标识
  用法：从父类开始找

案例：

  • 代码演示
// 父类
public class Fu {
    int num = 30;
}

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

    public void show() {
        int num = 10;
        System.out.println(num);   // 10
        System.out.println(this.num);   // 20
        System.out.println(super.num);   // 30
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        /*
            使用变量遵循就近原则，
                先在局部位置找，有就使用
                没有就去本类的成员位置找，有就使用
                没有就去父类的成员位置找，有就使用，没有就报错

            如果局部变量，本类的成员变量，父类的成员变量重名了，如何解决？
                直接写变量名      局部变量
                this.变量名      本类的成员变量
                super.变量名     父类的成员变量
         */
        Zi zi = new Zi();
        zi.show();
    }
}
  • 运行结果
    在这里插入图片描述

案例2

  • 需求：子父类中定义了同名的成员方法，如何使用？
  • 代码演示：
/*
    父类：武功类
    四大权限邱师傅的修饰范围从小到大分别是：
        private 默认（什么都不写就是默认） protected public
 */
public class Martial {
    // 练习内功
    public void internalStrength(){
        System.out.println("练习内功");
    }
    // 练习招式
    public void stroke() {
        System.out.println("练习招式");
    }
}

// 子类：九阴真经
public class NineYin extends Martial{
    // 练习内功
    public void internalStrength(){
        // 这里实在调用父类的成员方法
        super.internalStrength();

        System.out.println("以柔克刚");
    }

    public void stroke() {
        System.out.println("九阴白骨爪");
    }
}

public class Test {
    public static void main(String[] args) {
        // 需求：调用NineYin类中的功能
        NineYin ny = new NineYin();
        ny.internalStrength();
        ny.stroke();
    }
}
  • 运行结果：
    在这里插入图片描述
  • 图解
    在这里插入图片描述

继承关系中成员方法使用结论

  • 定义重名方法的前提：
     父类不能完全满足现实需求，扩展父类功能
     父类功能已过时，重新实现父类功能

案例3.1

  • 需求：创建对象时，构造方法时如何被调用的？
  • 代码演示
// 父类
public class Person {
    public Person() {
        System.out.println("Person类的 空参构造");
        // System.out.println("Person类的带参构造" + name);
    }
}

public class Worker extends Person{
    public Worker() {
        System.out.println("Worker类的空参构造");
    }
}

/*
    测试类，用来演示：构造方法的调用的
    结论：
        子类所有构造方法的第一行都有一个默认的super();用来访问父类的无参构造方法
        如果父类没有无参构造，可以通过super(参数)的形式访问父类的带参构造
 */
public class Test {
    public static void main(String[] args) {
        // 创建子类对象
        Worker w = new Worker();
    }
}
  • 运行结果：
    在这里插入图片描述
  • 结论：
     创建子类对象时，优先调用父类构造方法
     子类构造方法的第一行，隐含语句super(),用于调用父类的默认无参构造

案例3.2

  • 需求：父类不存在默认无参构造方法怎么办？
  • 分析：子类创建对象时，，必须先初始化该对象的父类内容，若父类中不存在默认无参构造，须手动调用父类其它构造。
  • 代码演示
// 父类
public class Person {
    public Person(String name) {
        // System.out.println("Person类的 空参构造");
        System.out.println("Person类的带参构造" + name);
    }
}

// 子类
public class Worker extends Person{
    public Worker() {
        super("张三");    // 用于初始化父类成员的
        System.out.println("Worker类的空参构造");
    }
}

public class Test {
    public static void main(String[] args) {
        // 创建子类对象
        Worker w = new Worker();
    }
}
  • 运行结果
    在这里插入图片描述

5. 方法重写

方法重写（Override）

  • 定义：
      子类中出现和父类方法定义相同的方法的现象
  • 解释：
      方法重写也叫方法的复写、覆盖
      方法名、参数列表、返回值类型都相同
  • 注意事项：
      父类私有方法无法重写
      子类方法访问权限不能小于父类方法
      子类不能比父类方法跑出更大的异常（了解）
  • 使用场景：
      扩展父类功能
      父类功能过时，重新实现父类功能

Java中的访问权限修饰符

在这里插入图片描述

方法重写和方法重载的区别

重载（Overload）

方法名：相同
参数列表：不同（个数或对应位置类型）
返回值类型：无关
修饰符：无关
定义位置：同一个类

重写（Override）

方法名：相同
参数列表：相同
返回值类型：相同
修饰符：访问权限不小于被重写方法
定义位置：子父类中

6. Java中继承的特点

  • 单继承
      Java只支持类的单继承，但是支持多层（重）继承
      Java支持接口的多继承，语法为：
        接口A extends 接口B,接口C,接口D…
  • 私有成员不能继承
      只能继承父类的非私有成员（成员变量、成员方法）
  • 构造方法不能继承
      构造方法用于初始化本类对象。
      创建子类对象时，需要调用父类构造初始化
      该对象的父类内容，若父类构造可以被继承，
      该操作会造成调用的混乱。
  • 继承体现了“is a”的关系
      子类符合“is a(是一个)”父类的情况下，才能使用继承，其它情况不建议使用
不准吃饭
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础_Java编程思想_面向对象之继承的使用场景
9.冄2.7.號的博客
03-11 508
继承的使用场景 子类通过继承，拥有了父类的非私有成员，这是开发中常见的做法，那么，继承还有哪些使用场景呢？ 向上抽取 多个类中存在相同的属性和行为时，可以将这些内容提取出来放到一个新类中，让这些类和新类产生父子关系，实现代码复用。 向下扩展 当需要扩展已有的类的功能时，可以通过继承已有的类，在子类中添加新功能或重新实现已有功能，对父类（已有的类）没有影响。 案例：定义继承关系的动物类并使用 需求 分别定义Dog类、Mouse类、Pig类，它们共有的属性有：name、age、sex，共有的行为有：ea
Java-Java面向对象继承的实现教程
最新发布
11-09
在Java编程语言中，面向...学习Java面向对象继承的实现，不仅有助于提升编程技巧，还能更好地理解面向对象编程的核心理念。在实际开发过程中，结合视频教程和其他学习资源，可以加深对这一主题的理解，提高编程能力。
JAVA继承
weixin_46256496的博客
04-04 191
继承是面向对象三大特征之一，可以使得子类具有弗雷德属性和方法，还可以在子类中重新定义，追加属性和方法。继承的格式格式：public class 子类名 extends 父类名{}范例：public class Zi extends Fu {}Fu：是父类，也被成为基类，超类Zi：是子类，也被成为派生类继承中子类的特点：子类可以有父类的内容子类还可以有自己特有的内容。
java-2 继承
qq_64054032的博客
05-20 109
什么是继承 继承是把两个类的共性抽取，放到一个类当中 class Dog{ public int length; public void bark(){ System.out.println(length+"www"); } } class Cat{ public int length; public void miao(){ System.out.println("miao"); } } public clas
java面向对象之——继承
qq_53999369的博客
05-05 1095
面向对象的特征之一 ——继承 那什么是继承呢？     继承是从已有的类中派生出新的类。 继承怎么用？     在类名后加extends关键字+被继承的类名表示继承关系 继承有什么用吗？     通俗的来说，子类可以吸收父类类的属性和行为， 并能扩展新的能力。 继承的语法有什么基本要求吗？    1.JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个 直接父类。 &n
从零开始学python之继承
yangzijiangtou
01-14 1124
继承： 定义一个类Animal(动物),这个类中需要两个方法：run() sleep() class Animal: def run(self): print('动物会跑') def sleep(self): print('动物睡觉') 定义一个类Dog(狗) class Dog: def run(self): print('狗会跑')
Java面向对象之继承练习题.doc
08-04
【Java面向对象之继承练习题】的解析与详解： 1. **类的继承**：在Java中，继承是面向对象编程的重要特性，允许一个类（子类）继承另一个类（父类）的属性和方法。例如，我们可以创建一个`Music`类作为其他音乐相关...
Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company
12-28
pta题目java的继承覆盖综合题源码，全部内容为自己原创，能够运行但是有些代码可能写的不是很精简，这个摘要也太长了吧，凑不够字数啊
java-面向对象特性PPT.ppt
10-31
"java-面向对象特性PPT" 本资源摘要信息主要讲解了面向对象编程的基本概念、面向对象设计、类...本资源摘要信息对面向对象编程和Java中的类和对象进行了详细的介绍和解释，为学习Java的学生提供了一个系统的学习资源。
java-面向对象的英雄类
12-20
在这个“java-面向对象的英雄类”主题中，我们将深入探讨Java中的面向对象编程，特别是继承的概念，这是Java OOP的三大特性（封装、继承和多态）之一。 面向对象编程的基本理念是将现实世界中的实体抽象为类，类是...
2021-03-08
小蚂蚁的博客
03-08 1129
面向对象基础–继承 1. 继承 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类中无需再定义这些属性和行为，只需要和抽取出来的类构成某种关系。 其中，多个类可以称为子类，也叫派生类；多个类抽取出来的这个类称为父类、超类（superclass）或者基类。 1.1 继承的好处： 提高代码的复用性。 提高代码的扩展性。 类与类之间产生了关系，是学习多态的前提。 通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下： 【修饰符】 class 父类 { ...
Day09Java基础学习
weixin_44400192的博客
01-30 310
这里写自定义目录标题 Day 09 面向对象（多态的概述及其代码体现） （1） 多态的概述：事物存在多种形态。 （2） 多态前提： 要有继承关系；要有方法重写；要有父类引用指向子类对象。 （3） 案例演示：代码体现多态 class Demo_Polymorphic{ public static void main(String[] args) { Cat c = new Cat(); c.e...
猫狗案例
weixin_43912065的博客
10-31 414
猫： 成员变量：姓名，年龄，颜色， 构造方法：无参，带参 成员方法： getXxx()/setXxx() eat() playGame() 狗： 成员变量：姓名，年龄，颜色 构造方法：无参，带参 成员方法： getXxx()/setXxx() eat() lookDoor() 共性： 成员变量：姓名，年龄，颜色 构造方法：无参，带参 成员方法： getXxx()/setXxx() e...
java 继承习题_java练习题_继承
weixin_39996908的博客
02-20 2050
一.extends和super的使用和方法的重写1.定义一个人的类(属性有名字，年龄。写一个能输出各个属性值的方法showInfo())，定义一个学生类(属性有性别)，学生继承人类要求：(1)父类的属性赋值用构造方法来实现(分别用有参数构造方法和无参数构造方法实现)(2)子类的属性也用构造方法来赋值。(3)在子类中重写父类的showInfo()方法(4)声明学生类的对象，调用学生的显示信息的方法。...
面向对象程序设计之Python
m0_47066335的博客
04-28 566
面向对象程序设计三大特性 封装：根据职责将属性和方法封装到一个抽象的类中 继承：实现代码的重用，相同的代码不需要重复编写 多态：不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度 封装 就是把类的属性和方法封装到类的内部，只能在内部使用，不能在类的外部使用 把属性和方法名前面加两个下划线__，这个属性和方法就成为了类的私有属性和方法 class woman: def __init__(self): self.name = "玛丽" self.__w
Java程序设计实验（三）：类的继承和多态实验
SSnTi的博客
08-16 2303
题目一 1（题目编号7173）、现定义一个类体系，基类为Dog，派生类为斑点狗SpottedDog类和非斑点狗UnspottedDog类，具体要求如下： （1）在基类中记录狗的品种breed，体重weight以及颜色color等属性，定义一个方法show()显示Dog信息； （2）在UnspottedDog类中，调用Dog类的构造方法，重写show()方法，只显示狗的品种； （3）在SpottedDog类中，新增表示斑点颜色的spotColor属性，定义包含四个属性的构造方法，重写show（）方法； （4）
2021-03-05
weixin_44431672的博客
03-05 708
@面向对象下TOC 继承 子类继承父类，目的子类扩展父类的属性以及方法，就是为了实现代码的复用（继承在Java中只能单继承，不能多继承） -子类可以继承父类的非私有化的属性以及方法 -所有的引用类型都默认继承了超类Object ※方法的重写（两同、一大、两小） 子类重写父类的方法（子类覆盖父类的方法），凸显出子类的行为特征 -方法名相同、方法参数列表相同【方法签名一致】 -和方法修饰符、返回值类型有关 –子类重写父类的方法，子类方法的权限修饰符比父类的大或者相等 –子类重写父类的方法，子类的返回值类型
Python与Java的重要不同点
afunyusong的专栏
03-31 1760
继承和多态静态语言 vs 动态语言对于静态语言（例如Java）来说，如果需要传入Animal类型，则传入的对象必须是Animal类型或者它的子类，否则，将无法调用run()方法。对于Python这样的动态语言来说，则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了：class Timer(object): def run(self):
java基础—继承题目：编写一个Animal类，具有属性：种类；具有功能：吃、睡。定义其子类Fish...
热门推荐
weixin_30617695的博客
09-22 1万+
编写一个Animal类，具有属性：种类；具有功能：吃、睡。定义其子类Fish package zhongqiuzuoye; public class Animal { //属性 private String type; public String getType() { return type; } ...
Java零基础：J2SE入门-面向对象编程概览与封装、继承、多态
Java零基础自学指南中，我们探讨的是J2SE（Java 2 Standard Edition）阶段的面向对象编程。面向对象编程（Object-Oriented Programming, OOP）是编程语言发展的重要里程碑，它与早期的机器语言、汇编语言相比，具有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值