J2SE基础夯实系列之父类引用指向子类对象

父类引用指向子类对象应该说是比较困难的知识点，多态，面向对象等方面的知识看似很简单的话，其实包含着很多规范在里面。

从对象的内存角度来理解试试.

假设现在有一个父类Father,它里面的变量需要占用1M内存.有一个它的子类Son,它里面的变量需要占用0.5M内存.

现在通过代码来看看内存的分配情况:

Father f = new Father();//系统将分配1M内存.

Son s = new Son();//系统将分配1.5M内存!
因为子类中有一个隐藏的引用super会指向父类实例,所以在实例化子类之前会先实例化一个父类,也就是说会先执行父类的构造函数.由于s中包含了父类的实例,所以s可以调用父类的方法.

Son s1 = s;//s1指向那1.5M的内存.

Father f1 =(Father)s;//这时f1会指向那1.5M内存中的1M内存,即是说,f1只是指向了s中实例的父类实例对象,所以f1只能调用父类的方法(存储在1M内存中),而不能调用子类的方法(存储在0.5M内存中).

Son s2 =(Son)f;//这句代码运行时会报ClassCastException.因为f中只有1M内存,而子类的引用都必须要有1.5M的内存,所以无法转换.

Son s3 =(Son)f1;//这句可以通过运行,这时s3指向那1.5M的内存.由于f1是由s转换过来的,所以它是有1.5M的内存的,只是它指向的只有1M内存.

示例：

class Father{

void print(){};

}

class Son extends Father{

void print(){System.out.println("子类中！");}

voidshow(){System.out.println("show 中！");}

}

class Demo{

public static void main(Stringargs[]){

Father obj=new Son();

obj.print();

obj.show();  //这个调用会报错！

}

}

1 .如果你想实现多态,那么必须有三个条件,父类引用,子类对象,方法覆盖你这里如果Fathor类有一个show()方法,那么形成方法覆盖,那么此时就可以这么写:obj.show(),此刻形成了多态.

2.
没有方法覆盖,那你这里只能解释为父类引用去访问一个子类的方法,当然,父类引用没有这么大范围的权限,当然会报错
PS:多态实际上是一种机制,在编译时刻,会生成一张虚拟表,来记录所有覆盖的方法,没有被覆盖的方法是不会记录到这张表的.若一个父类引用调用了没有覆盖的子类方法,那么是不符合该表的,那么编译时刻就会报错.
在执行程序的时候,虚拟机会去这张虚拟表中找覆盖的方法,比如引用中实际上存的是一个子类对象引用,那么就会去找子类中的相应的覆盖的方法来执行

定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。所以，父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的；同时，父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；（这里注意，主要子类中重写了，那么调用的就是子类中重写的方法）

看下面这段程序：

class Father{

public voidfunc1(){

func2(); //因为在子类中重写了这个方法，所以调用的时候用的是子类中的那个方法

}

//这是父类中的func2()方法，因为下面的子类中重写了该方法

//所以在父类类型的引用中调用时，这个方法将不再有效

//取而代之的是将调用子类中重写的func2()方法

public void func2(){

System.out.println("AAA");

}

}

class Child extends Father{

//func1(int i)是对func1()方法的一个重载

//由于在父类中没有定义这个方法，所以它不能被父类类型的引用调用

//所以在下面的main方法中child.func1(68)是不对的

public voidfunc1(int i){

System.out.println("BBB");

}

//func2()重写了父类Father中的func2()方法

//如果父类类型的引用中调用了func2()方法，那么必然是子类中重写的这个方法

public void func2(){

System.out.println("CCC");

}

}

public class PolymorphismTest {

public staticvoid main(String[] args) {

Father child = new Child();

child.func1();//打印结果将会是什么？

}

}

上面的程序是个很典型的多态的例子。子类Child继承了父类Father，并重载了父类的func1()方法，重写了父类的func2()方法。重载后的func1(inti)和func1()不再是同一个方法，由于父类中没有func1(inti)，那么，父类类型的引用child就不能调用func1(int
i)方法。而子类重写了func2()方法，那么父类类型的引用child在调用该方法时将会调用子类中重写的func2()。

那么该程序将会打印出什么样的结果呢？

很显然，应该是“CCC”。

变量是不存在重写覆盖的！

public class A { int a = 1; }

public class B extends A { int a = 2； }

测试类里调用了这个方法voidcompare(){

if(super.a == this.a)

System.out.println("notoverrided");

else

System.out.println("overrided");}

控制台出来的是overrided

类中的属性是没有多态性的，即你在引用上面使用属性时，系统只会去找引用的静态类型中的那个属性，而与它的实际类型无关。

静态方法也是没有多态性的。

对于多态，可以总结它为：

一、使用父类类型的引用指向子类的对象；

二、该引用只能调用父类中定义的方法和变量；

三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）

四、变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。（静态方法不存在重写问题）

当父类引用指向子类的对象时，该父类引用调用的任何方法，只要子类里面有就用子类的那个，不管是不是嵌套在方法里面的。

public class Test {
public static void main(String[] args) {
Parent parent = new Parent();
Parent child = new Child();
System.out.println(parent.getName());
System.out.println(child.getName());
}
}

class Parent {
public static String getName() {
return "Parent ";
}
}

class Child extends Parent {
public static String getName() {
return "Child ";
}
}

这里的结果是两个Parent！！是因为static方法的原因。
因为都是静态方法。所以子类方法的 getName()
就不是方法的重写，其貌似重写的作用根本没有产生，根据对象的声明，第二句只会输出的是 Parent.getName()
方法。

二 多态的好处（父类中抽象出共性，子类实现个性）

这个是实现多态要素之一，多态后就可以写出一段所有子类都通用的代码，当添加新的子类时，这段代码是不需要修改的。

比方说：父类Animal，子类Cat,Dog

//如果使用第2行，当改用Dog的时候，那么第3行也需要改变

1 Animal a = new Cat();

2 //Cat a = new Cat();

3 a.someMethod();

现在你要写一个汽车和卡车的javabean类，他们都是属于车吧，都有型号，车速，厂商，等变量和方法吧，如果他们都继承同一个父类，那个父类把他们共同的变量和方法都写好了，比如厂商。那么汽车和卡车的类就不用写厂商了，只要写他们不同的比如型号，车速就可以了。

也就是说是多态的好处，父类里面可以有共同的变量和方法写好。子类只需要写各自的东西就可以了。