›
›

Bài giảng Phương pháp lập trình hướng đối tượng - Chương 7: Vòng đời đối tượng trong kế thừa - Nguyễn Minh Huy

Download
Vòng đꢀi đꢁi tưꢂng  
trong kꢃ thꢄa  
GV. Nguyꢀn Minh Huy  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
1
Nꢆi dung  
ꢀ Khꢇi tꢈo trong kꢉ thꢊa.  
ꢀ Hꢋy trong kꢉ thꢊa.  
ꢀ Vꢌn đꢍ con trꢎ trong kꢉ thꢊa.  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
2
Nꢆi dung  
ꢀ Khꢅi tꢆo trong kꢃ thꢄa.  
ꢀ Hꢋy trong kꢉ thꢊa.  
ꢀ Vꢌn đꢍ con trꢎ trong kꢉ thꢊa.  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
3
Khꢇi tꢈo trong kꢉ thꢊa  
ꢀ Trình tꢏ tꢈo lꢁp đꢃi tưꢄng kꢉ thꢊa:  
ꢀ Nhà đưꢄc xây tꢊ móng đꢉn mái.  
ꢀ Khái niꢐm đưꢄc đꢑnh nghĩa tꢊ thꢌp đꢉn cao.  
ꢀ Đꢃi tưꢄng kꢉ thꢊa đưꢄc tꢈo lꢁp tꢊ “lõi” đꢉn “vꢎ”.  
ꢁ Thành phꢇn cơ sꢅ đưꢂc tꢆo trưꢈc.  
Đꢁi tưꢂng kꢃ thꢄa  
Đꢁi tưꢂng cơ sꢅ  
Thành phꢒn cơ sꢇ  
Thành phꢒn mꢂi  
Xây móng đꢉn mái  
Đꢑnh nghĩa thꢌp đꢉn cao  
Tꢈo lꢁp tꢊ lõi đꢉn vꢎ  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
4
Khꢇi tꢈo trong kꢉ thꢊa  
ꢀ Thꢓ tꢏ khꢇi tꢈo ꢇ đꢃi tưꢄng kꢉ thꢊa:  
ꢀ Phương thꢓc khꢇi tꢈo lꢂp cơ sꢇ đưꢄc gꢔi trưꢂc.  
ꢁ Khꢅi tꢆo phꢇn lõi cơ sꢅ.  
ꢀ Phương thꢓc khꢇi tꢈo lꢂp kꢉ thꢊa gꢔi sau.  
ꢁ Khꢅi tꢆo phꢇn vꢉ mꢈi.  
ꢀ Lꢂp kꢉ thꢊa có thꢕ lꢊa chꢋn cách tꢈo phꢒn lõi.  
ꢁ Chꢌ đꢍnh phương thꢎc khꢅi tꢆo lꢈp cơ sꢅ.  
ꢁ Không chꢌ đꢍnh: khꢅi tꢆo mꢏc đꢍnh đưꢂc gꢋi.  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
5
Khꢇi tꢈo trong kꢉ thꢊa  
ꢀ Ví dꢖ:  
class GiaoVien  
class GVCN : public GiaoVien  
{
{
private:  
private:  
char  
public:  
GVCN();  
*m_lopCN;  
char  
float  
int  
*m_hoTen;  
m_mucLuong;  
m_ngayNghi;  
GVCN(char *lopCN);  
GVCN(char *hoTen,  
public:  
GiaoVien();  
float mucLuong,  
int ngayNghi,  
char *lopCN);  
GiaoVien(char *hoTen,  
float mucLuong,  
int ngayNghi);  
};  
};  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
6
Khꢇi tꢈo trong kꢉ thꢊa  
ꢀ Ví dꢖ:  
GVCN::GVCN(char *lopCN) : GiaoVien(“Minh”, 500000, 0)  
{
m_lopCN = new char[strlen(lopCN) + 1];  
strcpy(m_lopCN, lopCN);  
}
GVCN::GVCN(char *hoTen, float mucLuong, int ngayNghi, char *lopCN)  
: GiaoVien(hoTen, mucLuong, ngayNghi)  
{
m_lopCN = new char[strlen(lopCN) + 1];  
strcpy(m_lopCN, lopCN);  
}
GVCN::GVCN()  
{
}
GiaoVien() đưꢂc gꢋi trưꢈc  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
7
Nꢆi dung  
ꢀ Khꢇi tꢈo trong kꢉ thꢊa.  
ꢀ Hꢐy trong kꢃ thꢄa.  
ꢀ Vꢌn đꢍ con trꢎ trong kꢉ thꢊa.  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
8
Hꢋy trong kꢉ thꢊa  
ꢀ Trình tꢏ hꢋy đꢃi tưꢄng kꢉ thꢊa:  
ꢀ Ngưꢄc lꢈi vꢂi trình tꢏ tꢈo lꢁp.  
ꢀ Phương thꢓc hꢋy lꢂp kꢉ thꢊa đưꢄc gꢔi trưꢂc.  
ꢁ Hꢐy phꢇn vꢉ bên ngoài.  
ꢀ Phương thꢓc hꢋy lꢂp kꢉ cơ sꢇ đưꢄc gꢔi sau.  
ꢁ Hꢐy phꢇn lõi cơ sꢅ.  
ꢀ Mꢗi lꢂp chꢘ có mꢆt cách hꢋy  
Đꢁi tưꢂng kꢃ thꢄa  
ꢁ Lꢈp kꢃ thꢄa không cꢇn  
chꢌ đꢍnh cách hꢐy lꢈp cơ sꢅ.  
Đꢁi tưꢂng cơ sꢅ  
Thành phꢒn cơ sꢇ  
Thành phꢒn mꢂi  
Hꢋy tꢊ vꢎ đꢉn lõi  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
9
Hꢋy trong kꢉ thꢊa  
ꢀ Ví dꢖ:  
GiaoVien::~GiaoVien()  
{
~GiaoVien() đưꢂc gꢋi sau  
delete m_hoTen;  
}
GVCN::~GVCN()  
{
~GVCN() đưꢂc gꢋi trưꢈc  
delete m_lopCN;  
}
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
10  
Nꢆi dung  
ꢀ Khꢇi tꢈo trong kꢉ thꢊa.  
ꢀ Hꢋy trong kꢉ thꢊa.  
ꢀ Vꢑn đꢒ con trꢉ trong kꢃ thꢄa.  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
11  
Vꢌn đꢍ con trꢎ trong kꢉ thꢊa  
ꢀ Luꢁt “ba ông lꢈn”:  
ꢀ Lꢂp có thuꢆc tính con trꢎ (cꢌp phát bꢆ nhꢂ):  
ꢁ Phꢙi cài đꢚt tưꢛng minh “ba ông lꢈn”:  
ꢂ Phương thꢓc hꢋy.  
ꢂ Phương thꢓc khꢇi tꢈo sao chép.  
ꢂ Toán tꢜ gán.  
ꢀ Lꢂp kꢉ thꢊa có thuꢆc tính con trꢎ?  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
12  
Vꢌn đꢍ con trꢎ trong kꢉ thꢊa  
ꢀ Dr. Guru khuyên:  
(Luꢓt “ba ông lꢈn” trong kꢃ thꢄa)  
ꢀ Lꢂp kꢉ thꢊa có thuꢆc tính con trꢎ (cꢌp phát bꢆ nhꢂ):  
ꢂ Trang bꢑ “ba ông lꢂn” cho lꢂp kꢉ thꢊa.  
ꢂ “Ông lꢈn” lꢈp kꢃ thꢄa kích hoꢆt “ông lꢈn” lꢈp cơ sꢅ.  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
13  
Vꢌn đꢍ con trꢎ trong kꢉ thꢊa  
Kích hoꢆt “ông lꢈn” lꢈp cơ sꢅ  
ꢀ Ví dꢖ:  
class A  
{
B::B(const B &b) : A(b)  
“Ông lꢈn” lꢈp cơ sꢅ  
{
// Cài đꢚt khꢇi tꢈo sao chép B.  
}
public:  
A(const A &a);  
A& operator =(const A &a);  
virtual ~A();  
B& operator =(const B &b)  
{
};  
A::operator =(b);  
class B: public A  
{
// Cài đꢚt toán tꢜ = cho B.  
}
public:  
~B() // Tꢊ đꢔng gꢋi ~A().  
B(const B &b);  
B& operator =(const B &b);  
~B();  
{
// Cài đꢚt hꢋy cho B.  
}
};  
“Ông lꢈn” lꢈp kꢃ thꢄa  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
14  
Tóm tꢝt  
ꢀ Khꢇi tꢈo trong kꢉ thꢊa:  
ꢀ Khꢇi tꢈo tꢊ lõi đꢉn vꢎ.  
ꢀ Tꢈo lõi: phương thꢓc khꢇi tꢈo lꢂp cơ sꢇ gꢔi trưꢂc.  
ꢀ Tꢈo vꢎ: phương thꢓc khꢇi tꢈo lꢂp kꢉ thꢊa gꢔi sau,  
ꢀ Có thꢕ chꢘ đꢑnh phương thꢓc khꢇi tꢈo lꢂp cơ sꢇ.  
ꢀ Hꢋy trong kꢉ thꢊa:  
ꢀ Hꢋy tꢊ vꢎ vào lõi.  
ꢀ Hꢋy lõi: phương thꢓc hꢋy lꢂp kꢉ thꢊa.  
ꢀ Hꢋy vꢎ: phương thꢓc hꢋy lꢂp cơ sꢇ.  
ꢀ Luꢁt “ba ông lꢂn” trong kꢉ thꢊa.  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
15  
Bài tꢁp  
ꢀ Bài tꢁp 7.1:  
Cho biꢉt thꢓ tꢏ gꢔi khꢇi tꢈo vꢂi:  
class A  
{ public:  
A( int iX ) { }  
};  
a) void main() { C obj( 1, 2, 3 ); }  
b) void main() { C obj( 4 );  
c) void main() { C obj;  
}
}
class B: public A  
{ public:  
B( ) { }  
B( int iX, int iY ): A( iX ) { }  
};  
class C: public B  
{ public:  
C( ) { }  
C( int iZ ) { }  
C( int iX, int iY, int iZ ): B( iX, iY ) { }  
};  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
16  
Bài tꢁp  
ꢀ Bài tꢁp 7.2:  
Giꢙi quyꢉt ba vꢌn đꢍ con trꢎ cho lꢂp GiaoVien và GVCN.  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
17  
Bài tꢁp  
ꢀ Bài tꢁp 7.3:  
Cho biꢉt thꢓ tꢏ gꢔi khꢇi tꢈo vꢂi:  
class X { };  
a) void main( ) { Z obj( 5 ); }  
class Y: public X  
{
public:  
Y( int i ) { }  
};  
b) void main( )  
{
Y obj1( 6 );  
Y obj2( obj1 );  
}
class Z: public Y  
c) void main( )  
{
{
public:  
Z obj1( 7 );  
Z( int i ): Y( i++ ) { }  
Z obj2( obj1 );  
}
};  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
18  
Bài tꢁp  
ꢀ Bài tꢁp 7.4:  
Hãy vꢞ cây kꢉ thꢊa cho nhꢟng lꢂp đꢃi tưꢄng hình hꢔc:  
(có thꢕ phát sinh nhꢟng lꢂp cơ sꢇ cꢒn thiꢉt đꢕ tái sꢜ dꢖng hiꢐu quꢙ)  
ꢅ Vuông.  
ꢅ Tam giác vuông.  
ꢅ Tam giác cân.  
ꢅ Tròn.  
ꢅ Ellipse.  
ꢅ Tam giác vuông cân.  
ꢅ Tam giác đꢍu.  
ꢅ Chꢟ nhꢁt.  
ꢅ Thoi.  
ꢅ Bình hành.  
ꢅ Thang vuông.  
ꢅ Thang cân.  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
19  
Bài tꢁp  
ꢀ Bài tꢁp 7.5:  
Mꢆt rꢈp chiꢉu phim có M hàng ghꢉ, mꢗi hàng ghꢉ có N ghꢉ.  
Giá vé đưꢄc tính theo vꢑ trí ngꢠi sao cho càng xa hàng ghꢉ trung tâm  
(cꢙ trưꢂc lꢡn sau) thì giá vé càng rꢢ, xa hơn mꢆt hàng ghꢉ giꢙm 3,000.  
Có 2 loꢈi rꢈp:  
ꢅ Rꢈp thưꢛng: giá vé ꢇ hàng ghꢉ trung tâm là 80,000.  
ꢅ Rꢈp cao cꢌp: giá vé ꢇ hàng ghꢉ trung tâm là 120,000, ngoài ra  
rꢈp có khuyꢉn mãi giꢙm 20% giá vé vào ngày thꢓ năm hàng tuꢒn.  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
20  
Tải về để xem bản đầy đủ
pdf 21 trang myanh 20140 Free
Download
Bạn đang xem 20 trang mẫu của tài liệu "Bài giảng Phương pháp lập trình hướng đối tượng - Chương 7: Vòng đời đối tượng trong kế thừa - Nguyễn Minh Huy", để tải tài liệu gốc về máy hãy click vào nút Download ở trên

File đính kèm:

  • pdfbai_giang_phuong_phap_lap_trinh_huong_doi_tuong_chuong_7_von.pdf