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. 继承的使用

当要使用一个继承体系时，如何使用 ?

1. 查看该体系中顶层类，了解该体系的基本功能。
2. 创建该体系中最子类的对象，完成功能的使用。

什么时候写继承？

当类存在所属关系，就定义继承，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 函数的两个特性

1. 重载：同一个类
2. 覆盖：子类中，覆盖也叫重写

6.2 注意事项

1. 子类的方法覆盖父类方法时，子类的权限必须大于父类的权限
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");
	}
}

子类的实例化过程，子类中的每个构造函数都会访问父类中空参数的构造函数

1. 结果：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");
	}
}

2. 结果：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();语句必须要定义在子类构造函数的第一行，因为父类的初始化要先完成