——继承与多态
---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------
继承
继承是面对对象的三大特征之一，也是实现多态的方式之一。
一个类继承另一个类的时候，可以继承除了构造函数以外的所有类成员。
继承的优缺点：
继承的优点：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。
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);
}
}
---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------