父类和子类间引用要注意的问题

父类与子类引用详解
最新推荐文章于 2025-05-14 17:36:45 发布
原创 最新推荐文章于 2025-05-14 17:36:45 发布 · 468 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

本文探讨了在Java中父类与子类之间的引用问题，特别是在数据隐藏和方法覆盖情况下的行为差异。父类引用只能访问子类继承的成员，而子类引用能访问所有成员。当子类覆盖父类方法时，父类引用调用的是子类的方法实现。

       父类和子类间引用要注意的问题(索创java上第六章)

       在发生数据隐藏的情况下(数据隐藏指子类中拥有与父类某属性相同的属性,父类的属性必须通过super才能访问到),父类和子类的声明引用的是同一个子类对象.但是父类引用访问的是隐藏的成员.父类引用不能访问子类中非继承的成员.否则会抛异常.但是子类引用可以访问子类对象从父类继承的成员.

         但是如果子类覆盖了父类的同名方法,则父类引用调用该方法时,访问的是子类方法体. 

sunnoco
关注
Java 多态（Polymorphism）---调用父类或子类方法的注意事项
Frank---7的博客
03-07 275
时，我们可以根据方法的归属来区分调用方式。在 Java 中，当。
【父类引用】转【子类引用】
wldbh的博客
10-16 267
背景 当我们想用父类引用 子类中父类没有的成员函数就必须得进行强制类型转换。 但是这还是比较复杂的 知识 强制类型转化有两种： （目标类型）被转化对象 目标类型（被转化对象） 场景 interface Area{//接口 double PI=3.14159265359; double calculateArea(); } class MyCircle implements Area{ double r; public MyCircle(double t) {//初始化 r=t; } pub
【java】父类与子类的引用赋值关系
X
07-06 3158
理清楚4个目标 父类引用（“名”） 父类对象（“实”） 子类引用 子类对象 理清楚几个操作 // 父类 public class parent{ } // 子类 public class sun{ } 父类引用指向父类对象 parent p1 = new parent(); 子类引用指向子类对象 son s1 = new son(); 3. 父类引用指向子类对象 parent p2 = new son(); 子类引用指向父类对象（错误！） son s2 = new pare
java基础之 继承 ，覆盖，super 父类引用和子类引用之间的赋值关系
qq_32174521的博客
08-06 638
// >> TODO 继承的语法就是在类名后面使用extends 加 要继承的类名 // >> TODO 被继承的类叫做父类（Parent Class），比如本例中的MerchandiseV2。 // >> TODO 继承者叫做子类（Sub Class），比如本例中的PhoneExtendsMerchandise。 // >> TODO Java中只允许一个类有一个直接的父类（Parent Class），即所谓的单继承 // >> TODO 没错.
在maven 父子项目及子项目引用问题
莫理琴的专栏
03-22 4675
在项目开发会存在这样的项目组织要求，一个父项目，几个子项目，子项目有单项引用。这样的要求反应到Maven中是怎样的呢？在maven 里互相依赖是不允许的，即只允许单项依赖。另外，正在开发中的子项目如何被另一子项目所依赖呢？这些问题可以到pom.xml得到解决。 有几个很关键的地方1 在pom.xml文件2 在引起的子模块3被依赖项目需要有java或其他文件，让maven 输
子类与父类引用遇到的问题
Dge_mei的博客
01-12 408
子类与父类遇到的问题 先展示下遇到的bug，原代码如下 package com.*****; public class Demo02 { public static void main(String[] args) { Son son=(Son) new Parent(); son.say(); } } class Parent{ public void say(){ System.out.println("我是父类中的say方法
Java中父类和子类之间的转换操作示例
08-19
在 Java 中，父类和子类之间的转换操作可以分为两种：父类引用强转成为子类引用和父类不可以强转成为子类。 一、父类引用强转成为子类引用 在 Java 中，父类引用可以强转成为子类引用。这意味着，我们可以将父类...
java父类和子类初始化顺序的深入理解
09-05
这个顺序对于理解类的初始化过程非常重要，特别是在处理复杂的继承结构时，可能包含多个父类和多个子类的构造器，以及静态和非静态初始化块。确保理解这个顺序可以帮助避免潜在的运行时错误，例如，依赖于未初始化的...
JAVA 多态操作----父类与子类转换问题实例分析
08-19
多态操作允许我们在编程中使用父类类型的引用来指向子类类型的对象，这种机制使得我们可以编写更加灵活和通用的代码。 在 Java 中，每个子类对象都是父类对象的实例，因此可以将子类对象赋值给父类变量。但是，反之...
探秘 Java 多态：父类引用指向子类对象
吾为热爱计科，致力于知识分享的践行者，此博客是我在这条道路上留下的足迹。
05-14 454
代码灵活性：可以通过父类类型统一处理不同子类对象可扩展性：新增子类时，无需修改现有代码降低耦合度：依赖抽象而非具体实现代码复用：通过继承和方法重写实现代码复用"父类的引用指向子类的对象" 是 Java 多态性的重要体现，它基于继承、方法重写和动态绑定机制，让我们能够编写出更加灵活、可扩展的代码。掌握这一特性对于理解面向对象编程思想和设计模式至关重要。在实际开发中，合理运用多态可以帮助我们构建更加优雅、健壮的软件系统。建议读者通过更多的实践案例深入理解这一概念，并探索其在设计模式中的广泛应用。
Java基础笔记
weixin_57654074的博客
12-26 815
JAVA基础笔记
父类和子类方法的调用
爱敲代码的零元
04-18 9376
由于没有找到想要的解释，于是自己就在idea上自测来寻找答案。关于父类，子类，多态之间方法的调用。
java基础：父类与子类之间变量和方法的调用
xxqi1229的专栏
10-25 1万+
1)父类构造函数 java中当调用某个类的构造方法的时候，系统总会调用父类的非静态初始化块进行初始化，这个调用是隐式的，而且父类的静态初始化代码 块总是会被执行，接着调用父类的一个或者多个构造器执行初始化，这个调用也可以通过super进行显式调用。 例如： 父类代码如下： public class Creature {//父类 {//非静态代码块 System.out.println
spring 子类和父类注入同一个属性时，子类会覆盖父类
一个专注于电子商务的人的唧唧歪歪
01-29 9826
在一期财务项目中，一个子类业务对象和父类业务对象同时注入同一个属性时，如果子类调用父类中某一个方法，如果该父类的方法引用了之前注入的属性，该属性是被子类覆盖的，也就是说在父类的上下文中，该属性是空的，暂且先不考虑代码的规范性，先通过一个简单的demo说明该问题点1、子类和父类同时注入的对象 ResourceManagerpublic class ResourceManager {  pub
父类引用指向子类对象
热门推荐
gideal_wang的专栏
12-01 3万+
父类引用指向子类对象指的是：例如父类Animal，子类Cat,Dog。其中Animal可以是类也可以是接口，Cat和Dog是继承或实现Animal的子类。Animal animal = new Cat();即声明的是父类，实际指向的是子类的一个对象。 那这么使用的优点是什么，为什么要这么用？可以用这几个关键词来概括：多态、动态链接，向上转型也有人说这是面向接口编程，可以降低
父类引用转化为子类引用
睡猫的博客
03-03 1557
对象引用实际上就是一个指针，父类的引用可以指向一个子类实例的。但是这个引用是不能调用子类扩展的方法的。 比如： Class A{     void f(){    } } Class B extends A{     void f1(){    } } A a = new (B); a.f1(); //编译不通过，因为对象A是没有f1（）方法的。 (B)a.f1(); //
//如果要在子类中调用父类的方法,则应在子类的构造方法中调用
Riak, Spark, Golang, Erlang, 云存储, 云计算, 数据挖掘
02-17 1127
//如果要在子类中调用父类的方法,则应在子类的构造方法中调用 public class six { public static void main(String[] args) { // TODO Auto-generated method stub kkk kk=new kkk(23,"dd"); } } class Base{ int age
【java0002】父类引用指向子类对象
仰望星空，脚踏实地。
04-09 522
1多态概念 多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。换句话说，实际上就是同一个类型的实例调用“相同”的方法，产生的结果是不同的。这里的“相同”打上双引号是因为这里的相同的方法仅仅是看上去相同的方法，实际上它们调用的方法是不同的。 2 理解多态，首先要知道“向上转型” 我定义了一个子类Cat，它继承了Animal类，那么后者就是前者是父类。我可以通过
Java多态 父类引用指向子类对象
weixin_34292402的博客
05-20 1342
Java多态的三个必要条件： 1、 继承 2、 子类重写父类方法 3、 父类引用指向子类对象 然后看一个例子 输出结果为： 给出结论：Father  c  =  new  Child()    在c的眼里只能看到 child 里面的 father 属性！                    当满Java多态的三个条件时，可以发现c.eat()调用的实际上是子类的eat（是因为子类重写覆盖了...
c# 比较父类和子类
最新发布
09-16
<think> 我们参考了用户提供的四个引用，这些引用主要涉及C#中父类与子类的关系，包括构造函数调用顺序、成员访问、类型转换以及集合操作。用户本次的问题是“C#中父类和子类的比较”，因此我们需要从多个维度比较父类和子类。 根据引用[1]：构造函数调用顺序是从最顶层的基类开始，逐级向下到最终的派生类。在示例中，BaseClass的构造函数先执行，然后是SubClass1，最后是SubClass1_1。 根据引用[2]：当使用父类类型引用子类对象时，只能访问父类中定义的成员（属性和方法），不能访问子类中新增的成员。例如，基类引用指向派生类对象时，无法调用派生类中新增的Methord2。 根据引用[3]：子类可以隐式转换为父类（向上转型），而父类转换为子类（向下转型）则需要显式转换，且可能抛出异常（如果父类变量实际引用的不是该子类对象）。 引用[4]则涉及从数据库中获取父类和子类的集合，但具体实现未给出，我们可以忽略其细节。 因此，我们可以从以下几个方面比较父类和子类： 1. 构造顺序 2. 成员访问 3. 类型转换 4. 方法重写（虽然引用中未明确，但这是重要比较点） 另外，我们还需要补充一些常见的比较点，如继承关系、多态性等。 下面我们逐一说明： ### 1. 构造顺序 在创建子类对象时，构造函数的调用顺序是：先调用基类的构造函数，再调用派生类的构造函数。如果类有多层继承，则从最顶层的基类开始，一直到最终的派生类。 ### 2. 成员访问 - 子类可以访问父类中非私有的成员（public, protected）。 - 当使用父类类型引用子类对象时，只能访问父类中定义的成员，不能访问子类中新增的成员（如引用[2]所示）。 ### 3. 类型转换 - 向上转换（子类转父类）：隐式转换，总是安全的。 - 向下转换（父类转子类）：需要显式转换（强制类型转换），如果父类变量实际指向的不是目标子类对象，则会在运行时抛出`InvalidCastException`。 ### 4. 方法重写（多态） 如果父类方法被标记为`virtual`，子类可以使用`override`关键字重写该方法。当通过父类引用调用该方法时，实际执行的是子类重写的方法（如果子类重写了）。这是多态性的体现。 ### 5. 继承关系 - 子类继承父类的成员（除了私有成员和构造函数），同时可以添加自己的成员。 - 子类可以隐藏父类的成员（使用`new`关键字），但这会破坏多态。 ### 6. 访问修饰符的影响 - 父类中标记为`private`的成员，子类不可访问。 - 父类中标记为`protected`的成员，子类可以访问，但外部不可访问。 ### 7. 抽象类和接口 - 抽象类（abstract class）不能实例化，只能被继承。子类必须实现抽象类中的所有抽象成员。 - 接口（interface）定义契约，子类（实现类）必须实现接口的所有成员。 ### 8. 密封类 如果父类被标记为`sealed`，则不能被继承。 ### 示例代码： ```csharp using System; public class BaseClass { public void BaseMethod() { Console.WriteLine("Base method"); } public virtual void VirtualMethod() { Console.WriteLine("Base virtual method"); } } public class SubClass : BaseClass { public void SubMethod() { Console.WriteLine("Sub method"); } public override void VirtualMethod() { Console.WriteLine("Sub override virtual method"); } } class Program { static void Main() { // 向上转换（隐式） BaseClass baseRef = new SubClass(); baseRef.BaseMethod(); // 输出: Base method baseRef.VirtualMethod(); // 输出: Sub override virtual method (多态) // baseRef.SubMethod(); // 编译错误，父类引用不能访问子类新增方法 // 向下转换（显式） if (baseRef is SubClass subRef) { subRef.SubMethod(); // 输出: Sub method } // 错误示例：如果实际对象不是SubClass，则会导致运行时错误 BaseClass anotherBase = new BaseClass(); // SubClass subRef2 = (SubClass)anotherBase; // 运行时InvalidCastException } } ``` ### 总结比较表： | 特性 | 父类 | 子类 | |--------------|------------------------------|-------------------------------| | 构造函数调用 | 在子类构造时首先被调用 | 在父类构造后调用 | | 成员访问 | 只能访问自己的成员 | 可访问自身及父类非私有成员 | | 转换方向 | 可以接受子类对象（向上转换） | 可以从父类转换（向下转换） | | 多态 | 可定义虚方法供子类重写 | 可重写父类虚方法 | | 继承 | 可以被继承 | 继承父类 | | 实例化 | 可直接实例化（非抽象类） | 可直接实例化 | 通过以上比较，我们可以看出父类和子类在C#中的主要区别和联系。 §§相关问题§§ 1. C#中如何实现父类方法在子类中的重写？ 2. 向下转型时如何避免InvalidCastException异常？ 3. 什么是C#中的密封类，它如何影响继承？ 4. 抽象类和接口在继承上有什么不同？ </think> 在C#中，父类（基类）和子类（派生类）的比较主要涉及继承关系、成员访问、类型转换和多态性等方面。以下是关键点的系统分析： --- ### 一、核心比较维度 1. **构造函数调用顺序** **规则**：子类实例化时，先调用父类构造函数，再调用子类构造函数（若存在多层继承，则从最顶层基类开始逐级调用）。 **示例**（引用[1]）： ```csharp var obj = new SubClass1_1(); // 输出顺序：BaseClass → SubClass1 → SubClass1_1 ``` 2. **成员访问权限** - **父类引用指向子类对象**： 只能访问父类定义的成员（属性和方法），无法访问子类新增成员（引用[2]）： ```csharp BaseClass obj = new ExtendClass(); obj.Methord1(); // 有效（父类方法） obj.Methord2(); // 编译错误！（子类新增方法） ``` - **子类访问父类成员**： 可直接访问父类非私有成员（`public`/`protected`）。 3. **类型转换规则** - **向上转型（子类→父类）**：隐式转换，始终安全（引用[3]）： ```csharp B child = new B(); A parent = child; // 隐式转换成功 ``` - **向下转型（父类→子类）**：需显式转换，可能抛出`InvalidCastException`： ```csharp if (parent is B validChild) validChild.b1 = "value"; // 显式转换后访问子类成员 ``` 4. **多态性（方法重写）** - 父类方法标记 `virtual`，子类用 `override` 重写： ```csharp class BaseClass { public virtual void Print() => Console.WriteLine("Base"); } class SubClass : BaseClass { public override void Print() => Console.WriteLine("Sub"); // 重写实现 } ``` - **调用行为**： ```csharp BaseClass obj = new SubClass(); obj.Print(); // 输出"Sub"（实际调用子类方法） ``` --- ### 二、关键差异总结表 | **特性** | **父类** | **子类** | |------------------------|-----------------------------------|-----------------------------------| | 构造函数调用顺序 | 优先执行 | 在父类构造函数后执行 | | 成员访问范围 | 仅限自身定义成员 | 可访问自身+父类非私有成员 | | 类型转换方向 | 可接受子类对象（向上转型） | 需显式转换才能转为父类（向下转型） | | 方法调用行为（多态） | 若未重写，执行自身逻辑 | 可重写父类虚方法，改变行为 | | 实例化限制 | 可直接实例化（非抽象类） | 可直接实例化 | --- ### 三、应用场景与注意事项 1. **设计原则**： - 遵循 **Liskov替换原则**（父类引用应能透明使用子类对象）。 - 避免过度嵌套继承（推荐组合优于继承）。 2. **集合操作**（引用[4]）： - 若需同时存储父类和子类对象，可使用父类类型集合： ```csharp List<BaseClass> list = new List<BaseClass>(); list.Add(new BaseClass()); list.Add(new SubClass()); // 合法 ``` 3. **类型检查**： - 使用 `is` 或 `as` 避免转换异常： ```csharp if (parentObj is SubClass child) child.SubMethod(); ``` ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值