Kế Thừa Trong Java – Techacademy

Kế thừa trong Java là 1 trong những tính năng quan trọng nhất của mạng lưới hệ thống lập trình hướng đối tượng người tiêu dùng ( OOP ). Chúng ta đã thấy tổng quan về kế thừa trong hướng dẫn trước của Các khái niệm OOP trong Java. Trong hướng dẫn này, tất cả chúng ta sẽ hiểu chi tiết cụ thể về kế thừa trong Java và kiểu của nó với nhiều ví dụ khác nhau .Kế thừa trong Java là 1 tính năng giúp dùng lại các phương pháp và biến của 1 lớp này trong 1 lớp khác. Nói cách khác, nó được cho phép 1 lớp mới kế thừa các thuộc tính và công dụng của 1 lớp hiện có mà không cần viết lại mã. Nó thực hiện Cha mẹ và con mối quan hệ. Điều này có nghĩa là lớp con hoàn toàn có thể dùng lại trực tiếp các biến và hàm của lớp cha .

I. Nguyên Nhân Dùng Tính Kế Thừa Trong Java ?

Tính kế thừa trong Java là môt kỹ thuật mà trong đấy 1 đối tượng người dùng thu được hầu hết thuộc tính và hành vi của đối tượng người tiêu dùng cha. Ý tưởng đằng sau tính kế thừa trong Java là các các bạn hoàn toàn có thể tạo các lớp mới mà được kiến thiết xây dựng dựa trên các lớp đang sống sót .

Khi các các bạn kế thừa từ 1 lớp đang tồn tại, các các bạn có thể tái dùng các phương thức và các trường của lớp cha, và các các bạn cũng có thể bổ sung thêm các phương thức và các trường khác. Tính kế thừa biểu diễn mối quan hệ IS-A, còn được gọi là mối quan hệ cha-con.

Bạn đang đọc: Kế Thừa Trong Java – Techacademy

Có 1 số nguyên do vì sao nên dùng kế thừa trong lập trình Java :
– Khả năng biểu lộ các mối quan hệ kế thừa bảo vệ sự thân thiện với các quy mô trong quốc tế thực .
– 1 nguyên do khác là năng lực tái dùng. Khi dùng tính kế thừa ta hoàn toàn có thể lấy 1 lớp mới từ 1 lớp hiện có và thêm tính năng mới vào nó mà không cần sửa đổi lớp cha và viết lại lớp cha để kế thừa nó .
– 1 nguyên do khác là đặc thù bắc cầu. Nếu lớp 1 kế thừa các thuộc tính từ 1 lớp B, sau đấy hầu hết các lớp con của A sẽ tự động hóa kế thừa từ B. Tính chất này được gọi là đặc thù bắc cầu của kế thừa .

II. Cú Pháp Của Tính Kế Thừa Trong Java

Mọi người đã biết rằng để kế thừa 1 lớp, tất cả chúng ta dùng từ khóa expand. Cú pháp của việc dùng kế thừa trong Java chính là :

class ten_lop_con extends ten_lop_cha {
  //cac phuong thuc va cac truong  
}

Từ khóa extends chỉ rằng bạn đang tạo 1 lớp mới mà kế thừa từ 1 lớp đang sống sót. Trong Java, 1 lớp mà được kế thừa được gọi là 1 lớp cha. Lớp mới được gọi là lớp con .
Trong ví dụ sau, Programmer là lớp con và Employee là lớp cha. Mối quan hệ giữa hai lớp là Programmer IS-A Employee. Nghĩa là Programmer là 1 kiểu của Employee .

class Employee {
  float salary = 40000;
}
class Programmer extends Employee {
  int bonus = 10000;
  public static void main(String args[]) {
    Programmer p = new Programmer();
    System.out.println("Luong Lap trinh vien la:" + p.salary);
    System.out.println("Bonus cua Lap trinh vien la:" + p.bonus);
  }
}

Ở trên, đối tượng người dùng Programmer hoàn toàn có thể truy vấn trường của riêng lớp nó cũng như của lớp Employee, đấy là ví dụ cho tính tái dùng .

III. Các Loại Kế Thừa Trong Java

Có 5 kiểu kế thừa trong Java đấy là đơn kế thừa, Đa kế thừa, Kế thừa đa cấp, Kế thừa phân cấp, Kế thừa lai
Khi 1 class được kế thừa từ nhiều class đươc gọi là đa kế thừa. Trong Java, đa kế thừa chỉ được tư vấn trải qua interface, như đã được nói đến trong bài interface trong Java

1. Đơn kế thừa (Single Inheritance):

Đơn kế thừa : nghĩa là 1 lớp chỉ được kế thừa từ đúng 1 lớp khác. Hay nói cách khác, lớp con chỉ có duy nhất 1 lớp cha .

Cú pháp khai báo đơn kế thừa :

class lopcon : phamvidulieu lopcha
{
  // nội dung lớp con
};

dưới đây là 1 ví dụ :

#include 
using namespace std;
 
// Lớp cha
class Mayvitinh
{
public:
    Mayvitinh()
    {
        cout << "This is a computer" << endl;
    }
};
 
// Lớp con kế thừa từ lớp cha
class mayAcer : public Mayvitinh
{
};
 
// main function
int main()
{
    mayAcer may1;
    return 0;

Chương trình sẽ cho hiệu quả :

2. Đa kế thừa (Multiple Inheritance):

Đa kế thừa là 1 tính năng của ngôn từ C + +. Trong đấy 1 lớp hoàn toàn có thể kế thừa từ nhiều hơn 1 lớp khác. Nghĩa là 1 lớp con được kế thừa từ nhiều hơn 1 lớp cơ sở .

Cú pháp khai báo đa kế thừa :

class lopcon : phamvitruycap lopcha1, phamvitruycap lopcha2, ....
{
  // nội dung của lớp con
};

Ở đây, các lớp cơ sở sẽ được phân tách bằng dấu phẩy, và khoanh vùng phạm vi truy vấn cho mọi lớp cơ sở phải được chỉ định .
Chúng ta cùng xem ví dụ sau :

#include 
using namespace std;
 
// Lớp cơ sở thứ nhất
class Mayvitinh
{
public:
    Mayvitinh()
    {
        cout << "This is a computer's brand" << endl;
    }
};

// Lớp cơ sở thứ hai
class Maylaptop
{
public:
    Maylaptop()
    {
        cout << "This is a laptop's brand" << endl;
    }
};
 
// Lớp con kế thừa từ 2 lớp cha
class mayAcer : public Mayvitinh, public Maylaptop
{
};
 
// main function
int main()
{
    mayAcer may1;
    return 0;
}

Sau khi chạy ta sẽ có tác dụng sau :

3. Kế thừa đa cấp (Multilevel Inheritance):

Kế thừa đa cấp : Trong kiểu thừa kế này, 1 lớp dẫn xuất được tạo từ 1 lớp dẫn xuất khác .

Ví dụ về kế thừa đa cấp :

#include 
using namespace std;
 
// Lớp cha
class Mayvitinh
{
public:
    Mayvitinh()
    {
        cout << "This is a computer's brand" << endl;
    }
};

// Lớp con kế thừa từ lớp cha
class Maylaptop : public Mayvitinh
{
public:
    Maylaptop()
    {
        cout << "This is a laptop's brand" << endl;
    }
};
 
// Lớp con kế thừa từ lớp cha thứ 2
class mayAcer : public Maylaptop
{
public:
     mayAcer(){
         cout << "This brand is Acer" << endl;
     }
};
 
// main function
int main()
{
    mayAcer may1;
    return 0;
}

Sau khi chạy ta có tác dụng :

4. Kế thừa phân cấp (Hierarchical Inheritance):

Kế thừa phân cấp : Trong kiểu thừa kế này, sẽ có nhiều hơn 1 lớp con được kế thừa từ 1 lớp cha duy nhất .

Chúng ta có ví dụ :

#include 
using namespace std;
 
// Lớp cha
class Mayvitinh
{
public:
    Mayvitinh()
    {
        cout << "This is a computer's brand" << endl;
    }
};

// Lớp con thứ nhất
class mayAsus : public Mayvitinh
{
};
 
// Lớp con thứ hai
class mayAcer : public Mayvitinh
{
};
 
// main function
int main()
{
    mayAcer may1;
    mayAsus may2;
    return 0;
}

Sau khi chạy ta có tác dụng :

5. Kế thừa lai (Kế thừa ảo) – Hybrid (Virtual) Inheritance:

Kế thừa lai ( Kế thừa ảo ) : được thực hiện bằng cách tích hợp nhiều hơn 1 loại thừa kế .

Chúng ta lấy ví dụ về sự tích hợp của phân cấp và đa kế thừa dưới đây :

#include 
using namespace std;
 
// Lớp cha
class Mayvitinh
{
public:
    Mayvitinh()
    {
        cout << "This is a computer's brand" << endl;
    }
};

// Lớp cha
class Maylaptop
{
public:
    Maylaptop()
    {
        cout << "This is a laptop's brand" << endl;
    }
};
 
// Lớp con thứ nhất
class mayAcer : public Mayvitinh
{
};

// Lớp con thứ hai
class mayAsus : public Mayvitinh, public Maylaptop
{
};
 
// main function
int main()
{
    mayAsus may1; 
    mayAcer may2;
    return 0;
}

Sau khi chạy ta có hiệu quả :

IV. Từ Khóa Instanceof Trong Java

Trong bài viết này, các bạn sẽ khám phá về toán tử Instanceof Java 1 cách cụ thể với sự trợ giúp của các ví dụ .
Trong Java, từ khóa Instanceof là 1 toán tử nhị phân. Nó được dùng để kiểm tra xem 1 đối tượng người dùng có phải là 1 Instance của 1 class đơn cử hay không .
Toán tử cũng kiểm tra xem 1 đối tượng người dùng có phải là 1 Instance của 1 class thực hiện 1 giao diện ( interface ) hay không ( sẽ được tranh luận sau trong bài hướng dẫn này ) .
Cú pháp của toán tử Instanceof là :

result = objectName Instanceof className;

Toán hạng bên trái của toán tử Instanceof là tên đối tượng người tiêu dùng và toán hạng bên phải là tên class. Kết quả sẽ true nếu 1 đối tượng người dùng là 1 Instance của 1 class và sẽ là false nếu nó không phải .

Ví dụ 1: Toán tử Instanceof

Xem thêm: Mẫu công văn hỏi đáp gửi chi cục thuế mới nhất 2023

/**
* Cafedev.vn - Kênh thông tin IT hàng đầu Việt Nam
*
* @author cafedevn
* Contact: [email protected]
* Fanpage: https://www.facebook.com/cafedevn
* Instagram: https://instagram.com/cafedevn
* Twitter: https://twitter.com/CafedeVn
* Linkedin: https://www.linkedin.com/in/cafe-dev-407054199/
*/

class Main {
    public static void main (String[] args) {
        String name = "Programiz";
        Integer age = 22;

        System.out.println("Is name an Instance of String: "+ (name Instanceof String));
        System.out.println("Is age an Instance of Integer: "+ (age Instanceof Integer));
    }
}

Khi tất cả chúng ta chạy chương trình, hiệu quả sẽ là :

Is name an Instance of String: true
Is age an Instance of Integer: true

Trong ví dụ trên, tất cả chúng ta đã tạo đối tượng người dùng name của kiểu String và 1 đối tượng người tiêu dùng khác là age của kiểu Integer. Sau đấy, tất cả chúng ta đã dùng toán tử Instanceof để kiểm tra xem liệu rằng đối tượng người dùng name có thuộc kiểu String và đối tượng người tiêu dùng age có thuộc kiểu Integer hay không .
dùng toán tử Instanceof trong tính kế thừa
Vơi tính thừa kế, toán tử Instanceof được dùng để kiểm tra xem liệu rằng 1 đối tượng người tiêu dùng của subclass có phải cũng là 1 toán tử Instanceof của siêu class hay là không .

Ví dụ 2: Instanceof trong kế thừa

/**
* Cafedev.vn - Kênh thông tin IT hàng đầu Việt Nam
*
* @author cafedevn
* Contact: [email protected]
* Fanpage: https://www.facebook.com/cafedevn
* Instagram: https://instagram.com/cafedevn
* Twitter: https://twitter.com/CafedeVn
* Linkedin: https://www.linkedin.com/in/cafe-dev-407054199/
*/

class Animal {
}

// Dog class is a subclass of Animal
class Dog extends Animal {
}

class Main {
    public static void main(String[] args){
        Dog d1 = new Dog();

        // checks if d1 is an object of Dog
        System.out.println("Is d1 an Instance of Dog: "+ (d1 Instanceof Dog));
       
        // checks if d1 is an object of Animal
        System.out.println("Is d1 an Instance of Animal: "+ (d1 Instanceof Animal));
    }
}

Khi tất cả chúng ta chạy chương trình, tác dụng sẽ là :

Is d1 is an Instance of Dog: true
Is d1 an Instance of Animal: true

Trong ví dụ trên, d1 là 1 Instance của cả class Dog và Animal. Do đấy, cả d1 Instanceof Dog và d1 Instanceof Animal trả về tác dụng là true .

V. Quan hệ HAS-A Trong Java

Nếu 1 class có tham chiếu đến 1 thực thể khác, được gọi là quan hệ HAS – A .
Ví dụ Chúng ta có class Student, 1 Student cần có các thông tin như id, name, email, etc. Và thực thể Address chứa các thông tin city, country, zipcode etc .

// File Student.java
public class Student {
    String id;
    String name;
    Address address;
}

// File Address.java
public class Address {
    String city;
    String country;
    String zipcode;
}

Class Student tham chiếu đến Address là 1 thực thể, tất cả chúng ta hoàn toàn có thể phát biểu như sau : Student có quan hệ HAS – A Address .

Mục đích dùng HAS – A

Ở ví dụ trên, các bạn trọn vẹn hoàn toàn có thể gộp các thuộc tính địa chỉ vào class Student như sau .

// File Student.java
public class Student {
    String id;
    String name;
    String city;
    String country;
    String zipcode;
}

Với cách làm trên của tất cả chúng ta là trọn vẹn ổn. Sau đấy ứng dụng lan rộng ra tất cả chúng ta có thêm class Employee cũng cần dùng đến địa chỉ. Nếu như làm theo cách trên thì tất cả chúng ta phải duplicate các thuộc tính address cho Employee. Làm như vậy thì code sẽ trở nên dài dòng, giảm tính reused code của project .
Vậy nên tất cả chúng ta cần dùng HAS – A để tăng tính tái dùng code. Định nghĩa Address ra 1 class riêng, và Student, Employee đều tham chiếu đến Address .

Khi nào nên dùng HAS -A

Như đã bàn luận ở trên, dùng HAS – A làm tăng tính tái dùng code. Khi các bạn thấy giữa các class có các thông tin chung giống hệt nhau thì ta nên tách nhỏ nó ra thành 1 class khác gồm có những thuộc tính chung .
Các bạn đừng nhầm lẫn HAS – A với IS – A ( thừa kế ) nha. Thừa kế là 1 khái niệm mà các class con dùng lại các thuộc tính và method của class cha có sẵn. HAS – A là đặt những điểm chung ra riêng 1 class và import vào các class khác để dùng .
Ví dụ
Address. java

// File Address.java
public class Address {
    String city;
    String country;
    String zipcode;
    public Address(String city, String country, String zipcode) {
        this.city = city;
        this.country = country;
        this.zipcode = zipcode;
    }
}

Student. java

// File Student.java
public class Student {
    int id;
    String name;
    Address address;
    Student(int id, String name, Address address) {
        this.id = id;
        this.name = name;
        this.address = address;
    }
    void display() {
        System.out.println("ID: " + id);
        System.out.println("Name: " + name);
        System.out.println("Address: " + address.city + " " + address.country + " " + address.zipcode);
    }
}

// File Main.java
public class Main {
    public static void main(String[] args) {
        Address address = new Address("HCM", "VN", 11000);
        Student student = new Student(1, "Hai", address);
        student.display();
    }
}

Output :

ID: 1
Name: Hai
Address: HCM VN 11000

VI. Bài Tập Kế Thừa Trong Java Có Lời Giải

Tạo 1 lớp Person tàng trữ các thông tin dưới đây ( Tên, giới tính, địa chỉ, ngay sinh )
Tạo 1 lớp Student kế thừa từ lớp person tàng trữ các thông tin như dưới đây :
Mã sinh viên, điểm trung bình, email
Viết 1 phương pháp nhập thông tin của student
Viết 1 phương pháp hiện thị thông tin của student
Viết phương trình xem xét có sinh viên nào được học bổng không ? điểm trung bình hơn 8.0 sẽ được hổng bổng
Khai báo class parent Person

class Person{
   protected String name;
   protected String sex;
   protected String adrress;
   protected String ngaysinh;
      public void intputPerson(){
      Scanner scanner = new Scanner(System.in);
      System.out.println("Nhap Ten :");
      this.name = scanner.nextLine();
      System.out.println("Nhap gioi tinh");
      this.sex = scanner.nextLine();
      System.out.println("Nhap dia chi");
      this.adrress = scanner.nextLine();
      System.out.println("Nhap ngay sinh");
      this.ngaysinh = scanner.nextLine();
   }
   public void showPerson(){
      System.out.println("Ho Ten : " +this.name + " Gioi Tinh : " +this.sex +" Dia chi : " +this.adrress +" Ngay sinh : " +this.ngaysinh);
   }
   }

Trong đấy :
Có 4 biến gồm có ( ten, gioitinh, diachi, ngaysing ) và có 2 phương pháp :
intputPerson : Là phương pháp nhập thông tin
showPerson : Xuất hiện thông tin
Tiếp thep khai báo 1 lớp student được kế thừa từ lớp Person

class Student extends Person{
   protected String masv;
   protected float diemtrungbinh;
   protected String email;
   public void intPutStudent(){
         Scanner input = new Scanner(System.in);
      System.out.println("Nhap ma sinh vien");
      this.masv = input.nextLine();
      System.out.println("Nhap diem trung binh");
      this.diemtrungbinh = input.nextFloat();
      System.out.println("Nhap email");
      this.email = input.nextLine();
   }
   public void showStudent(){
      System.out.println("Ma sinh vien : " +this.masv +" Diem trung binh " + this.diemtrungbinh);
   }
   public void kiemtrahocbong(){
      if(this.diemtrungbinh >=8){
         System.out.println("Duoc hoc bong");
      }else{
         System.out.println("Khong duoc hoc bong");
      }
   }
}

Lớp Person có 3 biến cần tàng trữ, và 3 phương pháp java
intPutStudent : Nhập thông tin của sinh viên đấy .
showStudent : Xuất thông tin của sinh viên
kiemtrahocbong : Phương thức kiểm tra học bổng
Hàm khởi tạo để thực hiện chương trình như sau :

ublic class BT1 {
   public static void main(String []args){
      Student person = new Student();
      person.intputPerson();
      person.intPutStudent();
      person.showPerson();
      person.showStudent();
      person.kiemtrahocbong();
   }
}

Kết quả :

VII. Đa Kế Thừa Trong Java

Nếu 1 lớp tiến hành đa kế thừa, hoặc 1 Interface kế thừa từ nhiều Interface thì đó là đa kế thừa .
Trong Java, 1 lớp chỉ được thừa kế ( extends ) từ 1 lớp, hoàn toàn có thể thiết lập ( implements ) nhiều interface. Tuy nhiên, 1 interface hoàn toàn có thể thừa kế ( extends ) nhiều interface .
1 interface không hề thiết lập ( implements ) interface khác, do interface không phần thiết lập, chỉ chứa các khai báo .
Ví dụ 1 lớp thiết lập ( implements ) nhiều interface :

public interface Shape {    
    void draw();    
}
 
public interface Color {
    String getColor();
}
 
public class Rectangle implements Shape, Color {
 
    @Override
    public void draw() {
        System.out.println("Draw " + this.getColor() + " rectangle");
    }
 
    @Override
    public String getColor() {
        return "red";
    }
     
}

Ví dụ interface kế thừa ( extend ) nhiều interface :

public interface Shape {    
    void draw();    
}
 
public interface Color {
    String getColor();
}
 
public interface ShapeColor extends Shape, Color {
 
}
 
public class Circle implements ShapeColor {
 
    @Override
    public void draw() {
        System.out.println("Draw " + this.getColor() + " circle");
    }
 
    @Override
    public String getColor() {
        return "red";
    }
     
}

Câu hỏi : Đa kế thừa không được tương hỗ trải qua lớp trong Java nhưng là hoàn toàn có thể bởi Interface, vì sao ?
Như đã trình làng, kế thừa không được tương hỗ trải qua lớp. Nhưng nó được tương hỗ bởi Interface chính bới không có tính lưỡng nghĩa khi trình tiến hành được phân phối bởi lớp Implementation .

Ví dụ đa thừa kế với Interface

Xem thêm: VẬN DỤNG PHƯƠNG PHÁP VẤN ĐÁP VÀO DẠY HỌC ĐỌC HIỂU NHẰM NÂNG CAO NĂNG LỰC NGỮ VĂN CHO HỌC SINH THPT

public interface Printable {  
    void print();  
} 
  
public interface Showable {  
    void print();  
}  
    
public class InterfaceDemo implements Printable, Showable {  
    public void print() {
        System.out.println("Welcome to gpcoder.com");
    }  
 
    public static void main(String args[]) {  
        InterfaceDemo obj = new InterfaceDemo();  
        obj.print();  
    }  
}

Trong ví dụ trên, interface Printable và Showable có cùng các phương pháp print ( ) nhưng trình tiến hành của nó được phân phối bởi lớp InterfaceDemo, cho nên vì thế không có tính lưỡng nghĩa ở đây .
Ví dụ đa thừa kế với class

public class Printable {
    void print() {
        System.out.println("Printable");
    }
}  
 
public class Showable {  
    void print() {
        System.out.println("Showable");
    }
}  
 
// Không thể thực hiện đa thừa kế với class
public class InterfaceDemo extends Printable, Showable {  
    public static void main(String args[]) {  
        InterfaceDemo obj = new InterfaceDemo();  
        obj.print();  // Không thể xác định được gọi phương thức print() của class nào
    }  
}

Trong ví dụ trên, lớp Printable và Showable có cùng các phương pháp print ( ) và InterfaceDemo kế thừa 2 class đó không override lại phương pháp print ( ) nên trình biên dịch không biết thực thi phương pháp print ( ) của lớp Printable hay là của lớp Showable. Để bảo vệ bảo đảm an toàn và giảm tính phức tạp của mạng lưới hệ thống nên Java không tương hỗ đa thừa kế so với class .

Source: https://suachuatulanh.org
Category : Hỏi Đáp Chuyên Gia