五（十）、多态

多态性:一个事物的多种形态；
  1.何为多态性？
              对象的多态性，父类的引用指向子类对象；换句话就是说：向上转型；看例子；

public class Day12Polymorphism17 {

    public static void main(String[] args) {
        Persons4 person = new Persons4();
        //person.eat();
        
        Man man = new Man();
        //man.eat();
        man.age = 25;
        //man.earnMony();
        //对象的多态性,父类的引用指向子类的对象；
        Persons4 p1 = new Man();
        Persons4 p2 = new Woman();
        p1.eat();
        p1.walk();
        //p1.earnMony();只能掉用父类方法，运行的是子类发方法；由于变量声明为父类类型，导致编译时，只能调用父类声明的属性，子类的属性和方法不能调用
        p2.eat();
        System.out.println(p1.id);
        
    }
}

这里Persons4 是父类，Man是子类，Persons4 p1 = new Man(); 也就是向上转型；new Man()为子类对象；p1是引用；所以就是 父类的引用指向子类对象；

附上相关代码：

class Persons4{
    String name;
    int age;
    int id = 1001;//身份证号
    
    public Persons4() {
    }
    public Persons4(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void eat() {
        System.out.println("吃饭");
    }
    public void walk() {
        System.out.println("走了");
    }
}

class Man extends Persons4{
    boolean isSmoking;
    int id = 1002;//身份证号
    public void earnMony() {
        System.out.println("男人负责挣钱养家");
    }
    public void eat() {
        System.out.println("男人多吃饭");
    }
}

class Woman extends Persons4{
    boolean isBeauty;
    public void goShopping(){
        System.out.println("女人，喜欢购物");
    }
    public void eat() {
        System.out.println("女人吃的少");
    }

              当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法；虚拟方法调用；也就是说 p1.eat();  结果是：男人多吃饭 p1.walk()结果是：“走了”
  2.多态的使用：虚拟方法调用
              有了对象的多态性以后，我们只能在编译器，只能调用父类中声明的方法，但是在执行期，我们实际执行的是子类重写的父类的方法；
  总结：方法：编译看左边，执行看右边；
          属性 编译和执行都看左边；
  4.多态的使用前提：
              a.要有类的继承关系；
              b.要有方法的重写；        
  5.对象的多态性只适用于方法，不适合用属性；
  　　p1.id 这里的结构还是1001
  6.多态是运行时方法；

这里，多态的使用时为了让代码更加简洁，让参数统一化；比如在方法的参数可以接受父类参数，那么如果你传入子类也可以，就可以简化代码了。那么这里就会又引入另外一个问题，如果方法参数是父类形参，当传入子类参数时，处理这个形参时，如何把 父类转换为子类对象呢？这样就引入了向下转型；向下转型符号 即强制类型转换符　　“()”;

public static void main(String[] args) {
        Persons4 person = new Persons4();
        Persons4 p1 = new Man();//多态
        Man man = (Man)p1;//向下类型转换 使用强制类型转换，可能异常；
        if(p1 instanceof Woman) {
            System.out.println("是女人，不可以强转");
        }else if(p1 instanceof Man) {
            System.out.println("是男人，可以强转");
        }
        //相关问题；
        //编译过，运行不过；
        Persons5 p2 = new Woman1();
        Man1 m2 = (Man1)p2;
        
        Persons5 p3 = new Persons5();
        Man1 m3 = (Man1)p3;
        
        //编译过，运行也过
        Object obj = new Woman1();
        Persons5 p4 = (Persons5) obj;
        
        //编译不通过
        //Man1 m5 = new Woman1();
        
    }

instanceof 关键字的使用说明：
 
　　a instanceof A:判断对象a是否是类A的实例，如果是，返回true，否则false；
 
　　B 是 A 的父类，如果 a instanceof A: 返回true，b instanceof A:返回也是true；

　　为了避免出现classcaseException的异常，我们在向下转型之前，先进行instanceof的判断，