devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

超级烧脑的java接口扩展练习题（封装+继承+多态+实现+相互调用+多个实现类）_写接口练习

作者：从前慢现在也慢 | 2024-06-30 15:18:23

赞

踩

写接口练习

———完成以下游戏角色内容————封装、继承、多态—————————

注：某些方法的形参列表、返回值可以根据情况调整，并非固定不可变

父类：Role（角色），是所有职业的父类
1）属性：name，表示角色的名字
2）方法：public int attack()，该方法返回值为角色的攻击对敌人的伤害

1：Role类

  1. package com.project.game;
  2.  
  3. public abstract class Role {
  4.     private String name;
  5.     public Role(){
  6.  
  7.     }
  8.  
  9.     public Role(String name) {
  10.         this.name = name;
  11.     }
  12.  
  13.     public String getName() {
  14.         return name;
  15.     }
  16.  
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  20.  
  21.     public abstract int attack();
  22. }

Role的第一个子类：Magicer（法师）
1）属性：魔法等级（范围为1~10）
2）方法：public int attack()，该方法返回法师的攻击对敌人造成的伤害值
      法师攻击伤害值为：魔法等级*魔法基本伤害值（固定为5）

2：Magicer类

  1. package com.project.game;
  2.  
  3. public class Magicer extends Role {
  4.     private int magicLevel;
  5.  
  6.     public Magicer() {
  7.     }
  8.  
  9.     public Magicer(int magicLevel) {
  10.         this.magicLevel = magicLevel;
  11.     }
  12.  
  13.     public int getMagicLevel() {
  14.         return magicLevel;
  15.     }
  16.  
  17.     public void setMagicLevel(int magicLevel) {
  18.         this.magicLevel = magicLevel;
  19.     }
  20.  
  21.     public int attack(){
  22.         int shanghai=5;
  23.         int num=magicLevel*shanghai;
  24.         System.out.println("法师攻击伤害值为："+num);
  25.         return num;
  26.     }
  27. }

Role的第二个子类：Soldier（战士）
1）属性：攻击伤害值
2）方法：public int attack()，该方法返回战士对敌人造成的伤害值
      战士的攻击伤害值为：其攻击伤害属性值

3：Soldier类

  1. package com.project.game;
  2.  
  3. import com.project.game.Role;
  4.  
  5. public class Soldier extends Role {
  6.     private int attackDamage;
  7.     public Soldier(){
  8.  
  9.     }
  10.     public Soldier(int attackDamage){
  11.         this.attackDamage=attackDamage;
  12.     }
  13.  
  14.     public int getAttackDamage(){
  15.         return attackDamage;
  16.     }
  17.     public void setAttackDamage(int attackDamage){
  18.         this.attackDamage=attackDamage;
  19.     }
  20.  
  21.     public int attack(){
  22.         System.out.println("战士攻击伤害值为："+attackDamage);
  23.         return attackDamage;
  24.     }
  25. }

再设计一个Team类，表示一个组队。
1）addMember，表示组队增加一个成员
      注意：组队成员最多为6人
      提示：应当利用一个数组属性，保存所有成员
2）attackSum，表示组队所有成员进行攻击时，对敌人造成的总伤害

4：Team类

  1. package com.project.game;
  2.  
  3. import com.project.game.Magicer;
  4. import com.project.game.Role;
  5.  
  6. public class Team {
  7.     Role[]role;
  8.     int count=0;
  9.     public void addMember(){
  10.         if(count<6){
  11.             count++;
  12.             role=new Role[count];
  13.         }
  14.     }
  15.  
  16.  
  17.     int num=0;
  18.     public void addMembers(Role roles){
  19.         if(num<role.length){
  20.  
  21.             role[num]=roles;
  22.             num++;
  23.  
  24.         }
  25.     }
  26. //   public void addMembers(Role role1){
  27. //       for(int i=1;i<role.length;i++){
  28. //           role[i]=role1;
  29. //       }
  30. //   }
  31.  
  32.  
  33.     public int attackSum(){
  34.         int zongshanghai=0;
  35.         for(int i=0;i<role.length;i++){
  36.             if(role[i] instanceof Magicer){
  37.                zongshanghai+=role[i].attack();
  38.             }else{
  39.                 zongshanghai+=role[i].attack();
  40.             }
  41.         }
  42.         return zongshanghai;
  43.     }
  44.  
  45. }

 5：Test测试类

  1. package com.project.game;
  2.  
  3. import com.project.game.Magicer;
  4. import com.project.game.Soldier;
  5. import com.project.game.Team;
  6.  
  7. public class Test {
  8.     public static void main(String[]args){
  9.         Team team=new Team();
  10.         team.addMember();
  11.         team.addMember();
  12.         team.addMember();
  13.         team.addMember();
  14.         team.addMember();
  15.         team.addMember();
  16.         System.out.println("count值为："+team.count);
  17.  
  18.         team.addMembers(new Magicer(2));
  19.         team.addMembers(new Magicer(2));
  20.         team.addMembers(new Magicer(2));
  21.         team.addMembers(new Magicer(2));
  22.         team.addMembers(new Magicer(2));
  23.         team.addMembers(new Soldier(100));
  24.         System.out.println("数组长度为："+team.role.length);
  25. //        for(int i=0;i<team.role.length;i++){
  26. //            System.out.println(i+"team.role[i]");
  27. //        }
  28.  
  29.  
  30.  
  31. //        team.addMembers(new Soldier(10));
  32. //        team.addMembers(new Soldier(10));
  33. //        team.addMembers(new Soldier(10));
  34. //        team.addMembers(new Soldier(10));
  35. //        team.addMembers(new Soldier(10));
  36. //        team.addMembers(new Soldier(10));
  37.  
  38.         int num=team.attackSum();
  39.         System.out.println("总伤害为："+num);
  40.  
  41.     }
  42. }


—————在上述代码基础之上完成以下需求——封装、继承、多态、接口—————————


创建Role接口，包含两个方法：
1）int attack(); 表示攻击，返回值表示对敌人的伤害
2）void practise(); 表示练习。练习之后对敌人的伤害会增加

6：Role接口

  1. package com.project.gameInterface;
  2.  
  3. public interface Role {
  4.     int attack();
  5.     void practise();
  6. }

创建NamedRole类，该类为一个抽象类，实现了Role 接口，并有两个属性：
1）name：角色的名字
2）age：角色的年龄

7：NamedRole抽象类

  1. package com.project.gameInterface;
  2.  
  3. public  abstract class NamedRole implements Role{
  4.     private String name;
  5.     private int age;
  6.  
  7.     public NamedRole() {
  8.     }
  9.  
  10.     public NamedRole(String name, int age) {
  11.         this.name = name;
  12.         this.age = age;
  13.     }
  14.  
  15.     public String getName() {
  16.         return name;
  17.     }
  18.  
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  22.  
  23.     public int getAge() {
  24.         return age;
  25.     }
  26.  
  27.     public void setAge(int age) {
  28.         this.age = age;
  29.     }
  30.  
  31.  
  32. }

增加MagicStick接口。该接口表示法师使用的法杖。接口中包含一个方法：
1）int fire()

8：MagicStick接口

  1. package com.project.gameInterface;
  2.  
  3. public interface MagicStick {
  4.     int fire();
  5. }

为MagicStick接口增加两个实现类，分别为GreenStick和BlackStick。其中，对于这两个类的fire方法：
1）GreenStick 平时返回1，夏天（6~8月）使用时返回2
2）BlackStic奇数月返回1，偶数月返回2

9：GreenStick类

  1. package com.project.gameInterface;
  2.  
  3. import java.time.LocalDate;
  4. import java.time.YearMonth;
  5.  
  6. public class GreenStick implements MagicStick{
  7.  
  8.     LocalDate currentDate = LocalDate.now();
  9.     YearMonth yearMonth = YearMonth.from(currentDate);
  10.     int month = yearMonth.getMonthValue();
  11.  
  12.     @Override
  13.     public int fire() {
  14.         System.out.println("当前月份: " + month);
  15.         if(month>=6&&month<=8){
  16.             System.out.println("六月到八月返回2");
  17.             return 2;
  18.         }else {
  19.             System.out.println("非六到八月返回1");
  20.             return 1;
  21.         }
  22.     }
  23. }

10：BlackStick类

  1. package com.project.gameInterface;
  2.  
  3. import java.time.LocalDate;
  4. import java.time.YearMonth;
  5.  
  6. public class BlackStick implements MagicStick{
  7.     LocalDate currentDate = LocalDate.now();
  8.     YearMonth yearMonth = YearMonth.from(currentDate);
  9.     int month = yearMonth.getMonthValue();
  10.  
  11.  
  12.     @Override
  13.     public int fire() {
  14.         System.out.println("当前月份: " + month);
  15.         if(month%2==0){
  16.             System.out.println("偶数月返回2");
  17.             return 2;
  18.         }else{
  19.            System.out.println("奇数月返回1");
  20.             return 1;
  21.         }
  22.     }
  23. }

修改Magicer类
1）为法师类增加MagicStick类的属性stick，表示法师使用的法杖
2）让其继承自NamedRole类，并实现attack和practise 功能
3）int attack()返回值为法师的魔法等级(level)*每一级的固定伤害(5)
4）void practise()方法：

    当法师的stick属性为null时，调用 practise则level++
    当法师的stick不为null时，调用practise 方法时，法师的等级level满足：level = level + 1 + stick.fire()；即：法师的等级增加为1+stick 属性的fire方法的返回值

11：修改Magicer类

  1. package com.project.gameInterface;
  2.  
  3.  
  4. public class Magicer extends NamedRole{
  5.     private int magicLevel;
  6.  
  7.     private  MagicStick stick;
  8.  
  9.  
  10.     public Magicer() {
  11.     }
  12.  
  13.     public Magicer(int magicLevel,MagicStick stick) {
  14.         this.magicLevel = magicLevel;
  15.         this.stick=stick;
  16.     }
  17.  
  18.     public int getMagicLevel() {
  19.         return magicLevel;
  20.     }
  21.  
  22.     public void setMagicLevel(int magicLevel) {
  23.         this.magicLevel = magicLevel;
  24.     }
  25.  
  26.     public MagicStick getStick() {
  27.         return stick;
  28.     }
  29.  
  30.     public void setStick(MagicStick stick) {
  31.         this.stick = stick;
  32.     }
  33.  
  34.     public int attack(){
  35.         int shanghai=5;
  36.         int num=magicLevel*shanghai;
  37.         System.out.println("法师攻击伤害值为："+num);
  38.         return num;
  39.     }
  40.  
  41.     @Override
  42.     public void practise() {
  43.         if(stick==null){
  44.             magicLevel++;
  45.         }else{
  46.             magicLevel+=1+stick.fire();
  47.         }
  48.         System.out.println("法师等级为："+magicLevel);
  49.     }
  50.  
  51. }

增加Weapon接口，表示战士使用的武器。Weapon接口中定义了两个方法：
1）void setSoldier(Soldier s); 该方法表示设置武器的使用者
2）int fire(); 该方法的返回值表示战士使用该武器时，对敌人的伤害值

12：Weapon接口

  1. package com.project.gameInterface;
  2.  
  3. public interface Weapon {
  4.     //表示战士使用的武器
  5.     void setSoldier(Soldier s);
  6.     int fire();
  7. }

为 Weapon 增加两个实现了，Bolo，表示大刀，Pike，表示长矛
1）当 soldier 的年龄大于等于 18 岁时，fire 方法返回 100
2）当 soldier 年龄小于 18 岁时，fire 方法返回 50

13：Bole类

  1. package com.project.gameInterface;
  2.  
  3. public class Bolo implements Weapon{
  4.     //大刀实现类
  5.     @Override
  6.     public void setSoldier(Soldier s) {
  7.         if(s.getAge()>=18){
  8.             int a=fire();
  9.             System.out.println("大于18返回值为"+a);
  10.         }else {
  11.             int b=fire1();
  12.             System.out.println("小于18返回值为"+b);
  13.         }
  14.     }
  15.  
  16.     @Override
  17.     public int fire() {
  18.         return 100;
  19.     }
  20.     public int fire1() {
  21.         return 50;
  22.     }
  23. }

Pike：Pike 类有一个属性：name，表示长矛的名字
1）当长矛的名字和战士的名字一致时，fire 方法返回 1000
2）当长矛的名字和战士的名字不一致时，fire 方法返回 25

14：Pick类

  1. package com.project.gameInterface;
  2.  
  3. public class Pick implements Weapon{
  4.     //长矛实现类
  5.     private String name;
  6.  
  7.     public Pick() {
  8.     }
  9.  
  10.     public Pick(String name) {
  11.         this.name = name;
  12.     }
  13.  
  14.     public String getName() {
  15.         return name;
  16.     }
  17.  
  18.     public void setName(String name) {
  19.         this.name = name;
  20.     }
  21.  
  22.     @Override
  23.     public void setSoldier(Soldier s) {
  24.         if(s.getName().equals(name)){
  25.             int a=fire();
  26.             System.out.println("名字相等时为："+a);
  27.         }else{
  28.             int b=fire1();
  29.             System.out.println("名字不相等时为："+b);
  30.         }
  31.  
  32.     }
  33.  
  34.     @Override
  35.     public int fire() {
  36.         return 1000;
  37.     }
  38.     public int fire1() {
  39.         return 25;
  40.     }
  41.  
  42.  
  43. //    public int fire() {
  44. //        if(soldier.getName().equals(name)){
  45. //            System.out.println("名字相等时为："+1000);
  46. //            return 1000;
  47. //        }else {
  48. //            System.out.println("名字不相等时为："+25);
  49. //            return 25;
  50. //        }
  51. //
  52. //    }
  53. }

修改 Soldier 类
1）为 Soldier 类增加一个 Weapon 属性，表示战士的武器
2）让其继承自 NamedRole 类，并实现 attack 和 practise 功能。其中

    Soldier 的 attack() 返回值为战士的 hurt 值与武器的 fire()返回值的 和，即：总攻击输出 = 战士的徒手伤害值 + 武器的伤害值
    practise()方法：每调用一次则战士的 hurt 值+10

15：修改Soldirer类

  1. package com.project.gameInterface;
  2.  
  3. import sun.security.mscapi.SunMSCAPI;
  4.  
  5. public class Soldier extends NamedRole {
  6.     private Weapon weapon;
  7.     private String name;
  8.     private int age;
  9.     private int attackDamage;
  10.  
  11.     public Soldier() {
  12.  
  13.     }
  14.  
  15.     public Soldier(String name) {
  16.         this.name = name;
  17.     }
  18.  
  19.     public Soldier(int age) {
  20.         this.age = age;
  21.     }
  22.  
  23.     public Soldier(String name, int age, int attackDamage) {
  24.         this.name = name;
  25.         this.age = age;
  26.         this.attackDamage = attackDamage;
  27.     }
  28.  
  29.     public Soldier(Weapon weapon, String name, int age, int attackDamage) {
  30.         this.weapon = weapon;
  31.         this.name = name;
  32.         this.age = age;
  33.         this.attackDamage = attackDamage;
  34.     }
  35.  
  36.     public Soldier(String name, int age, Weapon weapon, String name1, int age1, int attackDamage, int sum) {
  37.         super(name, age);
  38.         this.weapon = weapon;
  39.         this.name = name1;
  40.         this.age = age1;
  41.         this.attackDamage = attackDamage;
  42.         this.sum = sum;
  43.     }
  44.  
  45.     public Weapon getWeapon() {
  46.         return weapon;
  47.     }
  48.  
  49.     public void setWeapon(Weapon weapon) {
  50.         this.weapon = weapon;
  51.     }
  52.  
  53.     public String getName() {
  54.         return name;
  55.     }
  56.  
  57.     public void setName(String name) {
  58.         this.name = name;
  59.     }
  60.  
  61.     public int getAge() {
  62.         return age;
  63.     }
  64.  
  65.     public void setAge(int age) {
  66.         this.age = age;
  67.     }
  68.  
  69.     public int getAttackDamage() {
  70.         return attackDamage;
  71.     }
  72.  
  73.     public void setAttackDamage(int attackDamage) {
  74.         this.attackDamage = attackDamage;
  75.     }
  76.  
  77.     @Override
  78.     public void practise() {
  79.         attackDamage+=10;
  80.     }
  81.  
  82.     int sum=0;
  83.     public int attack() {
  84.         if (weapon instanceof Bolo){
  85.             weapon=new Bolo();
  86.             if(age>18){
  87.                 sum = attackDamage + weapon.fire();
  88.                 System.out.println("战士攻击伤害值为：" + sum);
  89.             }else {
  90.                 sum = attackDamage + ((Bolo) weapon).fire1();
  91.                 System.out.println("战士攻击伤害值为：" + sum);
  92.             }
  93.  
  94.             return sum;
  95.         }else {
  96.             weapon=new Pick("张三");
  97.             Pick p=(Pick)weapon;
  98.             if(p.getName().equals(name)){
  99.                 sum=attackDamage+weapon.fire();
  100.                 System.out.println("战士攻击伤害值为：" + sum);
  101.             }else {
  102.                 sum=attackDamage+((Pick) weapon).fire1();
  103.                 System.out.println("战士攻击伤害值为：" + sum);
  104.             }
  105.  
  106.             return sum;
  107.         }
  108.     }
  109.  
  110. }

16：测试类Test

  1. package com.project.gameInterface;
  2.  
  3. public class Test {
  4.     public static void main(String[]args){
  5. //        BlackStick b=new BlackStick();
  6. //        GreenStick g=new GreenStick();
  7. //        int num=g.fire();
  8. //        System.out.println(num);
  9. //        System.out.println(b.fire());
  10.  
  11.  
  12.  
  13.         Magicer magicer=new Magicer(10,new BlackStick());
  14.         magicer.practise();
  15.         Magicer m=new Magicer(10,new GreenStick());
  16.         m.practise();
  17.  
  18. //        Magicer mg=new Magicer(10,);
  19. //        mg.practise();
  20.         System.out.println("_______________________________________");
  21.  
  22.         Weapon b=new Bolo();
  23.         b.setSoldier(new Soldier(20));
  24.  
  25.  
  26.  
  27.         Weapon pick=new Pick("张三");
  28.         pick.setSoldier(new Soldier("张三"));
  29.         pick.setSoldier(new Soldier("李四"));
  30.  
  31.  
  32.  
  33.         System.out.println("-------------------------------------");
  34.  
  35.  
  36.         Soldier soldier=new Soldier(new Bolo(),"张三",120,10);
  37.         new Bolo().setSoldier(new Soldier(17));
  38.         soldier.practise();
  39.         soldier.practise();
  40.         soldier.practise();
  41.         soldier.attack();
  42.         new Bolo().setSoldier(new Soldier(20));
  43.         soldier.attack();
  44.  
  45.         System.out.println("--------------------------------");
  46.  
  47.         Soldier soldier1=new Soldier(new Pick("张三"),"张三",18,10);
  48.         new Pick("李四").setSoldier(new Soldier("张三"));
  49.         soldier1.practise();
  50.         soldier1.practise();
  51. //        new Pick("张三").fire();
  52.         soldier1.attack();
  53.  
  54.         Soldier soldier2=new Soldier(new Pick("张三"),"张三",18,10);
  55.         new Pick("张三").setSoldier(new Soldier("张三"));
  56.         soldier1.attack();
  57.  
  58.     }
  59. }

基本功能已经实现，可能会有部分功能可以编译运行，但是运行结果有误，不会报错

下面是原题

谢谢你的观看

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号