java字类与继承

一、Java子类与父类

继承就是一种由已有的类创建新类的机制，利用继承，我们可以先定义一个共有属性的一般类，根据该一般类再定义具有特殊属性的子类，子类继承一般类的属性和行为，并根据需要增加它自己的新的属性和行为。由继承而得到的类称为子类，被继承的类称为父类(超类)。

注意：

Java不支持多重继承，即子类只能有一个父类，人们习惯地称子类与父类的关系是“is-a”关系。

在类的声明中，通过使用关键字extends来定义一个类的子类，一般格式为：

class 子类名 extends 父类名 {
    …
}

例如：

class Student extends People {
    …
}

把Student类定义为People类的子类，People类是Student类的父类(超类)。

类的树形结构：

如果C是B的子类，B又是A的子类，习惯上称C是A的子孙类。Java的类按继承关系形成树形结构（将类看做树上的结点），在这个树形结构中，根结点是Object类（Object是java.lang包中的类），即Object是所有类的祖先类。任何类都是Object类的子孙类，每个类（除了Object类）有且仅有一个父类，一个类可以有多个或零个子类。

注意：

如果一个类（除了Object类）的声明中没有使用extends关键字，这个类被系统默认为是Object的子类。例如：类声明“class A”与“class A extends Object”是等同的。

二、Java子类的继承性

类有两种重要的成员：成员变量和方法。子类的成员中有一部分是子类自己声明定义的，另一部分是从它的父类继承的。子类继承父类的成员变量作为自己的一个成员变量，就好像该成员变量是在子类中直接声明一样，可以被子类中自己定义的任何实例方法操作。子类继承父类的方法作为自己的一个方法，就好像该方法是在子类中直接定义一样，可以被子类中自己定义的任何实例方法调用。

子类和父类在同一包中的继承性：

如果子类和父类在同一个包中，那么子类自然地继承了其父类中不是private的成员变量作为自己的成员变量，并且也自然地继承了父类中不是private的方法作为自己的方法，继承的成员变量或方法的访问权限保持不变。

子类和父类不在同一包中的继承性：

如果子类和父类不在同一个包中，父类中的private和友好访问权限的成员变量不会被子类继承，即子类只继承父类中的protected和public访问权限的成员变量和方法作为子类的成员变量和方法。

关于protected的进一步说明：

一个类A中的protected成员变量和方法可以被它的子孙类继承，比如B是A的子类，C是B的子类，D又是C的子类，那么B、C和D类都继承了A类的protected成员变量和方法。

如果用D类在D本身中创建了一个对象，那么该对象总是可以通过“.”运算符访问继承的或自己定义的protected变量和protected方法，但是，如果在另外一个类中，比如在Other类中用D类创建了一个对象object,该对象通过“.”运算符访问protected变量和protected方法的权限如下所述：

1. 对于子类D自己声明的protected成员变量和方法，只要Other类和D类在同一个包中，object对象就可以访问这些protected成员变量和方法。

2. 对于子类D从父类继承的protected成员变量或protected方法，需要追溯到这些protected成员变量或方法所在的“祖先”类，比如可能是A类，只要Other类和A类在同一个包中，object对象就能访问继承的protected变量和protected方法。

三、Java子类与对象

当用子类的构造方法创建一个子类的对象时，不仅子类中声明的成员变量被分配了内存，而且父类的成员变量也都分配了内存空间，但只将子类继承的那部分成员变量作为分配给子类对象的变量。

也就是说，父类中的private成员变量尽管分配了内存空间，也不作为子类对象的变量；同样，如果子类和父类不在同一包中，尽管父类的友好成员变量分配了内存空间，但也不作为子类对象的变量。

此时，我们或多或少觉得子类创建对象时似乎浪费了一些内存。这是因为当用子类创建对象时，父类的成员变量也都分配了内存空间，但只将其中一部分作为分配给子类对象的变量。比如：父类中的private成员变量尽管分配了内存空间，也不作为子类对象的变量，当然他们也不是父类某个对象的变量，因为我们根本就没有使用父类创建任何对象。但是，我们要注意到，子类中还有一部分方法是从父类继承的，这部分方法却可以操作这部分未继承的变量。

例如：子类ChinaPeople的对象调用继承的方法操作未被子类继承却分配了内存空间的变量。

class People {
    private int averHeight = 168;
    public int getAverHeight() {
        return averHeight;
    }
}
class ChinaPeople extends People {
    int height;
    public void setHeight(int h) {
        //height = h+averHeight; //非法，子类没有继承averHeight
        height = h;
    }
    public int getHeight() {
        return height;
    }
}
public class Main
    public static void main(String args[]) {
        ChinaPeople zhangSan = new ChinaPeople();
        System.out.println("子类对象未继承的averageHeight的值是:"+zhangSan.getAverHeight ());
        zhangSan.setHeight(180);
        System.out.println("子类对象的实例变量height的值是:"+zhangSan.getHeight());
    }

四、Java成员变量的隐藏和方法重写

在编写子类时，我们仍然可以声明成员变量，一种特殊的情况就是，所声明的成员变量的名字和从父类继承来的成员变量的名字相同，声明的类型可以不同，在这种情况下，子类就会隐藏所继承的成员变量。

子类隐藏继承的成员变量的特点如下：

(1)子类对象以及子类自己定义的方法操作与父类同名的成员变量是指子类重新声明的这个成员变量。

(2)子类对象仍然可以调用从父类继承的方法操作被子类隐藏的成员变量，也就是说，子类继承的方法所操作的成员变量一定是被子类继承或隐藏的成员变量。

注意：
子类继承的方法只能操作子类继承和隐藏的成员变量。子类新定义的方法可以操作子类继承和子类新声明的成员变量，但无法操作子类隐藏的成员变量。

子类通过重写可以隐藏已继承的方法，方法重写也称为方法覆盖。如果子类可以继承父类的某个方法，那么子类就有权利重写这个方法。方法重写是指子类中定义一个方法，这个方法的类型和父类的方法的类型一致或者是父类的方法的类型的子类型，并且这个方法的名字、参数个数、参数的类型和父类的方法完全相同。子类如此定义的方法称作子类重写的方法，不属于新增的方法。

子类通过方法的重写可以隐藏继承的方法，并把父类的状态和行为改变为自身的状态和行为。如果父类的方法f()可以被子类继承，子类就有权利重写f()，一旦子类重写了父类的方法f(),就隐藏了继承的方法f(),那么子类对象调用方法f()一定调用的是重写方法f()。如果子类没有重写，而是继承了父类的方法f()，那么子类创建的对象当然可以调用f()方法，只不过方法f()产生的行为和父类的相同而已。

重写方法既可以操作继承的成员变量、调用继承的方法，也可以操作子类新声明的成员变量、调用新定义的其他方法，但无法操作被子类隐藏的成员变量和方法。如果子类想使用被隐藏的方法或成员变量，必须使用关键字super。

注意：

重写父类的方法时，不允许降低方法的访问权限，但可以提高访问权限，访问限制修饰符按访问权限从高到低的排列顺序是：public、protected、友好的、private。例如：子类重写父类的方法f,该方法在父类中的访问权限是protected级别，子类重写时不允许级别低于protected。

五、Java super关键字

用super操作被隐藏的成员变量和方法

子类一旦隐藏了继承的成员变量，那么子类创建的对象就不再拥有该变量，该变量将归关键字super所拥有，同样子类一旦隐藏了继承的方法，那么子类创建的对象就不能调用被隐藏的方法，该方法的调用由关键字super负责。因此，如果在子类中想使用被子类隐藏的成员变量或方法就需要使用关键字super。

注意：

当super调用被隐藏的方法时，该方法中出现的成员变量是被子类隐藏的成员变量或继承的成员变量。

用super调用父类的构造方法

当用子类的构造方法创建一个子类的对象时，子类的构造方法总是先调用父类的某个构造方法，也就是说，如果子类的构造方法没有明显地指明使用父类的哪个构造方法，子类就调用父类的不带参数的构造方法。

由于子类不继承父类的构造方法，因此，子类在其构造方法中需使用super来调用父类的构造方法，而且super必须是子类构造方法中的头一条语句，即如果在子类的构造方法中，没有明显地写出super关键字来调用父类的某个构造方法，那么默认地有：

super ();

六、Java final关键字

final关键字可以修饰类、成员变量和方法中的局部变量。可以使用关键字final将类声明为final类，final类不能被继承，即不能有子类。

例如：

final class A {
…
}

A就是一个final类，将不允许任何类声明成A的子类。一般是出于安全性考虑将一些类修饰为final类。例如：Java在java.lang包中提供的String类对于编译器和解释器的正常运行有很重要的作用，Java不允许用户程序扩展String类，为此Java将它修饰为final类。

如果用final修饰父类中的一个方法，那么这个方法不允许子类重写，也就是说，不允许子类隐藏可以继承的final方法。

如果成员变量或局部变量被修饰为final,那它就是常量。由于常量在运行期间不允许再发生变化，所以常量在声明时没有默认值，这就要求程序在声明常量时必须指定该常量的值。

七、Java对象的上转型对象

我们知道老虎是动物，若动物类是老虎类的父类，需要注意的是，当说老虎是动物时，老虎将失掉老虎独有的属性和功能。从人的思维方式上看，说“老虎是动物”属于上溯思维方式，这种思维方式和Java语言中的上转型对象类似。

假设Animal类是Tiger类的父类，当用子类创建一个对象，并把这个对象的引用放到父类的对象中时，例如：

Animal a;
a = new Tiger();
或
Animal a;
Tiger b=new Tiger();
a = b;

这时称对象a是对象b的上转型对象，就好比说“老虎是动物”。 对象的上转型对象的实体是子类负责创建的，但上转型对象会失去原对象的一些属性和功能。

上转型对象具有如下特点：

(1)上转型对象不能操作子类新增的成员变量，不能调用子类新增的方法。

(2)上转型对象可以访问子类继承或隐藏的成员变量，也可以调用子类继承的方法或子类重写的实例方法。上转型对象操作子类继承的方法或子类重写的实例方法，其作用等价于子类对象去调用这些方法。因此，如果子类重写了父类的某个实例方法后，当对象的上转型对象调用这个实例方法时一定是调用了子类重写的实例方法。

注意：

(1)不要将父类创建的对象和子类对象的上转型对象混淆。

(2)可以将对象的上转型对象再强制转换到一个子类对象，这时，该子类对象又具备了子类所有的属性和功能。

(3)不可以将父类创建的对象的引用赋值给子类声明的对象，例如：不能说“人是中国人”。

八、Java继承与多态

我们都知道“哺乳动物有很多种叫声”，比如：“吼”“嚎”“汪汪”“喵喵”等等，这就是叫声的多态。

那么当一个类有很多子类时，并且这些子类都重写了父类中的某个方法，当我们把子类创建的对象的引用放到一个父类的对象中时，就得到了该对象的一个上转型对象，此时，这个上转型对象在调用这个方法时就可能具有多态，因为不同的子类在重写父类的方法时可能产生不同的行为。

比如：狗类的上转型对象调用“叫声”方法时产生的行为是“汪汪”，而猫类的上转型对象调用“叫声”方法时产生的行为是“喵喵”等等。

多态性就是指父类的某个方法被其子类重写时，可以各自产生自己的功能行为。

例如：

class 动物 {
    void cry() {
    }
}
class 狗 extends 动物 {
    void cry() {
        System.out.println("wangwang");
    }
}
class 猫 extends 动物 {
    void cry() {
        System.out.println("miaomiao");
    }
}
public class Main {
    public static void main(String args[]) {
        动物 animal;
        animal = new 狗();
        animal.cry();
        animal = new 猫();
        animal.cry();
    }
}

九、Java abstract类和abstract方法

1. abstract类

我们把用关键字abstract修饰的类称作abstract类，即抽象类，例如：

abstract class A {
    …
}

2. abstract方法

我们把用关键字abstract修饰的方法称作abstract方法，即抽象方法，例如：

abstract int max(int x,int y);

注意：
1）对于abstract方法，只允许声明，不允许实现，即没有方法体，而且不允许使用final和abstract同时修饰一个方法或类，也不允许使用static修饰abstract方法，即abstract方法必须是实例方法。

2）abstract类中可以有abstract方法，也可以有非abstract方法，而非abstract类中不可以有abstract方法。

例如：A类中的max()方法是abstract方法，min()方法是普通方法（非abstract方法）。

abstract class A {
    abstract int max(int x,int y);
    int min(int x,int y) {
        return x<y?x:y;
    }
}

对于abstract类，不能使用new运算符创建该类的对象，如果一个非abstract类是某个abstract类的子类，那么它必须重写父类的抽象方法，并给出方法体，这也就是不允许使用final和abstract同时修饰一个方法或类的原因。

我们可以使用abstract类声明对象，尽管不能使用new运算符创建该对象，但是该对象可以成为其子类对象的上转型对象，这样该对象就可以调用子类重写的方法。

注意：abstract类可以没有abstract方法，如果一个abstract类是abstract类的子类，那么它既可以重写父类的abstract方法，也可以继承父类的abstract方法。

此章节的学习会让你了解java类中类的继承和如何正确的调用。

学习来自“https://www.dotcpp.com”

总结

阅读和友谊拯救我们日益衰败的心灵。
我一直觉得送一本书是把自己的灵魂碎片送给朋友。如果能获得共鸣，那实在是人生一大幸事！