面向对象之多态

方法:
    概念:类的共同行为,封装了一段逻辑代码,在封装方法时,尽可能的
    只完成一项功能(避免将多个功能封装到一个方法内)
方法的使用:
    方法属于对象的行为,应该使用: 引用.方法.这些方法动态绑带到对象上
方法签名:
    方法名+形参列表 = 方法签名
    形参列表:指的是形参的类型顺序列表
    如: public void sum(int a,int b)
        方法签名是  sum+int,int
        public int eat(String food)
        方法签名    eat+String

（一）方法的重载(overload):

----我认为可以算在内，仅个人观点，重载是使用的多态，同一种方法在使用时根据参数列表不同而使用
    在同一个类型中,方法名不变,参数列表不同

    
    在方法调用时,编译器会检查类的信息中是否有此方法签名的方法
    c.sum(3,5);此时编译器检查类中是否有c.sum(int int )
        如果有,编译通过,没有,编译失败,并提示错误             
  

编译器在选择时会自动转换类型，使用方法

编译器只会选择一个方法来使用，不会因为有多个重载的方法而调用多次，或者覆盖

方法的选择有自己的顺序，符合要求便不会继续寻找

（二）方法的重写

方法的重写（override）：

-----方法实现的多种形态，不同的实现，
 子类可以继承父类的方法，在继承时，我们可以在子类中，编写与父类中的方法名相同
    参数列表也相同的方法。这就是重写
    （1）方法名相同，参数列表相同
    （2）返回值类型可以相同，也可以是父类型的返回值类型的子类型，返回值类型可以更加精确
    （3）修饰词可以不变，或者可以比父类的修饰权限更大，父类方法是私有的，不能重写

方法的重载（Overload）与重写（Override）
概念：
        重载：在同一个类中，方法名相同，参数列表不同
        重写：子类重写父类的方法，方法名相同，参数列表相同
        返回值类型可以相同，也可以是父类方法的返回值的子类
        修饰词可以相同，或者权限比父类方法的权限大
        父类的私有方法不能重写

（三）向上转型或者叫向上造型

父类型的变量，可以引用子类型的对象
    如：Animal a = new GoleFish();
    Animal类型的变量a引用了子类型GoldFish的对象
    符合人的思维：
        这条鱼是动物。

1、父类型的变量指向不同子类型对象，调用的功能有不同的实现
    Animal a = new Dog();
    a.niose();//汪
    Animal a = new Cat();
    a.noise();//喵
    2、不同的父类型变量指向同一个对象有不同的功能

          --功能是父类型里面的功能，父类型里没有的不能使用
    ZhengYangMen a = new ZhengYangMen();
    a.theftproof();
    a.opendoor();
    Inter ia = a;
    ia.theftproof;
    Door door =a;
    door.openDoor();
    door.closeDoor();

编译期绑定：
    在编译过程中，变量只能调出本类型的方法和成员变量（编译看变量类型，类型中没有的方法是不能调用的）
    简单说成：在编译期间，方法静态绑定到变量上。
运行期绑定
    运行过程中，真正执行的方法的逻辑与对象的类型有关系。（执行看对象，对象重写了方法，那么执行的是对象的方法）
    简单说成：方法在运行期间，动态绑定在对象上
成员变量都与变量的类型有关，与编译期，运行期无关。

（四）向下转型或者叫向下造型

将父类型（接口）的变量赋值给子类型的变量或者是其他父类型（接口）的变量

在向下造型的过程中可能会出现异常

        Animal a = new Dog()
        Dog dog = (Dog)a;
        dog.出骨头()
        Cat cat = a;//造型异常，此时animal是狗而不是猫，
        cat.抓老鼠();

所以需要强制类型转换，转换成猫
        Cat cat = (Cat)a;//编译通过，语法正确，运行期间造型错误
        cat.抓老鼠();
    为了避免出现错误，我们需要使用关键字 instanceof来判断对象是不是要转换的类型
        if(a instanceOf Cat){
            Cat cat = (Cat)a
        }

【在创建子类对象时，会不会产生父类对象】
【答案1：会产生，没有父类对象，哪来的子类对象】

【答案2：不会产生，创建子类对象时，子类对象的成员变量包含两部分，

    一部份为，从父类中继承过来的，
        在成员变量前有默认的this.
    一部分是自己本类的
        在成员变量前有默认的this.
    如果子类中独有的与继承过来的成员变量重名时。必须显式指定使用super.或者this.
    如果子类中没有与继承过来的成员变量相同名时，我们可以隐式不写，或者使用super.
    与this.中其中一个

    也可以理解为，两个类同名的成员变量，在构造器使用的是同一个this，也就是super=this

    为了避免不必要的麻烦   子类的成员变量尽可能的不要与父类的成员变量重名
】

Object：是所有引用类型的*父类。
         系统都会默认引用extends Object
此类中提供了常用的方法：
    1、toString():
        在Object中返回的是 类全名@HashCode值；
        即对象的内存在堆中的位置信息

  
    【类有类名和类全名之分
        类名（短名）:即最短的名称
        类全名：从包名开始写的名称   com.hyxy.oop.day05.Hoo
    如：String 是类名
        java.lang.String 是类全名
    】
此方法会在输出变量时，或引用变量进行拼接时，默认调用
而查看地址信息没有必要，我们通常要查看的是对象的成员变量的信息
因此我们都需要重写toString()方法，用于查看对象的详情
    格式："【成员变量1="+成员变量1+",成员变量2="+成员变量2

equals(Object obj)
    object类型中的此方法中的逻辑是比较调用者this与形参obj
    的地址信息是否相等

    (可以理解成底层为if，用==进行判断，引用类型输出的是地址值，代表了一个对象，在Java内存结构中

    每次实例化对象，都会开辟新的空间来存对象信息，也就是，每个空间都不同，有不同的位置，不是我们想要的)
    简单说成：比较this与obj是不是同一个元素（比较不了对象内部的元素）
    所以在定义类型时，继承过来的equals方法，我们要重写
    重写规则
        1、查看传进来的obj是不是null
            if(obj==null){
                return false
            }
        2、查看传进来的obj是不是this。
            if(obj==this){
                return true;
            }
        3、查看传进来的obj是不是本类型
            if(obj.getClass()!=this.getClass()){
                return false;
            }
            可以改成
            if(!(obj instanceof Person){
                return false;
            }

   

（也可以使用快捷提供的，基本类似）
instanceof关键字：作用是判断引用变量指向的对象是否属于某一类型（返回值是布尔类型）
    语法：
        Boolean f=变量名 instanceof 类型名