类的继承和多态性

      一、 继承就是重用现有的类来生成新类的一种特征；通俗地讲就是从现有的类（即父类或基类）创建新类（子类或派生类）的过程；现实生活中，继承可以达
到财产重用的目的，而在Java中，继承可以使代码重用。

类的继承  ：

1、在java中通过关键字 extends 继承一个已有的类，被继承的类成为父类（基类），新的类 称为 子类（派生类）。
2、在java中，不允许多继承。（为了解决单继承的问题，可以使用接口<interface>

3、在子类中定义一个与父类同名、返回类型、参数类型均相同的一个方法，称为方法的 覆盖。

4、覆盖 发生在子类与父类之间。
5、特殊变量super 提供了对父类的访问。

6、可以使用super 访问父类被子类隐藏的变量和覆盖的方法。

7、每个子类构造方法的第一条语句，都是隐含的调用super()，如果父类没有构造方法， 那么在编译的时候就会报错。

     先来看一下一段继承的代码，以方便更好的理解继承：

  

class Animal { // 父类
	int height, weight; // 变量（数据）
	Animal(){};
	Animal(int height, int weight)// 父类的构造方法 (带参数的父类构造方法)
	{
		System.out.println("animal construct");
	}

	void eat() // 父类的方法
	{
		System.out.println("animal eat");
	}

	void sleep()// 父类的方法
	{
		System.out.println("animal sleep");
	}

	void breathe()// 父类的方法
	{
		System.out.println("animal breathe");
	}

}

/**
*子类
**/
class Fish extends Animal { // 子类 关键字 extends 使 Fish 继承了 Animal 的 变量和方法
	int height;// 子类的变量 ，在调用时会隐藏父类的变量。

	Fish()// 子类的构造方法
	{
		super(30, 40);// 利用 super 调用带参数的父类构造方法。
		// 不能Animal(30,40)这样直接调用父类构造方法。只能用super()调用。
		// 父类的构造方法不能被子类继承。

		// super();//在调用子类构造方法的时候,隐含的调用了 super() 变量，
		// 也就是先调用父类的构造方法(不带参数)在调用子类的构造方法。如果父类没有构造方法，编译器就会报错。
		System.out.println("fish construct");
	}

	void breathe()// 子类的方法
	{
		super.breathe();// 通过 super 特殊变量 可以调用被子类覆盖的父类方法。
		super.height = 40;// 通过 super 特殊变量 可以调用被子类隐藏的父类变量。
		System.out.println("fish bubble");
	}
}

测试程序：

class Test {
	static void fn(Animal an) {
		an.breathe();
	}

	public static void main(String[] args) {
		Animal an = new Animal(); // 实例化Animal类的对象，an是对象的reference（引用）
		Fish fh = new Fish();// 实例化Fish类的对象，fh是对象的reference（引用）
		an.breathe();// an 调用Animal类的void breathe()方法。
		fh.height = 30;// fh给Animal类的变量int height 赋值.继承父类的成员变量.
		fh.breathe();// fh调用它自己的方法，假如它自己没有这个方法但父类（Animal）中有这个方法，它就会调用父类中的这个方法。
		// 反之（如果有），它就会调用它自己的方法，这就是方法的覆盖。

		
	}
}

运行结果：

animal construct
fish construct
animal breathe
animal breathe
fish bubble

      二、多态是指同一函数在不同的类中有不同的实现；多态的好处就是使类更灵活，更便于扩充。

多态性 ：

 1、通过覆盖父类的方法来实现，在运行时根据传递的对象引用，来调用相应的方法。
 2、简单概括多态性：当我们将子类对象的引用传给声明为父类的一个对象变量，如果子类有 这个方法就调用子类的方法，如果子类没有这个方法就调用父类的这个方法。
 3、多态性的好处：它可以根据在运行的时候，根据我们传递不同对象的引用， 来调用不同对象的方法。

代码如下：

测试代码：

class Test {
	static void fn(Animal an) {
		an.breathe();
	}

	public static void main(String[] args) {
		Animal an = new Animal(); // 实例化Animal类的对象，an是对象的reference（引用）
		Fish fh = new Fish();// 实例化Fish类的对象，fh是对象的reference（引用）
		an.breathe();// an 调用Animal类的void breathe()方法。
		fh.height = 30;// fh给Animal类的变量int height 赋值.继承父类的成员变量.
		fh.breathe();// fh调用它自己的方法，假如它自己没有这个方法但父类（Animal）中有这个方法，它就会调用父类中的这个方法。
		// 反之（如果有），它就会调用它自己的方法，这就是方法的覆盖。

		// 多态性
		Animal an1;// 将an声明为Animal的对象变量。
		Fish fh2 = new Fish();
		fh2.eat();
		an1 = fh;
		an1 = fh2;// 因为子类没有eat()这个方法，所以这调用的是父类的eat()方法。
		Test.fn(an1);// 直接用类名调用静态方法（static）。多态性
*/	}
}

运行结果：

animal construct
fish construct
animal eat
animal breathe
fish bubble
到此，继承和多态已经明朗化了。在结合 了网上论坛的资源，写一下这内容 ，方便查阅。