多态的好处
- 代码扩展性很好（由继承所带来的好处）
- 代码的维护性很好（由多态所带来的好处）
例题多态练习
class Animal2{
String name;
int age;
Animal2(){
}
Animal2(String name,int age){
this.name = name;
this.age = age;
}
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
}
class Dog2 extends Animal2{
Dog2(String name,int age){
this.name = name;
this.age = age;
}
@Override
public void eat() {
System.out.println("狗吃肉");
}
@Override
public void sleep() {
System.out.println("狗侧着睡");
}
}
class Alpaca extends Animal2{
Alpaca(String name,int age){
this.name = name;
this.age = age;
}
@Override
public void eat() {
System.out.println("羊驼吃草");
}
@Override
public void sleep() {
System.out.println("羊驼卧着睡");
}
}
class Panda extends Animal2{
Panda(String name,int age){
this.name = name;
this.age = age;
}
@Override
public void eat() {
System.out.println("熊猫吃竹子");
}
@Override
public void sleep() {
System.out.println("熊猫随便睡");
}
}
//用工具类改进
class AnimalTool{
//构造方法私有化
private AnimalTool(){
}
/*
将来再想养新的动物，只要在工具类中添加一个新的动物方法就可以了
//访问狗的方法
public static void useDog(Dog2 dog2){
dog2.eat();
dog2.sleep();
}
//访问羊驼的方法
public static void useAlpaca(Alpaca alpaca){
alpaca.eat();
alpaca.sleep();
}
//访问熊猫的方法
//访问老虎的方法
//...
但是呢，工具理论上是不允许修改的，所以我们需要再次改进
因为AnimalTool中的狗、羊驼、熊猫、老虎等等都属于动物，使用多态改进。
*/
public static void useAnimal(Animal2 animal){ // Animal2 animal2 = new Panda("团团", 2);//多态
animal.eat();
animal.sleep();
}
}
public class CatDogDemo {
public static void main(String[] args) {
// 现在我想养一只狗
Dog2 d1 = new Dog2("小花", 3);
// d1.eat();
// d1.sleep();
//使用方法改进后
// useDog(d1);
//使用工具类改进后
// AnimalTool.useDog(d1);
//使用多态改进之后
AnimalTool.useAnimal(d1);
//我想再养一条狗
Dog2 d2 = new Dog2("奶糖", 4);
// d2.eat();
// d2.sleep();
//使用方法改进后
// useDog(d2);
//使用工具类改进后
// AnimalTool.useDog(d2);
//使用多态改进之后
AnimalTool.useAnimal(d2);
//我还想养一条狗
Dog2 d3 = new Dog2("旺财", 2);
// d3.eat();
// d3.sleep();
//使用方法改进后
// useDog(d3);
//使用工具类改进后
// AnimalTool.useDog(d3);
//使用多态改进之后
AnimalTool.useAnimal(d3);
//你不觉得每次调用方法都需要写一遍eat()和sleep有重复的吗？
//使用方法改进
//我又想养羊驼
Alpaca a1 = new Alpaca("小白", 2);
// a1.eat();
// a1.sleep();
//使用方法改进后
// useAlpaca(a1);
//使用工具类改进后
// AnimalTool.useAlpaca(a1);
//使用多态改进之后
AnimalTool.useAnimal(a1);
//再养只羊驼
Alpaca a2 = new Alpaca("小黄", 3);
// a2.eat();
// a2.sleep();
//使用方法改进后
// useAlpaca(a2);
//使用工具类改进后
// AnimalTool.useAlpaca(a2);
//使用多态改进之后
AnimalTool.useAnimal(a2);
//再养只羊驼
Alpaca a3 = new Alpaca("小黑", 3);
// a3.eat();
// a3.sleep();
//使用方法改进后
// useAlpaca(a3);
//使用工具类改进后
// AnimalTool.useAlpaca(a3);
//使用多态改进之后
AnimalTool.useAnimal(a3);
//有重复的和狗一样也使用方法改进
/*
如果我现在不想养羊驼了，想养熊猫
是不是养n只熊猫，要new出n次
每个熊猫也有吃和睡的方法
按照上面的写代码的习惯，再额外新增一个熊猫的方法
但是，将来我还有可能养老虎，狮子，豹子等等。。。
这些动物按照上面的写代码的习惯,是不是应该都需要写一个方法，最后会发现这个程序非常臃肿杂乱
回想一下，我们之前将多个方法操作同一类型的时候，我们用工具类进行改进的
用工具类改进之后，将来再想养新的动物，只要在工具类中添加一个新的动物方法就可以
但是呢，工具理论上不允许修改的
所以我们需要再次改进
怎么改进呢？使用多态改进
*/
//使用多态改进之后
//利用的是多态访问成员方法的特点：编译看左，运行看右
Panda p1 = new Panda("团团", 2);
AnimalTool.useAnimal(p1);
Panda p2 = new Panda("圆圆", 3);
AnimalTool.useAnimal(p2);
Panda p3 = new Panda("平平", 4);
AnimalTool.useAnimal(p3);
}
// //访问狗的方法
// public static void useDog(Dog2 dog2){
// dog2.eat();
// dog2.sleep();
// }
//
// //访问羊驼的方法
// public static void useAlpaca(Alpaca alpaca){
// alpaca.eat();
// alpaca.sleep();
// }
//
// //访问熊猫的方法
//
// //访问老虎的方法
// //...
}
