JavaSE第十八讲：多态剖析

1.方法重写（Override）：又叫做覆写，子类与父类的方法返回类型一样、方法名称一样，参数一样，这样我们说子类与父类的方法构成了重写关系。

【举例重写程序如下】

public class InheritenceTest2
{
	public static void main(String[] args)
	{
		Dog dog = new Dog();
		dog.run();
	}	
}

class Animal
{
	public void run()
	{
		System.out.println("animal is running");
	}
}

class Dog extends Animal
{
	public void run()
	{	
		System.out.println("dog is running");
	}
}

执行结果：

D:\src>java InheritenceTest2

dog is running

修改程序如下（以下程序不可成为重写）：

public class InheritenceTest2
{
	public static void main(String[] args)
	{
		Dog dog = new Dog();
		dog.run(1);
	}	
}

class Animal
{
	public void run()
	{
		System.out.println("animal is running");
	}
}

class Dog extends Animal
{
	public void run(int i)
	{	
		System.out.println("dog is running");
	}
}

执行结果：

D:\src>java InheritenceTest2
dog is running

【说明】次处就不应该是重写，子类从父类当中继承了run()方法，而本省一个带参数的run(int i)的方法，所以只能说子类对父类的run()方法进行了重载，此时子类当中应该有两个run方法，一个是带参数的，一个是不带参数的，所以如果main方法中传递不带参数的run方法，则程序执行结果不同，参考以下程序。

public class InheritenceTest2
{
	public static void main(String[] args)
	{
		Dog dog = new Dog();
		dog.run();
	}	
}

class Animal
{
	public void run()
	{
		System.out.println("animal is running");
	}
}

class Dog extends Animal
{
	public void run(int i)
	{	
		System.out.println("dog is running");
	}
}

执行结果：
D:\src>java InheritenceTest2
animal is running

2.方法重写与方法重载之间的关系：重载发生在同一个类内部的两个或多个方法。重写发生在父类与子类之间。重载是一种平行的关系，重写是一种层次关系，伴随着继承而发生的。

3.当两个方法形成重写关系时，可以在子类方法中通过super.run()形式调用父类的run()方法，其中super.run()不必放在第一行语句【此处super.run()与super();是不同的】，因此此时父类对象已经构造完毕，先调用父类的run()方法还是先调用子类的run()方法是根据程序的逻辑决定的。

修改以上程序

public class InheritenceTest2
{
	public static void main(String[] args)
	{
		Dog dog = new Dog();
		dog.run();
	}	
}

class Animal
{
	public void run()
	{
		System.out.println("animal is running");
	}
}

class Dog extends Animal
{
	public void run()
	{	
		super.run();//调用父类的run方法
		System.out.println("dog is running");
	}
}

执行结果：
D:\src>java InheritenceTest2
animal is running
dog is running

修改上一个程序第20行那段代码，修改如下：

	public void run()
	{	
	//	super.run();//调用父类的run方法
		System.out.println("dog is running");
		super.run();
	}

执行结果：

D:\src>java InheritenceTest2
dog is running
animal is running

【说明】:Dog是继承了父类，super是对父类对象的引用，注意此处不是调用父类的构造方法与super();的区别，只是调用父类的普通方法【容易出错的地方】，此时父类对象已经生成了，所以只是顺序的调用方法而已。

4.在定义一个类的时候，如果没有显式指定该类的父类，那么该类就会继承于java.lang.Object类（JDK提供的一个类，Object类是Java中所有类的直接或间接父类）。Object类是Java中所有类的直接或间接父类。Object中的定义的十个方法每个都很重要，有时间要整理出来。

继承中构造方法的调用顺序，

public class InheritenceTest3
{
	public static void main(String[] args)
	{
		Son son = new Son();
	}
}

class Grandpa
{
	public Grandpa()
	{
		System.out.println("grandpa");
	}
}

class Father extends Grandpa
{
	public Father()
	{
		System.out.println("father");
	}
}

class Son extends Father
{
	public Son()
	{
		System.out.println("son");
	}
}

执行结果：
D:\src>java InheritenceTest3
grandpa
father
son

5.多态（Polymorphism）：我们说子类就是父类（玫瑰是花，男人是人），因此多态的意思就是：父类型的引用可以指向子类的对象。多态是构建在封装和继承之上的。

public class PolyTest
{
	public static void main(String[] args)
	{
		Flower rose = new Rose(); //多态
		rose.sing();
	}
}

class Flower
{
	public void sing()
	{
		System.out.println("flower is singing");
	}
}

class Rose extends Flower
{
	
}

执行结果：

D:\src>java PolyTest
flower is singing

【说明】：Flower rose = new Rose(); //多态       Flower类型的引用指向Rose的对象。