类的继承

基础知识
1.继承的语法格式
Java继承的关键字是：extends
继承格式：
public class 类名(子类名，超类名，派生类名) extends 类名(父类、基类) {

}
Java的继承是单继承，只有一个直系父类。
(class 子类名 extends 父类名：不能在建立类时写这个，应该先建立子类后再修改)

2.子类继承到了什么
子类继承到了父类所有的属性和方法。

因为访问修饰符的问题，导致只有一部分属性和方法能被子类和和子类的对象调用。

3.方法重写
什么情况要使用方法重写？
  同一个方法中，当子类的方法中的功能与父类中有所不同时，要用方法重载。

重写的条件
1.必须要存在继承关系。
2.方法的返回值数据类型、方法名、参数个数、参数类型、参数顺序都必须要和父类的完全一致。
3.子类重写方法时的访问修饰符范围可以大于或者等于父类方法的访问修饰符。

子类中的方法重写后可以直接被调用。

但方法重写以后如果要调用父类的方法，那么应该用super关键字调用父类方法。
              eg：public void study(){
super.study();//调用父类的方法
                  }

4.自动转型
要实现自动转型必须要存在继承关系
byte b = 10;
int i = b;
  这里的bite之所以可以自动转型为int，是因为int的取值范围大于bite。（int：32位，bite：8位）
用学生来表示大学生
用动物来表示人
用父母的名字指向儿子或者女儿
父类名 对象名 = new 子类构造方法();
          （在练习中都有举例）
报错：
因为Java的编译机制问题。
子类中的方法的访问级别不能低于父类中该方法的访问级别，为何呢？假如没有这个限制， 如果Child类的 outPut() 方法的访问级别为 private ，将会与 java 的多态机制发生冲突。Parent parent = new Child(); parent.outPut(); 这里Java 编译器会认为以上是合法的，但在运行时，根据动态绑定规则，Java 虚拟机会调用 parent 变量所引用的 Child 实例的 outPut()  方法，而 Child 的 outPut() 方法为 private，Java虚拟机无法访问。为了避免这样的矛盾，Java 虚拟机不允许子类方法缩小父类中被覆盖方法的访问权限。

5.多态
多态具体表现在重写和重载
多态就是类的多种表现方式
比如同名不同参
子类重写父类
6.接口
定义接口的关键字是interface
格式
public interface 接口名   extends 接口,... {
//常量
public static final 数据类型 常量名 = 值;

//抽象方法
public 返回值数据类型 方法名(数据类型 参数名,...);
}
注意四点：
               1.访问修饰符只有public一种
               2.static final可以不写，其输出也是常量
               3.

类去实现接口的关键字是：implements
public class 类名 extends 类名或者抽象类 implements 接口名,... {
//实现(重写)父接口中所有的抽象方法
}

接口和类的区别：


7.抽象类
定义抽象类的关键字：abstract class
格式：
public abstract class 抽象类名  extends 类名或者抽象类  implements 接口名,... {

//类中所有的属性和方法

//接口中的常量和抽象方法
public abstract 返回值数据类型 方法名(数据类型 参数名,...);

}

6.练习
1.回合制游戏:德玛（四个技能（技能名和攻击力））+卡牌（四个技能（技能名和攻击力））要去战斗，直到一方的血量为0的时候结束战斗，输出谁胜利了。
德玛和德玛战斗
卡牌和卡牌战斗
原始构思：
    1.将德玛写成一个类，将卡牌写成一个类，但由于德玛和卡牌不但可以和不同类战斗，还可以和同类战斗，对不同的对象使用相同的战斗方法。所以战斗方法中的参数必须可以同时表示这两个类（否则要重复写方法，添加不同的参数），这时需要建立一个父类，只要添加父类参数即可。
    2.德玛和卡牌的技能应该要有所不同，所以要使用方法重写。
      继承父类的方法不需要每个都用super关键字，只有当该方法在子类中重写了以后还  需调用父类方法，则用super关键字。
我的代码：
package 类的继承;


public class Actor {
protected String name;
    int HP;
//定义构造方法
public Actor(String name,int HP){
this.name=name;
this.HP=HP;
}
public String getName(){
return name;
}
public void setHP(int HP){
this.HP=HP;
}
      public int getHP(){
      return HP;
      }
      /**
       * 定义四个技能方法
       */
      public void fight1(Actor act){
      int HP=act.getHP();
  HP-=10;
  act.setHP(HP);
  System.out.println(name+"：刀光剑影，攻击力10");
System.out.println(act.getName()+"生命值还剩"+act.getHP());
      }
      public void fight2(Actor act){
      int HP=act.getHP();
  HP-=10;
act.setHP(HP);
System.out.println(name+"：青木颂，攻击力10");
System.out.println(act.getName()+"生命值还剩"+act.getHP());
      }
      public void fight3(Actor act){
      int HP=act.getHP();
  HP-=10;
act.setHP(HP);
System.out.println(name+"：步步伤，攻击力10");
System.out.println(act.getName()+"生命值还剩"+act.getHP());
      }
      public void fight4(Actor act){
      int HP=act.getHP();
HP-=50;
act.setHP(HP);
System.out.println(name+"：聚魂影，攻击力50");
System.out.println(act.getName()+"生命值还剩"+act.getHP());
      }
      //定义一个胜利的方法
      public void win(Actor act){
System.out.println(act.getName()+"血量不足,"+name+"胜利！！！");
}
}
//建立一个子类Dema：
package 类的继承;



public class Dema extends Actor {

public Dema(String name, int HP) {
super(name, HP);

}//Dema类中的构造方法为默认的，要继承父类的，则要用super关键字。
//方法1重写
      public void fight1(Actor act){
          int HP=act.getHP();
    HP-=20;
    act.setHP(HP);
    System.out.println(name+"：万箭穿心，攻击力20");
    System.out.println(act.getName()+"生命值还剩"+act.getHP());
          }
}
//建立一个子类Kapai：
package 类的继承;

public class Kapai extends Actor {
public Kapai(String name, int HP) {
super(name, HP);

}
//方法3重写
      public void fight3(Actor act){
          int HP=act.getHP();
    HP-=25;
    act.setHP(HP);
    System.out.println(name+"：群魔乱舞，攻击力25");
    System.out.println(act.getName()+"生命值还剩"+act.getHP());
          }
}
//主函数：
package 类的继承;

public class Manage {


public static void main(String[] args) {
// 实例化两个Dema对象
Dema de1=new Dema("德玛一号",100);
Actor de2=new Dema("德玛二号",100);
        Kapai ka1=new Kapai("卡牌一号",100);
        Actor ka2=new Kapai("卡牌二号",100);
      //德玛一号和德玛二号的战斗
while(de1.getHP()>0&&de2.getHP()>0){
//调用方法
de1.fight4(de2);
de2.fight1(de1);
de1.fight2(de2);
de2.fight3(de1);
}
             //判断输赢
if(de1.getHP()<=0)
de2.win(de1);
else
de1.win(de2);
System.out.println("\n");
//卡牌一号和卡牌二号的战斗
while(ka1.getHP()>0&&ka2.getHP()>0){
//调用方法
ka1.fight4(ka2);
ka2.fight1(ka1);
ka1.fight2(ka2);
ka2.fight3(ka1);
}
if(ka1.getHP()<=0)
ka2.win(ka1);
else
ka1.win(ka2);
System.out.println("\n");
//赢了的德玛和赢了的卡牌的战斗
         //先判断赢了的德玛和赢了的卡牌，再进行循环战斗
         //输出胜利的对象
if(ka1.getHP()>0&&de1.getHP()>0){
while(de1.getHP()>0&&ka1.getHP()>0){
//调用方法
de1.fight2(ka1);
ka1.fight3(de1);
}
  if(de1.getHP()<=0)
ka1.win(de1);
  else de1.win(ka1);
}
if(ka2.getHP()>0&&de1.getHP()>0){
while(de1.getHP()>0&&ka2.getHP()>0){
//调用方法
de1.fight2(ka2);
ka2.fight3(de1);
}
  if(de1.getHP()<=0)
ka2.win(de1);
  else de1.win(ka2);
}
if(ka1.getHP()>0&&de2.getHP()>0){
while(de2.getHP()>0&&ka1.getHP()>0){
//调用方法
de2.fight2(ka1);
ka1.fight3(de2);
}
  if(de2.getHP()<=0)
ka1.win(de2);
  else de2.win(ka1);
}
if(ka2.getHP()>0&&de2.getHP()>0){
while(de2.getHP()>0&&ka2.getHP()>0){
//调用方法
de2.fight2(ka2);
ka2.fight3(de2);
}
  if(de2.getHP()<=0)
ka2.win(de2);
  else de2.win(ka2);
}
}
}