java的多态性太难理解了能不能详细的解释下

多态是指在执行期间（——而非编译期间——）判断所引用的对象的实际类型，并且根据其实际类型调用他的相应方法。多态的存在使程序的扩展性达到了最好的层次。要实现多态必须具备3个条件：1.要有继承2.要有重写3.要有父类引用指向子类对象，三个条件缺一不可！我也是新手举个可能不太合适的小例子：有一个Animal类其中有一个enjoy（）方法，他有若干子类比如Cat、Dog（都重写了enjoy方法）...还有一个Person类，有一个构造方法：Person（string name，Animal animal），还定义了一个方法petenjoy（） {animal.enjoy()}，在这个构造方法中，我们不必仅仅只能传Animal类型的参数，我们也可以传他的子类，并且假如当我们new Person（"Miss Li”，new Dog dog()），并调用petenjoy方法时，会自动的调用dog的enjoy方法。总之，多态是为了增强程序的扩展性。说的可能不清楚，但是希望能对你有帮助。

多态是对不同对象，产生不同处理。
多态体现多种多样，函数重载，传入不同参数，调用不同函数。
模板函数，模板类，模板接口，可以处理传入限定的不同类型对象。
覆盖：同一函数，子类处理不同于父类。
还有接口，虚基类，同一函数，在不同的子类中，有不同实现方式。

package 案例;

public class Test{

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                Animal an=new Cat();
                an.Cry();
                an=new Dog();
                an.Cry();
                Master master =new Master();
                master.Feed(new Dog(), new Bone());
                master.Feed(new Cat(), new Fish());
        }

}
class Master
{
        //使用多态喂食
        public void Feed(Animal an,Food f)
        {
                an.eat();
                f.ShowName();
        }
}
class Food
{
        String name;
        public void ShowName()
        {}
}
class Fish extends Food
{
        public void ShowName()
        {
                System.out.println("鱼!!!");
        }
}
class Bone extends Food
{
        public void ShowName()
        {
                System.out.println("骨头!!!");
        }
}
class Animal
{
   private String name;
   private  int age;
public String getName() {
        return name;
}
public void setName(String name) {
        this.name = name;
}
public int getAge() {
        return age;
}
public void setAge(int age) {
        this.age = age;
}
public void Cry()
{
        System.out.println("不知道怎么叫!!!");
}
public void eat()
  {
        System.out.println("不知道!!!");
  }

}

class Cat extends Animal
{
        public void eat()
    {
        System.out.println("猫爱吃鱼!!!");
    }
        public void Cry()
        {
                System.out.println("喵喵叫!!!");
        }
}
class Dog extends Animal
{
        public void eat()
        {
                System.out.println("狗爱吃骨头!!!");
        }
        public void Cry()
        {
                System.out.println("旺旺叫!!!");
        }
}

看个代码会比较好理解吧

多态的定义：将参数定义为一个父类，各子类中都重写了父类的方法，在方法中用传入的父类对象调用这个方法，当传入什么子类时就会调用相应的各子类的方法。
多态存在的条件:有继承，有重写，父类引用指向子类对象。一旦满足，当父类里被重写的方法时，实际new的哪个子类对象，就调用子类对象方法。
父类引用指向子类对象解释：
A a = new B() ;
A是我们的引用类型，他是父类，B是子类。
a是一个子类对象，但是引用的是父类的类型。
举例：
//定义父类
abstract class Animal {
  private String name;
  Animal(String name) {
   this.name = name;
   }
  
  public void enjoy(){
    System.out.println("叫声......");
  }
  
// public abstract void enjoy();
}
//定义Cat类继承Animal
class Cat extends Animal {
  private String eyesColor;
  Cat(String n,String c) {
   super(n);
   eyesColor = c;
   }
  
  public void enjoy() {
    System.out.println("猫叫声......");
  }
  
  //public abstract void enjoy();
}
//定义dog类继承Animal
class Dog extends Animal {
  private String furColor;
  Dog(String n,String c) {
   super(n);
   furColor = c;
   }

  public void enjoy() {
    System.out.println("狗叫声......");
  }
}
//定义Bird类继承Animal
class Bird extends Animal {
  Bird() {
    super("bird");
  }
  public void enjoy() {
    System.out.println("鸟叫声......");
  }
}
//定义一个人物类
class Lady {
    private String name;
    private Animal pet;
    Lady(String name,Animal pet) {
        this.name = name; this.pet = pet;
    }
    public void myPetEnjoy(){
     pet.enjoy();
     }
}
//测试类
public class Test {
    public static void main(String args[]){
        Cat c = new Cat("catname","blue");
        Dog d = new Dog("dogname","black");
        Bird b = new Bird();
        Lady l1 = new Lady("l1",c);
        Lady l2 = new Lady("l2",d);
        Lady l3 = new Lady("l3",b);
        l1.myPetEnjoy();
        l2.myPetEnjoy();
        l3.myPetEnjoy();
    }
}
//上面程序人的构造方法中传的参数是Animal类型，但是我们在测试类中传入的参数分别是Cat,Dog还有Bird
//对象，每个人l1,l2,l3在调用自己的myPetEnjoy（）方法时候，会根据自己宠物的不同而输出不同的叫声；
//此列中有继承（Cat,dog,bird都是继承animal），有重写（都重写了enjoy()方法），有父类的引用指向子类对象（Lady的构造方法中
//参数是父类的引用，实际传入的参数是子类对象）

多态:可以理解为实物存在的多种体现形态。
  (貌似多态就是事物子类或是下级的细分，可以分出多种种类，看起来就是它的多种形态)。
  函数的重载与覆盖也是多态。
  
  1.多态的体现
   a.父类引用指向子类对象。
   b.父类的引用也可以接收自己的子类对象。
  2.多态的前提
   必须是类与类之间有父子关系（继承或是实现）。
   父类引用指向子类对象，但在使用子类对象方法功能时，必须是自己中也有该方法（功能）的定义。
  3.多态的好处
   a.多态的出现大大的提高了程序的扩展性。
  4.多态的弊端
   提高了扩展性，但是只能使用父类的引用访问父类中已有的成员。

这里我说下：1.朋友多态性并不是java独有，而是所有oop都具有的特性。
                  2.oop的另外2个特性是封装和继承
下面我来浅谈下3大基本特征：
        封装表现为对对象的属性用private进行修饰，使其对外部不可见，而只是通过setter和getter方法来对其进行操作。
继承的主要的功能是用于扩展父类的功能。
多态是面向对象语言中最重要的，掌握了多态，有助于理解各种设计模式。方法的重载和覆盖都体现了多态的性质，这都比较好理解，也就没必要做过多记录了。面向对象的多态性的另一块体现就是对象的多态，就自身而言，感觉掌握好了对象的多态，程序的很多结构都能理解和把握了。
对象的多态分为向上转型和向下转型两种，子类对象向父类对象转换，为向上转型；父类对象向子类对象转换，为向下转型。向上转型为自动转型（父类对象=子类对象），向下转型为强制转型（子类对象=（子类对象）父类对象）。
以下为一个初步描述面向对象的封装、继承与对象的多态性的例子：
package com.mytest.test;
abstract class Person{
//对抽象类Person类中的属性进行封装
private String name;
private int age;
public Person(String name,int age){
  this.setName(name);
  this.setAge(age);
}
//定义操作Person属性的getter和setter方法
public String getName() {
  return name;
}
public void setName(String name) {
  this.name = name;
}
public int getAge() {
  return age;
}
public void setAge(int age) {
  this.age = age;
}
    public abstract void walk();
public String say(){
  System.out.println("父类say()方法。。。");
  return "姓名："+this.name+"，年龄："+this.age;
}
}
class Student extends Person{
//对score进行封装
private int score;
    public Student(String name,int age,int score){
     super(name,age);
     this.setScore(score);
    }
    //操作score属性的getter和setter方法
public int getScore() {
  return score;
}
public void setScore(int score) {
  this.score = score;
}
public void walk(){
  System.out.println("此方法覆盖了父类的抽象方法。。。");
}
public String say(){
  System.out.println("子类say()方法。。。");
  //通过super调用父类的say()方法
  return super.say()+"，数学分数："+this.score;
}
public void test(){
  System.out.println("在子类中定义的一个父类中没有的方法");
}
}
public class Test {
    public static void main(String[] args){
     Person p=new Student("赵六",18,90);//此为对象的向上转型
     //test()方法对p不可见，即p无法调用test()方法
     p.walk();
     //p调用的是覆写过后的say()方法，即子类中的say()方法
     System.out.println(p.say());
//     Student s=(Student)p;//此为对象的向下转型
    }
}

希望能帮助你！

多态是指某一事物有不同的具体的体现。
多态的好处是可以提高程序的扩展性。
多态的前提：       
           1：必须要有关系，比如继承、或者实现。
        2：通常会有覆盖操作。
多态中成员的特点：
                Fu f = new Zi();
                1：成员变量：编译和运行都看Fu。
                2：非静态方法：编译看Fu，运行看Zi。
                3：静态方法：编译和运行都看Fu。
具体实例看楼上

java中的多态，可以总结它为：

    一、使用父类类型的引用指向子类的对象；

    二、该引用只能调用父类中定义的方法和变量；

    三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）

    四、变量不能被重写（覆盖），”重写“的概念只针对方法。