JAVA 学习模块十一： 继承

1.基本形式和概念

/*
优点：
1.提高了代码的复用性
2.让类与类之间产生了关系，给第三个特征多态提供了前提

java 中支持单继承，不直接支持多继承，但对c++中的多继承机制进行了改良

单继承： 一个子类只有一个直接父类
多继承： 一个子类可以有多个直接父类（Java中不允许）
不支持是因为多个父类中有相同成员，会产生调用不确定性

java 支持多层（重）继承：
c继承b ，b继承a
就会出现继承体系

当要使用一个继承体系时：
1.查看该体系中的顶层类，了解该体系的基本功能
2.创建体系中的最子类的对象，完成功能的使用。

什么时候定义继承：

当类与类之间有所属关系时，就定义继承。

*/

class Peeson
{
String name;
int age;

}

class Student extends Person //继承
{
//  String name;
//  int age;
void study()
{
System.out.println(name +"st");

}

}

class Worker

{
String name;
int age;
void work()
{
System.out.println(name+ "wo");

}

}

class Extend

{
public static void main(String[] args)
{
Student s = new Student();
s.name = "zhangsan";
s.age=20;
s.student();

}

}

2.继承的具体使用

/*
在子父类中。成员的特点体现。
1.成员函数
2.成员变量
3.构造函数

*/

/*
当本类的成员和局部变量同名用this区分。
当子父类的成员变量同名用super区分父类。
this和super用法很相似:关键字

区别：
this 代表一个本类对象的引用
super： 代表一个父类的空间

*/
//成员变量
class Fu
{
private int num1 = 4;
public int getNum()
{
return num1;
}

}

class Zi extends Fu
{
//  int num2 =  5;
int num1 = 4;
void show()
{
System.out.println(this.num1+"..."+super.getNum());

}

}

class ExtendDemo
{
public static void main(String[] args)
{
Zi z = new Zi();
z.show();
}

}

//成员函数

/*
当子父类中出现成员函数一模一样的情况，会运行子类的函数。
这种现象称为覆盖操作。这是函数在子父类中的特性。
函数两个特性：1.重载（同一个类中）/重写/覆写 2. 覆盖（子类中）

覆盖注意事项：
1.子类覆盖父类方法时，子类权限必须大于等于父类权限。（public private修饰的不可覆盖）
2.静态只能覆盖静态或者被静态覆盖。

什么时候使用覆盖：

*/
class Fu1
{
void show1()
{
System.out.println("fu show run");
}

}

class Zi extends Fu
{

void show1()
{
System.out.println("zi show run");
}
}

class ExtendsDemo3
{

public static void main(String[] args)
{
Zi z = new Zi();
z.show1();
z.show2();

}
}

/*
什么时候使用覆盖:
当对一个类进行子类的扩展时，子类需要保留父类的功能声明。
但是要定义子类中标特有的功能时，就要用覆盖操作完成。

*/

class Phone
{
void show()
{
System.out.println("number");
}

}

class NewPhone extends Phone
{
void show()
{
System.out.println("name");
//      System.out.println("number");
super.show();

}

}

/*子父类中的构造函数的特点

在子类构造对象时，发现在访问子类构造函数时，父类也就运行了。
原因是：
在子类的构造函数中第一行有个默认的隐式语句。super（）

构造函数不可覆盖，不可继承

为什么子类实例化的时候要访问父类中的构造函数：
那是因为子类继承了父类，获取到了父类中的内容（属性），所以在使用父类内容之前，要先看父类是如何对自己的
内容进行初始化的。所以子类在完成构造函数时，必须访问父类中的构造函数。
为了完成必须的动作，就在子类构造函数中加了 super（）语句。

如果父类中没有定义空参数构造函数，那么子类的构造函数，必须用super明确调用父类中的那个构造函数。
同时子类构造函数中如果使用了this调用了本类构造函数时，那么super 就没有了因为 super 和 this 都只能定义在第一行，所以只能有一个。但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数（构造函数可以有多个）。、
注意：super语句必须要定义在子类构造函数的第一行。因为父类的初始化动作要先完成。

*/

class Fu1
{
Fu()
{
System.out.println("zi show run");
}

}

class Zi extends Fu
{

Zi()
{
//super(); 调用的就是父类中的空参数的调用涵数。
//如果不是空参，那么就用  super（参数） 的形式
System.out.println("zi show run");
}
}

class ExtendsDemo4
{

public static void main(String[] args)
{
new Zi();

}
}

3.一个对象实例化的过程

/*
一个对象实例化的过程

Person p = new Person();

1. jvm 会读取指定的路径下的 Person.class 文件，并加载进内存，并会
先加载 Person 的父类（如果有父类的情况下）
2.在堆内存中开辟空间，分配地址
3.并在对象空间中，对对象中的属性进行默认初始化。
4.调用对应的构造函数进行初始化
5.在构造函数中，第一行会先调用父类中的构造函数进行初始化
6.父类初始化完毕后，再对子类的属性进行显示初始化
7.再进行子类构造函数的特定初始化
8.初始化完毕后，将地址值付给引用变量
9.

*/