继承python 继承之战

转载

bingfeng 2023-12-13 09:47:52

文章标签 继承python java System 子类父类 文章分类 Python 后端开发

练习
回合制对战游戏：奥特曼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;
 }
 }
 } }
}

运行的结果：

继承python 继承之战_父类

今日小感悟：

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　　　　    可以 　　 可以　　　 可以 　　　　　   可以

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。