Java——三大特性之一：多态（概念理解+应用举例）

1.概念理解

在Java语言中，具有着三大特性：封装、继承和多态。

那么，在之前的博文中，已经讲过了封装和继承，详细的内容可以参考博主下面的这两篇博文链接：👇👇👇

封装博文链接：https://blog.csdn.net/weixin_43823808/article/details/106330673

继承博文链接：https://blog.csdn.net/weixin_43823808/article/details/106349135

在这篇博文中，主要为大家讲解一下我对多态的理解：

多态是同一个行为具有多个不同表现形式或形态的能力，多态性是对象多种表现形式的体现。 

多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：👇👇👇

1.1 多态的优点 

①消除类型之间的耦合关系。

②可替换性。

③可扩充性。

④接口性。

⑤灵活性。

⑥简化性。

1.2 多态存在的三个必要条件

①继承。（子类继承父类，也可以是非抽象子类继承抽象父类）

②重写。 （子类对父类中方法的重写）

③父类引用子类对象。（向上转型，也可以通过向下转型再转换回来）

当使用多态方式调用某个方法时，首先检查父类中是否有该方法，如果没有，则编译的时候会报错；如果有，再去调用子类的同名方法。

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

 

2.应用举例

Example 1： 

class Animal {
	public void hobby() {
		System.out.println("动物的叫声有很多种！");
	}
}
class Cat extends Animal {
	public void hobby() { //子类重写父类的 hobby 方法
		super.hobby(); //要想调用父类中被重写的方法，必须使用 super 关键字
		System.out.println("猫：喵喵喵！");
	}
}
class Dog extends Animal { //Dog 子类的理解和上面的 Cat 子类是一样的
	public void hobby() {
		super.hobby();
		System.out.println("狗：汪汪汪！");
	}
}
public class Study {
	public static void main(String[] args) {
		Animal a=new Cat(); //父类声明对象，子类实例化对象，即向上转型
		a.hobby();
		Animal b=new Dog(); //父类声明对象，子类实例化对象，即向上转型
		b.hobby();
	}
}

以上这个例子，就是Java多态性的一个体现， 通过子类继承父类，并且子类去重写父类的中的同名方法，最后我们通过向上转型的方法来实现多态性。程序运行结果如下：👇👇👇

Example 2： 

abstract class Animal {//抽象类
	public abstract void eat();//继承它的子类必须重写这个方法
}
class Cat extends Animal {
	public void eat() {
		System.out.println("猫喜欢吃鱼！");
	}
	public void work() {
		System.out.println("猫也会抓老鼠！");
	}
}
class Dog extends Animal {
	public void eat() {
		System.out.println("狗喜欢吃骨头！");
	}
	public void work() {
		System.out.println("狗也会看家！");
	}
}
public class Testing {
	public static void show(Animal a) {//实例化一个对象a
	//在 main 方法中，直接使用类进行调用，所以 show 方法需定义为静态的
		a.eat(); //将两个子类的对象进行向上转型，并且子类已经重写了抽象父类的抽象方法eat
		//所以就相当于在调用两个字类中各自的 eat 方法
		if(a instanceof Cat) { //类型判断，如果 a 是子类 Cat 的对象
			Cat b=(Cat)a;
			b.work();
		}
		else if(a instanceof Dog) { //类型判断，如果 a 是子类 Dog 的对象
			Dog b=(Dog)a;
			b.work();
		}
	}
	public static void main(String[] args) {
		show(new Cat()); //通过 Testing 类调用 show 方法，具体在 Cat 类中实现
		show(new Dog()); //通过 Testing 类调用 show 方法，具体在 Dog 类中实现
		Animal c=new Cat(); //父类声明对象，子类实例化对象，即向上转型
		c.eat(); //调用 Cat 类的 eat 方法
		Cat d=(Cat)c; //将对象 c 强制转换回来，即向下转型
		d.work(); //调用 Cat 类的 work 方法
	}
}

show(new Cat());//等价于下面的这两行代码

Animal a=new Cat();//这两行更能体现“静态方法由类调用”这句话
Testing.show(a);

这个例子比第一个例子要复杂一点， 基本上和第一个例子中的解释是一样的。

但是需要注意的一点是：实例方法由对象调用，静态方法由类调用，就是这个例子中的 show 方法（声明为static静态）

具体的我已经将注释写的很清楚了，大家可以参考着去理解，下面是程序的运行结果：👇👇👇

---

那么，以上就是博主对于Java三大特性之一——多态的理解，希望对大家学习Java有所帮助！！！😄😄😄