类的继承

1.继承的作用
  提高代码的重用性；增强程序的扩展性
  （子类中可以有比父类更多的方法和属性（子类可以有自己的属性和方法），而父类中不能有这些方法和属性）

2.继承的格式
  public class 子类名 extends 父类名（）{

  }

3.可以继承与可以调用
  继承不等价于调用，子类可以继承父类所有的属性和方法，但不一定可以调用所以的属性和方法。正如子女可以继承父母的基因，但不一定会表现出基因所存储的所有性状。对于子类不能直接调用的父类中的属性和方法，可以以隐含的形式间接调用。
  当子类和父类在同一个包下时
     除了私有的（private）属性和方法，子类可以调用父类中其他所有方法和属性
  当子类和父类不在同一个包下时
     子类和子类对象可以调用父类中公有的（public）属性和方法
     子类（子类的{}中）可以调用父类中受保护的（protected）
     子类和子类对象都不能直接调用父类中私有的（private）和默认的方法和属性
*子类可以用super调用父类中的方法

4.方法重写 
如果实现了方法的重写，则优先调用子类的方法，条件是new的对象必须是子类的
  条件：有继承关系；
        返回值类型、方法名、参数类型、参数数量、参数顺序都要一致；
        子类中方法的访问修饰符可以大于或等于父类中方法的访问修饰符；
        private类的方法不能重写。

5.自动转型
    1>父类名 对象名=new 子类名（）；
    *此时不能调用子类自己定义的方法

    2>访问修饰符 返回值类型 方法名（父类名 参数）{
        //方法体
    }
   调用该方法时可写为
      对象名.方法名（子类中的对象）；

6.多态
  即对象的不同的表现形态，是继承、方法重写、方法重载、自动转型等技术的组合。

如下是Soldier和Boss对战过程，游戏参与者是两个战士，两个怪兽，每个参与者都可以攻打其他对象，每有一个参与者血量为零，则退出游戏，直至只剩下一个参与者，则其胜出。其中Soldier和Boss都是Person的子类，其中的攻击方法分别重写了Person中的攻击方法，并实现了自动转型。

定义一个Person类，作为Soldier和Boss的父类

/**
 * 定义一个Person类
 * @author chenlin
 */
public class Person {
	//定义姓名属性
	private String name;
	//定义血量属性
	private int blood;
	//定义技能属性
	private String skill;
	
	//定义一个构造方法,初始化name,blood,skill
     public Person(String name,int i,String skill){
    	 this.name = name;
    	 this.blood = i;
    	 this.skill = skill;	 
     }
     //方法重载
     public Person(){
    	 
     }
     //定义设置name,blood,skill属性的方法
     public void setName(String name){
    	 this.name = name;
     }
     public void setSkill(String skill){
    	 this.skill = skill;
     }
     public void setBlood(int blood){
    	 this.blood = blood;
     }
     //定义获取name,blood,skill属性值的方法
     public String getName(){
    	 return name;
     }
     public String getSkill(){
    	 return skill;
     }
     public int getBlood(){
    	 return blood;
     }   
     //定义攻击方法
     public void pk(Person p1,Person p2,int i){
    	 p2.setBlood(p2.getBlood()-i-3);
    	 System.out.println(p1.getName()+"用"+p1.getSkill()+"攻击"+p2.getName()+","+
    	    	 p2.getName()+"减少"+(i+1)+"滴血，"+p2.getName()+"剩余"+p2.getBlood()+"滴血。");
     }
}

定义一个Soldier类，继承Person类

public class Soldier extends Person{
 //定义Soldier中的攻击方法,进行方法的重写
	public void pk(Person p1,Person p2,int i){
		//如果p1和p2不是同一个对象，则执行以下过程，否则不执行任何操作
		if(p1!=p2&&p2.getName()!=null&&p1.getName()!=null){
   	 
   	 p2.setBlood(p2.getBlood()-i-3);
   	 switch(i){
   	 case 0:
   		 p1.setSkill("刀剑");
            break;
   	 case 1:
   		 p1.setSkill("枪炮");
   		 break;
   	 }
   	 System.out.println(p1.getName()+"用"+p1.getSkill()+"攻击"+p2.getName()+","+
   	    	 p2.getName()+"减少"+(i+3)+"滴血，"+p2.getName()+"剩余"+p2.getBlood()+"滴血。");
    }
  }
}

定义一个Boss类，继承Person类

/**
 * 定义一个Boss类作为Person类的子类
 * @author chenlin
 *
 */
public class Boss extends Person{
	//定义Boss中的攻击方法,进行方法的重写
		public void pk(Person p1,Person p2,int i){
			//如果p1和p2不是同一个对象，则执行以下过程，否则不执行任何操作
			if(p1!=p2&&p2.getName()!=null&&p1.getName()!=null){
	   	 
	   	 p2.setBlood(p2.getBlood()-i-3);
	   	 switch(i){
	   	 case 0:
	   		 p1.setSkill("火球");
	            break;
	   	 case 1:
	   		 p1.setSkill("闪电");
	   		 break;
	   	 }
	   	 System.out.println(p1.getName()+"用"+p1.getSkill()+"攻击"+p2.getName()+","+
	   	    	 p2.getName()+"减少"+(i+3)+"滴血，"+p2.getName()+"剩余"+p2.getBlood()+"滴血。");
			}
		}
			
}

定义一个对游戏过程进行测试的类

import java.util.Random;

public class Test2 {

	/**
	 * 定义一个主函数入口
	 * @param chenlin
	 */
	public static void main(String[] args) {
		/**
		 *  实例化四个Person类的对象
		 *  两个属于Soldier类的对象
		 *  两个属性Boss类的对象
		 *  实现类的自动转型
		 */
        Person sol1 = new Soldier();
        Person sol2 = new Soldier();
        Person bos1 = new Boss();
        Person bos2 = new Boss();
        /**
         * 对sol1、sol2、bos1、bos2的姓名属性进行设置
         * 实现对Person类中设置姓名的方法的继承
         */
        sol1.setName("战士甲");
        sol2.setName("战士乙");
        bos1.setName("怪兽甲");
        bos2.setName("怪兽乙");
        sol1.setBlood(20);
        sol2.setBlood(20);
        bos1.setBlood(20);
        bos2.setBlood(20);
        /**
         * 实例化一个Person类的数组，存放参加游戏的对象
         */
        Person per[]={sol1,sol2,bos1,bos2};
        //定义一个整型变量，记录被淘汰的对象数
        int f=0;
        /**
         * 实例化一个Person类的数组，存放参加游戏的对象
         */
        
        //用循环语句实现对战过程的连续性
        while(f<4){
            //用随机数i实现主动攻击者的随机性
        	 Random rand = new Random();
             int i = rand.nextInt(4);
             //用随机数p实现被攻击者的随机性
             Random rand1 = new Random();
             int p = rand1.nextInt(4);
             //用随机数j实现使用的技能的随机性
             Random rand2 = new Random();
             int j = rand2.nextInt(2);
             //实现游戏的对战过程
             switch(i){
             //使用自动转型
             case 0:sol1.pk(sol1, per[p], j);break;
             case 1:sol2.pk(sol2, per[p], j);break;
             case 2:bos1.pk(bos1, per[p], j);break;
             case 3:bos2.pk(bos2, per[p], j);break;
             }
             /**
              * 血量用完的参与者退出游戏
              * 同时姓名属性设置为null
              * f值增加一
              */
             if(per[p].getBlood()<=0&&per[p].getName()!=null)//调用父类的getBlood()和getName()方法
             	{System.out.println(per[p].getName()+"退出游戏！");
             	per[p].setName(null);
             	f++;
             	//当f为3时，说明只剩下一个参与者没有被淘汰了，那么其为胜出者
             if(f==3)
             {for(int w=0;w<4;w++)
               {
            	 if(per[w].getName()!=null)
            	 System.out.println(per[w].getName()+"胜利了！");//调用父类的getName()方法
               }
             }
             	}
            }
        }
	}