java 类的继承

1，使用继承的原因

    可以少编写代码，有的不同类里的属性方法都是可以通用的，使用继承后，可以减少代码

2，继承用怎样的代码表示

    在java 中，用extend 实现继承

   具体的格式：public class 类名（这个是子类名，也叫做超类名或者派生类名） extends 类名（这个是父类名，也叫基类名）{

//写方法体

}

3,、调用可以在子类中调用，

 在子类中调用，就是说存在继承关系的子类中，可以调用父类中定义

        过的属性和方法，但要注意其访问修饰符，如果是private,那么只能在
 当前类中的{}中调用，即是在子类中不能被调用。如果是默认的，那么只能在
  当前的包下中调用，如果子类在其他包中，则不能调用父类中的属性和函数。如果是
protected,则只能在当前包下和有继承关系的子类中调用，就算不在一个包中，有继承关系就行
如果是public,则在任何地方都可以调用
而且，子类在继承了父类的方法和属性后，还可以定义自己的属性和方法。这就大大增加了
子类的功能。
注意：子类一定要有一个和父类完全一样的构造方法，若父类的构造器是默认的，那么就不用
使用super来调用父类的构造器，它会默认调用，如果父类的构造器不是默认的，或者有多个（不包括
默认的那个时），子类必须要使用super调用一次，如果父类里有多个构造器，且存在一个默认的，那么
子类可以不用super,因为子类有一个默认的，与父类相同

4、方法重写：
   因为子类的一种同名方法可能要有其个性，与父类不同，或者比父类完善，就要用到方法重写
方法重写的条件：
 1.肯定要存在继承关系
 2.方法的返回值类型（特别注意），方法名，参数个数，参数类型，参数顺序必须要完全一致
  3.子类重写方法时方法的访问修饰符可以大于或者等于父类方法的访问修饰符。
     顺序：private<默认的<protected<public
  4.方法体不同，即是大括号里的代码不完全相同

重写之后的调用问题：
 1、先要确定好创建的对象是子类还是父类的
 2、若对象是子类的，若子类把此方法重写了，则优先调用子类的，否则执行父类的

5、自动转型问题（对我来说是难点）
  注意：首要条件是存在继承关系
有两种自动转型格式：
   一、父类名 创建的对象名 = new 子类名
    这种是有缺陷的，  在自动转型后，调用的函数名必须父类中有，但子类如果重写了该方法
则优先调用子类的
  二、调用的函数需要对象时，此对象可以是子类的，也可以是父类的类型
6.多态
 
 多态是由方法重载，继承，方法重写，自动转型等技术的组合。
  因为各种组合复杂多样，有多种形态
public class Manage {
 public static void main(String[] args) {// 主函数
  // 创建4个角色，并给属性赋值。
  Roll ro1 = new Player("奥特曼1号", 100, 5);
  Roll ro2 = new Player("奥特曼2号", 200, 8);
  Roll ro3 = new Playerfour("小怪兽 1号", 300, 12);
  Roll ro4 = new Playerfour("小怪兽2号", 50, 3);
       //循环调用pk函数，ro1与ro2和ro3打，直到一方胜利
  while(ro1.getBlood() > 0 && ((ro2.getBlood() >0)||ro3.getBlood()>0) ){
    ro1.pk(ro2);
    ro1.pk(ro3);
   if(ro2.getBlood() > 0)
    ro2.pk(ro1);
   if(ro3.getBlood()>0)
    ro3.pk(ro1);
}
  //若ro1胜利，ro1跟ro4打，并输出胜利者
  if(ro1.getBlood() > 0 ){
   
   while (ro4.getBlood()>0  && ro1.getBlood() >0 ){
    ro1.pk(ro4);
    if(ro4.getBlood()>0)
     ro4.pk(ro1);
    } 
   if(ro1.getBlood()>0){
    System.out.println(ro1.getName()+"胜利！");
   }else{
    System.out.println(ro4.getName()+"胜利！");
   }
  }
  //若ro2胜利，则ro2跟ro4打，并输出胜利者
  if(ro2.getBlood()>0){
   while (ro4.getBlood()>0  && ro2.getBlood() >0 ){
   ro2.pk(ro4);
   if(ro4.getBlood()>0)
    ro4.pk(ro2);
   } 
  if(ro2.getBlood()>0){
   System.out.println(ro2.getName()+"胜利！");
  }else{
   System.out.println(ro4.getName()+"胜利！");
  }
   
  }
  //若ro3胜利，则ro3跟ro4打，并输出胜利者
  if(ro3.getBlood()>0){
   while (ro4.getBlood()>0  && ro3.getBlood() >0 ){
    ro3.pk(ro4);
    if(ro4.getBlood()>0)
     ro4.pk(ro3);
    } 
   if(ro3.getBlood()>0){
    System.out.println(ro3.getName()+"胜利！");
   }else{
    System.out.println(ro4.getName()+"胜利！");
   }
  }
 
 }
}

 

public class Player extends Roll{//继承父类Roll
 public Player(String name,int blood,int aggressivity){
 super(name,blood,aggressivity);//调用父类的构造器
    }
 //重写pk
 public void pk(Roll p){
  p.setBlood(p.getBlood()-2*this.getAggressivity());
  System.out.println(getName()+"打了"+p.getName()+","+p.getName()+"的血量剩余"+p.getBlood());
 }
 
}

 

public class Roll {//创建Roll类
 //设置属性
 private String name;
 private int blood;
 private int aggressivity;
 //重载构造器
 public Roll(String name,int blood,int aggressivity){
  this.name=name;
  this.blood=blood;
  this.aggressivity=aggressivity;
 }
 //设置血量
 public void setBlood(int blood){
  this.blood=blood;
 }
 //得到血量
  public int getBlood(){
        return blood;
    }
  //得到姓名
   public String getName(){
    return name;
   }
  //得到攻击力
 public int getAggressivity(){
  return aggressivity;
 }
 //定义PK函数
 public void pk(Roll roll){
  roll.setBlood(roll.getBlood()-aggressivity);
  System.out.println(name+"打了"+roll.getName()+"，"+roll.getName()+"的血量剩余"+roll.getBlood());
 }
}

 

public class Playerfour extends Roll {   //继承父类
 public Playerfour(String name,int score,int aggressivity){
  super(name,score,aggressivity);//调用父类构造器
 }

}