Java知识总结-继承

<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">通过提取不同类的共性，并进行单独描述，作为一个新的类。</span>

例如，下面有两个类：学生类，工人类；

class Student{
String name;
int age;
void study(){
System.out.println("学生要学习");
}
}
class Worker{
String name;
int age;
void work(){
System.out.println("工人要工作");
}
}

很明显这两个类具有明显的共性，现在将这些共性提取出来作为一个新的类：人类：

class Person{
String name;
int age;
}

接着让学生类和工人类与新的类通过继承联系起来；

class Student extends Person{
void study(){
System.out.println("学生要学习");
}
}
class Worker extends Person{
void work(){
System.out.println("工人要工作");
}
}

当学生类和工人类继承Person类后，就可以直接使用Person类中的成员，所以不需要再定义这些成员。例：

从上面的例子可以看出继承的特点：

1.提高了代码的复用性；

2.让类与类之间产生了关系；

注意：继承的前提是类与类之间存在所属关系，不能为了获取其他类的功能和简化代码而继承。

二：

Java中只支持单继承，不支持多继承。

class A{
void show(){
System.out.println("A");
}
}
class B{
void show(){
System.out.println("B");
}
}

当一个类C同时继承上面两个类A和B时，

class C extends A,B{

}

当调用C的 show方法时，子类对象无法确定运行那个父类的show方法。

同时Java支持多层次的继承。

如：子类继承父类，父类还有自己的父类……例：

class A{

}
class B extends A{

}
class C extends B{

}
class D extends C{

}

这样就会形成一个继承体系。如何使用一个继承体系中的功能呢？

想要使用一个继承体系，先查询该父类的描述，父类中定义的是该体系的共性功能；

通过了解共性功能，就可以找到该体系的基本功能。那么这个体系就基本可以使用了；

再具体调用时，要创建最子类的对象；

因为父类有可能是不能创建对象，如抽象类。而且创建子类对象可以使用更多的功能，包括父类功能和子类功能。

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

三：

子父类中成员的调用特点：

1.变量

当子父类出现非私有同名变量时，子类对象访问本类中的变量时用this，此时this可省略；

子类对象访问父类中的变量时用super。

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

this代表本类对象的引用；

super代表父类对象的引用。

class Fu{
int num=2;
}
class Zi extends Fu{
int num=3;
void show(){
System.out.println(this.num); //结果为3.
}
}

此时的this可以省略。

class Fu{
int num=2;
}
class Zi extends Fu{
int num=3;
void show(){
System.out.println(num);//省略this后结果仍为3
System.out.println(super.num);//结果为2.
}
}

另，当子父类中变量不同名时，子类对象可以直接访问父类变量。

class Fu{
int num=3;
}
class Zi extends Fu{
int num2=7;
void show(){
System.out.println(num);//结果为3，此时访问父类变量可省略super
}
}

2.子父类中函数

当子父类出现一模一样的函数时，当子类对象调用该函数，运行子类函数的内容。这种情况叫做函数的覆盖。

覆盖：当子类继承父类，沿袭了父类的功能到子类中，当子类具备该功能，但功能内容和父类不一致时，没有必要定义新功能，而是使用覆盖特性，保留父类的功能定义，并重写功能内容。

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

            2.，静态不能覆盖非静态。

例：

class Fu{
void show(){
System.out.println("父类方法");
}
}
class Zi extends Fu{
void show(){
System.out.println("子类方法");
}
}
public class Test {
public static void main(String[] args) {
Zi z=new Zi();
z.show();
}
}

运行结果：

子类方法

此时也可以通过super关键词在子类中直接调用父类被覆盖的函数。

class Fu{
void show(){
System.out.println("父类方法");
}
}
class Zi extends Fu{
void show(){
System.out.println("子类方法");
}
void print(){
super.show();//调用父类被覆盖函数
}
}
public class Test {
public static void main(String[] args) {
Zi z=new Zi();
z.print();
}
}

运行结果

父类方法

在子类函数中通过super调用父类函数，可以实现子类函数在父类函数的基础上进行扩展。例如：

class Fu{
void show(){
System.out.println("父类原有功能");
}
}
class Zi extends Fu{
void show(){
super.show();
System.out.println("子类扩展功能");
}

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

运行结果：

父类原有功能
子类扩展功能

注：当父类函数私有化时，子类没有覆盖父类的函数。

3.子父类中构造函数的特点

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

因为子类的构造函数默认第一行有一条隐式语句super（）；

super（）会访问父类中空参数的构造函数，而且子类所有构造函数默认第一行都是super（）；

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

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

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

只有子类才有super();

构造函数里面只能有一个隐式语句，如果有了super();，就不能在有this();

结论：

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

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

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

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

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

class Fu{
Fu(){
System.out.println("a");
}
}
class Zi extends Fu{
Zi(){
System.out.println("b");
}
}
public class Test {
public static void main(String[] args) {
Zi z=new Zi();
}
}

运行结果：

a
b

从运行结果可以看出，在初始化子类对象时，父类也进行了初始化，并且是在子类之前。

class Fu{
Fu(){
System.out.println("a");
}
}
class Zi extends Fu{
Zi(){
System.out.println("b");
}
Zi(int x){
System.out.println("c");
}
Zi(int x,int y){
System.out.println("d");
}
}
public class Test {
public static void main(String[] args) {
Zi z1=new Zi();
Zi z2=new Zi(3);
Zi z3=new Zi(3,5);
}
}

运行结果：

a
b
a
c
a
d

从上面例子的结果可以看书，子类所有的构造函数都调用了父类的构造函数。即默认隐式存在语句super（）。

当父类没有空参数的构造函数时，子类构造函数默认的super（）就没有调用对象了，所以这时需要手动指定父类构造函数,例：

class Fu{
Fu(int x){
System.out.println("a");
}
}
class Zi extends Fu{
Zi()
4000
{
super(3);//访问父类指定构造函数
System.out.println("b");
}
Zi(int x){
this();//访问本类空参数构造函数，并通过本类空参数函数访问父类构造函数。
System.out.println("c");
}

}
public class Test {
public static void main(String[] args) {
Zi z1=new Zi();
Zi z2=new Zi(3);
}
}

运行结果：

a
b
a
b
c

当一个继承体系中，一个类B及其父类A都具有同一函数，类B中的函数覆盖了其父类A的函数，当一个新的类C继承类B并调用这个函数时，访问的是类C的父类B中的函数，例：

class A{
void show(){
System.out.println("A");
}
}
class B extends A{
void show(){
System.out.println("B");
}
}
class C extends B{

}
public class Test {
public static void main(String[] args) {
C c=new C();
c.show();
}
}

运行结果

B

所以在多重继承中，如果一个类的父类，父类的父类都有同一函数，则继承最近父类中函数。

四：

final关键字

final可以修饰类，方法，变量。

1.被final修饰的类不可以被继承。例：

final class Fu{
void show(){
System.out.println("父类");
}
}
class Zi extends Fu{
void show(){
System.out.println("子类");
}
}

当一个类继承被final修饰的类时，编译会报错。

2.被final修饰的方法不可以被覆盖。例：

class Fu{
final void show(){
System.out.println("父类");
}
}
class Zi extends Fu{
void show(){
System.out.println("子类");
}
}
public class Test {
public static void main(String[] args) {
Zi z=new Zi();
z.show();//报错
}
}

3.被final修饰的变量时常量，其该变量只能被赋值一次，final可以修饰成员变量和局部变量。

public class Test {
public static void main(String[] args) {
final int X=44;
X=33;
System.out.println("x="+x);
}
}

编译器报错