Java多态基础一

点击(此处)折叠或打开

1. package com.pp;
   
2. //多态:父类的引用可以指向子类的对象.即子类的一个实例可以被父类引用。
   
3. public class DDchild extends DDParent
   
4. {
   
5.     public DDchild()
   
6.     {
   
7.         super(1);
   
8.     }
   
9.     public void run()
   
10.     {
    
11.         System.out.println("DDchild is runing");
    
12.     }
    
13.     /**
    
14.      * @param args
    
15.      */
    
16.     
    
17.     public static void main(String[] args) {
    
18.         // TODO Auto-generated method stub
    
19.         /*
    
20.          * 1.多态必须先理解封装和继承。
    
21.          * 2.多态不能单独看待。
    
22.          * 3.多态是运行时绑定的：也就是编译的时候,java编译器并不知道pp这个引用指向了哪一个对象。运行的时候才知道
    
23.          * 4.方法重载不是面向对象的特征。方法重载是编译时绑定。
    
24.          */
    
25.         DDParent pp = new Achild();//多态:父类的引用可以指向子类的对象.即子类的一个实例可以被父类引用。
    
26.         pp.run();//多态：run方法必须在父类存在！！因为pp这个引用类型是父类型的。
    
27.         
    
28.         /*片段1.start*******************************************/
    
29.         //Bchild bb = (Bchild)pp;
    
30.         /*Bchild bb = (Bchild)pp;编译可以通过，但是运行的时候报错，说明：
    
31.          * 1.多态是运行时绑定的：也就是编译的时候,java编译器并不知道pp这个引用指向了哪一个对象。运行的时候才知道
    
32.          * 2.运行的时候，java发现pp引用指向了Achild对象,那就不允许Bchild的引用指向Achild对象
    
33.          */
    
34.         /*片段1.end*******************************************/
    
35.         
    
36.         /*片段2.start*******************************************/
    
37.         DDParent Spp = new Bchild();
    
38.         pp = Spp;
    
39.         Bchild bb = (Bchild)pp;
    
40.         /*Bchild bb = (Bchild)pp;编译可以通过，而且运行的时候通过，说明：
    
41.          * 1.多态是运行时绑定的：也就是编译的时候,java编译器并不知道pp这个引用指向了哪一个对象。运行的时候才知道
    
42.          * 2.运行的时候，java发现pp引用指向了Spp所指向的Bchild对象,那就允许Bchild的引用指向Bchild对象
    
43.          */
    
44.         /*片段2.end*******************************************/
    
45.         
    
46.         /*片段3.start*******************************************/
    
47.         Achild acc = new Achild();
    
48.         DDParent pp3 = acc;//向上类型转换，子类型的对象（实例）被父类型的引用所指向。不需要显式指定。
    
49.         pp3.run();
    
50.         /*片段3.end*******************************************/
    
51.         
    
52.         /*片段4.start*******************************************/
    
53.         //向下类型转换，父类型的对象（实例）被子类型的引用所指向。必须需要显式指定。
    
54.         DDParent acc4 = new DDParent();
    
55.         Achild pp4 = (Achild)acc4;
    
56.         pp4.run();
    
57.         /*片段4.end*******************************************/
    
58.         
    
59.     }
    
60. 
    
61. }
    
62. class Achild extends DDParent
    
63. {
    
64.     public Achild()
    
65.     {
    
66.         super(1);
    
67.     }
    
68. }
    
69. 
    
70. 
    
71. class Bchild extends DDParent
    
72. {
    
73.     public Bchild()
    
74.     {
    
75.         super(1);
    
76.     }
    
77. }
    
78. class DDParent
    
79. {
    
80.     int age = 50;
    
81.     int ttz = 170;
    
82.     public DDParent()
    
83.     {
    
84.         System.out.println("parent");
    
85.     }
    
86.     public DDParent(int i)
    
87.     {
    
88.         System.out.println("parent");
    
89.     }
    
90.     
    
91.     public void run()
    
92.     {
    
93.         System.out.println("Parent is runing");
    
94.     }
    
95. }
    
96. /*继承的特点：
    
97.  *1.父类有的，子类也有
    
98.  *2.父类没有的，子类可以增加
    
99.  *3.父类有的，子类可以改变
    
100. */