›
›

Bài giảng Phương pháp lập trình hướng đối tượng - Chương 8: Interface và Đa hình - Nguyễn Minh Huy

Download
Interface và Đa hình  
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 niꢇm interface.  
ꢀ Hàm ꢈo và liên kꢉt đꢆng.  
ꢀ Phương thꢊc hꢋy ꢈo.  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
2
Nꢆi dung  
ꢀ Khái niꢀm interface.  
ꢀ Hàm ꢈo và liên kꢉt đꢆng.  
ꢀ Phương thꢊc hꢋy ꢈo.  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
3
Khái niꢇm interface  
ꢀ Giao tiꢉp giꢌa đꢃi tưꢄng và bên ngoài:  
ꢀ Quy tꢍc hꢆp đen:  
ꢁ Thuꢆc tính: private, hꢎn chꢉ truy xuꢏt.  
ꢁ Phương thꢊc: public, cung cꢏp tính năng.  
ꢂ Đꢃi tưꢄng giao tiꢉp qua phương thꢊc.  
ꢂ Phꢐn khai báo public ꢂ INTERFACE.  
(Pꢊc)  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
4
Khái niꢇm interface  
ꢀ Đꢑc điꢒm Interface:  
ꢀ Là “phꢐn vꢓ” cꢋa lꢂp.  
Lꢂp = Interface + Khai báo private + Cài đꢑt.  
ꢀ Không chꢊa cài đꢑt.  
Nhꢁn interface PhanSo  
ꢀ Giao thꢊc giao tiꢉp cꢋa đꢃi tưꢄng.  
void xuLy( PhanSo p )  
class PhanSo  
{
}
// Xꢔ lý trên pꢕ  
{
private:  
int m_tu;  
int m_mau;  
public:  
void main()  
{
PhanSo p1( 1, 2 );  
PhanSo( int tu, int mau );  
PhanSo p2( 1, 3 );  
xuLy( p1 );  
PhanSo rutGon( );  
PhanSo nghichDao( );  
xuLy( p2 );  
};  
}
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
5
Khái niꢇm interface  
ꢀ Interface trong kꢉ thꢖa:  
ꢀ Lꢂp kꢉ thꢖa:  
ꢁ Thꢖa hưꢗng thuꢆc tính/phương thꢊc tꢖ lꢂp cơ sꢗ.  
ꢂ Thꢖa hưꢗng interface cꢋa lꢂp cơ sꢗ.  
ꢂ Có cùng giao thꢊc giao tiꢉp cꢋa lꢂp cơ sꢗ.  
ꢀ Tính đa hình trong kꢉ thꢖa:  
ꢁ Hàm nhꢁn đꢃi tưꢄng lꢂp cơ sꢗ  
ꢂ Cũng nhꢁn đꢃi tưꢄng lꢂp kꢉ thꢖa.  
ꢁ Con trꢓ kiꢒu lꢂp cơ sꢗ  
ꢂ Có thꢒ trꢓ đꢉn đꢃi tưꢄng lꢂp kꢉ thꢖa.  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
6
Khái niꢇm interface  
Chꢏp nhꢁn interface Animal  
ꢀ Interface trong kꢉ thꢖa:  
void xuLy(Animal p)  
class Animal  
{
{
p.talk();  
}
public:  
void talk() { cout << “Don’t talk”; }  
void main()  
};  
Chꢏp nhꢁn  
{
các đꢃi  
tưꢄng có  
interface  
Animal  
Animal a;  
class Cat: public Animal  
{
public:  
Cat  
c;  
d;  
Dog  
xuLy(a);  
xuLy(c);  
xuLy(d);  
Animal *p;  
p = &a;  
void talk() { cout << “Meo meo”; }  
};  
class Dog: public Animal  
{
p = &c;  
public:  
p = &d;  
void talk() { cout << “Gau gau”; }  
}
};  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
7
Nꢆi dung  
ꢀ Khái niꢇm interface.  
ꢀ Hàm ꢁo và liên kꢂt đꢃng.  
ꢀ Phương thꢊc hꢋy ꢈo.  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
8
Hàm ꢈo và liên kꢉt đꢆng  
ꢀ Vꢏn đꢘ liên kꢉt tĩnh trong C++:  
void xuLy(Animal p)  
class Animal  
{
{
Liên kꢉt  
cài đꢑt  
Animal  
khi dꢙch  
p.talk();  
public:  
}
void talk() { cout << “Don’t talk”; }  
void main()  
{
};  
Cat  
Dog  
c;  
d;  
class Cat: public Animal  
{
xuLy(c);  
public:  
xuLy(d);  
void talk() { cout << “Meo meo”; }  
};  
Liên kꢉt  
cài đꢑt  
Animal  
khi dꢙch  
Animal *p;  
p = &c;  
pꢄ>talk();  
p = &d;  
class Dog: public Animal  
{
public:  
pꢄ>talk();  
void talk() { cout << “Gau gau”; }  
}
};  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
9
Hàm ꢈo và liên kꢉt đꢆng  
ꢀ Khái niꢇm hàm ꢈo:  
ꢀ Hàm bình thưꢚng:  
ꢁ Lꢚi gꢛi hàm gꢍn vꢂi cài đꢑt hàm lúc dꢙch ꢂ Liên kꢉt tĩnh.  
ꢀ Hàm ꢈo:  
ꢁ Hàm đꢑc biꢇt.  
ꢁ Lꢚi gꢛi hàm chꢜ gꢍn vꢂi interface.  
ꢁ Bꢓ ngꢓ phꢐn cài đꢑt ꢂ Liên kꢉt đꢆng  
ꢂ Đưꢄc gꢍn đꢆng vào lúc chꢎy.  
ꢂ Tùy thuꢆc đꢃi tưꢄng lúc chꢎy.  
ꢀ Trong C++:  
ꢁ Khai báo: virtual <Chꢌ ký hàm>;  
ꢁ Chꢜ dùng đưꢄc vꢂi con trꢓ đꢃi tưꢄng.  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
10  
Hàm ꢈo và liên kꢉt đꢆng  
ꢀ Liên kꢉt đꢆng trong C++:  
void xuLy(Animal *p)  
class Animal  
{
{
Liên kꢉt  
pꢅ>talk();  
public:  
interface  
Animal,  
Bꢓ ngõ  
cài đꢑt  
}
virtual void talk() { cout << “Don’t talk”; }  
void main()  
{
};  
Cat  
Dog  
c;  
d;  
class Cat: public Animal  
{
xuLy(&c);  
public:  
xuLy(&d);  
void talk() { cout << “Meo meo”; }  
};  
Liên kꢉt  
interface  
Animal,  
Bꢓ ngõ  
cài đꢑt  
Animal *p;  
p = &c;  
pꢄ>talk();  
p = &d;  
class Dog: public Animal  
{
public:  
pꢄ>talk();  
void talk() { cout << “Gau gau”; }  
}
};  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
11  
Hàm ꢈo và liên kꢉt đꢆng  
ꢀ Xây dꢝng interface trong C++:  
ꢀ C++ cài đꢑt interface bꢞng “hàm thuꢅn ꢁo”.  
ꢀ Đꢑc điꢒm “hàm thuꢐn ꢈo”:  
ꢁ Hàm ꢈo, có thêm “= 0“ ꢗ cuꢃi khai báo.  
ꢁ Chꢜ có khai báo không có cài đꢑt.  
ꢁ Là “phꢐn vꢓ” đꢒ liên kꢉ đꢆng.  
ꢁ Bꢓ ngõ phꢐn cài đꢑt cho lꢂp kꢉ thꢖa.  
ꢂ Lꢂp có chꢊa hàm thuꢐn ꢈo là lꢆp trꢇu tưꢈng.  
ꢂ Không thꢒ tꢎo đꢃi tưꢄng tꢖ lꢂp trꢖu tưꢄng..  
class Animal  
{
Hàm thuꢐn ꢈo, không có cài đꢑt!!  
public:  
virtual void talk() = 0;  
};  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
12  
Hàm ꢈo và liên kꢉt đꢆng  
ꢀ Xây dꢝng interface trong C++:  
void xuLy(Animal *p)  
{
class Animal  
{
Lꢂp trꢖu tưꢄng  
Liên kꢉt  
interface  
Animal,  
Bꢓ ngõ  
cài đꢑt  
pꢅ>talk();  
public:  
}
virtual void talk() = 0;  
void main()  
};  
{
Cat  
Dog  
c;  
d;  
class Cat: public Animal  
{
xuLy(&c);  
public:  
xuLy(&d);  
void talk() { cout << “Meo meo”; }  
};  
Animal *p;  
p = new Animal; // Sai  
p = new Cat; // Đúng  
pꢄ>talk();  
class Dog: public Animal  
{
public:  
}
void talk() { cout << “Gau gau”; }  
};  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
13  
Hàm ꢈo và liên kꢉt đꢆng  
ꢀ Ý nghĩa cꢋa liên kꢉt đꢆng:  
ꢀ Giao tiꢉp thông qua interface.  
ꢀ Cài đꢑt thay đꢟi đꢆng, tùy nhu cꢐu ngưꢚi dùng.  
ꢂ Mã nguꢠn tꢟng quát.  
void giveATalk( int type )  
void giveATalk( Animal *p )  
{
{
if ( type == 0 )  
pꢄ>talk( );  
{
}
Cat c;  
c.talk( );  
}
else if ( type == 1 )  
{
Dog d;  
d.talk( );  
}
}
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
14  
Nꢆi dung  
ꢀ Khái niꢇm interface.  
ꢀ Hàm ꢈo và liên kꢉt đꢆng.  
ꢀ Phương thꢉc hꢊy ꢁo.  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
15  
Phương thꢊc hꢋy ꢈo  
ꢀ Xét ví dꢡ:  
void main()  
class GiaoVien  
{
{
GVCN *p1 = new GVCN;  
private:  
delete p1;  
char  
public:  
~GiaoVien() { delete m_hoTen; }  
*m_hoTen;  
~GVCN()  
~GiaoVien()  
};  
GiaoVien *p2 = new GVCN;  
delete p2;  
class GVCN : public GiaoVien  
{
}
~GiaoVien()  
private:  
char  
public:  
~GVCN() { delete m_lopCN; }  
*m_lopCN;  
Vì sao thꢉ tꢋ gꢌi  
phương thꢉc hꢊy  
khác nhau??  
};  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
16  
Phương thꢊc hꢋy ꢈo  
ꢀ Dr. Guru khuyên:  
ꢀ Phương thꢉc hꢊy cꢊa lꢆp phꢁi luôn là hàm ꢁo.  
ꢂ Liên kꢉt đꢆng đꢉn phương thꢊc hꢋy lꢂp kꢉ thꢖa.  
class GiaoVien  
{
public:  
virtual ~GiaoVien() { delete m_hoTen; }  
};  
class GVCN : public GiaoVien  
{
public:  
~GVCN() { delete m_lopCN; }  
};  
GiaoVien *p3 = new GVCN;  
delete p3;  
~GVCN()  
~GiaoVien()  
Phương pháp lꢁp trình hưꢂng đꢃi tưꢄng ꢅ GV. Nguyꢀn Minh Huy  
17  
Tóm tꢍt  
ꢀ Khái niꢇm interface:  
ꢀ Lꢂp = Interface + Khai báo private + Cài đꢑt.  
ꢀ Lꢂp kꢉ thꢖa thꢖa hưꢗng interface lꢂp cơ sꢗ.  
ꢀ Giꢈ lꢁp interface trong C++: hàm thuꢐn ꢈo.  
ꢀ
Hàm ꢈo:  
ꢀ Chꢜ ràng buꢆc vꢂi interface, không ràng buꢆc cài đꢑt.  
ꢀ Khai báo dùng “virtual”.  
ꢀ Phương thꢊc hꢋy ꢈo:  
ꢀ Phương thꢊc hꢋy phꢈi luôn là hàm ꢈo.  
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 8.1:  
Cho biꢉt nhꢌng gì xuꢏt hiꢇn  
trên màn hình trong các  
trưꢚng hꢄp:  
class A {  
public:  
[yyy] void f1() { cout << “Good morning.\n”; f2(); }  
[zzz] void f2() { cout << “Good afternoon.\n”; }  
};  
a) [yyy] trꢃng, [zzz] trꢃng.  
b) [yyy] trꢃng, [zzz] virtual.  
c) [yyy] virtual, [zzz] trꢃng.  
d) [yyy] virtual, [zzz] virtual.  
class B: public A {  
public:  
void f1() { cout << “Good evening.\n”; f2(); }  
void f2() { cout << “Good night.\n”; }  
};  
void main()  
{
A *p = new B;  
pꢅ>f1();  
}
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 8.2:  
Cho 2 loꢎi hình:  
ꢅ Hình tam giác: biꢒu diꢀn bꢗi 3 đꢜnh.  
ꢅ Hình chꢌ nhꢁt: biꢒu diꢀn bꢗi 2 điꢒm ꢅ trên trái và dưꢂi phꢈi.  
Viꢉt hàm nhꢁn vào danh sách 2 loꢎi hình trên và xuꢏt thông tin các hình  
có trong danh sách.  
Nꢉu thêm vào loꢎi hình mꢂi là hình tròn.  
ꢅ Hình tròn: biꢒu diꢀn bꢗi tâm và bán kính.  
Khi đó, chương trình sꢢ thay đꢟi như thꢉ nào?  
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 24 trang myanh 17920 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 8: Interface và Đa hình - 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_inter.pdf