黑马程序员——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