10-Java中什么是继承以及如何实现它

咬到舌头的小蛇

2024-01-15

Java

欢迎来到百战百胜！我们致力于为广大IT从业者、学生和爱好者提供全面、实用的资源和服务。加入我们的聊天群，这里有专业大佬为你提供有价值的建议和指导！

作为世界上使用最广泛的编程语言之一，Java具有许多强大的功能。Java中的继承是面向对象概念和Java的核心主题之一。它使开发人员能够将数据成员和属性从一个类继承到另一个类。

Java中的继承是什么?

继承是Java中的面向对象编程概念之一。继承允许从一个类到另一个类获取数据成员和属性。

组成继承数据成员和属性过程的组件如下：

基类(父类)

基类以替代词的形式提供数据成员和方法。任何需要方法或数据成员的基类都必须从它们各自的父类或基类中借用它们。

子类(子类)

子类也称为子类。其父类的实现将重新创建一个新类，即子类。

要继承父类，子类必须包含一个名为“扩展”的关键字。关键字“extends”使编译器能够理解子类导出其父类的功能和成员。

为了更容易地理解这一点，让我们验证一下Java中的继承语法。

语法:

class SubClass extends ParentClass  
{  
//DataMembers;
//Methods;   
}

下面的程序是更好地解释Java继承术语的一个很好的例子。

Example:

比方说，三星想要制造一款新的洗衣机，其中包括一种方法，可以激活发动机中的温和洗涤信息，同时还可以节省时间。为此，我们可以编写代码，以便机器可以将温和洗涤方法继承到其最新型号中。

//Inheritance Example
package inheritance;
class Machine {
protected String brand = "Samsung";
public void wash() {
System.out.println("Initiating Gentle-Wash Task");
}
}
public class WashingMachine extends Machine {
private String modelName = "Top Load Washing Machine";
public static void main(String[] args) {
WashingMachine washmachine = new WashingMachine();
washmachine.wash();
System.out.println(washmachine.brand + " - " + washmachine.modelName);
}
}

为什么我们需要继承？

我们需要继承的两个主要原因包括：

运行时多态

运行时，也称为动态多态，是执行过程中的方法调用，它覆盖运行时中的不同方法。

代码的可重用性

继承的过程涉及重用父类中定义的方法和数据成员。继承消除了在子类中编写相同代码的需要，从而节省了时间。

接下来，我们将介绍访问父类的指导原则。父类的可访问性基于使用的访问修饰符

访问修饰符

访问修饰符指定父类的可用性。在实时编码中，我们不能允许子类访问所有其他类。数据成员、方法或构造函数的可用性可以用四种方式描述。

Access_Modifiers_Inheritance_in_Java

Default

默认访问修饰符是一个默认选项，用于在未向类提供来自用户的任何特定访问修饰符时为其提供可访问性。默认访问说明符类似于PUBLIC访问修饰符。不同之处在于父类只能在当前正在使用的Java项目的包内访问，而不能在包外访问。
Example:

package Simplilearn;  
class Parent{ 
void msg(){System.out.println("Hello World");} 
} 
package Simpli;  
import Simplilearn.*; 
class Child{  
public static void main(String args[]){  
Parent P = new Parent();
//Compile Time Error  
P.msg();//Compile Time Error  
}
}

Public

当用户希望所有子类都可以从Java项目中的任何位置访问父类以及任何其他包时，可以使用PUBLIC访问修饰符。

Example:

//Public
package inheritance;
public class Summation 
{public int add(int x, int y)
{return x + y;
}
}
package inheritance2;
import inheritance.*;
public class Child {
public static void main(String args[])
{
Summation A = new Summation();
System.out.println(A.add(100, 200));
}
}

Protected

受保护访问修饰符与其他修饰符略有不同。此类仅可由其子类访问。如果用户需要从不同的类访问受保护的数据成员和方法，则访问受保护类的子类是唯一的方法。

Example:

//Protected
package inheritance;
public class Parent
{ 
protected void Print() 
{ 
System.out.println("Hello World");
} 
}
package inheritance2;
import inheritance.*;
public class Child extends Parent {
public static void main(String args[]) {
Child x = new Child();
x.Print();
}
}

Private

私有访问修饰符具有访问私有数据成员和方法的严格规则。私有访问说明符在类内提供访问，但不在类外提供访问。

Example:

//Private
//Without Getter and Setter
//This program will have Compile-time error
package inheritance;
class Print {
private int value = 5;
private void Display() {
System.out.println("Hello World");
}
}
public class call {
public static void main(String args[]) {  
Print A =new Print();    
System.out.println(A.value);  
A.Display();
}
}
//With Getter and Setter
package inheritance;
class Print {
private int x = 5;
void Display() {
System.out.println("Hello World");
}
public int getX() {
return x;
}
public void setX(int x)
{
this.x = x;
}
}
public class call {
public static void main(String args[]) 
{
Print A = new Print();
System.out.println(A.getX());
A.Display();
}
}

超级关键字

super关键字是引用直接父类对象的唯一关键字。如果创建子类的实例，则super关键字隐式引用父类实例。

Example:

//Super Keyword
package inheritance;
class Jet {
int TopCruiseSpeed = 1800;
}
public class Su30MKI extends Jet {
int TopCruiseSpeed = 2500;
void Print() {
System.out.println("Maximum cruise Speed: " + super.TopCruiseSpeed);
}
}
class Takeoff {
public static void main(String[] args) {
Su30MKI Fighter = new Su30MKI();
Fighter.Print();
}
}

Java中的继承类型

Java中有五种类型的继承：

Single Inheritance
Multi-Level Inheritance
Hierarchical Inheritance
Hybrid Inheritance
Multiple Inheritance

我们将详细讨论其中的每一个。

Single Inheritance

单一继承由一个父类和一个子类组成。子类继承父类方法和数据成员。

Single_Inheritance

Example:

//Single
package inheritance;
class Student {
void Play() {
System.out.println("Playing Fooball...");
}
}
class Bob extends Student {
void Study() {
System.out.println("Studing Physic...");
}
}
public class Single {
public static void main(String args[]) {
Bob d = new Bob();
d.Study();
d.Play();
}
}

Multi-Level Inheritance

多级继承类似于父子继承关系-不同之处在于一个子类继承另一个子类。

/Multi-Level_Inheritance

Example:

//Multi-Level Inheritance
package inheritance;
class Bike {
public Bike() {
System.out.println("Segment: 1000cc");
}
public void BikeType() {
System.out.println("Bike Type: Sports");
}
}
class NinJa extends Bike {
public NinJa() 
{
System.out.println("Make NinJa");  
}
public void brand() {
System.out.println("Manufacturer: Kawasaki");
}
public void speed() {
System.out.println("Max Speed: 290Kmph");
}
}
public class NinJa1000R extends NinJa {
public NinJa1000R() {
System.out.println("NinJa Model: 1000R");
}
public void speed() {
System.out.println("Max Speed: 280Kmph");
}
public static void main(String args[]) {
NinJa1000R obj = new NinJa1000R();
obj.BikeType();
obj.brand();
obj.speed();
}
}

Hierarchical Inheritance

层次继承是一种父子关系。唯一的区别是多个子类继承一个父类。

Hierarchial_Inheritance-Inheritance_in_Java

Example:

//Hierarchical Inheritance
package inheritance;
class Employee {
double leaves = 25.00;
}
class PEmployee extends Employee {
float totalHoursPerDay = (float) 8.00;
}
class TEmployee extends Employee {
float totalHoursPerDay = (float) 10.50;
}
public class EmployeeSalary {
public static void main(String args[]) {
PEmployee permenant = new PEmployee();
TEmployee temporary = new TEmployee();
System.out.println("Permanent Employee Total Number of leaves are :\n" + permenant.leaves);
System.out.println("Number of working hours for Permanent Employee are:\n" + permenant.totalHoursPerDay);
System.out.println("Temporary Employee Total Number of leaves are :\n" + temporary.leaves);
System.out.println("Number of working hours for Temporary Employee are :\n" + temporary.totalHoursPerDay);
}
}

Hybrid Inheritance

混合继承可以是Java支持的三种继承类型中的任何一种组合。

/Hybrid_Inheritance-Inheritance

Example:

//Hybrid Inheritance
package inheritance;
class C {
public void Print() {
System.out.println("C is the Parent Class to all A,B,D");
}
}
class A extends C {
public void Print() {
System.out.println("A has Single Inheritance with C and shares Hierarchy with B");
}
}
class B extends C {
public void Print() {
System.out.println("B has Single Inheritance with C and shares Hierarchy with A");
}
}
public class D extends A {
public void Print() {
System.out.println("D has Single Inheritance with A and Multi-Level inheritance with C");
}
public static void main(String args[]) {
A w = new A();
B x = new B();
C y = new C();
D z = new D();
y.Print();
w.Print();
x.Print();
z.Print();
}
}
public class D extends A {
public void Print() {
System.out.println("D has Single Inheritance with A and Multi-Level inheritance with C");
}
public static void main(String args[]) {
A w = new A();
B x = new B();
C y = new C();
D z = new D();
y.Print();
w.Print();
x.Print();
z.Print();
}
}

Multiple Inheritance

还有第五种继承类型，但在Java中不受支持，因为多类继承会导致歧义。多重继承也被称为钻石问题。因此，Java不支持多类继承。

Diamond_Problem-Inheritance_

Is-a Relationship

当一个类从另一个类继承方法和成员时，则称这种关系为is-a关系。

Example: Orange is-a fruit.

IS-A_Relation.

Example:

//IS-A Relation
package inheritance;
import java.util.*;
class Customer {
public String Name;
public String City;
Customer(String Name, String City) {
this.Name = Name;
this.City = City;
}
}
class Bank {
private final List<Customer> customers;
Bank(List<Customer> customers) {
this.customers = customers;
}
public List<Customer> TotalAccountsInBank() {
return customers;
}
}
public class IsARelation {
public static void main(String[] args) {
Customer C1 = new Customer("Raju", "Bangalore");
Customer C2 = new Customer("Shiva", "Hyderabad");
Customer C3 = new Customer("Sachin", "Mumbai");
Customer C4 = new Customer("Prashanth", "Vizag");
Customer C5 = new Customer("John", "Goa");
List<Customer> Customers = new ArrayList<Customer>();
Customers.add(C1);
Customers.add(C2);
Customers.add(C3);
Customers.add(C4);
Customers.add(C5);
Bank ABCBank = new Bank(Customers);
List<Customer> cust = ABCBank.TotalAccountsInBank();
for (Customer cst : cust) {
System.out.println("Name of the Customer : " + cst.Name + "\n" + "City : " + cst.City);
}
}
}

Has-a Relationship

当一个类从另一个类或其类的实例继承一个实例时，则该关系是Has-a类型。

Ex: Orange has-a citrus taste.

HAS-A_Relation

Example:

//HAS-A Relation
package inheritance;
class School {
private String name;
School(String name) {
this.name = name;
}
public String SchoolName() {
return this.name;
}
}
class Student {
private String name;
Student(String name) {
this.name = name;
}
public String StudentName() {
return this.name;
}
}
public class HasARelation {
public static void main(String[] args) {
School schl = new School("St.John's School");
Student candidate = new Student("Tobey Marshall");
System.out.println(candidate.StudentName() + " is an Ex-Student of " + schl.SchoolName());
}
}