——继承与多态

---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ ----------------------

继承

继承是面对对象的三大特征之一，也是实现多态的方式之一。

一个类继承另一个类的时候，可以继承除了构造函数以外的所有类成员。

继承的优缺点：

继承的优点：
      1，提高了代码的复用性。
      2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。

继承的缺点：打破了封装性。

继承的语法：

java中继承用的extends关键字

如：

class A extends B{

}

注：千万不要为了获取其他类的功能，简化代码而继承。
必须是类与类之间有所属关系才可以继承。所属关系 is a。

--------------------------------------------------------------------------------

继承的规则：

Java语言中：java只支持单继承，不支持多继承。

因为多继承容易带来安全隐患:当多个父类中定义了相同功能，

当功能内容不同时，子类对象不确定要运行哪一个。

但是java保留这种机制。并用另一种体现形式来完成表示。多实现。

java支持多层继承。也就是一个继承体系。

继承中功能的使用：

想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。
通过了解共性功能，就可以知道该体系的基本功能。
那么这个体系已经可以基本使用了。
那么在具体调用时，要创建最子类的对象，为什么呢？
一是因为有可能父类不能创建对象，
二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。

简而言之：查阅父类功能，创建子类对象使用功能。

示例代码：

package com.itheima.base;
/**
 * 继承
 * @author wuyong
 *
 */
public class ExtendsDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Father father1 = new Father();
		father1.show();
		Sun sun = new Sun();
		sun.show();
	}

}
/**
 * 父类Father
 * @author wuyong
 *
 */
class Father
{
	void show()
	{
		System.out.println("father");
	}
}
/**
 * 子类Sun，继承父类Father
 * @author wuyong
 *
 */
class Sun extends Father
{
	void show()
	{
		System.out.println("sun");
	}
	void print(){
		System.out.println("print");
	}
}
/**
 * java不支持多继承，所以以下是错误的。
 * @author wuyong
 *
 */
//class C extends A,B{}

子父类出现后，类成员的特点：

类中成员：

1,子父类中的变量

如果子类中出现非私有(private)的同名成员变量时，子类要访问本类中的变量，用this；
子类要访问父类中的同名变量，用super。

super的使用和this的使用几乎一致。

this代表的是本类对象的引用。

super代表的是父类对象的引用。

示例代码：

package com.itheima.base;

/**
 * 继承
 * @author wuyong
 *
 */
public class FieldDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Father father1 = new Father();
		Sun sun = new Sun();
		sun.show();
		sun.showName();
	}

}
/**
 * 父类Father
 * @author wuyong
 *
 */
class Father
{
	public String name = "Father";
	private int num = 4;
	public void setNum(int num)
	{
		this.num =num;
	}
	public int getNum()
	{
		return this.num;
	}
}
/**
 * 子类Sun，继承父类Father
 * @author wuyong
 *
 */
class Sun extends Father
{
	int num = 15;
	String name = "Sun";
	void show()
	{
		System.out.println(num);
	}
	void showName(){
		System.out.println("Father's name is " + super.name);
		System.out.println("Sun's name is " + this.name);
	}
}

2、子父类中的函数：

当子类出现和父类一模一样的函数时，

当子类对象调用该函数，会运行子类函数的内容。

如同父类的函数被覆盖一样。

这种情况是函数的另一个特性：重写(覆盖)

当子类继承父类，沿袭了父类的功能，到子类中，

但是子类虽具备该功能，但是功能的内容却和父类不一致，

这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。

覆盖：

      1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

      2，静态只能覆盖静态。

重载与重写的区别：

重载：只看同名函数的参数列表。

重写：子父类方法要一模一样。

示例代码：

package com.itheima.base;

/**
 * 继承
 * @author wuyong
 *
 */
public class MethodDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Father father1 = new Father();
		father1.speak();
		Father father2 = new Sun();
//		father2.show();//无法调用子类的show方法，所有子类没有重写父类的show方法。
		Sun sun = new Sun();
		sun.show();
		sun.speak();
	}

}
/**
 * 父类Father
 * @author wuyong
 *
 */
class Father
{
	/**
	 * 父类show方法
	 * 私有的方法无法被子类继承
	 */
	private int show()
	{
		System.out.println("Father's show");
	    return 1;
	}
	void speak()
	{	show();
		System.out.println("Father's speak");
	}
}
/**
 * 子类Sun，继承父类Father
 * @author wuyong
 *
 */
class Sun extends Father
{
	/**
	 * 重写了父类的方法
	 * /
	void speak()
	{
		 //调用父类的speak方法
	     super.speak();
	     System.out.println("Sun's speak");
	}
	/**
	 * 此方法并不是重写父类的方法，而是新的方法
	 */
	int show() //Zi中的show()无法覆盖Fu中的show()
	{
		System.out.println("Sun's show");
		return 0;
	}
}

3、子父类中的构造函数：

在对子类对象进行初始化时，父类的构造函数也会运行，

那是因为子类的构造函数默认第一行有一条隐式的语句 super();

super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();

为什么子类一定要访问父类中的构造函数？

因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。

所以子类在对象初始化时，要先访问一下父类中的构造函数。

如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。

注意：super语句一定定义在子类构造函数的第一行。

子类的实例化过程：

1.初始化父类的static成员。

2.初始化子类的static成员。

3.在栈和堆中定义子类变量并默认初始值，定义方法。

4.调用子类的构造方法运行了super()；

5.调用父类的构造方法并立即执行父类的构造代码块。

6.给父类的变量默认初始化，然后显示赋值。

7.父类构造方法继续运行，定义父类的属性和方法。
9.执行父类构造方法中其他语句（比如调用方法）。

10.执行子类的构造代码块

11.给子类变量赋值。

12.子类构造方法继续执行，定义子类的属性和方法。

13.再次给子类变量赋值。

14.执行子类构造方法中其他语句。

结论：

子类的所有的构造函数，默认都会访问父类中空参数的构造函数。

因为子类每一个构造函数内的第一行都有一句隐式super();

当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。

当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。

子类中至少会有一个构造函数会访问父类中的构造函数。

示例代码：

package com.itheima.base;

/**
 * 继承
 * @author wuyong
 *
 */
public class InstanceDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Father father1 = new Sun();
		father1 = new Sun(10);
	}

}
/**
 * 父类Father
 * @author wuyong
 *
 */
class Father
{
	 static String name = "Father";
	 static{
		 System.out.println("staticBlock == " + name);
	 }
	 int num = 5;
	 Father()
     {
         //super();
         num= 60;
         System.out.println("Father run");
     }
	 Father(int num)
     {
         System.out.println("Father ...." + this.num);
     }
}
/**
 * 子类Sun，继承父类Father
 * @author wuyong
 *
 */
class Sun extends Father
{
	 static String name = "Sun";
	 static{
		 System.out.println("staticBlock == " + name);
	 }
	 Sun()
     {
         super();  
         //super(4);
         System.out.println("Sun run");
     }
	 Sun(int num)
     {
		 //有了this()后，就没有super()了，因为this和super都必须是第一行数据，对对象进行初始化。
//         this();  
         //super();
         super(3);
         System.out.println("Sun..." + num);
     }
}

---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ ----------------------