黑马程序员--Java基础学习(面向对象)第八天

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

Java基础学习(面向对象)第八天

一,多态

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

动物：猫，狗。

猫 x = new 猫();

动物 x = new 猫();

1，多态的体现

      父类的引用指向了自己的子类对象。

      父类的引用也可以接收自己的子类对象

2，多态的前提

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

      通常还有一个前提：存在覆盖。

3，多态的好处：

      多态的出现大大的提高了程序的扩展性。

4，多态的弊端：

      提高了扩展性，但是只能使用父类的引用访问父类中的成员。

   

   /*
	动物，
	猫，狗。
	*/
abstract class Animal
{
            abstractvoid eat();
}
 
class Cat extends Animal
{
            publicvoid eat()
            {
                  System.out.println("吃鱼");
            }
            publicvoid catchMouse()
            {
                  System.out.println("抓老鼠");
            }
}
 
class Dog extends Animal
{
            publicvoid eat()
            {
                  System.out.println("吃骨头");
            }
            publicvoid kanJia()
            {
                  System.out.println("看家");
            }
}
 
class Pig extends Animal
{
            publicvoid eat()
            {
                  System.out.println("饲料");
            }
            publicvoid gongDi()
            {
                  System.out.println("拱地");
            }
}
 
//------------------------------------------------
class  DuoTaiDemo
{
            publicstatic void main(String[] args)
            {
                  /*Catc = new Cat();
                  c.eat();
 
                  Dogd = new Dog();
                  d.eat();
                  function(newDog());
                  */
 
                  //Animal c =  new Cat();
                  //c.eat();
                  function(newCat());
                  function(newDog());
                  function(newPig());
 
Animal a = new Cat();//类型提升。byte b= 2; int x = b;b提升为int型。向上转型。
                  a.eat();
 
                  //如果想要调用猫的特有方法时，如何操作？
                  //强制将父类的引用。转成子类类型。向下转型。
                  Catc = (Cat)a;
                  c.catchMouse();
                  //千万不要出现这样的操作，就是讲父类对象转换成子类类型。
//我们能转换的是父类引用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。
                  //多态自始至终都是子类对象在做着变化
                  //    Animal a = new Animal();
                  //    Cat c = (Cat)a;
                  /*
                  毕姥爷 x = new 毕老师();
                  x.讲课();
                 
                  毕老师 y = (毕老师)x；
                  y.看电影();
                  */
            }
            public static void function(Animala)//提高代码扩展性
            {
                  a.eat();
                  if(a instanceof Cat)//判断类型是不是Cat。
                  {
                        Cat c = (Cat) a;
                        c.catchMouse();
                  }
                  else if(a instanceof Dog)
                  {
                        Dog d = (Dog) a;
                        d.kanJia();
                  }
                  //a.catchMouse();不允许。
            }
            /*
            publicstatic void function(Cat c)
            {
                  c.eat();
            }
            publicstatic void function(Dog d)
            {
                  d.eat();
            }
            */
}

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

在编译时期：参阅引用型变量所属的类型中是否有调用的方法。如果有，编译通过，如果没有编译失败。

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

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

在多态中成员变量的特点：

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

在多态中，静态成员函数的特点：

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

二，Object类

      object:是所有对象的直接或者间接父类，传说中的上帝。

该类中定义的肯定是所有对象具备的功能。

Object类中已经提供了对对象是否相同的比较方法。

如果自定义类中也有比较相同的功能，没有必要重新定义。

只要沿袭父类中的功能，建立自己特有的比较内容即可。这就是覆盖。

class Demo //extends Object
{
  private int num;
  Demo(int num)
  {
        this.num = num;
  }
  //public boolean compare（Demo d）
  public boolean equals(Objectobj)//Object obj = d2;
  {
if(!(obj instanceof Demo))//要有判断和类型转换的过程。因为变量的获取是按左边类型判断的。
              return false;
        Demo d =(Demo) obj;
        return this.num ==d.num;
  }
}
class Person
{
}
class ObjectDemo
{
  public static voidmain(String[] args)
  {
        Demo d1 = new Demo(4);
        Demo d2 = new Demo(6);
        Demo d3 = d1;
        System.out.println(d1.equals(d2));
        System.out.println(d1==d2);
        System.out.println(d1==d3);
 
        System.out.println(d1.equals(d2));
 
        System.out.println(d1.toString());
        System.out.println(Integer.toHexString(d1.hashCode()));
 
        Class c =d1.getClass();
        System.out.println(c.getName());
  }
}