Java中的多态

一、多态的定义和体现：

定义：不同类的对象在调用同一方法时所呈现的多种不同的形态

多态的体现前提：

（1）类的继承

（2）方法重写

（3）父类引用指向子类对象

范例代码：

//父类
package test;

public class Animal {
	
	//成员方法
	public void eat() {
		System.out.println("动物吃东西");
	}

}

//子类
package test;
//子类继承父类
public class Cat extends Animal {  
	
    //重写后的方法
	@Override //注解
	public void eat() {
		System.out.println("猫爱吃鱼");
	}
	
}

//测试类
package test;

public class test {

	public static void main(String[] args) {
		
		//父引用指向子类对象
		Animal animal = new Cat();
		
}

 二、 多态调用成员特点

1.调用成员变量

特点：编译看左边，运行看左边

理解：

        （1）编译看左边：javac编译代码的时候，会先看左边父类有没有成员变量，如果有，则编译成功，否则编译失败

       （2） 运行看左边：java运行代码时，实际获取的是左边父类成员变量的值

2.调用成员方法

特点：编译看左边，运行看右边

理解：

        （1）编译看左边：javac编译代码时，会看左边父类中有没有成员方法，如果有，则编译成功，否则编译失败

        （2）运行看右边：java运行代码时，实际运行的是子类中重写的方法

 范例代码：

//父类
package test;

public class Animal {
	
	//成员变量
	public int age = 50;
	
	//成员方法
	public void eat() {
		System.out.println("动物吃东西");
	}

}

//子类
package test;
//子类继承父类
public class Cat extends Animal {  
	
	//成员方法
	public int age = 20;
	public int weight = 10;
	
	//重写后的方法
	@Override //注解 作用：判断方法是否重写
	public void eat() {
		System.out.println("猫爱吃鱼");
	}
	
	//成员方法
	public void method(){
	System.out.println("猫捉老鼠");
	}
	

}

package test;

public class test {

	public static void main(String[] args) {
		
		//父引用指向子类对象
		Animal animal = new Cat();
		
        //编译在左边，运行看左边
		System.out.println(animal.age); //获取父类中的成员变量的值
		System.out.println(animal.weight);//父类中没有该成员变量，所以无法调用该成员变量
		
		//编译在左边，运行看右边
		animal.eat(); //调用子类中重写后的方法
		animal.method(); //无法调用该方法，编译时父类中没有该方法，无法编译
		
	}

}

三、多态转型

1.向上转型

含义：把子类对象赋值给父类引用。

格式：父类名( ) 引用变量名  =  new  子类名( );

     

2.向下转型

含义： 父类引用转为子类对象。

格式：子类名( ) 引用变量名 =  (子类名)父类引用变量;

3.转换异常 

package test;

public class test {

    public static void main(String[] args) {
        
        Animal animal = new Dog();
        
        //向下转型异常
        //Cat cat = (Cat)animal; //出现转换异常,animal属于Dog类不能转换成Cat类
        //cat.eat();
        
        //解决方案
        //instanceof运算符用于判断一个对象是否属于一个类。
        if(animal instanceof Dog) { 
            Dog dog = (Dog)animal;
            dog.eat();
            
        }else if(animal instanceof Dog){
            Cat cat = (Cat)animal;
            cat.eat();
            
        }else{
            System.out.println("没有这个类型，无法转换");
        }
        
        
        
    }

}

范例代码：

//父类
package test;

public class Animal {
	//成员方法
	public void eat() {
		System.out.println("动物吃东西");
	}

}

//子类
package test;
//子类继承父类
public class Cat extends Animal {  

	//重写后的方法
	@Override //注解   作用：判断方法是否重写
	public void eat() {
		System.out.println("猫爱吃鱼");
	}
	
	//成员方法
	public void method(){
	System.out.println("猫捉老鼠");
	}
	

}

//测试类
package test;

public class test {

	public static void main(String[] args) {
		
		//父引用指向子类对象
		Animal animal = new Cat();  //向上转型
		
		//编译在左边，运行看右边
		animal.eat(); //调用子类中重写后的方法
		animal.method(); //根据编译看左边，编译时父类中没有该方法，所以会报错
		
		
		//父类引用转为子类对象
		Cat cat = (Cat)animal; //向下转型
		
		//调用方法
		cat.eat(); //调用子类中重写后的方法
		cat.method(); //子类对象调用成员变量
		
		
	}

}

四、多态的优势和弊端

优势：

（1）定义方法时，使用父类作为参数，可以接受所有子类对象，体现了多态的便利和扩展性。

（2）多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特征的运行和操作。

弊端：向上转型时多态引用不能调用子类中特有的方法。

范例代码：

//父类
package test;

public class Animal {
	//成员方法
	public void eat() {
		System.out.println("动物吃东西");
	}
	
	//成员方法
	public void seelp(){
	System.out.println("动物爱睡觉");
	}

}

//子类
package test;
//子类继承父类
public class Cat extends Animal {  

	//重写后的方法
	@Override //注解   作用：判断方法是否重写
	public void eat() {
		System.out.println("猫爱吃鱼");
	}
	
}

//子类
package test;

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

//操作类
package test;

public class Operation {
	//定义方法时，使用父类作为参数，可以接受所有子类对象，体现了多态的便利和扩展性。
	public void show(Animal animal) {
		
		animal.eat(); //传递的对象调用Animal类中的成员方法或子类重写父类的方法
		
		/*由于继承关系，子类创建的对象可以调用父类非私有的成员方法和成员变量
		 * 当父类中的方法在子类中被重写，则子类调用不是父类中的成员方法，而是子类重写后的方法*/
		
		animal.seelp();//传递的对象调用Animal类中的成员方法或子类重写父类的方法
	}
}

//测试类
package test;

public class test {

	public static void main(String[] args) {
		
		//创建操作类对象
		Operation  op = new Operation();
		
		//创建Cat类对象
		Cat cat = new Cat();
		op.show(cat);//调用show方法传递形参Cat类的对象
		
		//创建Dog类对象
		Dog dog = new Dog();
		op.show(dog);//调用show方法传递Dog类对象
		
		
		//创建Animal类的对象
		Animal animal = new Animal();
		op.show(animal);//调用show方法传递父类对象
	}

}