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ề ý

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

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

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.

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…

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 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 hiện nay rất đa dạng, trong đó Java được biết đến là một ngôn ngữ lập trình thuần hướng đối tượng Ngược lại, C++ dù sở hữu một số đặc điểm cơ bản của lập trình hướng đối tượng nhưng vẫn không được coi là ngôn ngữ lập trình thuần hướng đối tượng như Java.

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 bài toán hướng đối tượng thường xuất phát từ một yêu cầu cụ thể Từ đó, nhiệm vụ của lập trình viên là xác định các đối tượng phù hợp, thiết lập mối quan hệ và chức năng giữa các đối tượng này để tạo nên một hệ thống đáp ứng yêu cầu của bài toán ban đầu.

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ô hình hoá lớp đối tƣợng

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

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 triển khai theo nguyên tắc từ dưới lên trên, từ cụ thể đến trừu tượng Bắt đầu từ các đối tượng cụ thể, phương pháp này tập hợp thuộc tính của từng đối tượng, sau đó nhóm những đối tượng tương tự lại thành nhóm, loại bỏ thuộc tính riêng biệt và giữ lại thuộc tính chung nhất, từ đó nhóm thành lớp Do đó, quá trình hình thành lớp chính là quá trình chuyển từ mức thấp cụ thể đến mức cao trừu tượng.

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

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.

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:

- 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 thiết, lập trình viên có thể tận dụng công nghệ lắp ghép thành phần để tạo ra các chương trình với chức năng đa dạng bằng cách kết hợp những thành phần sẵn có Điều này không chỉ giúp tiết kiệm thời gian lập trình đáng kể mà còn gia tăng hiệu quả sản xuất phần mềm.

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 lập trình hướng tác nhân, các tác nhân là các thành phần hoạt động độc lập và có khả năng chủ động liên lạc, giao tiếp với nhau Điều này cho phép chúng phối hợp, cộng tác hoặc cạnh tranh với nhau để hoàn thành các nhiệm vụ Đặc điểm cơ bản của lập trình hướng tác nhân bao gồm sự tự chủ và khả năng giao tiếp của các tác nhâ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 và cạnh tranh với nhau nhằm hoàn thành nhiệm vụ chung của toàn hệ thống xã hội.

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.

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ế?

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 để ”

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

Đố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

-Tên: ABC -Các đỉnh: 3 -Màu viền: xanh -Màu tô: đỏ

-Tên: Jack -Tuổi: 19 -Cân nặng: 50

-Đi -Nói -Làm bài kiểm tra

- 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.

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 là định nghĩa các thuộc tính cùng kiểu dữ liệu của chúng, các giá trị cụ thể sẽ được gán khi tạo đối tượng Bên cạnh đó, khai báo lớp còn bao gồm các phương thức hoạt động trên các đối tượng đó.

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

-Nói -Làm bài kiểm tra

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

-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)

-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ó

Các biến dữ liệu và hàm tĩnh dùng chung cho mọi đối tượng trong lớp, được khởi tạo khi lớp được nạp vào lần đầu Tĩnh (static) thuộc lớp, không thuộc riêng đối tượng nào Khi thực hiện, nó tạo ra một bản sao của dữ liệu, hàm trong lớp.

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 đó

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) { 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) {

// 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()

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

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

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"

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

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

Giới thiệu và cài đặt ngôn ngữ 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ệ

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ừ 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)

- Đ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

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 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

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à

To create a Java project in Eclipse, open the Java perspective from the Window menu Then, select File > New from the menu bar (or use the shortcut Alt + Shift + N) and choose 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

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:

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.

 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.*;

//Đị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

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”);

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

Hàm tĩnh (static) được khai báo phụ thuộc vào lớp, không phụ thuộc vào đối tượng cụ thể Do đó, khi thực hiện không cần phải tạo lập đối tượng để gọi những hàm kiểu 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

• \jdk\bin>javac HelloWorldApp.java

-Kết quả sau khi biên dịch

Ngôn ngữ Java

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 ta

Trong Java, chúng ta có 3 cách comment code nhƣ sau:

File mã máy tương ứng

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

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:

+ Đị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.

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

 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 nên theo quy tắc đặt tên lạc đà (Camel Case), tức là chữ cái đầu của từ đầu tiên viết thường, chữ cái đầu của các từ sau viết hoa, chẳng hạn: diemTrungBinh.

Furthermore, in some cases, the variable name should clearly indicate the datatype of that variable For example: a variable with a List type should be named studentList, a variable with a Set type should be named studentSet, a variable with a Map type should be named studentMap, a variable with an Array type should be named studentArray, etc Set constant names ( 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.

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)

Các cấu trúc lệnh trên Java

3.4.1 Câu lệnh if…else a) Lệnh if đơn giản (Có một lệnh if)

Trang 44 if ()

; //khối lệnh bao bằng cặp dấu ngoặc {, }

Nếu có giá trị true thì thực hiện , ngƣợc lại thì

bị bỏ qua và thực hiện các lệnh tiếp theo của chương trình

Ví dụ: int a=9, b=7; if (a0) {

System.out.println("co doi so dong lenh");

System.out.println("so doi so la"+paraCount);

} else System.out.println("khong co doi so");

System.out.println("ngoai cau truc if-else");

//điều kiện (paraCount>0) chưa xác định vì đối số args chỉ đưa vào lúc chay chương trình c) Lệnh if-else-if if ()

; else if ()

Trang 45 else if ()

Nếu có giá trị true thì thực hiện

Còn lại nếu có giá trị true thì thực hiện Còn ngoài ra thực hiện

String hourS=args[0]; int hour=Integer.parseInt(hourS); if (hour10) return donGia*soLuong*0.95; else return donGia*soLuong;

} public String nhaSX() { return (tenNhaSX); } public String soDT()

//lop thuc thi ung dung public class TienTrinh

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

System.out.println("gia tien xe"+xe.thanhTien(2)); System.out.println("ten nha san pham"+xe.nhaSX()); System.out.println("gia tien xe"+xe.soDT());

Tính đa hình

Tính đa thể: Theo nghĩa chung nhất tính đa thể đƣợc thể hiện nhƣ sau: Cùng một một sự việc/chức năng/ hàm nhƣng có những thể hiện khác nhau (cách ứng xử khác nhau) tuỳ theo ngữ cảnh

Trong java cụ thể hoá tính đa thể bằng hai dạng sau: Overloading, Overriding 4.3.1 Nạp chồng (Overloading)

 Cùng một chức năng/ hàm mà mỗi đối tƣợng sẽ ứng xử khác nhau tuỳ theo ngữ cảnh

- Cùng chức năng/ hàm: Xây dựng các phương thức cùng tên trong cùng một lớp nhƣng tham số khác nhau (ứng xử khác nhau), tham số khác nhau do:

+Số lƣợng các tham số

+Kiểu dữ liệu tương ứng của tham số

 Khi tạo ra đối tượng từ lớp đó thì phương thức nào có tham số tương ứng khi gọi sẽ đƣợc thi hành

{ System.out.println("ham khong co tham so"); } public void check(int ts)

{ System.out.println("ham co tham so"+ts); } public double check(int ts1, double ts2)

{ return ts1+ts2; } public double check(double ts1, int ts2)

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

ChucNang obj=new ChucNang(); obj.check(); obj.check(3);

System.out.println("ket qua:int+double: "+obj.check(2,3.0));

System.out.println("ket qua: double*int: "+obj.check(3.0,3));

 Cùng một chức năng/ hàm (cùng tên hàm, kiểu dữ liệu trả về của hàm, tham số: kiểu dữ liệu, số lƣợng) nhƣng ứng xử khác nhau trên các đối tƣợng

 Trong nguyên lý kế thừa cùng một chức năng ở lớp cha nhƣng đối tƣợng ở lớp con lại có thể hiện khác nhau

 Cài đặt: Xây dựng chức năng ở lớp cha, sau đó cũng chức năng ấy đƣợc viết đè ở lớp con

{ protected double canh1; protected double canh2;

Hinh(double c1, double c2) { canh1 canh2

Trang 72 public static void main(String args[]) {

HinhChuNhat dtHinhCN=new HinhChuNhat(4,2); ref=dtHinhCN;

System.out.println("dien tich cua hinh chu nhat: "+ref.dienTich()); HinhVuong dtHinhV=new HinhVuong(4); ref=dtHinhV;

System.out.println("dien tich cua hinh vuong: "+ref.dienTich()); /*

System.out.println("dien tich cua hinh"+dtHinh.dienTich());

System.out.println("dien tich cua hinh chu nhat"+dtHinhCN.dienTich());

System.out.println("dien tich cua hinh chu nhat"+dtHinhV.dienTich());

Các xây dựng và sử dụng gói (Package) trong Java

-Gói dùng để nhóm các lớp, các giao diện có liên quan với nhau

4.4.1 Cách xây dựng gói a) Khai báo package

4.4.2 Các sử dụng gói b) Biên dịch gói trong textpad

-Biên dịch: command: D:\Program Files\Java\jdk1.5.0\bin\javac.exe -Đường dẫn đến trình biên dịch javac.exe parametes: -d D:\baitapjava\goi NhanVien.java

Biên dịch bằng tuỳ chọn –d

-Thƣ mục khởi tạo: initial folder: D:\baitapjava\goi Thƣ mục chứa tập tin cần biên dịch -Kết quả khi biên dịch:

Để sử dụng một lớp hoặc giao diện trong gói, bạn cần nhập gói đó trước Để nhập gói, bạn sử dụng câu lệnh "import ." Bạn cũng có thể sử dụng ký tự đại diện "*" để nhập tất cả các lớp hoặc giao diện trong gói.

Tạo hai lớp NhanVien, Phong và giao diện BaoHiem nằm trong gói qlns

// tạo file 1 package qlns; public class NhanVien

{ public int maNV; public String tenNV; public NhanVien( int id, String ten)

} public double luong(double hSL)

// tạo file 2 package qlns; public class Phong

{ public String maPhong; public String tenPhong; public Phong(String maP, String tenP) { maPhong=maP; tenPhong=tenP;

// tạo file 3 package qlns; public interface BaoHiem

Trang 74 public static final double baoHiemXHP00; public static final double baoHiemYT000; public double tinhLuong(double hsl);

//Sử dụng các lớp NhanVien import qlns.NhanVien; public class NhapGoi

{ public static void main (String args[])

NhanVien nV1=new NhanVien(1,"nguyen");

System.out.println("ma nhan vien : "+nV1.maNV);

System.out.println("ten nhan vien : "+nV1.tenNV); System.out.println("luong nhan vien : "+nV1.luong(2)); }

//Sử dụng các lớp Phong import qlns.Phong; public class ThongTinPhong

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

Phong nV=new Phong("hc","hanh chinh");

System.out.println("ma phong : "+nV.maPhong); System.out.println("ten phong : "+nV.layTenP()); }

//Sử dụng giao diện BaoHiem import qlns.BaoHiem; public class NhanLuong implements BaoHiem

{ public double tinhLuong(double hsl) { return (hsl*300000)-(baoHiemXH+baoHiemYT);

} public static void main(String args[]) {

System.out.println("bao hiem y te "+baoHiemYT);

System.out.println("bao hiem xa hoi "+baoHiemXH);

System.out.println("luong thuc nhan "+nV.tinhLuong(2));

-Nhập tất cả gói: import .*;

-Tất cả các thành viên trong gói khai báo là public để truy cập từ bên ngoài

- Đường dẫn đến lớp trong gói

- Khai báo: package .;

Gói 1: đã tạo trước đó

Nhập các lớp trong gói import ..; package qlns.vanphong; public class NhanVienVP

{ public int maPhong; public String tenPhong; public NhanVienVP(int maP, String tenP) { maPhong=maP; tenPhong=tenP;

Sự hoàn thành của đối tượng

Một số đối tƣợng có thể gắn với những tài nguyên (nhƣ tệp, kết nối mạng) và chúng đòi hỏi giải phóng tường minh Cơ chế hoàn thành của đối tượng cung cấp một kế sách để một đối tượng có thể thực hiện một hành động bất kỳ trước khi bộ nhớ đƣợc giải phóng Bộ dọn rác tự động gọi hàm finalize() đã đƣợc xây dựng trong lớp Object có dạng:

Protected void finalize() Throwable để tập hợp rác lại trước khi thiêu huỷ chúng Hàm này có thể được viết đè ở lớp con để thực hiện những công việc thích hợp trước khi huỷ bỏ đối tƣợng.

Xử lý ngoại lệ (Exception)

4.5.1 Định nghĩa một ngoại lệ

Exception là một sự kiện chỉ xảy ra trong quá trình chương trình Java thực thi một câu lệnh nào đó và thông thường nó sẽ phá vỡ luồng làm việc của chương trình,

Trang 76 tức là chương trình đang chạy sẽ lập tức ngừng lại và xuất hiện thông báo lỗi Đó chính là Exception (ngoại lệ)

Ví dụ về Exception đó chính là khi chúng ta tiến hành thực hiện phép chia một số nguyên dương cho số 0 thì khi biên dịch chương trình sẽ làm phát sinh lỗi và đó đƣợc coi là ngoại lệ

Trong Java có 2 loại Exception là Checked Exception và Unchecked Exception

 Checked Exception là các Exception xảy ra tại thời điểm Compile time (là thời điểm chương trình đang được biên dịch) Những Exception này thường liên quan đến lỗi cú pháp (syntax) và bắt buộc chúng ta phải "bắt" (catch) nó

 Unchecked Exception: là các Exception xảy ra tại thời điểm Runtime (là thời điểm chương trình đang chạy) Những Exception này thường liên quan đến lỗi logic và không bắt buộc chúng ta phải "bắt" (catch) nó.

4.5.2 Mô hình xử lý ngoại lệ

Trong Java, để xử lý ngoại lệ chúng ta sẽ có các cách:

- Sử dụng khối try catch để xử lý

- Sử dụng khối try catch finally

- Sử dụng từ khóa throw và throws

- Sử dụng try with resource

- Sử dụng Nested try (lồng một khối try trong một try khác)

- Sử dụng multicatch để bắt nhiều ngoại lệ.

 Khối lệnh try-catch-finally

} catch( )

- Các ngoại lệ sẽ đƣợc cho qua trong quá trình thực hiện khối try và bị giữ lại xử lý ở các khối catch Nếu có khối finally thì phải thực hiện đến cùng, bất luận có gặp phải ngoại lệ hay không

- Hoạt động của các khối trên đƣợc minh hoạ nhƣ sau:

-Các ngoại lệ thường gặp (kiểu ngoại lệ)

ArithmeticException: Lỗi do tính toán, thường chia cho không

IOException: Lỗi nhập xuất dữ liệu

FileNotFoundException: Lỗi truy cập tập tin

Ví dụ 1: public class ChiaChoKhong

{ public void chia() { int n1 ; int n2=0; try {

System.out.println("gap phai loi"+e);

} System.out.println("ket thuc ham chia");

} public static void main(String agrs[]) { new ChiaChoKhong().chia();

Thực hiện khối catch ứng với ngoại lệ 2

Thực hiện khối catch ứng với ngoại lệ 1

Thực hiện khối catch ứng với ngoại lệ n

Tìm khối catch để thực hiện

System.out.println("quay lai ham main");

Ví dụ 2: public class ChiaChoKhong1

{ public void chia() { int n1 ; int n2=0; try {

System.out.println("gap phai loi"+e);

System.out.println("Nhung viec can thuc hien");

} System.out.println("ket thuc ham chia");

} public static void main(String agrs[]) { new ChiaChoKhong1().chia();

System.out.println("quay lai ham main");

Để bỏ qua ngoại lệ tạm thời, bạn có thể sử dụng lệnh throw với cú pháp throw .

là biểu thức xác định một đối tƣợng của lớp throwable Thông thường, một đối tượng ngoại lệ sẽ được tạo ra trong câu lệnh throw để sau đó chúng đƣợc giữ lại và xử lý ở khối catch

Ví dụ class ChiaCho0Exception extends Exception

ChiaCho0Exception(String msg) { super(msg);}

{ public void chia() { int n1 ; int n2=0; try { if(n2==0) throw new ChiaCho0Exception("/by 0");

System.out.println("gap phai loi"+er);

System.out.println("Nhung viec can thuc hien");

} System.out.println("ket thuc ham chia");

} public static void main(String agrs[]) { new ChiaChoKhong2().chia();

System.out.println("quay lai ham main");

Khi thiết kế các hàm thành phần, chúng ta có thể sử dụng mệnh đề throws để tạm thời cho qua các ngoại lệ mà thực hiện một số công việc khác Những hàm này lại sử dụng theo cấu trúc try-catch-finally sau đó để xử lý các ngoại lệ khi chúng xuất hiện nhƣ trên Định nghĩa hàm với mệnh đề throws có dạng:

() throws {/*…*/}

Ví dụ: class ChiaCho0Exception extends Exception

ChiaCho0Exception(String msg) { super(msg);}

{ public void chia() throws ChiaCho0Exception { int n1 ; int n2=0; if(n2==0) throw new ChiaCho0Exception("/by 0");

System.out.println("ket thuc ham chia");

} public static void main(String agrs[]) { try { new ChiaChoKhong3().chia();

System.out.println("trong ham main() gap loi");

System.out.println("nhung viec can thuc hien");

} System.out.println("quay lai tu ham main");

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

Những phương thức nào trong chương trình sau là nạp chồng, phương thức nào là viết đè (đã đánh số phương thức đó trong chương trình và in đậm dòng) class BongDen

{ private int soWatts; protected boolean bat;

BongDen(int w, boolean b,String v) { soWatts=w; bat=b; viTri=v;

} protected double tienDien(double soChu) // (1)

} protected double tienDien(double soChu, double donGia) // (2)

DenTuyp(int w, boolean b, String v, double d)

} protected double tienDien(double soChu) // (3)

{ public static void main(String args[])

DenTuyp den=new DenTuyp(40, true, "phong hoc", 150);

System.out.println("Tien dien phai tra cho den tuyp"+den.tienDien(10)); }

Bài 2: Nhận xét các dòng lệnh (1), (2) và (3)(đã đánh số các dòng lệnh đó trong chương trình và in đậm dòng) class BongDen

{ private int soWatts; protected boolean bat; public String viTri;

BongDen(int w, boolean b,String v) { soWatts=w; bat=b; viTri=v;

} protected double tienDien(double soChu) { return soChu*1000;

} protected double tienDien(double soChu) // (1) { return soChu*9500;

DenTuyp(int w, boolean b, String v, double d) { super(w,b,v); chieuDai=d;

} protected double tienDien(double soChu) { return soChu*1000*0.95;

{ public static void main(String args[])

DenTuyp den=new DenTuyp(40, true, "phong hoc", 150);

System.out.println("Tien dien phai tra cho den tuyp" + den.soWatts);//(2)

System.out.println("Tien dien phai tra cho den tuyp"+den.tienDien(10));

Den den=new Den(45, false, "van phong", 75);//(3)

-Xây dựng lớp bóng đèn gồm các thuộc tính:

-Bật/ tắt để mô tả việc bật tắt của bóng đèn

-Vị trí để mô tả nơi đặt bóng đèn chọn kiểu dữ liệu tương ứng cho từng thuộc tính, phạm vi truy cập của các thuộc tính lần lƣợt là private, protected và public

-Xây dựng một phương thức trong lớp để tính tiền điện, phạm vi truy cập của phương thức là public, hàm nhận hai tham số là số chữ và đơn giá, hàm trả về giá trị tiền điện đƣợc xác định bằng: số chữ * đơn giá

-Xây dựng một lớp ứng dụng để tạo ra đối tƣợng từ lớp bóng đèn và cho hiển thị lên màn hình các thuộc tính và phương thức của đối tượng

-Xây dựng lớp bóng đèn với cùng một phương thức tính tiền điện nhưng với các yêu cầu khác nhau (nạp chồng)

-Phương thức tính tiền điện không nhận tham số thì tiền điện được tính là 5000 -Phương thức tính tiền điện nhận một tham số là số chữ thì tiền điện được tính là: số chữ*1000

-Phương thức tính tiền điện nhận hai tham số là số chữ và đơn giá thì tiền điện đƣợc tính là: số chữ*đơn giá

-Phạm vi truy cập các phương thức trên là public

Tạo lớp ứng dụng để khởi tạo đối tượng đèn và hiển thị phương thức tính toán tiền điện của đối tượng lên giao diện.

-Xây dựng một giao diện có tên là HinhTron, trong giao diện đó định nghĩa một hằng

PI có giá trị là 3.14 và hai phương thức tính chu vi, diện tích của hình tròn, hai phương thức này nhận vào một tham số (đây chính bán kính của đường tròn)

Để thiết kế giao diện hình tròn, lớp `GiaoDienHinhTron` được tạo Nó bao gồm các phương thức tính chu vi và diện tích Phương thức `tinhChuVi` trả về kết quả bằng `2 * PI * banKinh`, trong khi phương thức `tinhDienTich` trả về kết quả bằng `banKinh * banKinh * PI`.

-Xây dựng lớp ứng dụng để tạo ra đối tƣợng từ lớp GiaoDienHinhTron và cho hiển thị lên màn hình các phương thức tính chu vi và diện tích hình tròn của đối tượng

LẬP TRÌNH GIAO DIỆN TRÊN JAVA

Mở đầu

Các ứng dụng phần mềm hiện nay vô cùng thân thiện vì đƣợc trình bày nhiều màn hình giao diện đồ họa đẹp mắt Các ngôn ngữ lập trình hiện nay đƣợc cung cấp các đối tượng đồ họa, chúng có thể được điều khiển bởi người lập trình viên, hay bởi người sử dụng Một trong số những kết quả quan trọng nhất chính là các ngôn ngữ hiện nay được dựa trên Giao diện người dùng đồ họa (Graphical User Interface - GUI) Trong chương này, ta sẽ thảo luận về Java hỗ trợ tính năng GUI cùng các sự thi hành của chúng

GUI cung cấp chức năng nhập liệu theo cách thân thiện với người dùng GUI biến đổi từ ứng dụng đến ứng dụng và có thể chứa nhiều điều khiển nhƣ textbox, label, listbox hay các điều khiển khác Các ngôn ngữ lập trình khác nhau cung cấp nhiều cách khác nhau để tạo GUI Các phần mềm giống nhƣ VB hay VC++ có thể cung cấp chức năng kéo và thả trong khi đó phần mềm giống như C++ yêu cầu người lập trình phải viết toàn bộ mã để xây dựng một GUI.

Giới thiệu AWT và Swing

Java AWT (Abstract Window Toolkit) là một API để phát triển các ứng dụng dựa trên GUI hoặc cửa sổ trong java

Các thành phần Java AWT là các thành phần phụ thuộc vào nền tảng đƣợc hiển thị theo giao diện của hệ điều hành AWT có nghĩa là các thành phần của nó sử dụng các tài nguyên của hệ điều hành AWT là một bộ các lớp trong Java cho phép chúng ta tạo một GUI và chấp nhận các nhập liệu của người dùng thông qua bàn phím và chuột AWT cung cấp các item khác nhau để tạo một GUI hiệu quả và lôi cuốn người sử dụng

Gói java.awt cung cấp các lớp cho api AWT nhƣ TextField, Label, TextArea, RadioButton, CheckBox, Choice, List, v.v

AWT cung cấp các item nhƣ:

 Trình quản lý cách trình bày (Layout manager)

 Đồ họa (Graphic) và các tính năng vẽ (draw)

Gói AWT chứa các lớp, giao diện và các gói khác Hình sau đây mô tả một phần nhỏ của hệ thống phân cấp lớp AWT

Hình 5.1 Hệ thống cây phân cấp lớp AWT

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

Container là vùng mà ta có thể đặt các thành phần của bạn vào đó Bất cứ vật gì mà kế thừa từ lớp Container sẽ là một container Applet là một container, applet đƣợc dẫn xuất từ panel, lớp panel lại đƣợc dẫn xuất từ lớp Container

Một container có thể chứa nhiều phần tử, các phần tử này có thể đƣợc vẽ hay đƣợc tô màu tuỳ thích Hãy xem container nhƣ một cửa sổ Đã là cửa sổ thì phải có khung (frame), pane, latch, hook, và các thành phần có kích thước nhỏ hơn

Gói java.awt chứa một lớp gọi là Container Lớp này trực tiếp hay gián tiếp phát sinh ra hai container đƣợc sử dụng phổ biến nhất là Frame và Panel

Frame và Panel là các container thường được sử dụng Frame là các cửa sổ được tách riêng nhau nhƣng ngƣợc lại panel là các vùng đƣợc chứa trong một cửa sổ Panel không có các đường viền, chúng được trình bày trong một cửa sổ do trình duyệt hay appletviewer cung cấp Appletviewer là một công cụ đƣợc JDK hỗ trợ để xem các applet Frame là lớp con của Window Chúng đƣợc trình bày trong một cửa sổ độc lập, cửa sổ này có chứa các đường viền xung quanh

Một số đối tƣợng container trong Java:

[1] Panel: Đối tƣợng khung chứa đơn giản nhất, dùng để nhóm các đối tƣợng, thành phần còn lại Một Panel có thể chứa bên trong một Panel khác

Trang 86 import java.awt.*; class Paneltest extends Panel

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

Frame f=new Frame(“Testing a Panel”); f.add(p); f.setSize(300,200); f.setVisible(true);

Khung chứa (Frame) đóng vai trò như một cửa sổ cấp cao nhất, bao gồm một tiêu đề và đường viền tương tự như các ứng dụng cửa sổ khác Đây là thành phần thường được sử dụng để tạo nên cửa sổ chính của các ứng dụng.

Frame(): Tạo một frame vô hình (không nhìn thấy đƣợc)

Frame(String, title): Tạo một frame với nhan đề trống

Ví dụ: import java.awt.*; class FrameDemo extends Frame

{ public FrameDemo(String title) //hàm contructor { super(title);

} public static void main(String args[]) {

FrameDemo f=new FrameDemo(“I have been Frameed!!!”); f.setSize(300,200); f.setVisible(true);

[3] Dialogs: đây là một cửa sổ dạng hộp thoại (cửa sổ dạng này còn gọi là pop- up window), cửa sổ dạng này thường đượlc dùng để đưa ra thông báo, hay dùng để lấy dữ liệu nhập từ ngoài vào thông qua các đối tƣợng, thành phần trên dialog nhƣ

TextField Dialog cũng là một cửa sổ nhƣng không đầy đủ chức năng nhƣ đối tƣợng khung chứa Frame

Lớp „Dialog‟ tương tự như lớp Frame, nghĩa là Dialog là lớp con của lớp Window Đối tƣợng dialog đƣợc tạo nhƣ sau:

Frame myframe=new Frame(“My frame”); // calling frame

String title = “Title”; boolean modal = true;

Dialog dlg=new Dialog(myframe, title, modal);

Ví dụ: import java.awt.Frame; import java.awt.Dialog; class DialogDemo extends Frame

{ public static void main(String args[])

Frame myframe=new Frame("My frame"); // calling frame

String title = "Title Dialog"; boolean modal = true;

Dialog dlg=new Dialog(myframe, title, modal); dlg.setSize(300,200); dlg.setVisible(true);

Một component có thể được đặt trên giao diện người dùng, có thể được thay đổi kích thước hay làm cho nhìn thấy được Ví dụ được dùng phổ biến nhất là textfield, label, checkbox, textarea v.v… Các thành phần cao cấp khác nhƣ scrollbar, scrollpane và dialog cũng tồn tại Tuy nhiên chúng không được sử dụng thường xuyên

TextComponent Button Label Checkbox List Choice Container Canvas Scrollbar

Hình 5.2 Các lớp đối tƣợng thành phần

Lớp này đƣợc sử dụng để trình bày một String Nó không thể đƣợc sửa đổi Đây là một chuỗi chỉ đọc Sử dụng một trong những constructor sau đây để tạo một label:

 Label() Tạo một Label trống

 Label(String labeltext) Tạo một Label với văn bản đƣợc cho

 Label(String labeltext, int alignment) Tạo một Label với một chế độ canh lề alignment đƣợc cho, alignment có thể là Label.LEFT, Label.RIGHT hay Label.CENTER

Các phương thức được sử dụng phổ biến của label:

Phương thức Chức năng setFont(Font f) Thay đổi phông chữ đang đƣợc chọn của Label setText(String s) Thiết lập nhãn cho Label getText() Lấy nội dung hiện hành của Label

Ví dụ: minh họa các sử dụng label import java.awt.*; class Labeltest extends Frame

Label label1=new Label(“This is just a label”);//Tạo đối tượng Label public Labeltest(String title)

{ super(title); add(label1); //thêm vào container

} public static void main(String args[])

Labeltest f=new Labeltest(“Label”); f.setSize(300,200); f.show();

Một textfield là một vùng chỉ chứa một dòng đơn, trong đó văn bản có thể đƣợc trình bày hay được nhập vào bởi người dùng Tạo textfield:

 TextField(): Tạo một textfield mới

 TextField(int columns): Tạo một textfield mới với số cột đƣợc cho

 TextField(String s): Tạo một textfield mới với chuỗi văn bản đƣợc cho

 TextField(String s, int columns): Tạo một textfield mới với nhãn và số cột đƣợc cho

Các phương thức thường được sử dụng của đối tượng TextField:

Phương thức Chức năng setEchoChar(cha r)

Thiết lập các kí tự đƣợc trình bày trong dạng của một kí tự đƣợc cho setText(String s) Thiết lập nhãn cho TextField getText() Trả về nhãn của TextField setEditable(boole an)

Xác định trường có thể được soạn thảo hay không Trường chỉ đƣợc soạn thảo khi giá trị này đƣợc đặt là True isEditable() Xác định xem trường có đang trong mode soạn thảo hay không Giá trị trả về kiểu Boolean

Ví dụ: minh họa các sử dụng textfield import java.awt.*; class TextFieldtest extends Frame

TextField tf1=new TextField(30); public TextFieldtest(String title) { super(title); setLayout(new FlowLayout());

//phương thức setLayout() để thay đổi cách trình bày của các thành phần trên màn hình add(tf1);

} public static void main(String args[])

TextFieldtest f=new TextFieldtest(“TextField”); f.setSize(300,200); f.show();

Một Textarea đƣợc sử dụng khi văn bản nhập vào trên hai hay nhiều dòng Textarea có một scrollbar Thành phần TextArea là một trường văn bản có thể được soạn thảo với đặc tính nhiều dòng Để tạo một Textarea, làm theo các bước sau:

2) Chỉ ra số dòng hay số cột phần tử này cần có

3) Bố trí phần tử này trên màn hình

Trong Java, bạn có thể sử dụng các constructor sau để tạo TextArea:

 TextArea(): Tạo một TextArea mới

 TextArea(int rows, int cols): Tạo một TextArea mới với số lƣợng cột và dòng đƣợc cho

 TextArea(String text): Tạo một TextArea mới với nhãn đƣợc cho

 TextArea(String text, int rows, int cols): Tạo một TextArea mới với nhãn, số dòng và số cột đƣợc cho

Các phương thức thường được sử dụng nhiều nhất của TextArea:

Phương thức `setText(String)` dùng để đặt nhãn cho `TextArea` Phương thức `getText()` trả về nhãn của `TextArea` Phương thức `setEdiable(boolean)` xác định xem trường có thể được chỉnh sửa hay không.

Trường có thể được soạn thảo khi giá trị này là True isEdiable() Xác định xem trường có đang trong mode soạn thảo đƣợc không Trả về giá trị là kiểu Boolean insertText(String, int) Chèn String đƣợc cho vào vị trí index đƣợc cho replaceText(String, int, int)

Thay thế văn bản nằm giữa vị trí int, int đƣợc cho

Ví dụ: cách sử dụng của TextArea import java.awt.*; class TextAreatest extends Frame

Label lbl=new Label(“Details”);

Trang 91 public TextAreatest(String title) { super(title); setLayout(new FlowLayout()); add(lbl); add(ta1);

} public static void main(String args[]) {

TextAreatest t=new TextAreatest(“TextArea”); t.setSize(300,200); t.show();

Kết xuất của chương trình được chỉ ra ở hình bên dưới:

Nút nhấn hay còn gọi là nút lệnh là một phần nguyên của bất kỳ GUI nào Sử dụng button là cách dễ nhất để chặn các tác động của người dùng Để tạo một button, bạn làm theo các bước sau:

- Tạo phần tử button với một nhãn chỉ ra mục đích của button

- Bố trí phần tử này trên màn hình

- Hiển thị phần tử trên màn hình

Sử dụng một trong hai constructor sau để tạo các button trong Java:

Sử dụng setLabel() và getLabel() để thiết lập và nhận về nhãn của button

Ví dụ: tạo ra 3 button import java.awt.*; class Buttontest extends Frame

Button b3 = new Button(“Blue”); public Buttontest(String title) { super(title); setLayout(new FlowLayout()); add(b1); add(b2); add(b3);

} public static void main(String args[]) {

Buttontest t= new Buttontest(“Button”); t.setSize(300,200); t.show();

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

5.4.1.Tạo khung chứa cửa sổ chương trình Để tạo cửa sổ chính cho chương trình ứng dụng ta tiến hành các bước:

- Xác định kích thước của Frame

- Thể hiện Frame trên màn hình import java.awt.*; class FrameDemo2

{ public static void main(String args[])

// Tạo đối tượng khung chứaFrame

Frame fr = new Frame("My First Window") ;

// Xác định kích thước, vị trí của Frame fr.setBounds(0, 0, 640, 480);

// Hiển thị Frame fr.setVisible(true);

Kết quả thực thi chương trình:

5.4.2 Tạo hệ thống thực đơn Đối với thư viện AWT, để xây dựng hệ thống thực đơn cho chương trình ứng dụng chúng ta có thể dùng các lớp MenuBar, Menu, MenuItem, MenuShortcut

Ví dụ: Tạo hệ thống thực đơn cho chương trình Calculator import java.awt.*; import java.awt.event.*; class Calculator

{ public static void main(String[] args)

// Tao Frame ung dung final Frame fr = new Frame(); fr.setLayout(new BorderLayout());

Menu menuFile = new Menu("Edit");

MenuItem copyItem = new MenuItem("Copy Ctrl+C");

MenuItem pasteItem = new MenuItem("Paste Ctrl+V"); menuFile.add(copyItem); menuFile.add(pasteItem);

Menu menuHelp = new Menu("Help");

MenuItem hTopicItem = new MenuItem("Help Topics");

MenuItem hAboutItem = new MenuItem("About Calculator"); menuHelp.add(hTopicItem); menuHelp.addSeparator(); menuHelp.add(hAboutItem); menu.add(menuFile); menu.add(menuHelp);

Trang 101 fr.setMenuBar(menu); fr.setBounds(100, 100, 300, 200); fr.setTitle("Calculator");

//fr.setResizable(false); fr.setVisible(true);

// xử lý biến sự kiện đóng cửa số ứng dụng fr.addWindowListener( new WindowAdapter() { public void windowClosing(WindowEvent e) {

} } Kết quả thực thi chương trình:

5.4.3 Gắn Component vào khung chứa Để gắn một thành phần, một đối tƣợng component vào một cửa số (khung chứa) chúng ta dùng phương thức add của đối tượng khung chứa container

Ví dụ: import java.awt.*; class AddDemo

{ public static void main(String args[])

// Tạo đối tượng khung chứaFrame

Frame fr = new Frame("AddDemo App");

Button buttOk = new Button("OK");

// Gắn đối tượng nút nhấn vào khung chứa fr.add(buttOk);

// Xác định kích thước, vị trí của Frame fr.setSize(100, 100);

Kết quả thực thi chương trình:

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

Nhƣ chúng ta đã biết khung chứa container nhận các đối tƣợng từ bên ngoài đƣa vào và nó phải biết làm thế nào để tổ chức sắp xếp cho các đối tƣợng đó Mỗi đối tƣợng khung chứa đều có một bộ quản lý chịu trách nhiệm thực hiện công việc đấy đó là bộ quản lý trình bày (Layout Manager)

Interface LayoutManager định nghĩa giao tiếp cho những lớp biết đƣợc làm thế nào để trình bày những trong những containers

 FlowLayout public class FlowLayout extends Object implements LayoutManager, Serializable Đối với một container trình bày theo kiểu FlowLayout thì:

- Các component gắn vào đƣợc sắp xếp theo thứ tự từ trái sang phải và từ trên xuống dưới

- Các component có kích thước như mong muốn

- Nếu chiều rộng của Container không đủ chỗ cho các component thì chúng tự động tạo ra một dòng mới

- FlowLayout thường được dùng để để sắp xếp các button trong 1 panel

- Chúng ta có thể điều chỉnh khoảng cách giữa các component

Ví dụ 1: FlowLayoutDemo import java.awt.*; import java.lang.Integer; class FlowLayoutDemo

{ public static void main(String args[])

Frame fr = new Frame("FlowLayout Demo"); fr.setLayout(new FlowLayout()); fr.add(new Button("Red")); fr.add(new Button("Green")); fr.add(new Button("Blue"));

List li = new List(); for (int i=0; i Install New Software Add the following URL: "https://www.eclipse.org/windowbuilder/" Click "OK" and then "Next" to proceed with the installation.

Nếu chƣa cài đặt đƣợc thì vào trang: https//www.eclipse.org/windowbuilder/download.php tải về phiên bản WindowBuilder Pro đúng với phiên bản Eclipse đang đƣợc sử dụng và tiến hành cài đặt tay

Eclipse\ Help\ Install new Software\ nhấn nút Add\ nhấn nút Archive, chọn đường dẫn tới gói hỗ trợ cài đặt đã được tải về, OK

Ví dụ 1: Viết chương giải phương trình bậc 1

- Chọn File/New/Java Project, nhập tên dự án: GPTB1 Finish

- Nhấn chuột phải vào dự án, chọn New Other/ WindowBuilder/ Swing Designer/ Application Window, chọn next

- Nhập tên PTB1 vào mục Name, chọn Finish

- Chọn thẻ Design để thiết kế theo kiểu trực quan Màn hình giao diện trực quan sẽ xuất hiện

- Chọn Form đang thiết kế thiết lập thuộc tính

Variable: frmptb1, Title: Giải phương trình bậc 1

- Nhấn chuột phải vào Form đang thiết kế chọn Set layout/ Absolute layout

- Chọn đối tƣợng Jlabel, vẽ vào Form đang thiết kế, thiết lập thuộc tính

Text: Giải phương trình bậc 1 Font: Bold, size 16

- Tiếp tục tạo 3 đối tượng Jlabel, thiết lập thuộc tính text tương ứng là: Nhập a=; Nhập b=; Kết quả: (cũng thiết lập Font nhƣ trên)

- Tạo 3 đối tượng JtextField, đặt name tương ứng là: txta, txtb, txtkq

- Tạo 3 đối tƣợng Jbutton, thiết lập thuộc tính

Text: Giải; Làm lại; Thoát Name: btngiai; btnll; btnthoat

- Nhấn đôi chuột vào nút Giải nhập đoạn lệnh sau: btngiai.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent arg0) {

//Lấy giái trị nhập vào ở biến a và b

Trang 141 float a,b, kq; a=Float.parseFloat(txta.getText()); b=Float.parseFloat(txtb.getText());

{ if(b==0) txtkq.setText("Phương trình vô số nghiệm"); txtkq.setText("Phương trình vô nghiệm");

{ kq=-b/a; txtkq.setText("Phương trình có nghiệm

- Nhấn đôi chuột vào nút Làm lại nhập đoạn lệnh sau: btnll.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent arg0) { txta.setText(null); txtb.setText(null); txtkq.setText(null);

- Nhấn đôi chuột vào nút Thoát nhập đoạn lệnh sau:

JButton btnthoat = new JButton("Tho\u00E1t"); btnthoat.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent arg0) {

- Biên dịch và chạy chương trình

Lưu ý: Để tiến hành biên dịch chương trình sang tập tin thực thi (JAR, đây là file chạy trực tiếp chương trình được đóng gói) thực hiện theo cách sau:

+ Tại dự án trên, Menu File/ Export/ Java/ Runnable JAR file, chọn Next

+ Phần Launch configuration: chọn PTB1-GPTB1; phần Export destination chọn D:\PTB1, chọn Finish

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

Bài 1: Viết chương trình tạo một hộp lựa chọn trên ứng dụng đơn và trên Applet như sau:

Bài 2: Viết chương trình nhập vào hai ô văn bản, số lượng và giá bán và cho hiển thị kết quả:

Bài 3: Viết chương trình mô phỏng máy tính số học có giao diện như sau:

Bài 4: Tạo giao diện tính giai thừa N, với N đƣợc nhập bất kỳ Nhấn nút Tính để đƣa ra kết quả; Nút Làm lại để đƣa N và kết quả về rỗng; Nút thoát để đóng cửa sổ

Bài 5: Tạo giao diện tính tổng chẵn từ 1 đến N, với N đƣợc nhập từ bàn phím; Nhấn nút Tính để đƣa ra kết quả; Nút Làm lại để đƣa N và kết quả về rỗng; Nút thoát để đóng cửa sổ

Bài 6: Viết chương trình giao diện tính Chu vi – Diện tích hình chữ nhật (nhƣ hình) Yêu cầu nhập thông tin 2 cạnh a, b và đƣa ra kết quả tính

Chu vi, Diện tích của hình chữ nhật

Bài 7 Tạo giao diện giải phương trình bậc 2, với A, B, C đƣợc nhập từ bàn phím; Nhấn nút Giải để đƣa ra kết quả; Nút Làm lại để đƣa các thông số về rỗng; Nút Thoát để đóng cửa sổ

NHẬP XUẤT DỮ LIỆU

Tổng quát

Trong thực tế rất thường chúng ta phải thao tác với các tập tin và thư mục trong hệ thống Các thao tác này bao gồm: liệt kê danh sách tập tin, thƣ mục, thêm/ đổi tên, xóa thƣ mục, …Java cung cấp 2 class hỗ trợ những việc này:

Lớp java.io.File đại diện cho một tập tin (file) hoặc một thƣ mục (directory) của hệ thống, nó đƣợc đƣa vào Java từ phiên bản 1.0

Lớp java.io.File đại diện cho một tập tin hoặc một thƣ mục trong hệ thống, nó đại diện cho một đường dẫn (pathname)

Phiên bản 7.0, Java bổ xung thêm lớp java.nio.file.Files, việc bổ xung này làm đơn giản hóa việc thao tác với các tập tin và thư mục, tất cả các phương thức của class này đều là tĩnh và tự nhiên (static & nature) Khả năng tăng hiệu suất chương trình của NIO không chỉ phụ thuộc vào hệ điều hành mà còn phụ thuộc vào phiên bản JVM, hệ thống máy chủ, ổ cứng, hay thậm chí dữ liệu

Một hệ thống tập tin lưu trữ và tổ chức các tập tin trên một số loại phương tiện lưu trữ, thường là một hoặc nhiều ổ đĩa cứng, theo cách sao cho chúng có thể dễ dàng lấy ra

Hầu hết các hệ thống tập tin đƣợc sử dụng ngày hôm nay lưu trữ các tập tin trong một cây

(hoặc cấu trúc phân cấp) Ở đầu cây là một (hoặc nhiều hơn) các nút gốc Dưới nút gốc, có các tệp và thƣ mục (thƣ mục trong Microsoft Windows) Mỗi thƣ mục có thể chứa các tệp tin và các thƣ mục con, do đó có thể chứa các tệp và thƣ mục con, v.v … có khả năng lưu trữ một chiều sâu gần như vô hạn

Microsoft Windows hỗ trợ nhiều nút gốc

Mỗi nút gốc là một phân vùng như C:\ hoặc D:\,đại diện cho một phần của ổ đĩa cứng Hệ điều hành Solaris (Linux) sử dụng một nút gốc duy nhất, được biểu thị bằng ký tự dấu gạch chéo /.

Một tập tin được xác định bởi đường dẫn của nó thông qua hệ thống tập tin, bắt đầu từ nút gốc

Ví dụ, tập tin statusReport trong hình trên đƣợc mô tả bằng ký hiệu sau:

Trong Hệ điều hành Solaris: /home/user2/statusReport

Trong Microsoft Windows: C:\home\user2\statusReport

Ký tự đƣợc sử dụng để phân cách các tên thƣ mục cho hệ thống tập tin:

 Hệ điều hành Solaris sử dụng dấu gạch chéo (/)

 Microsoft Windows sử dụng dấu gạch chéo ngƣợc (\) Tuy nhiên, vẫn có thể sử dụng dấu gạch chéo (/) trên Microsoft Window

Chúng ta có thể lấy ký tự cách này bằng cách sử dụng thuộc tính seperator của lớp java.io.File nhƣ sau: File.separator

Thuộc tính seperator là một biến static, nó trả về dấu gạch chéo (/) nếu bạn sử dụng hệ điều hành Solaris hoặc trả về dấu gạch chéo ngƣợc (\) nếu bạn sử dụng hệ điều hành Window

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

Một đường dẫn tuyệt đối luôn chứa các phần tử gốc và danh sách thư mục đầy đủ cần thiết để định vị tệp tin Ví dụ, /home/user2/statusReport là một đường dẫn tuyệt đối Tất cả thông tin cần thiết để định vị tệp tin được chứa trong chuỗi đường dẫn

Một đường dẫn tương đối cần phải được kết hợp với một đường dẫn khác để truy cập một tập tin Ví dụ, user1/foo là một đường dẫn tương đối Nếu không có thêm thông tin, một chương trình không thể xác định chính xác vị trí thư mục user2/statusReport trong hệ thống tập tin

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

Lớp java.io.File đại diện cho một tập tin hoặc một thƣ mục trong hệ thống, nó đại diện cho một đường dẫn (path) Đường dẫn này có thể không thực sự tồn tại trên hệ thống Nếu tồn tại thì nó có thể là một thƣ mục (directory) hoặc là một tập tin (file)

Using the File object, we can represent a file path and check its existence We can also obtain basic information about the file, such as its last modified timestamp and its size For example, consider a file named timFile.txt located at D:\com\luuFile\timFile.txt.

// Tạo một đối tượng File đại diện cho một đường dẫn File file = new File("D:/com/luuFile/timFile.txt");

// Kiểm tra sự tồn tại

System.out.println("Path exists : " + file.exists()); if (file.exists()) {

// Kiểm tra có phải có phải là một folder hay không? System.out.println("isDirectory : "+ file.isDirectory());

// Kiểm tra có phải là một đường dẫn ẩn hay không? System.out.println("isHidden : " + file.isHidden()); // Lấy tên file/ folder

System.out.println("Simple Name: " + file.getName());

System.out.println("Absolute Path: "

// Kiểm tra kích thước file:

// Thời điểm sửa lần cuối, milliseconds long lastMofifyInMillis = file.lastModified();

Date lastModifyDate = new Date(lastMofifyInMillis); System.out.println("Last modify date:

Path exists : true isDirectory : false isHidden : false

Absolute Path: D:\com\luuFile\timFile.txt

Last modify date: Sat May 04 09:14:59 ICT 2019

6.1.4 Lấy đường dẫn đến thư mục đang làm việc import java.io.File; public class DuongDan { public static void main(String[] args) {

// Lấy thư mục hiện tại sử dụng getAbsolutePath()

System.out.println("Thu muc hien tai dang lam viec: " + currentDirectory);

// Lấy thư mục hiện tại sử dụng Property user.dir

String workingDir = System.getProperty("user.dir");

System.out.println("Thu muc hien tai dang lam viec: " + workingDir);

Thu muc hien tai dang lam viec:

Thu muc hien tai dang lam viec:

Lớp File cung cấp 2 phương thức để tạo môt thư mục:

 mkdir(): Tạo thư mục cho bởi đường dẫn nếu thư mục cha tồn tại

 mkdirs(): Tạo thư mục cho bởi đường dẫn, bao gồm cả các thư mục cha nếu nó không tồn tại import java.io.File; public class TaoThuMuc { public static void main(String[] args) {

File dir = new File("D:/com/luuFile/thumuc1");

System.out.println("Pathname: " + dir.getAbsolutePath());

System.out.println("Path exists: "+dir.exists());

System.out.println("Parent Path exists: " + dir.getParentFile().exists()); // false

//Với mkdir(),thư mục chỉ được tạo ra nếu thư mục cha tồn tại boolean created = dir.mkdir();

System.out.println("Directory created: " created);// false

File dir2 = new File("D:/com/luuFile/thumuc2");

System.out.println("Pathname: " + dir2.getAbsolutePath());

System.out.println("File exists: "+dir2.exists());// false

// Với mkdirs(), thư mục được tạo ra bao gồm cả các thư mục cha nếu nó không tồn tại created = dir2.mkdirs();

System.out.println("Directory created:

6.1.6 Tạo tập tin a Tạo file bằng phương thức File.createNewFile ()

Lớp java.io.File có thể dùng để tạo ra một file Để tạo đƣợc file ta thực hiện hai bước sau:

 Tạo một đối tƣợng File

Phương thức `createNewFile` sẽ trả về `true` nếu tệp được tạo thành công và `false` nếu tệp đã tồn tại Phương thức này cũng ném ngoại lệ `java.io.IOException` khi không thể tạo tệp Tệp được tạo ra sẽ rỗng và có kích thước bằng 0 byte.

Ví dụ : import java.io.*; public class TaoFile2 { public static void main(String[] args) throws IOException {

File file = null; boolean isCreat = false; try{ file = new File("D://test.txt");

//file được tạo trong ổ D isCreat = file.createNewFile(); if (isCreat)

System.out.print("Da tao file thanh cong!"); else

System.out.print("Tao file that bai");

Trang 149 b Tạo file bằng FileOutputStream

Nếu muốn tạo một file mới và đồng thời viết một số dữ liệu vào nó, ta có thể sử dụng FileOutputStream để ghi dữ liệu vào Dưới đây là một đoạn mã đơn giản để sử dụng

Ví dụ: import java.io.*; public class TaoFile3 { public static void main(String[] args) throws IOException {

String s = "Lap trinh java"; byte[] a = s.getBytes(); //ep kieu String ve mang byte try{ file = new FileOutputStream("D://output.txt"); file.write(a); //ghi mang byte vao file

System.out.print("Da ghi thanh cong!");

System.out.print(e);// In lỗi ra màn hình

} finally { file.close();//Nếu chương trình lỗi thì đóng file lại

Đọc và ghi dữ liệu với tập tin

Đọc và ghi file trong java là các hoạt động nhập/xuất dữ liệu (nhập dữ liệu từ bàn phím, đọc dữ liệu từ file, ghi dữ liệu lên màn hình, ghi ra file, ghi ra đĩa, ghi ra máy in…) đều đƣợc gọi là luồng (stream) a Các loại luồng dữ liệu

Có 2 kiểu luồng trong Java

- Hỗ trợ việc nhập xuất dữ liệu trên byte

- Thường được dùng khi đọc ghi dữ liệu nhị phân

- Luồng character (ký tự) đƣợc thiết kế hỗ trợ việc xuất nhập dữ liệu kiểu ký tự (Unicode)

- Dữ liệu dạng nhị phân - Dữ liệu dạng ký tự Unicode

 Kiến trúc luồng nhập dữ liệu (Input Stream)

 Kiến trúc luống xuất dữ liệu (Output Stream)

 Hai luồng quan trọng nhất là FileInputStream và FileOutputStream

Luồng này đƣợc sử dụng để đọc dữ liệu từ các file Các đối tƣợng có thể đƣợc tạo bởi sử dụng từ khóa new và có một số kiểu constructor có sẵn

Constructor sau đây nhận tên file nhƣ là một chuỗi để tạo một đối tƣợng Input

InputStream f = new FileInputStream("C:/java/hello");

Constructor sau nhận một đối tƣợng File để tạo một đối tƣợng Input Stream để đọc file Đầu tiên tạo một đối tượng file bởi sử dụng phương thức File() như sau:

File f = new File("D:/btjava/output");

Khi chúng ta có đối tƣợng InputStream, thì khi đó có một danh sách các phương thức có thể được sử dụng để đọc stream hoặc để thực hiện hoạt động nào khác trên stream này

STT Phương thức và Miêu tả

1 public void close() throws IOException{}

Phương thức này đóng output stream Giải phóng bất kỳ nguồn hệ thống nào liên kết với file Ném một IOException

2 protected void finalize()throws IOException {}

Phương thức này xóa sự kết nối tới File đó Bảo đảm rằng phương thức close của output stream này đƣợc gọi khi không có tham chiếu nào nữa tới stream này Ném một IOException

3 public int read(int r)throws IOException{}

Phương thức này đọc byte dữ liệu đã xác định từ InputStream Trả về một int Trả về byte dữ liệu tiếp theo và -1 sẽ đƣợc trả về nếu kết thúc file

4 public int read(byte[] r) throws IOException{}

Phương thức này đọc r byte từ input stream vào trong một mảng Trả về tổng số byte đã đọc Nếu kết thúc file, -1 đƣợc trả về

5 public int available() throws IOException{}

Cung cấp số byte mà đƣợc đọc từ input stream này Trả về một int

FileOutputStream đƣợc sử dụng để tạo một file và ghi dữ liệu vào trong nó Luồng này sẽ tạo một file, nếu nó đã không tồn tại, trước khi mở nó để ghi output Dưới đây là hai constructor mà có thể được sử dụng để tạo một đối tượng FileOutputStream trong Java

Constructor sau nhận một tên file nhƣ là một chuỗi để tạo một đối tƣợng input stream để ghi file

OutputStream f = new FileOutputStream("D:/btjava/hello")

Constructor sau nhận một đối tƣợng file để tạo một đối tƣợng output stream để ghi file

File f = new File("D:/btjava/hello");

Khi có đối tượng OutputStream, các phương thức sau có thể được sử dụng để ghi vào luồng hoặc thực hiện các hoạt động khác trên luồng này:

STT Phương thức và Miêu tả

1 public void close() throws IOException{}

Phương thức này đóng output stream Giải phóng bất kỳ nguồn hệ thống nào liên kết với file Ném một IOException

2 protected void finalize()throws IOException {}

Phương thức này xóa sự kết nối tới File đó Bảo đảm rằng phương thức close của output stream này đƣợc gọi khi không có tham chiếu nào nữa tới stream này Ném một IOException

3 public void write(int w)throws IOException{}

Phương thức này ghi byte đã xác định tới output stream

Ghi w byte từ mảng byte đã đề cập tới OutputStream b Các thao tác xử lý dữ liệu

 Bước 1: Tạo đối tượng luồng và liên kết với nguồn dữ liệu

 Bước 2: Thao tác dữ liệu (đọc hoặc ghi hoặc cả hai)

 Xử lý nhập xuất dữ liệu sử dụng luồng byte

Sử dụng luồng byte trong các trường hợp như nhập xuất kiểu dữ liệu nguyên thủy (nhƣ kiểu int, float, double, boolean), nhập xuất kiểu dữ liệu kiểu đối tƣợng (object) Đọc và ghi dữ liệu nhị phân (binary data)

Một số phương thức xử lý dữ liệu nhị phân của class DataInputStream

Một số phương thức xử lý dữ liệu nhị phân của class DataOutputStream

Data can be written to a file using DataOutputStream The file is opened for writing using FileOutputStream and a DataOutputStream is created for the file The writeInt method is used to write an integer to the file The file is closed when done.

//Bước 1: Tạo đối tượng luồng và liên kết nguồn dữ liệu

FileOutputStream fos = new FileOutputStream("d:/mydata.bin"); DataOutputStream dos = new DataOutputStream(fos);

//Bước 2: Ghi dữ liệu dos.writeInt(100); dos.writeDouble(9.5);

//Bước 3: Đóng luồng fos.close(); dos.close();

} catch (IOException ex) { ex.printStackTrace();

Ví dụ 2: Đọc dữ liệu chứa trong tập tin d:/mydata.bin với DataInputStream import java.io.DataInputStream; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException;

Trang 155 public class DocFile1 { public static void main(String[] args) throws IOException{ try {

//Bước 1: Tạo đối tượng luồng và liên kết nguồn dữ liệu FileInputStream fis = new FileInputStream("d:/mydata.bin"); DataInputStream dis = new DataInputStream(fis);

//Bước 2: Đọc dữ liệu int n = dis.readInt(); double m = dis.readDouble();

//Bước 3: Đóng luồng fis.close(); dis.close();

//Hiển thị nội dung đọc từ file

System.out.println("Số nguyên: " + n);

System.out.println("Số thực: " + m);

} catch (IOException ex) { ex.printStackTrace();

Utilizing two classes, FileInputStream and FileOutputStream, allows for the replication of an input file into an output file This process is demonstrated in the code snippet: import java.io.*; public class CopyFile1 { public static void main(String args[]) throws IOException

FileOutputStream out = null; try { in = new FileInputStream("d:/input.txt"); out = new FileOutputStream("d:/output.txt"); int c; while ((c = in.read()) != -1) { out.write(c);

}finally { if (in != null) { in.close();

} if (out != null) { out.close();

Ví dụ 4: Đọc và ghi dữ liệu kiểu object

Tạo lớp Stock và lớp này phải cài đặt giao diện Serializable import java.io.Serializable; public class Stock implements Serializable{ private int id; private String desc; private double price; private int quantity; public Stock(int id, String desc, double price, int quantity) { this.id = id; this.desc = desc; this.price = price; this.quantity = quantity;

@Override public String toString() { return id + "-" + desc + "-" + price + "-" + quantity;

Tạo lớp ObjectOutputExample dùng để ghi dữ liệu kiểu object import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectOutputStream; public class ObjectOutputExample { public static void main(String[] args) { try {

//Bước 1: Tạo đối tượng luồng và liên kết nguồn dữ liệu

FileOutputStream fos = new FileOutputStream("d:/mydata2.bin"); ObjectOutputStream oos = new ObjectOutputStream(fos);

Stock s[] = { new Stock(1, "CD ROM", 100, 2)

//Bước 2: Ghi mảng đối tượng vào file oos.writeObject(s);

//Bước 3: Đóng luồng fos.close(); oos.close();

System.out.println("Loi ghi file: "+ex);

Tạo lớp ObjectInputExample dùng để đọc dữ liệu kiểu object import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.ObjectInputStream; public class ObjectInputExample { public static void main(String[] args) { try {

//Bước 1: Tạo đối tượng luồng và liên kết nguồn dữ liệu FileInputStream fis = new

ObjectInputStream ois = new ObjectInputStream(fis);

Stock sArr[] = (Stock[]) ois.readObject(); for(Stock s : sArr){

//Bước 3: Đóng luồng fis.close(); ois.close();

System.out.println("Loi doc file: "+ex);

 Xử lý nhập xuất dữ liệu bằng luồng character

Các ví dụ ứng dụng

Sử dụng DataInputStream và DataOutputStream

Lớp DataInputStream trong java cho phép một ứng dụng đọc dữ liệu nguyên thủy từ luồng đầu vào một cách độc lập với máy Ứng dụng Java thường sử dụng DataOutputStream để ghi dữ liệu mà sau này có thể đƣợc đọc bởi một DataInputStream

Lớp DataOutputStream trong java cho phép một ứng dụng ghi các kiểu dữ liệu Java nguyên thủy đến output stream một cách độc lập với máy Ứng dụng Java thường sử dụng DataOutputStream để ghi dữ liệu mà sau này có thể đƣợc đọc bởi một DataInputStream

Bài 1 Ghi file sử dụng DataOutputStream import java.io.DataOutputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStream; public class DataOutputStreamExa { public static void main(String[] args) throws IOException { int id = 1;

DataOutputStream data = new DataOutputStream(file); data.writeInt(id); data.writeUTF(name);

Trang 160 data.flush(); data.close();

Bài 2 Đọc file sử dụng DataInputStream import java.io.DataInputStream; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; public class DataInputStreamExa { public static void main(String[] args) throws IOException {

DataInputStream inst = new DataInputStream(input); int id = inst.readInt();

System.out.println("Id: " + id + ", Name: " + name); inst.close();

Bài 3 Đọc 5 dòng đã cho trong một text.txt và biến đổi các dòng này thành các chữ hoa và cuối cùng sao chép chúng vào trong test1.txt import java.io.*; public class Bai3{ public static void main(String args[])throws IOException{

DataOutputStream out = new DataOutputStream(new

String count; while((count = d.readLine()) != null){

System.out.println(u); out.writeBytes(u + " ,");

Câu hỏi và bài tập https://vietjack.com/java_jdbc/ket_noi_jdbc_voi_mysql.jsp

Bài thực hành số 1: Tạo lớp NhanVien có các thuộc tính mã nhân viên, họ tên, tuổi và lương

 Viết setter, getter, constructor và toString

 Viết phương thức cho phép nhập thông tin cho 3 nhân viên từ bàn phím Sử dụng FileWriter để ghi thông tin vào nhanvien.txt

 Viết phương thức để đọc nội dung file nhanvien.txt và in những gì đọc được từ file ra màn hình

Bài thực hành số 2: Tạo lớp mới và thực hiện các xử lý sau

 Viết phương thức tạo mảng 3 nhân viên, nhập thông tin cho các nhân viên, sử dụng ObjectOutputStream để ghi mảng đối tƣợng nhân viên vào file nhanvien.bin

 Viết phương thức để đọc file nhanvien.bin và in mảng nhân viên ra màn hình

LẬP TRÌNH CƠ SỞ DỮ LIỆU

Giới thiệu

JDBC (Java Database Connectivity) là một API tiêu chuẩn dùng để tương tác với các loại cơ sở dữ liệu quan hệ JDBC có một tập hợp các class và các Interface dùng cho ứng dụng Java có thể nói chuyện với các cơ sở dữ liệu.

Kiến trúc JDBC

JDBC cung cấp cho chúng ta một cái nhìn tổng quát về kết nối database, thực thi câu lệnh SQL và xử lý kết quả trả về Nó bao gồm nhiều interface và mỗi interface sẽ đảm nhận một vai trò khác nhau

Có bốn interfaces chính của JDBC nằm trong package java.sql đó là: Driver, Connection, Statement, ResultSet Các loại database khác nhau nhƣ MySQL, Oracle, … sẽ dựa vào những interface này để hiện thực các đối tƣợng cho phù hợp với loại database đó Tập hợp các đối tƣợng hiện thực này chúng ta gọi chúng là những JDBC Driver Mỗi database sẽ cung cấp JDBC Driver khác nhau và đƣợc đóng gói thành những tập tin jar

Các thành phần của JDBC Api về cơ bản bao gồm:

1 DriverManager: o Là một class, nó dùng để quản lý danh sách các Driver (database drivers)

2 Driver : o Là một Interface, nó dùng để liên kết các liên lạc với cơ sở dữ liệu, điều khiển các liên lạc với database Một khi Driver đƣợc tải lên, lập trình viên không cần phải gọi nó một cách cụ thể

3 Connection : o Là một Interface với tất cả các method cho việc liên lạc với database Nó mô tả nội dung liên lạc, tất cả các thông tin liên lạc với cơ sở dữ liệu là thông qua chỉ có đối tƣợng Connection

4 Statement : o Là một Interface, gói gọn một câu lệnh SQL gửi tới cơ sở dữ liệu đƣợc phân tích, tổng hợp, lập kế hoạch và thực hiện

5 ResultSet : o ResultSet đại diện cho tập hợp các bản ghi lấy để thực hiện truy vấn.

Các khái niệm cơ bản

Trình điều khiển JDBC là thành phần phần mềm cho phép ứng dụng Java tương tác với cơ sở dữ liệu, bao gồm chức năng chuyển đổi kiểu dữ liệu Java sang kiểu dữ liệu tương ứng trước khi gửi giá trị đến Database.

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

Java sử dụng JDBC để làm việc với các cơ sở dữ liệu

Ví dụ làm việc với cơ sở dữ liệu Oracle từ Java cần phải có Driver (Đó là class điều khiển việc kết nối với loại cơ sở dữ liệu bạn muốn) Trong JDBC API chúng ta có java.sql.Driver , nó chỉ là một interface, và nó có sẵn trong JDK Nhƣ vậy phải download thƣ viện Driver ứng với loại Database mà chúng ta mong muốn

 Chẳng hạn với Oracle thì class thi hành Interface java.sql.Driver đó là: oracle.jdbc.driver.OracleDriver java.sql.DriverManager là một class trong JDBC API Nó làm nhiệm vụ quản lý các Driver

Xem hình minh họa dưới đây:

Chúng ta có 2 cách để làm việc với một loại cơ sở dữ liệu cụ thể nào đó

 Cách 1: Cung cấp thƣ viện Driver điều khiển loại cơ sở dữ liệu đó, đây là cách trực tiếp Nếu dùng DB oracle (hoặc DB khác) ta phải download thƣ viện dành cho loại DB này

 Cách 2: Khai báo một "ODBC DataSource" , và sử dụng cầu nối JDBC-

ODBC để kết nối với "ODBC DataSource" kia Cầu nối JDBC-ODBC là thứ có sẵn trong JDBC API

Câu hỏi của chúng ta là "ODBC DataSource" là cái gì?

ODBC - Open Database Connectivity: Nó chính là một bộ thƣ viện mở, có khả năng kết nối với hầu hết các loại cơ sở dữ liệu khác nhau, và nó miễn phí Đƣợc cung cấp bởi Microsoft

ODBC DataSource: Trên hệ điều hành Window bạn có thể khai báo một kết nối

ODBC tới một loại DB nào đó Và nhƣ vậy chúng ta có một nguồn dữ liệu (Data Source) Trong JDBC API, đã xây dựng sẵn một cầu nối JDBC-ODBC để JDBC có thể nói chuyện đƣợc với ODBC Data Source

Trong trường hợp nếu không muốn sử dụng JDBC-ODBC, chúng ta có thể sử dụng cách trực tiếp kết nối vào Database, trong trường hợp đó cần phải download Driver ứng với mỗi loại DB này Tại đây có hướng dẫn download một loại Driver cho các Database thông dụng:

Kết quả ta có vài file nhƣ sau:

Oracle có file ojdbc6.jar

MySQL có file mysql-connector-java-5.1.18-bin.jar

SQLServer có file jtds-1.3.1.jar hoặc sqljdbc4.jar

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

Tạo project để bắt đầu với JDBC

Tạo thƣ mục libs trên project và copy các thƣ viện kết nối trực tiếp các loại database Oracle, MySQL, SQLServer mà ta vừa download đƣợc ở trên vào Ta có thể copy hết hoặc một trong các thƣ viện đó, theo loại DB đƣợc sử dụng

Nhấn phải vào Project chọn Properties:

Thực hiện kết nối vào 3 loại database: MySQL, SQLServer, Oracle

Chúng ta tạo class ConnectionUtils để lấy ra đối tƣợng Connection kết nối với

Trang 173 Chúng ta có thể thay đổi Class ConnectionUtils để sử dụng kết nối tới một Database nào đó quen thuộc Và chạy class này để test kết nối

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

JDBC Driver chuyển đổi kiểu dữ liệu của Java thành kiểu dữ liệu của JDBC tương ứng trước khi gửi giá trị dữ liệu tới Database Ví dụ, một double trong Java được chuyển đổi thành một SQL DOUBLE

Bảng dưới đây tổng kết các kiểu dữ liệu mặc định của JDBC mà kiểu dữ liệu Java được chuyển đổi thành, khi bạn gọi phương thức setXXX() của các đối tượng PreparedStatement hoặc CallableStatement hoặc phương thức ResultSet.updateXXX()

SQL JDBC/Java setXXX updateXXX

VARCHAR java.lang.String setString updateString

CHAR java.lang.String setString updateString

LONGVARCHAR java.lang.String setString updateString

NUMERIC java.math.BigDecimal setBigDecimal updateBigDecimal

DATE java.sql.Date setDate updateDate

TIME java.sql.Time setTime updateTime

TIMESTAMP java.sql.Timestamp setTimestamp updateTimestamp

CLOB java.sql.Clob setClob updateClob

BLOB java.sql.Blob setBlob updateBlob

ARRAY java.sql.Array setARRAY updateARRAY

REF java.sql.Ref SetRef updateRef

STRUCT java.sql.Struct SetStruct updateStruct

JDBC 3.0 đã bổ sung hỗ trợ tới kiểu dữ liệu BLOB, CLOB, ARRAY, và REF Tương ứng, đối tượng ResultSet cũng có các phương thức là updateBLOB(), updateCLOB(), updateArray() và updateRef() Đối tượng ResultSet cũng cung cấp phương thức getXXX() tương ứng cho mỗi kiểu dữ liệu để lấy giá trị của các cột Mỗi phương thức có thể được sử dụng với tham số là tên cột hoặc chỉ mục cột

SQL JDBC/Java setXXX getXXX

VARCHAR java.lang.String setString getString

CHAR java.lang.String setString getString

LONGVARCHAR java.lang.String setString getString

NUMERIC java.math.BigDecimal setBigDecimal getBigDecimal

DATE java.sql.Date setDate getDate

TIME java.sql.Time setTime getTime

TIMESTAMP java.sql.Timestamp setTimestamp getTimestamp

CLOB java.sql.Clob setClob getClob

BLOB java.sql.Blob setBlob getBlob

ARRAY java.sql.Array setARRAY getARRAY

REF java.sql.Ref SetRef getRef

STRUCT java.sql.Struct SetStruct getStruct

Ví dụ: Kiểu dữ liệu Date và Time trong JDBC

Lớp java.sql.Date ánh xạ với kiểu dữ liệu DATE trong SQL, trong khi lớp java.sql.Time và java.sql.Timestamp tương ứng với các kiểu dữ liệu TIME và TIMESTAMP trong SQL.

Dưới đây là ví dụ minh họa cách các lớp Date và Time định dạng các giá trị date và time trong Java để kết nối với kiểu dữ liệu tương ứng trong SQL import java.sql.Date; import java.sql.Time; import java.sql.Timestamp; import java.util.*; public class ViDuJDBC { public static void main(String[] args) {

// Lay date va time chuan java.util.Date javaDate = new java.util.Date(); long javaTime = javaDate.getTime();

System.out.println("Java Date la:" + javaDate.toString());

//Lay va hien thi SQL DATE java.sql.Date sqlDate = new java.sql.Date(javaTime);

System.out.println("SQL DATE la: " +

//Lay va hien ti SQL TIME java.sql.Time sqlTime = new java.sql.Time(javaTime);

System.out.println("SQL TIME la: " + sqlTime.toString());

//Lay va hien thi SQL TIMESTAMP java.sql.Timestamp sqlTimestamp = new java.sql.Timestamp(javaTime);

System.out.println("SQL TIMESTAMP la: " + sqlTimestamp.toString());

Sao chép và dán ví dụ trên trong ViDuJDBC.java, sau đó biên dịch và chạy chương trình Java trên sẽ cho kết quả:

* Xử lý giá trị NULL trong JDBC

Sử dụng giá trị NULL trong Java và sử dụng giá trị NULL trong SQL là hai khái niệm khác biệt Do đó, để xử lý các giá trị SQL NULL trong Java, bạn có thể theo 3 cách:

1 Tránh sử dụng phương thức getXXX() mà trả về kiểu dữ liệu gốc

2 Sử dụng các lớp Wrapper cho các kiểu dữ liệu gốc, và sử dụng phương thức wasNull() của đối tƣợng ResultSet để kiểm tra xem biến lớp wrapper mà nhận giá trị đƣợc trả về bởi phương thức getXXX() có nên được thiết lập là Null không

3 Sử dụng kiểu dữ liệu gốc và phương thức wasNull() của đối tượng ResultSet để kiểm tra xem biến gốc mà nhận giá trị được trả về bởi phương thức getXXX() có nên được thiết lập tới một giá trị có thể chấp nhận mà bạn đã chọn để biểu diễn một NULL không Bạn theo dõi ví dụ sau để xem cách xử lý giá trị NULL:

String sql = "SELECT mssv, ho, ten, diemthi FROM sinhvienk60";

ResultSet rs = stmt.executeQuery(sql); int id = rs.getInt(1);

Trang 178 if( rs.wasNull( ) ) { id = 0;

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

Nếu nhƣ Java là ngôn ngữ lập trình thì MySQL là hệ quản trị cơ sở dữ liệu Những ví dụ sau đây sẽ hướng dẫn kết nối java với mysql, trình bày các bước cần thực hiện để truy xuất dữ liệu đƣợc chứa trên MySQL và hiển thị lên Table trong Java

Trong hầu hết các ứng dụng thì việc kết nối cơ sở dữ liệu là cần thiết Chẳng hạn ứng dụng quản lý kinh doanh, thông tin về khách hàng, thông tin về mặc hàng, …sẽ đƣợc lưu trữ trong database

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

Cài đặt MySQL Chúng ta có thể cài XAMPP hoặc tải và cài MySQL riêng Trong bài viết này, tôi sử dụng MySQL đƣợc cài trong XAMPP

Tạo một database tên mysql_db gồm một table là DEPT và thêm dữ liệu vào cho bảng DEPT

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

Bước 1 Khởi động XAMPP Control Panel -> chọn Admin

Trong http://localhost/phpmyadmin -> chọn New

Nhập tên database và chọn Create

Chọn SQL để nhập câu lệnh tạo bảng và câu lệnh thêm dữ liệu

Tạo bảng DEPT gồm 3 cột là DeptNo, DeptName và Loc

Câu lệnh tạo bảng DEPT create TABLE DEPT

Nhập câu lệnh tạo bảng DEPT và chọn Go

Thêm dữ liệu cho bảng DEPT

Câu lệnh thêm dữ liệu

INSERT INTO DEPT VALUES ('10', 'ACCOUNTING', 'NEW YORK')

INSERT INTO DEPT VALUES ('20', 'RESEARCH', 'DALLAS')

INSERT INTO DEPT VALUES ('30', 'SALES', 'CHICAGO')

INSERT INTO DEPT VALUES ('40', 'OPERATIONS', 'BOSTON')

Nhập câu lệnh thêm dữ liệu và chọn Go

7.6.3 Hướng dẫn kết nối java với mysql – Tạo ứng dụng

Bước 1 Khởi động Netbeans -> File -> New Project …

Chọn Java -> Java Application -> Next -> nhập tên project -> Finish

Bước 2 Chuột phải package -> chọn New -> chọn JFrame Form…

Bước 3: Nhập tên lớp (Class Name) -> chọn Finish

Bước 4 Thiết kế giao diện ứng dụng gồm 1 button là Display và 1 Table dùng để hiển thị thông tin

Bước 5 Tải JDBC Driver cho MySQL và thêm vào project

Trang 184 Để thêm vào project bạn chuột phải Libraries -> chọn Add JAR/Folder…

Chọn tập tin jar -> chọn Open

Bước 6: Viết xử lý cho nút Display

* Khai báo TableModel private String header[] = {"Department No", "Department name", "Location"};

Trang 185 private DefaultTableModel tblModel = new

* Đăng ký sự kiện (Chuột phải Display -> chọn Events -> chọn Action -

Viết code để truy vấn dữ liệu từ bảng DEPT và hiển thị lên table

String dbURL = "jdbc:mysql://localhost/mysql_db";

String password = ""; conn = DriverManager.getConnection(dbURL, username, password); if (conn != null) {

System.out.println("Kết nối thành công");

// Câu lệnh xem dữ liệu

String sql = "select * from DEPT ";

// Tạo đối tượng thực thi câu lệnh Select st = conn.createStatement();

// Thực thi rs = st.executeQuery(sql);

Vector data = null; tblModel.setRowCount(0);

// Nếu sách không tồn tại if (rs.isBeforeFirst() == false) {

JOptionPane.showMessageDialog(this, "Chưa có thông tin phòng ban!"); return;

// Trong khi chưa hết dữ liệu

Trang 186 while (rs.next()) { data = new Vector(); data.add(rs.getInt("DeptNo")); data.add(rs.getString("DeptName")); data.add(rs.getString("LOC"));

// Thêm một dòng vào table model tblModel.addRow(data);

} jTable1.setModel(tblModel); // Thêm dữ liệu vào table } catch (Exception e) { e.printStackTrace();