多态，重载，重写的理解

典型例子：

[html]  view plain  copy

1. public class Alpha {  
2.     public void foo(String... args){  
3.         System.out.println("Alpha:foo");  
4.     }  
5.        
6.     public void bar(String a){  
7.         System.out.println("Alpha:bar");  
8.     }  
9. }  
10. public class Beta extends Alpha {  
11.        
12.     public void foo(String a){                //与父类的方法名相同，参数不同，这里是重载  
13.         System.out.println("Beta:foo");  
14.     }  
15.        
16.     public void bar(String a){              //与父类的方法名相同，参数列表也相同，有继承关系，这里为重写  
17.         System.out.println("Beta:bar");  
18.     }  
19.     public static void main(String[] args) {  
20.         // TODO Auto-generated method stub  
21.         Alpha a = new Beta();                  //父类 xx = new 子类（）  
22.         Beta b = (Beta)a;                        //子类 xx = new 子类（）  
23.         a.foo("test");  
24.         b.foo("test");  
25.         a.bar("test");  
26.         b.bar("test");  
27.            
28.     }  
29.    
30. }  

输出结果：

[html]  view plain  copy

1. 1>  
2. Alpha:foo  
3. Beta:foo  
4. 2>  
5. Beta:bar  
6. Beta:bar  

结果分析：

1>父类和子类的foo方法是不一样的,因为其参数不同.所以不存在多态,用父类的引用调用foo,那就调用的是父类的foo(String ...args)方法，args是一个可变参数，处理为一个数组。用子类的引用调用foo时，调用的是子类的foo(String a)方法。

2> bar()方法，父类和子类是相同的，所以用多态，无论用父类引用还是子类引用，都调用的是子类的bar()。