多态

多态：

指的是一个事物,在不同时刻状态的一个体现!
Dog d = new Dog();//创建了一个狗类的对象
Animal a = new Dog();狗是一个动物

多态的前提条件:

1)必须有继承关系
2)继承一个类的同时,子类中必须有方法重写(使用子类中的方法去覆盖父类中的方法)
动物类:吃和睡的功能,子类重写父类的方法的原因:使用子类中有具体的功能..
3)父类的引用指向子类对象
* 继承的时候:使用子类的:Zi z = new Zi() ;
* Fu f = new Zi() ;将f代表的父类引用指向堆内存的子类的对象!
* 向上转型!

多态中的成员访问特点:

成员变量: 编译看左,运行看左!
非静态成员方法:编译看左,运行看右
： 子类中的方法会覆盖掉父类中的方法
静态的成员方法:编译看左边,运行看左边
(静态和类有关系)
构造方法:始终是给对象进行初始化的!..

多态的弊端:

子类只能使用父类的功能:不能使用子类中特有的功能!
* 要想使用子类具体功能
* 1)创建子类对象
* 2)向下转型:将父类的引用强制转换为子类对象
* Zi z = (Zi)(f) ;//还原成子类对象

关于多态的代码练习

class Fu{
    public int num = 20 ;
    public Fu(){}

    public void show(){
//      System.out.println(num);
        System.out.println("show Fu....");
    }   
     static void method(){
        System.out.println("method Fu....");
    }
}
class Zi extends Fu{
    //子类中的成员变量
    int num = 30 ;                      //成员变量:编译看左,运行看左!
    public void show(){                 //非静态成员方法:编译看左,运行看右
//      System.out.println(num);
        System.out.println("show Zi....");
    }

    public static void method(){        //静态的成员方法，所以编译看左边,运行看左边
        System.out.println("show method...");
    }
    public Zi(){        
    }   
//  public void function(){
//      System.out.println("function....");
//  }
}

public class DuoTaiDemo {
    public static void main(String[] args) {
        //创建对象的时候:
        //属于继承版:使用子类对象
//      Zi z = new Zi() ;
//      System.out.println(z.num);      
        //继承中的多态的情况!
        Fu f = new Zi() ;
        System.out.println(f.num);      //结果是20
        f.show();          //结果是show Zi....
        f.method();         //结果是method Fu....

//      f.function() ;
    }
}

多态的弊端:

• 父类对象不能访问子类特有功能!
• 
  
  • 解决 方案:
• 1)创建子类对象,调用本类自己的方法(这种方式不好,从内存角度考虑,耗内存)
• 2)不创建子类对象了,可不可以使用子类对象呢?
• 可以,父类的引用指向子类对象,—->把父类的引用强制转换为子类对象
• 
  
  • 向下转型!
• Fu f = new Zi() ;向上转型
• Zi z = (Zi)(f) ;//向下转型

相关代码：

class Father{
    public void show()  {
        System.out.println("show Father...");
    }
}

//子类
class Son extends Father{
    public void method(){
        System.out.println("method Son...");
    }

    public void show(){
        System.out.println("show Son.....");
    }
}
//测试类
public class DuoTaiDemo {
    public static void main(String[] args) {
        //多态前提条件:父类的引用指向子类对象
        Father f = new Son() ;         
        f.show();                           //show Son.....

//      f.method();//method()是子类的特有功能

//      Son s = new Son() ;
//      s.method();
//      s.show(); 
        System.out.println("-----------------");
        //向下转型
        Son s = (Son) f ;
        s.method();            //method Son...
        s.show();               //method Son...     
    }
}

孔子装爹案例

        class 孔子爹{
            public int age = 40 ;

            public void teach(){
                System.out.println("讲JavaEE");
            }
        }

        class 孔子  enxtends 孔子爹{
            public int age = 20 ;

            public void teach(){
                System.out.println("讲论语");
            }

            public void palyGame(){
                System.out.println("玩英雄联盟...");
            }
        }
//孔子爹由于请请他讲课的 人非常多,孔子感觉也去别人家讲课,
    戴上一副眼镜,粘上胡子,然后开始装爹

    //向上转型
    孔子爹    k爹  = new 孔子();
    Sop(k爹.age) ; //40 :编译看左,运行看左
    k爹.teach(); //讲论语

    //孔子讲完课回来,脱下爹的装备
    //向下转型
    孔子 k  = (孔子)k爹;
    Sop(k.age)//20
    k.teach();//讲论语
    k.playGame();//玩游戏

关于多态的练习2

public abstract class Animal {
    //成员变量
    private String name;
    private int age;
    private String color;

    //无参
    public Animal(){    
    }
    //有参
    public Animal(String name,int age,String color){
        this.name = name;
        this.age = age;
        this.color = color;
    }
    //set()/get()
    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 String getcolor(){
        return color;
    }
    public void setcolor(String color){
        this.color = color;
    }

    //抽象方法
    public abstract void eat();
    public abstract void sleep();
}

public class Cat extends Animal {
    //无参构造
    public Cat(){
        super();
    }
    //有参构造
    public Cat(String name,int age,String color){
        super(name,age,color);
    }

    @Override
    public void eat(){
        System.out.println("猫吃老鼠");
    }
    @Override
    public void sleep(){
        System.out.println("猫躺着睡觉");
    }

    public void playGame(){
        System.out.println("猫喜欢在书上玩");
    }

}

public class Dog extends Animal {
    //无参构造
    public Dog(){
        super();
    }
    //有参构造
    public Dog(String name,int age,String color){
        super(name,age,color);//访问父类的构造方法
    }
    @Override
    public void eat(){
        System.out.println("狗吃骨头");
    }

    @Override
    public void sleep(){
        System.out.println("狗躺着睡觉");
    }

    public void loolDoor(){
        System.out.println("狗看门");
    }
}

public class AbstractTest {
    public static void main(String[] args){
        //创建对象
        //无参的方法
        Animal a = new Dog(); //抽象类多态
        a.setname("柯基");
        a.setage(4);
        a.setcolor("橙灰");
        System.out.println(a.getname()+"-----"+a.getage()+"-----"+a.getcolor());
        a.eat();
        a.sleep();
    //  a.loolDoor();    错误 因为Animal里面没有loolDoor这一项

        //有参的构造方法
        Dog d = new Dog("泰迪",5,"黄毛");
        System.out.println(d.getname()+"-----"+d.getage()+"-----"+d.getcolor());
        d.loolDoor();

        Animal b = new Cat();
        b.setname("Tom");
        b.setage(3);
        b.setcolor("白色");
        System.out.println(b.getname()+"---"+b.getage()+"----"+b.getcolor());
        b.eat();
        b.sleep();
        //有参构造
        Cat c = new Cat("Bob",4,"灰色");
        System.out.println(c.getname()+"----"+c.getage()+"----"+c.getcolor());
        c.playGame();
    }
}