多态成员特点,多态转型

小灰灰 2022-05-15 10:09 202阅读 0赞

多态出现后会导致子父类中的成员变量有微弱的变化。看如下代码

class Fu \{

int num = 4;

class Zi extends Fu \{

int num = 5;

class Demo \{

public static void main(String\[\] args) \{

Fu f = new Zi();

System.out.println(f.num);

Zi z = new Zi();

System.out.println(z.num);

结果为:

1.  **多态成员变量(编译运行看左边)**

当子父类中出现同名的成员变量时，多态调用该变量时：

编译时期：参考的是引用型变量所属的类中是否有被调用的成员变量。没有，编译失败。

运行时期：也是调用引用型变量所属的类中的成员变量。

简单记：编译和运行都参考等号的左边。编译运行看左边。

多态出现后会导致子父类中的成员方法有微弱的变化。看如下代码

class Fu \{

int num = 4;

void show() \{

System.out.println("Fu show num");

class Zi extends Fu \{

int num = 5;

void show() \{

System.out.println("Zi show num");

class Demo \{

public static void main(String\[\] args) \{

Fu f = new Zi();

f.show();

结果为:

Zi show num

1.  **多态成员方法(编译看左,运行看右)**

编译时期：参考引用变量所属的类，如果没有类中没有调用的方法，编译失败。

运行时期：参考引用变量所指的对象所属的类，并运行对象所属类中的成员方法。

简而言之：编译看左边，运行看右边。

**多态--转型**

当父类的引用指向子类对象时，就发生了向上转型，即把子类类型对象转成了父类类型。向上转型的好处是隐藏了子类类型，提高了代码的扩展性。

但向上转型也有弊端，只能使用父类共性的内容，而无法使用子类特有功能，功能有限制。看如下代码

//描述动物类，并抽取共性eat方法

**abstract** **class** Animal \{

**abstract** **void** eat();

// 描述狗类，继承动物类，重写eat方法，增加lookHome方法

**class** Dog **extends** Animal \{

**void** eat() \{

System.***out***.println("啃骨头");

**void** lookHome() \{

System.***out***.println("看家");

// 描述猫类，继承动物类，重写eat方法，增加catchMouse方法

**class** Cat **extends** Animal \{

**void** eat() \{

System.***out***.println("吃鱼");

**void** catchMouse() \{

System.***out***.println("抓老鼠");

**public** **class** Test \{

**public** **static** **void** main(String\[\] args) \{

Animal a = **new** Dog(); //多态形式，创建一个狗对象

a.eat(); // 调用对象中的方法，会执行狗类中的eat方法

// a.lookHome();//使用Dog类特有的方法，需要向下转型，不能直接使用

// 为了使用狗类的lookHome方法，需要向下转型

// 向下转型过程中，可能会发生类型转换的错误，即ClassCastException异常

// 那么，在转之前需要做健壮性判断

if( !a instanceof Dog)\{ // 判断当前对象是否是Dog类型

System.out.println("类型不匹配，不能转换");

return;

Dog d = (Dog) a; //向下转型

d.lookHome();//调用狗类的lookHome方法

我们再来看一个demo

class 毕姥爷 \{  
    void 讲课() \{  
        System.out.println("政治");  
    \}

void 钓鱼() \{  
        System.out.println("钓鱼");  
    \}  
\}

// 毕老师继承了毕姥爷，就有拥有了毕姥爷的讲课和钓鱼的功能，  
// 但毕老师和毕姥爷的讲课内容不一样，因此毕老师要覆盖毕姥爷的讲课功能  
class 毕老师 extends 毕姥爷 \{  
    void 讲课() \{  
        System.out.println("Java");  
    \}

void 看电影() \{  
        System.out.println("看电影");  
    \}  
\}

public class Demo \{  
    public static void main(String\[\] args) \{  
        // 多态形式  
        毕姥爷 a = new 毕老师(); // 向上转型  
        a.讲课(); // 这里表象是毕姥爷，其实真正讲课的仍然是毕老师，因此调用的也是毕老师的讲课功能 //java  
        a.钓鱼(); // 这里表象是毕姥爷，但对象其实是毕老师，而毕老师继承了毕姥爷，即毕老师也具有钓鱼功能 //钓鱼

// 当要调用毕老师特有的看电影功能时，就必须进行类型转换  
        毕老师 b = (毕老师) a; // 向下转型  
        b.看电影();//看电影  
    \}  
\}

我们来总结一下：

1.  什么时候使用向上转型：

当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作，这时就可以使用向上转型。

如：Animal a = **new** Dog();

a.eat();

1.  什么时候使用向下转型

当要使用子类特有功能时，就需要使用向下转型。

如：Dog d = (Dog) a; //向下转型

d.lookHome();//调用狗类的lookHome方法

1.  向下转型的好处：可以使用子类特有功能。
2.  弊端是：需要面对具体的子类对象；在向下转型时容易发生ClassCastException类型转换异常。在转换之前必须做类型判断。

如：if( !a instanceof Dog)\{…\}