类的继承——简化代码的好方法

       类的继承里父类与子类的关系就像生活中父母与子女之间的关系一样，由于遗传导致子女必定会拥有父母的某些相同的基因，但是子女也可以拥有属于自己的基因，因此，子女大多会有某些特征或行为与父母相似，但是也会有属于自己的特点。然而，生活中的遗传是先天性的，而类的继承却是我们有意而为之的，因为利用继承不仅可以简化代码，减少工作量，子类还具有扩展性。
        继承的语法格式：
        public class 类名B extends 类名A {
                         //属性和方法 
        }
        注意：
               1.子类能继承到父类所有的属性和普通方法。
               2.类名B叫做子类，超类，派生类；类名A叫做父类，基类。
               3.Java的继承是单继承，不可以拥有多个父类。但是可以在继承一个父类之后还可以同时实现多个接口。
               4.能调用(使用)的方法、属性和访问修饰符有关系：
                  同类中 不同类同包 不同类不同包 不同类不同包有继承 

private       可以        不可以            不可以             不可以
默认的        可以         可以              不可以             不可以
protected    可以         可以             不可以               可以
public          可以        可以              可以                   可以 
       方法重写是在类的继承里，因为子类和父类拥有相似的行为，但是具体的方法又不同，所以需要利用方法重写来完成。比如说：父类是学生，子类是大学生，父类里有一个学习的方法：void study(){score++;System.out.println(name+"在学习中，学分是"+score);}子类中也有一个学习方法：protected void study(){System.out.println(getName()+"的学习方式不同啦！");}。
        方法重写的条件：
         1.返回值类型，方法名，参数个数，参数顺序，参数类型要和父类的完全一致。
         2.子类重写方法时，方法的访问修饰符可以大于或者等于父类方法的访问修饰符。
         3.调用时，因为对象的是子类的，所以应该优先在子类中查找，如果存在则调用；如果不存在则调用父类的。
       自动转型也是必须存在继承关系才能使用的。自动转型的优点是可以简化代码，并且在方法设置参数时，可以扩大访问范围。比如：在设置一个父类学生后，它的子类有大学生、高中生、初中生、小学生，只要在创建对象是将所有学生自动转型为学生，这时候一个英语老师她的教学方法里的参数就可以设为学生，而在调用时，参数可以写大学生、高中生、初中生、小学生，这样可以少写很多教学方法。但是缺点是，使用自动转型之后，子类自己的方法不能执行，但是可以强制转型，
       强制转型格式：
                            子类名 子类对象名（新设置的）=（子类名）父类对象名
       自动转型格式：
                            父类名 对象名=new 子类名（）；
       最后我们看一个例子：奥特曼和小怪兽进行PK，直到一方的血量为0时结束战斗，输出谁胜利了。要求：1.奥特曼可以攻击小怪兽或者其他的奥特曼对象2.小怪兽可以攻击奥特曼或者其他的小怪兽对象。3.只能使用一个战斗方法。
        首先写一个父类Juese（角色类）

public class Juese {
		private String name;
		private int strength;
		private int blood;
		java.util.Random rand = new java.util.Random();
		public void setName(String name){
			this.name=name;
		}
		public String getName(){
			return name;
		}
		public void setStrength(int strength){
			this.strength=strength;
		}
		public int getStrength(){
			return strength;
		}
		public void setBlood(int blood){
			this.blood=blood;
		}
		public int getBlood(){
			return blood;
		}
		public  void flight(Juese j){
		j.setBlood(j.getBlood()-rand.nextInt(getStrength()));
		System.out.println(j.getName()+"被"+name+"攻击了，剩余的血量是"+j.getBlood());
			if (j.getBlood()<=0)
				System.out.println(name+"胜利了");
		}
	}

        然后让Aoteman类和Xiaoguaishou类分别继承Juese类

public class Aoteman extends Juese {
}
public class Xiaoguaishou extends Juese{
}

最后写一个攻击方法，分别创建两个奥特曼对象和两个小怪兽对象，让他们进行PK

public class Flight {
       public static void main(String[] args) {
		Aoteman a=new Aoteman();
		a.setName("奥特曼");
		a.getName();
		a.setStrength(10);
		a.getStrength();
		a.setBlood(50);
		a.getBlood();
		Xiaoguaishou x=new Xiaoguaishou();
		x.setName("小怪兽");
		x.getName();
		x.setStrength(10);
		x.getStrength();
		x.setBlood(50);
		x.getBlood();
		Aoteman b=new Aoteman();
		b.setName("奥特曼");
		b.getName();
		b.setStrength(10);
		b.getStrength();
		b.setBlood(50);
		b.getBlood();
		Xiaoguaishou y=new Xiaoguaishou();
		y.setName("小怪兽");
		y.getName();
		y.setStrength(10);
		y.getStrength();
		y.setBlood(50);
		y.getBlood();
		while(a.getBlood()>0&&x.getBlood()>0&&b.getBlood()>0&&y.getBlood()>0){
			a.flight(x);
			a.flight(b);
			x.flight(a);
			x.flight(y);
			}	
	}
}