1. 一：
   
2. 父类
   
3. [java] public class A {
   
4.      
   
5.     final String name="A";
   
6. 
   
7.     void A1(){};
   
8. }
   
9. 
   
10. 子类
    
11. [java]
    
12. public class AA extends A{
    
13. 
    
14.     String name="AA";
    
15.      
    
16.     void AA1(){};
    
17.      
    
18.     public static void main(String[] args) {
    
19.          
    
20.         A a = new AA();
    
21.         System.out.println(a.name);
    
22.          
    
23.         AA aa = new AA();
    
24.         System.out.println(aa.name);
    
25.          
    
26.     }
    
27. }
    
28. 输出：
    
29. A
    
30. AA
    
31. 
    
32. 
    
33. 父类子类均定义了name属性
    
34. 同样实例化子类，
    
35. a是父类引用
    
36. aa是子类引用
    
37. 
    
38. 定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。
    
39. 
    
40. 怎么使用子类强大的功能呢？就是子类重写父类定义的方法，然后自己在扩展
    
41. 
    
42. 所以，父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的；
    
43. 
    
44. 是不是很蛋疼
    
45. 
    
46. 同时，父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；
    
47. 
    
48. public static void main(String[] args) {
    
49.       
    
50.         A a = new AA();
    
51.         System.out.println(a.name);
    
52.         a.A1();
    
53.       
    
54.         AA aa = new AA();
    
55.         System.out.println(aa.name);
    
56.         aa.A1();
    
57.         aa.AA1();
    
58.       
    
59.     }
    
60. A1方法在A中，A的子类AA没有重写A1方法，所以，可以访问a可以访问A1。
    
61. 
    
62. 对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。
    
63. 
    
64. [java]
    
65. public class A {
    
66.      
    
67.     final String name="A";
    
68. 
    
69.     void A1(){
    
70.         System.out.println("A A1()");
    
71.     };
    
72. }
    
73. 
    
74. [java]
    
75. public class AA extends A{
    
76. 
    
77.     String name="AA";
    
78.      
    
79.     void AA1(){
    
80.         System.out.println("AA AA1()");
    
81.     };
    
82.      
    
83.     @Override
    
84.     void A1() {
    
85.         // TODO Auto-generated method stub
    
86.         //super.A1();
    
87.      
    
88.         System.out.println("AA A1()");
    
89.     }
    
90.      
    
91.     public static void main(String[] args) {
    
92.          
    
93.         A a = new AA();
    
94.         System.out.println(a.name);
    
95.         a.A1();
    
96.          
    
97.     }
    
98. }
    
99. 输出：
    
100. A
     
101. AA A1()
     
102. 没有执行父类的A1，如果要执行父类的A1，则需要
     
103. [java]
     
104. super.A1();
     
105. 
     
106. 
     
107. 这正是我们需要的。
     
108. 
     
109. 给一个简单DOTA例子
     
110. 
     
111. 英雄基类
     
112. [java]
     
113. package com.jc;
     
114. 
     
115. abstract public class Hero {
     
116. 
     
117.      
     
118.     abstract void run();
     
119. 
     
120.     public void stop(){/****/};
     
121. }
     
122. SS暗影萨满-小Y
     
123. [java]
     
124. package com.jc;
     
125. 
     
126. public class SS extends Hero{
     
127. 
     
128.     @Override
     
129.     void run() {
     
130. 
     
131.         System.out.println("ss run()");
     
132.     }
     
133.      
     
134.     @Override
     
135.     public void stop() {
     
136. 
     
137.         System.out.println("ss stop()");
     
138.     }
     
139. 
     
140. }
     
141. BR蜘蛛
     
142. [java]
     
143. package com.jc;
     
144. 
     
145. public class BR extends Hero{
     
146. 
     
147.     @Override
     
148.     void run() {
     
149. 
     
150.         System.out.println("br run()");
     
151.     }
     
152. 
     
153.     @Override
     
154.     public void stop() {
     
155.         System.out.println("br stop");
     
156.     }
     
157. 
     
158. }
     
159. 
     
160. 执行测试
     
161. [java]
     
162. package com.jc;
     
163. 
     
164. public class Test {
     
165. 
     
166.     @org.junit.Test
     
167.     public void test1(){
     
168.          
     
169.         Hero br = new BR();
     
170.          
     
171.         br.run();
     
172.         br.stop();
     
173.          
     
174.         Hero ss = new SS();
     
175.          
     
176.         ss.run();
     
177.         ss.stop();
     
178.          
     
179.          
     
180.     }
     
181. }
     
182. 输出：
     
183. br run()
     
184. br stop
     
185. ss run()
     
186. ss stop()
     
187. 注：蜘蛛和小Y都执行了跑和停的方法，方法都是从父类继承的，但是却出现了不同的效果。
     
188. 这难道不是我们正需要的吗

复制代码

赞               

赞赞赞，一百个赞，我也正好学到面向对象这块了，一起加油

这个看了之后对继承又有了更深的理解

学习了！！！

很是全面，总结的不错

觉得继承和重写，就是为了提升复用性，概念比较简单，看怎么用。

学习一下