Tải bản đầy đủ (.ppt) (92 trang)

Chuong 3 Lop doi tuong

Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (551.97 KB, 92 trang )

<span class='text_page_counter'>(1)</span>Chương 3 Lớp và Đối tượng.

<span class='text_page_counter'>(2)</span> Nội dung 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12.. Lớp Đối tượng Phạm vi truy xuất thành phần lớp Đối tượng this Phương thức khởi tạo Phương thức huỷ Thành phần tĩnh Thành phần hằng Truyền tham số Tổ chức các lớp Biến CLASSPATH Một số lớp thông dụng.

<span class='text_page_counter'>(3)</span> 1. Lớp • Lớp là gì? • Lớp (Class) là một tập các đối tượng có cùng đặc trưng. • Ví dụ: lớp Sinh viên, lớp Động vật,… • Mỗi lớp gồm các thuộc tính và hành động đặc trưng của lớp..

<span class='text_page_counter'>(4)</span> 1. Lớp (tiếp) • Khai báo lớp đơn giản: class <TênLớp> { Khai báo các thuộc tính Khai báo các phương thức } • Khai báo thuộc tính: Kiểu. tênThuộcTính; 4.

<span class='text_page_counter'>(5)</span> 1. Lớp (tiếp) • Khai báo phương thức: Kiểu tênPhươngThức(ds Tham số) { Các lệnh của phương thức; return kếtQuả; }.

<span class='text_page_counter'>(6)</span> 1. Lớp (tiếp) • Ví dụ: khai báo lớp phân số đơn giản. class PS { int tu, mau; void hienThi() {System.out.println(tu+“/”+mau);} double giaTri() {return (double)tu/mau;} }.

<span class='text_page_counter'>(7)</span> Tính bao gói (Encapsulation) Một lớp bao gồm cả thuộc tính và các phương thức Tính bao gói giúp cho việc quản lý các lớp dễ dàng hơn khi lập trình..

<span class='text_page_counter'>(8)</span> 2. Đối tượng • Đối tượng (Object) là một thực thể thuộc một lớp nào đó. • Đối tượng được tạo từ lớp theo cú pháp: new TênLớp(); Ví dụ: new PS(); • Sẽ cấp phát vùng nhớ lưu đối tượng. • Trong Java vùng nhớ cấp phát cho đối tượng là Heap..

<span class='text_page_counter'>(9)</span> 2. Đối tượng (tiếp) • Tham chiếu (reference): • Để thao tác với đối tượng cần có tên, gọi là tham chiếu. • Khai báo tham chiếu: TênLớp tênThamChiếu; Ví dụ: PS p; • Tham chiếu đến đối tượng: tênThamChiếu = new TênLớp(); Ví dụ: p = new PS();.

<span class='text_page_counter'>(10)</span> Phân biệt giữa biến và đối tượng Primitive type. int i = 1. i. 1. Object type. PS p. p. reference. p: PS tu=1 mau=2.

<span class='text_page_counter'>(11)</span> 2. Đối tượng (tiếp) • Phép gán tham chiếu: tênThamChiếu1 = tênThamChiếu2; • Hai tên cùng tham chiếu đến 1 đối tượng. • Phân biệt phép gán biến và tham chiếu: int x = 5, y; PS p, q; y = x; p = new PS(); q = p;.

<span class='text_page_counter'>(12)</span> Phép gán biến và tham chiếu Phép gán tham chiếu. Phép gán biến i=j Before: After:. p1 = p2 Before: After:. i. 1. i. 2. p1. p1. j. 2. j. 2. p2. p2. p1: PS tu=1 mau=2. p2: PS tu=5 mau=7.

<span class='text_page_counter'>(13)</span> 2. Đối tượng (tiếp) • Thao tác với đối tượng qua tham chiếu: • Thao tác với thuộc tính: tênThamChiếu.tênThuộcTính • Ví dụ: p.tu=1; p.mau=2; • Thao tác với phương thức: tênThamChiếu.tênPhươngThức([ds đối số]); • Ví dụ: p.hienThi(); • double x = p.giaTri();.

<span class='text_page_counter'>(14)</span> 3. Phạm vi truy xuất các thành phần của lớp • Khai báo các thành phần với phạm vi truy xuất: <Phạm vi> <Khai báo thành phần> • <Phạm vi> gồm: • public: dùng chung tại mọi vị trí. • private: chỉ được truy xuất trong phạm vi của lớp..

<span class='text_page_counter'>(15)</span> 3. Phạm vi truy xuất …(tiếp) • Ví dụ: class PS { private int tu, mau; public void hienThi() { … } }.

<span class='text_page_counter'>(16)</span> 3. Phạm vi truy xuất … (tiếp) • Thông thường các thuộc tính được quy định phạm vi truy xuất là private. • Để truy xuất được các thuộc tính từ bên ngoài lớp, ta cung cấp các phương thức lấy giá trị và gán giá trị cho thuộc tính..

<span class='text_page_counter'>(17)</span> 3. Phạm vi truy xuất … (tiếp) • Ví dụ: lớp PS với các phương thức truy xuất. class PS { private int tu,mau; public int layTu(){ return tu;} public int layMau(){ return mau;} public void ganTu(int t){ tu = t;} public void ganMau(int m) { if (m>0) mau=m;} }.

<span class='text_page_counter'>(18)</span> 3. Phạm vi truy xuất … (tiếp). • Xét các thao tác sau: PS p = new PS(); p.tu = 1; p.mau=2; //sai vì tu, mau có phạm vi truy xuất là private..

<span class='text_page_counter'>(19)</span> 3. Phạm vi truy xuất … (tiếp) • Thay cho thao tác trên bằng thao tác: p.ganTu(1); p.ganMau(2);. • Để in phân số p lên màn hình phải thực hiện: System.out.println(p.layTu()+”/”+p.layMau());.

<span class='text_page_counter'>(20)</span> Che giấu thông tin (Hiding information) • Thông tin về lớp có thể che giấu đối với bên ngoài lớp. • Giúp cho việc bảo vệ thông tin tốt hơn. • Việc che giấu thông tin vẫn đảm bảo có thể thao tác được với đối tượng khi cần..

<span class='text_page_counter'>(21)</span> 4. Đối tượng this • Là đối tượng ngầm định khi viết mã lệnh các phương thức của một lớp. • Ví dụ: trong lớp PS class PS { private int tu, mau; public void ganTu(int tu) { this.tu = tu; } }.

<span class='text_page_counter'>(22)</span> 4. Đối tượng this (tiếp) • Khi thực hiện: PS p = new PS(); p.ganTu(5); thì this chính là phân số p..

<span class='text_page_counter'>(23)</span> Nạp chồng phương thức (Overloading) • Một lớp có thể chứa nhiều phương thức cùng tên với chức năng khác nhau. • Các phương thức nạp chồng phải khác nhau tham số. • Ví dụ: trong lớp PS có thể có hai phương thức cong: PS cong(int) PS cong(PS) • Khi sử dụng sẽ tự động chọn phương thức phù hợp.

<span class='text_page_counter'>(24)</span> 5. Phương thức khởi tạo • PTKT (constructor) là phương thức đặc biệt dùng để khởi tạo giá trị các thuộc tính của đối tượng khi mới được tạo ra. • Phương thức khởi tạo ngầm định: khi không khai báo phương thức khởi tạo. Chẳng hạn: PS p = new PS(); Khi đó p=?.

<span class='text_page_counter'>(25)</span> 5. Phương thức khởi tạo (tiếp) • Khai báo PTKT: tên PTKT trùng tên lớp. public TênLớp(ds tham số) {…} • Ví dụ: khai báo một số phương thức khởi tạo cho lớp PS..

<span class='text_page_counter'>(26)</span> 5. Phương thức khởi tạo (tiếp) class PS { private int tu, mau; public PS() {tu = 0; mau = 1;} public PS(int n) { tu=n; mau=1;} public PS(int t, int m) { tu = t; mau = m;} public PS(PS p) { tu = p.tu; mau=p.mau;} }.

<span class='text_page_counter'>(27)</span> 5. Phương thức khởi tạo (tiếp) • Sử dụng phương thức khởi tạo: PS p1 = new PS(); // p1 = 0/1 PS p2 = new PS(5);// p2 = 5/1 PS p3 = new PS(5,7);// p3 = 5/7 PS p4 = new PS(p2);// p4 = 5/1.

<span class='text_page_counter'>(28)</span> 6. Phương thức hủy • Chức năng phương thức hủy: thực hiện mỗi khi thu hồi ô nhớ của đối tượng. • Khai báo phương thức hủy: protected void finalize() • Bộ thu gom rác (Garbage Collection - GC) • Java tự động thu hồi và giải phóng ô nhớ cho các đối tượng không còn dùng..

<span class='text_page_counter'>(29)</span> 6. Phương thức hủy (tiếp) • Ví dụ minh họa: class Finalizer { int count; public Finalizer(int i) { count=i; System.out.println("Tao doi tuong thu "+count); } protected void finalize() { System.out.println("Huy do tuong thu "+count); super.finalize(); } }.

<span class='text_page_counter'>(30)</span> 6. Phương thức hủy {3} public class TestFinalize { public static void main(String args[]) { double a[]; for (int i=0;i<100;i++) {new Finalizer(i); a = new double[10000];} } }.

<span class='text_page_counter'>(31)</span> Kết quả thực hiện chương trình.

<span class='text_page_counter'>(32)</span> Luyện tập - lớp PS PS - int - int. tu mau. + PS() + PS(int n) + PS(int t, int m) + PS(PS p) + void ganTu(int t) + int layTu() + void ganMau(int m) + int layMau(). - void rutGon() + void tang(int n) + void gap(int n) + PS cong(int n) + PS cong(PS p) + PS tru(int n) + PS tru(PS p) + PS nhan(int n) + PS nhan(PS p) + PS chia(int n) + PS chia(PS p) + String toString() + void hienThi() + int soSanh(PS p).

<span class='text_page_counter'>(33)</span> Luyện tập – Lớp PS •. Khai báo một lớp sử dụng lớp PS đã định nghĩa thực hiện: • Tạo phân số p=1/2, q=5/7 • Thực hiện r = p+q; Hiển thị r. • Thực hiện t = 2*p - p/q; Hiển thị t • So sánh 2 phân số p, q cho biết kết quả. • Tạo mảng phân số chứa 5 phân số: 1/2, 13/2, 5/7, 6/9, 30/23. Sắp xếp theo thứ tự tăng rồi in kết quả lên màn hình..

<span class='text_page_counter'>(34)</span> 7. Thành phần tĩnh • Là những thành phần dùng chung cho mọi đối tượng được tạo ra từ một lớp. • Khai báo thuộc tính tĩnh <phạm vi> static <kiểu dữ liệu> <tên thuộc tính> • Khai báo phương thức tĩnh <phạm vi> static <kiểu dữ liệu> <tên phương thức>(<danh sách tham số>).

<span class='text_page_counter'>(35)</span> 7. Thành phần tĩnh (tiếp) • Ví dụ: class A{ int x; static int y; } A o1 = new A(), o2= new A() ; o1.x=5; o1.y=7; o2.x=10; o2.y=9; System.out.println(o1.y);??.

<span class='text_page_counter'>(36)</span> 7. Thành phần tĩnh (tiếp) • Thành phần tĩnh có thể thao tác qua tên lớp. Chẳng hạn với ví dụ trên có thể thực hiện: A.y = 5; • Trong phương thức tĩnh ta chỉ được phép dùng các phương thức tĩnh hoặc dữ liệu tĩnh..

<span class='text_page_counter'>(37)</span> 7. Thành phần tĩnh (tiếp) • Ví dụ: class A{ int x; static int y; static void pt1() { y=1;}//x = 1? void pt2() { x=1;y=1;} }.

<span class='text_page_counter'>(38)</span> 7. Thành phần tĩnh (tiếp) • Ví dụ: class StaticClass { static int count=0; private int data;StaticClass(int d){ data = d; count++;} public public void display(){ System.out.println("So doi tuong: "+ count + " du lieu= "+data);} }.

<span class='text_page_counter'>(39)</span> 7. Thành phần tĩnh (tiếp) class StaticTest { public static void main(String args[]){ StaticClass a= new StaticClass(1); a.Display(); StaticClass b= new StaticClass(2); a.Display();b.Display(); } }.

<span class='text_page_counter'>(40)</span> 8. Thành phần hằng • Thành phần hằng là những thuộc tính có giá trị cố định trong một đối tượng. • Khai báo thành phần hằng: final <kiểu dữ liệu> tênThuộcTính=<giá trị>;. • Ví dụ: khai báo hằng PI = 3.14 public final float PI = 3.14;.

<span class='text_page_counter'>(41)</span> Bài tập Bài 1: Cài đặt lớp NTN (ngày/tháng/năm). • Viết chương trình sử dụng lớp vừa định nghĩa: • Tạo 2 đối tượng n1=1/1/2006, n2=10/9/2007. • Tính khoảng cách giữa hai ngày. • So sánh hai ngày..

<span class='text_page_counter'>(42)</span> Sơ đồ lớp NTN NTN - int ngay - int thang - int nam + NTN() + NTN(int nam) + NTN(int ng, int th, int na) + NTN(NTN ntn) + void datNgay(int ngay) + int layNgay() + void datThang(int thang). + int layThang() + void datNam(int nam) + int layNam() -int songay(int th, int na) - NTN cong1ngay() - NTN tru1ngay() + NTN cong(int n) + NTN tru(int n) + int tru(NTN ng) + String toString() + void HienThi() + int SoSanh(NTN ntn).

<span class='text_page_counter'>(43)</span> Bài tập • Bài 2: Khai báo lớp ma trận số nguyên sao cho có thể khởi tạo, gán giá trị, truy xuất đến từng phần tử, cộng, trừ, nhân các ma trận. • Dùng lớp này để minh họa các thao tác: + Tạo 2 ma trận m1(3,3), m2(3,3) + Tìm vị trí phần tử lớn nhất trong ma trận m1. + Cộng hai ma trận m3 = m1 + m2 + Trừ hai ma trận m4 = m1 - m2 + Nhân hai ma trận m5 = m1 × m2.

<span class='text_page_counter'>(44)</span> MATRAN Sơ đồ lớp MATRAN - int[][] mt - int soDong - int soCot + MATRAN(int d, int c) +MATRAN(int[][]mang, int m, int n) + MATRAN(MATRAN mt) + int laySoDong() + int laySoCot() + int layGiaTri(int d, int c) + void ganGiaTri(int d, int c, int gt) + MATRAN cong(MATRAN m) + MATRAN tru(MATRAN m) + MATRAN nhan(MATRAN m) + void hienThi().

<span class='text_page_counter'>(45)</span> 9. Truyền tham số trong các phương thức Việc truyền tham số trong các phương thức của Java được quy định như sau: • Nếu tham số là các dữ liệu nguyên thủy như: int, boolean, char, float, … thì tham số được truyền theo trị. • Ví dụ: xét hàm đổi giá trị của hai biến nguyên như sau sẽ không thực hiện được chức năng như mong muốn..

<span class='text_page_counter'>(46)</span> Ví dụ class ThamTri{ public static void doigiatri(int x, int y) { int tg = x; x=y; y=tg; } public static void main(String args[]) { int i=5, j=7; doigiatri(i, j); System.out.println(“i=”+ i +” j=“+j); } }.

<span class='text_page_counter'>(47)</span> 9. Truyền tham số … (tiếp) • Nếu tham số là các đối tượng thì được truyền theo tham chiếu. • Việc truyền các đối tượng thực chất là tham chiếu đến các đối tượng. • Ví dụ: khai báo lớp myInt để thao tác với số nguyên (dùng cho truyền tham chiếu).

<span class='text_page_counter'>(48)</span> Ví dụ class myInt { private int i; public myInt() { i = 0;} public myInt(int x) { i = x;} public void setValue(int x) { i = x;} public int getValue() { return i;} }.

<span class='text_page_counter'>(49)</span> Ví dụ • Phương thức doigiatri() được viết cho các tham số thuộc lớp myInt như sau: public void doigiatri(myInt x, myInt y) { int tmp = x.getValue(); x.setValue(y.getValue()); y.setValue(tmp); } • Khi đó việc truyền tham số cho phương thức được thực hiện như truyền theo biến: myInt m= new myInt(5), n = new myInt(7); doigiatri(m,n);.

<span class='text_page_counter'>(50)</span> 9. Truyền tham số… (tiếp) • Tham số là các mảng thì được truyền theo biến. • Ví dụ: phương thức sắp xếp mảng số public static void sapXep(int a[], int n) { … } • Khi sử dụng: int b[]={5,7,8,2,3}; sapXep(b,5); // b = {2, 3, 5, 7, 8}.

<span class='text_page_counter'>(51)</span> 10. Tổ chức các lớp trong chương trình • Trong một chương trình Java có thể khai báo nhiều lớp. • Ta có thể khai báo các lớp dùng chung trong một file chương trình java: // thuvien.java class Lop1 { …} class Lop2 { …} ….

<span class='text_page_counter'>(52)</span> 10. Tổ chức các lớp … (tiếp) • Khi biên dịch: javac thuvien.java • Sẽ tạo ra các file: Lop1.class, Lop2.class, … • Tuy nhiên ta không thực hiện được các lớp này vì không có hàm main..

<span class='text_page_counter'>(53)</span> 11. Biến CLASSPATH • Biến ClassPath chứa các đường dẫn đến các lớp mà khi biên dịch tìm kiếm. • Quy định biến ClassPath: • Trong Windows: tạo biến môi trường. • Trong DOS: set ClassPath = … • Ví dụ: set ClassPath = .;c:\ThuVien • Trong đó: . Là thư mục hiện hành..

<span class='text_page_counter'>(54)</span> Bài thực hành số 3 • Bài 1. Viết thư viện lớp SoHoc chứa các phương thức: • soChan(int) • max(int,int) • max(double, double) • max(int, int, int) • max(int[],int) • sapXep(int[], int) • inMang(int[], int).

<span class='text_page_counter'>(55)</span> • Sử dụng lớp SoHoc thực hiện: • Kiểm tra 1 số là số chẵn hay lẻ. • Tìm số lớn trong 2 số nguyên, 2 số thực, 3 số nguyên. • Tìm số lớn trong mảng. • Sắp xếp mảng. • Bài 2. Cài đặt lớp NTN • Bài 3. Lớp ma trận các phân số.

<span class='text_page_counter'>(56)</span> Bài 4. Hãy tự tổ chức các lớp để quản lý các tài khoản ATM của một ngân hàng sao cho các tài khoản có thể nạp tiền, rút tiền, chuyển tiền đến một tài khoản khác, tính tổng số tiền của các khách hàng có trong hệ thống. Viết chương trình thực hiện. • Tạo danh sách 5 tài khoản, mỗi tài khoản có sẵn số tiền tối thiểu là 100. • Tài khoản 1111111 nạp tiền vào tài khoản 1000. • Tài khoản 1111111 chuyển cho tài khoản 2222222 số tiền 500 • Tài khoản 2222222 rút số tiền 200 • In số tiền hiện có của các tài khoản. • In tổng số tiền của các tài khoản..

<span class='text_page_counter'>(57)</span> 12. Một số lớp trong Java. 62.

<span class='text_page_counter'>(58)</span> 12.1 Lớp Math • Lớp Math: chứa các hằng, các phương thức là các hàm toán học. • Các hằng: E, PI • Hàm trả về trị tuyệt đối abs(…) static int abs(int) static long abs(long) static float abs(float) static double abs(double).

<span class='text_page_counter'>(59)</span> 12.1 Lớp Math • Hàm trả về phần nguyên trên: ceil(…) static double ceil(double d) • Hàm trả về phần nguyên dưới: floor(…) static double floor(double d) • Hàm làm tròn đến phần nguyên: round(…) static int round(float d) static long round(double d) • Hàm trả về số lớn trong 2 số: static int max(int a, int b) static long max(long a, long b).

<span class='text_page_counter'>(60)</span> Lớp Math (tiếp) • Hàm lũy thừa: static double pow (double d1, double d2) • Hàm e mũ: static double exp(double d) • Hàm logarit cơ số 10: static double log(double d) • Hàm căn bậc hai: static double sqrt(double d).

<span class='text_page_counter'>(61)</span> • Các hàm lượng giác: static double sin(double d) static double cos(double d) static double tan(double d) • Phương thức quy đổi: static double toRadians(double) static double toDegrees(double) • Hàm sinh số ngẫu nhiên trong khoảng từ 0.0 đến 1.0: static double random().

<span class='text_page_counter'>(62)</span> 12.2 Các lớp bao bọc • Lớp Integer: dùng bao bọc kiểu số nguyên. • Phương thức khởi tạo: Integer(int x) • Các hằng: static final int MAX_ VALUE=2147483647; static final int MIN_ VALUE= -2147483648.

<span class='text_page_counter'>(63)</span> • Một số phương thức: static int parseInt(String) static Integer valueOf(String) static String toString(int) int intValue() byte byteValue() int compareTo(Integer) String toString().

<span class='text_page_counter'>(64)</span> Các lớp bao bọc (tiếp) • Các lớp tương tự (tự đọc) • Lớp Byte • Lớp Long • Lớp Float • Lớp Double • Lớp Boolean • Lớp Character.

<span class='text_page_counter'>(65)</span> Luyện tập • Viết chương trình nhập mảng các đối tượng Integer. Tính tổng các đối tượng, sắp xếp các đối tượng theo thứ tự tăng và in lên màn hình..

<span class='text_page_counter'>(66)</span> 12.3 Lớp Date • Thao tác với ngày, giờ • Khởi tạo: Date(): ngày hiện hành. Date(String) Ví dụ: new Date(“10/02/2007”); Date(int year, int month, int day) Ví dụ: new Date(2007,10,2); Date(int year, int month, int day, int hour, int minute, int second).

<span class='text_page_counter'>(67)</span> Lớp Date (tiếp) • Một số phương thức: • int getDate(): ngày • int getMonth(): tháng 0..11 • int getYear(): năm tính từ 1900 • int getDay(): thứ trong tuần, 0 - CN. • int getHours(): giờ 0..23 • int getMinutes(): phút 0..59 • int getSeconds(): giây 0..59.

<span class='text_page_counter'>(68)</span> Lớp Date (tiếp) void setDate(int) void setMonth(int) void setYear(int) void setDay(int) void setHours(int) void setMinutes(int) void setSeconds(int) int compareTo(Date) boolean equals(Date).

<span class='text_page_counter'>(69)</span> Ví dụ • Chương trình cho biết Anh (chị) sinh vào thứ mấy?.

<span class='text_page_counter'>(70)</span> Đọc thêm • Các lớp liên quan đến thời gian: • DateFormat • Calendar • GregorianCalendar • Locate.

<span class='text_page_counter'>(71)</span> 12.4 Lớp String • Khởi tạo: String str = “xâu ký tự”; String str = new String(“xâu ký tự”); • Một số phương thức: • int length(): trả về chiều dài của xâu ký tự. • char charAt(int index): trả về ký tự tại vị trí index..

<span class='text_page_counter'>(72)</span> Lớp String (tiếp) • boolean equals(String str): so sánh hai xâu ký tự có giống nhau không. • boolean equalsIgnoreCase(String str): so sánh hai xâu ký tự không phân biệt chữ hoa và chữ thường. • boolean startWith(String str): kiểm tra xâu có bắt đầu bằng xâu str không. • boolean endWith(String str): kiểm tra xâu có kết thúc bằng xâu str không..

<span class='text_page_counter'>(73)</span> Lớp String (tiếp) • int compareTo(String str): so sánh xâu ký tự với xâu str, kết quả trả về số dương nếu xâu ký tự lớn hơn xâu str, 0 nếu hai xâu bằng nhau, số âm nếu xâu ký tự nhỏ hơn xâu str. • String toUpperCase(): chữ thường -> chữ hoa. • String toLowerCase(): chữ hoa->thường • String trim(): cắt bỏ khoảng trống ở đầu và cuối.

<span class='text_page_counter'>(74)</span> Lớp String (tiếp) • String substring(int startIndex) • String substring(int startIndex, int endIndex) • static String valueOf(boolean b) • static String valueOf(int i) • static String valueOf(long l) • static String valueOf(float f) • static String valueOf(double d).

<span class='text_page_counter'>(75)</span> Lớp String (tiếp) • int indexOf(int ch) • int indexOf(int ch, int fromIndex) • int indexOf(String str) • int indexOf(String str, int fromIndex) • int lastindexOf(int ch) • int lastindexOf(int ch, int fromIndex) • int lastindexOf(String str) • int lastindexOf(String str, int fromIndex).

<span class='text_page_counter'>(76)</span> Lớp String (tiếp) • String replace(char, char) • String replaceAll(String s1, String s2) • String replaceFirst(String s1, String s2) • String[] split(String st).

<span class='text_page_counter'>(77)</span> Ví dụ: tạo lớp TVString chứa các hàm về xâu ký tự. TVString + int dem(String s, char c) + int dem(String s1, String s2) + int demTu(String s) + String ten(String ht) + String ho(String ht).

<span class='text_page_counter'>(78)</span> Cài đặt TVString class TVString { public static int dem(String s, char c) { int d=0; for(int i=0; i<s.length(); i++) if(s.charAt(i)==c) d++; return d; }.

<span class='text_page_counter'>(79)</span> Cài đặt TVString (tiếp) public static int dem(String s1, String s2) { int n,d=0; n=s1.indexOf(s2); while (n>=0) { d++; n=s1.indexOf(s2,n+s2.length()); } return d; }.

<span class='text_page_counter'>(80)</span> Cài đặt TVString (tiếp) public static int demTu(String s) { int n,d=0; if (s.length()>0) d=1; n=s.indexOf(' '); while (n>=0) { d+ +; n=s.indexOf(' ',n+1); } return d; }.

<span class='text_page_counter'>(81)</span> Cài đặt TVString (tiếp) public static String ten(String ht) { int n; String kq; ht=ht.trim(); n = ht.lastIndexOf(" "); kq = ht.substring(n+1); return kq; }.

<span class='text_page_counter'>(82)</span> Cài đặt TVString (tiếp) public static String ho(String ht) { int n; String kq; ht=ht.trim(); n = ht.indexOf(" "); kq = ht.substring(0,n); return kq; }.

<span class='text_page_counter'>(83)</span> class VDString { public static void main(String args[]) { String s="Nguyen Van Anh"; System.out.println("So ky tu a trong xau la " + TVString.dem(s,'a')); System.out.println("So xau \"an\" trong xau la " + TVString.dem(s,"an")); System.out.println("So tu trong xau la " + TVString.demtu(s)); System.out.println("Ten la " + TVString.ten(s)); System.out.println("Ho la " + TVString.ho(s)); } }.

<span class='text_page_counter'>(84)</span> 12.5 Lớp StringBuffer • Lớp StringBuffer: dùng cho các xâu ký tự có thể thay đổi được. • Khởi tạo: • StringBuffer(String) • StringBuffer(int).

<span class='text_page_counter'>(85)</span> Lớp StringBuffer (tiếp) • Một số phương thức: • int length() • char charAt() • void setCharAt(int index, char ch) • StringBuffer append(String str) • StringBuffer insert(int offset, String str) • StringBuffer delete(int index) • StringBuffer delete(int start, int end).

<span class='text_page_counter'>(86)</span> Lớp StringBuffer (tiếp) • int indexOf(int ch) • int indexOf(int ch, int fromIndex) • int indexOf(String str) • int indexOf(String str, int fromIndex) • int lastindexOf(int ch) • int lastindexOf(int ch, int fromIndex) • int lastindexOf(String str) • int lastindexOf(String str, int fromIndex).

<span class='text_page_counter'>(87)</span> Lớp StringBuffer (tiếp) • StringBuffer reverse(): đảo ngược xâu. • int capacity(): khả năng chứa. • void ensureCapacity(int minCap): đặt khả năng chứa. • void setLength(int newLen): đặt chiều dài • String toString(): chuyển thành xâu..

<span class='text_page_counter'>(88)</span> Luyện tập. • Cài đặt các phương thức mã hóa và giải mã nguyên âm xâu ký tự sử dụng lớp StringBuffer. • Cài đặt phương thức chuẩn hóa xâu họ tên..

<span class='text_page_counter'>(89)</span> Bài thực hành số 3 • Bài 1. Viết các phương thức trên xâu ký tự: • Tạo xâu gồm n ký tự ch • Tạo xâu gồm n xâu str • Xóa ký tự ch. • Xóa xâu ký tự str • Mã hóa xâu theo source, destination • Chuẩn hóa các câu trong xâu. • Tách xâu thành mảng các từ.

<span class='text_page_counter'>(90)</span> Bài thực hành số 2 (tiếp) • Bài 2. Khai báo lớp SV với sơ đồ: SV -hoTen -ngaySinh -dtb + SV(String, Date, float) + layHoten() +…. + layHo() + layTen() + layDem() + layTuoi() + layXepLoai() 96.

<span class='text_page_counter'>(91)</span> DSSV -SV[] -soSV + DSSV(int) + them(SV) + laySV(int) + hienThi() + sapHoten() + sapTuoi() + sapDTB() + timTen(String) + lietKeXepLoai(String) + xoa(String).

<span class='text_page_counter'>(92)</span> • Chương trình: • Tạo một danh sách gồm 5 sinh viên. • Sắp xếp danh sách theo họ tên • Liệt kê những sinh viên giỏi • Tìm sinh viên tên Nam • Xóa sinh viên đầu tiên tên Hòa • Tính tuổi trung bình • Tăng DTB lên 0.5 cho những SV sinh trước năm 1980..

<span class='text_page_counter'>(93)</span>

Tài liệu bạn tìm kiếm đã sẵn sàng tải về

Tải bản đầy đủ ngay
×