java中多态和父子对象的引用的问题
Java的多态包括方法的多态和对象的多态。
方法的多态： 方法的重载(overload)：在一类中定义多个方法名相同但参数列表(包括个数和类型)不同的方法
&&&&&&&&&&&&&&&&&&&&
方法的覆盖(重写:override)：子类对从父类继承来的虚函数重新定义，它要求参数表必须跟父类
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&中被覆盖的那个函数的参数表完全相同
& 对象的多态：主要是指子类对象和父类对象的相互转换。
&&&&&&&&&&&&&&&&&
子类对象向父类对象转换：自动完成。调用方法时执行的是子类覆盖了的方法。&
&&&&&&&&&&&&&&&&&
父类对象向子类对象转换：强制完成。
class Father{
&int a=100;
&int b=200;
&public void mony(){
&&System.out.println("我是一代枭雄");
&public void run(){
&&System.out.println("我是父亲");
class Child extends Father{
&int a=300;
&int c=400;
&public void book(){
&&System.out.println("我喜欢读书");
&&//System.out.println(super.a);//只能在子类中调用父类的变量和方法
&public& void run(){
&&System.out.println("我是儿子");
public class test {
&&& public
static void main(String args[]){
Father father=new Father();
Child son=new Child();
Father fatherson=
fatherson.mony();
fatherson.run();
//无法调用fatherson.book();
System.out.println(fatherson.a+","+fatherson.b);//无法调用fatherson.c
System.out.println("-------------");
System.out.println(son.a+","+son.b+","+son.c+",");
System.out.println("-----------");
son.mony();
son.run();
son.book();
System.out.println("-------------");
Child sonfather=(Child)//需要强制转化
sonfather.book();
sonfather.mony();
sonfather.run();
System.out.println(sonfather.a+","+sonfather.b+","+sonfather.c);
我是一代枭雄
-------------
300,200,400,
-----------
我是一代枭雄
我喜欢读书
-------------
Exception in thread "main" java.lang.ClassCastException: Father
cannot be cast to Child
&at test.main(test.java:38)
就可以解决所有的问题。
对于多态：使用父类类型的引用指向子类的对象；引用只能调用父类中定义的方法和变量，子类重写父类中的方法后，再调用此方法的时候，就会调用子类的这个方法，变量不能被重写和覆盖的，变量只能是父类的定义的变量。同时父类不能直接转换成子类，强制转换虽然写的时候不报错，但是在执行的时候会报错，就如你可以说奔驰是车，但是不能说车是奔驰。子类创建的实例包括
了父类的所有的变量和方法，但是重写以重写的为准。如果子类要调用父类的原始值可以使用super指代父类，但是只能在子类的class中使用。
多态的三个条件是：继承，重写，父类引用指向子类对象。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。java继承和多态相关问题，方法里调用成员变量why是在类本身或其父类找，而不在子类找？跟方法调用不一样
int name = 1;
class Parent extends A{
public void f(){
System.out.println(name); //name不是指this.name么？
public void g(){
System.out.println("parent");
class Child extends Parent{
int name = 2;
public void g(){
System.out.println("child");
public class Hello {
public static void main(String[] args) {
Child c = new Child();
//为什么f（）函数输出name不是2？？
Parent d = new Child();
} //为什么调用函数就是当前对象g（）
//而函数里引用变量确是找父类或自己的类，而不找子类的变量？？？？？？
实例的同名方法被覆盖，对于实例c,d,Child.g()覆盖了Parent.g()。所以执行f()时，执行的是Child的g()。
如果有static修饰的话是被隐藏，而不是覆盖。
变量的话一般都是被隐藏。在Parent类中没有对name进行重新定义，所以f()中能打印出继承类A的name。
当然如果Child的某个方法中使用了name的话，它的值应该是2.
隐藏 和覆盖 的区别在于，子类对象转换成父类对象后，能够访问父类被隐藏 的变量和方法，而不能访问父类被覆盖 的方法。
2个name变量就不是同一个变量，当然不会找暂没有新消息哦～
&Java面向对象多态性的应用
Java面向对象多态性的应用
视频太卡？试试切换线路
是否提供源码：否适合人群：零基础开发者
Java面向对象多态性视频教程,主讲java多态,多态 java,java多态性,java多态实例,java中的多态,java的多态,java 多态性,java多态的例子,java多态的实现,以Java代码实例演示Java多态性的使用
Java面向对象多态性的应用视频教程,以java多态实例,java多态的例子,java中多态,多态java,java 多态实例,主讲Java多态性的使用,掌握Java多态的实现
Java面向对象instanceof关键字视频教程,主讲instanceof,instance of,java中的instanceof,java instanceof,instanceof泛型,java instanceof null,java关键字instanceof,java class instanceof,掌握instanceof关键字应用方法
Java面向对象抽象类应用视频教程,主讲java抽象类,java 抽象类,java抽象类的作用,java抽象方法,java抽象类与接口区别,java接口和抽象类,java抽象类实例,java中抽象类,掌握Java抽象类的创建和实现
Java面向对象接口的使用视频教程,主讲java接口,java 接口,java接口实例,java接口的作用,java抽象类和接口的区别,java接口和抽象类的区别,java中接口的作用,java接口开发,java接口定义,学会java接口的使用
只有成为VIP会员才能提问&回复，快吧！如果你还没有账号你可以一个账号。
添加新技术问题
课程 [Java面向对象多态性的应用]
中已存在问题
添加新技术问题
问题描述越详细，被解答的速度越快
有新回答时请邮件提醒我
着急，拜托快点
不急，慢慢解决
关联课程 [Java面向对象多态性的应用]
服务热线:400-678-8266散文吧网站
海不择细流，故能成其大。山不拒细壤，方能就其高。
重载和多态的区别
重载和多态一直是不同的，对于刚学java的人来说会比较容易混淆。下面是小编为大家准备的重载和多态的区别，希望大家喜欢!
重载和多态的区别
多态性也是面向对象方法的一个重要特性.多态性是指在在程序中出现的&重名&现象,即在一个程序中相同的名字可以表示不同的实现.
在JAVA中,多态性主要表现在如下两个方面:
(1)方法重载.通常指在同一个类中,相同的方法名对应着不同的方法实现,但是方法的参数不同.
(2)成员覆盖.通常指在不同类(父类和子类)中,允许有相同的变量名,但是数据类型不同;也允许有相同的方法名，但是对应的方法实现不同.
在重载的情况下,同一类中具有相同的名字的方法.如何选择它的方法体呢?不能使用类名来区分,通常采用不同的方法形参表,区分重载要求形参在类型,个数和顺序的不同,在定义重载方法时,应在方法的形参的类型,个数和顺序有所不同,以便在选择时能够区别开来.
在覆盖的情况下,同名的方法存在于不同的类中,在调用方法只要指明其方法所归属的类名就可以了.
class Shape {
void draw() {}
void erase() {}
class Circle extends Shape {
void draw() {
System.out.println(&Circle.draw()&);
void erase() {
System.out.println(&Circle.erase()&); }
class Square extends Shape {
void draw() {
System.out.println(&Square.draw()&);
void erase() {
System.out.println(&Square.erase()&);
class Triangle extends Shape {
void draw() {
System.out.println(&Triangle.draw()&);
void erase() {
System.out.println(&Triangle.erase()&);
public class Test {
public static Shape randShape() {
switch((int)(Math.random() * 3)) {
case 0: return new Circle();
case 1: return new Square();
case 2: return new Triangle();
public static void main(String[] args) {
Shape[] s = new Shape[9];
for(int i = 0; i & s. i++)
s[i] = randShape();
for(int i = 0; i & s. i++)
s[i].draw();
Triangle.draw()
Circle.draw()
Triangle.draw()
Triangle.draw()
Triangle.draw()
Square.draw()
Square.draw()
Triangle.draw()
Circle.draw()
Triangle.erase()
Circle.erase()
Triangle.erase()
Triangle.erase()
Triangle.erase()
Square.erase()
Square.erase()
Triangle.erase()
Circle.erase()
Press any key to continue...
又一次执行
Triangle.draw()
Triangle.draw()
Circle.draw()
Circle.draw()
Circle.draw()
Triangle.draw()
Triangle.draw()
Square.draw()
Circle.draw()
Triangle.erase()
Triangle.erase()
Circle.erase()
Circle.erase()
Circle.erase()
Triangle.erase()
Triangle.erase()
Square.erase()
Circle.erase()
Press any key to continue...
两次执行结果不同的原因是其中的Math.random()这个类导致的,math.random()得到的数是0-1之间的随机数.
写到这里,我突然想到了方法重载,那么它和多态,覆盖有什么区别呢?到GOOGLE是搜素了一下，不少.
不过，最重要的一点区别是:通过方法重载进而实现对象的多态性.
方法重载是指功能相同的多个方法使用同一个方法名.同名的多个方法的参数要有所不同,即在参数类型,参数个数和参数顺序上要有所区别,以便作为选择某个方法的根据.通常只有功能相同的方法进行重载才有意义.
例如:计算两个数之和的重载方法定义如下:
int add(int i,int j)
{retrun i+j;}
float add(float i,float j)
{retrun i+j;}
double add(double i,double j)
{retrun i+j;}
重载方法的选择通常是在编译时进行.系统根据不同的参数类型,个数或顺序,寻找最佳匹配方法.方法类型不参与匹配.
下面是搜到的一些例子.
public class Base{
public Base(int x,int y){
public int add(){
return (a + b);
public void add(int x,int y){
上面这段代码就是重载~~~他有三个特征
1：方法名必须一样 &add()&。
2：返回类型可以不一样 就象是 &int &和&void&.
3：参数可以不一样 就是add() 和add(int x,int y)这样的。
public class Base{
public void add(){
public class Child extends Base{
public void add(){
public static void main(string [] args){
Base b = new Child();
下面这个例子就是重写，他实现了多态~~
重写的要求是，方法名必须一样，返回类型必须一样，传入的参数必须一样
在main函数中定义父类的对象，但是用子类去实例化他，这样就可以通过父类的对象调用到子类的方法。
下面还有一个例题.
public class Parent {
public int addValue( int a, int b) {
class Child extends Parent {
Which methods can be added into class Child?
a int addValue( int a, int b ){// do something...}
b public void addValue (){// do something...}
c public int addValue( int a ){// do something...}
d public int addValue( int a, int b )throws MyException {//do something...}
a是覆盖,b ,c是重载
a的问题出在访问权限上,如果换成public也是可以的
d是异常的问题.
a的访问权限小于父类，所以错误，d是异常错误，b和c中的addValue方法和父类的方法参数不同，所以是重载.
在同一个类中方法成员的名称相同，但参数的类型和个数不同，这称为重载。
在存在继承关系的两个话，子类与父类的方法成员名称相同、参数的类型和个数相同的话，子类的方法覆盖父类的方法，这称为覆盖。