黑马程序员--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
4000
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());
}
}