继承（二）

最新推荐文章于 2022-05-15 17:13:30 发布
最新推荐文章于 2022-05-15 17:13:30 发布
阅读量132 收藏
点赞数
分类专栏： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1072403106/article/details/103240361
版权

一、子类不能继承的内容

1.引入

并不是父类所有的内容都可以给子类继承的：
子类不能继承父类的构造器，因为子类有自己的构造器。值得注意的是子类可以继承父类的私有成员（成员变量，方法），只是子类无法直接访问而已，可以通过getter/setter方法访问父类的private成员变量。

2.演示代码
public class Demo03 {
public static void main(String[] args) {
Zi z = new Zi();
System.out.println(z.num1);
// System.out.println(z.num2); // 私有的子类无法使用
// 通过getter/setter方法访问父类的private成员变量
System.out.println(z.getNum2());
z.show1();
// z.show2(); // 私有的子类无法使用
}
}
class Fu {
public int num1 = 10;
private int num2 = 20;
public void show1() {
System.out.println("show1");
}
private void show2() {
System.out.println("show2");
}
public int getNum2() {
return num2;
}
public void setNum2(int num2) {
this.num2 = num2;
}
}
class Zi extends Fu {
}

二、继承后的特点–成员变量

1.成员变量不重名

如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。代码如下：

class Fu {
// Fu中的成员变量
int num = 5;
}
class Zi extends Fu {
// Zi中的成员变量
int num2 = 6;
// Zi中的成员方法
public void show() {
// 访问父类中的num
System.out.println("Fu num="+num); // 继承而来，所以直接访问。
// 访问子类中的num2
System.out.println("Zi num2="+num2);
}
}
class Demo04 {
public static void main(String[] args) {
// 创建子类对象
Zi z = new Zi();
// 调用子类中的show方法
z.show();
}
}
2.成员变量重名

如果子类父类中出现重名的成员变量，这时的访问是有影响的。代码如下：

class Fu1 {
// Fu中的成员变量。
int num = 5;
}
class Zi1 extends Fu1 {
// Zi中的成员变量
int num = 6;
public void show() {
// 访问父类中的num
System.out.println("Fu num=" + num);
// 访问子类中的num
System.out.println("Zi num=" + num);
}
}
class Demo04 {
public static void main(String[] args) {
// 创建子类对象
Zi1 z = new Zi1();
// 调用子类中的show方法
z1.show();
}
}

演示结果：
Fu num = 6
Zi num = 6

3.super访问父类成员变量

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰父类成员变量，类似于之前学过的 this 。
需要注意的是：super代表的是父类对象的引用，this代表的是当前对象的引用。
使用格式：super.父类成员变量名
子类方法需要修改，代码如下：

class Fu {
// Fu中的成员变量。
int num = 5;
}
class Zi extends Fu {
// Zi中的成员变量
int num = 6;
public void show() {
int num = 1;
// 访问方法中的num
System.out.println("method num=" + num);
// 访问子类中的num
System.out.println("Zi num=" + this.num);
// 访问父类中的num
System.out.println("Fu num=" + super.num);
}
}
class Demo04 {
public static void main(String[] args) {
// 创建子类对象
Zi1 z = new Zi1();
// 调用子类中的show方法
z1.show();
}
}

演示结果：
method num=1
Zi num=6
Fu num=5

三、继承后的特点–成员方法

1. 成员方法不重名

如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。
代码如下：

class Fu {
public void show() {
System.out.println("Fu类中的show方法执行");
}
}
class Zi extends Fu {
public void show2() {
System.out.println("Zi类中的show2方法执行");
}
}
public class Demo05 {
public static void main(String[] args) {
Zi z = new Zi();
//子类中没有show方法，但是可以找到父类方法去执行
z.show();
z.show2();
}
}
2.成员方法重名

如果子类父类中出现重名的成员方法，则创建子类对象调用该方法的时候，子类对象会优先调用自己的方法。
代码如下：

class Fu {
public void show() {
System.out.println("Fu show");
}
}
class Zi extends Fu {
//子类重写了父类的show方法
public void show() {
System.out.println("Zi show");
}
}
public class ExtendsDemo05{
public static void main(String[] args) {
Zi z = new Zi();
// 子类中有show方法，只执行重写后的show方法
z.show(); // Zi show
}
}

四、方法重写

1.概念

**方法重写 ：**子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现

2.使用场景与案例

发生在子父类之间的关系。 子类继承了父类的方法，但是子类觉得父类的这方法不足以满足自己的需求，子类重新写了一个与父类同名的方法，以便覆盖父类的该方法。
例如：我们定义了一个动物类代码如下：

public class Animal {
public void run(){
System.out.println("动物跑的很快！");
}
public void cry(){
System.out.println("动物都可以叫~~~");
}
}

然后定义一个猫类，猫可能认为父类cry()方法不能满足自己的需求
代码如下：

public class Cat extends Animal {
public void cry(){
System.out.println("我们一起学猫叫，喵喵喵！喵的非常好听！");
}
}
public class Test {
public static void main(String[] args) {
// 创建子类对象
Cat ddm = new Cat()；
// 调用父类继承而来的方法
ddm.run();
// 调用子类重写的方法
ddm.cry();
}
}
3.@Override重写注解
  • @Override:注解，重写注解校验！
  • 这个注解标记的方法，就说明这个方法必须是重写父类的方法，否则编译阶段报错。
  • 建议重写都加上这个注解，一方面可以提高代码的可读性，一方面可以防止重写出错！

加上后的子类代码形式如下：

public class Cat extends Animal {
// 声明不变，重新实现
// 方法名称与父类全部一样，只是方法体中的功能重写写了！
@Override
public void cry(){
System.out.println("我们一起学猫叫，喵喵喵！喵的非常好听！");
}
}
4.注意事项
  1. 方法重写是发生在子父类之间的关系。
  2. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
  3. 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。

五、super(…)和this(…)

1.引入

请看上节中的如下案例：

class Person {
private String name;
private int age;
public Person() {
System.out.println("父类无参");
}
// getter/setter省略
}
class Student extends Person {
private double score;
public Student() {
//super(); // 调用父类无参构造器,默认就存在，可以不写，必须再第一行
System.out.println("子类无参");
}
public Student(double score) {
//super(); // 调用父类无参构造器,默认就存在，可以不写，必须再第一行
this.score = score;
System.out.println("子类有参");
}
// getter/setter省略
}
public class Demo07 {
public static void main(String[] args) {
// 调用子类有参数构造器
Student s2 = new Student(99.9);
System.out.println(s2.getScore()); // 99.9
System.out.println(s2.getName()); // 输出 null
System.out.println(s2.getAge()); // 输出 0
}
}

我们发现，子类有参数构造器只是初始化了自己对象中的成员变量score，而父类中的成员变量name和age依然是没有数据的，怎么解决这个问题呢，我们可以借助与super(…)去调用父类构造器，以便初始化继承自父类对象的name和age.

2.super和this的用法格式

super和this完整的用法如下，其中this，super访问成员我们已经接触过了。

this.成员变量 -- 本类的
super.成员变量 -- 父类的
this.成员方法名() -- 本类的
super.成员方法名() -- 父类的

接下来我们使用调用构造器格式：

super(...) -- 调用父类的构造器，根据参数匹配确认
this(...) -- 调用本类的其他构造器，根据参数匹配确认
3.super(…)用法
class Person {
    private String name = "凤姐";
    private int age = 20;

    public Person() {
        System.out.println("父类无参");
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
// getter/setter省略
}

class Student extends Person {
    private double score = 100;

    public Student() {
//super(); // 调用父类无参构造器,默认就存在，可以不写，必须再第一行
        System.out.println("子类无参");
    }

    public Student(String name ， int age，double score) {
        super(name, age);// 调用父类有参构造器Person(String name , int age)初始化name和age
        this.score = score;
        System.out.println("子类有参");
    }
// getter/setter省略
}

public class Demo07 {
    public static void main(String[] args) {
// 调用子类有参数构造器
        Student s2 = new Student("张三"，20，99);
        System.out.println(s2.getScore()); // 99
        System.out.println(s2.getName()); // 输出 张三
        System.out.println(s2.getAge()); // 输出 20
    }
}

注意：子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。
super(…)是根据参数去确定调用父类哪个构造器的。

5.this(…)用法
  • 默认是去找本类中的其他构造器，根据参数来确定具体调用哪一个构造器。
  • 为了借用其他构造器的功能。

/**
 * this(...):
 * 默认是去找本类中的其他构造器，根据参数来确定具体调用哪一个构造器。
 * 为了借用其他构造器的功能。
 *
 */
public class ThisDemo01 {
    public static void main(String[] args) {
        Student xuGan = new Student();
        System.out.println(xuGan.getName()); // 输出:徐干
        System.out.println(xuGan.getAge());// 输出:21
        System.out.println(xuGan.getSex());// 输出： 男
    }
}
class Student{
    private String name ;
    private int age ;
    private char sex ;
    public Student() {
// 很弱，我的兄弟很牛逼啊，我可以调用其他构造器：Student(String name, int age, char sex)
        this("徐干",21,'男');
    }
    public Student(String name, int age, char sex) {
        this.name = name ;
        this.age = age ;
        this.sex = 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 char getSex() {
        return sex;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
}
6.小结
  • 子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。
  • super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。
  • super(…)和this(…)是根据参数去确定调用父类哪个构造器的。
  • super(…)可以调用父类构造器初始化继承自父类的成员变量的数据。
  • this(…)可以调用本类中的其他构造器。

七、继承的特点

  1. Java只支持单继承，不支持多继承。
// 一个类只能有一个父类，不可以有多个父类。
class A {}
class B {}
class C1 extends A {} // ok
// class C2 extends A, B {} // error
  1. 一个类可以有多个子类。
// A可以有多个子类
class A {}
class C1 extends A {}
class C2 extends A {}
  1. 可以多层继承。
class A {}
class C1 extends A {}
class D extends C1 {}

顶层父类是Object类。所有的类默认继承Object，作为父类。

捏蓝
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++多重继承二义性原理实例解析
12-17
在实际编程中，应谨慎使用多重继承，并且充分理解如何处理可能出现的二义性问题，以确保代码的可读性和正确性。学习如何使用虚继承和作用域解析运算符是解决这类问题的关键。通过掌握这些知识点，程序员可以更好地...
JavaScript 继承详解（二）
10-29
`apply`接收一个数组或类数组作为第二个参数，而`call`则需要逐一列出参数。在上面的例子中，`foo.apply(pack)`和`foo.call(pack)`都将`this`指向`pack`对象。 JavaScript中的原型链是通过`__proto__`（非标准，但...
18、继承以及继承中成员变量和成员方法的重名问题
pray1996的博客
12-04 485
继承 继承类别写法： 定义父类格式： public class 父类名称{ ​ //… } 定义子类格式：//extends 扩大；扩展 public class 子类名称 extends 父类名称{ ​ //… } 父类子类中访问成员变量的规则：（父类子类中变量重名问题） 在父子类的继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方式： 直接通过子类对象访问成员变量 规则：等号左边时谁，就优先用谁，没有则向上找 间接通过成员方法访问成员变量 规则：该方
调用getter/setter方法, 访问私有变量, 调用私有方法
jackieriver的博客
07-17 1849
/******************************************************************************* * Copyright (c) 2005, 2014 springside.github.io * * Licensed under the Apache License, Version 2.0 (the "License");...
java面向对象(二)：继承，方法重写，final关键字，抽象类，接口
lituxiu的博客
09-27 372
1、继承 在java中，所有的类都直接或间接继承Object类，Object类称为所有Java类的祖先。java中的继承是通过extends关键字操作的。通常说被继承的类叫作父类，派生的类叫做子类，通过继承后，子类可以使用父类的成员变量和成员方法。由此特点，通常在生产中把父类设计为拥有所有子类的共同属性和行为的类，即多个类中相同的内容给提取出来定义到一个类。比如人会吃饭和睡觉，那么学生和老师也会吃饭和睡觉，如下 class Person { public void s...
java学习笔记（12-继承、抽象类）
deetvu2410的博客
01-07 135
1.继承关键字extends java中继承特点： 在Java中，类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类 多个类可以继承一个父类 在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类，例如C类继承自B类，而B类又可以去继承A类，这时，C类也可称作A类的子类 子类只能获取父类非私有成员 super:可以获取父类的成员变量和成员方法,用法和thi...
黑马程序员_面向对象2
u011003171的专栏
06-20 347
一、继承 1、继承的涵义 在程序中，可以使用extends关键字可以让一个类继承另外一个类。 继承的类为子类(派生类)，被继承的类为父类(超类, 基类)。 2、什么时候使用继承 当我们需要定义一个能实现某项特殊功能的类时，就可以使用继承。 最终还是为了一个目的，实现代码的复用性。 当我们定义一个类时，发现另一个类的功能这个类都需要，而这个类又要增加一些新功能时，就可以使用exte
关于多继承
m0_63783532的博客
05-15 1769
一.什么是多继承 多继承可以看作是单继承的扩展。所谓多继承是指派生类具有多个基类，派生类与每个基类之间的关系仍可看作是一个单继承。 二. 多继承下派生类的定义格式如下：
Python的继承多态
12-20
Python的继承多态是面向对象编程中的核心概念，它们允许我们构建灵活且可复用的代码结构。在Python中，继承使一个类可以基于另一个类创建，从而获取其特性并进行扩展，而多态则是允许不同类的对象对同一消息作出响应...
Javascript玩转继承（二）
10-25
型，也就是说，如果你的子类想要继承多个父类，原型继承是无法实现的，因为一个对象的`__proto__`只能指向另一个对象，而不能同时指向多个对象。这就是所谓的单继承，也是它的一个显著局限性。 然而，JavaScript ...
字符串的值一旦被创建，就不能改变指的是字符串的内容不能发生改变。而不是字符串的引用不能发生改变。
qq_36956082的博客
04-29 2458
当 “def” 赋值给 str 的时候，原来的 “abc 就变成垃圾”！ package com.string; public class Demo_String { /* String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。 字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以...
Java中String类的值在创建后不能修改
hbhgf的博客
11-19 3418
Java中String类的值在创建后不能修改 在Java中，String类型字符串的值在创建后就不能修改。这个修改是指String对象本身的内容没有改变，因为事实上String对象内容的改变是通过内存地址的改变来完成的。 String a = "Hello"; String b = "World"; a = a + b; System.out.println(a); //Hello World 如上输出结果为“Hello World”，实际内存变化如下图所示。第二次的a会在方法区的字符串常量池中重新分配一
java 继承
yt13yt的博客
11-15 102
/** 面向对象继承 继承的好处： 1。提高代码的复用性 2。让类与类之间产生了关系，不直接支持多继承，但对c++中的多继承做出了改良 不支持多继承的原因，一个子类只能有一个父类，java支持多层继承 */ class ExtendsDemo { } class Person { String name; int age; } class Study ex...
JAVA中 继承
weixin_57219176的博客
03-25 395
* 继承： * 需要定义独立类，将其他类的共性内容抽取到独立类中，让其他类和这个独立类产生一种关系：“继承”关系 * * 继承的好处： * 1）提供了代码的复用性（代码结构清晰） * 2）提升了代码的维护性 * 3）类和类产生的这种“继承关系”，是多态的前提条件 * * 继承关系也是一种弊端，类和类产生，耦合性增强 * * 开发原则：低耦合，高内聚 * * 耦合：尽量的一个类能完成的事情一个类去完成不要产生过多的关系 * 内聚：执行某件...
matlab下载.pdf
07-14
matlab下载下载方式及注意事项
Android系统原理及开发要点详解-从入门到精通
07-13
Android系统原理及开发要点详解 Java4 Android视频教程 Android开发视频教学 从入门到精通 Android的软件管理器的开发教程视频 Android深入浅出_Android高端课程分享试听 JavaWeb Android系统的手机防盗软件的实现 Android开发入门与实战随书视频 视频列表.txt 0.0MB 开发入门与实战代码.rar 6.1MB 第9章 我来“广播”你的“意图”——Intent和Broadcast面对面.wmv 15.1MB 第8章 移动信息仓库——Android的数据存储操作之轻轻地我保护——SharedPreferences存储-2.wmv 0.6MB 第8章 移动信息仓库——Android的数据存储操作之轻轻地我保护——SharedPreferences存储-1.wmv 24.3MB 第8章 移动信息仓库——Android的数据存储操作之Android数据存储概述.wmv 57.7MB 第7章 良好的学习开端——Android基本组件介绍之友好地互动交流——对话框(Dialog)介绍与实例-2.wmv 7.
GESP等级认证 2024年6月 C++一级真题
最新发布
07-14
GESP等级认证 2024年6月 C++一级真题 从官网上刚刚下载下来的,题都是热乎的,这可是最新真题 大家看一看瞧一瞧,走过路过不要错过,免费下载,全篇无水印,不好用随便吐槽我! 涵盖选择题,判断题,编程题,基础知识多,满满的干货,非常建议下载!!!!! 萌新小白来做做题,复习巩固都很合适!
大学生创业计划书(35)三份资料.doc
07-14
大学生创业计划书(35)三份资料.doc
多重继承二义性的问题？
07-14
多重继承中的二义性问题指的是当一个派生类同时继承自两个或多个具有相同成员函数或成员变量的基类时，可能会导致成员函数或成员变量的二义性。 考虑以下示例代码： ```cpp class Base1 { public: void display()...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值