Đề cương bài giảng Java

249 trang phuongnguyen 5290

Download

Bạn đang xem 20 trang mẫu của tài liệu "Đề cương bài giảng Java", để tải tài liệu gốc về máy bạn click vào nút DOWNLOAD ở trên

Tài liệu đính kèm:

de_cuong_bai_giang_java.pdf

Nội dung text: Đề cương bài giảng Java

Tr•êng ®¹i häc s• ph¹m kü thuËt h•ng yªn khoa c«ng nghÖ th«ng tin ooo §Ò c•¬ng bµi gi¶ng Java Nhóm biên soҥn: 1. Hoàng Trӑng ThӃ 2. NguyӉn Duy Tân Trang 1
0ӨC LӨC Chѭѫng 1: CÁC KHÁI NIӊM CѪ BҦN 5 BÀI 1. LÀM QUEN VӞI JAVA 5 I. Lӏch sӱ java 5 II. Java em là ai 5 II. Mӝt sӕÿһc trѭng cӫa java 5 III. Các kiӇu ӭng dөng Java 7 IV. Máy ҧo Java (JVM-Java Virtual Machine) 7 BÀI 2 NӄN TҦNG CӪA JAVA 9 I. Tұp ký tӵ dùng trong java 9 II. Tӯ khoá cӫa Java 9 III. Ĉӏnh danh (tên) 10 IV. Cҩu trúc mӝt chѭѫng trình java 10 V. Chѭѫng trình JAVA ÿҫu tiên 12 VI. Chú thích trong chѭѫng trình 14 VII. KiӇu dӳ liӋu 15 VII. Mӝt sӕ phép toán trên kiӇu dӳ liӋu nguyên thuӹ 17 IX. Toán tӱ chuyӇn kiӇu 23 X. Các hàm toán hӑc 24 XI. Các phép toán trên kiӇu kí tӵ 26 BÀI 3. ĈIӄU KHIӆN LUӖNG CHѬѪNG TRÌNH 27 I. Cҩu trúc rӁ nhánh 27 II. Cҩu trúc lһp while và do-while 30 III. Cҩu trúc for 32 IV. LӋnh break và continue 34 Chѭѫng 2: LҰP TRÌNH HѬӞNG ĈӔI TѬӦNG 37 BÀI 1. ĈӎNH NGHƬA LӞP 38 I. Khai báo lӟp 38 II. Chi tiӃt vӅ khai báo mӝt phѭѫng thӭc 40 III. Tӯ khoá this 43 IV. Tӯ khoá super 43 V. Sӱ dөng lӟp 44 VI. ĈiӅu khiӇn viӋc truy cұp ÿӃn các thành viên cӫa mӝt lӟp 44 BÀI 2. KHӢI ĈҪU VÀ DӐN DҼP 47 I. Phѭѫng thӭc tҥo dӵng (constructor) 47 II. Khӕi khӣi ÿҫu vô danh và khӕi khӣi ÿҫu tƭnh 49 III. Dӑn dҽp: kӃt thúc và thu rác 51 BÀI 3. CÁC THÀNH PHҪN TƬNH 52 I. Thuӝc tính tƭnh 52 II. Phѭѫng thӭc tƭnh 52 BÀI 4. NҤP CHӖNG PHѬѪNG THӬC 53 I. Khái niӋm vӅ phѭѫng thӭc bӝi tҧi 53 Trang 2
II. Yêu cҫu cӫa các phѭѫng thӭc bӝi tҧi 53 BÀI 5. Kӂ THӮA (INHERITANCE) 54 I. Lӟp cѫ sӣ và lӟp dүn xuҩt 54 II. Cách xây dӵng lӟp dүn xuҩt 54 III. Thӯa kӃ các thuӝc tính 54 IV. Thӯa kӃ phѭѫng thӭc 54 V. Khӣi ÿҫu lӟp cѫ sӣ 54 VI. Ghi ÿè phѭѫng thӭc ( Override ) 56 VI. Thành phҫn protected 56 VII. Tӯ khoá final 56 BÀI 6. LӞP CѪ SӢ TRӮU TѬӦNG 61 BÀI 7. ĈA HÌNH THÁI 62 BÀI 8. GIAO DIӊN, LӞP TRONG, GÓI 63 I. Giao diӋn 63 II. Lӟp trong 65 Bài 9. MҦNG, XÂU KÝ TӴ, TҰP HӦP 67 I. Mҧng 67 II. Xâu ký tӵ 70 III. Lӟp StringTokenizer 75 IV. Mӝt sӕ lӟp cѫ bҧn cӫa Java 77 V. Các lӟp tұp hӧp 83 Chѭѫng 3: XӰ LÝ NGOҤI Lӊ 92 I. Mөc ÿích cӫa viӋc xӱ lý ngoҥi lӋ 92 II. Mô hình sӱ lý ngoҥi lӋ cӫa java 92 III. Ĉһc tҧ ngoҥi lӋ 93 III. Ném ra ngoҥi lӋ 93 IV. Bҳt ngoҥi lӋ 93 V. Khӕi ‘finally’ 95 VI. Mӝt sӕ lӟp ngoҥi lӋ chuҭn cӫa Java 96 Chѭѫng 4: LҰP TRÌNH ĈA TUYӂN 97 I. Các kiӃn thӭc liên quan 97 II. Lұp trình ÿa tuyӃn trong Java 98 Chѭѫng 5: NHҰP XUҨT (Input/Output) 104 I. Lӟp luӗng 105 II. Lӟp File 113 Chѭѫng 6: LҰP TRÌNH ĈӖ HOҤ AWT 120 I. Giӟi thiӋu vӅ hӋ thӕng ÿӗ hoҥ cӫa Java 120 II. Trình quҧn lý hiӇn thӏ trong Java 124 III. Xӱ lý sӵ kiӋn trong Java 125 Chѭѫng 7 LҰP TRÌNH CѪ SӢ DӲ LIӊU 143 I. Tәng quan 143 II. Các kӇu trình ÿiӅu khiӇn JDBC 143 Trang 3
III. Các lӟp trong JDBC API dùng ÿӇ truy cұp CSDL 146 IV. KӃt nӕi CSDL vӟi JDBC 147 V. Tѭѫng tác vӟi CSDL 152 VI. Quҧn lý giao dӏch 160 Chѭѫng 8: LҰP TRÌNH SOCKET 164 I. Các kiӃn thӭc liên quan 164 II. Khҧo sát mӝt sӕ lӟp trong gói java.net 164 2. Lӟp URL và URI 171 3. Lӟp Socket 176 4. Lӟp ServerSocket 182 5. Lӟp DatagramSocket 185 6. Lӟp DatagramPacket 185 III. TCP Socket 185 Chѭѫng 9: JAVA MAIL 205 I. Các khái niӋm MAIL 205 II. Gӱi mail vӟi thѭ viӋn có sҹn cӫa java 206 III. Giӟi thiӋu java mail API 207 III. Gӱi mail 212 IV. Nhұn mail 215 V. Xoá mail 221 Chѭѫng 10: LҰP TRÌNH PHÂN TÁN VӞI 222 JAVA RMI ( REMOTE METHOD INVOKE) 222 I. RMI và lұp trình phân tán ÿӕi tѭӧng 222 II. Gӑi phѭѫng thӭc tӯ xa và các vҩn ÿӅ phát sinh 223 III. Vai trò cӫa các lӟp trung gian 223 IV. Cài ÿһt ÿӕi tѭӧng phân tán 224 Chѭѫng 11: JAVA JSP (JAVA SERVLET) 233 Chѭѫng 12: EJB (ENTERPRISE JAVA BEANS) 234 I. Tәng quan vӅ JavaBean 234 II. Xây dӵng thành phҫn JavaBean 234 III. Tìm hiӇu Instrospector 247 IV. Ĉóng gói JavaBean 249 Trang 4
Chѭѫng 1: CÁC KHÁI NIӊM CѪ BҦN BÀI 1. LÀM QUEN VӞI JAVA I. Lӏch sӱ java Java là mӝt ngôn ngӳ lұp trình ÿѭӧc Sun Microsystems giӟi thiӋu vào tháng 6 năm 1995. Tӯÿó, nó ÿã trӣ thành mӝt công cө lұp trình cӫa các lұp trình viên chuyên nghiӋp. Java ÿѭӧc xây dӵng trên nӅn tҧng cӫa C và C++. Do vұy nó sӱ dөng các cú pháp cӫa C và các ÿһc trѭng hѭӟng ÿӕi tѭӧng cӫa C++. Ban ÿҫu Java ÿѭӧc thiӃt kӃÿӇ làm ngôn ngӳ viӃt chѭѫng trình cho các sҧn phҭm ÿiӋn tӱ dân dөng nhѭÿҫu video, tivi, ÿLӋn thoҥi, máy nhҳn tin . Tuy nhiên vӟi sӵ mãnh mӁ cӫa Java ÿã khiӃn nó nәi tiӃng ÿӃn mӭc vѭӧt ra ngoài sӵ tѭӣng tѭӧng cӫa các nhà thiӃt kӃ ra nó. Java khӣi thuӹ tên là Oak- là cây sӗi mӑc ӣ phía sau văn phòng cӫa nhà thiӃt kӃ chính ông Jame Gosling, sau này ông thҩy rҵng ÿã có ngôn ngӳ lұp trình tên Oak rӗi, do vұy nhóm thiӃt kӃ quyӃt ÿӏnh ÿәi tên, “Java” là cái tên ÿѭӧc chӑn, Java là tên cӫa mӝt quán cafe mà nhóm thiӃt kӃ java hay ÿӃn ÿó uӕng. II. Java em là ai Java là ngôn ngӳ lұp trình hѭӟng ÿӕi tѭӧng, do vұy không thӇ dùng Java ÿӇ viӃt mӝt chѭѫng trình hѭӟng chӭc năng. Java có thӇ giҧi quyӃt hҫu hӃt các công viӋc mà các ngôn ngӳ khác có thӇ làm ÿѭӧc. Java là ngôn ngӳ vӯa biên dӏch vӯa thông dӏch. Ĉҫu tiên mã nguӗn ÿѭӧc biên dӏch bҵng công cө JAVAC ÿӇ chuyӇn thành dҥng ByteCode. Sau ÿó ÿѭӧc thӵc thi trên tӯng loҥi máy cө thӇ nhӡ chѭѫng trình thông dӏch JAVA. Mөc tiêu cӫa các nhà thiӃt kӃ Java là cho phép ngѭӡi lұp trình viӃt chѭѫng trình mӝt lҫn nhѭng có thӇ chҥy trên bҩt cӭ phҫn cӭng cө thӇ, thӃ nên khҭu hiӋu cӫa các nhà thiӃt kӃ Java là “Write One, Run Any Where”. Ngày nay, Java ÿѭӧc sӱ dөng rӝng rãi ÿӇ viӃt chѭѫng trình chҥy trên Internet. Nó là ngôn ngӳ lұp trình hѭӟng ÿӕi tѭӧng ÿӝc lұp thiӃt bӏ, không phө thuӝc vào hӋÿLӅu hành. Java không chӍ dùng ÿӇ viӃt các ӭng dөng chҥy ÿѫn lҿ hay trong mҥng mà còn ÿӇ xây dӵng các trình ÿiӅu khiӇn thiӃt bӏ cho ÿLӋn thoҥi di ÿӝng, PDA, II. Mӝt sӕÿһc trѭng cӫa java 1Ĉ˯n gi̫n Nhӳng ngѭӡi thiӃt kӃ mong muӕn phát triӇn mӝt ngôn ngӳ dӉ hӑc và quen thuӝc vӟi ÿa sӕ ngѭӡi lұp trình. Java tӵa nhѭ C++, nhѭng ÿã lѭӧc bӓÿi các ÿһc trѭng phӭc tҥp, không cҫn thiӃt cӫa C và C++ nhѭ: thao tác con trӓ, thao tác ÿӏnh nghƭa chӗng toán tӱ (operator overloading), Java không sӱ dөng lӋnh “goto” cǊng nhѭ file header (.h). Cҩu trúc “struct” và “union” cǊng ÿѭӧc loҥi bӓ khӓi Java. Nên có ngѭӡi bҧo Java là “C++ “, ngө ý bҧo java là C++ nhѭng ÿã bӓÿi nhӳng thӭ phӭc tҥp, không cҫn thiӃt. 2. H˱ͣng ÿ͙i t˱ͫng Có thӇ nói java là ngôn ngӳ lұp trình hoàn toàn hѭӟng ÿӕi tѭӧng, tҩt cҧc trong java ÿӅu là sӵ vұt, ÿâu ÿâu cǊng là sӵ vұt. 3. Ĉ͡c l̵p vͣi h͏ n͉n Mөc tiêu chính cӫa các nhà thiӃt kӃ java là ÿӝc lұp vӟi hӋ nӅn hay còn gӑi là ÿӝc lұp phҫn cӭng và hӋÿLӅu hành. Ĉây là khҧ năng mӝt chѭѫng trình ÿѭӧc viӃt tҥi mӝt máy nhѭng có thӇ chҥy ÿѭӧc bҩt kǤÿâu Trang 5
Tính ÿӝc lұp vӟi phҫn cӭng ÿѭӧc hiӇu theo nghƭa mӝt chѭѫng trình Java nӃu chҥy ÿúng trên phҫn cӭng cӫa mӝt hӑ máy nào ÿó thì nó cǊng chҥy ÿúng trên tҩt cҧ các hӑ máy khác. Mӝt chѭѫng trình chӍ chҥy ÿúng trên mӝt sӕ hӑ máy cө thӇÿѭӧc gӑi là phө thuӝc vào phҫn cӭng. Tính ÿӝc lұp vӟi hӋÿLӅu hành ÿѭӧc hiӇu theo nghƭa mӝt chѭѫng trình Java có thӇ chҥy ÿѭӧc trên tҩt cҧ các hӋÿLӅu hành. Mӝt chѭѫng trình chӍ chҥy ÿѭӧc trên mӝt sӕ hӋ ÿiӅu hành ÿѭӧc gӑi là phө thuӝc vào hӋÿLӅu hành. Các chѭѫng trình viӃt bҵng java có thӇ chҥy trên hҫu hӃt các hӋ nӅn mà không cҫn phҧi thay ÿәi gì, ÿiӅu này ÿã ÿѭӧc nhӳng ngѭӡi lұp trình ÿһt cho nó mӝt khҭu hiӋu µvi͇t m͡t l̯n, ch̩y m͕i n˯L¶, ÿiӅu này là không thӇ có vӟi các ngôn ngӳ lұp trình khác. Ĉӕi vӟi các chѭѫng trình viӃt bҵng C, C++ hoһc mӝt ngôn ngӳ nào khác, trình biên dӏch sӁ chuyӇn tұp lӋnh thành mã máy (machine code), hay lӋnh cӫa bӝ vi xӱ lý. Nhӳng lӋnh này phө thuӝc vào CPU hiӋn tҥi trên máy bҥn. Nên khi muӕn chҥy trên loҥi CPU khác, chúng ta phҧi biên dӏch lҥi chѭѫng trình. 4. M̩nh mͅ Java là ngôn ngӳ yêu cҫu chһt chӁ vӅ kiӇu dӳ liӋu, viӋc ép kiӇu tӵÿӝng bӯa bãi cӫa C, C++ nay ÿѭӧc hҥn chӃ trong Java, ÿLӅu này làm chѭѫng trình rõ ràng, sáng sӫa, ít lӛi Kѫn.Java kiӇm tra lúc biên dӏch và cҧ trong thӡi gian thông dӏch vì vұy Java loҥi bӓ mӝt mӝt sӕ loҥi lӛi lұp trình nhҩt ÿӏnh.Java không sӱ dөng con trӓ và các phép toán con trӓ. Java kiӇm tra tҩt cҧ các truy nhұp ÿӃn mҧng, chuӛi khi thӵc thi ÿӇÿҧm bҧo rҵng các truy nhұp ÿó không ra ngoài giӟi hҥn kích thѭӟc. Trong các môi trѭӡng lұp trình truyӅn thӕng, lұp trình viên phҧi tӵ mình cҩp phát bӝ nhӟ. Trѭӟc khi chѭѫng trình kӃt thúc thì phҧi tӵ giҧi phóng bӝ nhӟÿã cҩp. Vҩn ÿӅ nҧy sinh khi lұp trình viên quên giҧi phóng bӝ nhӟÿã xin cҩp trѭӟc ÿó. Trong chѭѫng trình Java, lұp trình viên không phҧi bұn tâm ÿӃn viӋc cҩp phát bӝ nhӟ. Qúa trình cҩp phát, giҧi phóng ÿѭӧc thӵc hiӋn tӵÿӝng, nhӡ dӏch vө thu nhһt nhӳng ÿӕi tѭӧng không còn sӱ dөng nӳa (garbage collection). &ѫ chӃ bүy lӛi cӫa Java giúp ÿѫn giҧn hóa qúa trình xӱ lý lӛi và hӗi phөc sau lӛi. 5. H͟ trͫ l̵p trình ÿa tuy͇n Ĉây là tính năng cho phép viӃt mӝt chѭѫng trình có nhiӅu ÿRҥn mã lӋnh ÿѭӧc chҥy song song vӟi nhau. Vӟi java ta có thӇ viӃt các chѭѫng trình có khҧ năng chҥy song song mӝt cách dӉ dàng, hѫn thӃ nӳa viӋc ÿӗng bӝ tài nguyên dùng chung trong Java cǊng rҩt ÿѫng giҧn. ĈLӅu này là không thӇ có ÿӕi vӟi mӝt sӕ ngôn ngӳ lұp trình khác nhѭ C/C++, pascal 6. Phân tán Java hӛ trӧÿҫy ÿӫ các mô hình tính toán phân tán: mô hình client/server, gӑi thӫ tөc tӯ xa 7. H͟ trͫ internet Mөc tiêu quan trӑng cӫa các nhà thiӃt kӃ java là tҥo ÿLӅu kiӋn cho các nhà phát triӇn ӭng dөng có thӇ viӃt các chѭѫng trình ӭng dөng internet và web mӝt cách dӉ dàng, vӟi java ta có thӇ viӃt các chѭѫng trình sӱ dөng các giao thӭc TCP, UDP mӝt cách dӉ dàng, vӅ lұp trình web phía máy khách java có công nghӋ java applet, vӅ lұp trình web phía máy khách java có công nghӋ servlet/JSP, vӅ lұp trình phân tán java có công nghӋ RMI, CORBA, EJB, Web Service. Trang 6
8. Thông d͓ch Các chѭѫng trình java cҫn ÿѭӧc thông dӏch trѭӟc khi chҥy, mӝt chѭѫng trình java ÿѭӧc biên dӏch thành mã byte code mã ÿӝc lұp vӟi hӋ nӅn, chѭѫng trình thông dӏch java sӁ ánh xҥ mã byte code này lên mӛi nӅn cө thӇ, ÿLӅu này khiӃn java chұm chҥp ÿi phҫn nào. III. Các kiӇu ӭng dөng Java Vӟi Java ta có thӇ xây dӵng các kiӇu ӭng dөng sau: 1. Ͱng dͭng Applets Applet là chѭѫng trình Java ÿѭӧc tҥo ra ÿӇ sӱ dөng trên Internet thông qua các trình duyӋt hӛ trӧ Java nhѭ IE hay Netscape. Applet ÿѭӧc nhúng bên trong trang Web. Khi trang Web hiӇn thӏ trong trình duyӋt, Applet sӁÿѭӧc tҧi vӅ và thӵc thi tҥi trình duyӋt. 2. Ͱng dͭng dòng l͏nh (console) Các chѭѫng trình này chҥy tӯ dҩu nhҳc lӋnh và không sӱ dөng giao diӋnÿӗ hӑa. Các thông tin nhұp xuҩt ÿѭӧc thӇ hiӋn tҥi dҩu nhҳc lӋnh. 3. Ͱng dͭng ÿ͛ h͕a Ĉây là các chѭѫng trình Java chҥy ÿӝc lұp cho phép ngѭӡi dùng tѭѫng tác qua giao diӋn ÿӗ hӑa. 4. JSP/Servlet Java thích hӧp ÿӇ phát triӇn ӭng dөng nhiӅu lӟp. Applet là chѭѫng trình ÿӗ hӑa chҥy trên trình duyӋt tҥi máy trҥm. Ӣ các ӭng dөng Web, máy trҥm gӱi yêu cҫu tӟi máy chӫ. Máy chӫ xӱ lý và gӱi kӃt quҧ trӣ lҥi máy trҥm. Các Java API chҥy trên máy chӫ chӏu trách nhiӋm xӱ lý tҥi máy chӫ và trҧ lӡi các yêu cҫu cӫa máy trҥm. Các Java API chҥy trên máy chӫ này mӣ rӝng khҧ năng cӫa các ӭng dөng Java API chuҭn. Các ӭng dөng trên máy chӫ này ÿѭӧc gӑi là các JSP/Servlet. hoһc Applet tҥi máy chӫ. Xӱ lý Form cӫa HTML là cách sӱ dөng ÿѫn giҧn nhҩt cӫa JSP/Servlet. Chúng còn có thӇÿѭӧc dùng ÿӇ xӱ lý dӳ liӋu, thӵc thi các giao dӏch và thѭӡng ÿѭӧc thӵc thi thông qua máy chӫ Web. 5. Ͱng dͭng c˯ sͧ dͷ li͏u Các ӭng dөng này sӱ dөng JDBC API ÿӇ kӃt nӕi tӟi cѫ sӣ dӳ liӋu. Chúng có thӇ là Applet hay ӭng dөng, nhѭng Applet bӏ giӟi hҥn bӣi tính bҧo mұt. 6. Ͱng dͭng m̩ng Java là mӝt ngôn ngӳ rҩt thích hӧp cho viӋc xây dӵng các ӭng dөng mҥng. Vӟi thѭ viӋn Socket bҥn có thӇ lұp trình vӟi hai giao thӭc: UDP và TCP. 7. Ͱng dͭng nhi͉u t̯ng Vӟi Java bҥn có thӇ xây dӵng phân tán nhiӅu tҫng vӟi nhiӅu hӛ trӧ khác nhau nhѭ: RMI, CORBA, EJB, Web Service 8. Ͱng dͭng cho các thi͇t b͓ di ÿ͡ng HiӋn nay phҫn lӟn các thiӃt bӏ di ÿӝng nhѭ: ĈiӋn thoҥi di ÿӝng, máy trӧ giúp cá nhân ÿӅu hӛ trӧ Java. ThӃ nên bҥn có thӇ xây dӵng các ӭng dөng chҥy trên các thiӃt bӏ di ÿӝng này. Ĉây là mӝt kiӇu ӭng dөng khá hҩp dãn, bӣi vì các thiӃt bӏ di ÿӝng này ngày càng phә biӃn và nhu cҫu có các ӭng dөng chҥy trên ÿó, ÿһc biӋt là các ӭng dөng mang tính chҩt giҧi trí nhѭ game IV. Máy ҧo Java (JVM-Java Virtual Machine) Máy ҧo là mӝt phҫn mӅm mô phӓng mӝt máy tính thұt (máy tính ҧo). Nó có tұp hӧp các lӋnh logic ÿӇ xác ÿӏnh các hoҥt ÿӝng cӫa máy tính và có mӝt hӋÿLӅu hành ҧo. Ngѭӡi ta có thӇ xem nó nhѭ mӝt máy tính thұt (máy tính có phҫn cӭng ҧo, hӋÿLӅu hành Trang 7
ҧo). Nó thiӃt lұp các lӟp trӯu tѭӧng cho: Phҫn cӭng bên dѭӟi, hӋÿLӅu hành, mã ÿã biên dӏch. Trình biên dӏch chuyӇn mã nguӗn thành tұp các lӋnh cӫa máy ҧo mà không phө thuӝc vào phҫn cӭng và hӋÿLӅu hành cө thӇ. Trình thông dӏch trên mӛi máy sӁ chuyӇn tұp lӋnh này thành chѭѫng trình thӵc thi. Máy ҧo tҥo ra mӝt môi trѭӡng bên trong ÿӇ thӵc thi các lӋnh bҵng cách: Ø Nҥp các file .class Ø Quҧn lý bӝ nhӟ Ø Dӑn “rác” ViӋc không nhҩt quán cӫa phҫn cӭng làm cho máy ҧo phҧi sӱ dөng ngăn xӃp ÿӇ lѭu trӳ các thông tin sau: Ø Các “Frame” chӭa các trҥng thái cӫa các phѭѫng thӭc. Ø Các toán hҥng cӫa mã bytecode. Ø Các tham sӕ truyӅn cho phѭѫng thӭc. Ø Các biӃn cөc bӝ. Khi JVM thӵc thi mã, mӝt thanh ghi cөc bӝ có tên “Program Counter” ÿѭӧc sӱ dөng. Thanh ghi này trӓ tӟi lӋnh ÿang thӵc hiӋn. Khi cҫn thiӃt, có thӇ thay ÿәi nӝi dung thanh ghi ÿӇÿәi hѭӟng thӵc thi cӫa chѭѫng trình. Trong trѭӡng hӧp thông thѭӡng thì tӯng lӋnh mӝt nӕi tiӃp nhau sӁÿѭӧc thӵc thi. Mӝt khái niӋm thông dөng khác trong Java là trình biên dӏch “Just In Time-JIT”. Các trình duyӋt thông dөng nhѭ Netscape hay IE ÿӅu có JIT bên trong ÿӇ tăng tӕc ÿӝ thӵc thi chѭѫng trình Java. Mөc ÿích chính cӫa JIT là chuyӇn tұp lӋnh bytecode thành mã máy cө thӇ cho tӯng loҥi CPU. Các lӋnh này sӁÿѭӧc lѭu trӳ và sӱ dөng mӛi khi gӑi ÿӃn. Trang 8
BÀI 2 NӄN TҦNG CӪA JAVA I. Tұp ký tӵ dùng trong java Mӑi ngôn ngӳ nói chung, ngôn ngӳ lұp trình nói riêng ÿӅu phҧi xây dӵng trên mӝt tұp hӧp chӳ cái (hay còn gӑi là bҧng chӳ cái), các kí tӵÿѭӧc nhóm lҥi theo mӝt cách nào ÿó ÿӇ tҥo thành các tӯ, các tӯ lҥi ÿѭӧc nhóm lҥi thành các câu (trong ngôn ngӳ lұp trình gӑi là câu lӋnh), mӝt chѭѫng trình máy tính tính là mӝt tұp các câu lӋnh ÿѭӧc bӕ trí theo mӝt trұt tӵ mà ngѭӡi viӃt ra chúng sҳp ÿһt Ngôn ngӳ java ÿѭӧc ÿѭӧc xây dӵng trên bҧng chӳ cái unicode, do vұy ta có thӇ dùng các kí tӵ unicode ÿӇÿһt tên cho các ÿӏnh danh. II. Tӯ khoá cӫa Java Mӛi ngôn ngӳ lұp trình có mӝt tұp các tӯ khoá, ngѭӡi lұp trình phҧi sӱ dөng tӯ khoá theo ÿúng nghƭa mà ngѭӡi thiӃt kӃ ngôn ngӳÿã ÿӅ ra, ta không thӇÿӏnh nghƭa lҥi nghƭa cӫa các tӯ khoá, nhѭ sӱ dөng nó ÿӇÿһt tên biӃn, hàm Sau ÿây là m͡t s͙ tͳ khoá th˱ͥng g̿p: Tӯ khóa Mô tҧ abstract Sӱ dөng ÿӇ khai báo lӟp, phѭѫng thӭc trӯu tѭӧng boolean KiӇu dӳ liӋu logic break Ĉѭӧc sӱ dөng ÿӇ kӃt thúc vòng lһp hoһc cҩu trúc switch byte kiӇu dӳ liӋu sӕ nguyên case ÿѭӧc sӱ dөng trong lӋn switch cast Chѭa ÿѭӧc sӱ dөng (ÿӇ dành cho tѭѫng lai) catch ÿѭӧc sӱ dөng trong xӱ lý ngoҥi lӋ char kiӇu dӳ liӋu ký tӵ class Dùng ÿӇ khai báo lӟp const Chѭa ÿѭӧc dùng continue ÿѭӧc dùng trong vòng lһp ÿӇ bҳt ÿҫu mӝt vòng lһp mӟi default ÿѭӧc sӱ dөng trong lӋnh switch do ÿѭӧc dùng trong vòng lһp ÿLӅu kiӋn sau double kiӇu dӳ liӋu sӕ thӵc else khҧ năng lӵa chӑn thӭ hai trong câu lӋnh if extends chӍ rҵng mӝt lӟp ÿӵѫc kӃ thӯa tӯ mӝt lӟp khác false Gía trӏ logic final Dùng ÿӇ khai báo hҵng sӕ, phѭѫng thӭc không thӇ ghi ÿè, hoһc lӟp không thӇ kӃ thӯa finally phҫn cuӕi cӫa khӕi xӱ lý ngoҥi lӋ float kiӇu sӕ thӵc for Câu lӋnh lһp goto Chѭa ÿѭӧc dùng if Câu lӋnh lӵa chӑn implements chӍ rҵng mӝt lӟp triӇn khai tӯ mӝt giao diӋn import Khai báo sӱ dөng thѭ viӋn instanceof kiӇm tra mӝt ÿӕi tѭӧng có phҧi là mӝt thӇ hiӋn cӫa lӟp hay không interface sӱ dөng ÿӇ khai báo giao diӋn long kiӇu sӕ nguyên native Khai báo phѭѫng thӭc ÿѭӧc viӃt bҵng ngông ngӳ biên dӏch C++ new tҥo mӝt ÿӕi tѭӧng mӟi Trang 9
null mӝt ÿӕi tѭӧng không tӗn tҥi package Dùng ÿӇ khai báo mӝt gói private ÿһc tҧ truy xuҩt protected ÿһc tҧ truy xuҩt public ÿһc tҧ truy xuҩt return Quay tӯ phѭѫng thӭc vӅ chӛ gӑi nó short kiӇu sӕ nguyên static Dùng ÿӇ khai báo biӃn, thuӝc tính tƭnh super Truy xuҩt ÿӃn lӟp cha switch lӋnh lӵa chӑn synchronized mӝt phѭѫng thӭc ÿӝc quyӅn truy xuҩt trên mӝt ÿӕi tѭӧng this Ám chӍ chính lӟp ÿó throw Ném ra ngoҥi lӋ throws Khai báo phѭѫng thӭc ném ra ngoҥi lӋ true Giá trӏ logic try sӱ dөng ÿӇ bҳt ngoҥi lӋ void Dùng ÿӇ khai báo mӝt phѭѫng thӭc không trҧ vӅ giá trӏ while Dùng trong cҩu trúc lһp III. Ĉӏnh danh (tên) Tên dùng ÿӇ xác ÿӏnh duy nhҩt mӝt ÿҥi lѭӧng trong chѭѫng trình. Trong java tên ÿѭӧc ÿһt theo quy tҳc sau: - Không trùng vӟi tӯ khoá - Không bҳt ÿҫu bҵng mӝt sӕ, tên phҧi bҳt ÿҫu bҵng kí tӵ hoһc bҳt ÿҫu bҵng kí $,_ - Không chӭa dҩu cách, các kí tӵ toán hӑc nhѭ +, -, *,/, % - Không trùng vӟi mӝt ÿӏnh danh khác trong cùng mӝt phҥm vi Chú ý: - Tên nên ÿһt sao cho có thӇ mô tҧÿѭӧc ÿӕi tѭӧng trong thӵc tӃ - Giӕng nhѭ C/C++, java có phân biӋt chӳ hoa chӳ thѭӡng - Trong java ta có thӇÿһt tên vӟi ÿӝ dài tuǤ ý - Ta có thӇ sӱ dөng các kí tӵ tiӃng viӋt ÿӇÿһt tên Quy ˱ͣc v͉ ÿ̿t tên trong java Ta nên ÿһt tên biӃn, hҵng, lӟp, phѭѫng thӭc sao cho nghƭa cӫa chúng rõ ràng, dӉ hiӇu, khoa hӑc và mang tính ѭӟc lӋ quӕc tӃ. Do java có phân biӋt chӳ hoa, chӳ thѭӡng nên ta phҧi cҭn thұn và chú ý. Sau ÿây là quy ѭӟc ÿһt tên trong java (chú ý ÿây chӍ là quy ѭӟc do vұy không bҳt buӝc phҧi tuân theo quy ѭӟc này): - Ĉӕi vӟi biӃn và phѭѫng thӭc thì tên bao giӡ cǊng bҳt ÿҫu bҵng ký tӵ thѭӡng, nӃu tên có nhiӅu tӯ thì ghép lҥi thì: ghép tҩt cҧ các tӯ thành mӝt, ghi tӯÿҫu tiên chӳ thѭӡng, viӃt hoa kí tӵÿҫu tiên cӫa mӛi tӯ theo sau trong tên, ví dө area, radius, readInteger -Ĉӕi vӟi tên lӟp, giao diӋn ta viӃt hoa các kí tӵÿҫu tiên cӫa mӛi tӯ trong tên, ví dө lӟp WhileTest, Circle - Tên hҵng bao giӡ cǊng viӃt hoa, nӃu tên gӗm nhiӅu tӯ thì chúng ÿѭӧc nӕi vӟi hau bӣi kí tӵ ghҥch dѭӟi ‘_’, ví dө PI, MAX_VALUE IV. Cҩu trúc mӝt chѭѫng trình java - Mӛi ӭng dөng Java bao gӗm mӝt hoһc nhiӅu ÿѫn vӏ biên dӏch (mӛi ÿѫn vӏ biên dӏch là mӝt tӋp tin có phҫn mӣ rӝng Java) - Mӛi ÿѫn vӏ biên dӏch bao gӗm mӝt hoһc nhiӅu lӟp Trang 10
- Mӛi ӭng dөng ÿӝc lұp phҧi có duy nhҩt mӝt phѭѫng thӭc main (ÿLӇm bҳt ÿҫu cӫa ӭng dөng) - Mӛi ÿѫn vӏ biên dӏch có nhiӅu nhҩt mӝt lӟp ÿѭӧc khai báo là public, nӃu nhѭ trong ÿѫn vӏ biên dӏch có lӟp public thì tên cӫa ÿѫn vӏ biên dӏch phҧi trùng vӟi tên cӫa lӟp public (giӕng hӋt nhau cҧ ký tӵ hoa lүn ký tӵ thѭӡng) - Bên trong thân cӫa mӕi lӟp ta khai báo các thuӝc tính, phѭѫng thӭc cӫa lӟp ÿó, Java là ngôn ngӳ hѭӟng ÿӕi tѭӧng, do vұy mã lӋnh phҧi nҵm trong lӟp nào ÿó. Mӛi lӋnh ÿӅu ÿѭӧc kӃt thúc bҵng dҩu chҩm phҧy “;”. 0͙t ÿɇn vʈ biên dʈch là m͙t tʄp tin .java //Nhɪp khɦu các thɉ viʄn import thɉ_viʄn; //Xây dͱng các l͛p public class clsMain{ « public static void main(String args[]) { //ÿLʀm bɬt ÿɤu cͧa chɉɇng trình } « } class l͛p1 { « } class l͛p2 { « } - Trong ngôn ngӳ Java, lӟp là mӝt ÿѫn vӏ mүu có chӭa dӳ liӋu và mã lӋnh liên quan ÿӃn - mӝt thӵc thӇ nào ÿó. Khi xây dӵng mӝt lӟp, thӵc chҩt bҥn ÿang tҥo ra mӝt mӝt kiӇu dӳ liӋu. KiӇu dӳ liӋu mӟi này ÿѭӧc sӱ dөng ÿӇ xác ÿӏnh các biӃn mà ta thѭѫng gӑi là “ÿӕi Wѭӧng”. Ĉӕi tѭӧng là các thӇ hiӋn (instance) cӫa lӟp. Tҩt cҧ các ÿӕi tѭӧng ÿӅu thuӝc vӅ mӝt lӟp có chung ÿһc tính và hành vi. Mӛi lӟp xác ÿӏnh mӝt thӵc thӇ, trong khi ÿó mӛi ÿӕi tѭӧng là mӝt thӇ hiӋn thӵc sӵ. - Khi ban khai báo mӝt lӟp, bҥn cҫn xác ÿӏnh dӳ liӋu và các phѭѫng thӭc cӫa lӟp ÿó. VӅ cѫ bҧn mӝt lӟp ÿѭӧc khai báo nhѭ sau: Trang 11
Cú pháp: class classname { var_datatype variablename; methodname (parameter_list){ } } Trong ÿó: class - Tӯ khoá xác ÿӏnh lӟp classname - Tên cӫa lӟp var_datatype - kiӇu dӳ liӋu cӫa biӃn variablename - Tên cӫa biӃn met_datatype - KiӇu dӳ liӋu trҧ vӅ cӫa phѭѫng thӭc methodname - Tên cӫa phѭѫng thӭc parameter_list – Các tham sӕÿѭӧc cӫa phѭѫng thӭc - Bҥn còn có thӇÿӏnh nghƭa mӝt lӟp bên trong mӝt lӟp khác. Ĉây là lӟp xӃp lӗng nhau, các thӇ hiӋn (instance) cӫa lӟp này tӗn tҥi bên trong thӇ hiӋn cӫa mӝt lӟp che phӫ chúng. Nó chi phӕi viӋc truy nhұp ÿӃn các thành phҫn cӫa lӟp bao phӫ chúng. Có hai loҥi lӟp trong ÿó là lӟp trong tƭnh “static” và lӟp trong không tƭnh “non static” + Lӟp trong tƭnh (static) Lӟp trong tƭnh ÿѭӧc ÿӏnh nghƭa vӟi tӯ khoá “static”. Lӟp trong tƭnh có thӇ truy nhұp vào các thành phҫn tƭnh cӫa lӟp phӫ nó. + Lӟp trong không tƭnh (non static) Lӟp bên trong (không phҧi là lӟp trong tƭnh) có thӇ truy nhұp tҩt cҧ các thành phҫn cӫa lӟp bao nó, song không thӇ ngѭӧc lҥi. V. Chѭѫng trình JAVA ÿҫu tiên ĈӇ có thӇ biên dӏch và chҥy các chѭѫng trình java ta phҧi cài - JRE (Java Runtime Enviroment) môi trѭӡng thӵc thi cӫa java, nó bao gӗm: JVM (Java Virtual Machine) máy ҧo java vì các chѭѫng trình java ÿѭӧc thông dӏch và chҥy trên máy ҧo java và tұp các thѭ viӋn cҫn thiӃt ÿӇ chҥy các ӭng dөng java. - Bӝ công cө biên dӏch và thông dӏch JDK cӫa Sun Microsystem Sau khi cài ÿһt JDK (giҧ sӱ thѭ mөc cài ÿһt là C:\JDK1.4) ta sӁ nhұn ÿѭӧc mӝt cҩu trúc thѭ mөc nhѭ sau: -ĈӇ biên dӏch mӝt chѭѫng trình java sang mã byte code ta dùng lӋnh C:\JDK1.4\BIN\javac TênT͏p.java -ĈӇ thông dӏch và chҥy chѭѫng trình ta sӱ dөng lӋnh Trang 12
C:\JDK1.4\BIN\java TênTӋp ĈӇ biên dӏch và chҥy chѭѫng trình Java ÿѫn giҧn ta nên thiӃt ÿһt hai biӃn môi trѭӡng “paht” và “classpath” nhѭ sau: -Ĉӕi vӟi dòng WinNT: + R-Click vào My Computerà chӑn Propertiesà chӑn AdvancedàEnviroment Variables + Trong phҫn System variables chӑn new ÿӇ thêm biӃn môi trѭӡng mӟi, trong hӝp thoҥi hiӋn ra gõ “classpath” vào ô Variable Name và “.;C:\jdk1.4\lib\tools.jar;C:\jdk1.4\lib\dt.jar;C:\jdk1.4\jre\lib\rt.jar” trong ô variable value (chú ý không gõ dҩu “ vào, mөc ÿích ÿӇ cho dӉ nhìn mà thôi) + CǊng trong phҫn System variables tìm ÿӃn phҫn path trong danh sáchàchӑn edit ÿӇ sӱa lҥi giá trӏ hiӋn có, trong ô value ta thêm vào cuӕi “;C:\jdk1.4\bin” Công viӋc ÿһt các biӃn môi trѭӡng ÿã xong, ÿӇ thҩy ÿѭӧc tác dөng cӫa các biӃn môi tUѭӡng ta cҫn phҧi khӣi ÿӝng lҥi máy -Ĉӕi vӟi dòng Win9X: Mӣ tӋp C:\Autoexec.bat sau ÿó thêm vào hai dòng sau: +classpath=.;C:\jdk1.4\lib\tools.jar;C:\jdk1.4\lib\dt.jar;C:\jdk1.4\jre\lib\rt.jar + path= ;c:\jdk1.4\bin Khӣi ÿӝng lҥi máy ÿӇ thҩy ÿѭӧc tác dөng cӫa các biӃn môi trѭӡng này Ví dͭÿ̯u tiên: chѭѫng trình Hello World (chѭѫng trình khi chҥy sӁ in ra màn hình lӡi chào Hello World) Các bѭӟc: Trang 13
- Mӣ mӝt chѭѫng trình soҥn thҧo văn bҧn hӛ trӧ asciii, nhѭ notepad, wordpad, EditPlus và gõ vào các dòng sau: public class HelloWorld { public static void main(String[] args){ System.out.println("Hello World"); } } - Ghi lҥi vӟi cái tên C:\HelloWorld.java (chú ý tên tӋp phҧi trùng vӟi tên lӟp, kӇ cҧ chӳ hoa chӳ thѭӡng, phҫn mӣ rӝng là java) - Mӣ cӫa sә DOS Prompt + ChuyӇn vào thѭ mөc C:\ + Gõ lӋnh javac HelloWorld.java ÿӇ biên dӏch chѭѫng trình, nӃu viӋc biên dӏch thành công (chѭѫng trình không có lӛi cú pháp) thì ta sӁ thu ÿѭӧc tӋp HelloWorld.class trong cùng thѭ mөc, nӃu trong chѭѫng trình còn lӛi cú pháp thì trong bӭѫc này ta sӁ nhұn ÿѭӧc mӝt thông báo lӛi và lúc này tӋp HelloWorld.class cǊng không ÿѭӧc tҥo ra + Gõ lӋnh java HelloWorld (chú ý không gõ phҫn mӣ rӝng) ÿӇ chҥy chѭѫng trình HelloWorld. Sau khi thông dӏch và chҥy ta nhұn ÿѭӧc VI. Chú thích trong chѭѫng trình Trong java ta có 3 cách ÿӇ ghi chú thích Cách 1: sӱ dөng cһp /* và */ ý nghƭa cӫa cһp chú thích này giӕng nhѭ cӫa C, C++ Cách 2: sӱ dөng cһp // ý nghƭa cӫa cһp chú thích này giӕng nhѭ cӫa C, C++ Cách 3: sӱ dөng cһp / và */, ÿây là kiӇu chú thích tài liӋu (không có trong C/C++), nó dùng ÿӇ tҥo ra tài liӋu chú thích cho chѭѫng trình. Vӟi cách thӭ nhҩt và cách ba ta có thӇ viӃt chú thích trên nhiӅu dòng, vӟi cách chú thích hai ta chӍ có thӇ chú thích trên mӝt dòng. Chú ý: Trong java ta có thӇÿһt chú thích ӣÿâu?, câu trҧ lӡi là: ӣÿâu có thӇÿһt ÿѭӧc mӝt dҩu cách thì ӣÿó có thӇÿһt chú thích. Trang 14
VII. KiӇu dӳ liӋu 1. Các ki͋u dͷ li͏u nguyên thuͽ .ʀu nguyên thuͷ kiɾu logic boolean Kiʀu kí tͱ Kiʀu s͑ Kiʀu s͑ Kiʀu s͑ thͱc boolean char byte short int long float doubl e Tӯ khoá Mô tҧ Kích cӥ Tӕi thiӇu Tӕi ÿa Lӟp bao (kiӇu sӕ nguyên) byte sӕ nguyên mӝt byte 8 bit -128 127 Byte short sӕ nguyên ngҳn 16 bit -215 215-1 Short int sӕ nguyên 32 bit -231 231-1 Integer long sӕ nguyên dài 64 bit -263 -263-1 Long (kiӇu sӕ thӵc) float kiӇu thӵc vӟi ÿӝ chính 32 bit IEEE754 IEEE75 Float xác ÿѫn 4 double Double-precision 64 bit IEEE754 IEEE75 Double floating point 4 (kiӇu khác) char kiӇu kí tӵ 16 bit Unicode 0 Unicode Character 216-1 boolean kiӇu logic true hoһc false - - Boolean void - - - - Void Ĉһc ÿLӇm cӫa các biӃn có kiӇu nguyên thӫy là vùng nhӟ cӫa chúng ÿѭӧc cҩp phát ӣ phҫn stack. Do vұy viӋc truy xuҩt vào mӝt biӃn kiӇu nguyên thӫy rҩt nhanh. 2. Ki͋u tham chi͇u Trong Java có 3 kiӇu dӳ liӋu tham chiӃu KiӇu dӳ liӋu Mô tҧ Mҧng (Array) Tұp hӧp các dӳ liӋu cùng kiӇu. Lӟp (Class) Là sӵ cài ÿһt mô tҧ vӅ mӝt ÿӕi tѭӧng trong bài toán. Giao diӋn Là mӝt lӟp thuҫn trӯu tѭӧng ÿѭӧc tҥo ra cho phép cài ÿһt (Interface) ÿa thӯa kӃ trong Java. Ĉһc ÿLӇm cӫa các biӃn kiӇu tham chiӃu là nó chӭa ÿӏa chӍ cӫa ÿӕi tѭӧng mà nó trӓ ÿӃn. Trang 15
Biɼn tham chiɼu Ĉ͑i tɉͣng Vùng nhӟ cӫa biӃn tham chiӃu ÿѭӧc cҩp phát ӣ vùng nhӟ stack còn vùng nhӟ cӫa ÿӕi tѭӧng ÿѭӧc cҩp phát ӣ vùng nhӟ heap. ViӋc truy xҩt vào vùng nhӟ heap chұm hѫn truy xҩt vào vùng nhӟ stack tuy nhiên java có cѫ chӃ cho phép truy cұp vào vùng nhӟ heap vӟi tӕc ÿӝ xҩp xӍ bҵng tӕc ÿӝ truy cұp vào vùng nhӟ stack. VIII. Khai báo bi͇n 1. Khai báo bi͇n 7ѭѫng tӵ ngôn ngӳ C/C++, ÿӇ khai báo biӃn trong java ta sӱ dөng cú pháp sau: type name [=InitValue]; trong ÿó: - type là kiӇu dӳ liӋu cuҧ biӃn - name là tên cӫa biӃn, tên biӃn là mӝt xâu kí tӵÿѭӧc ÿһt theo quy tҳc ÿһt tên cӫa java - InitValue là giá trӏ khӣi tҥo cho biӃn, ÿây là phҫn tuǤ chӑn, nӃu bӓ qua phҫn này thì giá trӏ ban ÿҫu cӫa biӃn ÿѭӧc khӣi tҥo giá trӏ mһc ÿӏnh Chú ý: - NӃu cҫn khai báo nhiӅu biӃn có cùng mӝt kiӇu dӳ liӋu ta có thӇÿһt các khai báo các biӃn trên mӝt dòng, các biӃn này ÿѭӧc phân cách nhau bӣi dҩu phҧy - Java sӁ xӱ lý các biӃn không ÿѭӧc khӣi ÿҫu giá trӏ nhѭ sau: + Ĉӕi vӟi thuӝc tính (biӃn ÿѭӧc khai báo trong phҥm vi cӫa lӟp) thì Java sӁ tӵÿӝng khӣi gán giá trӏ cho các biӃn theo quy tҳc sau: + giá trӏ 0 cho kiӇu dӳ liӋu sӕ + false cho kiӇu logic + kí tӵ null (mã 0) cho kí tӵ + giá trӏ null cho kiӇu ÿӕi tѭӧng + Ĉӕi vӟi các biӃn cөc bӝ thì biӃn không ÿѭӧc khӟi gán giá trӏ mһc ÿӏnh, tuy nhiên Java sӁ báo lӛi nӃu ta sӱ dөng mӝt biӃn chѭa ÿѭӧc nhұn giá trӏ 2. Ph̩m vi bi͇n Mӛi biӃn ÿѭӧc khai báo ra có mӝt phҥm vi hoҥt ÿӝng, phҥm vi cӫa biӃn là nѫi mà biӃn có thӇÿѭӧc truy cұp, ÿLӅu này xác ÿӏnh cҧ tính thҩy ÿѭӧc và thӡi gian sӕng cӫa biӃn. Trang 16
Ø BiӃn phҥm vi lӟp là biӃn ÿѭӧc khai báo bên trong lӟp nhѭng bên ngoài các phѭѫng thӭc và hàm tҥo, tuy nhiên viӋc khai báo phҧi xuҩt hiӋn trѭӟc khi biӃn ÿѭӧc sӱ dөng Ø BiӃn phҥm vi cөc bӝ là biӃn ÿѭӧc khai báo bên trong mӝt khӕi, phҥm vi cӫa biӃn tính tӯÿLӇm biӃn ÿѭӧc khai báo cho ÿӃn cuӕi khӕi mà biӃn ÿѭӧc khai báo Ví dө: { int i=1; // chӍ có i sҹn sàng sӱ dөng { int j=10; // cҧ i và j ÿӅu sҹn sàng } // chӍ có i sҹn sàng // j không sҹn sàng vì nҵm ngoài phҥm vi } Chú ý: Ta không th͋ làm ÿi͉u sau cho dù nó có th͋ trong C/C++ { int i=1; { int i=10;// không ÿѭӧc phép vì ÿã có mӝt biӃn cùng tên vӟi nó } } Nhӳng ngѭӡi thiӃt kӃ java cho rҵng ÿLӅu ÿó có thӇ gây lҫn lӝn, do vұy hӑÿã quyӃt ÿӏnh không cho phép che giҩu mӝt biӃn ӣ phҥm vi lӟn hѫn. Chú ý: thӡi gian sӕng cӫa các ÿӕi tѭӧng không tuân theo quy luұt thӡi gian sӕng cӫa các biӃn kiӇu nguyên thuӹ. VII. Mӝt sӕ phép toán trên kiӇu dӳ liӋu nguyên thuӹ 1. Phép gán Cú pháp BiӃn=BiӇuThӭc; Phép gán ÿѭӧc thӵc hiӋn bҵng toán tӱ ‘=’, nó có nghƭa là “ hãy tính toán giá trӏ biӇu thӭc bên phҧi dҩu gán, sau ÿó ÿѭa giá trӏÿó vào ô nhӟ có tên nҵm ӣ bên trái dҩu gán’ Chú ý: + Câu lӋnh gán gӗm mӝt dҩu ‘=’ + KiӇu cӫa biӇu thӭc bên phҧi dҩu gán phҧi tѭѫng thích vӟi kiӇu dӳ liӋu cӫa biӃn + Trong java ta có thӇ thӵc hiӋn mӝt dүy gán nhѭ sau: i = j = 10; // cҧ i và j ÿӅu có giá trӏ 10 Trang 17
2. Toán t͵ toán h͕c Ngôn ngӳ java cǊng có các phép toán sӕ hӑc nhѭ các ngôn ngӳ khác: + ( phép cӝng), - ( phép trӯ ), * ( phép nhân ),/ ( phép chia ), % ( phép toán chia lҩy phҫn nguyên) Ta mô tҧ tóm tҳt các phép toán sӕ hӑc qua bҧng tәng kӃt sau: Phép toán Sӱ dөng Mô tҧ + op1 + op2 Cӝng op1 vӟiop2 - op1 - op2 Trӯ op1 cho op2 * op1 * op2 Nhân op1 vӟi op2 / op1/ op2 chia op1 cho op2 % op1 % op2 Tính phҫn dѭ cӫa phép chia op1 cho op2 3. Toán t͵ tăng, gi̫m Giӕng nhѭ ngôn ngӳ C/C++, java cǊng có phép toán tăng, giҧm, ta có thӇ mô tҧ tóm tҳt qua các bҵng sau: Phép toán Sӱ dөng Mô tҧ 7ăng op lên 1 ÿѫn vӏ, giá trӏ cӫa op ÿѭӧc tăng lên trѭӟc khi biӇu ++ op++ thӭc chӭa nó ÿѭӧc tính 7ăng op lên 1 ÿѫn vӏ, giá trӏ cӫa op ÿѭӧc tăng lên sau khi biӇu thӭc ++ ++op chӭa nó ÿѭӧc tính Giҧm op xuӕng1 ÿѫn vӏ, giá trӏ cӫa op ÿѭӧc giҧm xuӕng trѭӟc khi op biӇu thӭc chӭa nó ÿѭӧc tính Giҧm op xuӕng1 ÿѫn vӏ, giá trӏ cӫa op ÿѭӧc giҧm xuӕng sau khi op biӇu thӭc chӭa nó ÿѭӧc tính Chú ý: n͇u toán t͵ tăng tr˱ͣc, tăng sau(gi̫m tr˱ͣc, gi̫m sau) ÿͱng m͡t mình(không nҵm trong biӇu thӭc ) thì chúng hoҥt ÿӝng nhѭ nhau, chúng chӍ khác nhau khi chúng nҵm trong biӇu thӭc 4. Phép toán quan h͏ Phép toán quan hӋ bao giӡ cǊng cho kӃt quҧ boolean, phép toán quan hӋ sӁ so sánh 2 giá trӏ, nó xác ÿӏnh mӕi quan hӋ giӳa chúng, ví dө! = sӁ trҧ vӅ true nӃu 2 toán hҥng là khác nhau. Ta tóm tҳt các phép toán qua bҧng sau: Phép toán Sӱ dөng Nhұn vӅ giá trӏ true khi > op1 > op2 op1 lӟn hѫn op2 >= op1 >= op2 op1 lӟn hѫn hoһc bҵng op2 < op1 < op2 op1 nhӓ hѫn op2 <= op1 <= op2 op1 nhӓ hѫn hoһc bҵng op2 == op1 == op2 op1 bҵng op2 != op1! = op2 op1 khác op2 Ví dө: Sӱ dөng các phép toán quan hӋ public class RelationalDemo { public static void main(String[] args) { // a few numbers Trang 18
int i = 37; int j = 42; int k = 42; System.out.println("Variable values "); System.out.println(" i = " + i); System.out.println(" j = " + j); System.out.println(" k = " + k); //greater than System.out.println("Greater than "); System.out.println(" i > j = " + (i > j)); // false System.out.println(" j > i = " + (j > i));// true System.out.println(" k > j = " + (k > j));// false, they are equal //greater than or equal to System.out.println("Greater than or equal to "); System.out.println(" i >= j = " + (i >= j));// false System.out.println(" j >= i = " + (j >= i));// true System.out.println(" k >= j = " + (k >= j));// true //less than System.out.println("Less than "); System.out.println(" i j = false j > i = true k > j = false Greater than or equal to i >= j = false j >= i = true k >= j = true Less than Trang 19
i > op1 >> op2 ÿѭӧc ÿLӅn bҵng các bít 0 Dӏch chuyӇn op1 sang trái op2 bit(giӳ nguyên dҩu cӫa op1), >> op1>>> op2 Dӏch chuyӇn op1 sang phҧi op2 bit, op2 bit Sau ÿây là hình minh hoҥ phép toán dӏch bít Trang 20
Ví dө: 13>>1=6 vì 13=11012 do vұy khi dӏch phҧi mӝt bit ta sӁÿѭӧc 1102=6 5<<1=10 vì 5=1012 do vұy khi dӏch trái 1 bit ta sӁÿѭӧc 10102=10 5<<2=100 vì 5=1012 do vұy khi dӏch trái 2 bit ta sӁÿѭӧc 101002=100 Nh̵n xét: phép toán d͓ch trái m͡t bit chính là phép nhân vͣi 2, còn d͓ch ph̫i chính là phép chia cho 2 6.2. Phép toán logic trên bit Các phép toán thao tác bit cho phép ta thao tác trên tӯng bit riêng lҿ trong mӝt kiӇu dӳ liӋu thích hӧp, các phép toán thao tác bit thӵc hiӋn ÿҥi sӕ boolean trên các bit tѭѫng ӭng cӫa 2 toán hҥng ÿӇ tҥo ra kӃt quҧ Ta tóm tҳt các phép toán trong bҧng sau: Phép toán Sӱ dөng Thӵc hiӋn & op1 & op2 Thӵc hiӋn phép and các bit tѭѫng ӭng cӫa op1 vӟi op2 | op1 | op2 Thӵc hiӋn phép or các bit tѭѫng ӭng cӫa op1 vӟi op2 ^ op1 ^ op2 Thӵc hiӋn phép xor các bit tѭѫng ӭng cӫa op1 vӟi op2 ~ ~op2 Thӵc hiӋn phép lұt not các bit cӫa op2 Bҧng giá trӏ chân lý cӫa các phép toán ÿái sӕ boolean: Trang 21
Phép AND op1 op2 Result 0 0 0 0 1 0 1 0 0 1 1 1 Phép XOR op1 op2 Result 0 0 0 0 1 1 Phép NOT op1 Result 0 1 1 0 1 0 1 1 1 0 op1 op2 Result 0 0 0 0 1 1 1 0 1 1 1 1 Ví dө: 1101// 13 & 1100// 12 1100// 12 1101// 13 | 1100// 12 1101// 13 1101// 13 ^ 1100// 12 0001// 1 ! 10101=01010 7. Toán t͵ gán t̷t Giӕng nhѭ C/C++ java cǊng có toán tӱ gán, ta tóm tҳt các toán tӱ gán qua bҧng sau: Phép gán Sӱ dөng 7ѭѫng ÿѭѫng += op1 += op2 op1 = op1 + op2 -= op1 -= op2 op1 = op1 - op2 *= op1 *= op2 op1 = op1 * op2 /= op1/ = op2 op1 = op1/ op2 %= op1 %= op2 op1 = op1 % op2 Trang 22
&= op1 &= op2 op1 = op1 & op2 |= op1 |= op2 op1 = op1 | op2 ^= op1 ^= op2 op1 = op1 ^ op2 >= op1 >>= op2 op1 = op1 >> op2 >>>= op1 >>>= op2 op1 = op1 >>> op2 8. Thͱ t͹ ˱u tiên cͯa các phép toán Thӭ tӵ ѭu tiên cӫa các phép toán xác ÿӏnh trình tӵ tính toán giá trӏ cӫa mӝt biӇu thӭc, java có nhӳng quy tҳc riêng ÿӇ xác ÿӏnh trình tӵ tính toán cӫa biӇu thӭc, ta phҧi nhӟ quy tҳc sau: Ø Các phép toán mӝt ngôi bao giӡ cǊng ÿѭӧc thӵc hiӋn trѭӟc tiên Ø Trong mӝt biӇu thӭc có nhiӅu phép toán thì phép toán nào có ÿӝ ѭu tiên cao hѫn sӁ ÿѭӧc thӵc hiӋn trѭӟc phép toán có ÿӝ ѭu tiên thҩp Ø Trong mӝt biӇu thӭc có nhiӅu phép toán có ÿӝ ѭu tiên ngang nhau thì chúng sӁÿѭӧc tính theo trình tӵ tӯ trái qua phҧi Ta có bҧng tóm tҳt thӭ tӵ ѭu tiên cӫa các phép toán trong bҧng sau: postfix operators []. (params) expr++ expr unary operators ++expr expr +expr -expr ~! creation or cast new (type)expr multiplicative */ % additive + - shift > >>> relational = instanceof equality ==! = Bitwise AND & Bitwise exclusive OR ^ Bitwise inclusive OR | Logical AND && Logical OR || Conditional ?: Assignment = += -= *=/ = %= &= ^= |= >= >>>= Trong bҧng trên thӭ tӵ ѭu tiên cӫa các phép toán ÿѭӧc giҧm tӯ trên xuӕng dѭӟi, trên cùng mӝt hàng thì chúng có ÿӝ ѭu tiên ngang nhau. · Toán tӱ dүy Không giӕng nhѭ C/C++, trong java chӛ duy nhҩt mà ta có thӇÿһt toán tӱ dүy là bên trong cһp ngoһc tròn cӫa cҩu trúc for( sӁÿѭӧc mô tҧ chi tiӃt trong chѭѫng sau ) IX. Toán tӱ chuyӇn kiӇu 9.1 Chuy͋n ÿ͝i ki͋u không t˱ͥng minh ViӋc chuyӇn ÿәi kiӇu thѭӡng ÿѭӧc diӉn ra mӝt cách tӵÿӝng trong trѭӡng hӧp biӇu thӭc gӗm nhiӅu toán hҥng có kiӇu dӳ liӋu khác nhau. ĈLӅu này ÿôi khi làm cho bҥn khá ngҥc nhiên vì nhұn ÿѭӧc mӝt kӃt quҧ không theo ý muӕn. Ví dө ta xét ÿRҥn trình sau: int two=2, three=3; Trang 23
float result=1.5 +three/two; kӃt quҧ nhұn ÿѭӧc cӫa result là 2.5. ĈiӅu mà bҥn mong muӕn là 3.0 chӭ không phҧi là 2.5. KӃt quҧ 2.5 nhұn ÿѭӧc là do three và two là hai giá trӏ nguyên nên kӃt quҧ cӫa phép chia three/two cho ta mӝt giá trӏ nguyên bàng 1 chӭ không phҧi là 1.5. ĈӇ nói rҵng kӃt quҧ cӫa phép chia three/two là mӝt giá trӏ thӵc chӭ không phҧi là mӝt giá trӏ nguyên thì mӝt trong hai toán hҥng cӫa phép chia này phҧi là mӝt sӕ thӵc. Do vұy ta cҫn phҧi chuyӇn kiӇu cӫa mӝt trong hai toán hҥng này hoһc cҧ hai thành sӕ thӵc. ĈӇ nhұn ÿѭӧc kӃt quҧÿúng trong trѭӡng hӧp này bҥn cҫn viӃt nhѭ sau: float result=1.5 + (float) three/two; hoһc float result=1.5 + three/ (float)two; hoһc float result=1.5 +(float)three/(float)two; Lý do mà ta viӃt nhѭ trên là nӃu trong mӝt phép toán có sӵ tham gia cӫa nhiӅu toán hҥng có kiӇu khác nhau thì java sӁ chuyӇn kiӇu tӵÿӝng cho các toán hҥng mӝt cách tӵÿӝng theo quy tҳc sau: byte -> short -> int -> long -> float -> double 9.2. Chuy͋n ÿ͝i ki͋u t˱ͥng minh ĈӇ chuyӇn ÿәi kiӇu mӝt cách tѭӡng minh ta sӱ dөng cú pháp sau: (type) biӇu_thӭc; khi gһp câu lӋnh này java sӁ tính toán giá trӏ cӫa biӇu thӭc sau ÿó chuyӇn ÿәi kiӇu giá trӏ cӫa biӇu thӭc thành kiӇu type. Ví dө: (int) 2.5 * 2 = 4 (int) 2.5 * 2.5 = 5 (int)(2.5 * 2.5) = 6 1+(float)5/2=1+5/(float)2=1+(float)5/(float)2=3.5 Chú ý: - Phép toán chuyӇn kiӇu là phép toán có ÿӝ ѭu tiên cao, nên (int)3.5*2¹(int)(3.4*2) - Cҫn chú ý khi chuyӇn mӝt biӇu thӭc kiӇu dӳ liӋu có miӅn giá trӏ lӟn sang mӝt kiӇu có miӅn giá trӏ nhӓ hѫn. Trong trѭӡng hӧp này có thӇ bҥn sӁ bӏ mҩt thông tin. X. Các hàm toán hӑc Các hàm toán hӑc nhѭ sin, cos, sqrt ÿѭӧc java viӃt sҹn trong lӟp Math. Lӟp này nҵm trong gói java.lang (gói mһc ÿӏnh) do vұy bҥn không cҫn phҧi thêm câu lӋnh import ӣÿҫu chѭѫng trình ÿӇ có thӇ sӱ dөng lӟp này. Các hàm này ÿѭӧc viӃt là các phѭѫng thӭc tƭnh do vұy ta không cҫn phҧi tҥo ra thӇ hiӋn cӫa lӟp Math. Bҧng sau liӋt kê mӝt sӕ phѭѫng thӭc tƭnh trong lӟp Math: Tên phѭѫng thӭc Mô tҧ ý nghƭa KiӇu tham sӕ KiӇu trҧ vӅ sin(arg) tính sin cӫa arg arg là mӝt biӇu thӭc kiӇu double double thӇ hiӋn mӝt cung theo radians cos(arg) tính cos cӫa arg arg là mӝt biӇu thӭc kiӇu double double thӇ hiӋn mӝt cung theo radians tan(arg) tính tang cӫa arg arg là mӝt biӇu thӭc kiӇu double double thӇ hiӋn mӝt cung theo radians asin(arg) tính sin-1 (arcsin) arg là mӝt biӇu thӭc kiӇu double trong hӋ Trang 24
arg double thӇ hiӋn mӝt cung radians theo radians acos(arg) tính cos-1 arg là mӝt biӇu thӭc kiӇu double trong hӋ (arccosin) cӫa arg double thӇ hiӋn mӝt cung radians theo radians atan(arg) tính tan-1 arg là mӝt biӇu thӭc kiӇu double trong hӋ (arctang) cӫa arg double thӇ hiӋn mӝt cung radians theo radians atan2 (arg1,arg2) tính tan-1 arg1,arg2 là các biӇu thӭc double trong hӋ (arctang) cӫa kiӇu double thӇ hiӋn mӝt radians cung theo radians arg1/arg2 abs(arg) tính trӏ tuyӋt ÿӕi arg là mӝt biӇu thӭc kiӇu The same type as cӫa arg int, long, float, hoһc double the argument max (arg1,arg2) Nhұn vӅ giá trӏ lӟn arg1, arg2 là mӝt biӇu thӭc Nhұn vӅ kiӇu trong hai tham sӕ kiӇu int, long, float, hoһc cùng kiùu vӟi double tham sӕ min (arg1,arg2) Nhұn vӅ giá trӏ arg1, arg2 lµ mét biùu thøc Nhұn vӅ kiӇu nhӓ trong hai tham kiùu int, long, float, hoÆc cùng kiùu vӟi sӕ double tham sӕ ceil(arg) Nhұn vӅ giá trӏ arg là biӇu thӭc kiӇu float double nguyên nhӓ hѫn hoһc double hoһc bҵng arg floor(arg) Nhұn vӅ giá trӏ arg là biӇu thӭc kiӇu float double nguyên lӟn hѫn hoһc double hoһc bҵng arg round(arg) Trҧ vӅ giá trӏ arg là biӇu thӭc kiӇu float Nhұn vӅ kiӇu int nguyên gҫn arg hoһc double nӃu arg kiêu float, nhҩt, giá trӏ này nhұn vӅ kiùu long chính là giá trӏ cӫa nӃu arg kiӇu arg sau khi ÿã làm double tròn rint(arg) Giӕng nhѭ arg là biӇu thӭc kiӇu double double round(arg) sqrt(arg) tính căn bұc hai arg là biӇu thӭc kiӇu double double cӫa arg pow (arg1,arg2) tính arg1arg2 Cҧ arg1 và arg2 là các biӇu double thӭc kiӇu double exp(arg) tính earg arg là biӇu thӭc kiӇu double double log(arg) tính logarithmӟ sӕ arg là biӇu thӭc kiӇu double double e cӫa arg random() Nhұn vӅ mӝt sӕ Không có tham sӕ double giҧ ngүu nhiên nҵm trong khoҧn [0, 1) Ví dө vӅ các hàm toán hӑc trong lӟp Math, bҥn hãy gõ ÿoҥn chѭѫng trình sau và cho chҥy thӱÿӇ thҩy ÿѭӧc kӃt quҧ tính toán cӫa các hàm toán hӑc. Trang 25
XI. Các phép toán trên kiӇu kí tӵ Ĉӕi vӟi kiӇu kí tӵ ta có thӇ thӵc hiӋn các phép toán sӕ hӑc (nhѭ: +, -, *,/ ) và các phép toán quan hӋ. Ví dͭ: char kt1=’A’; char kt2=tk1+a;// kt2 nhұn ký tӵ B char kt3=(char)33*2;// kt3 nhұn ký tӵ B (kt1>kt2)= false; (kt2=kt3)= false; Trang 26
BÀI 3. Ĉ,ӄU KHIӆN LUӖNG CHѬѪNG TRÌNH Chѭѫng trình là mӝt dүy các lӋnh ÿѭӧc bӕ trí thӵc hiӋn theo mӝt trình tӵ nào ÿó, nhѭng ÿôi khi ta muӕn ÿLӅu khiӇn luӗng thӵc hiӋn cӫa chѭѫng trình tuǤ thuӝc vào ÿiӅu kiӋn gì ÿó. Ngôn ngӳ lұp trình java cung cҩp mӝt sӕ phát biӇu cho phép ta ÿLӅu khiӇn luӗng thӵc hiӋn cӫa chѭѫng trình, chúng ÿѭӧc liӋt kê trong bҧng sau: KiӇu lӋnh Tӯ khoá Lһp while, do-while, for QuyӃt ÿӏnh if-else, switch-case Xӱ lý lӛi try-catch-finally, throw RӁ nhánh break, continue, label:, return I. Cҩu trúc rӁ nhánh 1.1. Phát bi͋u if a) D̩ng khuy͇t Cú pháp if (Boolean-expression) statement; sӵ hoҥt ÿӝng cӫa cҩu trúc if thiӃu ÿѭӧc mô ta qua sѫÿӗ sau: T statement ÿiӅu kiӋn F b) D̩ng ÿͯ Cú pháp if (Boolean-expression) statement1; else statement2; sӵ hoҥt ÿӝng cӫa cҩu trúc if thiӃu ÿѭӧc mô ta qua sѫÿӗ sau: sai ÿúng Statement2 Statement 1 ÿLӅu kiӋn Trang 27
1.2. Bi͋u thͱc ÿL͉u ki͏n Cú pháp: Variable=booleanExpression? true-result-expression: false-result-expression; 1.3. c̭u trúc switch a) D̩ng khuy͇t Cú pháp switch (biӇu_thӭc) { case gt_1: lӋnh 1; [ break;] case gt_2: lӋnh 2; [ break;] case gt_n: lӋnh n; [ break;] } Sau ÿây là sѫÿӗ khӕi mô tҧ sӵ hoҥt ÿӝng cӫa cҩu trúc rӁ nhánh switch dҥng thiӃu Yes biӇu_thӭc Eҵng gt_1 OӋnh 1 break; No biӇu_thӭc Yes Eҵng gt_2 OӋnh 2 break; No biӇu_thӭc Yes Eҵng gt_n OӋnh n break; No Trang 28
b) D̩ng ÿͯ Cú pháp switch(biӇu_thӭc) { case gt_1: lӋnh 1; [ break;] case gt_2: lӋnh 2; [ break;] case gt_n: lӋnh n; [ break;] default: lӋnh n+1; } Sau ÿây là sѫÿӗ khӕi mô tҧ sӵ hoҥt ÿӝng cӫa cҩu trúc switch dҥng ÿӫ Yes biʀu_thͩc Eɮng gt_1 /ʄnh 1 No biʀu_thͩc Yes Eɮng gt_2 /ʄnh 2 No biʀu_thͩc Yes Eɮng gt_n /ʄnh n No Oʄnh n+1 Chú ý: - BiӇu_thӭc phҧi là mӝt biӇu thӭc có kiӇu char, byte, short, int nhѭng không thӇ là kiӇu long, nӃu biӇu_thӭc có kiӇu khác vӟi các kiӇu liӋt kê ӣ trên thì java sӁÿѭa ra mӝt thông báo lӛi. - NӃu biӇu_thӭc bҵng giá trӏ cӫa gt_i thì các lӋnh tӯ lӋnh i cho ÿӃn lӋnh n nӃu không có default (lӋnh n+1 nӃu có default) sӁÿѭӧc thӵc hiӋn. - Câu lӋnh break thoát ra khӓi cҩu trúc switch. 6ѫÿӗ khӕi mô tҧ sӵ hoҥt ÿӝng cӫa cҩu trúc switch trong trѭӡng hӧp có lӋnh break Trang 29
1.4. Toán t͵ÿL͉u ki͏n Toán tӱÿLӅu kiӋn là mӝt loҥi toán tӱÿһc biӋt vì nó gӗm ba thành phҫn cҩu thành biӇu thӭc ÿLӅu kiӋn. hay nói cách khác toán tӱÿLӅu kiӋn là toán tӱ 3 ngôi. Cú pháp : Bi͋u thͱc 1? bi͋u thͱc 2 : bi͋u thͱc 3; Trong ÿó biӇu thӭc 1: BiӇu thӭc 1 là mӝt biӇu thӭc logic. Tӭc là nó trҧ trҧ vӅ giá trӏ True hoһc False biӇu thӭc 2: Giá trӏ trҧ vӅ nӃu biӇu thӭc 1 nhұn giá True. biӇu thӭc 3: Giá trӏ trҧ vӅ nӃu biӇu thӭc 1 nhұn giá trӏ False Chú ý: KiӇu giá trӏ cӫa biӇu thӭc 2 và biӇu thӭc 3 phҧi tѭѫng thích vӟi nhau. Ví dө: ĈRҥn biӇu thӭc ÿLӅu kiӋn sau trҧ vӅ giá trӏ “a là sӕ chҹn” nӃu nhѭ giá trӏ cӫa biӃn a là sӕ chҹn, ngѭӧc lҥi trҧ vӅ giá trӏ “a là sӕ lҿ” nӃu nhѭ giá trӏ cӫa biӃn a là sӕ lҿ. String result=a%2==0 ? ³a là s͙ ch̽Q´ : ³a là s͙ l̓´; II. Cҩu trúc lһp while và do-while 1. L̿p ki͋m tra ÿL͉u ki͏n tr˱ͣc Ta có thӇ sӱ dөng cҩu trúc while ÿӇ thӵc thi lһp ÿi lһp lҥi mӝt lӋnh hoһc mӝt khӕi lӋnh trong khi ÿLӅu kiӋn ÿúng Cú pháp: while (BooleanExpression) { statement; } ta có thӇ thҩy ÿѭӧc luӗng thӵc hiӋn cӫa chѭѫng trình thông qua sѫÿӗ khӕi sau: sai ĈiӅu kiӋn lһp ÿúng LӋnh trѭӟc tiên phát biӇu while sӁ tính giá trӏ cӫa biӇu thӭc logic, nӃu giá trӏ cӫa biӇu thӭc logic là ÿúng thì câu lӋnh trong thân cӫa while sӁÿѭӧc thӵc hiӋn, sau khi thӵc hiӋn xong nó tính lҥi giá trӏ cӫa biӇu thӭc logic, nӃu giá trӏÿúng nó lҥi tiӃp tөc thӵc hiӋn lӋnh trong thân while cho ÿӃn khi giá trӏ cӫa biӇu thӭc sai. Ví dͭ: Trang 30
public class WhileDemo { public static void main(String[] args) { String copyFromMe = "Copy this string until you " + "encounter the letter 'g'."; StringBuffer copyToMe = new StringBuffer(); int i = 0; char c = copyFromMe.charAt(i); while (c! = 'g') { copyToMe.append(c); c = copyFromMe.charAt(++i); } System.out.println(copyToMe); } } Chú ý: + BiӇu thӭc bên trong cһp ngoһc tròn phҧi là mӝt biӇu thӭc logic ( biӇu thӭc trҧ vӅ giá trӏ true hoһc false ) + BiӇu thӭc ÿLӅu kiӋn phҧi nҵm trong cһp ngoһc tròn + Sau tӯ khoá while ta chӍ có thӇÿһt ÿѭӧc duy nhҩt mӝt lӋnh, do vұy ÿӇ có thӇ thӵc hiӋn nhiӅu tác vө sau while ta phҧi bao chúng trong mӝt khӕi lӋnh + Bên trong thân cӫa vòng lһp while ta nên có lӋnh làm thay ÿәi giá trӏ cӫa biӇu thӭc logic, nӃu không chúng ta sӁ rѫi vào vòng lһp vô hҥn. + Câu lӋnh trong thân cҩu trúc while có thӇ không ÿѭӧc thӵc hiӋn lҫn nào (do biӇu thӭc lôgic ban ÿҫu có giá trӏ false ) 2. L̿p ki͋m tra ÿL͉u ki͏n sau Cú pháp: do { statement(s); } while (expression); sӵ hoҥt ÿӝng cӫa cҩu trúc này ÿѭӧc thӇ hiӋn qua sѫÿӗ sau: LӋnh ÿúng ĈLɾu kiʄn lɴp sai Nhìn vào sѫÿӗ này ta thҩy sӵ hoҥt ÿӝng cӫa nó nhѭ sau: b1. Thӵc hiӋn lӋnh b2. Sau khi thӵc hiӋn lӋnh xong nó tính giá trӏ cӫa biӇu thӭc logic Trang 31
b3. NӃu biӇu thӭc logicÿúng nó quay trӣ lҥi b1, nӃu sai thì b4 b4. KӃt thúc vòng lһp và thӵc hiӋn lӋnh sau do-while ví dө: public class DoWhileDemo { public static void main(String[] args) { String copyFromMe = "Copy this string until you " + "encounter the letter 'g'."; StringBuffer copyToMe = new StringBuffer(); int i = 0; char c = copyFromMe.charAt(i); do { copyToMe.append(c); c = copyFromMe.charAt(++i); } while (c! = 'g'); System.out.println(copyToMe); } } Chú ý: + BiӇu thӭc bên trong cһp ngoһc tròn phҧi là mӝt biӇu thӭc logic ( biӇu thӭc trҧ vӅ giá trӏ true hoһc false ) + BiӇu thӭc ÿLӅu kiӋn phҧi nҵm trong cһp ngoһc tròn + Sau tӯ khoá do ta có thӇÿһt ÿѭӧc nhiӅu lӋnh + Bên trong thân cӫa vòng lһp do-while ta nên có lӋnh làm thay ÿәi giá trӏ cӫa biӇu thӭc logic, nӃu không chúng ta sӁ rѫi vào vòng lһp vô hҥn. + Câu lӋnh trong thân cҩu trúc do-while ÿѭӧc thӵc hiӋn ít nhҩt mӝt lҫn III. Cҩu trúc for Ĉây la cҩu trúc lһp phә biӃn nhҩt trong các ngôn ngӳ lұp trình, mà nӝi dung cuҧ vòng lһp cҫn phҧi lһp ÿi lһp lҥi mӝt sӕ lҫn biӃt trѭӟc, cú pháp cӫa nó nhѭ sau: for (initialization; termination; increment) { statement } Trong ÿó: - initialization là giá tr͓ khͧi t̩o tr˱ͣc khi vòng l̿p b̷t ÿ̯u, nó ch͑ÿ˱ͫc th͹c hi͏n duy nhҩt mӝt lân trѭӟc khi vòng lһp bҳt ÿҫu - termination là ÿi͉u ki͏n dùng ÿ͋ k͇t thúc quá trình l̿p - increment là câu l͏nh dùng ÿ͋ÿL͉u khi͋n quá trình l̿p - statement là câu l͏nh mà ta c̯n ph̫i th͹c hi͏n l̿p ÿi l̿p l̩i. 6ѫÿӗ khӕi diӉn giҧi sӵ hoҥt ÿӝng cӫa cҩu trúc for sau: Trang 32
initialization termination ÿúng increment statement Nh̵n xét: + Thân cӫa cҩu trúc lһp for ta chӍ có thӇÿһt ÿѭӧc duy nhҩt mӝt lӋnh, do vұy ÿӇ có thӇ thӵc hiӋn nhiӅu tác vө trong thân for ta phҧi bao chúng trong khӕi lӋnh + Thân vòng lһp for có thӇ không ÿѭӧc thӵc hiӋn lҫn nào + Các phҫn initialization, termination, increment có thӇ khuyӃt tuy nhiên dҩy phҭy dành cho nó vүn phҧi có + Sӕ lҫn thӵc hiӋn initialization=1 + Sӕ lҫn thӵc hiӋn termination = sӕ lҫn lһp +1 + Sӕ lҫn thӵc hiӋn increment = sӕ lҫn lһp + Ta có thӇÿһt mӝt vài khai báo biӃn trong phҫn initialization, nhѭ ví dө sau + Ta có thӇ mô tҧ cҩu trúc while thông qua cҩu trúc for nhѭ sau for (; Boolean_Expression;) statement; Ví dө: kiӋt kê ra 128 các kí tӵ asciii ÿҫu tiên public class ListCharacters { public static void main(String[] args) { for ( char c = 0; c < 128; c++) if (c! = 26 ) // ANSI Clear screen System.out.println( "value: " + (int)c +" character: " + c); } }// /:~ Toán t͵ d̳y và vòng l̿p for Trong bài trѭӟc ta ÿã nhҳc ÿӃn toán tӱ dүy (toán tӱ dүy là mӝt dүy các lӋnh ÿѫn ÿѭӧc cách nhau bӣi dҩu phҭy), trong java chӛ duy nhҩt mà ta có thӇÿһt toán tӱ dүy ÿó là bên trong cҩu trúc lһp for, ta có thӇÿһt toán tӱ dүy cҧ trong phҫn initialization lүn phҫn increment Ví dө vӅ toán tӱ dүy public class CommaOperator { public static void main(String[] args) { for(int i = 1, j = i + 10; i < 5; i++, j = i * 2) { System.out.println("i= " + i + " j= " + j); } } } KӃt quҧ chҥy chѭѫng trình sau: i= 1 j= 11 Trang 33
i= 2 j= 4 i= 3 j= 6 i= 4 j= 8 IV. LӋnh break và continue Bên trong thân cӫa các cҩu trúc lһp ta có thӇÿLӅu khiӇn luӗng thӵc hiӋn bҵng cách sӱ dөng lӋnh break và continue, lӋnh break sӁ chҩm dӭt quá trình lһp mà không thӵc hiӋn nӕt phân còn lҥi cӫa cҩu trúc lһp, continue sӁ ngѭng thӵc thi phҫn còn lҥi cӫa thân vòng lһp và chuyӇn ÿLӅu khiӇn vӅÿLӇm bҳt ÿҫu cӫa vòng lһp, ÿӇ thӵc hiӋn lҫn lһp tiӃp theo, ví dө sau chӍ ra cách sӱ dөng break và continue bên trong cҩu trúc lһp for và while public class BreakAndContinue { public static void main(String[] args) { for(int i = 0; i < 100; i++) { if(i == 74) break;// Out of for loop if(i % 9! = 0) continue;// Next iteration System.out.println(i); } int i = 0; // An "infinite loop": while(true) { i++; int j = i * 27; if(j == 1269) break;// Out of loop if(i % 10! = 0) continue;// Top of loop System.out.println(i); } } } kӃt quҧ chҥy chѭѫng trình sau: 0 9 18 27 36 45 54 63 72 10 20 30 40 Bên trong cҩu trúc lһp for giá trӏ cӫa i không thӇÿҥt ÿѭӧc giá trӏ 100 vì phát biӇu break sӁ kӃt thúc vòng lһp khi i=74 Chú ý: Java không có l͏nh nẖy goto, tuy nhiên trong java v̳n có m͡t vài v͇t tích cӫa lӋnh nhҭy goto ( khét tiӃng và ÿѭӧc coi là nguӗn sinh các lӛi ) ÿó là lӋnh break và continue Trang 34
Nhãn cͯa vòng l̿p Trong thӵc tӃ các vòng lһp có thӇ lӗng vào nhau, mӭc ÿӝ lӗng nhau không hҥn chӃ, thӃ thì câu hӓi ÿһt ra là lӋnh break sӁ thoát ra khӓi vòng lһp nào, câu trҧ lӡi là nó thoát ra khӓi vòng lһp mà lӋnh break ÿѭӧc ÿһt, thӃ thì làm cách nào ta có thӇ cho nó thoát ra khӓi mӝt vòng lһp tuǤ ý nào ÿó, câu trҧ lӡi là java ÿã hӛ trӧ cho ta mӝt công cөÿó là nhãn cӫa vòng lһp. Nhãn là mӝt cái tên sau ÿó có 2 dҩu chҩm Ví dͭ LabelName: Chӛ duy nhҩt mà nhãn có ý nghƭa ÿó là ngay trѭӟc lӋnh lһp, ta không thӇ có bҩt cӭ mӝt lӋnh nào nҵm giӳa nhãn và lӋnh lһp, ta mô tҧ sӵ hoҥt ÿӝng, cách sӱ dөng nhãn cӫa vòng lһp thông qua ví dө sau: public class LabeledFor { public static void (String[] args) { int i = 0; outer: // Can't have statements here for(; true; ) { // infinite loop inner:// Can't have statements here for(; i < 10; i++) { prt("i = " + i); if(i == 2) { prt("continue"); continue; } if(i == 3) { prt("break"); i++; // Otherwise i never // gets incremented. break; } if(i == 7) { prt("continue outer"); i++; // Otherwise i never // gets incremented. continue outer; } if(i == 8) { prt("break outer"); break outer; } for(int k = 0; k < 5; k++) { if(k == 3) { prt("continue inner"); continue inner; } } } } // Can't break or continue // to labels here Trang 35
} static void prt(String s) { System.out.println(s); } } kӃt quҧ chҥy cKѭѫng trình nhѭ sau: i = 0 continue inner i = 1 continue inner i = 2 continue i = 3 break i = 4 continue inner i = 5 continue inner i = 6 continue inner i = 7 continue outer i = 8 break outer Trang 36
Chѭѫng 2: LҰP TRÌNH HѬӞNG ĈӔI TѬӦNG Lӟp là khái niӋm trӑng tâm cӫa lұp trình hѭӟng ÿӕi tѭӧng, java là ngôn ngӳ lұp trình hѭӟng ÿӕi tѭӧng, mӝt chѭѫng trình java gӗm mӝt tұp các ÿӕi tѭӧng, các ÿӕi tѭӧng này phӕi hӧp vӟi nhau ÿӇ tҥo thành mӝt ӭng dөng hoàn chӍnh. Các ÿӕi tѭӧng ÿѭӧc mô tҧ qua khái niӋm lӟp, lӟp là sӵ mӣ rӝng khái niӋm RECORD trong pascal, hay struct cӫa C, ngoài các thành phҫn dӳ liӋu, lӟp còn có các hàm ( phѭѫng thӭc, hành vi ), ta có thӇ xem lӟp là mӝt kiӇu dӳ liӋu, vì vұy ngѭӡi ta còn gӑi lӟp là kiӇu dӳ liӋu ÿӕi tѭӧng. Sau khi ÿӏnh nghƭa lӟp ta có thӇ tҥo ra các ÿӕi tѭӧng ( bҵng cách khai báo biӃn ) cӫa lӟp vӯa tҥo, do vұy có thӇ quan niӋm lӟp là tұp hӧp các ÿӕi tѭӧng cùng kiӇu. Trang 37
BÀI 1. ĈӎNH NGHƬA LӞP I. Khai báo lӟp 1.1. M͡t lͣp ÿ˱ͫc ÿ͓nh nghƭa theo m̳u sau: [pbulic][final][abstract] class { // khai báo các thu͡c tính // khai báo các ph˱˯ng thͱc } sau ÿâu là ví dөÿѫn giҧn ÿӏnh nghƭa lӟp ngăn xӃp: Tәng quát: mӝt lӟp ÿѭӧc khai báo dҥng sau: [public][ ][ class [extends ] [implements ] { } Trong ÿó: 1. Bӣi mһc ÿӏnh mӝt lӟp chӍ có thӇ sӱ dөng bӣi mӝt lӟp khác trong cùng mӝt gói vӟi lӟp ÿó, nӃu muӕn gói khác có thӇ sӱ dөng lӟp này thì lӟp này phҧi ÿѭӧc khai báo là lӟp public. 2. abstract là bә tӯ cho java biӃt ÿây là mӝt lӟp trӯu tѭӧng, do vұy ta không thӇ tҥo ra mӝt thӇ hiӋn cӫa lӟp này 3. final là bә tӯ cho java biӃt ÿây là mӝt lӟp không thӇ kӃ thӯa Trang 38
4. class là tӯ khoá cho chѭѫng trình biӃt ta ÿang khai báo mӝt lӟp, lӟp này có tên là NameOfClass 5. extends là tӯ khoá cho java biӃt lӟp này này ÿѭӧc kӃ thӯa tӯ lӟp super 6. implements là tӯ khoá cho java biӃt lӟp này sӁ triӇn khai giao diӋn Interfaces, ÿây là mӝt dҥng tѭѫng tӵ nhѭ kӃ thӯa bӝi cӫa java. Chú ý: a) Thuӝc tính cӫa lӟp là mӝt biӃn có kiӇu dӳ liӋu bҩt kǤ, nó có thӇ lҥi là mӝt biӃn có kiӇu là chính lӟp ÿó b) Khi khai báo các thành phҫn cӫa lӟp (thuӝc tính và phѭѫng thӭc) có thӇ dùng mӝt trong các tӯ khoá private, public, protectedÿӇ giӭo hҥn sӵ truy cұp ÿӃn thành phҫn ÿó. – Ccác thành phҫn private chӍ có thӇ sӱ dөng ÿѭӧc ӣ bên trong lӟp, ta không thӇ truy cұp vào các thành phҫn private tӯ bên ngoài lӟp – Các thành phҫn public có thӇ truy cұp ÿѭӧc cҧ bên trong lӟp lүn bên ngoài lӟp. – Các thành phҫn protected Wѭѫng tӵ nhѭ các thành phҫn private, nhѭng có thӇ truy cұp ÿѭӧc tӯ bҩt cӭ lӟp con nào kӃ thӯa tӯ nó. – NӃu mӝt thành phҫn cӫa lӟp khi khai báo mà không sӱ dөng mӝt trong 3 bә tӯ protected, private, public thì sӵ truy cұp là bҥn bè, tӭc là thành phҫn này có thӇ truy cұp ÿѭӧc tӯ bҩt cӭ lӟp nào trong cùng gói vӟi lӟp ÿó. c) Các thuӝc tính nên ÿӇ mӭc truy cұp private ÿӇÿҧm bҧo tính dҩu kín và lúc ÿó ÿӇ bên ngoài phҥm vi cӫa lӟp có thӇ truy cұp ÿѭӧc ÿӃn thành phҫn private này ta phҧi tҥo ra các phѭѫng thӭc phѭѫng thӭc get và set. d) Các phѭѫng thӭc thѭӡng khai báo là public, ÿӇ chúng có thӇ truy cұp tӯ bҩt cӭÿâu. e) Trong mӝt tӋp chѭѫng trình (hay còn gӑi là mӝt ÿѫn vӏ biên dӏch) chӍ có mӝt lӟp ÿѭӧc khai báo là public, và tên lӟp public này phҧi trùng vӟi tên cӫa tӋp kӇ cҧ chӳ hoa, chӳ thѭӡng 1.2. Khai báo thu͡c tính Trӣ lҥi lӟp Stack public class Stack { private Vector items; // a method with same name as a member variable public Vector items() { } } Trong lӟp Stack trên ta có mӝt thuӝc tính ÿѭӧc ÿӏnh nghƭa nhѭ sau: private Vector items; ViӋc khai báo nhѭ trên ÿѭӧc gӑi là khai báo thuӝc tính hay còn gӑi là biӃn thành viên lӟp Tәng quát viӋc khai báo mӝt thuӝc tính ÿѭӧc viӃt theo mүu sau: Trong ÿó: Trang 39
Ø accessLevel có th͋ là m͡t trong các tͳ public, private, protected ho̿c có th͋ b͗ trӕng, ý nghƭa cӫa các bә tӯ này ÿѭӧc mô tҧӣ phҫn trên Ø - static là tͳ khoá báo r̹ng ÿây là m͡t thu͡c tính lͣp, nó là m͡t thu͡c tính s͵ dөng chung cho cҧ lӟp, nó không là cӫa riêng mӝt ÿӕi tѭӧng nào. Ø - transient và volatile ch˱a ÿ˱ͫc dùng Ø - type là m͡t ki͋u dͷ li͏u nào ÿó Ø name là tên cͯa thu͡c tính Chú ý: Ta phҧi phân biӋt ÿѭӧc viӋc khai báo nhѭ thӃ nào là khai báo thuӝc tính, khai báo thӃ nào là khai báo biӃn thông thѭӡng? Câu trҧ lӡi là tҩt cҧ các khai báo bên trong thân cӫa mӝt lӟp và bên ngoài tҩt cҧ các phѭѫng thӭc và hàm tҥo thì ÿó là khai báo thuӝc tính, khai báo ӣ nhӳng chӛ khác sӁ cho ta biӃn. 1.3. Khai báo ph˱˯ng thͱc Trong lӟp Stack trên ta có phѭѫng thӭc push dùng ÿӇÿҭy mӝt ÿӕi tѭӧng vào ÿӍnh ngăn xӃp, nó ÿѭӧc ÿӏnh nghƭa nhѭ sau: CǊng giӕng nhѭ mӝt lӟp, mӝt phѭѫng thӭc cǊng gӗm có 2 phҫn: phҫn khai báo và ph̯n thân - Phҫn khai báo gӗm có nhӳng phҫn sau( chi tiӃt cӫa khai báo ÿѭӧc mô tҧ sau): - Phҫn thân cӫa phѭѫng thӭc gӗm các lӋnh ÿӇ mô tҧ hành vi cӫa phѭѫng thӭc, các hành vi này ÿѭӧc viӃt bҵng các lӋnh cӫa java. II. Chi tiӃt vӅ khai báo mӝt phѭѫng thӭc 1. T͝ng quát m͡t ph˱˯ng thͱc ÿ˱ͫc khai báo nh˱ sau: accessLevel //mô tҧ mӭc ÿӝ truy cұp ÿӃn phѭѫng thӭc static //ÿây là phѭѫng thӭc lӟp abstract //ÿây là phѭѫng thӭc không có cài ÿһt final //phѭѫng thӭc này không thӇ ghi ÿè native //phѭѫng thӭc nàyÿѭӧc viӃt trong mӝt ngôn ngӳ khác synchronized //ÿây là phѭѫng thӭc ÿӗng bӝ returnType //giá trӏ trҧ vӅ cӫa phѭѫng thӭc MethodName //tên cӫa phѭѫng thӭc throws //khai báo các ngoҥi lӋ có thӇ ÿѭӧc nem ra tӯ phѭѫng exception thӭc Trong ÿó: Trang 40
- accessLevel có thӇ là mӝt trong các tӯ khoá public, private, protected hoһc bӓ trӕng, ý nghƭa cӫa các bә tӯ này ÿѭӧc mô tҧ trong phҫn khai báo lӟp - static là tӯ khoá báo cho java biӃt ÿây là mӝt phѭѫng thӭc lӟp - abstract tӯ khoá cho biӃt ÿây là mӝt lӟp trӯu tѭӧng, nó không có cài ÿһt. - final ÿây là tӯ khoá báo cho java biӃt ÿây là phѭѫng thӭc không thӇ ghi ÿè tӯ lӟp con - nativeÿây là tӯ khoá báo cho java biӃt phѭѫng thӭc này ÿѭӧc viӃt bҵng mӝt ngôn ngӳ lұp trình nàoÿó không phҧi là java ( thѭӡng ÿѭӧc viӃt bҵng C/C++) - synchronizedÿây là mӝt phѭѫng thӭc ÿӗng bӝ, nó rҩt hӳu ích khi nhiӅu phѭѫng thӭc cùng truy cұpÿӗng thӡi vào tài nguyên miӅn găng - returnType là mӝt kiӇu dӳ liӋu, ÿây là kiӇu trҧ vӅ cӫa phѭѫng thӭc, khi phѭѫng thӭc không trҧ vӅ dӳ liӋu thì phҧi dùng tӯ khoá void - MethodName là tên cӫa phѭѫng thӭc, tên cӫa phѭѫng thӭc ÿѭӧc ÿһt theo quy tҳc ÿһt tên cӫa java - throws là tӯ khoá dùng ÿӇ khai báo các ngoҥi lӋ có thӇÿѭӧc ném ra tӯ phѭѫng thӭc, theo sau tӯ khoá này là danh sách các ngoҥi lӋ có thӇÿѭӧc phѭѫng thӭc này ném ra Chú ý: 1) NӃu trong lӟp có ít nhҩt mӝt phѭѫng thӭc trӯu tѭӧng thì lӟp ÿó phҧi là lӟp trӯu Wѭӧng 2) không có thuӝc tính trӯu tѭӧng 3) ta không thӇ tҥo ÿӕi tѭӧng cӫa lӟp trӯu tѭӧng 4) khác vӟi ngôn ngӳ C/C++, java bҳt buӝc bҥn phҧi khai báo giá trӏ trҧ vӅ cho phѭѫng thӭc, nӃu phѭѫng thӭc không trҧ vӅ dӳ liӋu thi dùng tӯ khoá void (trong C/C++ khi ta không khai báo giá trӏ trҧ vӅ thì mһc ÿӏnh giá trӏ trҧ vӅ là int) 2. Nh̵n giá tr͓ tr̫ v͉ tͳ ph˱˯ng thͱc Ta khai báo kiӇu giá trӏ trҧ vӅ tӯ lúc ta khai báo phѭѫng thӭc, bên trong thân cӫa phѭѫng thӭc ta phҧi sӱ dөng phát biӇu return value; ÿӇ nhұn vӅ kӃt quҧ, nӃu hàm ÿѭӧc khai báo kiӇu void thì ta chӍ sӱ dөng phát biӇu return; mӋnh ÿӅ return ÿôi khi còn ÿѭӧc dùng ÿӇ kӃt thúc mӝt phѭѫng thӭc. 3. Truy͉n tham s͙ cho ph˱˯ng thͱc Khi ta viӃt các phѭѫng thӭc, mӝt sӕ phѭѫng thӭc yêu cҫu phҧi có mӝt sӕ tham sӕ, các tham sӕ cӫa mӝt phѭѫng thӭc ÿѭӧc khai báo trong lӡi khai báo phѭѫng thӭc, chúng phҧi ÿѭӧc khai báo chi tiӃt có bao nhiêu tham sӕ, mӛi tham sӕ cҫn phҧi cung cҩp cho chúng mӝt cái tên và kiӇu dӳ liӋu cӫa chúng. Ví dө: ta có mӝt phѭѫng thӭc dùng ÿӇ tính tәng cӫa hai sӕ, phѭѫng thӭc này ÿѭӧc khai báo nhѭ sau: public double tongHaiSo(double a, double b){ return (a + b); } 1. Ki͋u tham s͙ Trong java ta có thӇ truyӅn vào phѭѫng thӭc mӝt tham sӕ có kiӇu bҩt kǤ, tӯ kiӇu dӳ liӋu nguyên thuӹ cho ÿӃn tham chiӃu ÿӕi tѭӧng. 2. Tên tham s͙ Khi bҥn khai báo mӝt tham sӕÿӇ truyӅn vào phѭѫng thӭc thì bҥn phҧi cung cҩp cho nó mӝt cái tên, tên nay ÿѭӧc sӱ dөng bên trong thân cӫa phѭѫng thӭc ÿӇ tham chiӃu ÿӃn tham sӕÿѭӧc truyӅn vào. Trang 41
Chú ý: Tên cӫa tham sӕ có thӇ trùng vӟi tên cӫa thuӝc tính, khi ÿó tên cӫa tham sӕ sӁ “che” ÿi tên cӫa phѭѫng thӭc, bӣi vұy bên trong thân cӫa phѭѫng thӭc mà có tham sӕ có tên trùng vӟi tên cӫa thuӝc tính, thì khi nhҳc ÿӃn cái tên ÿó có nghƭa là nhҳc ÿӃn tham sӕ. 3. Truy͉n tham s͙ theo tr͓ Khi gӑi mӝt phѭѫng thӭc mà tham sӕ cӫa phѭѫng thӭc có kiӇu nguyên thuӹ, thì bҧn sao giá trӏ cӫa tham sӕ thӵc sӵ sӁÿѭӧc chuyӇn ÿӃn phѭѫng thӭc, ÿây là ÿһc tính truyӅn theo trӏ ( pass- by – value ), nghƭa là phѭѫng thӭc không thӇ thay ÿәi giá trӏ cӫa các tham sӕ truyӅn vào. Ta kiӇm tra ÿLӅu này qua ví dө sau: public class TestPassByValue { public static void test(int t) { t++; System.out.println("Gia tri cӫa t bi?n trong ham sau khi tang len 1 la " + t); } public static void main(String[] args) { int t = 10; System.out.println("Gia tri cӫa t tru?c khi gӑi ham = " + t); test(t); System.out.println("Gia tri cӫa t truoc khi gӑi ham = " + t); } } Ta sӁ nhұn ÿѭӧc kӃt quҧ ra nhѭ sau: Gia tri cӫa t truoc khi gӑi ham = 10 Gia tri cӫa t bên trong ham sau khi tang len 1 la 11 Gia tri cӫa t truoc khi gӑi ham = 10 4. Thân cͯa ph˱˯ng thͱc Trong ví dө sau thân cӫa phѭѫng thӭc isEmpty và phѭѫng thӭc popÿѭӧc in ÿұm và có mҫu ÿӓ class Stack { static final int STACK_EMPTY = -1; Object[] stackelements; int topelement = STACK_EMPTY; boolean isEmpty() { if (topelement == STACK_EMPTY) return true; else return false; } Object pop() { if (topelement == STACK_EMPTY) return null; else { return stackelements[topelement ]; } } Ví dө: Xây dӵng lӟp man import java.lang.*; import java.io.*; import java.util.*; public class Man Trang 42
{protected String ten; int namsinh; public Man(String name,int birthday){ ten=name;namsinh=birthday; } public int tuoi() {Calendar now=Calendar.getInstance(); return (now.get(Calendar.YEAR) - namsinh); } public void hienthi() {System.out.println("Ho va ten:"+ten); System.out.println("Ho va ten:"+tuoi()); } public void HienThiNgay() { Calendar now=Calendar.getInstance(); System.out.println("Ngay hien tai=" +now.get(Calendar.DATE)); System.out.println("Thang hien tai=" +now.get(Calendar.MONTH)); System.out.println("Nam hien tai=" +now.get(Calendar.YEAR)); System.out.println("Gio hien tai=" +now.get(Calendar.HOUR)); System.out.println("Phut hien tai=" +now.get(Calendar.SECOND)); } III. Tӯ khoá this Thông thѭӡng bên trong thân cӫa mӝt phѭѫng thӭc ta có thӇ tham chiӃu ÿӃn các thuӝc tính cӫa ÿӕi tѭӧng ÿó, tuy nhiên trong mӝt sӕ tình huӕng ÿһc biӋt nhѭ tên cӫa tham sӕ trùng vӟi tên cӫa thuӝc tính, lúc ÿó ÿӇ chӍ các thành viên cӫa ÿӕi tѭӧng ÿó ta dùng tӯ khoá this, tӯ khoá this dùng ÿӇ chӍÿӕi tѭӧng này. Ví dө sau chӍ ra cho ta thҩy trong tình huӕng này bҳt buӝc phҧi dùng tӯ khoá this vì tên tham sӕ cӫa phѭѫng thӭc tҥo dӵng lҥi trùng vӟi tên cӫa thuӝc tính class HSBColor { int hue, saturation, brightness; HSBColor (int hue, int saturation, int brightness) { this.hue = hue; this.saturation = saturation; this.brightness = brightness; } IV. Tӯ khoá super Khi mӝt lӟp ÿѭӧc kӃ thӯa tӯ lӟp cha trong cҧ lӟp cha và lӟp con ÿӅu có mӝt phѭѫng thӭc trùng tên nhau, thӃ thì làm thӃ nào có thӇ gӑi phѭѫng thӭc trùng tên ÿó cӫa lӟp cha, java cung cҩp cho ta tӯ khoá super dùng ÿ͋ ch͑ÿ͙i t˱ͫng cͯa lͣp cha Ta xét ví dө sau class ASillyClass { boolean aVariable; void aMethod() { aVariable = true; } } Trang 43
class ASillierClass extends ASillyClass { boolean aVariable; void aMethod() { aVariable = false; super.aMethod(); System.out.println(aVariable); System.out.println(super.aVariable); } } trong ví dө trên ta thҩy trong lӟp cha có phѭѫng thӭc tên là aMethod trong lӟp con cǊng có mӝt phѭѫng thӭc cùng tên, ta còn thҩy cҧ hai lӟp này cùng có mӝt thuӝc tính tên aVariable ÿӇ có thӇ truy cұp vào các thành viên cӫa lӟp cha ta phҧi dùng tӯ khoá super. Chú ý: Ta không thӇ dùng nhiӅu tӯ khoá này ÿӇ chӍ lӟp ông, lӟp cө chҷng hҥn viӃt nhѭ sau là sai: super.super.add(1,4); V. Sӱ dөng lӟp Sau khi khao mӝt mӝt lӟp ta có thӇ xem lӟp nhѭ là mӝt kiӇu dӳ liӋu, nên ta có thӇ tҥo ra các biӃn, mҧng các ÿӕi tѭӧng, viӋc khai báo mӝt biӃn, mҧng các ÿӕi tѭӧng cǊng Wѭѫng tӵ nhѭ khai báo mӝt biӃn, mҧng cӫa kiӇu dӳ liӋu nguyên thuӹ ViӋc khai báo mӝt biӃn, mҧng ÿѭӧc khai báo theo mүu sau: ; [kích thѭӟc mҧng]; [kích thѭӟc mҧng] ; VӅ bҧn chҩt mӛi ÿӕi tѭӧng trong java là mӝt con trӓ tӟi mӝt vùng nhӟ, vùng nhӟ này chính là vùng nhӟ dùng ÿӇ lѭu trӳ các thuӝc tính, vùng nhӟ dành cho con trӓ này thì ÿѭӧc cҩp phát trên stack, còn vùng nhӟ dành cho các thuӝc tính cӫa ÿӕi tѭӧng này thì ÿѭӧc cҩp phát trên heap. VI. ĈiӅu khiӇn viӋc truy cұp ÿӃn các thành viên cӫa mӝt lӟp Khi xây dӵng mӝt lӟp ta có thӇ hҥn chӃ sӵ truy cұp ÿӃn các thành viên cӫa lӟp, tӯ mӝt ÿӕi tѭӧng khác. Ta tóm tҳt qua bҧng sau: Tӯ khoá Truy cұp Truy cұp Truy cұp Truy cұp trong Truy cұp trong trong trong lӟp trong lӟp lӟp khác cùng gói lӟp khác khác gói chính lӟp con cùng con khác ÿó gói gói private X - - - - protected X X X X - public X X X X X default X X - X - Trong bҧng trên thì X thӇ hiӋn cho sӵ truy cұp hӧp lӋ còn – thӇ hiӋn không thӇ truy cұp vào thành phҫn này. 1. Các thành ph̯n private Các thành viên private chӍ có thӇ sӱ dөng bên trong lӟp, ta không thӇ truy cұp các thành viên private tӯ bên ngoài lӟp này. Ví dͭ: class Alpha Trang 44
{ private int iamprivate; private void privateMethod() { System.out.println("privateMethod"); } } class Beta { void accessMethod() { Alpha a = new Alpha(); a.iamprivate = 10;// không hӧp lӋ a.privateMethod();// không hӧp lӋ } } 2. Các thành ph̯n protected Các thành viên protected sӁÿѭӧc thҧo luұn trong chѭѫng sau 3. Các thành ph̯n public Các thành viên public có thӇ truy cұp tӯ bҩt cӭÿâu, ta se xem ví dө sau: package Greek; public class Alpha { public int iampublic; public void publicMethod() { System.out.println("publicMethod");} } package Roman; import Greek.*; class Beta { void accessMethod() { Alpha a = new Alpha(); a.iampublic = 10; // hӧp lӋ a.publicMethod(); // hӧp lӋ } } 4. Các thành ph̯n có mͱc truy xṷt gói Khi ta khai báo các thành viên mà không sӱ dөng mӝt trong các tӯ public, private, protected thì java mһc ÿӏnh thành viên ÿó có mӭc truy cұp gói. Ví dө package Greek; class Alpha { int iampackage; void packageMethod() { System.out.println("packageMethod");} } package Greek; class Beta { Trang 45
void accessMethod() { Alpha a = new Alpha();a.iampackage = 10;// legal a.packageMethod();// legal} } Trang 46
BÀI 2. KHӢI ĈҪU VÀ DӐN DҼP I. Phѭѫng thӭc tҥo dӵng (constructor) 1. Công dͭng Phѭѫng thӭc tҥo dӵng là mӝt phѭѫng thӭc cӫa lӟp ( nhѭng khá ÿһc biӋt ) thѭӡng dùng ÿӇ khӣi tҥo mӝt ÿӕi tѭӧng mӟi. Thông thѭӡng ngѭӡi ta thѭӡng sӱ dөng hàm tҥo ÿӇ khӣi gán giá trӏ cho các thuӝc tính cӫa ÿӕi tѭӧng và có thӇ thӵc hiӋn mӝt sӕ công viӋc cҫn thiӃt khác nhҵm chuҭn bӏ cho ÿӕi tѭӧng mӟi. 2. Cách vi͇t hàm t̩o a) ÿ̿c ÿL͋m cͯa ph˱˯ng thͱc t̩o d͹ng Ø hàm tҥo có tên trùng vӟi tên cӫa lӟp Ø hàm tҥo không bao giӡ trҧ vӅ kӃt quҧ Ø nó ÿѭӧc java gӑi tӵÿӝng khi mӝt ÿӕi tѭӧng cӫa lӟp ÿѭӧc tҥo ra Ø hàm tҥo có thӇ có ÿӕi sӕ nhѭ các phѭѫng thӭc thông thѭӡng khác Ø trong mӝt lӟp có thӇ có nhiӅu hàm tҥo b) Ví dͭ Ví dͭ 1: sӱ dөng hàm tҥo ÿӇ in ra màn hình xâu “Creating Rock” class Rock { Rock() {// This is the constructor System.out.println("Creating Rock"); } } public class SimpleConstructor { public static void main(String[] args) { for(int i = 0; i < 10; i++) new Rock();// call constructor } } Ví dͭ 2: sӱ dөng hàm tҥo có ÿӕi class Rock2 { Rock2(int i) { System.out.println( "Creating Rock number " + i); } } public class SimpleConstructor2 { public static void main(String[] args) { for(int i = 0; i < 10; i++) new Rock2(i);// gӑi hàm tҥo có ÿӕi } }// /:~ 3. Hàm t̩o m̿c ÿ͓nh Khi xây dӵng mӝt lӟp mà không xây dӵng hàm tҥo thӃ thì java sӁ cung cҩp cho ta mӝt hàm tҥo không ÿӕi mһc ÿӏnh, hàm tҥo này thӵc chҩt không làm gì cҧ, nӃu trong lӟp ÿã có ít nhҩt mӝt hàm tҥo thì hàm tҥo mһc ÿӏnh sӁ không ÿѭӧc tҥo ra, khi ta tҥo ra mӝt ÿӕi Wѭӧng thì sӁ có mӝt hàm tҥo nào ÿó ÿѭӧc gӑi, nӃu trình biên dӏch không tìm thҩy hàm tҥo Wѭѫng ӭng nó sӁ thông báo lӛi, ÿLӅu này thѭӡng xҭy ra khi chúng ta không xây dӵng hàm Trang 47
tҥo không ÿӕi nhѭng khi tҥo dӵng ÿӕi tѭӧng ta lҥi không truyӅn vào tham sӕ, nhѭÿѭӧc chӍ ra trong ví dө sau: public class TestPassByValue { public TestPassByValue(String s) { System.out.println(s); } public static void main(String[] args) { TestPassByValue thu = new TestPassByValue(); // lӛi vì lӟp này không có hàm tҥo không ÿӕi TestPassByValue thu1 = new TestPassByValue("Hello World"); // không vҩn ÿӅ gì } } 4. G͕i hàm t̩o tͳ hàm t̩o Khi bҥn viӃt nhiӅu hàm tҥo cho lӟp, có ÿôi lúc bҥn muӕn gӑi mӝt hàm tҥo này tӯ bên trong mӝt hàm tҥo khác ÿӇ tránh phҧi viӃt lһp mã. ĈӇ có thӇ gӑi ÿӃn hàm tҥo ta sӱ dөng tӯ khoá this. Cú pháp this(danh sách ÿӕi sӕ); Ví dө: public class Test { public Test () { System.out.println("hàm tҥo không ÿӕi"); } public Test ( int i) { this();// gӑi ÿӃn hàm tҥo không ÿӕi cӫa chính lӟp này } public static void main(String[] args) { TestPassByValue thu=new TestPassByValue(10); } } Chú ý: a) bên trong cҩu tӱ ta chӍ có thӇ gӑi ÿѭӧc tӕi ÿa mӝt cҩu tӱ, ÿLӅu này có nghƭa là ta không thӇ gӑi ÿѭӧc tӯ 2 cҩu tӱ trӣ lên bên trong mӝt cҩu tӱ khác nhѭÿѭӧc chӍ ra trong ví dө sau: public class TestPassByValue { public TestPassByValue() { System.out.println("Day la ham tao khong doi"); } public TestPassByValue(int i) { System.out.println("Day la ham tao doi so nguyen"); } public TestPassByValue(String s) { this();// không thӇ gӑi hai hàm tҥo trӣ lên bên trong mӝt hàm tҥo this(10); System.out.println("Day la ham tao doi so xau"); } Trang 48
public static void main(String[] args) { TestPassByValue thu = new TestPassByValue();// TestPassByValue thu1 = new TestPassByValue("Hello World");// } } b) khi gӑi mӝt hàm tҥo bên trong mӝt hàm tҥo khác thì lӡi gӑi hàm tҥo phҧi là lӋnh ÿҫu tiên trong thân phѭѫng thӭc, nên ví dө sau sӁ bӏ báo lӛi public class Test{ public Test () { System.out.println("Day la ham tao khong doi"); } public Test (String s) { System.out.println("Day la ham tao doi so xau"); this();// gͥi ÿ͗n c̽u t΅ ph̻i là l͟nh ÿ̿u tiên } public static void main(String[] args) { Test thu = new Test (³Hello World´); } } nӃu cho dӏch ví dө trên trình biên dӏch sӁ phàn nàn "Test.java": call to this must be first statement in constructor at line 7, column 9 II. Khӕi khӣi ÿҫu vô danh và khӕi khӣi ÿҫu tƭnh 1. Kh͙i vô danh Trong java ta có thӇÿһt mӝt khӕi lӋnh không thuӝc mӝt phѭѫng thӭc nào, nghƭa là khӕi này không thuӝc bҩt cӭ phѭѫng thӭc nào kӇ cҧ hàm tҥo. khi ÿó khӕi lӋnh này ÿѭӧc gӑi là khӕi vô danh, khӕi vô danh này ÿѭӧc java gӑi thӵc thi khi mӝt ÿӕi tѭӧng ÿѭӧc tҥo ra, các khӕi vô danh ÿѭӧc gӑi trѭӟc cҧ hàm tҥo, thông thѭӡng ta hay sӱ dөng khӕi vô danh ÿӇ khӣi ÿҫu các thuӝc tính cӫa lӟp hoһc ÿѭӧc sӱ dөng ÿӇ khӣi tҥo cho các thӝc tính cӫa mӝt lӟp vô danh(vì lӟp vô danh không có tên do vұy ta không thӇ viӃt hàm tҥo cho lӟp này, trong trѭӡng hӧp này khӕi vô danh là giҧi pháp duy nhҩt ) Ví dө: ӣ ví dө này ta có 3 khӕi vô danh, khi chҥy java cho thӵc thi các khӕi vô danh này theo thӭ tӵ tӯ trên xuӕng dѭӟi public class Untitled1{ // hàm tҥo public Untitled1 (){ System.out.println ( "Day la ham tao" ); } // b͇t ÿ̿u khͩi vô danh { System.out.println ( "khoi khoi dau thu 3 "); }// k͗t thúc khͩi vô danh //b͇t ÿ̿u khͩi vô danh { System.out.println ( "khoi khoi dau thu 1 "); }//k͗t thúc khͩi vô danh // b͇t ÿ̿u khͩi vô danh { Trang 49
System.out.println ( "khoi khoi dau thu 2 "); }//k͗t thúc khͩi vô danh public static void main ( String[] args ) { Untitled1 dt1 = new Untitled1 (); Untitled1 dt2 = new Untitled1 (); } } khi chҥy chѭѫng trình sӁ cho kӃt quҧ sau: khoi khoi dau thu 3 khoi khoi dau thu 1 khoi khoi dau thu 2 Day la ham tao khoi khoi dau thu 3 khoi khoi dau thu 1 khoi khoi dau thu 2 Day la ham tao 2. Kh͙i khͧi ÿ̯u tƭnh Khӕi khӣi ÿҫu tƭnh là mӝt khӕi lӋnh bên ngoài tҩt cҧ các phѭѫng thӭc, kӇ cҧ hàm tҥo, trѭӟc khӕi lӋnh này ta ÿһt tӯ khoá static, tӯ khoá này báo cho java biӃt ÿây là khӕi khӣi ÿҫu tƭnh, khӕi này chӍÿѭӧc gӑi 1 lҫn khi ÿӕi tѭӧng ÿҫu tiên cӫa lӟp này ÿѭӧc tҥo ra, khӕi khӣi ÿҫu tƭnh này cǊng ÿѭӧc java gӑi tӵÿӝng trѭӟc bҩt cӭ hàm tҥo nào, thông tKѭӡng ta sӱ dөng khӕi khӣi ÿҫu tƭnh ÿӇ khӣi ÿҫu các thuӝc tính tƭnh ( static ), sau ÿây là mӝt ví dө có 1 khӕi khӣi ÿҫu tƭnh và mӝt khӕi vô danh, ÿӇ bҥn thҩy ÿѭӧc sӵ khác nhau giӳa khӕi khӣi ÿҫu tƭnh và khӕi vô danh public class Untitled1 { public Untitled1 () { System.out.println ( "Ĉây là hàm tҥo" ); } static {// ÿây là khͩi khͷi ÿ̿u tƭnh System.out.println ( "Ĉây là khͩi khͷi ÿ̿u tƭnh"); System.out.println("Khͩi này ch͡ÿ́ͻc gͥi 1 l̿n khi th͛ hi͟n ÿ̿u tiên cͿa lͳp ÿ́ͻc W̹o ra"); } {//ÿây là khͩi vô danh System.out.println ( "Ĉây là khͩi vô danh "); } public static void main ( String[] args ) { Untitled1 dt1 = new Untitled1 ();/ / tҥo ra thӇ hiӋn thӭ nhҩt cӫa lӟp Untitled1 dt2 = new Untitled1 ();/ / tҥo tiӃp thӇ hiӋn thѭ 2 cӫa lӟp } } khi cho chҥy chѭѫng trình ta sӁÿѭӧc kӃt quҧ ra nhѭ sau: Ĉây là khӕi khӣi ÿҫu tƭnh Khӕi này chӍÿѭӧc gӑi 1 lҫn khi thӇ hiӋn ÿҫu tiên cӫa lӟp ÿѭӧc tҥo ra Trang 50
Ĉây là khӕi vô danh Ĉây là hàm tҥo Ĉây là khӕi vô danh Ĉây là hàm tҥo Nhìn vào kӃt quҧ ra ta thҩy khӕi khӣi ÿҫu tƭnh chӍÿѭӧc java gӑi thӵc hiӋn 1 lҫn khi ÿӕi Wѭӧng ÿҫu tiên cӫa lӟp này ÿѭӧc tҥo, còn khӕi vô danh ÿѭӧc gӑi mӛi khi mӝt ÿӕi tѭӧng mӟi ÿѭӧc tҥo ra III. Dӑn dҽp: kӃt thúc và thu rác 1. Ph˱˯ng thͱc finalize Java không có phѭѫng thӭc hӫy bӓ. Phѭѫng thӭc finalize tѭѫng tӵ nhѭ phѭѫng thӭc hӫy bӓ cӫa C++, tuy nhiên nó không phҧi là phѭѫng thӭc hӫy bӓ. Sӣ dƭ nó không phҧi là phѭѫng thӭc hӫy bӓ vì khi ÿӕi tѭӧng ÿѭӧc hӫy bӓ thì phѭѫng thӭc này chѭa chҳc ÿã ÿѭӧc gӑi ÿӃn. Phѭѫng thӭc này ÿѭӧc gӑi ÿӃn chӍ khi bӝ thu rác cӫa Java ÿѭӧc khӣi ÿӝng và lúc ÿó ÿӕi tѭӧng không còn ÿѭӧc sӱ dөng nӳa. Do vұy phѭѫng thӭc finalize có thӇ không ÿѭӧc gӑi ÿӃn. 2. C˯ ch͇ gom rác cͯa java Ngѭӡi lұp trình C++ thѭӡng sӱ dөng toán tӱ new ÿӇ cҩp phát ÿӝng mӝt ÿӕi tѭӧng, nhѭng lҥi thѭӡng quên gӑi toán tӱ delete ÿӇ giҧi phóng vùng nhӟ này khi không còn dùng ÿӃn nӳa, ÿLӅu này làm rò rӍ bӝ nhӟÿôi khi dүn ÿӃn chѭѫng trình phҧi kӃt thúc mӝt cách bҩt thѭӡng, quҧ thұt ÿâu là mӝt ÿLӅu tӗi tӋ. Trong java ta không cҫn quan tâm ÿӃn ÿLӅu ÿó, java có mӝt cѫ chӃ thu rác tӵÿӝng, nó ÿӫ thông minh ÿӇ biӃt ÿӕi tѭӧng tѭӧng nào không dùng nӳa, rӗi nó tӵÿӝng thu hӗi vùng nhӟ dành cho ÿӕi tѭӧng ÿó. Trong ngôn ngӳ C++ khi mӝt ÿӕi tѭӧng bӏ phá huӹ, sӁ có mӝt hàm ÿѭӧc gӑi tӵ ÿӝng, hàm này ÿѭӧc gӑi là huӹ tӱ hay còn gӑi là hàm huӹ, thông thѭӡng hàm hàm huӹ mһc ÿӏnh là ÿӫ là ÿӫÿӇ dӑn dҽp, tuy nhiên trong mӝt sӕ trѭӡng hӧp thì hàm huӹ mһc ÿӏnh lҥi không thӇÿáp ӭng ÿѭӧc, do vұy ngѭӡi lұp trình C++, phҧi viӃt ra hàm huӹ riêng ÿӇ làm viӋc ÿó, tuy nhiên java lҥi không có khái niӋm hàm huӹ hay mӝt cái gì ÿó tѭѫng tӵ. Trang 51
BÀI 3. CÁC THÀNH PHҪN TƬNH I. Thuӝc tính tƭnh Thuӝc tính ÿѭӧc khai báo vӟi tӯ khoá static gӑi là thuӝc tính tƭnh Ví dө: class Static{ static int i = 10;// Ĉây là thuӝc tính tƭnh int j = 10;// Ĉây là thuӝc tính thѭӡng } + Các thuӝc tính tƭnh ÿѭӧc cҩp phát mӝt vùng bӝ nhӟ cӕÿӏnh, trong java bӝ nhӟ dành cho các thuӝc tính tƭnh chӍÿѭӧc cҩp phát khi lҫn ÿҫu tiên ta truy cұp ÿӃn nó. + Thành phҫn tƭnh là chung cӫa cҧ lӟp, nó không là cӫa riêng mӝt ÿӕi tѭӧng nào cҧ. + ĈӇ truy xuҩt ÿӃn thuӝc tính tƭnh ta có thӇ dùng mӝt trong 2 cách sau: tên_lӟp.tên_thuӝc_tính_tƭnh; tên_ÿӕi_tѭѫng.tên_thuӝc_tính_tƭnh; cҧ 2 cách truy xuҩt trên ÿӅu có tác dөng nhѭ nhau + khӣi gán giá trӏ cho thuӝc tính tƭnh thành phҫn tƭnh ÿѭӧc khӣi gán bҵng mӝt trong 2 cách sau: Ø Sӱ dөng khӕi khӣi ÿҫu tƭnh (xem lҥi bài trѭӟc ) Ø Sӱ dөng khӣi ÿҫu trӵc tiӃp khi khai báo nhѭ ví dө trên Chú ý: Ta không th͋ s͵ dͭng hàm t̩o ÿ͋ khͧi ÿ̯u các thu͡c tính tƭnh, bͧi vì hàm t̩o không ph̫i là ph˱˯ng thͱc tƭnh. II. Phѭѫng thӭc tƭnh Mӝt phѭѫng thӭc ÿѭӧc khai báo là static ÿѭӧc gӑi là phѭѫng thӭc tƭnh Ví dө: class Static{ static int i;// Ĉây là thuӝc tính tƭnh // phѭѫng thӭc tƭnh static void println (){ System.out.println ( i ); } } + Phѭѫng thӭc tƭnh là chung cho cҧ lӟp, nó không lӋ thuӝc vào mӝt ÿӕi tѭӧng cө thӇ nào + Lӡi gӑi phѭѫng thӭc tƭnh xuҩt phát tӯ: tên cӫa lӟp: tên_lӟp.tên_phѭѫng_thӭc_tƭnh(tham sӕ); tên cӫa ÿӕi tѭӧng: tên_ÿӕi_tѭѫng. tên_phѭѫng_thӭc_tƭnh(tham sӕ); + Vì phѭѫng thӭc tƭnh là ÿӝc lұp vӟi ÿӕi tѭӧng do vұy ӣ bên trong phѭѫng thӭc tƭnh ta không thӇ truy cұp các thành viên không tƭnh cӫa lӟp ÿó, tӭc là bên trong phѭѫng thӭc tƭnh ta chӍ có thӇ truy cұp ÿӃn các thành viên tƭnh mà thôi. + Ta không thӇ sӱ dөng tӯ khoá this bên trong phѭѫng thӭc tƭnh Trang 52
BÀI 4. NҤP CHӖNG PHѬѪNG THӬC I. Khái niӋm vӅ phѭѫng thӭc bӝi tҧi Java cho phép ta xây dӵng nhiӅu phѭѫng thӭc trùng tên nhau, trong cùng mӝt lӟp, hiӋn Wѭӧng các phѭѫng thӭc trong mӝt lӟp có tên giӕng nhau ÿѭӧc gӑi là bӝi tҧi phѭѫng thӭc. II. Yêu cҫu cӫa các phѭѫng thӭc bӝi tҧi Do sӱ dөng chung mӝt cái tên cho nhiӅu phѭѫng thӭc, nên ta phҧi cho java biӃt cҫn phҧi gӑi phѭѫng thӭc nào ÿӇ thӵc hiӋn, java dӵa vào sӵ khác nhau vӅ sӕ lѭӧng ÿӕi cǊng nhѭ kiӇu dӳ liӋu cӫa các ÿӕi này ÿӇ phân biӋt các phѭѫng thӭc trùng tên ÿó. Ví dө: public class OverloadingOrder { static void print(String s, int i) { System.out.println( "String: " + s + ", int: " + i); } static void print(int i, String s) { System.out.println( "int: " + i + ", String: " + s); } public static void main(String[] args) { print("String first", 11); print(99, "Int first"); } }// /:~ Chú ý: 1) NӃu nӃu java không tìm thҩy mӝt hàm bӝi tҧi thích hӧp thì nó sӁÿѭa ra mӝt thông báo lӛi 2) Ta không thӇ sӱ dөng giá trӏ trҧ vӅ cӫa hàm ÿӇ phân biӋt sӵ khác nhau giӳa 2 phѭѫng thӭc bӝi tҧi 3) Không nên quá lҥm dөng các phѭѫng thӭc bӝi tҧi vì trình biên dӏch phҧi mҩt thӡi gian phán ÿoán ÿӇ tìm ra hàm thích hӧp, ÿLӅu này ÿôi khi còn dүn ÿӃn sai sót 4) Khi gӑi các hàm nҥp chӗng ta nên có lӋnh chuyӇn kiӇu tѭӡng minh ÿӇ trình biên dӏch tìm ra hàm phù hӧp mӝt cách nhanh nhҩt 5) Trong java không thӇÿӏnh nghƭa chӗng toán tӱ nhѭ trong ngôn ngӳ C++, có thӇ ÿây là mӝt khuyӃt ÿLӇm, nhѭng nhӳng ngѭӡi thiӃt kӃ java cho rҵng ÿLӅu này là không cҫn thiӃt, vì nó quá phӭc tҥp. Trang 53
BÀI 5. Kӂ THӮA (INHERITANCE) I. Lӟp cѫ sӣ và lӟp dүn xuҩt - Mӝt lӟp ÿѭӧc xây dӵng thông qua kӃ thӯa tӯ mӝt lӟp khác gӑi là lӟp dүn xuҩt (hay còn gӑi là lӟp con, lӟp hұu duӋ ), lӟp dùng ÿӇ xây dӵng lӟp dүn xuҩt ÿѭӧc gӑi là lӟp cѫ sӣ ( hay còn gӑi là lӟp cha, hoһc lӟp tә tiên ) Ø Mӝt lӟp dүn xuҩt ngoài các thành phҫn cӫa riêng nó, nó còn ÿѭӧc kӃ thӯa tҩt cҧ các thành phҫn cӫa lӟp cha II. Cách xây dӵng lӟp dүn xuҩt ĈӇ nói lӟp b là dүn xuҩt cӫa lӟp a ta dùng tӯ khoá extends, cú pháp nhѭ sau: class b extends a { // phҫn thân cӫa lӟp b } III. Thӯa kӃ các thuӝc tính Thӝc tính cӫa lӟp cѫ sӣÿѭӧc thӯa kӃ trong lӟp dүn xuҩt, nhѭ vұy tұp thuӝc tính cӫa lӟp dүn xuҩt sӁ gӗm: các thuӝc tính khai báo trong lӟp dүn xuҩt và các thuӝc tính cӫa lӟp cѫ sӣ, tuy nhiên trong lӟp dүn xuҩt ta không thӇ truy cұp vào các thành phҫn private, package cӫa lӟp cѫ sӣ IV. Thӯa kӃ phѭѫng thӭc Lӟp dүn xuҩt kӃ thӯa tҩt cҧ các phѭѫng thӭc cӫa lӟp cѫ sӣ trӯ: Ø Phѭѫng thӭc tҥo dӵng Ø Phѭѫng thӭc finalize V. Khӣi ÿҫu lӟp cѫ sӣ Lӟp dүn xuҩt kӃ thӯa mӑi thành phҫn cӫa lӟp cѫ, ÿiӅu này dүn ta ÿӃn mӝt hình dung, là lӟp dүn xuҩt có cùng giao diӋn vӟi lӟp cѫ sӣ và có thӇ có các thành phҫn mӟi bә sung thêm. nhѭng thӵc tӃ không phҧi vұy, kӃ thӯa không chӍ là sao chép giao diӋn cӫa lӟp cӫa lӟp cѫ sӣ. Khi ta tҥo ra mӝt ÿӕi tѭӧng cӫa lӟp suy dүn, thì nó chӭa bên trong nó mӝt sӵ vұt con cӫa lӟp cѫ sӣ, sӵ vұt con này nhѭ thӇ ta ÿã tҥo ra mӝt sӵ vұt tѭӡng minh cӫa lӟp cѫ sӣ, thӃ thì lӟp cѫ sӣ phҧi ÿѭӧc bҧo ÿҧm khӣi ÿҫu ÿúng, ÿӇ thӵc hiӋn ÿLӅu ÿó trӑng java ta làm nhѭ sau: Th͹c hi͏n khͧi ÿ̯u cho lͣp c˯ sͧ b̹ng cách g͕i c̭u t͵ cͯa lͣp c˯ sͧ bên trong c̭u t͵ cͯa lͣp d̳n xṷt, n͇u b̩n không làm ÿi͉u này thì java sͅ làm giúp ban, nghƭa là java luôn t͹ ÿ͡ng thêm lͥi g͕i c̭u t͵ cͯa lͣp c˯ sͧ vào c̭u t͵ cͯa lͣp d̳n xṷt n͇u nh˱ ta quên làm ÿi͉u ÿó, ÿ͋ có th͋ g͕i c̭u t͵ cͯa lͣp c˯ sͧ ta s͵ dͭng tͳ khoá super Ví dө 1: ví dө này không gӑi cҩu tӱ cӫa lӟp cѫ sӣ mӝt cách tѭӡng minh class B { public B () { System.out.println ( "Ham tao cӫa lop co so" );} } public class A extends B { public A () {// không gӑi hàm tҥo cӫa lӟp cѫ sӣ tѭӡng minh System.out.println ( "Ham tao cӫa lop dan xuat" ); } Trang 54
public static void main ( String arg[] ) { A thu = new A (); } } KӃt quҧ chҥy chѭѫng trình nhѭ sau: Ham tao cӫa lop co so Ham tao cӫa lop dan xuat Ví dͭ 2: ví dө này sӱ dөng tӯ khoá super ÿӇ gӑi cҩu tӱ cӫa lӟp cѫ sӣ mӝt cách tѭӡng minh class B { public B () { System.out.println ( "Ham tao cӫa lop co so" ); } } public class A extends B { public A () {super();// gӑi tҥo cӫa lӟp cѫ sӣ mӝt cách tѭӡng minh System.out.println ( "Ham tao cӫa lop dan xuat" ); } public static void main ( String arg[] ) { A thu = new A (); } } khi chҥy chѭng trình ta thҩy kӃt quҧ giӕng hӋt nhѭ ví dө trên Chú ý 1: NӃu gӑi tѭӡng minh cҩu tӱ cӫa lӟp cѫ sӣ, thì lӡi gӑi này phҧi là lӋnh ÿҫu tiên, nӃu ví dө trên ÿәi thành class B { public B () {System.out.println ( "Ham tao cӫa lop co so" );} } public class A extends B {public A () {// Lӡi gӑi cҩu tӱ cӫa lӟp cѫ sӣ không phҧi là lӋnh ÿҫu tiên System.out.println ("Ham tao cӫa lop dan xuat"); super (); } public static void main ( String arg[] ) { A thu = new A (); } } NӃu biên dӏch ÿRҥn mã này ta sӁ nhân ÿѭӧc mӝt thông báo lӛi nhѭ sau: "A.java": call to super must be first statement in constructor at line 15, column 15 Chú ý 2: ta chӍ có thӇ gӑi ÿӃn mӝt hàm tҥo cӫa lӟp cѫ sӣ bên trong hàm tҥo cӫa lӟp dүn xuҩt, ví dө chӍ ra sau ÿã bӏ báo lӛi class B { public B (){System.out.println ( "Ham tao cӫa lop co so" );} public B ( int i ) {System.out.println ( "Ham tao cӫa lop co so" );} Trang 55
} public class A extends B { public A () {super (); super ( 10 );/ / không thӇ gӑi nhiӅu hѫn 1 hàm tҥo cӫa lӟp cѫ sӣ System.out.println ( "Ham tao cӫa lop dan xuat" ); } public static void main ( String arg[] ) { A thu = new A (); } } 1. Tr̵t t͹ khͧi ÿ̯u Trұt tӵ khӣi ÿҫu trong java ÿѭӧc thӵc hiӋn theo nguyên tҳc sau: java sӁ gӑi cҩu tӱ cӫa lӟp cѫ sӣ trѭӟc sau ÿó mӟi ÿӃn cҩu tӱ cӫa lӟp suy dүn, ÿLӅu này có nghƭa là trong cây phҧ hӋ thì các cҩu tӱ sӁÿѭӧc gӑi theo trұt tӵ tӯ gӕc xuӕng dҫn ÿӃn lá 2. Tr̵t t͹ d͕n d́p Mһc dù java không có khái niӋm huӹ tӱ nhѭ cӫa C++, tuy nhiên bӝ thu rác cӫa java vүn hoҥt ÿӝng theo nguyên tҳc làm viӋc cӫa cҩu tӱ C++, tӭc là trұt tӵ thu rác thì ngѭӧc lҥi so vӟi trұt tӵ khӣi ÿҫu. VI. Ghi ÿè phѭѫng thӭc ( Override ) HiӋn tѭӧng trong lӟp cѫ sӣ và lӟp dүn xuҩt có hai phѭѫng thӭc giӕng hӋt nhau ( cҧ tên lүn bӝ tham sӕ) gӑi là ghi ÿè phѭѫng thӭc ( Override ), chú ý Override khác Overload. G͕i ph˱˯ng thͱc b͓ ghi ÿè cͯa lͣp c˯ sͧ Bên trong lӟp dүn xuҩt, nӃu có hiӋn tѭӧng ghi ÿè thì phѭѫng thӭc bӏ ghi ÿè cӫa lӟp cѫ sӣ sӁ bӏҭn ÿi, ÿӇ có thӇ gӑi phѭѫng thӭc bӏ ghi ÿè cӫa lӟp cѫ sӣ ta dùng tӯ khoá super ÿӇ truy cұp ÿӃn lӟp cha, cú pháp sau: super.overridden MethodName(); Chú ý: NӃu mӝt phѭѫng thӭc cӫa lӟp cѫ sӣ bӏ bӝi tҧi ( Overload ), thì nó không thӇ bӏ ghi ÿè ( Override ) ӣ lӟp dүn xuҩt. VI. Thành phҫn protected Trong mӝt vài bài trѭӟc ta ÿã làm quen vӟi các thành phҫn private, public, sau khi ÿã hӑc vӅ kӃ thӯa thì tӯ khoá protected cuӕi cùng ÿã có ý nghƭa. Tӯ khoá protected báo cho java biӃt ÿây là thành phҫn riêng tѭÿӕi vӟi bên ngoài nhѭng lҥi sҹn sàng vӟi các con cháu VII. Tӯ khoá final Tӯ khoá final trong java có nhiӅu nghƭa khác nhau, nghƭa cӫa nó tuǤ thuӝc vào ngӳ cҧnh cө thӇ, nhѭng nói chung nó muӕn nói “cái này không thӇ thay ÿәi ÿѭӧc”. 1. Thu͡c tính final Trong java cách duy nhҩt ÿӇ tҥo ra mӝt hҵng là khai báo thuӝc tính là final Ví dө: public class A { // ÿӏnh nghƭa hҵng tên MAX_VALUE giá trӏ 100 static final int MAX_VALUE = 100; public static void main ( String arg[] ) Trang 56
{ A thu = new A (); System.out.println("MAX_VALUE= " +thu.MAX_VALUE); } } Chú ý: 1) Khi ÿã khai báo mӝt thuӝc tính là final thì thuӝc tính này la hăng, do vұy ta không thӇ thay ÿәi giá trӏ cӫa nó 2) Khi khai báo mӝt thuӝc tính là final thì ta phҧi cung cҩp giá trӏ ban ÿҫu cho nó 3) NӃu mӝt thuӝc tính vӯa là final vӯa là static thì nó chӍ có mӝt vùng nhӟ chung duy nhҩt cho cҧ lӟp 2. Ĉ͙i s͙ final Java cho phép ta tҥo ra các ÿӕi final bҵng viӋc khai báo chúng nhѭ vұy bên trong danh sách ÿӕi, nghƭa là bên trong thân cӫa phѭѫng pháp này, bҩt cӭ cӕ gҳng nào ÿӇ thay ÿәi giá trӏ cӫa ÿӕi ÿӅu gây ra lӛi lúc dӏch Ví dө sau bӏ báo lӛi lúc dӏch vì nó cӕ gҳng thay ÿәi giá trӏ cӫa ÿӕi final public class A { static public void thu ( final int i ) { i=i+1;//không cho phép thay ÿәi giá trӏ cӫa tham sӕ final System.out.println ( i );; } public static void main ( String arg[] ) { int i = 100; thu ( i ); } } chѭѫng trình này sӁ bӏ báo lӛi: "A.java": variable i might already have been assigned to at line 5, column 9 3. Ph˱˯ng thͱc final Mӝt phѭѫng thӭc bình thѭӡng có thӇ bӏ ghi ÿè ӣ lӟp dүn xuҩt, ÿôi khi ta không muӕn phѭѫng thӭc cӫa ta bӏ ghi ÿè ӣ lӟp dүn xuҩt vì lý do gì ÿó, mөc ÿích chӫ yӃu cӫa các phѭѫng thӭc final là tránh ghi ÿè, tuy nhiên ta thҩy rҵng các phѭѫng thӭc private sӁ tӵÿӝng là final vì chúng không thӇ thҩy ÿѭӧc trong lӟp dүn xuҩt lên chúng không thӇ bӏ ghi ÿè, nên cho dù bҥn có cho mӝt phѭѫng thӭc private là final thì bҥn cǊng chҧ thҩy mӝt hiӋu ӭng nào 4. Lͣp final NӃu bҥn không muӕn ngѭӡi khác kӃ thӯa tӯ lӟp cӫa bҥn, thì bҥn hãy dùng tӯ khoá final ÿӇ ngăn cҧn bҩt cӭ ai muӕn kӃ thӯa tӯ lӟp này. Chú ý: Do mӝt lӟp là final (tӭc không thӇ kӃ thӯa )do vұy ta không thӇ nào ghiÿè các phѭѫng thӭc cӫa lӟp này, do vұy ÿӯng cӕ gҳng cho mӝt phѭѫng thӭc cӫa lӟp final là final Ví dͭ v͉ tính k͇ thͳa 1. Xây d͹ng lͣp c˯ sͧ package JavaContent; import java.util.*; class HocSinh { //Khai bao du lieu thanh phan protected Trang 57
String hoTen; String diaChi; int namSinh; protected double dToan; double dLy; double dHoa; //Khai bao Contructor & Detructor public HocSinh(String name,String Address,int birthday,double d1,double d2,double d3) {hoTen=name;diaChi=Address;namSinh=birthday;dToan=d1;dLy=d2;dHoa=d3; } //Khai bao cac phuong thuc cua lop Man public int tinhTuoi() {Calendar now=Calendar.getInstance(); return (now.get(Calendar.YEAR)-namSinh); } public double tongDiem() {return (dToan+dLy+dHoa);} public void hienThi() {System.out.println("Ho va ten nhan su="+hoTen); System.out.println("Dia chi ="+diaChi); System.out.println("Tuoi="+tinhTuoi()); System.out.println("Diem Toan="+dToan); System.out.println("Diem Ly="+dLy); System.out.println("Diem Hoa="+dHoa); System.out.println("Tong diem cac mon="+tongDiem()); } public static void main(String args[]) {HocSinh ng1=new HocSinh("Nguyen Tam Hung","Quang Ninh",1977,6.4,9.0,6.7); ng1.hienThi(); } } 2. Xây d͹ng lͣp d̳n xṷt package JavaContent; import java.io.*; import java.lang.*; public class HocSinhCD extends HocSinh {// Khai bao du lieu thanh phan cho lop CanBo protected double dTin; static private BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); // Khai bao Contructor,Detructor; public HocSinhCD(String name, String Address, int birthday, double d1,double d2, double d3,double d4) { super(name, Address, birthday, d1, d2, d3);dTin=d4;} // Xay dung cac phuong thuc public double tongDiem() {return (dToan+dLy+dHoa+dTin);} // public double diemTBUT() {return (dToan*2+dLy+dHoa+dTin*2)/6;} // public void hienThi1() {System.out.println("CAC THONG SO VE CAN BO"); Trang 58
hienThi(); System.out.println("Diem mon Tin=" +dTin); System.out.println("Diem TBC co uu tien=" +diemTBUT()); } // public static void main(String args[]) {String ht=" ",dc=" "; int ns=0; double d1=0,d2=0,d3=0,d4=0; System.out.print("Nhap vao ho ten:");ht=readString(); System.out.print("Nhap vao dia chi:");dc=readString(); System.out.print("Nhap vao nam sinh:");ns=readInt(); System.out.print("Nhap vao diem Toan:");d1=readDouble(); System.out.print("Nhap vao diem Ly:");d2=readDouble(); System.out.print("Nhap vao diem Hoa:");d3=readDouble(); System.out.print("Nhap vao diem in:");d4=readDouble(); HocSinhCD hs1=new HocSinhCD(ht,dc,ns,d1,d2,d3,d4); // HocSinhCD hs1=new HocSinhCD("Nguyen Van Thanh","Ha Tay",1980,7.0,7.0,7.0,7.0); hs1.hienThi1(); HocSinhCD TK1[]=new HocSinhCD[100];//Khai bao mot mang hoc sinh trong 1 lop TK1[0]=hs1; TK1[0].hienThi(); //Goi phuong thuc Hie Thi cua lop co so hs1.hienThi(); //Doi hpuong thuc readDoube } // Xay dung cac phuong thuc nhap du lieu public static int readInt() {int d=0; try{ String str=br.readLine(); d=Integer.parseInt(str); }catch(IOException ex){System.out.println("Loi IO "+ex.toString());} return d; } // public static long readLong() { long d=0; try{ String str=br.readLine(); d=Long.parseLong(str); }catch(IOException ex){System.out.println("Loi IO "+ex.toString());} return d; } // public static float readFloat() { float d=0; try{ String str=br.readLine(); d=Float.parseFloat(str); }catch(IOException ex){System.out.println("Loi IO "+ex.toString());} Trang 59
return d; } // public static double readDouble() { double d=0; try{ String str=br.readLine(); d=Double.parseDouble(str); }catch(IOException ex){System.out.println("Loi IO "+ex.toString());} return d; } // public static String readString() { String str=" "; try{ str=br.readLine(); }catch(IOException ex){System.out.println("Loi IO "+ex.toString());} return str; } } Trang 60
BÀI 6. LӞP CѪ SӢ TRӮU TѬӦNG Mӝt lӟp cѫ sӣ trӯu tѭӧng là mӝt lӟp chӍÿѭӧc dùng làm cѫ sӣ cho các lӟp khác, ta không thӇ tҥo ra thӇ hiӋn cӫa lӟp này, bӣi vì nó ÿѭӧc dùng ÿӇÿӏnh nghƭa mӝt giao diӋn chung cho các lӟp khác. Phѭѫng thӭc trӯu tѭӧng Mӝt lӟp trӯu tѭӧng có thӇ chӭa mӝt vài phѭѫng thӭc trӯu tѭӧng, do lӟp trӯu tѭӧng chӍ làm lӟp cѫ sӣ cho các lӟp khác, do vұy các phѭѫng thӭc trӯu tѭӧng cǊng không ÿѭӧc cài ÿһt cө thӇ, chúng chӍ gӗm có khai báo, viӋc cài ÿһt cө thӇ sӁ dành cho lӟp con Chú ý: 1. NӃu trong lӟp có phѭѫng thӭc trӯu tѭӧng thì lӟp ÿó phҧi ÿѭӧc khai báo là trӯu tѭӧng 2. NӃu mӝt lӟp kӃ thӯa tӯ lӟp trӯu tѭӧng thì: hoһc chúng phҧi ghi ÿè tҩt cҧ các phѭѫng thӭc ҧo cӫa lӟp cha, hoһc lӟp ÿó phҧi là lӟp trӯu tѭӧng 3. Không thӇ tҥo ra ÿӕi tѭӧng cӫa lӟp trӯu tѭӧng Trang 61
BÀI 7. ĈA HÌNH THÁI Ĉa hình thái trong lұp trình hѭӟng ÿӕi tѭӧng ÿӅ cұp ÿӃn khҧ năng quyӃt ÿӏnh trong lúc thi hành (runtime) mã nào sӁÿѭӧc chҥy, khi có nhiӅu phѭѫng thӭc trùng tên nhau nhѭng ӣ các lӟp có cҩp bұc khác nhau. Chú ý: Khҧ năng ÿa hình thái trong lұp trình hѭӟng ÿӕi tѭӧng còn ÿѭӧc gӑi vӟi nhiӅu cái tên khác nhau nhѭ: tѭѫng ӭng bӝi, kӃt ghép ÿӝng, Ĉa hình thái cho phép các vҩn ÿӅ khác nhau, các ÿӕi tѭӧng khác nhau, các phѭѫng thӭc khác nhau, các cách giҧi quyӃt khác nhau theo cùng mӝt lѭӧc ÿӗ chung. Các bѭӟc ÿӇ tҥo ÿa hình thái: 1) Xây dӵng lӟp cѫ sӣ (thѭӡng là lӟp cѫ sӣ trӯu tѭӧng, hoһc là mӝt giao diӋn), lӟp này sӁÿѭӧc các lӟp con mӣ rӝng( ÿӕi vӟi lӟp thѭӡng, hoһc lӟp trӯu tѭӧng), hoһc triӇn khai chi tiӃt ( ÿӕi vӟi giao diӋn ). 2) Xây dӵng các lӟp dүn xuҩt tӯ lӟp cѫ sӣ vӯa tҥo. trong lӟp dүn xuҩt này ta sӁ ghi ÿè các phѭѫng thӭc cӫa lӟp cѫ sӣ( ÿӕi vӟi lӟp cѫ sӣ thѭӡng), hoһc triӇn khai chi tiӃt nó ( ÿӕi vӟi lӟp cѫ sӣ trӯu tѭӧng hoһc giao diӋn). 3) Thӵc hiӋn viӋc tҥo khuôn xuӕng, thông qua lӟp Fѫ sӣ, ÿӇ thӵc hiӋn hành vi ÿa hình thái Khái niӋm vӅ tҥo khuôn lên, tҥo khuôn xuӕng Ø HiӋn tѭӧng mӝt ÿӕi tѭӧng cӫa lӟp cha tham trӓÿӃn mӝt ÿӕi tѭӧng cӫa lӟp con thì ÿѭӧc gӑi là tҥo khuôn xuӕng, viӋc tҥo khuôn xuӕng luôn ÿѭӧc java chҩp thuұn, do vұy khi tҥo khuôn xuӕng ta không cҫn phҧi ép kiӇu tѭӡng minh. Ø HiӋn tѭӧng mӝt ÿӕi tѭӧng cӫa lӟp con tham trӓ tӟi mӝt ÿӕi tѭӧng cӫa lӟp cha thì ÿѭӧc gӑi là tҥo khuôn lên, viӋc tҥo khuôn lên là an toàn, vì mӝt ÿӕi tѭӧng cӫa lӟp con cǊng có ÿҫy ÿӫ các thành phҫn cӫa lӟp cha, tuy nhiên viӋc tҥo khuôn lên sӁ bӏ báo lӛi nӃu nhѭ ta không ép kiӇu mӝt cách tѭӡng minh. Trang 62
BÀI 8. GIAO DIӊN, LӞP TRONG, GÓI Giao diӋn là mӝt khái niӋm ÿѭӧc java ÿѭa ra vӟi 2 mөc ÿích chính: Ø ĈӇ tҥo ra mӝt lӟp cѫ sӣ thuҫn ҧo, mӝt lӟp không có bҩt cӭ hàm nào ÿѭӧc cài ÿһt Ø Thӵc hiӋn hành vi tѭѫng tӵ nhѭ kӃ thӯa bӝi, bӣi trong java không có khái niӋm kӃ thӯa bӝi, nhѭ cӫa C++ Lӟp trong cho ta mӝt cách thӭc tinh vi ÿӇ che giҩu mã mӝt cách tӕi ÿa, trong java ta có thӇ ÿӏnh nghƭa mӝt lӟp bên trong mӝt lӟp khác, thұm chí ta còn có thӇ tҥo lӟp trong, bên trong thân cӫa mӝt phѭѫng thӭc, ÿLӅu này cho phép ta có thӇ tҥo ra các lӟp cөc bӝ, chӍÿѭӧc sӱ dөng nӝi bӝ bên trong mӝt ÿѫn vӏÿó. Ta không thӇ tҥo ra mӝt lӟp trong, trong ngôn ngӳ C++ I. Giao diӋn Tӯ khoá interface ÿã ÿѭa khái niӋm abstract ÿi xa thêm mӝt bѭӟc nӳa. Ta có thӇ nghƭ nó nhѭ là mӝt lӟp abstract “thuҫn tuý”, nó cho phép ta tҥo ra mӝt lӟp thuҫn ҧo, lӟp này chӍ gӗm tұp các giao diӋn cho các lӟp muӕn dүn xuҩt tӯ nó, mӝt interface cǊng có thӇ có các trѭӡng, tuy nhiên java tӵÿӝng làm các trѭӡng này thành static và final ĈӇ tҥo ra mӝt interface, ta dùng tӯ khoá interface thay vì tӯ khoá class. Mӝt interface gӗm có 2 phҫn: phҫn khai báo và phҫn thân, phҫn khai báo cho biӃt mӝt sӕ thông tin nhѭ: tên cӫa interface, nó có kӃ thӯa tӯ mӝt giao diӋn khác hay không. Phҫn thân chӭa các khai báo hҵng, khai báo phѭѫng thӭc ( nhѭng không có cài ÿһt). Giӕng nhѭ mӝt lӟp ta cǊng có thӇ thêm bә tӯ public vào trѭӟc ÿӏnh nghƭa cӫa interface. Sau ÿây là hình ҧnh cӫa mӝt interface. Nhѭng do java tӵÿӝng làm các trѭӡng thành final nên ta không cҫn thêm bә tӯ này, do vұy ta có thӇÿӏnh nghƭa lҥi giao diӋn nhѭ sau: Nhѭng do java tӵÿӝng làm các trѭӡng thành final nên ta không cҫn thêm bә tӯ này public interface StockWatcher { final String sunTicker = "SUNW"; final String oracleTicker = "ORCL"; final String ciscoTicker = "CSCO"; void valueChanged(String tickerSymbol, double newValue); } Trang 63
1. Ph̯n khai báo cͯa giao di͏n Tәng quát phҫn khai báo cӫa mӝt giao diӋn có cҩu trúc tәng quát nhѭ sau: Public //giao diӋn này là công cӝng interface InterfaceName //tên cӫa giao diӋn Extends SuperInterface //giao diӋn này là mӣ rӝng cӫa 1 giao diӋn khác { InterfaceBody //thân cӫa giao diӋn } Trong cҩu trúc trên có 2 phҫn bҳt buӝc phҧi có ÿó là phҫn interface và InterfaceName, các ph̯n khác là tuǤ ch͕n. 2. Ph̯n thân Phҫn thân khai báo các các hҵng, các phѭѫng thӭc rӛng ( không có cài ÿһt ), các phѭѫng thӭc này phҧi kӃt thúc vӟi dҩu chҩm phҭy ‘;’, bӣi vì chúng không có phҫn cài ÿһt Chú ý: 1. Tҩt cҧ các thành phҫn cӫa mӝt giao diӋn tӵÿӝng là public do vұy ta không cҫn phҧi cho bә tӯ này vào. 2. Java yêu cҫu tҩt cҧ các thành phҫn cӫa giao diӋn phҧi là public, nӃu ta thêm các bә tӯ khác nhѭ private, protected trѭӟc các khai báo thì ta sӁ nhұn ÿѭӧc mӝt lӛi lúc dӏch 3. Tҩt cҧ các trѭӡng tӵÿӝng là final và static, nên ta không cҫn phҧi cho bә tӯ này vào. 3. Tri͋n khai giao di͏n Bӣi mӝt giao diӋn chӍ gӗm các mô tҧ chúng không có phҫn cài ÿһt, các giao diӋn ÿѭӧc ÿӏnh nghƭa ÿӇ cho các lӟp dүn xuҩt triӇn khai, do vұy các lӟp dүn xuҩt tӯ lӟp này phҧi triӇn khai ÿҫy ÿӫ tҩt cҧ các khai báo bên trong giao diӋn, ÿӇ triӇn khai mӝt giao diӋn bҥn bao gӗm tӯ khoá implements vào phҫn khai báo lӟp, lӟp cӫa bҥn có thӇ triӇn khai mӝt hoһc nhiӅu giao diӋn ( hình thӭc này tѭѫng tӵ nhѭ kӃ thӯa bӝi cӫa C++) Ví dͭ 1 public class StockApplet extends Applet implements StockWatcher { . public void valueChanged(String tickerSymbol, double newValue) { if (tickerSymbol.equals(sunTicker)) { . } else if (tickerSymbol.equals(oracleTicker)) { . } else if (tickerSymbol.equals(ciscoTicker)) { . } } } Ví dͭ 2 public interface MyInterface{ public void add(int x, int y); public void volume(int x, int y, int z); Trang 64
} //Hoһc interface Interface_Const{ public static final double price = 100.0; public static final int counter = 5; } + Sӱ dөng Interface trên package JavaContent; public class Use_MyInterface implements MyInterface,Interface_Const { public void add(int x, int y) {System.out.println("Tong cua 2 so "+x+" + " + y+" la:"+ (x+y));} public void volume(int x, int y, int z) { System.out.println("Tich cua 3 so "+x+" * " + y+"*"+z+" la:"+ (x*y*z)); } public static void main(String args[]) {Use_MyInterface uu=new Use_MyInterface(); uu.add(4,8); uu.volume(20,15,9); System.out.println("Gia tri hang so price="+price); System.out.println("Gia tri hang so counter="+counter); } } Chú ý: + NӃu mӝt lӟp triӇn khai nhiӅu giao diӋn thì các giao diӋn này ÿѭӧc liӋt kê cách nhau bӣi dҩu phҭy ‘,’ + Lӟp triӇn khai giao diӋn phҧi thӵc thi tҩt cҧ các phѭѫng thӭc ÿѭӧc khai báo trong giao diӋn, nӃu nhѭ lӟp ÿó không triӇn khai, hoһc triӇn khai không hӃt thì nó phҧi ÿѭӧc khai báo là abstract + Do giao diӋn cǊng là mӝt lӟp trӯu tѭӧng do vұy ta không thӇ tҥo thӇ hiӋn cӫa giao diӋn + Mӝt lӟp có thӇ triӇn khai nhiӅu giao diӋn, do vұy ta có lӧi dөng ÿLӅu này ÿӇ thӵc hiӋn hành vi kӃ thӯa bӝi, vӕn không ÿѭӧc java hӛ trӧ + Mӝt giao diӋn có thӇ mӣ rӝng mӝt giao diӋn khác, bҵng hình thӭc kӃ thӯa II. Lӟp trong Có thӇÿһt mӝt ÿӏnh nghƭa lӟp này vào bên trong mӝt lӟp khác. ÿLӅu này ÿѭӧc gӑi là lӟp trong. Lӟp trong là mӝt tính năng có giá trӏ vì nó cho phép bҥn gӝp nhóm các lӟp vӅ mһt logic thuӝc vӅ nhau và ÿӇ kiӇm soát tính thҩy ÿѭӧc cӫa các lӟp này bên trong lӟp khác. Tuy nhiên bҥn phҧi hiӇu rҵng lӟp trong không phҧi là là hӧp thành Ví dө: public class Stack { private Vector items; .//code for Stack's methods and constructors not shown public Enumeration enumerator() { return new StackEnum(); } class StackEnum implements Enumeration { int currentItem = items.size() - 1; public boolean hasMoreElements() { Trang 65
return (currentItem >= 0); } public Object nextElement() { if (!hasMoreElements()) throw new NoSuchElementException(); else return items.elementAt(currentItem ); } } } Lӟp trong rҩt hӳu hiӋu khi bҥn bҥn muӕn tҥo ra các lӟp ÿLӅu hӧp ( ÿѭӧc bàn kӻ khi nói vӅ thiӃt kӃ giao diӋn ngѭӡi dùng ) Trang 66
Bài 9. MҦNG, XÂU KÝ TӴ, TҰP HӦP I. Mҧng 1. M̫ng 1 chi͉u a) Khai báo Cú pháp khai báo: - KDL tên_m̫ng[];//Khai báo mӝt con trӓ mҧng - KDL []tên_m̫ng;//nhѭ trên - KDL tên_m̫ng[] = new KDL[spt];//Tҥo ra mӝt mҧng có spt phҫn tӱ Trong cú pháp trên thì: Ø KDL là mӝt kiӇu dӳ liӋu bҩt kǤ nhѭ: kiӇu nguyên thӫy, kiӇu ÿӕi tѭӧng nó xác ÿӏnh kiӇu dӳ liӋu cӫa tӯng phҫn tӱ cӫa mҧng. Ø Spt là sӕ phҫn tӱ cӫa mҧng. Chú ý: Ø Mҧng trong Java là mӝt ÿӕi tѭӧng Ø CǊng nhѭ các ÿӕi tѭӧng khác, mҧng phҧi ÿѭӧc tҥo ra bҵng toán tӱ new nhѭ sau: Tên_m̫ng=new KDL[spt]; Ø Khi mҧng ÿѭӧc tҥo ra thì mӛi phҫn tӱ cӫa mҧng sӁ nhұn mӝt giá trӏ mһc ÿӏnh, quy tҳc khӣi tҥo giá trӏ cho các phҫn tӱ cӫa mҧng cǊng chính là quy tҳc khӣi ÿҫu giá trӏ cho các thuӝc tính cӫa ÿӕi tѭӧng, tӭc là mӛi phҫn tӱ cӫa mҧng sӁ nhұn giá trӏ: + 0 nӃu KDL là kiӇu sӕ + ‘\0’ nӃu KDL là kí tӵ + false nӃu KDL là boolean + null nӃu KDL là mӝt lӟp nào ÿó. Ví dͭ 1: Khai báo mӝt mҧng sӕ nguyên gӗm 100 phҫn tӱ Cách 1: int mangInt[]; //Khai báo mӝt con trӓÿӃn mҧng các sӕ nguyên mangInt=new int[100]; //Tҥo ra mҧng Cách 2: int mangInt[]=new int[100]; Ví dͭ 2: Giҧ sӱ ta có lӟp SinhVien ÿã ÿѭѫc ÿӏnh nghƭa, hãy khai báo mӝt mҧng gӗm 100 ÿӕi tѭӧng cӫa lӟp SinhVien SinhVien arraySinhVien[]=new SinhVien[100]; Chú ý: Lúc này mӛi phҫn tӱ cӫa mҧng arraySinhVien là mӝt con trӓ cӫa lӟp SinhVien và hiӋn giӡ mӛi phҫn tӱ cӫa mҧng ÿang trӓÿӃn giá trӏ null. ĈӇ khӣi tҥo tӯng phҫn tӱ cӫa mҧng ta phҧi làm nhѭ sau: arraySinhVien[0]=new SinhVien(“sv01”, “NguyӉn Văn An”, “Hѭng Yên”); arraySinhVien[1]=new SinhVien(“sv02”, “NguyӉn Thӏ Bình”, “Bҳc Giang”); . arraySinhVien[99]=new SinhVien(“sv100”, “Ĉào Thӏ MӃn”, “Hà Nam”); Ngoài cách khai báo trên Java còn cho phép ta kӃt hӧp cҧ khai báo và khӣi gán các phҫn tӱ cӫa mҧng theo cách sau: int[] mangInt = {1, 3, 5, 7, 9}; Tҥo ra mӝt mҧng gӗm 5 phҫn tӱ, các phҫn tӱ cӫa mҧng lҫn lѭӧt ÿѭӧc gán các giá trӏ là: 1, 3, 5, 7, 9 Trang 67