Java的多态

梦里梦外; 2023-01-12 07:47 129阅读 0赞

JAVA引用变量有两个类型：一个是编译时类型，一个是运行时类型.编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，就会出现所谓的多态！

## 一、多态性 ##

先看看下面的程序：

class BaseClass{
    	public int book=6;
    	public void base(){
    		System.out.println("父类的普通方法");
    	}	
    	public void test(){
    		System.out.println("父类的被覆盖的方法");
    	}
    }
    
    public class SubClass  extends BaseClass{
            
    	//重新定义一个book实例属性覆盖父类的book实例属性
    	public String book="轻量级J2EE应用实战";
    	public void test(){
    		System.out.println("子类覆盖父类的方法");
    	}
    	public void sub(){
    		System.out.println("子类普通的方法");
    	}
    	
    	public static void main(String[] args) {
    		//下面编译时类型和运行时类型一样，因此不存在多态
    		BaseClass bc=new BaseClass();
    		//输出6
    		System.out.println(bc.book);
    		//下面两次调用将执行BaseClass的方法
    		bc.base();
    		bc.test();
    		//下面编译时类型和运行时类型都一样，因此不存在多态
    	    SubClass sc=new SubClass();
    	    //输出"轻量级J2EE应用实战"
    	    System.out.println(sc.book);
    		//下面调用将执行从父类继承的base方法
    	    sc.base();
    	    //下面将执行当前类的test方法
    	    sc.test();
    	    
    	    //下面编译时类型和运行时类型不一样，多态发生
    	    BaseClass ploymophicBc=new SubClass();
    	    //输出6，表明访问的是父类属性
    	    System.out.println(ploymophicBc.book);
    	    //下面调用将执行从父类继承到的方法
    	    ploymophicBc.base();
    	    //下面调用将执行从当前类的方法
    	    ploymophicBc.test();
    	    
    	    //因为ploymophicBc的编译类型是BaseClass,BaseClass类没有提供sub方法
    	    //所以下面代码编译时会出现错误
    //	    ploymophicBc.sub()
    	}
    	
    }

Java允许把一个子类对象直接赋给一个父类的引用变量，无需任何类型转换，或者被称为向上转型（upcasting），向上转型由系统自动完成！

注意：引用变量在编译阶段，只能调用其编译时类型所具有的方法，但在运行时，则执行运行时类型所具有的方法！因此编写代码时，引用变量只能调用声明该变量时所用类里包含的方法。例如，我们通过Object  p=new Person()，这个p只能调用Object 类的方法，而不能调用Person类里定义的方法（除非Personl类重写了Object 类的方法）！

与方法不同的是，对象的属性则不具备多态性：如上面代码执行的变量，程序中输出它的book属性时，并不是输出SubClass类里定义的属性，而是输出BaseClass属性里的实例属性！

通过引用变量来访问其包含的实例属性时，系统总是试图访问它编译时类型所定义的属性，而不是它运行时所定义的属性！

## 二、引用变量的强制类型转换 ##

关于类型的转换需要注意以下两点：

1.  基本类型的转换只能在数值类型之间进行，这里所说的数值类型包括整型、字符型和浮点型。但数值型不能和布尔型之间进行转换。
2.  引用类型之间的转换，只能把一个父类变量转换成子类类型，如果是两个没有任何继承关系的类型，则无法进行类型转换，否则编译时会出现错误。如果试图把一个父类实例转换子类类型，则必须这个对象是子类的实例才行（即编译时类型为父类类型，而运行时类型时子类类型），否则在运行时引发ClassCastException异常。

下面的一段程序用来演示强制类型转换：

public class TestConversion {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		double d=13.4;
    		double l=(long)d;
    		System.out.println(l);
            int in=5; 
            //下面代码编译时会报错，试图把一个数值型变量转换为boolean型
            //编译时候会提示，不可转换的类型
            //boolean b=(boolean)in;
            Object obj="Hello";
            //obj变量的编译时类型时Object ，是String类型的父类，可以强制类型转换
            //而obj变量实际上类型时String类型，所以运行时也可通过
             String objStr=(String)obj;
             System.out.println(objStr);
             //定义一个objPri变量，编译类型为Object,实际类型为Integer
             Object objPri=new Integer(5);
             //objPri编译时类型是object ，是String类型的父类，可以强制类型转换
             //而objPri变量实际上类型是Integer类型
             //所以下面代码运行时会引发ClassCastException异常
             String str=(String)objPri;
    	}
    
    }

## 三、instanceof  操作符 ##

使用instanceof需要注意：instanceof运算符前面操作数的编译类型要么与后面的类相同，要么是后面类的父类，否则会引起编译错误！

public class TestInstanceof {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		
    		Object hello="Hello";
    		//String 是Object类的子类，所以可以进行instanceof运算，返回true
            System.out.println("字符串是否是Object类的实例:"+(hello instanceof Object));
            //返回true
            System.out.println("字符串是否是String类的实例:"+(hello instanceof String));
            //Math是Object类的子类，所以可以进行instanceof,运算，返回false
            System.out.println("字符串是否是Math类的实例:"+(hello instanceof Math));
            //String实现了Comparable接口，所以返回true
            System.out.println("字符串是否是Comparable类的实例:"+(hello instanceof Comparable));
            String a="Hello";
            //String类既不是Math类，也不是Math类的父类，所以下面的代码编译无法通过
           // System.out.println("字符串是否是Math类的实例:"+(a instanceof Math));
    
    	}
    
    }

关于instanceof运算符的作用是：在执行强制类型转换前，首先判断前一个对象时候是后一个类的实例，是否可以成功的转换，从而保证代码更加健壮！