多态都是在什么情况下使用啊?
能不能给举个例子?

多态(总结)
        (1)同一个对象，在不同时刻的多种运行状态。
        (2)举例：
                动物，狗   狗是狗，狗是动物。
                水(气体，液态，固定)
        (3)前提
                A:存在着继承或者实现关系
                B:有方法的重写
                C:父类(接口)引用指向子类(实现)对象
        (4)不同形式模拟多态
                A:普通类
                B:抽象类
                C:接口
        (5)多态中对象调用成员的特点
                Fu f = new Zi();
               
                A:成员变量
                        编译看左边，运行看左边
                B:成员方法
                        编译看左边，运行看右边
                C:静态方法
                        编译看左边，运行看左边
        (6)多态的思想
                指挥同一批对象做事情。

                举例：带兵打仗，下课等。
       
        (7)向上转型和向下转型
                Animal a = new Dog();  //向上转型
                //使用Dog中特有的方法
                Dog d = (Dog) a;  //向下转型

                //注意：不能转换成不同类型的
                Cat c = (Cat)a;
               
                举例：
                孔子爹:教课(java)
                孔子:教课(论语)，玩游戏()

                //多态
                孔子爹 k爹 = new 孔子(); //孔子就穿上他爹的衣服，装爹 向上转型
                k爹.教课();  //论语
                //k爹.玩游戏();

                孔子 k = (孔子) k爹;  //脱下衣服，穿上自己衣服。向下转型
                k.玩游戏();

1. package com.cn;
   
2. 
   
3. public class DuoTaiTest {
   
4.        
   
5.         public static void main(String[] args) {
   
6.                 int sum1 = He(1,2);//调用第一个He()
   
7.                 int sum2 = He(1,2,3);//调用第二个He()
   
8.                 System.out.println("sum1="+sum1+"sum2="+sum2);
   
9. 
   
10.         }
    
11.         public static int He(int x, int y)
    
12.         {
    
13.                 return x+y;
    
14.                
    
15.         }
    
16.         public static int He(int x, int y, int z)
    
17.         {
    
18.                 return He(x, y)+z;
    
19.         }
    
20. 
    
21. }

复制代码

多态有许多种，这里的只是一种情况。

1、首先你要理解多态就是多种形态。java里指的是对象的多态性。
2、多态在程序中的体现:父类或者接口的引用指向了自己的子类对象。
3、多态的前提：a、类之间必须要存在关系（继承，实现）；b、要有覆盖操作。
4、多态的好处：提高了程序的扩展性；可以对具体事物的共性类型进行统一操作，将复杂问题简单化。

理解好上面多态的一些特性，那么下面我就举个例子说明一下什么是多态：
class 动物{}

class 狗 extends 动物{}

狗 x = new 狗();

动物 y = new 狗();//狗这个实体对象即使狗类型，也是动物类型。这就是狗对象的多态性。
代码实现：
abstract class Animal
{
abstract void eat();
}

class Dog extends Animal
{
public void eat()
{
  System.out.println("骨头");
}
public void lookHome()
{
  System.out.println("看家");
}
}

class Demo2
{
public static void main(String[] args)
{
   Animal a = new Dog();//多态向上转型：其实是可以对子类对象的功能进行限定，仅使用父类型的基本功能即可。
   method(a);//当定义了很多狗，需要统一给狗吃饭，这时就可以定义一个方法，提高代码的复用性。可以对具体事物的共性类型进行统一操作，将复杂问题简单化。
}
public static void method(Animal a)
{
  a.eat();
}
}

楼上正解，新人混脸熟。

多态：可以理解为事物存在的多种体现形态
1：多态的体现，父类的引用指向自己的子类对象，父类的引用也可以接受自己的子类对象
2：多态的好处，大大提高了程序的扩展性
3：多态的前提，必须是类与类之间有关系，要么继承要么实现。通常还有一个前提，存在覆盖：
4：多态的弊端，提高了扩展性，但是只能使用父类的引用访问父类的成员。
5：多太的应用；在编译时期：参阅引用型变量所属的类中是否有调用方法，如果有，编译通过，如果没

有编译失败。在运行时期：参阅对象所属的类中是否有调用方法。简单总结就是成员函数在多态调用时
编译看左边，运行看右边（非静态函数）；对于静态函数来讲，
在多态中成员变量的特点，无论编译和运行都参考左边，引用型变量所属的类。
在多态中静态成员函数的特点，无论编译和运行都参考左边。
abstract class Student()
{
   abstract void study();
   void sleep(){
System.out.println("躺着睡觉");
  }
}
class BaseStudent extends Student
{
   public void study()
  {
    System.out.println("base...... study");

}
   public void shixi()
{
   System.out.println("基础班学生在实习.....");
}
}
class DuoTaiTest
{
  public static void main(String[] args){
   Student s=new BaseStudent();
   s.study();
   BaseStudentbs=(BaseStudent)s;
   bs.shixi();
   
}

}