java 多态

主要内容：一、多态；二、多态中成员的特点；三、多态的主板示例；四、Object类  
一、多态
    1、多态的概念：可以理解为事物存在的多种体现形态。父类引用指向子类对象。
       例：动物 x = new 猫();
    2，多态的体现：
           父类的引用指向了自己的子类对象。
  父类的引用也可以接收自己的子类对象。
    3，多态的前提：
           必须是类与类之间有关系。要么继承，要么实现。
  通常还有一个前提：存在覆盖。
    4，多态的好处：
           多态的出现大大的提高了程序的扩展性。
    5，多态的弊端：
           提高了扩展性，但是只能使用父类的引用访问父类中的成员。
  如果想要访问子类的特有方法或者属性，还要强制让父类引用向下转型。
  所以多态的出现，一致都是子类在来回转换角色，
  向上转型父类引用指向子类对象，或者向下转型，访问子类特有的内容
    6，关键字instanceof：
           instanceof用于判断某个引用是否是某一个类型。


    例：动物：猫，狗。

 

  abstract class Animal
  {
       public 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 DuoTaiDemo
  {
        public static void main(String[] args)
 {
      Animal a = new Cat();//类型提升。向上转型。
      a.eat();
      //如果想要调用猫的特有方法时，如果操作？
      //强制将父类的引用。转成子类类型。向下转型。
      Cat c = (Cat)a;
      c.catchMouse;
 }
 public static void function(Animal a)
 {
      a.eat();
 }
  }

    7，多态的应用——实例：

 

 

       abstract class Student
{
    public abstract void study();
           public void sleep()
    {
          System.out.println("躺着睡");
    }
}
class DoStudent
{
    public void doSome(Student stu)
    {
         stu.study();
     stu.sleep();
    }
}

二、多态中成员的特点：
    1，在多态中，非静态成员函数的特点：
       在编译时期：参阅引用型变量所属的类中是否有调用的方法。
       如果有，编译通过，如果没有编译失败。
       在运行时期：参阅对象所属的类中是否有调用的方法。
       简单总结：成员函数在多态调用时，编译看左边，运行看右边。


    2，在多态中，成员变量的特点：
       无论编译和运行，都参考左边(引用型变量所属的类)。


    3，在多态中，静态成员函数的特点：
       无论编译和运行，都参考左边。


三、多态的主板示例
    需求：电脑运行实例，电脑运行基于主板。

 

 

   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("netcard open");
}
public void close()
{
    System.out.println("netcard close");
}
   }
   class DuoTaiDemo
   {
        MainBoard mb = new MainBoard();
 mb.run();
 mb.usePCI(null);
 mb.usePCI(new NetCard());
   }

四、Object类
    1，Object是类层次结构的根类。每一个类都使用Object 作为超类。
       所有对象(包括数组)都实现这个类的方法。
       Object：是所有对象的直接或者间接父类，传说中的上帝。
       该类中定义的肯定是所有对象都具备的功能。
    
    2，equals()方法：
       Object类中已经提供了对对象是否相同的比较方法：equals();
       如果自定义类中已有比较相同的功能，没有必要重新定义。
       只有沿袭父类中的功能，建立自己特有比较内容即可。这就是覆盖。
       例：

 

 

       class Demo //extends Object
{
     private int num;
     Demo(int num)
     {
         this.num = num;
     }
     public boolean equals(Object obj)//Object obj=new Demo();
     {
          Demo d = (Object)obj;
   return this.num == d.num;
     }
}
class ObjectDemo
{
     public static void main(String[] args)
     {
          if(!obj instanceof Demo))
        return false;
          Demo d1 = new Demo(4);
   Demo d2 = new Demo(4);
   System.out.println(d1.equals(d2));
     }
}

    3，toString()方法：

       返回该对象的字符串表示。

 

   class Demo
   {
       private int num;
Demo(int num)
{
    this.num = num;
}
public String toString()//复写Object的toString()方法
{
    return "demo:"+num;
}
   }
   class ObjectDemo
   {
       public static void main(String[] args)
{
    Demo d1 = new Demo(4);
    System.out.println(d1.toString());
}
   }

 

    4，hashCode()方法：
       返回该对象的哈希值。
    5，getClass()方法：
       返回此Object的运行时类。
       返回值是类Class

       用Class来描述所有的class文件。

 

   class Demo
   {}
   class ObjectDemo
   {
       Demo d = new Demo();
Class c = d.getClass();
System.out.println(c.getName());
System.out.println(Integer.toHexString(d.hashCode()));
System.out.println(d.toString());
   }