多态

多态的含义是：对外一种表现形式，内在有多种具体实现。

Java中多态的具体体现 方法重载 方法覆盖 多态参数。

例如

package com.zr.duotai.text;

import java.util.Date;
public class Feed implements f{
 public void hava(){
        System.out.println(A+B+C);    
    };
    public static void main (String [] args){
        Person p=new Person();
        Dog88 d=new Dog88();
        p.feed(d);
        Cat88 c=new Cat88();
        p.feed(c);
     Feed l=new Feed();  
     l.hava();
     //Date date=new Date();
     Date date1 = new Date();
     long t = date1.getTime();
     Date date = new Date(t);
    //用t实例化一个date对象
     System.out.println(date);//输出时间 
    }
    void setTime(){
        
    }
}
class Animal88{
    int aa=12;
    void eat(){
        System.out.println("yibanshiwu");
    }
    }
    

class Dog88 extends Animal {
     static int aa=22;
    void eat(){
        System.out.println("狗吃骨头，是大事");
    }    
}
class Cat88 extends Animal{
    int aa=32;
    void eat(){
        System.out.println("猫吃鱼，是小事");
    }
}
class Person{
    void feed(Animal animal){  //参数多态
        System.out.println();
        animal.eat();    
    }
}
interface h{
    int A=22;
}
interface c{
    int B=22;
}
interface d{
    int C=22;
}
interface f extends h,c,d{
    abstract  void hava();
}
多态实质：编译期与运行期不同。
当编译器类型是父类，运行期类型是子类时，被称为父类引用指向子类对象

class  Animal{
               …… 
}
class Cat  extends Animal{
               ……
}
class Dog extends Animal {
               ……
}
Cat m = new Cat() 
Animal x = new Cat()  //Animal 的引用指向Cat的对象
在继承关系中变量不存在多态，变量是子类隐藏了父类变量。多态一般都发生在方法的重载（方法不能用static修饰）。
向上转型

class Animal{
     abstract void eat();
}
class Cat extends Animal{
      void look() {
    System.out.println("看家");
     }
    }      
 ………
   Animal x=new Cat()  //向上造型，Cat对象提升到Animal对象
   x.eat()   //只能使用父类中的方法
   x.look()  //报错！不能使用子类中的方法

向下造型

class Animal{
     abstract void eat();
}
class Cat extendsAnimal{
      void look() {
        System.out.println("看家");
        }
    }      
 ………
Animal x=new Cat()
Cat  m=(Cat)x;  //向下转型
   m.eat() ;
   m.look();//子父类中的方法都可以使用