Java面向对象--继承
1. 继承的概述
继承就是子类继承父类的变量和方法，下面用代码解释一下：
class Student {// 定义学生类
String name;
int age;
void study() {
System.out.println(name + "studay good" + age);
}
}
class Work {// 定义工人类
String name;
int age;
void work() {
System.out.println(name + "work good" + age);
}
}
从上述例子中可以看到，学生类和工人类都有共同的特征，为了实现代码复用性，进行抽取，java中抽取用类表示将共有的的行为或特征进行抽取，然后原来的来类也要可以用，我们就需要用原来类继承我们抽取的类，用extends关键字进行调用，如：
class Student extends Person {// 定义学生类
void study() {
System.out.println(name + "studay good" + age);
}
}
class Work extends Person {// 定义工人类
void work() {
System.out.println(name + "work good" + age);
}
}
class Person {// 定义我们抽取的类
String name;
int age;
}
通常称Person（被继承的类）类为父类（也叫操类，基类），称Work和Student（继承类）称为子类。
2. 继承的优点
- 提高代码复用性
- 让类与类产生关系，给多态提供了前提
- java支持单继承，不支持多继承，对C++多继承进行改良
单继承：一个子类只能有一个直接父类
class A {
}
class B {
}
class C extends A {
}
或者
class A {
}
class B {
}
class C extends B {
}
多继承：一个子类能有多个直接父类(为什么不能多继承)【不直接支持，会产生调用的不确定性】
class A {
void show() {
System.out.println(a);
}
}
class B {
void show() {
System.out.println(b);
}
}
class C extends A,B {
}
当我们new c();调用show方法，调用的是A的还是B的？为了区分java对此进行了改良，不用多继承，用接口
- java支持多层（多重继承）=>传递性
class A {
}
class B extends A {
}
class C extends B {
}
3. 类的继承原则
- 单继承
- 继承具有传递性
- 继承不能循环
- 除Object类，所有类都有父类
4. 继承的使用
当要使用一个继承体系时，如何使用 ?
- 查看该体系中顶层类，了解该体系的基本功能。
- 创建该体系中最子类的对象，完成功能的使用。
什么时候写继承？
当类存在所属关系，就定义继承，A属于B,则A继承B
5. 继承中的成员变量
当本类局部和成员变量名相同时用this区分
当子父类中成员变量相同时用super区分
this和super的用法很相似
this：代表一个本类对象的引用
super：代表一个父类空间
class A {
int num = 5;
}
class B extends A {
int num = 10;
void show() {
System.out.println(this.num + "……" + super.num);//调用子类和父类的成员变量
}
}
注意：子类不能直接访问父类的私有成员
6. 继承中的成员方法
class A {
int num = 5;
void show1() {
System.out.println(num);
}
}
class B extends A {
int num = 10;
void show2() {
System.out.println(num);
}
}
public class Extendstext {
public static void main(String[] args) {
B b = new B();
b.show1();
b.show2();
}
}
当子父类中函数一样，将会运行子类的函数，称为覆盖操作
class A {
int num = 5;
void show() {
System.out.println(num);
}
}
class B extends A {
int num = 10;
void show() {
System.out.println(num);
}
}
public class Extendstext {
public static void main(String[] args) {
B b = new B();
b.show();
}
}
6.1 函数的两个特性
- 重载：同一个类
- 覆盖：子类中，覆盖也叫重写
6.2 注意事项
- 子类的方法覆盖父类方法时，子类的权限必须大于父类的权限
- 静态只能覆盖静态，或被静态覆盖
6.3 什么时候使用覆盖操作
当对一个类进行子类扩展时，子类需要保留父类的功能声明，但要定义子类中功能的特有内容时，就用覆盖操作完成。(修改方法，添加功能)如：
class Phone {// 定义一个手机类
void call() {// 通话功能
}
void show() {// 展示功能
System.out.println("number");
}
}
class newphone extends Phone {
void show() {// 展示功能重写
System.out.println("name");
System.out.println("jpg");
System.out.println("number");
}
}
或者
class newphone extends Phone {
void show() {// 展示功能重写
System.out.println("name");
System.out.println("jpg");
super.show();//调用父类show方法
}
}
7. 继承中的构造函数
在子类构造对象时，访问子类构造函数时，父类也运行，在子类的构造函数中，有一个默认的隐士语句，super();调用父类中空参数的构造函数，无覆盖，无继承
无参数
class fu {
fu() {
System.out.println("fu run");
}
}
class zi extends fu {
zi() {
super();//隐士自带的调用父类空参数构造函数
System.out.println("zi run");
}
}
有参数
class fu {
fu(int x) {
System.out.println("fu run");
}
}
class zi extends fu {
zi() {
super(4);//隐士自带的调用父类空参数构造函数
System.out.println("zi run");
}
}
子类的实例化过程，子类中的每个构造函数都会访问父类中空参数的构造函数
- 结果：AC AD
public class Extendstext {
public static void main(String[] args) {
new zi();
new zi(6);
}
}
class fu {
fu(){
System.out.println("A");
}
fu(int x) {
System.out.println("B");
}
}
class zi extends fu {
zi() {
System.out.println("C");
}
zi(int x){
System.out.println("D");
}
}
- 结果：BD
public class Extendstext {
public static void main(String[] args) {
new zi(6);
}
}
class fu {
fu(){
System.out.println("A");
}
fu(int x) {
System.out.println("B");
}
}
class zi extends fu {
zi() {
System.out.println("C");
}
zi(int x){
super(x);//覆盖隐式super();
System.out.println("D");
}
}
为什么自子类实例化的时候，会调用父类构造方法？
子类继承父类，所以子类有父类的属性，在使用父类内容前，要先看父类如何对自己的内容进行初始化，所以子类构造函数初始化的时候，必须调用父类构造函数，所以在子类的构造函数默认加了super();
如果父类中没有定义无参构造函数或者说是父类中定义了有参，没有定义无参，那么必须用super();来指定调用父类的构造函数
如果子类的构造函数中使用了this();调用本类的构造函数，那么super();就没有了，因为super和this只能定义在第一行，所以只能有一个，但是可以保证的是，子类中肯定会有其他构造方法来访问父类的构造函数。
注意：super();语句必须要定义在子类构造函数的第一行，因为父类的初始化要先完成