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

本文探讨了Java中的多态性，包括其概念、前提条件、好处与坏处，以及转型操作。强调了多态在提高程序扩展性方面的优势，并通过实例解释了如何在实际场景中应用多态，如学生类的层次结构和电脑运行示例。同时，提到了在多态环境下成员函数、成员变量和静态成员函数的特点。最后，提到了Object类中的equals()和toString()方法的重写及其应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
多态：可以理解为事物存在的多种体现形态
1.多态的体现
父类的引用指向了自己的子类对象，父类的引用也可以接受自己的
子类对象，如

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.多态的应用
需求：基础班学生–学习、睡觉
高级班学生—学习、睡觉

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.需求：电脑运行实例，电脑运行基于主板

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、关闭数据库连接

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:是所有对象的直接或间接父类，该类中定义的是所有对象都
具备的功能

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

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

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

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()方法

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()));//返回对象的哈希值十六进制

    }
}