“奥特曼“与”小怪兽”的继承者们之战
练习
回合制对战游戏：奥特曼A和小怪兽A进行PK,直到一方的血量为0时结束战斗，输出谁胜利了！
如果奥特曼A胜利，则奥特曼A和奥特曼B进行Pk,直到一方的血量为0时结束战斗，输出谁胜利了！
如果小怪兽A胜利，则小怪兽A和小怪兽B进行Pk,直到一方的血量为0时结束战斗，输出谁胜利了！
首先要弄清楚奥特曼A与奥特曼B是父类与子类的关系，所以子类是可以继承到父类所有的（任何访问修饰符的属性和方法）属性的和方法的，从而可以提高代码的重用性以及程序的扩展性。
下面来看一下代码的实现：
//设置一个“Ao（奥特曼B）”类
package D52
public class Aoa {
private String name;
private int attack;
private int blood;
public void setName(String a) {
name = a;
}
public String getName() {
return name;
}
public void setAttack(int b) {
attack = b;
}
public int getAttack() {
return attack;
}
public void setBlood(int c) {
blood = c;
}
public int getBlood() {
return blood;
}
public void attack(Mastera x) {
x.setBlood(x.getBlood() - attack);
System.out.println(name + "正在攻击" + x.getName() + "," + "小怪兽掉血"
+attack + "剩余血量" + x.getBlood());//小怪兽掉的血是奥塔曼的攻击力
if (x.getBlood() <= 0) {
System.out.println(name + "胜利啦!");
}
}
public void attack(Aob b) {
b.setBlood(b.getBlood() - attack);
System.out.println(name + "正在攻击" + b.getName() + "," + "奥特曼B掉血"
+ attack + "剩余血量" + b.getBlood());
if (b.getBlood() <= 0) {
System.out.println(name + "胜利啦！");
}
}
}
//设置一个“Mastera（小怪兽A）”类
package D521;
public class Mastera {
private String name;
private int attack;
private int blood;
public void setName(String x) {
name = x;
}
public String getName() {
return name;
}
public void setAttack(int xb) {
attack = xb;
}
public int getAttack() {
return attack;
}
public void setBlood(int xc) {
blood = xc;
}
public int getBlood() {
return blood;
}
public void attack(Aoa a) {
a.setBlood(a.getBlood() - attack);
System.out.println(name + "正在攻击" + a.getName() + "," + "奥特曼掉血"
+ attack+ "剩余血量" + a.getBlood());
if (a.getBlood() <= 0) {
System.out.println(name + "胜利啦！");
}
}
public void attack(Masterb bx) {
bx.setBlood(bx.getBlood() - attack);
System.out.println(name + "正在攻击" + bx.getName() + "," + "小怪兽B掉血"
+ attack+ "剩余血量" + bx.getBlood());
if (bx.getBlood() <= 0) {
System.out.println(name + "胜利啦！");
}
}
}
//设置一个“Aob(奥特曼B)类”（用继承性）
package D521;
//奥特曼B子类继承了奥特曼A父类的所有属性和行为
public class Aob extends Aoa {
public void attack(Aoa a) {
a.setBlood(a.getBlood() - getAttack());
System.out.println(getName() + "正在攻击" + a.getName()+ "," + "奥特曼B掉血"
+ getAttack()+ "剩余血量" + a.getBlood());//尤其要注意的是，我的attack的访问修饰符是private，所以不能直接使用，要用“getAttack”去调用它
if (a.getBlood() <= 0) {
System.out.println(getName() + "胜利啦！");
}
}
}
//设置一个“Masterb（小怪兽B）”类
package D521;
public class Masterb extends Mastera {
public void attack( Mastera x){
x.setBlood(x.getBlood()-getAttack());
System.out.println(x.getName()+"正在攻击"+getName()+","+"奥特曼B掉血"+getAttack()+"剩余血量"+x.getBlood());
if(x.getBlood()<=0){
System.out.println(getName()+"胜利啦！");
}
}
}
//最后再设置一个主函数，即”Manger“
package D521;
public class Manger {
public static void main(String args[]) {
Aoa a = new Aoa();
a.setName("奥特曼A");
a.setBlood(100);
a.setAttack(30);
Mastera x = new Mastera();
x.setName("小怪兽A");
x.setBlood(100);
x.setAttack(20);
Aob b = new Aob();
b.setName("奥特曼B");
b.setBlood(100);
b.setAttack(20);
Masterb bx = new Masterb();
bx.setName("小怪兽B");
bx.setBlood(100);
bx.setAttack(30);
while (a.getBlood() > 0 && x.getBlood() > 0) {
a.attack(x);
if (x.getBlood() <= 0) {
break;
}
x.attack(a);
if (a.getBlood() <= 0) {
break;
}
}
if (a.getBlood() > 0) {
while (a.getBlood() > 0 && b.getBlood() > 0) {
a.attack(b);
b.attack(a);
}
}
if (x.getBlood() > 0) {
while (a.getBlood() > 0 && x.getBlood() > 0) {
x.attack(bx);
bx.attack(x);
}
}
}
}
但是上述的代码还是太繁琐了，我用到了类的继承性，但是使用得并不灵活，我们还可以用到自动转型，更加方便。
思路是：奥特曼A PK 小怪兽A
PK 奥特曼B
小怪兽A PK 奥特曼A
PK 小怪兽B
如果按照上面的写法，则需要写成：
PK{
PK(Aoa a){ a.attack(); }
PK(Aob b){ b.attack(); }
PK(Monstera ax){ ax.attack(); }
PK(Monsterb bx){ bx.attack(); }
}
现在只需要：
PK(Role role){role.PK()}//这就是自动转型的思维
所以我们可以把奥特曼A、B，小怪兽A、B都当做一个个的角色，这个小程序就是角色与角色之间的PK
//定义一个Role类
public class Role {
public String name;
public int blood;
public int attack;
public void PK(Role role) {
role.blood -= attack;
System.out.println(name + "正在攻打" + role.name + "," + role.name
+ "剩余血量是：" + role.blood);
}
}
接下来就是Ao类和Monster类继承role类的所有属性和功能：
//Ao类继承role类的所有属性和功能
package s522;
public class Ao extends Role{
}
//Monster类继承role类的所有属性和功能
package s522;
public class Monster extends Role{
}
最后建立一个主函数，即Manger类
package s522;
public class Manger {
public static void main(String[] args) {
Ao a1 = new Ao();//可以替换为Role a1 =new Ao();
a1.name = "奥特曼A";
a1.blood = 100;
a1.attack = 5;
Ao a2 = new Ao();
a2.name = "奥特曼B";
a2.blood = 100;
a2.attack = 5;
Monster m1 = new Monster();
m1.name = "小怪兽A";
m1.blood = 100;
m1.attack = 3;
Monster m2 = new Monster();
m2.name = "小怪兽B";
m2.blood = 100;
m2.attack = 3;
while (a1.blood > 0 && m1.blood > 0) {
a1.PK(m1);
if (m1.blood <= 0) {
System.out.println(a1.name + "胜利！");
break;
}
m1.PK(a1);
if (a1.blood <= 0) {
System.out.println(m1.name + "胜利！");
break;
}
}
if (a1.blood > 0) {
while (a1.blood > 0 && a2.blood > 0) {
a1.PK(a2);
if (a2.blood <= 0) {
System.out.println(a1.name + "胜利！");
break;
}
a2.PK(a1);
if (a1.blood <= 0) {
System.out.println(a2.name + "胜利！");
break;
}
}
}
else {
while (m2.blood > 0 && m1.blood > 0) {
m2.PK(m1);
if (m1.blood <= 0) {
System.out.println(m2.name + "胜利！");
break;
}
m1.PK(m2);
if (m2.blood <= 0) {
System.out.println(m1.name + "胜利！");
break;
}
}
}
}
}
运行的结果：
今日小感悟：
1用“Alt+/?”快捷键可以得到输入的提示
2右击鼠标，source中的format可以自动调整格式
3自动转型的思维：
自动转型的格式：
父类名 对象名 = new 子类名();
例如：Role a1 = new Ao();相当于Ao a1 = new Ao;
使用自动转型后的缺点是：
无法调用父类中没有定义过的属性和方法；如果调用就会编译报错。
这是因为Java的编译机制所引起的问题，Java在编译时只会考虑对象名的类型（在编译过程中，会根据对象名的类型，去查找这些调用的属性和方法是否存在，如果存在则编译通过，如果不存在则编译报错）
4 private访问修饰符修饰的方法不能重写；final修饰的方法不能重写。
5怎样调用重写后的方法呢？
new关键字后的类名是谁的，那么就优先调用睡的方法。
如果类名是子类的，那么会优先调用子类的方法，如果子类没有这个方法，才会调用父类的方法.
6什么情况要使用方法重写:父类中存在某一个方法，但是子类也有这个方法，但是方法的具体实现不同的时候。
例如：父类有一个看书学习的方法，子类也有一个看书学习的方法，但是两者不完全一致。
例如：父母有一个做饭的方法，子女也有一个做饭的方法，但是两者做饭的方式是不完全一致。
如果存在上述的情况，需要使用方法重写来实现，实现方法重写的条件：
a.必须要存在继承关系。
b.子类在重写父类方法时，子类方法的访问修饰符要比父类方法的访问修饰符范围大或者一致。
c.子类在重写父类方法时，子类方法的返回值类型，方法名，参数都要和父类方法的完全一致。
d.子类在重写父类方法时，子类方法中的代码必须要和父类方法的代码不同。
7为什么需要使用继承？
a.提高代码的重用性;
b.提高程序的扩展性;
8Java继承的语法格式
Java继承的关键字：extends
格式：
public class 类名（子类、派生类、超类） extends 类名（父类、基类） {
}
生活中什么样的关系需要使用继承来实现呢？
包含关系：学生包含大学生、初中生、...
父母子女的关系
9
访问修饰符 同类中 同包中 不同包中 不同包但是有继承关系的子类中
private 可以 不可以 不可以 不可以
默认的 可以 可以 不可以 不可以
protected 可以 可以 不可以 可以
public 可以 可以 可以 可以
【推荐】还在用 ECharts 开发大屏？试试这款永久免费的开源 BI 工具！
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步