📅  最后修改于: 2020-11-15 04:26:39             🧑  作者: Mango
继承可以定义为一个类获取另一类的属性(方法和字段)的过程。通过使用继承,信息可以按层次结构顺序进行管理。
继承其他属性的类称为子类(派生类,子类),其属性被继承的类称为超类(基类,父类)。
extend是用于继承类属性的关键字。以下是extended关键字的语法。
句法
class Super {
.....
.....
}
class Sub extends Super {
.....
.....
}
以下是演示Java继承的示例。在此示例中,您可以观察到两个类,即Calculation和My_Calculation。
使用extends关键字,My_Calculation继承了Calculation类的方法addition()和Subtraction()。
将以下程序复制并粘贴到名为My_Calculation.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类的对象时,将在其中创建超类内容的副本。这就是为什么使用子类的对象可以访问超类的成员的原因。
Superclass引用变量可以保存子类对象,但是使用该变量只能访问超类的成员,因此,要访问两个类的成员,建议始终创建该子类的引用变量。
如果考虑上述程序,则可以按如下所示实例化该类。但是,使用超类引用变量(在这种情况下为cal ),就无法调用方法multiplication() ,该方法属于子类My_Calculation。
Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);
注–子类从其超类继承所有成员(字段,方法和嵌套类)。构造函数不是成员,因此它们不会被子类继承,但是可以从子类中调用超类的构造函数。
super关键字与此关键字相似。以下是使用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;
// display method of superclass
public void display() {
System.out.println("This is the display method of superclass");
}
}
public class Sub_class extends Super_class {
int num = 10;
// display method of sub class
public void display() {
System.out.println("This is the display method of subclass");
}
public void my_method() {
// Instantiating subclass
Sub_class sub = new Sub_class();
// Invoking the display() method of sub class
sub.display();
// Invoking the display() method of superclass
super.display();
// printing the value of variable num of subclass
System.out.println("value of the variable named num in sub class:"+ sub.num);
// printing the value of variable num of superclass
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是一种说法:该对象是该对象的一种。让我们看看如何使用extend关键字实现继承。
public class Animal {
}
public class Mammal extends Animal {
}
public class Reptile extends Animal {
}
public class Dog extends Mammal {
}
现在,基于上面的示例,用面向对象的术语来说,以下是正确的-
现在,如果我们考虑IS-A关系,我们可以说-
通过使用extends关键字,子类将能够继承超类的所有属性,但超类的私有属性除外。
通过使用实例运算符,我们可以确保哺乳动物实际上是动物。
例
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 {
}
让我们使用instanceof运算符检查以确定哺乳动物是否实际上是动物,而狗实际上是动物。
例
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特定的事物。这种关系有助于减少代码重复和错误。
让我们看一个例子-
例
public class Vehicle{}
public class Speed{}
public class Van extends Vehicle {
private Speed sp;
}
这表明该类货车具有HAS-A Speed。通过为Speed设置单独的类,我们不必将属于speed的整个代码放入Van类中,这使得可以在多个应用程序中重用Speed类。
在面向对象的功能中,用户无需担心哪个对象正在执行实际工作。为此,Van类向Van类的用户隐藏了实现细节。因此,基本上会发生什么,就是用户会要求Van班级执行某些操作,而Van班级将自己完成工作或要求另一个班级执行操作。
继承有多种类型,如下所示。
要记住的一个非常重要的事实是Java不支持多重继承。这意味着一个类不能扩展一个以上的类。因此跟随是非法的-
例
public class extends Animal, Mammal{}
但是,一个类可以实现一个或多个接口,这帮助Java摆脱了多重继承的可能性。