面向对象多态

------多态------

1 多态的定义： 就是一种事物的多种形态

2 多态的前提：
    1. 有类的封装
    2. 有类与类之间，继承关系的存在，
    3. 父类引用指向子类对象。
    
3 练习 代码实现多态关系。
    创建 一个Animal 动物类
    再创建一个 Cat 类。继承于 Animal 类。
        猫类和动物类，都实现吃饭的方法。
    
    在测试类中，创建 Cat 类的对象。
        但是要父类引用，指向子类对象的方式。
        调用cat 类的方法。

4  多态关系中，成员访问的特点

    多态关系中：成员访问的特点：

    成员变量： 编译看左边，运行看左边        跟着父类走
    成员方法： 编译看左边，运行看右边         跟着子类走
    静态方法： 编译看左边，运行看左边        跟着父类走
            
        public class Animal {
            public String name  = "神秘动物";
            public  int age;
            public static void sleep(){
                System.out.println("动物会睡觉！");
            }
            public void eat(){
                System.out.println("动物会吃东西！");
            }
        }

        /**
         * 猫类，继承于动物类。
         */
        public class Cat extends Animal {
            public String name  = "小花猫";
            public int age;
            public static void sleep(){
                System.out.println("猫会睡觉！");
            }
            public void eat(){
                System.out.println("猫喜欢吃鱼！");
            }
        }

        public class Test1 {
            public static void main(String[] args) {
                Cat c = new Cat();  // 猫是一只 猫
                System.out.println(c.name);
                c.eat();
                c.sleep();
                    
                //父类引用创建子类对象的方式，创建对象，称之为多态。
                Animal a =  new Cat();    //把猫添加到动物引用。    猫是一只动物
                System.out.println(a.name);
                a.eat();
                a.sleep();
                
            }
        }

5  利用多态的特点，实现方法的重写。

     当我们想使用父类的 属性的时候，        可以用多态，或创建父类对象。
     当我们想使用父类里面的静态方法的时候， 可以使用多态，或创建父类对象
     当我们想使用子类中重写的方法的时候，    可以用多态，或创建本类对象。
     
     
     当我们既向用父类的属性，和静态方法    ！
     又想使用自己特有的方法的时候    ！
     可以多态的形式创建对象——> 
                                父类引用指向子类对象。
                                
                                
                                

6  封装一个父类 father 一个子类，son 
        子类重写父类的方法。 print 打印方法。 手抄        int num =10
        子类里面有独有的方法内容。    打印机打印。        int num = 2000;
        
        测试的是  多态创建对象的情况下， 成员方法访问特点。

        public class Father{        //封装的类
            int num = 10;
            public void print(){
                System.out.println("使用手抄的形式打印");
            }
        }
        public class Son extends Father{    //产生继承关系
            int num = 2000;
            public void print(){    //方法的重写
                System.out.println("使用打印机的方式打印");
            }        
        }
        public class Test{
            public static void main(String[] args){
                Father f = new Son();        //多态的形式创建对象，父类引用指向子类对象
                f.print();
                System.out.println("每小时可以打印份数为："+ f.num);
            }
        }

练习： 超人的练习

        定义一个普通人的类。
                String name = "andy";
                封装一个谈生意的方法。谈10块钱的小单子 talk            
        定义一个超人的类，继承于 普通人的类，
                String name ="SuperMan";
                重写谈生意的方法，谈一个亿的大生意  talk        
                超人类特有方法，会飞 fly
        测试类，测试多态情况下的对象，访问成员方法。
        
        public class Test2{
            public static void main(String[] args){
                Man m = new SuperMan();
                m.talk();
                m.fly();
                System.out.println(m.name);
            }
        }
        class Man{
            String name = "小帅";
            public void talk(){
                System.out.println(name+"谈10块钱的大单子");
            }
        }
        class SuperMan extends Man{
            String name = "超人";
            public void talk(){
                System.out.println(name+"谈1个亿的小单子");
            }
            public void fly(){
                System.out.println("飞出去，谈小单子！");
            }
        }

7  多态向上转型和向下转型的问题

        多态的形成，本身就是父类引用指向子类对象
            就是向上转型的操作        右侧的对象，向上转型为左侧的引用。
        
        向下转型： 类似于基本数据类型的强制转换。
                把父类，强制转化为子类对象。
                
                
        例如：
                Animal a = new Cat();    //猫类向上转型为动物类
                Cat c = (Cat) a;        //动物类向下转型为猫类

                

 练习： 汽车租赁。
 
        car 汽车类。
            汽车的 租金 price  车牌号属性 number
    
            宝马车 继承于 car 类
            
            金龙  继承于 car 类
            
            五菱红光  继承于 car 类
        
        租赁公司类，Master 
         public    Car[] rent(String[] carsName){
             Car[] cars = new Car[4];
                
         }