Home #C/C++ #laptrinhhuongdoituong #OOP Tính Kế Thừa Trong Lập Trình Hướng Đối Tượng (Bài 6)

Tính Kế Thừa Trong Lập Trình Hướng Đối Tượng (Bài 6)

tháng 7 31, 2021
Read

 


Tính Kế Thừa Trong Lập Trình Hướng Đối Tượng

Xin chào tất cả mọi người, mình quay lại rồi đây. Thời gian vừa rồi mình khá bận nên không có thời gian chia sẻ tiếp với mọi người. Và hôm nay chúng ta tiếp tục tới phần tiếp theo là tính kế thừa trong lập trình hướng đối tượng nhé

Tính Kế Thừa Trong C++

Tính kế thừa là một trong những đặc tính quan trọng nhất của lập trình hướng đối tượng.
Nó là khả năng lấy một thuộc tính, đặc tính của một lớp cha để áp dụng lên lớp con.

Lớp kế thừa các thuộc tính từ một lớp khác được gọi là Lớp con hoặc Lớp dẫn xuất.
Lớp có các thuộc tính được kế thừa bởi lớp con được gọi là Lớp cha hoặc Lớp cơ sở.

Tại sao chúng ta cần dùng tính kế thừa? Và khi nào thì cần dùng nó?

Đầu tiên chúng ta lấy một ví dụ thực tế trước nhé. Chúng ta có 3 lớp: Class Bus, Class Car, Class Truck.
Các phương thức fuelAmount(), capacity(), applyBrakes() đều có trong 3 lớp này. Khi đó, nếu chúng ta tạo các lớp này thì chúng ta phải viết trong mỗi lớp đều có 3 phương thức trên.

Tồi tệ hơn chút nữa, nếu bạn muốn sửa lại code trong một phương thức nào đó, thì bạn phải sửa chúng cả ở 3 lớp. Sẽ rất tốn thời gian, và có thể dễ sai sót đúng không nào.

Vì thế để tránh điều này và cũng đảm bảo dữ liệu sẽ không bị dư thừa, tính kế thừa sẽ được sử dụng ở đây.

Khi áp dụng tính kế thừa, đầu tiên ta sẽ lại một lớp: Class Vehical. Trong lớp này sẽ có cả 3 phương thức fuelAmount(), capacity() và applyBrakes().
Sau đó chúng ta mới tạo 3 lớp: Class Bus, Class Car, Class Truck. Rồi cho 3 lớp này kế thừa từ lớp Class Vehical.


Hình ảnh trên cho thấy khi áp dụng tính kế thừa, ta chỉ cần viết một lần các phương thức kia trong lớp cha và cho các lớp con kế thừa lại.

Điều này sẽ tránh việc sai sót khi sửa và tăng khả năng sử dụng lại.
Khả năng sử dụng lại ở đây là: Nếu bạn muốn thêm một lớp Class Taxi chẳng hạn, bạn chỉ cần khai báo nó kế thừa từ Class Vehical là cũng có thể dùng được 3 phương thức trên rồi.

Cú pháp sử dụng tính kế thừa

Cú pháp chung để khai báo kế thừa như sau:

0
1
2
3
4
5
 
class subclass_name : access_mode base_class_name
{
  //body of subclass
};
 

Trong đó:

  • subclass_name là tên lớp con sẽ áp dụng kế thừa
  • base_class_name là tên lớp cha
  • access_mode có thể là public, private hoặc protected

Nếu các bạn không chỉ rõ access_mode thì mặc định sẽ là private.

Dưới đây là một ví dụ về sử dụng tính kế thừa trong C++.

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
#include <bits/stdc++.h>
using namespace std;
 
//Lớp Cha
class Parent {
public:
    int id_p;
};
 
// Lớp con kế thừa từ lớp cha
class Child : public Parent {
public:
    int id_c;
};
 
int main() {
    Child obj1;
    obj1.id_c = 7;
    obj1.id_p = 91;
    cout << "Child id is " << obj1.id_c << endl;
    cout << "Parent id is " << obj1.id_p << endl;
 
    return 0;
}
 

Sau khi chạy chương trình ta có kết quả sau

0
1
2
3
 
Child id is 7
Parent id is 91
 

Trong chương trình trên, class Child là lớp con, nó sẽ được kế thừa các thành viên dữ liệu dạng public từ class Parent
Nếu để các thành viên dữ liệu trên dạng private thì sẽ không thể dùng kế thừa
Bạn có thể xem lại các loại phạm vi truy cập: Tại đây

Các phạm vi kế thừa

Tiếp theo thì chúng ta sẽ tìm hiểu về các phạm vi kế thừa ( Access Mode ).
Ta sẽ có 3 loại chính đó là:

  1. public: Nếu kế thừa ở dạng này, sau khi kế thừa, tất cả các thành viên dạng public lớp cha sẽ public ở lớp con, dạng protected ở lớp cha vẫn sẽ là protected ở lớp con.
  2. protected: Nếu dùng protected thì sau khi kế thừa, tất cả các thành viên dạng public lớp cha sẽ trở thành protected tại lớp con.
  3. private: Trường hợp ta sử dụng private, thì sau khi kế thừa, tất cả các thành viên dạng public và protected ở lớp cha sẽ thành private tại lớp con.

Bảng dưới đây sẽ tóm tắt các phạm vi kế thừa cho cả 3 loại public, protected, và private

Các loại kế thừa trong C++

Trong phần này, ta sẽ cùng tìm hiểu, ngôn ngữ C++ sẽ có các loại kế thừa nào nhé!

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

Đơn kế thừa là gì?

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


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

0
1
2
3
4
5
 
class subclass_name : access_mode base_class
{
  //body of subclass
};
 

Đây là một ví dụ về đơn kế thừa

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
#include <iostream>
using namespace std;
 
// Lớp cha
class Vehicle
{
public:
    Vehicle()
    {
        cout << "This is a Vehicle" << endl;
    }
};
 
// Lớp con kế thừa từ lớp cha
class Car : public Vehicle
{
};
 
// main function
int main()
{
    // creating object of sub class will
    // invoke the constructor of base classes
    Car obj;
    return 0;
}
 

Sau khi biên dịch và chạy chương trình ta có kết quả

0
1
2
 
This is a vehicle
 

Đa kế thừa (Multiple Inheritance)

Định nghĩa

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


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

0
1
2
3
4
5
 
class subclass_name : access_mode base_class1, access_mode base_class2, ....
{
  //body of subclass
};
 

Ở đây, các lớp cơ sở sẽ được phân tách bằng dấu phẩy , và phạm vi truy cập cho mọi lớp cơ sở phải được chỉ định.

Chúng ta cùng xem ví dụ sau:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
#include <iostream>
using namespace std;
 
// Lớp cơ sở thứ nhất
class Vehicle
{
public:
    Vehicle()
    {
        cout << "This is a Vehicle" << endl;
    }
};
 
// Lớp cơ sở thứ hai
class FourWheeler
{
public:
    FourWheeler()
    {
        cout << "This is a 4 wheeler Vehicle" << endl;
    }
};
 
// Lớp con kế thừa từ 2 lớp cha
class Car : public Vehicle, public FourWheeler
{
};
 
// main function
int main()
{
    Car obj;
    return 0;
}
 

Sau khi chạy ta sẽ có kết quả sau

0
1
2
3
 
This is a Vehicle
This is a 4 wheeler Vehicle
 

Lưu ý: Khi đa kế thừa cần tránh trường hợp có nhiều lớp cơ sở có tên phương thức giống nhau. Vì khi gọi từ lớp con thì chương trình không biết nên gọi phương thức đó từ lớp cơ sở nào.

Nếu bạn cần tìm hiểu rõ hơn về đa kế thừa. Bạn có thể truy cập: Tại đây

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

Định nghĩa

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


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

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
#include <iostream>
using namespace std;
 
// Lớp cha
class Vehicle
{
public:
    Vehicle()
    {
        cout << "This is a Vehicle" << endl;
    }
};
// Lớp con kế thừa từ lớp cha
class fourWheeler : public Vehicle
{
public:
    fourWheeler()
    {
        cout << "Objects with 4 wheels are vehicles" << endl;
    }
};
// Lớp con kế thừa từ lớp cha thứ 2
class Car : public fourWheeler
{
public:
    car()
    {
        cout << "Car has 4 Wheels" << endl;
    }
};
 
// main function
int main()
{
    Car obj;
    return 0;
}
 

Sau khi chạy ta có Output:

0
1
2
3
4
 
This is a Vehicle
Objects with 4 wheels are vehicles
Car has 4 Wheels
 

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

Định nghĩa

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

Ví dụ

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
#include <iostream>
using namespace std;
 
// Lớp cha
class Vehicle
{
public:
    Vehicle()
    {
        cout << "This is a Vehicle" << endl;
    }
};
 
// Lớp con thứ nhất
class Car : public Vehicle
{
};
 
// Lớp con thứ hai
class Bus : public Vehicle
{
};
 
// main function
int main()
{
    Car obj1;
    Bus obj2;
    return 0;
}
 

Sau khi chạy ta có kết quả:

0
1
2
3
 
This is a Vehicle
This is a Vehicle
 

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

Định nghĩa

Kế thừa lai (Kế thừa ảo): được thực hiện bằng cách kết hợp nhiều hơn một loại thừa kế. Ví dụ: Kết hợp kế thừa phân cấp và đa kế thừa.

Hình ảnh dưới đây cho thấy sự kết hợp của phân cấp và đa kế thừa:

Ví dụ

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
#include <iostream>
using namespace std;
 
// Lớp cha
class Vehicle
{
public:
    Vehicle()
    {
        cout << "This is a Vehicle" << endl;
    }
};
 
// Lớp cha
class Fare
{
public:
    Fare()
    {
        cout << "Fare of Vehicle\n";
    }
};
 
// Lớp con thứ nhất
class Car : public Vehicle
{
};
 
// Lớp con thứ hai
class Bus : public Vehicle, public Fare
{
};
 
// main function
int main()
{
    Bus obj2;
    return 0;
}
 

Sau khi chạy ta có kết quả như sau:

0
1
2
3
 
This is a Vehicle
Fare of Vehicle
 

Bài viêt của mình xin được kết thúc tại đây. Mình rất mong nhận được sự quan tâm, cũng như những góp ý từ các bạn để bài viết của mình ngày một hoàn thiện hơn. Cảm ơn tất cả mọi người. Xin chào và hẹn gặp lại.

Tags :

Không có nhận xét nào:

Đăng ký: Đăng Nhận xét ( Atom )
Được tạo bởi Blogger.