BÀI GIẢNG MÃ HỌC PHẦN: NGÔN NGỮ LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG

Công Nghệ Thông Tin, it, phầm mềm, website, web, mobile app, trí tuệ nhân tạo, blockchain, AI, machine learning - Công Nghệ Thông Tin, it, phầm mềm, website, web, mobile app, trí tuệ nhân tạo, blockchain, AI, machine learning - Công nghệ thông tin TRỜNG ĐẠI HỌC QUẢNG NAM KHOA TOÁN - TIN    BÀI GIẢNG MÃ HỌC PHẦN: 21031641 NGÀNH ĐÀO TẠO: ĐẠI HỌC CÔNG NGHỆ THÔNG TIN 1. Giảng viên biên soạn: Th.S TRẦN THỊ DIỆU HIỀN 2. Số tín chỉđơn vị học trình: 4 TC 3. TổKhoa quản lý học phần: Khoa Toán - Tin Quảng Nam, tháng 01 năm 2024 MỤC LỤC CHƠNG 1 TỔNG QUAN VỀ CÁCH TIẾP CẬN HỚNG ĐỐI TỢNG ............................... 5 1.1. Phƣơng pháp tiếp cận của lập trình truyền thống ............................................................. 5 1.1.1. Lập trình tuyến tính ....................................................................................................... 5 1.1.2. Lập trình cấu trúc .......................................................................................................... 5 1.2. Phƣơng pháp tiếp cận hƣớng đối tƣợng ........................................................................... 6 1.2.1. Phƣơng pháp lập trình hƣớng đối tƣợng ....................................................................... 6 1.2.2. Phƣơng pháp phân tích và thiết kế hƣớng đối tƣợng .................................................... 8 1.3. So sánh hai cách tiếp cận.................................................................................................. 8 1.4. Xu hƣớng phát triển của lập trình hƣớng đối tƣợng ......................................................... 9 1.5. Câu hỏi và bài tập ........................................................................................................... 10 CHƠNG 2 NHỮNG KHÁI NIỆM CƠ BẢN CỦA LẬP TRÌNH HỚNG ĐỐI TỢNG ...... 12 2.1. Đối tƣợng (Object) ............................................................................................................. 12 2.2. Lớp đối tƣợng (Class) ........................................................................................................ 13 2.3. Trừu tƣợng hóa dữ liệu (Abstraction) ............................................................................... 13 2.4. Khái niệm kế thừa (Inheritance) ........................................................................................ 14 2.5. Khái niệm đóng gói (Encapsulation) ................................................................................. 15 2.6. Khái niệm đa hình (Polymorphism) ................................................................................... 17 2.7. Câu hỏi và bài tập .............................................................................................................. 18 CHƠNG 3 NGÔN NGỮ LẬP TRÌNH JAVA ........................................................................... 19 3.1. Giới thiệu và cài đặt ngôn ngữ Java ................................................................................... 19 3.1.1. Lịch sử của Java .......................................................................................................... 19 3.1.2. Đặt trƣng của ngôn ngữ Java ...................................................................................... 19 3.1.3. Cài đặt, cấu hình các phần mềm và biên dịch chƣơng trình Java ............................... 20 3.2. Kiến trúc chƣơng trình Java ........................................................................................... 24 3.2.1. Các thành phần cơ bản của Java ................................................................................. 25 3.2.2. Chƣơng trình Java đầu tiên ......................................................................................... 26 3.2.3. Phân tích chƣơng trình ................................................................................................ 26 3.3. Ngôn ngữ Java ................................................................................................................... 27 3.3.1. Ghi chú (Comment) .................................................................................................... 27 3.3.2. Từ khóa (Keyword)..................................................................................................... 28 3.3.3. Giới thiệu về biến ........................................................................................................ 28 3.3.4. Kiểu dữ liệu................................................................................................................. 30 3.3.5. Biến (Variable) và hằng số (Constant)........................................................................ 33 3.3.5. Mảng (Array) và xâu ký tự ......................................................................................... 34 3.3.6. Các toán tử và biểu thức ............................................................................................. 41 3.4. Các cấu trúc lệnh trên Java ................................................................................................ 43 3.4.1. Câu lệnh if…else......................................................................................................... 43 3.4.2. Câu lệnh switch…case ................................................................................................ 45 3.4.3. Vòng lặp while ............................................................................................................ 47 3.4.4. Vòng lặp do…while .................................................................................................... 48 3.4.5. Vòng lặp for ................................................................................................................ 49 3.4.6. Các lệnh nhảy (Break-Continue-Label) ...................................................................... 50 3.5. Hàm – Phƣơng thức (Fuction – Method) ........................................................................... 52 3.5. Câu hỏi và bài tập .............................................................................................................. 54 CHƠNG 4 KẾ THỪA VÀ ĐA HÌNH TRÊN JAVA ................................................................ 57 4.1. Kế thừa đơn ........................................................................................................................ 57 4.1.1. Lớp (Class) .................................................................................................................. 57 4.1.2. Sự kế thừa ................................................................................................................... 65 4.2. Kế thừa bội ......................................................................................................................... 67 4.2.1. Định nghĩa, cài đặt giao diện (Interface) .................................................................... 67 4.2.2. Sử dụng giao diện ....................................................................................................... 67 4.3. Tính đa hình ....................................................................................................................... 70 4.3.1. Nạp chồng (Overloading) ........................................................................................... 70 4.3.2. Viết đè (Overriding) .................................................................................................... 71 4.4. Các xây dựng và sử dụng gói (Package) trong Java .......................................................... 72 4.4.1. Cách xây dựng gói ...................................................................................................... 72 4.4.2. Các sử dụng gói .......................................................................................................... 72 4.5. Xử lý ngoại lệ (Exception) ................................................................................................. 75 4.5.1. Định nghĩa một ngoại lệ.............................................................................................. 75 4.5.2. Mô hình xử lý ngoại lệ ................................................................................................ 76 4.6. Câu hỏi và bài tập .............................................................................................................. 80 CHƠNG 5 LẬP TRÌNH GIAO DIỆN TRÊN JAVA ................................................................ 84 5.1. Mở đầu ............................................................................................................................... 84 5.2. Giới thiệu AWT và Swing ................................................................................................. 84 5.3. Khái niệm các đối tƣợng cơ bản ........................................................................................ 85 5.3.1. Container (Thùng chứa) .............................................................................................. 85 5.3.2. Component (Thành phần) ........................................................................................... 87 5.3.3. Layout Manager: trình quản lý cách trình bày ............................................................ 98 5.4. Thiết kế GUI cho chƣơng trình .......................................................................................... 99 5.4.1.Tạo khung chứa cửa sổ chƣơng trình ........................................................................... 99 5.4.2. Tạo hệ thống thực đơn ................................................................................................ 99 5.4.3. Gắn Component vào khung chứa .............................................................................. 101 5.4.4. Trình bày các Component trong khung chứa ............................................................ 102 5.4.5. Các đối tƣợng khung chứa Container ....................................................................... 109 5.5. Xử lý biến cốsự kiện ....................................................................................................... 112 5.5.1. Mô hình xử lý sự kiện (Event-Handling Model) ...................................................... 112 5.5.2. Xử lý sự kiện chuột ................................................................................................... 114 5.5.3. Xử lý sự kiện bàn phím ............................................................................................. 129 5.6. Applet ............................................................................................................................... 131 5.6.1. Khái niệm về Applet ................................................................................................. 131 5.6.3. Hoàn tất một Applet .................................................................................................. 134 5.7. Lập trình giao diện với WindowBuilder trong Eclipse .................................................... 138 5.7.1. tải và cài đặt WindowBuilder ................................................................................... 138 5.7.2. Lập trình .................................................................................................................... 139 CHƠNG 6 NHẬP XUẤT DỮ LIỆU ....................................................................................... 144 6.1. Tổng quát ......................................................................................................................... 144 6.1.1. Đƣờng dẫn (Path) ...................................................................................................... 144 6.1.2. Đƣờng dẫn tƣơng đối và tuyệt đối ............................................................................ 145 6.1.3. Giới thiệu lớp java.io.File ......................................................................................... 145 6.1.4. Lấy đƣờng dẫn đến thƣ mục đang làm việc .............................................................. 146 6.1.5. Tạo thƣ mục .............................................................................................................. 147 6.1.6. Tạo tập tin ................................................................................................................. 148 6.2. Đọc và ghi dữ liệu với tập tin .......................................................................................... 149 6.3. Các ví dụ ứng dụng .......................................................................................................... 159 CHƠNG 7 LẬP TRÌNH CƠ SỞ DỮ LIỆU ............................................................................. 162 7.1.Giới thiệu .......................................................................................................................... 162 7.2. Kiến trúc JDBC ................................................................................................................ 162 7.3. Các khái niệm cơ bản ....................................................................................................... 163 7.3.1. JDBC Driver ............................................................................................................. 163 7.3.2. JDBC URL ................................................................................................................ 163 7.4. Kết nối cơ sở dữ liệu với JDBC ....................................................................................... 163 7.4.1. Đăng ký trình điều khiển........................................................................................... 165 7.4.2. Thực hiện kết nối ...................................................................................................... 167 7.5. Kiểu dữ liệu SQL và kiểu dữ liệu java............................................................................. 174 7.6. Các thao tác cơ bản trên cơ sở dữ liệu ............................................................................. 178 7.6.1. Hƣớng dẫn kết nối java với mysql – Chuẩn bị ......................................................... 178 7.6.2. Hƣớng dẫn kết nối java với mysql – Tạo database ................................................... 178 Trang 5 CHƠNG 1 TỔNG QUAN VỀ CÁCH TIẾP CẬN HỚNG ĐỐI TỢNG Chương này giới thiệu đến các bạn một số vấn đề liên quan đến lập trình truyề n thống, lập trình hướng đối tượng; so sánh những ưu nhược điểm đối với 2 cách tiếp cận. Xu hướng phát triển của lập trình hướng đối tượng trong giai đoạn hiện nay và tương lai. 1.1. Phƣơng pháp tiếp cận của lập trình truyền thống Máy tính đầu tiên đƣợc lập trình bằng mã nhị phân, sử dụng các công tắt cơ khí để nạp chƣơng trình. Cùng với sự xuất hiện của các thiết bị lƣu trữ lớn và bộ nhớ máy tính có dung lƣợng lớn nên các ngôn ngữ lập trình cấp cao đầu tiên đƣợc đƣa vào sử dụng . Thay vì phải suy nghĩ trên một dãy các bit và byte, lập trình viên có thể viết một loạt lệnh gần với tiếng Anh và sau đó chƣơng trình dịch thành ngôn ngữ máy. 1.1.1. Lập trình tuyến tính Lập trình tuyến tính là một phƣơng pháp, kỹ thuật lập trình truyền thống. Trong lập trình tuyến tính, chƣơng trình sẽ chỉ có một hàm và đƣợc thực hiện tuần tự từ đầu tới cuối. Đặc trƣng của lập trình tuyến tính là: đơn giản và đơn luồng. Ví dụ ngôn ngữ Assembly …  u điểm: Đơn giản, chƣơng trình đơn giản, dễ hiểu  Nhƣợc điểm: Không thể áp dụng cho các chƣơng trình phức tạp, không thể sử dụng lại code. 1.1.2. Lập trình cấu trúc Lập trình hƣớng cấu trúc hay còn gọi là lập trình hƣớng thủ tục (Procedure Oriented Programming – POP): là một kỹ thuật lập trình, trong đó chƣơng trình đƣợc chia thành các hàm (chƣơng trình con) Mỗi chƣơng trình còn có thể đƣợc chia ra nhiều chƣơng trình con khác để đơn giản hóa công việc của chúng. Quá trình này đƣợc gọi là quá trình làm mịn. – Ví dụ chƣơng trình nhập và hiển thị thông tin ngƣời dùng sẽ chia thành hai chƣơng trình con là chƣơng trình nhập và xuất, nếu việc nhập thông tin phức tạp thì chƣơng trình nhập thông tin có thể chia ra nhiều chƣơng trình con khác nhau… Trong lập trình hƣớng cấu trúc ta thƣờng quan tâm đến việc phát triển các hàm mà ít quan tâm tới dữ liệu – thứ mà chúng dùng để xử lý công việc. Điều này khiến cho dữ liệu khó kiểm soát. Để liên kết giữa các hàm với nhau ta thƣờng dùng biến toàn cục hoặc con trỏ. Các tính chất cơ bản của lập trình hƣớng cấu trúc là: – Tập chung vào công việc cần thực hiện (thuật toán) – Chƣơng trình lớn đƣợc chia thành các hàm nhỏ hơn – Phần lớn các hàm sử dụng dữ liệu chung – Dữ liêu trong hệ thống đƣợc chuyển động từ hàm này sang hàm khác. Trang 6 – Hàm biến đổi dữ liệu từ dạng này sang dạng khác – Sử dụng cách tiếp cận top-down trong thiết kế chƣơng trình - Ví dụ: Các ngôn ngữ lập trình hƣớng cấu trúc: Pascal, C… 1.2. Phƣơng pháp tiếp cận hƣớng đối tƣợng 1.2.1. Phƣơng pháp lập trình hƣớng đối tƣợng Xuất phát từ hai hạn chế chính của phƣơng pháp lập trình cấu trúc:  Không quản lí đƣợc sự thay đổi dữ liệu khi có nhiều chƣơng trình cùng thay đổi một biến chung. Vấn đề này đặc biệt nghiêm trọng khi các ứng dụng ngày càng lớn, ngƣời ta không thể kiểm soát đƣợc sự truy nhập đến các biến dữ liệu chung.  Không tiết kiệm đƣợc tài nguyên con ngƣời: Giải thuật gắn liền với cấu trúc dữ liệu, nếu thay đổi cấu trúc dữ liệu, sẽ phải thay đổi giải thuật, và do đó, phải viết lại mã chƣơng trình từ đầu. Để khắc phục đƣợc hai hạn chế này khi giải quyết các bài toán lớn, ngƣời ta xây dựng một phƣơng pháp tiếp cận mới, là phƣơng pháp lập trình hƣớng đối tƣợng, với hai mục đích chính: Đóng gói dữ liệu để hạn chế sự truy nhập tự do vào dữ liệu, không quản lí đƣợc. Cho phép sử dụng lại mã nguồn, hạn chế việc phải viết lại mã từ đầu cho các chƣơng trình. Việc đóng gói dữ liệu đƣợc thực hiện theo phƣơng pháp trừu tƣợng hoá đối tƣợng thành lớp từ thấp lên cao nhƣ sau: Thu thập các thuộc tính của mỗi đối tƣợng, gắn các thuộc tính vào đối tƣợng tƣơng ứng. Nhóm các đối tƣợng có các thuộc tính tƣơng tự nhau thành nhóm, loại bỏ bớt các thuộc tính cá biệt, chỉ giữ lại các thuộc tính chung nhất. Đây đƣợc gọi là quá trình trừu tƣợng hoá đối tƣợng thành lớp. Đóng gói dữ liệu của các đối tƣợng vào lớp tƣơng ứng. Mỗi thuộc tính của đối tƣợng trở thành một thuộc tính của lớp tƣơng ứng. Trang 7 Việc truy nhập dữ liệu đƣợc thực hiện thông qua các phƣơng thức đƣợc trang bị cho lớp. Không đƣợc truy nhập tự do trực tiếp đến dữ liệu. Khi có thay đổi trong dữ liệu của đối tƣợng, ta chỉ cần thay đổi các phƣơng thức truy nhập thuộc tính của lớp, mà không cần phải thay đổi mã nguồn của các chƣơng trình sử dụng lớp tƣơng ứng. Việc cho phép sử dụng lại mã nguồn đƣợc thực hiện thông qua cơ chế kế thừa trong lập trình hƣớng đối tƣợng. Theo đó: Các lớp có thể đƣợc kế thừa nhau để tận dụng các thuộc tính, các phƣơng thức của nhau. Trong lớp dẫn xuất (lớp đƣợc kế thừa) có thể sử dụng lại các phƣơng thức của lớp cơ sở (lớp bị lớp khác kế thừa) mà không cần thiết phải cài đặt lại mã nguồn. Ngay cả khi lớp dẫn xuất định nghĩa lại các phƣơng thức cho mình, lớp cơ sở cũng không bị ảnh hƣởng và không phải sửa lại bất kì một đoạn mã nguồn nào. Ngôn ngữ lập trình hƣớng đối tƣợng phổ biến hiện nay là Java, C++, C, …. Tuy nhiên, C++ mặc dù cũng có những đặc trƣng cơ bản của lập trình hƣớng đối tƣợng nhƣng vẫn không phải là ngôn ngữ lập trình thuần hƣớng đối tƣợng. Java thật sự là một ngôn ngữ lập trình thuần hƣớng đối tƣợng. Đặc trƣng Lập trình hƣớng đối tƣợng có hai đặc trƣng cơ bản: Đóng gói dữ liệu: dữ liệu luôn đƣợc tổ chức thành các thuộc tính của lớp đối tƣợng. Việc truy nhập đến dữ liệu phải thông qua các phƣơng thức của đối tƣợng lớp. Sử dụng lại mã nguồn: việc sử dụng lại mã nguồn đƣợc thể hiện thông qua cơ chế kế thừa. Cơ chế này cho phép các lớp đối tƣợng có thể kế thừa từ các lớp đối tƣợng khác. Khiđó, trong các lớp kế thừa, có thể sử dụng các phƣơng thức (mã nguồn) của các lớp bị kế thừa, mà không cần phải định nghĩa lại. u điểm Lập trình hƣớng đối tƣợng có một số ƣu điểm nổi bật: Không còn nguy cơ dữ liệu bị thay đổi tự do trong chƣơng trình. Vì dữ liệu đã đƣợc đóng gói vào các đối tƣợng. Nếu muốn truy nhập vào dữ liệu phải thông qua các phƣơng thức cho phép của đối tƣợng. Khi thay đổi cấu trúc dữ liệu của một đối tƣợng, không cần thay đổi các đổi mã nguồn của các đối tƣợng khác, mà chỉ cần thay đổi một số hàm thành phần của đối tƣợng bị thay đổi. Điều này hạn chế sự ảnh hƣởng xấu của việc thay đổi dữ liệu đến các đối tƣợng khác trong chƣơng trình. Có thể sử dụng lại mã nguồn, tiết kiệm tài nguyên. Vì nguyên tắc kế thừa cho phép các lớp kế thừa sử dụng các phƣơng thức đƣợc kế thừa từ lớp khác nhƣ những phƣơng thức của chính nó, mà không cần thiết phải định nghĩa lại. Phù hợp với các dự án phần mềm lớn, phức tạp. Trang 8 1.2.2. Phƣơng pháp phân tích và thiết kế hƣớng đối tƣợng Một vấn đề cơ bản đặt ra cho phƣơng pháp hƣớng đối tƣợng là từ một bài toán ban đầu, làm sao để thu đƣợc một tập các đối tƣợng, với các chức năng đƣợc phối hợp với nhau, đáp ứng đƣợc yêu cầu của bài toán đặt ra? Phƣơng pháp phân tích thiết kế hƣớng đối tƣợng ra đời nhằm trả lời cho câu hỏi này. Mục đích là xây dựng một tập các lớp đối tƣợng tƣơng ứng với mỗi bài toán, phƣơng pháp này tiến hành theo hai pha chính: Pha phân tích: Chuyển đổi yêu cầu bài toán từ ngôn ngữ tự nhiên sang ngôn ngữ mô hình. Pha thiết kế: Chuyển đổi đặc tả bài toán dƣới dạng ngôn ngữ mô hình sang một mô hình cụ thể có thể cài đặt đƣợc. Hai pha phân tích và thiết kế này bao gồm nhiều bƣớc khác nhau(gồm 6 bƣớc): Mô tả bài toán Đặc tả yêu cầu Trích chọn đối tƣợng Mô hình hoá lớp đối tƣợng Thiết kế tổng quan Thiết kế chi tiết. 1.3. So sánh hai cách tiếp cận Phƣơng pháp tiếp cận hƣớng đối tƣợng có bản chất hoàn toàn khác với phƣơng pháp tiếp cận truyền thống nhƣ: Phƣơng pháp mô hình bài toán Đặc trƣng về đóng gói u, nhƣợc điểm Lĩnh vực ứng dụng Phƣơng pháp mô hình bài toán Hai cách này khác nhau ở cách tiếp cận và mô hình bài toán. Phƣơng pháp hƣớng đối tƣợng tiến hành theo phƣơng pháp từ dƣới lên trên, từ thấp lên cao, từ cụ thể đến trừu tƣợng. phƣơng pháp hƣớng đối tƣợng bắt đầu bằng những đối tƣợng cụ thể, tập hợp thuộc tính của từng đối tƣợn, sau đó nhóm các đối tƣợng tƣơng tự lại thành nhóm, loại bỏ các thuộc tính cá biệt, giữ lại những thuộc tính chung nhất, nhóm thành lớp. Cho nên quá trình hình thành lớp là quá trình đi từ thấp lên cao, từ cụ thể ở mức thấp đến trừu tƣợng hóa ở mức cao. Phƣơng pháp cấu trúc trong lập trình truyền thống tiếp cận theo phƣơng pháp từ trên xuống dƣới, từ tổng quan đến chi tiết. Phƣơng pháp bắt đầu từ một bài toán tổng quan, ở mức khái quát cao, chia nhỏ dần, làm mịn dần cho đến khi thu đƣợc một tập các bài toán con, nhỏ hơn, cụ thể hơn, chi tiết hơn. Trang 9 Đặc trƣng về đóng gói Phƣơng pháp hƣớng đối tƣợng có đặc trƣng là dữ liệu đƣợc đóng gói để hạn chế truy cập tự do trực tiếp vào dữ liệu. Đóng gói cho phép sử dụng lại mã nguồn để tiết kiệm tài nguyên và công sức lập trình. Phƣơng pháp cấu trúc là cấu trúc dữ liệu và giải thuật, mối quan hệ phụ thuộc chặc chẽ của giải thuật vào cấu trúc dữ liệu. u, nhƣợc điểm Phƣơng pháp hƣớng đối tƣợng có ƣu iểm là bảo vệ đƣợc dữ liệu tránh bị truy cập tự do trực tiếp từ bên ngoài cho phép sử dụng lại mã nguồn để tiết kiệm tài nguyên và công sức lập trình. Tuy nhiên, phƣơng pháp này lại khá phức tạp, khó theo dõi đƣợc luồng dữ liệu và giải thuật không phải là vấn đề trọng tâm của phƣơng pháp này. Phƣơng pháp hƣớng cấu trúc có ƣu điểm là tƣ duy giải thuật rõ ràng, dễ theo dõi luồng dữ liệu, chƣơng trình đơn giản và dễ hiểu. Tuy nhiên không bảo vệ đƣợc an toàn dữ liệu trong chƣơng trình và sự phụ thuộc chặc chẽ của dữ liệu và giải thuật do đó việc kế thừa khó khăn. Lĩnh vực ứng dụng Phƣơng pháp hƣớng đối tƣợng thƣờng áp dụng cho những bài toán lớn, phức tạp, có nhiều luồng dữ liệu khác nhau, không thể quản lí bằng phƣơng pháp cấu trúc. Phƣơng pháp cấu trúc thƣờng phù hợp với những bài toán nhỏ, có luồng dữ liệu rõ ràng và ngƣời lập trình có khả năng tự quản lí đƣợc mọi truy nhập đến dữ liệu của chƣơng trình. 1.4. Xu hƣớng phát triển của lập trình hƣớng đối tƣợng Lập trình hƣớng thành phần (Component-oriented programming-COP) Xuất phát từ lập trình hƣớng đối tƣợng, tƣ duy lập trình hƣớng thành phần theo ý tƣởng: Giải quyết bài toán bằng cách xây dựng một tập các thành phần (component) cótính độc lập tƣơng đối với nhau. Mỗi thành phần đảm nhiệm một phần công việc nhất định. Sau đó, ngƣời ta ghép các thành phần với nhau để thu đƣợc một phần mềm thoảmãn một tập các yêu cầu xác định. Với lập trình hƣớng thành phần, ngƣời ta có thể tiến hành lập trình theo phƣơng pháp sau: Xây dựng một thƣ viện các thành phần, mỗi thành phần thực hiện một côngviệc xác định. Khi cần phát triển một phần mềm cụ thể, ngƣời ta chỉ cần chọn những thành phần có sẵn trong thƣ viện để ghép lại với nhau. Ngƣời lập trình chỉ phải phát triểnthêm các thành phần mình cần mà chƣa có trong thƣ viện. Phƣơng pháp này có những ƣu điểm rất lớn: Trang 10 - Lập trình viên có thể chia sẻ với nhau những thành phần mình đã xây dựng cho nhiều ngƣời khác dùng chung. - Khi cần, lập trình viên có thể lắp ghép các thành phần có sẵn khác nhau để tạo thành các chƣơng trình có chức năng khác nhau. Tất cả chỉ cần dựa trên công nghệ lắp ghép thành phần, tiết kiệm đƣợc rất nhiều công sức lập trình. Lập trình hƣớng tác nhân (Agent-oriented programming) Lập trình hƣớng agent có thể xem là một mức trừu tƣợng cao hơn của lập trình hƣớngthành phần. Trong đó, các agent là các thành phần có khả năng hoạt động độc lập, tự chủ để hoàn thành công việc của mình. Hơn nữa, các agent có khả năng chủ động liên lạc với các agent khác để có thể phối hợp, cộng tác hay cạnh tranh nhau để hoàn thành nhiệm vụ. Lập trình hƣớng agent có hai đặc trƣng cơ bản: - Thứ nhất là khả năng tự chủ của mỗi agent để hoàn thành nhiệm vụ riêng của nó. - Thứ hai là tính tổ chức xã hội giữa các agent, cho phép các agent phối hợp,cộng tác, cạnh tranh nhau để hoàn thành nhiệm vụ chung của toàn hệ thống. Lập trình hƣớng khía cạnh (Aspect-oriented programming-AOP) Phƣơng pháp lập trình hƣớng khía cạnh là phƣơng pháp lập trình phát triển tƣ duy tách biệt các mối quan tâm khác nhau thành các mô đun khác nhau. Ở đây, một mối quantâm thƣờng không phải một chức năng nghiệp vụ cụ thể và có thể đóng gói mà là mộtkhía cạnh (thuộc tính) chung mà nhiều mô đun phần mềm trong cùng hệ thống nên có,ví dụ lƣu vết thao tác và lỗi (error logging). Với AOP, chúng ta có thể cài đặt các mối quan tâm chung cắt ngang hệ thống bằng cácmô đun đặc biệt gọi là aspect thay vì dàn trải chúng trên các mô đun nghiệp vụ liênquan. Các aspect sau đó đƣợc tự kết hợp với các mô đun nghiệp vụ khác bằng quátrình gọi là đan (weaving) bằng bộ biên dịch đặc biệt. AspectJ là một công cụ AOP cho ngôn ngữ lập trình Java. Trình biên dịch AspectJ sẽ đan xen chƣơng trình Java chính với các aspect thành các tập tin bytecode chạy trên máy ảo Java. 1.5. Câu hỏi và bài tập Bài 1. Nêu các đặc trƣng cơ bản trong cách tiếp cận lập trình hƣớng chức năng và lập trình hƣớng đối tƣợng. Bài 2. Vẽ một sơ đồ phân cấp lớp cho các lớp sau đây: táo, chuối, thịt bò, nƣớc giải khát, phó mát, thứ có thể ăn uống, sản phẩm bơ sửa, đồ ăn, trái cây, đậu xanh, thịt, sữa, thịt heo, rau muống, rau. Bài 3. Những đặc điểm nào của tivi mà chúng cần thiết để đƣợc trừu tƣợng từ góc nhìn của Một khách hàng? Một kỹ sƣ thiết kế? Ngƣời bán? Nhà sản xuất? Trang 11 Bài 4. Chọn một bài toán mà bạn muốn mô hình hoá từ cách tiếp cận hƣớng đối tƣợng. Bạn nên chọn các lĩnh vực mà bạn quan tâm hay bạn thƣờng gặp trong công việc hàng ngày. Giả sử bạn sẽ viết một chƣơng trình để tự động vài chức năng của bài toán. Đầutiên viết một trang giấy mô tả yêu cầu của chƣơng trình. Đoạn văn đầu tiên mô tả tổng quát hệ thống dự định. Kế đến nêu rõ yêu cầu chức năng mà ngƣời sử dụng bìnhthƣờng mô tả hệ thống, tránh dùng các từ kỹ thuật nhƣ, “Hệ thống này phải chạy trên môi trƣờng Windows NT, và dùng giao thức TCPIP để . . .” Trang 12 CHƠNG 2 NHỮNG KHÁI NIỆM CƠ BẢN CỦA LẬP TRÌNH HỚNG ĐỐI TỢNG Nội dung chương giới thiệu tới người đọc những khái niệm trong lập trình hướng đối tượng như: Đối tượng (Object); Lớp đối tượng (Class); Kế thừa (Inhenrritan); Đ óng gói (Encapsulation); … 2.1. Đối tƣợng (Object) Đối tượng là khái niệm cơ sở quan trọng nhất của cách tiếp cận hƣớng đối tƣợng. Theo nghĩa thông thƣờng thì đối tƣợng là ngƣời, vật hay hiện tƣợng mà con ngƣời nhằm vào trong suy nghĩ, trong hành động; là bất kỳ cái gì nhìn thấy, sờ mó đƣợc. Trong phƣơng pháp hƣớng đối tƣợng thì Đối tượng là một khái niệm, một sự trừu tượ ng hoá hay một sự vật có nghĩa trong bài toán đang khảo sát. Đối tượng là thực thể của hệ thống, của cơ sở dữ liệu (CSDL) và đƣợc xác định thông qua định danh (IDentifier) của chúng. Mỗi đối tƣợng có tập các đặc trƣng bao gồm: tên đối tượng nhằm xác định một thự c thể, dữ liệu thành phần (thuộc tính của đối tƣợng) nhằm mô tả đối tƣợng, các hàm thành phần (hành độngphƣơng thức: Method) trên dữ liệu để mô tả hành vi của đối tƣợng. Đối tƣợng là những thực thể đƣợc xác định trong thời gian hệ thống hƣớng đối tƣợng hoạt động. Nhƣ vậy đối tƣợng có thể biểu diễn cho ngƣời, vật, hay một bảng dữ liệu, … cần xử lý trong chƣơng trình. Nhiệm vụ của lập trình hƣớng đối tƣợng (LTHĐT) là phân tích bài toán thành các đối tƣợng và xác định bản chất của sự trao đổ i thông tin giữa chúng. Đối tƣợng trong chƣơng trình cần phải đƣợc chọn sao cho nó thể hiện đƣợ c một cách gần nhất với những thực thể có trong hệ thống thực. Hệ thống xem nhƣ tập các đối tƣợng đƣợc trao đổi với nhau thông qua việc gử i và nhận thông điệp.  Các ví dụ về đối tƣợng + Mô tả đối tƣợng: Các đối tƣợng cụ thể đƣợc mô tả bằng hình sau: + Trao đổi thông tin giữa các đối tƣợng: Xét các đối tƣợng: - Phòng kế toán: chịu trách nhiệm lƣơng các nhân sự, phƣơng thức chi trả lƣơng -Tên: Java -Số tiết: 60 -Nhập tên GVGD -Nhập số lớp học -Tên: ABC -Các đỉnh: 3 -Màu viền: xanh -Màu tô: đỏ -Vẽ -Xóa -Dời -Tên: Jack -Tuổi: 19 -Cân nặng: 50 -Đi -Nói -Làm bài kiểm tra Trang 13 - Phòng nhân sự: chịu trách nhiệm các thông tin nhân sự, một nhân sự yêu cầ u phòng kế toán chi trả lƣơng cho mình, gọi phƣơng thức từ đối tƣợng khác. 2.2. Lớp đối tƣợng (Class) Tập các đối tƣợng có cùng tính chất và cách ứng xử chung (thuộc tính, hàm): Lớp ngƣời, lớp đa giác…Lớp đƣợc hiểu nhƣ một bản mẫu, đối tƣợng là thể hiện (Instance) củ a một lớp xác định. Trong lập trình hƣớng đối tƣợng, lớp đƣợc xem là đồng nhất với kiể u dữ liệu trừu tƣợng (ADT- Abstract Data Type). Khai báo lớp: Bao gồm các thuộc tính cùng với kiểu dữ liệu, các giá trị cụ thể củ a thuộc tính sẽ đƣợc gán sau khi đã tạo ra đối tƣợng. Trong khai báo lớp có những phƣơng thức trong lớp đó. Lớp đƣợc mô tả nhƣ sau: 2.3. Trừu tƣợng hóa dữ liệu (Abstraction) Trừu tƣợng hóa là cách biểu diễn những đặc tính chính và bỏ qua những chi tiế t. Trừu tƣợng hóa là sự mở rộng kiểu dữ liệu và cho phép định nghĩa những phép toán trừu tƣợng trên những dữ liệu trừu tƣợng. Để xây dựng cách lớp, chúng ta phải sử dụng khái niệm trừu tƣợng hóa. Trong ứ ng dụng chúng ta quan tâm đến việc mô tả đối tƣợng trong thế giới thự c thông qua các tính chất của đối tƣợng bỏ qua cách biểu diễn dữ liệu. Ví dụ: đối tƣợng hình gồm có số cạnh, màu viền, màu nền (trừu tƣợng hoá về dữ liệu). Ta cũng quan tâm đến tập tất cả các hành vi có thể có của đối tƣợng để xây dự ng các hàm. Ví dụ: vẽ, di chuyển, xoá. Ta không quan tâm vào cách thực thi của hàm mà tập trung vào các đối số và giá trị trả về của hàm (sự trừu tƣợng hoá về thủ tục). Khi xây dựng phần mềm thì nguyên lý trừu tƣợng hóa đƣợc thực hiệ n thông qua việc trừu tƣợng hóa các chức năng, hàm và trừu tƣợng hóa các kiểu dữ liệu nguyên thủy. -String Tên -int Tuổi -byte Cân nặng -Đi -Nói -Làm bài kiểm tra -String Tên - int Các đỉnh - int Màu viền - int Màu tô -Vẽ -Xóa -Dời -String Tên -int Số tiết -Nhập tên GVGD -Nhập số lớp học Trang 14 2.4. Khái niệm kế thừa (Inheritance) Khái niệm "kế thừa" thƣờng đƣợc dùng trong các ngôn ngữ lập trình hƣớng đối tƣợng để chuyển quan hệ tổng quát hóa và đặc biệt hóa của thế giới thực vào các chƣơng trình máy tính. Tính kế thừa cho phép ta xây dựng một lớp mới dựa trên các định nghĩa của một lớp đã có. Nếu một lớp A là lớp đặc biệt hóa của lớp B (nghĩa là lớp B là lớp tổng quát hóa của lớp A) thì trong lập trình hƣớng đối tƣợng lớp A đƣợc cài đặt là lớp kế thừa của lớp B (nói ngắn gọn là "lớp A kế thừa lớp B"). Khi lớp A kế thừa lớp B thì lớp B đƣợc gọi là "lớp cơ sở" hay "lớp cha" (trong mối quan hệ kế thừa đang xét), còn lớp A thì đƣợc gọi là "lớp kế thừa", "lớp con" hay "lớp dẫn xuất".  Tính thừa kế là cho phép dùng lại một lớp hiện có (sử dụng các thuộc tính, phƣơng thức) để xây dựng một lớp mới bằng cách bổ sung thêm các thuộc tính và phƣơng thức mới. Ví dụ: -Lớp sinh viên có các tính chất: mã sv, tên sinh viên, ngày sinh...các phƣơng thức: nộp điểm, thi... -Lớp sinh viên thể dục cũng có các thuộc tính và phƣơng thức nhƣ lớp sinh viên nhƣng có thêm các thuộc tính khác nhƣ chiều cao, cân nặng...và các phƣơng thức: chạ y, nhảy cao... Lớp sinh viên thể dục (lớp con) là lớp kế thừa từ lớp sinh viên (lớp chalớp cơ sở siêu lớp)  Nguyên lý kế thừa: -Kế thừa đơn: Một lớp có thể kế thừa từ một lớp cơ sở, cây phân cấp các lớp. -Kế thừa bội: Một lớp có thể kế thừa từ nhiều lớp cơ sở. Trong Java chỉ hỗ trợ kế thừa đơn, kế thừa bội thực hiện thông qua khái niệm giao diện (Interface). Ví dụ về cấu trúc phân cấp các lớp theo quan hệ kế thừa nhƣ hình sau:  Việc kế thừa phải tuân thủ theo nguyên tắc bao bọc thông tin, có nghĩa: -public: Các biến dữ liệu, các hàm đƣợc truy cập mọi nơi trong hệ thốngLop A Lop B Trang 15 -private: Các biến dữ liệu, các hàm đƣợc truy cập chỉ trong lớp đó. -protected: Các biến dữ liệu, các hàm đƣợc truy cập chỉ trong lớp đó và trong các lớp con của nó. -static: Các biến dữ liệu, các hàm đƣợc dùng cho mọi đối tƣợng, đƣợc khởi tạ o khi nạp lớp vào lúc đầu. Khai báo static đƣợc dùng nhƣ sau: Nó thuộc vào một lớp chứ không thuộc một đối tƣợng riêng lẻ nào. Khi thực hiện sẽ tạo ra một bản sao của dữ liệ u, hàm trong lớp. 2.5. Khái niệm đóng gói (Encapsulation) Đóng gói là sự che giấu bên trong dữ liệu riêng của mỗi đối tƣợng của lớp đƣợc khai báo và chỉ đƣợc truy xuất thông qua hệ thống các phƣơng thức có sẵn của lớp (chỉ có thể gọi những phương thức có sẵn của lớp). Vì vậy, nó còn đƣợc gọi là data hiding (nghĩa là che giấu dữ liệu).  Tính đóng gói có những đặc điểm nhƣ sau: - Tạo ra cơ chế để ngăn ngừa việc gọi phƣơng thức của lớp này tác động hay truy xuất dữ liệu của đối tƣợng thuộc về lớp khác. - Dữ liệu riêng (khi được khai báo là private) của mỗi đối tƣợng đƣợc bảo vệ khỏi sự truy xuất không hợp lệ từ bên ngoài. - Ngƣời lập trình có thể dựa vào cơ chế này để ngăn ngừa việc gán giá trị không hợp lệ vào thành phần dữ liệu của mỗi đối tƣợng. - Cho phép thay đổi cấu trúc bên trong của một lớp mà không làm ảnh hƣởng đến những lớp bên ngoài có sử dụng lớp đó.  Để cài đặt tính đóng gói, chúng ta có 2 bƣớc nhƣ sau: - Khai báo các thuộc tính của đối tƣợng trong lớp là private để các lớp khác không thể truy cập trực tiếpsửa đổi đƣợc. - Cung cấp các phƣơng thức gettersetter có phạm vi truy cập là public để truy cập và sửa đổi các giá trị của thuộc tính trong lớp. Phƣơng thức getter là phƣơng thức truy cập vào thuộc tính của đối tƣợng và trả về các thuộc tính của đối tƣợng, còn phƣơng thức setter là phƣơng thức truy cập vào thuộc tính của đối tƣợng và gán giá trị cho các thuộc tính của đối tƣợng đó. Ví dụ: File Person.java public class Person { khai báo các thuộc tính của đối tượng là private private String cmnd; private String hoTen; tạo các phương thức gettersetter 2 phương thức getCmnd() và getHoTen() là phương thức getter dùng để trả về số chứng minh nhân dân và họ tên của đối tượng Trang 16 và kiểu trả về của hai phương thức này tương ứng với kiểu dữ liệu của thuộc tính 2 phương thức setCmnd() và setHoTen() là phương thức setter dùng để gán giá trị cho thuộc tính chứng minh nhân dân và họ tên của đối tượng trong đó tham số truyền vào của 2 phương thức này được gọi là tham số (biến cục bộ) và có kiểu dữ liệu tương ứng với kiểu dữ liệu của thuộc tính (biến đối tượng) public String getCmnd() { return cmnd; } this là từ khóa có ý nghĩa là một tham chiếu đặc biệt chiếu tới đối tượng chủ của phương thức hiện hành this có thể được dùng để truy cập biến đối tượng (instance variable) hoặc gọi phương thức đối với đối tượng hiện hành. Thông thường, công dụng này của this chỉ có ích khi tên biến đối tượng bị trùng với tham số (biến cục bộ - local variable) của phương thức public void setCmnd(String cmnd) { this.cmnd = cmnd; } public String getHoTen() { return hoTen; } public void setHoTen(String hoTen) { this.hoTen = hoTen; } } File TesrPerson.java public class TestPerson { public static void main(String args) { Person person = new Person(); gán giá trị họ tên cho đối tượng person vừa tạo thông qua setHoTen() và gán số chứng minh nhân dân thông qua setCmnd() person.setHoTen("Trần Văn Bình"); person.setCmnd("212321678"); truy cập đến tên của đối tượng person thông qua phương thức getHoten() và số chứng minh nhân dân thông qua phương thức getCmnd() Trang 17 System.out.println("Tên: " + person.getHoTen() + ", số cmnd: " + person.getCmnd()); } } 2.6. Khái niệm đa hình (Polymorphism) Kỹ thuật đa hình trong các ngôn ngữ lập trình hƣớng đối tƣợng tạo điều kiện cho các lập trình viên gia tăng khả năng tái sử dụng những đoạn mã nguồn đƣợc viết một cách tổng quát và có thể thay đổi cách ứng xử một cách linh hoạt tùy theo loại đối tƣợng. Tính đa hình (Polymorphism) trong Java đƣợc hiểu là trong từng trƣờng hợp, hoàn cảnh khác nhau thì đối tƣợng có hình thái khác nhau tùy thuộc vào từng ngữ cảnh. Đối tƣợng có tính đa hình đƣợc xem nhƣ một đối tƣợng đặc biệt vì có lúc đối tƣợng này trở thành một đối tƣợng khác và cũng có lúc đối tƣợng này trở thành một đối tƣợng khác nữa (tùy vào từng hoàn cảnh). Sự "nhập vai" vào các đối tƣợng khác nhau này giúp cho đối tƣợng đa hình ban đầu có thể thực hiện những hành động khác nhau của từng đối tƣợng cụ thể. Ví dụ: Khi bạn ở trong trƣờng học là sinh viên thì bạn có nhiệm vụ học, nghe giảng,..., nhƣng khi bạn ở nhà thì bạn lại đóng vai trò là thành viên trong gia đình và bạn có nhiệm vụ phải làm việc nhà, rồi khi bạn vào siêu thị thì bạn đóng vai trò là khách hàng đi mua hàng. Vì vậy, chúng ta có thể hiểu đa hình của đối tƣợng là trong từng trƣờng hợp, hoàn cảnh khác nhau thì đối tƣợng có khả năng thực hiện các công việc khác nhau. Để thể hiện tính đa hình, chúng ta cần đảm bảo 2 điều kiện sau:  Các lớp phải có quan hệ kế thừa với 1 lớp cha nào đó.  Phƣơng thức đa hình phải đƣợc ghi đè (override) ở lớp con. Tính đa hình chỉ đƣợc thể hiện ghi đã ghi đè lên phƣơng thức của lớp cha. File Shape.java public class Shape { public void show() { System.out.println("Đây là phương thức show() của lớp Shape"); } } File Rectangle.java public class Rectangle extends Shape { public void show() { System.out.println("Đây là phương thức show() của lớp Rectangle"); } } File Square.java public class Square extends Shape { public void show() { Trang 18 System.out.println("Đây là phương thức show() của lớp Square"); } } File Main.java public class Main { public static void main(String args) { Shape shape = new Shape(); shape.show(); hiển thị dòng "Đây là phương thức show() của lớp Shape" bản chất của shape là Shape, nhưng vì khai báo Rectangle nên chúng ta chỉ nhìn thấy những gì mà Rectangle có vì vậy sẽ chạy những hàm của Rectangle shape = new Rectangle(); shape.show(); hiển thị dòng "Đây là phương thức show() của lớp Rectangle" tương tự lúc này shape sẽ đóng vai trò là 1 Square shape = new Square(); shape.show(); hiển thị dòng "Đây là phương thức show() của lớp Square" } } 2.7. Câu hỏi và bài tập Bài 1. Nêu các đặc trƣng cơ bản trong cách tiếp cận lập trình hƣớng chức năng và lập trình hƣớng đối tƣợng. Bài 2. Tại sao lại gọi khái niệm lớp là kiểu dữ liệu trừ tƣợng trong LTHĐT. Bài 3. Khái niệm kế thừa trong lập trình hƣớng đối tƣợng là gì? Cho một ví dụ về tính kế thừa. Java hỗ trợ quan hệ kế thừa nhƣ thế nào? Bài 4. Nêu nguyên lý hoạt động của tính đa thể. Cho ví dụ. Bài 5. Sƣu tập các thuộc tính và phƣơng thức khi mô tả lớp “Sinh Vien”, cho một thể hiện của lớp này. Bài 6. Sƣu tập các thuộc tính và phƣơng thức khi mô tả lớp “Phan So”, cho một thể hiện của lớp này. Bài 7. Sƣu tập các thuộc tính và phƣơng thức khi mô tả lớp “Hoc Sinh”, cho một thể hiện của lớp này. Trang 19 CHƠNG 3 NGÔN NGỮ LẬP TRÌNH JAVA Trong nội dung chương này, chúng ta sẽ lần lượt tìm hiểu về khái niệm Java là gì? Bên cạnh đó, nội dung chương này cũng sẽ lần lượt giới thiệu những đặc điểm cơ bản và ứng dụng của ngôn ngữ Java và các Platform cơ bản của ngôn ngữ lập trình Java. Cách cài đặt Java, cấu hình biến môi trường cho Java và các bước cài đặt và cấu hình Eclipse. Nội dung chương cũng giới thiệu các kiểu dữ liệu có trong Java, cấu trúc một chương trình Java và các cấu trúc lệnh của Java. 3.1. Giới thiệu và cài đặt ngôn ngữ Java 3.1.1. Lịch sử của Java Giới thiệu ngôn ngữ Java Java là một ngôn ngữ lập lập trình, đƣợc phát triển bởi Sun Microsystem vào năm 1995, là ngôn ngữ kế thừa trực tiếp từ CC++ và là một ngôn ngữ lập trình hƣớng đối tƣợng. Java là tên một hòn đảo ở Indonesia - hòn đảo nổi tiếng với loại coffee Peet và cũng là loại nƣớc uống phổ biến của các kỹ sƣ Sun. Ban đầu Ngôn ngữ này đƣợc đặt tên là "Oak" (có nghĩa là "Cây sồi" - 1991), nhƣng các luật sƣ của Sun xác định rằng tên đó đã đƣợc đăng ký nhãn hiệu nên các nhà phát triển đã phải thay thế bằng một tên mới - và cũng vì lý do trên mà cái tên Java đã ra đời và trở thành tên gọi chính thức của Ngôn ngữ này - Ngôn ngữ Lập trình Java. Ứng dụng của Java Hiện nay Java đƣợc sử dụng với các mục đích sau: - Phát triển ứng dụng cho các thiết bị điện tử thông minh, các ứng dụng cho doanh nghiệp với quy mô lớn. - Tạo các trang web có nội dung động (web applet), nâng cao chức năng của server. - Phát triển nhiều loại ứng dụng khác nhau: Cơ sở dữ liệu, mạng, Internet, viễn thông, giải trí,... 3.1.2. Đặt trƣng của ngôn ngữ Java Đặc điểm của Java - Thông dịch (Interpreter): Tệp chƣơng trình nguồn (.java) đƣợc biên dị ch qua tập tin nhị phân (.class), tập tin chứa các mã thực hiện của chƣơng trình và các tham số của máy ảo Java (Java Virtual Machine: JVM). Máy ảo Java có tác dụng thông dị ch chuyển tập tin nhị phân thành các lệnh cần thiết phù hợp với từng cấu hình. - Ứng dụng hoàn toàn toàn độc lập với cấu hình máy, “viết một lần, chạy mọi nơi” (Write Once, Run Anywhere), nghĩa là Java cho phép chúng ta viết code một lầ n và thực thi đƣợc trên các hệ điều hành khác nhau. Ví dụ, chúng ta viết code trên Hệ Trang 20 điều hành Windows và nó có thể thực thi đƣợc trên các Hệ điều hành Linux và Mac OS.... Vì vậy, các ứng dụng phù hợp với mạng Internet (Web). - Cơ chế bảo mật cao - Quen thuộc: Vì Java kế thừa trực tiếp từ CC++ nên nó có những đặc điểm của ngôn ngữ này, Java đơn giản vì mặc dù dựa trên cơ sở C++ nhƣng Sun đã cẩn thận lƣợc bỏ các tính năng khó nhất của của C++ để làm cho ngôn ngữ này dễ sử dụng hơn. Hƣớng đối tƣợng và quen thuộc. - Mạnh mẽ (thể hiện ở cơ chế tự động thu gom rác - Garbage Collection) và an toàn. - Kiến trúc trung lập, độc lập nền tảng và có tính khả chuyển (Portability). - Hiệu suất cao. - Phân tán. - Đa nhiệm: Ngôn ngữ Java cho phép xây dựng trình ứng dụng, trong đó nhiều quá trình có thể xảy ra đồng thời. Tính đa nhiệm cho phép các nhà lập trình có thể biên soạn phần mềm đáp ứng tốt hơn, tƣơng tác tốt hơn và thực hiện theo thời gian thực. 3.1.3. Cài đặt, cấu hình các phần mềm và biên dịch chƣơng trình Java Các platform cơ bản của Java Java Platform gồm có 3 thành phần chính:  Java Virtual Machine (Java VM): Máy ảo Java.  Java Application Programming Interface (Java API).  Java Development Kit (JDK) gồm trình biên dịch, thông dịch, trợ giúp, soạn tài liệu... và các thƣ viện chuẩn. Trang 21 Tiêu chuẩn của một môi trƣờng Java Thông thƣờng, các chƣơng trình Java trải qua 5 giai đoạn chính:  Editor: Lập trình viên viết chƣơng trình và đƣợc lƣu vào máy tính với định dạng .java.  Compiler: Biên dịch chƣơng trình thành bytecodes (định dạng .class) - nhờ bƣớc trung gian này mà Java đƣợc viết 1 lần và chạy trên các hệ điều hành khác nhau.  Class Loader: Đọc file .class chứa mã bytecodes và lƣu vào trong bộ nhớ.  Bytecode Verifier: Đảm bảo rằng mã bytecodes là hợp lệ và không vi phạm các vấn đề về bảo mật của Java.  Intepreter: Biên dịch bytecodes thành mã máy để máy tính có thể hiểu đƣợc và sau đó thực thi chƣơng trình. Download và cài đặt JDK (Java Development Kit) Đầu tiên, ta vào trang chủ của Oracle để tiến hành tải về JDK http:www.oracle.comtechnetworkjavajavasedownloadsindex.html. Trang 22 Tại đây, tùy thuộc vào máy tính cài hệ điều hành Windows 32 bit hay 64 bit mà ta chọn phiên bản cho phù hợp. Trƣớc tiên cần chọn vào mục Accept License Agreement và sau đó tiến hành chọn phiên bản JDK phù hợp và lƣu vào ổ đĩa. Tiến hành cài đặt: Bƣớc 1: Kích chuột phải vào file JDK vừa tải về và chọn Open hoặc chúng ta có thể nhấp đôi chuột vào file này để mở file cài đặt lên. Bƣớc 2: Chọn Next Bƣớc 3: Chọn Change để thay đổi thƣ mục cài đặt. Nếu không cần thay đổi, chúng ta chọn Next để tiếp tục Thiết lập biến môi trƣờng và cấu hình cho Java Mở System Properties\ chọn Advanced system settings\Environment Variables\ Trong hộp thoại Environment Variables, chúng ta vào phần System variables và chọn New Trong hộp thoại New System Variable, chúng ta điền vào ô Variable name là JAVAHOME, còn trong ô Variable value chúng ta nhấn vào nút Browser Directory và trỏ tới đƣờng dẫn cài đặt thƣ mục JDK. Nhấn OK để hoàn tất việc đặt tên biến môi trƣờng. Tiếp theo, cũng trong phần System variables, chúng ta tiến hành sửa đổi biến môi trƣờng Path nhƣ sau: Kích chuột vào dòng Path và chọn Edit. Hộp thoại Edit environment variable xuất hiện, chúng ta nhấn chuột vào nút New và điền vào dòng sau: JAVAHOME\bin;, nhấn OK để kết thúc. Để biết đƣợc quá trình cấu hình và cài đặt biến môi trƣờng thành công hay chƣa, bạn gõ tổ hợp phím Windows + R, hộp thoại Run sẽ xuất hiện, bạn nhập vào cmd ở dòng Run. Màn hình Command Prompt xuất hiện, bạn nhập vào dòng sau: java - version. Nếu chúng ta cấu hình thành công thì sẽ có kết quả nhƣ sau: Trang 23 Hƣớng dẫn cách cài đặt và sử dụng Eclipse Download và cài đặt Eclipse Đầu tiên chúng ta vào trang chủ để tải về Eclipse :https:www.eclipse.orgdownloads?. Chọn Download Packages để vào màn hình download Eclipse. Sau đó chọn Eclipse IDE for Java EE Developers và chọn phiên bản 32 bit hay 64 bit tùy thuộc vào phiên bản hệ điều hành đang dùng. Chúng ta chọn ổ đĩa để lƣu file Eclipse. Cài đặt Bƣớc 1: Tiến hành giải nén file nén Eclipse vừa tải về. Bƣớc 2: Kích chuột phải vào eclipse.exe và chọn Open hoặc chúng ta có thể nhấp đôi chuột vào file này để mở file cài đặt lên. Hộp thoại Eclipse Launcher xuất hiện. Trong ô Workspace chúng ta sẽ chọn đƣờng dẫn trỏ tới thƣ mục lƣu Workspace (Workspace ở đây là một thư mục để lưu trữ tập tất cả các Project mà chúng ta tạo ra trên Eclipse). Bạn có thể chọn vào Use this as the default and do not again để mỗi khi khởi động Eclipse lên thì hộp thoại này sẽ không xuất hiện nữa. Chọn Launch để tiến hành cài đặt Eclipse. Hƣớng dẫn sử dụng Eclipse  Thay đổi Workspace Để thay đổi đƣờng dẫn Workspace, bạn vào Switch Workspace → Other và chọn vào đƣờng dẫn bạn cần thay đổi.  Kiểm tra phiên bản Java Để xem phiên bản Java bạn đang dùng, bạn vào Window → Preferences. Hộp thoại Preferences đƣợc hiển thị, bạn nhìn vào dòng Compiler compliance settings sẽ thấy đƣợc phiên bản Java đang dùng.  Tạo Project Để tạo một project Java mới, trƣớc tiên bạn cần phải thay đổi Perpective là Java. Để thay đổi bạn chọn Window → Perpective → Open Perpective và chọn Java. Sau đó, bạn vào File → New (hoặc nhấn tổ hợp phím tắt Alt + Shift + N) và chọn Java Project. Trang 24 Trong hộp thoại New Java Project, bạn nhập vào tên Project trong ô Project name và nhấn Finish.  Tạo Package Package trong Java dùng để nhóm các Lớp (Class), Interface và các gói phụ có liên quan với nhau vào chung một nhóm lớn, nhóm này đƣợc gọi là Package. Để tạo một Package mới, chúng ta vào Package Explorer ở phía trái màn hình, nhấp đôi chuột vào tên project vừa tạo → kích chuột phải vào src → New → Package: Đặt tên cho Package và nhấn Finish để hoàn tất.  Tạo Class Để tạo mới một Lớp (Class), bạn nhấp phải chuột vào tên Package và chọn New → Class. Hộp thoại New Java Class xuất hiện, bạn nhập vào tên Class trong ô Name và chọn vào public static void main(String args) và bấm Finish để kết thúc. Lƣu ý: Để sử dụng tính chất nhắc lệnh của Eclipse, các bạn gõ tổ hợp phím Ctrl + Space, ví dụ để gõ nhanh hàm main thì các bạn gõ chữ main và nhấn Ctrl + Space, chọn vào dòng main - main method và nhấn Enter để hoàn thành. Biên dịch chƣơng trình trên Eclipse Để biên dịch và thực thi chƣơng trình, chúng ta có 3 cách nhƣ sau: Cách 1: Chọn vào biểu tƣợng Run trên thanh công cụ: Cách 2: Chọn vào chữ Run trên thanh công cụ và chọn Run (hoặc nhấn tổ hợp phím Ctrl + F11) Cách 3: Nhấp chuột phải vào tên Class và chọn Run As → Java Application: Nếu trong file HelloWord.java của bạn có chứa những dòng chữ tiếng Việt (ví dụ như: "Chào mừng các bạn đến với ngôn ngữ lập trình Java") thì các bạn phải chọn định dạng UTF-8 bằng cách nhấp chuột phải vào tên Project chọn Properties (hoặc nhấn tổ hợp phím Alt + Enter). Hộp thoại Properties for file HelloWorld xuất hiện, vào phần Resource và tìm đến dòng Text file encoding chọn Other và thay đổi định dạng chữ thành UTF-8. Sau đó, bạn chọn vào Apply và Apply and Close để hoàn tất việc thay đổi định dạng chữ. 3.2. Kiến trúc chƣơng trình Java Những thành phần cơ bản của 1 chƣơng trình Java: Gói (Packages) Giao diện (Interfaces) Những phần của một chƣơng trình Java: Lệnh khai báo gói(package ) Lệnh chỉ định gói đƣợc dùng (Lệnh import) Khai báo lớp public (một file java chỉ chứa 1 lớp public class) Các lớp khác (classes private to the package) Tập tin nguồn Java có thể chứa tất cả hoặc một vài trong số các phần trên. Trang 25 3.2.1. Các thành phần cơ bản của Java ddddddddddddddddddddddddddddddddddddddđ Trong một tệp chƣơng trình java cho phép định nghĩa nhiều lớp hoặc nhiề u giao diện. Tệp chƣơng trình java trùng với tên lớp đƣợc khai báo là public và lớp này chứ a hàm main() nếu là ứng dụng độc lập. Tệp chƣơng trình nguồn có phần mở rộng .java Khi biên dịch thì mỗi lớp hoặc giao diện trong tệp sẽ tạo ra tệ p byte code có tên trùng với tên lớp và giao diện, có phần mở rộng là .class Trong chƣơng trình Java không có các khai báo biến, hàm tách biệt khỏi lớ p và chỉ có các khai báo và định nghĩa các lớp, interface. Nhƣ thế chương trình Java được xem như là tập các lớp, interface và các đối tượng của chúng trao đổi thông điệp vớ i nhau (bằng các lời gọi hàm) để thực hiện các nhiệm vụ của ứng dụng. Trong đó:  Phần 1: thƣ mục chung cần tạo để lƣu các tập tin trong chƣơng trình.  Phần 2: đƣa vào các gói trong Java mà ngƣời dùng sử dụng. import java.io.; Phần 1: Tuỳ chọn Định nghĩa gói package Phần 2: có thể có hoặc không có các gói sử dụng nhập gói cần sử dụng import java.io.; Phần 3: không hoặc nhiều hơn Định nghĩa các lớp và các giao diện public class {…} class {…} interface {…} interface {…} Trang 26 import java.math.; import java.lang.; import java.applet.; import java.awt.; import java.util.; import java.net.; import java.awt.event.; import java.sql.;….  Phần 3: nội dung soạn thảo của chƣơng trình. 3.2.2. Chƣơng trình Java đầu tiên Viết chƣơng trình in dòng HelloWord lên màn hình Console. Khởi động Notepad hoặc Eclipse và gõ đoạn mã sau, lƣu lại với tên HelloWorldApp.java import java.io.; public class HelloWorldApp { public static void main(String args) { In dòng chữ Hello World System.out.println(“Hello World”); } } 3.2.3. Phân tích chƣơng trình Giải thích cấu trúc chƣơng trình: + public: Thuộc tính public của hàm main() cho biết là hàm này đƣợ c phép truy nhập đối với mọi lớp từ bên ngoài của lớp HelloWordApp và cho phép gọi để thự c hiện bởi chƣơng trình thông dịch java. + static: Từ khóa static khai báo hàm này phụ thuộc vào cả lớp, không phụ thuộc vào đối tƣợng cụ thể, do vậy khi thực hiện không cần phải tạo lập đối tƣợng để gọ i những hàm nhƣ thế. + void: Từ khóa void cho biết hàm main() không có kết quả trả lại. + Hàm main có các đối số là mảng các xâu (đối tƣợng) agrs của String. Trang 27 Biên dịchThông dịch chƣơng trình java sử dụng jdk Vào cmd > đến thƣ mục chứa bài tập đã lƣu Biên dịch ..\jdk\bin>javac HelloWorldApp.java Thông dịch ..\jdk\bin>java HelloWorldApp -Kết quả sau khi biên dịch 3.3. Ngôn ngữ Java 3.3.1. Ghi chú (Comment) Comment code trong Java là những đoạn code mà compiler sẽ bỏ qua lúc biên dịch (tức là trình biên dịch sẽ bỏ qua khi gặp phải những đoạn comment này trong code của chúng ta). Vậy tại sao chúng ta cần phải sử dụng tới các comment này trong chƣơng trình của mình? Đó là vì: Các đoạn comment này dùng để giải thích về ý

TRƯỜNG ĐẠI HỌC QUẢNG NAM KHOA TOÁN - TIN

  

BÀI GIẢNG

MÃ HỌC PHẦN: 21031641

NGÀNH ĐÀO TẠO: ĐẠI HỌC CÔNG NGHỆ THÔNG TIN

1 Giảng viên biên soạn: Th.S TRẦN THỊ DIỆU HIỀN

MỤC LỤC

CHƯƠNG 1TỔNG QUAN VỀ CÁCH TIẾP CẬN HƯỚNG ĐỐI TƯỢNG 5

1.1 Phương pháp tiếp cận của lập trình truyền thống 5

1.4 Xu hướng phát triển của lập trình hướng đối tượng 9

1.5 Câu hỏi và bài tập 10

CHƯƠNG 2NHỮNG KHÁI NIỆM CƠ BẢN CỦA LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG 12

2.1 Đối tượng (Object) 12

2.2 Lớp đối tượng (Class) 13

2.3 Trừu tượng hóa dữ liệu (Abstraction) 13

2.4 Khái niệm kế thừa (Inheritance) 14

2.5 Khái niệm đóng gói (Encapsulation) 15

2.6 Khái niệm đa hình (Polymorphism) 17

2.7 Câu hỏi và bài tập 18

CHƯƠNG 3NGÔN NGỮ LẬP TRÌNH JAVA 19

3.1 Giới thiệu và cài đặt ngôn ngữ Java 19

3.1.1 Lịch sử của Java 19

3.1.2 Đặt trưng của ngôn ngữ Java 19

3.1.3 Cài đặt, cấu hình các phần mềm và biên dịch chương trình Java 20

3.2 Kiến trúc chương trình Java 24

3.2.1 Các thành phần cơ bản của Java 25

3.2.2 Chương trình Java đầu tiên 26

3.5 Hàm – Phương thức (Fuction – Method) 52

3.5 Câu hỏi và bài tập 54

CHƯƠNG 4KẾ THỪA VÀ ĐA HÌNH TRÊN JAVA 57

4.6 Câu hỏi và bài tập 80

CHƯƠNG 5LẬP TRÌNH GIAO DIỆN TRÊN JAVA 84

5.1 Mở đầu 84

5.2 Giới thiệu AWT và Swing 84

5.3 Khái niệm các đối tượng cơ bản 85

5.3.1 Container (Thùng chứa) 85

5.3.2 Component (Thành phần) 87

5.3.3 Layout Manager: trình quản lý cách trình bày 98

5.4 Thiết kế GUI cho chương trình 99

5.4.1.Tạo khung chứa cửa sổ chương trình 99

5.4.2 Tạo hệ thống thực đơn 99

5.4.3 Gắn Component vào khung chứa 101

5.4.4 Trình bày các Component trong khung chứa 102

5.4.5 Các đối tượng khung chứa Container 109

5.7 Lập trình giao diện với WindowBuilder trong Eclipse 138

5.7.1 tải và cài đặt WindowBuilder 138

5.7.2 Lập trình 139

CHƯƠNG 6NHẬP XUẤT DỮ LIỆU 144

6.1 Tổng quát 144

6.1.1 Đường dẫn (Path) 144

6.1.2 Đường dẫn tương đối và tuyệt đối 145

6.1.3 Giới thiệu lớp java.io.File 145

6.1.4 Lấy đường dẫn đến thư mục đang làm việc 146

6.1.5 Tạo thư mục 147

7.4 Kết nối cơ sở dữ liệu với JDBC 163

7.4.1 Đăng ký trình điều khiển 165

7.4.2 Thực hiện kết nối 167

7.5 Kiểu dữ liệu SQL và kiểu dữ liệu java 174

7.6 Các thao tác cơ bản trên cơ sở dữ liệu 178

7.6.1 Hướng dẫn kết nối java với mysql – Chuẩn bị 178

7.6.2 Hướng dẫn kết nối java với mysql – Tạo database 178

CHƯƠNG 1

TỔNG QUAN VỀ CÁCH TIẾP CẬN HƯỚNG ĐỐI TƯỢNG

Chương này giới thiệu đến các bạn một số vấn đề liên quan đến lập trình truyền thống, lập trình hướng đối tượng; so sánh những ưu nhược điểm đối với 2 cách tiếp cận Xu hướng phát triển của lập trình hướng đối tượng trong giai đoạn hiện nay và tương lai

1.1 Phương pháp tiếp cận của lập trình truyền thống

Máy tính đầu tiên được lập trình bằng mã nhị phân, sử dụng các công tắt cơ khí để nạp chương trình Cùng với sự xuất hiện của các thiết bị lưu trữ lớn và bộ nhớ máy tính có dung lượng lớn nên các ngôn ngữ lập trình cấp cao đầu tiên được đưa vào sử dụng Thay vì phải suy nghĩ trên một dãy các bit và byte, lập trình viên có thể viết một loạt lệnh gần với tiếng Anh và sau đó chương trình dịch thành ngôn ngữ máy

1.1.1 Lập trình tuyến tính

Lập trình tuyến tính là một phương pháp, kỹ thuật lập trình truyền thống Trong lập trình tuyến tính, chương trình sẽ chỉ có một hàm và được thực hiện tuần tự từ đầu tới cuối Đặc trưng của lập trình tuyến tính là: đơn giản và đơn luồng Ví dụ ngôn ngữ Assembly …

 Ưu điểm: Đơn giản, chương trình đơn giản, dễ hiểu

 Nhược điểm: Không thể áp dụng cho các chương trình phức tạp, không thể sử dụng lại code

1.1.2 Lập trình cấu trúc

Lập trình hướng cấu trúc hay còn gọi là lập trình hướng thủ tục (Procedure Oriented Programming – POP): là một kỹ thuật lập trình, trong đó chương trình được chia thành các hàm (chương trình con)

Mỗi chương trình còn có thể được chia ra nhiều chương trình con khác để đơn giản hóa công việc của chúng Quá trình này được gọi là quá trình làm mịn

– Ví dụ chương trình nhập và hiển thị thông tin người dùng sẽ chia thành hai chương trình con là chương trình nhập và xuất, nếu việc nhập thông tin phức tạp thì chương trình nhập thông tin có thể chia ra nhiều chương trình con khác nhau…

Trong lập trình hướng cấu trúc ta thường quan tâm đến việc phát triển các hàm mà ít quan tâm tới dữ liệu – thứ mà chúng dùng để xử lý công việc Điều này khiến cho dữ liệu khó kiểm soát

Để liên kết giữa các hàm với nhau ta thường dùng biến toàn cục hoặc con trỏ Các tính chất cơ bản của lập trình hướng cấu trúc là:

– Tập chung vào công việc cần thực hiện (thuật toán) – Chương trình lớn được chia thành các hàm nhỏ hơn – Phần lớn các hàm sử dụng dữ liệu chung

– Dữ liêu trong hệ thống được chuyển động từ hàm này sang hàm khác

– Hàm biến đổi dữ liệu từ dạng này sang dạng khác

– Sử dụng cách tiếp cận top-down trong thiết kế chương trình - Ví dụ: Các ngôn ngữ lập trình hướng cấu trúc: Pascal, C…

1.2 Phương pháp tiếp cận hướng đối tượng 1.2.1 Phương pháp lập trình hướng đối tượng

Xuất phát từ hai hạn chế chính của phương pháp lập trình cấu trúc:

 Không quản lí được sự thay đổi dữ liệu khi có nhiều chương trình cùng thay đổi một biến chung Vấn đề này đặc biệt nghiêm trọng khi các ứng dụng ngày càng lớn, người ta không thể kiểm soát được sự truy nhập đến các biến dữ liệu chung

 Không tiết kiệm được tài nguyên con người: Giải thuật gắn liền với cấu trúc dữ liệu, nếu thay đổi cấu trúc dữ liệu, sẽ phải thay đổi giải thuật, và do đó, phải viết lại mã chương trình từ đầu

Để khắc phục được hai hạn chế này khi giải quyết các bài toán lớn, người ta xây dựng một phương pháp tiếp cận mới, là phương pháp lập trình hướng đối tượng, với hai mục đích chính:

• Đóng gói dữ liệu để hạn chế sự truy nhập tự do vào dữ liệu, không quản lí được • Cho phép sử dụng lại mã nguồn, hạn chế việc phải viết lại mã từ đầu cho các chương trình

Việc đóng gói dữ liệu được thực hiện theo phương pháp trừu tượng hoá đối tượng thành lớp từ thấp lên cao như sau:

• Thu thập các thuộc tính của mỗi đối tượng, gắn các thuộc tính vào đối tượng tương ứng

• Nhóm các đối tượng có các thuộc tính tương tự nhau thành nhóm, loại bỏ bớt các thuộc tính cá biệt, chỉ giữ lại các thuộc tính chung nhất Đây được gọi là quá trình trừu tượng hoá đối tượng thành lớp

• Đóng gói dữ liệu của các đối tượng vào lớp tương ứng Mỗi thuộc tính của đối tượng trở thành một thuộc tính của lớp tương ứng

• Việc truy nhập dữ liệu được thực hiện thông qua các phương thức được trang bị cho lớp Không được truy nhập tự do trực tiếp đến dữ liệu

• Khi có thay đổi trong dữ liệu của đối tượng, ta chỉ cần thay đổi các phương thức truy nhập thuộc tính của lớp, mà không cần phải thay đổi mã nguồn của các chương trình

• Trong lớp dẫn xuất (lớp được kế thừa) có thể sử dụng lại các phương thức của lớp cơ sở (lớp bị lớp khác kế thừa) mà không cần thiết phải cài đặt lại mã nguồn

• Ngay cả khi lớp dẫn xuất định nghĩa lại các phương thức cho mình, lớp cơ sở cũng không bị ảnh hưởng và không phải sửa lại bất kì một đoạn mã nguồn nào

Ngôn ngữ lập trình hướng đối tượng phổ biến hiện nay là Java, C++, C#, … Tuy nhiên, C++ mặc dù cũng có những đặc trưng cơ bản của lập trình hướng đối tượng nhưng vẫn không phải là ngôn ngữ lập trình thuần hướng đối tượng Java thật sự là một ngôn ngữ lập trình thuần hướng đối tượng

Đặc trưng

Lập trình hướng đối tượng có hai đặc trưng cơ bản:

• Đóng gói dữ liệu: dữ liệu luôn được tổ chức thành các thuộc tính của lớp đối tượng Việc truy nhập đến dữ liệu phải thông qua các phương thức của đối tượng lớp

• Sử dụng lại mã nguồn: việc sử dụng lại mã nguồn được thể hiện thông qua cơ chế kế thừa Cơ chế này cho phép các lớp đối tượng có thể kế thừa từ các lớp đối tượng khác Khiđó, trong các lớp kế thừa, có thể sử dụng các phương thức (mã nguồn) của các lớp bị kế thừa, mà không cần phải định nghĩa lại

Ưu điểm

Lập trình hướng đối tượng có một số ưu điểm nổi bật:

• Không còn nguy cơ dữ liệu bị thay đổi tự do trong chương trình Vì dữ liệu đã được đóng gói vào các đối tượng Nếu muốn truy nhập vào dữ liệu phải thông qua các phương thức cho phép của đối tượng

• Khi thay đổi cấu trúc dữ liệu của một đối tượng, không cần thay đổi các đổi mã nguồn của các đối tượng khác, mà chỉ cần thay đổi một số hàm thành phần của đối tượng bị thay đổi

Điều này hạn chế sự ảnh hưởng xấu của việc thay đổi dữ liệu đến các đối tượng khác trong chương trình

• Có thể sử dụng lại mã nguồn, tiết kiệm tài nguyên Vì nguyên tắc kế thừa cho phép các lớp kế thừa sử dụng các phương thức được kế thừa từ lớp khác như những phương thức của chính nó, mà không cần thiết phải định nghĩa lại

• Phù hợp với các dự án phần mềm lớn, phức tạp

1.2.2 Phương pháp phân tích và thiết kế hướng đối tượng

Một vấn đề cơ bản đặt ra cho phương pháp hướng đối tượng là từ một bài toán ban đầu, làm sao để thu được một tập các đối tượng, với các chức năng được phối hợp với nhau, đáp ứng được yêu cầu của bài toán đặt ra?

Phương pháp phân tích thiết kế hướng đối tượng ra đời nhằm trả lời cho câu hỏi này Mục đích là xây dựng một tập các lớp đối tượng tương ứng với mỗi bài toán, phương pháp này tiến hành theo hai pha chính:

Pha phân tích: Chuyển đổi yêu cầu bài toán từ ngôn ngữ tự nhiên sang ngôn ngữ mô hình

Pha thiết kế: Chuyển đổi đặc tả bài toán dưới dạng ngôn ngữ mô hình sang một mô hình cụ thể có thể cài đặt được

Hai pha phân tích và thiết kế này bao gồm nhiều bước khác nhau(gồm 6 bước): • Mô tả bài toán

Phương pháp mô hình bài toán

Hai cách này khác nhau ở cách tiếp cận và mô hình bài toán

Phương pháp hướng đối tượng tiến hành theo phương pháp từ dưới lên trên, từ thấp lên cao, từ cụ thể đến trừu tượng phương pháp hướng đối tượng bắt đầu bằng những đối tượng cụ thể, tập hợp thuộc tính của từng đối tượn, sau đó nhóm các đối tượng tương tự lại thành nhóm, loại bỏ các thuộc tính cá biệt, giữ lại những thuộc tính chung nhất, nhóm thành lớp Cho nên quá trình hình thành lớp là quá trình đi từ thấp lên cao, từ cụ thể ở mức thấp đến trừu tượng hóa ở mức cao

Phương pháp cấu trúc trong lập trình truyền thống tiếp cận theo phương pháp từ trên xuống dưới, từ tổng quan đến chi tiết Phương pháp bắt đầu từ một bài toán tổng quan, ở mức khái quát cao, chia nhỏ dần, làm mịn dần cho đến khi thu được một tập các bài toán con, nhỏ hơn, cụ thể hơn, chi tiết hơn

Đặc trưng về đóng gói

Phương pháp hướng đối tượng có đặc trưng là dữ liệu được đóng gói để hạn chế truy cập tự do trực tiếp vào dữ liệu Đóng gói cho phép sử dụng lại mã nguồn để tiết kiệm tài nguyên và công sức lập trình

Phương pháp cấu trúc là cấu trúc dữ liệu và giải thuật, mối quan hệ phụ thuộc chặc chẽ của giải thuật vào cấu trúc dữ liệu

Ưu, nhược điểm

Phương pháp hướng đối tượng có ưu iểm là bảo vệ được dữ liệu tránh bị truy cập tự do trực tiếp từ bên ngoài cho phép sử dụng lại mã nguồn để tiết kiệm tài nguyên và công sức lập trình Tuy nhiên, phương pháp này lại khá phức tạp, khó theo dõi được luồng dữ liệu và giải thuật không phải là vấn đề trọng tâm của phương pháp này

Phương pháp hướng cấu trúc có ưu điểm là tư duy giải thuật rõ ràng, dễ theo dõi luồng dữ liệu, chương trình đơn giản và dễ hiểu Tuy nhiên không bảo vệ được an toàn dữ liệu trong chương trình và sự phụ thuộc chặc chẽ của dữ liệu và giải thuật do đó việc kế thừa khó khăn

Lĩnh vực ứng dụng

Phương pháp hướng đối tượng thường áp dụng cho những bài toán lớn, phức tạp, có nhiều luồng dữ liệu khác nhau, không thể quản lí bằng phương pháp cấu trúc

Phương pháp cấu trúc thường phù hợp với những bài toán nhỏ, có luồng dữ liệu rõ ràng và người lập trình có khả năng tự quản lí được mọi truy nhập đến dữ liệu của chương

Giải quyết bài toán bằng cách xây dựng một tập các thành phần (component) cótính độc lập tương đối với nhau Mỗi thành phần đảm nhiệm một phần công việc nhất định

Sau đó, người ta ghép các thành phần với nhau để thu được một phần mềm thoảmãn

Khi cần phát triển một phần mềm cụ thể, người ta chỉ cần chọn những thành phần có sẵn trong thư viện để ghép lại với nhau Người lập trình chỉ phải phát triểnthêm các thành phần mình cần mà chưa có trong thư viện

Phương pháp này có những ưu điểm rất lớn:

- Lập trình viên có thể chia sẻ với nhau những thành phần mình đã xây dựng cho nhiều người khác dùng chung

- Khi cần, lập trình viên có thể lắp ghép các thành phần có sẵn khác nhau để tạo thành các chương trình có chức năng khác nhau Tất cả chỉ cần dựa trên công nghệ lắp ghép thành phần, tiết kiệm được rất nhiều công sức lập trình

Lập trình hướng tác nhân (Agent-oriented programming)

Lập trình hướng agent có thể xem là một mức trừu tượng cao hơn của lập trình hướngthành phần

Trong đó, các agent là các thành phần có khả năng hoạt động độc lập, tự chủ để hoàn thành công việc của mình Hơn nữa, các agent có khả năng chủ động liên lạc với các agent khác để có thể phối hợp, cộng tác hay cạnh tranh nhau để hoàn thành nhiệm vụ

Lập trình hướng agent có hai đặc trưng cơ bản:

- Thứ nhất là khả năng tự chủ của mỗi agent để hoàn thành nhiệm vụ riêng của nó - Thứ hai là tính tổ chức xã hội giữa các agent, cho phép các agent phối hợp,cộng tác, cạnh tranh nhau để hoàn thành nhiệm vụ chung của toàn hệ thống

Lập trình hướng khía cạnh (Aspect-oriented programming-AOP)

Phương pháp lập trình hướng khía cạnh là phương pháp lập trình phát triển tư duy tách biệt các mối quan tâm khác nhau thành các mô đun khác nhau Ở đây, một mối quantâm thường không phải một chức năng nghiệp vụ cụ thể và có thể đóng gói mà là mộtkhía cạnh (thuộc tính) chung mà nhiều mô đun phần mềm trong cùng hệ thống nên có,ví dụ lưu vết thao tác và lỗi (error logging)

Với AOP, chúng ta có thể cài đặt các mối quan tâm chung cắt ngang hệ thống bằng cácmô đun đặc biệt gọi là aspect thay vì dàn trải chúng trên các mô đun nghiệp vụ liênquan Các aspect sau đó được tự kết hợp với các mô đun nghiệp vụ khác bằng quátrình gọi là đan (weaving) bằng bộ biên dịch đặc biệt

AspectJ là một công cụ AOP cho ngôn ngữ lập trình Java Trình biên dịch AspectJ sẽ đan xen chương trình Java chính với các aspect thành các tập tin bytecode chạy trên máy ảo Java

1.5 Câu hỏi và bài tập

Bài 1 Nêu các đặc trưng cơ bản trong cách tiếp cận lập trình hướng chức năng và lập

trình hướng đối tượng

Bài 2 Vẽ một sơ đồ phân cấp lớp cho các lớp sau đây: táo, chuối, thịt bò, nước giải

khát, phó mát, thứ có thể ăn uống, sản phẩm bơ sửa, đồ ăn, trái cây, đậu xanh, thịt, sữa, thịt heo, rau muống, rau

Bài 3 Những đặc điểm nào của tivi mà chúng cần thiết để được trừu tượng từ góc nhìn

của Một khách hàng? Một kỹ sư thiết kế? Người bán?

Nhà sản xuất?

Bài 4 Chọn một bài toán mà bạn muốn mô hình hoá từ cách tiếp cận hướng đối tượng

Bạn nên chọn các lĩnh vực mà bạn quan tâm hay bạn thường gặp trong công việc hàng ngày

Giả sử bạn sẽ viết một chương trình để tự động vài chức năng của bài toán Đầutiên viết một trang giấy mô tả yêu cầu của chương trình Đoạn văn đầu tiên mô tả tổng quát hệ thống dự định Kế đến nêu rõ yêu cầu chức năng mà người sử dụng bìnhthường mô tả hệ thống, tránh dùng các từ kỹ thuật như, “Hệ thống này phải chạy trên môi trường Windows NT, và dùng giao thức TCP/IP để ”

CHƯƠNG 2

NHỮNG KHÁI NIỆM CƠ BẢN CỦA LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG

Nội dung chương giới thiệu tới người đọc những khái niệm trong lập trình hướng đối tượng như: Đối tượng (Object); Lớp đối tượng (Class); Kế thừa (Inhenrritan); Đóng

gói (Encapsulation); …

2.1 Đối tượng (Object)

Đối tượng là khái niệm cơ sở quan trọng nhất của cách tiếp cận hướng đối tượng

Theo nghĩa thông thường thì đối tượng là người, vật hay hiện tượng mà con người nhằm vào trong suy nghĩ, trong hành động; là bất kỳ cái gì nhìn thấy, sờ mó được Trong

phương pháp hướng đối tượng thì Đối tượng là một khái niệm, một sự trừu tượng hoá hay một sự vật có nghĩa trong bài toán đang khảo sát

Đối tượng là thực thể của hệ thống, của cơ sở dữ liệu (CSDL) và được xác định

thông qua định danh (IDentifier) của chúng

Mỗi đối tượng có tập các đặc trưng bao gồm: tên đối tượng nhằm xác định một thực thể, dữ liệu thành phần (thuộc tính của đối tượng) nhằm mô tả đối tượng, các hàm thành phần (hành động/phương thức: Method) trên dữ liệu để mô tả hành vi của đối tượng

Đối tượng là những thực thể được xác định trong thời gian hệ thống hướng đối tượng hoạt động Như vậy đối tượng có thể biểu diễn cho người, vật, hay một bảng dữ liệu, … cần xử lý trong chương trình Nhiệm vụ của lập trình hướng đối tượng (LTHĐT) là phân tích bài toán thành các đối tượng và xác định bản chất của sự trao đổi thông tin giữa chúng Đối tượng trong chương trình cần phải được chọn sao cho nó thể hiện được một cách gần nhất với những thực thể có trong hệ thống thực

Hệ thống xem như tập các đối tượng được trao đổi với nhau thông qua việc gửi và nhận thông điệp

 Các ví dụ về đối tượng

+ Mô tả đối tượng: Các đối tượng cụ thể được mô tả bằng hình sau:

+ Trao đổi thông tin giữa các đối tượng: Xét các đối tượng:

- Phòng kế toán: chịu trách nhiệm lương các nhân sự, phương thức chi trả lương

- Phòng nhân sự: chịu trách nhiệm các thông tin nhân sự, một nhân sự yêu cầu phòng kế toán chi trả lương cho mình, gọi phương thức từ đối tượng khác

2.2 Lớp đối tượng (Class)

Tập các đối tượng có cùng tính chất và cách ứng xử chung (thuộc tính, hàm): Lớp người, lớp đa giác…Lớp được hiểu như một bản mẫu, đối tượng là thể hiện (Instance) của một lớp xác định Trong lập trình hướng đối tượng, lớp được xem là đồng nhất với kiểu dữ liệu trừu tượng (ADT- Abstract Data Type)

Khai báo lớp: Bao gồm các thuộc tính cùng với kiểu dữ liệu, các giá trị cụ thể của thuộc tính sẽ được gán sau khi đã tạo ra đối tượng Trong khai báo lớp có những phương thức trong lớp đó Lớp được mô tả như sau:

2.3 Trừu tượng hóa dữ liệu (Abstraction)

Trừu tượng hóa là cách biểu diễn những đặc tính chính và bỏ qua những chi tiết Trừu tượng hóa là sự mở rộng kiểu dữ liệu và cho phép định nghĩa những phép toán trừu tượng trên những dữ liệu trừu tượng

Để xây dựng cách lớp, chúng ta phải sử dụng khái niệm trừu tượng hóa Trong ứng dụng chúng ta quan tâm đến việc mô tả đối tượng trong thế giới thực thông qua các tính chất của đối tượng bỏ qua cách biểu diễn dữ liệu

Ví dụ: đối tượng hình gồm có số cạnh, màu viền, màu nền (trừu tượng hoá về dữ liệu)

Ta cũng quan tâm đến tập tất cả các hành vi có thể có của đối tượng để xây dựng các hàm

Ví dụ: vẽ, di chuyển, xoá

Ta không quan tâm vào cách thực thi của hàm mà tập trung vào các đối số và giá trị trả về của hàm (sự trừu tượng hoá về thủ tục)

Khi xây dựng phần mềm thì nguyên lý trừu tượng hóa được thực hiện thông qua việc trừu tượng hóa các chức năng, hàm và trừu tượng hóa các kiểu dữ liệu nguyên thủy - int Màu viền - int Màu tô

2.4 Khái niệm kế thừa (Inheritance)

Khái niệm "kế thừa" thường được dùng trong các ngôn ngữ lập trình hướng đối

tượng để chuyển quan hệ tổng quát hóa và đặc biệt hóa của thế giới thực vào các chương trình máy tính Tính kế thừa cho phép ta xây dựng một lớp mới dựa trên các định nghĩa của một lớp đã có

Nếu một lớp A là lớp đặc biệt hóa của lớp B (nghĩa là lớp B là lớp tổng quát hóa của lớp A) thì trong lập trình hướng đối tượng lớp A được cài đặt là lớp kế thừa của lớp B (nói ngắn gọn là "lớp A kế thừa lớp B") Khi lớp A kế thừa lớp B thì lớp B được gọi là "lớp cơ sở" hay "lớp cha" (trong mối quan hệ kế thừa đang xét), còn lớp A thì được gọi là "lớp kế thừa", "lớp con" hay "lớp dẫn xuất"

 Tính thừa kế là cho phép dùng lại một lớp hiện có (sử dụng các thuộc tính, phương thức) để xây dựng một lớp mới bằng cách bổ sung thêm các thuộc tính và phương thức mới Ví dụ:

-Lớp sinh viên có các tính chất: mã sv, tên sinh viên, ngày sinh các phương thức: nộp điểm, thi

-Lớp sinh viên thể dục cũng có các thuộc tính và phương thức như lớp sinh viên nhưng có thêm các thuộc tính khác như chiều cao, cân nặng và các phương thức: chạy, nhảy cao

Lớp sinh viên thể dục (lớp con) là lớp kế thừa từ lớp sinh viên (lớp cha/lớp cơ sở/ siêu lớp)

 Nguyên lý kế thừa:

-Kế thừa đơn: Một lớp có thể kế thừa từ một lớp cơ sở, cây phân cấp các lớp

-Kế thừa bội: Một lớp có thể kế thừa từ nhiều lớp cơ sở Trong Java chỉ hỗ trợ kế thừa đơn, kế thừa bội thực hiện thông qua khái niệm giao diện (Interface)

Ví dụ về cấu trúc phân cấp các lớp theo quan hệ kế thừa như hình sau:

 Việc kế thừa phải tuân thủ theo nguyên tắc bao bọc thông tin, có nghĩa:

-public: Các biến dữ liệu, các hàm được truy cập mọi nơi trong hệ thống

-private: Các biến dữ liệu, các hàm được truy cập chỉ trong lớp đó

-protected: Các biến dữ liệu, các hàm được truy cập chỉ trong lớp đó và trong các

lớp con của nó

-static: Các biến dữ liệu, các hàm được dùng cho mọi đối tượng, được khởi tạo khi

nạp lớp vào lúc đầu Khai báo static được dùng như sau: Nó thuộc vào một lớp chứ không thuộc một đối tượng riêng lẻ nào Khi thực hiện sẽ tạo ra một bản sao của dữ liệu, hàm trong lớp

2.5 Khái niệm đóng gói (Encapsulation)

Đóng gói là sự che giấu bên trong dữ liệu riêng của mỗi đối tượng của lớp được khai

báo và chỉ được truy xuất thông qua hệ thống các phương thức có sẵn của lớp (chỉ có thể

gọi những phương thức có sẵn của lớp) Vì vậy, nó còn được gọi là data hiding (nghĩa là

che giấu dữ liệu)

 Tính đóng gói có những đặc điểm như sau:

- Tạo ra cơ chế để ngăn ngừa việc gọi phương thức của lớp này tác động hay truy xuất dữ liệu của đối tượng thuộc về lớp khác

- Dữ liệu riêng (khi được khai báo là private) của mỗi đối tượng được bảo vệ khỏi

sự truy xuất không hợp lệ từ bên ngoài

- Người lập trình có thể dựa vào cơ chế này để ngăn ngừa việc gán giá trị không hợp lệ vào thành phần dữ liệu của mỗi đối tượng

- Cho phép thay đổi cấu trúc bên trong của một lớp mà không làm ảnh hưởng đến những lớp bên ngoài có sử dụng lớp đó

 Để cài đặt tính đóng gói, chúng ta có 2 bước như sau:

- Khai báo các thuộc tính của đối tượng trong lớp là private để các lớp khác không thể truy cập trực tiếp/sửa đổi được

- Cung cấp các phương thức getter/setter có phạm vi truy cập là public để truy cập và sửa đổi các giá trị của thuộc tính trong lớp Phương thức getter là phương thức truy cập vào thuộc tính của đối tượng và trả về các thuộc tính của đối tượng, còn phương thức setter là phương thức truy cập vào thuộc tính của đối tượng và gán giá trị cho các thuộc tính của đối tượng đó

Ví dụ:

File Person.java

public class Person {

// khai báo các thuộc tính của đối tượng là private private String cmnd;

private String hoTen;

// tạo các phương thức getter/setter

// 2 phương thức getCmnd() và getHoTen() là phương thức getter

// dùng để trả về số chứng minh nhân dân và họ tên của đối tượng

// và kiểu trả về của hai phương thức này tương ứng với kiểu dữ liệu của thuộc tính

// 2 phương thức setCmnd() và setHoTen() là phương thức setter

// dùng để gán giá trị cho thuộc tính chứng minh nhân dân và họ tên của đối tượng

// trong đó tham số truyền vào của 2 phương thức này được gọi là tham số (biến cục bộ)

// và có kiểu dữ liệu tương ứng với kiểu dữ liệu của thuộc tính (biến đối tượng)

public String getCmnd() { return cmnd;

}

// this là từ khóa có ý nghĩa là một tham chiếu đặc biệt // chiếu tới đối tượng chủ của phương thức hiện hành

// this có thể được dùng để truy cập biến đối tượng (instance variable)

// hoặc gọi phương thức đối với đối tượng hiện hành // Thông thường, công dụng này của this chỉ có ích

// khi tên biến đối tượng bị trùng với tham số (biến cục bộ - local variable) của phương thức

public void setCmnd(String cmnd) {

public static void main(String[] args) { Person person = new Person();

System.out.println("Tên: " + person.getHoTen() + ", số cmnd: " + person.getCmnd());

} }

2.6 Khái niệm đa hình (Polymorphism)

Kỹ thuật đa hình trong các ngôn ngữ lập trình hướng đối tượng tạo điều kiện cho các lập trình viên gia tăng khả năng tái sử dụng những đoạn mã nguồn được viết một cách tổng quát và có thể thay đổi cách ứng xử một cách linh hoạt tùy theo loại đối tượng

Tính đa hình (Polymorphism) trong Java được hiểu là trong từng trường hợp, hoàn

cảnh khác nhau thì đối tượng có hình thái khác nhau tùy thuộc vào từng ngữ cảnh Đối tượng có tính đa hình được xem như một đối tượng đặc biệt vì có lúc đối tượng này trở thành một đối tượng khác và cũng có lúc đối tượng này trở thành một đối tượng khác nữa

(tùy vào từng hoàn cảnh) Sự "nhập vai" vào các đối tượng khác nhau này giúp cho đối

tượng đa hình ban đầu có thể thực hiện những hành động khác nhau của từng đối tượng cụ thể

Ví dụ: Khi bạn ở trong trường học là sinh viên thì bạn có nhiệm vụ học, nghe

giảng, , nhưng khi bạn ở nhà thì bạn lại đóng vai trò là thành viên trong gia đình và bạn có nhiệm vụ phải làm việc nhà, rồi khi bạn vào siêu thị thì bạn đóng vai trò là khách hàng đi mua hàng Vì vậy, chúng ta có thể hiểu đa hình của đối tượng là trong từng trường hợp, hoàn cảnh khác nhau thì đối tượng có khả năng thực hiện các công việc khác nhau

Để thể hiện tính đa hình, chúng ta cần đảm bảo 2 điều kiện sau:  Các lớp phải có quan hệ kế thừa với 1 lớp cha nào đó

 Phương thức đa hình phải được ghi đè (override) ở lớp con Tính đa hình chỉ

được thể hiện ghi đã ghi đè lên phương thức của lớp cha

File Shape.java

public class Shape { public void show() {

System.out.println("Đây là phương thức show() của lớp Shape");

} }

File Rectangle.java

public class Rectangle extends Shape { public void show() {

System.out.println("Đây là phương thức show() của lớp Rectangle");

} }

File Square.java

public class Square extends Shape { public void show() {

System.out.println("Đây là phương thức show() của lớp

public static void main(String[] args) { Shape shape = new Shape();

shape.show(); // hiển thị dòng "Đây là phương thức show() của lớp Shape"

// bản chất của shape là Shape, nhưng vì khai báo Rectangle nên chúng ta chỉ nhìn thấy những gì mà Rectangle có

// vì vậy sẽ chạy những hàm của Rectangle shape = new Rectangle();

shape.show(); // hiển thị dòng "Đây là phương thức show() của lớp Rectangle"

// tương tự lúc này shape sẽ đóng vai trò là 1 Square shape = new Square();

shape.show(); // hiển thị dòng "Đây là phương thức show() của lớp Square"

} }

2.7 Câu hỏi và bài tập

Bài 1 Nêu các đặc trưng cơ bản trong cách tiếp cận lập trình hướng chức năng và lập

trình hướng đối tượng

Bài 2 Tại sao lại gọi khái niệm lớp là kiểu dữ liệu trừ tượng trong LTHĐT

Bài 3 Khái niệm kế thừa trong lập trình hướng đối tượng là gì? Cho một ví dụ về tính

kế thừa Java hỗ trợ quan hệ kế thừa như thế nào?

Bài 4 Nêu nguyên lý hoạt động của tính đa thể Cho ví dụ

Bài 5 Sưu tập các thuộc tính và phương thức khi mô tả lớp “Sinh Vien”, cho một thể

hiện của lớp này

Bài 6 Sưu tập các thuộc tính và phương thức khi mô tả lớp “Phan So”, cho một thể

hiện của lớp này

Bài 7 Sưu tập các thuộc tính và phương thức khi mô tả lớp “Hoc Sinh”, cho một thể

hiện của lớp này

CHƯƠNG 3

NGÔN NGỮ LẬP TRÌNH JAVA

Trong nội dung chương này, chúng ta sẽ lần lượt tìm hiểu về khái niệm Java là gì? Bên cạnh đó, nội dung chương này cũng sẽ lần lượt giới thiệu những đặc điểm cơ

bản và ứng dụng của ngôn ngữ Java và các Platform cơ bản của ngôn ngữ lập trình Java

Cách cài đặt Java, cấu hình biến môi trường cho Java và các bước cài đặt và cấu hình Eclipse

Nội dung chương cũng giới thiệu các kiểu dữ liệu có trong Java, cấu trúc một chương trình Java và các cấu trúc lệnh của Java

3.1 Giới thiệu và cài đặt ngôn ngữ Java 3.1.1 Lịch sử của Java

Giới thiệu ngôn ngữ Java

Java là một ngôn ngữ lập lập trình, được phát triển bởi Sun Microsystem vào

năm 1995, là ngôn ngữ kế thừa trực tiếp từ C/C++ và là một ngôn ngữ lập trình hướng đối tượng

Java là tên một hòn đảo ở Indonesia - hòn đảo nổi tiếng với loại coffee Peet và cũng là loại nước uống phổ biến của các kỹ sư Sun Ban đầu Ngôn ngữ này được đặt

tên là "Oak" (có nghĩa là "Cây sồi" - 1991), nhưng các luật sư của Sun xác định rằng

tên đó đã được đăng ký nhãn hiệu nên các nhà phát triển đã phải thay thế bằng một tên mới - và cũng vì lý do trên mà cái tên Java đã ra đời và trở thành tên gọi chính thức của Ngôn ngữ này - Ngôn ngữ Lập trình Java

Ứng dụng của Java

Hiện nay Java được sử dụng với các mục đích sau:

- Phát triển ứng dụng cho các thiết bị điện tử thông minh, các ứng dụng cho doanh nghiệp với quy mô lớn

- Tạo các trang web có nội dung động (web applet), nâng cao chức năng của

server

- Phát triển nhiều loại ứng dụng khác nhau: Cơ sở dữ liệu, mạng, Internet, viễn thông, giải trí,

3.1.2 Đặt trưng của ngôn ngữ Java

Đặc điểm của Java

- Thông dịch (Interpreter): Tệp chương trình nguồn (.java) được biên dịch qua tập tin nhị phân (.class), tập tin chứa các mã thực hiện của chương trình và các tham số của máy ảo Java (Java Virtual Machine: JVM) Máy ảo Java có tác dụng thông dịch chuyển tập tin nhị phân thành các lệnh cần thiết phù hợp với từng cấu hình

- Ứng dụng hoàn toàn toàn độc lập với cấu hình máy, “viết một lần, chạy mọi nơi” (Write Once, Run Anywhere), nghĩa là Java cho phép chúng ta viết code một lần và thực thi được trên các hệ điều hành khác nhau Ví dụ, chúng ta viết code trên Hệ

điều hành Windows và nó có thể thực thi được trên các Hệ điều hành Linux và Mac OS Vì vậy, các ứng dụng phù hợp với mạng Internet (Web)

- Cơ chế bảo mật cao

- Quen thuộc: Vì Java kế thừa trực tiếp từ C/C++ nên nó có những đặc điểm của ngôn ngữ này, Java đơn giản vì mặc dù dựa trên cơ sở C++ nhưng Sun đã cẩn thận lược bỏ các tính năng khó nhất của của C++ để làm cho ngôn ngữ này dễ sử dụng hơn

Hướng đối tượng và quen thuộc

- Mạnh mẽ (thể hiện ở cơ chế tự động thu gom rác - Garbage Collection) và an

toàn

- Kiến trúc trung lập, độc lập nền tảng và có tính khả chuyển (Portability)

- Hiệu suất cao - Phân tán

- Đa nhiệm: Ngôn ngữ Java cho phép xây dựng trình ứng dụng, trong đó nhiều quá trình có thể xảy ra đồng thời Tính đa nhiệm cho phép các nhà lập trình có thể biên soạn phần mềm đáp ứng tốt hơn, tương tác tốt hơn và thực hiện theo thời gian thực

3.1.3 Cài đặt, cấu hình các phần mềm và biên dịch chương trình Java

Các platform cơ bản của Java

Java Platform gồm có 3 thành phần chính:

 Java Virtual Machine (Java VM): Máy ảo Java

 Java Application Programming Interface (Java API)

 Java Development Kit (JDK) gồm trình biên dịch, thông dịch, trợ giúp, soạn tài

liệu và các thư viện chuẩn

Tiêu chuẩn của một môi trường Java

Thông thường, các chương trình Java trải qua 5 giai đoạn chính:

 Editor: Lập trình viên viết chương trình và được lưu vào máy tính với định

dạng java

 Compiler: Biên dịch chương trình thành bytecodes (định dạng class) - nhờ

bước trung gian này mà Java được viết 1 lần và chạy trên các hệ điều hành khác nhau  Class Loader: Đọc file class chứa mã bytecodes và lưu vào trong bộ nhớ

 Bytecode Verifier: Đảm bảo rằng mã bytecodes là hợp lệ và không vi phạm

các vấn đề về bảo mật của Java

 Intepreter: Biên dịch bytecodes thành mã máy để máy tính có thể hiểu

được và sau đó thực thi chương trình

Download và cài đặt JDK (Java Development Kit)

Đầu tiên, ta vào trang chủ của Oracle để tiến hành tải về JDK

http://www.oracle.com/technetwork/java/javase/downloads/index.html

Tại đây, tùy thuộc vào máy tính cài hệ điều hành Windows 32 bit hay 64 bit mà

ta chọn phiên bản cho phù hợp Trước tiên cần chọn vào mục Accept License Agreement và sau đó tiến hành chọn phiên bản JDK phù hợp và lưu vào ổ đĩa

Tiến hành cài đặt:

Bước 1: Kích chuột phải vào file JDK vừa tải về và chọn Open hoặc chúng ta có thể

nhấp đôi chuột vào file này để mở file cài đặt lên

Bước 2: Chọn Next

Bước 3: Chọn Change để thay đổi thư mục cài đặt Nếu không cần thay đổi, chúng ta

chọn Next để tiếp tục

Thiết lập biến môi trường và cấu hình cho Java

Mở System Properties\ chọn Advanced system settings\Environment Variables\

Trong hộp thoại Environment Variables, chúng ta vào phần System variables và

chọn New

Trong hộp thoại New System Variable, chúng ta điền vào ô Variable name là JAVA_HOME, còn trong ô Variable value chúng ta nhấn vào nút Browser

Directory và trỏ tới đường dẫn cài đặt thư mục JDK Nhấn OK để hoàn tất việc đặt

tên biến môi trường

Tiếp theo, cũng trong phần System variables, chúng ta tiến hành sửa đổi biến

môi trường Path như sau: Kích chuột vào dòng Path và chọn Edit Hộp thoại Edit environment variable xuất hiện, chúng ta nhấn chuột vào nút New và điền vào dòng

sau: %JAVA_HOME%\bin;, nhấn OK để kết thúc

Để biết được quá trình cấu hình và cài đặt biến môi trường thành công hay chưa,

bạn gõ tổ hợp phím Windows + R, hộp thoại Run sẽ xuất hiện, bạn nhập vào cmd ở

dòng Run Màn hình Command Prompt xuất hiện, bạn nhập vào dòng sau: java

-version Nếu chúng ta cấu hình thành công thì sẽ có kết quả như sau:

Hướng dẫn cách cài đặt và sử dụng Eclipse Download và cài đặt Eclipse

Đầu tiên chúng ta vào trang chủ để tải về Eclipse

:https://www.eclipse.org/downloads/? Chọn Download Packages để vào màn hình

download Eclipse

Sau đó chọn Eclipse IDE for Java EE Developers và chọn phiên bản 32 bit hay

64 bit tùy thuộc vào phiên bản hệ điều hành đang dùng

Chúng ta chọn ổ đĩa để lưu file Eclipse Cài đặt

Bước 1: Tiến hành giải nén file nén Eclipse vừa tải về

Bước 2: Kích chuột phải vào eclipse.exe và chọn Open hoặc chúng ta có thể

nhấp đôi chuột vào file này để mở file cài đặt lên

Hộp thoại Eclipse Launcher xuất hiện Trong ô Workspace chúng ta sẽ chọn

đường dẫn trỏ tới thư mục lưu Workspace (Workspace ở đây là một thư mục để lưu

trữ tập tất cả các Project mà chúng ta tạo ra trên Eclipse) Bạn có thể chọn vào Use

this as the default and do not again để mỗi khi khởi động Eclipse lên thì hộp thoại

này sẽ không xuất hiện nữa

Chọn Launch để tiến hành cài đặt Eclipse

Hướng dẫn sử dụng Eclipse

 Thay đổi Workspace

Để thay đổi đường dẫn Workspace, bạn vào Switch Workspace → Other và

chọn vào đường dẫn bạn cần thay đổi  Kiểm tra phiên bản Java

Để xem phiên bản Java bạn đang dùng, bạn vào Window → Preferences Hộp thoại Preferences được hiển thị, bạn nhìn vào dòng Compiler compliance settings sẽ

thấy được phiên bản Java đang dùng  Tạo Project

Để tạo một project Java mới, trước tiên bạn cần phải thay đổi Perpective là Java Để thay đổi bạn chọn Window → Perpective → Open Perpective và chọn

Java Sau đó, bạn vào File → New (hoặc nhấn tổ hợp phím tắt Alt + Shift + N) và

chọn Java Project

Trong hộp thoại New Java Project, bạn nhập vào tên Project trong ô Project name và nhấn Finish

 Tạo Package

Package trong Java dùng để nhóm các Lớp (Class), Interface và các gói phụ có

liên quan với nhau vào chung một nhóm lớn, nhóm này được gọi là Package Để tạo một Package mới, chúng ta vào Package Explorer ở phía trái màn hình, nhấp đôi chuột vào tên project vừa tạo → kích chuột phải vào src → New → Package:

Đặt tên cho Package và nhấn Finish để hoàn tất  Tạo Class

Để tạo mới một Lớp (Class), bạn nhấp phải chuột vào tên Package và

chọn New → Class

Hộp thoại New Java Class xuất hiện, bạn nhập vào tên Class trong ô Name và chọn vào public static void main(String[] args) và bấm Finish để kết thúc Lưu ý: Để sử dụng tính chất nhắc lệnh của Eclipse, các bạn gõ tổ hợp phím Ctrl + Space, ví

dụ để gõ nhanh hàm main thì các bạn gõ chữ main và nhấn Ctrl + Space, chọn vào dòng main - main method và nhấn Enter để hoàn thành

Biên dịch chương trình trên Eclipse

Để biên dịch và thực thi chương trình, chúng ta có 3 cách như sau: Cách 1: Chọn vào biểu tượng Run trên thanh công cụ:

Cách 2: Chọn vào chữ Run trên thanh công cụ và chọn Run (hoặc nhấn tổ hợp phím Ctrl + F11)

Cách 3: Nhấp chuột phải vào tên Class và chọn Run As → Java Application:

Nếu trong file HelloWord.java của bạn có chứa những dòng chữ tiếng Việt (ví dụ như: "Chào mừng các bạn đến với ngôn ngữ lập trình Java") thì các bạn phải chọn

định dạng UTF-8 bằng cách nhấp chuột phải vào tên Project chọn Properties (hoặc

nhấn tổ hợp phím Alt + Enter) Hộp thoại Properties for file HelloWorld xuất hiện,

vào phần Resource và tìm đến dòng Text file encoding chọn Other và thay đổi định dạng chữ thành UTF-8 Sau đó, bạn chọn vào Apply và Apply and Close để hoàn tất việc thay đổi định dạng chữ

3.2 Kiến trúc chương trình Java

Những thành phần cơ bản của 1 chương trình Java: Gói (Packages)

Giao diện (Interfaces)

Những phần của một chương trình Java:

Lệnh khai báo gói(package )

Lệnh chỉ định gói được dùng (Lệnh import)

Khai báo lớp public (một file java chỉ chứa 1 lớp public class) Các lớp khác (classes private to the package)

Tập tin nguồn Java có thể chứa tất cả hoặc một vài trong số các phần trên

3.2.1 Các thành phần cơ bản của Java

ddddddddddddddddddddddddddddddddddddddđ

Trong một tệp chương trình java cho phép định nghĩa nhiều lớp hoặc nhiều giao diện Tệp chương trình java trùng với tên lớp được khai báo là public và lớp này chứa hàm main() nếu là ứng dụng độc lập Tệp chương trình nguồn có phần mở rộng java

Khi biên dịch thì mỗi lớp hoặc giao diện trong tệp sẽ tạo ra tệp byte code có tên trùng với tên lớp và giao diện, có phần mở rộng là class

Trong chương trình Java không có các khai báo biến, hàm tách biệt khỏi lớp và

chỉ có các khai báo và định nghĩa các lớp, interface Như thế chương trình Java được xem như là tập các lớp, interface và các đối tượng của chúng trao đổi thông điệp với nhau (bằng các lời gọi hàm) để thực hiện các nhiệm vụ của ứng dụng.

Trong đó:

 Phần 1: thư mục chung cần tạo để lưu các tập tin trong chương trình  Phần 2: đưa vào các gói trong Java mà người dùng sử dụng

import java.io.*; //Phần 1: Tuỳ chọn //Định nghĩa gói

package <tên gói>

//Phần 2: có thể có hoặc không có các gói sử dụng //nhập gói cần sử dụng

import java.io.*;

//Phần 3: không hoặc nhiều hơn //Định nghĩa các lớp và các giao diện

 Phần 3: nội dung soạn thảo của chương trình

3.2.2 Chương trình Java đầu tiên

Viết chương trình in dòng HelloWord lên màn hình Console

Khởi động Notepad hoặc Eclipse và gõ đoạn mã sau, lưu lại với tên

Giải thích cấu trúc chương trình:

+ public: Thuộc tính public của hàm main() cho biết là hàm này được phép truy nhập đối với mọi lớp từ bên ngoài của lớp HelloWordApp và cho phép gọi để thực hiện bởi chương trình thông dịch java

+ static: Từ khóa static khai báo hàm này phụ thuộc vào cả lớp, không phụ thuộc vào đối tượng cụ thể, do vậy khi thực hiện không cần phải tạo lập đối tượng để gọi những hàm như thế

+ void: Từ khóa void cho biết hàm main() không có kết quả trả lại + Hàm main có các đối số là mảng các xâu (đối tượng) agrs[] của String

Biên dịch/Thông dịch chương trình java sử dụng jdk Vào cmd > đến thư mục chứa bài tập đã lưu

Comment code trong Java là những đoạn code mà compiler sẽ bỏ qua lúc biên

dịch (tức là trình biên dịch sẽ bỏ qua khi gặp phải những đoạn comment này trong code của chúng ta) Vậy tại sao chúng ta cần phải sử dụng tới các comment này trong

chương trình của mình? Đó là vì: Các đoạn comment này dùng để giải thích về ý nghĩa, công dụng của các biến, phương thức, các Class hoặc bất kỳ những dòng lệnh khác để cho chương trình của chúng ta dễ hiểu và dễ bảo trì hơn; ngoài ra, nó cũng dùng để bỏ qua biên dịch một đoạn code nào đó trong quá trình viết code của chúng

* Comment đặc biệt dùng để tạo Java code documentation ở định dạng HTML (Java Document)

*/

3.3.2 Từ khóa (Keyword)

Ngôn ngữ lập trình đã định danh sẵn các từ để để biểu diễn các từ khóa của ngôn ngữ và không thể sử dụng cho những thực thể khác Các khóa của Java có thể chia

thành 9 nhóm:

Ví dụ:

+ Định nghĩa lớp: class, extends, interface, implements

+ Từ khoá cho việc dùng các biến, các lớp: abstract, public, private, protected, static, synchronized, volatile, final, native

+ Tổ chức các lớp: package, import

+ Các kiểu dữ liệu cơ bản: long, int, short, byte, double, char, boolean, void + Giá trị hằng gán cho biến: true, false, this, super, null

+ Xử lý ngoại lệ: throw, throws, try, catch, finally + Tạo lập và kiểm tra đối tượng: new, instanceof

+ Các dòng điều khiển chương trình: if,else, case, while, switch, defaulse, break, continue, do, return, for

+ Các từ khoá khác: const, goto, var, operator, byvalue, cast, future, genetic, inner, outer, rest

3.3.3 Giới thiệu về biến

Thực ra những quy tắc này chúng ta tự đưa ra để dễ dàng phát triển dự án Ví dụ

khi một dự án có nhiều lập trình viên tham gia thì cần phải đưa ra một chuẩn (quy tắc)

để đặt tên biến, tên hàm để khi nhìn vào các lập trình viên có thể hiểu code của nhau

Trước tiên chúng ta tìm hiểu về quy tắc chung khi đặt tên biến, tên hằng, tên package, tên class, tên interface

Quy tắc chung;

 Lập trình viên nên khai báo tên có ý nghĩa và thể hiện được mục đích của file/ biến/ phương thức/ đó

 Tên khai báo không nên dài quá 20 ký tự hoặc có thể ít hơn nhưng phải đảm

bảo đầy đủ về mặt ý nghĩa của nó, và tên cũng không được đặt quá ngắn, trừ

khi đó là tên tạm (ví dụ như: a, i, j, )

 Tránh đặt những tên tương tự nhau Ví dụ như, hai biến có tên là persistentObject và persistentObjects không nên được sử dụng trong một Class vì sẽ dễ gây ra nhầm lẫn trong quá trình viết code

 Tránh đặt tên gây khó hiểu, dễ nhầm lẫn về mặt ý nghĩa

 Tên chứa từ viết tắt cũng nên được hạn chế sử dụng trừ khi từ viết tắt đó phổ

biến và được nhiều người biết đến Ví dụ như: bạn không được đặt tên biến là diemTB mà nên đặt tên là diemTrungBinh nhưng bạn hoàn toàn có thể đặt tên là fileHTML thay vì fileHypertextMarkupLanguage vì tên này quá dài và từ HTML cũng là một từ khá phổ biến, ít nhất là trong giới lập trình viên chúng ta  Tránh kết hợp nhiều ngôn ngữ khác nhau (Tiếng Anh + Tiếng Việt + ), chẳng

hạn như addSinhVien, addLop,

 Không trùng với các "từ khóa" (chúng ta sẽ tìm hiểu ở phần tiếp theo)

 Không được bắt đầu bằng số, ví dụ như: 123sinhVien

 Tên phải được bắt đầu bằng một chữ cái, hoặc các ký tự như $, _,

 Không được chứa khoảng trắng, các ký tự toán học Nếu tên bao gồm nhiều từ thì phân cách nhau bằng dấu _

 Trong Java có phân biệt chữ hoa chữ thường Ví dụ, như hocSinh sẽ khác với hocsinh

Đặt tên biến

 Tên biến phải tuân theo quy tắc chung ở trên được đặt theo quy tắc lạc

đà (Camel Case): đó là chữ cái đầu tiên của từ đầu tiên phải viết thường và chữ

cái đầu tiên của các từ tiếp theo phải viết hoa, ví dụ: diemTrungBinh

 Ngoài ra, trong một số trường hợp, tên biến cần phải thể hiện rõ kiểu dữ liệu của biến đó Ví dụ: biến có kiểu là List thì nên đặt tên là studentList, biến có kiểu là Set thì nên đặt tên là studentSet, biến có kiểu là Map thì nên đặt tên là studentMap, biến có kiểu là Array thì nên đặt tên là studentArray,

Đặt tên hằng số (Constant)

Tên hằng số phải tuân theo quy tắc chung ở trên và phải được viết hoa (ví dụ PI) Nếu tên hằng số có từ hai từ trở lên thì phải có dấu _ ngăn cách giữa các từ, ví dụ: SO_FIBONACCI

Đặt tên phương thức (Method)

 Tên phương thức phải tuân theo quy tắc chung ở trên

 Chữ cái đầu tiên của từ đầu tiên trong tên phương thức phải viết thường và là

một động từ, còn chữ cái đầu tiên của các từ tiếp theo phải viết hoa (giống quy tắc đặt tên biến) Ví dụ: tinhDiemTrungBinh, themNhanVien,

Đặt tên Class và Interface

 Tên Class và Interface phải tuân theo quy tắc chung ở trên và chữ cái đầu tiên của mỗi từ phải được viết hoa Ví dụ: Class SinhVien

 Tên Class nên có thêm những từ có hậu tố phía sau để thể hiện rõ hơn mục đích

của Class đó, chẳng hạn như DivZeroException (chúng ta sẽ tìm hiểu rõ hơn

về Exception ở những bài sau)

 Tên Interface nên có thêm chữ I đằng trước Ví dụ: IFrame

 Tên lớp dẫn xuất nên có từ Abstract làm tiền tố, ví dụ: Class

AbstractStudent (chúng ta sẽ tìm hiểu về lớp dẫn xuất ở những bài sau)

Đặt tên Package

Tên Package phải tuân theo quy tắc chung ở trên và phải viết thường Đặt tên Project

Tên Project phải tuân theo quy tắc chung ở trên và chữ cái đầu tiên của mỗi từ phải viết hoa

3.3.4 Kiểu dữ liệu

Kiểu dữ liệu trong Java dùng để xác định kích thước và loại giá trị có thể được

lưu trữ trong một định danh (Định danh ở đây bao gồm tên biến, phương thức, tên

lớp, Interface và tên Package) Các kiểu dữ liệu khác nhau cho phép chúng ta lựa chọn

kiểu phù hợp với yêu cầu của bài toán đặt ra

Trong Java có 2 kiểu dữ liệu thường gặp đó là: Primitive data (kiểu dữ liệu cơ sở) và Wrapper class (Lớp bao bọc)

 Primitive data

Kiểu dữ liệu cơ sở là kiểu dữ liệu đơn giản nhất trong Java Tại một thời điểm,

một kiểu dữ liệu cơ sở chỉ lưu trữ một giá trị đơn, không có các thông tin khác Trong Java, chúng ta có 8 kiểu dữ liệu cơ sở thường gặp:

short 16 -32,768 đến 32,767 short shortNumber = 10000; int 32 -2,147,483,648 đến 2,147,483,647 int intNumber = 100000;

long 64 -9,223,372,036,854,775,808 đến

9,223,372,036,854,775,807 long longNumber = 100000l; float 32 1.4E-45 đến 3.4028235E38 float floatNumber = 9.08f; double 64 4.9E-34 đến 1.7976931348623157E308 double doubleNumber = 9.08;

boolean 1 true/false (mặc định là false) boolean boolValue = true;

 Wrapper class

Trong Java, ứng với mỗi kiểu dữ liệu cơ sở thì chúng ta sẽ có một kiểu dữ liệu

Wrapper class, sở dĩ chúng ta gọi kiểu dữ liệu này là Wrapper class là vì nó "gói" các

kiểu dữ liệu cơ sở vào trong một đối tượng của nó Vì vậy, Wrapper class là kiểu dữ liệu vừa có thể lưu trữ giá trị đơn và vừa có thêm các phương thức khác

Dưới đây là danh sách các Wrapper class ứng với mỗi kiểu dữ liệu cơ sở:

 Ép kiểu trong Java

Ép kiểu trong Java là quá trình chuyển đổi kiểu dữ liệu này sang kiểu dữ liệu

khác Chúng ta cần sử dụng đến thao tác ép kiểu khi chúng ta cần chuyển đổi kiểu dữ liệu của biến này sang kiểu dữ liệu khác để phục vụ cho một mục đích nào đó Ví dụ: Chúng ta thực hiện phép chia số nguyên 2 cho 4, nếu chúng ta không sử dụng đến ép

Primitive data Wrapper class

kiểu thì kết quả của phép toán này sẽ trả về 0, như vậy thì yêu cầu của bài toán đã không còn đúng nữa

Có 2 loại ép kiểu trong Java: Ép kiểu rộng và ép kiểu hẹp

Implicit Casting (Ép kiểu rộng/ Ép kiểu không tường minh)

Chuyển từ kiểu có vùng lưu trữ nhỏ lên kiểu có vùng lưu trữ lớn hoặc về kiểu có cùng kiểu dữ liệu Loại này không làm mất mát dữ liệu Sơ đồ chuyển đổi như sau:

byte → short → int → long → float → double  Các kiểu dữ liệu byte và short được chuyển lên kiểu int

 Nếu có một toán hạng có kiểu dữ liệu long thì toàn bộ biểu thức chứa toán hạng này sẽ được chuyển về kiểu long

 Nếu có một toán hạng có kiểu dữ liệu float thì toàn bộ biểu thức chứa toán hạng này sẽ được chuyển về kiểu float

 Nếu có một toán hạng có kiểu dữ liệu doublethì toàn bộ biểu thức chứa toán hạng này sẽ được chuyển về kiểu double

Ví dụ: ép kiểu rộng

public class EpKieuRong {

public static void main(String[] args) {

Explicit Casting (Ép kiểu hẹp/ Ép kiểu tường minh)

Chuyển từ kiểu có vùng lưu trữ lớn về kiểu có vùng lưu trữ nhỏ Loại này có thể làm mất mát dữ liệu Sơ đồ chuyển đổi như sau:

double → float → long → int → short → byte

Lưu ý: Khi ép kiểu dữ liệu chúng ta phải thật sự cẩn thận nếu không sẽ làm ảnh

hưởng đến kết quả của toàn bộ bài toán Ví dụ: ép kiểu hẹp

public class EpKieuHep {

public static void main(String[] args) { /*

* Ép kiểu hẹp */

Một biến của Java là tên gọi của một vùng nhớ bên trong máy tính dùng để lưu

trữ giá trị mà chương trình của chúng ta có thể tương tác được Giữa biến và kiểu dữ liệu có một mối liên hệ mật thiết với nhau, một kiểu dữ liệu phải có một biến để lưu

 Kiểu dữ liệu dùng để xác định kích thước và loại giá trị có thể được lưu trữ

 Giá trị là dữ liệu thực tế được lưu trữ trên biến và có thể thay đổi được

Trong Java có 3 loại biến thường gặp đó là: Local variable (biến cục bộ), Instance variable (thuộc tính) và Static variable (biến tĩnh) Chúng ta sẽ tìm

hiểu kỹ về thuộc tính và biến tĩnh khi bước sang chương về lập trình hướng đối tượng

Cách khai báo biến trong Java: có 2 cách Tuy nhiên chúng ta nên sử dụng cách 2

 Cách 1: [kiểu_dữ_liệu] [tên_biến]; ví dụ double d1;

 Cách 2: [kiểu_dữ_liệu] [tên_biến] = [giá_trị]; ví dụ double d1 = 100.04;

Ví dụ một số cách khai báo biến và khởi tạo giá trị cho biến hợp lệ: int age; // Khai báo biến kiểu int

String name = "Freetuts"; // Khai báo biến kiểu String và có khởi tạo giá trị

b Biến cục bộ (Local Variable)

Là biến được khai báo bên trong thân hàm, trong hàm tạo hoặc bên trong các khối lệnh và chỉ có phạm vi trong nội bộ thân hàm

Các biến cục bộ được khởi tạo khi các hàm, hàm tạo hoặc các khối lệnh được tạo ra và các biến này sẽ bị hủy bỏ một khi các hàm, hàm tạo hoặc các khối lệnh chứa nó kết thúc

Các phạm vi truy cập không được sử dụng khi khai báo biến cục bộ

Các biến cục bộ không có giá trị mặc định, vì vậy các bạn cần phải khai báo và khởi tạo giá trị ban đầu cho biến trước khi sử dụng

Ví dụ:

public class LocalVariable {

public static void main(String[] args) {

int localVariable1 = 19; // đây là biến cục bộ float localVariable2 = 5.4f; // đây là biến cục bộ System.out.println("Giá trị của biến localVariable1 =

Trong đời sống hằng ngày, có những giá trị không bao giờ thay đổi chẳng hạn như: Một ngày có 24 giờ, một năm có 12 tháng và trong toán học giá trị không thay đổi này được thể hiện thông quá số PI, số Fibonacci, Trong Java cũng vậy, hằng số là những giá trị không bao giờ thay đổi trong suốt quá trình sử dụng, là một giá trị bất biến trong chương trình

Để khai báo hằng số ta sử dụng từ khóa static finalđặt trước tên hằng số: [Phạm vi truy cập] static final [kiểu dữ liệu] [tên hằng số] = [giá trị];

Dưới đây là chương trình minh họa cách sử dụng hằng số public class Constant {

// Khai báo hằng số

public static final int HOUR_OF_DAY = 24;

public static final String CHUOI = "Hello Freetuts!";

public static void main(String[] args) {

System.out.println("Một ngày có " + HOUR_OF_DAY + "

Trong Java cũng như các ngôn ngữ lập trình khác, mảng là kiểu dữ liệu có cấu trúc gồm một tập hợp cố định các phần tử có cùng kiểu dữ liệu, các phần tử của

mảng có cùng tên và được phân biệt nhau bởi chỉ số Mỗi phần tử của mảng được sử dụng như là một biến đơn, kiểu dữ liệu của mảng chính là kiểu dữ liệu của phần tử Như vậy, đối với mảng thì chúng ta cần quan tâm đến các thành phần sau:

 Các thông tin liên quan đến mảng: tên mảng, số phần tử của mảng, kiểu dữ

liệu của mảng

 Số chiều của mảng: Nếu mảng chỉ có một chỉ số để lưu trữ các giá trị vào

trong các biến thành phần của mảng thì được gọi là mảng một chiều Nếu mảng

có 2 chỉ số để lưu trữ các giá trị (chẳng hạn giá trị của một bảng có m dòng, n cột) được gọi là mảng 2 chiều Tương tự, ta có mảng 3 chiều, 4 chiều, ., n

chiều

Trong lập trình, mảng thường xuyên được sử dụng không chỉ bởi tính đơn giản, dễ sử dụng của nó mà còn ở khả năng đáp ứng nhu cầu lưu trữ dữ liệu trong các bài toán thực tế Chúng ta có thể sử dụng mảng khi cần lưu trữ nhiều giá trị, chẳng hạn như lưu trữ các số nguyên từ 1 đến 5; dãy 32 chuỗi ký tự, trong đó mỗi chuỗi lưu trữ tên của một sinh viên trong một lớp học

Trong Java, mảng được hỗ trợ dưới dạng mảng một chiều cho đến mảng nhiều chiều Nhưng thông thường, khi lập trình chúng ta thường chỉ sử dụng mảng có tối đa là ba chiều và mảng một chiều là mảng được sử dụng nhiều nhất

 Mảng 1 chiều trong Java: Mảng một chiều là một tập hợp của nhiều phần

tử có kiểu dữ liệu giống nhau

Cú pháp khai báo mảng

Để khai báo mảng, chúng ta cần phải xác định trước 3 thông tin cần thiết sau:

 Kiểu dữ liệu của mảng

Trong đó, [Kiểu_dữ_liệu] mô tả kiểu của mỗi phần tử thuộc mảng (như int, char, double, String, ), tên_mảng là tên của mảng và quy tắc đặt tên phải tuân theo quy tắc

đặt tên biến trong Java

Ví dụ: int[] a;: khai báo mảng tên a và có kiểu dữ liệu là int Cấp phát bộ nhớ cho mảng

Tương tự như chuỗi, bản chất của mảng là 1 đối tượng (chi tiết về đối tượng chúng ta sẽ được học trong chương Lập trình hướng đối tượng), vì vậy mảng cần phải

được cấp phát bộ nhớ trước khi sử dụng Để cấp phát bộ nhớ cho mảng thì chúng ta có 2 cách như sau:

Cách 1: [Kiểu_dữ_liệu] tên_mảng[] = new [Kiểu_dữ_liệu]

[Số_phần_tử_của_mảng];

Cách 2: [Kiểu_dữ_liệu][] tên_mảng = new [Kiểu_dữ_liệu]

[Số_phần_tử_của_mảng];

Trong đó, [Số_phần_tử_của_mảng] chỉ ra số lượng phần tử tối đa mà mảng có thể lưu trữ, giá trị này phải là một số nguyên dương

Ngoài ra, Java còn cho phép chúng ta vừa có thể khai báo mảng và vừa khởi tạo giá trị cho mảng

Ví dụ:

int[] a = new int[] {2, 10, 4, 8, 5};: khai báo mảng một chiều có tên là a, kiểu dữ liệu là int và mảng này chứa 5 phần tử có giá trị lần lượt là 2, 10, 4, 8, 5

Truy xuất các phần tử của mảng

Đối với mảng thì chúng ta có thể truy xuất các phần tử của mảng thông qua

các chỉ số của phần tử đó Cú pháp như sau: Tên_mảng[Chỉ_số_phần_tử];

Trong đó, [Chỉ_số_phần_tử] là số thứ tự của các phần tử trong mảng và bắt đầu từ 0 Như vậy, mảng có n phần tử thì các phần tử của nó có chỉ số lần lượt là 0, 1, 2, , n - 1

Ví dụ: Chúng ta có đoạn chương trình sau:

public static void main(String[] args) {

// Khai báo và khởi tạo giá trị ban đầu cho mảng char[] kyTu = new char[] {'a', 'b', 'c', 'd', 'e'}; // hiển thị ký tự tại vị trí thứ 2 trong mảng

System.out.println("Ký tự tại vị trí thứ 2 trong mảng là "

public static void main(String[] args) { int size; // kích thước của mảng

Scanner scanner = new Scanner(System.in);

System.out.println("Nhập vào độ dài của mảng: "); size= scanner.nextInt();

// khai báo và cấp phát bộ nhớ cho mảng

// mảng này có tên là array và kích thước = size int[] array = new int[size];

// array.length: trả về kích thước của mảng

// vòng lặp này sẽ duyệt i từ 0 đến chiều dài của mảng - 1 for (int i = 0; i < size; i++) {

// hiển thị giá trị các phần tử trong mảng for (int i = 0; i < size; i++) {

System.out.println("Phần tử thứ " + i + ": " + array[i]);

} }

Gán giá trị cho phần tử của mảng

Cho 2 mảng array1 và array2 là các mảng có cùng kiểu dữ liệu Giả sử các phần tử trong mảng array1 đã có giá trị, khi đó chúng ta có thể gán giá trị của một phần tử trong array1 cho một phần tử trong mảng array2 như sau:

public static void main(String[] args) { // khai báo mảng array1 và array2 int[] array1 = {2, 10, 3, 9, 8}; int array2[] = new int[5];

// gán giá trị của phần tử thứ 2 trong mảng array1 // cho phần tử thứ 3 trong mảng array2

 Mảng 2 chiều trong Java: mảng hai chiều là mảng có 2 chỉ số để lưu trữ

các giá trị (chẳng hạn giá trị của một bảng có m dòng, n cột)

Trong đó: [Kiểu_dữ_liệu] mô tả kiểu của mỗi phần tử thuộc mảng (như int, char, double, String, ), tên_mảng là tên của mảng và quy tắc đặt tên phải tuân theo quy tắc

đặt tên biến trong Java

Ví dụ: int a[][];: khai báo mảng hai chiều a có kiểu dữ liệu là int Cấp phát bộ nhớ cho mảng

Để cấp phát bộ nhớ cho mảng 2 chiều thì chúng ta sử dụng từ khóa new, trong đó [Số_dòng], [Số_cột]: là hai số nguyên dương chỉ ra số lượng dòng và số lượng cột của mảng hai chiều và trong Java có 2 cách để cấp phát bộ nhớ như sau:

Cách 1: [Kiểu_dữ_liệu] Tên_mảng[][] = new [Kiểu_dữ_liệu] [Số_dòng][Số_cột];

Ví dụ: khai báo và cấp phát bộ nhớ cho mảng number có 2 dòng, 3 cột: int number[][] = new int[2][3];

Cách 2: [Kiểu_dữ_liệu][][] Tên_mảng = new [Kiểu_dữ_liệu] [Số_dòng][Số_cột];

Ví dụ: khai báo và cấp phát bộ nhớ cho mảng A có 3 dòng, 5 cột: String[][] A = new String[3][5];

Khi trình biên dịch gặp lệnh trên thì nó sẽ cấp phát vùng nhớ để chứa mảng hai

chiều có 3 dòng, 5 cột với số phần tử trong mảng = số dòng * số cột = 15 Hình ảnh

minh họa của mảng hai chiều trên như là một bảng gồm có các dòng và các cột như sau:

Bản chất của mảng 2 chiều là mỗi dòng của nó chính là một mảng một chiều Ví dụ: với mảng hai chiều a có 3 dòng, 5 cột, mỗi phần tử của mảng có kiểu int thì a được xem như mảng một chiều có 3 phần tử, mỗi phần tử này là một mảng một chiều có 5 phần tử

Ngoài ra, Java còn cho phép chúng ta vừa có thể khai báo mảng và vừa khởi tạo giá trị cho mảng Ví dụ để khai báo mảng một chiều có tên là diem, kiểu dữ liệu là int và mảng này chứa 6 phần tử có giá trị lần lượt là 1, 2, 3, 4, 5, 6 thì chúng ta làm như sau:

// khai báo một mảng 2 chiều có 3 dòng và 2 cột int diem[][] = {{1, 2}, {3, 4}, {5, 6}};

Truy xuất các phần tử của mảng

Mỗi phần tử của mảng 2 chiều được truy xuất thông qua tên mảng cùng với chỉ số dòng và chỉ số cột của phần tử đó Tương tự như mảng một chiều, nếu một mảng

hai chiều có m dòng và n cột thì chỉ số của dòng sẽ chạy từ 0, 1, 2, , m - 1 và chỉ số của cột sẽ chạy từ 0, 1, 2, , n - 1

Cú pháp như sau: Tên_mảng[Chỉ_số_dòng][Chỉ_số_cột]

Ví dụ: Để truy cập đến phần tử nằm ở dòng 2, cột 1 của mảng diem được khai báo

ở trên thì chúng ta làm như sau:

public static void main(String[] args) {

// khai báo một mảng 2 chiều có 3 dòng và 2 cột

public static void main(String[] args) { // khai báo số dòng và số cột cho mảng int soDong, soCot;

// khai báo và cấp phát bộ nhớ cho mảng int[][] A = new int[soDong][soCot];

// Để nhập giá trị các phần tử cho mảng // chúng ta sẽ sử dụng 2 vòng lặp for

// vòng lặp for bên ngoài sẽ duyệt i từ 0 đến soDong - 1 // và vòng lặp for bên trong sẽ duyệt j từ 0 đến soCot - 1 // mỗi lần như vậy thì sẽ nhập vào phần tử tại vị trí i, j for (int i = 0; i < soDong; i++) {

for (int j = 0; j < soCot; j++) {

// hiển thị các phần tử trong mảng vừa nhập

// chúng ta cũng sử dụng 2 vòng lặp for như khi nhập System.out.println("Mảng vừa nhập: ");

for (int i = 0; i < soDong; i++) { for (int j = 0; j < soCot; j++) {

b Chuỗi ký tự trong Java

 Khai báo chuỗi ký tự

Trong Java, để khai báo 1 chuỗi ký tự thì chúng ta có 2 cách nhƣ sau:

Cách 1:

Cú pháp: String tenChuoi = "giá_trị_khởi_tạo";

Trong đó, giá_trị_khởi_tạo của chuỗi có thể có hoặc không và nếu có thì phải đặt trong cặp dấu " "

Nếu một chuỗi có giá_trị_khởi_tạo = " " thì chuỗi đó đƣợc gọi là chuỗi rỗng

Ví dụ:

public static void main(String[] args) { // khai báo chuỗi rỗng

String chuoi1 = "";

// khai báo chuỗi có nội dung là "Welcome" String chuoi2 = "Welcome";

// hiển thị giá trị của 2 chuỗi trên ra màn hình

System.out.println("Chuỗi rỗng có giá trị = " + chuoi1); System.out.println("Chuỗi 2 có giá trị = " + chuoi2); }

Cách 2: Sử dụng từ khóa new

Cú pháp: String tenChuoi = new String("giá_trị");

Trong đó giá_trị là một chuỗi bất kỳ và phải đặt trong cặp dấu " " Ví dụ:

public static void main(String[] args) {

// khai báo một chuỗi có nội dung là "Welcome to Java!" String chuoi = new String("Welcome to Java!");

System.out.println(chuoi); }

 Các hàm xử lý chuỗi ký tự

 Hàm xác định độ dài chuỗi ký tự: trả về độ dài chuỗi ký tự Cú pháp: int length = tên_chuỗi.length();

 Hàm nối 2 chuỗi ký tự: nối chuỗi str2 vào str1 và trả về chuỗi str3

Hàm có tác dụng so sánh hai chuỗi string1, string2 và trả về kết quả: Nếu result = 0 thì hai chuỗi đó bằng nhau

Nếu result < 0 thì chuỗi string1 < string2 Nếu result > 0 thì chuỗi string1 > string2