java笔记10 多态 Object类

1.      多态

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

1.2  多态的体现

父类引用指向子类对象

例：动物中猫，狗。
    猫这个对象对应的类型是猫类型：猫 x = new 猫();
    同时猫也是动物中的一种，也可以把猫称为动物：动物  y = new 猫();
    动物是猫和狗具体事物中抽取出来的父类型。
    当父类型引用指向了子类对象的时候，就产生了多态。

1.3  多态的前提

必须是类与类有关系，继承或者实现。

通常还有一个前提：子类覆盖父类方法。

1.4  示例

public class H_0802Duotai
{
         public static void main(String[] args)
         {
                            function(new Dog());
                            function(new Cat());
                            function(new Pig());
                            Animal a=new Cat();
                            a.eat();
                            //System.out.println(a.x);
         }       
         public static void function(Animal a)
         {
                   a.eat();
         }
}
abstract class Animal
{
         int x=3;   
         abstract void eat();//抽象方法
}
class Cat extends Animal
{
                   int x=5;
                   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 Pig extends Animal
{
                   public void eat()
                   {
                            System.out.println("吃饲料");
                   }
                   public void gongDi()
                   {
                            System.out.println("拱地");
                   }
                  
}

结果：

吃骨头

吃鱼

吃饲料

吃鱼

1.5  多态的局限性

只能使用父类的引用访问父类中的成员

1.6  多态的好处

提高了代码的扩展性，前期定义的代码可以使用后期的内容。

 

2.      多态的转型

2.1  Animal a=new Cat();

转型时使用子类方法

属性还是父类属性。

2.2  向上转型。要调用猫的特有方法（catchMouse），强制转型

Cat c=（Cat）a；//a本身必须是猫

可以将父类引用进行转换，不可以将父类对象转换成子类对象

注意：多态自始至终都是子类对象在做变化。

2.3  判断类型是否符合用instanceof关键字

格式：<对象 instanceof类型> ，判断一个对象是否所属于指定的类型。

If（a instanceof Cat）{}

 

3.      多态时成员的特点

3.1  成员变量

编译时：参考引用型变量所属的类中的是否有调用的成员变量。有，编译通过，没有，编译失败。

运行时：参考引用型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员变量。

简单说：编译和运行都参考等号的左边（父类）。

3.2  成员函数

编译时：参考引用型变量所属的类中是否有调用的函数。有，编译通过。没有，编译失败。
运行时：参考的是对象所属的类中是否有调用的函数。

简单说：编译看左边（父类有没有），运行看右边（子类复写后）。

3.3  静态函数

编译时：参考的是对象所属的类中是否有调用的函数。
 运行时：参考的是对象所属的类中是否有调用的函数。
 简单说：编译和运行看左边。

示例

public class H_0805Duotai
{
         public static void main(String[] args)
         {
                   Fu f=new Zi();
                   f.method1();
                   f.method2();
                  
                   //f.method3();  编译失败，编译时先找f类型中的方法，如果没有，编译失败。
                   //运行时，是看newZi() 对象中的方法，没有的时候调用父类（继承）
                   //方法：编译看左边 运行看右边
                   System.out.println(f.x);//结果是5,看父类
                   // 成员属性：多态过程中，无论编译和运行，都是参考左边。
                  
                   //静态函数不会重写，谁调用谁使用。
                   Zi z=new Zi();
                   z.method1();//zi method 1
                   z.method2();//fu method 2  子类没有，调用父类
                   z.method3();//zi method 3
                  
         }
 
}
 
class Fu
{
         int x=5;
         void method1()
         {
                   System.out.println("fu method 1");
         }
         void method2()
         {
                   System.out.println("fu method 2");
         }
}
class Zi extends Fu
{
         int x=3;
         void method1()
         {
                   System.out.println("zi method 1");
         }
         void method3()
         {
                   System.out.println("zi method 3");
         }
}

结果：

zi method 1

fu method 2

5

zi method 1

fu method 2

zi method 3

 

4.      Object类

Object类：所有类的直接或者间接父类。Java认为所有的对象都具备一些基本的共性内容，这些内容可以不断的向上抽取，最终就抽取到了一个最顶层的类中的，该类中定义的就是所有对象都具备的功能。

 

重要方法：

1、  boolean equals(Object obj)：

用于比较两个对象是否相等，其实内部比较的就是两个对象地址。

而根据对象的属性不同，判断对象是否相同的具体内容也不一样。所以在定义类时，一般都会复写equals方法，建立本类特有的判断对象是否相同的依据。

public class ObjectTest
{
    public static void main(String[] args){
        Person p1 = new Person(20);
        Person p2 = new Person(20);
 
        System. out.println(p1.equals(p2));
  }
}
class Person
{
    private int age ;
    Person( int age)
    {
          this.age =age;
    }
    //比较Person的年龄，是否是同龄人
    //一般都会覆盖此方法，根据对象的特有内容，建立判断对象是否相同的依据。
    public boolean equals(Object obj)
    {
          if(!(objinstanceof Person))
                throw new ClassCastException("类型错误");
          Person p = (Person)obj;
          return this .age == p.age;
   }
}

结果： true

2、  String toString()：

将对象变成字符串；默认返回的格式：类名@哈希值 = getClass().getName() + '@' + Integer.toHexString(hashCode())

为了对象对应的字符串内容有意义，可以通过复写，建立该类对象自己特有的字符串表现形式。

public String toString(){

         return "person :"+age;

}

3、Class getClass()：获取任意对象运行时的所属字节码文件对象。

4、int hashCode()：返回该对象的哈希码值。