Java 继承
在Java编程中，继承是Java面向对象程序的一个重要概念。继承是一个类获取另一个类的属性（方法和属性）的过程。通过使用继承，信息可以按层次顺序进行管理。
继承其他类的属性的类称为子类（派生类、子类），而继承其属性的类则称为超类（基类、父类）。
Java 继承的需要
- 代码可重用性:继承的基本需求是重用这些功能。如果您曾经定义过某些功能，则通过使用继承，您可以轻松地在其他类和包中使用它们。
- 扩展性:继承有助于扩展类的功能。如果您有一个具有某些功能的基类，则可以通过使用派生类中的继承来扩展它们。
- 方法重写的植入:需要继承来实现以下功能之一:多态性的概念，即方法重写。
- 实现抽象:OOP 的另一个概念是抽象，也需要继承。
Java 继承的实现
要在Java中实现（使用）继承，需要使用extends关键字。它将基类的属性（属性或/和方法）继承给派生类。 "extends"一词的意思是扩展功能，即功能的可扩展性。
实现继承的语法
考虑以下在 Java 中实现（使用）继承的语法:
class Super {
.....
.....
}
class Sub extends Super {
.....
.....
} Java 继承示例
以下是演示 Java 继承的示例。在这个例子中，你可以观察到两个类，即Calculation和My_Calculation。
使用extends关键字，My_Calculation继承了Calculation类的addition()和Subtraction()方法。
将以下程序粘贴到名为 My_Calculation.java 的文件中
实现继承的 Java 程序
class Calculation {
int z;
public void addition(int x, int y) {
z = x + y;
System.out.println("The sum of the given numbers:"+z);
}
public void Subtraction(int x, int y) {
z = x - y;
System.out.println("The difference between the given numbers:"+z);
}
}
public class My_Calculation extends Calculation {
public void multiplication(int x, int y) {
z = x * y;
System.out.println("The product of the given numbers:"+z);
}
public static void main(String args[]) {
int a = 20, b = 10;
My_Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);
demo.multiplication(a, b);
}
} 编译并执行上述代码，如下所示。
javac My_Calculation.java
java My_Calculation 执行程序后，将产生以下结果 -
输出
The sum of the given numbers:30
The difference between the given numbers:10
The product of the given numbers:200 在给定的程序中，当一个对象My_Calculation 创建类，并在其中创建超类内容的副本。这就是为什么，使用子类的对象可以访问超类的成员。
超类引用变量可以保存子类对象，但使用该变量只能访问超类的成员，因此要访问这两个类的成员，建议始终创建子类的引用变量。
如果您考虑上面的程序，您可以实例化该类，如下所示。但是使用超类引用变量（本例中为 cal），您无法调用属于子类 My_Calculation 的方法 multiplication()。
Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b); 注意 - 子类继承其超类的所有成员（字段、方法和嵌套类）。构造函数不是成员，因此它们不会被子类继承，但可以从子类调用超类的构造函数。
Java 继承:super 关键字
super 关键字与 this 关键字类似。以下是使用 super 关键字的场景。
用于区分超类的成员和子类的成员，如果它们具有相同的名称。
它用于从子类调用超类构造函数。
区分成员
如果一个类继承了另一个类的属性。如果超类的成员与子类的名称相同，为了区分这些变量，我们使用 super 关键字，如下所示。
super.variable
super.method(); 示例代码
本节为您提供演示 super 关键字用法的程序。
在给定的程序中，您有两个类，即 Sub_class 和 Super_class，两者都有一个名为 display() 且具有不同实现的方法，以及一个名为 num 且具有不同值的变量。我们调用两个类的 display() 方法并打印两个类的变量 num 的值。在这里您可以看到，我们使用了 super 关键字来区分超类和子类的成员。
将程序复制并粘贴到名为 Sub_class.java 的文件中。
示例
class Super_class {
int num = 20;
//超类的显示方法
public void display() {
System.out.println("This is the display method of superclass");
}
}
public class Sub_class extends Super_class {
int num = 10;
//子类的显示方法
public void display() {
System.out.println("This is the display method of subclass");
}
public void my_method() {
//实例化子类
Sub_class sub = new Sub_class();
//调用子类的display()方法
sub.display();
//调用超类的display()方法
super.display();
//打印子类变量num的值
System.out.println("value of the variable named num in sub class:"+ sub.num);
//打印超类变量num的值
System.out.println("value of the variable named num in super class:"+ super.num);
}
public static void main(String args[]) {
Sub_class obj = new Sub_class();
obj.my_method();
}
} 使用以下语法编译并执行上述代码。
javac Super_Demo
java Super 执行程序时，您将得到以下结果 -
输出
This is the display method of subclass
This is the display method of superclass
value of the variable named num in sub class:10
value of the variable named num in super class:20 调用超类构造函数
如果一个类继承另一个类的属性，子类会自动获取超类的默认构造函数。但如果要调用超类的参数化构造函数，则需要使用 super 关键字，如下所示。
super(values); 示例代码
本节给出的程序演示了如何使用 super 关键字来调用超类的参数化构造函数。该程序包含一个超类和一个子类，其中超类包含一个接受整数值的参数化构造函数，我们使用 super 关键字来调用超类的参数化构造函数。
复制并粘贴以下程序在名为 Subclass.java 的文件中
示例
class Superclass {
int age;
Superclass(int age) {
this.age = age;
}
public void getAge() {
System.out.println("The value of the variable named age in super class is: " +age);
}
}
public class Subclass extends Superclass {
Subclass(int age) {
super(age);
}
public static void main(String args[]) {
Subclass s = new Subclass(24);
s.getAge();
}
} 使用以下语法编译并执行上述代码。
javac Subclass
java Subclass 输出
The value of the variable named age in super class is: 24 IS-A 关系
IS-A 是一种表达方式:此对象是该对象的一种类型。让我们看看如何使用 extends 关键字来实现继承。
public class Animal {
}
public class Mammal extends Animal {
}
public class Reptile extends Animal {
}
public class Dog extends Mammal {
} 现在，基于上面的示例，用面向对象的术语来说，以下内容正确 -
- Animal 是 Mammal 类的超类。
- Animal 是 Reptile 类的超类。
- Mammal 和 Reptile 是 Animal 类的子类.
- Dog 是 Mammal 类和 Animal 类的子类。
现在，如果我们考虑 IS-A 关系，我们可以说 -
- 哺乳动物是动物
- 爬行动物是动物
- 狗是哺乳动物
- 因此:狗是动物也是哺乳动物
通过使用extends关键字，子类将能够继承超类的所有属性，除了超类的私有属性之外。
通过使用实例运算符，我们可以确保 Mammal 实际上是 Animal。
示例
class Animal {
}
class Mammal extends Animal {
}
class Reptile extends Animal {
}
public class Dog extends Mammal {
public static void main(String args[]) {
Animal a = new Animal();
Mammal m = new Mammal();
Dog d = new Dog();
System.out.println(m instanceof Animal);
System.out.println(d instanceof Mammal);
System.out.println(d instanceof Animal);
}
} 输出
true
true
true 既然我们对extends关键字有了很好的了解，那么让我们看看implements关键字是如何用于获取IS-A关系的。
通常，implements 关键字与类一起使用来继承接口的属性。接口永远不能由类扩展。
示例
public interface Animal {
}
public class Mammal implements Animal {
}
public class Dog extends Mammal {
} Java 继承:instanceof 关键字
让我们使用 instanceof 运算符来检查确定 Mammal 是否实际上是 Animal，而狗是否实际上是 Animal。
示例
interface Animal{}
class Mammal implements Animal{}
public class Dog extends Mammal {
public static void main(String args[]) {
Mammal m = new Mammal();
Dog d = new Dog();
System.out.println(m instanceof Animal);
System.out.println(d instanceof Mammal);
System.out.println(d instanceof Animal);
}
} 输出
true
true
true HAS-A 关系
这些关系主要基于用法。这决定了某个类是否HAS-A某个东西。这种关系有助于减少代码重复和错误。
让我们看一个示例 -
示例
public class Vehicle{}
public class Speed{}
public class Van extends Vehicle {
private Speed sp;
} 这表明类 Van HAS-A速度。通过为 Speed 建立一个单独的类，我们不必将属于 speed 的整个代码放入 Van 类中，这使得在多个应用程序中重用 Speed 类成为可能。
在面向对象中功能，用户无需关心哪个对象正在做真正的工作。为了实现这一点，Van 类向 Van 类的用户隐藏了实现细节。因此，基本上发生的情况是用户要求 Van 类执行某个操作，而 Van 类将自行完成该工作或要求另一个类执行该操作。
Java 继承的类型
在Java中，继承主要有单一、多级、层次化三种类型。 Java 不支持多重和混合继承。
要记住的一个非常重要的事实是 Java 不支持多重继承和混合继承。这意味着一个类不能扩展多个类。因此以下内容是非法的 -
1。 Java单继承
只有一个基类和一个派生类的继承称为单继承。单一（或单级）继承仅将数据从一个基类继承到一个派生类。
Java 单继承示例
class One {
public void printOne() {
System.out.println("printOne() method of One class.");
}
}
public class Main extends One {
public static void main(String args[]) {
//创建派生类的对象(Main)
Main obj = new Main();
//调用方法
obj.printOne();
}
} 输出
printOne() method of One class. 2. Java 多级继承
将基类继承到派生类，然后将该派生类进一步继承到另一个派生类的继承称为多级继承。多级继承涉及多个基类。
Java 多级继承示例
class One {
public void printOne() {
System.out.println("printOne() method of One class.");
}
}
class Two extends One {
public void printTwo() {
System.out.println("printTwo() method of Two class.");
}
}
public class Main extends Two {
public static void main(String args[]) {
// 创建派生类的对象（Main）
Main obj = new Main();
//调用方法
obj.printOne();
obj.printTwo();
}
} 输出
printOne() method of One class.
printTwo() method of Two class. 3. Java 层次继承
只有一个基类和多个派生类的继承称为层次继承。
Java 层次继承示例
//基类
class One {
public void printOne() {
System.out.println("printOne() Method of Class One");
}
}
//派生类1
class Two extends One {
public void printTwo() {
System.out.println("Two() Method of Class Two");
}
}
//派生类2
class Three extends One {
public void printThree() {
System.out.println("printThree() Method of Class Three");
}
}
//测试类
public class Main {
public static void main(String args[]) {
Two obj1 = new Two();
Three obj2 = new Three();
//所有类都可以访问类一的方法
obj1.printOne();
obj2.printOne();
}
} 输出
printOne() Method of Class One
printOne() Method of Class One 示例
public class extends Animal, Mammal{} 但是，一个类可以实现一个或多个接口，这帮助Java摆脱了多重继承的不可能性。