类的继承

类的继承

      1.类的继承就是在现有类的基础上，派生出一个新的类，新派生的类自动具有了现有类的全部属性和特征，同时，新类还加入了原有类所没有的新的属性、特征和方法，所以可以说新类是对原有类的扩展。

      在继承关系中，被继承的类称为父类（或基类），通过继承产生的类称为子类（派生类）。Java中不允许多继承，只存在单继承，一个类只可以有一个父类。

      子类和父类是相对而言的，一个子类也可以成为另外一个类的父类。如动物可以是一个父类，动物中有飞禽、陆生动物、水生动物都拥有动物所具有的属性。一个子类可以是一个父类的对象，而一个父类不一定是一个子类的对象。子类和父类如一般和具体，普通和特殊的关系。

      继承的格式为 :public class 子类名 extends 父类名。

      父类的非私有性方法可以默认继承给子类，子类不可以调用父类中的私有方法，父类的构造方法子类不可以继承.

      如果子类和父类同一个包下，则除私有的属性和方法外，其他都能被调用；如果子类父类在不同包中，但对象在子类外去调用方法，只有公有的方法和属性能被调用；如果不同包下，但是在子类中调用，则公有的和受保护的都能被调用。 

 

以下范围依次由严到宽：

private ：本类访问； 

default ：表示默认，不仅本类访问，而且是同包可见。

Protected：同包可见+不同包的子类可见

Public ：表示所有的地方均可见。

 

 

2.方法重写

      在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。

 

关于方法重写的特性：

      1)发生方法重写的两个方法返回值、方法名、参数列表必须完全一致(子类重写父类的方法)

      2)子类方法的访问级别不能低于父类相应方法的访问级别(子类访问级别不能低于父类访问级别)

例：

 

public class Student{
	private name;
	public setName(name){
		this.name=name;
	}
	public getName(){
		return name;
	}
	public void study(){
	System.out.println("学生的学习方法");
	}
}
public class UNStudent extends Student{
	public void study(){
	System.out.println(name+"是大学生，大学生的学习方法");
	}
}
public class JStudent extends Student{
	public void study(){
	System.out.println(name+"我是初中生，初中生的学习方法");
	}
}

 

上例中UNStudent和JStudent是Student的两个子类，两个子类中的study方法为方法重写。

 

3.自动转型

自动转型的格式为：

public 返回值类型 方法名(父类名 子类变量名)

父类名 变量名=new 子类名();

方法 方法名(子类变量名);

 

4.多态性

多态：多态指的是编译时类型变化，而运行时类型不变。

多态分两种： 

① 编译时多态：编译时动态重载； 

② 运行时多态：指一个对象可以具有多个类型。  

对象是客观的，人对对象的认识是主观的。

例：

 

Animal a=new Dog()；
Dog d=(Dog)a。//声明父类来引用子类

 

 

运行时多态的三原则：（应用时为覆盖）

      1、 对象不变；（改变的是主观认识） 

      2、 对于对象的调用只能限于编译时类型的方法，如调用运行时类型方法报错。 

      在上面的例子中：Animal a=new Dog()；对象a的编译时类型为Animal，运行时类型为dog。 注意：编译时类型一定要为运行时类型的父类（或者同类型）。 

      对于语句：Dog d=(Dog)a。将d强制声明为a类型，此时d为Dog()，此时d就可以调用运行时类型。注意：a和d指向同一对象。 

      3、 在程序的运行时，动态类型判定。运行时调用运行时类型，即它调用覆盖后的方法。

 

 

下面为运用到类的继承的一个实例，Warrior VS BOSS：

 

import java.util.Random;
public class Role {
	public void setName(String name) {
		this.name = name;
	}
	public void setBlood(int HP) {
		this.HP = HP;
	}
	public String getName() {
		return name;
	}
	public int getBlood() {
		return HP;
	}
	public void setMagic(int MP) {
		this.MP = MP;
	}
	public int getMagic() {
		return HP;
	}
	public int HP;
	public int MP;
	public String name;

	private int defense;

	public void setDefense(int defense) {
		this.defense = defense;
	}
	public int getDefense() {
		return defense;
	}
	public void Attack(Role r) {
		r.setBlood(r.getBlood() - 1);
		System.out.println(name + "在攻击" + r.getName() + "," + r.getName()
				+ "掉血1点，剩余" + r.getBlood() + "血");
	}
}

public class Warrior extends Role {
	public void Attack(Role r) {
		Random rand = new Random();
		int atk = rand.nextInt(50);// 生成一个0-19的随机数值
		if (atk == 0) {
			System.out.println(r.getName() + "闪避" + name + "的攻击");
		} else if (atk <= r.getDefense()) {
			System.out.println(r.getName() + "免疫" + name + "的攻击");
		} else {
			r.setBlood(r.getBlood() - (atk - r.getDefense()));
			System.out.println(name + "在攻击" + r.getName() + "," + r.getName()
					+ "掉血" + (atk - r.getDefense()) + "点，剩余" + r.getBlood()
					+ "血");
		}
	}
	public void Prop() {
		setBlood(getBlood() + 20);
		System.out.print(getName() + "使用了红色血瓶,生命值增加20点    ");
		System.out.println(getName() + "血量剩余" + getBlood());

	}
}
public class BOSS extends Role {
	public void Attack(Role r) {
		// 实例化一个随机数类的对象
		Random rand = new Random();
		int atk = rand.nextInt(20);// 生成一个0-19的随机数值
		if (atk == 0) {
			System.out.println(r.getName() + "闪避了" + name + "的攻击");
		} else {
			r.setBlood(r.getBlood() - atk);
			System.out.println(name + "在攻击" + r.getName() + "," + r.getName()
					+ "掉血" + atk + "点，剩余" + r.getBlood() + "血");
		}
	}
	public void Vampire(Warrior r) {
		int a,b,c;
		b = (int) (r.getBlood() * 0.15);
		a = r.getBlood() - b;
		r.setBlood(a);
		setBlood(getBlood() + b);
		setMagic(getMagic()-2);
		c=getMagic();
		System.out.print(name + "吸取了" + r.getName() + " " + b + "点血量,剩余"+c+"点MP  ");
		System.out.println(r.getName() + "受到" + b + "点伤害,血量剩余" + a + "点");
	}
}
public class Though {
	public static void main(String[] args) {
		Warrior hero1 = new Warrior();
		Warrior hero2 = new Warrior();
		BOSS boss1 = new BOSS();
		// BOSS boss2=new BOSS();
		hero1.setName("战士1");
		hero2.setName("战士2");
		boss1.setName("BOSS1");
		// boss2.setName("BOSS2");
		hero1.setBlood(100);
		hero2.setBlood(150);
		hero1.setMagic(10);
		boss1.setBlood(300);
		boss1.setDefense(20);
		boss1.setMagic(10);
		// boss2.blood(450);
		Random rd= new Random();
		
		while (hero1.getBlood() >= 0 && hero2.getBlood() >= 0
				&& boss1.getBlood() >= 0) {
			int rd1=rd.nextInt(2);
			int rd2=rd.nextInt(2);
			int rd3=rd.nextInt(2);
			int rd4=rd.nextInt(2);
			switch(rd1){
			case 0:hero1.Attack(boss1);break;
			case 1:hero1.Prop();break;
			}
			switch(rd2){
			case 0:hero2.Attack(boss1);break;
			case 1:hero2.Prop();break;
			}
			if (boss1.getMagic()>=2)
				switch(rd3){
				case 0:boss1.Attack(hero1);break;
				case 1:boss1.Vampire(hero1);break;
				}
				else boss1.Attack(hero1);
			if (boss1.getMagic()>=2)
				switch(rd4){
				case 0:boss1.Attack(hero2);break;
				case 1:boss1.Vampire(hero2);break;
				}
				else boss1.Attack(hero2);
			if (boss1.getBlood() <= 0) {
				System.out.print("战士" + "胜利!!!");
				break;
			}
			if (hero1.getBlood() <= 0 && hero2.getBlood() <= 0) {
				System.out.print("boss1" + "胜利!!!");
				break;
			}
		}
	}
}