多态

多态

在java里面对于多态的核心表现主要有以下两点：

1.方法的多态性：

　　方法的重载：同一个方法名称可以根据参数的类型及个数不同调用不同的方法体；

　　方法的覆写：同一个父类方发，可能根据实例化的子类不同也有不同的实现，

2.对象的多态性（前提：方法的覆写）：

 　　【自动 90%】对象的向上转型：父类 父类对象=子类实例化；

　　 【强制 1%】对象的向下转型：父类 子类对象=（子类）父类实例；

　　　　　9%是不进行转型，例如：String，

范例：回顾一个简单程序

class A{
    public void print(){
        System.out.println("【A】");
    }
}    
class B extends A{
    public void print(){
        System.out.println("【B】");
    }    
}
public class Newbegin{
    public static void main(String args[]) {
        B b=new B();//实例化子类对象
        b.print();//调用被覆写过的方法

    }    
} 

范例：实现向上转型

class A{
    public void print(){
        System.out.println("【A】");
    }
}    
class B extends A{
    public void print(){
        System.out.println("【B】");
    }    
}
public class Newbegin{
    public static void main(String args[]) {
        A a=new B();//向上转型
        a.print();//调用被覆写过的方法
    }    
} 

不管是发生了向上转型，那么其核心的本质还是在于：你使用了那一个子类（new 在哪里）而后你调用的方法是否被子类覆写了。

向下转型：就是将父类对象变为子类对象，但是在这之前需要明确一个核心概念，为什么需要向下转型？

当你需要使用到子类扩充操作的时候就要使用向下转型。

范例：向下转型

class A{
    public void print(){
        System.out.println("【A】");
    }
}    
class B extends A{
    public void print(){
        System.out.println("【B】");
    }    
    public void funB(){//这个方法只有子类有
        System.out.println("【B】funB方法执行了");
    }
}
public class Newbegin{
    public static void main(String args[]) {
        A a=new B();//向上转型
        a.print();//调用被覆写过的方法
        //这个时候父类能够调用的方法只能是自己本类定义好的方法，如果想调用子类的方法，。 
        B b=(B)a;//向下转型
        b.funB();
    }    
} 

如果想要向下转型，就必须要先向上转型，否则转型会出现：ClassCastException

向下转型可能存在隐患，那么就要依靠instanceof关键字来实现了。

instanceof返回的是boolean类型。

范例：观察instanceof的使用

class A{
    public void print(){
        System.out.println("【A】");
    }
}    
class B extends A{
    public void print(){
        System.out.println("【B】");
    }    
    public void funB(){//这个方法只有子类有
        System.out.println("【B】funB方法执行了");
    }
}
public class Newbegin{
    public static void main(String args[]) {
        A a=new B();//实例化父类
        System.out.println(a instanceof A);
        System.out.println(a instanceof B);
        //以后对于子类的特殊操作尽量慎用
        if(a instanceof B){//避免了ClassCastException的问题，
            B b= (B)a;
            b.funB();
        }
    }    
} 

思考一下这种转换，有什么意义？

范例：要求定义一个方法，而这个方法可以接受Person类的所有实例。并调用Person类的方法

class Person{
    public void takeoff(){//脱
        System.out.println("脱掉****");
    }
}
class Student extends Person{
    public void takeoff(){//脱
        System.out.println("一件件脱掉****");
    }
}    
class Worker extends Person{
    public void takeoff(){//脱
        System.out.println("直接卷了");
    }
}
public class Newbegin{
    public static void main(String args[]) {
        in(new Student());
        in(new Worker());

    }    
    public static void in(Person per){
        per.takeoff();//所有人都要进行。
    }

1.操作参数统一，用向上转型来，对象的多态核心在于方法的覆写

2.通过对象的向上转型可以实现，接收参数的统一，而向下转型可以实现子类扩充方法的调用（一般不操作）

3.两个没有关系的是不能进行转型。会ClassCastException。