Java——Object类，多态

Object类

是所有类的父类，在建立一个新的Java类时默认会继承Object类，其中包含一些重要的方法

• 常用：

1. getClass()返回对象运行时候的实例类
2. toString()字符串
3. equals()比较对象内容相等，通常在子类中会重写【与= =不同， ==表示 1.引用类型指向地址是否相同，2.基本类型的值是否相等】
4. hashCode()用于哈希查找，经常会与equals()一起重写

注：哈希码（表示同一类对象按照不同的特征得到不同的哈希码，例如对一串数字取余会有不同的余数，通过余数的不同将其划分为不同的种类）

-稍微不常用：
clone()，notify()，notifyAll()，wait()，finalize()

多态

一般来讲引用变量是包含两种类型的：
编译时类型（比较模糊，一般为一个父类）：由声明时的类型决定
运行时类型（运行时，具体哪个子类就是哪个子类）：由实际对应的对象类型决定。
这就会导致一些定义的对象在编译代码时不会报错，而运行程序时则会报错

1. 定义：对同一个指令（调用同一名称的方法），不同对象给予不同反应（具体实现的方法不同）

2. 规则：
   （1） 必须要有继承关系
   （2） 子类方法必须重写父类方法（达到不同的实现）
   （3） 父类的引用指向子类对象

3. 优点：减少代码量，提高代码的可维护性和可扩展性

举例，喂食（同一个指令），给猫喂鱼，给狗喂骨头（不同实现）

• 多态实现：

1. 使用父类作为方法形参实现
2. 使用父类作为方法返回值实现

Pet类（抽象）:

package abd.Multi;

public abstract class Pet {

    public abstract void feed();

}

Cat类:

package abd.Multi;

public class Cat extends Pet{
    @Override
    public void feed() {
        System.out.println("猫吃鱼");
    }
}

Dog类：

package abd.Multi;

public class Dog extends Pet {
    @Override
    public void feed() {
        System.out.println("狗吃骨头");
    }
}

People类（测试）：

package abd.Multi;

public class People {


    //直接创建，在调用时无法指定具体对哪一个对象进行调用
    public void feed1(){
        new Dog().feed();
        new Cat().feed();

    }

    //改良1：针对不同对象调用不同方法
    public void feed2(Cat cat){
        cat.feed();
    }

    public void feed2(Dog dog){
        dog.feed();
    }

   //改良2：父类引用直接指向子类对象，从而精简代码，也是多态的实现
    //父类作为形参实现多态
    public void feed3(Pet pet){
        pet.feed();
    }

    //父类作为返回值实现多态
    public Pet buyPet(int type){
        if (type == 1){
            return new Cat();
        }else {
            return new Dog();
        }
    }
    
    public static void main(String[] args) {
        People per = new People();
        per.feed1();

        Cat cat = new Cat();
        Dog dog = new Dog();
        per.feed2(cat);
        per.feed2(dog);

        Dog dog1 = new Dog();
        Cat cat1 = new Cat();
        per.feed3(dog1);
        per.feed3(dog);
        per.feed3(cat1);

		//instanceof 判断它左边的对象是否是它右边的类的实例，，运用： 对象 instanceof 类或接口
        Pet pet = per.buyPet(1);
        if (pet instanceof Cat){
            System.out.println("买猫");
        }else {
            System.out.println("买狗");
        }
    }

}

注：

1. 向上转型
   （1）上转型对象不能操作子类新增的成员变量和方法
   （2）上转型对象可以操作子类继承或重写的成员变量和方法
   （3）若子类重写父类方法，那么调用被重写方法
   综上：转型后的对象只能操作父类中存在的方法，这些方法若在子类中继承或重写则直接调用子类中更新好的方法，，而父类中不存在但子类中存在的方法是不能被调用的。向上转型相当于一些方法受限制不可用了

//自动类型转换
Pet pet1 = new Cat();//  cat2是父类引用，指向子类对象（Cat（）），cat2在栈里，可以指向堆中的任意块，但是由于各种编译规范对匹配类型进行校验，所以只有匹配特殊的类型才能正常运行，，在这里就是指向子类对象

3. 向下转型 （一般会与instanceof一起使用判断类型转换是否正确）

//强制类型转换
Cat cat12 = (Cat)pet1;//正确运行
Dog dog12 = (Dog)pet1;//编译无问题，运行有问题，，，必须转换为父类引用的真实子类

类型转换类似于基本数据类型转换