黑马程序员——Java基础：多态及其应用

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

多态：可以理解为事物存在的多种体现形态

1.多态的体现

父类的引用指向了自己的子类对象，父类的引用也可以接受自己的

子类对象，如

[code]Animal a = new Cat();

    function(new Cat());
    function(new Dog());     //后期加入代码
    public  static void function(Animal a)
    {
        a.eat();
    }

2.多态的前提

1）必须是类与类之间有关系，要么继承，要么实现；

2）存在覆盖，

3.多态的好处和坏处

好处：多态提高了程序的扩展性

坏处：只能使用父类的引用访问父类中的成员

5.转型

问：如果想要调用子类的特有方法？

答：强制将父类的引用转成子类类型

Animal a = new Cat(); //类型提升，向上转型

Cat c = (Cat) a; //向下转型，转型前要判断一下对象的类型，

if(a instanceof Cat){},即：对象 instanceof 类型。

千万不要将父类对象转成子类类型，我们只能转换的是父类引用

指向自己子类对象时，该引用被提升，也可被强制转换

Animal a = new Animal();//这时a不能提升也不能强制转换

6.多态的应用

需求：基础班学生–学习、睡觉

高级班学生—学习、睡觉

[code]abstract class Student
{
    public abstract void study();
    public void sleep()
    {
        System.out.println("躺着睡");
    }
}
class DoStudent   //工具类
{
    public void doSome(Student stu)
    {
        stu.study();
        stu.sleep();    
    }
}
class BaseStudent extends Student
{
    public  void study()
    {
        System.out.println("base study");
    }
    public void sleep()
    {
        System.out.println("坐着睡");
    }
}
class AdvStudent extends Student
{
    public  void study()
    {
        System.out.println("advance study");
    }
    public void sleep()
    {
        System.out.println("站着睡");
    }
}

class DuoTai
{
    public static void main(String [] args)
    {
        DoStudent ds = new DoStudent();
        ds.doSome(new BaseStudent());
        ds.doSome(new AdvStudent());
    }
}

7.多态成员的特点

1）在多态中非静态成员函数的特点：

编译时期：参阅引用型变量所属的类中是否有调用的方法，如果有

编译通过，如果没有，编译失败

运行时期：参阅对象的类中是否有调用方法

总结：成员函数在多态调用时，编译看左边，运行看右边

2）多态中成员变量的特点：

无论编译和运行，都参考左边（引用型变量所属的类）

3）多态中静态成员函数特点：

无论编译和运行，都参考左边

8.需求：电脑运行实例，电脑运行基于主板

[code]interface PCI    //接口增加了功能扩展
{
    public void open();
    public void close();
}
class MainBoard
{
    public void run()
    {
        System.out.println("mainboard run");
    }
    public void usePCI(PCI p)  //接口型引用指向自己的子类对象
    { 
        if(p!=null)
        {
            p.open();
            p.close();
        }

    }
}
class NetCard implements PCI
{
    public void open()
    {
        System.out.println("netcard open");
    }

    public void close()
    {
        System.out.println("netcard close");
    }
}
class SoundCard implements PCI
{
    public void open()
    {
        System.out.println("soundcard open");
    }
    public void close()
    {
        System.out.println("soundcard close");
    }
}
class DuoTai
{
    public static void main(String [ ] args)
    {
        MainBoard mb = new MainBoard();          
        mb.run();
        mb.usePCI(null);
        mb.usePCI(new NetCard());
        mb.usePCI(new SoundCard());
    }
}

9.需求：对于一个数据库的操作

数据是用户信息

连接JDBC Hibernate、操作crud、关闭数据库连接

[code]interface UserInfoDao
{
    public void add(User user);
    public void delete(User user);
}
class UserInfoByJDBC extends UserInfoDao
{
    public void add(User user)
    {
        1.连接数据库;
        2.使用sql添加语句;
        3.关闭连接;
    }
    public void delet(User user) 
    {
        1.连接数据库;
        2.使用sql添加语句;
        3.关闭连接;
    }
}
class UserInfoHibernate extends UserInfoDao
{
    public void add(User user)
    {
        1.连接数据库;
        2.使用sql添加语句;
        3.关闭连接;
    }
    public void delet(User user) 
    {
        1.连接数据库;
        2.使用sql添加语句;
        3.关闭连接;
    }
}
class DBoperate
{
    public static void main(String [] args)
    {
        //UserInfoByJDBC ub = new UserInfoByJDBC();
        //UserInfoByHibernate uh = new UserInfoByHibernate();
        UserInfoDao ud = new UserInfoByJDBC();
        UserInfoDao ud = new UserInfoByHibernate();
        ud.add();
        ud.delete();
    }
}

10.Object:是所有对象的直接或间接父类，该类中定义的是所有对象都

具备的功能

[code]Object类中已经提供了对对象是否相同的比较方法，只要沿袭父类中的

功能，建立自己特有比较内容即可。

//覆写父类中equals(Object obj)方法的应用

[code]class Demo //extends Object
{
    private int num;
    Demo(int num)
    {
        this.num = num;
    }
    public boolean equals(Object obj)//覆写父类中equals(Object obj)方法
    {
        if(!(obj instanceof Demo))       //判断传入的对象是否正确
            return false;
        else
        {
            Demo d = (Demo)obj;          //类型转换
            return this.num ==d.num;
        }
        Demo d = (Demo)obj; 
        return this.num ==d.num;
    }
}

class ObjectDemo
{
    public static void main(String [ ] args)
    {
        Demo d1 = new Demo(5);
        Demo d2 = new Demo(5);

        System.out.println(d1.equals(d2));
    }
}

结果


//覆写父类中toString()方法

[code]class Demo //extends Object
{
    private int num;
    Demo(int num)
    {
        this.num = num;
    }
    public boolean equals(Object obj)
    {
        Demo d = (Demo)obj; 
        return this.num ==d.num;
    }
    public String toString()
    {
        return "Demo:"+num;
    }
}

class ObjectDemo
{
    public static void main(String [ ] args)
    {
        Demo d1 = new Demo(5);
        System.out.println(d1.toString());//每个对象的字符串表现形式

        Class c = d1.getClass();       //c是类型文件
        System.out.println(c.getName()); //显示对象所属的类

        System.out.println(d1.hashCode());//返回对象的哈希值十进制
        System.out.println(Integer.toHexString(d1.hashCode()));//返回对象的哈希值十六进制

    }
}

结果