多态数组

概述
使用
演示

多态参数

定义
举栗

旅行者请吃饭
骑士团发工资

关于接口的多态参数和多态数组

接口的多态参数
接口的多态数组

一、多态数组

1.概述 :

多态数组，需要满足数组类型定义为父类类型，而里面保存的实际元素类型为子类类型（可同时存放多种子类）。实际达到的效果就是父类引用指向子类对象。

2.使用 :

多态数组在使用时往往与instanceof关键字配合使用。即在遍历数组时，通过增加if条件语句进行判断，使得不同类型的子类对象元素可以分别使用它们各自的特有方法。

3.演示 :

还记得我们在多态篇开篇中举的旅行者请刻晴，钟离和甘雨吃饭的例子吗？没错😂，up雀氏有一个栗子用到死的嫌疑。但是不要紧，演示看重的是效果😎。可能有小伙伴儿们没看过多态篇，我把代码再给大家放一下，Liyue_people类，Keqing类，Zhongli类，Ganyu类代码如下 :

packageknowledge.polymorphism.application;
publicclassLiyue_people {
privateStringname;
privateintage;
privateStringgender;
publicLiyue_people() {
    }
publicLiyue_people(Stringname, intage, Stringgender) {
this.name=name;
this.age=age;
this.gender=gender;
    }
publicStringgetName() {
returnname;
    }
publicvoidsetName(Stringname) {
this.name=name;
    }
publicintgetAge() {
returnage;
    }
publicvoidsetAge(intage) {
this.age=age;
    }
publicStringgetGender() {
returngender;
    }
publicvoidsetGender(Stringgender) {
this.gender=gender;
    }
}
classKeqingextendsLiyue_people {
publicKeqing(Stringname, intage, Stringgender) {
super(name, age, gender);
    }
//刻晴————天街巡游publicvoidsky_street_cruise() {
System.out.println("剑光如我，斩尽芜杂！");
    }
}
classZhongliextendsLiyue_people {
publicZhongli(Stringname, intage, Stringgender) {
super(name, age, gender);
    }
//钟离————天星publicvoidsky_stars() {
System.out.println("天动万象！");
    }
}
classGanyuextendsLiyue_people {
publicGanyu(Stringname, intage, Stringgender) {
super(name, age, gender);
    }
//甘雨————降众天华publicvoiddescend_to_heaven() {
System.out.println("为了岩王帝君！");
    }
}

好滴，现在我们以Test_polyArray类为测试类，并在测试类建立一个Liyue_people类型的数组，设数组长度为3，然后为数组手动添加元素，令数组的三个元素分别指向Keqing类对象，Zhongli类对象，和Ganyu类对象。因为刻晴类，钟离类和甘雨类都没有用public修饰，所以不能跨包使用，因此up将它们的代码复制了一份到本包下。

Test_polyArray类代码如下 :

packageknowledge.polymorphism.application;
publicclassTest_polyArray {
publicstaticvoidmain(String[] args) {
Liyue_people[] liyue_people=newLiyue_people[3];
liyue_people[0] =newKeqing("刻晴", 18, "女");
liyue_people[1] =newZhongli("摩拉克斯", 6000, "男");
liyue_people[2] =newGanyu("甘雨", 3000, "女");
for (inti=0; i<liyue_people.length; i++) {
if (liyue_people[i] instanceofKeqing) {
System.out.println();
                ((Keqing) liyue_people[i]).sky_street_cruise();
            } elseif (liyue_people[i] instanceofZhongli) {
                ((Zhongli) liyue_people[i]).sky_stars();
            } elseif (liyue_people[i] instanceofGanyu){
                ((Ganyu)liyue_people[i]).descend_to_heaven();
            }
        }
    }
}

运行结果 :

二、多态参数

1.定义 :

方法的形参类型定义为父类类型，当传入的实参类型为子类类型时，每传入一个子类对象，都相当于形成了一次多态（父类引用指向子类对象）。

2.举栗 :

①旅行者请吃饭 :

其实就是我们在“多态中成员方法的使用”章节中，对旅行者请吃饭方法的改进😂。大家应该已经都掌握了，不理解的可以再回去看看，这里不再赘述。

②骑士团发工资 :

再给大家举个栗子吧，加深印象。如下 :

蒙德的风花节马上就要到了，骑士团准备趁风花节到来之际给大家发放工资，让大家过一个好节。现在有三个人的工资需要发放：琴团长，可莉，和优菈。骑士团每个人的基本工资是10000摩拉，琴团长作为代理团长，日理万机，功勋卓著，理应多发放100000摩拉；而可莉因为频繁炸🐟，被关了三次禁闭，因此要扣除5000摩拉；优菈则因为劳伦斯贵族的身份而被骑士团的财务部针对，记账时故意抹去了一个0，因此优菈仅仅能拿到1000摩拉。请使用java进行描述：

思路 :

①琴团长，可莉，和优菈都是西风骑士团的人，因此，可以定义一个Knights类（骑士团类）作为父类。再分别定义Qin类，Keli类，和Youla类去继承Knights类。

②骑士团每个人的基本工资是10000，因此可在父类定义成员变量base_salary来表示基本工资。

③这三个人都需要领工资，因此可在父类定义成员方法getSalary() 来表示领工资。

④由于这三个人除了基本工资外，各人实际领到的工资都会有一些变化，因此需要在每个子类中重写getSalary() 方法，并返回各自应得的薪水。此外，也可以在子类中重写toString() 方法，已打印出领工资对象的基本信息。

⑤需要一个机构来发工资啊，不然工资都自己去领，那不乱套了？我们可以定义一个Knights_finance（骑士团财务部）来执行发工资的职责——即在Knights_finance类中定义一个pay_off() 方法。该方法需要传入一个要领工资的对象，这里就要用到多态参数了，将形参类型定义为Knights类型，不管传入哪个子类，都可以形成多态，并且每传入一次都会形成一次多态。并且，在方法体中利用instanceof关键字判断出是谁来领工资了，调用子类对象重写后的getSalary() 方法，即可返回他应得的工资。那么不管是琴团长，可莉，还是优菈，只要是骑士团的人来领工资，都可以通过这个方法实现，这样就达到了一个方法实现多个需求的效果，与我们上一个栗子中的旅行者类的请客吃饭方法原理一致。

⑥最后就是定义一个测试类了，up这里定义了一个Get_paid类。在测试类中创建骑士团财务部对象，然后调用pay_off() 方法即可。

关系图 :

代码 :

老规矩，为了形式简洁，up将Qin类，Keli类和Youla类都写在了Knights类的源文件中，Knights类，Qin类，Keli类，Youla类代码如下 :

packageknowledge.polymorphism.application.poly_parameter;
publicclassKnights {                  /** 父类 : Knights类（以JavaBean标准来写） *///成员变量privateStringname;
privatedoublebase_salary=10000;         //注意 : 工资以摩拉为单位//构造器publicKnights() {
    }
publicKnights(Stringname, doublebase_salary) {
this.name=name;
this.base_salary=base_salary;
    }
//getter，setter方法publicStringgetName() {
returnname;
    }
publicvoidsetName(Stringname) {
this.name=name;
    }
publicdoublegetBase_salary() {
returnbase_salary;
    }
publicvoidsetBase_salary(doublebase_salary) {
this.base_salary=base_salary;
    }
//定义骑士团公有的领工资方法publicdoublegetSalary() {
returnbase_salary;
    }
}
classQinextendsKnights {             /** 子类 : 琴类 */publicQin(Stringname, doublebase_salary) {
super(name, base_salary);
    }
//重写父类getSalary() 方法，返回琴团长应得的工资。publicdoublegetSalary() {
returnsuper.getSalary() +100000;
    }
//重写toString() 方法，打印琴团长的基本信息publicStringtoString() {
return"Qin{"+"name='"+getName() +"\'"+"，base_salary="+getBase_salary() +"}";
    }
}
classKeliextendsKnights {            /** 子类 : 可莉类 */publicKeli(Stringname, doublebase_salary) {
super(name, base_salary);
    }
//重写父类getSalary() 方法，返回可莉应得的工资。publicdoublegetSalary() {
returnsuper.getSalary() -5000;
    }
//重写toString() 方法，打印可莉的基本信息publicStringtoString() {
return"Keli{"+"name='"+getName() +"\'"+"，base_salary="+getBase_salary() +"}";
    }
}
classYoulaextendsKnights {           /** 子类 : 优菈类 */publicYoula(Stringname, doublebase_salary) {
super(name, base_salary);
    }
//重写父类getSalary() 方法，返回优菈应得的工资。publicdoublegetSalary() {
returnsuper.getSalary() /10;
    }
//重写toString() 方法，打印优菈的基本信息publicStringtoString() {
return"Youla{"+"name='"+getName() +"\'"+"，base_salary="+getBase_salary() +"}";
    }
}

Knights_finance类代码如下 :

packageknowledge.polymorphism.application.poly_parameter;
publicclassKnights_finance {
publicvoidpay_off(Knightsknight) {       //利用多态参数，不管多少人领工资，都只需要一个方法if (knightinstanceofQin) {
System.out.println("琴团长如理万机，功勋显著，因此补发1w摩拉的津贴。");
System.out.println("琴团长能领到的工资为: "+knight.getSalary());
        } elseif (knightinstanceofKeli) {
System.out.println("可莉频繁炸🐟，关禁闭三次，因此扣除5000摩拉！");
System.out.println("可莉能领到的工资为: "+knight.getSalary());
        } elseif (knightinstanceofYoula) {
System.out.println("优菈的工资清单被骑士团\"不小心\"弄错啦，因此工资被抹了一个0。");
System.out.println("优菈能领到的工资为: "+knight.getSalary());
        }
    }
}

Get_paid类代码如下 :

packageknowledge.polymorphism.application.poly_parameter;
publicclassGet_paid {
publicstaticvoidmain(String[] args) {
//创建领工资对象//创建琴类对象Qinqin=newQin("琴", 10000);
//创建可莉对象Kelikeli=newKeli("可莉", 10000);
//创建优菈对象Youlayoula=newYoula("优菈", 10000);
//创建发工资对象//创建骑士团财务部对象Knights_financeknights_finance=newKnights_finance();
System.out.println("谁来领工资了？"+qin);
knights_finance.pay_off(qin);
System.out.println("----------------------------------");
System.out.println("谁来领工资了？"+keli);
knights_finance.pay_off(keli);
System.out.println("----------------------------------");
System.out.println("谁来领工资了？"+youla);
knights_finance.pay_off(youla);
    }
}

运行结果 :

三、关于接口的多态(没学接口不要看）

1.接口的多态参数 :

对照上文中多态参数的定义，我们可以将方法的形参设置为接口类型，每次传入一个实现类对象都相当于一次接口多态（接口引用指向实现类对象）。

现在我们要求定义一个Usb接口，在接口中定义抽象方法connect()，然后分别定义Ipad类，Phone类，Mouse类，Keyboard类去实现Usb接口中的connect() 方法。最后以ConnectUsb类为测试类。在测试类中，我们定义一个静态方法，然后将形参类型设置为接口类型，在方法体中通过接口引用调用connect() 方法。代码如下 :

packageknowledge.port.application.port_parameter;
publicinterfaceUsb {
voidconnect();
}
classIpadimplementsUsb {
@Overridepublicvoidconnect() {
System.out.println("平板已连接usb接口");
    }
}
classPhoneimplementsUsb {
@Overridepublicvoidconnect() {
System.out.println("手机已连接usb接口");
    }
}
classMouseimplementsUsb {
@Overridepublicvoidconnect() {
System.out.println("鼠标已连接usb接口");
    }
}
classKeyBoardimplementsUsb{
@Overridepublicvoidconnect() {
System.out.println("键盘已连接usb接口");
    }
}
classConnectUsb {
publicstaticvoidmain(String[] args) {
//创建平板类对象Ipadipad=newIpad();
//创建手机类对象Phonephone=newPhone();
//创建鼠标类对象Mousemouse=newMouse();
//创建键盘类对象KeyBoardkeyBoard=newKeyBoard();
//调用多态参数的静态方法invoke_port(ipad);
System.out.println("----------");
invoke_port(phone);
System.out.println("----------");
invoke_port(mouse);
System.out.println("----------");
invoke_port(keyBoard);
    }
publicstaticvoidinvoke_port(Usbusb) {
usb.connect();
    }
}

运行结果 :

2.接口的多态数组 :

以多态参数的代码为基础，Usb接口，以及各个实现类代码均不变。不一样的是，我们在测试类中创建一个接口类型的数组，然后手动为每个元素（即接口类引用）分配不同的对象。接着利用for循环遍历数组，遍历过程中增加instanceof关键字和if结合的判断语句，如果满足条件就向下转型，调用对应实现类的方法。其实就和普通的多态数组一回事儿！原理一致。

测试类ConnectUsb代码如下 :

packageknowledge.port.application.port_parameter;
importjava.util.Map;
publicinterfaceUsb {
voidconnect();
}
classIpadimplementsUsb {
@Overridepublicvoidconnect() {
System.out.println("平板已连接usb接口");
    }
}
classPhoneimplementsUsb {
@Overridepublicvoidconnect() {
System.out.println("手机已连接usb接口");
    }
}
classMouseimplementsUsb {
@Overridepublicvoidconnect() {
System.out.println("鼠标已连接usb接口");
    }
}
classKeyBoardimplementsUsb{
@Overridepublicvoidconnect() {
System.out.println("键盘已连接usb接口");
    }
}
classConnectUsb {
publicstaticvoidmain(String[] args) {
//创建接口类型的数组Usb[] usbs=newUsb[4];
//手动赋值usbs[0] =newIpad();
usbs[1] =newPhone();
usbs[2] =newMouse();
usbs[3] =newKeyBoard();
for (inti=0; i<usbs.length; i++) {
if (usbs[i] instanceofIpad) {
usbs[i].connect();
            } elseif (usbs[i] instanceofPhone) {
usbs[i].connect();
            } elseif (usbs[i] instanceofMouse) {
usbs[i].connect();
            } else {
usbs[i].connect();
            }
        }
/*实际上，此处我们不需要使用instanceof关键字的if语句，因为我们不使用实现类的特有方法，依靠动态绑定机制就可以解决了。*/System.out.println("-------------------------------------");
for (inti=0; i<usbs.length; i++) {
usbs[i].connect();
System.out.println("===========");
        }
    }
}

运行结果 :

🆗，到这里多态的应用就暂时结束了。其实代码本身没什么难度，重点是要掌握多态参数和多态数组的使用。感谢阅读！

java 多态的应用——多态数组和多态参数详解

一、多态数组

1.概述 :

2.使用 :

3.演示 :

二、多态参数

1.定义 :

2.举栗 :

①旅行者请吃饭 :

②骑士团发工资 :

三、关于接口的多态(没学接口不要看）

1.接口的多态参数 :

2.接口的多态数组 :

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

java 多态的应用——多态数组和多态参数详解

一、多态数组

1.概述 :

2.使用 :

3.演示 :

二、多态参数

1.定义 :

2.举栗 :

①旅行者请吃饭 :

②骑士团发工资 :

三、关于接口的多态(没学接口不要看）

1.接口的多态参数 :

2.接口的多态数组 :

热门文章

最新文章

相关课程

相关电子书

相关实验场景