Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

Lap trinh HDT Java, Object-Oriented Programming in Java

2,056 views

Published on

Compiled by Vu Duy-Linh. Email: vdlinh@ctu.edu.vn

Published in: Engineering
  • Be the first to comment

Lap trinh HDT Java, Object-Oriented Programming in Java

  1. 1. KHOA CỌNG NGH THỌNG TIN & TRUY N THỌNG L P TRÌNH H NG Đ I T NG JAVA Biên so n: Vũ Duy Linh CTU - 2015 Object Oriented Progamming in Java TR NG Đ I H C C N TH KHOA CỌNG NGH THỌNG TIN & TRUY N THỌNG
  2. 2. L i nói đ u Giáo trình L p trình h ng đ i t ng Java được biên soạn nh m phục vụ cho ngư i học, nhất là cho sinh viên ngành Công nghệ thông tin, có được một tài liệu học tập chính th c và hiệu quả trong môi trư ng đào tạo, giảng dạy bậc đại học c a trư ng Đại học Cần Thơ. Học phần được phân bố với số lượng là 03 tín chỉ, dành cho những đối tượng ngư i học mà đa phần chỉ mới tiếp cận được với ngôn ngữ lập trình căn bản C. Do vậy, việc cấu trúc và s p xếp kiến th c trong các chương cho giáo trình cũng được xem xét cẩn thận. Sau nhiều năm học phần này được giảng dạy, với th i lượng 02 tín chỉ lý thuyết và 01 tín chỉ thực hành, giáo trình đã xác định được cấu trúc hợp lý và chặt chẽ với kỳ vọng hướng ngư i học, từ mới b t đầu cũng như đã biết ngôn ngữ Java, đều có thể tiếp thu và đạt được mục tiêu c a học phần hướng đối tượng này. Trong đó, phần đầu giáo trình được đề cập đến những kiến th c cơ bản c a ngôn ngữ Java, sau đó sẽ được đưa từng phần kiến th c về đối tượng cũng như hướng đối tượng vào những phần tiếp theo, và cuối cùng là các kiến th c lập trình về giao diện ngư i dùng cũng như về cơ s dữ liệu. Như vậy, mục tiêu c a học phần này là ngư i học sẽ được trang bị đầy đ về các kiến th c như lập trình có cấu trúc, phân tích và thiết kế mô hình đối tượng cũng như hướng đối tượng, để từ đó có thể cài đặt chúng b ng ngôn ngữ Java, và quan trọng nhất là ngư i học có thể đọc hiểu được các sơ đồ c a những frameworks đã và đang phát triển rất mạnh gần đây c a những công nghệ như: Java, .Net hoặc .PHP,… Giáo trình bao gồm 12 chương, mỗi chương đều có ví dụ minh họa với mã nguồn chạy trên môi trư ng Java SE 5 tr lên và các bài tập yêu cầu, nh m giúp sinh viên có các bài thực hành trong phòng máy và tự rèn luyện thêm nhà. Số ví dụ và bài tập này được đề cập từ đơn giản đến nâng cao mà đích đến là các bài tập lớn theo dạng case study cho các chương chính c a lập trình hướng đối tượng, điều hữu ích cần được trải nghiệm b i sinh viên học học phần này. Với mong muốn có một tài liệu hữu ích cho sinh viên học tập và để tham khảo cho cộng đồng Java vùng đồng b ng Sông Cửu Long cũng như Việt Nam, giáo trình đã được biên soạn dựa vào kiến th c và các ví dụ minh họa từ nhiều nguồn trong và ngoài nước, cũng như từ những kinh nghiệm giảng dạy c a bản thân ngư i viết. Tuy nhiên, sự hiểu biết là hữu hạn nên những thiếu sót ch c hẳn sẽ khó tránh khỏi. Giáo trình rất mong nhận được sự chia xẻ và góp ý c a ngư i đọc cũng như c a sinh viên qua địa chỉ email: vdlinh@ctu.edu.vn, để hoàn thiện và phục vụ cho việc học và giảng dạy tốt hơn. Ngư i biên soạn, Vũ Duy Linh
  3. 3. Lập trình hướng đối tượng Java i M C L C Ch ng 1. Tổng quan v ngôn ngữ l p trình Java.....................................................1 1.1 Giới thiệu...............................................................................................................1 1.1.1 Môi trư ng phát triển ng dụng Java .............................................................1 1.1.2 Cài đặt môi trư ng phát triển ng dụng Java.................................................3 1.2 Những đặc tính và phạm vi ng dụng c a Java.....................................................5 1.2.1 Đặc tính Java ..................................................................................................5 1.2.2 Phạm vi ng dụng Java...................................................................................6 Bài tập chương 1..........................................................................................................6 Ch ng 2. L p trình Java c bản ................................................................................7 2.1 Cấu trúc chương trình Java đơn giản.....................................................................7 2.2 Các thành phần cơ bản...........................................................................................8 2.2.1 Từ khóa...........................................................................................................8 2.2.2 Kiểu dữ liệu nguyên th y ...............................................................................9 2.2.3 Danh hiệu tự đặt .............................................................................................9 2.2.4 Biến.................................................................................................................9 2.2.5 Biến h ng......................................................................................................11 2.2.6 Chú thích ......................................................................................................11 2.3 Các cấu trúc kiểm soát dòng lệnh........................................................................11 2.3.1 Lệnh rẽ nhánh if............................................................................................11 2.3.2 Lệnh rẽ nhánh switch....................................................................................13 2.3.2 Lệnh lặp có số lần xác định trước.................................................................14 2.3.2.1 Dạng 1: for..................................................................................................................... 14 2.3.2.2 Dạng 2: for-each............................................................................................................ 14 2.3.2 Lệnh lặp có số lần chưa xác định trước........................................................15 2.3.2.1 Dạng 1: while .. do......................................................................................................... 15 2.3.2.2 Dạng 2: do .. while......................................................................................................... 15 2.4 Phương th c tự định nghĩa .................................................................................16 2.4.1 Định nghĩa phương th c...............................................................................16 2.4.2 L i gọi phương th c.....................................................................................17 Bài tập chương 2........................................................................................................20
  4. 4. Lập trình hướng đối tượng Java ii Ch ng 3. Khái ni m v l p trình h ng đ i t ng................................................21 3.1 Giới thiệu.............................................................................................................21 3.1.1 Đối tượng......................................................................................................22 3.1.2 Lớp ...............................................................................................................23 3.2 Các giai đoạn phát triển hệ thống hướng đối tượng............................................24 3.2.1 Phân tích hệ thống hướng đối tượng ............................................................25 3.2.2 Thiết kế hệ thống..........................................................................................25 3.2.3 Thiết kế đối tượng ........................................................................................26 3.2.3.1 Trừu tượng hóa ............................................................................................................. 26 3.2.3.2 Thừa kế.......................................................................................................................... 28 3.2.4 Giai đoạn cài đặt...........................................................................................28 3.3 Quá trình phát triển chương trình hướng đối tượng............................................31 3.4 Các đặc tính c a lập hướng đối tượng Java ........................................................33 3.4.1 Tính trừu tượng ............................................................................................33 3.4.2 Tính bao đóng .............................................................................................33 3.4.3 Tính thừa kế ................................................................................................34 3.4.4 Tính đa hình .................................................................................................34 3.4.5 Tính bền vững ..............................................................................................35 Bài tập chương 3 .......................................................................................................36 Ch ng 4. L p, đ i t ng, truy n thông đi p và gói...............................................37 4.1 Lớp ......................................................................................................................37 4.1.1 Khái niệm .....................................................................................................37 4.1.2 Lớp tự định nghĩa.........................................................................................37 4.1.2.1 Cú pháp khai báo tổng quát .......................................................................................... 38 4.1.2.2 Kiểm soát truy cập đến các thành viên của lớp............................................................. 39 4.1.2.3 Lớp tận cùng..............................................................................................40 4.2 Đối tượng.............................................................................................................40 4.2.1 Khái niệm .....................................................................................................40 4.2.2 Tạo đối tượng ...............................................................................................40 4.3 Thành viên thể hiện và thành viên lớp ................................................................43 4.3.1 Thành viên thể hiện......................................................................................43 4.3.2 Thành viên lớp..............................................................................................43 4.4 Phương th c dựng ..............................................................................................45 4.5 Phương th c ghi và đọc.......................................................................................46
  5. 5. Lập trình hướng đối tượng Java iii 4.6 Phương th c h y ................................................................................................48 4.7 Truyền tham số....................................................................................................50 4.8 Truyền thông điệp giữa các đối tượng.................................................................57 4.9 Gói.....................................................................................................................62 Bài tập chương 4........................................................................................................65 Ch ng 5. Mảng chuẩn, l p Arrays và khung n n t p h p Java...........................67 5.1 Mảng chuẩn .........................................................................................................67 5.1.2 Mảng một chiều............................................................................................67 5.1.3 Mảng nhiều chiều .........................................................................................69 5.1.4 Truyền tham số b ng mảng ..........................................................................71 5.1.5 Lớp mảng Arrays..........................................................................................72 5.2 Khung nền tập hợp Java ......................................................................................73 5.2.1 Giới thiệu......................................................................................................73 5.2.2 Danh sách mảng ...........................................................................................74 5.2.3 Tập HashMap ...............................................................................................76 5.2.4 LinkedHashMap và LinkedHashSet.............................................................78 Bài tập chương 5........................................................................................................80 Ch ng 6. L p bao gói kiểu nguyên thủy, và các l p chuỗi ký tự..........................81 6. 1 Lớp bao kiểu nguyên th y..................................................................................81 6.2 Lớp chuỗi ký tự String.........................................................................................83 6.2.1 Khai báo và kh i tạo.....................................................................................83 6.2.2 Truyền tham số b ng chuỗi String ...............................................................84 6.3 Chuỗi StringBuffer ..............................................................................................86 6. 4 Lớp StringTokenizer...........................................................................................87 Bài tập chương 6........................................................................................................88 Ch ng 7. Bao đóng, m i k t h p và thừa k ...........................................................89 7. 1 Tính bao đóng.....................................................................................................89 7.2 Các mối kết hợp...................................................................................................90 7.2.1 Mối kết hợp phụ thuộc..................................................................................92 7.3.2 Mối kết hợp ..................................................................................................94 7.3.2.1 Mối kết hợp có hướng/một chiều................................................................................. 94 7.3.2.2 Mối kết hợp hai chiều ................................................................................................... 95 7.3.3 Mối kết hợp hạn định..................................................................................101
  6. 6. Lập trình hướng đối tượng Java iv 7.3.4 Lớp liên kết ................................................................................................102 7.3.5 Kết tập chặt.................................................................................................102 7.3.6 Kết tập lỏng ................................................................................................104 7.3.8 Mối kết hợp thực thi...................................................................................105 7.3 Thừa kế..............................................................................................................108 7.3.1 Các cơ chế trừu tượng ................................................................................108 7.3.1.1 Cơ chế phân lớp........................................................................................................... 108 7.3.1.2 Tổng quát hóa.............................................................................................................. 109 7.3.1.3 Chuyên biệt hóa........................................................................................................... 109 7.3.2 Phương pháp thiết kế..................................................................................110 Bài tập chương 7 .....................................................................................................117 Ch ng 8. Đa hình ....................................................................................................125 8.1 Khái niệm đa hình .............................................................................................125 8.2 Đa hình tĩnh.......................................................................................................126 8.3 Chuyển đổi (ép) kiểu.........................................................................................127 8.4 Đa hình động .....................................................................................................131 Bài tập chương 8 .....................................................................................................137 Ch ng 9. L p trừu t ng và giao di n .................................................................139 9.1 Khái nhiệm về lớp trừu tượng...........................................................................139 9.2 Cách khai báo lớp trừu tượng............................................................................139 9.3 Khái niệm giao diện ..........................................................................................146 9.3.1 Cú pháp khai báo........................................................................................147 9.3.2 Sự cài đặt giao diện ....................................................................................147 9.3.3 Thừa kế bội b ng giao diện........................................................................153 Bài tập chương 9 .....................................................................................................172 Ch ng 10. Ngo i l và xử lý ngo i l .....................................................................175 10.1 Giới thiệu.........................................................................................................175 10.2 Ngoại lệ.........................................................................................................176 10.2.1 Lớp chuẩn ngoại lệ Error..........................................................................177 10.2.2 Lớp chuẩn Exception .............................................................................178 10.3 Xử lý ngoại lệ................................................................................................180 10.3.1 Thẩy ngoại lệ............................................................................................180 10.3.2 Xử lý ngoại lệ...........................................................................................181 10.3.2.1 Câu lệnh try .. catch .. finally ..................................................................................... 181
  7. 7. Lập trình hướng đối tượng Java v 10.3.2.2 Lan truyền ngoại lệ.................................................................................................... 184 10.3.2 Câu lệnh kiểm ch ng biểu th c................................................................185 Bài tập chương 10....................................................................................................190 Ch ng 11. Luồng và t p tin....................................................................................191 11.1 Tập tin ............................................................................................................191 11.2 Luồng...............................................................................................................195 11.2.1 Khái niệm .................................................................................................195 11.2.2 Các luồng xuất nhập chuẩn (Stream I/O in Standard I/O) .....................196 Bài tập chương 11....................................................................................................205 Ch ng 12. Giao di n ng i dùng và k t n i c sở dữ li u ................................207 12.1 Lập trình giao diện Java với SWT...................................................................207 12.2 Lập trình giao diện Java với Swing.................................................................211 12.3 Kết nối cơ s dữ liệu........................................................................................216 Bài tập chương 12....................................................................................................228 Tài li u tham khảo.....................................................................................................229
  8. 8. Lập trình hướng đối tượng Java 1 Ch ng 1. Tổng quan v ngôn ngữ l p trình Java Chương này sẽ cung cấp cho ngư i học các kiến th c cần thiết về môi trư ng, công nghệ và các lĩnh vực ng dụng c a Java. Giúp cho ngư i mới học đ thông tin để b t tay vào việc lập trình trên môi trư ng Java, đồng th i, có cái nhìn tổng thể về công nghệ Java đã và đang phát triển và được ng dụng trên thế giới. 1.1 Gi i thi u Java là ngôn ngữ lập trình máy tính cấp cao được sử dụng rộng rãi nhất hiện nay trên thế giới. Nó được phát triển b i hãng Sun Microsystems vào năm 1991, và phiên bản đầu tiên gọi là Oak do James Gosling phát triển, đến năm 1995 tên chính th c được gọi là Java. Các nhà phát triển Java đầu tiên được kể đến là: James, Arthur Van, Karl Jacob cũng như các nhân vật nổi bật khác. Phương pháp lập trình hướng đối được Java hỗ trợ mạnh và lập trình viên được cung cấp một thư viện rất phong phú và đồ sộ để có thể triển khai các dự án nhiều cấp độ khác nhau. Ngôn ngữ Java thư ng được ưu tiên chọn lựa để phát triển các ng dụng tầm doanh nghiệp. Trong các lãnh vực IT hiện nay, ngôn ngữ Java có thể phát triển được hầu hết các loại ng dụng mà điển hình có thể kể ra là: lập trình ng dụng nền web, lập trình di động, lập trình trò chơi, lập trình mạng, phân tán và lập trình trên công nghệ đám mây (Cloud). 1.1.1 Môi tr ng phát triển ứng d ng Java Hình 1.1: Java SE Platform
  9. 9. Lập trình hướng đối tượng Java 2 th i điểm hiện nay, phiên bản Java SE 8 (Java platform standard edition) đang được sử dụng rộng rãi. Nó bao gồm bộ công cụ phát triển JDK 8 (Java SE Development Kit) và môi trư ng thực thi JRE 8 (Java SE Runtime Environment) như hình 1.1. Hình 1.2: Môi trường phát triển và thực thi chương trình Môi trư ng JRE cung cấp các lớp thư viện API (Application Programming Interface) và máy tính ảo Java (Java Virtual Machine). Máy tính ảo là công cụ thực thi mã (Java bytecode) trong tập tin .class dựa vào cách thông dịch (interpreter). Hình 1.3: Kiến trúc mã trung gian c a Java Như vậy, môi trư ng phát triển và thực thi Java được bộ JDK thực hiện qua hai giai đoạn: Biên dịch và thông dịch. Dựa vào các lệnh như java, javac mà mã nguồn Java được biên dịch thành các tập tin bytecode. Tiếp đến chúng được chuyển vào máy tính
  10. 10. Lập trình hướng đối tượng Java 3 ảo Java để thông dịch thành mã máy (machine code) tương ng cho mỗi hệ điều hành mà JVM được cài vào đó như hình 1.2. Do vậy, khác với ngôn ngữ C/C++ hoặc Delphi, Java sử dụng kiến trúc độc lập với mọi hệ điều hành (architecture independent) dựa trên mã trung gian (chính là tập tin byte code) để tạo nên một cuộc cách mạng mới cho lập trình: Viết một lần, chạy mọi nơi – write one, run anywhere như hình 1.3. 1.1.2 CƠi đặt môi tr ng phát triển ứng d ng Java Trước hết, chúng ta download bộ JDK được hỗ trợ miễn phí cho nhiều hệ điều hành như Windows, Linux, Mac OS,… Chúng ta có thể lên địa chỉ website: http://www.oracle.com/technetwork/java/javase/downloads/index.html để tải về và cài đặt vào hệ thống máy tính. Sau khi cài đặt xong, cần thiết lập biến môi trư ng để Java có thể biên dịch và thực thi từ bất kỳ nơi nào trên hệ điều hành hỗ trợ nó. Tiếp theo, chúng ta cũng cần tải và cài đặt các phần mềm hỗ trợ soạn thảo mã nguồn. giai đoạn mới học tập, ngư i học có thể sử dụng các trình soạn thảo văn bản đơn giản như: NotePad++, jEdit, EditPlus, KompoZer,… hoặc các phần mềm có hỗ trợ môi trư ng phát triển tích hợp (Integrated Development Environment) như: NetBeans IDE, Eclipse IDE, JCreator IDE,... để soạn thảo các ng dụng đơn giản cũng như phát triển các ng dụng dựa trên các khung làm việc (Frameworks) phải cấu hình ph c tạp. Một số links hữu ích cho các phần mềm này như: https://netbeans.org/, http://www.eclipse.org/, http://www.jcreator.com/,... Một số lệnh chế độ command line sau khi đã cài đặt JDK: javac: Trình biên dịch java java : Chạy ng dụng độc lập jdb : Gỡ rối (Java Debugger) appletviewer : Chạy ng dụng applets javap: Để in mã trung gian Java (bytecodes) javah: Tạo ra header files cho ngôn ngữ C. Ví d 1.1: Sử dụng trình soản thảo như NotePad++, EditPlus, hoặc Wordpad rồi nhập vào mã lệnh java (source code) như chương trình đơn giản sau: //Filename: HelloJavaApp.java public class HelloJavaApp { public static void main(String[] args) { System.out.println("Hello! This is a Java application..."); } } Biên dịch mã nguồn: javac HelloJavaApp.java ↲ (Tạo file: HelloJavaApp.class) Thực thi chương trình: java HelloJavaApp
  11. 11. Lập trình hướng đối tượng Java 4 Kết quả chạy chương trình: Hello! This is a Java application… Ví d 1.2: Viết ng dụng Java b ng Netbean IDE Hình 1.4: Cấu trúc dự án đơn giản trên Netbean IDE Ví d 1.3: Viết chương trình tính cộng 2 số a và b, với a, b là 2 số bất kỳ được nhập từ bàn phím theo cách nhập từ đối số dòng lệnh (command line) package ctu.vdlinh.chapter1; /** * @author Vũ Duy Linh */ public class Cong { public static void main(String[] args) { double a, b; a = Double.parseDouble(args[0]); b = Double.parseDouble(args[1]); System.out.printf("a + b= %.2fn", a+b); } } * Từ dấu nh c lệnh c a MS-DOS hoặc Linux gõ lệnh: java ctu.vdlinh.chapter1 Cong 5.5 12.7 ↲ * Từ Netbean IDE 7.4: Vào ch c năng Run/Set Project Configuration/Customize... để thiết lập các đối số:
  12. 12. Lập trình hướng đối tượng Java 5 Hình 1.5: Xác định giá trị cho các đối số c a phương th c main trong Netbean * Từ Eclipse Mars IDE : Vào ch c năng Run/Run Configurations... để thiết lập các đối số đầu vào c a chương trình: Hình 1.6: Xác định giá trị cho các đối số c a phương th c main trong Eclipse 1.2 Những đặc tính và ph m vi ứng d ng của Java 1.2.1 Đặc tính Java Java là ngôn ngữ bậc cao, có tính thân thiện, đơn giản và dễ sử dụng. Java là ngôn ngữ kh i sướng việc sử dụng kiến trúc mã trung gian nên nó cần được biên dịch (compiled) và thông dịch (interpreted) để chạy chương trình. Bên cạnh đó, ngôn ngữ Java có có tính định kiểu mạnh, tư ng minh và hướng đối tượng. Điểm nổi bật nhất là Java có tính bảo mật (secure) cao và an toàn hơn các ngôn ngữ khác do được kiểm tra an toàn trước từng bước (ngôn ngữ  biên dịch  thực thi: tính đóng gói  .java  .class  class loader  machine code) nên từ bên ngoài khó có thể xâm nhập vào chương trình được.
  13. 13. Lập trình hướng đối tượng Java 6 Đặc tính quan trọng nữa là Java có tính khả chuyển cao vì JVM dựa trên nền tảng chính POSIX (Portable Operating System Interface [for Unix]) – Giao diện hệ điều hành linh động: Cung cấp mã nguồn di động cho các thiết bị đầu cuối, ngoại vi. Nó cung cấp khả năng lập trình phân tán (distribution): Hỗ trợ TCP, UDP, Socket và Network communication: Applets, servlets, aglets – hệ thống mobile agents, remote method invocation (RMI), Common Object Request Broker Architecture (CORBA),… 1.2.2 Ph m vi ứng d ng Java Java là nền tảng cho hầu như mọi loại ng dụng mạng và là tiêu chuẩn toàn cầu cho việc phát triển và cung cấp các ng dụng nhúng và di động, trò chơi, ng dụng web, và phần mềm doanh nghiệp. Với hơn 9 triệu nhà phát triển trên toàn thế giới, Java cho phép bạn để phát triển và triển khai các ng dụng, các dịch vụ một cách hiệu quả. Hiện nay, có thể nói, phạm vi ng dụng c a ngôn ngữ và công nghệ Java có mặt kh p mọi nơi: Từ máy tính xách tay đến trung tâm dữ liệu, từ ng dụng Console cho đến siêu máy tính khoa học, từ điện thoại di động đến ng dụng Internet. Dưới đây là các thông tin về ng dụng c a công nghệ Java theo http://www.java.com/en/about/  97% of Enterprise Desktops Run Java  89% of Desktops (or Computers) in the U.S. Run Java  9 Million Java Developers Worldwide  #1 Choice for Developers  #1 Development Platform  3 Billion Mobile Phones Run Java  100% of Blu-ray Disc Players Ship with Java  5 Billion Java Cards in Use  125 million TV devices run Java  5 of the Top 5 Original Equipment Manufacturers Ship Java ME Bài t p ch ng 1 Bài 1.1: Sử dụng trình soạn thảo tùy ý, viết chương trình hiển thị câu ca dao: “Công cha như núi Thái Sơn, Nghĩa mẹ như nước trong nguồn chảy ra. Một lòng thờ mẹ kính cha, Cho tròn chữ hiếu mới là đạo con!” Bài 1.2: Sử dụng Netbean IDE, Eclipse IDE, JCreator IDE hoặc trình soạn thảo văn bản tùy ý để viết chương trình hiển thị kết quả phép nhân hai số nguyên được nhập từ dòng lệnh command line.
  14. 14. Lập trình hướng đối tượng Java 7 Ch ng 2. L p trình Java c bản Chương này sẽ trình bày các kiến th c c a ngôn ngữ lập trình Java căn bản để giúp cho ngư i học, học môn L p trình h ng đ i t ng Java, được dễ dàng hơn. Tuy nhiên, giáo trình chỉ trình bày ng n gọn các kiến th c Java cơ bản vì ngư i học đã được học phần L p trình căn bản như C. Các kiến th c bao gồm cấu trúc một chương trình Java cơ bản, các từ khóa, các kiểu dữ liệu cơ bản/nguyên th y, câu lệnh có cấu trúc rẽ nhánh và lặp, phân biệt sự khác biệt giữa dạng hàm và th tục c a phương th c,… Có thể nói, m c độ lập trình căn bản, ngôn ngữ lập trình C và Java giống nhau nên ngư i học cần dành th i gian để tự rèn luyện phần Java căn bản này thông qua các kiến th c đã được học ngôn ngữ C. Trong học phần này, giáo trình cũng dành hơn một phần sáu th i lượng thực hành để sinh viên được hướng dẫn từ giảng viên. 2.1 C u trúc ch ng trình Java đ n giản Cấu trúc chương trình Java dạng aplication cần có ít nhất một lớp chính (main class). Lớp chính là lớp mà có ch a phương th c main. Khái niệm về lớp và đối tượng sẽ được trình bày chi tiết trong phương pháp lập trình hướng đối tượng (HĐT) các phần sau. Cấu trúc cơ bản c a một chương chương trình Java có dạng như hình 2.1. Hình 2.1: Cấu trúc chương trình Java cơ bản Ví d 2.1: Minh họa cấu trúc chương trình đơn giản c a ngôn ngữ Java với chỉ một lớp chính (main class). Các câu lệnh ví dụ trên được giải thích như sau: Dòng (1): Tạo các gói (package) là ctu.vdlinh.simple Dòng (3) đến (8): Phần mô tả chương trình. Đây là phong cách lập trình chuyên nghiệp mà lập trình viên cần lưu ý khi viết và chuyển giao dự án. Dòng (9): Nạp thư viện cần thiết cho chương trình.
  15. 15. Lập trình hướng đối tượng Java 8 Dòng (11) đến (15) là lớp chính, FirstSample. Lớp chính là lớp có ch a phương th c main trong nó. Khi là lớp chính, nó phải được lưu tên tập tin (file name) trùng với tên lớp, FirstSample.java. Từ khóa public sẽ chỉ ra lớp hoặc phương th c đó được truy cập mọi nơi c a dự án. Từ khóa static c a phương th c main được gọi là phương th c lớp, và phương th c này có thể được gọi mà không cần phải kh i tạo đối tượng c a lớp ch a nó (phương th c static chỉ được phép truy xuất tới các biến static c a lớp do đã được fix sẵn trong bộ nhớ). Còn từ khóa void xác định đây là một phương th c dạng th tục: không trả về (return;) giá trị nào cả khi phương th c thực hiện xong. 2.2 Các thành ph n c bản 2.2.1 Từ khóa Từ khóa (keywords) là các từ dành riêng cho ngôn ngữ Java, nó có ý nghĩa và ch c năng đã được xác định, và không được dùng nó vào các việc khác hoặc đặt tên danh hiệu trùng với các từ khóa này. Dưới đây là danh sách một số từ khóa thông dụng c a ngôn ngữ Java: abstract default if private this assert do implements protected throw boolean double import public throws break else instanceof return transient byte enum int short try case extends interface static void catch final long strictfp volatile char finally native super while class float new switch continue for package synchronized
  16. 16. Lập trình hướng đối tượng Java 9 2.2.2 Kiểu dữ li u nguyên thủy Kiểu nguyên thuỷ (primitive data type): Còn được gọi là kiểu căn bản, đó là kiểu mà các phép toán được dịch trực tiếp sang các lệnh c a máy (operational data). Vì Java là một ngôn ngữ định kiểu mạnh nên khi khai báo biến, h ng, chúng ta cần xác định cho chúng một kiểu dữ liệu nhất định. Kiểu Kích th c Khoảng giá tr boolean 8 bit true hoặc false byte 8 bit -128 đến 127 short 16 bit -32,768 đến 32,767 int 32 bit -2,147,483,648 đến +2,147,483,647 long 64 bit -9,223,372,036,854,775,808  +9,223,372,036,854,775,807 char 16 bit u0000 đến uFFFF (chuẩn unicode) float 32 bit -3.40292347E+38  +3.40292347E+38 double 64 bit -1.7976931348623157E+308  +1.7976931348623157E+308 2.2.3 Danh hi u tự đặt Quy t c đặt tên danh hiệu (identifier): B t đầu b ng một chữ cái, một dấu gạch dưới, hoặc một dấu dollard ($), không có khoảng tr ng, không trùng với các từ khoá và có phân biệt chữ hoa chữ thư ng. Trong lập trình, các danh hiệu được sử dụng phổ biến cho đặt tên biến, h ng, tên kiểu/lớp ngư i dùng. Ví d 2.2: Đặt tên cho biến, h ng, tên phương th c… theo quy ước camel-case Danh hiệu tự đặt hợp lệ: myList1, x1, tinhDelta… Danh hiệu không hợp lệ: my List1, 1x, tinh-Delta,… Ví d 2.3: Đặt tên lớp ngư i dùng theo quy ước proper-case Đúng style: SinhVien, GiangVien, DBConnection,… //chuyên nghiệp Sai style: sinhvien, giangVien, DBconnection,… //không nên sử dụng 2.2.4 Bi n Biến (variable): Theo định nghĩa c a Khoa học máy tính, biến gồm một số ô nhớ được định danh duy nhất b i một danh hiệu. Chúng ta sử dụng biến để ch a một giá trị nào đó thuộc một kiểu dữ liệu xác định trước, và giá trị c a nó có thể thay đổi trong quá trình thực thi chương trình. Cách 1: Khai báo và kh i tạo riêng biệt kiểu_nguyên_thuỷ tên_Biến;
  17. 17. Lập trình hướng đối tượng Java 10 tên_Biến = giá_trị; Cách 2: Khai báo và kh i tạo đồng th i kiểu_nguyên_thuỷ tên_Biến = giá_trị; Mỗi biến được khai báo chỉ tồn tại trong phạm vi (scope) c a nó – tương tự như ngôn ngữ C đã học. Cần chú ý việc chuyển kiểu để tương thích với nhau, như minh họa th tự gán hợp lệ: double  float  long  int  short, char  byte. Ví d 2.4: Khai báo và kh i tạo đúng cho các biến Boolean kiemTra = true; byte b = 100; short s = -100; int tich = 1; int decVal = 26; int octVal = 032; int hexVal = 0x1a; float diemTrB = 9.5f; double dienTich = 7278.25; char capitalC = 'C'; char unicodeC='u1EE9'; // Java sử dụng UTF-16 String uniGreeting="Chu00e0o bu00e9: Vu0169u0020Duyu0020Thu1EE9c!" Hình 2.2: Hiển thị chuỗi ký tự unicode Việc cấp pháp bộ nhớ cho các biến kiểu nguyên th y được quản lý b i Stack trong JVM nên mỗi biến đều được cấp phát một địa chỉ riêng biệt như sau: Hình 2.3: Sơ đồ cấp phát bộ nhớ cho kiểu nguyên th y
  18. 18. Lập trình hướng đối tượng Java 11 2.2.5 Bi n hằng H ng (constant) cũng tương tự như biến ngoại trừ nó giữ một giá trị cố định (hay được gọi là các biến chỉ đọc). Trong Java, chúng được khai báo b i từ khóa final và quy định viết in hoa (upper-case), chẳng hạn như: final int SI_SO = 40; final double PI = 3.1428; Ví d 2.5: Viết chương trình với một lớp chính để nhập bán kính r c a hình tròn, tính diện tích và hiển thị các thông tin c a nó lên màn hình b ng Eclipse IDE: /** * Filename: HinhTron.java */ package ctu.vdlinh.chapter2; public class HinhTron { public static void main(String[] args) { final double PI = 3.1428; // hằng PI double bk = 5.5; // biến bán kính double dt; // biến diện tích dt = PI * bk * bk; System.out.println("Bán kính= " + bk + ", diện tích= " + dt); } } 2.2.6 Chú thích Java cung cấp 03 kiểu ghi chú thích (comments) khác nhau: Cặp dấu /* */ được sử dụng cho chú thích có nhiều hàng Cặp dấu xổ trái // được sử dụng cho chú thích đơn hàng Cặp dấu /** */ được sử dụng để tạo tài liệu Sử dụng Javadoc để tạo tập tin hướng dẫn dạng .html cho cácchú thích trong cặp dấu /** và */ 2.3 Các c u trúc kiểm soát dòng l nh 2.3.1 L nh rẽ nhánh if Trong Java có 3 dạng câu lệnh if Dạng 1: if if (booleanExpression) { statement(s); //Khối lệnh với điều kiện true }
  19. 19. Lập trình hướng đối tượng Java 12 Dạng 2: if .. else if (booleanExpression) { true-statement(s); //Khối lệnh với điều kiện true } else { false-statement(s); //Khối lệnh với điều kiện false } Ví d 2.6: Chương trình minh họa sử dụng lệnh if .. else //File name: LenhIfElse.java package edu.vdlinh.chapter2; public class LenhIfElse { public static void main(String[] args) { double markIELTS = 7.0; if (markIELTS >= 6.5) { System.out.println("Chúc mừng bạn!"); System.out.println("Bạn thật giỏi Anh văn!" ; } else { System.out.println("Hãy luyện tập và thử lại!"); } } } Một toán tử điều kiện (conditional operator) có ch c năng tương tự như lệnh if .. else trên là dạng booleanExpr ? trueExpr : falseExpr; Ví d 2.6: Minh họa toán tử điều kiện để tìm giá trị nhỏ hơn c a hai số nguyên. int a =10, b =17; int min = (a < b) ? a : b; D ng 3: if .. elseif .. elseif .. else (nested-if) if (booleanExpr_1) { block_1; //Khối lệnh 1 } else if (booleanExpr_2){ block_2 ; //Khối lệnh 2 } else if ( booleanExpr_3 ) { ... // Khối lệnh tiếp theo } else {
  20. 20. Lập trình hướng đối tượng Java 13 block_else ; // Khối lệnh cuối cho else } Ví d 2.7: Minh họa lệnh sử dụng nested-if cho 5 trư ng hợp phân biệt nhau if (diemThi >= 8.5) System.out.println("A"); else if (diemThi >= 7.5) System.out.println("B"); else if (diemThi >= 6.5) System.out.println("C"); else if (diemThi >= 4.0) System.out.println("D"); else System.out.println("F"); 2.3.2 L nh rẽ nhánh switch switch (evaluatedExpression) { case constantExpr_1: block_1; break; case constantExpr_2: block_2; break; … case constantExpr_n: block_n; break; default: default_block; } Chú ý: Khác với lệnh if trên, biểu th c chọn lựa evaluatedExpression để rẽ nhánh trong lệnh switch có kiểu r i rạc như: int, char, hoặc enum. Ví d 2.8: Minh họa sử dụng câu lệnh rẽ nhánh switch với kiểu liêt kê (enum) //File name: JavaEnumSwitchCase.java package ctu.vdlinh.chapter2; public class JavaEnumSwitchCase{ enum ThucUong {
  21. 21. Lập trình hướng đối tượng Java 14 Coffee, LaVie, Camvat } public static void main(String[] args) { ThucUong chon = ThucUong.Coffee; switch (chon) { case Coffee: System.out.println("Bạn chọn uống cafe. "); break; case LaVie: System.out.println("Bạn chọn nước suối Lavie."); break; case Camvat: System.out.println("Bạn chọn uống nước cam vắt."); break; } } } 2.3.2 L nh lặp có s l n xác đ nh tr c 2.3.2.1 Dạng 1: for for ( initialization; booleanExpression; step ){ statement(s); } Trong đó: initialization để kh i tạo giá trị ban đầu c a biến chạy; boolean-expression: là điều kiện dừng, step: bước nhảy tăng hoặc giảm. Ví d 2.9: Đoạn mã minh họa lệnh lặp với biến chạy i có giá trị đầu (kh i tạo) là 1 và giá trị cuối là 9 với bước nhảy là 2 rồi hiển thị nó. for (int i = 1; i < 10; i+=2) { System.out.print(i +"t"); } Kết quả của câu lệnh for là: 1 3 5 7 9 2.3.2.2 Dạng 2: for-each for ( datatype variable: array | collection ){ statement(s); }
  22. 22. Lập trình hướng đối tượng Java 15 Câu lệnh for-each được sử dụng rất phổ biến trong lập trình kiểu đối tượng như ngôn ngữ Java. Trong hầu hết các mã lệnh, lập trình viên đều sử dụng collection để quản lý các đối tượng cho hiệu quả và tối ưu. Ví d 2.10: Minh họa sử dụng câu lệnh for-each trên kiểu enum //File name: JavaEnumSwitchCaseExample.java package ctu.vdlinh.chapter2; public class JavaEnumSwitchCaseExample { enum WeekDay { Sun, Mon, Tue, Wed, Thu, Fri, Sat } public static void main(String[] args) { System.out.print("Days of week: "); for (WeekDay day : WeekDay.values()) { System.out.print(day + ", "); } } } 2.3.2 L nh lặp có s l n ch a xác đ nh tr c 2.3.2.1 Dạng 1: while .. do while (booleanExpression) { statement(s); } Đây là dạng vòng lặp kiểm tra điều kiện trước khi thực hiện công việc hay khối lệnh. Nó sẽ lặp cho đến khi điều kiện tr thành false thì ngừng. Ví d 2.11: Minh họa sử dụng câu lệnh while .. do với mỗi bước lặp là tăng 2 int i = 1; while (i < 10) { System.out.print(i +"t"); i += 2; } Kết quả c a câu lệnh while .. do là: 1 3 5 7 9 2.3.2.2 Dạng 2: do .. while do { statement(s); } while (booleanExpression);
  23. 23. Lập trình hướng đối tượng Java 16 Tương tự như while .. do trên nhưng nó sẽ thực hiện công việc hay khối lệnh trước rồi mới kiểm tra điều kiện. Ví d 2.12: Minh họa sử dụng câu lệnh do .. while với ít nhất một lần công việc (statements) được thực hiện. int i = 1; do { System.out.print(i +"t"); i += 2; }while (i < 10 ); Kết quả c a câu lệnh do .. while là: 1 3 5 7 9 2.4 Ph ng thức tự đ nh nghĩa trong các phương pháp lập trình trước đây như lập trình hướng th tục, các đoạn lệnh mà có ch c năng riêng biệt hoặc lặp đi lặp lại nhiều lần thư ng được tách thành các th tục (procedure) hoặc hàm (function) riêng biệt khỏi chương trình chính (phương th c main) và thư ng được gọi là các chương trình con (sub-program). Lợi ích c a chương trình con là hữu dụng vì tính module hóa theo từng ch c năng, tránh lặp lại các dòng code, và khả năng tái sử dụng. 2.4.1 Đ nh nghĩa ph ng thức Trong giáo trình này, lập trình theo phương pháp hướng đối tượng, th tục và hàm được gọi là phương th c (method). Phương th c ngư i dùng (lập trình viên) tự định nghĩa (user-defined method) có cú pháp như sau: [modifiers] returnType methodName([ parameterList ] ){ Body; //Gồm declarations; và statements; } Tên phương th c (methodName): Là phần b t buộc phải có. Nó thư ng được đặt theo dạng động từ vì hàm ch a ý nghĩa cho một thao tác (operation), một ng xử (behavior), hay thông điệp (message) nào đó c a đối tượng. Danh sách các tham số (parameterList): Mỗi tham số bao gồm (tên) tham số hình th c (formal parameter) và kiểu dữ liệu (data type) c a nó. Nếu có nhiều tham số thì chúng sẽ được phân cách nhau b i dấu phẩy. Tên phương th c và danh sách các tham số c a nó được gọi chung là chữ ký phương th c (method signature). Các bổ từ (modifiers): Chúng là một trong những từ khóa c a bổ từ truy cập như: public, protected, private hoặc mặc định để trống (friendly) nh m xác định phạm vi truy cập c a phương th c này khi được gọi và/hoặc các bổ từ khác như static, abstract, synchronized,... Kiểu dữ liệu trả về (returnValueType) : Khi một phương th c dạng hàm thì cần phải trả về một kết quả cho nó thông qua câu lệnh return ketQuaTraVe; còn khi phương th c dạng th tục ta sử dụng câu lệnh return; để không trả về kết quả nào cả.
  24. 24. Lập trình hướng đối tượng Java 17 Thân phương th c (body method): Bao gồm khối các câu lệnh để khai báo biến, h ng cục bộ (phạm vi hoạt động chỉ trong phương th c ch a nó) và các câu lệnh tuần tự để thực hiện các nhiệm vụ theo ý c a lập trình viên và/hoặc trả về kết quả tính được cho phương th c. Ví d 2.13: Phương th c tính tổng hai số thực public static final double tinhTong(double a, double b){ double tong; //khai báo cục bộ (local) tong = a + b; //lệnh tính tổng; return tong; //lệnh trả về giá trị cho phương thức hàm } 2.4.2 L i g i ph ng thức Để phương th c được thực thi (run), thì phương th c đó phải được gọi thông qua tên phương th c và các tham số thực (actual parameters) được truyền đến cho các tham số hình th c (formal parameters) nếu có. Ví d 2.14: Viết chương trình giải phương trình bậc nhất ax +b = 0
  25. 25. Lập trình hướng đối tượng Java 18 Ví d 2.15: Tính dãy Fibonacci được định nghĩa: F1 = 1, F2 = 1 và Fn = Fn - 2 + Fn -1. Hãy in dãy n số Fibonacci theo hai cách đệ quy và không đệ quy, với n là một số nguyên dương được nhập từ bàn phím. // Filename: Fibonacci.java package ctu.vdlinh.chapter2; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class Fibonacci { void nonRecursiveFibo(int m){ //không đệ quy System.out.print("1"); int i=2; //xử lý từ số đến m int f1=0, f2=1, f3; while(i <= m){ f3 = f1 + f2; System.out.print("t"+f3); f1 = f2; f2 = f3; i++; } System.out.println(); } int recursiveFibo(int m){ //đệ quy if(m <= 2)return 1; else return recursiveFibo(m-1) + recursiveFibo(m-2); } public static void main(String arg[])throws IOException { BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); System.out.print("Nhập giá trị n= "); int n = Integer.parseInt(br.readLine()); System.out.println("Dãy n số Fibonacci không đệ quy) là:"); Fibonacci fibo = new Fibonacci(); fibo.nonRecursiveFibo(n); System.out.println("Dãy n số Fibonacci đệ quy) là:"); for(int i=1; i<=n; i++) {
  26. 26. Lập trình hướng đối tượng Java 19 System.out.print(fibo.recursiveFibo(i) + "t"); } System.out.println(); } } Kết quả chạy chương trình: Nhập giá trị n= 9 Dãy n số Fibonacci không đệ quy) là: 1 1 2 3 5 8 13 21 34 Dãy n số Fibonacci đệ quy) là: 1 1 2 3 5 8 13 21 34 Ví d 2.16: Viết chương trình nhập một số nguyên dương n>=2, in các số nguyên tố tìm được trong các số từ 1 đến n, với số nguyên tố là số chỉ chia hết cho 1 và chính nó. // File name: SoNguyenTo.java package ctu.vdlinh.chapter2; import java.util.Scanner; public class SoNguyenTo { public static void main(String[] args) { Scanner scan = new Scanner(System.in); System.out.print("Nhập số nguyên dương n= " ; short n = scan.nextShort(); scan.close(); System.out.println("Dãy các số nguyên tố tìm được:"); for (short i = 1; i <= n; i++) { //kiểm tra i có là số nguyên tố không short dem = 0; for(short j=1; j<= i/2; j++){ //nên viết theo while/do if(i % j == 0) dem++; } if(dem == 1) // i là SNT System.out.printf("%4d", i); } System.out.println(); } }
  27. 27. Lập trình hướng đối tượng Java 20 Chạy thử chương trình: Nhập số nguyên dương n= 0 Dãy các số nguyên tố tìm được: 2 3 5 7 Bài t p ch ng 2 Bài 2.1: Viết chương trình giải phương trình ax + b = 0, với a, b là hai số thực được nhập tùy ý từ bàn phím. Bài 2.2: Viết chương trình giải phương trình ax2 + bx + c = 0, với các hệ số kiểu số thực được nhập tùy ý từ bàn phím. Bài 2.3: Viết chương trình nhập hai số thực a, b bất kỳ từ bàn phím. Hãy viết các phương th c sau: a. phuongThucCong(a, b) // cộng hai số a và b b. phuongThucTru(a, b) // trừ hai số a và b c. phuongThucNhan(a, b) // nhân hai số a và b d. phuongThucChia(a, b) // chia hai số a và b rồi tính biểu th c a ba S    25 /)5(*12 // sử dụng các phương th c trên Bài 2.4: Viết chương trình tính n!, với n được nhập từ bàn phím. Bài 2.5: Viết chương trình nhập vào 2 số nguyên dương n và một số thực a tùy ý. Hãy tính và in kết quả lên màn hình cho biểu th c S1 và S2 như sau: n naaaaS  ...321 32 !...!3!21 ... 2 32 n aaaa S n   
  28. 28. Lập trình hướng đối tượng Java 21 Ch ng 3. Khái ni m v l p trình h ng đ i t ng Thế giới hiện hữu là các đối tượng, bao gồm thế giới tự nhiên và nhân tạo. Làm sao để đưa các đối tượng hữu hình và vô hình c a bài toán vào trong hệ thống máy tính là mục tiêu c a môn học. Chương này, giáo trình sẽ đề cập đến các khái niệm cơ bản c a phương pháp lập trình đối tượng, hướng đối tượng đó là: Đối tượng, lớp các đối tượng, quá trình phân tích và mô hình đối tượng để ánh xạ thế giới thực vào máy tính. Đồng th i cũng đưa ra những đặc tính, những ưu điểm c a phương pháp hướng đối tượng so với các phương pháp lập trình trước đó. 3.1 Gi i thi u Trong khoa học máy tính, thông thư ng, khi viết chương trình chúng ta thư ng dựa trên một phương pháp lập trình nào đó. Thông qua học phần Lập trình căn bản A b ng ngôn ngữ Pascal hoặc C, chúng ta đã làm quen với các phương pháp tiếp cận th tục (Procedural programming). Với phương pháp này, mã lệnh được module dựa trên các dựa trên các chương trình con (routines hoặc subroutines) để tránh sự lặp lại c a các dòng lệnh được thực hiện nhiều lần. Phương pháp lập này đã được sử dụng phổ biến từ những năm 1970, tuy nhiên nó tồn tại những khuyết điểm, bất lợi đối với xu hướng phát triển c a lãnh vực công nghệ phần mềm như: Khó thể hiện những thực thể trong tự nhiên, khó bảo trì, không bảo mật, chỉ phù hợp với những dự án nhỏ. Ngược lại, triết lý c a lập trình hướng đối tượng lại tập trung vào các đối và sự tương tác c a chúng trong không gian c a bài toán. Và hệ thống ng dụng sẽ được xây dựng dựa trên mô hình các đối tượng này. Vì các đối tượng và sự tương tác c a chúng thuộc nhiều ch ng loại và rất đa dạng trong tự nhiên cũng như những sản phẩm nhân tạo (thế giới thực), nên một ng dụng phần mềm được phát triển b ng cách sử dụng phương pháp lập trình hướng đối tượng sẽ có tính tương đồng và sát với thực tế hơn so với các phương pháp lập trình hướng th tục hoặc có cấu trúc. Hình 3.1: Các đối tượng và sự tương tác giữa chúng trong hệ thống Về mặt kỹ thuật, phương pháp lập trình dạng th tục thư ng xem nhẹ việc bảo vệ dữ liệu mà đặt nặng vào việc sử dụng các thuật toán để áp lên các dữ liệu nh m đạt được kết quả mong muốn (Program = Data structure + Algorithm). Ngược lại với phương pháp
  29. 29. Lập trình hướng đối tượng Java 22 trên, phương pháp lập trình HĐT lại nâng dữ liệu lên hàng ưu tiên. Điều này được thực hiện b ng cách đóng gói các dữ liệu và các phương th c phương th c biến đổi (Mutator methods /Setters) và phương th c truy cập (Accessor methods /Getters) mà chúng có quyền truy cập đến dữ liệu vào trong một đơn vị duy nhất đó là chính là đối tượng (Object). Hình 3.2: Sự khác biệt quan điểm c a hai phương pháp lập trình 3.1.1 Đ i t ng Đối tượng (object) là một khái niệm rất trực quan và phổ biến trong thế giới thực, nó là một đối tượng bất kỳ thuộc vào một loài nào đó trong tự nhiên, trong các thực thể nhân tạo, trong kinh doanh, trong các sản phẩm sử dụng, v.v… như hình 3.3. Hình 3.3: Các đối tượng trong môi trường học tập Mỗi đối tượng phần mềm (software object) là khái niệm tương tự như các đối tượng trong thế giới thực: chúng cũng bao gồm các trạng thái (state) và và các hành vi
  30. 30. Lập trình hướng đối tượng Java 23 (behavior) c a nó. Trạng thái đại diện giá trị dữ liệu c a đối tượng (object’s data), còn hành vi là các thao tác mà đối tượng đó có thể thực hiện như hình 3.4. Hình 3.4: Một đối tượng phần mềm Ví d 3.1: Từ vi.wikipedia.org, có đưa các thông tin về danh hài Hoài Linh. Để minh họa cho khái niệm đối tượng, một số thông tin được trích ra như hình 3.5. Hình 3.5: Danh hài Hoài Linh Danh hài Hoài Linh này, hiển nhiên, là một đối tượng con ngư i, và được sống trong cộng đồng các đối tượng con ngư i khác. Một số thông tin c a đối tượng này gồm: họ tên là ắNguyễn Bảo Hoài LinhẰ, phái là nam, và tuổi hiện tại là 45, … Đối tượng này có các hành vi như diễn hài, làm MC, giám khảo,... Khi cần, danh hài này có thể tương tác với các đối tượng xung quanh khác b ng các hành vi như diễn kịch cho khán giải xem, làm giám khảo cho các thí sinh dự thi,…. Như vậy các thông tin này chính là trạng thái hiện hành c a đối tượng. Có những trạng thái bất biến theo th i gian như họ tên, phái, nhưng cũng có trạng thái thay đổi như tuổi chẳng hạn. Các hành vi thì luôn luôn tồn tại trong đối tượng này, nhưng mỗi th i điểm thì đối tượng này có thể có những hành vi khác nhau, chẳng hạn có ngày thì diễn kịch, có ngày thì làm MC,… 3.1.2 L p Lớp (class) là một nguyên mẫu (prototype) định nghĩa cấu trúc cho sự đại diện các đối tượng có chung những đặc điểm (thuộc tính và các hành vi) c a chúng. Các đặc điểm này phải cung cấp được các thông tin khi đề cập đến nhóm đối tượng thuộc lớp đó và được gọi là thuộc tính c a đối tượng (object attributes). Các hành vi được sử chung cho
  31. 31. Lập trình hướng đối tượng Java 24 các đối tượng cùng loại được gọi là hoạt động/phương th c c a đối tượng (object operations). Theo Booch: một lớp là một tập các đối tượng chia sẻ từ một cấu trúc và hành vi chung (A class is a set of objects that share a common structure and a common behavior). Hình 3.6: Các đối tượng cùng chung một cấu trúc lớp Student Trên sơ đồ sử dụng ký hiệu UML, một lớp có 03 phần đó là: Tên lớp (class name), các thuộc tính (attributes) và các hành vi (operations). Với ngôn ngữ lập trình, chúng được gọi là các trư ng (fields) và các phương th c (methods) tương ng. Ví d 3.2: Lớp DienVien, được viết b ng ngôn ngữ giả và theo sơ đồ UML class DienVien Fields: //các trư ng hoTen gioiTinh tuoi Methods: //các phương th c dienHai(){…} lamGiamKhao(){…} lamMC(){…} Giả sử, trên sân khấu (hệ thống) có 3 diễn viên hài khác nhau như: Trư ng Giang, Chí Tài, và Hoài Linh, thì từ lớp DienVien tạo ra 3 đối tượng diễn viên với các định danh là dienVien1, dienVien2, dienVien3. 3.2 Các giai đo n phát triển h th ng h ng đ i t ng Phát triển hệ thống hướng đối tượng đòi hỏi các kỹ thuật hướng đối tượng (Object-Oriented techiques) được sử dụng trong suốt quá trình phân tích và cài đặt c a hệ thống. Phương pháp này đòi hỏi ngư i phân tích phải xác định được các đối tượng trong hệ thống là cái gì, chúng sẽ ng xử (behave) như thế nào theo th i gian hoặc trong
  32. 32. Lập trình hướng đối tượng Java 25 sự đáp ng (response) lại với các sự kiện, và các mối quan hệ nào giữa đối tượng này với các đối tượng khác trong hệ thống. Hình 3.7: Các khái niệm chính c a hướng đối tượng Mô hình hóa đối tượng (Object modeling) được dựa trên sự xác định (identifying) các đối tượng trong hệ thống và mối quan hệ giữa chúng. Các giai đoạn cơ bản vệc thiết kế hệ thống sử dụng mô hình hóa đối tượng là: Phân tích (Analysis stage), thiết kế hệ thống (System design stage), thiết kế đối tượng (Object design stage) và cuối là sự cài đặt chúng (Implementation). 3.2.1 Phân tích h th ng h ng đ i t ng Phân tích hệ thống (System analysis stage) là giai đoạn đầu tiên c a phát triển phần mềm và cũng là bước đầu tiên trong kỹ thuật mô hình hóa đối tượng (OMT) mà triết lý c a nó là xem hệ thống ban đầu như là một tập các hệ thống con nhỏ hơn mà trong đó mỗi hệ thống con gồm các đối tượng tương tác với nhau. Do vậy, ngư i phát triển (developer) hệ thống cần tham khảo với các ngư i dùng để tìm ra những yêu cầu (requirements), và phân tích chúng để hiểu rõ ch c năng c a hệ thống đang quan tâm. Dựa vào sự phân tích trên, ngư i phân tích sẽ phác thảo và đưa ra một mô hình (model) c a hệ thống mong muốn sao cho giống với những tình huống trong thế giới thực. Trong mô hình này chỉ đưa ra cái gì (what) mà hệ thống đòi hỏi phải thực hiện mà không cần quan tâm đến các chi tiết cần cài đặt. Như vậy , trong thiết kế hướng đối tượng, ngư i phân tích phải trừu tượng sao cho tìm ra được một mô hình c a dự án mà đó nhấn mạnh vào việc tìm kiếm và mô tả các lớp đối tượng (class), hay các khái niệm (concepts) trong phạm vi bài toán. 3.2.2 Thi t k h th ng Sau khi kiến trúc tổng thể c a hệ thống mong muốn đã được quyết định, giai đoạn tiếp theo là thiết kế đối tượng (System design stage). Trong giai đoạn này, hệ thống được tổ
  33. 33. Lập trình hướng đối tượng Java 26 ch c thành một tập các hệ thống con (sub-systems) mà chúng tương tác qua lại được với nhau. Giai đoạn phân rã này, ngư i phân tích cần quan tâm đến các đặc điểm kỹ thuật cũng như những yêu cầu nào c a hệ thống đối với ngư i dùng đầu cuối (end-user). Trong thực tế, giai đoạn này là xây dựng mô hình vật lý c a hệ thống thông tin từ mô hình được phân tích hệ thống nên phải tập trung để quyết định các vấn đề liên quan như chọn chiến lược nào để cài đặt data-stores như data structure, file hoặc database; xác định các nguồn tài nguyên (resources) và cơ chế để kiểm soát việc truy xuất chúng,… 3.2.3 Thi t k đ i t ng Trong giai đoạn thiết kế đối (Object design stage), các chi tiết c a giai đoạn phân tích hệ thống và thiết kế hệ thống trên sẽ được cài đặt (implemented). Các đối tượng được xác định trong giai đoạn thiết kế hệ thống sẽ được thiết kế. Việc thiết kế các đối tượng này là chia mỗi nhóm đối tượng có đặc tính giống nhau được đại diện b i một đối tượng phần mềm (class) cũng như những cách chúng tương tác với nhau (thông qua mối kết hợp Has-a hoặc mối liên kết thừa kế sự Is-a giữa chúng) để thực hiện đầy đ và trọn vẹn các yêu cầu đề ra. Các đoạn này được thực hiện nh vào quá trình trừu tượng hóa. 3.2.3.1 Trừu tượng hóa Một trong những cơ chế then cơ nhất c a hướng đối tượng là sự trừu tượng hóa (abstraction). Trừu tượng là một phương pháp mạnh mẽ để quản lý xuyên suốt các hệ thống ph c tạp và nó được dùng để xác định các loại đối tượng, sự tương tác cũng như phân loại theo th bậc c a chúng. Các đối tượng này được xác định dựa vào nguyên lý OBD, mà đó một tập các đối tượng tương tự nhau sẽ được quan sát và các đặc điểm chung c a chúng sẽ được liệt kê ra. Mỗi nhóm đối tượng giống nhau này được đại diện b i các thuộc tính và các phương th c c a chúng và ta gọi là lớp đối tượng (class). Hình 3.8: Từ quan niệm tới đối tượng phầm mềm Như vậy, quá trình trừu tượng hóa sẽ được dùng để hình thành được một mô hình các đối tượng (model hay abstraction). Khi xây dựng mô hình (model), chúng ta cần tránh rơi vào các m c chi tiết, mà thay vào đó cần tập trung vào một số tính năng quan trọng c a hệ thống. Quá trình này thư ng được dùng với một thuật ngữ khác là sự che dấu thông tin (Information Hiding).
  34. 34. Lập trình hướng đối tượng Java 27 Lưu ý r ng, việc trừu tượng ra c a một lớp đối tượng thay đổi tùy theo vào mỗi ng dụng cụ thể c a nó. Chẳng hạn hạn như khi trừu tượng để định nghĩa một lớp các đối tượng cây bút (lớp Pen) cửa tiệm, các thuộc tính có thể quan tâm như là: màu s c bút, màu mực, loại bút,… trong khi đó, nếu ta định nghĩa một lớp Pen mà hệ thống quản lý nó là xư ng sản xuất thì các thuộc tính quan tâm có thể khác trên như: hình dạng, đư ng kính, kích thước,… c a nó. Có nhiều m c (layers) c a sự trừu tượng hóa: M c trừu tượng cao nhất là dự án đang quan tâm sẽ được xem xét như một cộng đồng các đối tượng tương tác với nhau để đạt được những mục đích chung đề ra. M c trừu tượng tiếp theo là nhóm (group) các đối tượng hoạt động chung với nhau thành một đơn vị (unit) như package trong java, namespace trong C++ hoặc unit trong Delphi để dễ quản lý. M c trừu tượng th 3 đó là cung cấp dịch vụ (service) cho nhau giữa các đối tượng. Khi ta xem xét sự tương tác giữa 02 lớp đối tượng riêng biệt trên mô hình dịch vụ thì đó chính là sự tương tác giữa client và server. Trong đó server có thể là một Interface trong Java (như ví dụ 3.3) để cung cấp những dịch vụ là các ch c năng (abstract behaviors/methods) cần phải có, còn client như là các lớp hoặc các lớp trừu tượng để cài đặt cụ thể các dịch vụ c a server. Khái niệm này sẽ được đề cập thêm trong phần truyền thông điệp (messages) giữa các đối tượng phần sau. Ví d 3.3: Vai trò server c a interface List<E> phục vụ cho client là lớp trừu tượng AbstractList<E> interface List <E>{ public boolean add(E e); public boolean add(int index, E element); public Iterator<E> iterator(); //… } public abstract class AbstractList<E> extends AbstractColletion <E> implements List <E> { //… } M c trừu tượng tiếp nữa đó là xem xét trong cùng một phạm vi phía server thì nó phục vụ được gì từ phía client. Vs dụ như cùng List<E> nhưng phía Client có thể là LinkedList, có thể là ArrayList, Stack hoặc Vector.
  35. 35. Lập trình hướng đối tượng Java 28 Hình 3.9: Dịch vụ và cung cấp dịch vụ M c trừu tượng sau cùng là trừu tượng để thực hiện một nhiệm vụ (a single task, single method) riêng biệt duy nhất. Những quan tâm m c trừu tượng này là một dãy chính xác các thao tác tuần tự được sử dụng để thực hiện cho hoạt động (activity) đó. Một dạng khác c a trừu tượng hóa còn là sự áp đặt cấu trúc (structure) lên một hệ thống c a dự án đang phát triển. Dạng trừu tượng cấu trúc này có thể phản ảnh một số khía cạnh thực tế c a hệ thống hoặc giúp chúng ta hiểu rõ được hệ thồng ph c tạp c a dự án hơn. Có thể thực hiện điều này thông qua nhiều cơ chế khác nhau như: Phân chia thành các bài toán con (division into parts), Sự bao gói và thay thế lẫn nhau (Encapsulation and interchangeability), giao diệm và lớp cài đặt (interface and implementation), dịch vụ (service view), các thành phần kết hợp Has-a (composition), chuyên biệt hóa Is-a (specialization), và các mẫu (patterns) . Một số trong các phần này sẽ được trình bày các chương sau. 3.2.3.2 Thừa kế Có thể nói sự trừu tượng có mặt trong suốt quá trình phát triển phần mềm hướng đối tượng. Trong giai đoạn thiết kế đối tượng (Object design stage), sự trừu tượng còn được thể hiện rõ nét hơn trong khái niệm thừa kế. Thừa kế (Inheritance) là một trong những nguyên lý quan trọng nhất c a OOP, khái niệm này được sử dụng cho ý tư ng về tính tái sử dụng (reusability) c a các lớp đối tượng: Một lớp đối tượng mới có thể được định nghĩa b ng cách sử dụng (một) lớp tương tự đã tồn tại và thêm vào một vài đặc điểm mới cần quan tâm. Bên cạnh việc dữ liệu là trung tâm, OOP còn thêm vào nhiều ý tư ng mới quan trọng như cơ chế gửi nhận thông điệp (messages) và đa hình (polymorphism). 3.2.4 Giai đo n cƠi đặt Giai đoạn cài đặt (Implementation) này, các đối tượng được thiết kế sẽ được cài đặt hay lập trình theo ngôn ngữ lập trình hướng đối tượng nào đó, chẳng hạn b ng Java hoặc .Net, .PHP,…
  36. 36. Lập trình hướng đối tượng Java 29 Ví d 3.4: Cài đặt lớp DienVien b ng mã lệnh Java class DienVien{ public String hoTen; private Boolean gioiTinh; private Integer tuoi; public void dienHai(){ //... } public void lamGiamKhao(){ //... } public void lamMC(){ //... } } Ví d 3.5: Minh họa tính trừu tượng hóa để xây dựng mô hình đối tượng cho bài toán (đơn giản) quản lý máy laptop c a hãng Toshiba như hình 3.12. Hình 3.12: Một sản phẩm máy laptop trên thị trường Giai đoạn phân tích, thiết kế đối tượng: Để lưu giữ các thông tin sản xuất về máy laptop, các nhà quản lý Toshiba sẽ định nghĩa ra một lớp ToshibaLaptop chẳng hạn. Trong đó có các trư ng để lưu giữ các thông tin như số đơn vị hệ thống (system unit number), số hiệu mẫu (model/part number) và số sơ-ri (serial number). Các hành vi/hoạt động c a máy có thể thực hiện được như: kh i động máy, nhập/xuất và xử lý dữ liệu,… Như vậy ta có thể định nghĩa một lớp máy laptop Toshiba qua các m c như sau:
  37. 37. Lập trình hướng đối tượng Java 30 Hình 3.13: Minh họa các m c thiết kế một lớp Mỗi đối tượng (phần mềm) lưu trữ trạng thái c a nó trong các biến trư ng (fields) và thực hiện các hành vi c a mình thông qua các phương th c, chẳng hạn như máy laptop hình 3.12 là một thể hiện (sản phẩm cụ thể) mà hãng Toshiba đưa ra thị trư ng. Hình 3.14: Đối tượng myLaptop Dựa vào giá trị các trạng thái c a các thuộc tính mà hãng sẽ phân biệt được máy này với các máy cùng loại được phân phối trên toàn thế giới. Sau khi đã có mô hình đối tượng, kế đến là giai đoạn cài đặt mã lệnh Java cho lớp ToshibaLaptop như sau: class ToshibaLaptop { private String systemUnitNumber; private String modelNumber; private String serialNumber; void boot() { // ... } void readData() { // ...
  38. 38. Lập trình hướng đối tượng Java 31 } void writeData() { // ... } void processing() { // ... } } 3.3 Quá trình phát triển ch ng trình h ng đ i t ng Theo các tác giả R. Morelli và R.Walde, quá trình phát triển chương trình được thể hiện b i hình 3.15. Trong sơ đồ này, bước đầu là phải xác định rõ được các vấn đề c a dự án. Tiếp đến, phân rã bài toán ban đầu thành các bài toán nhỏ hơn dựa trên nguyên t c chia-để-trị (the divide-and-conquer principle) với tư duy xác định các đối tượng có thể có trong hệ thống và các kịch bản mà chúng sẽ tương tác với nhau như thế nào. Bước th ba là quá trình trừu tượng hóa để tạo ra một mô hình (model) các đối tượng trên nền tảng đối tượng (OBP-Object-based programming) hoặc hướng đối tượng. Hay nói cách khác, đây là bước phân tích và thiết kế sơ đồ lớp theo nền tảng OBP hoặc m rộng hơn OOP. Bước 4 là viết mã lệnh Java, và bước cuối cùng là kiểm thử và chỉnh sửa. Hình 3.15: Sơ đồ phát triển chương trình
  39. 39. Lập trình hướng đối tượng Java 32 Dưới đây là một ví dụ ng n gọn để minh họa việc phân tích và thiết kế hướng đối tượng cho một ng dụng là trò chơi tung xúc s c. Ví d 3.6: Phân tích và thiết kế hướng đối tượng cho trò chơi đơn giản xúc s c ắDice gameẰ mà ngư i chơi đươc tung 2 lần. Nếu tổng điểm b ng 7 thì th ng ngược lại thua. B c 1 - Xác đ nh s đồ use cases: Yêu cầu ngư i chơi phải l c xúc x c hai lần. Hệ thống sẽ hiển thị kết quả: Nếu giá trị mặt xúc x c có tổng cộng bảy, ngư i chơi chiến th ng; ngược lại, ngư i chơi bị thua. Hình 3.16: Use case c a trò chơi B c 2 - Xác đ nh mô hình mi n (Domain model = static view + conceptual class): Gồm các lớp khái niệm là Player, Die, và DiceGame, cùng với các mối kết hợp (associations) và các thuộc tính c a chúng. Hình 3.17: Mô hình miền c a trò chơi B c 3 - Xác đ nh biểu đồ t ng tác (Interaction Diagrams = dynamic view): Để minh họa cho quá trình tương tác c a các đối tượng b ng sơ đồ trình tự (sequence diagram). Nó chỉ ra một cách tuần tự các thông điệp (message) giữa các đối tượng phần mềm, và các l i gọi phương th c tương ng. Hình 3.18: Mô hình tương tác c a trò chơi
  40. 40. Lập trình hướng đối tượng Java 33 B c 4 - Xác đ nh s đồ l p thi t k (Design class diagrams = Static view): Ngược lại với mô hình miền, sơ đồ này không minh họa các lớp khái niệm trong thế giới thực mà nó chỉ ra các lớp phần mềm (software classes) bao gồm các thuộc tính và phương th c c a các lớp . Hình 3.19: Sơ đồ lớp c a trò chơi 3.4 Các đặc tính của l p h ng đ i t ng Java Lập trình hướng đối tượng là phương pháp lập trình dựa trên OBP và có m rộng thêm tính thừa kế và đa hình. Như vậy, tổng quát, phương pháp lập trình hướng đối tượng có các đặc tính sau: 3.4.1 Tính trừu t ng Như đề cập trên, trừu tượng hóa công cụ để xây dựng được mô hình (model) c a hệ thống thực hướng đối tượng. Nó được sử dụng xuyên suốt từ giai đoạn phân tích đến giai đoạn cài đặt mã lệnh, thuật toán. Nh vào các phương c a trừu tượng mà một bài toán ban đầu ph c tạp khó hình dung, dần dần tr nên rõ ràng, cụ thể và có thể cài đặt được. Trong giáo trình này, việc trừu tượng hóa sao cho giải quyết được một bài toán đang xét trong thế giới thực vào hệ thống máy tính b ng phương pháp hướng đối tượng thông qua kỹ thuật mô hình hóa đối tượng (Object-modeling technique), chỉ yêu cầu giới hạn qua (ít nhất) hai bước sau: Bước 1: Xây dựng mô hình tĩnh các lớp đối tượng (sơ đồ lớp) hoặc mô hình động (mô hình tuần tự) giữa các đối tượng. Bước 2: Sử dụng ngôn ngữ Java, với các tính năng mạnh c a nó, để viết và cài đặt bài toán (dự án, một hệ thống IT đang quan tâm) đã được thiết kế bước trên. 3.4.2 Tính bao đóng Tính bao đóng (encapsulation): Là việc cài đặt mã lệnh cho các phương th c nội tại và cách th c truy xuất các thuộc tính c a lớp thành một đơn vị duy nhất  Cung cấp một cơ chế duy nhất để bảo vệ dữ liệu (che dấu và bảo vệ dữ liệu khỏi ngư i dùng muốn can thiệp hoặc thao tác sai mục đích) là thông qua các interfaces (methods) mới có thể modify được các dữ liệu.
  41. 41. Lập trình hướng đối tượng Java 34 Hình 3.20: Bao đóng 3.4.3 Tính thừa k Thừa kế (inheritance): Là một cơ chế cho phép lập trình viên định nghĩa lớp con mới (child/ sub/ derived class) b ng cách m rộng từ (các) lớp cha/cơ s (parent/ super/ base class) đã tồn tại. Lớp con thừa hư ng các đặc điểm (properties = attribute + operations) từ lớp cha trong phạm vi truy xuất được phép. Quá trình phân tích tìm các lớp con dẫn xuất từ lớp cha được thực hiện qua cơ chế chuyên biệt hoá (specialization). Hình 3.21: Thừa kế Thừa kế là một trong những đặc tính quan trọng nhất trong phương pháp hướng đối tượng và có thể nói đó là một cuộc cách mạng c a lĩnh vực công nghệ phần mềm trong những năm gần đây. 3.4.4 Tính đa hình Đa hình (polymorphism): là khả năng đảm nhận nhiều dạng: Một hành động (thông qua phương th c) được đối tượng thực hiện b ng nhiều cách khác nhau, và các đối tượng khác loại có thể thực hiện chung một ng xử theo cách riêng c a mình.
  42. 42. Lập trình hướng đối tượng Java 35 3.4.5 Tính b n vững Mục đích c a tính bền vững (persistence) là lưu giữ sự tồn tại c a đối tượng lâu hơn sự thực thi c a chương trình. JFC sử dụng tuần tự hoá (serialization): Cơ chế để đảm bảo sự bền vững là sự tuần tự hóa - java.io.Serializable; Nó chuyển đổi dữ liệu (đối tượng) vào luồng (byte stream) và ghi nó vào tập tinđể lưu trữ - sử dụng phương th c writeObject(). Sau đó, chương trình sẽ được java bean khôi phục lại b ng cơ chế deserialization để có được trạng thái ban đầu c a đối tượng - sử dụng phương th c readObject(). Hình 3.22: Native Java persistence Với công nghệ Java, các framework được phát triển để hỗ trợ cho tính năng persistence như: JPO/OpenJPA, TopLink, EclipseLink, Hibernate,… Hình 3.23: Persistence frameworks 3.4.6 Tính đồng b hóa Cơ chế đồng bộ hóa (concurrency) cho phép thực hiện nhiều ch c năng/công việc tại một th i điểm. Ví dụ như hệ điều hành đa nhiệm - Java thực hiện thông qua cơ chế tiến trình (processes) và tuyến đoạn (threads) và tuần tự hoá (synchronization). Java API là gói java.util.concurrent; Chú ý: Concurrent và Synchronized collection class đều cung
  43. 43. Lập trình hướng đối tượng Java 36 cấp thread-safety, nhưng Synchronized collection như HashMap, ArrayList lại chậm hơn Concurrent collection như ConcurrentHashMap, CopyOnWriteArrayList. Lý do chính là khi locking, Synchronized collection lock toàn bộ đối tượng (whole object) trong khi đó Concurrent collection lại sử dụng thread-safety thông minh hơn (smartly). 3.4.7 Tính ủy quy n Tính y quyền (delegation) là ch c năng cho phép một phương th c method_A c a lớp A thực hiện một nhiệm vụ thông qua một phương th c method_B lớp B. Điều này có thể thực hiện được thông qua các mối kết tập (associations) và và thừa kế (inheritance). 3.4.8 Tính tổng quát Tính tổng quát (generics) cho phép các kiểu dữ liệu classes và interfaces là các tham số khi định nghĩa lớp, giao diện và phương th c. Các tham số kiểu (type parameters) cung cấp một cách để bạn có thể tái sử dụng cùng một đoạn mã (lớp generics, giao diện generics và phương th c generic) với các kiểu dữ liệu đầu vào khác nhau. Với Java generics, cho phép sự trừu tượng hóa có đặc tính đa hình (parametric polymorphism) cũng như thừa kế các lớp generics. Tóm l i: Trong phương pháp OOP, bốn nguyên lý chính được đề cập là: Trừu tượng, bao đóng, thừa kế và đa hình. Bài t p ch ng 3 Bài 3.1: Hình dung bạn đang gia đình, hãy liệt kê càng nhiều càng tốt: - Các đối tượng và số lượng có trong gia đình bạn - Cho biết những đối tượng nào chung loài (lớp) nhau - Với mỗi loại đối tượng đó có những đặc điểm và hoạt động nào có thể có Bài 3.2: Hãy trừu tượng hóa để xây dựng mô hình cho mỗi một đối tượng trong môi trư ng học tập bậc đại học: - Đối tượng sinh viên - Đối tượng giảng viên - Đối tượng chuyên viên - Đối tượng môn học/ học phần - Đối tượng lớp học Bài 3.3: Hãy liệt kê ra ít nhất 03 mô hình (mỗi mô hình có nhiều nhất là 3 lớp) mà có tính thừa kế b ng ngôn ngữ tự nhiên hoặc sơ đồ UML. Bài 3.4: Sử dụng ngôn ngữ tự nhiên, hãy chỉ ra một ví dụ có trong thực tế tự nhiên hoặc những sản phảm nhân tạo mà có tính đa hình. Bài 3.5: Dịch vụ ATM mà bạn được cung cấp để giao dịch thông qua thẻ có thể có những đặc tính nào c a hướng đối tượng? Hãy nêu ra và cho ví dụ cụ thể để minh họa điều đó.
  44. 44. Lập trình hướng đối tượng Java 37 Ch ng 4. L p, đ i t ng, truy n thông đi p và gói Trong chương này sẽ trình bày các kiến th c về lớp, việc tạo và h y các đối tượng, các cách truyền tham số kiểu dữ liệu nguyên th y và kiểu đối tượng, cách truyền nhận thông điệp giữa chúng và cách gom các lớp vào chung một gói (một không gian tên vùng) theo ngôn ngữ Java. 4.1 L p 4.1.1 Khái ni m Lớp (class) đại diện cho một mẫu các đối tượng (vật thể hoặc phi vật thể) có chung những đặc điểm giống nhau, bao gồm các tên trư ng (fields) và các phương th c (methods) c a nó. Trong sơ đồ UML, ngư i ta thư ng sử dụng thêm thuật ngữ khác đó là tên thuộc tính (attributes) thay cho tên trư ng, và hành vi (behaviors/ operations) thay cho phương th c. Trên sơ đồ UML, lớp có 03 phần là Tên lớp (Class name), các thuộc tính và hành vi như hình 4.1: Hình 4.1: Ký hiệu UML cho lớp Ví d 4.1: Các thầy cô giảng dạy trong trư ng Đại học Cần Thơ đều là đối tượng giảng viên nên định nghĩa một lớp GiangVien đại diện cho các thầy cô trong trư ng. Hình 4.2: Định nghĩa lớp giảng viên Lớp Giảng viên, ta quan tâm đến 03 thông tin: Mã số giảng viên, họ tên, chuyên ngành, và 02 phương th c là: giảng dạy học phần và nghiên c u khoa học. 4.1.2 L p tự đ nh nghĩa Trong ngôn ngữ Java, lập trình viên có thể định nghĩa một lớp để đại diện cho một nhóm các đối tượng có chung những thuộc tính và phương th c như cú pháp sau.
  45. 45. Lập trình hướng đối tượng Java 38 4.1.2.1 Cú pháp khai báo tổng quát [Doc comment] [Modifier] class Identifer [extends SuperClassName] [implements Interfaces] { ClassBody; //Members } Trong đó, từ khóa (keyword) class đ ng trước một danh hiệu là tên lớp (Identifer) và cặp dấu móc nhọn { } để b t đầu và kết thúc một lớp. Các thành phần tùy chọn (trong cặp [ ]) còn lại sẽ được đề cập sau. Với ClassBody là phần định phần nghĩa thân c a lớp. Nó gồm phần khai báo các thuộc tính (còn được gọi là biến thành viên member variables) và các phương th c hay còn được gọi những phương th c thành viên (member methods). Cú pháp chi tiết c a lớp tự định nghĩa: [Doc comment] [Modifier] class Identifer [extends SuperClassName] [implements Interfaces] { [Modifier] dataType fieldName1; [Modifier] dataType fieldName2; //... [Modifier] returnType Identifer1( [ParameterList] )[throws] { MethodBody } [Modifier] returnType Identifer2( [ParameterList] )[throws] { MethodBody } //… } Trong đó, cần phân biệt các loại biến khác nhau: Các biến thành viên được gọi là các trư ng (fields), các biến trong phương th c hoặc trong khối lệnh là các biến cục bộ (local variable), và các biến trong phần khai báo trong chữ ký phương th c (method signature) được gọi là các tham số (parameters). Ví d 4.2: Với thực thể giảng viên trong sơ đồ UML hình 4.2 trên, ta có lớp GiangVien theo ngôn ngữ Java như sau:
  46. 46. Lập trình hướng đối tượng Java 39 public class GiangVien { private String maGV; public String hoTen; public Boolean gioiTinh; public void giangDay(String maHP) { //cài đặt thân phương thức } protected void nghienCuuKH() { //cài đặt thân phương thức } } 4.1.2.2 Kiểm soát truy cập đến các thành viên của lớp Các bổ từ m c độ truy cập (access level modifiers) xác định xem liệu các lớp khác có thể sử dụng biến trư ng hoặc gọi đến một phương th c cụ thể nào đó c a nó hay không. Có hai cấp độ kiểm soát truy cập đến các thành viên c a một lớp: mức lớp (class level/ top level): được xác định b i bổ từ truy cập đ ng ngay trước từ khóa class. Nó có 2 dạng public hoặc không có modifier. public: Lớp sẽ được truy cập mọi nơi trong dự án – anywhere. Không có modifier: Lớp chỉ được truy cập trong phạm vi cùng gói (package-private hay friendly). mức các thành viên của lớp (member level): được xác định b i bổ từ truy cập đ ng trước tên biến trư ng hoặc trước tên mỗi phương th c (fields và methods). Nó có thể là một trong 4 bổ từ truy cập sau: private: Các thành viên chỉ có thể truy xuất được phạm vi bên trong lớp c a chính nó mà thôi, ngay cả các thành viên lớp con cũng không thể truy xuất tới được (không được thừa kế). public: Các thành viên c a lớp sẽ được truy cập từ tất cả các lớp khác. Không có modifier (friendly/ package access): Trong cùng gói là public còn khác gói là private. protected: Các thành viên được truy xuất b i các phương th c cùng lớp, các phương th c trong các lớp con (được thừa kế) và các phương th c khác lớp nhưng phải cùng gói. Ví d 4.3: Định nghĩa kiểu dữ liệu lớp HinhTron mà lớp này và phương th c tinhDienTich được truy xuất mọi nơi, biến trư ng banKinh chỉ được truy xuất trong thân c a lớp HinhTron, còn phương th c tinhChuVi được truy xuất trong phạm vi c a gói hiện hành.
  47. 47. Lập trình hướng đối tượng Java 40 public class HinhTron { // mức lớp: public private double banKinh; // mức thành viên: private double tinhChuVi() { // mức thành viên: friendly return 2 * Math.PI * banKinh; // có phương thức thể hiện } public double tinhDienTich() { // mức thành viên: public return Math.PI * banKinh * banKinh; } } 4.1.2.3 L p t n cùng Ngoài các bổ từ truy cập trên, còn có các bổ từ khác như final, synchronized, transient, native,… Nếu m c lớp được khai báo với bổ từ modifier là final, thì được gọi là lớp tận cùng (final class), nghĩa là không cho phép m rộng hoặc thừa kế (inheriance) cho các lớp con làm hậu duệ c a nó. Nếu m c thành viên được khai báo thêm từ khóa final thì đó là phương th c h ng (final method) hoặc biến h ng (final variable). Với phương th c h ng, thì không được phép ghi chồng (over-riding) lên nó. 4.2 Đ i t ng 4.2.1 Khái ni m Đối tượng (object) là một thể hiện, instance, c a một lớp. Mỗi đối tượng phần mềm (A software object) lưu giữ các trạng thái (states) c a nó trong các biến trư ng (fields) ngay tại mỗi th i điểm run-time và được gọi là giá trị hiện hành c a đối tượng (object's data, và thực hiện các hành vi (behaviors) c a nó b ng các phương th c (methods). Phương th c là khối lệnh có cấu trúc (như phương pháp lập trình hướng th tục) được cài đặt để thao tác trên các biến trư ng (setter/getter) c a đối tượng cũng như thực hiện hành vi khác c a nó mà điển hình nhất là để truyền nhận thông điệp (message passing) giữa các đối tượng với nhau. 4.2.2 T o đ i t ng Trước khi tạo đối tượng, chúng ta cần biết đối tượng sẽ được tạo ra từ một trong các lớp chuẩn Java, hoặc các lớp tự định nghĩa nào. Mỗi đối tượng có một định danh (identity/ name) để phân biệt nhau như: gv1, gv2 và được tạo ra thông qua từ khóa new trong Java.
  48. 48. Lập trình hướng đối tượng Java 41 Hình 4.3: Tạo 2 đối tượng gv1, gv2 từ lớp Giảng viên Cách 1: Khai báo và kh i tạo riêng biệt TênLớp biếnThamChiếu; biếnthamChiếu = new TênLớp([Các đối số]); Biến tham chiếu (reference variable) là biến lưu trữ giá trị địa chỉ ô nhớ c a đối tượng được tạo mà nó trỏ đến. Nếu đối tượng chưa được tạo thì địa chỉ c a ô nhớ đó chưa xác định, còn ngược lại thì địa chỉ ô nhớ đó sẽ được cấp phát để ch a đối tượng. Chú ý r ng, trong Java, địa chỉ c a các biến c a tham chiếu được quản lý b i Stack, còn địa chỉ ch a đối tượng thì được quản lý b i Heap. Ví d 4.4: HinhTron ht1; //khai báo biến tham chiếu ht1 Biến ht1 được gọi là tham chiếu đến đối tượng lớp hình tròn nhưng đối tượng chưa được tạo ra (địa chỉ Heap c a đối tượng hình tròn chưa xác định, no object instance) ht1 = new HinhTron(); Biến ht1 được gọi là tham chiếu đối tượng (object reference) hình tròn. Các cách đọc khác có thể là: tham chiếu (tới đối tượng hình tròn) ht1; hoặc: Địa chỉ ch a đối tượng hình tròn được trỏ b i tham chiếu ht1. Ta cũng có thể h y và giải phóng đối tượng khỏi bộ nhớ b ng cách gán giá trị null cho tham chiếu đối tượng như lệnh: ht1 = null; //null reference Cách 2: Khai báo và kh i tạo TênLớp biếnThamChiếu = new TênLớp([Các đối số]); Ví d 4.5: Khai báo và kh i tạo biến tham chiếu ht2 tới đối tượng HinhTron HinhTron ht2 = new HinhTron(); Sau khi đã khai báo và kh i tạo, để truy xuất đến các biến trư ng và phương th c c a đối tượng xem hình 4.4, ta sử dụng theo dạng sau:
  49. 49. Lập trình hướng đối tượng Java 42 thamChiếuĐốiTượng.tênBiếnTrư ng thamChiếuĐốiTượng.tênPhươngThức([Các_đối_số]) Hình 4.4: Minh họa intelligent code completion c a Eclipse IDE Sau đây là một số ví dụ minh cách cấp phát và quản lý bộ nhớ cho loại biến nguyên th y và biến kiểu đối tượng trong Java: Hình 4.5: Minh họa cấp phát trong Stack và Heap Ví d 4.6: Viết chương trình (theo OBP) để tạo một hình tròn có toạ độ tâm O(50,100), bán kính b ng 30 và hiển thị thông tin và diện tích c a nó. //File name: LopChinh.java class HinhTron { int x = 50; int y = 100;
  50. 50. Lập trình hướng đối tượng Java 43 double banKinh = 30; double tinhDienTich() { return Math.PI * Math.pow(banKinh, 2); } } public class LopChinh { public static void main(String[] args) { HinhTron ht = new HinhTron(); System.out.printf("Hình tròn vừa tạo có tâm O(%d,%d)" + " và diện tích= %.4fn", ht.x, ht.y, ht.tinhDienTich()); } } 4.3 Thành viên thể hi n và thành viên l p Khi định nghĩa một lớp, chúng ta cần chú ý phân biệt rõ hai ch c năng cho hai loại biến trư ng và phương th c (gọi chung là các thành viên, members) đó là các thành viên thể hiện (instance members) và các thành viên lớp (class members) . 4.3.1 Thành viên thể hi n Là các biến thể hiện (instance variables) và các phương th c thể hiện (instance methods). Đây là phần dữ liệu dành riêng cho mỗi đối tượng được tạo ra. Với cách này, địa chỉ c a mỗi đối tượng được tạo sẽ lưu vào trong vùng nhớ riêng biệt nhau. Mục đích sử dụng tính năng này là khi chúng ta muốn các đối tượng được tạo ra cùng từ một lớp nhưng giá trị c a các thuộc tính (hay trạng thái) giữa chúng là được lưu giữ riêng biệt nhau. Ví dụ như: giá trị mã số sinh viên, họ tên, tuổi,… c a mỗi sinh viên là khác nhau nên chúng được gọi là biến thể hiện. Với các phương th c thể hiện thì có thể thao tác/truy xuất trên cả hai loại biến trư ng: biến thể hiện (instance variables) và biến lớp (class variables). 4.3.2 Thành viên l p Ngược lại với instance member, các thành viên (c a) lớp bao gồm các biến lớp (class variables) và phương th c lớp (class methods). Nó được xác định b i từ khóa static, được khai báo đ ng trước mỗi biến trư ng hoặc phương th c. Đây là phần dữ liệu dành riêng cho lớp và được truy xuất trực tiếp b i tên lớp. Với cách này, các thành viên c a các đối tượng được tạo ra từ một lớp sẽ có chung địa chỉ c a biến lớp và được xem như biến dùng chung cho các đối tượng được tạo ra cùng từ một lớp. Từ các phương th c thể hiện, chúng ta có thể truy xuất đến các biến thể hiện cũng như các biến lớp. Ngược lại, từ các phương th c lớp, chúng ta không thể truy cập đến các biến thể hiện được khai báo trong lớp hiện tại mà chỉ có thể đến các biến lớp và các
  51. 51. Lập trình hướng đối tượng Java 44 phương th c lớp (khác) và không sử dụng từ khóa this và sufer. Các thành viên lớp được gọi thông qua tên lớp mà không cần phải thông qua tên đối tượng. Thành viên lớp được sử dụng với mục đích khi chúng ta muốn giá trị thuộc tính (hay trạng thái) là chia xẻ chung với nhau giữa các đối tượng cùng lớp. Chẳng hạn như: Mỗi một nhiệm kỳ, mọi ngư i dân Việt nam đều có chung một ông Ch tịch nước, như vậy thuộc tính ắtên ch tịch nướcẰ c a mỗi đối tượng ngư i Việt là loại biến lớp. Ví dụ khác sinh động hơn là trong các trò chơi (games), chúng ta thư ng có kịch bản đối kháng giữa các nhóm đối tượng, nhóm đối tượng A đấu với nhóm các đối tượng B. Nếu số đối tượng A tồn tại trong hệ thống trong khi số đối tượng B không còn thì ta có thể kết luận ắBên A th ng bên BẰ. Như vậy việc đếm số lượng các đối tượng tồn tại c a mỗi loại trong hệ thống thực (run-time) cần phải sử dụng đến biến dùng chung này. Ví d 4.7: Lớp giảng viên có ch a instance và class members Hình 4.6: Minh họa thành viên thể hiện và thành viên lớp //Filename: GiangVien.java package ctu.vdlinh.chapter4; class GiangVien { private String maGV; public String hoTen; public Boolean gioiTinh = true; //Nam public static String donViCQ = "Đại học Cần Thơ - CTU"; public void giangDay(String maHP) { System.out.println("Giảng viên: " + maGV+ ", dạy mã số học phần " + maHP); } protected void nghienCuuKH() { System.out.println("Nghiên cứu trong các lĩnh vực phù hợp.n"); }
  52. 52. Lập trình hướng đối tượng Java 45 public static void main(String[] args) { System.out.println("Các giảng viên thuộc cơ quan chủ quản: "+ GiangVien.donViCQ +":n"); GiangVien gv1 = new GiangVien(); gv1.maGV = "000001"; gv1.hoTen = "Trần Phước Đường"; gv1.giangDay("SH001"); gv1.nghienCuuKH(); GiangVien gv2 = new GiangVien(); gv2.maGV = "000002"; gv2.hoTen = "Võ Tòng Xuân"; gv2.giangDay("SH002"); gv2.nghienCuuKH(); GiangVien gv3 = new GiangVien(); gv3.maGV = "000514"; gv3.hoTen = "Phạm Thị Xuân Lộc"; gv3.gioiTinh = false; //Nữ gv3.giangDay("CT106"); gv3.nghienCuuKH(); } } 4.4 Ph ng thức dựng Trong quá trình xây dựng lớp, chúng ta thư ng cài đặt các phương th c dựng c a nó. Phương th c dựng (constructors) được dùng để tạo mới một đối tượng, xác định giá trị ban đầu cho các thuộc tính c a đối tượng nếu có. Trong một lớp có thể có nhiều phương th c dựng, tên c a mỗi phương th c dựng phải giống với tên lớp và là dạng th tục nên nó không có kiểu trả về (kiểu void). Trong phương th c dụng, từ khóa this thư ng được sử dụng để phân biệt tên biến trư ng (variables ) với tên tham số hình th c (parametters) nếu chúng có tên giống nhau. Từ khóa this là một tham chiếu (reference to the current object) chỉ đến đối tượng hiện hành. Nó được dùng để phân biệt giữa biến thể hiện (instance variables) và các tham số hình th c khi chúng giống tên nhau Sử dụng từ khóa super để tham chiếu tới đối tượng thuộc lớp cha. Nó được dùng để gọi các phương th c, các biến thành viên từ lớp cha. Trong Java có sẵn một phương th c dựng mặc định (không có tham số) và chúng ta có thể ghi chồng (overriding ) phương th c mặc định này. Ví d 4.8: Lớp giảng viên có ch a instance, class members và có constructors package ctu.vdlinh.chapter4; class GiangVien { private String maGV; public String hoTen; public Boolean gioiTinh = true; public static String donViCQ = "CTU";

×