黑马程序员——java第八天：面向对象（多态、Object-equals&-toString）

-------
android培训、java培训、期待与您交流！ ----------

多态：

定义：某一类事物的多种存在形态。
例：动物中猫，狗。
猫这个对象对应的类型是猫类型
猫x = new猫();
同时猫也是动物中的一种，也可以把猫称为 动物。
动物y = new猫();//向上转型
动物是猫和狗具体事物中抽取出来的父类型。
父类型引用指向了子类对象。

1、
多态的体现：

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

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

2、多态的前提

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

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

3、多态的好处

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

4、多态的弊端：

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

如何使用子类特有方法­（转型）？

publicclass DuoTaiDemo {

publicstaticvoid main(String[] args)

{

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

//a.eat();

//如果想要调用猫的特有方法时，如何操作？

//强制将父类的引用。转成子类类型。向下转型。

///Cat c = (Cat)a;

//c.catchMouse();

//千万不要出现这样的操作，就是将父类对象转成子类类型。

//我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。

//多态自始至终都是子类对象在做着变化。

//         Animal a = new Animal();

//         Cat c = (Cat)a;

function(new Dog());

function(new Cat());

}

publicstaticvoid function(Animal a)//Animal a = new Cat();

{

a.eat();//因为父类中只有eat方法，所以正多态中只能调用这个方法。

/*

if(a instanceof Animal)//这个判断不管a是谁（Cat、Dog、Pig）都是正确的true

{

System.out.println("haha");

}

*/

if(a instanceof Cat)

{

Cat c = (Cat)a;//通过向下转型，转为子类引用，就可以用子类特有方//法了

c.catchMouse();

}

elseif(a instanceof Dog)

{

Dog c = (Dog)a;

c.kanJia();

}

/*

instanceof : 用于判断对象的类型。对象 intanceof类型(类类型接口类型)

*/

}

}

abstractclass Animal{

publicabstractvoid 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("拱地");

}

}

例子：

/*

基础班学生：

学习，睡觉。

高级班学生：

学习，睡觉。

可以将这两类事物进行抽取。

*/

abstract class Student

{

publicabstract void study();

publicvoid sleep()

{

System.out.println("躺着睡");

}

}

class DoStudent

{

publicvoid doSome(Student stu)

{

stu.study();

stu.sleep();

}

}

class BaseStudent extends Student

{

publicvoid study()

{

System.out.println("basestudy");

}

publicvoid sleep()

{

System.out.println("坐着睡");

}

}

class AdvStudent extends Student

{

publicvoid study()

{

System.out.println("adv study");

}

}

class DuoTaiDemo3

{

publicstatic void main(String[] args)

{

DoStudentds = new DoStudent();

ds.doSome(newBaseStudent());

ds.doSome(newAdvStudent());

//               BaseStudentbs = new BaseStudent();

//               bs.study();

//               bs.sleep();

//               AdvStudentas = new AdvStudent();

//               as.study();

//               as.sleep();

}

}

多态成员的特点：

1、成员函数(非静态)：编译时：要查看引用变量所属的类中是否有所调用的成员。

在运行时：要查看对象所属的类中是否有所调用的成员。

终而言之：成员函数在多态调用时，编译看左边，运行看右边

2、 成员变量：只看引用变量所属的类。

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

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

package e1;

class Fu

{

intnum = 5;

staticintnum1 = 3;

void method1()

{

System.out.println("fumethod_1");

}

void method2()

{

System.out.println("fumethod_2");

}

staticvoid method4()

{

System.out.println("fumethod_4");

}

}

class Zi extends Fu

{

intnum = 8;

staticintnum1 = 6;

void method1()

{

System.out.println("zimethod_1");

}

void method3()

{

System.out.println("zimethod_3");

}

staticvoid method4()

{

System.out.println("zimethod_4");

}

}

publicclass  DuoTaiDemo4

{

publicstaticvoid main(String[] args)

{

//     Fu f = new Zi();//2、在多态中，成员变量特点：

//     System.out.println(f.num);

//     Zi z = new Zi();

//     System.out.println(z.num);

//f.method1();//1、在多态中，成员函数(非静态)特点：

//f.method2();

//f.method3();

Fu f = new Zi();//3、在多态中，静态成员函数的特点：

System.out.println(f.num1);

f.method4();

Zi z = new Zi();

z.method4();

//     Zi z = new Zi();

//     z.method1();

//     z.method2();

//     z.method3();

}

}

Object类—equals()

equals(Object b);比较的是地址值。实现其他比较功能要子类覆写。

Object类中已经提供了对对象是否相同的比较方法。如果自定义类中也有比较相同的功能，没有必要重新定义，只需要沿袭父类中的功能，建立自己特有比较内容即可——覆盖。

class Demo //extends Object

{

private int num;

Demo(int num)

{

this.num = num;

}

public booleanequals(Object obj)//Object obj = new Demo();

{

if(!(objinstanceof Demo))

returnfalse;

Demo d =(Demo)obj;

return this.num== d.num;

}

/*

public booleancompare(Demo d)

{

returnthis.num==d.num;

}

*/

public String toString()

{

return"demo:"+num;

}

}

class Person

{

}

class ObjectDemo

{

public static voidmain(String[] args)

{

Demo d1 = newDemo(4);

System.out.println(d1);//输出语句打印对象时，会自动调用对象的toString方法。打印对象的字符串表现形式。

Demo d2 = newDemo(7);

System.out.println(d2.toString());

//Demo d2 = newDemo(5);

//Class c =d1.getClass();

//

//               System.out.println(c.getName());

//               System.out.println(c.getName()+"@@"+Integer.toHexString(d1.hashCode()));

//               System.out.println(d1.toString());

//Person p =new Person();

///System.out.println(d1.equals(p));

}

}

Object类toString（）

任意对象都可以转为字符串，toString（）方法返回一个字符串，该字符串由类名、@、和此对象哈希值的无符号十六进制组成。

返回的字符串等于“getClass().getName()+‘@’+Integer。toHexString（hashCode（））”组成。

------- android培训、java培训、期待与您交流！ ----------详细请查看：http://edu.csdn.net