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