关于java子类创建对象时,父类做了什么的问题 [问题点数:20分]

Bbs1
本版专家分:0
结帖率 0%
Bbs1
本版专家分:0
Bbs4
本版专家分:1110
Bbs4
本版专家分:1110
Bbs1
本版专家分:0
Bbs1
本版专家分:0
子类继承父类时,创建对象,构造方法的调用问题
在学习继承的时候,遇到一些小<em>问题</em>,这里总结一下,有错误望指正: 先来看一段代码: //标准<em>父类</em> class Father{ //成员变量 private String name; private int age; //构造方法 //空参 public Father(){ } //有参 public Father(String nam
子类创建对象
因为<em>子类</em>是继承自<em>父类</em>,所以在为<em>子类</em><em>创建对象</em>之前,其会先后的为<em>父类</em>的静态全局变量、<em>子类</em>的静态全局变量进行初始化,之后再先后为<em>父类</em>的实例全局变量、<em>子类</em>的实例全局变量进行初始化。              1.<em>子类</em>要为<em>父类</em>的私有属性单独的在堆里开辟空间,这个空间不属于任何一个对象,原因是私有属性要使用必须要有个空间,并默认初始化,不会为<em>父类</em>的私有方法在堆里开辟空间,原因是私有方法在方法区。   
Java创建子类对象时的内存分配
定义一个<em>父类</em> public class Animal { private String color; public String getColor() { return color; } public void setColor(String color) { this.color = color; } } 定义一个<em>子类</em> public class D
java中创建子类对象时会不会创建父类对象
答案是:创建<em>子类</em>对象时不会创建<em>父类</em>对象。我们创建<em>子类</em>对象时,只是说创建了<em>父类</em>空间,并进行了初始化。如果说创建<em>子类</em>的时候就会创建它的<em>父类</em>,那内存空间中不都是Object类的对象吗?(想想<em>java</em>的设计师也不会这么做的)下面转自知乎作者:祖春雷链接:https://www.zhihu.com/question/51920553/answer/128761716来源:知乎这个<em>问题</em>主要涉及到<em>java</em>对象的...
java中,创建子类对象时,父类对象会也被一起创建么?
作者:Accelerator链接:https://www.zhihu.com/question/51920553/answer/128610039来源:知乎著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。我来说句,反对桑弘毅 的第一句:”在创建<em>子类</em>对象时,首先会调用<em>父类</em>的构造器,创造一个<em>父类</em>的对象“。调用<em>父类</em>构造方法是真的,但是根本没有创建<em>父类</em>对象,只不过是调用<em>父类</em>构造方法来初...
Java之创建对象初始化顺序
创建顺序如下: <em>父类</em>静态成员(包括方法和变量,按顺序初始化) <em>子类</em>静态成员(包括方法和变量,按顺序初始化) <em>父类</em>成员变量(包括非静态代码块) <em>父类</em>构造方法 <em>子类</em>成员变量(包括非静态代码块) <em>子类</em>构造方法 验证代码: // 主类,用来创建<em>子类</em>对象,验证我们的结果 public class Main { public static void main(String[] args) { ...
浅论创建子类对象时是否创建了父类对象
浅论创建<em>子类</em>对象时是否创建了<em>父类</em>对象 这仅仅是我个人的理解,因为是初学者,所有可能存在理解错误或者不到位的情况。如果存在错误请指出,谢谢。 我们都知道在创建<em>子类</em>对象时,调用<em>子类</em>构造方法前,必须调用<em>父类</em>的构造方法。 那么调用构造方法就代表着<em>创建对象</em>了吗? 假设1: 如果创建<em>子类</em>对象没有创建<em>父类</em>对象,那么我们<em>子类</em>继承过来的属性和通过super调用的方法来自哪里? // <em>父类</em>A ...
Java____父类子类——构造代码块、方法调用顺序问题
package fatherson; //先静态初始化并且只有一次!!然后构造代码块!!再构造方法!! //声明一个继承自<em>父类</em>的<em>子类</em>时,先把<em>父类</em>的构造代码块及构造方法初始化然后初始化<em>子类</em>的构造代码块和构造方法 class Parent { public static String p_StaticField = "<em>父类</em>--静态变量"; public String p_Field = "父
创建子类对象时,父类构造函数中调用被子类重写的方法为什么调用的是子类的方法,而被子类重载的方法不会调用?
<em>问题</em>:创建<em>子类</em>对象时,<em>父类</em>构造函数中调用被<em>子类</em>重写的方法为什么调用的是<em>子类</em>的方法,而被<em>子类</em>重载的方法不会调用? public class Basic{ public void add(int i) { System.out.println("Basic add"); } public Basic() { add('a');
New一个子类对象的时候是否创建了父类的对象
首先:很坚决的说没有创建<em>父类</em>的对象!!!1.首先从<em>子类</em>到直接<em>父类</em>,依次执行<em>父类</em>的构造方法(没有显示调用构造方法的情况下),这个过程执行<em>父类</em>成员的初始化。 我仔细把书上继承那章又读了好几遍!!!书上说的很明确,“创键<em>子类</em>的对象的时候,会先调用<em>父类</em>的构造函数!会先调用<em>父类</em>构造函数!会先调用<em>父类</em>的构造函数!”(重要的事情说三遍)!!并没有说会创建<em>父类</em>的对象,没说!!!!书上其实写的很微妙!应该直接指明这
继承--关于子类对象中包含父类内容的随笔
今天老师讲到这里是走了下神,之后一直理解不到位,很难受。。。 代码及堆内的内存图如下:class A{} class B extends A{} class C extends B{} 纠结的<em>问题</em>是为什么可以访问实例成员变量,而不能访问静态的呢,后来经过老师提醒,知道堆内C的对象包含的只是普通成员变量,<em>父类</em>的方法和静态成员等都在方法区中,不写在堆中。。。调用时通过<em>父类</em>指向方法区调用ps:静态方法
子类创建对象的内存变化
         一个类可以继承另一个类,另一个类还可以继承其他类(必须有某种关联关系,满足 is-a的关系,使代码编写有意义)。那么<em>子类</em>在<em>创建对象</em>的时候内存中发生了哪些改变呢?        如下图:有三个类,分别是Son,Father以及Grandpa.他们之间是继承的关系,这里Grandpa默认继承object类。在程序执行的时候会通过类加载器判断这三个类是否已经加载,如果没有那么就讲这三个...
关于理解Java中的多态性,父类引用创建子类对象
好几次都想起这个<em>问题</em>,每次想到都要脑子里面就要思考一番今天就做一个小笔记拿百度上的一个例子<em>父类</em>A,<em>子类</em>BA a=new B();①加入A是一个接口或者抽象类,那么不可以<em>创建对象</em>,用起引用去指向其他<em>子类</em>或实现类来<em>创建对象</em>是可以的具体来说,假如一个类需要实现各种水果,香蕉,苹果等,有共同的方法eat()就必须给每一个类写一个方法public void eat(Banana banana)public ...
javaSE 多态的特性, 成员变量编译运行都取决于父类的变量值, 非静态成员方法编译看父类运行看子类
Test.<em>java</em>(测试类):package cn.xx.demo; /* * 多态中,成员特点 * * 成员变量: * 编译的时候, 参考<em>父类</em>中有没有这个变量,如果有,编译成功,没有编译失败 * 运行的时候, 运行的是<em>父类</em>中的变量值 * 编译运行全看<em>父类</em> * * 成员方法: * 编译的时候, 参考<em>父类</em>中有没有这个方法,如...
关于子类创建对象调用父类方法时this的问题(以及方法重写)
如下实例提出<em>问题</em>:class T{    T(){        System.out.println(&quot;T()&quot;);    }   void foo(){this.bar();}   void bar(){       System.out.println(&quot;T.bar&quot;);   }}class B extends T{    B(){        System.out.println(&quot;B(...
子类父类作用域的一点认识
记住一个原则:(1)通过对象调用属性,只看类型,不看对象;                      (2)通过对象调用方法,只看对象,不看类型; 举个例子: public class Father {   //<em>父类</em>     public String a = "Father";    //<em>父类</em>属性     public Father() {   //<em>父类</em>构造函数         a = "fat
java创建一个子类对象是会调用父类的构造方法会不会创建父类
1、<em>子类</em>在创建实例后,类初始化方法会调用<em>父类</em>的初始化方法(除了<em>java</em>.lang.Object类,因为<em>java</em>.lang.Object类没有<em>父类</em>),而这种调用会逐级追述,直到<em>java</em>.lang.Object的初始化方法。这个地方我说的是初始化方法,而不是构造方法,因为构造方法是相对于<em>java</em>源程序而言,而编译后的class文件是初始化方法即" "方法(红色部分为方法名),初始化方法是由<em>java</em>源程
java类的加载顺序,父类子类初始化的顺序和重写所遇到的上塑造型
类的加载顺序 什么时候类加载 第一次需要使用类信息时加载。 类加载的原则:延迟加载,能不加载就不加载。 触发类加载的几种情况: (1)、调用静态成员时,会加载静态成员真正所在的类及其<em>父类</em>。 通过<em>子类</em>调用<em>父类</em>的静态成员时,只会加载<em>父类</em>而不会加载<em>子类</em>。 (2)、第一次 new 对象的时候 加载(第二次再 new 同一个类时,不需再加载)。 (3)、加载<em>子类</em>会先加载<em>父类</em>。(覆盖<em>父类</em>方法时
java 继承创建父类对象
代码 public class A { int a=1; double d=2.0; void show(){ System.out.println(&amp;quot;Class A: a=&amp;quot;+a +&amp;quot;\td=&amp;quot;+d); } } public class B extends A{ float a=3.0f; String d=&amp;quot;Jav...
Java中,关于子类构造函数中调用父类构造函数完成对象创建的简单分析
在使用new进行对象创建时,其实是调用了其相关类的构造方法。也就是说,对象创建时,最先执行的是构造方法。若在构造方法中没有对其类中的成员变量进行初始化,则在构造方法执行完之前,即对象还没有创建完毕,其成员变量是不存在的(此处不存在指的是内存中没有此变量)。下面通过一个小例子来说明这种情况
java关于继承的问题
<em>java</em>中<em>关于</em>继承
Java为什么在实例化子类的对象时,会先调用父类的构造器
1、为什么在实例化<em>子类</em>的对象时,会先调用<em>父类</em>的构造器? 答:<em>子类</em>继承<em>父类</em>后,获取到<em>父类</em>的属性和方法,这些属性和方法在使用前必须先初始化,所以须先调用<em>父类</em>的构造器进行初始化   2、在哪里调用<em>父类</em>的构造器? 答:在<em>子类</em>构造器的第一行会隐式的调用 super();,即调用<em>父类</em>的构造器         如果<em>父类</em>中没有定义空参的构造器,则必须在<em>子类</em>的构造器的第一行显示的调用super(参数); ...
就先有父类先有子类(个人理解)
由于昨天上课讲到先有<em>父类</em>,还是先有<em>子类</em>时候,有点迷,教员老师说先有<em>子类</em>再有<em>父类</em>。但是自我感觉不太符合逻辑,老师意思是<em>父类</em>是众多<em>子类</em>抽取共性造出来的,具有便于维护,安全,更好的延伸性的特点。 但是我觉得在逻辑上是先有爹,再有儿子,而不能说大儿子,二儿子都像爹,就说先有儿子,再有爹,举例说虽然我们是某某的同学,所以先认识某某,然后某一天去其家玩,认识了其父亲,就说你啥时候生的你爹啊,和你这么像,你这
子类可以覆盖掉父类的同步方法
下面有关<em>java</em>的一些细节<em>问题</em>,描述错误的是? 如果<em>父类</em>中的某个方法使用了 synchronized关键字,而<em>子类</em>中也覆盖了这个方法,默认情况下<em>子类</em>中的这个方法并不是同步的,必须显示的在<em>子类</em>的这个方法中加上 synchronized关键字才可。 当然,也可以在<em>子类</em>中调用<em>父类</em>中相应的方法,这样虽然<em>子类</em>中的方法并不是同步的,但<em>子类</em>调用了<em>父类</em>中的同步方法,也就相当<em>子类</em>方法也同步了。
Java子类继承父类,构造方法的执行顺序问题
在Java中,<em>子类</em>实例化时会调用<em>父类</em>构造方法,<em>子类</em><em>父类</em>方法中会有一个函数生成表,执行时实现动态链接,<em>子类</em>重写<em>父类</em>方法时执行顺序也是这样    对于执行<em>父类</em>构造方法的<em>问题</em>。可以归纳为两种情况 1,如果<em>父类</em>有无参构造方法,<em>子类</em>会默认调用此方法(除非super显示调用<em>父类</em>有参)为隐式调用。 2,在<em>子类</em>中使用super显示调用<em>父类</em>有参了,或者this调用自身其他构造方法,则调用<em>父类</em>有
Java中父类子类加载顺序
最近在总结一些和JVM相关的知识,现在总结一下<em>关于</em><em>父类</em>和<em>子类</em>加载顺序的<em>问题</em>。简而言之就是先静态后非静态,先<em>父类</em>后<em>子类</em>,具体顺序如下: <em>父类</em>静态变量 <em>父类</em>静态代码块(若有多个按代码先后顺序执行) <em>子类</em>静态变量 <em>子类</em>静态代码块(若有多个按代码先后顺序执行) <em>父类</em>非静态变量 <em>父类</em>非静态代码块(若有多个按代码先后顺序执行) <em>父类</em>构造函数 <em>子类</em>非静态变量 <em>子类</em>非静态代码块(若有多个按代码先...
创建子类对象会调用父类的初始化方法,而不只是构造函数
本文转载自:http://blog.csdn.net/fpf_721521/article/details/5518753 1、<em>子类</em>在创建实例后,类初始化方法会调用<em>父类</em>的初始化方法(除了Java.lang.Object类,因为<em>java</em>.lang.Object类没有<em>父类</em>),而这种调用会逐级追述,直到<em>java</em>.lang.Object的初始化方法。 这个地方我说的是初始化方法,而不是构造方法,因
java基础部分——子类继承父类时,程序运行顺序
  先来看个例子,看看执行结果是什么:class Father{ private int m = 5; public static int n = 10; public Father(){ System.out.println(&quot;<em>父类</em>构造函数fahter&quot;+m); } static { System.out.println(&quot;<em>父类</em>静态代码块。。。。。&quot;); } { ...
java 面试题三十三 子类父类方法执行顺序的问题
. 判断以下Teacher类的main方法的运行结果(B) public class Teacher extends Person { public Teacher () { super(); } public Teacher(int a) { System.out.println (a); } public void func() { System.out.print ("2, ");
关于父类子类的初始化问题
在Java中创建一个类的对象时,如果该类存在<em>父类</em>,则先调用<em>父类</em>的构造方法,然后再调用<em>子类</em>的构造方法。如果<em>父类</em>没有定义构造方法,则调用编译器自动创建的不带参数的默认构造方法。如果<em>父类</em>定义了public的无参的构造方法,则在调用<em>子类</em>的构造方法前会自动先调用该无参的构造方法。如果<em>父类</em>只有有参的构造方法,没有无参的构造方法,则<em>子类</em>必须在构造方法中必须显式调用super(参数列表)来指定某个有参的构造方法。
new 一个没有定义构造方法的子类对象,会调用父类的默认构造方法
如题:new 一个没有构造方法的<em>子类</em>,会调用<em>父类</em>的无参构造方法。如下面的两个类:
java 中 继承抽象类,在创建子类实例的时候,构造函数创建实例了吗?
大家都知道我们在继承的情况下,如果new 一个<em>子类</em>的对象,那么就会先去调用<em>父类</em>的构造函数,那么<em>问题</em>来了,我们继承的如果是一个抽象类的话,那他是怎么创建<em>父类</em>对象呢?因为抽象类是不能<em>创建对象</em>的啊!也就是说调用构造函数就是new 对象吗?准备两个类 实现继承关系public abstract class Father { private String name; private int ...
子类调用父类构造器时的Java类成员初始化顺序
我们先看一个经典的例子: class Root{ static{ System.out.println("Root的静态初始化块"); } { System.out.println("Root的普通初始化块"); } public Root(){ System.out.println("Root的无参构造器"); } } class Mid extends Root {
new操作符具体干了什么呢?
1、创建了一个空对象,并且this变量引用该对象,同时还继承了该函数; 2、属性和方法被加入到this引用的对象中; 3、新创建的对象由this所引用,并且最后隐式的返回this。 var obj={}; obj.__proto__=Base.prototype; Base.call(obj);
Java中创建对象在内存中做了哪些事情?
Student s = new Student();//<em>做了</em>哪些事情?A:把Student.class文件加载到内存B:在栈内存给s变量开辟一个空间C:在堆内存为学生对象申请一个空间D:给成员变量进行默认初始化E:通过构造方法给成员变量进行显示初始化F:通过构造方法给成员变量进行初始化G:数据初始化完毕,然后把堆内存的地址值赋值给栈内存的s变量...
java继承中new子类对象的执行顺序
下面测试代码块,静态代码块,构造器的初始化顺序 public class TestExtends { public static void main(String[] args) { A a = new A(5); /*输出结果: * B constructor A.draw(), radius = 0 A constructor A.draw(), radius = 5
为什么在创建子类对象的时候会调用父类的构造函数
原文:Constructors of Sub and Super Class in Java? 1.为什么在创建<em>子类</em>对象的时候会调用<em>父类</em>的构造函数? public class Sub extends Super{ public Sub() { System.out.println(&quot;Sub&quot;); } public static void main(...
从对象的内存角度来理解“父类的引用指向子类的对象”
 多态中总不理解Father f = new Son()是怎么引用<em>子类</em>对象的,现在从从对象的内存角度来理解试试. 假设现在有一个<em>父类</em>Father,它里面的变量需要占用1M内存.有一个它的<em>子类</em>Son,它里面的变量需要占用0.5M内存. 现在通过代码来看看内存的分配情况: Father f = new Father();//系统将分配1M内存. Son s = new S
java关于子类实例化时调用父类无参构造方法的问题
<em>java</em>中<em>子类</em>在实例化的时候调用<em>父类</em>的无参构造方法容易混淆的大致分以下几种情况: 1、<em>子类</em>和<em>父类</em>同时具有有参和无参的构造方法,<em>子类</em>有参构造方法中第一行写的有super.(xx),且<em>子类</em>实例化时用的是有参构造方法,那么此时不会先调用<em>父类</em>的无参构造方法,而是直接调用<em>子类</em>的有参构造方法; 2、<em>子类</em>和<em>父类</em>同时具有有参和无参的构造方法,<em>子类</em>有参构造方法中第一行写的没有super.(xx),且<em>子类</em>
子类会自动调用父类的无参构造函数
今天去一个公司笔试,遇到了如下的一道题: class TestA{  public TestA(){   System.out.println("A");  } } class TestB extends TestA{  public TestB(){   System.out.println("B");  } } public class Test{  public
Java中父类子类成员变量重名的处理
Java中类成员变量的作用域为类本身。如果在<em>子类</em>中存在和<em>父类</em>相同变量名的成员变量会如何呢? 其实这些可以完全按照C语言中全局变量和局部变量的关系来处理,即局部变量会覆盖全局变量,而在超过局部变量作用域,就是全局变量起作用。 例如:              public class Parent  {                     public int x = 5;      
Java继承,子类实例化时,调用父类的无参构造方法
<em>子类</em>继承<em>父类</em>时,会继承<em>父类</em>的非私有成员变量和方法。<em>子类</em>实例化时,必须执行<em>父类</em>一系列的初始化工作,如果有多个间接<em>父类</em>,从最初的那个<em>父类</em>执行,这样,<em>子类</em>才能够拥有<em>父类</em>的成员变量和方法。<em>子类</em>实例化时总是先调用<em>父类</em>的无参构造方法示例一<em>父类</em>:Father <em>子类</em>:SonFather.<em>java</em>//package com;public class Father { private String name
C++ 父类子类调用构造函数和析构函数的顺序
2018-03-19 创建人:Ruo_Xiao 邮箱:xclsoftware@163.com 建立对象时,会先调用<em>父类</em>的构造函数再调用<em>子类</em>的构造函数。 销毁对象时,会先调用<em>子类</em>的析构函数再调用<em>父类</em>的析构函数 ...
java 用户自定义的父类转换成子类的方法
在工作中,一般是实体类对应的数据库表,另外再定义一个Model继承实体类,在model里往往添加一些辅助的属性。我们从数据库查出的数据放在实体类里,但是展现数据时需要用到model类,这时就需要把实体类转换成Model类。<em>父类</em>不可能强制转换成<em>子类</em>,所以写了一个通用的方法,适用于这种场景下的转换,代码如下: /** * 通过public的 get set方法进行复制,适合用于<em>父类</em>
Java中静态代码块、构造方法、代码块、父类子类之间执行顺序及父类子类实例化对象
PS:今天群里一个小伙伴笔试,匆匆发来的求助信息。。。1.<em>父类</em>、<em>子类</em>之间代码块与构造方法public class HelloA { public HelloA(){ System.out.println(&amp;amp;amp;amp;amp;amp;amp;amp;amp;quot;HelloA&amp;amp;amp;amp;amp;amp;amp;amp;amp;quot;); } {System.out.println(&amp;amp;amp;amp;amp;
Java中子类父类的构造函数?
这篇文章总结了<em>关于</em>Java构造的常见​​<em>问题</em>。 1)为什么创建一个<em>子类</em>对象要也需要调用<em>父类</em>的构造函数? class Super { String s; public Super(){ System.out.println("Super"); } } public class Sub extends Super { public Sub(){
关于java子类方法覆盖(Override)父类方法时,该子类方法返回值的问题
<em>关于</em><em>java</em><em>子类</em>方法覆盖(Override)<em>父类</em>方法时,该<em>子类</em>方法返回值的<em>问题</em> <em>java</em>   edwardchu 2016年09月12日提问 · 2016年09月12日更新 关注 4 关注 收藏 0 收藏,1.1k 浏览 <em>问题</em>对人有帮助,内容完整,我也想知道答案 0 <em>问题</em>没有实际价值,缺少关键内容,没有改进余地
java中实例化子类时会不会调用父类的构造方法?
<em>子类</em>不会继承<em>父类</em>的构造方法(这里说的不能继承是说,构造方法不能在<em>子类</em>中被覆写,有时候说的“继承”<em>父类</em>的构造方法是说<em>子类</em>的构造方法调用<em>父类</em>的构造方法。),但是<em>子类</em>在实例化对象时:如果<em>子类</em>的构造器没有显示的调用超类的方法,则将自动调用超类默认构造器(<em>子类</em>构造器中默认是有super()的(可以使用super(参数)调用有参构造),所以会调用<em>父类</em>构造方法,如果是this()就不会调用了,他们两个不能同时存
Java核心技术试题
一、不定向选择题(共30题,每题2分,共60分) 1、为了区分重载多态中同名的不同方法,要求( )。 A) 采用不同的参数列表 B) 返回值类型不同 C) 调用时用类名或对象名做前缀 D) 参数名不同 2、定义主类的类头时可以使用的访问控制符是( )。 A) private B) protected C) public D) private protected
Java基础:抽象类和抽象方法
一.Java抽象类概念:在面向对象的概念中,所有的对象都是通过类来描述的,但是反过来,并不是所有的类都是用来描述对象的,如果一个类中没包含足够的信息来描述一个具体的对象,这样的类就是抽象类。理解:对象跟类相互依赖,Java通过类来<em>创建对象</em>,类用来描述对象。抽象类除了不能实例化对象之外,类的其他功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。理解:抽象类不能实例化对象,但是可以作为...
子类父类定义相同的方法和属性的解析:
<em>子类</em>和<em>父类</em>定义相同的方法只要符合方法覆盖的条件:<em>子类</em>和<em>父类</em>定义相同属性不会产生覆盖:解析:这个<em>问题</em>不仅要考虑变量、静态变量和常量三种情况,还要考虑private、friendly(即不加访问修饰符)、protected和public四种访问权限下对属性的不同影响,private的变量与其它三种访问权限变量的不同,对象无法直接访问私有变量。<em>子类</em><em>父类</em>定义相同get,set方法的引起重写(override)。结论:由于private变量受访问
thread08 - 子类中调用父类的同步方法
package com.neutron.t08; import <em>java</em>.util.concurrent.TimeUnit; /** * <em>问题</em>:<em>子类</em>的同步方法是否可以调用<em>父类</em>的同步方法 */ public class T08 { protected synchronized void hello() { System.out.println("parent hel
Java父类子类的关系
一、<em>父类</em>引用指向<em>子类</em>对象时 若<em>子类</em>覆盖了某方法,则<em>父类</em>引用调用<em>子类</em>重新定义的新方法 若<em>子类</em>未覆盖某方法,则<em>父类</em>引用调用<em>父类</em>本身的旧方法 若<em>子类</em>覆盖了某属性,但<em>父类</em>引用仍调用<em>父类</em>本身的旧属性 若<em>子类</em>未覆盖某属性,则<em>父类</em>引用调用<em>父类</em>本身的旧属性 <em>父类</em>引用不能访问<em>子类</em>新定义的方法 二、<em>子类</em>引用指向自身对象时 若<em>子类</em>覆盖了某方法,则<em>子类</em>引用调用<em>子类</em>重新定义的新方法 若<em>子类</em>未覆盖某方法,则子...
Java 中子类重写父类的方法时声明抛出异常不能比父类范围大
在<em>java</em> 中,当我们<em>子类</em>要重写<em>父类</em>中的方法,如果<em>父类</em>的方法有异常声明,那么<em>子类</em>重写这个方法时候,所要声明的异常不应该比<em>父类</em>的大。只能是小等,或者可以没有。原因如下。  假如我们自定意义一个异常:  public class MyException extends Exception {  public MyException(String message) {  }  public
java子类父类的同名变量覆盖问题
变量,或者叫做类的属性,在继承的情况下,如果<em>父类</em>和<em>子类</em>存在同名的变量会出现什么情况呢?这就是这道题要考查的知识点——变量(属性)的覆盖。 这个<em>问题</em>虽然简单,但是情况却比较复杂。因为我们不仅要考虑变量、静态变量和常量三种情况,还要考虑private、friendly(即不加访问修饰符)、protected和public四种访问权限下对属性的不同影响。
Java——父子实例的内存情况解析
众所周知,在Java中,一个非final类可以被其他类所继承,同时<em>子类</em>将拥有<em>父类</em>的实例变量和实例方法,而且<em>子类</em>还可以重写<em>父类</em>中的方法。但当<em>子类</em>中存在和<em>父类</em>同名的变量和方法时,分别用<em>父类</em>类型的变量、<em>子类</em>类型的变量去调用对象的实例变量和方法时,会有怎样的结果呢? 我们不妨来做个试验:定义一个Base类(<em>父类</em>),在其中声明一个实例变量和实例方法;同时定义一个Sub类(<em>子类</em>),在其中声明与<em>父类</em>中相同的实例
父类子类中存在同一个成员变量
<em>父类</em>和派生的<em>子类</em>存在同一个成员变量名,是如何分配内存空间的? 在vs编译器中可以将源文件配置好后,看到内存布局:具体方法就是在vs的c++项目的属性中,添加/d1 reportAllClassLayout,注意添加到C/C++项目下的命令行中,不要放在链接器下的命令行中,否则会报错而且看不到内存布局。这样上面这个<em>问题</em>就可以直接看到了:#include "stdafx.h"class Base {
java异常类子类父类的关系
<em>java</em>异常类<em>子类</em>和<em>父类</em>的关系 在<em>java</em> 中,当我们<em>子类</em>要重写<em>父类</em>中的方法,如果<em>父类</em>的方法有异常声明,那么<em>子类</em>重写这个方法时候,所要声明的异常不应该比<em>父类</em>的大。只能是小等,或者可以没有。原因如下。 假如我们自定意义一个异常:    public class MyException extends Exception { public MyException(String
关于PHP中构造函数以及子类继承父类构造函数的相关问题
<em>关于</em>PHP中构造函数以及<em>子类</em>继承<em>父类</em>构造函数的相关<em>问题</em>这几天一直在看php与mysql程序设计,在看到面向对象用法是发现一个<em>问题</em> 书上的代码是这样的:<?php class Employess { protected $name; protected $title; function _construct() {
创建子类对象调用父类构造器
从第一段代码中可以看出,在创建<em>子类</em>对象时候,如果<em>子类</em>的构造函数没有显示调用<em>父类</em>的构造函数,则会调用<em>父类</em>的默认无参构造函数 从第二段代码中可以看出,在创建<em>子类</em>对象时候,如果<em>子类</em>的构造函数没有显示调用<em>父类</em>的构造函数且<em>父类</em>自己提供了无参构造函数,则会调用<em>父类</em>自己的无参构造函数。 为什么这个时候会调用自己的,而不调用默认的?是不是因为<em>父类</em>一旦定义了自己的无参构造函数,就重写了其<em>父类</em>object提供
java,子类继承父类,在子类中,用this和super调用父类方法有什么区别
当有相同的属性或者方法是this<em>子类</em>表示调用自己的属性或者方法, super调用<em>父类</em>的属性或者方法。 当<em>子类</em>调用的属性方法在<em>子类</em>中不存在时,那么this和super都是调用<em>父类</em>的属性或者方法...
关于子类父类中的this的用法
在看毕向东<em>java</em>视频的时候,多态这一章讲到了一段代码: public class Demo { public static void main(String[] args) { Fu f = new Zi(); f.show(); } } class Fu { int num = 1; void show() { System.out.println(this.num)
java中super的作用及子类对象的创建过程
1.super 可以用于在<em>子类</em>方法中调用<em>父类</em>的方法(被覆盖的也可以调用) 相当于this,只不过只在<em>子类</em>的方法中使用 2.<em>子类</em>对象的创建 在创建<em>子类</em>对象时,调用<em>子类</em>构造器时,会先调用<em>父类</em>的无参构造器。(所以在一般定义类时都会先定义一个无参构造器,以便于继承。)如图: 创建<em>子类</em>对象时 在此段代码中,如果<em>父类</em>中没有无参构造器,则会报错。
构造器是静态方法吗?New一个子类对象的时候是否创建了父类的对象
在thinking in <em>java</em>中,第96页提到,“即使没有显示地使用static关键字,构造器实际上也是静态方法“,对此我产生了疑惑,于是找相关资料进行确认,在一篇大神的博客中得到了答案,那就是构造器不是静态方法。主要是以下几点原因:Java虚拟机规范第二版中定义了四种不同的字节码指令来处理Java程序中不同种类的方法的调用:· invokestatic - 用于调用类(静态)方法 · inv...
Java 理解 子类成员变量与父类成员变量同名 方法的重写
Java 理解 <em>子类</em>成员变量与<em>父类</em>成员变量同名 方法的重写
JAVA new子类的时候是否会创建父类
JAVA new<em>子类</em>的时候是否会创建<em>父类</em> <em>问题</em>: 学习<em>java</em>基础的记得自己死记硬背这句话: <em>子类</em>创建的时候,会先隐式调用<em>父类</em>无参数构造方法(如果<em>父类</em>没有构造方法,系统则会给<em>父类</em>默认添加无参构造) 自己测试过,如果<em>父类</em>有参构造,没有无参构造,<em>子类</em>必须显示调用<em>父类</em>有参构造 结论:<em>子类</em>必须调用<em>父类</em>的构造方法 <em>问题</em>: 调用<em>父类</em>构造方法==new <em>父类</em>? 理论分析 从类的加载过...
Java关于子类父类私有方法覆盖的问题
最近在学习到Java的继承和多态时遇到了这样的一个<em>问题</em>:<em>关于</em>继承链中<em>子类</em>对<em>父类</em>的私有方法是否可以覆盖的<em>问题</em>,在此记录一下自己对这个<em>问题</em>解决以后的一些心得。
父类子类出现重名变量
#include &amp;lt;iostream&amp;gt; using namespace std; class Parent { public: Parent(int a) { this-&amp;gt;a = a; } int a; }; class Child: public Parent { public: Child(int p_a, int c_a): Parent(p_a) ...
java 父类引用指向子类对象---动态绑定之易错点详解
知识点: 1、<em>java</em> 中<em>父类</em>引用指向<em>子类</em>对象时动态绑定针对的只是<em>子类</em>重写的成员方法; 2、<em>父类</em>引用指向<em>子类</em>对象时,<em>子类</em>如果重写了<em>父类</em>的可重写方法(非private、非 final 方法),那么这个对象调用该方法时默认调用的时<em>子类</em>重写的方法,而不是<em>父类</em>的方法; 3、对于<em>java</em>当中的方法而言,除了final,static,private 修饰的方法和构造方法是前期绑定外,其他的方法全部为动态
JAVA基础(一):面向对象之接口与继承以及子类父类的相互转换
面向对象的编程思想,通过将现实世界的个体种类抽象成类(class),个体抽象成对象(object),个体与个体之间的关系抽象成继承(inheritance),让开发人员能够以符合正常思维的方式进行程序设计,提高了效率。
java父类构造函数调用子类覆盖方法
原文链接:http://blog.csdn.net/zhuoaiyiran/article/details/19489745 参考:http://blog.csdn.net/bettarwang/article/details/26160183 1.如果<em>父类</em>构造器调用了被<em>子类</em>重写的方法,且通过<em>子类</em>构造函数创建<em>子类</em>对象,调用了这个<em>父类</em>构造器(无论显示还是隐式),就会导致<em>父类</em>在构造时实际上
子类调用父类默认构造函数
对文件名为Test.<em>java</em>的<em>java</em>代码描述正确的是() class Person { String name = "No name"; public Person(String nm) { name = nm; } } class Employee extends Person { String empID = "0000"; publ
对于父类的私有属性,子类是从哪里访问到的?
其实也是牵扯到<em>子类</em>继承<em>父类</em>时,<em>父类</em>的private属性在<em>子类</em>中是什么样的<em>问题</em>。 根据JAVA官方的定义: A subclass does not inherit the private members of its parent class. However, if the superclass has public or protected methods for accessing its
[java][31]子类重写父类加@Override注解
<em>java</em>小白的学习记录......       如果<em>子类</em>重写<em>父类</em>的方法,在<em>子类</em>方法前面加上@Override, 系统可以检查<em>子类</em>方法的参数是否与<em>父类</em>一致,在编译期尽早发现错误。实例:1)<em>父类</em>public class SeniorClass { public String toString() { return &quot;Senior&quot;; }}2)<em>子类</em>public class JuniorClass e...
JAVA在子类中访问父类的私有属性
因私有成员变量无法被外界所访问,所以在<em>子类</em>中无法直接获取<em>父类</em>中的私有成员变量,此时可以通过在<em>父类</em>中添加获取方法进行获取。class F { private int num =1; public int getnum() { return num; } } class S { System.out.println(super.getnum());
(Java重写/覆盖)子类的方法访问权限比父类
https://zhidao.baidu.com/question/480340728.html 因为 向上转型及<em>java</em>程序设计维护的原因 例: 假设一个<em>父类</em>A 拥有的方法 public void setXXX(){} 可以被其他任意对象调用 这个方法被<em>子类</em>B 覆写后 为 void setXXX(){} 即 默认的 访问权限 只能被本包极其<em>子类</em> 所访问 假设 其他包中的对象 C 调用 方法为:...
java子类重写父类方法要注意的问题
<em>子类</em>不能重写<em>父类</em>的静态方法,私有方法。即使你看到<em>子类</em>中存在貌似是重写的<em>父类</em>的静态方法或者私有方法,编译是没有<em>问题</em>的,但那其实是你重新又定义的方法,不是重写。具体有关重写<em>父类</em>方法的规则如下: 重写规则之一:重写方法不能比被重写方法限制有更严格的访问级别。 (但是可以更广泛,比如<em>父类</em>方法是包访问权限,<em>子类</em>的重写方法是public访问权限。)比如:Object类有个toString()方法,开始
Java之调用被子类重载的方法
有一种特殊的重写方法,就是当<em>子类</em>重写<em>父类</em>方法,<em>父类</em>表面上只是调用属于自己的、被<em>子类</em>重写的方法,但随着contex的执行改变,将会变成<em>父类</em>直接调用<em>子类</em>的方法。 public class Animal { private String desc; public Animal() { System.out.println("Animalgouzao"+desc); // TODO Aut
java之中的四种访问权限和子类如何继承父类特性
Public:对所有类可见 Protected:对同一包中的类,和<em>子类</em>可见 Private:仅对类本身可见         Default:对同一包中的类可见 为了理解方便,可见的意思也就是可以使用这个特性(域,方法,类),对<em>子类</em>可见就是<em>子类</em>也具有这些特性。但是继承的时候,<em>子类</em>从父亲继承来的那些东西,他们的权限仍然是保持不变的,<em>子类</em>是具有这些特性,但是你能不能使用<em>子类</em>的这些特性,取决于这些
java基础之继承extends,以及子类实例化过程
本例子是继承、<em>子类</em>实例化的过程的例子 继承: 1、<em>java</em>只支持单继承,不允许多继承 2、使用继承是为了减少重复代码 3、继承,即<em>子类</em>得到了<em>父类</em>的所有成员变量和成员函数。 <em>子类</em>实例化过程: super关键字的用法。 1、在<em>子类</em>的构造函数中,必须调用<em>父类</em>的构造函数 2、若<em>子类</em>构造函数当中没有主动调用<em>父类</em>的构造函数,编译器会默认加上一行super()来调用<em>父类</em>的构造函数; 3
父类子类的静态代码块、代码块、构造方法执行顺序
StaticTest.<em>java</em>package com.staticTest; /** * 测试静态代码块执行顺序 * 1、static能修饰的类只有静态内部类 * 2、静态方法不能直接访问非静态成员(方法,成员变量) * 3、静态代码块在类加载的时候,就直接加载,且只执行一次 * 4,执行顺序:<em>父类</em>静态代码块与静态成员 * <em>子类</em>静态代码块与静态成员 *
java子类继承父类的属性说明
先看一段代码: 定义<em>父类</em>: 定义<em>子类</em>1: 定义<em>子类</em>2: 测试类: 运行结果为: 可以看出,用<em>父类</em>实例化,<em>子类</em>对象继承<em>父类</em>对象的属性值,<em>子类</em>构造函数中不super()也没用。若想不继承<em>父类</em>的属性,直接用<em>子类</em>进行实例化。 这样的情况建议使用abstract抽象类,不关注<em>子类</em>的实现,只声明,不实现。...
Java继承时,父类中的this指向子类对象
代码如下 <em>父类</em> public class Car { public void fool() { System.out.println("Car:fool1"); } public void foo2() { this.fool(); System.out.println("Car:fool2"); } } <em>子类</em> public class
Java中父类子类的加载顺序详解
最近准备换工作,好久没笔试面试的我,就网上找了点大家分享的题随便看了看。然后就看到有<em>关于</em>Java中<em>父类</em>与<em>子类</em>的加载顺序的题,出简单点的就出选择题,出复杂的就出成简答题了。说句实话,在实际开发工作中,好像用不到(也许是我技术不到家,所以没用到吧)但是为了应付笔试还是得了解。开始正题吧。
java子类继承父类时是否继承构造函数呢?
<em>java</em>继承中对构造函数是不继承的。以下是例子: public class FatherClass { public FatherClass() {       System.out.println(100); } public FatherClass(int age) {      System.out.println(age); }} public class SonC
当一个方法只在父类中定义时,调用该方法时会使用父类中的属性
class Father { private String name = "Father"; public String getName() { return name; } } class Child extends Father{ private String name = "child"; public static void main(
java中catch子句的排列是子类在前还是父类在前?为什么呢
对于catch子句的排列,下列哪种是正确的() A.<em>父类</em>在先,<em>子类</em>在后 B.<em>子类</em>在先,<em>父类</em>在后 C.有继承关系的异常不能在同一个try程序段内 D.先有<em>子类</em>,其他如何排列都无关选B<em>子类</em>在前,因为是顺序执行嘛,如果你把<em>父类</em>放前面就执行不到后边的了,比如你把Exception放到第一位,那么后面的就不会得到执行了,而且通常<em>子类</em>的信息比<em>父类</em>的要更精准一点,所以通常都是<em>子类</em>放前面...
java 序列化 父子类
环境 <em>java</em>:1.7+ 前言 今天读了这篇文章,一篇译文: 我下面的讲解就是基于这篇文章 Java序列化示例教程 到了晚上又看到了这么一篇文章: Java 序列化的高级认识 中的对敏感字段加密 突然对其中某段代码产生了兴趣;现在记录下 回顾 我先记录下我今天看到的知识,看看我记住多少! 1、序列化本质其实就是 对象 –&amp;gt; 二进制,目的为了存储或者网络传输 ...
子类继承父类,构造函数的特点 super()
在对<em>子类</em>进行初始化时候,<em>父类</em>的构造函数一定会运行 因为<em>子类</em>的构造函数第一行里面有个隐式语句super();<em>子类</em>的所有构造函数默认第一行都有句super(); <em>子类</em>调用<em>父类</em>构造函数super(参数),<em>子类</em>调用<em>父类</em>一般方法:super.方法名 <em>子类</em>一定要访问<em>父类</em>? 因为<em>父类</em>的数据<em>子类</em>可以直接获取,所以当<em>子类</em>对象建立时候,需先查看<em>父类</em>如何对这些数据初始化, 1.当<em>父类</em>中有个空参数的构造函数时候
Java中父类子类static静态方法和非静态方法以及构造方法的执行顺序
执行顺序:<em>父类</em>静态块--&amp;gt;<em>子类</em>静态块--&amp;gt;<em>父类</em>非静态块--&amp;gt;<em>父类</em>构造方法--&amp;gt;<em>子类</em>非静态块--&amp;gt;<em>子类</em>构造方法      当<em>父类</em>或<em>子类</em>中有多个静态方法时按在代码中的顺序执行 public class Father { static { System.out.println(&quot;Father中的静态块:1&quot;); } static { System...
为什么在实例化子类的对象的时候会调用先调用父类的构造函数
1、为什么在实例化<em>子类</em>的对象的时候会调用先调用<em>父类</em>的构造函数? 答:因为<em>子类</em>继承<em>父类</em>之后,获取到了<em>父类</em>的内容(属性/字段),而这些内容在使用之前必须先初始化,所以必须先调用<em>父类</em>的构造函数进行内容的初始化. 2、在什么地方调用基类的构造函数? 答:在<em>子类</em>的构造函数中的第一行会隐士的调用 super();子句,即调用了<em>父类</em>的构造函数 如果<em>父类</em>里面没有定义参数为空的构造函数,那么必须在<em>子类</em>的构造
Java基础之异常Exception---异常在子父类覆盖中的体现
ps:案例来源于毕向东老师Java基础教程异常在子<em>父类</em>覆盖中的体现注意: 1,<em>子类</em>在覆盖<em>父类</em>时,如果<em>父类</em>的方法抛出异常,那么<em>子类</em>的覆盖方法,只能抛出<em>父类</em>的异常或者该异常的<em>子类</em>。 2,如果<em>父类</em>方法抛出多个异常,那么<em>子类</em>在覆盖该方法时,只能抛出<em>父类</em>异常的子集。 3,如果<em>父类</em>或者接口的方法中没有异常抛出,那么<em>子类</em>在覆盖方法时,也不可以抛出异常。 如果<em>子类</em>方法发生了异常。就必须要进行
多态的执行究竟是父类的还是子类的?
首先Java实现多态有三个必要条件:继承、重写、向上转型。          继承:在多态中必须存在有继承关系的<em>子类</em>和<em>父类</em>。          重写:<em>子类</em>对<em>父类</em>中某些方法进行重新定义,在调用这些方法时就会调用<em>子类</em>的方法。          向上转型:在多态中需要将<em>子类</em>的引用赋给<em>父类</em>对象,只有这样该引用才能够具备技能调用<em>父类</em>的方法和<em>子类</em>的方法。 然后就是多态中的执行<em>问题</em>了,我们可以用一句话来
java子类继承父类时,是否继承构造函数
<em>java</em>继承中对构造函数是不继承的,只是调用(隐式或显式)。以下是例子: 1、<em>子类</em>隐式的调用父的构造函数 public class FatherClass { // 无参的构造函数 public FatherClass() { System.out.println("我是<em>父类</em>无参数的构造方法:" + 100); } //有参的构造
面试题之父类子类执行顺序部分
面试题之<em>父类</em>和<em>子类</em>执行顺序部分
文章热词 Java 双目视觉问题 特征点问题 相机标定问题 最优化问题
相关热词 c#关于子类构造函数 c++ 关于unique的问题 c++ 在子类初始化父类 c#子类父类类型转换 学习python时遇到的问题 python学什么的
我们是很有底线的