黑马程序员——多态

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

定义：某一类事物的多种存在的形态
例如： 动物中 猫 狗

  猫 x = new 猫();

同时猫也是动物中的一种，也可以把猫成为动物。

动物 y = new 猫();

动物是猫狗具体事物中抽取出来的父型
父型引用指向了子类对象

例如 函数：重载跟覆盖，就是函数的多态性体现

1.多态的体现
父类的引用指向了自己的子类对象 【动物c=new猫();】
父类的引用也可以接收自己的子类对象

2.多态的前提
必须是类与类之间有关系，要么继承，要么实现。

3.多态的【好处】
多态的出现大大的提高了程序的扩展性
通常还有一个前提：存在覆盖。
【弊端】：只能访问父类中的成员

4.多态的应用

abstract class Animal//动物的共性行为
{
    abstract void eat();//共性行为【吃】的方法不确定，抽象【强制】

}

class Cat extends Animal
{
    public void eat()
    {
        System.out.println("吃鱼");
    }
    public void catchMouse()
    {
        System.out.println("抓老鼠");
    }
}
class Dog extends Animal
{
    public void eat()
    {
        System.out.println("吃骨头");
    }
    public void KanJia()
    {
        System.out.println("看家");
    }
}

class Pig extends Animal
{
    public void eat()
    {
        System.out.println("饲料");
    }
    public void gongdi()
    {
        System.out.println("拱地");
    }
}



class DuoTaiDemo

{
    public static void main(String[] args) 
    {
        //Cat c = new Cat();
        //c.eat();

        //Dog d = new Dog();
        //d.eat();
        /*
        Cat c = new Cat();
        //c.eat();

        Cat c1 = new Cat();       [code]00[/code]
        //c1.eat();
        function(c1);

        function(new Dog());
        function(new Pig());
        */
         //Cat c = new Cat();//不是多态
        //Animal c = new Cat();//一个对象具备多种形态造成的，既是猫类型 同时也是动物类型
        //c.eat();
        function(new Cat());
        function(new Dog());
        function(new Pig());
    }
    public static void function(Animal a)//Animal a = new Cat();
    //提高代码的扩展性
    {
        a.eat();
    }
    /*
    public static void function(Cat c)//Cat c= new Cat();
    {
        c.eat();
    }
    public static void function(Dog d)
    {
        d.eat();
    }
        public static void function(Pig p)
    {
        p.eat();
    }
    */

}

class DuoTaiDemo2

{
    public static void main(String[] args) 
    {
        Animal a = new Cat();//类型提升。byte b =2; int x =b;  b提升为int类型
        //将猫提升为了动物。向上转型
        a.eat();
        //如果想要调用猫的特有方法时，如何操作？
        //Cat c = new Cat();//又新建了一个对象不是原对象
        //可以将 强制将父类的引】用，转成了子类类型。 向下转型
        Cat c =(Cat)a;// 【左边】 为要转换的类型
        c.catchMouse();
    /*
    //【合起来的这两句就是错误的，先建立了一个动物的对象，不确定是什么动物，然后把动物变成 猫，这个是不符合逻辑的】
        Animal a = new Animal();
        Cat c =(Cat)a;
        【千万不要出现如此操作，将父类对象转成子类类型】，猫是动物，但动物不一定是猫。

        我们能转换的是父类的引用指向了自己子类的对象是，有【明确的对象】，那该引用可以被提升也可以被强制转换。
        简单的说 知道了对象是【猫】了，那根据程序的要求，猫的属性【既是动物】，【又是猫】

        多态自始至终都是【子类对象】在做变化

    */

    }
    public static void function(Animal a)//Animal a = new Cat();
    {
        a.eat();
    }



}

在多态中成员函数的特点（非静态 重写特性）
在【编译】时期：参阅【引用型】变量所属类型红是否有调用的方法，如果有编译通过，如果没有则失败
在【运行】时期：参阅【对象】所属的类中是否有调用的方法

简单点总结就是：成员函数在多态调用时，编译看左边，运行看右边。

子类访问父类，子类有的就访问自己的，没有就找父类的，父类没有编译失败。
局部有的变量，就看局部的，局部没有就找成员的，成员没有找父类，父类也没有就要失败

特殊一：
在多态中成员变量的特点
无论编译或者运行都是参考左边（引用型变量所属的类）

特殊二：
在多态中，【静态】成员函数的特点，无论是编译或者运行都是参考左边。

/*
需求：
电脑运行实例
电脑运行基于主板

//正常的写法


class MainBoard
{
    public void run() 
    {
        System.out.println("mianboarid run");
    }
    public void useNetCard(NetCard c)//方法名上下一致。注意大小写 
    {
        c.open();
        c.close();
    }

}

class NetCard
{
    public void open()
    {
        System.out.println("nercard open");
    }
    public void close()
    {
        System.out.println("nercard close");
    }

}

class  DuoTaiDemo5//文件名保持一致
{
    public static void main(String[] args) 
    {
        MainBoard mb = new MainBoard();
        mb.run();
        mb.useNetCard(new NetCard());
    }
}

*/
//接口的写法

interface PCI//接口的出现增加了功能的扩展，多态的应用增加了程序的扩展性
{
    public void open();
    public void close();
}

class MainBoard
{
    public void run()
    {
        System.out.println("mainboard run");
    }
    public void usePCI(PCI p)//PCI p = new NetCard();// 接口型对象指向了自己的子类对象
    {
        if(p!=null)
        {
            p.open();
            p.close();
        }

    }
}

class NetCard implements PCI//扩展保持规则
{
    public void open()
    {
        System.out.println("nercard open");
    }
    public void close()
    {
        System.out.println("nercard close");
    }

}
class SoundCard implements PCI//扩展保持规则
{
    public void open()
    {
        System.out.println("SoundCard open");
    }
    public void close()
    {
        System.out.println("SoundCard close");
    }
}


class DuoTaiDemo5//文件名保持一致
{
    public static void main(String[] args) 
    {
        MainBoard mb = new MainBoard();
        mb.run();
        mb.usePCI(null);
        mb.usePCI(new NetCard());
        mb.usePCI(new SoundCard());
    }
}

/*
    视屏 104
需求：数据库的操作
1.连接数据库 JDBC  Hibernate
2.操作数据库
    c cteate r read u upad d delete
3.关闭数据库
*/
interface UseInfoDao
{
    public void add(User user);
    public void delete(User user);
}



class UseInfoByJDBC implements UseInfoDao //实现接口功能
{
    public void add(User user)
    {
        1.JDBC连接数据库；
        2.使用sql 添加语句 添加数据；
        3.关闭连接；
    }

    public void delete(User user)
    {
        1.JDBC连接数据库；
        2.使用sql 删除语句 删除数据；
        3.关闭连接；
    }
}

class UseInfoByHibernate implements UseInfoDao实现接口功能
{
    public void add(User user)
    {
        1.Hibernate连接数据库；
        2.使用sql 添加语句 添加数据；
        3.关闭连接；
    }

    public void delete(User user)
    {
        1.Hibernate连接数据库；
        2.使用sql 删除语句 删除数据；
        3.关闭连接；
    }
}




class  DBoperate//使用功能
{
    public static void main(String[] args) 
    {
        //UseInfoByJDBC ui = new UseInfoByJDBC();
        UserInfoDao ui =  ；
        ui.add(user);
        ui.delete(user);
    } 
}

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-