 












١

 ‫ﺑﺴﻢ ﺍﷲ ﺍﻟﺮﲪﻦ ﺍﻟﺮﺣﻴﻢ‬

‫أﺳﺄل ﷲ أن ﯾﺗﻘﺑل ھذا اﻟﻌﻣل وﯾﺟﻌﻠﮫ ﺧﺎﻟص ﻟوﺟﮫ اﻟﻛرﯾم ‪،‬‬

‫وأﺷﻛر ﻛل ﻣن ﺳﺎھم ﻓﻲ اﻟﻛﺗﺎب وﻟو ﺑﺳؤال واﺣد ‪ ،‬وﻛذﻟك ﻻ‬
‫أﻧﺳﻰ أﺷﻛر ﻣﻧﺗدﯾﺎت اﻟﻔرﯾﻖ اﻟﻌرﺑﻲ ﻟﻠﺑرﻣﺟﺔ ﻟﻣﺎ ﯾﻘدﻣوه ﻣن‬
‫إﺛراء ﻟﻠﻣﺣﺗوى اﻟﻌرﺑﻲ )وﻗد ﺗم أﺧذ ﺑﻌض اﻷﺳﺋﻠﺔ ﻣﻧﮭم( ‪.‬‬
‫‪...‬‬

‫ظﮭر اﻟﻐﯾب‬

‫وﻻ ﺗﻧﺳوﻧﻲ وﺟﻣﯾﻊ اﻟﻣﺳﺎھﻣﯾن ﻣن ﺻﺎﻟﺢ دﻋﺎﺋﻛم ﻓﻲ‪..‬‬

‫‪٢‬‬
 ‫اﻟﻣﺣﺗوﯾﺎت‬
‫اﻟﺻﻔـﺣﺔ‬
‫اﻟوﺣدة اﻷوﻟﻰ ‪ :‬اﻷﺳﺎﺳﯾﺎت‬
‫‪٨‬‬ ‫س‪ : ١‬ﻟﻐﺔ ﺟﺎﻓﺎ ‪......................‬‬
‫‪٨‬‬ ‫س‪ : ٢‬ﻣﻣﯾزاﺗﮭﺎ ‪...................‬‬
‫‪٩‬‬ ‫س‪ : ٣‬اﺻداراﺗﮭﺎ ‪..................‬‬
‫‪٩‬‬ ‫س ‪ : ٤‬اﻟوﻗت ﻣﻊ اﻟﺟﺎﻓﺎ ‪..............‬‬
‫‪١٠‬‬ ‫س‪ : ٥‬اﻧﺗﺷﺎر اﻟﺟﺎﻓﺎ ‪...................‬‬
‫‪١١‬‬ ‫س‪ : ٦‬اﻟﻛﻠﻣﺎت اﻟﻣﺣﺟوزة ‪................‬‬
‫‪١١‬‬ ‫س ‪ : ٧‬اﻋﺎدة ﺗﺳﻣﯾﺔ ‪............... class‬‬
‫‪١١‬‬ ‫س ‪ variable : ٨‬و‪................. value‬‬
‫‪١١‬‬ ‫س ‪ : ٩‬اﻟﻛوﻧﺳﺗراﻛﺗر ‪...................‬‬
‫‪١٢‬‬ ‫س ‪ : ١٠‬إﻧﺷﺎء ﻛﺎﺋن ﻣن ﻛﻼس ‪...........‬‬
‫‪١٢‬‬ ‫س ‪ private & protected & public : ١١‬ﻟﻠﻣﺗﻐﯾرات ‪....‬‬
‫‪١٣‬‬ ‫س ‪ : ١٢‬ﺗﺧزﯾن ﻗﯾﻣﺔ ﻓﻲ ﻣﺗﻐﯾر ‪...........‬‬
‫‪١٤‬‬ ‫س ‪ : ١٣‬ﻣﺳﺎواة ﻣﺗﻐﯾر ﻓﻲ ﻣﺗﻐﯾر ‪....‬‬
‫‪١٤‬‬ ‫س ‪ : ١٤‬إذا ﻟم ﺗﻌطﻰ اﻟﻘﯾﻣﺔ اﻹﺑﺗداﺋﯾﺔ ﻟﻠﻣﺗﻐﯾر ‪...‬‬
‫‪١٤‬‬ ‫س ‪ : ١٥‬ﻗواﻋد ﺗﺳﻣﯾﺔ اﻟﻣﺗﻐﯾرات ‪.........‬‬
‫‪١٥‬‬ ‫س ‪ : ١٦‬اﻟﻌﻠﻣﯾﺎت اﻟرﯾﺎﺿﯾﺔ ﻋﻠﻰ اﻟﻣﺗﻐﯾرات ‪.....‬‬
‫‪١٦‬‬ ‫س ‪ : ١٧‬ﺿﺑط ﻗﯾﻣﺔ ﻟﻠﻣﺗﻐﯾر ‪......‬‬
‫‪١٦‬‬ ‫س ‪ : ١٨‬اﻟﻣﺗﻐﯾر ﺑوﻟﯾﺎن ‪..... Boolean‬‬

‫‪٣‬‬
١٨ ............ if & else : ١٩ ‫س‬
١٩ ........... Switch : ٢٠ ‫س‬
٢١ ........ Methods ‫ أﻧواع اﻟـ‬: ٢١ ‫س‬
٢٢ .......... Packages ‫ اﻟـ‬: ٢٢ ‫س‬
٢٢ .... overriding & overloading : ٢٣ ‫س‬
٢٢ ............ ‫ أﻧواع اﻟﻣﺗﻐﯾرات‬: ٢٤ ‫س‬
٢٢ ...... escape sequence : ٢٥ ‫س‬
٢٣ ..... static ‫ ﻣﻌﻧﻰ‬: ٢٦ ‫س‬
٢٣ ....... java.lang.* ‫ ﺑﺎﻛﺞ‬: ٢٧ ‫س‬
٢٣ ...... ‫ & و && ﻓﻲ ﺟﻣل اﻟﻣﻘﺎرﻧﺔ‬: ٢٨ ‫س‬
٢٤ ..... toString() (‫ اﻟطرﯾﻘﺔ )اﻟداﻟﺔ‬: ٢٩ ‫س‬
٢٧ ...... ‫ ﻟﻣﻠف ﺟﺎﻓﺎ‬Compile ‫ ﻋﻣل‬: ٣٠ ‫س‬
٢٧ .......... ‫ ﺗﺷﻐﯾل ﺑرﻧﺎﻣﺞ اﻟﺟﺎﻓﺎ‬: ٣١ ‫س‬
٢٧ ........ Casting ‫ ﻣﺻطﻠﺢ‬: ٣٢ ‫س‬
٢٨ ................. ‫ اﻟﺛواﺑت‬: ٣٣ ‫س‬
٢٨ ... global & local & static & dynamic : ٣٤‫س‬
٢٩ ... String & StringBuffer : ٣٥ ‫س‬
٢٩ .... GregorianCalendar ‫ ﻛﻼس‬: ٣٦ ‫س‬
(Inheritance) ‫اﻟوراﺛﺔ‬
٢٩ .... (inheritance) ‫ ﻣﻌﻧﻰ اﻟوراﺛﺔ‬:٣٧ ‫س‬

٤
‫‪٣٠‬‬ ‫س ‪ : ٣٨‬اﻟوﺻول إﻟﻰ اﻷب ﻣن اﻹﺑن ‪......‬‬
‫اﻹﺳﺗﺛﻧﺎءات )‪(Exceptions‬‬
‫‪٣٠‬‬ ‫س ‪ : ٣٩‬اﻹﺳﺗﺛﻧﺎءات ‪...............‬‬
‫‪٣١‬‬ ‫س ‪ : ٤٠‬ﺣﻣل اﻹﺳﺗﺛﻧﺎءات ‪.............‬‬
‫‪٣١‬‬ ‫س ‪ : ٤١‬أﻧواع اﻹﺳﺗﺛﻧﺎءات ‪...............‬‬
‫ﻋﺎم‬
‫‪٣٢‬‬ ‫س ‪ : ٤٢‬اﻵﺳﻛﻲ ﻛود ‪...............‬‬
‫‪٣٣‬‬ ‫س ‪ : ٤٣‬ﻣﺻطﻠﺢ ‪............ Deprecated‬‬
‫‪٣٣‬‬ ‫س ‪............... Generic Class : ٤٤‬‬
‫‪٣٤‬‬ ‫س ‪............... Interface : ٤٥‬‬
‫‪GUI‬‬
‫‪٣٤‬‬ ‫س ‪ : ٤٦‬واﺟﮭﺔ اﻟﻣﺳﺗﺧدم اﻟرﺳوﻣﯾﺔ ‪....... GUI‬‬
‫‪٣٥‬‬ ‫س ‪.......... JFrame : ٤٧‬‬
‫‪٣٥‬‬ ‫س ‪ : ٤٨‬طرق اﺳﺗﺧدام ‪......... JFrame‬‬
‫‪٣٥‬‬ ‫س ‪ : ٤٩‬ﻋﻣل واﺟﮭﺔ ﻣرﺋﯾﺔ ﺑﺎﻟﻛود ‪.......‬‬
‫‪٤٣‬‬ ‫س ‪.......... Swing : ٥٠‬‬
‫‪٤٤‬‬ ‫س ‪ : ٥١‬ﻣﻛﺗﺑﺔ ‪........... SWT‬‬
‫‪٤٤‬‬ ‫س ‪....... static & methods : ٥٢‬‬
‫‪٤٤‬‬ ‫س ‪ : ٥٣‬ﻣﻛﺗﺑﺎت اﻟواﺟﮭﺎت ‪.........‬‬
‫‪٤٦‬‬ ‫س ‪ : ٥٤‬ﻛﻼس ‪ Color‬واﻻﺧﺗﻼف ‪......‬‬

‫‪٥‬‬
‫‪٤٦‬‬ ‫س ‪ : ٥٥‬ﻓﺗﺢ ﺻﻔﺣﺔ وﯾب ﻣﻌﯾﻧﺔ ‪...........‬‬
‫‪٤٧‬‬ ‫س ‪ : ٥٦‬ﺗﻌدد ﻟﻐﺎت اﻟﺑرﻧﺎﻣﺞ ‪.........‬‬
‫‪٤٧‬‬ ‫س ‪ : ٥٧‬اﻟﻣﻠﻔﺎت ‪....... Properties‬‬
‫‪٤٨‬‬ ‫س ‪ : ٥٨‬ﻓﺋﺔ ‪............. Locale‬‬
‫‪٤٨‬‬ ‫س ‪ : ٥٩‬ﻓﺋﺔ ‪........... ResourceBuodle‬‬
‫‪٤٩‬‬ ‫س ‪ : ٦٠‬ﻗراءة ﻣﺣﺗوى ﻣﻠف ﻧﺻﻲ ‪.........‬‬
‫‪٥١‬‬ ‫س ‪ : ٦١‬أﻣر اﻹﻗﻔﺎل داﺧل ‪...... finally‬‬
‫‪٥٢‬‬ ‫س ‪ : ٦٢‬ﻗراءة ﻣﻠف ﺑﺎﺳﺗﻌﻣﺎل اﻟﻔﺋﺔ ‪...... Scanner‬‬
‫ﻋﺎم‬
‫‪٥٣‬‬ ‫س ‪ : ٦٣‬اﻟـ ‪.............. JPA‬‬
‫‪٥٣‬‬ ‫س ‪........ JVM & JRE & JDK : ٦٤‬‬
‫‪Data Structure‬‬
‫س ‪٥٥ ... Databases & Data Structures : ٦٥‬‬
‫‪٦١‬‬ ‫س ‪..... LinkedList & ArrayList : ٦٦‬‬
‫‪٦٣‬‬ ‫س ‪..... LinkedList & List : ٦٧‬‬
‫‪٦٣‬‬ ‫س ‪ : ٦٨‬ﺗرﺗﯾب ﻣﺻﻔوﻓﺔ ‪..........‬‬
‫ﻋﺎم‬
‫‪٦٤‬‬ ‫س ‪...... Java Annotations : ٦٩‬‬
‫‪٦٨‬‬ ‫س ‪ : ٧٠‬ﺑرﻣﺟﺔ ﺣواﺷﻲ ﺟدﯾدة ‪.....‬‬
‫‪٧٣‬‬ ‫س ‪ : ٧١‬ﻣﻌﺎﻟﺟﺔ اﻟﺣواﺷﻲ ‪........‬‬

‫‪٦‬‬
 ‫‪Databases‬‬
‫‪٨٢‬‬ ‫س ‪ : ٧٢‬رﺑط ﻗﺎﻋدة ﺑﯾﺎﻧﺎت أﻛﺳس ﺑﺎﻟﺟﺎﻓﺎ ‪......‬‬
‫‪Graphics 2D‬‬
‫‪٩٦‬‬ ‫س ‪ : ٧٣‬رﺳم أﺷﻛﺎل ھﻧدﺳﯾﺔ ‪................‬‬
‫ﻣﺷﺎرﯾﻊ ﺟﺎھزة‬
‫‪١٠٠‬‬ ‫‪ : ٧٤‬ﻋﻣل ﺑرﻧﺎﻣﺞ ﺷﺑﯾﮫ ﺑﺎﻟرﺳﺎم ‪...........‬‬
‫‪١١٩‬‬ ‫‪ capture : ٧٥‬ﺗﺻوﯾر اﻟﺷﺎﺷﺔ ‪..........‬‬
‫‪١٢٢‬‬ ‫‪ splash : ٧٦‬ﺟﺎري اﻟﺗﺣﻣﯾل ‪.............‬‬
‫‪١٢٤‬‬ ‫‪.......................... open net : ٧٧‬‬
‫‪١٢٥‬‬ ‫‪ count letter : ٧٨‬ﺣﺳﺎب ظﮭور اﻟﺣروف ‪....‬‬
‫‪١٢٧‬‬ ‫‪ draw Time : ٧٩‬رھﯾب ﺟدا ‪..........‬‬
‫‪١٣٣‬‬ ‫‪ Color : ٨٠‬ﺗﻠوﯾن اﻟﺧط وﺗﻐﯾﯾر ﻧوﻋﮫ ‪....‬‬
‫‪١٣٥‬‬ ‫‪ clac : ٨١‬ﺣﺎﺳﺑﺔ ﺑﺎﺳﺗﺧدام اﻟﺟﺎﻓﺎ ‪.........‬‬
‫‪١٤٣‬‬ ‫أﺳﻣﺎء اﻟﻣﺷﺎرﻛﯾن ﻓﻲ اﻟﻛﺗﺎب‬

‫‪٧‬‬
 ‫اﻷﺳﺎﺳﯾﺎت‬
‫س‪ : ١‬ﻣﺎھﻲ ﻟﻐﺔ ﺟﺎﻓﺎ وﻣﺎ ھﻲ ﺑداﯾﺎﺗﮭﺎ ؟‬
‫ﺟﺎﻓﺎ )‪ (Java‬ھﻲ ﻋﺑﺎرة ﻋن ﻟﻐﺔ ﺑرﻣﺟﺔ اﺑﺗﻛرھﺎ ﺟﯾﻣس ﺟوﺳﻠﯾﻧﺞ ﻓﻲ ﻋﺎم ‪ ١٩٩٢‬م‬
‫أﺛﻧﺎء ﻋﻣﻠﮫ ﻓﻲ ﻣﺧﺗﺑرات ﺷرﻛﺔ ﺻن ﻣﯾﻛروﺳﯾﺳﺗﻣز‪ ،‬وذﻟك ﻻﺳﺗﺧداﻣﮭﺎ ﺑﻣﺛﺎﺑﺔ اﻟﻌﻘل‬
‫اﻟﻣﻔﻛر اﻟﻣﺳﺗﺧدم ﻟﺗﺷﻐﯾل اﻷﺟﮭزة اﻟﺗطﺑﯾﻘﯾﺔ اﻟذﻛﯾﺔ ﻣﺛل اﻟﺗﯾﻠﻔزﯾون اﻟﺗﻔﺎﻋﻠﻲ‪ ،‬وﻗد ﻛﺎﻧت‬
‫ﻟﻐﺔ اﻟﺟﺎﻓﺎ ﺗطوﯾرً ا ﻟﻠﻐﺔ اﻟﺳﻲ ﺑﻼس ﺑﻼس )‪ ،(++C‬وﻋﻧد وﻻدﺗﮭﺎ أطﻠﻖ ﻋﻠﯾﮭﺎ ﻣﺑﺗﻛرھﺎ‬
‫"أواك" ﺑﻣﻌﻧﻰ ﺷﺟرة اﻟﺳﻧدﯾﺎن؛ وھﻲ اﻟﺷﺟرة اﻟﺗﻲ ﻛﺎن ﯾراھﺎ ﻣن ﻧﺎﻓذة ﻣﻛﺗﺑﮫ وھو‬
‫ﯾﻌﻣل ﻓﻲ ﻣﺧﺗﺑرات ﺻن ﻣﯾﻛروﺳﯾﺳﺗﻣز‪ ،‬ﺛم ﺗﻐﯾر اﻻﺳم إﻟﻰ ﺟﺎﻓﺎ‪ ،‬وھذا اﻻﺳم )ﻋﻠﻰ‬
‫ﻏﯾر اﻟﻌﺎدة ﻓﻲ ﺗﺳﻣﯾﺔ ﻟﻐﺎت اﻟﺑرﻣﺟﺔ( ﻟﯾس اﻟﺣروف اﻷوﻟﻰ ﻣن ﻛﻠﻣﺎت ﺟﻣﻠﺔ ﻣﻌﯾﻧﺔ أو‬
‫ﻣطوروا ھذه اﻟﻠﻐﺔ ﻟﯾﻧﺎﻓس اﻷﺳﻣﺎء‬‫ّ‬ ‫ﺗﻌﺑﯾرا ﺑﻣﻌﻧﻰ ﻣﻌﯾن‪ ،‬وﻟﻛﻧﮫ ﻣﺟرد اﺳم وﺿﻌﮫ‬
‫اﻷﺧرى‪ ،‬وھﻰ اﺣدى ﻟﻐﺎت اﻟﺑرﻣﺟﺔ‪ ،‬أي ﻣﺟﻣوﻋﺔ ﻣن اﻷواﻣر واﻟﺗﻌﻠﯾﻣﺎت اﻟﺗﻲ ﺗﻌطﻰ‬
‫ﻟﻠﺣﺎﺳب ﻓﻲ ﺻورة ﺑرﻧﺎﻣﺞ ﻣﻛﺗوب ﺑﻠﻐﺔ ﺑرﻣﺟﺔ ﻣﻌﯾﻧﺔ ﺑواﺳطﺔ ﻣﻌﺎﻟﺞ ﻧﺻوص‪،‬‬
‫وﯾﺗﻛون ﻣﺻدر اﻟﺑرﻧﺎﻣﺞ ﻣن ﻋدة ﺳطور وﻛل ﺳطر ﯾﻌﺗﺑر ﺟﻣﻠﺔ‪ ،‬وﯾﺗﻌﺎﻣل اﻟﺣﺎﺳب ﻣﻊ‬
‫ﻛل ﺟﻣﻠﺔ ﺑﺗرﺗﯾب ﻣﻌﯾن ﻹﻧﺟﺎز اﻷﻣر اﻟذي ﺻﻣم اﻟﺑرﻧﺎﻣﺞ ﻟﺗﺣﻘﯾﻘﮫ‪.‬‬

‫س ‪ : ٢‬ﻣﺎھﻲ ﻣﻣﯾزات ﻟﻐﺔ ﺟﺎﻓﺎ ؟‬

‫اﻟﺳﮭوﻟﺔ‪.‬‬ ‫‪‬‬
‫داﻋﻣﺔ و ﻣوﺟﮭﺔ ﻟﻠﻛﯾﺎﻧﺎت‪.‬‬ ‫‪‬‬
‫ﺳﮭوﻟﺔ اﻟﺣﺻول ﻋﻠﯾﮭﺎ‪.‬‬ ‫‪‬‬
‫آﻣﻧﺔ‪.‬‬ ‫‪‬‬
‫ﻗﺎﺑﻠﺔ ﻟﻠﻧﻘل و اﻟﺗﻧﻔﯾذ‪.‬‬ ‫‪‬‬
‫إﺿﺎﻓﺔ اﻟﺣرﻛﺔ واﻟﺻوت إﻟﻰ ﺻﻔﺣﺎت اﻟوﯾب‪.‬‬ ‫‪‬‬
‫ﻛﺗﺎﺑﺔ اﻷﻟﻌﺎب واﻟﺑراﻣﺞ اﻟﻣﺳﺎﻋدة‪.‬‬ ‫‪‬‬
‫إﻧﺷﺎء ﺑراﻣﺞ ذات واﺟﮭﺔ ﻣﺳﺗﺧدم رﺳوﻣﯾﺔ‪.‬‬ ‫‪‬‬
‫ﺗﺻﻣﯾم ﺑرﻣﺟﯾﺎت ﺗﺳﺗﻔﯾد ﻣن ﻛل ﻣﻣﯾزات اﻷﻧﺗرﻧت‪ .‬ﺗوﻓر ﻟﻐﺔ اﻟﺟﺎﻓﺎ ﺑﯾﺋﺔ ﺗﻔﺎﻋﻠﯾﺔ‬ ‫‪‬‬
‫ﻋﺑر اﻟﺷﺑﻛﺔ اﻟﻌﻧﻛﺑوﺗﯾﺔ وﺑﺎﻟﺗﺎﻟﻲ ﺗﺳﺗﻌﻣل ﻟﻛﺗﺎﺑﺔ ﺑراﻣﺞ ﺗﻌﻠﯾﻣﯾﺔ ﻟﻺﻧﺗرﻧت ﻋﺑر‬
‫ﺑرﻣﺟﯾﺎت اﻟﻣﺣﺎﻛﺎة اﻟﺣﺎﺳوﺑﯾﺔ ﻟﻠﺗﺟﺎرب اﻟﻌﻠﻣﯾﺔ وﺑرﻣﺟﯾﺎت اﻟﻔﺻول اﻻﻓﺗراﺿﯾﺔ‬
‫ﻟﻠﺗﻌﻠﯾم اﻹﻟﻛﺗروﻧﻲ واﻟﺗﻌﻠﯾم ﻋن ﺑﻌد‪ .‬ﻻ ﺗﻧﺣﺻر ﻓﺎﻋﻠﯾﺔ اﻟﺟﺎﻓﺎ ﻓﻲ اﻟﺷﺑﻛﺔ‬

‫‪٨‬‬
 ‫اﻟﻌﻧﻛﺑوﺗﯾﺔ ﻓﻘط ﺑل ﺗﻣﻛﻧﻧﺎ ﻣن إﻧﺷﺎء ﺑراﻣﺞ ﻟﻼﺳﺗﻌﻣﺎل اﻟﺷﺧﺻﻲ واﻟﻣﮭﻧﻲ‪ ،‬ھذه‬
‫اﻟﺑراﻣﺞ ﺗﻧﺟز ﻋﺑر ﺟﻣﻠﺔ ﻣن اﻟﺑراﻣﺞ اﻟﺗﻲ ﺗﺳﮭل ﻛﺗﺎﺑﺔ اﻷواﻣر ﻛﺑرﻧﺎﻣﺞ‬
‫‪ NetBeans‬و‪.Eclipse‬‬

‫س ‪ : ٣‬ﻣﺎ إﺻدارات اﻟﺟﺎﻓﺎ ؟‬

‫‪Java SE‬‬
‫اﻹﺻدار اﻟﻘﯾﺎﺳﻲ ﻣن اﻟﺟﺎﻓﺎ ﺑﺎﻹﻧﺟﻠﯾزﯾﺔ )‪ (Java Standard Edition‬ھو‬
‫اﻟﺟزء اﻟﺧﺎص ﺑﺑرﻣﺟﺔ ﺑراﻣﺞ ﺳطﺢ اﻟﻣﻛﺗب ) ‪StandAlone‬‬
‫‪.(applications‬‬

‫‪Java EE‬‬
‫اﺻدار اﻹﻧﺗرﺑراﯾس ﺑﺎﻹﻧﺟﻠﯾزﯾﺔ )‪(Java Enterprise Edition‬ھو ﯾﺧﺗﻠف‬
‫ﻋن اﻹﺻدار اﻟﻘﯾﺎﺳﻲ ﻓﻲ أﻧﮫ ﺧﺎص ﺑﺑرﻣﺟﺔ اﻟﺧوادم واﻟﺗطﺑﯾﻘﺎت اﻟﻣوزﻋﺔ‬
‫وﺑرﻣﺟﺔ اﻟوﯾب‪.‬‬
‫‪Java ME‬‬
‫اﺻدار اﻟﻣﺎﯾﻛرو ﺑﺎﻹﻧﺟﻠﯾزﯾﺔ )‪ (Java Micro Edition‬وھو إﺻدار ﺧﺎص‬
‫ﺑﺎﻟﺑرﻣﺟﺔ ﻋﻠﻰ اﻟﮭواﺗف اﻟﻣﺣﻣوﻟﺔ واﻷﺟﮭزة اﻟﻣﺣدودة ﻓﻲ اﻟﻣﺻﺎدر ﻋﻣوﻣﺎ‬
‫وﺗﻌﺗﺑر اﻟﺧﯾﺎر اﻷول ﻟﻣﺑرﻣﺟﻲ أﻟﻌﺎب اﻟﮭواﺗف اﻟﻣﺣﻣوﻟﺔ‪.‬‬

‫‪Java Fx‬‬
‫ﺗﻘﻧﯾّﺔ أﺧرى اﺻدرﺗﮭﺎ ﺻن ﻣﯾﻛروﺳﯾﺳﺗﻣز ﻟﺗطوﯾر ﺗطﺑﯾﻘﺎت ﻣن ﻧوع "‪ "RIA‬أي‬
‫"‪."Rich Internet Applications‬‬

‫س‪ : ٤‬ﻛم ﯾﺗطﻠب اﻟوﻗت ﻣن ﻣﻣﺎرﺳﺔ وﺗﻌﻠم اﻟﺟﺎﻓﺎ ﺣﺗﻰ ﺗﺻﺑﺢ ﻣﺣﺗرف ؟‬
‫اﻟﺟﺎﻓﺎ ﻟﻐﺔ ھﺎﺋﻠﺔ وﻛﺑﯾرة وطﺑﻌﺎ اﻟﻣدة ﺗﻛون ﺣﺳب ھﻣﺔ اﻟﺷﺧص وارادﺗﮫ وﻟﻛﻲ‬
‫ﺗﺻﺑﺢ ﻣﺣﺗرف ﻓﻲ اﻟﻠﻐﺔ ﻛوﻗت ﺗﻘرﯾﺑﻲ ﯾﺣﺗﺎج ﻟك ﺛﻼﺛﺔ إﻟﻰ ﺧﻣﺳﺔ ﺳﻧﯾن ‪.‬‬

‫‪٩‬‬
 ‫س‪ :٥‬ﻣﺎ ھو ﻣدى اﻧﺗﺷﺎر اﻟﺟﺎﻓﺎ ﺧﺻوﺻﺎ ﻓﻲ اﻟوطن اﻟﻌرﺑﻲ؟‬

‫ﻓﻲ اﻟﺣﻘﯾﻘﺔ اﻟﺟﺎﻓﺎ ﻣﻧﺗﺷرة ﻓﻲ اﻟدول اﻟﻣﺗﻘدﻣﺔ ﺑﺻورة ﻛﺑﯾرة ﺟدا و ﺧﺻوﺻﺎ ً ﻓﻲ‬
‫) اﻣرﯾﻛﺎ وﺑرﯾطﺎﻧﯾﺎ ( و ﻟﻛن ﻣﻊ اﻻﺳف ﻓﮭﻲ ﻋﺎﻟﻣﻧﺎ اﻟﻌرﺑﻲ ﻗﻠﯾﻠﺔ اﻻﻧﺗﺷﺎر و أن‬
‫ﻛﺎﻧت اﻟﺟﺎﻣﻌﺎت أدﺧﻠﺗﮭﺎ و ﻟﻛن ﻣﻧذ ﻣدة ﺑﺳﯾطﺔ ﻧﺳﺑﯾﺎ ً‪.‬‬

‫س‪ : ٦‬ﻣﺎھﻲ اﻟﻛﻠﻣﺎت اﻟﻣﺣﺟوزة ﻓﻲ ﻟﻐﺔ ﺟﺎﻓﺎ اي اﻟﻛﻠﻣﺎت اﻟﺗﻲ ﻻ ﯾﺳﻣﺢ ﺑﺎﺳﺗﺧداﻣﮭﺎ إﻻ‬
‫ﻟﻠﻐرض اﻟذي اﻧﺷﺄت ﻣن اﺟﻠﮫ ؟‬

‫‪١٠‬‬
 ‫س‪ : ٧‬ﻛﯾف ﯾﻣﻛن إﻋﺎدة ﺗﺳﻣﯾﺔ ‪ class‬ﻣﻌﯾن ﻣن ﻋﻠﻰ أﺣد اﻟـ ‪ IDE‬؟‬
‫ﺗﺿﻐط ﻋﻠﻰ اﻟﻛﻼس ﺑﺎﻟزر اﻷﯾﻣن ﺛم ﺗﺿﻐط ﻣن اﻟﻘﺎﺋﻣﺔ ﻋﻠﻰ ‪ Refactor‬ﺛم ﺗﺧﺗﺎر‬
‫‪ rename‬وﺳوف ﯾﺗم ﺗﺣدﯾث اﻻﺳم ﻓﻲ اﻟﻛود ﺗﻠﻘﺎﺋﯾﺎ دون ﺗدﺧل ﻣﻧك‬
‫س‪ : ٨‬ﻣﺎ ھو اﻟﻣﻘﺻود ﺑـ ‪ variable‬و‪ value‬ﻓﻲ ﺟﺎﻓﺎ؟‬
‫‪: Variable‬ھو اﻟﻣﺗﻐﯾر ‪.‬‬
‫‪ :Value‬ھو اﻋطﺎء او اﺳﻧﺎد ﻗﯾﻣﮫ ﻟذﻟك اﻟﻣﺗﻐﯾر ‪.‬‬

‫س‪ : ٩‬ﻣﺎ ھﻮ اﻟﻜﻮﻧﺴﺘﺮاﻛﺘﺮ )‪ (Constructor‬؟‬

‫ﯾﺴﺘﺨﺪم اﻟﻜﻮﻧﺴﺘﺮاﻛﺘﺮ ﻹﻋﻄﺎء اﻟﻘﯿﻢ اﻷوﻟﯿﺔ ﻟﻸوﺑﺠﻜﺖ ﻓﻲ اﻟﻜﻼس وﯾﻜﻮن ﻟﮫ ﻧﻔﺲ إﺳﻢ‬
‫اﻟﻜﻼس ﺗﻤﺎﻣﺎ ً‬
‫ھﻨﺎك اﺧﺘﻼف ﻣﺎ ﺑﯿﻦ اﻟﻜﻮﻧﺴﺘﺮاﻛﺘﺮ واﻟﻤﯿﺜﻮد ﻓﻲ اﻵﺗﻲ ‪:‬‬
‫‪.‬اﻟﻜﻨﻮﺳﺘﺮاﻛﺘﺮ ‪ :‬ﯾﺴﺘﺨﺪم ﻹﻋﻄﺎء اﻟﻘﯿﻢ اﻻﺑﺘﺪاﺋﯿﺔ ﻟﻸوﺑﺠﻜﺖ ﻋﻨﺪ ﺧﻠﻘﮫ ‪.‬‬
‫‪ .‬اﻟﻤﯿﺜﻮد ‪ :‬ﺗﻌﻄﻲ ﻗﯿﻢ ﻟﻸوﺑﺠﻜﺖ وﻟﻜﻦ ﻋﻨﺪ اﺳﺘﺪﻋﺎﺋﮭﺎ ﻓﻘﻂ ‪.‬‬
‫اﻟﻜﻮﻧﺴﺘﺮاﻛﺘﺮ ﻓﻲ اﻟﻜﻼس ﻻﯾﻮرث ﻟﻠﺴﺐ ﻛﻼس وﯾﻌﺮف ﻋﻠﻰ أﻧﮫ ‪public‬‬
‫ﺣﺘﻰ ﺗﺴﮭﻞ ﻋﻤﻠﯿﺔ ﺧﻠﻖ اﻷوﺑﺠﻜﺖ ﻣﻨﮫ ﺧﺎرج اﻟﻜﻼس ﻧﻔﺴﮫ ‪.‬‬

‫"‪The KeyWord "THIS‬‬

‫ﺗﺴﺘﺨﺪم ﺑﻐﺮض اﺳﺘﺪﻋﺎء اﻷوﺑﺠﻜﺖ ‪.‬‬
‫"‪key word "SUPER‬‬
‫ﺗﺴﺘﺨﺪم ﻓﻲ ﻛﻮﻧﺴﺘﺮاﻛﺘﺮ اﻟﺴﺐ ﻛﻼس ذﻟﻚ ﻟﺘﻘﻮم ﺑﻮراﺛﺔ ﺟﻤﯿﻊ اﻟﻤﺘﻐﯿﺮات واﻟﻘﯿﻢ اﻟﻤﻌﺮﻓﺔ‬
‫ﻓﻲ اﻟﺴﻮﺑﺮ ﻛﻼس ‪.‬‬

‫‪١١‬‬
 ‫س‪ : ١٠‬ﻛﯿﻒ اﻗﻮم ﺑﺈﻧﺸﺎء ﻛﺎﺋﻦ ﻣﻦ ﻛﻼس ﺑﺄﺷﻜﺎل ﻣﺨﺘﻠﻔﺔ )أي ﻋﻦ طﺮﯾﻖ ادراج‬
‫ﺑﺎراﻣﺘﺮات ﻣﺨﺘﻠﻔﺔ( ؟‬
‫ﯾﻜﻮن ھﺬا ﻋﻦ طﺮﯾﻖ اﻧﺸﺎء ﻋﺪد ﻣﻦ اﻟﻜﻮﻧﺴﺘﺮاﻛﺘﺮ ﻟﻨﻔﺲ اﻟﻜﻼس وذﻟﻚ ﺣﺴﺐ اﻟﺤﺎﺟﺔ‬
‫ﻟﮫ‬
‫ﻣﺜﺎل ‪:‬‬
‫اﻧﺸﺎء اﻟﻜﻮﻧﺴﺘﺮاﻛﺘﺮ اﻻﻓﺘﺮاﺿﻲ }{)(‪public constructor‬‬
‫اﻧﺸﺎء اﻟﻜﻮﻧﺴﺘﺮاﻛﺘﺮ اﻻول ﺑﺒﺎراﻣﯿﺘﺮ واﺣﺪ }{)‪public constructor(int a‬‬
‫اﻧﺸﺎء اﻟﻜﻮﻧﺴﺘﺮاﻛﺘﺮ اﻟﺜﺎﻧﻲ ﺑﺒﺎراﻣﯿﺘﺮﯾﻦ ‪public constructor(int a,int b){} ...‬‬
‫اﻟﺦ ‪.‬‬

‫س‪ : ١١‬ﻣﺎ ﻣﻌﻨﻰ اﻟﺒﺮﯾﻔﺎﯾﺖ )‪ (private‬و اﻟﺒﺮوﺗﻜـﺘﺪ )‪ (protected‬و اﻟﺒﺎﺑﻠﻚ‬

‫)‪ (public‬ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﺘﻐﯿﺮات ؟؟‬

‫ﻛﻞ ﻣﺘﻐﯿﺮ ﻓﻲ ﻟﻐﺔ ﺟﺎﻓﺎ وﯾﺘﻤﯿﺰ ﺑﺨﺎﺻﯿﺔ ﻣﻦ اﻟﺨﻮاص اﻟﺜﻼﺛﺔ اﻟﻤﺬﻛﻮرة اﻋﻼه واﻟﺘﻲ‬
‫ﺗﺴﻤﻰ ﺑـ)‪ ،(acces modefires‬وھﺬه اﻟﺨﻮاص ھﻲ اﻟﺘﻲ ﺗﺴﻤﺢ ﺑﺈﻣﻜﺎﻧﯿﺔ اﻟﻮﺻﻮل اﻟﻰ‬
‫اﻟﻤﺘﻐﯿﺮ ﻣﻦ ﻋﺪﻣﮭﺎ ‪.‬‬

‫ﺑﺮاﯾﻔﺖ )‪ :(private‬و ھﻲ ﺧﺎﺻﯿﺔ ﺗﺸﻔﯿﺮ ﻣﺘﻜﺎﻣﻞ ﻟﻠﻤﺘﻐﯿﺮ ﺣﯿﺚ ﯾﻤﻨﻊ ﻣﻨﻌﺎ ﺑﺎﺗﺎ اﻟﻮﺻﻮل‬
‫اﻟﯿﮫ ﻣﻦ ﺧﺎرج اﻟﻜﻼس اﻟﻤﻌﺮف ﺑﺪاﺧﻠﮭﺎ ﻣﺒﺎﺷﺮة ) أي ﻋﻦ طﺮﯾﻖ اﺳﻤﮫ ( ‪.‬‬

‫‪١٢‬‬
 ‫ﺑﺮوﺗﻜـﺘﺪ )‪ : (protected‬وھﻲ ﺧﺎﺻﯿﺔ اﻗﻞ درﺟﺔ ﻣﻦ اﻟﺒﺮﯾﻔﺎﯾﺖ ﺣﯿﺚ ﺗﺴﻤﺢ ﻟﻠﻜﻼﺳﺎت‬
‫اﻟﻮارﺛﺔ ﻣﻦ اﻟﻜﻼس اﻻﺻﻠﻲ اﻟﺬي ﻋﺮف اﻟﻤﺘﻐﯿﺮ ﺑﺪاﺧﻠﮫ ﻣﻦ اﻟﻮﺻﻮل اﻟﯿﮫ ﺑﺴﮭﻮﻟﺔ ) أي‬
‫ﻋﻦ طﺮﯾﻖ اﻻﺳﻢ ‪ ،‬اﺳﻢ اﻟﻤﺘﻐﯿﺮ ﻣﺒﺎﺷﺮة ( ‪.‬‬

‫ﺑﺎﺑﻠﯿﻚ )‪ : (public‬ھﻲ اﻟﺨﺎﺻﯿﺔ اﻟﺜﺎﻟﺜﺔ وھﻲ أﻟﯿﻦ اﻟﺨﻮاص ‪ ،‬ﺣﯿﺚ ﺗﺴﻤﺢ ﻟﻚ ﺑﺎﻟﻮﺻﻮل‬
‫ﻟﻠﻤﺘﻐﯿﺮ ﻣﻦ أي ﻣﻜﺎن ﺷﺌﺖ ‪.‬‬

‫ﻣﻼﺣﻈﺔ ‪ :‬اذا ﻟﻢ ﻧﻘﻢ ﺑﺈدراج أي ﺧﺎﺻﯿﺔ ﻣﻦ ھﺬه اﻟﺨﻮاص ﻟﻠﻤﺘﻐﯿﺮ ﻓﺎن ﻟﻐﺔ ﺟﺎﻓﺎ ﺗﻘﻮم‬
‫ﺑﻤﻨﺤﮫ ﺧﺎﺻﯿﺔ ‪ Default Access Modifier‬اﻓﺘﺮاﺿﯿﺎ ‪.‬‬

‫واﻟـ ‪: Default Access Modifier‬‬

‫ﻧوع راﺑﻊ ﻟل‪ Access Modifier‬ﻟﻛن ﻏﯾر ﻣﺷﮭوره ﺟدا‬
‫اﻟﻣﺗﻐﯾر أو اﻟداﻟﺔ اﻟﺗﻲ ﻟﻣﺎ ﺗﺳﺑﻘﮭﺎ أي ﻛﻠﻣﺔ ﻣن اﻟﺛﻼث اﻟﺳﺎﺑﻘﺔ ‪ private‬أو‬
‫‪ protected‬أو ‪ public‬ﻓﮭﻲ ﺗﻌﺗﺑر ‪. Default‬‬
‫و اﻟﺗﻌﺎﻣل ﻣﻌﮭﺎ ﻣﺣﺻور داﺧل اﻟﻛﻼﺳﺎت اﻟﺗﻲ داﺧل اﻟـ ‪. pakage‬‬

‫س‪: ١٢‬ﻛﯾف أﺧزن ﻗﯾﻣﺔ ﻓﻲ ﻣﺗﻐﯾر ؟‬

‫ﯾﻣﻛن ﺗﺣدﯾد ﻗﯾﻣﺔ أوﻟﯾﺔ ﻟﻠﻣﺗﻐﯾر ﻋﻧدﻣﺎ ﻧﻘوم ﺑﺈﻧﺷﺎﺋﮫ وﻧﺳﺗطﯾﻊ أﯾﺿﺎ ﺗﺣدﯾد ﻗﯾﻣﺔ ﻟﻠﻣﺗﻐﯾر ﻓﻲ أي‬
‫ﻣوﺿﻊ ﺗﺎﻟﻲ ﺿﻣن اﻟﺑرﻧﺎﻣﺞ وﺗﺳﺗﻌﻣل ﻋﻼﻣﺔ = ﻟﺗﺣدﯾد ﻗﯾﻣﺔ أوﻟﯾﺔ ﻟﻠﻣﺗﻐﯾر ﻋﻧد إﻧﺷﺎﺋﮫ وﯾﻣﻛن أن‬
‫ﻧﺄﺧذ ﻣﺛﺎل‬

‫;‪int i = 500‬‬
‫ﻧﻼﺣظ أﻧﻧﺎ أﻧﺷﺄﻧﺎ ﻣﺗﻐﯾرا ‪i‬‬
‫ھذا اﻟﻣﺗﻐﯾر ﯾﺣﺗوي ﻋﻠﻰ اﻟﻘﯾﻣﺔ اﻹﺑﺗداﺋﯾﺔ ‪ ، ٥٠٠‬وھﻛذا وﺑﻧﻔس اﻟطرﯾﻘﺔ ﯾﻣﻛﻧﻧﺎ إﻋداد اﻟﻣﺗﻐﯾرات‬
‫اﻟﻣﺧزﻧﺔ ﻟﻸﻋداد ‪..‬‬

‫‪١٣‬‬
 ‫وﯾﺧﺗﻠف اﻷﻣر ﺑﺎﻟﻧﺳﺑﺔ ﻟﻠﻣﺗﻐﯾرات اﻟﻣﺧزﻧﺔ ﻟﺳﻠﺳﻠﺔ ﻧﺻﯾﺔ ﺣﯾث ﯾﺟب وﺿﻊ ﻋﻼﻣﺎت اﻗﺗﺑﺎس‬
‫ﺣول اﻟﻘﯾﻣﺔ اﻟﻣراد ﺗﺧزﯾﻧﮭﺎ‬
‫;" ‪String studentName = "Hamza‬‬

‫س‪ : ١٣‬ھل ﯾﻣﻛن إﻋداد أﺣد اﻟﻣﺗﻐﯾرات ﻟﯾﺳﺎوي ﻗﯾﻣﺔ ﻣﺗﻐﯾر آﺧر ﻣن ﻧﻔس اﻟﻧوع ؟‬
‫ﻧﻌم ﯾﻣﻛﻧﻧﺎ إﻋداد ﻣﺗﻐﯾر ﻟﯾﺳﺎوي ﻗﯾﻣﺔ ﻣﺗﻐﯾر آﺧر ﻣن ﻧﻔس اﻟﻧوع ﻛﻣﺎ ﻧرى ﻓﻲ اﻟﻣﺛﺎل اﻟﺗﺎﻟﻲ‬
‫;‪int i = 500‬‬
‫; ‪int k= i‬‬
‫س ‪ : ١٤‬ﻟﻛن ﻣﺎذا ﯾﺣدث إذا ﻟم أﺣدد ﻗﯾﻣﺔ اﺑﺗداﺋﯾﺔ ﻟﻠﻣﺗﻐﯾر؟‬
‫ھﻧﺎ ﯾﺣدث ﺧطﺄ وﯾظﮭر ﻣﺗرﺟم اﻟﺟﺎﻓﺎ رﺳﺎﻟﺔ ﺧطﺄ وﻟذﻟك ﯾﺟب ﺗﺣدﯾد ﻗﯾﻣﺔ أوﻟﯾﺔ ﻟﻠﻣﺗﻐﯾر‬

‫س ‪ : ١٥‬ھل ھﻧﺎك ﻗواﻋد ﻣﻌﯾﻧﺔ ﻟﺗﺳﻣﯾﺔ اﻟﻣﺗﻐﯾرات ؟‬

‫ﻧﻌم ھﻧﺎك ﻗواﻋد ﯾﺟب ﻣراﻋﺎﺗﮭﺎ ﻋﻧد ﺗﺳﻣﯾﺔ اﻟﻣﺗﻐﯾرات ﺣﯾث ﺗﺑدأ أﺳﻣﺎء اﻟﻣﺗﻐﯾرات ﺑﺣرف‬
‫إﻧﺟﻠﯾزي أو ﻋﻼﻣﺔ اﻟدوﻻر ‪ $‬أو ﻋﻼﻣﺔ اﻟﺗﺳطﯾر )‪ (-‬وﯾﻛون ﺑﺎﻗﻲ اﻹﺳم ﺣرف أو ﻋدد وﺑﺷرط‬
‫ﻋدم وﺿﻊ ﻣﺳﺎﻓﺎت ﻓﺎرﻏﺔ وﻻ ﯾﻣﻛﻧﻧﺎ إﺳﺗﻌﻣﺎل أﯾﺿﺎ ﻋﻼﻣﺎت اﻟﺗرﻗﯾم ﺣﯾث ﯾظﮭر ﻣﺗرﺟم اﻟﺟﺎﻓﺎ‬
‫رﺳﺎﻟﺔ ﺧطﺄ إذا ﻛﺎن ﻓﻲ إﺳم اﻟﻣﺗﻐﯾر ﻣﺳﺎﻓﺎت ﻓﺎرﻏﺔ أو ﻋﻼﻣﺎت ﺗرﻗﯾم واذا اﺳﺗﻌﻣﻠت ﺣرﻓﺎ ﻛﺑﯾرا‬
‫ﻓﻲ اﺳم ﻣﺗﻐﯾر ﻓﺎﻧﮫ ﯾﺟب اﺳﺗﻌﻣﺎﻟﮫ ﺑﻧﻔس اﻟطرﯾﻘﺔ ﻓﻲ ﻛل اﻟﺑرﻧﺎﻣﺞ ﻋﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل ‪:‬‬

‫ھذا اﺳم ﻟﻣﺗﻐﯾر ﻟن ﯾﻛون ﻧﻔس ھذا ‪studentName‬‬

‫ﺗﻐﯾﯾر اﻟﺣرف اﻷول ﻣن ﺻﻐﯾر اﻟﻰ ﻛﺑﯾر ﻓﻲ ﻧﻔس اﻟﺑرﻧﺎﻣﺞ ﻻﺳم اﻟﻣﺗﻐﯾر ‪StudentName‬‬
‫ﯾؤدي اﻟﻰ ﺧطﺄ ﻋﻧد اﻟﺗرﺟﻣﺔ‬
‫وﻟذﻟك ﯾﺟب أن ﯾﻛون اﺳم اﻟﻣﺗﻐﯾر داﻻ ﻋﻠﻰ اﻟﻐرض ﻣن اﺳﺗﻌﻣﺎل ھذا اﻟﻣﺗﻐﯾر واﻟﺣرف اﻷول ﻣن‬
‫اﺳﻣﮫ ﯾﺟب أن ﯾﻛون ﺻﻐﯾرا وﻓﻲ ﺣﺎﻟﺔ ﺗﻛون اﺳم اﻟﻣﺗﻐﯾر ﻣن أﻛﺛر ﻣن ﻛﻠﻣﺔ ﯾﻛون اﻟﺣرف اﻷول‬
‫ﻣن اﻟﻛﻠﻣﺔ اﻷوﻟﻰ ﺻﻐﯾرا وﺑﺎﻗﻲ اﻟﻛﻠﻣﺎت ﺗﺑدأ ﺑﺣروف ﻛﺑﯾرة وﺑدون ﻓواﺻل أو ﻋﻼﻣﺎت ﺗرﻗﯾم‬

‫‪١٤‬‬
 ‫س ‪ : ١٦‬ﻣﺎذا ﻋن اﻟﻌﻣﻠﯾﺎت اﻟرﯾﺎﺿﯾﺔ ﻋﻠﻰ اﻟﻣﺗﻐﯾرات ؟‬
‫ﻛﻣﺎ ﻗﻠﻧﺎ ﺳﺎﺑﻘﺎ ﺗطﻠب اﻟﺑرﻣﺟﺔ ﻋﻣوﻣﺎ ﻗدرات رﯾﺎﺿﯾﺔ ﻣﻌﯾﻧﺔ وﻓﻛر رﯾﺎﺿﻲ ﻓﻲ اﻟﻣﺑرﻣﺞ وﻋﻠﻰ‬
‫اﻟرﻏم ﻣن ﻗﯾﺎم اﻟﺣﺎﺳب ﺑﻛل اﻟﻌﻣﻠﯾﺎت اﻟرﯾﺎﺿﯾﺔ اﻻ أﻧﮫ ﯾرﯾد ﺗﻌﻠﯾﻣﺎت وأواﻣر ﻣن اﻟﻣﺑرﻣﺞ ﺣﺗﻰ‬
‫ﯾﻘوم ﺑﮭﻛذا ﻋﻣﻠﯾﺎت وﺗﺳﻣﻰ اﻷواﻣر اﻟﺗﻲ ﺗﻌطﯾﮭﺎ ﻟﻠﺣﺎﺳب واﻟﺗﻲ ﺗﺣﺗﺎج اﻟﻰ ﻋﻣﻠﯾﺎت رﯾﺎﺿﯾﺔ‬
‫ﺗﻌﺎﺑﯾر وﯾﻣﻛﻧﻧﺎ‬
‫اﺳﺗﺧدام ھذه اﻟﺗﻌﺎﺑﯾر ﻟﻠﻘﯾﺎم ﺑﻌدة ﻣﮭﺎم ﻣﻧﮭﺎ ﺗﻐﯾﯾر ﻗﯾﻣﺔ ﻣﺗﻐﯾر واﺳﺗﻌﻣﺎل اﻟﻣﻌﺎدﻻت ﻓﻲ اﻟﺑرﻧﺎﻣﺞ‬
‫وﺗﺳﺟﯾل ﻋدد ﻣرات ﺣدوث ﻋﻣل ﻣﺎ ﻓﻲ اﻟﺑرﻧﺎﻣﺞ وﺗﺳﺗﻌﻣل ھذه اﻟﺗﻌﺎﺑﯾر اﻟﺟﻣﻊ واﻟطرح واﻟﺿرب‬
‫واﻟﻘﺳﻣﺔ وﺑﺎﻗﻲ اﻟﻘﺳﻣﺔ‬
‫ﯾﻌﻧﻲ ھذا أﻧﻧﺎ رﺟﻌﻧﺎ اﻟﻰ اﻟﻣرﺣﻠﺔ اﻻﺑﺗداﺋﯾﺔ واﻟﻰ ﻣدرس اﻟﺣﺳﺎب اﻟﯾس ﻛذﻟك‬
‫ﻣﺎ أﺟﻣل اﻟﻌودة اﻟﻰ ذﻛرﯾﺎت اﻟطﻔوﻟﺔ واﻟﻣرﺣﻠﺔ اﻷوﻟﻰ وﺗﻠك اﻷﯾﺎم اﻟﺧواﻟﻲ ﺣﯾث اﻟﺑراءة واﻷﺣﻼم‬
‫اﻟوردﯾﺔ ـ ﻣﺎ ﻋﻠﯾﻧﺎ ـ ﻧرﺟﻊ ﺑﺎﻟذاﻛرة اﻟﻰ أﯾﺎم ﻣدرس اﻟرﯾﺎﺿﯾﺎت ﻓﻲ اﻟﻣرﺣﻠﺔ اﻹﻋدادﯾﺔ وﻧﺳﺗرﺟﻊ‬
‫اﻟﻌﻣﻠﯾﺎت اﻷرﺑﻊ اﻟﺷﮭﯾرة ﻓﻲ اﻟﺣﺳﺎب اﻟﺟﻣﻊ واﻟطرح واﻟﺿرب واﻟﻘﺳﻣﺔ وﻋﻼﻣﺎﺗﮭﺎ اﻷرﺑﻊ‬
‫‪ +‬اﻟﻣﻌروﻓﺔ‬
‫و ‪ -‬و * و ‪ /‬ھذه اﻟرﻣوز ﺗﺳﻣﻰ ﻣؤﺛرات وﺗﺳﺗﻌﻣل ھذه اﻟﻣؤﺛرات ﻓﻲ ﺑراﻣﺞ اﻟﺟﺎﻓﺎ ﻹﺟراء‬
‫اﻟﻌﻣﻠﯾﺎت اﻟرﯾﺎﺿﯾﺔ ﻋﻠﻰ اﻷرﻗﺎم طﺑﻌﺎ ﯾراودك ﺗﺳﺎؤل ﻋن اﻹﺧﺗﻼف ﺑﯾن * و × وﺑﯾن ‪ /‬و ÷‬
‫وﻟﻛن ﻛل أﻣر ﻧﺗﻔﻖ ﻓﯾﮫ ﻋﻠﻰ ﻗواﻋد ﻣن اﻟﺑداﯾﺔ ﯾﺳﮭل اﻷﻣور وھذا ﺑﻣﺛﺎﺑﺔ اﻟدﺳﺗور اﻟذي ﻧﻣﺷﻲ ﻋﻠﻰ‬
‫ﻣﻧﮭﺎﺟﮫ‬
‫‪operators‬‬ ‫ﻣﻌﺎﻣﻼت )ﻣؤﺛرات (‬
‫ﻧﺳﺗﻌﻣل اﻟﻌﻼﻣﺔ ‪ +‬ﻹﺟراء ﻋﻣﻠﯾﺔ اﻟﺟﻣﻊ‬
‫ﻧﺳﺗﻌﻣل اﻟﻌﻼﻣﺔ ‪ -‬ﻟﺗﻌﺑﯾر اﻟطرح‬

‫ﯾﺳﺗﻌﻣل ﺗﻌﺑﯾر اﻟﺿرب اﻟﻌﻼﻣﺔ * ﻓﻲ ﺑراﻣﺞ اﻟﺟﺎﻓﺎ‬

‫ﯾﺳﺗﻌﻣل ﺗﻌﺑﯾر اﻟﻘﺳﻣﺔ اﻟﻌﻼﻣﺔ ‪ /‬ﻓﻲ ﺑراﻣﺞ اﻟﺟﺎﻓﺎ‬
‫ﻧﺳﺗﻌﻣل اﻟﻣؤﺛر ‪ %‬ﻟﺗﺣدﯾد ﺑﺎﻗﻲ اﻟﻘﺳﻣﺔ‬
‫ﻧﺳﺗﻌﻣل اﻟﻣؤﺛر ‪ ++‬ﻟزﯾﺎدة اﻟﻘﯾﻣﺔ اﻟﻣﺧزﻧﺔ ﻓﻲ اﻟﻣﺗﻐﯾر ﺑﻣﻘدار واﺣد‬
‫ﯾﺳﺗﺧدم اﻟﻣﻌﺎﻣل ‪ --‬ﻹﻧﻘﺎص ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ﺑﻣﻘدار واﺣد‬

‫‪١٥‬‬
 ‫س‪ : ١٧‬أﻻ ﺗرى أن اﻷﻣور ﻗد ﺑدأت ﻓﻲ اﻟﺗﻌﻘﯾد ﯾﻌﻧﻲ إذا ﻛﺎن ھﻧﺎك أﻛﺛر ﻣن ﻋﻣﻠﯾﺔ ﺣﺳﺎﺑﯾﺔ ﻓﻲ‬
‫اﻟﺑرﻧﺎﻣﺞ اﻻ ﯾﻧﺑﻐﻲ أن أﻋرف اﻟﺗرﺗﯾب اﻟذي ﯾﺗﺑﻌﮫ اﻟﺣﺎﺳب ﻹﻧﺟﺎز ھذه اﻟﻌﻣﻠﯾﺎت ﺣﺗﻰ ﯾﻣﻛﻧﻧﻲ‬
‫ﺿﺑط ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ؟‬
‫أﺣﺳﻧت ھذا ﻣوﺿوع ھﺎم ﺟدا وﻧﺳﺗرﺟﻊ ﻣن اﻟدراﺳﺔ ﻓﻲ اﻟﻣرﺣﻠﺔ اﻟﺛﺎﻧوﯾﺔ ﻛﯾف ﻛﺎن ﻣدرس‬
‫اﻟرﯾﺎﺿﯾﺎت ﯾرﻛز ﻋﻠﻰ ھذا اﻷﻣر وﻣن ﯾﺗوزع ﻋﻠﻰ اﻵﺧر وﻣن ﯾﺳﺑﻖ ﻣن ﻓﻲ ھذه اﻟﻌﻣﻠﯾﺎت‬
‫اﻟرﯾﺎﺿﯾﺔ وﻓﻲ ﺑراﻣﺞ اﻟﺣﺎﺳب ﺗﺗم ھذه اﻟﻌﻣﻠﯾﺎت ﺣﺳب اﻟﺗرﺗﯾب اﻟﺗﺎﻟﻲ‬
‫ﯾﺗم أوﻻ اﻟزﯾﺎدة واﻟﻧﻘص ﺑﻣﻘدار واﺣد‬

‫ﯾﻠﻲ ذﻟك اﻟﺿرب واﻟﻘﺳﻣﺔ وﺑﺎﻗﻲ اﻟﻘﺳﻣﺔ‬

‫ﯾﺄﺗﻲ ﺑﻌد ذﻟك اﻟﺟﻣﻊ واﻟطرح‬
‫ﺛم اﻟﻣﻘﺎرﻧﺔ‬
‫وﺗﺳﺗﺧدم اﻟﻌﻼﻣﺔ = ﻟﺿﺑط ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر‬

‫س ‪ :١٨‬ھل ﯾرﺟﻊ اﻟﻣﺗﻐﯾر ﺑوﻟﯾﺎن اﻟذي ﯾﺳﺗﻌﻣل ﻟﺗﺧزﯾن ﻗﯾﻣﺗﯾن ﻓﻘط ھﻣﺎ ـ ﺻواب ‪،‬ﺧطﺄ ؟‬
‫ﻧﻌم ﯾﺎ ﺻدﯾﻖ اﻟﺟﻣﻠﺔ اذا ﺗﻌﻣل ﺑﻧﻔس اﻟﻣﺑدأ ﺣﯾث ﺗﺧﺗﺑر اﻟﺷرط ﻣن ﺣﯾث اﻟﺻواب أو اﻟﺧطﺄ وﻻ‬
‫ﺗﻘوم ﺑﺎﻟﻌﻣل إﻻ إذا ﻛﺎن اﻟﺷرط ﺻﺣﯾﺣﺎ‬
‫ﻣﺛﺎل ﺑﺳﯾط ﯾوﺿﺢ اﻷﻣور ﻟو ﺳﻣﺣت ؟‬
‫)‪if (hour < 12‬‬
‫;)"‪System.out.println("Good morning.‬‬

‫وﻧﻼﺣظ ھﻧﺎ أن ﺟواب اﻟﺷرط ﯾرﺗﺑط ﺑﻔﻌل اﻟﺷرط ﺑﻣﻌﻧﻰ أﻧﮫ اذا ﻟم ﯾﺗﺣﻘﻖ اﻟﺷرط ﻓﺎﻧﮫ ﻟن ﯾﺣدث‬
‫ﺷﻲء‬
‫وﻟﻛن ﻓﻲ ﺑﻌض اﻟﺣﺎﻻت أرﯾد أن أﻗﺎرن ﺑﯾن ﻗﯾﻣﺗﯾن ﻓﻣﺎذا أﻓﻌل ؟‬

‫اذا أردت أن ﺗﺧﺗﺑر ھل ﻗﯾﻣﺔ ﻣﻌﯾﻧﺔ ﺗﺳﺎوي أﺧرى أو أﻗل ﻣﻧﮭﺎ ﯾﻣﻛﻧك اﺳﺗﺧدام اﻟﻣؤﺛر أﺻﻐر ﻣن‬

‫‪١٦‬‬
 ‫=> أو ﯾﺳﺎوي‬
‫ﯾﺳﺗﺧدم ﻻﺧﺗﺑﺎر أﻛﺑر ﻣن أو ﯾﺳﺎوي =<‬

‫=> & =<‬

‫ھل ﯾﻣﻛﻧﻧﻲ إﺧﺗﺑﺎر اﻟﻣﺳﺎوة ﻓﻘط ؟‬

‫ﻧﻌم ﯾﻣﻛﻧك اﺧﺗﺑﺎر ﻣﺎ اذا ﻛﺎن ﻣﺗﻐﯾر ﻣﺎ ﯾﺳﺎوي ﻗﯾﻣﺔ ﻣﻌﯾﻧﺔ أو ﻻ وھل ﻣﺗﻐﯾر ﻣﺎ ﯾﺳﺎوي ﻣﺗﻐﯾر آﺧر‬
‫ﺑﺎﺳﺗﻌﻣﺎل اﻟﻣؤﺛر == وﻧﻼﺣظ أﻧﮫ ﯾﺗﻛون ﻣن ﻋﻼﻣﺗﻲ ﯾﺳﺎوي وﻧؤﻛد ﻋﻠﻰ أﻧﮫ ﻻ ﺗﺳﺗﻌﻣل ﻋﻼﻣﺗﻲ‬
‫اﻟﺗﺳﺎوي اﻻ ﻓﻲ اﻟﺟﻣل اﻟﺷرطﯾﺔ‬
‫طﯾب واﺧﺗﺑﺎر ﻋدم اﻟﻣﺳﺎوة ﻛﯾف ﯾﻛون ؟‬

‫ﻧﺳﺗﻌﻣل اﻟﻣؤﺛر =! ﻻﺧﺗﺑﺎر ﻋدم اﻟﻣﺳﺎوة‬

‫وھل ﻧﺳﺗﺧدم اﻟﻣؤﺛرﯾن اﻟﺳﺎﺑﻘﯾن ﻟﻛل أﻧواع اﻟﻣﺗﻐﯾرات ؟‬
‫ﻧﺳﺗﺧدم اﻟﻣؤﺛرﯾن == & =! ﻟﻛل أﻧواع اﻟﻣﺗﻐﯾرات ﻣﺎ ﻋدا اﻟﻣﺗﻐﯾر اﺳﺗرﯾﻧﺞ اﻟﺧﺎص ﺑﺳﻠﺳﻠﺔ‬
‫اﻟﺣروف وﻗد ﺗﻛﻠﻣﻧﺎ ﻓﻲ اﻟدرس اﻟﺳﺎدس ﻋن ھذا اﻟﻣوﺿوع وأﺷرﻧﺎ ﻓﻲ ﺣﯾﻧﮫ اﻟﻰ اﺳﺗﻌﻣﺎل اﻟﻧﮭﺞ‬
‫اﯾﻛوال ﻻﺧﺗﺑﺎر ﺗﺳﺎوي ﺳﻠﺳﻠﺗﻲ ﺣروف‬
‫ﻓﻲ ﺟﻣﯾﻊ اﻷﻣﺛﻠﺔ اﻟﺳﺎﺑﻘﺔ ﺗﺟﻌل ﺟواب اﻟﺷرط أﻣرا واﺣدا وھو اﻟﻧﮭﺞ‬
‫) ( ‪println‬‬
‫وﻟﻛﻧﻧﺎ ﻓﻲ ﻋدﯾد ﻣن اﻟﺣﺎﻻت ﻗد ﻧرﻏب ﻓﻲ اﻧﺟﺎز أﻛﺛر ﻣن ﻣﮭﻣﺔ ﻛﻧﺗﯾﺟﺔ ﻟﻔﻌل اﻟﺷرط ﻓﻣﺎذا ﻧﻔﻌل ؟‬

‫ﻛﻼﻣك ﺻﺣﯾﺢ ﯾﺎﺻدﯾﻘﻲ ﻣﻌك ﺣﻖ وأﺑﺷرك أﻧك اﻵن ﻗد ﺑدأت ﺗﻧﺗﮭﺞ اﻟﻧﮭﺞ اﻟﺻﺣﯾﺢ ﻓﻲ اﻟﺑرﻣﺟﺔ‬
‫وھذه اﻟﻣﻠﺣوظﺔ ﺗﺄﺧذﻧﺎ اﻟﻰ اﻟﻐوص ﻓﻲ ﺑﺣر اﻟﺑرﻣﺟﺔ ﻟﻧﺑﺣث ﻋن اﻟدر ﻓﻲ ﺻدﻓﺎﺗﮫ‬

‫ﻟﻛﻲ ﺗﻧﺟز أﻛﺛر ﻣن ﻣﮭﻣﺔ ﻛﻧﺗﯾﺟﺔ ﻟﺗﺣﻘﻖ اﻟﺷرط ﻋﻠﯾك أن ﺗﻧﺷﺄ ﺟﻣل ﻛﺗﻠﯾﺔ ﺑواﺳطﺔ } { اﻟﺣﺎﺻرﺗﯾن‬

‫‪١٧‬‬
 ‫ﺑﺎﻟﻣﻧﺎﺳﺑﺔ اﻟﺟﻣل اﻟﻛﺗﻠﯾﺔ ھﻲ ﺟﻣل ﻣرﺗﺑﺔ ﻓﻲ اطﺎر ﻣﺟﻣوﻋﺔ‬
‫) (‪main‬‬
‫وھذه اﻟﻛﺗﻠﺔ ﺗﺑدأ ﺑﺣﺎﺻرة اﻟﻔﺗﺢ } وﺗﻧﺗﮭﻲ ﺑﺣﺎﺻرة اﻟﻐﻠﻖ { اذا ً ﻧﺳﺗﻌﻣل اﻟﺟﻣل اﻟﻛﺗﻠﯾﺔ ﻣﻊ ﻓﻌل‬
‫اﻟﺷرط ﻟﻛﻲ ﻧﺟﻌل اﻟﺣﺎﺳب ﯾﻘوم ﺑﺈداء ﻋدة ﻣﮭﺎم ﻛﻧﺗﯾﺟﺔ ﻟﺗﺣﻘﻖ اﻟﺟﻣﻠﺔ اﻟﺷرطﯾﺔ‬
‫{ )‪if (minute != 0‬‬
‫;)" " ‪System.out.print(" " + minute +‬‬
‫;)"‪System.out.print( (minute != 1) ? "minutes" : "minute‬‬
‫;)"‪System.out.print(" past‬‬
‫}‬
‫س ‪: ١٩‬ﻓﻲ ﺑﻌض اﻷﺣﯾﺎن ﻧرﯾد ﻣن اﻟﺣﺎﺳب اﻧﺟﺎز ﻋﻣل ﻣﺎ اذا ﻛﺎن اﻟﺷرط ﺻﺣﯾﺣﺎ واﻟﻘﯾﺎم ﺑﻌﻣل‬
‫آﺧر اذا ﻛﺎن ھذا اﻟﺷرط ﻏﯾر ﺻﺣﯾﺢ ﻓﻣﺎذا ﻧﻔﻌل أﺳﺗﺎذي اﻟﻌزﯾز ﻓﻲ ھذه اﻟﻣﺷﻛﻠﺔ ؟‬
‫ﻟﻛﻲ ﺗﻔﻌل ذﻟك ﻋﻠﯾك اﺳﺗﻌﻣل اﻟﺟﻣﻠﺔ‬

‫‪ if‬ﻣﻊ اﻟﺟﻣﻠﺔ ‪else‬‬

‫)‪if (hour < 12‬‬
‫;)"‪System.out.println("Good morning.\n‬‬
‫)‪else if (hour < 17‬‬
‫;)"‪System.out.println("Good afternoon.\n‬‬
‫‪else‬‬
‫;)"‪System.out.println("Good evening.\n‬‬
‫_____________________________________________________‬
‫_________________‬
‫)'‪if ( grade = = 'A‬‬
‫;)" ﻧﺎﺟﺢ ﺑﺎﻣﺗﯾﺎز "(‪System.out.println‬‬

‫‪١٨‬‬
‫)'‪else if ( grade = = 'B‬‬
‫;)" ﻧﺎﺟﺢ ﺑﺗﻘدﯾر ﺟﯾد ﺟدا "(‪System.out.println‬‬
‫)'‪else if ( grade = = 'C‬‬
‫;)" ﻧﺎﺟﺢ ﺑﺗﻘدﯾر ﺟﯾد"(‪System.out.println‬‬
‫)'‪else if ( grade = = 'D‬‬
‫;)" ﻧﺎﺟﺢ ﺑﺗﻘدﯾر ﻣﻘﺑول"(‪System.out.println‬‬
‫‪else‬‬
‫;)" راﺳب وﺑﺎق ﻟﻼﻋﺎدة "(‪System.out.println‬‬
‫س ‪ :٢٠‬اﻟﺣﺎﻻت اﻟﺳﺎﺑﻘﺔ ﻓﯾﮭﺎ ﺷرطﺎن ﻓﻘط ﺑﺎﺳﺗﺛﻧﺎء اﻟﻣﺛﺎل أﻋﻼه اﻻ ﯾوﺟد طرﯾﻘﺔ أﺧرى ﻟﻠﺗﻌﺎﻣل‬
‫ﻣﻊ ﺷروط ﻣﺧﺗﻠﻔﺔ ﻣﺗﻧوﻋﺔ‬
‫ﯾوﺟد طرﯾﻘﺔ أﺧرى ﻻﺧﺗﺑﺎر ﻣﺟﻣوﻋﺔ ﻣﺗﻧوﻋﺔ ﻣن اﻟﺷروط واﻻﺳﺗﺟﺎﺑﺔ ﻟﻛل ﻣﻧﮭﺎ ﻣﻧﻔردا ھذه‬
‫اﻟطرﯾﻘﺔ ھﻲ اﺳﺗﻌﻣﺎل اﻟﺟﻣﻠﺔ‬
‫‪switch‬‬

‫‪----------------------------------------------------------‬‬
‫{ )‪switch (month‬‬
‫‪case (1):‬‬
‫;)"‪System.out.print("January‬‬
‫;‪break‬‬
‫‪case (2):‬‬
‫;)"‪System.out.print("February‬‬
‫;‪break‬‬
‫‪case (3):‬‬
‫;)"‪System.out.print("March‬‬

‫‪١٩‬‬
break;
case (4):
System.out.print("April");
break;
case (5):
System.out.print("May");
break;
case (6):
System.out.print("June");
break;
case (7):
System.out.print("July");
break;
case (8):
System.out.print("August");
break;
case (9):
System.out.print("September");
break;
case (10):
System.out.print("October");
break;
case (11):
System.out.print("November");

٢٠
‫;‪break‬‬
‫‪case (12):‬‬
‫;)"‪System.out.print("December‬‬
‫}‬
‫ﯾﺣدد اﻟﺳطر اﻷول ﻣن اﻟﺟﻣﻠﺔ ﺳوﯾﺗش اﻟﻣﺗﻐﯾر اﻟﻣراد اﺧﺗﺑﺎره وھو ھﻧﺎ ﻣﺗﻐﯾر اﻟﺷﮭر ﺛم ﻧﺗﺳﺗﻌﻣل‬
‫ﺑﻌد ذﻟك اﻟﺣﺎﺻرﺗﯾن ﻟﺗﻛوﯾن ﺟﻣﻠﺔ ﻛﺗﻠﯾﺔ‬

‫اﻟﺟﻣﻠﺔ ‪case‬‬

‫ﺗﺧﺗﺑر ھذه اﻟﺟﻣﻠﺔ ﻗﯾﻣﺔ ﻣﺗﻐﯾر اﻻﺧﺗﺑﺎر اﻟﻣﺣدد ﻓﻲ اﻟﺟﻣﻠﺔ ﺳوﯾﺗش ﻣﻘﺎرﻧﺔ ﺑﻘﯾﻣﺔ ﻣﻌﯾﻧﺔ‬

‫س ‪ :٢١‬ﻣﺎ ھﻲ أﻧواع ال‪) Methods‬اﻟدوال( ﻓﻲ اﻟﺟﺎﻓﺎ ؟‬

‫ھﻧﺎك ﻧوﻋﺎن ﻣن اﻟﻣﯾﺛودز ‪:‬‬
‫‪ : Getter‬وﺗﺳﻣﻰ ‪ accessors methods‬وﻻ ﺗﻐﯾر ﺷﯾﺋﺎ ﻣن ﺣﺎﻟﺔ اﻷوﺑﺟﻛت وﺗﻛون‬
‫ﻣﻌﮭﺎ ﻛﻠﻣﺔ ‪ return‬ﻣﻼزﻣﺔ ﻟﮭﺎ ‪.‬‬
‫ﻣﺛﺎل ‪ ()frog.getPostion :‬ﻻﺗرﺟﻊ أي ﻗﯾم‪.‬‬

‫‪ : Setter‬وﺗﺳﻣﻲ ‪ Mutater methods‬ﺗﻐﯾر ﻣن ﺣﺎﻟﺔ اﻻوﺑﺟﻛت وﻻﺗوﺟد ﻣﻌﮭﺎ‬

‫ﻛﻠﻣﺔ ‪ return‬ﻣﺛﺎل ‪ (frog.setColour(RED :‬ﻏﯾرت اﻻوﺑﺟﻛت ﻓروغ ﻟﻠون‬
‫اﻻﺣﻣر‪.‬‬

‫‪٢١‬‬
 ‫س ‪ :٢٢‬ﻣﺎ ھﻲ اﻟـ ‪ packages‬؟‬
‫ھﻲ ﻣﺟﻣوﻋﺔ ﻣن اﻟﻛﻼﺳﺎت ﯾﺗم اﺳﺗدﻋﺎﺋﮭﺎ ﻋﻧد اﻟﺣﺎﺟﺔ إﻟﯾﮭﺎ‪ .‬وﺗﺳﺗﺧدم ﻛﻠﻣﺔ ‪import‬‬
‫ﻻﺳﺗدﻋﺎﺋﮭﺎ ‪ ،‬وﺗﻘوم ﺑﺎﺳﺗدﻋﺎء ﺟﻣﯾﻊ اﻟﻛﻼﺳﺎت ذات اﻟﻌﻼﻗﺔ ﻓﻲ اﻟﺑﺎﻛﺞ ﻋﻧد وﺿﻊ ﻋﻼﻣﺔ‬
‫اﻟﻧﺟﻣﺔ )*( ‪.‬‬

‫ھﻧﺎك ﻧوﻋﯾن ﻣن اﻟﺑﺎﻛﺞ ﻓﻲ اﻟﺟﺎﻓﺎ ‪:‬‬

‫‪ <------- standered java backages -١‬ﻛﻼﺳﺎت ﺟﺎھزة ﻟﻼﺳﺗﺧدام‪.‬‬
‫‪ <------- developer java packages -٢‬ﺗﻛﺗب او ﺗطور ﺑواﺳطﺔ اﻟﻣﺑرﻣﺞ ﻧﻔﺳﮫ‪.‬‬

‫س ‪ :٢٣‬ﻣﺎ ھو اﻟﻔرق ﺑﯾن ال ‪ overriding & overloading‬؟‬

‫‪ : overriding‬ﺗﻌﻧﻲ أن ﻧﻔس اﻟﻣﯾﺛود ﺑﻧﻔس اﻷﺳم ﻓﻲ اﻟﺳوﺑر ﻛﻼس واﻟﺳب ﻛﻼس‬
‫ﻟﻛﻧﻧﺎ ﻧﻌدل ﻋﻠﯾﮭﺎ ﻓﻲ اﻟﺳب ﻛﻼس ﺣﺳب اﻷﻣر اﻟﻣراد ﺗﻐﯾﯾره أو ﺗﻌدﯾﻠﮫ ‪.‬‬
‫‪: overloading‬ﻧﻔس اﻟﻣﯾﺛود ﻓﻲ ﻧﻔس اﻟﻛﻼس ﻟﻛﻧﮭﺎ ﺗﺧﺗﻠف ﻓﻲ ﻋدد اﻟﺑﺎراﻣﯾرات ‪.‬‬

‫س ‪ :٢٤‬ﻣﺎ ھﻲ أﻧواع اﻟﻣﺗﻐﯾرات ﻓﻲ اﻟﺟﺎﻓﺎ ؟‬

‫‪ << primitive data type‬ﻣﺟﻣوﻋﺔ ﻣن اﻟﻘﯾم وﺗﻧﻘﺳم اﻟﻲ اﻧواﻋﻧﺎ اﻟﻣﻌروﻓﺔ ‪ ،‬ﻣﺛل ‪:‬‬
‫‪int, double, byte, etc‬‬
‫‪ << refrenace type‬ﺗﺷﯾر إﻟﻰ اوﺑﺟﻛت ﻣﺛل ‪. String , Array :‬‬

‫س ‪ :٢٥‬ﻣﺎ ھو ﻣﺻطﻠﺢ اﻟـ ‪ escape sequence‬؟‬

‫ھو ﻣﺻطﻠﺢ ﯾﻌﻧﻲ اﺳﺗﺧدام ﻋﻼﻣﺔ اﻟﺑﺎك ﺳﻼش )\( ﻟﯾﻐﯾر ﻣﻔﻌول ﻣﺎ ﺑﻌد اﻟﺣروف ﻓﻲ‬
‫ﻟﻐﺔ اﻟﺟﺎﻓﺎ ﻓﻣﺛﻼ ‪:‬‬
‫'‪ '\n‬ﺗﻌﻧﻲ ﺳطر ﺟدﯾد‪.‬‬

‫‪٢٢‬‬
 ‫س ‪ :٢٦‬ﻣﺎ ﻣﻌﻧﻰ اﺳﺗﺧدام ‪ static‬ﻓﻲ اﻟـ ‪ methods & variables‬؟‬
‫ﻋﻧدﻣﺎ ﯾﺣﺗوي اﻟﻛﻼس ﻋﻠﻲ أي ﻣن ‪ static methods OR variables‬ﺗﻌﻧﻲ اﻧﮭﺎ‬
‫ﺗﺣﺗوي ﻋﻠﻰ ﻧﺳﺧﺔ واﺣدة ﻓﻘط ﻓﻲ اﻟﻛﻼس ﻟﻛل اﻻوﺑﺟﻛﺗز ‪.‬‬
‫ﯾﺗم اﺳﺗﺧدام ‪ static variables‬ﻣﻊ اﻟﺛواﺑت او ﻋﻧد ﺗﻌرﯾف ‪ variable‬واﺣد ﻓﻲ ﻛل‬
‫اﻟﻛﻼﺳﺎت ‪.‬‬

‫س ‪ :٢٧‬ﻣﺎ ھﻲ ﺑﺎﻛﺞ *‪ java.lang.‬؟‬

‫ھذه اﻟﺑﺎﻛﺞ ﯾﺗم اﺳﺗﺧداﻣﮭﺎ ﻓﻲ ﺟﻣﯾﻊ ﻛﻼﺳﺎت اﻟﺟﺎﻓﺎ ﻟذﻟك ﻟﯾس ھﻧﺎك داﻋﻲ ﻟﻺﺳﺗدﻋﺎﺋﮭﺎ‬
‫ﻓﻲ ﻛل ﺑرﻧﺎﻣﺞ ‪ ،،‬ﻷﻧﮫ ﯾﺗم اﺳﺗدﻋﺎﺋﮭﺎ اﺗوﻣﺎﺗﯾﻛﯾﺎ ‪.‬‬
‫س ‪ :٢٨‬ﻣﺎ ھو اﻟﻔرق ﺑﯾن )&( و )&&( ﻓﻲ ﺟﻣل اﻟﻣﻘﺎرﻧﺔ ؟‬

‫اﻟﻔرق ﺑﯾﻧﮭﻣﺎ‪:‬‬
‫اﻟﺣﺎﻟﺔ اﻷوﻟﻰ )&( ‪:‬‬
‫ﻓﻲ ھذه اﻟﺣﺎﻟﺔ ﯾﻘوم اﻟﻣﺗرﺟم )اﻟﻛوﻣﺑﯾﻠر( ﺑﺎﻟﻧظر إﻟﻰ اﻟﻣدﺧل اﻷول ﻓﺈذا ﻛﺎن ﺧﺎطﺋﺎ ﻓﺈﻧﮫ‬
‫ﻻ ﯾﻔﺣص اﻟﻣدﺧل اﻟﺛﺎﻧﻲ ‪.‬‬

‫ﻣﺛﺎﻟﮫ‪:‬‬
‫)(‪public void and‬‬

‫{‬
‫; ‪int a = 10‬‬
‫; ‪int b = 5‬‬
‫))‪if ((a == 22) & (++b == 5‬‬
‫;)"‪System.out.println("case one‬‬

‫;)‪System.out.println (b‬‬
‫}‬

‫‪٢٣‬‬
 ‫ﺑﺎﻟطﺑﻊ ﻟن ﯾﻘوم اﻟﻣﺗرﺟم ﺑطﺑﺎﻋﺔ )"‪ ("case one‬ﻷن أﺣد اﻟﺷرطﯾن ﻟم ﯾﺗﺣﻘﻖ وﻟﻛن‬
‫ﻋﻧدﻣﺎ ﯾطﺑﻊ ‪ b‬ﻓﺈﻧﮫ ﺳﯾطﺑﻌﮭﺎ ﻛﻣﺎ ھﻲ دون أن ﯾزﯾد ﻋﻠﯾﮭﺎ ﻷﻧﮫ ﻟم ﯾﻔﺣص اﻟﻣدﺧل اﻟﺛﺎﻧﻲ‬
‫‪..‬‬
‫ﻟذا ﺳﯾطﺑﻊ ﻟﻧﺎ ‪.. ٥‬‬

‫اﻟﺣﺎﻟﺔ اﻟﺛﺎﻧﯾﺔ )&&( ‪:‬‬

‫أﻣﺎ ﻓﻲ ھذه اﻟﺣﺎﻟﺔ ﻓﺈن اﻟﻣﺗرﺟم ﯾﻧظر إﻟﻰ اﻟﻣدﺧل اﻷول واﻟﺛﺎﻧﻲ ﻣﻌﺎ ﺣﺗﻰ ﻟو ﻛﺎن‬
‫اﻟﻣدﺧل اﻷول ﺧﺎطﺋﺎ ً ‪..‬‬
‫)( ‪public void and_and‬‬

‫{‬
‫; ‪int a = 10‬‬
‫; ‪int b = 5‬‬
‫))‪if ((a == 22) && (++b == 5‬‬
‫;)"‪System.out.println("case two‬‬

‫;)‪System.out.println (b‬‬
‫}‬

‫أﯾﺿﺎ ھﻧﺎ ﻟن ﯾﻘوم اﻟﻣﺗرﺟم ﺑطﺑﺎﻋﺔ )"‪ ("case two‬ﻷن أﺣد اﻟﺷرطﯾن ﻟم ﯾﺗﺣﻘﻖ وﻟﻛن‬
‫ﻋﻧدﻣﺎ ﯾطﺑﻊ ‪ b‬ﻓﺈﻧﮫ ﺳﯾزﯾد ﻋﻠﯾﮭﺎ ﻷﻧﮫ ﻗﺎم ﺑﻔﺣص اﻟﻣدﺧل اﻟﺛﺎﻧﻲ‪..‬‬
‫ﻟذا ﺳﯾطﺑﻊ ﻟﻧﺎ ‪.. ٦‬‬

‫س ‪ :٢٩‬ﻣﺎ ﻓﺎﺋدة اﻟطرﯾﻘﺔ ‪()toString‬؟‬

‫ھذه اﻟطرﯾﻘﺔ ﻣوﺟودة ﻓﻲ اﻟﻔﺋﺔ ‪ Object‬وﺑﺎﻟﺗﺎﻟﻲ ﻓﮭﻲ ﻣوﺟودة ﻓﻲ ﺟﻣﯾﻊ اﻟﻔﺋﺎت‪ ،‬ﻷن ﻛل اﻟﻔﺋﺎت‬
‫ﺗرث ﻣن اﻟﻔﺋﺔ ‪.Object‬‬

‫‪٢٤‬‬
 String ‫ھذه اﻟطرﯾﻘﺔ ﺗﻧﺗﺞ ﺻورة ﻧﺻﯾﺔ ﻟﻠﻛﺎﺋن ﻋﻠﻰ ﺷﻛل ﻛﺎﺋن‬

toString ‫ ﻟطرﯾﻘﺔ‬Sun ‫ھذا ﺗﻌرﯾف‬

public String toString()

Returns a string representation of the object. In general, the toString method returns a string that "textually
represents" this object. The result should be a concise but informative representation that is easy for a person
to read. It is recommended that all subclasses override this method.

‫ﻟﻧﻔﺗرض ﻟدﯾﻧﺎ اﻟﻔﺋﺔ)اﻟﻛﻼس( اﻟﺗﺎﻟﯾﺔ‬

public class Person {

String firstName, lastName;

int age;

public Person(String firstName, String lastName, int age) {

this.firstName = firstName;

this.lastName = lastName;

this.age = age;

‫إذا ﻧﻔذﻧﺎ اﻟﻛود اﻟﺗﺎﻟﻲ‬

Person p = new Person("Ahmed", "Ali", 40);

System.out.println(p);

‫ﺳﻧﺣﺻل ﻋﻠﻰ اﻟﻧﺗﯾﺟﺔ اﻟﺗﺎﻟﯾﺔ‬

Person@3e25a5

٢٥
 .Object ‫ اﻟﻣوروﺛﺔ ﻣن‬toString‫ ل‬override ‫ﺣﺻﻠﻧﺎ ﻋﻠﻰ ھذه اﻟﻧﺗﯾﺟﺔ ﻹﻧﻧﺎ ﻟم ﻧﻌﻣل‬

‫ﻟﻛن إذا ﻏﯾرﻧﺎ اﻟﻛود اﻟﺳﺎﺑﻖ إﻟﻰ اﻟﺗﺎﻟﻲ‬

public class Person {

String firstName, lastName;

int age;

public Person(String firstName, String lastName, int age) {

this.firstName = firstName;

this.lastName = lastName;

this.age = age;

@Override

public String toString() {

return firstName + " " + lastName + " is " + age + " years
old.";

‫ﺳﻧﺣﺻل ﻋﻠﻰ اﻟﻧﺗﯾﺟﺔ اﻟﺗﺎﻟﯾﺔ‬

.Ahmed Ali is 40 years old

٢٦
 ‫س ‪ :٣٠‬ﻛﯾف أﻋﻣل ‪ Compile‬ﻟﻣﻠف ‪ java‬ﺑﺎﺳﺗﻌﻣﺎل ﺳطر اﻷواﻣر؟‬
‫ﻧﻛﺗب اﻷﻣر ‪ javac‬ﻣﺗﺑوﻋﺎ ﺑﺎﺳم اﻟﻣﻠف‬

‫ﻣﺛﻼ‬
‫‪javac arabteam.java‬‬

‫س ‪ :٣١‬ﻛﯾف أﺷﻐل ﺑرﻧﺎﻣﺞ ﺟﺎﻓﺎ ﺑﻌد ﻋﻣﻠﯾﺔ ‪ compile‬ﺑﺎﺳﺗﻌﻣﺎل ﺳطر اﻷواﻣر؟‬

‫ﺑﻌد ﻋﻣﻠﯾﺔ اﻟـ ‪ compile‬ﯾﻧﺗﺞ ﻣﻠف ﯾﺣﻣل ﻧﻔس اﺳم ﻣﻠف ‪ java.‬و ﻟﻛن ذو اﻣﺗداد ‪class.‬‬
‫ﻟﺗﺷﻐﯾل ھذا اﻟﻣﻠف ﻧﻛﺗب اﻷﻣر ‪ java‬ﻣﺗﺑوﻋﺎ ﺑﺎﺳم اﻟﻣﻠف )ﻣن دون اﻟﻧﻘطﺔ و اﻻﻣﺗداد(‬
‫ﻣﺛﺎل‪:‬‬
‫ﻟدﯾﻧﺎ ﻣﻠف ‪arabteam.class‬‬
‫ﻧﻛﺗب‬
‫‪java arabteam‬‬

‫س ‪ :٣٢‬ﻣﺎ ھو ﻣﺻطﻠﺢ اﻟـ ‪ Casting‬؟‬

‫ھو ﯾﻌﻧﻲ اﻟﺗﺣوﯾل ﻣن ﻧوع ﻟﻧوع آﺧر وذﻟك ﺑﻛﺗﺎﺑﺔ اﻟﻧوع اﻟﻣطﻠوب اﻟﺗﺣوﯾل اﻟﯾﮫ ﺑﯾن‬
‫ﻗوﺳﯾن )( اﻣﺎم اﻻﻛﺳﺑرﯾﺷﯾن اﻟﻣراد ﺗﺣوﯾﻠﮫ ‪ ،‬ﻣﺛل ‪:‬‬
‫;‪int a= 35 , b =24 , c =12‬‬
‫;‪char c‬‬
‫;)‪c = (char) (a+ b+c‬‬

‫‪٢٧‬‬
 ‫س ‪ :٣٣‬ﻣﺎ ھﻲ اﻟطرﯾﻘﺔ ﻟﺗﻌرﯾف اﻟﺛواﺑت )‪ (Constants‬؟‬
‫ﯾﺳﺗﺧدم ﻣﻊ اﻟﺛواﺑت ﻛﻠﻣﺔ ‪ final‬ﻟﻠدﻻﻟﺔ ﻋﻠﻰ اﻧﮭﺎ ﻗﯾﻣﺔ ﻧﮭﺎﺋﯾﺔ ﻏﯾر ﻗﺎﺑﻠﺔ ﻟﻠﺗﻐﯾﯾر ‪.‬‬
‫ﻣﺛل ‪final int s = 2 ; :‬‬

‫س ‪ : ٣٤‬ﻣﺎ ھو اﻟﻔرق ﺑﯾن ھذه اﻟﻣﺗﻐﯾرات ﻓﻲ اﻟﺟﺎﻓﺎ ؟‬

‫‪global‬‬
‫‪local‬‬
‫‪static‬‬
‫‪dynamic‬‬

‫‪ global‬ﻣﻌﻧﺎھﺎ اﻧﮫ أي أﺣد ﯾﻘدر ﯾﺷوف ھذا اﻟﻣﺗﻐﯾر ‪..‬‬

‫أﻣﺎ ‪] local‬ﯾﺻﺑﺢ ﻋﻠﻰ ﻣﺳﺗوى اﻟﺑﻠوك او اﻟﻔﺎﻧﻛﺷن اﻟﻠﻲ ﻣﺗﻌرف ﻓﻲ داﺧﻠﮭﺎ اﻟﻔﺎرﯾﺑل او‬
‫ﻋﻠﻰ ﻣﺳﺗوى اﻟﻛﻼس اﻟذي ﻓﻲ داﺧﻠﮫ اﻟﻔراﯾﺑل ‪..‬‬
‫اﻣﺎ ال ‪ Static‬ﻓﮭذا ﻣﺗﻐﯾر ﯾﺑﻘﻰ ﺛﺎﺑت ﻣﻌﺎك ﻋﻠﻰ طول ﺑﻧﻔس اﻟﻘﯾﻣﺔ ﺣﺗﻰ اﻻﻧﺗﮭﺎء ﻣن‬
‫اﻟﺑرﻧﺎﻣﺞ‬
‫‪ dynamic‬ھذا ﻣﺗﻐﯾر ﺗﺗﻐﯾر ﻗﯾﻣﺗﮫ اﺛﻧﺎء ال ‪ run -time‬ﻟﻠﺑرﻧﺎﻣﺞ ‪..‬‬

‫‪٢٨‬‬
 ‫س‪ : ٣٥‬ﻣﺎ ھو اﻟﻔرق ﺑﯾن ‪ String and Stringbuffer‬؟‬

‫‪:String‬ﯾﻌﺗﺑر ﻛﻧوع ﻟﺗﻌرﯾف ﻣﺗﻐﯾر ﻧﺻﻲ وﻻ ﯾﺣﺗﺎج إﻟﻰ ‪ new‬وﻻ ﯾﻣﻛن اﻟﺗﻌدﯾل ﻋﻠﯾﮫ‬
‫اﺛﻧﺎء ﺗﺷﻐﯾل اﻟﺑرﻧﺎﻣﺞ ‪. RunTime‬‬
‫‪ : Stringbuffer‬ﻟﺗﻌرﯾف ﻣﺗﻐﯾر ﻧﺻﻲ اﯾﺿﺎ وﻟﻛﻧﮫ ﯾﺣﺗﺎج إﻟﻰ ‪ new‬وﯾﻣﻛن اﻟﺗﻌدﯾل‬
‫ﻋﻠﯾﮫ ﻓﻲ أﺛﻧﺎء ‪. RunTime‬‬

‫س‪ : ٣٦‬ﻣﺎ ﻣﻌﻧﻰ ھذا اﻟﻛﻼس ﻓﻲ اﻟﺧط اﻻﺣﻣر ؟‬

‫‪import java.util.GregorianCalendar‬‬

‫ھو ﻛﻼس ﻣﺣﺟوز ﻓﻲ ﻟﻐﺔ ﺟﺎﻓﺎ وﯾوﺟد ﻓﻲ داﺧﻠﮭﺎ ﻋده دوال ﻟﻠوﻗت واﻟﺗﺎرﯾﺦ وﺗﻐﯾر‬
‫اﻟوﻗت ﺣﺳب اﻟﻣوﻗﻊ ‪.‬‬

‫اﻟوراﺛﺔ )‪(Inheritance‬‬

‫س‪ : ٣٧‬ﻣﺎ ﻣﻌﻧﻰ اﻟوراﺛﺔ )‪ (inheritance‬؟؟‬

‫ھﻲ ﺑﻣﻔﮭوﻣﮭﺎ اﻟﺷﺎﺋﻊ ان ﯾرث اﻻﺑن ﻣن اﺑﯾﮫ ﺑﻌض او ﻛل ﺻﻔﺎﺗﮫ و ﺧﺎﺻﯾﺎﺗﮫ ‪ ،‬ﻓﻠﻐﺔ‬
‫ﺟﺎﻓﺎ ﺗوﻓر ﻟك ھذه اﻟﺧﺎﺻﯾﺔ ﻣن ﺧﻼل اﻣﻛﺎﻧﯾﺔ وراﺛﺔ ﻛﻼس ﻣن ﻛﻼس اﺧر ﺣﯾث ﯾﺻﺑﺢ‬

‫‪٢٩‬‬
 ‫اﻟﻛﻼس اﻟﺟدﯾد ﯾﻣﺗﻠك ﻛل ﺧواص اﻟﻛﻼس اﻻول )ﻣﺗﻐﯾرات ‪ ،‬دوال ‪...‬اﻟﺦ ( وﯾﺳﻣﻰ‬
‫اﻟﻛﻼس اﻟﺟدﯾد ﺑـ ﺳﺎب ﻛﻼس )‪.(SubClass‬‬

‫س‪ : ٣٨‬ھل ﻧﺳﺗطﯾﻊ اﻟوﺻول اﻟﻰ ﻛل ﻣﺗﻐﯾرات اﻟﻛﻼس اﻻﺻﻠﻲ ﻣن اﻟﻛﻼس اﻟﺳﺎب‬
‫ﻛﻼس )‪ (SubClass‬ﻋن طرﯾﻖ اﺳم اﻟﻣﺗﻐﯾر ﻣﺑﺎﺷرة‬
‫اذا ﻛﺎﻧت ﺑراﯾﻔت ؟؟‬

‫اﻟﺟواب ‪ :‬ﻻ‪ ،‬ﻻ ﯾﻣﻛﻧك اﻟوﺻول اﻟﻰ اﻟﻣﺗﻐﯾرات ﺑﺻﯾﻐﺔ ﺑراﯾﻔت ﻋن طرﯾﻖ اﺳم‬
‫اﻟﻣﺗﻐﯾر ﻣﺑﺎﺷرة ﺑل ﻋن طرﯾﻖ اﻟﺳﯾت )‪ (set‬و اﻟﺟﯾت )‪ (get‬اﻟﺧﺎﺻﺔ ﺑﺎﻟﻣﺗﻐﯾر‪.‬‬

‫ﻣﻼﺣظﺔ ‪ :‬ﻣن اﻟﻣﺳﺗﺣﺳن ﺟﻌل اﻟﻣﺗﻐﯾر ﺑﺻﯾﻐﺔ ﺑروﺗﻛﺗد ﻓﻲ اﻟﻛﻼس اﻻﺻﻠﻲ ﻟﯾﺳﮭل‬
‫ﻋﻠﯾك اﻟوﺻول اﻟﯾﮫ ﻣن ﺧﻼل اﻟﻛﻼﺳﺎت اﻟوارﺛﺔ ﻣن ھذا اﻟﻛﻼس ‪.‬‬

‫اﻹﺳﺗﺛﻧﺎءات )‪(Exceptions‬‬
‫س ‪ :٣٩‬ﻣﺎ ھﻲ اﻹﺳﺗﺛﻧﺎءات ؟‬
‫ھو ﺣدث ﯾظﮭر اﺛﻧﺎء ﺗﻧﻔﯾذ اﻟﺑرﻧﺎﻣﺞ وﯾﻌرﻗل ﺧط ﺳﯾر اﻟﺑرﻧﺎﻣﺞ اﻟطﺑﯾﻌﻲ وﯾﺗم ﺣﻣل ھذه‬
‫اﻻﺳﺗﺛﻧﺎءات ﻟﻠﺗﻌﺎﻣل ﻣﻊ اﻻﺧطﺎء اﻟﻣﺗوﻗﻌﺔ واﻟﻐﯾر ﻣﺗوﻗﻌﺔ ‪.‬‬
‫اﻣﺛﻠﺔ ﻋﻠﻰ ﺑﻌض اﻻﺧطﺎء اﻟﻣﺗوﻗﻌﺔ ‪:‬‬
‫ﺑرﻧﺎﻣﺞ ﯾﺣﺎول ﻗراءة ﻟﯾﻧك ﻏﯾر ﻣوﺟود‬
‫ﺑرﻧﺎﻣﺞ ﻣﺻﻣم ﻟﻘراءة ارﻗﺎم اﻧﺗﺟر ﻣن ﻣﻠف ﻓﯾﺟدھﺎ ﻣن ﻧوع ﺳﺗرﯾﻧﺞ ‪.‬‬

‫‪٣٠‬‬
 ‫س ‪ :٤٠‬ﻣﺎ ھﻲ ﻋﻣﻠﯾﺔ ﺣﻣل اﻻﺳﺗﺛﻧﺎءات )‪ (Exception handle‬؟‬
‫‪ -١‬ﻋﻧدﻣﺎ ﯾﺟد اﻟﺳﺳﺗم ﺧطﺄ ﯾﺗم إﯾﻘﺎف ﺗدﻓﻖ ﺗﻧﻔﯾذ اﻟﺑﯾﺎﻧﺎت ﻓﻲ اﻟﺑرﻧﺎﻣﺞ وﺗﺳﻣﻰ ﺑﻌﻣﻠﯾﺔ‬
‫ﻗذف اﻻﺳﺗﺛﻧﺎء ‪. throw the exception‬‬
‫‪ -٢‬ﯾﺗم ﺧﻠﻖ اوﺑﺟﻛت ﻣن ﻧوع ﺧﺎص ﯾﺳﻣﻲ ‪ exception‬وﯾﺣﻣل ﻣﻌﻠوﻣﺎت ﻋن اﻟﺧطﺄ‬
‫اﻟذي ﺣدث ‪.‬‬
‫‪ -٣‬ﺑﻌد ذﻟك ﯾﺗم اﻟﺗﻌﺎﻣل ﻣﻊ اﻟﺧطﺄ واﻟﺗﻘﺎطﮫ واﯾﺟﺎد ﺣل ﻣﻧﺎﺳب وﺗﺳﻣﻰ ﺑﻌﻣﻠﯾﺔ‬
‫‪. catch the exception‬‬

‫س ‪ :٤١‬ﻣﺎ ھﻲ أﻧواع اﻹﺳﺗﺛﻧﺎءات ؟‬

‫‪Errors class and its subclasses -١‬‬
‫ﻟﻼﺧطﺎء اﻟداﺧﻠﯾﺔ ﻓﻲ اﻟﺑرﻧﺎﻣﺞ ‪ :‬ﻣﺛل اﻧﺗﮭﺎء اﻟذاﻛرة‬
‫‪Exception class and its subclasses -٢‬‬
‫اﺧطﺎء ﻣﺣﺗﻣﻠﺔ وﻣﺗوﻗﻊ ﺣدوﺛﮭﺎ وﺗﺳﻣﻰ ‪ Checked exceptions‬وﻻﺑد ﻣن اﻟﺗﻘﺎطﮭﺎ‬
‫واﻻ ﺗﺳﺑب ﺧطﺄ ﻓﻲ اﻟﺑرﻧﺎﻣﺞ‬
‫‪Runtime exceptions and its subclasses-٣‬‬
‫أﺧطﺎء ﯾﺳﻣﺢ اﻟﻣﺗرﺟم ‪ compiler‬ﺑﺗﺟﺎھﻠﮭﺎ وﺗﺳﻣﻰ ‪Uncheck Exception‬‬

‫*‪ -‬ﺑﺎﻟﻧﺳﺑﺔ ﻟﻠـ ‪ Checked exceptions‬ﯾﺗم اﻟﺗﻘﺎط اﻟﺧطﺄ ﺑطرﯾﻘﺗﯾن ‪:‬‬

‫‪Try.. catch blocks -١‬‬
‫وطرﯾﻘﺗﮫ ‪:‬‬
‫‪ try‬اﻟﻛود اﻟﻣﺷﻛوك ﺑﺣدوث ﺧطﺄ ﻓﯾﮫ‬
‫‪ catch‬اﻟﻛود اﻟذي ﯾﺟب ان ﯾﻧﻔذ إذا ﺣﺻل وﺣدث اﻻﺳﺗﺛﻧﺎء‬

‫‪٣١‬‬
 ‫ﯾﺗم اﺳﺗﺧدام ‪ finally block‬داﺋﻣﺎ ﯾﺗم ﺗﻧﻔﯾذه ﺑﻌد ال‪ try‬ﺑﻠوك وﯾﺳﺗﺧدم ﻟوﺿﻊ ﻛود‬
‫ﻧظﯾف ﺧﺎﻟﻲ ﻣن اﻻﺳﺗﺛﻧﺎءات‪.‬‬
‫‪ -٢‬ﺗﻌرﯾف اﻻﺳﺗﺛﻧﺎء ‪ exception‬ﻓﻲ راس اﻟﻣﯾﺛود ‪: in the method header‬‬
‫ﯾﺗم ﺗﻌرﯾف اﻻﺳﺗﺛﻧﺎء ﻓﻲ راس اﻟﻣﯾﺛود ﺑﺎﺳﺗﺧدام ﻛﻠﻣﺔ ‪ Throws‬ﯾﻠﯾﮭﺎ ﻧوع اﻻﺳﺗﺛﻧﺎء ‪..‬‬
‫‪public Boolean check format (String fileName) throws EO‬‬
‫‪Exception‬‬

‫ﻋﺎم‬
‫س ‪System.out.print ('1'+1); : ٤٢‬‬
‫ﻟﻣﺎذا اﻵوت ﺑوت طﺑﻊ ‪ ٥٠‬؟!‬
‫ﻻن ‪character 1‬‬
‫ﻗﯾﻣﺗﮫ ب اﻻﺳﻛﻲ ﻛود ‪٤٩‬‬

‫زي ﻣﺛﻼ ﺣرف '‪'a‬‬

‫ﻗﯾﻣﺗﮫ ‪٩٧‬‬
‫ﻓﻠﻣﺎ ﺗﺳوي‬
‫'‪a' +1‬‬
‫ﯾطﺑﻊ ﻟك ‪٩٨‬‬

‫‪٣٢‬‬
 ‫وھذا ﺟدول آﺳﻛﻲ ﯾوﺟد ﻓﯾﮫ ﻛل ‪ char‬وﻗﯾﻣﺗﮫ ب اﻟـ ‪Decemal‬‬
‫‪http://www.unfiction.com/dev/tutorial/ascii.html‬‬

‫س ‪ :٤٣‬ﻣﺎ ھو ﻣﻌﻧﻰ ﻣﺻطﻠﺢ اﻟـ ‪ Deprecated‬؟‬

‫ﻟﻧﻔﺗرض أﻧك ﻛﺗﺑت ﻣﻛﺗﺑﺔ‪ ،‬واﻟﻧﺳﺧﺔ اﻷوﻟﻰ اﻟﻣﻛﺗﺑﺔ ﺗﺣﺗوي ﻋﻠﻰ اﻟﻔﺋﺔ ‪.Class1‬‬
‫ﻓﻲ اﻟﻧﺳﺧﺔ اﻟﺛﺎﻧﯾﺔ ﻣن اﻟﻣﻛﺗﺑﺔ‪ ،‬وﺟدت أن اﻟﻔﺋﺔ ‪ Class1‬ﯾﻧﻘﺻﮭﺎ اﻟﻛﺛﯾر ﻣن اﻟﻣﯾزات‪،‬‬
‫ﻓﻘررت أن ﺗﻛﺗب ﻓﺋﺔ ﺟدﯾدة ‪ Class2‬اﻟﺗﻲ ﺗﻘوم ﺑﻧﻔس ﻋﻣل ‪ Class1‬ﺑﺎﻹﺿﺎﻓﺔ ﻷﺷﯾﺎء‬
‫أﺧرى‪.‬‬

‫طﺑﻌﺎ ﻟن ﺗﻘوم ﺑﻣﺳﺢ ‪ Class1‬ﻣﺑﺎﺷرة‪ ،‬ﺑل أوﻻ ﺳﺗﻘوم ﺑوﺻﻔﮭﺎ ﺑﺄﻧﮭﺎ ‪،deprecated‬‬
‫أي أﻧﮭﺎ ﻣﺗﻘﺎدﻣﺔ)ﻗدﯾﻣﺔ أو ﻣﮭﻣﻠﮫ(‪ ،‬ﺣﺗﻰ ﯾﻌرف اﻟﻣﺳﺗﻌﻣﻠون أن ھذه اﻟﻔﺋﺔ ﻣﺗﻘﺎدﻣﺔ وﯾﺟب‬
‫اﺳﺗﻌﻣﺎل ‪ .Class2‬ﺑﻌد ذﻟك‪ ،‬ﻓﻲ اﻟﻧﺳﺦ اﻟﻘﺎدﻣﺔ‪ ،‬ﯾﻣﻛﻧك ﺣذﻓﮭﺎ‪.‬‬
‫ﻓﻲ أﻛﺛر اﻷﺣﯾﺎن ﺗﺳﺗﺧدم اﻟـ ‪ Deprecated‬ﻟوﺻف اﻟطراﺋﻖ ‪ Methods‬اﻟﻣﺗﻘﺎدﻣﺔ‬
‫واﻟﺗﻲ ﯾﻧﺻﺢ ﺑﻌدم اﺳﺗﺧداﻣﮭﺎ‬
‫ﻣﺛﺎل‪ :‬ﻓﻲ ‪ JFrame‬اﻟطرﯾﻘﺔ ‪ Show‬ھﻲ ‪ Deprecated‬ﺣﯾث ﺗم اﺳﺗﺑداﻟﮭﺎ ﺑﺎﻟطرﯾﻘﺔ‬
‫‪setVisible‬‬

‫س ‪ :٤٤‬ﻣﺎ ھو اﻟـ ‪ Generic class‬؟‬

‫ھو ﻛﻼس ﯾﺗﻌﺎﻣل ﺑﺷﻛل ﻋﺎم وﯾﺣﺗوي ﻋﻠﻰ اﻷﻗل ﻋﻠﻰ ﻋﻧﺻر واﺣد ﻏﯾر ﻣﺣدد اﻟﻧوع ‪،‬‬
‫ﯾﺗم ﺗﺣدﯾده ﻓﻲ أﺛﻧﺎء إﻧﺷﺎء اﻷوﺑﺟﻛت ‪.‬‬

‫‪٣٣‬‬
‫وھو ﺑﺎﺧﺗﺻﺎر اﻟﻘدرة ﻋﻠﻰ أﻧﻲ ارﺳل أو أﺑﻌث ‪ Type‬ﻛﺑراﻣﯾﺗر ‪ ،‬وال ‪ Generic‬اﻗدر‬
‫اﺳﺗﺧدﻣﮫ ﻣﻊ اﻟﻛﻼس أو اﻟﻣﯾﺛود ‪ ،‬ﯾﻌﻧﻲ ﻛﺄﻧﻲ اﻗوﻟﮫ أن اﻟﻣﯾﺛود اﻟﻠﻲ اﺳﺗﺧدﻣت ﻣﻌﮭﺎ ال‬
‫‪ Generic‬أﻧﮭﺎ راح ﺗﺎﺧذ ‪ Type‬ﻏﯾر ﻣﺣدده ﻓﻲ وﻗت إﻧﺷﺎﺋﻲ ﻟﻠﻛﻼس أو اﻟﻣﯾﺛود ‪،‬‬
‫طﯾب ﯾﻌﻧﻲ ﻣﺗﻰ ﺗﺣدد ﻟﮫ اﻟﻘﯾﻣﺔ ؟ راح ﺗﺣدده ﻟﮫ أﻧت أو اﻟﻣﺳﺗﺧدم وھو ﯾﺳﺗﺧدم اﻟﻛﻼس‬
‫أو اﻟﻣﯾﺛود ‪ ،‬ﻓﻌﺷﺎن ﻛذا ھذا ﯾﻌﺗﺑر أﻣر ﻟل ‪ Compiler‬أﻧﮫ ﯾﺷﯾّك ﻋﻠﻰ ‪Compiler‬‬
‫‪ Time‬ﻋﻠﻰ اﻟﻘﯾﻣﺔ أو ال ‪ Type‬اﻟﻠﻲ ﻣرﺳﻠﮫ ﻟﮫ ‪،‬وطﺑﻌﺎ ھو ﻗﺳم ﻛﺑﯾر ﺟدا ﺑس ھذا‬
‫ﺷرح ﺑﺳﯾط ﻟﮫ ‪.‬‬

‫س ‪ :٤٥‬ﻣﺎ ھو اﻟـ ‪ Interface‬؟‬

‫ھو ﻋﺑﺎرة ﻋن ﺷﻲء ﺷﺑﯾﮫ ﺑﺎﻟﻛﻼس اﻟﻌﺎدي إﻻ اﻧﮫ ﻻﯾﺣﺗوي ﺳوى ﻋﻠﻰ ﻣﺗﻐﯾرات ﺛﺎﺑﺗﺔ و‬
‫ﻣﯾﺛودات ﻣن ﻧوع ‪ Abstract‬أي ﻣﯾﺛود ھﯾدر ﻓﻘط ‪.‬‬
‫* اﻻﻧﺗرﻓﯾس ‪ :‬ﻛﻲ ﯾﺗم اﺳﺗﺧداﻣﮫ ﻻﺑد ان ﻧﻌﻣل ‪ implements‬ﻟﻛﻼس آﺧر ‪.‬‬
‫* ﻻﯾﻣﻛن ﺧﻠﻖ اوﺑﺟﻛت ﻣن اﻻﻧﺗرﻓﯾس ﺑﺎﺳﺗﺧدام ﻛﻠﻣﺔ ‪. new‬‬
‫* ﯾﺳﺗطﯾﻊ اﻻﻧﺗرﻓﯾس ان ﯾرث ﻣن اﻛﺛر ﻣن اﻧﺗرﻓﯾس ﺑﺎﺳﺗﺧدام ﻛﻠﻣﺔ ‪. extends‬‬
‫* اﻟﻛﻼس اﻟﻌﺎدي ﻏﯾر ﻣﺳﻣوح ﻟﮫ ﺑﺎﻟوراﺛﺔ ﻣن اﻛﺗر ﻣن ﺳوﺑر ﻛﻼس ‪ ،‬ﻟﻛﻧﮫ ﯾﻣﻛن ﻟﮫ‬
‫‪ implements‬اﻛﺗر ﻣن اﻧﺗرﻓﯾس ‪.‬‬

‫‪GUI‬‬
‫س ‪ : ٤٦‬ﻣﺎ ھﻲ ‪) GUI‬واﺟﮭﺔ اﻟﻣﺳﺗﺧدم اﻟرﺳوﻣﯾﺔ( ﻓﻲ اﻟﺟﺎﻓﺎ؟‬
‫• ﻋﻧﺻر اﻟـ ‪ GUI‬ھو ﻛﺎﺋن ﯾﺗﻔﺎﻋل ﻣﻌﮭﺎ اﻟﻣﺳﺗﺧدم ﻋن طرﯾﻖ ﻣﺎوس أو ﻟوﺣﺔ اﻟﻣﻔﺎﺗﯾﺢ‪،‬‬
‫أو أي ﻧوع آﺧر ﻣن اﻟﻣدﺧﻼت‪.‬‬

‫‪٣٤‬‬
‫• وﻣن اﻷﻣﺛﻠﺔ اﻟﻔﻌﻠﯾﺔ إذا ﺗﻌﺎﻣﻠﻧﺎ ﻣﻊ ﻛﻼس ‪ JOptionPane‬ﻣﺛﻼ ً ‪ ،‬ﻧﺳﺗﺧدم اﻟﻣﯾﺛود‬
‫)(‪ showInputDialog‬ﻟﻠﺣﺻول ﻋﻠﻰ ﻣدﺧﻼت ﻣن اﻟﻣﺳﺗﺧدم‪.‬‬

‫س ‪ : ٤٧‬ﻣﺎ ھو ﻋﻣل اﻟﻣﻛون)اﻟﻌﻧﺻر( ‪JFrame‬؟‬

‫• ‪ JFrame‬ﻣﻛون ﯾوﻓر اﻟﺑﻧﯾﺔ اﻟﺗﺣﺗﯾﺔ ﻟواﺟﮭﺔ اﻟﻣﺳﺗﺧدم اﻟرﺳوﻣﯾﺔ )‪. (GUI‬‬
‫• ﯾوﻓر ‪ JFrame‬ﺷﻛل أو ﺳﻠوك اﻟﻧﺎﻓذة‪ ،‬ﻓﮭو ﯾﺣﺗوي ﻋﻠﻰ ﺷرﯾط اﻟﻌﻧوان‪ ،‬و أزرار‬
‫ﻹﻏﻼق‪ ،‬واﻟﺗﻛﺑﯾر‪ ،‬واﻟﺗﻘﻠﯾل إﻟﻰ أدﻧﻰ ﺣد ﻣن اﻟﻧﺎﻓذة‪.‬‬

‫س ‪ : ٤٨‬ﻣﺎ ھﻲ طرق اﺳﺗﺧدام اﻟـ ‪ JFrame‬؟‬

‫• إﻧﺷﺎء ‪) object‬ﻛﺎﺋن( ﻣن ﻧوع ‪.JFrame‬‬
‫• اﻟوراﺛﺔ )‪ (extends‬ﻣن ﻛﻼس )ﻓﺋﺔ( ‪. Jframe‬‬

‫س ‪ : ٤٩‬ﻛﯾﻔﯾﺔ ﻋﻣل واﺟﮭﺎت ﻣرﺋﯾﺔ ﺑﺎﻟﺟﺎﻓﺎ ﺑﺎﺳﺗﺧدام اﻟﻛود ؟‬

‫‪ ‬ﻛﯾﻔﯾﺔ ﻋﻣل ‪ Frame‬ﻋن طرﯾﻖ اﻟﻛود ﻓﻲ اﻟداﻟﺔ اﻟرﺋﯾﺳﯾﺔ ‪:‬‬
‫‪ ‬ﻣﻼﺣظﺔ ھذه اﻟﻛﺎﺋﻧﺎت ﻣوﺟودة ﻓﻲ ﻣﻛﺗﺑﺔ ‪swing‬‬
‫;*‪import javax.swing.‬‬
‫واﻟـ * ﻹدراج ﻛل اﻟﻛﺎﺋﻧﺎت اﻟﻣوﺟودة ﻓﻲ اﻟﻣﻛﺗﺑﺔ ‪.‬‬

‫;)(‪JFrame Frame2 = new JFrame‬‬

‫;))(‪Frame2.setLayout(new FlowLayout‬‬
‫;)"ﻋﻨﻮان اﻟﻔﺮﯾﻢ"(‪Frame2.setTitle‬‬

‫;)‪Frame2.setSize(300,300‬‬ ‫‪//‬‬ ‫ﺣﺠﻢ اﻟﻔﺮﯾﻢ‬

‫‪٣٥‬‬
 Frame2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
Frame2.pack();
Frame2.setVisible(true); // ‫إﻇﮭﺎر اﻟﻔﺮﯾﻢ‬
Frame2.setLocation(200,60); // ‫ﻟﺘﺤﺪﯾﺪ ﻣﻜﺎن ﻇﮭﻮر‬
‫اﻟﻨﺎﻓﺬة‬
Frame2.setResizable(false); // ‫ﻟﻤﻨﻊ ﺗﻐﯿﯿﺮ ﺣﺠﻢ‬
‫اﻟﻨﺎﻓﺬة‬
Frame2.setBackground(Color.BLUE); vcvcvcvcvv

: ‫ أو ﻋن طرﯾﻖ اﻟوارﺛﺔ‬
public class MainClass extends JFrame {
public static void main(String[] args) {
new MainClass().setVisible(true);
}

: ‫ ﻟﻌﻣل ﺧﻠﻔﯾﺔ ﻟون ﻟﻠﻧﺎﻓذة‬

Container C = Arabic.getContentPane();
C.setBackground(Color.red);

‫ أوﻻ ﻻﺑد ﻣﻌرﻓﺔ ﺣﺟم اﻟﺷﺎﺷﺔ‬: ‫ ﻛﯾﻔﯾﺔ ﺟﻌل اﻟﻧﺎﻓذة ﻓﻲ ﻣﻧﺗﺻف اﻟﺷﺎﺷﺔ‬
// import the libraries
import java.awt.Dimension;
import java.awt.Toolkit;

// Get the size of the screen

Dimension dim =
Toolkit.getDefaultToolkit().getScreenSize();

// Determine the new location of the window

int w = Frame2.getSize().width;
int h = Frame2.getSize().height;
int x = (dim.width-w)/2;
int y = (dim.height-h)/2;

// Move the window

٣٦
 Frame2.setLocation(x, y);

‫ ﺗﻘوم ﺑـ ﺗﺣﺟﯾم اﻟﻔرﯾم ﺗﻠﻘﺎﺋﯾﺎ ﺑﻧﺎء ﻋﻠﻰ ﺣﺟم اﻟﻣﻛوﻧﺎت اﻟﻣوﺟودة ﻋﻠﻰ اﻟﻔرﯾم ﺑدﻻ‬Pack () ‫ ﻋﻣل اﻟداﻟﺔ‬
: ‫ﻣن اﺳﺗﺧدام اﻟداﻟﺔ‬
Frame2.setSize(width, height);

: ‫ ﻓﻘط ﺳوف ﯾظﮭر ﻋﻧوان اﻟﻔرﯾم ﻛﻣﺎ ﻓﻲ اﻟﺻورة‬setSize ‫ﻷﻧﮫ إذا ﻟم ﻧﺳﺗﺧدم ھذه اﻟداﻟﺔ أو داﻟﺔ‬

Example :

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Pack extends JFrame {

private Button button1 = new Button("Button 1");
private Button button2 = new Button("Button 2");
private Button button3 = new Button("Button 3");
private Button button4 = new Button("Button 4");
private Button button5 = new Button("Button 5");

public Pack() {
super("pack() vs. setSize() method Example");
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});

Container contentPane = this.getContentPane();

contentPane.setLayout(new FlowLayout());
contentPane.add(button1);
contentPane.add(button2);

٣٧
 contentPane.add(button3);
contentPane.add(button4);
contentPane.add(button5);

//this.setSize(450, 90);
this.pack();
}

public static void main(String[] args) {

Pack mainFrame = new Pack();
mainFrame.setVisible(true);
}
}

‫ ﻟﻠﻔرﯾم‬JLabel ‫إﺿﺎﻓﺔ ﻋﻧوان‬ 

JLabel t1 = new JLabel("Any text here");

JLabel t2 = new JLabel(message);// message is a String variable

setText() method ‫ ﺑﺎﺳﺗﺧدام اﻟداﻟﺔ‬Label ‫ ﯾﻣﻛن ﺗﻐﯾﯾر اﻟﻌﻧوان اﻟظﺎھر ﻋﻠﻰ اﻟـ‬o
t1.setText("New Text"); // You can also use variables here

: ‫ ﺑﺎﺳﺗﺧدام اﻟداﻟﺔ‬Label ‫ اﻟﺣﺻول ﻋﻠﻰ اﻟﻧص اﻟﻣوﺟود ﻓﻲ اﻟﻌﻧوان‬o

String str = t1.getText();

‫ واﺳﺗدﻋﺎء داﻟﺔ اﻟﺑﻧﺎء ﻣﻊ إرﺳﺎل ﻟﮭﺎ‬Object ‫ ﻛـ‬Button ‫ ﻧﺗﻌﺎﻣل ﻣﻊ اﻟـ‬Frame ‫ إﺿﺎﻓﺔ زر إﻟﻰ اﻟـ‬
‫اﻟﻌﻧوان اﻟذي ﺳوف ﯾظﮭر ﻋﻠﻰ اﻟزر‬
JButton button = new JButton("Title of Button");

٣٨
 setText(String) ‫ أو إرﺳﺎل اﻟﻌﻧوان ﻓﻲ اﻟداﻟﺔ‬o
button.setText("Title of Button ");

: ‫ ﺑﺎﺳﺗﺧدام اﻟداﻟﺔ‬JButton ‫ اﻟﺣﺻول ﻋﻠﻰ اﻟﻧص اﻟﻣوﺟود ﻓﻲ اﻟﻌﻧوان‬o

String txt = button.getText();

:‫ داﻟﺔ إﺿﺎﻓﺔ ﺗﻠﻣﯾﺢ ﻟﻠزر ﻣن ﺧﻼل اﻟداﻟﺔ‬o

b.setToolTipText("click me");

‫ ﺛم ﯾﺗم إﺿﺎﻓﺗﮫ ھذا اﻟﻛﺎﺋن إﻟﻰ اﻟﻔرﯾم ﻗﺑل ﻣﺎ ﯾﺗم ﻋرض اﻟﻔرﯾم ﻣن ﺧﻼل اﻟداﻟﺔ‬o
setVisible()
Frame2.add(b);

‫ ﯾﺳﻣﺢ ﻟﻠﺗﺣرﯾر ﻣن ﺳطر واﺣد ﻣن اﻟﻧص‬JTextField ‫إﺿﺎﻓﺔ ﺣﻘل ﻧﺻﻲ‬ 

JTextField tf = new JTextField(); // The default
constructor

JTextField tf2 = new JTextField(25); // Constructs the

JTextField of size

JTextField tf3 = new JTextField("Hello World", 25); // With size

and default text

setText () ‫ ﯾﻣﻛﻧك ﺗﻌﯾﯾن ﻧص أو اﺳﺗرﺟﺎﻋﮭﺎ ﻣن ﺧﻼل اﻟداﻟﺔ‬o

tf.setText("New Text"); /* or */ tf.setText(txt);

JFrame ‫ وﯾﻣﻛن إﺿﺎﻓﺗﮫ إﻟﻰ‬o

frame.add(new JTextField("Hello World", 25));
// or //
frame.add(tf);
getText () ‫ ﻟﻠﺣﺻول ﻋﻠﻰ اﻟﻧص اﻟﻣوﺟود ﻓﻲ اﻟﺣﻘل اﻟﻧﺻﻲ ﻣن ﺧﻼل اﻟداﻟﺔ‬o

٣٩
String Stext = JTextField1.getText();

‫ ﻋن طرﯾﻖ ﻣﺻﻔوﻓﺔ ﻋﻧﺎﺻر‬: ‫ ﻟﻠﻔرﯾم‬combbox ‫ إﺿﺎﻓﺔ ﻗﺎﺋﻣﺔ‬

JComboBox com = new JComboBox();
s = new String []{"sasa","sasfg","dd","aa"};
com.setModel(new javax.swing.DefaultComboBoxModel(s));
Frame2.add(com);

‫ ﻣن ﺧﻼل اﻟداﻟﺔ‬JTextField ‫ إﺿﺎﻓﺔ ﻋﻧﺻر ﻟﻠﻘﺎﺋﻣﺔ ﻣن ﺣﻘل ﻧﺻﻲ‬o

:JComboBox.addItem(Object item )
tf3 = new JTextField("Hello World", 25); // With
size and default text

Frame2.add(tf3);
com = new JComboBox<Object>();
Frame2.add(com);
com.addItem(tf3.getText()); // add to CombBox from
JTextField

‫ ﻻن ﻛل ﻣﺎ‬Object ‫ ﯾﻌﺗﺑر‬String ‫ ﻻن ﻣﺗﻐﯾر ﻣن ﻧوع‬: ‫ إﺿﺎﻓﺔ ﻋﻧﺻر ﻟﻠﻘﺎﺋﻣﺔ ﻣن ﻣﺗﻐﯾر ﻧﺻﻲ‬o

Objects ‫ﻓﻲ اﻟﺟﺎﻓﺎ ھﻲ ﻋﺑﺎرة ﻋن‬

String comtxt="Add in Combobox";

com.addItem(comtxt);

setEditable ‫ ﻗﺎﺑﻠﺔ ﻟﻠﺗﻌدﯾل ﻣن ﺧﻼل اﻟداﻟﺔ‬CombBox ‫ ﻟﺟﻌل اﻟﻘﺎﺋﻣﺔ‬o

com.setEditable(true);

‫ ﻟﻠﻔرﯾم‬list ‫ إﺿﺎﻓﺔ ﻗﺎﺋﻣﺔ‬

list = new JList(data); //data has type Object[]

‫ ﻣﻊ إﺿﺎﻓﺔ ﻗﯾم ﻟﮭﺎ ﻣن ﻣﺻﻔوﻓﺔ‬

String[] ar = {"one", "two", "three"};
JList list = new JList(ar);
Frame2.add(list);

٤٠
‫ ﻻﺑد اوﻻ ﺗﻌرﯾف اﻟـ‬ListModel class ‫ ﻣن ﺧﻼل اﻟﻛﻼس‬list ‫ ﯾﻣﻛن إﺿﺎﻓﺔ ﻋﻧﺎﺻر ﻟﻠـ‬o
DefaultListModel

DefaultListModel listModel = new DefaultListModel();

listModel.addElement("item 1");
listModel.addElement("item 2");

list ‫ ﻓﻲ داﻟﺔ اﻟﺑﻧﺎء ﻟﻠـ‬DefaultListModel ‫ وﯾﻣﻛن اﺳﺗﺧدام اﻟـ‬o

JList list = new JList(listModel);

addElement() method ‫ اﻵن ﻹﺿﺎﻓﺔ ﻋﻧﺎﺻر إﺿﺎﻓﯾﺔ ﻓﻲ أي وﻗت أﺛﻧﺎء ﺗﻧﻔﯾذ ﺑﺎﺳﺗﺧدام‬o

listModel.addElement("new item");

‫ ﯾﻣﻛن إﺿﺎﻓﺔ ﻋﻧﺻر ﻓﻲ اﻟﻘﺎﺋﻣﺔ ﺑﺗﺣدﯾد ﻣوﻗﻌﮭﺎ‬o

int index=3;
listModel.add(index, object);

‫ ﺳواء ﻣﺗﻐﯾر ﻧﺻﻲ أو ﻗﯾﻣﺔ ﻣن ﺣﻘل ﻧﺻﻲ أو ﻏﯾرة‬object ‫ اﻟـ‬o

‫ ﻋﻧوان اﻟﻌﻧﺻر اﻟﻣراد ﺣذﻓﮫ‬index ‫ ﺣﯾث اﻟـ‬list ‫ ﻟﺣذف ﻋﻧﺻر ﻣﻌﯾن ﻣن اﻟـ‬o
listModel.remove(index);
:‫ ﻟﺤﺬف ﻛﻞ اﻟﻌﻨﺎﺻﺮ‬o
listModel.clear();

list ‫ اﻟﻌﻧﺻر اﻟﻣﺣدد ﻓﻲ اﻟـ‬o

list.setSelectedItem(n);

‫ اﺳﺗﺧدم‬،JList ‫ ﻹرﺟﺎع ﺳﻠﺳﻠﺔ اﻟﻣﺣدد ﺣﺎﻟﯾﺎ ﻓﻲ‬o

s = (String) list.getSelectedValue();

‫ ﻓﻲ اﻟواﻗﻊ ﯾﻣﻛن أن ﺗﺣﺗوي ﻋﻠﻰ أﻧواع‬JList ‫ ﻷن‬object ‫وﯾﻌرف ھذا اﻷﺳﻠوب ﯾﻌﯾد ﻛﺎﺋن‬
‫ اﻟﺻور اﻟﺻﻐﯾرة ﺗﻌرف ﺑﺎﺳم اﻟرﻣوز‬،‫اﻟﻛﺎﺋﻧﺎت اﻷﺧرى ﻣن ﺳﻼﺳل )ﻋﻠﻰ ﺳﺑﯾل اﻟﻣﺛﺎل‬

JList ‫ ﻟﻠﺗﺣدﯾد اﻟﻣﺗﻌدد ﻓﻲ اﻟـ‬o

JList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERV
AL_SELECTION);

٤١
 : ‫ ﻟﮭﺎ أﻛﺛر ﻣن ﻗﯾﻣﺔ‬ListSelectionModel ‫ﺣﯾث اﻟﺧﺎﺻﯾﺔ‬

- MULTIPLE_INTERVAL_SELECTION //(default select) ‫ﺗﺣدﯾد ﻣﺗﻌدد‬

‫ﻟﻠﻌﻧﺎﺻر‬
- SINGLE_INTERVAL_SELECTION // ‫ﺗﺣدﯾد واﺣد ﻓﻘط‬
- SINGLE_SELECTION

// Create a list that allows adds and removes

DefaultListModel model = new DefaultListModel();
JList list = new JList(model);

// Initialize the list with items

String[] items = {"A", "B", "C", "D"};
for (int i=0; i<items.length; i++) {
listModel.add(i, items[i]);
}

// Append an item
int pos = list.getModel().getSize();
listModel.add(pos, "E");

// Insert an item at the beginning

pos = 0;
listModel.add(pos, "a");

‫ ﻟﺗﻐﯾر ﻣﺣﺗوى اﻟﻣوﻗﻊ اﻟﻣﺣدد‬o

pos = 1; // index of item to replace it

listModel.set(pos, "b");

index ‫ ﻟﺣذف اﻟﻌﻧﺎﺻر ﻣﺣدد ﺣﺳب اﻟـ‬o

٤٢
‫‪// Remove the first item‬‬
‫;‪pos = 0‬‬ ‫‪// any index of item‬‬
‫;)‪listModel.remove(pos‬‬
‫‪ o‬ﻟﺣذف أﺧر ﻋﻧﺻر ﻓﻲ اﻟﻘﺎﺋﻣﺔ‬

‫‪// Remove the last item‬‬

‫;‪pos = listModel.getSize()-1‬‬
‫{ )‪if (pos >= 0‬‬
‫;)‪listModel.remove(pos‬‬
‫}‬

‫‪ o‬ﻟﺣذف ﻛل اﻟﻌﻧﺎﺻر ﻓﻲ اﻟـ ‪:list‬‬

‫‪// Remove all items‬‬

‫;)(‪listModel.clear‬‬

‫س ‪ : ٥٠‬ﻣﺎ ھﻲ اﻟـ ‪Swing‬؟؟‬

‫ھﻲ ﻣﻛﺗﺑﺔ ﻷدوات اﻟواﺟﮭﺔ اﻟرﺳوﻣﯾﺔ ) ﻣﺛل ‪ :‬اﻷزرار ‪ ،‬ﻣرﺑﻌﺎت اﻟﻧص … ( ﺗﺧﺗﺻر‬
‫إﻟﻰ ‪ GUI‬و ھﻲ ﻣن إﻧﺗﺎج ‪ ، Sun Microsystems‬ﺗﻛون ﻣﺿﻣﻧﮫ ﻣﻊ اﻟـ ‪ Java‬ﺑﺎﺳم‬
‫‪. Swing‬‬
‫ﺗﺗﻣﯾز ﺑﺄﻧﮭﺎ‪:‬‬
‫‪.‬ﻣﺗﻌددة اﻟﻣﻧﺻﺎت ‪ ،‬أي ﺗﻌﻣل ﻋﻠﻰ أي ﺑﯾﺋﺔ ﺗﺷﻐﯾل‬
‫ﻗﺎﺑﻠﮫ ﻟﻠﺗﻌدﯾل‬
‫ﻗﺎﺑﻠﯾﮫ ﻟﻠﺗﺟدﯾد‬
‫ﺧﻔﯾﻔﺔ‬

‫‪٤٣‬‬
 ‫س ‪: ٥١‬ﻣﺎ ھﻲ ﻣﻛﺗﺑﺔ ‪ SWT‬؟‬
‫ھﻲ ﻣﻛﺗﺑﮫ ﻟﻠـ ‪ GUI‬ﻓﻲ ﻟﻐﺔ اﻟـ ‪ ، Java‬وﺗﺳﻣﻰ ‪ . SWT‬ﺗم ﺑرﻣﺟﺗﮭﺎ ﻓﻲ ﺷرﻛﺔ ‪ IBM‬و‬
‫اﻷن ھﻲ ﻣﺷروع ﻣﻔﺗوح اﻟﻣﺻدر ‪ ،‬ﻣدﻋﻣﮫ ﻣن ‪ ، IBM‬ﺗﻌﺗﺑر اﻟـ ‪ SWT‬ﻣﺛﺎل ﻟﻸدوات‬
‫اﻟﺛﻘﯾﻠﺔ ) ‪ ، ( Heavyweight‬وﺗﺳﻣﺢ ﺑﺎﺳﺗﻐﻼل أﺳﺎس ﻧظﺎم اﻟﺗﺷﻐﯾل ﻟﻌﻣل وﺟﮭﮫ‬
‫رﺳوﻣﯾﮫ ‪ ، GUI‬وﺗﻘوم ﺑﺈﻧﺷﺎﺋﮭﺎ ﺑﺎﺳﺗﺧدام اﻟواﺟﮭﺔ اﻷﺻﻠﯾﺔ ﻟﻠـ ‪ ، Java‬ﻣن ﻣُﻣَ ﯾزاﺗﮭﺎ‬
‫اﻟﺳرﻋﺔ و اﻟﺗﺄﺛﯾرات اﻟﺟﻣﯾﻠﺔ اﻟﺗﻲ ﯾ ُطﻠﻖ ﻋﻠﯾﮭﺎ أﺳم اﻟـ ‪ ، Look and Feel‬و ﻣن‬
‫ﺳﻠﺑﯾﺎﺗﮭﺎ ﻛﺛرة اﺣﺗﻣﺎﻻت اﻷﺧطﺎء ﺑﮭﺎ و أﻗل ﻛﻔﺎءه ﻣن اﻟـ ‪ ، Swing‬و اﻟـ ‪ SWT‬ﺗﻣﺎﻣﺎ ً‬
‫ﻣﺛل ﻣﻛﺗﺑﺔ ‪. Windows Centric‬‬

‫س ‪ : ٥٢‬ﻟﻣﺎذا داﺋﻣﺎ ﯾﻔﺿل أن ﺗﻛون اﻟـ ‪ method‬داﺧل اﻟـ ‪ class‬ﺗﻛون ‪ static‬؟‬

‫ﻟﻛﻲ اﺳﺗطﯾﻊ ان اﺳﺗﺧدﻣﮭﺎ ﺧﺎرج اﻟﻛﻼس ﻣن ﻏﯾر ان اﻧﺷﺄ أوﺑﺟﻛت ﻣن اﻟﻛﻼس ﻓﻘط‬
‫ﺑواﺳطﺔ اﺳم اﻟﻛﻼس واﺳم اﻟﻔﻧﻛﺷن ﻣﺛﻼ ‪. className.method‬‬

‫س ‪ : ٥٣‬ﻛﻢ ﻣﻜﺘﺒﺔ ﻟﻠﻮاﺟﮭﺎت ﻟﺪى اﻟﺠﺎﻓﺎ ؟‬

‫‪ swing .1‬اﻟﻤﻜﺘﺒﺔ اﻟﻤﻌﺘﻤﺪ ﺣﺎﻟﯿﺎ ﻟﺪى اﻟﺠﺎﻓﺎ‬

‫‪http://docs.oracle.com/javase/tutorial/uiswing/ swing‬‬

‫‪ awt .2‬ھﻲ ﻣﻜﺘﺒﺔ ﻗﺪﯾﻤﺔ اﻧﺘﮭﻰ دﻋﻤﮭﺎ ﻣﻦ ﻗﺒﻞ اﻟﺠﺎﻓﺎ‬

‫‪http://docs.oracle.com/javase/6/docs/technotes/guides/awt/‬‬

‫‪ swt .3‬اﻟﻤﻜﺘﺒﺔ اﻟﺘﻲ اﻧﺘﺠﺘﮭﺎ ‪IBM‬‬

‫‪http://www.eclipse.org/swt/‬‬

‫‪ gwt .4‬اﻟﻤﻜﺘﺒﺔ اﻟﺨﺎ ﺻﺔ ﺑـ‪ googl‬ﻟﺒﻨﺎء ﺗﻄﺒﯿﻘﺎت اﻟﻮﯾﺐ‬

‫‪http://www.gwtproject.org/overview.html‬‬

‫‪٤٤‬‬
. RIA ‫ ﺗﻘﻨﯿﺔ أﺧﺮى أﺻﺪرﺗﮭﺎ ﺻﻦ ﻣﺎﯾﻜﺮوﺳﯿﺴﺘﻤﺰ ﻟﺘﻄﻮﯾﺮ ﺗﻄﺒﯿﻘﺎت ﻣﻦ ﻧﻮع‬javafx UI .5

http://docs.oracle.com/javafx/

qt-jambi ‫ وﺗﺴﻤﻲ‬QT .6

http://qt-jambi.org/

GTK.7

http://java-gnome.sourceforge.net/

‫ ؟‬orange 1 , orange 2 ‫ ﻣﺎ ھو اﻟﻔرق ﻣﺎ ﺑﯾن‬: ٥٤‫س‬

‫؟؟؟‬

٤٥
‫ﻟو ﺗﻼﺣظون ﻓﻲ اﻟﺻورة أن داﺧل ﻛﻼ اﻟﺛﺎﺑﺗﯾن ﻓﻲ ﻛﻼس ‪ Color‬ﻣﺎ ﻓﯾﮫ ﺑﯾﻧﮭم ﻓرق إﻻ‬
‫ﻓﻲ ﺣﺎﻟﺔ اﻷﺣرف ‪ ،‬وﻛﺎن ﻓﻲ اﻟﺳﺎﺑﻖ ﻻ ﯾوﺟد إﻻ اﻟﺛﺎﺑت ‪(lowercase)orange‬‬
‫وﻟﻛن ﺑﻌد ‪ JDK 1.4‬ﺗﻣت اﺿﺎﻓﺔ ‪ ، (uppercase)ORANGE‬ﻟﻛﻲ ﯾﻧﻔذوا ﻣﺻطﻠﺢ أن‬
‫اﻟﺛواﺑت داﺋﻣﺎ ﺗﻛون ‪) Upper_Case‬اﺗﻔﺎﻗﯾﺔ ﺗرﻣﯾز اﻟﺛواﺑت(‪.‬‬

‫س‪ : ٥٥‬ﻛﯾف ﯾﻣﻛن اﻟﻣﻧﺎداة ﻋﻠﻰ اﻟﻣﺗﺻﻔﺢ اﻹﻓﺗراﺿﻲ و ﻓﺗﺢ ﺻﻔﺣﺔ وﯾب ﻣﻌﯾﻧﺔ؟‬

‫اﻟﺟﺎﻓﺎ وﻣﻧذ ﻧﺳﺧﺗﮭﺎ اﻟﺳﺎدﺳﺔ‪ ،‬ﺗﺗﯾﺢ إﻣﻛﺎﻧﯾﺔ اﻟﻣﻧﺎداة ﻋﻠﻰ اﻟﻣﺗﺻﻔﺢ اﻹﻓﺗراﺿﻲ‪ ،‬وذﻟك‬
‫ﻋن طرﯾﻖ اﻟﻔﺋﺔ )‪ Desktop (class‬اﻟﺗﻲ ﺗوﻓر ﻟﻧﺎ اﻟـ ‪) Method‬اﻟطرﯾﻘﺔ( ‪browse‬‬

‫‪//get a Desktop object‬‬

‫;)(‪Desktop desktop = Desktop.getDesktop‬‬

‫‪٤٦‬‬
‫{ ‪try‬‬

‫‪//open the default browser using the method browse which take an URI‬‬
‫‪object representing the web page‬‬

‫;))"‪desktop.browse(new URI("http://arabteam2000-forum.com/‬‬

‫{ )‪} catch (URISyntaxException ex‬‬

‫;)(‪ex.printStackTrace‬‬

‫}‬

‫س ‪ :٥٦‬ﻛﯾف أﺟﻌل واﺟﮭﺔ ﺑرﻧﺎﻣﺟﻲ ﻣﺗﻌددة اﻟﻠﻐﺎت؟‬

‫ﻣﺎ ﻧرﯾده ھو إظﮭﺎر ﻛل رﺳﺎﺋل وﻧﺻوص اﻟواﺟﮭﺔ ﺣﺳب اﻟﻠﻐﺔ اﻟﺗﻲ ﯾﺗم اﺧﺗﯾﺎرھﺎ‪ .‬إذن ﻟو ﻛﻧﺎ‬
‫ﺳﻧﺟﻌل ﺛﻼث ﻟﻐﺎت ﻣﺗوﻓرة ﻓﻲ اﻟﺑرﻧﺎﻣﺞ‪ ،‬ﻓﺳﯾﻠزﻣﻧﺎ ﺛﻼث ﻧﺳﺦ ﻣن ﻛل ﻧص ورﺳﺎﻟﺔ‪ ،‬ﻛل ﻧﺳﺧﺔ‬
‫ﺑﻠﻐﺔ ﻣﺧﺗﻠﻔﺔ‪ .‬ﺳﻧﺿﻊ ﻛل ﻧﺳﺧﺔ ﻣن اﻟﻧﺻوص ﻓﻲ ﻣﻠف ‪ properties‬ﻣﺳﺗﻘل‪ ،‬ﻣﺎ ﯾﻌﻧﻲ أن‬
‫اﻟﺑرﻧﺎﻣﺞ ﻟن ﯾﺣﺗوي ﻋﻠﻰ أي ﻧص‪ ،‬ﺑل ﻛل ﺷﻲء ﺳﯾﻛون ﻓﻲ اﻟﻣﻠﻔﺎت ‪.properties‬‬

‫س ‪ :٥٧‬ﻣﺎ ھﻲ اﻟﻣﻠﻔﺎت ‪ properties‬؟‬

‫ﻋﻧد ﻛﺗﺎﺑﺔ ھذه اﻟﻣﻠﻔﺎت‪ ،‬ﯾﺟب اﺣﺗرام ﻧﻣوذج ﻣﺣدد‪ :‬أوﻻ إﺳم اﻟﻣﻠف‪ ،‬ﻣﺛﻼ "‪ ،"labels‬ﻣﺗﺑوﻋﺎ‬
‫ﺑﺎﻟرﻣز "_"‪ ،‬ﻣﺗﺑوﻋﺎ ﺑﺎﻟرﻣز اﻟﺧﺎص ﺑﺎﻟﻠﻐﺔ‪ ،‬ﻣﺛﻼ رﻣز اﻟﻌرﺑﯾﺔ ھو "‪ ،"ar‬رﻣز اﻟﻔرﻧﺳﯾﺔ "‪"fr‬‬
‫ورﻣز اﻹﻧﺟﻠﯾزﯾﺔ ھو "‪ ."en‬إذن ﺣﺳب اﻟﻧﻣوذج ﻓﺈن إﺳم ﻣﻠف اﻟﻠﻐﺔ اﻟﻌرﺑﯾﺔ ﯾﺟب أن ﯾﻛون‬
‫ﻛﺎﻟﺗﺎﻟﻲ ‪labels_ar.properties‬‬

‫ﻣﺣﺗوى ھذه اﻟﻣﻠﻔﺎت ﯾﻛون ﻋﻠﻰ ﺷﻛل‬

‫‪key=value‬‬
‫‪key=value‬‬

‫‪٤٧‬‬
 ‫‪....‬‬
‫ﺑﺣﯾث أﻧﻧﺎ ﻧﺳﺗرﺟﻊ اﻟﻧص اﻟذي ﻧرﯾده ﺑواﺳطﺔ ‪.key‬‬
‫ﻛﻣﺎ أﻧﮫ ﺗﺟدر اﻹﺷﺎرة إﻟﻰ أن اﻟﻣﻠﻔﺎت ‪ properties‬ﺗﻘﺑل ﻓﻘط اﻟﺗرﻣﯾز ‪ ،ISO-8859-1‬أي‬
‫اﻟﺣروف اﻟﻼﺗﯾﻧﯾﺔ ﻓﻘط‪ ،‬إذا أردﻧﺎ إﺿﺎﻓﺔ ﺣروف ﻋرﺑﯾﺔ‪ ،‬ﯾﺟب أن ﻧﻛﺗب اﻟرﻣز ‪unicode‬‬
‫اﻟﻣرادف ﻟﻛل ﺣرف‪.‬‬

‫س ‪ :٥٨‬ﻣﺎ ھﻲ ﻓﺋﺔ اﻟـ ‪ java.util.Locale‬؟‬

‫ھذه اﻟﻔﺋﺔ ﺗﻣﻛﻧﻧﺎ ﻣن ﺗﺣدﯾد اﻟﻣﻧطﻘﺔ اﻟﺟﻐراﻓﯾﺔ أو اﻟﺛﻘﺎﻓﯾﺔ اﻟﺗﻲ ﻧرﯾد‪ .‬ﻓﺑﻣﺎ أﻧﻧﺎ ﻧرﯾد أن ﻧﻐﯾر ﻟﻐﺔ‬
‫واﺟﮭﺔ ﺑرﻧﺎﻣﺟﻧﺎ‪ ،‬ﻓﯾﻠزﻣﻧﺎ وﺳﯾﻠﺔ ﻟﺗﺣدﯾد ھذه اﻟﻠﻐﺔ‪ ،‬وھﻧﺎ ﺗظﮭر ﻓﺎﺋدة اﻟﻔﺋﺔ ‪ .Locale‬ﻣﺛﻼ إذا أردﻧﺎ‬
‫إﻧﺷﺎء ‪ Locale‬ﺧﺎص ﺑﺎﻟﻌرﺑﯾﺔ‪ ،‬ﻓﺈﻧﻧﺎ ﻧﻣرر رﻣز اﻟﻠﻐﺔ اﻟﻌرﺑﯾﺔ ﻟل‪. constructor‬‬

‫;)"‪Locale arLocale = new Locale("ar‬‬

‫ﻟﻤﻌﺮﻓﺔ اﻟﺮﻣﺰ اﻟﺨﺎص ﺑﻜﻞ ﻟﻐﺔ ‪--> h p://www.loc.gov/standards/iso639-2/php/code_list.php‬‬

‫س ‪ :٥٩‬ﻣﺎ ھﻲ ﻓﺋﺔ اﻟـ ‪ java.util.ResourceBundle‬؟‬

‫ھذه اﻟﻔﺋﺔ ھﻲ اﻟﺗﻲ ﺗﻘوم ﺑﺗﺣﻣﯾل ﻣﻠف ال‪ properties‬اﻟﺧﺎص ﺑﺎﻟﻠﻐﺔ اﻟﺗﻲ ﻧﺣددھﺎ‪ ،‬وﺑﺎﻟطﺑﻊ ﺗﺣدﯾد‬
‫اﻟﻠﻐﺔ ﯾﻌﻧﻲ إﻧﺷﺎء ﻛﺎﺋن ‪ Locale‬ﺧﺎص ﺑﮭﺎﺗﮫ اﻟﻠﻐﺔ‪ .‬ﺑﻌد ﺗﺣﻣﯾل اﻟﻣﻠف ﻓﺈﻧﻧﺎ ﻧﺳﺗطﯾﻊ اﻟوﺻول ﻟﻠﻘﯾم‬
‫اﻟﻣوﺟودة ﺑداﺧﻠﮫ ﻋن طرﯾﻖ ‪ getString‬اﻟﺗﻲ ﻧﻣرر ﻟﮭﺎ ﻗﯾﻣﺔ ال‪.key‬‬

‫ﻟﻠﺣﺻول ﻋﻠﻰ ﻛﺎﺋن ‪ ResourceBundle‬ﻓﺈﻧﻧﺎ ﻧﻧﺎدي ﻋﻠﻰ اﻟطرﯾﻘﺔ ‪ ،getBundle‬وﻧﻣرر ﻟﮭﺎ‬

‫إﺳم اﻟﻣﻠف ‪ ،properties‬ﻟﻛن ﻟﯾس ﻛل اﻹﺳم‪ ،‬ﻟﻛن ﻓﻘط اﻟﺟزء اﻟﻣوﺟود ﻗﺑل اﻟﻠﻐﺔ‪ ،‬ﻣﺛﻼ إذا ﻛﺎن‬
‫ﻟدﯾﻧﺎ اﻟﻣﻠف ‪ ،labels_en.properties‬ﻓﺈﻧﻧﺎ ﻧﻣرر "‪ "labels‬ﻓﻘط ﻟﻠطرﯾﻘﺔ ‪ .getBundle‬ھذه‬
‫اﻟطرﯾﻘﺔ ﺗﻧﺗظر ﻣﻌطﻰ آﺧر‪ ،‬وھو ﻛﺎﺋن ‪ Locale‬ﯾﻣﺛل اﻟﻠﻐﺔ اﻟﺗﻲ ﻧرﯾد اﺳﺗﻌﻣﺎﻟﮭﺎ‪.‬‬

‫‪٤٨‬‬
Locale currentLocale = new Locale("ar");

ResourceBundle myResources = ResourceBundle.getBundle("labels", currentLocale);

String someValue = myResources.getString("someKey");

Java I/O

‫ ﻛﯾف أﻗرأ ﻣﺣﺗوى ﻣﻠف ﻧﺻﻲ ﺳطرا ﺑﺳطر؟‬:٦٠ ‫س‬

‫ أو اﻟﻔﺋﺔ‬BufferedReader ‫ ﯾﻣﻛﻧﻧﺎ اﺳﺗﻌﻣﺎل اﻟﻔﺋﺔ‬،‫ﻟﻘراءة ﻣﻠف ﻧﺻﻲ ﺳطرا ﺑﺳطر‬

:Scanner

:readLine ‫ واﻟطرﯾﻘﺔ‬BufferedReader ‫ﺑﺎﺳﺗﻌﻣﺎل اﻟﻔﺋﺔ‬

‫ اﻟذي‬FileReader ‫ ﻛﺎﺋن ﻣن ﻓﺋﺔ‬constructor‫ وﻧﻣرر ﻟل‬BufferedReader ‫أوﻻ ﻧﻧﺷﺊ ﻛﺎﺋن‬

‫ﻧﻣرر ﻟﮫ ﺑدوره ﻣﺳﺎر اﻟﻣﻠف اﻟذي ﻧرﯾد ﻗراءﺗﮫ‬

BufferedReader reader = null;

//...

reader = new BufferedReader(new FileReader("myfile.txt"));

٤٩
 ‫ وﻧﻘوم ﺑﻌد ذﻟك‬،String ‫ ﺑﻘراءة ﺳطر ﻣن اﻟﻣﻠف وﺗﺧزﯾﻧﮫ ﻓﻲ ﻣﺗﻐﯾر ﻣن ﻓﺋﺔ‬loop ‫ﺛم ﻧﻘوم داﺧل‬
.‫ﺑطﺑﺎﻋﺔ ﻗﯾﻣﺔ ھذا اﻟﻣﺗﻐﯾر‬

‫ ﻣﻣﺎ ﯾﻌﻧﻲ أﻧﻧﺎ وﺻﻠﻧﺎ إﻟﻰ ﻧﮭﺎﯾﺔ‬،null ‫)( اﻟﻘﯾﻣﺔ‬readLine ‫ ﺗﺗوﻗف ﻋﻧدﻣﺎ ﺗﻌﯾد اﻟطرﯾﻘﺔ‬loop‫ال‬
.‫اﻟﻣﻠف‬

String line;

while ((line = reader.readLine()) != null) {

System.out.println(line);

:‫اﻟﻜﻮد ﻛﺎﻣﻼ‬

BufferedReader reader = null;

try {

reader = new BufferedReader(new FileReader("myfile.txt"));

String line;

while ((line = reader.readLine()) != null) {

System.out.println(line);

} catch (IOException ex) {

ex.printStackTrace();

} finally {

try {

if (reader != null) {

reader.close();

٥٠
 ‫}‬

‫{ )‪} catch (IOException ex‬‬

‫;)"‪System.out.println("Closing stream failed.‬‬

‫}‬

‫}‬

‫س ‪ :٦١‬ﻣﺎذا وﺿﻌﻧﺎ أﻣر إﻗﻔﺎل ‪ reader‬داﺧل ‪finally‬؟ ﻣﺎذا ﺳﯾﺣﺻل ﻟو وﺿﻌﻧﺎ أﻣر‬
‫اﻹﻏﻼق داﺧل ال ‪ ،try block‬ﺑﻌد اﻹﻧﺗﮭﺎء ﻣن ال‪ ،loop‬ﻛﻣﺎ اﻟﻛود اﻟﺗﺎﻟﻲ؟‬

‫‪//...‬‬

‫;‪String line‬‬

‫{ )‪while ((line = reader.readLine()) != null‬‬

‫;)‪System.out.println(line‬‬

‫}‬

‫)(‪reader.close‬‬

‫‪//...‬‬

‫ﻟﻧﻔﺗرض ﻣﺛﻼ أن اﻟﺑرﻧﺎﻣﺞ ﻋﻧد ﺗﻧﻔﯾذ اﻷﻣر ‪ readLine‬واﺟﮫ ﻣﺷﻛﻠﺔ ﻓﻲ ﻗراءة اﻟﻣﻠف‪ ،‬ﻣﻣﺎ ﺟﻌﻠﮫ‬
‫ﯾرﻓﻊ ‪ ،IOException‬ھذا ﯾﻌﻧﻲ أﻧﮫ ﺳﯾﺗﺟﺎھل ﻛل اﻟﻛود اﻟﻣوﺟود ﺑﻌد اﻟﺳطر اﻟذي رﻓﻊ اﻹﺳﺗﺛﻧﺎء‬
‫وﺳﯾﻧﻔذ ﻣﺑﺎﺷرة اﻟﻛود اﻟﻣوﺟود ﻓﻲ ‪ ،catch bloc‬وﺑﺎﻟﺗﺎﻟﻲ ﻟن ﯾﻧﻔذ أﻣر اﻹﻏﻼق‪ ،‬وﺳﯾﺑﻘﻰ‬
‫ال‪ reader‬ﻣﻔﺗوﺣﺎ‪ ،‬وﺑﺎﻟﺗﺎﻟﻲ ﻟن ﯾﺗم ﺗﺣرﯾر اﻟذاﻛرة اﻟﺗﻲ ﯾﺳﺗﻌﻣﻠﮭﺎ‪.‬‬

‫اﻟﺣل إذن ھو وﺿﻊ إﻣر اﻹﻏﻼق داﺧل ‪ ،finally bloc‬ﻷن اﻟﻛود اﻟﻣوﺟود داﺧﻠﮫ ﯾﺗم ﺗﻧﻔﯾذه داﺋﻣﺎ‪،‬‬
‫ﺳواء ﺗم رﻓﻊ ‪ exception‬أو ﻻ‪.‬‬

‫‪٥١‬‬
 ‫ ؟‬Scanner ‫ ﻛﯾف ﻧﻘرأ اﻟﻣﻠف ﺑﺎﺳﺗﻌﻣﺎل اﻟﻔﺋﺔ‬:٦٢ ‫س‬

‫ وﻧﻣرر ﻟﮫ اﻟﻣﻠف اﻟذي ﺳﻧﻘرأه‬Scanner ‫أوﻻ ﻧﻧﺷﺊ ﻛﺎﺋن‬

Scanner scanner = new Scanner(new File("myfile.txt"));

‫ ﻟﻛن أوﻻ ﯾﺟب أن‬،()nexLine ‫ ﺑﻘراءة اﻟﻣﻠف ﺳطرا ﺳطرا ﺑواﺳطﺔ اﻟطرﯾﻘﺔ‬loop ‫ﺛم ﻧﻘوم داﺧل‬
. ‫ﻧﺗﺣﻘﻖ أﻧﻧﺎ ﻟم ﻧﺻل إﻟﻰ ﻧﮭﺎﯾﺔ اﻟﻣﻠف‬

while (scanner.hasNextLine()) {

String line = scanner.nextLine();

System.out.println(line);

scanner‫ﺛم ﻧﻘﻔل ال‬

scanner.close();

: ‫اﻟﻛود ﻛﺎﻣﻼ‬

Scanner scanner = new Scanner(new File("myfile.txt"));

while (scanner.hasNextLine()) {

String line = scanner.nextLine();

System.out.println(line);

scanner.close();

٥٢
 ‫ﻋﺎم‬

‫س‪ : ٦٣‬ﻣﺎ ھﻲ اﻟـ ‪ JPA‬؟‬

‫‪، Java Persistence APIs‬‬

‫‪- framework‬إن ﺻﺢ اﻟﺗﻌﺑﯾر‪ -‬ﻟﻠﺗﻌﺎﻣل ﻣﻊ اﻟداﺗﺎ ﺑﯾس )‪ (Database‬ﺑطرﯾﻘﺔ ‪OOP‬‬
‫‪ .‬أي أﻧك ﻻ ﺗﺗﻌﺎﻣل ﻣﻊ اﻟداﺗﺎ ﺑﯾس ﺑﺎﺳﺗﻌﻼﻣﺎت ﻋﺎدﯾﺔ ‪-‬ﺧﺎﺻﺔ ﻓﻲ ﺣﺎﻟﺔ اﻹﺿﺎﻓﺔ‬
‫واﻟﺗﻌدﯾل‪ -‬وﻣﻊ ذﻟك ﯾوﺟد اﺳﺗﻌﻼﻣﺎت ﻟﻠﺑﺣث واﻟﺣذف‪..‬‬
‫‪ JPA‬ھﻲ ﺗﺣﻘﯾﻖ ﻟﻣﻔﮭوم ‪ (Object Relationship Mapping) ORM‬أي اﻟﺗﻌﺎﻣل‬
‫ﻣﻊ اﻟداﺗﺎ ﺑﯾس ﺑطرﯾﻘﺔ ﻏرﺿﯾﺔ ‪.‬‬

‫س ‪ : ٦٤‬ﻣﺎ ھو اﻟﻔرق ﺑﯾن ‪ JDK‬و ‪ JRE‬و ‪ JVM‬؟‬

‫ﺣﺎول ان ﺗﺟﺎوب ﻋﻠﻰ ﺣﺳب ﻣﻌرﻓﺗك ﺛم ﻗﺎرن ﺑﯾن اﻻﺟﺎﺑﺗﯾن ‪ ،‬واذا ﻛﺎﻧت ھﻧﺎك اي‬
‫اﺿﺎﻓﺔ او ﺷرح ﺗﻔﺻﯾﻠﻲ ‪ ،‬ﻓﻛﻠﻧﺎ ﻧﺳﺗﻔﯾد ﻣﻊ ﺑﻌض ‪..‬‬
‫ھذا اﻟﺳؤال ﻏﺎﻟﺑﺎ اﻟﻣﺑرﻣﺟون ﻣﺎ ﯾﮭﺗﻣون ﻓﯾﮫ ﻛﺛﯾرا وﻻ ﻓﻲ ﻛﯾﻔﯾﺔ ﻋﻣﻠﯾﺔ ﺗرﺟﻣﺔ اﻟﺑرﻧﺎﻣﺞ‬
‫!‬
‫|‬
‫|‬
‫|‬
‫|‬
‫|‬

‫‪٥٣‬‬
 ‫)‪JDK (Java Development Kit‬‬
‫ﻳﻨﺪرج ﺗﺤﺘﻪ اﻻدوات اﻟﺨﺎﺻﺔ ﺑﻌﻤﻞ ﺑﺮاﻣﺞ ﺑﺎﺳﺘﺨﺪام ﻟﻐﺔ اﻟﺠﺎﻓﺎ ‪،‬‬
‫وھﺬه اﻻدوات ﺗﺤﺘﻮي أﻳﻀﺎ ﻋﻠﻰ ‪ Compiler‬اﻟﺨﺎص ﺑﻠﻐﺔ اﻟﺠﺎﻓﺎ‬
‫وﻟﺘﺸﻐﯿﻞ ھﺬه اﻟﺒﺮاﻣﺞ ﻋﻠﻰ اﻟﺠﮫﺎز اﻟﻤﺴﺘﺨﺪم ﻻﺑﺪ ﻣﻦ وﺟﻮد ‪jre‬‬

‫)‪JRE (Java Runtime Environment‬‬

‫ﺗﺤﺘﻮي ھﺬه اﻟﺒﺎﻛﺪج ﻋﻠﻰ اﻟﻤﻜﺘﺒﺎت واﻟﻤﻠﻔﺎت اﻟﺨﺎﺻﺔ ﺑﻠﻐﺔ اﻟﺠﺎﻓﺎ واﻳﻀﺎ اﻟﻤﻠﻔﺎت‬
‫اﻟﻤﺪﻋﻮﻣﺔ ﺳﻮاء اﻓﺘﺮاﺿﯿﺎ ﻣﻊ اﻟﺠﺎﻓﺎ او اﺿﯿﻔﺖ ﻋﻦ طﺮﻳﻖ اﻟﻤﺒﺮﻣﺞ ‪ ،‬وﻟﻜﻨﮫﺎ ﻻ ﺗﺤﺘﻮي‬
‫ﻋﻠﻰ أي أدوات ﺗﺴﺘﺨﺪم ﻓﻲ ﻋﻤﻠﯿﺔ اﻟﺘﻜﻮﻳﺪ ﻣﺜﻞ اﻟﻜﻮﻣﺒﯿﻠﺮ و ﻏﯿﺮ ذﻟﻚ ‪ .‬وﻟﮫﺬا اذا اردت‬
‫ﺗﺸﻐﯿﻞ اي ﺑﺮﻧﺎﻣﺞ ﻟﻠﺠﺎﻓﺎ ﻻ ﺑﺪ ان ﻳﻜﻮن ﻋﻠﻰ ﺟﮫﺎزك اﻟﺨﺎص ھﺬه اﻟﺒﺎﻛﺪج‬

‫)‪JVM (Java Virtual Machine‬‬

‫ﺑﻌﺪ ﻣﺎ ﺣﻮل ﻣﻠﻒ ‪ .java‬ﻣﻦ إﻟﻰ ‪.class‬‬
‫وھﺬا اﻟﻤﻠﻒ ﻣﻜﻮن ﻣﻦ ﺑﺎﻳﺖ ﻛﻮد طﺒﻌﺎ ﻧﻈﺎم اﻟﺘﺸﻐﯿﻞ ﻻ ﻳﻔﮫﻤﻪ‬
‫ﻓﺘﻘﻮم ‪ jvm‬ﺑﺘﺤﻮﻳﻞ ﻣﻠﻒ ‪ .class‬ﻣﻦ ‪ Byte code‬إﻟﻰ ‪) Binary‬ﻟﻐﺔ اﻻﻟﻪ(‬

‫‪٥٤‬‬
 ‫‪Data Structure‬‬
‫س ‪ :٦٥‬أول ﺳؤال ﻣﻣﻛن ﯾﻛون ﻋﻠﻰ ﺑﺎﻟك أن ھل اﻟـ ‪ Data Structure‬ﻟﮭﺎ ﻋﻼﻗﺔ ﺑﺎﻟـ‬
‫‪ Database‬ام ﻻ ؟‬

‫اﻹﺟﺎﺑﺔ ﻻ ‪ ،‬ھﻧﺎك ﻓرق ﺑﯾن ﻣﺎ ﯾﻌرف ﺑﻘواﻋد اﻟﺑﯾﺎﻧﺎت ‪ ، Databases‬وﺑﯾن ﻣﻔﮭوم‬

‫ھﯾﺎﻛل)ﺗراﻛﯾب(اﻟﺑﯾﺎﻧﺎت ‪. Data Structure‬‬

‫ﻗواﻋد اﻟﺑﯾﺎﻧﺎت ھﻲ ﻋﻣﻠﯾﺔ ﺗﺧزﯾن اﻟﺑﯾﺎﻧﺎت ‪.‬‬

‫أﻣﺎ ھﯾﺎﻛل اﻟﺑﯾﺎﻧﺎت ھﻲ اﻟﻠﻲ ﺗﺣﺗﺎﺟﮭﺎ ﻷداء ﺑرﻧﺎﻣﺞ ﺑﻛﻔﺎءة ﻋﺎﻟﯾﺔ ﻓﻲ وﻗت اﻟﺗﻧﻔﯾذ )ﺧﻼل‬
‫اﻟـ ‪.(runtime‬‬

‫ﺑﻣﻌﻧﻰ أوﺿﺢ ﻗواﻋد اﻟﺑﯾﺎﻧﺎت أﻧت ﺗﺧزن ﻓﯾﮭﺎ اﻟﺑﯾﺎﻧﺎت ﻷﺟل أﻧك ﻟو أﻏﻠﻘت اﻟﻛﻣﺑﯾوﺗر‬
‫ﺗﺟﻲ اﻟﯾوم اﻟﺛﺎﻧﻲ ﺗﻠﻘﺎھﺎ ﻣوﺟودة ‪.‬‬

‫ﻓﯾﮫ ﻓرق ﺑﯾن ﺗﺧزﯾن ﺑﯾﺎﻧﺎت وﺑﯾن ﺑﯾﺎﻧﺎت ﺣﯾﺔ ﻓﻲ اﻟذاﻛرة ﻟﻠﺗﻌﺎﻣل ﻣﻌﮭﺎ ‪.‬‬

‫ﻓﻲ اﻟﺑرﻧﺎﻣﺞ ﻋﺎدة اﻟﻌﻣﻠﯾﺎت اﻟﺗﻲ ﺗﺗم ﻓﻲ ‪ RunTime‬ﺗﺗم ﻋﻠﻰ ‪.Data Structure‬‬

‫ھﯾﺎﻛل اﻟﺑﯾﺎﻧﺎت ﺑﺎﺧﺗﺻﺎر ھﻲ ﺗﺣﻠﯾل ﺷﻛل اﻟﺑﯾﺎﻧﺎت ﺷﻠون ﺗﻛون داﺧل اﻻوﺑﺟﻛت‬
‫وﻧﺳﺗﺧدﻣﮭﺎ ﻟﺟﻣﻊ اﻟﺑﯾﺎﻧﺎت وﺗرﺗﯾﺑﮭﺎ وﺗﻧظﯾﻣﮭﺎ ‪...‬‬

‫‪٥٥‬‬
 ‫ﻓﻲ ﺟﺎﻓﺎ ﻓﯾﮫ اوﺑﺟﻛت ﺟﺎھزة ﻟك أﻧك ﺗﺳﺗﺧدﻣﮭﺎ ﻋﻠﻰ طول ﯾﻌﻧﻲ ﻣﺎ ﯾﺣﺗﺎج ﺗﻌﯾد ﻛﺗﺎﺑﺔ‬
‫ﻛل ﺷﺊ ﻣن اﻟﺻﻔر ﻣﺛل ﻣﺎ ھو ﻓﻲ ‪ C‬و ‪ ، C++‬ﻛذﻟك ﻧﺗﻛﻠم ﻋن أن ھﯾﺎﻛل اﻟﺑﯾﺎﻧﺎت‬
‫ﯾﺄﺗﻲ ﻣﻌﮭﺎ ﺧوارزﻣﯾﺎت ﻟﻠﺗرﺗﯾب وإﻋﺎدة اﻟﺗرﺗﯾب وﺻﯾﺎﻏﺔ أﺟزاء اﻟﺑﯾﺎﻧﺎت اﻟﻣوﺟودة ‪،‬‬
‫وھذه اﻟﺧوارزﻣﯾﺎت ﻣوﺟودة ﻣﻊ اﻻوﺑﺟﻛت ﯾﻌﻧﻲ ﻣﺿﻐوطﺔ ﻣﻊ اﻻوﺑﺟﻛت او‬
‫اﻻﻧﺗرﻓﯾس اﻟﻠﻲ راح ﻧﺗﻛﻠم ﻋﻧﮫ اﻵن ‪.‬‬

‫ﻣرﻛز اﻟﻌﻣﻠﯾﺎت ھو اﻧﺗرﻓﯾس ‪ interface‬رھﯾب ﺟدا ً ھو اﻟـ ‪. Collection‬‬

‫اﻟﺷﻛل اﻷﺳﺎﺳﻲ ﻟﻠـ ‪ Collection interface‬ھو أﻧﮫ ﯾﺗﻔرع ﻣﻧﮫ اﺛﻧﯾن ﻣن اﻟـ‬
‫‪ : interface‬وھﻲ ‪ Set‬و ‪. List‬‬

‫‪ Set‬ﻣﻌﻧﺎھﺎ ﻣﺟﻣوﻋﺔ ﻣن اﻷﺷﯾﺎء أو اﻟﺑﯾﺎﻧﺎت ﻻ ﯾوﺟد ﻓﯾﮭﺎ ﺗﻛرار ‪.‬‬

‫ﻣﺎ ﺗﻘﺑل اﻟﺗﻛرار اذا ﻛﺎن ‪ ConCrete Class‬ﻻزم ﺗﻌرف ﻓﯾﮫ اﻟـ ‪Two Method‬‬
‫اﻟﻣوﺟوده ﻓﻲ ﻛل اوﺑﺟﻛت اﻟﻠﻲ ھﻲ ‪ equals‬و ‪. hashcode‬‬
‫‪ List‬ﻣﻌﻧﺎھﺎ ﻣﺟﻣوﻋﺔ ﻣن اﻷﺷﯾﺎء واﻟﺑﯾﺎﻧﺎت وﺗﺳﻣﺢ ﺑﺎﻟﺗﻛرار وﺑﻣزاﯾﺎ أﺧرى ‪.‬‬

‫أﯾﺿﺎ ﯾوﺟد اﻟـ ‪ Map Interfaca‬ﻟﻛﻧﮫ ﻟﯾس ﻣن ‪ Collection‬ﻓﮭو ﺟﺳم ﺑرﻣﺟﻲ آﺧر‬
‫ﻋﺑﺎرة ﻋن دﻣﺞ ﺟﺳﻣﯾن ﻣﻊ ﺑﻌض ‪.‬‬

‫ﻧﻘطﺔ ﻣﮭﻣﮫ أن ھذه اﻻﻧﺗرﻓﯾس ‪ Set‬و ‪ List‬ﻻ ﯾﻣﻛن اﻧك ﺗﺳوي ﻣﻧﮭﺎ اوﺑﺟﻛت ﯾﻌﻧﻲ ﻣﺎ‬
‫ﺗﻘدر ﺗﺳوي ﻣن ﻋﻧدھﺎ ‪ new‬ﻣﺛﻼ ‪ new Set‬أو ‪، new List‬‬
‫ﻷﻧﮭﺎ ﻛﺄي اﻧﺗرﻓﯾس ﻻ ﺗﺳﺗطﯾﻊ ان ﺗﻧﺷﺄ ﻣﻧﮫ اوﺑﺟﯾﻛت واﻟدوال اﻟﻠﻲ ﻓﯾﮫ ﺗطﺑﻘﮭﺎ ﻛﻼﺳﺎت‬
‫‪ ConCrete‬ﯾﻌﻧﻲ اوﺑﺟﻛت ﺟﺎھزة ﻟﻼﺳﺗﺧدام ﻓﺗﺳﺗطﯾﻊ‬
‫إذا ﺗﺑﻲ ‪:‬‬

‫‪٥٦‬‬
 ‫‪ Set‬ﺗﻘدر ﺗﺳﺗﻌﻣل أﻣﺎ ‪ HashSet‬أو ‪ TreeSet‬اﻟﻣطﺑّ ِﻘﺎن ﻟﮫ ‪.‬‬

‫‪ List‬ﺗﻘدر ﺗﺳﺗﻌﻣل أﻣﺎ ‪ ArrayList‬أو ‪. LinkedList‬‬

‫‪ Map‬ﺗﻘدر ﺗﺳﺗﻌﻣل ‪ HashMap‬أو ‪. TreeMap‬‬

‫‪ Tree‬ﻣﻌﻧﺎﺗﮭﺎ ‪ Sorted‬ﯾﻌﻧﻲ ﻣرﺗﺑﺔ ﺣﺳب ﺗرﺗﯾب ﻣﻌﯾن اﻧت ﺣددﺗﮫ ﺳﺎﺑﻘﺎ ً ‪.‬‬

‫ﻣﻼﺣظﺔ ‪ :‬أﻧﻲ اﺗﻛﻠم اﻵن ﻋن اﻟﺷﻛل اﻷﺳﺎﺳﻲ أﻣﺎ اﻵن ﻓﻲ اﻟـ ‪ Collection‬ﻓﯾﮫ‬
‫اﻧﺗرﻓﯾس ﺟدﯾد ‪ Queue‬وﻓﻲ ‪ Set‬و ‪ List‬ﻛﻼﺳﺎت أﺧرى ﺟﺎھزة‬
‫ﻟﻼﺳﺗﺧدام ﻏﯾر اﻟﻠﻲ ذﻛرﺗﮭم ‪ .‬ﯾﻣﻛﻧك ﻣﺷﺎھدة اﻟﺻورة ﻓﻲ آﺧر اﻟﻣﻘﺎﻟﺔ وﺗﺷﺎھد‬
‫‪ Collection‬وﺗﻔرﻋﺎﺗﮫ ‪.‬‬

‫ﻟو أﺧذﻧﺎ اﻟﺷﻛل اﻷﺳﺎﺳﻲ ﺑﺷﻛل ﻣﻛﺑر ﻗﻠﯾﻼ ً ﻧﺷوف أن ‪ Collection‬ﻣرﺗﺑط ﻓﻲ ﺷﺊ‬
‫اﺳﻣﮫ ‪ Iteratable‬و ‪ Iterate‬ﯾﻌﻧﻲ اﻧﮫ ﻗﺎﺑل اﻧﮫ ﯾدور‬
‫واﯾﺿﺎ ً ﻋﻧدي ﻣن ‪ Iteratable Interface‬اوﺑﺟﻛت اﺳﻣﮫ ‪ Iterator <--‬وھذا‬
‫اﻻوﺑﺟﻛت اﻗدر اﺳﺗدﻋﯾﮫ ﻋن طرﯾﻖ اﻟﻛوﻧﺳﺗراﻛﺗر ‪. Constructor‬‬

‫‪: Iteratable Interface‬‬

‫ﯾوﺟد ﻓﯾﮫ ﻋﻣﻠﯾﺔ واﺣدة ﻓﻘط اﻟﻠﻲ ھﻲ ))(‪ Iterator‬ﻛوﻧﺳﺗراﻛﺗر( ‪ ،‬ﯾوﺟد ﻓﻲ اﻻوﺑﺟﻛت‬
‫أو ﻛﻼس ‪ Iterator‬ﺛﻼث ﻋﻣﻠﯾﺎت ‪:‬‬

‫‪٥٧‬‬
 boolean hasNext()
. Loop ‫ﻷﺟل ﺗﺣدﯾد اﻟوﺟﮫ ﻟﻠوب‬

boolean next()
‫ﯾﻌطﯾك اﻷوﺑﺟﻛت اﻟﺗﺎﻟﻲ‬

void remove()
. ‫اذا ﺗﺑﻐﻰ ﺗﺷﯾل )ﺗﺣذف( ﻛﺎﺋن‬

. java.util ‫ ﻣن اﻟﺑﺎﻛﺞ‬collection interface ‫أول ﺷﺊ اﻟـ‬

.
: collection interface ‫ﻧدﺧل اﻵن ﻓﻲ ﻋﻣﻠﯾﺎت اﻟـ‬

: ‫ ﺗﺣﺗوي ﻋﻠﻰ‬Informative Methods _١

Iterator Iterator()
‫ﻋرﻓﻧﺎھﺎ ﻓوق‬

boolean isEmpty()
(true Or false) boolean ‫ ﻓﺎﺿﻲ وﯾرﺟﻊ ﻟﻧﺎ‬collection ‫ھﻧﺎ ﻧﺳﺄل ھل اﻟﻛوﻟﻛﺷن‬

int size()

٥٨
 . ‫ﯾرﺟﻊ ﻟﻧﺎ اﻟﺣﺟم‬

: Object Based Methods _٢

boolean equals(Object o)
. ‫ﻧﺳﺗﻌﻠﻣﮭﺎ ﻓﻲ اﻟﻣﻘﺎرﻧﺔ ﺑﯾن اﺛﻧﯾن ﻣن اﻟﻛوﻟﻛﺷن‬

int hashCode()
. ‫ﯾرﺟﻊ ﻟﻧﺎ اﻟرﻗم اﻟﺧﺎص ﺑﺎﻻوﺑﺟﻛت‬

: Element Based Methods _٣

boolean add(Object o)
. ‫إذا اﺑﻐﻰ اﺿﯾف ﻛﺎﺋن‬

boolean remove(Object o)
. ‫إذا اﺑﻐﻰ اﺣذف ﻛﺎﺋن‬

boolean contins(Object o)
. ‫إذا اﺷﯾك ھل ﺗﺣﺗوي ﻋﻠﻰ‬

: Output To Arrays Methods _٤

٥٩
 ‫)(‪Object[] toArray‬‬
‫إذا ﺧﻠﺻت ﻣن اﻷوﺑﺟﻛت واﺑﻐﻰ اﺣوﻟﮫ إﻟﻰ ِ◌‪. Arrays‬‬

‫) ‪Object[] toArray(Object[] o‬‬

‫ﻧﻔﺳﮭﺎ ﻟﻛﻧﮭﺎ ﺗﺣول ﻣﺻﻔوﻓﺔ وﺗرﺟﻌﮭﺎ ﻟﻧﺎ ‪.‬‬
‫‪: Collection Based Methods _٥‬‬
‫ھذي ﻋﻣﻠﯾﺎت ﺧﺎﺻﺔ ﺑﯾن ﻛوﻟﻛﺷن وﻛﻠوﻛﺷن ﻣﺛﻼ ‪ A‬و ‪. B‬‬

‫)‪boolean addAll(Collection c‬‬

‫ﺗﻌطﻲ ﻛوﻟﻛﺷن ﺗﺿﺎف ﺑﺎﻟﻛﺎﻣل ﻋﻠﻰ اﻟﻛوﻟﻛﺷن اﻟﻣراده ‪.‬‬

‫)‪boolean containsAll(Collection c‬‬

‫ﻣﺛﻼ ھل ‪ A‬ﺗﺣﺗوي ﻋﻠﻰ ﻛل ﻋﻧﺎﺻر ‪. B‬‬

‫)‪boolean removeAll(Collection c‬‬

‫أﻧﺎ ﻣﻣﻛن اﻗوﻟﮫ ‪ B removeAll A‬ﻓﺳﯾﺣذف ﻛل اﻟﻌﻧﺎﺻر ﻏﯾر اﻟﻣوﺟودة أو اﻟﻣﺷﺗرﻛﺔ‬
‫‪.‬‬

‫)(‪void clear‬‬
‫راح ﯾﻧظف ‪ A‬ﯾﻌﻧﻲ راح ﯾﻔﺿﯾﮭﺎ ﻣن اﻟداﺧل‪.‬‬

‫)‪boolean retainAll(Collection c‬‬

‫‪٦٠‬‬
 ‫ھﻧﺎ ﻧﻘوﻟﮫ ﺣﺎﻓظ ﻋﻠﻰ اﻟﻠﻲ ﻣوﺟود ﻓﻲ ‪ A‬و ‪. B‬‬

‫س ‪ : ٦٦‬ﻣﺎ ھو اﻟﻔرق ﺑﯾن اﻟـ ‪ arrayList‬و اﻟـ ‪ LinkedList‬؟‬

‫ﻟو ﺗﻼﺣظ اﻟﺻورة ﺗﺷوف أن ‪ ArrayList‬و ‪ LinkedList‬ﻣن ﻧﻔس اﻻﻧﺗرﻓﯾس ‪، List‬‬

‫ﯾﻌﻧﻲ ﻣﺗﺷﺎﺑﮭﺎت ﺟدا ﻓﻲ اﻻﺳﺗﺧدام‪ ،‬وﻟﻛن ‪ LinkedList‬ﻟدﯾﮫ ﺗﻔرع ﻣن اﻻﻧﺗرﻓﯾس‬
‫‪ ، Queue‬وھذا ﯾﻌطﯾﮭﺎ ﻣﻣﯾزات )دوال( أﻛﺛر ﻣن ‪ ArrayList‬ﻣﺛل ‪poll , peek ,‬‬
‫‪ offer‬وﻏﯾرھﺎ ‪ ،‬اﻟﻔرق اﻟرﺋﯾﺳﻲ ھو اﻟﺗﻧﻔﯾذ )‪ (implementation‬اﻟﻠﻲ ﯾﺳﺑب أداء‬

‫‪٦١‬‬
 ‫ ﺗﺗﻐﯾر ﺣﺟﻣﮭﺎ واﺿﺎﻓﺔ‬array‫ ك‬ArrayList ‫ ﺗﺳﺗﻌﻣل ال‬، ‫ﻣﺧﺗﻠف ﻟﻠﻌﻣﻠﯾﺎت اﻟﻣﺧﺗﻠﻔﺔ‬
‫ اﯾﺿﺎ ﯾﻣﻛن اﻟوﺻول إﻟﯾﮭﺎ ﻣﺑﺎﺷرة ﻋن‬، ‫ﻋﻧﺎﺻر ﺟدﯾدة وﯾزداد ﺣﺟﻣﮭﺎ ﺑﺷﻛل دﯾﻧﺎﻣﯾﻛﻲ‬
‫ ﺗﺳﺗﻌﻣل أو ﺗﻧﻔذ ﻛﻘﺎﺋﻣﺔ ﻣزدوﺟﺔ ﻣرﺗﺑطﺔ‬LinkedList ‫ وال‬، get ‫ و‬set ‫طرﯾﻖ دوال‬
‫ وﻟﻛن أدﺋﮭﺎ أﻓﺿل ﻓﻲ اﻻﺿﺎﻓﺔ واﻹزاﻟﺔ‬get ‫ و‬set ‫ أداﺋﮭﺎ ﺳﺊ ﻟﻠدوال‬، ‫ﻣﻊ ﺑﻌﺿﮭﺎ‬
.. ‫ وھﻧﺎك اﺧﺗﻼﻓﺎت أﺧرى‬.. arrayList ‫أﻓﺿل ﻣن ال‬
: LinkedList ‫وھذا ﻣﺛﺎل ﺑﺳﯾط ﻻﺳﺗﻌﻣﺎل‬

List<String> staff = new LinkedList<>(); // LinkedList implements

List
staff.add("Amy"); staff.add("Bob"); staff.add("Carl"); Iterator
iter = staff.iterator();
String first = iter.next(); // visit first element String second =
iter.next(); // visit second element iter.remove(); // remove last
visited element

٦٢
 ‫ ﻣﺎ ھو اﻟﻔرق ﺑﯾن‬: ٦٧ ‫س‬
List<String> list = new LinkedList<String>();
‫و‬
LinkedList list<String> = new LinkedList<String>();

‫؟‬

‫ ﻓﻲ اﻷﺳﻔل ﻟﻛن ﯾﻛون وﻗﺗﮭﺎ ﺗﺑﻐﻰ‬LinkedList ‫اﻟﻔرق اﻧك ﻣﻣﻛن ﺗﺣﺗﺎج ﻧﻔس ال‬
‫ أو اﻧك ﺗﻛون ﺗﺑﻐﻰ ﺗﺣﺻل ﻋﻠﻰ اﻟﻘﯾم ﻣﺛل ﻣﺎ اﻧﺎ واﺿﻊ ﻓﻲ‬ArrayList ‫ﺗﺳﺗﺧدﻣﮭﺎ ك‬
‫ ھﻲ اﻷﻧﺳب وﻧﻔس اﻟﺷﺊ ﻟو ﻛﺎن اﻟوﻗت‬ArrayList ‫ ﻓﺑﺎﻟوﻗت ھذا ﺗﻛون‬، ‫اﻟﺷرح ﻓوق‬
‫ أو‬LinkedList ‫ ﻓﺈﺳﻧﺎد ال‬، LinkedList ‫ إﻟﻰ‬ArrayList ‫اﻧﺳب اﻧﻲ اﺳﺗﺑدل‬
.. ‫ ﻻﺟل اﻧﻲ ﻟو اﺑﻐﻰ اﺑدل ﺑﯾﻧﮭم ﻓﻲ وﻗت ﻻﺣﻖ‬، List interface ‫ إﻟﻰ‬ArrayList

‫( ﻋﻧﺎﺻر اﻟﻣﺻﻔوﻓﺔ؟؟‬sorting) ‫ ﻛﯾف أﻗوم ﺑﺗرﺗﯾب‬:٦٨ ‫س‬

argument‫ واﻟﺗﻲ ﺗﻧﺗظر ك‬Arrays.sort ‫ ﯾﻣﻛﻧﻧﺎ اﺳﺗﻌﻣﺎل اﻟطرﯾﻘﺔ‬،‫ﻣن أﺟل ﺗرﺗﯾب ﻣﺻﻔوﻓﺔ ﻣﺎ‬
‫اﻟﻣﺻﻔوﻓﺔ اﻟﺗﻲ ﻧرﯾد ﺗرﺗﯾﺗﺑﮭﺎ‬
: ‫ﻣﺛﻼ‬

int[] array1 = {10, 3, 4, 45, 2, 0, 9};

System.out.println("array1 before sorting: " + Arrays.toString(array1));

Arrays.sort(array1);

System.out.println("array1 after sorting: " + Arrays.toString(array1));

‫واﻟﻨﺘﯿﺠﺔ ھﻲ ﻛﺎﻟﺘﺎﻟﻲ‬

array1 before sorting: [10, 3, 4, 45, 2, 0, 9]

array1 after sorting: [0, 2, 3, 4, 9, 10, 45]

٦٣
 ‫ﻣﻼﺣﻈﺔ ‪:‬ﻳﺠﺐ أن ﺗﻜﻮن ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ إﻣﺎ ‪ primitive types‬أو ﻓﺌﺎت ﺗﻌﻤﻞ‬
‫‪ implement‬ﻟﻠﻮاﺟﮫﺔ ‪ Comparable‬وﺗﻌﺮف اﻟﻄﺮﻳﻘﺔ ‪compareTo‬‬

‫ﻋﺎم‬
‫س ‪ :٦٩‬ﻣﺎ ھو ‪ Java Annotations‬؟‬
‫ال ‪ ،Annotation‬أو )ﺣﺴﺐ ﻣﻌﺠﻢ ‪ (ArabEyes‬اﻟﺘﻌﻠﯿﻖ‪/‬اﻟﺤﺎﺷﯿﺔ‪ ،‬ھﻮ‬
‫إﺿﺎﻓﺔ ﻣﻌﻠﻮﻣﺎت إﻟﻰ اﻟﺸﯿﻔﺮة‪ .‬ﻟﻜﻦ اﻟﻔﺮق ﺑﯿﻨﮫﺎ وﺑﯿﻦ ال ‪ comments‬أو‬
‫ال ‪ ،Javadoc‬ھﻮ أن ال ‪ annotations‬ﻳﻤﻜﻦ اﺳﺘﻌﻤﺎﻟﮫﺎ ﻣﻦ طﺮف‬
‫‪ annotation processor‬ﻟﻠﻘﯿﺎم ﺑﻌﻤﻠﯿﺎت ﻣﺨﺘﻠﻔﺔ‪ :‬إﻧﺸﺎء ﻣﻠﻔﺎت‪ ،‬إﻧﺸﺎء‬
‫ﺟﺪاول ﻓﻲ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت‪ ،‬اﻟﺘﺤﻘﻖ ﻣﻦ اﺣﺘﺮام اﻟﺸﯿﻔﺮة ﻟﻠﻤﻌﺎﻳﯿﺮ‬
‫اﻟﻤﺤﺪدة‪ ،‬أو ﺣﺘﻰ إﺿﺎﻓﺔ أﺳﻄﺮ ﺟﺪﻳﺪة ﻣﻦ اﻟﻜﻮد‪ ..‬وﻗﺪ ﺗﻤﺖ إﺿﺎﻓﺔ ال‬
‫‪ annotations‬إﻟﻰ اﻟﺠﺎﻓﺎ ﻓﻲ اﻟﻨﺴﺨﺔ اﻟﺨﺎﻣﺴﺔ ‪.JavaSE 5‬‬

‫ھﻨﺎك ﻧﻮﻋﯿﻦ ﻣﻦ ال ‪ ،annotations‬اﻟﺤﻮاﺷﻲ اﻟﻤﻮﺟﻮدة ﻓﻲ اﻟﺠﺎﻓﺎ‪،‬‬

‫وھﻲ ﺛﻼﺛﺔ ﻓﻘﻂ‪ ،‬واﻟﺤﻮاﺷﻲ اﻟﺘﻲ ﻳﻜﺘﺒﮫﺎ اﻟﻤﺒﺮﻣﺞ‪.‬‬

‫اﻟﺤﻮاﺷﻲ )‪ (Annotation‬اﻟﻤﻮﺟﻮدة ﻓﻲ اﻟﺠﺎﻓﺎ‪:‬‬

‫‪ :@Override‬ﺗﻘﻮم ھﺬه اﻟﺤﺎﺷﯿﺔ ﺑﺎﻹﺷﺎرة إﻟﻰ أن اﻟﻄﺮﻳﻘﺔ اﻟﺘﻲ ﺗﺄﺗﻲ‬

‫ﺑﻌﺪھﺎ ﺗﻘﻮم ب ‪ override‬ﻟﻄﺮﻳﻘﺔ ﻓﻲ اﻟﻔﺌﺔ اﻷم‪ .‬إذا ﻟﻢ ﻳﺠﺪ ال‬
‫‪ compiler‬أي طﺮﻳﻘﺔ ﺑﻨﻔﺲ اﻟﺘﻮﻗﯿﻊ )‪ (method signature‬ﻓﻲ اﻟﻔﺌﺔ ﻷم‬
‫ﻓﺴﯿﺮﺳﻞ رﺳﺎﻟﺔ ﺧﻄﺄ‪.‬‬
‫ﻣﺜﺎل‪ :‬ﻟﻨﻔﺘﺮض اﻟﻔﺌﺔ اﻟﺘﺎﻟﯿﺔ‪ ،‬واﻟﺘﻲ ﺗﻌﻤﻞ ‪ override‬ﻟﻠﻄﺮﻳﻘﺔ ‪toString‬‬
‫اﻟﻤﻮﺟﻮدة ﻓﻲ اﻟﻔﺌﺔ ‪ .Object‬ﺳﻨﻘﻮم ﻋﻤﺪا ﺑﻜﺘﺎﺑﺔ ال "‪ "S‬اﻟﻤﻮﺟﻮدة ﻓﻲ‬
‫‪ toString‬ب ‪ lower case‬ﺑﺪل ‪ ،upper case‬وﻧﺮى ﻣﺎ اﻟﻨﺘﯿﺠﺔ‪.‬‬

‫‪‬‬ ‫{ ‪public class TestOverride‬‬

‫‪‬‬ ‫‪@Override‬‬

‫‪‬‬ ‫{ )(‪public String tostring‬‬

‫‪‬‬ ‫;"‪return "Nothing special‬‬

‫‪‬‬ ‫}‬

‫‪٦٤‬‬
 }

‫ ﻳﻄﺒﻊ رﺳﺎﻟﺔ اﻟﺨﻄﺄ‬compiler ‫ ﻓﺈن ال‬،compilation ‫ﻋﻨﺪ ﻋﻤﻞ ال‬

:‫اﻟﺘﺎﻟﯿﺔ‬

TestOverride.java:2: method does not override or implement a

method from a supertype

Override@

error ١

‫ إﻻ أﻧﻪ ﻳﻨﺼﺢ‬،‫ اﺧﺘﯿﺎري‬Override@ ‫ﻣﻊ أن اﺳﺘﻌﻤﺎل اﻟﺤﺎﺷﯿﺔ‬

،‫ ﺣﺘﻰ ﻻ ﻧﻘﻮم ﺳﮫﻮا ﺑﺈﻧﺸﺎء طﺮﻳﻘﺔ ﺟﺪﻳﺪة وﻣﺴﺘﻘﻠﺔ‬،‫ﺑﺎﺳﺘﻌﻤﺎﻟﮫﺎ داﺋﻤﺎ‬
‫ ﻟﻄﺮﻳﻘﺔ ﻣﻮﺟﻮدة ﻓﻲ اﻟﻔﺌﺔ‬override ‫ﻓﻲ اﻟﻮﻗﺖ اﻟﺬي ﻧﻈﻦ أﻧﻨﺎ ﻗﻤﻨﺎ ب‬
.‫اﻷم‬

‫ ھﺬه اﻟﺤﺎﺷﯿﺔ ﺗﺸﯿﺮ إﻟﻰ أن اﻟﻄﺮﻳﻘﺔ أﺻﺒﺤﺖ‬:@Deprecated

‫ ﻣﺜﻞ‬compilation ‫ وھﺬا ﻻ ﻳﻨﺘﺞ ﻋﻨﻪ ﺧﻄﺄ ﻓﻲ ال‬،deprecated
.(compiler warning) ‫ ﻟﻜﻦ ﻓﻘﻂ إﻧﺬار‬،Override@
‫ ﻟﻠﻜﻮد اﻟﺘﺎﻟﻲ‬compilation ‫ ﻋﻨﺪﻣﺎ ﻧﻘﻮم ﺑﺎل‬،‫ﻣﺜﻼ‬

 public class TestDeprecated {

 public TestDeprecated() {

 DeprecatedCode d = new DeprecatedCode();

 d.someMethod();

 }

 }

٦٥
 class DeprecatedCode {

 @Deprecated

 public void someMethod() {

 System.out.println("I am so deprecated!!");

 }

 }

:compiler ‫ﻓﺴﻨﺤﺼﻞ ﻋﻠﻰ اﻟﺮﺳﺎﻟﺔ اﻟﺘﺎﻟﯿﺔ ﻣﻦ ال‬

.Note: TestDeprecated.java uses or overrides a deprecated API

Note: Recompile with -Xlint:deprecation for details

.
Xlint- ‫وﻋﻨﺪ إﺿﺎﻓﺔ اﻟﺨﯿﺎر‬

javac -Xlint TestDeprecated.java $

TestDeprecated.java:4: warning: [deprecation] someMethod()

in DeprecatedCode has been deprecated

‫)(؛‬d.someMethod

warning ١

‫ ﺗﻘﻮم ھﺬه اﻟﺤﺎﺷﯿﺔ ﺑﺈﻟﻐﺎء ﻛﻞ اﻹﻧﺬارات اﻟﺨﺎﺻﺔ‬:@SuppressWarnings

‫ ﻣﺜﻼ‬.compiler‫ﺑﺎل‬

٦٦
 public class TestSupressWarnings {

 public TestSupressWarnings() {

 java.util.List<String> list = new java.util.ArrayList();

 }

 }

‫ ﻧﺘﯿﺠﺔ ھﺬا اﻟﺴﻄﺮ‬unchecked ‫ھﺬا اﻟﻜﻮد ﻳﻌﻄﯿﻨﺎ إﻧﺬارا ﻣﻦ ﻧﻮع‬

java.util.List<String> list = new java.util.ArrayList();

‫ ﻳﻜﻔﻲ إﺿﺎﻓﺔ‬،‫ إذا ﻛﻨﺎ ﻣﺘﺄﻛﺪﻳﻦ ﻣﻤﺎ ﻧﻌﻤﻞ وأردﻧﺎ إزاﻟﺔ اﻹﻧﺬار‬،
@SuppressWarnings
compilation‫ وﺳﺘﺘﻢ ﻋﻤﻠﯿﺔ ال‬،‫وﺗﺤﺪﻳﺪ ﻧﻮع اﻹﻧﺬار اﻟﺬي ﻧﺮﻳﺪ إزاﻟﺘﻪ‬
:‫ﺑﺪون أي إﻧﺬار‬

public class TestSupressWarnings {

@SuppressWarnings("unchecked")

public TestSupressWarnings() {

java.util.List<String> list = new java.util.ArrayList();

،‫ ﻟﯿﺴﺖ ﻓﻲ ﺗﻠﻚ اﻟﻤﺘﺎﺣﺔ ﻣﻦ طﺮف اﻟﺠﺎﻓﺎ‬Annotations ‫اﻟﻘﻮة اﻟﺤﻘﯿﻘﺔ ﻟﻞ‬

..‫ﻟﻜﻦ ﻓﻲ ﺗﻠﻚ اﻟﺘﻲ ﻳﻤﻜﻦ ﻟﻠﻤﺒﺮﻣﺞ ﻛﺘﺎﺑﺘﮫﺎ‬

٦٧
 ‫س ‪ :٧٠‬ﻛﯾﻔﯾﺔ ﺑرﻣﺟﺔ ﺣواﺷﻲ ﺟدﯾدة ؟‬

‫طﺮﻳﻘﺔ ﺻﯿﺎﻏﺔ اﻟﺤﺎﺷﯿﺔ ﺗﻜﻮن ﻋﺎدة ﻛﺎﻟﺘﺎﻟﻲ‬

‫‪//meta-annotations‬‬

‫{ ‪public @interface AnnotationName‬‬

‫‪//Annotation attributes‬‬

‫}‬

‫ﺣﯿﺚ ‪ AnnotationName‬ھﻮ إﺳﻢ اﻟﺬي ﻧﺮﻳﺪ إﻋﻄﺎءه ﻟﻠﺤﺎﺷﯿﺔ‪.‬‬

‫ال ‪meta-annotations‬‬

‫ال ‪ meta-annotations‬ھﻲ ﺣواﺷﻲ ﺗﻌطﻲ ﻣﻌﻠوﻣﺎت ﻋن اﻟﺣﺎﺷﯾﺔ اﻟﺗﻲ ﻧﺣن ﺑﺻدد ﻛﺗﺎﺑﺗﮭﺎ‬
‫)‪.(annotating the annotation‬‬

‫اﻟﻔرق ﺑﯾﻧﮭﺎ وﺑﯾن اﻟﺣواﺷﻲ اﻟﻣﻌﯾﺎرﯾﺔ اﻟﺗﻲ ﺗﻛﻠﻣﻧﺎ ﻋﻧﮭﺎ ﺳﺎﺑﻘﺎ ) ‪Override, @Deprecated,‬‬
‫‪ (@@SuppressWarnings‬ھو أن اﻟﺣواﺷﻲ اﻟﻣﻌﯾﺎرﯾﺔ ﺗﺻف اﻟﻛود‪ ،‬ﺑﯾﻧﻣﺎ ال ‪meta-‬‬
‫‪ annotations‬ﺗﺻف اﻟﺣواﺷﻲ ﻓﻘط‪ ،‬وﻻ ﺗﺳﺗﻌﻣل ﻟوﺻف اﻟﻛود‪.‬‬

‫ﯾوﺟد أرﺑﻊ ‪ ،meta-annotations‬وھﻲ ﻛﺎﻟﺗﺎﻟﻲ‬

‫‪@Target, @Retention, @Inherit, @Documented‬‬

‫‪٦٨‬‬
 :‫ وﯾﻣﻛن أن ﻧﻣرر ﻟﮭﺎ اﻟﻘﯾم اﻟﺗﺎﻟﯾﺔ‬،‫ ﺗﺣدد ﻣﻛﺎن ﺗواﺟد اﻟﺣﺎﺷﯾﺔ‬:@Target

.constructor‫ ﯾﻣﻛن ﺗطﺑﯾﻘﮭﺎ ﻋﻠﻰ ال‬:ElementType.CONSTRUCTOR

.‫ ﯾﻣﻛن ﺗطﺑﯾﻘﮭﺎ ﻋﻠﻰ اﻟﺣﻘول‬:ElementType.FIELD
.‫ ﯾﻣﻛن ﺗطﺑﯾﻘﮭﺎ ﻋﻠﻰ اﻟﻣﺗﻐﯾرات اﻟﻣﺣﻠﯾﺔ‬:ElementType.LOCAL_VARIABLE
.‫ ﯾﻣﻛن ﺗطﺑﯾﻘﮭﺎ ﻋﻠﻰ ﺗﻌرﯾف اﻟطرق‬:ElementType.METHOD
.‫ ﯾﻣﻛن ﺗطﺑﯾﻘﮭﺎ ﻋﻠﻰ ﺗﻌرﯾف اﻟﺣزﻣﺔ‬:ElementType.PACKAGE
‫ ﯾﻣﻛن ﺗطﺑﯾﻘﮭﺎ ﻋﻠﻰ اﻟﻣدﺧﻼت اﻟﺧﺎﺻﺔ ﺑطرﯾﻘﺔ أو‬:ElementType.PARAMETER
.constructor
.enum ‫ ﺣﺎﺷﯾﺔ أو‬،‫ واﺟﮭﺔ‬،‫ ﯾﻣﻛن ﺗطﺑﯾﻘﮭﺎ ﻋﻠﻰ ﻓﺋﺔ‬:ElementType.TYPE

:‫ ﺳﯾﻛون ﺷﻛﻠﮭﺎ ﻛﺎﻟﺗﺎﻟﻲ‬،‫ ﻓﻘط‬constructor ‫ﻣﺛﻼ ﻟو أردﻧﺎ ﻛﺗﺎﺑﺔ ﺣﺎﺷﯾﺔ ﺧﺎﺻﺔ ﺑﺎل‬

@Target(ElementType.CONSTRUCTOR)

public @interface ConstructorAnnotation {

:‫ واﻟﻄﺮق ﻣﻌﺎ‬constructor ‫وﻓﻲ ﺣﺎﻟﺔ أردﻧﺎ أن ﺗﻜﻮن اﻟﺤﺎﺷﯿﺔ ﺧﺎﺻﺔ ﺑﺎل‬

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD})

public @interface ConstructorAnnotation {

٦٩
‫ﻋﻨﺪﻣﺎ ﻻ ﻧﺤﺪد@‪ ، Target‬ﻓﮫﺬا ﻳﻌﻨﻲ أﻧﻪ ﺳﯿﺘﻢ ﺗﻄﺒﯿﻖ اﻟﺤﺎﺷﯿﺔ ﻋﻠﻰ ﺟﻤﯿﻊ‬
‫اﻟﻌﻨﺎﺻﺮ اﻟﺘﻲ ﺗﻢ ذﻛﺮھﺎ ﻓﻲ اﻷﻋﻠﻰ ‪.‬‬

‫‪ :@Retention‬ھذه ال ‪ meta-annotation‬ﺗﻘوم ﺑﺗﺣدﯾد ﻣدى )‪ (scope‬اﻟﺣﺎﺷﯾﺔ‪ ،‬وھﻲ ﺗﻘﺑل‬

‫اﻟﻘﯾم اﻟﺗﺎﻟﯾﺔ‪:‬‬

‫‪ :RetentionPolicy.SOURCE‬ﻻ ﯾﺗم ﺗﺧزﯾن اﻟﺣﺎﺷﯾﺔ ﻓﻲ اﻟﻣﻠﻔﺎت ‪ ،class.‬وﺑﺎﻟﺗﺎﻟﻲ ﯾﻣﻛن‬

‫اﻟوﺻول إﻟﯾﮭﺎ ﻓﻘط ﻣن طرف اﻷدوات اﻟﺗﻲ ﺗﺳﺗﻌﻣل اﻟﻣﻠف اﻟﻣﺻدري )‪،compiler, javadoc‬‬
‫‪ .(...‬ﻣﺛﻼ‬
‫‪.@Override, @SuppressWarnings‬‬
‫‪ :RetentionPolicy.CLASS‬ﯾﺗم ﺗﺧزﯾن اﻟﺣﺎﺷﯾﺔ ﻓﻲ اﻟﻣﻠف ‪ ،class.‬ﻟﻛن ﯾﺗم إﻟﻐﺎﺋﮭﺎ ﻣن طرف‬
‫ال ‪ Virtual Machine‬ﻋﺗد ﺗﺷﻐﯾل اﻟﺑرﻧﺎﻣﺞ‪.‬‬
‫‪ :RetentionPolicy.RUNTIME‬ﯾﺗم ﺗﺧزﯾن اﻟﺣﺎﺷﯾﺔ ﻓﻲ اﻟﻣﻠف ‪ ،class.‬وﻻ ﯾﺗم إﻟﻐﺎﺋﮭﺎ ﻣن‬
‫طرف ال ‪ Virtual Machine‬ﻋﺗد ﺗﺷﻐﯾل اﻟﺑرﻧﺎﻣﺞ‪ ،‬وﺑﺎﻟﺗﺎﻟﻲ ﯾﻣﻛن اﻟوﺻول إﻟﯾﮭﺎ ﺑﺎﺳﺗﻌﻣﺎل‬
‫ال‪.reflection‬‬
‫ﻣﺛﺎل‪:‬‬

‫)‪@Target(ElementType.CONSTRUCTOR‬‬

‫)‪@Retention(RetentionPolicy.SOURCE‬‬

‫}{ ‪public @interface ConstructorAnnotation‬‬

‫‪ :@Inherit‬ﺗﺷﯾر إﻟﻰ أن ھذه اﻟﺣﺎﺷﯾﺔ ﯾﻣﻛن أن ﺗرﺛﮭﺎ اﻟﻔﺋﺎت اﻟﻔرﻋﯾﺔ )‪ (subclasses‬ﻣن اﻟﻔﺋﺔ‬
‫اﻟﺗﻲ ﺗم ﺗطﺑﯾﻖ اﻟﺣﺎﺷﯾﺔ ﻋﻠﯾﮭﺎ‪ .‬اﻟﺳﻠوك اﻹﻓﺗراﺿﻲ ھو ﻋدم اﻟﺗورﯾث‪.‬‬
‫‪ :@Documented‬ﯾﻘول ﻟل ‪ javadoc‬ﺑﺈظﮭﺎر ھذه اﻟﺣﺎﺷﯾﺔ ﻓﻲ اﻟﺗوﺛﯾﻖ اﻟذي ﺳﯾﺗم ﺗوﻟﯾده‪.‬‬

‫‪٧٠‬‬
 ‫ﺧﺻﺎﺋص اﻟﺣﺎﺷﯾﺔ‪:‬‬

‫ﯾﻣﻛن أن ﺗﻛون اﻟﺣﺎﺷﯾﺔ ﺧﺎﻟﯾﺔ ﻣن أي ﺧﺎﺻﯾﺔ‪ ،‬وﻓﻲ ھذه اﻟﺣﺎﻟﺔ ﺗﺳﻣﻰ ‪.Markup Annotation‬‬
‫ﻣﺛﻼ‪:‬‬

‫{ ‪public @interface AMarkupAnnotation‬‬

‫}‬

‫أو ﯾﻣﻛن أن ﺗﺣﺗوي ﻋﻠﻰ واﺣدة أو ﻋدة ﺧﺻﺎﺋص‪ .‬ھذه اﻟﺧﺻﺎﺋص ﺗﻛﺗب ﻋﻠﻰ ﺷﻛل طرق‬
‫)‪ (method‬ﻓﺎرﻏﺔ‪.‬‬

‫ﻛل ﺧﺎﺻﯾﺔ ﯾﻣﻛن أن ﺗﺗوﻓر ﻋﻠﻰ ﻗﯾﻣﺔ اﻓﺗراﺿﯾﺔ‪ .‬ﻗﯾﻣﺔ ھذه اﻟﺧﺻﺎﺋص ﯾﺟب أن ﺗﻛون ﻣن أﺣد ھذه‬
‫اﻷﺻﻧﺎف ﻓﻘط‪:‬‬

‫اﻷﺻﻧﺎف اﻟﺑداﺋﯾﺔ )‪.(primitive types‬‬

‫‪String‬‬
‫‪java.lang.Class‬‬
‫‪enum‬‬
‫‪java.lang.annotation.Annotation‬‬
‫ﻣﺻﻔوﻓﺔ ﻣﻛوﻧﺔ ﻣن أﺣد اﻷﺻﻧﺎف اﻟﺳﺎﺑﻘﺔ‪.‬‬
‫ﻳﺘﻢ ﺗﻌﺮﻳﻒ ﺧﺎﺻﯿﺔ اﻟﺤﺎﺷﯿﺔ ﻛﺎﻟﺘﺎﻟﻲ ‪:‬‬

‫{ ‪public @interface AnAnnotation‬‬

‫‪.‬ﺧﺎﺻﯿﺔ ﺑﺪون ﻗﯿﻤﺔ اﻓﺘﺮاﺿﯿﺔ‪//‬‬

‫;)(‪int id‬‬

‫‪٧١‬‬
 //‫ﺧﺎﺻﯿﺔ ﺗﻤﺘﻠﻚ ﻗﯿﻤﺔ اﻓﺘﺮاﺿﯿﺔ‬.

String description() default "This is an annotation for testing";

‫ ﻧﻘﻮم ﺑﺘﺤﺪﻳﺪ ﻗﯿﻤﺔ اﻟﺨﺼﺎﺋﺺ ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‬،‫وﻋﻨﺪ اﺳﺘﻌﻤﺎل اﻟﺤﺎﺷﯿﺔ‬

@AnAnnotation(id=1)

public class SomeClass {

//...

‫أو‬

@AnAnnotation(id=1,description="non default description")

public class SomeClass {

//...

‫( ؟‬Annotation Processing) ‫ ﻛﯾﻔﯾﺔ ﻣﻌﺎﻟﺟﺔ اﻟﺣواﺷﻲ‬: ٧١ ‫س‬

٧٢
 ‫ﻣﻌﺎﻟﺟﺔ اﻟﺣواﺷﻲ ﯾﻣﻛن أن ﺗﺗم ﺑطرﯾﻘﺗﯾن‪ :‬ﺑﺎﺳﺗﻌﻣﺎل ال ‪ reflection‬أو ﺑﺎﺳﺗﻌﻣﺎل اﻵداة ‪.apt‬‬

‫اﺳﺗﻌﻣﺎل ال ‪reflection‬‬

‫اﻟﺣواﺷﻲ اﻟﺗﻲ ﯾﻣﻛن ﻣﻌﺎﻟﺟﺗﮭﺎ ﺑﺎﺳﺗﻌﻣﺎل ال‪ reflection‬ھﻲ ﺗﻠك اﻟﺗﻲ ﯾﺗم ﺣﻔظﮭﺎ إﻟﻰ وﻗت‬
‫اﻟﺗﺷﻐﯾل‪ :‬أي أﻧﻧﺎ أﻋطﯾﻧﺎ اﻟﻘﯾﻣﺔ ‪ RetentionPolicy.RUNTIME‬إﻟﻰ ‪.@Retention‬‬

‫ﻣﻌﺎﻟﺟﺔ اﻟﺣواﺷﻲ ﺑﺎﺳﺗﻌﻣﺎل ال‪ reflection‬ﺗﻌﺗﻣد ﻋﻠﻰ اﻟواﺟﮭﺔ‬

‫‪.java.lang.reflect.AnnotatedElement‬‬
‫اﻟﻔﺋﺎت اﻟﺗﺎﻟﯾﺔ ھﻲ اﻟﺗﻲ ﺗﻘوم ﺑﺗطﺑﯾﻖ ھذه اﻟواﺟﮭﺔ‪Class, Constructor, Field, Method, :‬‬
‫‪. Package‬‬

‫اﻟواﺟﮭﺔ ‪ AnnotatedElement‬ﺗ ُﻌﻠن أرﺑﻊ طرق‪:‬‬

‫)‪public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass‬‬

‫ھذه اﻟطرﯾﻘﺔ ﺗﻌﯾد ‪ true‬إذا ﻛﺎﻧت اﻟﺣﺎﺷﯾﺔ اﻟﻣُﻣَرﱠ رة ﻟﮭﺎ )اﻟﻣﻌطﻰ ‪ (annotationClass‬ﻣُطَﺑﻘﺔ‬
‫ﻋﻠﻰ اﻟﻌﻧﺻر اﻟذي ﯾﻧﺎدي ﻋﻠﻰ ھذه اﻟطرﯾﻘﺔ )أﻗﺻد ﺑﺎﻟﻌﻧﺻر‪ ،‬إﻣﺎ ﻓﺋﺔ‪ ،constructor ،‬ﺣﻘل‪،‬‬
‫طرﯾﻘﺔ أو ﺣزﻣﺔ(‪ ،‬و ‪ false‬إن ﻟم ﺗﻛن اﻟﺣﺎﺷﯾﺔ ﻣوﺟودة‪ .‬ھذه اﻟطرﯾﻘﺔ ﻣﻔﯾدة ﺧﺎﺻﺔ ﺑﺎﻟﻧﺳﺑﺔ ﻟل‬
‫‪. marker annotations‬‬

‫)‪<T extends Annotation> T getAnnotation(Class<T> annotationClass‬‬

‫‪٧٣‬‬
 ‫ھذه اﻟطرﯾﻘﺔ ﺗﻧﺗظر ﻧوع اﻟﺣﺎﺷﯾﺔ اﻟﺗﻲ ﻧرﯾد اﻟﺣﺻول ﻋﻠﯾﮭﺎ‪ ،‬ﺛم ﺗﻌﯾد ﻟﻧﺎ اﻟﺣﺎﺷﯾﺔ إذا ﻛﺎﻧت‬
‫ﻣوﺟودة‪ ،‬أو ‪ null‬ﻓﻲ اﻟﺣﺎﻟﺔ اﻟﻣﻌﺎﻛﺳﺔ‪.‬‬

‫)(‪Annotation[] getAnnotations‬‬

‫ﺗﻌﯾد ھذه اﻟطرﯾﻘﺔ ﻣﺟﻣوع اﻟﺣواﺷﻲ اﻟﻣوﺟودة‪ ،‬ﻋﻠﻰ ﺷﻛل ﻣﺻﻔوﻓﺔ‪ .‬إن ﻟم ﯾﻛن ھﻧﺎك أي ﺣﺎﺷﯾﺔ‪،‬‬
‫ﻓﺈن اﻟطرﯾﻘﺔ ﺗﻌﯾد ﻣﺻﻔوﻓﺔ ﻓﺎرﻏﺔ‪.‬‬

‫)(‪Annotation[] getDeclaredAnnotations‬‬

‫ﺗﻌﯾد ھذه اﻟطرﯾﻘﺔ ﻣﺟﻣوع اﻟﺣواﺷﻲ اﻟﻣوﺟودة ﻓﻲ اﻟﻌﻧﺻر‪ ،‬ﻣﻊ اﺳﺗﺛﻧﺎء اﻟﺣواﺷﻲ اﻟﻣوروﺛﺔ ﻣن‬
‫اﻟﻔﺋﺔ اﻷم‪.‬‬

‫ﻣﺛﺎل‪.‬‬

‫ﻟﻧﻔﺗرض أﻧﻧﺎ ﻧﻣﻠك ﻣﺟﻣوﻋﺔ ﻣن ال ‪ ،JavaBeans‬وﻧرﯾد إﻧﺷﺎء ﺟداول ﻓﻲ ﻗواﻋد ﻣطﺎﺑﻘﺔ ﻟﮭﺎ ﻓﻲ‬
‫ﻗﺎﻋدة اﻟﺑﯾﺎﻧﺎت‪.‬‬

‫أوﻻ‪ ،‬ﻧﻛﺗب اﻟﺣﺎﺷﯾﺔ ‪.TableBean‬‬

‫ﻗﻠﻧﺎ ﺳﺎﺑﻘﺎ أن ال‪ reflection‬ﺗﺳﺗﻌﻣل ﻓﻘط ﺑﺎﻟﻧﺳﺑﺔ ﻟﻠﺣواﺷﻲ اﻟﺗﻲ ﻧﻌطﻲ ﻓﯾﮭﺎ اﻟﻘﯾﻣﺔ‬
‫‪ RetentionPolicy.RUNTIME‬إﻟﻰ ‪.@Retention‬‬
‫أﯾﺿﺎ‪ ،‬ھذه اﻟﺣﺎﺷﯾﺔ ﺳﺗطﺑﻖ ﻓﻘط ﻋﻠﻰ ‪ ،JavaBeans‬أي اﻟﻔﺋﺎت‪ ،‬وﺑﺎﻟﺗﺎﻟﻲ ﺳﻧﻌطﻲ اﻟﻘﯾﻣﺔ‬
‫‪ ElementType.TYPE‬إﻟﻰ ‪.@Target‬‬
‫اﻟﺣﺎﺷﯾﺔ ﻓﺎرﻏﺔ‪ ،‬أي أﻧﮭﺎ ‪.marker annotation‬‬

‫‪٧٤‬‬
import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.TYPE)

public @interface TableBean {

.‫اﻵن ﺳﻧﻛﺗب اﻟﺣواﺷﻲ اﻟﺧﺎﺻﺔ ﺑﺎﻟﺣﻘول‬

‫ ﻛل ﻋﻣود ﻓﻲ اﻟﺟدول ﻟﮫ ﻋدة ﺧﺻﺎﺋص‬.‫ ﺳﯾﻣﺛل ﻋﻣودا ﻓﻲ اﻟﺟدول‬JavaBean‫ﻛل ﺣﻘل ﻓﻲ ال‬
‫( ﻟﻛن ﺳﻧﻛﺗﻔﻲ ﻓﻲ‬... primary key, foreign key, unique ،NULL, NOTNULL ،‫)اﻟﻧوع‬
.‫اﻟﻣﺛﺎل ﺑﺗﺣدﯾد اﻟﻧوع ﻓﻘط‬

‫ ﺣﯾث ﻟﺳﻧﺎ ﺑﺣﺎﺟﺔ‬،‫ ﻓﺎرﻏﺔ أﯾﺿﺎ‬Int ‫ اﻟﺣﺎﺷﯾﺔ‬.VarChar ‫ و‬Int ،‫ﺳﻧﻛﺗب ﺣﺎﺷﯾﺗﯾن ﻟﻧوﻋﯾن ﻓﻘط‬
‫ وھﻲ ﺗﻣﺛل طول‬،length ‫ ﻓﺗﻣﺗﻠك اﻟﺧﺎﺻﯾﺔ‬VarChar ‫ أﻣﺎ اﻟﺣﺎﺷﯾﺔ‬،‫ﻷي ﻣﻌﻠوﻣﺎت ﺗﺧص اﻟﺣﻘل‬
.‫اﻟﻧص‬
.RetentionPolicy.RUNTIME ‫ أي‬،‫@ ﻟﮭﺎ ﻧﻔس ﻗﯾﻣﺔ اﻟﺣﺎﺷﯾﺔ اﻟﺳﺎﺑﻘﺔ‬Retention ،‫طﺑﻌﺎ‬
‫ أي أن اﻟﺣواﺷﻲ ﺗﻧطﺑﻖ ﻋﻠﻰ اﻟﺣﻘول‬،ElementType.FIELD ‫ ﻓﺳﺗﻛون ﻗﯾﻣﺗﮭﺎ‬،@Target ‫أﻣﺎ‬
.‫ﻓﻘط‬

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

٧٥
import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.FIELD)

public @interface VarChar {

int length() default 20;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.FIELD)

public @interface Int {

.‫اﻵن ﺳﻧﻛﺗب اﻟﻔﺋﺔ اﻟﺗﻲ ﺳﺗﻘوم ﺑﻣﻌﺎﻟﺟﺔ ھذه اﻟﺣواﺷﻲ‬

.‫ﻣﺑدأ اﻟﻣُﻌﺎﻟﺞ ﺑﺳﯾط‬

٧٦
 .Class ‫أوﻻ ﻧﻌطﯾﮫ ﻣﺻﻔوﻓﺔ ﻣن اﻟﻛﺎﺋﻧﺎت ﻣن ﻓﺋﺔ‬
‫( ﻟﻣﻌرﻓﺔ إذا‬isAnnotationPresent(TableBean.class ‫ﯾﻘوم اﻟﻣﻌﺎﻟﺞ ﺑﺎﻟﻣﻧﺎداة ﻋﻠﻰ اﻟطرﯾﻘﺔ‬
.@TableBean ‫ﻛﺎﻧت اﻟﻔﺋﺔ ﺗﺣﺗوي ﻋﻠﻰ اﻟﺣﺎﺷﯾﺔ‬
.‫ ﻓﺈﻧﮫ ﯾﻘوم ﺑﺎﺳﺗرﺟﺎع ﻛل اﻟﺣﻘول اﻟﻣوﺟودة ﻓﻲ اﻟﻔﺋﺔ‬،‫إذا وﺟد اﻟﺣﺎﺷﯾﺔ‬
@VarChar ‫@ أو‬Int ‫ ﯾﻘوم ﺑﺎﻟﺗﺣﻘﻖ ﻣن وﺟود اﻟﺣواﺷﻲ‬،‫ﺑﺎﻟﻧﺳﺑﺔ ﻟﻛل ﺣﻘل‬
.Hashtable ‫( ﻓﻲ‬VarChar ‫ أو‬Int) ‫ وﻧوﻋﮫ‬،‫ ﻓﺈﻧﮫ ﯾﺧزن إﺳم اﻟﺣﻘل‬،‫إذا ﻛﺎﻧت ﻣوﺟودة‬
. SQL ‫ ﻓﺈن اﻟﻣﻌﺎﻟﺞ ﯾﻧﺷﺊ اﻹﺳﺗﻌﻼم‬،‫ﺑﻌد اﻟﻣرور ﻋﻠﻰ ﻛل ﺣﻘول اﻟﻔﺋﺔ‬

import java.lang.reflect.Field;

import java.util.Hashtable;

public class AnnotationsProcessor {

private Class[] beansToProcess;

public AnnotationsProcessor(Class[] beansToProcess) {

this.beansToProcess = beansToProcess;

public void process() {

for (Class bean : beansToProcess) {

//A Hashtable containing the name of the column, and its

type

Hashtable<String, String> columns = new

Hashtable<String, String>();

٧٧
 //A StringBuilder containing the result query

StringBuilder query = new StringBuilder();

if (isTableBean(bean)) {

//Get the table name

String tableName =
bean.getSimpleName().toLowerCase();

//Get all the fields

Field[] fields = bean.getDeclaredFields();

for (Field f : fields) {

if (isVarChar(f)) {

//Get the length element from the

annotation

int length =
f.getAnnotation(VarChar.class).length();

columns.put(f.getName(),
"VARCHAR(" + length + ")");

} else if (isInt(f)) {

columns.put(f.getName(), "INT");

query.append("CREATE TABLE " + tableName + "(");

for (String columnName : columns.keySet()) {

query.append(columnName + " " +

columns.get(columnName) + ",");

٧٨
 query.deleteCharAt(query.lastIndexOf(","));

query.append(");");

System.out.println(query.toString());

/*

* Execute the query with JDBC

*/

private boolean isTableBean(Class c) {

return c.isAnnotationPresent(TableBean.class);

private boolean isVarChar(Field f) {

return f.isAnnotationPresent(VarChar.class);

private boolean isInt(Field f) {

return f.isAnnotationPresent(Int.class);

‫ ﺑﺴﯿﻂ‬JavaBeans

٧٩
@TableBean

public class Person {

@VarChar(length=40) private String name;

@Int private int age;

public int getAge() {

return age;

public void setAge(int age) {

this.age = age;

public String getName() {

return name;

public void setName(String name) {

this.name = name;

main ‫ﺛﻢ اﻟـ‬

٨٠
public class Main {

public static void main(String[] args) {

Class[] c = {Person.class};

AnnotationsProcessor proc = new AnnotationsProcessor(c);

proc.process();

.‫ وﻻ ﯾﺟب اﻹﻋﺗﻣﺎد ﻋﻠﯾﮫ ﻟﻠﺣﻛم ﻋﻠﻰ ﻓﺎﺋدة اﻟﺣواﺷﻲ ﻣن ﻋدﻣﮭﺎ‬،‫اﻟﻣﺛﺎل ﺑﺳﯾط ﺟدا‬

Databases
‫( ﺑﺎﻟﺟﺎﻓﺎ ؟‬access)‫ ﻛﯾﻔﯾﺔ رﺑط ﻗﺎﻋدة ﺑﯾﺎﻧﺎت اﻛﺳس‬:٧٢ ‫س‬

‫ او اي ﺑرﻧﺎﻣﺞ آﺧر ﺑﺎﻻﺿﺎﻓﺔ اﻟﻰ ﺑرﻧﺎﻣﺞ اﻻﻛﺳس‬NetBeans ‫اﻟﺷﻐل ﺑﯾﻛون ﻓﻲ ﺑرﻧﺎﻣﺞ‬

٨١
 ‫…‪ .‬ﻧﺑدأ ﻋﻠﻰ ﺑرﻛﺔ ﷲ …‪.‬‬

‫ﻧﻔرض ان ﻋﻧدﻧﺎ ﻗﺎﻋدة ﺑﯾﺎﻧﺎت ﺑﺎﺳم ‪ DB‬وﻓﯾﮭﺎ ﺟدول ﺑﺎﺳم ‪Mouses‬‬

‫اﻵن ﻧﻔﺗﺢ ﻟوﺣﺔ اﻟﺗﺣﻛم ‪ Control Panel‬ﻣن زر أﺑدا‬

‫ﺑﻌد ذﻟك ﻧذھب اﻟﻰ ‪System and Security‬‬

‫ﺛم ﻧﺧﺗﺎر ‪Administrative tools‬‬

‫‪٨٢‬‬
 ‫وﻧﻔﺗﺢ ‪(Data Source (ODBC‬‬

‫ﻧﺿﻐط ﻋﻠﻰ زر ‪ add‬ﻟﻛﻲ ﻧﺿﯾف ﻗﺎﻋدة اﻟﺑﯾﺎﻧﺎت اﻟﻲ اﻟﻧظﺎم ‪ ODBC‬وﯾﺗم اﻟﺗﻌرف ﻋﻠﯾﮭﺎ ﻣن‬
‫ﺧﻼل ‪NetBeans‬‬

‫ﺑﻌد اﻟﺿﻐط ﻋﻠﻰ زر ‪add‬‬

‫ﻧﻘوم ﺑﺎﺧﺗﯾﺎر ‪(Microsoft Access Driver (*.mdb, *accdb‬‬

‫‪٨٣‬‬
‫ﻧﻘوم ﺑﻛﺗﺎﺑﺔ اﺳم ﻗﺎﻋدة اﻟﺑﯾﺎﻧﺎت واﻟذي ﺳﯾﻛون ﻛراﺑط ﻟﻘﺎﻋدة اﻟﺑﯾﺎﻧﺎت )اﻻﺳم ﯾﻛون ﻣﺣﻔوظ‬ ‫‪-١‬‬
‫ﻓﻲ ‪ ODBC‬وﻻ ﯾﺷﺗرط ان ﯾﻛون ﻧﻔس اﺳم ﻗﺎﻋدة اﻟﺑﯾﺎﻧﺎت اﻻﺻﻠﻲ(‬

‫ﻧﻘوم ﺑﺗﺣدﯾد ﻣﻛﺎن ﻗﺎﻋدة اﻟﺑﯾﺎﻧﺎت‬ ‫‪-٢‬‬

‫ﺑﻌد ذﻟك ﻧﺿﻐط ‪ok‬‬

‫اﻻن ﺗم اﺿﺎﻓﺔ ﻗﺎﻋدة اﻟﺑﯾﺎﻧﺎت اﻟﻰ ‪ODBC‬‬

‫…………………………………………‪..‬‬

‫ﻧذھب اﻟﻰ اﻟﺑرﻧﺎﻣﺞ اﻟذي ﻧرﯾد ﺗوﺻﯾﻠﮫ ﺑﻘﺎﻋدة اﻟﺑﯾﺎﻧﺎت‬

‫‪٨٤‬‬
 ‫اوﻻ ‪ :‬طرﯾﻘﺔ اﺳﺗﯾراد ﺟدول واظﮭﺎره ﻛﺎﻣﻼ‬

‫ﻧﻘوم ﺑﺗﺟﮭﯾز اﻟﻔرﯾم اﻟﺗﺎﻟﻲ‬

‫ﻧﻧﺗﻘل اﻟﻰ وﺿﻊ‪Source‬‬

‫وﻧﻘوم ﺑﺈﺳﺗدﻋﺎء اﻟﻣﻛﺗﺑﺔ اﻟﺧﺎﺻﺔ ﺑﺎﻟﺗﻌﺎﻣل ﻣﻊ ‪SQL‬‬

‫‪*Import java.sql‬؛‬

‫‪٨٥‬‬
 ‫ﺑﻌد ذﻟك ﻧﻘوم ﺑﺎﺿﺎﻓﺔ اﻟداﻟﺔ )‪ ( Method‬اﻟﺗﺎﻟﯾﺔ ‪:‬‬

‫ﺳوف ﻧﻘوم ﺑﺷرح ﻛل ﺳطر ‪:‬‬

‫‪ – ١٩‬ﻧﻘوم ﺑﺗﻌرﯾف اﻟﻣﺗﻐﯾر ‪ con‬ﻟﯾﻘوم ﺑرﺑط ﻗﺎﻋدة اﻟﺑﯾﺎﻧﺎت اﻟﺗﻲ اﻧﺷﺄﻧﺎھﺎ‬

‫‪ -٢٠‬ﻧﻘوم ﺑﺗﻌرﯾف اﻟﻣﺗﻐﯾر ‪ sql‬ﻟﯾﻘوم ﺑﺗﻧﻔﯾذ ﺟﻣل اﻻﺳﺗﻌﻼم‬

‫‪ – ٢١‬ﻧﻘوم ﺑﺗﻌرﯾف اﻟﻣﺗﻐﯾر ‪ search‬وھذا ﺳﯾﺗم ﺷرﺣﮫ ﻻﺣﻘﺎ‬

‫‪ -٢٢‬ﻧﻌرف اﻟﻣﺗﻐﯾر ‪ rs‬ﻟﺣﻔظ ﻧﺗﺎﯾﺞ اﻻﺳﺗﻌﻼم )اﻟﺑﯾﺎﻧﺎت (‬

‫‪ -٢٥‬ﻧﻘوم ﺑﺎﻧﺷﺎء اﻟداﻟﺔ ‪connDB‬‬

‫‪٨٦‬‬
 ‫‪ – ٢٦‬ﻧﺳﺗﺧدم ‪ try – catch‬ﻟﻠﺗﺣذﯾر ﻣن وﺟود اي ﺧطﺄ‬

‫‪ Class -٢٧‬ھﻲ ﻣﻛﺗﺑﺔ ﺧﺎﺻﺔ ﺑﻠﻐﺔ اﻟﺟﺎﻓﺎ و ‪ forName‬ھﻲ ﺧﺎﺻﯾﺔ ﺗﺎﺑﻌﺔ ﻓﻲ اﻟﻛﻼس ﻧﺳﺗﺧدﻣﮭﺎ‬
‫ﻟﺗﻘوم ﺑﺎﺳﺗدﻋﺎء ‪ JBDC‬ﻟﺗﺗم ﻋﻣﻠﯾﺔ رﺑط اﻟﺟﺎﻓﺎ ﺑﻘﺎﻋدة اﻟﺑﯾﺎﻧﺎت‬

‫‪ - ٢٨‬اﻻﺗﺻﺎل ﺑﻘﺎﻋدة اﻟﺑﯾﺎﻧﺎت ﻋن طرﯾﻖ اﻟراﺑط ‪ DB‬اﻟذي اﻧﺷﺄﻧﺎه‬

‫‪ -٢٩‬اﻧﺷﺎء ﺟﻣل اﻻﺳﺗﻌﻼم وﺗطﺑﯾﻘﮭﺎ داﺧل اﻟﻣﺷروع‬

‫‪ -٣٠‬ﺗﻧﻔﯾذ ﺟﻣل اﻻﺳﺗﻌﻼم اﻟﻣطﻠوﺑﺔ‬

‫‪ -٣١‬ﺗﻘوم ﺑﺎﻧﺷﺎء ﻧﺎﻓذة ﻟﻛﻲ ﺗﺗﺄﻛد ان اﻻﺗﺻﺎل ﻗد ﺗم ﺑﻧﺟﺎح‬

‫‪ – ٣٢‬ﻧﻌرف ﻣﺧزن ﻟﻠﺟدول وﺣﯾث ان اﻟﺟدول ﻻ ﯾﺗم ﺗﻌﺑﺋﺗﮫ اﻻ ﻋن طرﯾﻖ ﻣﺻﻔوﻓﮫ واﻟﻣﺻﻔوﻓﺔ‬
‫ﺗﺄﺧذ اﻟﺑﯾﺎﻧﺎت ﻣن ‪ DB‬وﺗﻘوم ﺑﺗﻌﺑﺋﺔ اﻟﺟدول‬

‫‪ -٣٣‬ﻧﺟﻌل اﻟﺟدول ﯾﺄﺧذ ﺑﯾﺎﻧﺎﺗﮫ ﻣن ‪dtm‬‬

‫‪ –٣٥& ٣٤‬ﻧﺿﯾف ﻋﻣودﯾن ف ‪ dtm‬واﻟذي ﺳﯾﻧﻘل اﻟﺑﯾﺎﻧﺎت اﻟﻰ اﻟﺟدول وﻧﺳﻣﻲ اﻻول ‪ID‬‬
‫واﻟﺛﺎﻧﻲ ‪Brand‬‬

‫‪ – ٣٦‬ﺑﻌد ﺟﻠب اﻟﺑﯾﺎﻧﺎت ﻣن ‪ DB‬وﺣﻔظﮭﺎ ﻓﻲ ‪ rs‬اذا ﻛﺎن ھﻧﺎﻟك ﺳطر ﺗﺎﻟﻲ ﻧﻔذ اﻻﺗﻲ‬

‫‪٨٧‬‬
 ‫‪ – ٣٩‬ﯾﻘوم ﺑﺎﻟﺑدأ ﻣن اﻟﺻف اﻻول‬

‫‪ – ٤٤- ٤٠‬ﯾﻘوم ﺑﺈﻧﺷﺎء ﻟوب ﻻدﺧﺎل اﻟﺑﯾﺎﻧﺎت ﻓﻲ ‪dtm‬‬

‫‪ -٤٥‬ﯾﻘوم ﺑﺎﻟرﺟوع اﻟﻰ اﻟﺻف اﻻول‬

‫‪ – ٥٢-٤٧‬اذا ﻛﺎﻧت ‪ DB‬ﺧﺎﻟﯾﺔ ﻓﺳﯾﺗم اﺑﻘﺎء اﻟﺣﻘول اﻟﻣﺣددة ﺧﺎﻟﯾﺔ‬

‫‪ – ٥٥‬ﻓﻲ ﺣﺎل وﺟود ﺧطﺄ ‪ ،‬ﺳﯾﺗم اظﮭﺎر رﺳﺎﻟﺔ ﻣﺑﯾﻧﺔ اﻟﺧطﺄ‬

‫‪ – ٥٦‬اﻟﺧروج ﻣن اﻟﺑرﻧﺎﻣﺞ‬

‫ﻛود اﻟزر ‪Connect‬‬

‫ﻋﻧد اﻟﺿﻐط ﻋﻠﯾﮫ ﯾﺗم اﺳﺗدﻋﺎء اﻟداﻟﺔ ‪ connDB‬وﺑدأ اﻻﺗﺻﺎل ﺑﻘﺎﻋدة اﻟﺑﯾﺎﻧﺎت‬

‫ﻛود اﻟزر ‪Search‬‬

‫‪٨٨‬‬
‫ﻓﻲ ﺣﺎﻟﺔ ان اﻟﻣﺳﺗﺧدم ﯾرﯾد اﻟﺑﺣث ﻓﻲ اﻟﺟدول ﯾﻘوم ﺑﺎﻟﻛﺗﺎﺑﺔ ﻓﻲ اﻟﺣﻘل ‪ JTextField3‬وﺗﻧﻔﯾذ‬
‫اﻟﻣﺗﻐﯾر ‪Search‬‬

‫اﻣﺎ اذا ﻛﺎن اﻟﺣﻘل ﻓﺎرغ ﻓﺈن اﻟﻣﺗﻐﯾر ‪ Search‬ﯾﻛون ﻓﺎرﻏﺎ‬

‫ﻛود اﻟزر >‬

‫ﻟﻌرض اﻟﺻف اﻟﺳﺎﺑﻖ‬

‫‪٨٩‬‬
 ‫ﻛود اﻟزر >>‬

‫ﻟﻌرض آﺧر ﺻف ﻓﻲ اﻟﺟدول‬

‫ﻛود زر <‬

‫ﻟﻌرض اﻟﺻف اﻟﺗﺎﻟﻲ‬

‫ﻛود زر <<‬

‫‪٩٠‬‬
 ‫ﻟﻌرض أول ﻋﻣود ﻓﻲ اﻟﺟدول‬

‫ﻛود زر ‪New‬‬

‫ﻹﺿﺎﻓﺔ ﻋﻣود ﺟدﯾد‬

‫‪٩١‬‬
 ‫ﻛود زر ‪Update‬‬

‫ﻟﻌﻣل ﺗﻐﯾر ﻓﻲ ﺑﯾﺎﻧﺎت ﺻف ﻣن اﻟﺟدول‬

‫‪٩٢‬‬
 ‫ﻛود زر ‪Delete‬‬

‫ﻟﻣﺳﺢ اي ﺻف ﻣن ﺻﻔوف اﻟﺟدول‬

‫‪٩٣‬‬
‫ﺛﺎﻧﯾﺎ ‪ :‬طرﯾﻘﺔ اﺳﺗﯾراد ﻋﻣود ووﺿﻌﮫ ﻣﺣﺗواه ﻓﻲ ﻛوﻣﺑوﺑوﻛس‬

‫ﻧﻘوم ﺑﺗﺟﮭﯾز اﻟﻔرﯾم اﻟﺗﺎﻟﻲ‬

‫وأﺣﺑﺑت ان ﯾﻛون ﺑﺳﯾط‬

‫ﺳﺗﻛون اﻟداﻟﺔ ‪ connDB‬ﺑﮭذه اﻟطرﯾﻘﺔ ‪،،،‬‬

‫‪٩٤‬‬
‫ﻓﻲ ھذه اﻟداﻟﺔ ﻗﻣت ﺑﺗﻐﯾر ﻗﯾﻣﺔ اﻟﻣﺗﻐﯾر ‪ rs‬ﺣﯾث ﺳﯾﻘوم ﺑﺟﻠب ﻓﻘط ﻋﻣود واﺣد ﻓﻘط وھو‬
‫‪BRAND‬‬

‫وﻗﻣت ﺑﺎﺳﺗﺧدام ‪ do – while‬ﻟوب ﻟﺗﻌﺑﺋﺔ اﻟﻛوﻣﺑو ﺑوﻛس‬

‫‪٩٥‬‬
 ‫‪Graphics 2D‬‬

‫س ‪ :٧٣‬ﻛﯾف أرﺳم أﺷﻛﺎل ھﻧدﺳﯾﺔ ﻓﻲ اﻟﺟﺎﻓﺎ؟‬

‫ﻧﻘوم ﺑﺎﻟرﺳم ﻓﻲ أﺣد ﻣﻛوﻧﺎت ‪ Swing‬ﻏﺎﻟﺑﺎ ﻓﻲ ‪ .JPanel‬وﻛل ﻋﻣﻠﯾﺎت اﻟرﺳم ﺗﺗم داﺧل اﻟطرﯾﻘﺔ‬
‫‪.paintComponent‬‬
‫ھذه اﻟطرﯾﻘﺔ ﺗﻧﺗظر ﻛﺎﺋﻧﺎ ﻣن ﻓﺋﺔ ‪ ،Graphics‬ھذا اﻟﻛﺎﺋن ﯾﻣﻛن اﻋﺗﺑﺎره ﻓرﺷﺎة اﻟرﺳم‪ ،‬ﻓﮭو اﻟذي‬
‫ﯾوﻓر ﻟﻧﺎ اﻟطرق اﻟﺗﻲ ﺗﻣﻛﻧﻧﺎ ﻣن اﻟرﺳم وﺗﻐﯾﯾر ﻟون اﻟرﺳم ‪.‬‬

‫ﻣن ﺑﯾن اﻟطرق)اﻟدوال( اﻟﺗﻲ ﺗﺣﺗوي ﻋﯾﮭﺎ اﻟﻔﺋﺔ ‪Graphics‬‬

‫)‪drawRect(int x, int y, int width, int height‬‬

‫ھذه اﻟطرﯾﻘﺔ ﺗرﺳم ﻣﺳﺗطﯾﻼ ﻓﺎرﻏﺎ‪ x .‬و ‪ y‬ﯾﻣﺛﻼن اﻹﺣداﺛﯾﺎت اﻟﺗﻲ ﺳﻧﺑدأ ﻣﻧﮭﺎ اﻟرﺳم‪ width ،‬و‬
‫‪ height‬ﯾﻣﺛﻼن اﻟﻌرض واﻟطول‪.‬‬

‫)‪fillRect(int x, int y, int width, int height‬‬

‫ھذه اﻟطرﯾﻘﺔ ﺗرﺳم ﻣﺳﺗطﯾﻼ ﻣﻣﻠوءً ‪ x .‬و ‪ y‬ﯾﻣﺛﻼن اﻹﺣداﺛﯾﺎت اﻟﺗﻲ ﺳﻧﺑدأ ﻣﻧﮭﺎ اﻟرﺳم‪ width ،‬و‬
‫‪ height‬ﯾﻣﺛﻼن اﻟﻌرض واﻟطول‪.‬‬

‫)‪drawOval(int x, int y, int width, int height‬‬

‫ھذه اﻟطرﯾﻘﺔ ﺗرﺳم داﺋرة ﻓﺎرﻏﺔ‪ x .‬و ‪ y‬ﯾﻣﺛﻼن اﻹﺣداﺛﯾﺎت اﻟﺗﻲ ﺳﻧﺑدأ ﻣﻧﮭﺎ اﻟرﺳم‪ width ،‬و‬
‫‪ height‬ﯾﻣﺛﻼن اﻟﻌرض واﻟطول‪.‬‬

‫)‪fillOval(int x, int y, int width, int height‬‬

‫‪٩٦‬‬
‫ و‬width ،‫ ﯾﻣﺛﻼن اﻹﺣداﺛﯾﺎت اﻟﺗﻲ ﺳﻧﺑدأ ﻣﻧﮭﺎ اﻟرﺳم‬y ‫ و‬x .‫ھذه اﻟطرﯾﻘﺔ ﺗرﺳم داﺋرة ﻣﻣﻠوءة‬
.‫ ﯾﻣﺛﻼن اﻟﻌرض واﻟطول‬height

drawLine(int x1, int y1, int x2, int y2)

‫ ﯾﻣﺛﻼن إﺣداﺛﯾﺎت‬y2 ‫ و‬x2 ،‫ ﯾﻣﺛﻼن إﺣداﺛﯾﺎت ﺑداﯾﺔ اﻟﺧط‬y1 ‫ و‬x1 .‫ھذه اﻟطرﯾﻘﺔ ﺗرﺳم ﺳطرا‬
.‫اﻟﻧﮭﺎﯾﺔ‬

setColor(Color c)

.‫ھذه اﻟطرﯾﻘﺔ ﺗﺣدد اﻟﻠون اﻟذي ﺳﯾﺗم اﺳﺗﻌﻣﺎﻟﮫ ﻓﻲ اﻟرﺳم‬

‫ ﻟﻣﻌرﻓﺔ ﻛل اﻹﻣﻛﺎﻧﯾﺎت اﻟﺗﻲ ﺗﺗﯾﺣﮭﺎ ھذه‬،Graphics ‫ھذه ﻓﻘط ﺑﻌض اﻟطرق اﻟﻣوﺟودة ﻓﻲ اﻟﻔﺋﺔ‬
.Sun ‫ ﯾﻣﻛﻧﻛم ﻣراﺟﻌﺔ ﺗوﺛﯾﻖ‬،‫اﻟﻔﺋﺔ‬
‫ﻣﺛﺎل‬

import java.awt.Color;

import java.awt.Graphics;

import javax.swing.JFrame;

import javax.swing.JPanel;

public class TestPaint {

public static void main(String[] args) {

JFrame frm = new JFrame();

frm.add(new PaintBoard());

frm.setSize(300, 400);

frm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frm.setVisible(true);

٩٧
 }

class PaintBoard extends JPanel {

@Override

protected void paintComponent(Graphics g) {

super.paintComponent(g);

g.drawRect(10, 10, 80, 80);

g.setColor(Color.RED);

g.fillRect(120, 10, 80, 80);

g.setColor(Color.BLUE);

g.drawOval(10, 120, 80, 80);

g.setColor(Color.GREEN);

g.fillOval(120, 120, 80, 80);

g.setColor(Color.BLACK);

g.drawLine(50, 240, 200, 340);

‫واﻟﻨﺘﯿﺠﺔ‬

٩٨
٩٩
 ‫ﻣﺷﺎرﯾﻊ ﺟﺎھزة‬

‫‪ - ٧٤‬ﻋﻤﻞ ﺑﺮﻧﺎﻣﺞ ﺷﺒﯿﮫ ﺑـ "اﻟﺮﺳﺎم"‪ .‬ﯾﻘﻮم اﻟﻤﺴﺘﺨﺪم ﺑﺘﺤﺪﯾﺪ اﻟﻠﻮن واﻟﺸﻜﻞ وﯾﻨﻘﺮ ﻋﻠﻰ‬
‫اﻟﺸﺎﺷﺔ ﻟﯿﺒﺪأ ﺑﺎﻟﺮﺳﻢ ‪ ،‬اﺳﺘﺨﺪام ﺷﺮح ﺗﻘﻨﯿﺎت اﻟﺒﻨﺎء ﻓﻲ اﻟﺼﻒ ﻟﺮﺳﻢ اﻟﺸﻜﻞ اﻟﻤﺤﺪد اﻧﻈﺮ‬
‫‪.‬ﻟﻠﺸﻜﻞ ﻓﻲ اﻷﺳﻔﻞ ‪.‬‬

‫)اﻟﺰر ‪ (CLS‬ﻟﻤﺴﺢ ﻣﻨﻄﻘﺔ ﻋﻤﻞ ‪.‬‬

‫‪CLS C1 C2 C3 C4 C5 C6 C7‬‬

‫‪١٠٠‬‬
 Colors

//Main :

package cgproject_4;

public class CGProject_4 {

public static void main(String[] args) {

Paint P=new Paint();

P.setDefaultCloseOperation(Paint.EXIT_ON_CLOSE);

P.setVisible(true);

//Classe:

package cgproject_4;

import java.awt.Color;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import javax.swing.JButton;

١٠١
import javax.swing.JFrame;

import javax.swing.JPanel;

public class Paint extends JFrame implements ActionListener,MouseListener

private int x1,y1,x2,y2;

private Color c;

private JPanel jpanel;

private JButton
bt1,bt2,bt3,bt4,bt5,bt6,bt7,bt8,bt9,bt10,bt11,bt12,bt13,bt14,bt15,bt16,bt17,bt1
8;

private Graphics2D g;

private int count=0,ch;

private float r,a,b;

Paint()

super("Paint : Hekam");

setSize(900,680);

this.setLayout(null);

bt1=new JButton(){

@Override

١٠٢
protected void paintComponent(Graphics g){

super.paintComponent(g);

Graphics2D g2d = (Graphics2D) g;

g2d.setColor(Color.BLACK);

g2d.drawLine(20,60,60,20);

};

bt1.setLocation(0,0);

bt1.setSize(80,80);

bt1.addActionListener(this);

this.add(bt1);

bt2=new JButton(){

@Override

protected void paintComponent(Graphics g) {

super.paintComponent(g);

Graphics2D g2d = (Graphics2D) g;

g2d.setColor(Color.BLACK);

g2d.drawRect(15,15,50,40);

};

bt2.setLocation(0,80);

١٠٣
bt2.setSize(80,80);

bt2.addActionListener(this);

this.add(bt2);

bt3=new JButton(){

@Override

protected void paintComponent(Graphics g) {

super.paintComponent(g);

Graphics2D g2d = (Graphics2D) g;

g2d.setColor(Color.BLACK);

g2d.drawOval(15,15,50,50);

};

bt3.setLocation(0,160);

bt3.setSize(80,80);

bt3.addActionListener(this);

this.add(bt3);

bt4=new JButton(){

@Override

protected void paintComponent(Graphics g) {

super.paintComponent(g);

Graphics2D g2d = (Graphics2D) g;

١٠٤
 g2d.setColor(Color.BLACK);

g2d.drawOval(10,15,60,50);

};

bt4.setLocation(0,240);

bt4.setSize(80,80);

bt4.addActionListener(this);

this.add(bt4);

bt5=new JButton(){

@Override

protected void paintComponent(Graphics g) {

super.paintComponent(g);

Graphics2D g2d = (Graphics2D) g;

g2d.setColor(Color.BLACK);

g2d.drawLine(40,10,40,65);

};

bt5.setLocation(0,320);

bt5.setSize(80,80);

bt5.addActionListener(this);

this.add(bt5);

bt6=new JButton(){

١٠٥
@Override

protected void paintComponent(Graphics g) {

super.paintComponent(g);

Graphics2D g2d = (Graphics2D) g;

g2d.setColor(Color.BLACK);

g2d.drawLine(10,40,60,40);

};

bt6.setLocation(0,400);

bt6.setSize(80,80);

bt6.addActionListener(this);

this.add(bt6);

bt7=new JButton(){

@Override

protected void paintComponent(Graphics g) {

super.paintComponent(g);

Graphics2D g2d = (Graphics2D) g;

g2d.setColor(Color.BLACK);

g2d.drawRect(15,15,45,45);

};

bt7.setLocation(0,480);

bt7.setSize(80,80);

١٠٦
bt7.addActionListener(this);

this.add(bt7);

bt8=new JButton("CLS");

bt8.setLocation(0,560);

bt8.setSize(80,80);

bt8.addActionListener(this);

this.add(bt8);

bt9=new JButton();

bt9.setBackground(Color.black);

bt9.setLocation(80,560);

bt9.setSize(80,80);

bt9.addActionListener(this);

this.add(bt9);

bt10=new JButton();

bt10.setBackground(Color.red);

bt10.setLocation(160,560);

bt10.setSize(80,80);

bt10.addActionListener(this);

this.add(bt10);

١٠٧
bt11=new JButton();

bt11.setBackground(Color.yellow);

bt11.setLocation(240,560);

bt11.setSize(80,80);

bt11.addActionListener(this);

this.add(bt11);

bt12=new JButton();

bt12.setBackground(Color.orange);

bt12.setLocation(320,560);

bt12.setSize(80,80);

bt12.addActionListener(this);

this.add(bt12);

bt13=new JButton();

bt13.setBackground(Color.green);

bt13.setLocation(400,560);

bt13.setSize(80,80);

bt13.addActionListener(this);

this.add(bt13);

bt14=new JButton();

bt14.setBackground(Color.cyan);

bt14.setLocation(480,560);

bt14.setSize(80,80);

bt14.addActionListener(this);

١٠٨
this.add(bt14);

bt15=new JButton();

bt15.setBackground(Color.magenta);

bt15.setLocation(560,560);

bt15.setSize(80,80);

bt15.addActionListener(this);

this.add(bt15);

bt16=new JButton();

bt16.setBackground(Color.white);

bt16.setLocation(640,560);

bt16.setSize(80,80);

bt16.addActionListener(this);

this.add(bt16);

bt17=new JButton();

bt17.setBackground(Color.darkGray);

bt17.setLocation(720,560);

bt17.setSize(80,80);

bt17.addActionListener(this);

this.add(bt17);

bt18=new JButton("Exit");

bt18.setSize(80,80);

bt18.setLocation(800,560);

١٠٩
 bt18.addActionListener(this);

this.add(bt18);

jpanel=new JPanel();

jpanel.setLocation(80,0);

jpanel.setSize(815,560);

jpanel.setBackground(Color.white);

jpanel.addMouseListener(this);

this.add(jpanel);

public void setColor(Color color){

c =color;

public void BCircle(Graphics g, int xc, int yc, int r){

int x = 0, y = r, s = 3-(2*r);

while(x<=y){

g.drawLine(xc+x, yc+y, xc+x, yc+y);

g.drawLine(xc+x, yc-y, xc+x, yc-y);

g.drawLine(xc-x, yc+y, xc-x, yc+y);

g.drawLine(xc-x, yc-y, xc-x, yc-y);

g.drawLine(xc+y, yc+x, xc+y, yc+x);

١١٠
 g.drawLine(xc+y, yc-x, xc+y, yc-x);

g.drawLine(xc-y, yc+x, xc-y, yc+x);

g.drawLine(xc-y, yc-x, xc-y, yc-x);

if (s<0)

s += 4*x + 6;

else{

s += 4*(x-y) + 10;

y--;

x++;

public void Ellipse(Graphics g,int xc,int yc,int a,int b){

double ct,st;

double xt;

double x,y;

double theta=2.0/(a+b);

ct=Math.cos(theta);

st=Math.sin(theta);

x=0; y=b;

while (y>=0)

١١١
 {

PutPixel(g,(int)Math.round(x+xc),(int)Math.round(yc-y));

PutPixel(g,(int)Math.round(xc-x),(int)Math.round(yc-y));

PutPixel(g,(int)Math.round(xc-x),(int)Math.round(yc+y));

PutPixel(g,(int)Math.round(xc+x),(int)Math.round(yc+y));

xt=x;

x=(x*ct)+(a*1.0/b)*(y*st);

y=(y*ct)-(b*1.0/a)*(x*st);

public void PutPixel(Graphics g,int x,int y){

g.drawLine(x, y, x, y);

@Override

public void actionPerformed(ActionEvent e) {

if(e.getSource()==bt1){

ch=1;

else if(e.getSource()==bt2){

ch=2;

١١٢
}

else if(e.getSource()==bt3){

ch=3;

else if(e.getSource()==bt4){

ch=4;

else if(e.getSource()==bt5){

ch=5;

else if(e.getSource()==bt6){

ch=6;

else if(e.getSource()==bt7){

ch=7;

else if(e.getSource()==bt8){

repaint();

else if(e.getSource()==bt9){

setColor(Color.black);

else if(e.getSource()==bt10){

setColor(Color.red);

else if(e.getSource()==bt11){

١١٣
 setColor(Color.yellow);

else if(e.getSource()==bt12){

setColor(Color.orange);

else if(e.getSource()==bt13){

setColor(Color.green);

else if(e.getSource()==bt14){

setColor(Color.cyan);

else if(e.getSource()==bt15){

setColor(Color.magenta);

else if(e.getSource()==bt16){

setColor(Color.white);

else if(e.getSource()==bt17){

setColor(Color.lightGray);

else if(e.getSource()==bt18)

System.exit(0);

١١٤
@Override

public void mouseClicked(MouseEvent e) {

count++;

if(count==1){

x1=e.getX();

y1=e.getY();

else if(count==2){

x2=e.getX();

y2=e.getY();

paintComponent(g);

@Override

public void mouseEntered(MouseEvent e) {

@Override

public void mouseExited(MouseEvent e) {

١١٥
}

public void mousePressed(MouseEvent e) {

public void mouseReleased(MouseEvent e) {

public void paintComponent(Graphics g) {

g=(Graphics2D) jpanel.getGraphics();

if(ch==1){

g.setColor(c);

g.drawLine(x1, y1, x2, y2);

x1=0;y1=0; x2=0; y2=0;

count=0;

if(ch==2){

if(x1>x2){

int temp ;

temp= x2;

x2 = x1;

x1 = temp;

if(y1>y2){

int temp = y2;

١١٦
 y2 = y1;

y1 = temp;

g.setColor(c);

g.drawRect(x1, y1,x2-x1,y2-y1);

x1=0;y1=0; x2=0; y2=0;

count=0;

if(ch==3){

r=(float) Math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));

g.setColor(c);

BCircle(g,x1,y1,Math.round(r));

x1=0;y1=0; x2=0; y2=0;

count=0;

if(ch==4){

a=(float) Math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));

b=a/2;

g.setColor(c);

Ellipse(g,x1,y1,Math.round(a),Math.round(b));

x1=0;y1=0; x2=0; y2=0;

count=0;

١١٧
 if(ch==5){

g.setColor(c);

g.drawLine(x1, y1, x1, y2);

x1=0;y1=0; x2=0; y2=0;

count=0;

if(ch==6){

g.setColor(c);

g.drawLine(x1, y1, x2, y1);

x1=0;y1=0; x2=0; y2=0;

count=0;

if(ch==7){

if(x1>x2){

int temp ;

temp= x2;

x2 = x1;

x1 = temp;

if(y1>y2){

int temp = y2;

y2 = y1;

y1 = temp;

١١٨
 ‫}‬

‫;)‪g.setColor(c‬‬

‫;))‪g.drawRect(x1, y1,x2-x1,(x2-x1‬‬

‫;‪x1=0;y1=0; x2=0‬‬ ‫;‪y2=0‬‬

‫;‪count=0‬‬

‫}‬

‫}‬

‫}‬

‫‪capture-٧٥‬‬

‫ﻛﯾف ﺗﻌﻣل ﺻوره ﻟﻠﺷﺎﺷﺔ ﻣن اﻟﺑرﻧﺎﻣﺞ‬

‫ﻋﻠﻣﺎ ان اﻟﺻورة ﺳوف ﺗﺣﺗﻔظ ﻓﻲ ﻣﺳﺎر اﻟﺑرﻧﺎﻣﺞ ﺑﺎﺳم ‪screen.jpg‬‬

‫ﻛﯿﻒ ﺗﻌﻤﻞ ﺻﻮره ﻟﻠﺸﺎﺷﮫ ﺑﻈﻐﻄﮫ زر ﻣﻦ ﺧﻼل اﻟﺒﺮﻧﺎﻣﺞ*‪/‬‬

‫‪١١٩‬‬
 * To change this license header, choose License Headers in Project
Properties.

* To change this template file, choose Tools | Templates

* and open the template in the editor.

*/

package javaapplication2;

import java.awt.AWTException;

import java.awt.Image;

import java.awt.Rectangle;

import java.awt.Robot;

import java.awt.Toolkit;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.IOException;

import javax.imageio.ImageIO;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JOptionPane;

/**

١٢٠
* @author mohammed s

*/

public class JavaApplication2 {

static JFrame f;

static JButton captur;

static JButton close;

/**

* @param args the command line arguments

*/

public static void main(String[] args) {

f=new JFrame("capture image");

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

f.setSize(600,600);

f.setVisible(true);

captur=new JButton("capture");

captur.setBounds(10,500,100,50);

f.add(captur);

captur.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

try {

Robot r=new Robot();

BufferedImage buffer=r.createScreenCapture(new
Rectangle(Toolkit.getDefaultToolkit().getScreenSize()));

١٢١
 try {

ImageIO.write(buffer,"JPG",new
File("screen.jpg"));

JOptionPane.showMessageDialog(null," ‫ﺗﻢ اﻟﺤﻔﻆ ﻓﻲ‬

‫" ﻣﺴﺎر اﻟﺒﺮﻧﺎﻣﺞ‬+File.pathSeparator);

} catch (IOException ex) {

ex.printStackTrace();

} catch (AWTException ex) {

ex.printStackTrace();

});

// TODO code application logic here

splash-٧٦
‫وھﻲ ﻛﯾف ﺗﻌﻣل ﯾﻌﻧﻲ ﻓﻲ ﻣﻘدﻣﮫ اﻟﺑرﻧﺎﻣﺞ ﺻوره ﺟﺎري اﻟﺗﺣﻣﯾل وﺻوره ﻣﻌﺑره ﻋن‬
‫اﻟﺑرﻧﺎﻣﺞ ﺷﺎﺷﮫ ﻣدﺗﮭﺎ ﺧﻣس ﺛواﻧﻲ‬

// Splash.java

//

import javax.swing.*;

١٢٢
import java.awt.*;

class Splash {

public static void main(String[] args) {

// Throw a nice little title page up on the screen first

showSplash(3000);

System.exit(0); // replace with application code!

// A simple little method to show a title screen in the

// center of the screen for a given amount of time.

public static void showSplash(int duration) {

JWindow splash = new JWindow();

JPanel content = (JPanel)splash.getContentPane();

// set the window's bounds, centering the window

splash.setBounds(200,100,455,500);

// build the splash screen

JLabel label = new JLabel(new ImageIcon("mm.png"));

JLabel copyrt = new JLabel

("wait ...", JLabel.CENTER);

copyrt.setFont(new Font("Sans-Serif", Font.BOLD, 40));

copyrt.setForeground(Color.green);

١٢٣
 content.add(label, BorderLayout.CENTER);

content.add(copyrt, BorderLayout.SOUTH);

content.setBorder(BorderFactory.createLineBorder(Color.blue, 20));

// display it

splash.setVisible(true);

// Wait a little while, maybe while loading resources

try { Thread.sleep(duration); } catch (Exception e) {}

splash.setVisible(false);

open net-٧٧
‫ ﻣﺛﻼ‬google.com ‫ﻛﯾف ﺗﻔﺗﺢ ﻣﺳﺗﻌرض اﻟﻧت ﻣن ﺑرﻧﺎﻣﺟك‬

import java.awt.Desktop;

import java.io.IOException;

import java.net.URI;

import java.net.URISyntaxException;

class mo{

١٢٤
 public static void main(String[] args) {

Desktop desktop= Desktop.getDesktop();

try {

//open the default browser using the method browse which take
an URI object representing the web page

desktop.browse(new URI("http://google.com"));

} catch (URISyntaxException ex) {

ex.printStackTrace();

} catch (IOException ex) {

ex.printStackTrace();

}}

count letter-٧٨
‫ﻛﯾف ﺗﻌﻣل ﺑرﻧﺎﻣﺞ ﯾﺣﺳب ﻟك ﻋدد ظﮭور ﻛل ﺣرف ﻣن اﻟﺣروف اﻻﻧﺟﻠﯾزﯾﮫ ﺑطرﯾﻘﮫ‬
‫ﻣﺣﺗرﻓﮫ ﺟدا‬

import javax.swing.JOptionPane;

class CountEachLetter {

/** Main method */

١٢٥
 public static void main(String[] args) {

// Prompt the user to enter a string

String s = JOptionPane.showInputDialog("Enter a string:");

// Invoke the countLetters method to count each letter

int[] counts = countLetters(s.toLowerCase());

// Declare and initialize output string

String output = "";

// Display results

for (int i = 0; i < counts.length; i++) {

if (counts[i] != 0)

output += (char)('a' + i) + " appears " +

counts[i] + ((counts[i] == 1) ? " time\n" : " times\n");

// Display the result

JOptionPane.showMessageDialog(null, output);

// Count each letter in the string

static int[] countLetters(String s) {

int[] counts = new int[26];

for (int i = 0; i < s.length() ; i++) {

١٢٦
if (Character.isLetter(s.charAt(i)))

counts[s.charAt(i) - 'a']++;

return counts;

draw time-٧٩
‫وھو اﻋﺗﺑره ﺑرﻧﺎﻣﺞ رھﯾب ﺟدا‬
‫ﻹﻧﮫ ﯾﻌطﯾك ﺣﻘﻠﯾن ﺣﻘل ﺗدﺧل ﻓﯾﮫ اﻟﺳﺎﻋﺔ وﺣﻘل ﺗدﺧل ﻓﯾﮫ اﻟدﻗﺎﺋﻖ وﺗﺿﻐط اﻟزر وھو‬
‫ﯾروح ﯾﻌﻣل ﻟﮭﺎ رﺳﻣﮫ ﻋﻠﻰ اﻟﻔورم‬
‫ﻣﻣﻛن ﺗﻌطﯾﮫ ﺗﺎﯾﻣر اﻟﺳﺎﻋﮫ ﺣﻖ اﻟوﯾﻧدوز وھو ﯾظل ﯾرﺳم ﻋﻠﻰ طول‬

import java.awt.* ;

import java.awt.event.* ;

import javax.swing.* ;

class MaFenetre extends JFrame implements ActionListener

{ public MaFenetre ()

{ setTitle ("PENDULE") ;

١٢٧
 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

setSize (400, 250) ;

Container contenu = getContentPane() ;

panControles = new JPanel() ;

contenu.add (panControles, "North") ;

saisieHeures = new JTextField (4) ;

panControles.add (saisieHeures) ;

etiqHeures = new JLabel (" Heures") ;

panControles.add (etiqHeures) ;

saisieMinutes = new JTextField (4) ;

panControles.add (saisieMinutes) ;

etiqMinutes = new JLabel (" Minutes") ;

panControles.add (etiqMinutes) ;

ok = new JButton ("Mise a l'heure") ;

panControles.add (ok) ;

ok.addActionListener (this) ;

panPendule = new PanPendule(this) ;

contenu.add (panPendule) ;

panPendule.setBackground (Color.yellow) ;

public int getMinutes ()

{ return minutes ;

public int getHeures ()

{ return heures ;

١٢٨
public void actionPerformed (ActionEvent e)

{ int h, m ; // pour les valeurs saisies

if (e.getSource() == ok)

{ try

{ String chHeures = saisieHeures.getText() ;

h = Integer.parseInt (chHeures) ;

catch (NumberFormatException ex)

{ h = -1 ; // on force une valeur invalide

saisieHeures.setText ("") ;

try

{ String chMinutes = saisieMinutes.getText() ;

m = Integer.parseInt (chMinutes) ;

catch (NumberFormatException ex)

{ m = -1 ; // on force une valeur invalide

saisieMinutes.setText ("") ;

// si les valeurs obtenues sont valides, on les place dans

// les champs heures et minutes et on force le dessin

// sinon, on replace les anciennes valeurs dans les champs texte

repaint() ;

if ((h>=0) && (h<24) && (m>=0) && (m<60))

{ heures = h ; minutes = m ;

١٢٩
}

else

{ saisieMinutes.setText (""+minutes) ;

saisieHeures.setText (""+heures) ;

private JPanel panControles ;

private PanPendule panPendule ;

private JTextField saisieHeures, saisieMinutes ;

private JLabel etiqHeures , etiqMinutes ;

private JButton ok ;

private int minutes=0, heures=0 ;

class PanPendule extends JPanel

{ public PanPendule (MaFenetre fen)

{ this.fen = fen ;

public void paintComponent (Graphics g)

{ super.paintComponent(g) ;

// dessin du cercle

Dimension dim = getSize() ;

int largeur = dim.width, hauteur = dim.height ;

boolean panTropLarge = (largeur>hauteur) ;

int xCentre = largeur/2, yCentre = hauteur/2 ;

int rayon ;

١٣٠
if (panTropLarge) rayon = hauteur/2 - 2 ; else rayon = largeur/2 - 2 ;

g.drawOval (xCentre-rayon, yCentre-rayon, 2*rayon, 2*rayon) ;

// dessin grande aiguille

int minutes = fen.getMinutes() ;

double angle = Math.PI/2 * (1. - minutes/15.) ;

g.drawLine (xCentre, yCentre,

(int)(xCentre+rayon*Math.cos(angle)),

(int)(yCentre-rayon*Math.sin(angle))) ;

// dessin petite aiguille

int heures = fen.getHeures() ;

angle = Math.PI/2 * (1. - heures/3. - minutes/180.) ;

g.drawLine (xCentre, yCentre,

(int)(xCentre+rayon/2.*Math.cos(angle)),

(int)(yCentre-rayon/2.*Math.sin(angle))) ;

private MaFenetre fen ;

class Pendule

{ public static void main (String args[])

{ MaFenetre fen = new MaFenetre() ;

fen.setVisible(true) ;

color-٨٠

١٣١
 ‫وھو ﻛﯾف ﺗﻠون اﻟﺧط وﻛﯾف ﺗﻐﯾر ﻧوع اﻟﺧط ﺑﺎﺳﺗﺧدام اﻟﺟﺎﻓﺎ‬

import java.awt.Color;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.Action;

import javax.swing.ButtonGroup;

import javax.swing.JButton;

import javax.swing.JCheckBox;

import javax.swing.JColorChooser;

import javax.swing.JFrame;

import javax.swing.JOptionPane;

import javax.swing.JScrollPane;

import javax.swing.JTextArea;

class mo implements ActionListener {

public JFrame f;

public JCheckBox c1,c2;

public JButton b1;

private Color color=Color.GRAY;

private Component mo;

JTextArea t;

public static void main(String[] args) {

mo n=new mo();

١٣٢
}

public mo()

f=new JFrame();

f.setVisible(true);

f.setSize(300,300);

f.setLayout(null);

c1=new JCheckBox("bold");

c2=new JCheckBox("italic");

t=new JTextArea();

c1.setBounds(10,20,100,30);

c2.setBounds(10,50,100,30);

JScrollPane s=new JScrollPane(t);

s.setBounds(10,100,100,100);

ButtonGroup g=new ButtonGroup();

g.add(c1);

g.add(c2);

f.add(c1);

f.add(c2);

f.add(s);

b1=new JButton("ch");

b1.setBounds(10,200,100,50);

b1.addActionListener(this);

f.add(b1);

c1.addActionListener(this);

١٣٣
 c2.addActionListener(this);

public void actionPerformed(ActionEvent e) {

if(e.getSource()==c1)

{String messg=t.getText();

t.setFont(new Font("",Font.BOLD,14));

t.setText(messg);

if(e.getSource()==c2)

{String messg=t.getText();

t.setFont(new Font("",Font.ITALIC,14));

t.setText(messg);}

if(e.getSource()==b1)

color=JColorChooser.showDialog(t,"choss",color);

t.setCaretColor(color);

t.setColumns(10);

t.setLineWrap(true);

// t.setBackground(color);

}}

١٣٤
 calc -٨١
‫ﻛﯾف ﺗﻌﻣل اﻟﮫ ﺣﺎﺳﺑﮫ ﺑﺎﺳﺗﺧدام اﻟﺟﺎﻓﺎ‬

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.*;

import java.util.Currency;

import java.util.Set;

import javax.swing.*;

import javax.swing.JFrame;

import javax.swing.JOptionPane;

import javax.swing.JTextField;

class calc implements ActionListener{

public JFrame f;

public JButton p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14,p15;

public JTextField t1,t2,t3;

public Double num1,sum;

private JButton p;

private JLabel l1;

public java.lang.Double min;

١٣٥
 private Color red = Color.lightGray;

public java.lang.Double mult;

String op;

private ImageIcon icon;

public static void main(String[] args) {

calc ali=new calc();

ali.method();

public void method() {

f=new JFrame("calc");

f.setVisible(true);

f.setBounds(20,20,1000,900);

f.setLayout(null);

f.setTitle("‫;)"اﻟﺔ ﺣﺎﺳﺒﺔ‬

// icon = new ImageIcon ("k1.jpg");

//f.add(icon);

l1=new JLabel(new ImageIcon("l.png"));

l1.setBounds(1,1,1000,900);

١٣٦
f.add(l1);

p15=new JButton(new ImageIcon("clear.png"));

p1=new JButton(new ImageIcon("1.png"));

p1.setSelected(true);

p2=new JButton(new ImageIcon("2.png"));

p3=new JButton(new ImageIcon("3.png"));

p4=new JButton(new ImageIcon("4.png"));

p5=new JButton(new ImageIcon("5.png"));

p6=new JButton(new ImageIcon("6.png"));

p7=new JButton(new ImageIcon("7.png"));

p8=new JButton(new ImageIcon("8.png"));

p9=new JButton(new ImageIcon("9.png"));

p10=new JButton(new ImageIcon("+.png"));

p11=new JButton(new ImageIcon("-.png"));

p12=new JButton(new ImageIcon("m.png"));

p13=new JButton(new ImageIcon("=.png"));

p1.setForeground(Color.red);

p1.setBackground(Color.blue);

t1=new JTextField();

Color color1 = Color.red;

t1.setFont(new Font("",Font.PLAIN,18));

p15.addActionListener(this);

p1.addActionListener(this);

p2.addActionListener(this);

١٣٧
 p3.addActionListener(this);

p4.addActionListener(this);

p5.addActionListener(this);

p6.addActionListener(this);

p7.addActionListener(this);

p8.addActionListener(this);

p9.addActionListener(this);

p10.addActionListener(this);

p11.addActionListener(this);

p12.addActionListener(this);

p13.addActionListener(this);

t1.setBounds(600,100,200,100);

//ImageIcon image = new ImageIcon ("k1.jpg");

p1.setBounds(20,100,100,100);

p2.setBounds(200,100,100,100);

p3.setBounds(380,100,100,100);

// p15.setBounds(450,100,60,20);

p4.setBounds(20,250,100,100);

p5.setBounds(200,250,100,100);

p6.setBounds(380,250,100,100);

p7.setBounds(20,400,100,100);

p8.setBounds(200,400,100,100);

p9.setBounds(380,400,100,100);

p15.setBounds(550,400,100,100);

١٣٨
 p10.setBounds(20,550,100,100);

p11.setBounds(200,550,100,100);

p12.setBounds(380,550,100,100);

p13.setBounds(550,550,100,100);

// p14.setBounds(700,550,100,100);

l1.add(t1);

l1.add(p1);

l1.add(p2);

l1.add(p3);

l1.add(p15);

l1.add(p4);

l1.add(p5);

l1.add(p6);

l1.add(p7);

l1.add(p8);

l1.add(p9);

l1.add(p10);

l1.add(p11);

l1.add(p12);

l1.add(p13);

//f.add(p14);

public void actionPerformed(ActionEvent e) {

if(e.getSource()==p1)

{//t1.setFont(new Font("",Font.BOLD,18));

١٣٩
 t1.setText(t1.getText().concat("1"));

else

if(e.getSource()==p2)

{t1.setText(t1.getText().concat("2"));

//t1.setText("2");

if(e.getSource()==p3)

{t1.setText(t1.getText().concat("3"));

//t1.setText("3");

if(e.getSource()==p4)

{t1.setText(t1.getText().concat("4"));

// t1.setText("4");

if(e.getSource()==p5)

{t1.setText(t1.getText().concat("5"));

// t1.setText("5");

if(e.getSource()==p6)

{t1.setText(t1.getText().concat("6"));

// t1.setText("6");

if(e.getSource()==p7)

١٤٠
{t1.setText(t1.getText().concat("7"));

//t1.setText("7");

if(e.getSource()==p8)

{t1.setText(t1.getText().concat("8"));

// t1.setText("8");

if(e.getSource()==p9)

{t1.setText(t1.getText().concat("9"));

// t1.setText("9");

if(e.getSource()==p10)

{num1 = Double.parseDouble(t1.getText());

t1.setText("");

op="+";

if(e.getSource()==p11)

{min = Double.parseDouble(t1.getText());

t1.setText("");

op="-";

if(e.getSource()==p15)

١٤١
{num1=0.0;sum=0.0;

mult=0.0;

t1.setText("");

if(e.getSource()==p12)

{num1 = Double.parseDouble(t1.getText());

t1.setText("");

op="*";

if(e.getSource()==p13)

{if(op=="+"){

sum= Double.parseDouble(t1.getText());

sum+=num1;

t1.setText(sum.toString());}

if(op=="-")

{ num1= Double.parseDouble(t1.getText());

min=min-num1;

t1.setText(min.toString());}

if(op=="*")

{mult= Double.parseDouble(t1.getText());

mult*=num1;

t1.setText(mult.toString());

}}}

١٤٢
 ‫أﺳﻣﺎء اﻟﻣﺷﺎرﻛﯾن ﻓﻲ اﻟﻛﺗﺎب ‪:‬‬
‫ﻋﺑد اﻟﻠطﯾف ﻋﺑد اﻟﻌزﯾز ﷴ ﺟﺎﻣﻊ‬
‫‪maisam alrawi‬‬
‫ﻣﯾﺎدة ﺣﻣود ﻋوض ﺣﺳن‬
‫ﷴ اﻣﯾن‬
‫‪Mai Kamel Amro‬‬
‫ﺣﻛم ﻣﺣﻣود ﻋﺑدﷲ اﺣﻣﯾدات‬
‫‪Mostafa Anter‬‬
‫‪Sabeel Akhras‬‬
‫راﻣﻲ ﻋﺑداﻟﻛرﯾم ﷴ اﻟﺣﻣﺎدي‬
‫ﺣﻣزة ﺑراھﻣﻲ‬
‫ﺑﺎﺳل ﺳﻌﯾد‬
‫ﷴ ﺳﻧﺎن ﻣﺣﺳن ﻣﺳﻌود‬
‫راﻛﺎن ﻓﺎﺿل‬

‫‪‬‬