Java--多态(polymorphic),上下转型，多态好处弊端

素颜马尾好姑娘i 2023-10-17 10:48 164阅读 0赞

多态(polymorphic)：事物存在的多种形态  
多态前提  
(1)要有继承关系  
(2)要有方法重写  
(3)要有父类引用指向子类对象  
多态好处  
(1)提高了代码的维护性  
(2)提高了代码的扩展性  
多态坏处

不能使用子类的特有属性和行为

成员变量  
编译看左边(父类)，运行看左边(父类)  
成员方法  
编译看左边(父类)，运行看右边(子类)  
静态方法  
编译看左边(父类)，运行看左边(父类)；  
静态和类相关，算不上重写，因此访问还是左边的

只有非静态的成员方法，编译看左边，运行看右边

class Polymorphic{
    	public static void main(String[] args){
    		Cat c = new Cat();
    		c.eat();
    		Animal a = new Cat();           //父类引用指向子类对象,就是向上转型
    		a.eat();
    		// a.catchMouse();
    		Cat c1 = (Cat)a;                //向下转型
    		c1.catchMouse(); 
    
    		//多态提高扩展性
    		animalEat(new Cat());          //一般在实际开发中创建对象时使用父类应用指向子类对象，直接创建子类对象更方便，可以使用子类中的特有属性和行为
    		animalEat(new Dog());
    
    		System.out.println("------------------------");
    		Father f = new Son();			//父类引用指向子类对象
    		System.out.println(f.num);
    		f.print();
    		f.staticPrint();				//相当于使用类名去调用
    
    		System.out.println("------------------------");
    		//基本数据类型自动类型提升和强制类型转换
    		int i = 10;
    		byte b = 20;
    		// i = b;                         //自动类型提升
    		// b = (byte)i;				      //强制转换
    	}
    
        //如果两子类之间强转，就会出现类型转换异常，ClassCastException
    	public static void animalEat(Animal a){ //当做参数时使用多态最好，因为扩展性好
    		a.eat();
    		// a.catchMouse();            //不能使用子类的特有属性和行为
    		//关键字 instanceof 判断前边的引用是否为后边的数据类型
    		if (a instanceof Cat) {
    			Cat c = (Cat)a;
    			c.eat();
    			c.catchMouse();
    		}else if (a instanceof Dog) {
    			Dog d = (Dog)a;
    			d.eat();
    			d.lookHome();
    		}else{
    			a.eat();
    		}
    	}
    }
    
    class Animal{
    	public void eat(){
    		System.out.println("动物吃饭");
    	}
    }
    
    class Cat extends Animal{
    	public void eat(){
    		System.out.println("猫吃鱼");
    	}
    	public void catchMouse(){
    		System.out.println("猫抓老鼠");
    	}
    }
    
    class Dog extends Animal{
    	public void eat(){
    		System.out.println("狗吃肉");
    	}
    	public void lookHome(){
    		System.out.println("狗看门");
    	}
    }
    
    /*
      成员变量
         编译看左边(父类)，运行看左边(父类)
      成员方法
         编译看左边(父类)，运行看右边(子类)
      静态方法
         编译看左边(父类)，运行看左边(父类)；
         静态和类相关，算不上重写，因此访问还是左边的
      只有非静态的成员方法，编译看左边，运行看右边
    */
    class Father{
    	int num = 10;
    	public void print(){
    		System.out.println("Father");
    	}
    	public static void staticPrint(){
    		System.out.println("static Father");
    	}
    }
    
    class Son extends Father{
    	int num = 20;
    	public void print(){
    		System.out.println("Son");
    	}
    	public static void staticPrint(){
    		System.out.println("static Son");
    	}
    }

成员变量：

![Center][]

成员方法：

![Center 1][]

父类不能调用子类的方法，报错：

![Center 2][]

最终输出：

![Center 3][]

[Center]: https://img-blog.csdn.net/20170220174519520?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvTWluZ2dlUWluZ2NodW4=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 1]: https://img-blog.csdn.net/20170220174531051?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvTWluZ2dlUWluZ2NodW4=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 2]: https://img-blog.csdn.net/20170220174601951?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvTWluZ2dlUWluZ2NodW4=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 3]: https://img-blog.csdn.net/20170220174616943?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvTWluZ2dlUWluZ2NodW4=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center