Java 多态

多态

       本质：就是方法的重写

       语法：编译类型 对象 = new 运行类型

       编译类型是在代码是编译时的类型，一旦定义，不可以更改

       运行类型是代码在运行时走的类型，可以改变

       多态的前提：两个类存在继承关系

       方法才有多态，因为属性没有重写，因此属性的值要看编译类型

public class HelloWorld {
    public static void main(String[] args) {
        //属性没有重写，属性的值看编译类型
        Base base = new Sub();
        System.out.println(base.count);//输出10
    }
}
//父类
class Base{
    int count = 10;
}
//子类
class Sub extends Base{
    int count = 20;
}

向上转型：

       语法：父类类型  引用名 = new 子类类型（）

        //父类的引用指向子类的对象
        Base base = new Sub();

       本质：父类的引用指向子类的对象

       特点：编译类型看左边，运行类型看右边

              编译类型，决定了在编译阶段能调用的成员

              运行类型，决定了调用成员走那个类中的成员

       注意：①可以调用父类的成员方法，但需要遵守访问权限

              ②不能调用子类的特有方法

              ③最终运行效果要看子类的具体实现，即调用方法时，按照子类（运行类型）先                开始查找，然后调用，若子类没有在找父类，按照方法调用规则一致

向下转型：

       语法：子类类型 引用名 = （子类类型） 父类引用

        //父类类型强制转换为子类类型
        Sub sub = (Sub) base;

              此时编译类型和运行类型都是子类类型

       本质：相当于是把父类类型强制转换为子类类型

       注意：①只能强转父类的引用，不能强转父类的对象

                ②要求父类的引用必须指向当前目标类型的对象

                ③当向下转型后，可以调用子类类型中的所有方法

instanceof 比较操作符

       作用：用于判断对象的运行类型是否为XX类型或XX类型的子类型

        System.out.println(base instanceof Base);//输出true
        System.out.println(base instanceof Sub);//输出true
        System.out.println(sub instanceof Base);//输出true

Java的动态绑定机制（非常非常重要）

       ①当调用对象方法时，该方法会和对象的内存地址/运行类型绑定

       ②当调用对象属性时，没有动态绑定机制，哪里声明哪里使用

多态的应用

       多态数组：数组的定义类型为父类类型，里面保存的元素类型为子类类型

      

       多态参数：方法定义的形参类型为父类类型，实参类型允许为子类类型

Object 类

       是类层次结构的根类，每个类都使用Object 类作为超类，所有对象（包括数组）都实现这个类的方法

       equals(Object obj)：判断引用的对象与obj是否相等，只能判断引用类型

              默认判断的是地址是否相等

//Object 类里面的equals() 源码
public boolean equals(Object obj){
    retrun (this == obj);
}

但往往子类会重写equals()方法，用于判断内容是否相等，比如String，Integer

//Integer 类里面的重写的 equals() 源码
public boolean equals(Object obj){
   if(obj instanceof Integer){
         retrun value == ((Integer)obj).intValue();
    }
    return false;
}

        == 比较运算符：既可以判断基本类型，也可以判读引用类型

              判断基本类型，是判断两个值是否相等

              判断引用类型，是判断两个对象的地址是否相等，即判断是否为同一对象    

finalize()：当垃圾回收器确定不存在该对象的更多引用时，由对象的垃圾回收去调用

              垃圾回收器会回收（销毁）没有引用的对象，在销毁前，会调用finalize() 方法

              垃圾回收机制：是由系统来决定的（即有自己的GC算法），

                            也可以通过System.gc（）来主动触发垃圾回收机制，有几率不触发

       getClass()：返回此Object的运行类型

       hashCode()：返回该对象的哈希码值

              小结：①提高具有哈希结构的容器的效率

                       ②两个引用，如果指向同一对象，则哈希值肯定是一样的

                       ③两个引用，如果指向不同对象，则哈希值是不一样的

                       ④哈希值主要根据地址号来的，但不能将哈希值等价于地址

                       ⑤后面在讲集合中的hashCode() 如果需要，要重写

       toString()：返回该对象的字符串表示

              默认返回：全类名 + @ +哈希值的十六进制

              全类名：包名 + 类名        getClass().getName()

              当直接输出一个对象时，toString() 方法会被默认调用