继承和多态

继承

继承：

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例 域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

生活中的继承：

继承的概述：

• 继承是面向对象程序设计的一个重要特征，它是通过继承原有类派生出子类，进而构造出更为复杂的子类。
• 子类既有新定义的行为特征，又继承了原有类的行为特征。
• 父类与子类存在着包含与被包含的关系，是一种is-a的关系。
• 在Java中继承可以在现有类的基础上进行功能的扩展，这样能够更加快速地开发出新类，使新类不仅可以复用当前类的特征和行为而且还可以定义自己的特征和行为。
• 通过继承可大幅度提高代码的复用性，减少代码量，便于程序的后期维护。

*Java继承语法：*

[修饰符] class 子类名  extends 父类名{



  //类定义部分



}

父类也称为基类或超类

继承的实现：

*示例：*定义父类武器，以及子类圣剑和长矛

public class Weapon { //父类  武器
	String name;//武器名
	int attackValue;//攻击值

    	//构造方法
    public Weapon(String name, int attackValue) {
        System.out.println("--执行武器父类Weapon的构造方法--");
    	this.name = name;
    	this.attackValue = attackValue;
    }
    //攻击方法
    public void attack(){
    	System.out.println("武器名:"+name+"\t"+"攻击
    		值:"+attackValue);
    }

}

public class Sword extends Weapon{ //圣剑  子类
	public Sword(String name, int attackValue) {
		super(name, attackValue);
	}
}
public class Spear extends Weapon{ //圣剑  长矛
	//构造方法
	public Spear(String name,int attackValue) {
		super(name, attackValue);
	}
}
public class ExtendsTest { // 测试类
 	public static void main(String[] args){
 		Sword word = new Sword("圣剑",300);
 		word.attack();
 		Spear spear = new Spear("长矛",250);
 		spear.attack();
 	}
}

多态

多态：

从一定角度来看，封装和继承几乎都是为多态而准备的。

多态是指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

多态是指同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

在编译时，可以通过父类的引用指向子类对象，而在运行时，则通过父类所指向的子类对象，调用子类中重写父类的方法。

多态的应用：

示例：指向子类的父类引用在执行重写方法时所体现的多态性

//父类 人物
public class Figure {
	protected String name;
	public void attack(){
		//此处不进行具体的攻击操作，不同职业的英雄攻击方式不同
	}
	public  void run(){		
		System.out.println("在奔跑");
	}
}

//子类 战士
public class Warrior  extends  Figure{
	//重写父类的attack()方法
	public void attack(){
	            System.out.println(this.name+"正在物理攻击......");
	}
}
//子类 法师
public class Master extends Figure {
	//重写父类的attack()方法
	public void attack(){		
		System.out.println(this.name+"正在魔法攻击......");
	}	
	public static void main(String[] args) {
	     Figure master=new Master();
	     master.name="恶魔巫师";
	     Figure warrior=new Warrior();
	     warrior.name="撼地神牛";
	     master.attack();
	     warrior.attack();
	}
}

引用变量的强制类型转换：

示例：调用父类引用的方法没有在父类进行定义

//子类 法师
public class Master extends Figure {
	//重写父类的attack()方法
	public void attack(){		
	            System.out.println(this.name+"正在魔法攻击......");
	}
	//子类特有的轰炸功能
	public void bomb(){
	            System.out.println(this.name+“正在魔法轰炸......");
	}	
	public static void main(String[] args) {
	     Figure figure=new Master();
	     figure.name="恶魔巫师";
                       figure.attack();
	     figure.bomb(); //此处编译出错
	}
}

分析：

引用变量只能调用其编译时类型的方法，而不能调用运行时类型的方法，即 使实际所引用的对象确实包含该方法。

如果需要让引用变量调用运行时类型的方法，则必须将其强制类型转换为运 行时类型，强制类型转换需借助于类型转换运算符。

instance of 运算符

*instance of* 运算符用于判断一个实例是否为某个类的实例

语法：

a instanceof A

判断实例a是否为类A的实例，如果为真则返回true，否则返回false。

//子类 法师
public class Master extends Figure {
	//重写父类的attack()方法
	public void attack(){		
	            System.out.println(this.name+"正在魔法攻击......");
	}
	//子类特有的轰炸功能
	public void bomb(){
	            System.out.println(this.name+“正在魔法轰炸......");
	}	
	public static void mafigurein(String[] args) {
	     Figure figure=new Master();
	     figure.name="恶魔巫师";
                       figure.attack();
                       if(figure instanceof Master )
	      	Master master = (Master)figure; // 使用向下类型转换
	      master.bomb();   //成功调用Master类的bomb
	}
}

总结：
声明包的语句是“package 包名”，该语句必须放在第一行，导入类的语句是 “import 包名.类名”。
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例 域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
子类继承父类的语法是：“[修饰符] class 子类名 extends 父类名”。
重载就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。
重写就是在子类方法重写父类方法，重写的方法和被重写的方法必须具有相同方法名称、参数
列表和返回类型。
多态是指同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
在编译时，可以通过父类的引用指向子类对象，而在运行时，则通过父类所指向的子类对象，调用子类中重写父类的方法。