2024年面向对象类继承与接口实验报告

试验十类继承与接口（二）课程名称：面对对象程序设计试验项目名称：试验十类继承与接口（二）学生姓名：专业：学号：试验地点：试验日期：年月【试验目标】1．掌握Java类的继承特点，包括子类申明、对象创建2.掌握域的继承与隐藏的特点和使用方法3.掌握措施的继承与重写的特点和使用方法【试验内容】一.改错题检查下面代码是否有错，假如有错，写明错误原因，并修正错误。（1）classAaa{inti; Aaa(){i=-1;} Aaa(inta){i=a;} Aaa(doubled){Aaa((int)d);}}是否犯错：是犯错原因（假如犯错）：结构器调用结构器不能直接用名classAaa{ inti; Aaa(){i=-1;} Aaa(inta){i=a;} Aaa(doubled){this((int)d);} }（2）classAaa{inti; Aaa(){i=-1;} Aaa(inta){i=a;} Aaa(doublea){intb=(int)a;this(b);}}是否犯错：是犯错原因（假如犯错）：this放第一行classAaa{ inti; Aaa(){i=-1;} Aaa(inta){i=a;} Aaa(doublea){this((int)a);} }（3）classAaa{inti;Aaa(inta){i=a;}}classBbbextendsAaa{Bbb(){}}是否犯错：是犯错原因（假如犯错）：父类没有无参结构，子类中药通过super调用父类结构classAaa{ inti; Aaa(inta){i=a;} } classBbbextendsAaa{ Bbb(inta){ super(a); } }（4）classAaa{privateinti;protectedintj;}classBbbextendsAaa{Bbb(){ i=10; j=99;}}是否犯错：是犯错原因（假如犯错）：private只能在自己的类中使用classAaa{ protectedinti; protectedintj; } classBbbextendsAaa{ Bbb(){ i=10; j=99; } }（5）编译下面程序，程序是否犯错classA{inti=100;}classBextendsA{inti=10000;publicstaticvoidmain(String[]args){System.out.println(this.i);System.out.println(super.i);}}是否犯错：是犯错原因（假如犯错）：不能在静态措施使用thissuperclassA{ inti=100; } classBextendsA{ inti=10000; publicvoidmain(String[]args){ System.out.println(this.i); System.out.println(super.i); } }c)假如将上述类B的inti=10000改为staticinti=10000;类A的inti=100改为staticinti=100;程序是否犯错?是犯错原因（假如犯错）：不能在静态措施使用thissuperclassA{ inti=100; } classBextendsA{ inti=10000; publicvoidmain(String[]args){ System.out.println(this.i); System.out.println(super.i); } }d)假如将类B的main措施改为publicstaticvoidmain(String[]args){Bb=newB();System.out.println(b.i);System.out.println((A)b.i);}程序是否犯错?是犯错原因（假如犯错）：不能强制将in类型改为A假如没犯错,给出成果:上面的System.out.println(b.i)的含义:System.out.println((A)b.i)的含义:（6）classAaa{inti;publicvoidAaa(inta){i=a;}publicstaticvoidmain(String[]args){Aaaa=newAaa(10);}}是否犯错：是犯错原因（假如犯错）：结构器没有返回classAaa{ inti; publicAaa(inta){i=a;} publicstaticvoidmain(String[]args){ Aaaa=newAaa(10); } }（7）classAaa{publicstaticvoidmain(String[]args){ int[][]a=newint[5][];for(inti=0;i<a.length;i++)for(intj=0;i<a[i].length;j++){a[i][j]=(int)(100*Math.random());System.out.println(a[i][j]);}}}是否犯错：犯错原因（假如犯错）：for(intj=0;i<a[i].length;j++)出现无限循环classAaa{ publicstaticvoidmain(String[]args){ int[][]a=newint[5][5]; for(inti=0;i<a.length;i++) for(intj=0;j<a[i].length;j++){ a[i][j]=(int)(100*Math.random()); System.out.println(a[i][j]); } } }（8）classA{intabc(inti){return1;}//措施1intabc(intj){return2;}//措施2intabc(inti,intj){return3;}//措施3voidabc(inti){}//措施4}是否有错：是上面类A中定义的四个措施是否都是措施的重载，有无重复定义的措施，假如有，那么哪几个措施是重复定义的？措施1和措施2是重复定义（9）classA{voidshow(){System.out.println("A类的show()");}}classBextendsA{intshow(){System.out.println("B类的show()");}publicstaticvoidmain(String[]args){ Bb=newB(); b.show();}}上面程序中的措施覆盖是否犯错：是犯错原因（假如犯错）：假如将类B中的措施show()改为：intshow(intb){System.out.println("B类的show()");returnb;}程序是否犯错？不犯错二.程序分析设计题下面各个设计要放在各自的包中。1.最初设计最初设计的所有类都放到first包中（1）员工类的设计假设企业有三种类型的员工：经理（manager），高级工（advancedworker），一般工人（normalworker）。先分别设计描述这三种类型工人的类，要求如下:三个类的名称分别为Manager,AdvancedWorker,NormalWorker;每个类都有name（姓名），id（工号），age（年龄），workingAge（工龄）等private类型的实例变量，而每个实例变量都有public类型的get和set措施。每个类都要定义结构器，包括无参数结构器和最少一个有参数结构器（用于对实例变量赋初值）每个类都要定义一个public型的salary措施，用于计算员工对象的每个月薪水，并返回计算成果，工资计算逻辑是：底薪+工龄工资。例如，经理的底薪是0，另外依照工龄每年加200元；高级工的底薪是10000元，另加每年100元的工龄工资；一般员工的底薪是8000，另加每年80元的工龄工资。其他功效能够自行考虑publicclassManager{//定义name，id，age，workingAge等private类型的实例变量//定义两个结构器，无参数结构器和有参数结构器publicManager(Stringname,Stringid,intage,intworkingAge){/*补充对象初始化代码*/}//定义每个实例变量的public类型的get和set措施。publicdoublesalary(){/*代码补充*/}}publicclassAdvancedWorker{//类似Manager}publicclassNormalWorker{//类似Manager}（2）企业类的设计企业类用于描述企业，要求如下：类名：Company设计企业的private实例变量有：企业名称（name），三个员工对象数组（分别描述经理们、高级工们、一般员工们）等，针对这些实例变量分别提供get和set措施。注意：为了简化设计，这些员工对象数组的创建不在Company对象内部，而是通过有参数结构器或者set措施从Company对象外部赋值到Company对象内部。提供结构器：包括无参数结构器、两个有参数结构器(一个要对所有实例变量初始赋值，另外一个只需要对name赋值)。设计实例措施totalSalary，计算返回所有员工的工资，即对三个员工对象数组分别循环累计汇总工资其他功效能够自行增加publicclassCompany{//private实例变量，包括name，以及advancedWorkers，normalWorkers两个对象数组//Manager对象数组作为示例，下面已经给出privateManager[]managers;//设计无参数结构器//两个有参数结构器(一个要对所有实例变量初始赋值，另外一个只需要对name赋值) Company(Stringname,Manager[]managers,AdvancedWorker[]advancedWorkers,NormalWorker[]normalWorkers){ //初始化代码 }//每个实例变量的get和set措施 publicdoubletotalSalary(){//统计经理们的工资总额：通过循环调用managers[i]的salary措施，然后累加//统计高级工们的工资总额：通过循环调用advancedWorkers[i]的salary措施，然后累加//统计一般工们的工资总额：通过循环调用normalWorkers[i]的salary措施，然后累加//返回上述三个工资总额的共计值 }（3）测试类publicclassTest{ publicstaticvoidmain(String[]args){ Manager[]managers=newManager[2];//下面示例两行代码手工创建Manager对象，并分别对managers的两个元素赋值managers[0]=newManager(“王一”,”001”,30,10);managers[1]=newManager(“张二”,”002”,40,15); AdvancedWorker[]advancedWorkers=newAdvancedWorker[4];//参考上述代码，创建AdvancedWorker对象，并分别对advancedWorkers的4个元素赋值NormalWorkernormalWorkers=newNormalWorker[8];//同上，手工创建NormalWorker对象，并分别对normalWorkers的8个元素赋值//将上述三个员工对象作为参数传递到Company对象内部。 Companycompany=newCompany(“企业名字”,managers,advancedWorkers,normalWorkers); System.out.println("企业年工资总额："+company.totalSalary());//输出企业工资总额 }}2.改进设计：利用类的基础和上转型重新设计目前对前面的最初设计进行改造。本次所有类都放到second包中。（1）设计员工类的继承结构前面的最初设计中，一个重要的缺陷就是代码重复，就是三种类型的员工类有许多重复的代码，这时能够通过设计继承结构，将这些重复代码放到超类中，缓解代码重复问题。要求设计如下：设计一个Worker类，该类描述员工，作为经理（manager），高级工（advancedworker），一般工人（normalworker）的共同的超类。Worker类提供子类的公共功效，即将子类的重复代码或类似代码移到Worker类中。例如，：Worker类需要定义name（姓名），id（工号），age（年龄），workingAge（工龄）等private类型的实例变量，而每个实例变量都有public类型的get和set措施。Worker类定义两个结构器，包括无参数结构器和一个有参数结构器（用于对四个实例变量赋初值）Worker类定义一个public型的salary措施，用于计算员工对象的每个月薪水，详细代码在将来的子类中重定义（目前只需要返回0）。三个子类Manager、AdvancedWorker、NormalWorker从Worker类继承，要求：每个子类定义各自的结构器，要求同最初设计，注意通过结构器调用链重用超类结构器的代码（即通过super调用超类结构器）每个类都各自重定义Worker类的salary措施，用于计算员工对象的每个月薪水，详细计算逻辑（与最初设计相同）：底薪+工龄工资。例如，经理的底薪是0，另外依照工龄每年加200元；高级工的底薪是10000元，另加每年100元的工龄工资；一般员工的底薪是8000，另加每年80元的工龄工资。其他功效能够自行考虑publicclassWorker{//定义name，id，age，workingAge等private类型的实例变量//定义两个结构器，无参数结构器和有参数结构器publicWorker(Stringname,Stringid,intage,intworkingAge){/*补充对象初始化代码*/}//定义每个实例变量的public类型的get和set措施。publicdoublesalary(){return0;}//详细的计算措施由子类重定义。}publicclassManagerextendsWorker{publicManager(Stringname,Stringid,intage,intworkingAge){/*补充对象初始化代码，调用抄类结构器的代码*/}publicManager(){/*补充对象初始化代码*/}publicdoublesalary(){return0;}//依照经理的工资计算逻辑重定义措施。}//AdvancedWorker、NormalWorker两个类的代码与Manager类似（2）重新设计企业类在最初设计的Company类的基础上，将代码改造，要求如下：类名：Company重新设计企业的实例变量，定义private实例变量：企业名称（name），Worker对象数组（workers），此处与前面的设计不一样，仅仅设计一个超类Worker对象数组，而不是定义三个不一样的三个子类对象数组，然后针对这些实例变量分别提供get和set措施。注意：为了简化设计，这些员工对象数组的创建不在Company对象内部，而是通过有参数结构器或者set措施从Company对象外部赋值到Company对象内部。提供结构器：包括无参数结构器、两个有参数结构器(一个要对所有实例变量初始赋值，另外一个只需要对name赋值)。设计实例措施totalSalary，计算返回所有员工的工资，即对workers对象数组循环累计汇总工资（此处与最初设计不一样，不用对三个子类数组分别循环统计）其他功效能够自行增加publicclassCompany{//private实例变量，包括nameprivateWorker[]workers;//只需要定义1个超类类型的数组，不需要定义多个子类对象数组//设计无参数结构器//两个有参数结构器(一个要对所有实例变量初始赋值，另外一个只需要对name赋值) Company(Stringname,Worker[]workers){//对最初设计的代码进行简化 //初始化代码 }//每个实例变量的get和set措施 publicdoubletotalSalary(){//对最初设计的代码进行简化//统计员工的工资总额：通过循环调用workers[i]的salary措施，然后累加//返回上述三个工资总额的共计值 }（3）改写测试类在最初设计的Test类的基础上改写代码。publicclassTest{ publicstaticvoidmain(String[]args){Workerworkers=newWorker\[14];//员工数量共14个//下面示例两行代码手工创建Manager对象，并分别对managers的两个元素赋值workers[0]=newManager(“王一”,”001”,30,10);//创建子类Manager对象，并转型为超类workers[1]=newManager(“张二”,”002”,40,15);//含义同上 //参考上述代码，用4行代码分别创建AdvancedWorker对象，并赋值给workers的元素 //参考上述代码，用8行代码分别创建NormalWorker对象，并赋值给workers的元素//将上述三个员工对象作为参数传递到Company对象内部。 Companycompany=newCompany(“企业名字”,workers); System.out.println("企业年工资总额："+company.totalSalary());//输出企业工资总额 }}3.改进设计：将超类设计为抽象类目前对前面的改进设计进行改造。本次所有类都放到third包中。前面设计的一个缺陷是：超类Worker类的salary措施不是抽象措施，并给我出了一个没故意义的代码，这么就无法强迫子类重定义这个salary措施。为了防止这种情况，需要将Worker类的salary措施定义为抽象措施，而将Worker类定义为抽象类。其他要求不变，编译通过，正常运行测试类代码。试验报告要求将编程题源程序、运行成果，以及试验中遇到的问题和处理问题的措施，写在试验报告上。packagefirst;publicclassAdvancedWorker{ privateStringname; privateStringid; privateintage; privateintworkingAge; publicAdvancedWorker(){} publicAdvancedWorker(Stringname,Stringid,intage,intworkingAge){ =name; this.id=id; this.age=age; this.workingAge=workingAge; } publicvoidsetName(Stringname){ =name; } publicStringgetName(){ returnname; } publicvoidsetId(Stringid){ this.id=id; } publicStringgetId(){ returnid; } publicvoidsetAge(intage){ this.age=age; } publicintgetAge(){ returnage; } publicvoidsetWorkingAge(intworkingAge){ this.workingAge=workingAge; } publicintgetWorkingAge(){ returnworkingAge; } publicdoublesalary(){ return10000+100*workingAge; }}packagefirst;publicclassCompany{ //private实例变量，包括name，以及advancedWorkers，normalWorkers两个对象数组 //Manager对象数组作为示例，下面已经给出 privateStringname; privateManager[]managers; privateAdvancedWorker[]advancedWorkers; privateNormalWorker[]normalWorkers; //设计无参数结构器 Company(){} //两个有参数结构器(一个要对所有实例变量初始赋值，另外一个只需要对name赋值) Company(Stringname,Manager[]managers,AdvancedWorker[]advancedWorkers,NormalWorker[]normalWorkers){ //初始化代码 =name; this.managers=managers; this.advancedWorkers=advancedWorkers; this.normalWorkers=normalWorkers; } Company(Stringname){ =name; } //每个实例变量的get和set措施 publicdoubletotalSalary(){ //统计经理们的工资总额：通过循环调用managers[i]的salary措施，然后累加 doublesum1=0; for(inti=0;i<managers.length;i++){ sum1=sum1+managers[i].salary(); } //统计高级工们的工资总额：通过循环调用advancedWorkers[i]的salary措施，然后累加 doublesum2=0; for(inti=0;i<advancedWorkers.length;i++){ sum2=sum2+advancedWorkers[i].salary(); } //统计一般工们的工资总额：通过循环调用normalWorkers[i]的salary措施，然后累加 doublesum3=0; for(inti=0;i<normalWorkers.length;i++){ sum3=sum3+normalWorkers[i].salary(); } //返回上述三个工资总额的共计值 returnsum1+sum2+sum3; }}packagefirst;publicclassManager{ //定义name，id，age，workingAge等private类型的实例变量 //定义两个结构器，无参数结构器和有参数结构器 privateStringname; privateStringid; privateintage; privateintworkingAge; publicManager(){} publicManager(Stringname,Stringid,intage,intworkingAge){ /*补充对象初始化代码*/ =name; this.id=id; this.age=age; this.workingAge=workingAge; } //定义每个实例变量的public类型的get和set措施。 publicvoidsetName(Stringname){ =name; } publicStringgetName(){ returnname; } publicvoidsetId(Stringid){ this.id=id; } publicStringgetId(){ returnid; } publicvoidsetAge(intage){ this.age=age; } publicintgetAge(){ returnage; } publicvoidsetWorkingAge(intworkingAge){ this.workingAge=workingAge; } publicintgetWorkingAge(){ returnworkingAge; } publicdoublesalary(){ return0+200*workingAge;} }packagefirst;publicclassNormalWorker{ privateStringname; privateStringid; privateintage; privateintworkingAge; publicNormalWorker(){} publicNormalWorker(Stringname,Stringid,intage,intworkingAge){ =name; this.id=id; this.age=age; this.workingAge=workingAge; } publicvoidsetName(Stringname){ =name; } publicStringgetName(){ returnname; } publicvoidsetId(Stringid){ this.id=id; } publicStringgetId(){ returnid; } publicvoidsetAge(intage){ this.age=age; } publicintgetAge(){ returnage; } publicvoidsetWorkingAge(intworkingAge){ this.workingAge=workingAge; } publicintgetWorkingAge(){ returnworkingAge; } publicdoublesalary(){ return8000+80*workingAge; }}packagefirst;publicclassTest{ publicstaticvoidmain(String[]args){ Manager[]managers=newManager[2];//下面示例两行代码手工创建Manager对象，并分别对managers的两个元素赋值managers[0]=newManager("王一","001",30,10);managers[1]=newManager("张二","002",40,15); AdvancedWorker[]advancedWorkers=newAdvancedWorker[4]; advancedWorkers[0]=newAdvancedWorker("0","0",30,10); advancedWorkers[1]=newAdvancedWorker("1","1",30,10); advancedWorkers[2]=newAdvancedWorker("2","2",30,10); advancedWorkers[3]=newAdvancedWorker("3","3",30,10);//参考上述代码，创建AdvancedWorker对象，并分别对advancedWorkers的4个元素赋值NormalWorker[]normalWorkers=newNormalWorker[8];normalWorkers[0]=newNormalWorker("0","0",30,10);normalWorkers[1]=newNormalWorker("1","1",30,10);normalWorkers[2]=newNormalWorker("2","2",30,10);normalWorkers[3]=newNormalWorker("3","3",30,10);normalWorkers[4]=newNormalWorker("4","4",30,10);normalWorkers[5]=newNormalWorker("5","5",30,10);normalWorkers[6]=newNormalWorker("6","6",30,10);normalWorkers[7]=newNormalWorker("7","7",30,10);//同上，手工创建NormalWorker对象，并分别对normalWorkers的8个元素赋值//将上述三个员工对象作为参数传递到Company对象内部。 Companycompany=newCompany("企业名字",managers,advancedWorkers,normalWorkers); System.out.println("企业年工资总额："+company.totalSalary());//输出企业工资总额 }}packagesecond;publicclassAdvancedWorkerextendsWorker{ publicAdvancedWorker(Stringname,Stringid,intage,intworkingAge){ super(name,id,age,workingAge); } publicAdvancedWorker(){} publicdoublesalary(){ return10000+100*getWorkingAge(); }}packagesecond;publicclassCompany{ //private实例变量，包括name privateStringname; privateWorker[]workers;//只需要定义1个超类类型的数组，不需要定义多个子类对象数组 //设计无参数结构器 Company(){} //两个有参数结构器(一个要对所有实例变量初始赋值，另外一个只需要对name赋值) Company(Stringname,Worker[]workers){//对最初设计的代码进行简化 //初始化代码 =name; this.workers=workers; } Company(Stringname){ =name; } //每个实例变量的get和set措施 publicdoubletotalSalary(){//对最初设计的代码进行简化 //统计员工的工资总额：通过循环调用workers[i]的salary措施，然后累加 //返回上述三个工资总额的共计值 doublesum=0; for(inti=0;i<this.workers.length;i++) if(this.workers[i]!=null) sum=sum+this.workers[i].salary(); returnsum; }}packagesecond;public classManagerextendsWorker{ publicManager(Stringname,Stringid,intage,intworkingAge){ super(name,id,age,workingAge); } publicManager(){} publicdoublesalary(){ return0+200*getWorkingAge(); }}packagesecond;publicclassNormalWorkerextendsWorker{ publicNormalWorker(Stringname,Stringid,intage,intworkingAge){ super(name,id,age,workingAge); } publicNormalWorker(){} publicdoublesalary(){ return8000+80*getWorkingAge(); }}packagesecond;publicclassTest{ publicstaticvoidmain(String[]args){Worker[]workers=newWorker[14];//员工数量共14个//下面示例两行代码手工创建Manager对象，并分别对managers的两个元素赋值workers[0]=newManager("王一","001",30,10);//创建子类Manager对象，并转型为超类workers[1]=newManager("张二","002",40,15);//含义同上 //参考上述代码，用4行代码分别创建AdvancedWorker对象，并赋值给workers的元素workers[0]=newAdvancedWorker("0","0",30,10);workers[1]=newAdvancedWorker("1","1",30,10);workers[2]=newAdvancedWorker("2","2",30,10);workers[3]=newAdvancedWorker("3","3",30,10); //参考上述代码，用8行代码分别创建NormalWorker对象，并赋值给workers的元素workers[0]=newNormalWorker("0","0",30,10);workers[1]=newNormalWorker("1","1",30,10);workers[2]=newNormalWorker("2","2",30,10);workers[3]=new