那为同学教下多态的用法？？？，最好给个例子

1. class Fu
   
2. {
   
3.         boolean show(char a)
   
4.         {
   
5.                   System.out.println(a);
   
6.                   return true;
   
7.         }
   
8. }
   
9. class Demo extends Fu
   
10. {
    
11.         public static void main(String[] args)
    
12.         {
    
13.                 int i=0;
    
14.                   Fu f=new Demo();
    
15.                   Demo d=new Demo();
    
16.                   for(f.show('A'); f.show('B')&&(i<2);f.show('C'))
    
17.                   {
    
18.                           i++;
    
19.                            d.show('D');
    
20.                   }
    
21.         }
    
22.         boolean show(char a)
    
23.         {
    
24.                   System.out.println(a);
    
25.                   return false;
    
26.         }
    
27. }
    

复制代码

//编译时看父类，运行时看子类
// f.show('B')&&(i<2)  如果左边f.show('B')是false，就不会执行到右边(i<2)；
//A B

多态就是父类的引用指向子类的实例对象

很简单，比如说 B类继承了A类，那么A类就是B类的父类。
通过 A a = new B();产生的对象就是多态的体现.
在a调用成员变量时，编译和运行时都参考引用类型变量所属的类中是否有这个成员变量。
在a调用成员方法时，编译时参考引用类型变量所属的类中是否有这个成员方法，如果有编译就通过；在运行时参考引用类型变量指向的对象中是否有这个成员方法，如果有就直接运行，如果没有就去引用类型变量所属的类中去找这个成员方法，如果有就直接运行，如果没有就报错。
而调用静态成员方法时不管编译和运行都参考引用类型的变量所属的类中是否有这个静态方法，有就运行，没有就报错。其实调用静态成员方法直接类名调用就行了，多态对静态成员方法和静态成员变量几乎没什么影响。我目前也就学这么多，希望对你有帮助。

java中多态表现在：
本类中：重载，跟返回值无关。
父类子类：运行期间，动态地根据子类类型，调用其相应的方法。
        必须满足三个条件：继承、重写，父类对象指向子类对象。
至于例子  动物多态网上很多的，百度一下吧。。

假设有一个类 叫 鸟类，它拥有属性翅膀，拥有方法鸣叫，如下
public class Bird{
   private Wing wing;
   public void moo(){
          System.out.println("鸟叫声");
   }
}
鸟类封装了 翅膀类和moo方法；另外有两个类都继承鸟类并重写了moo方法，分别是鹦鹉和麻雀如下：
鹦鹉类：
public class Parrot extends Bird{
   public void moo(){
         System.out.println("鹦鹉的叫声");
   }
}
麻雀类：
public class Sparrow extends Bird{
   public void moo(){
         System.out.println("麻雀的叫声");
   }
}
方法重写应该懂吧，不懂自己找书看吧；然后你有个妻子她想听鸟叫，就有个妻子类
public class Wife{
     public void listen(Bird bird){
        bird.moo();
   }
   /*这时多态就很好的体现了，你妻子想听鸟叫，无论什么鸟都可以给她，但是你想让她和鹦鹉
  *说话，你就买了一只鹦鹉传给listen方法，结果你妻子听到了鹦鹉的叫声，程序输出：鹦
  *鹉的叫声
  */
  public static void main(String[] args) {
       new Wife().listen(new Parrot());       
  }
}
多态实现了动态绑定，让程序有了很好的扩展性，比如你以后想买一只燕子送给你妻子，就只需要写个燕子类Swallow继承Bird方法就可以了，而不需要再在妻子类里添加一个方法listen(Swallow swallow)……上面编码没用编译器，可能有错误，请谅解

创建Quadrangle类，再分别创建两个内部类Square和Parallelogramgle,它们都继承了Quadrangle类。编写draw()方法，该方法接收Quadrangle类的对象作为参数，即使用这两个内部类的父类作为方法参数。在主方法中分别以两个内部类的实力对象作为参数执行draw()方法。

1. 
   
2. public class Quadrangle{
   
3.         //实例化保存四边形对象的数组对象
   
4.         private Quadrangle[] qtest=new Quadrangel[6];
   
5.         private int nextindex=0;
   
6.         public void draw(Quadrangle q){                                //定义draw()方法，参数为四边形对象
   
7.                 if (nextindex<qtest.length){
   
8.                         qtest[nextindex]=q;
   
9.                         System.out.println(nextindex);
   
10.                         nextindex++;
    
11.                 }
    
12.         }
    
13.         public static void main(String[] args) {
    
14.                 //实例化两个四边形对象，用于调用draw()方法
    
15.                 Quadrangle q=new Quadrangle();
    
16.                 q.draw(new Square());                        //以正方形对象为参数调用draw()方法
    
17.                 //以平行四边形对象为参数调用draw()方法
    
18.                 q.draw(new Parallelogramgle());
    
19.                 }
    
20. }
    
21. class Square extends Quadrangle{                        //定义一个正方形类，继承四边形类
    
22.         public Square(){
    
23.                 System.out.println("正方形");
    
24.         }
    
25. }
    
26. //定义一个平行四边形类，继承四边形类
    
27. class Parallelogramgle extends Quadrangle{
    
28.         public Parallelogramgle(){
    
29.                 System.out.println("平行四边形“）;
    
30.         }
    
31. }
    

复制代码

运行Quadrangle类，结果为：
正方形
0
平行四边形
1

上面事例已经很多了，我就说点总结把：（父类引用指向子类对象）


实现多态的机制:
父类的引用变量可以指向子类的实例对象,而程序调用的方法在运行期才动态绑定，就是引用变量所指向的真正实例对象的方法,也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。

多态的作用：
把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。
只修改方法的实现，不必修改方法的声明

大家说的都很好，谢谢了