java 父类引用子类对象时编译器报错 [问题点数:50分,结帖人weixin_39982772]

Bbs1
本版专家分:0
结帖率 50%
Bbs1
本版专家分:50
java父类引用指向子类对象
继承和方法重写已经很熟悉了,这次 主要验证一下,当一个<em>父类</em>的<em>引用</em>指向一个<em>对象</em>的时候,它会调用<em>子类</em>的方法,而不是<em>父类</em>的。 <em>引用</em>在栈内存中存在<em>对象</em>的内存地址。真正的<em>对象</em>(通过 new Student()创建的)存放在堆内存里。 在这块堆内存区域内,存在的是<em>子类</em>的属性(包括自己特有的,以及通过super()构造方法中从<em>父类</em>获得的) 和方法(继承<em>父类</em>但没有覆盖的,以及覆盖<em>父类</em>的方法和自己特
父类引用指向子类对象之属性
多态
Java多态的理解--父类引用指向子类对象
1、定义:在程序中定义的某个<em>引用</em>变量具体所指向的类型和调用的方法在编码时并不能确定,而只有在运行的时候才能确定。   2、简单理解:你定义的<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 父类引用指向子类对象---动态绑定之易错点详解
知识点: 1、<em>java</em> 中<em>父类</em><em>引用</em>指向<em>子类</em><em>对象</em>时动态绑定针对的只是<em>子类</em>重写的成员方法; 2、<em>父类</em><em>引用</em>指向<em>子类</em><em>对象</em>时,<em>子类</em>如果重写了<em>父类</em>的可重写方法(非private、非 final 方法),那么这个<em>对象</em>调用该方法时默认调用的时<em>子类</em>重写的方法,而不是<em>父类</em>的方法; 3、对于<em>java</em>当中的方法而言,除了final,static,private 修饰的方法和构造方法是前期绑定外,其他的方法全部为动态
Java 关于多态中,父类引用子类对象中的“引用”解释,释义
首先,你要明白什么是变量,变量的实质是一小块内存单元,这一小块内存里存储着变量的值。 比如int a = 1; a就是变量的名名,1就是变量的值。 而当变量【变量名】指向一个<em>对象</em>时,这个变量就被称为<em>引用</em>变量 比如A a =new A(); a就是<em>引用</em>变量,它指向了一个A<em>对象</em>,也可以说它<em>引用</em>了一个A<em>对象</em>。我们通过操纵这个a来操作A<em>对象</em>。 此时变量a的值为它所<em>引用</em><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中子类继承父类必须调用父类的构造方法?
刚睡完午觉起来,有点迷糊,然后接着练习Java中元组(tuple)的时候突然就遇到这么个问题,关于继承的问题,奇怪在睡觉之前怎么就没发现这个问题呢,传说中的“面向睡一觉编程”吗。。。Orz先贴上代码: 首先是创建一个<em>父类</em>文件TwoTuple.<em>java</em>package test.fifth;public class TwoTuple { public A first; pu
java中的多态问题,即父类引用子类对象
<em>java</em>多态,如何理解<em>父类</em><em>引用</em>指向<em>子类</em><em>对象</em> 要理解多态性,首先要知道什么是“向上转型”。         我定义了一个<em>子类</em>Cat,它继承了Animal类,那么后者就是前者是<em>父类</em>。我可以通过   Cat c = new Cat(); 实例化一个Cat的<em>对象</em>,这个不难理解。         但当我这样定义时:   Animal a = new Cat();   表示定义了一个Animal类型的...
父类引用指向子类对象 成员变量继承问题
package chapter_03.step_03;/** * 当<em>父类</em><em>引用</em>指向<em>子类</em><em>对象</em>    成员变量继承问题 * @author Administrator * */public class Test02 { public static void main(String[] args) { Parent p = new Child(); Child c = new Child(); Sy...
父类引用指向子类对象怎么调用子类的方法
多态。 如果说<em>父类</em>中有这个属性跟方法,<em>子类</em>有重写过,那么调用的是<em>子类</em>中的属性跟方法。 如果<em>父类</em>中没有这个属性跟方法,那么<em>子类</em>调用就会出错。 如果<em>父类</em>有这个属性跟方法,而<em>子类</em>没有,则调用的是<em>父类</em>的属性跟方法。
java继承实质、父类引用指向子类对象(多态)、声明时类型、运行时类型
继承是面向<em>对象</em>的三大特征(封装、继承和多态)之一,也是<em>java</em>语言的重要特性。 那么,继承<em>父类</em>的成员变量和继承<em>父类</em>的方法有什么区别吗?答案是肯定的。有的人甚至都不知道这个问题的存在。 继承成员变量和继承方法的区别: 可能大家都认同 “当<em>子类</em>继承<em>父类</em>时,<em>子类</em>会获得<em>父类</em>中定义的成员变量和方法,当访问权限允许的情况下,<em>子类</em>可以直接访问<em>父类</em>的变量和方法”。这种观点其实稍显笼统,因为jav
Java 父类引用指向子类对象有啥用 总结
你可能会写如下2个方法feed(Cat cat){    }feed(Dog dog){    }如果Cat、Dog都是Animal的<em>子类</em>,那你就可以写成feed(Animal animal){    }Animal a1=new Dog();    //<em>父类</em><em>引用</em>指向<em>子类</em><em>对象</em>Animal a2=new Cat();feed(a1);feed(a2);有人说这是面向接口编程,可以降低程序的耦合性,即...
JAVA父类引用指向子类对象是什么意思?有什么作用?
转自:http://zhidao.baidu.com/question/397089741.html JAVA<em>父类</em><em>引用</em>指向<em>子类</em>的<em>对象</em>是什么意思?有什么作用? 给你举个简单的例子吧。类A,另外一个类B继承了类A。有如下代码: A a = new B() ; 这就称<em>父类</em>的<em>引用</em>a 指向了<em>子类</em>的<em>对象</em>new B(),就是这个意思。 追问: 有什么用呢?
关于父类引用指向子类对象(A a = New B();)的使用,理解向上转型
首先什么是向上转型?       向上转型是JAVA中的一种调用方式,是多态的一种表现。向上转型并非是将B自动向上转型为A的<em>对象</em>,相反它是从另一种角度去理解向上两字的:它是对A的<em>对象</em>的方法的扩充,即A的<em>对象</em>可访问B从A中继承来的和B复写A的方法,其它的方法都不能访问,包括A中的私有成员方法。 我们举个例子,看下面的代码: class Animal{ public void
Java多态 父类引用指向子类对象
原文地址http://www.cnblogs.com/111testing/p/6880831.html Java多态的三个必要条件: 1、 继承 2、 <em>子类</em>重写<em>父类</em>方法 3、 <em>父类</em><em>引用</em>指向<em>子类</em><em>对象</em> 然后看一个例子 输出结果为: 给出结论:Father  c  =  new  Child()    在c的眼里只能看到 child
父类引用指向子类对象,为什么会调用的是子类中重新的方法
老毕的"编译看左边,运行看右边"(多态执行)   (对面向<em>对象</em>语言中理解多态、继承很有帮助~~~)   老毕在讲到多态执行问题时,结合下面的例子,给我们总结了一套口诀:“成员变量,静态方法看左边;非静态方法:编译看左边,运行看右边。”意思是:当<em>父类</em>变量<em>引用</em><em>子类</em><em>对象</em>时(Fu f = new Zi(); ),在这个<em>引用</em>变量f指向的<em>对象</em>中,他的成员变量和静态方法与<em>父类</em>是一致
java多态性详解——父类引用子类对象
<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><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>或者在<em>子类</em>内部只能访问<em>子类</em>的同名成员;但是<em>父类</em>的成员仍然存在),是指当<em>子类</em>中有和<em>父类</em>同名的成员变量时,此时<em>子类</em>中有两个名字相同的
Java父类引用指向子类实例的用法
1.适合使用(<em>父类</em><em>引用</em>指向<em>子类</em>实例)的情况: <em>父类</em>是接口 接口有多个实现类,通过接口<em>引用</em>可以指向任何一个实现类,调用其方法,实现多态,传递参数时可以使用 2.不适合使用(<em>父类</em><em>引用</em>指向<em>子类</em>实例)的情况: <em>父类</em>不是接口,封装了一批公共方法,便于<em>子类</em>调用 ...
关于父类引用指向子类对象的那些事
废话不多说,先上代码:public class Father { static int b=7; int a=5; public void say(){ System.out.println("父亲say"); } public void write(){ System.out.println("父亲write");
深入理解父类变量引用子类对象
从<em>对象</em>的内存角度出发 假设现在有一个<em>父类</em>Father,它里面的变量需要占用1M内存.有一个它的<em>子类</em>Son,它里面的变量需要占用0.5M内存. 现在通过代码来看看内存的分配情况:(假设<em>子类</em>继承<em>父类</em>所有属性和方法)Father f = new Father();//系统将分配1M内存 Son s = new Son();/
为什么父类引用可以指向子类对象 子类引用不能指向父类对象 泛型
假设有<em>父类</em>Fu ,其<em>子类</em>为Zi ,从<em>对象</em>的内存角度,假设Fu类里面的变量占内存2M, Zi 类里的变量占内存1M: Fu f = new Fu ();//系统将分配2M内存 Zi z = new Zi ();//系统将分配3M内存(2+1) 因为<em>子类</em>中有一个隐藏的<em>引用</em>super会指向<em>父类</em>实例,所以在实例化<em>子类</em>之前会先实例化一个<em>父类</em>,也就是说会先执行<em>父类</em>的构造函数.所以
多态的理解(父类引用指向子类对象
多态:要有继承,方法的重写,<em>父类</em><em>引用</em>指向<em>子类</em><em>对象</em>           ?疑问:Animal cat = new Cat(); //向上转型。        <em>父类</em><em>引用</em>指向<em>子类</em><em>对象</em>,该<em>引用</em>不能再访问<em>子类</em>新增加的成员,那么这样和直接new一个<em>父类</em>实例(Animal a = new Animal())有什么区别?            1、当<em>父类</em>是抽象类或是接口时,不能实例化时,只能运用多态,向上转型
JAVA父类引用指向子类对象
1.什么是多态? 方法的重写、重载与动态连接构成多态性 Java之所以引入多态的概念,原因之一就它在类的继承上的问题和C++不同,后者允许多继承,这确实给其带来了非常强大的功能,但是复杂的继承关系也给C++开发者带来了更大的麻烦,为了规避风险,Java只允许单继承,势必在功能上有很大的限制,所以,Java引入多态性的概念以弥补这点不足,此外,抽象类和接口也是解决单继承规定限制的重要手段.同时,...
Java编程中在子类重载方法中调用父类中该方法时,该方法包含递归时出现的调用错误
package Test; /** * 计算最大公约数和最小公倍数 * @author Yifan * @version 1.0 */ class Divisor { /** * 求最大公约数 * @param a * @param b 所求的两个数字 * @return 返回a和b的最大公约数 */ int f(int a,int b) { int tem
Java中继承子类父类引用问题
定义了一个<em>子类</em>Cat,它继承了Animal类,那么后者就是前者是<em>父类</em>。可以通过 Cat c = new Cat(); 实例化一个Cat的<em>对象</em>,这个不难理解。但当这样定义时: Animal a = new Cat(); 这代表什么意思呢? 很简单,它表示我定义了一个Animal类型的<em>引用</em>,指向新建的Cat类型的<em>对象</em>。由于Cat是继承自它的<em>父类</em>Animal,所以Animal类型的
对象的内存角度来理解“父类引用指向子类对象
 多态中总不理解Father f = new Son()是怎么<em>引用</em><em>子类</em><em>对象</em>的,现在从从<em>对象</em>的内存角度来理解试试. 假设现在有一个<em>父类</em>Father,它里面的变量需要占用1M内存.有一个它的<em>子类</em>Son,它里面的变量需要占用0.5M内存. 现在通过代码来看看内存的分配情况: Father f = new Father();//系统将分配1M内存. Son s = new S
父类引用指向子类对象属性值
<em>父类</em><em>引用</em>指向<em>子类</em><em>对象</em>指的是: 例如<em>父类</em>Animal,<em>子类</em>Cat,Dog。其中Animal可以是类也可以是接口,Cat和Dog是继承或实现Animal的<em>子类</em>。 Animal animal = new Cat(); 即声明的是<em>父类</em>,实际指向的是<em>子类</em>的一个<em>对象</em>。 那这么使用的优点是什么,为什么要这么用?可以用这几个关键词来概括:多态、动态链接,向上转型 也有人说这是面向接口编程,可以降低程
父类引用指向子类对象的理解
虽然接触<em>java</em>已经好长时间了,但对于一些知识点,还是有些模糊,就比如今天说的这个。 接触<em>java</em>的人都知道,继承是面向<em>对象</em>的三个特征之一(封装、继承、多态),继承中有一对概念,即<em>父类</em>和<em>子类</em>。他们通过关键字extends关联。 eg: <em>父类</em>:parent <em>子类</em>:son son extends parent parent  par = new son(); 关于这句,说明两点,
子类new出来的实例赋值给父类对象父类对象调用方法遇到的问题。
一句话总结,看不懂参考一下下面的代码: 声明的<em>对象</em>是<em>父类</em>的<em>对象</em>(SuperClass),但实际指向的内存空间是<em>子类</em>new出来的实例。 如果<em>父类</em><em>对象</em>调用方法(比如,toString),<em>子类</em>没有重写此方法,则调用<em>父类</em>的(toString)方法。 如果<em>子类</em>重写了此方法(toString),则会调用<em>子类</em>的toString方法。 代码地址:点我下载 代码测试一:先测试<em>子类</em>没有重写<em>父类</em>的方法(toS
向下转型 -- 父类、抽象类、接口引用指向子类、实现类
只能调用<em>父类</em>、抽象类或抽象类中已经有的方法,才能使用。如果<em>子类</em>中有的方法,在<em>父类</em>中没有,则不能调用格式:<em>父类</em> <em>对象</em> = new <em>子类</em>构造函数();<em>对象</em>.方法();        只能调用<em>子类</em>和<em>父类</em>中共有的方法或接口:接口  <em>对象</em> = new 实现类构造函数();<em>对象</em>.方法();     只能调用接口和实现类中共有的方法...
Java中,关于在子类构造函数中调用父类构造函数完成对象创建的简单分析
在使用new进行<em>对象</em>创建时,其实是调用了其相关类的构造方法。也就是说,<em>对象</em>创建时,最先执行的是构造方法。若在构造方法中没有对其类中的成员变量进行初始化,则在构造方法执行完之前,即<em>对象</em>还没有创建完毕,其成员变量是不存在的(此处不存在指的是内存中没有此变量)。下面通过一个小例子来说明这种情况
深入了解父类引用指向子类
<em>父类</em>应用指向<em>子类</em><em>对象</em>指的是: <em>父类</em>Animal,<em>子类</em> Cat,Dog。其中Animal可以是接口或类,Cat和Dog 是继承或实现Animal的<em>子类</em>。 Animal animal= new Cat(); 声明的为<em>父类</em>,实际指向的是<em>子类</em><em>对象</em>。我们先从<em>对象</em>内存角度理解。 假设Aninal<em>父类</em>,它里面的变量需要占用1M,它的<em>子类</em>Dog和Cat,需要占用0.5M内存。 通过代码看内存分配:
Java中父类引用指向子类实例对象
版权声明:欢迎转载,交流共享,转载请注明出处!如若转载请贴上此链接(山里樵夫俗称大叔):http://blog.csdn.net/u014143369 https://blog.csdn.net/u014143369/article/details/53287040 知识点: 1、<em>java</em> 中<em>父类</em><em>引用</em>指向<em>子类</em><em>对象</em>时动态绑定针对的只是<em>子类</em>重写的成员方法; 2、<em>父类</em><em>引用</em>指向<em>子类</em><em>对象</em>时,<em>子类</em>如果重写了父...
面向对象三大特征,super关键字,以及父类引用指向子类对象。访问权限的大小。
一.封装,反射的时候在详细补充。 二.继承 补充:<em>子类</em>的访问权限一定要大于等于<em>父类</em>。 访问权限的优先级顺序:public(在哪里都可以访问)>protected(保护的意思,<em>子类</em>可以访问,但是<em>子类</em>的权限要大于<em>父类</em>的权限,这是首要条件,否者<em>子类</em>依旧访问不到) >默认(就是什么都不写的意思,只能在同一个包下被访问)>private(只能在同一个类下被访问)。 补充:super关键字的含义:s
关于java多态性之父类引用指向子类对象
在使用多态前,要确保两个类之间是继承关系 public class Animal{ } public class Dog extends Animal{ } 之后创建<em>对象</em>: Animal animal1 = new Animal(); Animal animal2 = new Dog(); 这时,Animal animal2 = new Dog(); 就是<em>父类</em><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><em>对象</em>指向自身<em>对象</em>都不难理解,因此为了方便理解,下面举了一个例子:水杯和水壶的比喻。             下面的一段代码来实现这个比喻: 1 public class Kettle { 2 public Kettle(){ 3 ...
(多态)子类实例赋给父类引用的简单例子
注意(<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>的地址。 创建一个抽象类Teacher,包括name属性和TeachClass()方法; public abstract class Teacher { /** *name:老师姓名,字符类型 *TeachClass:老师讲课,继承多态...
父类声明,子类实例化中不能调用子类特有的方法(强制转换)
package com.byxy; public class Person { private String name; private int age; private char gender; public String getName() { return name; } public void setName(String name) { this.name = name; } pub...
Java向上转型与向下转型(子类对象赋给父类的)
http://www.cnblogs.com/gold-worker/archive/2012/09/26/2704717.html Java向上转型与向下转型 一.定义:    通俗理解向上转型:    就是<em>子类</em>转型成<em>父类</em>。   classA   {   }   classBextendsA   {   }   A b=new B();   这个就是向上转
子类引用父类的静态字段,不会导致子类初始化 - 每天五分钟搞定Java面试
先看代码 // <em>父类</em> public class SuperClass { static { System.out.println(&quot;SuperClass Init!&quot;); } public static int value = 123; } //<em>子类</em> public class SubClass extends SuperClass{ static ...
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>源程
创建子类对象时,父类构造函数中调用被子类重写的方法为什么调用的是子类的方法,而被子类重载的方法不会调用?
问题:创建<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');
java类中子类重写父类中的方法,父类对象子类对象实例化以后,父类引用如何调用父类中的被重写方法。
多态的体现。 代码如下; package TestMENG; public class Base { int i = 99; public void amethod() { System.out.println(" Base.amethod() "); } Base() { amethod(); } } package TestMENG; public c...
父类的变量访问子类对象的成员
以<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>的成员    (1)先创建<em>父类</em>的数组变量;    (2)创建<em>子类</em><em>对象</em>并放入数组,利用数组元素来访问<em>子类</em>的内容。   例 package com; ...
关于子类创建对象调用父类方法时this的问题(以及方法重写)
如下实例提出问题: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(...
关于子类父类中的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)
[BIT0429]-Java多态:父类引用指向子类对象的原理
今天,我们来写一个小程序说明在多态中,<em>父类</em><em>引用</em>指向<em>子类</em><em>对象</em>的原理。在此之前我们简略提一下面向<em>对象</em>的三大特征:封装、继承、多态。而多态的前提有:继承、<em>子类</em>重写<em>父类</em>方法、<em>父类</em><em>引用</em>指向<em>子类</em><em>对象</em>。而多态前提的最后一个则涉及到程序静态时编译和动态时运行的区别,下面我们通过代码来说明。 首先創建一個“人”類,并定義一個“吃”的方法,表示所有“人”的對象都會吃飯。package cn.bjsxt.oop03; p
java父类变量引用子类对象
有代码如: Father c=new CH
java 类实例化及类加载时: 父类子类中, 静态代码块、构造代码块、静态方法、静态常量等的执行顺序
名词解释:        静态代码块:就是用static修饰的用{}括起来的代码段,可用于对静态属性进行初始化。类加载时会执行        构造代码块:直接用{}括起来的代码段.<em>对象</em>实例化时候会执行,构造代码块优先于构造函数执行        构造函数:不再赘述 综上所述在单个类被实例化时候的执行顺序如下:静态代码块 &amp;gt; 构造代码块 &amp;gt; 构造函数。 如果牵涉到<em>子类</em>继承<em>父类</em>的...
C++ 父类指针指向子类对象||子类指针指向父类对象的理解
<em>父类</em><em>子类</em>指针函数调用注意事项 1,如果以一个基础类指针指向一个衍生类<em>对象</em>(派生类<em>对象</em>),那么经由该指针只能访问基础类定义的函数(静态联翩) 2,如果以一个衍生类指针指向一个基础类<em>对象</em>,必须先做强制转型动作(explicit cast),这种做法很危险,也不符合生活习惯,在程序设计上也会给程序员带来困扰。(一般不会这么去定义) 3,如果基础类和衍生类定义了相同名称的成员函数,那么通过<em>对象</em>指针调
为什么一个对象可以用父类声明,却用子类实例化
基本概念 这个实例是<em>子类</em>的,但是因为你声明时是用<em>父类</em>声明的,所以你用正常的办法访问不到<em>子类</em>自己的成员,只能访问到从<em>父类</em>继承来的成员。 在<em>子类</em>中用override重写<em>父类</em>中用virtual申明的虚方法时,实例化<em>父类</em>调用该方法,执行时调用的是<em>子类</em>中重写的方法; 如果<em>子类</em>中用new覆盖<em>父类</em>中用virtual申明的虚方法时,实例化<em>父类</em>调用该方法,执行时调用的是<em>父类</em>中的虚方法; /// /
java类中子类重写父类中的方法,父类对象子类对象实例化以后,父类对象如何调用父类中的被重写方法
<em>父类</em> 实例 = new <em>子类</em>() 实例可以调用<em>父类</em>中特有的方法(未在<em>子类</em>中覆盖的方法) 实例可以调用<em>子类</em>中覆盖<em>父类</em>的方法 但不可以调用<em>子类</em>中特有的方法(即<em>父类</em>中没有的方法) ...
Java反射通过父类对象调用子类的方法
在做网站开发的时候我们都会写一个控制器,控制器的作用就是接收客户端的请求,有时候为了控制访问入口的唯一性,方便我们监控用户访问的数据;最近在抽时间写一个底层转发控制器请求的工具,说通俗一点就是首先我定义一个抽象类或者接口A(实现类A就标识为控制器),然后定义很多继承或者实现了A类的类B(用户真正的Controller); 1.定义一个抽象类作为所有控制器的<em>父类</em> package thread; ...
(JAVA子类引用指象父类引用)JAVA克隆对象,包括父类属性,无需实现序列化接口
最近做一个东西,需要拷贝一个<em>对象</em>,而且<em>父类</em>属性也需要拷贝。.很多人可能会说直接<em>引用</em>待拷贝的<em>对象</em>就可以了。但是这个方法支持了使用<em>子类</em><em>引用</em>指象<em>父类</em><em>引用</em>。以下是代码:/**   /** 将sourceObj的属性拷贝到targetObj * @param sourceObj * @param targetObj * @param clazz 从哪一个类开始(比如source...
浅谈将子类对象赋值给父类对象
最近对将<em>子类</em><em>对象</em>赋值给<em>父类</em><em>对象</em>有点心得,想和大家分享一下,但本人水平有限,请各位指正和批评。言归正传,下面是几个小例子,请大家看一看。测试一 <em>父类</em>:public class Supclass { public void print() { System.out.println("this is <em>父类</em>print()方法" + "——此时<em>对象</em>" + this.toString
父类方法调用关系,内部类总结
public class Privateoverride { private void f() { System.out.println("private f()"); } public static main(String[] args) { PrivateOverride po = new Derived(); po.f(); } } class Derived
Java子类父类之间的对象转换(说明继承)
      在使用Java的多态机制时,常常使用的一个特性便是<em>子类</em>和<em>父类</em>之间的<em>对象</em>转换。从<em>子类</em>向<em>父类</em>的转换称为向上转换(upcasting),通过向上转换,我们能够在编写程序时采用通用程序设计的思想,在需要使用<em>子类</em><em>对象</em>的时候,通过把变量定义为<em>父类</em>型,我们可以通过一个变量,使用该<em>父类</em>型的所有<em>子类</em>型实例;从<em>父类</em>型向<em>子类</em>型的转换称为向下转换(downcasting),通过向下转换,我们能在必要的时候,将...
C#里的父类对象引用子类实例的理解
面向<em>对象</em>的多态  //<em>父类</em>可以<em>引用</em><em>子类</em><em>对象</em>。             //<em>父类</em><em>引用</em>只能调用<em>子类</em>继承<em>父类</em>的方法,<em>父类</em><em>引用</em>不能调用<em>子类</em>独有的方法。             People newPeople = new Man("Bilu");//如在“人类”类中<em>引用</em>一个 “男人”实例           //<em>子类</em><em>引用</em>不能直接赋值<em>父类</em><em>对象</em>,除非将<em>父类</em><em>对象</em>进行强制转换
父类对象赋给子类对象子类对象赋给父类对象
把<em>子类</em><em>对象</em>赋给<em>父类</em><em>对象</em>,这时候<em>父类</em>的COPY赋值操作符只负责处理<em>子类</em><em>对象</em>中<em>父类</em>成分的COPY工作。 把<em>父类</em><em>对象</em>赋给<em>子类</em><em>对象</em>,一般情况下是不能成立的。除非你在<em>子类</em>中定义一个以<em>父类</em><em>对象</em>为形参的<em>子类</em>构造函数,其实这一种变形的COPY构造函数,它还可以有其他参数用于构造<em>子类</em><em>对象</em>之用。在此构造函数中构造一个临时性的<em>子类</em><em>对象</em>,然后再调用<em>父类</em>COPY赋值操作符完成赋值操...
子类继承父类时,子类父类有同名变量,当使用子类对象调用父类方法使用同名变量,这个变量是子类的,还是父类的?(转)
public class Test4 { 2 public static void main(String[] args){ 3 Son son = new Son(); 4 son.minusOne(); 5 System.out.println(son.testValue); 6 System.out.prin...
Java 父类子类对象初始化过程及例子
基本初始化过程: 对于一个简单类的初始化过程是:static 修饰的模块(static变量和static 块) - 按照代码顺序依次执行。 |实例变量 及非static模块- 按照代码顺序依次执行。 |构造函数 - 执行对应的构造函数。 <em>子类</em>的初始化过程。<em>父类</em>static修饰的模块 |<em>子类</em>static修饰模块 |<em>父类</em>实例变量和非static块 |父
java中将子类对象赋给父类对象
例子一 <em>父类</em>:public class Supclass   {   public void print()   {   System.out.println("this is <em>父类</em>print()方法"+"——此时<em>对象</em>"+this.toString());   }   } <em>子类</em>:public class Subclass extends Supclass   {   public stat
C++ 多态问题:为什么不直接用子类引用子类,而是用父类指针指向子类
刚开始的时候对于这个问题我一直搞不明白,总觉得这是多此一举,后来上网查资料看到了一些人的解释明白了为什么要这样,用一个例子来解释应该最好理解了: 你写了一个飞机游戏,画面里出现什么类型飞机是随机决定的,你的代码里也就不可能用一个具体飞机类型来操作。 所以,往往是随机生成各种类型飞机,他们有共同的<em>父类</em>,你的代码就可以用<em>父类</em>指针来控制行为。比如中弹后的能量损失多少之类,每种飞机可能不同。 参考
父类转换到子类时发生java.lang.ClassCastException
在<em>父类</em>转换到<em>子类</em>时会发生ClassCastException异常,稍微了解Java的人都知道,但是我为什么要写出来,只是抛出一个问题用来提出解决办法,当你面对一个工程时成千上百的类时,是不太容易发现类之间的关系的,所以即使知道该原则,有时候还是避免不了
父类对象instanceof子类“对吗
”<em>父类</em><em>对象</em>instanceof<em>子类</em>“对吗  分享| 2015-08-27 22:46超级耶耶  外语学习<em>java</em> 这道题 class Cup { } class PoisonCup extends Cup { public void takeCup(Cup c) { if (c instanceof PoisonCup) { System.out.println("I
多态,如何理解父类引用指向子类对象
先放死板的说明:     一、使用<em>父类</em>类型生成<em>子类</em>的<em>对象</em>;    二、该<em>引用</em>只能调用<em>父类</em>中定义的方法和变量;    三、如果<em>子类</em>中重写了<em>父类</em>中的一个方法,那么在调用这个方法的时候,将会调用<em>子类</em>中的这个方法;(动态连接、动态调用)    四、变量不能被重写(覆盖),”重写“的概念只针对方法,如果在<em>子类</em>中”重写“了<em>父类</em>中的变量,那么在编译时会<em>报错</em>。多态的3个必要条件:  1.继承   2.重写   3...
父类子类的转换(向下转型)and instanceof 运算符
1.将一个指向<em>子类</em><em>对象</em>的<em>父类</em><em>引用</em>赋给一个<em>子类</em>的<em>引用</em>,称为向下转型。此时必须进行强制类型转换。 2.对比: 基本数据类型之间进行强制类型转换是对被强制转换类型“做手术”。 如:double  d1=5;       //对5做手术,变成5.0 int  a=(int)3.14;    //对3.14做手术,变成3 <em>引用</em>数据类型之间强势转换时是还原<em>子类</em>的真实目的,而不是给<em>子类</em>“做
java关于子类继承父类-创建一个子类对象时调用顺序
调用顺序:(这里基于无参构造器,暂且不考虑有参构造器的情况)1.创建第一个<em>子类</em><em>对象</em>时:<em>父类</em>静态块-&amp;gt;被调<em>子类</em>静态块-&amp;gt;<em>父类</em>动态块-&amp;gt;<em>父类</em>无参构造器-&amp;gt;被调<em>子类</em>动态块-&amp;gt;被调<em>子类</em>无参构造器这里我定义了一个<em>父类</em>Person,一个<em>子类</em>Student,创建第一个Student<em>对象</em>:运行结果如下:这个很容易理解,因为静态块是在类被加载的时候而加载的,因此<em>父类</em>和<em>子类</em>静态块优先被调...
Java 中父类怎么调用子类的方法?
<em>父类</em>能调用<em>子类</em>的方法吗? 答:能。 怎么做? ● 把<em>子类</em>传递到<em>父类</em>的有参构造中,然后调用。● 使用反射的方式调用,你使用了反射还有谁不能调用的?! ● <em>父类</em>调用<em>子类</em>的静态方法。 案例展示: package com.ywq; public class Test2{ public static void main(String[] args) { Son son = ...
Java的多态问题-父类调用子类对象时无法直接使用子类的方法,而只能使用子类重写自己的方法;
问这程序的输出结果package Wangyi; class Base { public void method() { System.out.println(&quot;Base&quot;); } } class Son extends Base { public void method() { System.out.println(&quot;So...
java对象引用向上转型后,无法调用子类独有的方法和属性问题
在下面的代码中,即可验证这一点,class StaticTest1 { private static int c=2017; public void print(){ System.out.println(c+" is a different year!"); } } public class Statictest extends StaticTest1 {
java中,创建子类对象时,父类对象会也被一起创建么?
作者:Accelerator链接:https://www.zhihu.com/question/51920553/answer/128610039来源:知乎著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。我来说句,反对桑弘毅 的第一句:”在创建<em>子类</em><em>对象</em>时,首先会调用<em>父类</em>的构造器,创造一个<em>父类</em>的<em>对象</em>“。调用<em>父类</em>构造方法是真的,但是根本没有创建<em>父类</em><em>对象</em>,只不过是调用<em>父类</em>构造方法来初...
C#父类引用指向子类对象
<em>父类</em><em>引用</em>指向<em>子类</em><em>对象</em>指的是: 例如<em>父类</em>Animal,<em>子类</em>Cat,Dog。其中Animal可以是类也可以是接口,Cat和Dog是继承或实现Animal的<em>子类</em>。 Animal animal = new Cat(); 即声明的是<em>父类</em>,实际指向的是<em>子类</em>的一个<em>对象</em>。 那这么使用的优点是什么,为什么要这么用?可以用这几个关键词来概括:多态、动态链接,向上转型 也有人说这是
Java父类对象调用子类实体:方法重写与动态调用
众所周知Java的handle和C++的ponter而不是object对应,我们很熟悉C++的<em>父类</em>pointer调用<em>子类</em>实体的例子,那么对于Java的handle是不是也可以这样呢? 这里我先给一个例子 class Father{ public void announce(){ System.out.println("Father"); } } class Chi
面向对象的调用方法(调用子类父类,静态方法)
&amp;lt;?php class Foo{ public function test(){ var_dump('foo-test'); } public function test2(){ var_dump('foo-test2'); } static public function test3(){ ...
java中创建子类对象时会不会创建父类对象
答案是:创建<em>子类</em><em>对象</em>时不会创建<em>父类</em><em>对象</em>。我们创建<em>子类</em><em>对象</em>时,只是说创建了<em>父类</em>空间,并进行了初始化。如果说创建<em>子类</em>的时候就会创建它的<em>父类</em>,那内存空间中不都是Object类的<em>对象</em>吗?(想想<em>java</em>的设计师也不会这么做的)下面转自知乎作者:祖春雷链接:https://www.zhihu.com/question/51920553/answer/128761716来源:知乎这个问题主要涉及到<em>java</em><em>对象</em>的...
子类引用变量可以赋给父类引用变量
<em>子类</em> <em>引用</em>变量 赋给 <em>父类</em> <em>引用</em>变量(可以)  简单的判别办法  把右边的当做左边来用,看说得通不 Hero h = new Hero(); ADHero ad = new ADHero(); h = ad; 右边ad<em>引用</em>所指向的<em>对象</em>的类型是 物理攻击英雄 左边h<em>引用</em>的类型是 普通英雄 把物理攻击英雄 当做 普通英雄,说不说得通? 说得通,就可以
java父类强制转换成子类的错觉
引言:<em>父类</em><em>引用</em>指向<em>子类</em><em>对象</em>在<em>java</em>中十分常见,比如: Object object=new a();//a是一个类名 但是有时候我们看见<em>子类</em><em>引用</em>指向了<em>父类</em><em>对象</em>,就是上边的反过来,比如 图片中圈1标识的代码,反正就是怎么看都别扭,但是却一点问题没有。(图片是疯狂android讲义的截图,379页,讲述activity和service传递消息的那个章节。IBender是个接口,B
Java 子类父类这间的转换
    最近同事调的一个服务<em>报错</em>,查看后是日期之间转换出的问题。代码里是把 <em>java</em>.sql.Date 类型的<em>对象</em> 强制转换为 <em>java</em>.sql.Timestamp 类型的<em>对象</em>。报<em>java</em>.lang.ClassCastException。       代码:               <em>java</em>.sql.Date date = new <em>java</em>.sql.Date(2011,9,15); ...
父类引用指向子类对象时变量传递问题
在复习Super的时候想到<em>父类</em><em>引用</em>指向<em>子类</em><em>对象</em>时调用方法传递和变量传递问题 代码如下:package com.newterm;public class SuperDemo { public static void main(String[] args) { Father2 fa = new Father2(); fa.play(); fa.r
java子类实现了抽象父类的方法后仍报错的问题
这是抽象<em>父类</em>里面的方法这是<em>子类</em>里面实现<em>父类</em>方法,可是却<em>报错</em>了根据提示把注解删掉后,<em>子类</em>名处又<em>报错</em>了看了好久终于知道是抽象<em>父类</em>需要先保存在实现<em>子类</em>,不过我的<em>父类</em>名前没有&quot;*&quot;号,所以一直没发现(。&amp;gt;︿&amp;lt;)_θ...
C#怎么理解“父类引用指向子类对象
<em>父类</em>代码如下:public class Person{//<em>父类</em>的构造函数public Person(){Console.WriteLine("Person");}//<em>父类</em>的虚方法public virtual void virFun(){Console.WriteLine("Person's Fun");}}<em>子类</em>代码如下:<br /
Java中父类强制转换为子类的可能
Java中<em>父类</em>强制转换为<em>子类</em>的可能 之前徒弟问了一个问题, 在Java中, <em>父类</em><em>对象</em>到底能不能转换成对应的<em>子类</em><em>对象</em>? 到底能不能, 今天就来说说这个问题, 先看下面一段代码: package cn.com.hanbinit.test; /** * 检验<em>父类</em>是否可以强转为<em>子类</em> * @author icer * */ public class ConvertPro
java子类如何调用父类变量和方法
深入浅出,保证一看就懂 package com.company; /** * Created by liuyazhou on 2016/9/21. */ public class Test { // private static String str1="str1"; ///在TestSon中System.out.println(str1);<em>报错</em> // p
TreeSet里面放对象,如果同时放入了父类子类的实例对象,那比较时使用的是父类的compareTo方法,还是使用的子类的compareTo方法,还是抛异常!
package com.echo1; import <em>java</em>.util.Iterator; import <em>java</em>.util.TreeSet; public class CompareTest { public static void main(String[] args) { TreeSet&amp;lt;Parent&amp;gt; t=new TreeSet&amp;lt;&amp;gt;(); Paren...
向上转型:父类引用指向子类对象
package 向上转型;/*向上转型:<em>子类</em>的<em>对象</em>赋值给<em>父类</em>的<em>引用</em>(<em>父类</em>的<em>引用</em>所指向的属性是<em>父类</em>的属性) ,如此就可调用<em>父类</em>类的方法,而不可以调用自身的方法,但如果<em>父类</em>的方法被<em>子类</em>重写, 那就调用<em>子类</em>的方法 。好处:减少重复代码*/ public class Human {     public void sleep() {         System.out.println(&quot;Human ...
关于java父类子类转型的问题java.lang.ClassCastException
我们都知道,<em>java</em>是面向<em>对象</em>的语言,继承是其一个很重要的特性,看下面这段代码:package my.<em>java</em>.test; class FatherClass { int fatherField; void fatherMethod() { System.out.println(&quot;这是<em>父类</em>的方法&quot;); } } package my.<em>java</em>.test; ...
java父类对象子类对象的互相转换
首先是可以的。前提是:此<em>父类</em><em>对象</em>为<em>子类</em><em>对象</em>强转的结果 例如: Father father = (Father)son; 当这种情况时,可以用instanceof判断是否是<em>子类</em>类型(实际) 然后强转回去 if(father instanceof Son) Son son =(Son)father; 除此之外,不行。 往深了讲。<em>子类</em>强制转换为<em>父类</em><em>对象</em>时,并没有实际丢失它原有内存空间(比<em>父类</em>多的那些部分...
强转失败的情况,父类子类
/** * 一个<em>java</em>文件中只能包含一个public类。 * * @author jiaxutianhuo * */ public class Instanceof { // 内部类 class a { } public static void test(F f){ f.t1(); // C2 c2=(C2)f; // c2.t2();相当于下一行写法,将f强制转
JAVA中关于new子类对象时是否创建父类
JAVA中关于new<em>子类</em><em>对象</em>时是否创建<em>父类</em>今天在抽取dao层的重复代码到 BaseDaoImpl 里时遇到一个问题:怎样获取<em>父类</em>泛型的数据?经过分析最后找到了答案,但是在查找资料的过程中还是有一些一下不解的地方(可能脑壳没有那么的灵活),这里就向大家分享一下。 下面直接向上代码: A.<em>java</em> <em>父类</em> package com.tzq.test; import <em>java</em>.lang.re
内置锁的重入-子类中调用父类方法时锁对象是谁?
  运行结果   总结:super的含义是什么?不是指的<em>父类</em>而是一个用来<em>引用</em>继承而来的成员的<em>引用</em>。 super.doSomething()的含义是,通过super<em>引用</em>调用从<em>父类</em>继承而来的doSomething()方法,那么锁的还是当前的<em>子类</em><em>对象</em>,因此<em>子类</em><em>对象</em>被锁了2次,说明内置锁是可重入的,否则会发生死锁。...
父类声明子类实例化对象详解
测试代码: public class Employee { public String name; public String getType(){ return &quot;Employee&quot;; } } public class Manager extends Employee{ private int money; public String getType(){ retu...
里氏代换 -- 子类可以替换父类
里氏代换原则由2008年图灵奖得主、美国第一位计算机科学女博士Barbara Liskov教授和卡内基·梅隆大学Jeannette Wing教授于1994年提出。其严格表述如下:如果对每一个类型为S的<em>对象</em>o1,都有类型为T的<em>对象</em>o2,使得以T定义的所有程序P在所有的<em>对象</em>o1代换o2时,程序P的行为没有变化,那么类型S是类型T的<em>子类</em>型。这个定义比较拗口且难以理解,因此我们一般使用它的另一个通俗版
子类调用父类方法时,方法中的变量用谁的
public class T1 { private int a=6; public void ha(){ System.out.println(this.a); } }   public class T2 extends T1{ int a=7; }   public class Test { public...
JAVA new子类的时候是否会创建父类
JAVA new<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>构造方法==new <em>父类</em>? 理论分析 从类的加载过...
JSP超市管理系统下载
该系统决定采用B/S结构,JSP作为开发平台,数据库采用Microsoft SQL Server 2000,完成了系统的程序实施。本系统的设计实施为商品销售管理系统的运行做基础,为商品销售的管理提供良好的条件。 相关下载链接:[url=//download.csdn.net/download/u011932665/6197955?utm_source=bbsseo]//download.csdn.net/download/u011932665/6197955?utm_source=bbsseo[/url]
pt100温度控制系统下载
pt100温度控制系统pt100温度控制系统pt100温度控制系统 相关下载链接:[url=//download.csdn.net/download/alex20081018/2102083?utm_source=bbsseo]//download.csdn.net/download/alex20081018/2102083?utm_source=bbsseo[/url]
飞思卡尔智能车PWM控制下载
飞思卡尔智能车PWM控制 控制飞思卡尔智能车的小电机 进行加速减速等控制 相关下载链接:[url=//download.csdn.net/download/lucifer19871203/2420858?utm_source=bbsseo]//download.csdn.net/download/lucifer19871203/2420858?utm_source=bbsseo[/url]
文章热词 机器学习教程 Objective-C培训 交互设计视频教程 颜色模型 设计制作学习
相关热词 mysql关联查询两次本表 native底部 react extjs glyph 图标 学习java子类和父类 学习java时
我们是很有底线的