面向对象特征三：多态

（教08-01）

多态：可以理解为事物存在的多种体现形态。

 

人：男人 女人

（教08-01）

多态：可以理解为事物存在的多种体现形态。

 

人：男人 女人

 

动物：猫 狗

 

猫 x=new 猫();

动物 x=new 猫();

1、多态的体现

  父类的引用指向了自己的子类对象

  父类的引用也可以接受自己子类的对象

2、多态的前提

  必须是类与类之间有关系。要么继承，要么实现。

  通常还有一个前提：存在覆盖

3、多态的好处

  多态的出现大大的提高了程序的扩展性

4、多态的弊端

  提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5、多态的应用

6、多态的出现代码中的特点

[java]  view plain copy

1. class Animal  
2. {  
3.          abstractvoid eat();  
4. }  
5.    
6. class Cat extends Animal  
7. {  
8.          publicvoid eat()  
9.          {  
10.                    System.out.println("吃鱼");  
11.          }  
12.          publicvoid catchMouse()  
13.          {  
14.                    System.out.println();  
15.          }  
16. }  
17.    
18. class Dog extends Animal  
19. {  
20.          publicvoid eat()  
21.          {  
22.                    System.out.println("吃骨头");  
23.          }  
24.          publicvoid kanJia()  
25.          {  
26.                    System.out.println("看家");  
27.          }  
28. }  
29.    
30. class DuoTaiDemo  
31. {  
32.          publicstatic void main(String[] args)  
33.          {  
34.                    Animala=new Cat();//类型提升，向上转型。  
35.                    a.eat();  
36.                    //如果想要调用特有属性怎么办？  
37.                    //强制将父类的引用，转成子类类型.向下转型  
38.                    Catc=(Cat)a;  
39.                    c.catchMouse();  
40.         //千万不要出现这样的操作，就是将父类的对象转成子类类型  
41.         //我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。  
42.         //多态自始至终都是子类对象在做着变化  
43.                    //Animala=new Animal();  
44.                    //Catc=(Cat)a;不可以转换  
45.                    function(newDog());  
46.         function(new Cat());  
47.    
48.          }  
49.          publicstatic void function(Animal a)  
50.          {  
51.                    a.eat();  
52.                    if(a instanceof Cat)//判断对象所属类型instanceof  
53.                    {  
54.                             Catc=(Cat)a;  
55.                             c.catchMouse();  
56.                    }  
57.          }  
58. }  
59.    

/*

多态的应用

 

基础班学生：

   学习，睡觉。

高级班学生：

   学习，睡觉。

 

可以将这两类事物进行抽取

*/

 

[java]  view plain copy

1. abstract class Student  
2. {  
3.          publicabstract void study();  
4.          publicvoid sleep()  
5.          {  
6.                    System.out.println("躺着睡");  
7.          }  
8.    
9. }  
10.    
11. class BaseStudent extends Student  
12. {  
13.          publicvoid study()  
14.          {  
15.                    System.out.println("basestudy");  
16.          }  
17.          publicvoid sleep()  
18.          {  
19.                    System.out.println("站着睡");  
20.          }  
21. }  
22.    
23. class AdvStudent extends Student  
24. {  
25.          publicvoid study()  
26.          {  
27.                    System.out.println("advstudy");  
28.          }  
29. }  
30.    
31. class DoStudent  
32. {  
33.          publicvoid doSome(Student stu)  
34.          {  
35.                    stu.study();  
36.                    stu.sleep();  
37.          }  
38. }  
39.    
40. class  DoTaiDemoTest  
41. {  
42.          publicstatic void main(String[] args)  
43.          {  
44.                    DoStudentds=new DoStudent();  
45.                    ds.doSome(newBaseStudent());  
46.                    ds.doSome(newAdvStudent());  
47.          }  
48. }  
49.    
50. class Fu  
51. {  
52.          intnum=5;//面试题  
53.          voidmethod1()  
54.          {  
55.                    System.out.println("fumethod_1");  
56.          }  
57.          voidmethod2()  
58.          {  
59.                    System.out.println("fumethod_2");  
60.          }  
61.          staticvoid method4()//面试题  
62.          {  
63.                    System.out.println("fumethod_4");  
64.          }  
65. }  
66.    
67. class Zi extends Fu  
68. {  
69.          intnum=8;//面试题  
70.          voidmethod1()  
71.          {  
72.                    System.out.println("zimethod_1");  
73.          }  
74.          voidmethod3()  
75.          {  
76.                    System.out.println("zimethod_3");  
77.          }  
78.          staticvoid method4()//面试题  
79.          {  
80.                    System.out.println("zimethod_4");  
81.          }  
82. }  
83.    
84. class DuoTaiDemo2  
85. {  
86.          publicstatic void main(String[] args)  
87.          {  
88.                    Fuf=new Zi();  
89.                    System.out.println(f.num);//运行结果是父类中的变量5  

面试题：

在多态中，成员变量的特点：

无论编译和运行，都参考左边（引用型变量所属的类）。

 

        f.method4();//结果是父类中的静态方法执行，因为静态依存于类，不参考对象

面试题：

在多态中，静态成员函数的特点：

无论编译和运行，都参考左边

 

                   Fuf=new Zi();

                   f.method1();

                   f.method2();

                   //f.method3();编译错误

 

在多态中成员函数的特点：

在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有，编译失败

在运行时期：参阅对象所属的类中是否有调用的方法。有则运行。

简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

         }

}

 

电脑主板多态和接口练习：

[java]  view plain copy

1. /* 
2. 需求： 
3. 电脑运行实例 
4. 电脑运行基于主板 
5. */  
6.    
7. class MainBoard  
8. {  
9.          publicvoid run()  
10.          {  
11.                    System.out.println("mainboardrun");  
12.          }  
13.          publicvoid usePCI(PCI p)//PCI p=new NetCard 接口型引用指向自己的子类对象  
14.          {  
15.                    if(p!=null){  
16.                    p.open();  
17.                    p.close();  
18.                    }  
19.                    else  
20.                             System.out.println("NO");  
21.          }  
22. }  
23.    
24. interface PCI  
25. {  
26.          publicvoid open();  
27.          publicvoid close();  
28. }  
29.    
30. class NetCard implements PCI  
31. {  
32.          publicvoid open()  
33.          {  
34.                    System.out.println("netcardopen");  
35.          }  
36.          publicvoid close()  
37.          {  
38.                    System.out.println("netcardclose");  
39.          }  
40. }  
41.    
42. class SoundCard implements PCI  
43. {  
44.          publicvoid open()  
45.          {  
46.                    System.out.println("soundCardopen");  
47.          }  
48.          publicvoid close()  
49.          {  
50.                    System.out.println("soundCardclose");  
51.          }  
52. }  
53.    
54. class DuoTaiDemo5  
55. {  
56.          publicstatic void main(String[] args)  
57.          {  
58.                    MainBoardmb=new MainBoard();  
59.                    mb.run();  
60.                    mb.usePCI(null);  
61.                    mb.usePCI(newNetCard());  
62.                    mb.usePCI(newSoundCard());  
63.                     
64.          }  
65. }  

 

多态扩展实例：

需求：数据库的操作

数据是：用户信息

1、连接数据库 JDBC Hibernate

2、操作数据库。

  c create r read u update d delete

3、关闭数据库连接。

 

[java]  view plain copy

1. interface UserInfoDao  
2. {  
3.          publicvoid add(User user);  
4.          publicvoid delete(User user);  
5. }  
6. class UserInfoByJDBC implementsUserInfoDao  
7. {  
8.          publicvoid add(User user)  
9.          {  
10.                    1、连接数据库。  
11.                    2、使用sql添加语句添加数据，  
12.                    3、关闭连接  
13.          }  
14.          publicvoid delete(User user)  
15.          {  
16.                    1、连接数据库。  
17.                    2、使用sql添加语句删除数据，  
18.                    3、关闭连接  
19.          }  
20. }  
21.    
22. class UserInfoByHibernate implementsUserInfoDao  
23. {  
24.          publicvoid add(User user)  
25.          {  
26.                    1、连接数据库。  
27.                    2、使用sql添加语句添加数据，  
28.                    3、关闭连接  
29.          }  
30.          publicvoid delete(User user)  
31.          {  
32.                    1、连接数据库。  
33.                    2、使用sql添加语句删除数据，  
34.                    3、关闭连接  
35.          }  
36. }  
37.    
38. class  DBOperate  
39. {  
40.          publicstatic void main(String[] args)  
41.          {  
42.                    UserInfoDaoui=new UserInfoByJDBC();  
43.                    ui.add(user);  
44.                    ui.delete(user);  
45.          }  
46. }  

 

Object类 equals和toString练习：

object:是所有对象的直接后者间接父类，传说中的上帝。

该类中定义的肯定是所有对象都具备的功能

 

object类中已经提供了对对象是否相同的比较方法。equals

 

如果自定义类中也有比较相同的功能，没有必要重新定义。

只要沿袭父类的功能，建立自己特有比较内容即可，这就是覆盖。

 

[java]  view plain copy

1. class Demo//extends Object  
2. {  
3.          privateint num;  
4.          Demo(intnum)  
5.          {  
6.                    this.num=num;  
7.          }  
8.          publicboolean equals(Object obj)//Object obj=new Demo();复写  
9.          {  
10.                    if(!(objinstanceof Demo))//判断是否是同一类型，不同类型不可以比  
11.                             returnfalse;  
12.                    Demod=(Demo)obj;//多态，向下转型  
13.                    returnthis.num==d.num;  
14.          }  
15.          publicString toString()//自己的toString方法，覆盖  
16.          {  
17.                    return"demo:"+num;  
18.          }  
19. }  
20.    
21. class Person  
22. {  
23. }  
24.    
25. class ObjectDemo  
26. {  
27.          publicstatic void main(String[] args)  
28.          {  
29.                    Demod1=new Demo(4);  
30.                    Demod2=new Demo(4);  
31.                    //Personp=new Person();  
32.                    Classc=d1.getClass();  
33.    
34.        System.out.println(c.getName()+"@@"+Integer.toHexString(d1.hashCode()));  
35.                    System.out.println(d1.toString());  
36.    
37.                    //System.out.println(d1.equals(p));  
38.          }  
39. }  

我的总结：明确面向对象的第三个特征多态，知道多态的特点和使用。特别注意多态在成员变量、静态成员函数和成员函数中编译和运行的特点。了解object类。

通过小题目了解向上转型和向下转型：

[java]  view plain copy

1. class A  
2. {  
3.  String a="class A";  
4. }  
5. class B extends A  
6. {  
7.  String b="class B";  
8. }  
9. class E  
10. {  
11.  public static void main(String[] args)   
12.  {  
13.   A a1,a2=new A();  
14.   B b1,b2=new B();  
15.   a1=b2;  
16.   b1=(B)a1;  
17.   b2=(B)a2;//A cannot be cast to B  
18.   System.out.println(a1.a);  
19.   System.out.println(b1.b);  
20.  }  
21. }  

 

动物：猫 狗

 

猫 x=new 猫();

动物 x=new 猫();

1、多态的体现

  父类的引用指向了自己的子类对象

  父类的引用也可以接受自己子类的对象

2、多态的前提

  必须是类与类之间有关系。要么继承，要么实现。

  通常还有一个前提：存在覆盖

3、多态的好处

  多态的出现大大的提高了程序的扩展性

4、多态的弊端

  提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5、多态的应用

6、多态的出现代码中的特点

[java]  view plain copy

1. class Animal  
2. {  
3.          abstractvoid eat();  
4. }  
5.    
6. class Cat extends Animal  
7. {  
8.          publicvoid eat()  
9.          {  
10.                    System.out.println("吃鱼");  
11.          }  
12.          publicvoid catchMouse()  
13.          {  
14.                    System.out.println();  
15.          }  
16. }  
17.    
18. class Dog extends Animal  
19. {  
20.          publicvoid eat()  
21.          {  
22.                    System.out.println("吃骨头");  
23.          }  
24.          publicvoid kanJia()  
25.          {  
26.                    System.out.println("看家");  
27.          }  
28. }  
29.    
30. class DuoTaiDemo  
31. {  
32.          publicstatic void main(String[] args)  
33.          {  
34.                    Animala=new Cat();//类型提升，向上转型。  
35.                    a.eat();  
36.                    //如果想要调用特有属性怎么办？  
37.                    //强制将父类的引用，转成子类类型.向下转型  
38.                    Catc=(Cat)a;  
39.                    c.catchMouse();  
40.         //千万不要出现这样的操作，就是将父类的对象转成子类类型  
41.         //我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。  
42.         //多态自始至终都是子类对象在做着变化  
43.                    //Animala=new Animal();  
44.                    //Catc=(Cat)a;不可以转换  
45.                    function(newDog());  
46.         function(new Cat());  
47.    
48.          }  
49.          publicstatic void function(Animal a)  
50.          {  
51.                    a.eat();  
52.                    if(a instanceof Cat)//判断对象所属类型instanceof  
53.                    {  
54.                             Catc=(Cat)a;  
55.                             c.catchMouse();  
56.                    }  
57.          }  
58. }  
59.    

/*

多态的应用

 

基础班学生：

   学习，睡觉。

高级班学生：

   学习，睡觉。

 

可以将这两类事物进行抽取

*/

 

[java]  view plain copy

1. abstract class Student  
2. {  
3.          publicabstract void study();  
4.          publicvoid sleep()  
5.          {  
6.                    System.out.println("躺着睡");  
7.          }  
8.    
9. }  
10.    
11. class BaseStudent extends Student  
12. {  
13.          publicvoid study()  
14.          {  
15.                    System.out.println("basestudy");  
16.          }  
17.          publicvoid sleep()  
18.          {  
19.                    System.out.println("站着睡");  
20.          }  
21. }  
22.    
23. class AdvStudent extends Student  
24. {  
25.          publicvoid study()  
26.          {  
27.                    System.out.println("advstudy");  
28.          }  
29. }  
30.    
31. class DoStudent  
32. {  
33.          publicvoid doSome(Student stu)  
34.          {  
35.                    stu.study();  
36.                    stu.sleep();  
37.          }  
38. }  
39.    
40. class  DoTaiDemoTest  
41. {  
42.          publicstatic void main(String[] args)  
43.          {  
44.                    DoStudentds=new DoStudent();  
45.                    ds.doSome(newBaseStudent());  
46.                    ds.doSome(newAdvStudent());  
47.          }  
48. }  
49.    
50. class Fu  
51. {  
52.          intnum=5;//面试题  
53.          voidmethod1()  
54.          {  
55.                    System.out.println("fumethod_1");  
56.          }  
57.          voidmethod2()  
58.          {  
59.                    System.out.println("fumethod_2");  
60.          }  
61.          staticvoid method4()//面试题  
62.          {  
63.                    System.out.println("fumethod_4");  
64.          }  
65. }  
66.    
67. class Zi extends Fu  
68. {  
69.          intnum=8;//面试题  
70.          voidmethod1()  
71.          {  
72.                    System.out.println("zimethod_1");  
73.          }  
74.          voidmethod3()  
75.          {  
76.                    System.out.println("zimethod_3");  
77.          }  
78.          staticvoid method4()//面试题  
79.          {  
80.                    System.out.println("zimethod_4");  
81.          }  
82. }  
83.    
84. class DuoTaiDemo2  
85. {  
86.          publicstatic void main(String[] args)  
87.          {  
88.                    Fuf=new Zi();  
89.                    System.out.println(f.num);//运行结果是父类中的变量5  

面试题：

在多态中，成员变量的特点：

无论编译和运行，都参考左边（引用型变量所属的类）。

 

        f.method4();//结果是父类中的静态方法执行，因为静态依存于类，不参考对象

面试题：

在多态中，静态成员函数的特点：

无论编译和运行，都参考左边

 

                   Fuf=new Zi();

                   f.method1();

                   f.method2();

                   //f.method3();编译错误

 

在多态中成员函数的特点：

在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有，编译失败

在运行时期：参阅对象所属的类中是否有调用的方法。有则运行。

简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

         }

}

 

电脑主板多态和接口练习：

[java]  view plain copy

1. /* 
2. 需求： 
3. 电脑运行实例 
4. 电脑运行基于主板 
5. */  
6.    
7. class MainBoard  
8. {  
9.          publicvoid run()  
10.          {  
11.                    System.out.println("mainboardrun");  
12.          }  
13.          publicvoid usePCI(PCI p)//PCI p=new NetCard 接口型引用指向自己的子类对象  
14.          {  
15.                    if(p!=null){  
16.                    p.open();  
17.                    p.close();  
18.                    }  
19.                    else  
20.                             System.out.println("NO");  
21.          }  
22. }  
23.    
24. interface PCI  
25. {  
26.          publicvoid open();  
27.          publicvoid close();  
28. }  
29.    
30. class NetCard implements PCI  
31. {  
32.          publicvoid open()  
33.          {  
34.                    System.out.println("netcardopen");  
35.          }  
36.          publicvoid close()  
37.          {  
38.                    System.out.println("netcardclose");  
39.          }  
40. }  
41.    
42. class SoundCard implements PCI  
43. {  
44.          publicvoid open()  
45.          {  
46.                    System.out.println("soundCardopen");  
47.          }  
48.          publicvoid close()  
49.          {  
50.                    System.out.println("soundCardclose");  
51.          }  
52. }  
53.    
54. class DuoTaiDemo5  
55. {  
56.          publicstatic void main(String[] args)  
57.          {  
58.                    MainBoardmb=new MainBoard();  
59.                    mb.run();  
60.                    mb.usePCI(null);  
61.                    mb.usePCI(newNetCard());  
62.                    mb.usePCI(newSoundCard());  
63.                     
64.          }  
65. }  

 

多态扩展实例：

需求：数据库的操作

数据是：用户信息

1、连接数据库 JDBC Hibernate

2、操作数据库。

  c create r read u update d delete

3、关闭数据库连接。

 

[java]  view plain copy

1. interface UserInfoDao  
2. {  
3.          publicvoid add(User user);  
4.          publicvoid delete(User user);  
5. }  
6. class UserInfoByJDBC implementsUserInfoDao  
7. {  
8.          publicvoid add(User user)  
9.          {  
10.                    1、连接数据库。  
11.                    2、使用sql添加语句添加数据，  
12.                    3、关闭连接  
13.          }  
14.          publicvoid delete(User user)  
15.          {  
16.                    1、连接数据库。  
17.                    2、使用sql添加语句删除数据，  
18.                    3、关闭连接  
19.          }  
20. }  
21.    
22. class UserInfoByHibernate implementsUserInfoDao  
23. {  
24.          publicvoid add(User user)  
25.          {  
26.                    1、连接数据库。  
27.                    2、使用sql添加语句添加数据，  
28.                    3、关闭连接  
29.          }  
30.          publicvoid delete(User user)  
31.          {  
32.                    1、连接数据库。  
33.                    2、使用sql添加语句删除数据，  
34.                    3、关闭连接  
35.          }  
36. }  
37.    
38. class  DBOperate  
39. {  
40.          publicstatic void main(String[] args)  
41.          {  
42.                    UserInfoDaoui=new UserInfoByJDBC();  
43.                    ui.add(user);  
44.                    ui.delete(user);  
45.          }  
46. }  

 

Object类 equals和toString练习：

object:是所有对象的直接后者间接父类，传说中的上帝。

该类中定义的肯定是所有对象都具备的功能

 

object类中已经提供了对对象是否相同的比较方法。equals

 

如果自定义类中也有比较相同的功能，没有必要重新定义。

只要沿袭父类的功能，建立自己特有比较内容即可，这就是覆盖。

 

[java]  view plain copy

1. class Demo//extends Object  
2. {  
3.          privateint num;  
4.          Demo(intnum)  
5.          {  
6.                    this.num=num;  
7.          }  
8.          publicboolean equals(Object obj)//Object obj=new Demo();复写  
9.          {  
10.                    if(!(objinstanceof Demo))//判断是否是同一类型，不同类型不可以比  
11.                             returnfalse;  
12.                    Demod=(Demo)obj;//多态，向下转型  
13.                    returnthis.num==d.num;  
14.          }  
15.          publicString toString()//自己的toString方法，覆盖  
16.          {  
17.                    return"demo:"+num;  
18.          }  
19. }  
20.    
21. class Person  
22. {  
23. }  
24.    
25. class ObjectDemo  
26. {  
27.          publicstatic void main(String[] args)  
28.          {  
29.                    Demod1=new Demo(4);  
30.                    Demod2=new Demo(4);  
31.                    //Personp=new Person();  
32.                    Classc=d1.getClass();  
33.    
34.        System.out.println(c.getName()+"@@"+Integer.toHexString(d1.hashCode()));  
35.                    System.out.println(d1.toString());  
36.    
37.                    //System.out.println(d1.equals(p));  
38.          }  
39. }  

我的总结：明确面向对象的第三个特征多态，知道多态的特点和使用。特别注意多态在成员变量、静态成员函数和成员函数中编译和运行的特点。了解object类。

通过小题目了解向上转型和向下转型：

[java]  view plain copy

1. class A  
2. {  
3.  String a="class A";  
4. }  
5. class B extends A  
6. {  
7.  String b="class B";  
8. }  
9. class E  
10. {  
11.  public static void main(String[] args)   
12.  {  
13.   A a1,a2=new A();  
14.   B b1,b2=new B();  
15.   a1=b2;  
16.   b1=(B)a1;  
17.   b2=(B)a2;//A cannot be cast to B  
18.   System.out.println(a1.a);  
19.   System.out.println(b1.b);  
20.  }  
21. }