JAVA 面向对象（多态的概念，作用，好处；重写与重载的区别）

什么是多态

终于到了类的最后一个特点：多态。
多态的意思是多种形态，其实也就是一个实体在不同情况下，用不同的形态去应对。
这么做的好处是好处是可以把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。打个比方，我们在继承中讲过的动物类与狗猫，当时我们知道由于猫与狗的叫声不同，所以我们在继承后，分别写了他们叫喊的方法，那么在学完多态以后我们可以写一个实体，让他作为狗的时候汪汪汪，猫的时候喵喵喵。
到这里我们知道多态有一个必须的前提叫做：继承，没有继承就没有多态啊。

多态的实现

那我们如何实现多态呢？
我们先来了解几个概念

重载与重写

在自定义方法中，我们通过函数名相同，参数的类型/个数不同和返回值没有关系来进行函数的重载。

public class duotaioop {

	void cz() {

	}
	void cz(int a) {

	}
	char cz(char c) {
		return c;

	}
	void cz(int a,char c) {

	}
	void cz(char c,int a) {

	}
	//注意注意
	int cz(char c,int a) {

	}
	public static void main(String[] args) {

	}
}

以上的重载中我们可以发现，我们对于函数重载的返回值是没有要求的，但是参数必须在类型或着数量或者顺序上有所不同。
那么重写呢？重写其实也很简单，它相当于自己写了一个方法，只是和父类的方法名一样。

public class duotaioop {

	public static void main(String[] args) {
	    Animal animal= new Animal();
		animal.call();
		Dog dog = new Dog();
		dog.call();
    	Cat cat = new Cat();
		cat.call();
	}
}
class Animal{
	void call() {
		System.out.println("嗷嗷嗷");
	}
}
class Dog extends Animal{
	void call() {
		System.out.println("汪汪汪");
	}
}
class Cat extends Animal{
	void call() {
		System.out.println("喵喵喵");
	}
}

我们在使用子类的call();方法的时候把父类的该方法覆盖掉了，因此我们使用的就变为了子类的call();方法，也就在这里同样的一个方法在不同的情况下（动物的不同）叫声就不一样了，这里便是重写。

多态的使用与实现

这个时候一些小伙伴会说“啊，博主，我直接在类中写一个call()方法和这种情况不是一样的嘛！”这里自然在相对比较少的时候确实没什么差别，因为我们还没有写多态呢。

public class duotaioop {
	static void listencall(Animal a) {
		 a.call();
	}
	public static void main(String[] args) {
		Animal dog = new Dog();
		Animal cat = new Cat();
		listencall(dog);
		listencall(cat);
	}
}
class Animal{
	void call() {
		System.out.println("嗷嗷嗷");
	}
}
class Dog extends Animal{
	void call() {
		System.out.println("汪汪汪");
	}
}
class Cat extends Animal{
	void call() {
		System.out.println("喵喵喵");
	}
}

我们在重写函数后，我们现在写一个方法，听叫声的方法；我们把猫放过去他就喵喵喵，狗放过去他就汪汪汪。因此我们定义了一个方法listencall(Animal a)，这样我们就实现了，放什么叫什么？
注意大家如果看我的代码就会发现我在new对象的时候并没有采用Dog dog = new Dog();这种方式，这种方式其实就是一种向上转型，也就是子类转换为父类。

多态的好处

1、 多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法。
2、 提高了程序的扩展性和可维护性。
这种过于官方的说法似乎不太适合我们接受。前者其实主要是由多态来保证的，后者是由继承来保证的。
那么我们拿代码来说明一下：

public class duotaioop {
	public static void main(String[] args) {
		Dog dog = new Dog();
		Cat cat = new Cat();
		Listen.listencall(dog);
		Listen.listencall(cat);
	}
}
class Listen {
	static void listencall(Animal a) {
		a.call();
	}
}

动物的那串代码与上边保持一致，我就没有再复制了…
这就是我们不需要再知道到底是需要什么类型了，我们仅仅调用了dog并且把它放到Listen类中的listencall方法就可以了。这就是上述好处的具体实现。
至于第二个其实我觉得这个作为继承的好处应该更为准确，当然他的作用在于，比如我们想要猫和狗同时多一个方法，我们仅仅需要在动物类里加一个方法就可以了，而出了错，我们仅仅再父对象改一下就可以了。这就是代码的可维护性和可扩展性。