[已解决]遇到这样一个题目 半天没有头绪 来这碰碰运气

mumei2018

题目要求用到构造器 多态 继承 封装（getter 和 setter） 做一个游戏

有三种角色
human    monster   ghost
血量各自为
50    100     40

都用攻击的功能（方法） 攻击时 方法的参数为攻击对象

然后三种角色 互相克制   

比如human克制ghost

所以

human打ghost ghost 掉10hp   反过来则是human掉5hp

monster克制human

ghost克制human

创造三个角色后让他们随机自动攻击随机对象

一个角色没血时 提示 xx is dead
只剩一个时 提示 xx survive。

看书 看了两三天了 写了一堆乱七八糟的东西 也不知要怎样用上构造器 多态 继承 封装（getter 和 setter）  来这碰碰运气 看看能不能得到点什么范本 谢谢各位了

最佳答案

月排行榜 / 总排行榜

陶远航

2023-9-17 19:31:49

下面是一个示例代码，展示了如何利用构造器、多态、继承和封装来创建一个角色游戏：

1. import random
   
2. 
   
3. class Character:
   
4.     def __init__(self, name, hp=50):
   
5.         self.name = name
   
6.         self.hp = hp
   
7. 
   
8.     def attack(self, target):
   
9.         raise NotImplementedError("Subclass must implement attack method")
   
10. 
    
11.     def is_alive(self):
    
12.         return self.hp > 0
    
13. 
    
14.     def __str__(self):
    
15.         return self.name
    
16. 
    
17. 
    
18. class Human(Character):
    
19.     def __init__(self):
    
20.         super().__init__("Human", hp=50)
    
21. 
    
22.     def attack(self, target):
    
23.         if isinstance(target, Ghost):
    
24.             target.hp -= 10
    
25.         elif isinstance(target, Monster):
    
26.             target.hp -= 5
    
27. 
    
28. 
    
29. class Monster(Character):
    
30.     def __init__(self):
    
31.         super().__init__("Monster", hp=100)
    
32. 
    
33.     def attack(self, target):
    
34.         if isinstance(target, Human):
    
35.             target.hp -= 10
    
36.         elif isinstance(target, Ghost):
    
37.             target.hp -= 5
    
38. 
    
39. 
    
40. class Ghost(Character):
    
41.     def __init__(self):
    
42.         super().__init__("Ghost", hp=40)
    
43. 
    
44.     def attack(self, target):
    
45.         if isinstance(target, Human):
    
46.             target.hp -= 5
    
47.         elif isinstance(target, Monster):
    
48.             target.hp -= 10
    
49. 
    
50. 
    
51. def main():
    
52.     characters = [Human(), Monster(), Ghost()]
    
53. 
    
54.     while len(characters) > 1:
    
55.         attacker = random.choice(characters)
    
56.         target = random.choice(characters)
    
57.         
    
58.         if attacker != target and attacker.is_alive() and target.is_alive():
    
59.             print(f"{attacker} attacks {target}!")
    
60.             attacker.attack(target)
    
61.             
    
62.             if not target.is_alive():
    
63.                 characters.remove(target)
    
64.                 print(f"{target} is dead.")
    
65.                
    
66.             print("Current status:")
    
67.             for character in characters:
    
68.                 print(f"{character}: {character.hp} HP")
    
69.             print()
    
70. 
    
71.     if characters:
    
72.         print(f"{characters[0]} survives.")
    
73.     else:
    
74.         print("No one survives.")
    
75. 
    
76. if __name__ == "__main__":
    
77.     main()
    

复制代码

这个示例代码定义了三个角色类：Human、Monster和Ghost，它们都继承自Character基类。每个角色类都实现了attack方法来执行相应的攻击行为。在主函数中，创建了三个角色对象，并通过随机选择攻击对象来模拟随机自动攻击的游戏场景。当一个角色的HP降至0以下时，会被从角色列表中移除，直到只剩下一个角色或者没有角色存活时游戏结束。

希望这个示例能对您有所帮助！
如果问题已经解决，请设置最佳答案

跳转到最佳答案楼层

Mike_python小

游戏角色设计与实现：

以下是一个使用构造器、多态、继承和封装的Java游戏角色设计与实现的示例代码，按照你的需求进行了编写。你可以根据自己的需要进行修改和完善。

1. java
   
2. import java.util.Random;
   
3. 
   
4. class GameCharacter {
   
5.     private String name;
   
6.     private int health;
   
7. 
   
8.     public GameCharacter(String name, int health) {
   
9.         this.name = name;
   
10.         this.health = health;
    
11.     }
    
12. 
    
13.     public String getName() {
    
14.         return name;
    
15.     }
    
16. 
    
17.     public int getHealth() {
    
18.         return health;
    
19.     }
    
20. 
    
21.     public void setHealth(int health) {
    
22.         this.health = health;
    
23.     }
    
24. 
    
25.     public void attack(GameCharacter target) {
    
26.         // 在子类中实现具体的攻击逻辑
    
27.     }
    
28. 
    
29.     public boolean isDead() {
    
30.         return health <= 0;
    
31.     }
    
32. 
    
33.     public void displayStatus() {
    
34.         System.out.println(name + " - Health: " + health);
    
35.     }
    
36. }
    
37. 
    
38. class Human extends GameCharacter {
    
39.     public Human(String name, int health) {
    
40.         super(name, health);
    
41.     }
    
42. 
    
43.     @Override
    
44.     public void attack(GameCharacter target) {
    
45.         int damage = 10;
    
46.         target.setHealth(target.getHealth() - damage);
    
47.         System.out.println(getName() + " attacks " + target.getName() + " and deals " + damage + " damage");
    
48.     }
    
49. }
    
50. 
    
51. class Monster extends GameCharacter {
    
52.     public Monster(String name, int health) {
    
53.         super(name, health);
    
54.     }
    
55. 
    
56.     @Override
    
57.     public void attack(GameCharacter target) {
    
58.         int damage = 5;
    
59.         target.setHealth(target.getHealth() - damage);
    
60.         System.out.println(getName() + " attacks " + target.getName() + " and deals " + damage + " damage");
    
61.     }
    
62. }
    
63. 
    
64. class Ghost extends GameCharacter {
    
65.     public Ghost(String name, int health) {
    
66.         super(name, health);
    
67.     }
    
68. 
    
69.     @Override
    
70.     public void attack(GameCharacter target) {
    
71.         int damage = 10;
    
72.         target.setHealth(target.getHealth() - damage);
    
73.         System.out.println(getName() + " attacks " + target.getName() + " and deals " + damage + " damage");
    
74.     }
    
75. }
    
76. 
    
77. public class Game {
    
78.     public static void main(String[] args) {
    
79.         Human human = new Human("Human", 50);
    
80.         Monster monster = new Monster("Monster", 100);
    
81.         Ghost ghost = new Ghost("Ghost", 40);
    
82. 
    
83.         GameCharacter[] characters = { human, monster, ghost };
    
84. 
    
85.         Random random = new Random();
    
86. 
    
87.         while (true) {
    
88.             // 随机选择攻击者和被攻击者
    
89.             int attackerIndex = random.nextInt(characters.length);
    
90.             int targetIndex = random.nextInt(characters.length);
    
91. 
    
92.             if (attackerIndex != targetIndex) {
    
93.                 GameCharacter attacker = characters[attackerIndex];
    
94.                 GameCharacter target = characters[targetIndex];
    
95. 
    
96.                 attacker.attack(target);
    
97.                 target.displayStatus();
    
98. 
    
99.                 // 判断游戏是否结束
    
100.                 boolean allDeadExceptOne = true;
     
101.                 for (GameCharacter character : characters) {
     
102.                     if (!character.isDead()) {
     
103.                         if (allDeadExceptOne) {
     
104.                             allDeadExceptOne = false;
     
105.                         } else {
     
106.                             allDeadExceptOne = true;
     
107.                             break;
     
108.                         }
     
109.                     }
     
110.                 }
     
111. 
     
112.                 if (allDeadExceptOne) {
     
113.                     for (GameCharacter character : characters) {
     
114.                         if (!character.isDead()) {
     
115.                             System.out.println(character.getName() + " survives.");
     
116.                         }
     
117.                     }
     
118. 
     
119.                     break;
     
120.                 }
     
121.             }
     
122.         }
     
123.     }
     
124. }
     

复制代码

这个示例代码创建了三个角色类：Human、Monster和Ghost，它们都继承自GameCharacter基类。每个角色类都实现了attack方法，根据不同的角色类型，攻击造成不同的伤害。

在main方法中，我们创建了一个包含所有角色的数组，并使用Random类来随机选择攻击者和被攻击者。游戏循环持续进行，直到只有一个角色存活为止。

编译并运行这个程序，你会看到角色之间的攻击和血量变化，并且当只剩下一个角色存活时会有相应的提示输出。

这是一个基础的游戏实现示例，你可以根据自己的需要进行扩展和修改。希望对你有所帮助！

球一个最佳答案谢谢啦！这对我非常重要！

isdkz

这道题目可以用面向对象的思想来解决，需要用到构造器、多态、继承、封装等概念。下面是一个可能的解决方案：

首先，我们可以定义一个角色类  Role ，它包含角色的基本属性和方法：

1. public abstract class Role {
   
2.     private String name; // 角色名称
   
3.     private int hp; // 角色血量
   
4. 
   
5.     public Role(String name, int hp) {
   
6.         this.name = name;
   
7.         this.hp = hp;
   
8.     }
   
9. 
   
10.     public String getName() {
    
11.         return name;
    
12.     }
    
13. 
    
14.     public int getHp() {
    
15.         return hp;
    
16.     }
    
17. 
    
18.     public void setHp(int hp) {
    
19.         this.hp = hp;
    
20.     }
    
21. 
    
22.     public abstract void attack(Role target); // 攻击方法，由子类实现
    
23. }
    

复制代码

注意这里使用了抽象类和抽象方法，因为不同的角色有不同的攻击方式，需要由子类实现。

接下来，我们定义三个角色类  Human 、 Monster  和  Ghost ，它们继承自  Role ，并实现各自的攻击方法：

1. public class Human extends Role {
   
2.     public Human() {
   
3.         super("Human", 50);
   
4.     }
   
5. 
   
6.     @Override
   
7.     public void attack(Role target) {
   
8.         if (target instanceof Ghost) {
   
9.             target.setHp(target.getHp() - 10);
   
10.             System.out.println(getName() + " attacks " + target.getName() + ", " + target.getName() + " loses 10 HP.");
    
11.         } else {
    
12.             target.setHp(target.getHp() - 5);
    
13.             System.out.println(getName() + " attacks " + target.getName() + ", " + target.getName() + " loses 5 HP.");
    
14.         }
    
15.     }
    
16. }
    
17. 
    
18. public class Monster extends Role {
    
19.     public Monster() {
    
20.         super("Monster", 100);
    
21.     }
    
22. 
    
23.     @Override
    
24.     public void attack(Role target) {
    
25.         if (target instanceof Human) {
    
26.             target.setHp(target.getHp() - 20);
    
27.             System.out.println(getName() + " attacks " + target.getName() + ", " + target.getName() + " loses 20 HP.");
    
28.         } else {
    
29.             target.setHp(target.getHp() - 10);
    
30.             System.out.println(getName() + " attacks " + target.getName() + ", " + target.getName() + " loses 10 HP.");
    
31.         }
    
32.     }
    
33. }
    
34. 
    
35. public class Ghost extends Role {
    
36.     public Ghost() {
    
37.         super("Ghost", 40);
    
38.     }
    
39. 
    
40.     @Override
    
41.     public void attack(Role target) {
    
42.         if (target instanceof Human) {
    
43.             setHp(getHp() + 5);
    
44.             System.out.println(getName() + " attacks " + target.getName() + ", " + getName() + " gains 5 HP.");
    
45.         } else {
    
46.             target.setHp(target.getHp() - 15);
    
47.             System.out.println(getName() + " attacks " + target.getName() + ", " + target.getName() + " loses 15 HP.");
    
48.         }
    
49.     }
    
50. }
    

复制代码

注意这里使用了  instanceof  运算符来判断攻击对象的类型，从而实现不同的攻击效果。

最后，我们可以编写一个游戏类  Game ，它创建三个角色对象并让它们随机攻击随机对象，直到只剩下一个角色为止：

1. import java.util.Random;
   
2. 
   
3. public class Game {
   
4.     public static void main(String[] args) {
   
5.         Role[] roles = new Role[] {new Human(), new Monster(), new Ghost()};
   
6. 
   
7.         Random random = new Random();
   
8. 
   
9.         while (true) {
   
10.             Role attacker = roles[random.nextInt(3)];
    
11.             Role target = roles[random.nextInt(3)];
    
12. 
    
13.             if (attacker == target || target.getHp() <= 0) {
    
14.                 continue;
    
15.             }
    
16. 
    
17.             attacker.attack(target);
    
18. 
    
19.             if (target.getHp() <= 0) {
    
20.                 System.out.println(target.getName() + " is dead.");
    
21.             }
    
22. 
    
23.             int aliveCount = 0;
    
24.             Role aliveRole = null;
    
25.             for (Role role : roles) {
    
26.                 if (role.getHp() > 0) {
    
27.                     aliveCount++;
    
28.                     aliveRole = role;
    
29.                 }
    
30.             }
    
31. 
    
32.             if (aliveCount == 1) {
    
33.                 System.out.println(aliveRole.getName() + " survive.");
    
34.                 break;
    
35.             }
    
36.         }
    
37.     }
    
38. }
    

复制代码

注意这里使用了随机数来选择攻击者和攻击对象，以及使用了循环和条件语句来判断游戏结束的条件。

以上就是一个可能的解决方案，希望能够帮助到你。

陶远航

下面是一个示例代码，展示了如何利用构造器、多态、继承和封装来创建一个角色游戏：

1. import random
   
2. 
   
3. class Character:
   
4.     def __init__(self, name, hp=50):
   
5.         self.name = name
   
6.         self.hp = hp
   
7. 
   
8.     def attack(self, target):
   
9.         raise NotImplementedError("Subclass must implement attack method")
   
10. 
    
11.     def is_alive(self):
    
12.         return self.hp > 0
    
13. 
    
14.     def __str__(self):
    
15.         return self.name
    
16. 
    
17. 
    
18. class Human(Character):
    
19.     def __init__(self):
    
20.         super().__init__("Human", hp=50)
    
21. 
    
22.     def attack(self, target):
    
23.         if isinstance(target, Ghost):
    
24.             target.hp -= 10
    
25.         elif isinstance(target, Monster):
    
26.             target.hp -= 5
    
27. 
    
28. 
    
29. class Monster(Character):
    
30.     def __init__(self):
    
31.         super().__init__("Monster", hp=100)
    
32. 
    
33.     def attack(self, target):
    
34.         if isinstance(target, Human):
    
35.             target.hp -= 10
    
36.         elif isinstance(target, Ghost):
    
37.             target.hp -= 5
    
38. 
    
39. 
    
40. class Ghost(Character):
    
41.     def __init__(self):
    
42.         super().__init__("Ghost", hp=40)
    
43. 
    
44.     def attack(self, target):
    
45.         if isinstance(target, Human):
    
46.             target.hp -= 5
    
47.         elif isinstance(target, Monster):
    
48.             target.hp -= 10
    
49. 
    
50. 
    
51. def main():
    
52.     characters = [Human(), Monster(), Ghost()]
    
53. 
    
54.     while len(characters) > 1:
    
55.         attacker = random.choice(characters)
    
56.         target = random.choice(characters)
    
57.         
    
58.         if attacker != target and attacker.is_alive() and target.is_alive():
    
59.             print(f"{attacker} attacks {target}!")
    
60.             attacker.attack(target)
    
61.             
    
62.             if not target.is_alive():
    
63.                 characters.remove(target)
    
64.                 print(f"{target} is dead.")
    
65.                
    
66.             print("Current status:")
    
67.             for character in characters:
    
68.                 print(f"{character}: {character.hp} HP")
    
69.             print()
    
70. 
    
71.     if characters:
    
72.         print(f"{characters[0]} survives.")
    
73.     else:
    
74.         print("No one survives.")
    
75. 
    
76. if __name__ == "__main__":
    
77.     main()
    

复制代码

这个示例代码定义了三个角色类：Human、Monster和Ghost，它们都继承自Character基类。每个角色类都实现了attack方法来执行相应的攻击行为。在主函数中，创建了三个角色对象，并通过随机选择攻击对象来模拟随机自动攻击的游戏场景。当一个角色的HP降至0以下时，会被从角色列表中移除，直到只剩下一个角色或者没有角色存活时游戏结束。

希望这个示例能对您有所帮助！
如果问题已经解决，请设置最佳答案