面向对象——多态

最新推荐文章于 2025-05-20 20:46:40 发布

原创最新推荐文章于 2025-05-20 20:46:40 发布 · 194 阅读

1 ·

CC 4.0 BY-SA版权

Java 专栏收录该内容

99 篇文章

订阅专栏

本文深入解析Java多态的概念、实现方式及其好处，并通过示例代码展示如何在实际项目中运用多态提高代码的扩展性和灵活性。重点讨论了多态在方法调用、类型转换、以及静态方法的调用等方面的特性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、定义

多态：某一类事务的多种存在形态。

例如：动物中的猫和狗。

//动物是猫和狗抽取出来的本质特性。
class Animal{

}

class Cat extends Animal{

}

class Dog extends Animal{

}

   Cat c=new Cat();//创建一个Cat对象，类型是Cat。
   
   //猫也是动物的一种，我们可以把猫称为动物。  父类型引用指向了子类对象。
  
   Animal a=new Cat();//创建一个Cat对象，类型是Animal。

  

class Duotai {

   public static void main(String [] args ){

      
  }

}

简单说：就是一个对象对应者不同的类型。

二、多态在代码中的体现：

父类或者接口的引用指向其子类的对象。

Animal a=new Cat( );

三、多态的好处：

提高了代码的扩展性，前期定义的代码可以使用后期的内容。

四、多态的弊端：

前期定义的内容不能调用后期子类的特有内容。

五、多态的前提：

1、必须有关系，继承，实现。

2、要有覆盖(重写)

六、类型转换：

Animal a =new Cat( ); 自动类型提升，猫对象提升了动物类型。但是特有功能无法访问。

作用就是限制对子类特有功能的访问。

专业讲：向上转型。将子类型隐藏。就不用使用子类的特有方法。

如果还想使用具体动物猫的特有功能。你可以将该对象进行向下转型。

Cat c= new (Cat)a; 向下转型的目的是使用子类中的特有方法。

注意：对于转型，自始自终都是子类对象在做着变化，要么引用指向父类，要么引用指向本类。

例如：Animal a1=new Dog( );

Cat c1=new (Cat)a1;

以上代码编译器会报异常，ClassCastException 类型转换错误。

注意：只有具有继承关系的类之间才能发生转换。

七、转型的特点。

向上转型：

1、子类向上转型为父类，提高了代码的扩展性，可以传很多对象进来。

2、限制了子类的特有功能。

向下转型：

1、可以使用子类的特有功能。

abstract class Animal
{
	abstract void eat();

}

class Dog extends Animal
{
	void eat()
	{
		System.out.println("啃骨头");
	}
	void lookHome()
	{
		System.out.println("看家");
	}
}

class Cat extends Animal
{
	void eat()
	{
		System.out.println("吃鱼");
	}
	void catchMouse()
	{
		System.out.println("抓老鼠");
	}
}

class Pig extends Animal
{
	void eat()
	{
		System.out.println("饲料");
	}
	void gongDi()
	{
		System.out.println("拱地");
	}
}

class DuoTaiDemo 
{
	public static void main(String[] args) 
	{
		
//		Cat c = new Cat();
//		c.eat();
//		c.catchMouse();

		Animal a = new Cat(); //自动类型提升，猫对象提升了动物类型。但是特有功能无法s访问。
							//作用就是限制对特有功能的访问。
							//专业讲：向上转型。将子类型隐藏。就不用使用子类的特有方法。


//		a.eat();

		//如果还想用具体动物猫的特有功能。 
		//你可以将该对象进行向下转型。
//		Cat c = (Cat)a;//向下转型的目的是为了使用子类中的特有方法。
//		c.eat();
//		c.catchMouse();

//		注意：对于转型，自始自终都是子类对象在做着类型的变化。
//		Animal a1 = new Dog();
//		Cat c1 = (Cat)a1;//ClassCastException


		/*
		Cat c = new Cat();

//		Dog d = new Dog();

//		c.eat();
		method(c);
//		method(d);
//		method(new Pig());
		*/

		method(new  Dog());

	}

	public static void method(Animal a)//Animal a = new Dog();
	{
		a.eat();

		if(a instanceof Cat)//instanceof：用于判断对象的具体类型。只能用于引用数据类型判断
//						//通常在向下转型前用于健壮性的判断。

		{
			Cat c = (Cat)a;
			c.catchMouse();
		}
		else if(a instanceof Dog)
		{
			Dog d = (Dog)a;
			d.lookHome();
		}
		else
		{
		
		}
		
	}
	/*
	public static void method(Cat c)
	{
		c.eat();
	}
	public static void method(Dog d)
	{	
		
	}
	*/	
}

多态时成员的特点：

1、成员变量：

编译时：参考引用型变量所属的类是否有调用的成员变量, 有，编译通过，没有，编译失败。

运行时：参考引用型变量所属的类是否有调用的成员变量, 并运行该所属类中的成员变量。

简单说：编译和运行都参考等号左边。

2、成员函数(非静态)。

编译时：参考引用型变量所属的类中是否有调用的函数。有编译通过，没有，编译失败。

运行时：参考的是对象所属的类中是否有调用的函数。

简单说：编译看左边，运行看右边。

因为成员函数存在覆盖特性。

3、静态函数。

编译时：参考引用型变量所属的类中是否有调用的静态方法。

运行时：参考引用型变量所属的类中是否有调回用的静态方法。

简单说：编译和运行都看左边。

其实对于静态方法，是不需要对象的。直接用类名调用即可。

class Fu
{
//	int num = 3;
	void show()
	{
		System.out.println("fu show");
	}

	static void method()
	{
		System.out.println("fu static method");
	}
}

class Zi extends Fu
{
//	int num = 4;
	void show()
	{
		System.out.println("zi show");
	}

	static void method()
	{
		System.out.println("zi static method");
	}
}



class  DuoTaiDemo3
{
	public static void main(String[] args) 
	{
		Fu.method();
		Zi.method();
		Fu f = new Zi();//
//		f.method();
//		f.show();
//		System.out.println(f.num);


//		Zi z = new Zi();
//		System.out.println(z.num);
	}
}