‫‪Chp9‬‬

‫اﻟﻜﺎﺋﻨﺎت واﻷﺻﻨﺎف‬

‫ﻓﻲ ﻨﻬﺎﻴﺔ ﻫﺫﺍ ﺍﻟﻔﺼل ﺴﻭﻑ ﺘﺘﻌﻠﻡ ‪:‬‬

‫ﺍﻟﺘﻌﺭﻑ ﺇﻟﻰ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﻭﺠﻬﺔ ‪.OOP‬‬
‫ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﺍﻟﻜﺎﺌﻨﺎﺕ ﻭﺍﻷﺼﻨﺎﻑ ﻭﺍﻟﻌﻼﻗﺔ ﺒﻴﻨﻬﻤﺎ‪.‬‬
‫ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﻜﻴﻔﻴﺔ ﺘﻌﺭﻴﻑ ﺍﻟﺼﻨﻑ ﻭﻜﻴﻔﻴﺔ ﺼﻨﻊ ﻜﺎﺌﻥ ﻤﻥ ﺼﻨﻑ‪.‬‬
‫ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﺎﻨﻴﺎﺕ)‪.(constructors‬‬
‫ﺘﺤﺩﻴﺩ ﻤﺠﺎل ﺘﻐﻁﻴﺔ ﺍﻟﻤﺘﺤﻭﻻﺕ ‪.‬‬
‫ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻷﺼﻨﺎﻑ ﺍﻟﺩﺍﺨﻠﻴﺔ‪.‬‬

‫‪ 9‬اﻟﻔﺼﻞ اﻟﺘﺎﺳﻊ اﻟﻜﺎﺋﻨﺎت واﻷﺻﻨﺎف‬

‫‪[email protected]‬‬ ‫‪293‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫‪INTRODUCTION‬‬ ‫‪ 9.1‬ﻣﻘﺪﻣﺔ‬

‫اﻟﺒﺮﻧﺎﻣﺞ ھﻮ ﻣﺠﻤﻮﻋﺔ ﻣﻦ ﺗﻌﻠﯿﻤﺎت ﻣﺮﺗﺒﺔ وﻣﺘﺴﻠﺴﻠﺔ ﻣﻨﻄﻘﯿﺎ ﺗﺆدي ﻓﻲ اﻟﻨﮭﺎﯾﺔ ﻟﺒﻠﻮغ ھﺪﻓﺎً ﻣﺎ ھﺬا‬
‫ﻋﻦ اﻟﺒﺮاﻣﺞ ﻋﺎﻣﺔ وھﺬا ھﻮ اﻟﺘﻌﺮﯾﻒ اﻟﻤﺒﺴﻂ ﻟﻠﺒﺮﻧﺎﻣﺞ وﺑﺎﻟﺘﺎﻟﻲ ﯾﻤﻜﻦ ﺗﻌﺮﯾﻒ اﻟﺒﺮﻣﺠﺔ ﺑﺄﻧﮭﺎ‬
‫ﻋﻤﻠﯿﺔ وﺿﻊ ھﺬه اﻟﺘﻌﻠﯿﻤﺎت ﺑﺎﻟﻄﺮﯾﻘﺔ اﻟﻤﺮﺗﺒﺔ واﻟﻤﺘﺴﻠﺴﻠﺔ ﻣﻨﻄﻘﯿﺎً ﺑﺤﯿﺚ ﺗﺆدي ﻓﻲ اﻟﻨﮭﺎﯾﺔ ﻟﺒﻠﻮغ‬
‫اﻟﮭﺪف ‪ .‬وﻟﻤﺎ ﻛﺎﻧﺖ اﻟﺒﺮﻣﺠﺔ ﻟﻠﺤﺎﺳﺐ اﻵﻟﻲ ﻣﺜﻠﮭﺎ ﻓﻲ ذﻟﻚ ﻣﺜﻞ ﺑﺎﻗﻲ اﻟﻨﺸﺎﻃﺎت اﻹﻧﺴﺎﻧ ﯿﺔ ﻗﺪ‬
‫ﻣﺮت ﺑﻤﺮاﺣﻞ ﺗﻄﻮر ﻛﺎن ﯾﻨﺒﻐﻲ ﻋﻠﯿﻨﺎ أن ﻧﻠﻤﺢ ھﻨﺎ ﻷھﻢ ھﺬه اﻟﻤﺮاﺣﻞ ﺣﺘﻰ ﺗﺴﺘﻄﯿﻊ أن ﺗﺪرك‬
‫ﻣﻌﻨﻰ ﻋﺒﺎرة اﻟﺒﺮﻣﺠﺔ اﻟﻤﻮﺟﮭﺔ أو ‪ object oriented‬واﻟﺘﻲ ﯾﻄﻠﻖ ﻋﻠﯿﮭﺎ اﺧﺘﺼﺎرا ل )‬
‫‪. ( O.O.P‬‬

‫ﻣﺎذا ﻧﻌﻨﻲ ﺑﺎﻟﺒﺮﻣﺠﺔ اﻟﻜﺎﺋﻨﯿﺔ اﻟﻤﻨﺤﻰ ‪ -‬اﻟﺒﺮﻣﺠﺔ اﻟﻤﻮﺟﮭﺔ ﺑﺎﻟﻜﺎﺋﻨﺎت‬

‫) ‪ OOP(Object Orientation Programming‬؟‬
‫ﻓﻲ اﻟﺒﺪاﯾﺔ ﻛﺎﻧﺖ ﻃﺮﯾﻘﺔ اﻟﺒﺮﻣﺠﺔ اﻟﺴﺎﺋﺪة ھﻲ اﻟﺒﺮﻣﺠﺔ اﻟﺨﻄﯿﺔ ﺣﯿﺚ ﻛﺎن اﻟﺒﺮﻧﺎﻣﺞ ﯾﻜﺘﺐ ﻛﻠﮫ ﻓﻲ‬
‫ﻣﻠﻒ واﺣﺪ وﺗﺮﺗﺐ أواﻣﺮ وﺗﻌﻠﯿﻤﺎت اﻟﺒﺮﻧﺎﻣﺞ ﻛﻠﮭﺎ ﻓﻲ ھﺬا اﻟﻤﻠﻒ ﺑﺤﯿﺚ ﯾﺒﺪأ ا ﻟﺤﺎﺳﺐ ﻓﻲ ﺗﻨﻔﯿﺬ‬
‫ھﺬه اﻷواﻣﺮ واﻟﺘﻌﻠﯿﻤﺎت ﻣﻦ أﻋﻠﻰ وﻛﻠﻤﺎ اﻧﺘﮭﻰ اﻟﺤﺎﺳﺐ ﻣﻦ ﺗﻨﻔﯿﺬ اﺣﺪ ھﺬه اﻟﺘﻌﻠﯿﻤﺎت ﯾﻨﺘﻘﻞ ﻟﻠﺘﻲ‬
‫ﺗﻠﯿﮫ وھﻜﺬا ﺣﺘﻰ ﯾﻨﺘﮭﻲ اﻟﺒﺮﻧﺎﻣﺞ وﻛﺎﻧﺖ ﻋﻤﻠﯿﺔ اﺧﺘﺒﺎر اﻟﺒﺮﻧﺎﻣﺞ أﺻﻌﺐ ﻣﺎ ﯾﻤﻜﻦ وﻛﺬﻟﻚ ﻛﺎﻧﺖ‬
‫ﺻﻌﻮﺑﺔ ﻓﻲ ﺗﺼﺤﯿﺢ اﻷﺧﻄﺎء ‪ .‬ﺑﻌﺪ ذﻟﻚ ﻇﮭﺮت ﻃﺮﯾﻘﺔ اﻟﺒﺮﻣﺠﺔ اﻹﺟﺮاﺋﯿﺔ أو اﻟﺘﺮﻛﯿ ﺒﯿﺔ وھﻲ‬
‫اﻟﺘﻲ ﺗﻌﺘﻤﺪ ﻋﻠﻰ ﺗﻘﺴﯿﻢ اﻟﺒﺮﻧﺎﻣﺞ ﻟﻤﺠﻤﻮﻋﺔ ﻣﻨﻔﺼﻠﺔ ﻣﻦ اﻹﺟﺮاءات واﻟﻮﻇﺎﺋﻒ ﻛﻞ ﻣﻨﮭﺎ ﯾﺆدي‬
‫ﺟﺰءاً ﻣﺤﺪداً ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ وﺑﺎﻟﺘﺎﻟﻲ أﺻﺒﺢ اﻟﺒﺮﻧﺎﻣﺞ ﺷﻜﻠﮫ أﻓﻀﻞ ﻣﻘﺴﻢ ﻟﻤﺠﻤﻮﻋﺔ ﻣﻦ اﻷﻗﺴﺎم‬
‫ﯾﻤﻜﻦ ﺻﯿﺎﻧﺔ وﺗﺠﺮﺑﺔ ﻛﻞ ﺟﺰء ﻋﻠﻰ ﺣﺪاه ﻛﻤﺎ ﯾﻤﻜﻦ اﺳﺘﺨﺪام ﻧﻔﺲ اﻟﺠﺰء ﻓﻲ ﺑﺮﻧﺎﻣﺞ أﺧﺮ‪ .‬ﻓﻌﻰ‬
‫اﻟﻤﺜﺎل ﯾﺘﻜﻮن اﻟﺒﺮﻧﺎﻣﺞ ﻓﻲ ﻓﯿﺠﻮال ﺑﯿﺴﻚ ﻣﻦ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻮﺣﺪات )‪(modules‬‬ ‫ﺳﺒﯿﻞ‬
‫ﻓﻤﺜﻼً اﻟﻨﺎﻓﺬة اﻟﺮﺋﯿﺴﯿﺔ اﻟﺘﻲ أﻧﺸﺄھﺎ ﻓﯿﺠﻮال ﺑﯿﺴﻚ ﻟﻚ ﺑﺄي ﻣﺸﺮوع ﺟﺪﯾﺪ وﯾﺴﻤﯿﮭﺎ‬ ‫ﻣﻮدﯾﻮل ‪.‬‬
‫‪ form1‬وھﻲ وﺣﺪة ﻣﻮدﯾﻮل وھﺬه اﻟﻮﺣﺪة ﻟﮭﺎ ﻋﺪة ﻣﻮاﺻﻔﺎت ﻣﺜﻞ ﻣﻜ ﺈﻧﮭﺎ ﻓﻲ اﻟﺸﺎﺷﺔ وأﺑﻌﺎدھﺎ‬
‫وﻟﻮن اﻟﺨﻠﻔﯿﺔ وﻏﯿﺮ ذﻟﻚ ﻣﻦ ا ﻟﺨﺼﺎﺋﺺ وﻛﺬﻟﻚ ﯾﻤﻜﻦ أن ﯾﺤﺪث ﻟﮭﺎ ﻋﺪة أﺷﯿﺎء ﻣﺜﻞ أن ﯾﻨﻘﺮ‬
‫ﺑﺎﻟﻔﺎرة ﻓﻮﻗﮭﺎ أو ﯾﺘﻢ ﺗﻐﯿﺮ أﺑﻌﺎدھﺎ وﻛﺬﻟﻚ ﻓﺎن ھﺬا اﻟﺸﻲء ﯾﺴﺘﺠﯿﺐ ﻟﺘﻠﻚ اﻷﺷﯿﺎء ﺑﺮدود أﻓﻌﺎل‬
‫ﻣﺨﺘﻠﻔﺔ ﻣﺜﻞ أن ﯾﺨﺘﻔﻲ أو ﯾﻈﮭﺮ وذﻟﻚ ﺿﻤﻦ إﺟﺮاء ﻣﺮﺗﺒﻂ ﺑﻮﻗﻮع ﺣﺪث ﻣﺎ ﯾﻤﻜﻦ أن ﯾﺤﺘﻮي‬
‫‪ form1‬ﺑﺪوره ﻋﻠﻰ ﻣﺠﻤﻮﻋﺔ أﺧﺮى ﻣﻦ اﻷﺷﯿﺎء ﻣﺜﻞ ﻣﻔﺘﺎح زر أو ﺻﻨﺪوق ﻧﺺ ‪text box‬‬
‫ﻛﻞ ﻣﻨﮭﻤﺎ ﻋﺒﺎرة ﻋﻦ ‪ object‬ﻟﮫ ﺧﺼﺎﺋﺼﮫ ‪ properties‬وأﺣﺪاث ‪ event‬وأﻓﻌﺎل ‪mesot‬‬
‫وﻗﺪ ﺗﻄﻮرت اﻟﻔﻜﺮة أﻛﺜﺮ ﻓﻈﮭﺮت اﻟﺒﺮﻣﺠﺔ اﻟﺸﯿﺌﯿﺔ ‪.‬‬

‫ﺣﯿﺚ ﯾﺘﻜﻮن اﻟﺒﺮاﻣﺞ ﻓﯿﮭﺎ ﻣﻦ ﻋﺪة أﺷﯿﺎء ﺑﺪﻻ ﻣﻦ إﺟﺮاءات ووﻇﺎﺋﻒ ‪ .‬واﻷﺷﯿﺎء ﻗﺮﯾﺒﺔ ﺟﺪا ﻣﻦ‬
‫أذھﺎﻧﻨﺎ ﺣﯿﺚ ﯾﻤﺘﻠﺊ اﻟﻌﺎﻟﻢ ﻣﻦ ﺣﻮﻟﻨﺎ ﺑﺎﻷﺷﯿﺎء ﻓﻜﻞ ﺷﻲ ﻟﮫ اﺳﻢ ﻓﮭﻮ ﺷﻲ وﻻ ﻣﺎﻧﻊ أن ﯾﻜﻮن ﺟﺰء‬
‫ﻣﻨﮫ ﺷﻲ أﺧﺮ وھﻜﺬا وإذا ﻧﻈﺮﻧﺎ ﻟﻸﺷﯿﺎء ﺣﻮﻟﻨﺎ ‪ OBJECT‬ﻓﺴﻮف ﻧﺠﺪ أن اﻷﺷﯿﺎء أﻧﻮاع ‪.‬‬

‫‪[email protected]‬‬ ‫‪294‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫أن ﻟﻜﻞ ﺷﻲ ﻣﺠﻤﻮﻋﺔ ﺧﻮاص وﺻﻔﺎت ﺗﺤﺪد ﺷﻜﻠﮫ وﺳﻠﻮﻛﮫ ﻛﻤﺎ ﺳﻨﺠﺪ أن‬ ‫وﻛﺬﻟﻚ ﻧﻼﺣﻆ‬
‫ﺧﺼﺎﺋﺺ ﺑﻌﺾ اﻷﺷﯿﺎء ﻟﯿﺲ ﻟﮭﺎ وﺟﻮد ﻓﻲ ﻧﻮع أﺧﺮ ﻣﻦ اﻷﺷﯿﺎء ‪.‬‬

‫وﻗﺒﻞ أن ﻧﺪﺧﻞ ﻓﻲ ﺗﻔﺎﺻﯿﻞ اﻟﺒﺮﻣﺠﺔ اﻟﻤﻮﺟﮭﺔ ﺳﻨﺸﺮح اﻟﺒﺮﻣﺠﺔ اﻟﻤﮭﯿﻜﻠﺔ ﻟﻜﻲ ﺗﺮﺳﺦ اﻟﻔﻜﺮة‬
‫وﺗﺴﺘﻮﻋﺐ ﻣﻌﻨﻰ اﻟﺒﺮﻣﺠﺔ اﻟﻤﻮﺟﮭﺔ‪.‬‬

‫‪ 9.1.1‬اﻟﺒﺮﻣﺠﺔ اﻟﻤﮭﯿﻜﻠﺔ‬
‫أوﻻ‪ ،‬ﻟﻨﺨﺘﺒﺮ ﺑﺼﻮرة ﺳﺮﯾﻌﺔ ﻛﯿﻒ ﯾﺘﻢ ﺗﺼﻤﯿﻢ اﻷﻧﻈﻤﺔ اﻟﺒﺮﻣﺠﯿﺔ ﺑ ﺎﺳﺘﺨﺪام اﻻﺗﺠﺎه اﻟﻤﮭﯿﻜﻞ‬
‫)أﺣﯿﺎﻧﺎ ﯾُﺴﻤّﻰ وﻇﺎﺋﻔﻲ ‪.(Functional‬‬

‫ﻓﻲ اﻟﺒﺮﻣﺠﺔ اﻟﻤﮭﯿﻜﻠﺔ ‪ ،Structured Programming‬اﻟﻄﺮﯾﻘﺔ اﻟﻤﺘّﺒﻌﺔ ﻋﺎﻣﺔ ھﻲ اﻟﻨﻈﺮ إﻟﻰ‬

‫اﻟﻤﺴﺄﻟﺔ‪ ،‬ﺛﻢ ﺗﺼﻤﯿﻢ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻮﻇﯿﻔﯿﺎت ‪ functions‬اﻟﺘﻲ ﯾﻤﻜﻨﮭﺎ اﻧﺠﺎز اﻟﻤﮭﺎم اﻟﻤﻄﻠﻮﺑﺔ‬
‫إذا ﺗﻀﺨّﻤﺖ ھﺬه اﻟﻮﻇﯿﻔﯿﺎت ‪ ،‬ﯾﺘﻢ ﺗﺠﺰﺋﺘﮭﺎ ﺣﺘﻰ ﺗﺼﯿﺮ ﺻﻐﯿﺮة ﺑﺎﻟﺤﺪّ اﻟﺬي ﯾﺘﯿﺴّﺮ ﻓﯿﮫ‬ ‫ﻟﺤﻠﮭﺎ‪.‬‬
‫ﻣﻨﺎوﻟﺘﮭﺎ و ﻓﮭﻤﮭﺎ‪ .‬ھﺬه اﻟﻌﻤﻠﯿﺔ ﺗﺪﻋﻰ اﻟﺘﻔﻜﯿﻚ اﻟﻮﻇﺎﺋﻔﻲ ‪.functional decomposition‬‬

‫ﻣﻌﻈﻢ اﻟﻮﻇﯿﻔﯿﺎت ﺳﺘﺤﺘﺎج إﻟﻰ ﺑﯿﺎﻧﺎت ﻣﻦ ﻧﻮع ﻣﺎ ﻟﺘﻌﻤﻞ ﻋﻠﯿﮭﺎ‪ .‬اﻟﺒﯿﺎﻧﺎت ﻓﻲ اﻵﻧ ﻈﻤﺔ اﻟﻮﻇﺎﺋﻔﯿﺔ‬
‫ﻋﺎدة ﻣﺎ ﯾﺤﺘﻔﻆ ﺑﮭﺎ ﻓﻲ ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت ﻣﻦ ﻧﻮع ﻣﺎ ) أو ﻗﺪ ﯾﺤﺘﻔﻆ ﺑﮭﺎ ﻓﻲ اﻟﺬاﻛﺮة ﻛﻤﺘﻐﯿّﺮات ﺷﺎﻣﻠﺔ‬
‫‪. (global variables‬‬

‫ﻟﻨﺄﺧﺬ ﻣﺜﺎﻻ ﺑﺴﯿﻄﺎ‪ ،‬ﺗﺨﯿّﻞ ﻣﻨﻈﻮﻣﺔ ﻹدارة ﻣﻌﮭﺪ‪ ،‬ھﺬه اﻟﻤﻨﻈﻮﻣﺔ ﺗﺤﺘﻔﻆ ﺑﺒﯿﺎﻧﺎت اﻟﻄﻠﺒﺔ و اﻟﻤﺪرّﺑﯿﻦ‬
‫ﻓﻲ اﻟﻤﻌﮭﺪ إﺿﺎﻓﺔ ﻟﻠﻤﻌﻠﻮﻣﺎت ﺣﻮل اﻟﺪورات اﻟﻤﺘﻮﻓﺮة‪ ،‬ﻛﺬﻟﻚ ﺗﻘﻮم اﻟﻤﻨﻈﻮﻣﺔ ﺑﺘﺘﺒﻊ ﻛﻞ ﻃﺎﻟﺐ و‬
‫اﻟﻔﺼﻮل اﻟﺘﻲ اﻟﺘﺤﻖ ﺑﮭﺎ‪.‬‬

‫اﻟﺘﺼﻤﯿﻢ اﻟﻮﻇﺎﺋﻔﻲ اﻟﻤﺤﺘﻤﻞ ﺳﯿﺘﻀﻤّﻦ ﻛﺘﺎﺑﺔ اﻟﻮﻇﯿﻔﯿﺎت ‪ functions‬اﻟﺘﺎﻟﯿﺔ‪:‬‬

‫‪add_student 5‬‬ ‫إﺿﺎﻓﺔ ﻃﺎﻟﺐ‬

‫‪enter_for_exam‬‬ ‫دﺧﻮل اﻣﺘﺤﺎن‬
‫‪check_exam_marks‬‬ ‫ﻓﺤﺺ ﻋﻼﻣﺎت اﻣﺘﺤﺎن‬
‫‪issue_certificate‬‬ ‫إﺻﺪار ﺷﮭﺎدة‬
‫‪expel_student‬‬ ‫ﻃﺮد ﻃﺎﻟﺐ‬

‫‪[email protected]‬‬ ‫‪295‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ﺳﻮف ﻧﺤﺘﺎج أﯾﻀﺎ إﻟﻰ ﻧﻤﻮذج ﺑﯿﺎﻧﺎت ‪ data model‬ﻟﯿﻤﺜّﻞ ھﺬه اﻟﻮﻇﯿﻔﯿﺎت‪ .‬ﻧﺤﺘﺎج ﻟﺘﺨﺰﯾﻦ‬
‫ﻣﻌﻠﻮﻣﺎت ﻋﻦ اﻟﻄﻠﺒﺔ‪ ،‬و اﻟﻤﺪرﺑﯿﻦ و اﻻﻣﺘﺤﺎﻧﺎت و اﻟﺪورات‪ ،‬ﻟﺬا ﯾﺠﺐ ﻋﻠﯿﻨﺎ ﺗﺼﻤﯿﻢ ﻣﺨﻄﻂ‬
‫ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت ‪ database schema‬ﻟﻼﺣﺘﻔﺎظ ﺑﮭﺬه اﻟﺒﯿﺎﻧﺎت ﻛﻤﺎ ﻓﻲ اﻟﺸﻜﻞ ‪.9-1‬‬

‫ﺑﺪأ واﺿﺤﺎ أن‬ ‫اﻵن‬

‫اﻟﻮﻇﯿﻔﯿﺎت ‪ functions‬اﻟﺘﻲ‬
‫ﺣﺪّدﻧﺎھﺎ ﺳﺎﺑﻘﺎ ﺳﻮف ﺗﻌﺘﻤﺪ‬
‫ﻋﻠﻰ ھﺬه اﻟﻤﺼﻔﻮﻓﺔ ﻣﻦ‬
‫ﻣﺜﻼ‪ ،‬وﻇﯿﻔﺔ‬ ‫اﻟﺒﯿﺎﻧﺎت‪.‬‬
‫"‪ ) "add_student‬اﺿﺎﻓﺔ‬
‫ﺳﺘﻘﻮم ﺑﺘﻐﯿﯿﺮ‬ ‫ﻃﺎﻟﺐ(‬
‫ﻣﺤﺘﻮﯾﺎت "‪"Students‬‬
‫‪ ،‬و وﻇﯿﻔﺔ‬ ‫ﻃﻠﺒﺔ(‬ ‫)‬
‫ﺷﻜﻞ ‪ 9-1‬ﻣﺨﻄﻂ ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت ﺑﺴﯿﻂ‪ .‬اﻟﺨﻄﻮط اﻟﻤﻨﻘﻄّﺔ ﺗﺸﯿﺮ إﻟﻰ اﻋﺘﻤﺎدﯾﺔ ﻣﺼﻔﻮﻓﺔ‬ ‫"‪"issue_certificate‬‬
‫ﺑﯿﺎﻧﺎت ﻋﻠﻰ أﺧﺮى‪ ،‬ﻣﺜﻼ‪ ،‬ﻛﻞ ﻃﺎﻟﺐ ﯾﺘﻢ ﺗﺪرﯾﺒﮫ ﺑﻮاﺳﻄﺔ ﻋﺪة ﻣﺪرّﺑﯿﻦ‪.‬‬ ‫) إﺻﺪار ﺷﮭﺎدة( ﺗﺤﺘﺎج إﻟﻰ‬
‫اﻟﻮﺻﻮل إﻟﻰ ﺑﯿﺎﻧﺎت ﻃﺎﻟﺐ ‪ ) Student‬ﻟﻤﻌﺮﻓﺔ ﺗﻔﺎﺻﯿﻞ اﻟﻄﺎﻟﺐ اﻟﺬي ﯾﺤﺘﺎج ﻟﻠﺸﮭﺎدة( و‬
‫ﺳﺘﺤﺘﺎج اﻟﻮﻇﯿﻔﺔ أﯾﻀﺎ إﻟﻲ ﺑﯿﺎﻧﺎت اﻻﻣﺘﺤﺎﻧﺎت ‪. Exam‬‬

‫اﻟﻤﺨﻄﻂ ‪ 9-2 diagram‬ﻋﺒﺎرة ﻋﻦ رﺳﻢ ﻟﻜﻞ اﻟﻮﻇﯿﻔﯿﺎت‪ ،‬ﻣﺠﺘﻤﻌﺔ رﻓﻖ اﻟﺒﯿﺎﻧﺎت‪ ،‬و رﺳﻤﺖ‬
‫اﻟﺨﻄﻮط ﻓﯿﮭﺎ ﺣﯿﺜﻤﺎ وﺟﺪت اﻋﺘﻤﺎدﯾﺔ ‪. dependency‬‬

‫ﺷﻜﻞ ‪ :9-2‬ﺧﺮﯾﻄﺔ اﻟﻮﻇﺎﺋﻒ‪ ،‬و اﻟﺒﯿﺎﻧﺎت و اﻻﻋﺘﻤﺎدﯾﺎت‪.‬‬

‫‪[email protected]‬‬ ‫‪296‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫اﻟﻤﺸﻜﻠﺔ ﻣﻊ ھﺬه اﻟﻤﻘﺎرﺑﺔ أن اﻟﻤﺴﺄﻟﺔ اﻟﺘﻲ ﻧﺘﻌﺎﻣﻞ ﻣﻌﮭﺎ إذا ﻣﺎ ﺗﻌﻘﺪت أﻛﺜﺮ ﺳﺘﺰداد ﺻﻌﻮﺑﺔ‬
‫اﻟﻤﺤﺎﻓﻈﺔ ﻋﻠﻰ اﻟﻤﻨﻈﻮﻣﺔ و ﺻﯿﺎﻧﺘﮭﺎ‪ .‬ﻓﻠﻮ أﺧﺬﻧﺎ اﻟﻤﺜﺎل أﻋﻼه‪ ،‬ﻣﺎذا ﺳﯿﺤﺪث ﻟﻮ ﺗﻐﯿّﺮت اﻟﻤﺘﻄﻠﺒﺎت‬
‫‪ requirement‬ﺑﻄﺮﯾﻘﺔ ﺗﺆدّي إﻟﻰ ﺗﻐﯿﯿﺮ أﺳﻠﻮب ﻣﻨﺎوﻟﺔ ﺑﯿﺎﻧﺎت اﻟﻄﺎﻟﺐ ‪.Student‬‬

‫ﻛﻤﺜﺎل‪ ،‬ﻟﻨﺘﺨﯿّﻞ أن ﻣﻨﻈﻮﻣﺘﻨﺎ ﺗﻌﻤﻞ ﻋﻠﻰ أﻛﻤﻞ ﻣﺎ ﯾﻜﻮن‪ ،‬ﻟﻜﻨﻨﺎ اﻛﺘﺸﻔﻨﺎ أن ﺗﺨﺰﯾﻦ ﺗﺎرﯾﺦ ﻣﯿﻼد‬
‫اﻟﻄﺎﻟﺐ ﻋﻠﻰ ﺷﻜﻞ ﻋﺪد ذو ﺧﺎﻧﺘﯿﻦ ﻛﻲ ﯾﻤﺜﻞ اﻟﺴﻨﺔ ﻛﺎﻧﺖ ﻓﻜﺮة ﺳﯿّﺌﺔ‪ ،‬اﻟﺤﻞ اﻟﻤﺒﺪأ ھﻨﺎ ھﻮ أن ﻧﻘﻮم‬
‫ﺑﺘﻐﯿﯿﺮ ﺣﻘﻞ ﺗﺎرﯾﺦ اﻟﻤﯿﻼد ﻓﻲ ﺟﺪول اﻟﻄﻠﺒﺔ ‪ Students‬ﻣﻦ ﺧﺎﻧﺘﯿﻦ إﻟﻰ أرﺑﻊ ﺧﺎﻧﺎت ﻟﺮﻗﻢ‬
‫اﻟﺴﻨﺔ‪.‬‬

‫اﻟﻤﺸﻜﻠﺔ اﻟﺠﺪﯾﺔ ﻟﮭﺬا اﻟﺘﻐﯿﯿﺮ ﺗﻨﺒﻊ ﻣﻦ أﻧﮫ ﻗﺪ ﯾﺴﺒّﺐ ﻓﻲ ﻇﮭﻮر أﺛﺎر ﺟﺎﻧﺒﯿﺔ ﻏﯿﺮ ﻣﺘﻮﻗﻌﺔ‪ .‬ﻓﺒﯿﺎﻧﺎت‬
‫ﺟﺪول اﻻﻣﺘﺤﺎﻧﺎت ‪ Exam‬و ﺟﺪول اﻟﺪورات ‪ Courses‬و ﺟﺪول اﻟﻤﺪرّﺑﯿﻦ ‪ Tutors‬ﻛﻠﮭﺎ‬
‫) ﺑﻄﺮﯾﻘﺔ أو ﺑﺄﺧﺮى( ﺗﻌﺘﻤﺪ ﻋﻠﻰ ﺑﯿﺎﻧﺎت ﺟﺪول اﻟﻄﺎﻟﺐ ‪ ، Students‬ﻟﺬا ﻗﺪ ﻧﺘﺴﺒﺐ ﻓﻲ ﻛﺴﺮ‬
‫ﺘﻐﯿﯿﺮﻧﺎ اﻟﺒﺴﯿﻂ ھﺬا‪ ،‬و إﻋﺎﻗﺔ وﻇﯿﻔﯿﺎت ‪ add_student‬و‬ ‫ﺑﻌﺾ اﻟﻌﻤﻠﯿﺎت ﺑ‬
‫‪ ،‬ﻓﻮﻇﯿﻔﺔ‬ ‫‪ enter_for_exams‬و ‪ issue_certificate‬و ‪expel_student‬‬
‫‪ add_student‬ﻟﻦ ﺗﻌﻤﻞ ﺑﺎﻟﺘﺄﻛﯿﺪ ﻹﻧﮭﺎ ﺗﺘﻮﻗﻊ أن ﺗﻜﻮن اﻟﻤﻌﻠﻮﻣﺔ اﻟﺨﺎﺻﺔ ﺑﺴﻨﺔ اﻟﻤﯿﻼد ﻋﻠﻰ‬
‫ﺷﻜﻞ رﻗﻢ ﺑﺨﺎﻧﺘﯿﻦ ﺑﺪﻻ ﻣﻦ أرﺑﻊ‪.‬‬

‫إذا‪ ،‬ﻟﺪﯾﻨﺎ ﻣﻌﺪل ﻛﺒﯿﺮ ﻣﻦ اﻟﻤﺸﺎﻛﻞ اﻟﻤﺤﺘﻤﻠﺔ‪ ،‬و اﻷﺳﻮأ إﻧﻨﺎ ﻟﻦ ﻧﺴﺘﻄﯿﻊ ﺑﺴﮭﻮﻟﺔ ﺗﻌﯿﯿﻦ أﻣﺎﻛﻦ‬
‫اﻻﻋﺘﻤﺎدﯾﺔ ﻓﻲ اﻟﺘﻮﻟﯿﻒ ‪ code‬اﻟﺘﻲ ﺳﺘﺘﺄﺛﺮ ﺑﮭﺬا اﻟﺘﻐﯿﯿﺮ‪.‬‬

‫ﻛﻢ ﻣﻦ ﻣﺮّة ﻗﻤﺖ ﺑﺘﻌﺪﯾﻞ ﺳﻄﺮ ﻓﻲ اﻟﺘﻮﻟﯿﻒ و ﺑﻜﻞ ﺑﺮاءة دون أن ﺗﻌﻲ اﻧﻚ ﺳﺒّﺒﺖ ﻋﻦ ﻏﯿﺮ ﻗﺼﺪ‬
‫ﻓﻲ ﻛﺴﺮ ﻋﻤﻠﯿﺎت أﺧﺮى ﻗﺪ ﺗﺒﺪو ﻻ ﻋﻼﻗﺔ ﻟﮭﺎ ﻓﻲ اﻟﻈﺎھﺮ؟‬

‫ﻛﺈﺷﻜﺎﻟﯿﺔ ﻋﺎم ‪) 2000‬ﺛﻐﺮة اﻷﻟﻔﯿﺔ( ذات اﻟﺘﻜﻠﻔﺔ اﻟﻌﺎﻟﯿﺔ ﻛﺎن ﺳﺒﺒﮭﺎ ﺑﺎﻟﻀﺒﻂ ھﺬه اﻟﻤﺸﻜﻠﺔ‪ .‬ﻓﺤﺘﻰ‬
‫ﻟﻮ أن ﺣﻠﮭﺎ ﯾﻔﺘﺮض ﺑﮫ أن ﯾﻜﻮن ﺑﺴﯿﻄﺎ ) ﺗﻐﯿﯿﺮ ﻛﻞ ﺣﻘﻞ ﺳﻨﺔ ﻣﻦ ﺧﺎﻧﺘﯿﻦ إﻟﻰ أرﺑﻊ( ﻓﺎن‬
‫اﻟﺘﺪاﻋﯿﺎت اﻟﻤﺤﺘﻤﻠﺔ ﻟﮭﺬا اﻟﺘﻐﯿﯿﺮ اﻟﺒﺴﯿﻂ ﯾﺠﺐ اﻟﺘﺤﻘﻖ ﻣﻨﮭﺎ و ﻓﺤﺼﮭﺎ ﺑﺪﻗﺔ‪.‬‬

‫وﯾﻤﻜﻦ ﺗﻠﺨﯿﺺ ﺧﻮاص ﺑﺮﻣﺠﺔ اﻹﺟﺮاءات ﻛﺎﻷﺗﻲ‪:‬‬

‫‪ .1‬ﺗﺮﻛﺰ ﻋﻠﻰ اﻟﻤﻌﺎﻟﺠﺔ )اﻟﺨﻮارزﻣﯿﺎت(‪.‬‬
‫‪ .2‬ﯾﻘﺴﻢ اﻟﺒﺮﻧﺎﻣﺞ اﻟﻜﺒﯿﺮ إﻟﻰ ﻣﺠﻤﻮﻋﺔ ﺑﺮاﻣﺞ ﺻﻐﯿﺮة ﺗﺴﻤﻰ اﻟﺪوال‪.‬‬
‫‪ .3‬أﻏﻠﺐ اﻟﺪوال ﺗﺘﻘﺎﺳﻢ اﻟﻤﺘﻐﯿﺮات اﻟﺸﺎﻣﻠﺔ ‪.global‬‬
‫‪ .4‬ﺗﻨﺘﻘﻞ اﻟﺒﯿﺎﻧﺎت ﺑﺼﻮرة ﻣﻔﺘﻮﺣﺔ ﺣﻮل اﻟﻨﻈﺎم ﻣﻦ داﻟﺔ إﻟﻰ داﻟﺔ أﺧﺮى‪.‬‬
‫‪ .5‬ﺗﺴﺘﺨﺪم ﻃﺮﯾﻘﺔ ﻣﻦ أﻋﻠﻰ إﻟﻰ أﺳﻔﻞ ﻓﻲ ﺗﺼﻤﯿﻢ اﻟﺒﺮاﻣﺞ‪.‬‬

‫‪[email protected]‬‬ ‫‪297‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫‪ 9.1.2‬اﻟﻌﻼﻗﺔ ﺑﯿﻦ ﻛﺎﺋﻨﺎت اﻟﻌﺎﻟﻢ اﻟﺤﻘﯿﻘﻲ وﻛﺎﺋﻨﺎت اﻟﺒﺮﻣﺠﺔ‬
‫ﻋﻨﺪﻣﺎ ﻓﻜﺮ ﻣﺨﺘﺮﻋﻮ اﻟﺒﺮﻣﺠﺔ اﻟﻜﺎﺋﻨﺔ ﺑﮭﺬا اﻟﻤﻔﮭﻮم اﻟﺠﺪﯾﺪ ﻛﻞ ﻣﺎ ﻛﺎن ﻟﺪﯾﮭﻢ ﻓﻲ ذﻟﻚ اﻟﻮﻗﺖ ھﻮ‬
‫ﺗﺴﮭﯿﻞ اﻟﺒﺮﻣﺠﺔ ﺑﺄﻛﺒﺮ ﻓﺮﺻﺔ ﻟﺘﺼﺒﺢ ﻣﺸﺎﺑﮭﺔ ﻟﻠﺘﺼﺮﻓﺎت ﻋﻠﻰ اﻟﻮاﻗﻊ ﺗﻤﺎﻣﺎ ﻓﻜﺮ اﻟﻤﺨﺘﺮﻋﻮن‬
‫ﻋﻠﻰ ﻃﺮﯾﻘﺔ ﻹﺑﻌﺎد اﻟﻤﺒﺮﻣﺞ ﻛﻠﯿﺎ ﻋﻦ ﻃﺮﯾﻘﺔ ﻋﻤﻞ ﻛﺎﺋﻦ ﻣﺎ ﻓﻲ اﻟﺒﺮﻣﺠﺔ ﺑﺤﯿﺚ ﯾﺮﻛﺰ ﻋﻤﻠﮫ ﻓﻘﻂ‬
‫ﻋﻠﻰ ﻛﯿﻔﯿﺔ اﺳﺘﻌﻤﺎﻟﮫ !!‬
‫ﻟﺘﺮﻛﯿﺰ ھﺬا اﻟﻤﻔﮭﻮم ﻓﻲ اﻟﻮاﻗﻊ ﺧﺬ ﻋﻨﺪك ﻣﺜﺎﻻ‪ :‬ﻟﻌﺒﺔ رﺟﻞ أﻟﻲ ﯾﻠﻌﺐ ﺑﮭﺎ ﻃﻔﻞ وﯾﺤﺮﻛﮭﺎ ﺑﯿﺪﯾﮫ‬
‫وﯾﻀﻐﻂ ﻓﯿﮭﺎ أزرارا ﻟﺘﺼﺪر ﺑﻌﺾ اﻷﺻﻮات واﻟﺤﺮﻛﺎت وﺗﻨﻔﺬ ﺑﻄﺎرﯾﺘﮭﺎ ﻓﺘﺘﻮﻗﻒ ﻋﻦ اﻟﻠﻌﺐ‬
‫وﯾﺮﻣﯿﮭﺎ ﻓﻲ اﻷرض ﻓﺘﺘﺤﻄﻢ !!‬
‫اﻵن ھﺬا اﻟﻄﻔﻞ ﻟﻦ ﯾﻌﺮف ﻣﻄﻠﻘﺎ ﻛﯿﻒ ﯾﻌﻤﻞ ھﺬا اﻟﺮﺟﻞ اﻵﻟﻲ ﻛﯿﻒ ﯾﺘﺤﺮك إذا ﺿﻐﻄﻨﺎ ھﺬا‬
‫اﻟﺰر ﻛﯿﻒ ﯾﺼﺪر ﺻﻮﺗﺎ إذا ﺿﻐﻄﻨﺎ ذﻟﻚ اﻟﺰر !!‬
‫ھﺬا ﻣﺸﺎﺑﮫ ﺗﻤﺎﻣﺎ ﻟﻤﺎ ﯾﺮﯾﺪﻧﺎ ﻣﺨﺘﺮﻋﻮ ال ‪ OOP‬اﻟﻮﺻﻮل إﻟﯿﮫ أن ﻧﺘﺤﻜﻢ ﺑﺎﻟﻜﺎﺋﻨﺎت ﺑﻜﻞ ﺳﮭﻮﻟﺔ‬
‫دون اﻟﺪﺧﻮل ﻓﻲ ﺗﻔﺎﺻﯿﻞ ﻃﺮﯾﻘﺔ ﻋﻤﻠﮭﺎ وﻣﻦ ھﻨﺎ ﺑﺰغ ﻓﺠﺮ ﻣﻔﮭﻮﻣﯿﻦ ﺟﺪﯾﺪﯾﻦ ﻟﻠﺒﺮﻣﺠﺔ " ﺻﺎﻧﻌﻮ‬
‫اﻟﻔﺌﺎت "وﻣﺴﺘﺨﺪﻣﻮ اﻟﻔﺌﺎت ‪.‬‬

‫ﻓﺎﻟﻜﺎﺋﻨﺎت ‪ Objects‬ﻓﻲ ﻋﺎﻟﻢ اﻟﻮاﻗﻊ ﯾﻤﻜﻦ ﺗﻤﯿﯿﺰھﺎ ﺑﺸﯿﺌﯿﻦ ‪ :‬ﻛﻞ ﻛﺎﺋﻦ ﻓﻲ ﻋﺎﻟﻢ اﻟﻮاﻗﻊ ﻟﺪﯾﮫ‬
‫ﺑﯿﺎﻧﺎت ‪ data‬و ﺳﻠﻮك ‪ . behaviour‬ﻓﻤﺜﻼ ﺟﮭﺎز اﻟﺘﻠﻔﺎز ھﻮ ﻛﺎﺋﻦ و ﯾﻌﺎﻟﺞ ﺑﯿﺎﻧﺎت ﺑﻄﺮﯾﻘﺔ‬
‫ﺗﺠﻌﻠﮭﺎ ﺗﺘﻀﺒﻂ ﻣﻦ ﺧﻼل ﻗﻨﺎة ﻣﺤﺪدة‪ ،‬ﻣﻌﺪّل اﻟﻤﺴﺢ ﯾﺘﻢ ﺗﺤﺪﯾﺪه إﻟﻰ ﻗﯿﻤﺔ ﻣﻌﯿّﻨﺔ‪ ،‬ﻛﺬﻟﻚ ﻣﻌﺪّل‬
‫اﻟﺘﺒﺎﯾﻦ و ﺷﺪّة اﻹﺿﺎءة و ھﻜﺬا‪ .‬اﻟﺘﻠﻔﺎز أﯾﻀﺎ ﯾﻤﻜﻨﮫ " ﯾﻘﻮم" ﺑﺄﺷﯿﺎء‪ ،‬اﻟﺘﻠﻔﺎز ﯾﻤﻜﻨﮫ اﻟﺘﺸﻐﯿﻞ أو‬
‫اﻹﻗﻔﺎل‪ ،‬اﻟﻘﻨﻮات ﯾﻤﻜﻦ ﺗﻐﯿ ﯿﺮھﺎ‪ ،‬و ھﻜﺬا‪ .‬ﻋﻠﻰ اﻟﻤﻨﻮال ﻧﻔﺴﮫ إذاً ‪ ،‬ﻓﺎن " ﻛﺎﺋﻨﺎت" اﻟﻌﺎﻟﻢ اﻟﺤﻘﯿﻘﻲ‬
‫ﺑﺎﻹﻣﻜﺎن ﻗﻮﻟﺒﺘﮭﺎ ﺑﻄﺮﯾﻘﺔ ﻣﺸﺎﺑﮭﺔ ﻟﻠﻘﻮاﻟﺐ اﻟﺒﺮﻣﺠﯿﺔ‪.‬‬

‫ﻟﮭﺬا اﻟﺴﺒﺐ‪ ،‬ﻧﺴﻤّﻲ ھﺬه اﻟﻘﻮاﻟﺐ ﺑﺎﻟﻜﺎﺋﻨﺎت ‪ Objects‬و ﻣﻨﮭﺎ ﺟﺎء ﻣﺼﻄﻠﺢ اﻟﺒﺮﻣﺠﺔ ‪ /‬اﻟﺘﺼﻤﯿﻢ‬
‫ﺑﺎﻟﻤﻨﺤﻰ ﻟﻠﻜﺎﺋﻦ ‪.Object Oriented Design/Programming‬‬

‫ﺗﺼﻨﻒ اﻟﻜﺎﺋﻨﺎت إﻟﻰ ﺻﻨﻔﯿﻦ‪:‬‬

‫• ﻛﺎﺋﻨﺎت ﻧﺸﻄﺔ ﺣﯿﺔ )‪(Animate Objects‬‬

‫وھﻲ اﻟﺘﻲ ﻧﺤﺲ ﻓﯿﮭﺎ ﻓﻨﺠﺪ ﻟﮭﺎ ﺣﺮﻛﺔ‬
‫وﻧﺸﺎط‪.‬‬
‫ﻛﺎﺋﻨﺎت ﻏﯿﺮ ﻧﺸﻄﺔ ﻏﯿﺮ ﺣﯿﺔ )‪ (Inanimate Objects‬ھﻲ اﻟﺘﻲ ﻻ ﻧﻼﺣﻆ ﻟﮭﺎ‬ ‫•‬
‫ﻧﺸﺎط أو ﺣﺮﻛﺔ أو وﻗﻊ أﯾﻨﻤﺎ وﺟﺪت ‪.‬‬

‫وﺟﻤﯿﻊ اﻟﻜﺎﺋﻨﺎت ﺑﺼﻨﻔﯿﮭﺎ ﻟﮭﺎ‪:‬‬

‫‪ .1‬ﺧﺼﺎﺋﺺ ‪ Attribute‬ﻣﺜﻞ ‪:‬اﻟﺤﺠﻢ‪ ،‬اﻟﻠﻮن‪ ،‬اﻟﻮزن‪ ،‬اﻟﺸﻜﻞ‪...‬أﻟﺦ ‪.‬‬

‫‪ .2‬ﺳﻠﻮك ‪ Behavior‬ﻓﻤﺜﻼً‪ :‬اﻟﻄﻔﻞ )ﻛﺎﺋﻦ( ﯾﺒﻜﻲ‪ ،‬وﯾﻨﺎم‪ ،‬وﯾﻤﺸﻲ‪ ،‬وﯾﺄﻛﻞ )ﺳﻠﻮﻛﯿﺎت( ‪.‬‬

‫‪[email protected]‬‬ ‫‪298‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫وﺧﺼﻮﺻﺎً اﻟﻤﺒﺮﻣﺞ ﯾﺘﻌﻠﻢ ﻋﻦ اﻟﻜﺎﺋﻨﺎت ﺑﻤﻌﺮﻓﺔ ﺧﺼﺎﺋﺼﮭﺎ‪ ،‬وﻣﻼﺣﻈﺔ ) ﺗﺠﺮﺑﺔ(‬ ‫اﻹﻧﺴﺎن‬
‫ﺳﻠﻮﻛﮭﺎ‪ ،‬ﻓﻤﻦ اﻟﻤﻤﻜﻦ أن ﯾﻜﻮن ﻟﻜﺎﺋﻨﺎت ﻣﺨﺘﻠﻔﺔ ﻧﻔﺲ اﻟﺨﺼﺎﺋﺺ وﺳﻠﻮك ﻣﺘﻘﺎرب‪.‬‬
‫ﺣﯿﺚ أن ﻧﻈﻤﻨﺎ اﻟﺒﺮﻣﺠﯿﺔ ﺗﻘﺪّم ﺣﻠﻮﻻ ﻟﻤﺸﺎﻛﻞ ﺣﻘﯿﻘﯿﺔ ﻓﻲ واﻗﻌﻨﺎ ) ﺳﻮاء ﻛﺎن ذﻟﻚ ﻧﻈﺎم ﺗﺴﺠﯿﻞ ﻓﻲ‬
‫ﻣﻌﮭﺪ‪ ،‬أو ﻧﻈﺎم إدارة ﻣﺨﺎزن ‪ ،‬أو ﻧﻈﺎم ﺗﻮﺟﯿﮫ ﺻﻮارﯾﺦ( ‪ ،‬ﯾﻤﻜﻨﻨﺎ ﺗﺤﺪﯾﺪ اﻟﻜﺎﺋﻨﺎت ﻓﻲ اﻟﻌﺎﻟﻢ‬
‫اﻟﻮاﻗﻌﻲ و ﺑﺴﮭﻮﻟﺔ ﻧﻘﻮم ﺑﺘﺤﻮﯾﻠﮭﺎ إﻟﻰ ﻛﺎﺋﻨﺎت ﺑﺮﻣﺠﯿﺔ‪.‬‬

‫وﺻﻨﺎع اﻟﻔﺌﺎت ھﻢ ﻛﻤﺎ ﻓﻲ ﻟﻌﺒﺔ اﻟﺮﺟﻞ اﻵ ﻟﻲ اﻟﺸﺮﻛﺔ اﻟﻤﺼﻨﻌﺔ ﻟﮭﺬه اﻟﻠﻌﺒﺔ واﻟﻤﺴﺘﺨﺪﻣﻮن ھﻢ‬
‫اﻷﻃﻔﺎل اﻟﺬﯾﻦ ﯾﻠﻌﺒﻮن ﺑﮭﺎ وﻻ ﯾﻌﻠﻤﻮن ﺷﯿﺌﺎ ﻋﻦ ﻃﺮﯾﻘﺔ ﻋﻤﻠﮭﺎ اﻟﺪاﺧﻠﯿﺔ ﻓﻘﻂ ﯾﺼﺪر اﻟﺼﺎﻧﻌﻮن‬
‫ﻟﻜﻲ ﯾﻌﺮف اﻟﻄﻔﻞ ﻛﯿﻒ ﯾﺴﺘﻤﺘﻊ ﺑﮭﺎ وھﻮ ﺗﻤﺎﻣﺎ ﻣﺎ ﯾﺤﺪث ﻓﻲ‬ ‫‪ Manual‬ﻟﻄﺮﯾﻘﺔ اﻻ ﺳﺘﺨﺪام‬
‫ﻛﺎﺋﻨﺎت ال ‪. OOP‬‬
‫اﻵن ھﻞ ﯾﻤﻜﻦ ﻓﻌﻼ أن ﺗﻜﻮن اﻟﺒﺮﻣﺠﺔ ﺑﮭﺬه اﻟﺴﮭﻮﻟﺔ ؟‬
‫ﻣﺼﻨﻌﻮ اﻟﻔﺌﺎت ﺳﯿﻜﻮن ﺑﺎﻟﻄﺒﻊ ﻋﻠﯿﮭﻢ اﻟﻌﺐء اﻷﻛﺒﺮ‬ ‫أﻗﻮل ﻧﻌﻢ إذا رﻛﺰ ﻛﻞ ﻋﻠﻰ ﻋﻤﻠﮫ ‪،‬‬
‫اﻟﻤﺴﺘﺨﺪﻣﻮن ﻗﺪ ﯾﻜﻮن ﻋﻠﯿﮭﻢ ﻋﺐء وﻗﺪ ﯾﻜﻮﻧﻮن ﻓﻲ ﻗﻤﺔ ﺣﺎﻻت اﻻﺳﺘﻤﺘﺎع ﺑﮭﺬا اﻟﻜﺎﺋﻦ ‪ ،‬ﺣﺎﻻت‬
‫اﻻﺳﺘﻤﺘﺎع ﻓﻲ اﻟﻮاﻗﻊ ﻛﻤﺎ ﻟﺪﯾﻨﺎ اﻟﻄﻔﻞ اﻟﺬي ﯾﻠﻌﺐ ﺑﺎﻟﻜﺎﺋﻦ اﻵﻟﻲ اﻟﻜﺎﻣﻞ وھﻲ أﺧﺮ ﻣﺮاﺣﻞ‬
‫اﻟﻜﺎﺋﻦ ﻷن اﻟﻄﻔﻞ ﻟﻦ ﯾﺴﺘﺨﺪم اﻟﻜﺎﺋﻦ ﻟﯿﻄﻮره ﻟﻜﺎﺋﻦ أﺧﺮ " إﻻ إذا ﻛﻨﺎ ﻓﻲ ﻋﺎﻟﻢ ال‬ ‫اﺳﺘﺨﺪام‬
‫‪ Matrix‬وﻧﺤﻦ ﻻ ﻧﻌﻠﻢ ! ﻓﻘﻂ ﺳﯿﻜﺘﻔﻲ ﺑﺎﻟﻠﻌﺐ ﺑﮫ ‪ ،‬أﻣﺎ ﻟﻮ ﻛﻨﺎ ﻓﻲ ﻣﺜﺎل أﺧﺮ ﻟﻮ ﻛﺎن اﻟﻜﺎﺋﻦ اﻟﺤﺎﻟﻲ‬
‫ﻟﺪﯾﻨﺎ ھﻮ ﻋﺒﺎرة ﻋﻦ ﻣﺤﺮك ﺳﯿﻜﻮن ھﻨﺎك ﺑﻌﺾ اﻟﻌﺐء ﻋﻠﻰ ﻣﺴﺘﺨﺪم اﻟﻜﺎﺋﻦ اﻟﺬي ﺳﯿﻘﻮم ﺑﺘﺮﻛﯿﺒﮫ‬
‫ﻣﻊ ﻋﺪة ﻛﺎﺋﻨﺎت أﺧﺮى ﻟﯿﻜﻮن ﻓﻲ اﻟﻨﮭﺎﯾﺔ ﻛﺎﺋﻨﺎ ﺟﺪﯾﺪا ‪ .‬ھﻨﺎ ﻧﺤﻦ ﻟﻢ ﻧﻨﺘﮭﻲ ﻣﻦ ﺳﻠﺴﻠﺔ اﻟﺘﻄﻮﯾﺮ ﻟﮭﺬا‬
‫اﻟﻜﺎﺋﻦ ﺑﻌﺪ ﻓﯿﻤﻜﻦ اﻋﺘﺒﺎر اﻟﻤﺴﺘﺨﺪﻣﯿﻦ ﻣﻄﻮرﯾﻦ ﺑﮭﺬا اﻟﻤﻔﮭﻮم ﻣﻄﻮرو اﻟﻤﺤﺮﻛﺎت ﺳﯿﺒﯿﻌﻮﻧﮭﺎ‬
‫ﻟﻤﺼﻨﻌﯿﻦ أﺧﺮﯾﯿﻦ وﺑﮭﺬا اﻟﺘﻜﺎﻣﻞ ﻧﺒﻨﻲ واﻗﻌﻨﺎ ﻓﻲ اﻟﺤﯿﺎة ﻧﻔﺲ اﻟﻤﻔﮭﻮم ﺗﻤﺎﻣﺎ ﻣﻮﺟﻮد ﻓﻲ ﻋﺎﻟﻢ‬
‫اﻟﺒﺮﻣﺠﺔ ‪ OOP‬ﻟﻜﻦ ﻣﻦ ﯾﺴﺘﻄﯿﻊ اﻟﻮﺻﻮل ﻟﮭﺬه اﻟﻤﺮاﺣﻞ ﻣﻦ اﻟﺘﻄﻮﯾﺮ ﻣﻦ ﻗﺎل أﻧﮫ ﻻ ﯾﻮﺟﺪ ﻟﻮ‬
‫دﺧﻠﺖ ورأﯾﺖ ﺑﺮﻣﺠﺔ اﻷﻟﻌﺎب ﺳﺘﺠﺪ اﻟﻌﺠﺐ اﻟﻌﺠﺎب ‪.‬‬
‫وﻟﻮ اﺿﻄﻠﻌﺖ ﻋﻠﻰ ﻧﻤﺎذج ﻣﺤﺎﻛﺎة اﻟﻮاﻗﻊ اﻻﻓﺘﺮاﺿﻲ ﻓﮭﻲ اﻟﻘﻤﺔ ﻓﻲ اﺳﺘﺨﺪام اﻟﻜﺎﺋﻨﺎت ﻹ ﻧﮭﺎ‬
‫ﺗﺒﻨﻰ أﺳﺎﺳﺎ ﻋﻠﻰ ﻣﺤﺎوﻟﺔ ﻣﺤﺎﻛﺎة ﻛﺎﺋﻦ ﻓﻲ اﻟﻄﺒﯿﻌﺔ ﺑﺸﻜﻞ ﺣﻘﯿﻘﻲ ﺗﻤﺎﻣﺎ ﻟﯿﻌﻤﻞ ﻋﻠﻰ اﻟﻜﻤﺒﯿﻮﺗﺮ‬
‫ﺑﻨﻔﺲ ﻃﺮﯾﻘﺔ ﻋﻤﻠﮫ ﻓﻲ اﻟﻄﺒﯿﻌﺔ ﻣﺜﻼ ﻣﺘﺘﺎﺑﻌﺎت اﻷﺷﻌﺔ وﻣﺤﺎﻛﺎة ﺣﺮﻛﺔ اﻟﺮﯾﺎح واﻷﻋﺎﺻﯿﺮ‬
‫ﻣﺤﺎﻛﯿﺎت أﺣﻮال اﻟﻄﻘﺲ ﻣﺤﺎﻛﯿﺎت اﻟﺘﻔﺎﻋﻼت اﻟﻜﯿﻤﯿﺎﺋﯿﺔ وﻏﯿﺮھﺎ ‪.‬‬
‫ﺔ ﺳﯿﻜﻮن اﻟﻤﻄﻮرون ﺑﺪاﯾﺔ ﻛﺎﺋﻦ ھﻮ ﻋﺒﺎرة ﻋﻦ ذرة‬ ‫ﻣﺜﻼ ﻓﻲ ﻣﺤﺎﻛﯿﺎت اﻟﺘﻔﺎﻋﻼت اﻟﻜﯿﻤﯿﺎﺋﯿ‬
‫ﺑﺎﻷﻟﻜﺘﺮوﻧﺎﺗﮭﺎ وﻧﻮاﺗﮭﺎ وﺑﻮزوﺗﺮوﻧﺎﺗﮭﺎ وﺑﺮوﺗﻮﻧﺎﺗﮭﺎ وﻛﻞ ﻣﺤﺘﻮﯾﺎﺗﮭﺎ ھﺬا اﻟﻜﺎﺋﻦ ﺳﯿﺪﻣﺞ ﻓﻲ ﻛﺎﺋﻦ‬
‫أﻛﺒﺮ ﻣﻨﮫ وھﻮ اﻟﺠﺰيء ﺳﯿﺘﻜﻮن ﻣﻦ ﻋﺪة ﻛﺎﺋﻨﺎت ذرة ﺛﻢ ﻧﺘﺪرج ﺣﺘﻰ ﻧﺼﻞ إﻟﻰ اﻟﻤﺎدة اﻟﻜﯿﻤﯿﺎﺋﯿﺔ‬
‫وﯾﻜﻮن ﻣﺒﺮﻣﺠﻮ اﻟﻜﺎﺋﻨﺎت اﻟﺴﻔﻠﯿﺔ ﻗﺪ اﻃﻠﻌﻮا ﻋﻠﻰ ﻛﯿﻔﯿﺔ ﺗﻔﺎﻋﻞ اﻟﺠﺰﯾﺌﺎت ﻣﻊ ﺑﻌﻀﮭﺎ ﺑﺸﻜﻞ ﺗﺎم ﺛﻢ‬
‫ﯾﺒﺪؤون ﺑﻜﺘﺎﺑﺔ " اﻟﺪوال ‪ ،‬اﻟﺘﻲ ﺳﺘﻘﻮم ﺑﻌﻤﻠﯿﺔ اﻻﻟﺘﺤﺎم اﻟﺪﻣﺞ ﺑﯿﻦ اﻟﺠﺰﯾﺌﺎت وﯾﻤﻺﻧﮭﺎ ﺑﻜﻞ ﺗﻔﺎﺻﯿﻞ‬
‫اﻟﺘﻔﺎﻋﻼت ﻓﻲ اﻟﻨﮭﺎﯾﺔ ﻓﻘﻂ ﻣﺎ ﻋﻠﻰ ﻣﺴﺘﺨﺪم اﻟﻜﺎﺋﻦ اﻟﻨﮭﺎﺋﻲ وھﻮ " ﻛﺎﺋﻦ ﺑﯿﺎﻧﺎت اﻟﻤﺤﻠﻮل " إن‬
‫ﻧﺪﺧﻞ ﻟﮫ ﺑﯿﺎﻧﺎت اﻟﻤﺤﻠﻮل اﻷول واﻟﺜﺎﻧﻲ وﻧﻄﻠﺐ ﻣﻨﮫ أن ﯾﺘﻔﺎﻋﻞ ﺑﯿﻨﮭﻤﺎ وﻧﻨﺘﻈﺮ ﻧﺘﯿﺠﺔ اﻟﺘﻔﺎﻋﻞ !‬
‫ھﺬه اﻷﺷﯿﺎء ﺑﺎﻟﻄﺒﻊ ﺗﺤﺘﺎج ﻟﻜﻤﺒﯿﻮﺗﺮات ﻋﻤﻼﻗﺔ ﺳﺮﯾﻌﺔ ﻟﺘﻨﻔﺬ ﻛﻞ ھﺬا اﻟﻜﻢ ﻣﻦ اﻟﺘﻌﻠﯿﻤﺎت ‪.‬‬

‫‪[email protected]‬‬ ‫‪299‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ﻟﻜﻦ ﯾﻤﻜﻦ اﻟﺘﺪرج وﺻﻮﻻ ﻟﻤﺴﺘﻮﯾﺎت ﻣﺒﺮﻣﺠﻲ اﻷﻟﻌﺎب ﺣﯿﺚ ﯾﻘﻮﻣﻮن ﺑﺒﻨﺎء أﻟﻌﺎﺑﮭﻢ ﻋﻠﻰ أﺳﺎس‬
‫اﻟﻜﺎﺋﻨﺎت ﻣﺜﻼ ﺧﺬ ﻋﻨﺪك ﻟﻌﺒﺔ ﺑﻠﯿﺎردو وھﻮ ﻣﺜﺎل أوﺿﺢ ﻧﻮﻋﺎ ﻣﺎ ‪.‬‬
‫ﻣﺎ ﻋﻠﻰ ﻣﻄﻮري اﻟﻠﻌﺒﺔ إﻻ اﺳﺘﺨﺪام ﻛﺎﺋﻨﺎت ﻛﺮة ﺑﻠﯿﺎردو " ﻹ ﻧﮭﺎ اﻟﺠﺰء اﻷﺻﻌﺐ " ﻛﺎﺋﻦ‬
‫اﻟﺒﻠﯿﺎردو ھﺬا ﺳﯿﺘﻌﺎﻣﻞ ﻛﻤﺎ ﻓﻲ اﻟﺤﯿﺎة اﻟﻮاﻗﻌﯿﺔ ﺗﻤﺎﻣﺎ ﺳﯿﻜﻮن اﻟﻜﺎﺋﻦ ﻋﺒﺎرة ﻋﻦ ﺟﺴﻢ ﻛﺮوي ﻟﮫ‬
‫ﻛﺘﻠﺔ ﺑﺎﻓﺘﺮاض أن اﻟﺠﺎذﺑﯿﺔ اﻷرﺿﯿﺔ ‪ 9.8‬ﺳﻨﻌﻄﯿﮫ أﯾﻀﺎ ﻣﻜﺎن ﻟﺘﺨﺰﯾﻦ ﻣﻌﻠﻮﻣﺎت ﻃﺎ ﻗﺘﮫ اﻟﺤﺮﻛﯿﺔ‬
‫وﻃﺎﻗﺘﮫ اﻟﻜﺎﻣﻨﺔ ﻓﻜﻞ ﻣﺎ ﻋﻠﯿﻨﺎ ھﻮ ﻛﺘﺎﺑﺔ داﻟﺔ ﻟﺘﻘﻮم ﺑﻌﻤﻠﯿﺔ اﻟﺘﺼﺎدم ﺑﺤﯿﺚ أن ﻛﻞ ﻛﺮة ﻋﻨﺪﻣﺎ‬
‫ﺗﺼﻄﺪم ﺑﻜﺮة أﺧﺮى ﺳﺘﺴﺘﻤﺪ ﻃﺎﻗﺔ ﺣﺮﻛﯿﺔ وﻃﺎﻗﺔ ﻛﺎﻣﻨﺔ داﺧﻠﮭﺎ ﺑﮭﺬا اﻟﻤﺒﺪأ ﯾﻤﻜﻦ أن ﻧﺤﺮك‬
‫ﻛﺮاﺗﻨﺎ وﻧﻨﺴﻰ ﺗﻤﺎﻣﺎ ﻛﯿﻔﯿﺔ ﺗﺼﺎدﻣﮭﺎ واﻧﻌﻜﺎﺳﮭﺎ !‬
‫أردت أن أﺑﯿﻦ ھﺬه اﻷﻣﻮر ﻹﻧﮭﺎ اﻷﺷﯿﺎء اﻟﺘﻲ ﻋﻘﺪت اﻟﻜﺜﯿﺮ ﻓﻲ ﻓﮭﻤﺎ ﺑﺎﻟﺸﻜﻞ اﻟﺼﺤﯿﺢ ﻟﻢ ﻷﺟﺪ‬
‫ﻛﺘﺎﺑﺎ ﯾﺘﺤﺪث ﻋﻨﮭﺎ ﺑﺎﻟﺸﻜﻞ اﻟﻤﻔﺮوض ﻛﻞ اﻟﻜﺘﺐ ﺗﻌﻄﻲ أﻣﺜﻠﺔ ﺳﻄﺤﯿﺔ ﺳﺮﯾﻌﺔ ﻣﺒﺎﺷﺮة ﻻ ﺗﻌﺒﺮ‬
‫ﻋﻦ اﻻﺳﺘﺨﺪام اﻷﻣﺜﻞ ﻟﻠﻜﺎﺋﻨﺎت ‪.‬‬
‫ﻓﻤﺜﻼ ﻟﻮ ﻗﻠﺖ ﻟﻚ ﻣﺜﺎل ﻣﺼﻌﺪ ﻛﮭﺮﺑﺎﺋﻲ ھﻮ ﻋﺒﺎرة ﻋﻦ ﻛﺎﺋﻦ ﺳﺘﻘﻮل ﻟﻲ ﯾﻤﻜﻦ أﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎ ﻛﮭﺬا‬
‫دون ا ﻟﺪﺧﻮل ﻓﻲ ﺗﻔﺎﺻﯿﻞ اﻟﻜﺎﺋﻨﺎت ﺑ ﺎﺳﺘﺨﺪام ﻟﻐﺔ إﺟﺮاﺋﯿﺔ ﺑﺴﯿﻄﺔ ! ﻓﯿﺼﺒﺢ اﻟﻤﺒﺮﻣﺞ اﻟﻤﺒﺘﺪئ‬
‫اﻟﺬي ﺳﯿﻜﻮن ﺿﯿﻖ اﻷﻓﻖ ﻓﻲ اﻟﺒﺪاﯾﺔ ﻣﺸﻮﺷﺎ ﻻ ﯾﻌﺮف اﻻﺳﺘﺨﺪام اﻷﻣﺜﻞ ﻟﮭﺬه اﻟﺘﻘﻨﯿﺔ ‪.‬‬
‫اﻟﻔﻠﺴﻔﯿﺔ أﻗﻮل أن اﻟﻤﺴﺘﻘﺒﻞ ﺳﯿﺤﻤﻞ ﻓﻘﻂ ﻟﻐﺎت ﻛﺎﺋﻨﯿﮫ‬ ‫أﺧﯿﺮا ﻗﺒﻞ أن أﻧﺘﮭﻲ ﻣﻦ ھﺬه اﻟ ﻤﻘﺪﻣﺔ‬
‫اﻟﻤﻨﺤﻰ ﻣﻦ ﻟﻢ ﯾﺮد ا ﻟﺪﺧﻮل ﻓﻲ ذﻟﻚ ﺳﯿﺴﻘﻂ وﻣﺎ ﻋﻠﯿﮫ إﻻ ﺑﺎﻧﺘﻈﺎر ﻗﺪره ‪ .‬ﻓﺄﻣﺮ اﻟﻜﺎﺋﻨﺎت ﻟﯿﺲ‬
‫ﻣﻌﻘﺪا ﺑﻞ ﻣﻔﮭﻮﻣﮫ ﻣﺨﺘﻠﻒ ﻓﻘﻂ و ﻟﻨﻔﺮض أن ﻟﺪﯾﻨﺎ ﻣﺒﺮﻣﺞ ﯾﺮﯾﺪ إﻧﺸﺎء ﻟﻌﺒﺔ ﺗﺼﻮﯾﺐ ﺛﻼﺛﯿﺔ‬
‫اﻷﺑﻌﺎد ﻣﺜﻞ ‪ Quake3‬ﻣﺜﻼ ﺑﮭﺎ ﺷﺨﺼﯿﺎت وأﻧﺎس ﯾﺘﺤﺮﻛﻮن وﯾﺘﺼﺮﻓﻮن ﺑﺸﻜﻞ ذﻛﻲ وﻛﺄن‬
‫ﻟﮭﻢ ﻋﻘﻮل ﯾﻔﻜﺮون ﺑﮭﺎ اﻵن اﻧﻈﺮ إﻟﻰ ﺣﺎل أ ﺣﺪ اﻟﻤﺒﺮﻣﺠﯿﻦ اﻟﻘﺎﺑﻌﯿﻦ أﻣﺎم أﺟﮭﺰﺗﮭﻢ ﻛﻞ اﻟﻮﻗﺖ‬
‫وھﻮ ﯾﻜﺘﺐ ﻛﻮد ﺗﻜﺎﻣﻞ اﻟﻠﻌﺒﺔ ﻣﻊ ﺑﻌﻀﮭﺎ ﻟﻮﻻ اﻟﻜﺎﺋﻨﺎت ﻓﻲ اﻟﺒﺮﻣﺠﺔ ﻟﻈﻞ ھﺬا اﻟﻤﺒﺮﻣﺞ ‪6‬‬
‫ﺳﻨﻮات وھﻮ ﯾﺤﺎول أن ﯾﺘﻜﺎﻣﻞ ﺑﯿﻦ أﻻف اﻷﺟﺰاء ﻓﻲ ﻣﻘﺎﺑﻞ أن ﯾﺠﻠﺲ ﺳﻨﺘﯿﻦ ﻓﻘﻂ وھﻮ ﯾﺴﺘﻌﻤﻞ‬
‫ﻛﻮد ﻟﻠﻜﺎﺋﻨﺎت ‪.‬‬
‫"اﻷﻟﻌﺎب اﻟﻜﺒﯿﺮة ﺗﺴﺘﻐﺮق ﻓﺘﺮة ﻣﺘﻮﺳﻄﮭﺎ ﺳﻨﺘﯿﻦ " ‪.‬‬
‫اﻵن ﻟﻨﻔﺮض ﻣﺜﻼ أن ھﺬا اﻟﻤﺒﺮﻣﺞ ﻻ ﯾﺴﺘﺨﺪم ﻛﻮد ﻛﺎﺋﻨﻲ ﺳﯿﻀﻄﺮ ﻓﻲ ﻛﻞ ‪ frame‬أن ﯾﺘﻜﻔﻞ‬
‫ﺑﺘﺤﺮﯾﻚ ﻛﻞ ﺷﺨﺼﯿﺔ ﻓﻲ اﻟﻠﻌﺒﺔ وﯾﻘﻠﻖ ﺑﺸﺄن ﺗﺼﺮﻓﮭﺎ ھﻞ ھﻮ ﺳﻠﯿﻢ أم ﻻ ھﻞ ﺗﻌﺪى اﻟﻜﺎﺋﻦ‬
‫اﻷﺧﺮ ﺣﺪود اﻟﻤﺸﮭﺪ أم ﻻ ھﻞ اﺻﻄﺪم ﺷﺨﺼﯿﻦ ﻣﻊ ﺑﻌﻀﮭﻤﺎ ﻓﻲ اﻟﻤﺸﮭﺪ أم ﻻ ﺳﯿﺠﻦ ﺟﻨﻮﻧﮫ‬
‫وھﻮ ﯾﺤﺎول ﻣﻼﺣﻘﺔ ھﺬه اﻻﺣﺘﻤﺎﻻت وﻛﻞ ﺗﻌﺪﯾﻞ ﻃﻔﯿﻒ ﺳﯿﺄﺧﺬ ﻣﻨﮫ وﻗﺘﺎ ﻛﺒﯿﺮا وﻛﻞ ﺗﻌﺪﯾﻞ ﻛﺒﯿﺮ‬
‫اﻟﮭﺎوﯾﺔ ھﺬا ﺑﺎﻟﻨﺴﺒﺔ ﻟﺤﺎل ﻣﺒﺮﻣﺞ واﺣﺪ ﻓﻤﺎ ﺑﺎﻟﻚ إذا ﺗﺸﺎرك‬ ‫ﯾﻤﻜﻦ أ ن ﯾﺆدي ﺑﺎﻟﻤﺸﺮوع إﻟﻰ‬
‫ﻓﺮﯾﻖ ﻟﺘﻄﻮﯾﺮ اﻟﻠﻌﺒﺔ ﯾﺠﺐ ﻋﻠﯿﮭﻢ أوﻻ أن ﯾﺘﻮاﺟﺪوا ﻓﻲ ﻣﻜﺎن واﺣﺪ واﺣﺘﻤﺎل ﺗﻀﺎرب اﻷﻛﻮاد‬
‫ﺑﯿﻨﮭﻢ ﻛﺒﯿﺮ ﻟﺪرﺟﺔ ﺗﺠﻌﻞ ﻣﻦ اﻟﻤﺴﺘﺤﯿﻞ ﺗﻨﻔﯿﺬ اﻟﻤﺸﺮوع ‪.‬‬
‫ﻓﻲ اﻟﻤﻘﺎﺑﻞ اﻓﺮض أن ﻣﺒﺮﻣﺠﻨﺎ ﯾﺴﺘﺨﺪم ﻛﻮد ﻛﺎﺋﻨﻲ اﻟﻤﻨ ﺤﻰ ﺳﯿﺘﻢ ﺗﻘﺴﯿﻢ أﻋﻀﺎء اﻟﻤﺸﺮوع إﻟﻰ‬
‫ﻓﺮق ﻛﻞ ﻓﺮﯾﻖ ﻟﮫ ﻣﮭﻤﺔ واﺿﺤﺔ ﻣﺤﺪدة ﻛﺎﻟﺸﻤﺲ ‪.‬‬
‫ﻣﺜﻼ اﻟﻔﺮﯾﻖ اﻟﺬي ﺳﯿﮭﺘﻢ ﺑﻜﺘﺎﺑﺔ ﻛﻮد اﻟﺸﺨﺼﯿﺎت ﺳﯿﻘﻮم ﺑﻜﺘﺎﺑﺔ ﻓﺌﺔ ﺗﻌﺮف اﻟﺸﺨﺼﯿﺔ وﯾﻀﻊ ﻛﻞ‬
‫اﻻﺣﺘﻤﺎﻻت اﻟﻤﻤﻜﻨﺔ ﻟﮭﺬه اﻟﺸﺨﺼﯿﺔ اﻟﺤﺮﻛﺔ اﻟﺘﺨﺎﻃﺐ اﻷﺻﻮات ﺣﺪود اﻟﻤﺸﮭﺪ اﻟﺘﺼﺎدم ﺑﯿﻦ‬

‫‪[email protected]‬‬ ‫‪300‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ﻣﺖ اﻟﺸﺨﺼﯿﺔ ﺑﺄﺧﺮى ﻗﺪ ﺗﺮﺗﺪ وﺗﺼﺪر ﺻﻮﺗﺎ ﻣﺜﻼ أو ﻏﯿﺮھﺎ ﻣﻦ‬ ‫اﻟﺸﺨﺼﯿﺎت ﻣﺎذا ﻟﻮ اﺻﻄﺪ‬
‫اﻻﺳﺘﺠﺎﺑﺎت ‪.‬‬
‫ﺣﺘﻰ اﻵن ھﺬا اﻟﻜﺎﺋﻦ ﺑﺪأ ﯾﺘﺠﺴﺪ ﺑﺎﻟﻄﺒﻊ ﺑﻌﺪ ﻣﻜﺎﻣﻠﺔ ﻓﺮﯾﻖ رﺳﻢ اﻟﺸﺨﺼﯿﺔ ﻣﻊ اﻟﻤﺒﺮﻣﺞ ﯾﺒﻘﻰ أﻣﺮ‬
‫ﻣﮭﻢ ﺑﺚ اﻟﺤﯿﺎة ﻓﻲ ھﺬه اﻟﺸﺨﺼﯿﺔ ! ﻛﯿﻒ ﯾﻤﻜﻦ ﺑﺚ اﻟﺤﯿﺎة ﻓﯿﮭﺎ ﺑﻌﺪ ﺗﻌﺮﯾﻒ اﻟﻔﺌﺔ وﺗﻌﺮﯾﻒ ﻛﻞ‬
‫اﻟﻤﺘﻐﯿﺮات اﻟﻀﺮورﯾﺔ ﻓﯿﮭ ﺎ واﻟﺪوال اﻟﺘﻲ ﺳﺘﻘﻮم ﺑﺎﻷﻣﻮر اﻟﻤﮭﻤﺔ ﺗﺒﻘﻰ اﻟﺪاﻟﺔ اﻷب اﻟﺘﻲ ھﻲ ﻓﻲ‬
‫اﻟﻌﻘﻞ اﻟﺒﺸﺮي اﻟﺬي ﯾﺤﺪد ﻣﺎ ﯾﺠﺐ ﻓﻌﻠﮫ ﺣﺴﺐ اﻟﺘﻐﯿﺮات اﻟﺨﺎرﺟﯿﺔ " ﻻ ﯾﻤﻜﻦ‬ ‫اﻟﻮاﻗﻊ ﻛ ﺈﻧﮭﺎ‬
‫ﺑﺎﻟﻄﺒﻊ ﺟﻌﻠﮭﺎ ﺗﺘﺼﺮف ﻛﺎﻟﻌﻘﻞ اﻟﺒﺸﺮي " ﻣﺜﻼ ﻟﻨﻔﺮض أن اﻟﺸﺨﺼﯿﺔ ﺳﺘﻜﻮن ﺣﺎرس ﻟﺒﻮاﺑﺔ وﻛﻞ‬
‫ﻣﻦ ﯾﻘﺘﺮب ﻣﻦ ھﺬه اﻟﺒﻮاﺑﺔ ﺳﯿﺘﻢ اﻟﺘﺼﺪي ﻟﮫ ‪.‬‬
‫ﺳﻨﻜﺘﺐ داﻟﺔ اﺳﻤﮭﺎ ‪ UpDate‬ﯾﺘﻢ اﺳﺘﺪﻋﺎءھﺎ ﻛﻞ ‪ Frame‬ﻣﺜﻼ ﺑﺤﯿﺚ ﯾﺘﻢ ﻣﺴﺢ داﺋﺮة ﻧﺼﻒ‬
‫ﻗﻄﺮھﺎ ‪ 8‬أﻣﺘﺎر ﻣﻦ اﻟﺸﺨﺼﯿﺔ وإذا وﺟﺪت ﺷﺨﺼﯿﺔ أﺧﺮى ﻓﻲ ھﺬا اﻟﻤﺪى ﺗﺴﺘﺪﻋﻰ داﻟﺔ أﺧﺮى‬
‫ﻟﺘﺤﻔﯿﺰ اﻟﻘﺘﺎل ! داﻟﺔ ﺗﺤﻔﯿﺰ اﻟﻘﺘﺎل ﺳﺘﺴﺘﺪﻋﻲ داﻟﺔ ﻟﺘﻐﯿﺮ وﺿﻌﯿﺔ اﻟﺸﺨﺼﯿﺔ اﻟﺮﺳﻮﻣﯿﮫ ﺛﻢ ﺗﺴﺘﺪﻋﻲ‬
‫داﻟﺔ اﻟﮭﺠ ﻮم وھﻜﺬا ﺑﺴﻠﺴﻠﺔ ﻛﮭﺬه ﻣﻦ اﻻﺣﺘﻤﺎﻻت اﻷﺳﺎﺳﯿﺔ ﯾﻜﻮن ﻟﺪﯾﻨﺎ ﻓﻲ اﻟﻨﮭﺎﯾﺔ ﻣﻘﺎﺗﻞ ﺻﻨﺪﯾﺪ‬
‫ﯾﺘﺼﺮف ﺑﺘﻠﻘﺎﺋﯿﺔ وﺑﺎﻟﺸﻜﻞ اﻟﻤﻄﻠﻮب ‪.‬‬
‫ﺳﻨﻮات وﻛﺄﻧﮫ ﯾﻘﻀﯿﮭﺎ ﻓﻲ اﻟﺴﺠﻦ وﻧﻌﻄﯿﮫ ﻓﺌﺔ‬ ‫اﻵن ﻓﻠﻨﻌﺪ ﻟﻤﺒﺮﻣﺠﻨﺎ اﻟﺬي ﻛﺎن ﺳﯿﻘﻀﻲ ‪6‬‬
‫اﻟﺸﺨﺼﯿﺔ وأﻧﻮاع اﻟﺸﺨﺼﯿﺎت اﻷﺧﺮى ﺳﯿﻜﻮن ﺳﻌﯿﺪا ﺟﺪا ﻷﻧﮫ ﻟﻦ ﯾﻔﻌﻞ ﺷﯿﺌﺎ ﻓﻲ ﻛﻞ ‪Frame‬‬
‫إﻻ أﻧﮫ ﺳﯿﺴﺘﺪﻋﻲ اﻟﺪاﻟﺔ ‪ UpDate‬ﻛﻞ ﻣﺮة وﯾﻨﺘﮭﻲ اﻷﻣﺮ ! ﻷن اﻟﺪاﻟﺔ ھﻲ اﻟﺘﻲ ﺳﺘﺠﻌﻞ اﻟﻜﺎﺋﻦ‬
‫ﯾﺘﺼﺮف ھﻜﺬا ﯾﻤﻜﻦ ﻟﻜﻞ ﻋﻀﻮ ﻓﻲ اﻟﻔﺮﯾﻖ أن ﯾﺮﻛﺰ ﻓﻘﻂ ﻋﻠﻰ ﻋﻤﻠﮫ وﺑﺸﻜﻞ ﻣﺪھﺶ‪ .‬وأن ﯾﻌﻤﻠﻮا‬
‫ﻣﻊ ﺑﻌﻀﮭﻢ ﺑﺸﻜﻞ ﻓﻌﺎل ﺣﺘﻰ ﻟﻮ ﻛﺎن ﺑﯿﻨﮭﻢ أﻻف اﻷﻣﯿﺎل !‬
‫اﻵن ھﺬه اﻟﻔﺌﺔ ﻓﺌﺔ اﻟﺸﺨﺼﯿﺔ ﺣﺠﻤﮭﺎ ﻗﺪ ﯾﻜﻮن ﻛﺒﯿﺮ ﻟﻜﻦ ﻣﺒﺮﻣﺞ اﻟﻠﻌﺒﺔ ﻟﻦ ﯾﻘﻠﻖ ﺑﺸ ﺈﻧﮭﺎ ﻓﻠﯿﺲ ﻟﮫ‬
‫أي ﻋﻼﻗﺔ ﺑﺤﺠﻤﮭﺎ ﻓﻘﻂ ﻛﻞ ﻣﺎ ﻋﻠﯿﮫ ھﻮ أن ﯾﻀﻌﮭﺎ وﯾﻘﺮأ ﻃﺮﯾﻘﺔ اﺳﺘﺨﺪام ھﺎ وﯾﻨﺴﻰ ﻛﻞ ﺷﻲء ‪،‬‬
‫وﯾﻌﺘﻤﺪ ﻋﻠﻰ أن ﻣﺒﺮﻣﺞ اﻟﻔﺌﺔ ﻗﺪ أﺗﻘﻦ ﻋﻤﻠﮫ ﻓﻌﻼ ھﻨﺎ ﺗﻘﺮﯾﺒﺎ ﯾﻜﻤﻦ اﻟﻌﺐء اﻷﻛﺒﺮ ﻋﻠﻰ ﻣﺒﺮﻣﺞ اﻟﻔﺌﺔ‬
‫ﺣﯿﺚ ﯾﺠﺐ أن ﯾﻜﻮن ﺣﺬرا وﯾﺘﺄﻛﺪ ﺑﺸﻜﻞ ﻛﺒﯿﺮ ﻣﻦ ﻋﻤﻞ اﻟﻔﺌﺔ ﺑﺎﻟﺸﻜﻞ اﻟﺼﺤﯿﺢ ‪.‬‬

‫‪ 9.1.3‬ﺧﻮاص اﻟﺒﺮﻣﺠﺔ اﻟﻤﻮﺟﮭﺔ‬

‫وﯾﻤﻜﻦ ﺗﻠﺨﯿﺺ ﺧﻮاص اﻟﺒﺮﻣﺠﺔ اﻟﻤﻮﺟﮭﺔ‪:‬‬
‫‪ -1‬ﺗﺮﻛﺰ ﻋﻠﻰ اﻟﺒﯿﺎﻧﺎت ﻓﻀﻼً ﻋﻠﻰ اﻹﺟﺮاءات‪.‬‬
‫‪ -2‬اﻟﺒﺮاﻣﺞ ﺗﻘﺴﻢ إﻟﻰ ﻣﺎ ﯾﺴﻤﻰ ‪) Objects‬أﺷﯿﺎء(‪.‬‬
‫‪ -3‬ھﯿﺎﻛﻞ اﻟﺒﯿﺎﻧﺎت ﺗﺼﻤﻢ ﺑﺤﯿﺚ ﺗﻌﻜﺲ ﺧﻮاص ‪.OOP‬‬
‫‪ -4‬اﻟﺪوال ﺗﺘﺮاﺑﻂ ﻣﻊ ﺑﻌﻀﮭﺎ اﻟﺒﻌﺾ ﻓﻲ ھﯿﺎﻛﻞ اﻟﺒﯿﺎﻧﺎت‪.‬‬
‫‪ -5‬اﻟﺒﯿﺎﻧﺎت ﻣﺨﻔﯿﺔ ‪ hidden‬وﻻ ﯾﻤﻜﻦ اﻟﻮﺻﻮل إﻟﯿﮭﺎ ﻣﻦ ﻗﺒﻞ داﻟﺔ ﺧﺎرﺟﯿﺔ‪.‬‬
‫ﯾﻤﻜﻦ أن ﺗﺘﺼﻞ ﻣﻊ ﺑﻌﻀﮭﺎ ‪ ،‬ﻣﻦ ﺧﻼل ﻣﺨﺎﻃﺒﺔ‬ ‫‪ -6‬اﻷﺷﯿﺎء ‪Objects‬‬
‫ﻣﺴﻠﻜﯿﺎﺗﮭﺎ‪.‬‬
‫‪ -7‬اﻟﺒﯿﺎﻧﺎت اﻟﺠﺪﯾﺪة واﻟﺪوال ﯾﻤﻜﻦ أن ﺗﻀﺎف ﺑﺴﮭﻮﻟﺔ ﻋﻨﺪ اﻟﺤﺎﺟﺔ‪.‬‬
‫‪ -8‬ﺗﺴﺘﺨﺪم ﻃﺮﯾﻘﺔ اﻷﺳﻔﻞ إﻟﻰ اﻷﻋﻠﻰ ‪ bottom-up‬ﻓﻲ ﺗﺼﻤﯿﻢ اﻟﺒﺮاﻣﺞ‪.‬‬

‫‪[email protected]‬‬ ‫‪301‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫‪ -9‬ﻃﺮﯾﻘﺔ اﻟﺘﻔﻜﯿﺮ ﺗﺨﺘﻠﻒ ﻋﻦ اﻻﺗﺠﺎه اﻟﻤﮭﯿﻜﻞ‪.‬‬
‫‪ -10‬ﻧﻘﻮم ﺑﺎﻟﺠﻤﻊ ﺑﯿﻦ اﻟﺒﯿﺎﻧﺎت و اﻟﺘﺼﺮﻓﺎت ذات اﻟﻌﻼﻗﺔ داﺧﻞ أﺻﻨﺎف‪.‬‬

‫ﻟﻤﺎذا اﻟﻜﺎﺋﻨﺎت ﻣﮭﻤﺔ ﺟﺪا ؟‬

‫ھﻨﺎك اﻟﻜﺜﯿﺮ ﻣﻦ اﻷﺳﺒﺎب ‪ ،‬دﻋﻨﻲ أﻋﻄﯿﻚ ﺑﻌﻀﺎھﺎ ‪:‬‬
‫‪ -1‬ﻗﺪرﺗﻚ ﻋﻠﻰ ﻣﻌﺮﻓﺔ ﻣﻜﺎن اﻟﺨﻄﺄ ﺑﺴﮭﻮﻟﺔ إذا ﺣﺼﻞ‪.‬‬
‫‪ -2‬اﻟﻘﺪرة ﻋﻠﻰ ﺗﺘﻄﻮﯾﺮ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺴﮭﻮﻟﺔ ﻣﻊ اﻟﻮﻗﺖ‪.‬‬
‫‪ -3‬اﻟﻘﺪرة ﻋﻠﻰ إﻋﺎدة اﺳﺘﺨﺪام اﻟﻜﺜﯿﺮ ﻣﻦ أﺟﺰاء اﻟﺒﺮﻧﺎﻣﺞ ﻟﺘﻄﻮﯾﺮ ﺑﺮاﻣﺞ أﺧﺮى‪.‬‬
‫‪ -4‬ﻋﺪم اﻟﺤﺎﺟﺔ ﻹﻋﺎدة ﻛﺘﺎﺑﺔ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﯿﺔ ﻋﻨﺪ ﻛﻞ إﺻﺪار ﺟﺪﯾﺪ ﻟﻠﺒﺮﻧﺎﻣﺞ‪.‬‬
‫‪ -5‬ﺳﮭﻮﻟﺔ ﺗﺤﻮﯾﻞ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﯿﺔ ﻟﻠﻐﺔ ﻣﺨﺘﻠﻔﺔ‪.‬‬
‫‪ -6‬اﻟﻘﺪرة ﻋﻠﻰ ﺗﻮزﯾﻊ اﻟﻌﻤﻞ ﻓﻲ ﺑﺮﻧﺎﻣﺞ واﺣﺪ ﺿﺨﻢ ﻋﻠﻰ أﻛﺜﺮ ﻣﻦ ﻣﺒﺮﻣﺞ ﺑﺴﮭﻮﻟﺔ وﯾﺴﺮ‪.‬‬

‫‪ 9.1.4‬إﺳﺘﺮاﺗﺠﯿﺔ اﻟﻤﻨﺤﻰ اﻟﻜﺎﺋﻨﻲ‬

‫ﺑﺎﻟﺮﻏﻢ ﻣﻦ أن ھﺬا اﻟﻔﺼﻞ ﻗﺪ ﻟﻤﺲ ﺑﺎﺧﺘﺼﺎر ﻓﻮاﺋﺪ اﻟﻤﻨﺤﻰ ﻟﻠﻜﺎﺋﻦ ) ﻣﺜﻞ‪ :‬ﻣﻨﻈﻮﻣﺎت أﻛﺜﺮ ﺛﺒﺎﺗ ﺎ‪،‬‬
‫ﺗﻤﺜﯿﻞ أﻓﻀﻞ ﻟﻠﻮاﻗﻊ( ‪ ،‬إﻻ أﻧﻨﺎ ﺗﺮﻛﻨﺎ ﺑﻌﺾ اﻷﺳﺌﻠﺔ ﺑﺪون إﺟﺎﺑﺔ‪ .‬ﻛﯿﻒ ﻧﻤﯿّﺰ اﻟﻜﺎﺋﻨﺎت اﻟﺘﻲ‬
‫ﻧﺤﺘﺎﺟﮭﺎ ﻋﻨﺪ ﺗﺼﻤﯿﻤﻨﺎ ﻟﻤﻨﻈﻮﻣﺔ ﻣﺎ؟‬
‫ﻣﺎ ھﻲ اﻟﺴﻤﺎت ‪ attributes‬اﻟﻤﻔﺘﺮض وﺟﻮدھﺎ؟ ﻣﺎ ھﻮ اﻟﺤﺠﻢ اﻟﻤﻨﺎﺳﺐ ﻟﻠﺼﻨﻒ؟ و ﻏﯿﺮھﺎ‬
‫ﻣﻦ اﻷﺳﺌﻠﺔ‪.‬‬

‫أﺣﺪ أھﻢ ﻧﻘﺎط ﺿﻌﻒ اﻟﻤﻨﺤﻰ ﻟﻠﻜﺎﺋﻦ ﻓﻲ اﻟﻤﺎﺿﻲ ھﻮ إﻧﮭﺎ ﻓﻲ اﻟﻮﻗﺖ اﻟﺬي ﺗﺘﻤﯿّﺰ ﻓﯿﮫ ﺑ ﺈﻧﮭﺎ ﻗﻮﯾﺔ‬
‫ﻋﻠﻰ ﻣﺴﺘﻮى اﻟﺼﻨﻒ‪/‬اﻟﻜﺎﺋﻦ‪ ،‬إﻻ إﻧﮭﺎ ﺿﻌﯿﻔﺔ ﻋﻨﺪ اﻟﺘﻌﺒﯿﺮ ﻋﻦ ﺳﻠﻮك اﻟﻤﻨﻈﻮﻣﺔ ﻛﻜﻞّ‪ .‬اﻟﻨﻈﺮ ﻣﻦ‬
‫ﺧﻼل اﻷﺻﻨﺎف ﺷﻲء ﺟﯿّﺪ‪ ،‬ﻟﻜﻦ اﻷﺻﻨﺎف ﻓﻲ ﺣﺪ ذاﺗﮭﺎ ھﻲ ﻛﯿﻨﻮﻧﺎت ﻋﻠﻰ ﻣﺴﺘﻮى ﻣﻨﺨﻔﺾ و‬
‫ﻻ ﯾﻤﻜﻦ ﻟﮭﺎ أن ﺗﺼﻒ ﻣﺎ ﺗﻘﻮم ﺑﮫ اﻟﻤﻨﻈﻮﻣﺔ ﻛﻜﻞ‪ .‬ﺑ ﺎﺳﺘﺨﺪام اﻷﺻﻨﺎ ف ﻓﻘﻂ ﻓﺈن اﻷﻣﺮ ﯾﺸﺒﮫ‬
‫ﻣﺤﺎوﻟﺔ ﻓﮭﻢ ﻛﯿﻔﯿﺔ ﻋﻤﻞ اﻟﺤﺎﺳﻮب ﻣﻦ ﺧﻼل ﻓﺤﺺ ﻣﻜﻮﻧﺎت اﻟﻠﻮﺣﺔ اﻷم!‬

‫اﻻﺗﺠﺎه اﻟﺤﺪﯾﺚ و اﻟﻤﺪﻋﻮم ﺑﻘﻮة ﻣﻦ ﻗﺒﻞ ‪ UML‬ھﻮ ﻧﺴﯿﺎن ﻛﻞّ ﻣﺎ ﯾﺘﻌﻠّﻖ ﺑﺎﻟﻜﺎﺋﻨﺎت و اﻷﺻﻨﺎف‬
‫ﻓﻲ اﻟﻤﺮاﺣﻞ اﻟﻤﺒﻜّﺮة ﻟﻠﻤﺸﺮوع‪ ،‬و اﻟﺘﺮﻛﯿﺰ ﺑﺪل ذﻟﻚ ﻋﻠﻰ ﻣﺎ ﯾﺠﺐ أن ﺗﻜﻮن اﻟﻤﻨﻈﻮﻣﺔ ﻗﺎدرة‬
‫ﺑﻌﺪ ذﻟﻚ‪ ،‬و ﻣﻊ ﺗﻘﺪّم اﻟﻌﻤﻞ ﻓﻲ اﻟﻤﺸﺮوع ﯾﺘﻢ ﺗﺪرﯾﺠﯿﺎ ﺑﻨﺎء اﻷﺻﻨﺎف ﻟﺘﺠﺴﯿﺪ‬ ‫ﻋﻠﻰ اﻟﻘﯿ ﺎم ﺑﮫ‪.‬‬
‫اﻟﻨﻮاﺣﻲ اﻟﻮﻇﯿﻔﯿﺔ ﻟﻠﻤﻨﻈﻮﻣﺔ اﻟﻤﻄﻠﻮﺑﺔ‪.‬‬

‫‪Abstract Data Type‬‬ ‫‪ 9.2‬أﻧﻮاع اﻟﺒﯿﺎﻧﺎت اﻟﺘﺠﺮﯾﺪﯾﺔ )‪(ADT‬‬

‫‪[email protected]‬‬ ‫‪302‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ﻓﻲ ﺟﻤﯿﻊ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ﺗﻮﺟﺪ أﻧﻮاع ﻣﻌﺮﻓﺔ ﻣﺴﺒﻘﺎً ﻣﻦ ﻗﺒﻞ ﻣﺘﺮﺟﻢ اﻟﻠﻐﺔ‪ .‬ﻣﺜﻼً ‪ int‬ﯾﻌﺘﺒﺮ ﻧﻮع‬
‫ﻧﻘﻮم ﺑﺎﺳﺘﺨﺪام ه ﻟﻤﻌﺎﻟﺠﺔ ‪ Manipulate‬اﻷرﻗﺎم اﻟﺼﺤﯿﺤﺔ ‪ ،‬واﻟﻤﻘﺼﻮد ﺑﻜﻠﻤﺔ ﻣﻌﺎﻟﺠﺔ ھﻨﺎ ھﻮ‬
‫إﺟﺮاء اﻟﻌﻤﻠﯿﺎت اﻟﻤﻌﺘﺎدة ﻋﻠﻰ ھﺬا اﻟﻨﻮع ﻣﺜﻞ "‪ "/ * + -‬وھﻜﺬا ‪ ،‬ﻷن اﻟﺠﻤﻊ واﻟﻄﺮح واﻟﻀﺮب‬
‫ﻋﻤﻠﯿﺎت ﺗﺠﺮى ﻋﺎدة ﻋﻠﻰ اﻷرﻗﺎم‪.‬‬

‫‪ ADT‬ھﻲ ﻗﺎﻋﺪة اﻷﺳﺎس ﻓﻲ اﻟﺒﺮﻣﺠﺔ ﺑﻄﺮﯾﻘﺔ ‪ ، OOP‬وھﻲ اﻟﺨﻄﻮة اﻷوﻟﻰ اﻟﺘﻲ ﯾﺘﻢ ﻓﯿﮭﺎ‬
‫ﺗﺼﻤﯿﻢ وﺗﻌﺮﯾﻒ أﻧﻮاع ﺟﺪﯾﺪة‪ .‬ھﺬه اﻷﻧﻮاع اﻟﺠﺪﯾﺪة ﯾﺘﻢ ﺗﻌﺮﯾﻔﮭﺎ وﺗﺮﺟﻤﺘﮭﺎ ﻣﻦ أوﺻﺎف وأﻓﻌﺎل‬
‫اﻟﻨﻮع ﻧﻔﺴﮫ‪ ،‬ﻓﺎﻷوﺻﺎف ﯾﺘﻢ اﻟﺘﻌﺒﯿﺮ ﻋﻨﮭﺎ ﺑﻤﺘﻐﯿﺮات ‪ ، Variables‬و اﻷﻓﻌﺎل ﯾﺘﻢ اﻟﺘﻌﺒﯿﺮ ﻋﻨﮭﺎ‬
‫ﺑﺪوال ‪Functions‬ﻛﻤﺎ ﻓﻲ اﻟﺠﺪول ‪.9-1‬‬

‫ﺟﺪول ‪9-1‬‬
‫أﻓﻌﺎل‬ ‫أوﺻﺎف‬ ‫اﻟﺸﺊ ‪ /‬اﻟﻜﺎﺋﻦ‬
‫ﻟﻮن ‪ ،‬ﻋﺪد اﻷﺑﻮاب ‪ ،‬ﻟﻮن ‪ ،‬ﺗﺸﻐﯿﻞ ‪ ،‬إﯾﻘﺎف ‪ ،‬ﺗﻐﯿﯿﺮ‬ ‫ﺳﯿﺎرة‬
‫ﺳﺮﻋﺎت ‪... ،‬‬ ‫ﺳﺮﻋﺔ ‪ ،‬ﻧﻮع ‪ ،‬أﺳﻢ ‪..،‬‬
‫ﺗﺮﻛﯿﺐ ‪ ،‬ﺗﻨﻈﯿﻒ ‪،‬‬ ‫ﻟﻮن ‪ ،‬ﻧﻮع اﻟﻘﻤﺎش ‪،‬ﻋﺪد‬ ‫ﺻﺎﻟﻮن‬
‫ﻓﻚ‪...‬‬ ‫اﻟﻜﺮاﺳﻲ ‪... ،‬‬

‫اﻷوﺻﺎف واﻷﻓﻌﺎل اﻟﺘﻲ ﯾﺘﻢ ﺗﻌﺮﯾﻔﮭﺎ ﻟﮭﺬه اﻷﻧﻮاع اﻟﺠﺪﯾﺪة ﺗﺨﺘﻠﻒ ﻣﻦ ﺑﺮﻧﺎﻣﺞ إﻟﻰ أﺧﺮ ‪ ،‬ﻓﻤﺜ ً‬
‫ﻼ‬
‫ﻟﻮ أردﻧﺎ أن ﻧﻘﻮم ﺑﺘﻌﺮﯾﻒ ﻧﻮع ﺳﯿﺎرة ﻻﺳﺘﺨﺪام ه ﻓﻲ ﺑﺮﻧﺎﻣﺞ ﺗﺤﻜﻢ ﺑﺎﻟﺴﺮﻋﺎت ﻓﺈن ﻟﻮن اﻟﺴﯿﺎرة‬
‫ﺳﯿﻜﻮن ﻏﯿﺮ ﻣﮭﻢ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻨﺎ‪.‬‬

‫ﯾﺴﻤﻰ ھﺬا اﻟﻨﻮع ﻣﻦ اﻟﺒﯿﺎﻧﺎت ﺑﺎﻟﺒﯿﺎﻧﺎت اﻟﺘﺠﺮﯾﺪﯾﺔ وذﻟﻚ ﻹﻧﮭﺎ ﻻزاﻟﺖ ﺗﺤﺘﺎج إﻟﻰ ﺗﻌﺮﯾﻒ ﻣﺤﺪد‬
‫ﻻﺳﺘﺨﺪام ھﺎ ﻣﻦ ﻗﺒﻞ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ‪ ،‬ﻓﻨﻮع اﻟ ﻘﻤﺎش ﻣﺜﻼً ﻋﺒﺎرة ﻋﻦ ﻣﻌﻠﻮﻣﺔ ﯾﺠﺐ ﺗﺮﺟﻤﺘﮭﺎ ﺣﺘﻰ‬
‫ﯾﻤﻜﻦ اﻟﺘﻌﺒﯿﺮ ﻋﻨﮭﺎ ‪ ،‬ﻓﻤﺜﻼً ‪:‬‬
‫‪int Fabric; // 1=Blue, 2=Red….‬‬
‫أو‬

‫… ‪char Fabric; // B=blue, R=red,‬‬

‫‪ 9.3‬اﻷﺷﯿﺎء )‪(Objects‬‬

‫ﺗﻌﺪ اﻷﺷﯿﺎء اﻟﻮﺣﺪة اﻷﺳﺎﺳﯿﺔ ﻓﻲ ﻧﻈﺎم اﻟﺒﺮﻣﺠﺔ اﻟﺸﯿﺌﯿﺔ ‪ OOP system‬ﺣﯿﺚ ﯾﻤﻜﻦ أن ﻧﻤﺜﻞ‬
‫ﺷﺨﺺ ‪ ،‬ﻣﻜﺎن ‪ ،‬ﺣﺴﺎب ﻓﻲ ﻣﺼﺮف ‪ ،‬أو ﯾﻤﻜﻦ أن ﻧﻤﺜﻞ ﺑﯿﺎﻧﺎت ﺗﻌﺮف ﻣﻦ ﻗﺒﻞ اﻟﻤﺴﺘﺨﺪم ﻣﺜﻞ‬
‫اﻟﻤﺘﺠﮭﺎت ‪ ،vectors‬اﻟﻘﻮاﺋﻢ ‪ lists‬وﺗﺄﺧﺬ اﻷﺷﯿﺎء ﻣﺴﺎﺣﺔ ﻓﻲ اﻟﺬاﻛﺮة وﻟﮭﺎ ﻋﻨﻮان ﻣﺜﻞ اﻟﻘﯿﻮد‬
‫ﻟﺬﻟﻚ ﻧﺴﺘﻄﯿﻊ أن ﻧﻘﻮل أن اﻟﻜﻠﻤﺔ ﺷﻲء ‪ Object‬ﻣﻌﻨﻰ ﻣﺤﺪد ﻓﻲ اﻟﺒﺮﻣﺠﺔ‬ ‫‪. Records‬‬

‫‪[email protected]‬‬ ‫‪303‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫اﻟﺸﯿﺌﯿﺔ ‪ OOP‬ﻓﮭﻮ ﯾﻤﺘﻠﻚ ﺧﻮاص وﻣﻨﮭﺠﯿﺔ‪ ،‬وھﻮﯾﺔ ﻓﺒﺎﻟﻨﺴﺒﺔ ﻟﻠﺨﻮاص ‪ Attribute‬ﺗﺸﯿﺮ إﻟﻰ‬
‫اﻟﺒﯿﺎﻧﺎت اﻟﺘﻲ ﯾﺤﻔﻈﮭﺎ ﻛﻞ ﺷﻲء ﺧﺎص ﺑﮫ‪ ،‬أﻣﺎ ﻣﻨﮭﺠﯿﺔ ‪ Methods‬ﻓﺘﺸﯿﺮ إﻟﻰ اﻟﻘﻮاﻋﺪ اﻟﺘﻲ‬
‫ﺗﺤﻜﻢ ﺳﻠﻮك اﻟﺸﻲء ‪ Object Behavior‬ﻛﺎﺳﺘﺠﺎﺑﺔ اﻟﺮﺳﺎﺋﻞ ﺣﯿﺚ ﯾﻤﺜﻞ إرﺳﺎل اﻟﺮﺳﺎﻟﺔ‬
‫‪ Message‬ھﻮ اﻟﻌﻤﻞ اﻟﺬي ﯾﺆدﯾﮫ اﻟﺸﻲء ﻛﻄﻠﺐ ﻣﻦ ﺷﻲء أﺧﺮ‪ .‬ﻛﻤﺎ ﯾﺤﺘﺎج ﻛﻞ ﺷﻲء إﻟﻰ‬
‫ھﻮﯾﺔ ‪ Identity‬ﻓﺮﯾﺪة ﻟﺘﻤﯿﺰه ﻋﻦ ﻛﻞ اﻷﺷﯿﺎء اﻷﺧﺮى‪.‬‬

‫وﯾﻤﻜﻦ رﺳﻢ اﻷﺷﯿﺎء ﻛﺼﻨﺪوق ﻟﮫ ﺣﺎﻓﺎت داﺋﺮﯾﺔ ﻟﮫ اﺳﻢ اﻟﺸﻲء وﺗﻘﻊ ﺧﻮاﺻﮫ وﻣﻨﮭﺠﯿﺘﮫ داﺧﻞ‬
‫اﻟﺼﻨﺪوق واﻟﺸﻜﻞ ‪ 9-3‬ﯾﻤﺜﻞ رﺳﻤﯿﻦ اﻷول )‪ (a‬ﯾﻤﺜﻞ ﻃﺮﻗﺘﯿﻦ ﻟﺘﻤﺜﯿﻞ ﺷﻲء وھﻮ أﻣﺎ اﻟﺮﺳﻢ‬
‫اﻟﺜﺎﻧﻲ )‪ (b‬ﻓﯿﻤﺜﻞ ﺷﯿﺌﯿﯿﻦ أﺣﺪاھﻤﺎ ﯾﺮﺳﻞ رﺳﺎﻟﺔ ﻟﻸﺧﺮ‪.‬‬

‫ﺷﻜﻞ ‪ (a) 9-3‬ﻃﺮﯾﻘﺔ ﻟﺘﻤﺜﯿﻞ اﻟﺸﻲء‬

‫‪[email protected]‬‬ ‫‪304‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ﺷﻜﻞ ‪ (b) 9-3‬ﯾﻮﺿﺢ ﺻﻨﺪوﻗﯿﻦ ﻟﺸﯿﺌﯿﻦ ﺗﺮﺳﻞ أﺣﺪاھﻤﺎ رﺳﺎﻟﺔ ﻟﻸﺧﺮ‬

‫‪ 9.4‬اﻟﺼﻨﻒ ‪class‬‬

‫أن ﻣﺠﻤﻮﻋﺔ اﻟﺒﯿﺎﻧﺎت واﻟﺒﺮاﻣﺞ ﻟﺸﻲء ﻣﺎ ﯾﻤﻜﻦ أن ﺗﻜﻮن ﻧﻮع ﻣﻦ اﻟﺒﯿﺎﻧﺎت اﻟﻤﻌﺮﻓﺔ ﻣﻦ ﻗﺒﻞ‬
‫اﻟﻤﺴﺘﺨﺪم وذﻟﻚ ﺑ ﺎﺳﺘﺨﺪام اﻟﺼﻨﻒ ‪ ، class‬ﻟﺬﻟﻚ ﻓﺈن اﻟﺼﻨﻒ ﯾﻌﺪ ﻓﻜﺮة ‪ OOP‬اﻟﺘﻲ ﺗﻐﻠﻒ‬
‫اﻟﺒﯿﺎﻧﺎت واﻹﺟﺮاءات اﻟﻤﺘﻄﻠﺒﺔ ﻟﻮﺻﻒ اﻟﻤﺤﺘﻮى واﻟﺴﻠﻮك ﻟﻮﺟﻮد اﻟﻌﺎﻟﻢ اﻟﺤﻘﯿﻘﻲ ‪ .‬وﺣﺎﻟﻤﺎ ﯾﻌﺮف‬
‫‪ Class‬ﯾﻤﻜﻦ أن ﺗﻮﻟﺪ ﻋﺪد ﻣﻦ اﻷﺷﯿﺎء ‪ Object‬اﻟﺘﻲ ﺗﻨﺘﻤﻲ إﻟﻰ ‪ . Class‬وﻓﻲ ﺿﻮء ذﻟﻚ‬
‫ﻓﺈن اﻟﺼﻨﻒ ‪ Class‬ﯾﻌﺪ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻷﺷﯿﺎء ‪ Object‬اﻟﻤﺘﺸﺎﺑﮫ اﻟﻨﻮع ﻓﻌﻠﻰ ﺳﺒﯿﻞ اﻟﻤﺜﺎل ﻓﺈن‬
‫ﺻﻨﻒ اﻟﻔﺎﻛﮭﺔ ﯾﻀﻢ أﻧﻮاﻋﺎً ﻋﺪﯾﺪة ﻣﺜﻞ اﻟﺘﻔﺎح واﻟﺒﺮﺗﻘﺎل و اﻟﻤﻨﺠﺔ وﻏﯿﺮھﺎ‪.‬‬

‫ﺻﻨﻒ واﺣﺪ ﻣﺘﻰ ﻣﺎ ﻗﺪﻣﺖ ﻧﻔﺲ اﻟﺴﻄﺢ اﻟﺒﯿﻨﻲ ﻟﻠﻌﺎم اﻟﺨﺎرﺟﻲ‪،‬‬ ‫وﯾﻤﻜﻦ اﻟﻘﻮل أن ﺷﯿﺌﺎن إﻟﻰ‬
‫ﻓﻀﻼً ﻋﻦ اﺳﺘﺨﺪام ھﻤﺎ ﻧﻔﺲ ھﯿﻜﻞ اﻟﺨﻮاص ﻓﻲ ﺗﺨﺰﯾﻦ ﺑﯿﺎ ﻧﺎﺗﮭﺎ اﻟﺪاﺧﻠﯿﺔ وﻧﻔﺲ اﻟﻤﻨﮭﺠﯿﺔ ﻓﻲ‬
‫اﻻﺳﺘﺨﺪام ﻟﻠﺮﺳﺎﺋﻞ‪.‬‬

‫وﯾﻀﻢ اﻟﺼﻨﻒ ‪ Class‬ﺳﻄﺢ ﺑﯿﻨﻲ ‪ Interface‬وھﯿﻜﻞ ﺧﻮاص وﻣﻨﮭﺠﯿﺔ ﻟﻸﺷﯿﺎء اﻟﺘﻲ ﺗﻨﺘﻤﻲ‬
‫ﻟﮭﺎ‪ .‬ﺣﯿﺚ ﯾﺒﯿﻦ ﺷﻜﻞ ‪ 9-4‬ﺑﺴﯿﻂ ﺟﺪا ﻣﻦ ﺻﻨﻒ اﻟﺤﺴﺎب اﻟﺒﻨﻜﻲ ‪ ،‬واﻟﺬي ﯾﺤﻮي ﻋﻠﻰ اﻟﺒﯿﺎﻧﺎت‬
‫واﻟﻌﻤﻠﯿﺎت ‪:‬‬

‫‪[email protected]‬‬ ‫‪305‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ﺷﻜﻞ ‪ 9-4‬ﯾﺒﯿﻦ ﺻﻨﻒ اﻟﺤﺴﺎب اﻟﺒﻨﻜﻲ‬

‫‪ 9.4.1‬إﻧﺸﺎء اﻷھﺪاف‬
‫ﯾﺘﻢ ﺗﻌﺮﯾﻒ اﻷﺻﻨﺎف ﻓﻲ ﻟﻐﺔ ‪ Java‬ﻋﻦ ﻃﺮﯾﻖ اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ ،class‬ﺣﯿﺚ ﯾﺘﺒﻌﮭﺎ اﺳﻢ‬
‫وﻋﻨﺪ اﺧﺘﯿﺎر اﺳﻢ ﻟﻠﺼﻨﻒ ﻻ ﺑﺪ ﻣﻦ ﺗﻄﺒﯿﻖ اﻟﻘﻮاﻋﺪ اﻟﺨﺎﺻﺔ ﺑﺎﻷﺳﻤﺎء ‪ .‬واﻟﻤﺜﺎل‬ ‫اﻟﺼﻨﻒ‪،‬‬
‫‪ Account.Java‬ﯾﺒﯿﻦ ﻛﯿﻔﯿﺔ ﺗﻌﺮﯾﻒ اﻟﺼﻨﻒ ‪ ، Account‬ﻟﻜﻦ دون وﺟﻮد ﺟﻤﻞ ﺗﻨﻔﯿﺬﯾﺔ‬
‫ﻷﻧﮫ ﻟﻠﺘﻮﺿﯿﺢ ﻓﻘﻂ‪.‬‬

‫‪[email protected]‬‬ ‫‪306‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ﺷﺮح اﻟﻤﺜﺎل‪:‬‬
‫ﻛﻤﺎ ﻧﻼﺣﻆ ﻓﻲ اﻟﻤﺜﺎل ﻓﺈن ﻋﻤﻠﯿﺔ ﺗﻌﺮﯾﻒ اﻷﺻﻨﺎف ﺗﻜﻮن ﺑﺎﻟﻄﺮﯾﻘﺔ اﻵﺗﯿﺔ‪:‬‬
‫‪ -‬ﻧﺒﺪأ ﺑﺎﺳﻢ اﻟﺼﻨﻒ )‪ (class name‬وﯾﻤﻜﻦ أن ﯾﻜﻮن ﻣﺴﺒﻮﻗﺎً ﺑﻜﻠﻤﺔ ‪public‬‬
‫)وﺗﻌﻨﻲ ﻋﺎم( وھﺬا ﯾﻌﻨﻲ أﻧﺔ ﯾﻤﻜﻦ ﻷي ﺻﻨﻒ آﺧﺮ أن ﯾﻘﻮم ﺑﺈﻧﺸﺎء ﻧﺴﺦ ﻣﻦ‬
‫ھﺬا اﻟﺼﻨﻒ ‪ ،‬أﻣﺎ إذا ﻟﻢ ﺗﻮﺿﻊ اﻟﻜﻠﻤﺔ ‪ public‬ﻓﻲ ﻋﻤﻠﯿﺔ اﻟﺘﻌﺮﯾﻒ ﻓﺄن‬
‫اﻷﺻﻨﺎف داﺧﻞ ﻧﻔﺲ اﻟﺤﺰﻣﺔ اﻟﺘﻲ ﯾﻮﺟﺪ ﺑﮭﺎ ھﺬا اﻟﺼﻨﻒ ھﻲ وﺣﺪھﺎ ﺗﺴﺘﻄﯿﻊ‬
‫إﻧﺸﺎء ﻧﺴﺦ ﻣﻦ ھﺬا اﻟﺼﻨﻒ‪.‬‬
‫‪ -‬ﺛﻢ ﺑﻌﺪ ذﻟﻚ ﻧﺒﺪأ ﺑﺘﻌﺮﯾﻒ اﻟﻤﺘﻐﯿﺮات ﻛﻤﺎ ﻓﻲ اﻷﺳﻄﺮ)‪ (6-4‬وﻛﻤﺎ ﻧﻼﺣﻆ ﻓﺈن‬
‫اﻟﻤﺘﻐﯿﺮات ﻣﺴﺒﻮﻗﺔ ﺑﻜﻠﻤﺔ ‪) private‬وﺗﻌﻨﻲ ﺧﺎص( وھﺬا ﯾﻌﻨﻲ أن اﻟﻤﺘﻐﯿﺮات‬
‫ﯾﻤﻜﻦ اﻟﺘﻌﺎﻣﻞ ﻣﻌﺎ داﺧﻞ ھﺬا اﻟﺼﻨﻒ ﻓﻘﻂ‪ ،‬أﻣﺎ إذا ﻛﺎﻧﺖ ﻣﺴﺒﻮﻗﺔ ﺑﺎﻟﻜﻠﻤﺔ‬
‫‪ public‬ﻓﺈن ﺟﻤﯿﻊ اﻷﺻﻨﺎف ﯾﻤﻜﻨﮭﺎ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ھﺬه اﻟﻤﺘﻐﯿﺮات ﺑﻌﺪ إﻧﺸﺎء‬
‫ﻧﺴﺨﺔ ﻣﻦ ھﺬا اﻟﺼﻨﻒ‪ ،‬أﻣﺎ إذا ﻟﻢ ﻧ ﻀﻊ ﺷﻲء ﻓﺈن اﻷﺻﻨﺎف داﺧﻞ ﻧﻔﺲ‬
‫اﻟﺤﺰﻣﺔ اﻟﺘﻲ ﯾﻮﺟﺪ ﺑﮭﺎ ھﺬا اﻟﺼﻨﻒ ھﻲ وﺣﺪھﺎ ﺗﺴﺘﻄﯿﻊ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ھﺬه‬
‫اﻟﻤﺘﻐﯿﺮات ‪.‬‬
‫‪ -‬وﻓﻲ اﻷﺳﻄﺮ )‪ (7-12‬ﺗﻢ ﺗﻌﺮﯾﻒ اﻟﻌﻤﻠﯿﺎت )اﻟﻤﻨﺎھﺞ( ﻋﻠﻰ اﻟﺼﻨﻒ‪.‬‬

‫‪[email protected]‬‬ ‫‪307‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫‪ 9.4.2‬إﻧﺸﺎء اﻷﺻﻨﺎف واﻟﻮﺻﻮل ﻟﻤﻜﻮﻧﺎﺗﮫ‬
‫واﻵن ﺑﻌﺪ ﻣﺎ ﻻﺣﻈﻨﺎ ﻛﯿﻒ ﯾﺘﻢ ﺗﻌﺮﯾﻒ اﻷﺻﻨﺎف ﻟﻨﺮى ﻛﯿﻒ ﯾﺘﻢ اﺳﺘﺨﺪام ھﺬه اﻷﺻﻨﺎف‪ :‬ﺗﺘﻢ‬
‫ﻋﻤﻠﯿﺔ اﺳﺘﺨﺪام اﻷﺻﻨﺎف وذﻟﻚ ﻋﻦ ﻃﺮﯾﻖ إﻧﺸﺎء ﻛﺎﺋﻨﺎت )‪ (Objects‬ﺗﻜﻮن ﻋﻠﻰ ﺷﻜﻞ ﻧﺴﺦ‬
‫ﻣﻦ اﻟﺼﻨﻒ ‪ ،‬وﺑﺎﻟﺘﺎﻟﻲ ﯾﺘﻢ اﻟﺘﻌﺎﻣﻞ ﻧﮫ ھﺬه اﻟﻜﺎﺋﻨﺎت ) اﻟﻨﺴﺦ( ‪ ،‬وﺗﺘﻢ ﻋﻤﻠﯿﺔ إﻧﺸﺎء اﻟﻨﺴﺦ ﻋﻠﻰ‬
‫اﻟﻨﺤﻮ اﻟﺘﺎﻟﻲ‬
‫‪ -‬ﺗﻌﺮﯾﻒ ﻣﺘﻐﯿﺮ ﻣﻦ ﻧﻮع اﻟﺼﻨﻒ اﻟﻤﺮاد اﺳﺘﺨﺪام ه واﻟﺬي ﺗﻢ ﺗﻌﺮﯾﻔﮫ ﻣﺴﺒﻘﺎً‪.‬‬
‫إﻧﺸﺎء ﻛﺎﺋﻦ ﺣﻘﯿﻘﻲ ﻣﻦ ﻧﻔﺲ اﻟﺼﻨﻒ وذﻟﻚ ﺑ ﺎﺳﺘﺨﺪام ﻛﻠﻤﺔ ‪ new‬ﻣﺘﺒﻮﻋﺔ‬ ‫‪-‬‬
‫ﺑﺈﺣﺪى اﻟﺒﺎﻧﯿﺎت )‪. (constructors‬‬
‫ﺛﻢ ﺑﻌﺪ ذﻟﻚ ﯾﺘﻢ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻜﺎﺋﻦ ﺑ ﺎﺳﺘﺨﺪام اﺳﻢ اﻟﻤﺘﻐﯿﺮ اﻟﺬي ﯾﺸﯿﺮ إﻟﯿﮫ‬ ‫‪-‬‬
‫ﻣﺘﺒﻮﻋﺎً ﺑﻨﻘﻄﺔ ﺛﻢ ﺑﺄﺣﺪ اﻟﻤﺘﻐﯿﺮات أو اﻟﻤﻨﺎھﺞ ﺣﺴﺐ أﻣﻜﺎﻧﯿﺔ اﻟﻮﺻﻮل) ‪public‬‬
‫‪ . (, private , protected , default‬واﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﯾﺒﯿﻦ ﻛﯿﻔﯿﺔ إﻧﺸﺎء‬
‫ﻛﺎﺋﻦ ﻣﻦ اﻟﺼﻨﻒ ‪ Account‬اﻟﺬي ﺗﻢ ﺗﻌﺮﯾﻔﮫ ﻓﻲ اﻟﻤﺜﺎل ‪.Account‬‬

‫‪1. // Bank‬‬
‫{ ‪2. public class Chp9_1‬‬
‫{ )‪3. public static void main(String[] args‬‬
‫;)(‪4. Account acc =new Account‬‬
‫;)‪5. acc.deposit(1000‬‬
‫‪6.‬‬ ‫}‬
‫} ‪7.‬‬

‫ﺷﺮح اﻟﻤﺜﺎل‪:‬‬
‫ﻓﻲ اﻟﺴﻄﺮ‪ 4‬ﺗﻢ ﺗﻌﺮﯾﻒ وإﻧﺸﺎء اﻟﻤﺘﻐﯿﺮ ‪ acc‬ﻟﯿﺼﺒﺢ ﻛﺎﺋﻦ ﻣﻦ ﻧﻮع ‪ account‬وھﺬا ﯾﻌﻨﻲ أن‬
‫ﺗﻘﻮم ﺑﺈﻧﺸﺎء ھﺬا اﻟﻜﺎﺋﻦ ﺑﻌﺪ اﺳﺘﺪﻋﺎء اﺣﺪى‬ ‫اﻟﻤﺘﻐﯿﺮ ‪ acc‬ﯾﺸﯿﺮ إﻟﻰ ﻛﺎﺋﻦ ﻣﻦ ﻧﻮع ‪new‬‬
‫اﻟﺒﺎﻧﯿﺎت اﻟﺨﺎﺻﺔ ﺑﺎﻟﺼﻨﻒ ‪ . Account‬وﻓﻲ اﻟﺴﻄﺮ ‪ 5‬ﺗﻤﺖ اﺳﺘﺪﻋﺎء اﻟﻄﺮﯾﻘﺔ ‪ deposit‬ﻓﻲ‬
‫داﺧﻞ اﻟﻜﺎﺋﻦ ‪ ، acc‬وذﻟﻚ ﺑﻜﺘﺎﺑﺔ اﺳﻢ اﻟﻜﺎﺋﻦ ﻣﺘﺒﻮﻋﺎ ﯾﺎﺳﻢ اﻟﻤﻨﮭﺞ ﯾﻔﺼﻞ ﺑﯿﻨﮭﺎ ﻧﻘﻄﺔ‪ .‬واﻟﺸﻜﻞ ‪9-‬‬
‫‪ 5‬ﯾﺒﯿﻦ ﻣﺤﺘﻮى اﻟﻜﺎﺋﻦ ‪.acc‬‬

‫‪[email protected]‬‬ ‫‪308‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ﺷﻜﻞ ‪ 9-5‬ﯾﺒﯿﻦ ﻣﺤﺘﻮى اﻟﻜﺎﺋﻦ ‪acc‬‬

‫‪ -‬اﺳﺘﺨﺪاﻣﺎت اﻟﻜﻠﻤﺔ أﻟﻤﻔﺘﺎﺣﯿﮫ ) ‪( new‬‬

‫‪ (1‬ﯾﺘﻢ إﻧﺸﺎء ھﺪف ﻣﻦ اﻟﻔﺼﯿﻠﺔ اﻟﻤﻌﻠﻦ ﻋﻨﮭﺎ ‪.‬‬
‫‪ (2‬ﯾﺘﻢ ﺣﺠﺰ ﺟﺰء ﻣﻦ اﻟﺬاﻛﺮة ﻟﮭﺬا اﻟﮭﺪف ‪.‬‬
‫‪ (3‬ﯾﺘﻢ اﺳﺘﺪﻋﺎء داﻟﺔ اﻟﺒﻨﺎء اﻟﺨﺎﺻﺔ ﺑﮭﺬه اﻟﻔﺼﯿﻠﺔ ‪.‬‬

‫‪ 9.4.3‬دوال اﻟﺒﻨﺎء ‪Constructor‬‬

‫وھﻮ ﻋﺒﺎرة ﻋﻦ ﻃﺮﯾﻘﺔ اﻟﺘﻜﻮﯾﻦ اﻟﺘﻲ ﯾﺘﻢ ﺑﮭﺎ إﻧﺸﺎء اﻟﻌﻀﻮ ﻣﻦ اﻟﻔﺼﯿﻠﺔ ﻓﺘﺄﺧﺬ ﻧﻔﺲ اﺳﻢ اﻟﻔﺼﯿﻠﺔ‬
‫وﺗﻨﻔﺬ ﻋﻨﺪ إﻧﺸﺎء اﻟﻔﺼﯿﻠﺔ و ﻣﻦ اﻟﺘﻨﻮﯾﮭﺎت ﻟﮭﺎ‬

‫ﺗﺴﺘﻄﯿﻊ إﻋﻄﺎء ﻗﯿﻢ اﺑﺘﺪاﺋﯿﺔ ﻟﻤﺘﻐﯿﺮات ﻓﺼﯿﻠﺔ اﻟﮭﺪف ‪.‬‬

‫ﯾﺠﺐ أن ﺗﻤﻠﻚ داﻟﺔ اﻟﺒﻨﺎء ﻧﻔﺲ اﺳﻢ ‪. Class‬‬

‫‪[email protected]‬‬ ‫‪309‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ﻻ ﺗﻤﻠﻚ اﻟﺒﺎﻧﯿﺎت ﻧﻤﻂ إرﺟﺎع وﻻ ﺣﺘﻰ ‪. void‬‬

‫ﯾﺘﻢ اﺳﺘﺪﻋﺎء اﻟﺒﺎﻧﯿﺎت ﺑﺎﺳﺘﺨﺪام اﻟﻌﺎﻣﻞ ‪ new‬ﻋﻨﺪ إﻧﺸﺎء اﻟﻜﺎﺋﻦ ‪.‬‬

‫اﻟﺮﺋﯿﺴﻲ أي ﺑﺎﻧﻲ ﺑﺸﻜﻞ ﺻﺮﯾﺢ ﻓﺄﻧﺔ ﺗﻠﻘﺎﺋﯿﺎُ ﯾﺘﻢ‬ ‫إذا ﻟﻢ ﯾﻌﺮف ‪Class‬‬
‫ﺗﻌﺮﯾﻒ ﺑﺎﻧﻲ اﻓﺘﺮاﺿﻲ وھﺬا اﻟﻜﻮد ﯾﺒﯿﻦ ذﻟﻚ‪.‬‬
‫}{ ‪1. class Bird‬‬
‫{ ‪2. class Chp9_2‬‬
‫{ )‪3. public static void main(String[] args‬‬
‫;)(‪4. Bird nc = new Bird‬‬
‫‪5.‬‬ ‫}‬
‫} ‪6.‬‬

‫ﻣﻦ اﻷﺧﻄﺎء اﻟﻤﺮﺗﻜﺒﺔ وﺿﻊ ﻛﻠﻤﺔ ‪ void or int‬ﻗﺒﻞ اﺳﻢ اﻟﺒﺎﻧﻲ ﻓﯿﺼﺒﺢ‬
‫ﻃﺮﯾﻘﺔ وﻟﯿﺲ ﺑﺎﻧﯿﺎً ‪.‬‬

‫ﯾﻤﻜﻦ ﺗﻌﺮﯾﻒ ال ‪ Constructor‬ﺑﺤﯿﺚ ﯾﻜﻮن ﻓﺎرﻏﺎً ﻣﻦ اﻟﻜﻮد ﻷﺳﺒﺎب‬

‫‪.‬‬

‫ﺧﺎص ﺑﻚ‪ ،‬ﻓﺄﻧﻚ ﺗﻔﻘﺪ اﻟـ‬ ‫إذا ﻗﻤﺖ ﺑﺘﻌﺮﯾﻒ ‪constructor‬‬

‫‪ constructor‬اﻻﻓﺘﺮاﺿﻲ‪ ،‬ﻓﺈذا أردت أن ﺗﺤﺘﻔﻆ ﺑﮫ‪ ،‬ﻋﻠﯿﻚ أن ﺗﻘﻮم ﺑﻜﺘﺎﺑﺘﮫ ﯾﺪوﯾﺎً ‪.‬‬

‫ﯾﻤﻜﻦ أن ﯾﻜﻮن ﻟﻨﻔﺲ اﻟﻔﺌﺔ أﻛﺜﺮ ﻣﻦ ‪ Constructor‬ﯾﺨﺘﻠﻔﻮن ﻓﻲ أﻋﺪاد أو‬

‫أﻧﻮاع اﻟﻤﺘﻐﯿﺮات ﻓﻲ ﺳﻠﺴﻠﺔ اﻟﻤﺘﻐﯿﺮات اﻟﻤﻤﺮرة ﻟﮭﻢ‪ ،‬أو ﻛﻼھﻤﺎ ‪.‬‬

‫‪[email protected]‬‬ ‫‪310‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ﺷﻜﻞ اﻟـ ‪ Constructor‬ﻗﺪ ﯾﺸﺒﮫ ﺷﻜﻞ اﻟﻮﻇﯿﻔﺔ‪ ،‬و ﻟﻜﻦ ﺗﺬﻛّﺮوا داﺋﻤﺎً‪ .‬اﺳﻢ‬
‫اﻟـ ‪ Constructor‬ھﻮ ﻧﻔﺲ اﺳﻢ اﻟﻔﺌﺔ‪ ،‬و ﻻ ﯾﻮﺟﺪ ﻟﮫ ﻧﻮع ﺑﻌﻜﺲ اﻟﻮﻇﯿﻔﺔ ‪.‬‬

‫إن ﻋﻤﻞ ‪ new‬ھﻮ إﻧﺸﺎء اﻟﻌﻀﻮ ﻣﻦ اﻟـ ‪ constructor‬اﻟﻤﻨﺎﺳﺐ‪ .‬ﻓﺈذا ﻟﻢ‬

‫اﻟـ ‪constructor‬‬ ‫ﻓﻲ اﻟﻔﺌﺔ ﺗﻘﻮم ‪ new‬ﺑ ﺎﺳﺘﺨﺪام‬ ‫ﯾﻮﺟﺪ ‪constructor‬‬
‫اﻻﻓﺘﺮاﺿﻲ ‪.‬‬
‫ﺑﺮﻧﺎﻣﺞ اﻟﺒﺎﻧﻲ اﻷﻓﺘﺮاﺿﻲ ‪1. //‬‬
‫{‪2. class Chp9_3‬‬
‫‪3.‬‬ ‫{)][‪public static void main(String args‬‬
‫‪4.‬‬ ‫;)(‪new Chp9_3‬‬
‫‪5.‬‬ ‫;)"‪System.out.println("by‬‬
‫‪6.‬‬ ‫;)‪new Chp9_3(10‬‬
‫‪7.‬‬ ‫}‬
‫};)"‪8. Chp9_3( ){ System.out.println("yes‬‬
‫};)‪9. Chp9_3(int b){ System.out.println(b+b‬‬
‫} ‪10.‬‬

‫ﺷﺮح اﻟﻤﺜﺎل‪:‬‬
‫ﻧﻼﺣﻆ ﻣﻦ ﻛﻮدﻧﺎ اﻟﺴﺎﺑﻖ اﻧﮫ ﻋﻨﺪﻣﺎ ﺗﺮﯾﺪ ﺗﻔﻌﯿﻞ دوال ﺑﻨﺎء ‪ Class‬ﻧﻔﺴﮫ ﯾﺘﻢ ﺑــ ‪ new‬ﺗﻢ اﺳﻢ‬
‫داﻟﺔ اﻟﺒﻨﺎء أو ﺑﺈﻧﺸﺎء ھﺪف ﻣﻦ ﻧﻮع ‪. Chp9_3 m=new Chp9_3(); Class‬‬

‫دوال اﻟﺒﻨﺎء ﺗﺴﺒﻖ أي ﺟﻤﻞ ﻣﻜﺘﻮﺑﺔ ﺑﺪاﺧﻞ اﻟﻜﻮد ﻓﯿﻨﻔﺬ اﻟﺒﺮﻧﺎﻣﺞ أوﻻ داﻟﮫ اﻟﺒﻨﺎء اﻷوﻟﻰ‬
‫ﺛﻢ اﻟﺜﺎﻧﯿﺔ ﺛﻢ ﺟﻤﻠﺔ اﻟﻄﺒﺎﻋﺔ ‪.‬‬
‫وﻓﻲ ﻛﻮدﻧﺎ اﻷﺗﻲ ﯾﺨﺘﻠﻒ اﻷﻣﺮ‬

‫‪[email protected]‬‬ ‫‪311‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ﺑﺮﻧﺎﻣﺞ ﯾﻮﺿﺢ أﺳﺒﻘﯿﺔ ﺗﻨﻔﯿﺬ دوال اﻟﺒﻨﺎء‪1. //‬‬
‫{ ‪2. class Chp9_4‬‬
‫‪3.‬‬ ‫اﻟﻜﺘﻞ اﻟﻤﻌﺸﻌﺸﺔ‪//‬‬
‫‪4.‬‬ ‫};)"‪{System.out.println("by‬‬
‫‪5.‬‬
‫{)][‪6. public static void main(String args‬‬
‫‪7.‬‬ ‫;)(‪new Chp9_4‬‬
‫;)‪8. new Chp9_4(10‬‬
‫‪9.‬‬ ‫}‬
‫‪10.‬‬
‫};)"‪11. Chp9_4( ){System.out.println("yes‬‬
‫‪12.‬‬
‫};)‪13. Chp9_4( int b){System.out.println(b+b‬‬
‫} ‪14.‬‬

‫ﺷﺮح اﻟﻤﺜﺎل‪:‬‬
‫ﻧﻼﺣﻆ أﻧﺔ ﺗﻢ ﺗﻨﻔﯿﺬ ﺟﻤﻠﺔ اﻟﻄﺒﺎﻋﺔ اﻟﺘﻲ ﺧﺎرج اﻟﺪاﻟﺔ اﻟﺮﺋﯿﺴﯿﺔ اﻟﺘﻲ ﺑﺪاﺧﻞ ‪ Block‬ات اﻟﻤﺴﻤﺎة‬
‫ﻋﻨﺪ ﺗﻨﻔﯿﺬ داﻟﺔ اﻟﺒﻨﺎء اﻷوﻟﻰ وﻣﺮة ﻋﻨﺪ ﺗﻨﻔﯿﺬ داﻟﺔ‬ ‫اﻟﻜﺘﻞ اﻟﻤﻌﺸﻌﺸﺔ ﻓﻲ اﻟﺴﻄﺮ ‪ 4‬ﻣﺮﺗﺎن ﻣﺮة‬
‫اﻟﺒﻨﺎء اﻟﺜﺎﻧﯿﺔ ‪0‬‬
‫وﻣﻦ اﻟﻤﻼﺣﻆ أن ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ‪ Chp9_3‬ﻛﺎﻧﺖ داﻟﺔ اﻟﺒﻨﺎء ﺗﺴﺒﻖ أي ﺟﻤﻞ ﻣﻜﺘﻮﺑﺔ وﻻ ﻛﻦ‬
‫ﻓﺄي ﺟﻤﻞ ﻣﻜﺘﻮﺑﺔ ﺑﺪاﺧﻞ ﺑﻠﻮﻛﺎت وﻣﻮﻗﻌﮭﺎ ﺧﺎرج اﻟﺪاﻟﺔ اﻟﺮﺋﯿﺴﯿﺔ ﻓ ﺈﻧﮭﺎ‬ ‫ھﻨﺎ اﻷﻣﺮ ﯾﺨﺘﻠﻒ اﻵن‬
‫ﺗﺴﺒﻖ ﺗﻨﻔﯿﺬ داﻟﺔ اﻟﺒﻨﺎء ‪.‬‬

‫ﺟﻤﻠﺔ اﻟﻄﺒﺎﻋﺔ اﻟﺴﺎﺑﻘﺔ ﻓﻲ اﻟﺴﻄﺮ ‪ 3‬ﻻ ﺗﻨﻔﺬ إﻃﻼﻗﺎ إﻟﻰ إذا ﺣﺪث إﻃﻼق ﻟﻠﻔﺌﺔ‪.‬‬
‫ﻋﺪم ﺗﻨﻔﯿﺬ داﻟﺔ اﻟﺒﻨﺎء‪1. //‬‬
‫{ ‪2. class Chp9_5‬‬
‫‪3.‬‬ ‫};)"‪{System.out.println("by‬‬
‫{)][‪4. public static void main(String args‬‬
‫;)"‪5. System.out.println("start‬‬
‫} ‪6.‬‬
‫} ‪7.‬‬

‫‪[email protected]‬‬ ‫‪312‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ﻓﻲ ھﺬا اﻟﻜﻮد أﯾﻀﺎ ﯾﺨﺘﻠﻒ اﻷﻣﺮ‬
‫أﺳﺒﻘﯿﺔ ﺗﻨﻔﯿﺬ اﻟﺠﻤﻞ اﻻﺳﺘﺎﺗﯿﻜﯿﺔ‪1. //‬‬
‫{ ‪2. class Chp9_6‬‬
‫{)][‪3. public static void main(String args‬‬
‫‪4.‬‬ ‫;)(‪new Chp9_6‬‬
‫} ‪5.‬‬
‫‪6.‬‬
‫{) (‪7. Chp9_6‬‬ ‫};)"‪System.out.println("yes‬‬
‫‪8.‬‬ ‫};)"‪{System.out.println("by‬‬
‫‪9.‬‬
‫‪10.‬‬ ‫‪static‬‬
‫‪11.‬‬ ‫};)"‪{System.out.println("start‬‬
‫} ‪12.‬‬

‫ﺷﺮح اﻟﻤﺜﺎل‪:‬‬
‫ﻧﻼﺣﻆ أن اﻟﻤﺤﺮر ﻧﻔﺬ ﻣﺤﺘﻮى ‪ static‬ﻛﻤﺎ ﻓﻲ اﻟﺴﻄﺮ ‪ 10‬ﺛﻢ ﻣﺤﺘﻮى اﻟﻜﺘﻠﺔ اﻟﻤﻌﺸﻌﺸﺔ ﻓﻲ‬
‫اﻟﺴﻄﺮ ‪ 8‬ﺛﻢ داﻟﺔ اﻟﺒﻨﺎء ﻓﻲ اﻟﺴﻄﺮ ‪. 7‬‬

‫ﻗﺒﻞ ﻛﻞ ﺷﻲء ﺣﺘﻰ وان ﻟﻢ ﯾﺘﻢ إﻃﻼق ‪Class‬‬ ‫داﺋﻤﺎً ﯾﺘﻢ ﺗﻨﻔﯿﺬ ﻣﺤﺘﻮى ‪static‬‬
‫ﻛﻤﺎ ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‪:‬‬
‫ﺗﻨﻔﯿﺬ اﻟﺠﻤﻞ اﻻﺳﺘﺎﺗﯿﻜﺔ ‪1. //‬‬
‫{ ‪2. class Chp9_7‬‬
‫{)][‪3. public static void main(String args‬‬
‫‪4.‬‬ ‫;)"‪System.out.println("by‬‬
‫‪5.‬‬ ‫}‬
‫‪6.‬‬
‫‪7.‬‬ ‫};)"‪static{System.out.println("start‬‬
‫} ‪8.‬‬

‫‪[email protected]‬‬ ‫‪313‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ ﺗﻤﺮﯾﺮ اﻟﺒﺎراﻣﺘﺮات إﻟﻰ اﻟﻜﺎﺋﻨﺎت‬9.4.4
‫ﻟﻘﺪ ﺗﻌﻠﻤﻨﺎ ﻣﺴﺒﻘﺎً ﻛﯿﻒ ﻧﻤﺮر اﻟﺒﺎراﻣﺘﺮات اﻟﺘﻲ ﺗﻨﺘﻤﻲ إﻟﻰ اﻵﻧ ﻤﺎط اﻷوﻟﯿﺔ واﻟﻤﺼﻔﻮﻓﺎت إﻟﻰ‬
‫ ﯾﻘﻮم اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﺑﺘﻤﺮﯾﺮ ﻗﯿﻤﺔ‬، ‫ ﯾﻤﻜﻨﻚ أﯾﻀﺎ ﺗﻤﺮﯾﺮ اﻟﺒﺎراﻣﺘﺮات إﻟﻰ اﻟﻜﺎﺋﻨﺎت‬، ‫اﻟﻤﻨﺎھﺞ‬
.‫ﻣﺘﺤﻮل إﻟﻰ اﻟﻜﺎﺋﻦ ﻋﺒﺮ داﻟﺔ اﻟﺒﻨﺎء‬

1. //‫ﺑﺘﻤﺮﯾﺮ ﻗﯿﻤﺔ ﻣﺘﺤﻮل إﻟﻰ اﻟﻜﺎﺋﻦ ﻋﺒﺮ داﻟﺔ اﻟﺒﻨﺎء‬

2. // this used implicitly and explicitly to refer to members of an object.
3.
4. public class Chp9_8
5. {
6. public static void main( String args[] )
7. {
8. SimpleTime time = new SimpleTime( 15, 30, 19 );
9. System.out.println( time.buildString() );
10. } // end main
11. } // end class ThisTest
12.
13. // class SimpleTime demonstrates the "this" reference
14. class SimpleTime
15. {
16. private int hour; // 0-23
17. private int minute; // 0-59
18. private int second; // 0-59
19.
20. // if the constructor uses parameter names identical to
21. // instance variable names the "this" reference is
22. // required to distinguish between names
23. public SimpleTime( int hour, int minute, int second )
24. {
25. this.hour = hour; // set "this" object's hour
26. this.minute = minute; // set "this" object's minute
27. this.second = second; // set "this" object's second
28. } // end SimpleTime constructor
29.
30. // use explicit and implicit "this" to call toUniversalString
31. public String buildString()
32. { String s="this.toUniversalString()\t"+ this.toUniversalString()+
33. "\ntoUniversalString()\t\t"+ toUniversalString() ;
34. return s;
35.
36. } // end method buildString
37.
38. // convert to String in universal-time format (HH:MM:SS)
39. public String toUniversalString()

[email protected] 314 ‫ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬/‫م‬

 40. {
41. // "this" is not required here to access instance variables,
42. // because method does not have local variables with same
43. // names as instance variables
44. String s=this.hour+":"+ this.minute+":"+ this.second;
45. return s;
46.
47. } // end method toUniversalString
48. } // end class SimpleTime

:‫ﻓﯿﻜﻮن ﻧﺎﺗﺞ اﻟﺘﻨﻔﯿﺬ ﻛﻤﺎ ﯾﻠﻲ‬

‫ ﻣﻘﺎرن اﻷھﺪاف‬9.4.5
، (<= , < , > , >=) Operator ‫ﻓﻲ ﻓﺼﻞ أﻧﻮاع اﻟﺒﯿﺎﻧﺎت ﺗﻌﺮﻓﻨﺎ إﻟﻰ ﻣﻮﺿﻮع اﻟﻤﺆﺛﺮات‬
‫وھﺬه اﻟﻤﺆﺛﺮات ﺗﻌﻤﻞ ﻓﻘﻂ ﻣﻊ اﻷﻧﻮاع اﻟﻤﺒﯿﻨﺔ ﻓﻲ اﻟﻠﻐﺔ وإذا ﺣﺎوﻟﺖ اﺳﺘﺨﺪام ھﺎ ﻣﻊ اﻷھﺪاف‬
.‫ﻓﺴﯿﻘﻮم اﻟﻤﺘﺮﺟﻢ ﺑﺈﺻﺪار رﺳﺎﺋﻞ ﺧﻄﺎء‬
‫ =!( ﻓﺎﻷول ﯾﻘﻮم ﺑﻔﺤﺺ اﻟﻤﺴﺎواة‬، ==) ‫وﻟﻜﻦ ﯾﻮﺟﺪ اﺳﺘﺜﻨﺎء ﻣﻦ ھﺬه اﻟﻤﺆﺛﺮات وھﻤﺎ اﺛﻨﺎن‬
‫وﻟﻜﻦ ﻓﻲ ﻷھﺪاف ﯾﺨﺘﻠﻒ ﻋﻤﻠﮭﺎ ﻓﻲ اﻷھﺪاف ﻛﻤﺎ ﻓﻲ اﻟﻤﺜﺎل‬ ، ‫واﻟﺜﺎﻧﻲ ﯾﻘﻮم ﺑﻨﻔﻲ اﻟﻤﺴﺎواة‬
:‫اﻟﺘﺎﻟﻲ‬

1. // ‫ﺑﺮﻧﺎﻣﺞ ﻣﻘﺎرﻧﺔ اﻷھﺪاف‬

2. class ammar{ int i ; ammar(int a){i=a;}}
3.
4. class Chp9_9 {
5. public static void main(String args[]){
6. ammar a=new ammar(10);
7. ammar a1=new ammar(100);
8. System.out.println(a==a1);
9.
10. a=new ammar(100);
11. System.out.println(a==a1);
12.
13. a=a1;
14. System.out.println(a==a1);
15.
16. a.i=1000;
17. System.out.println(a1.i);
18. }
19. }

[email protected] 315 ‫ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬/‫م‬

 ‫ﺷﺮح اﻟﻤﺜﺎل‪:‬‬
‫اﻟﺴﻄﺮ ‪ 8‬ﻟﯿﺲ ﺑﻤﻌﻨﻰ أن ﻣﺤﺘﻮى ‪ Class‬اﻷول ﯾﺴﺎوي ﻣﺤﺘﻮى ‪ Class‬اﻟﺜﺎﻧﻲ ﻻ وﻟﻜﻦ ھﻞ‬
‫ﻣﻮﻗﻊ ‪ Class‬اﻷول ﯾﺴﺎوي ﻣﻮﻗﻊ ‪ Class‬اﻟﺜﺎﻧﻲ ﻓﻲ اﻟﺬاﻛﺮة ‪.‬‬

‫رﻏﻢ إﻧﻨﺎ ﺳﺎوﯾﻨﺎ ﻣﺤﺘﻮى اﻟﻜﻼﺳﯿﻦ إﻻ إﻧﻨﺎ ﻧﺠﺪ ﻧﺎﺗﺞ أﻣﺮ اﻟﻄﺒﺎﻋﺔ ‪ false‬واﻟﺴﺒﺐ‬ ‫اﻟﺴﻄﺮ ‪13‬‬
‫ذﻛﺮﻧﺎه ﺳﺎﺑﻘﺎً‪.‬‬

‫اﻟﺴﺆال ھﻨﺎ ﻛﯿﻒ ﺗﻐـﯿـﺮت ﻗﯿﻤﺔ ‪ a1.i‬وﻧﺤﻦ ﻏـﯿـﺮﻧﺎ ﻗﯿﻤﺔ ‪ a.i‬؟‬

‫اﻹﺟﺎﺑﺔ ھـﻮ ﻋـﻨﺪﻣﺎ ﺟﻌﻠﻨﺎ ‪ a =a1‬ﻓـﺄﻧـﺔ أﺻﺒﺢ ‪ a‬ﯾﺆﺷﺮ إﻟﻰ ﻣﻮﻗﻊ ‪ a1‬وأي ﺗﻐﯿﺮ ﻓﻲ ‪a.i‬‬
‫ﺗـﺘـﻐـﯿـﺮ ﻗﯿﻤﺔ ‪ a1.i‬واﻟﻌﻜﺲ ﻛﻤﺎ ﻓﻲ اﻟﺴﻄﺮ ‪.14‬‬

‫ھﺬا اﻟﻜﻮد أﯾﻀﺎ ﺑﮫ ﻗﺎﻋﺪة ‪:‬‬

‫ﺑﺮﻧﺎﻣﺞ ﯾﻮﺿﺢ ﺗﻐﯿﺮ اﻟﻤﻮﻗﻊ اﻟﺬاﻛﺮي ﻟﻠﻔﺌﺔ ‪1. //‬‬
‫} };‪2. class Chp9__10{ int i; Chp9__10(int a){i=a‬‬
‫‪3.‬‬
‫{ ‪4. class Chp9_10‬‬
‫‪5.‬‬ ‫{)][‪public static void main(String args‬‬
‫‪6.‬‬ ‫;)‪Chp9__10 a=new Chp9__10(10‬‬
‫‪7.‬‬ ‫;‪Chp9__10 a1= a‬‬
‫‪8.‬‬ ‫;)‪System.out.println(a==a1‬‬
‫‪9.‬‬ ‫;)‪System.out.println(a1.i‬‬
‫‪10.‬‬
‫‪11.‬‬ ‫;)‪a=new Chp9__10(100‬‬
‫‪12.‬‬
‫‪13.‬‬ ‫;)‪System.out.println(a==a1‬‬
‫‪14.‬‬ ‫;)‪System.out.println(a.i‬‬
‫‪15.‬‬ ‫;)‪System.out.println(a1.i‬‬
‫‪16.‬‬ ‫}‬
‫} ‪17.‬‬

‫‪[email protected]‬‬ ‫‪316‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ﺷﺮح اﻟﻤﺜﺎل‪:‬‬
‫اﻟﺴﻄﺮ ‪ 11‬ﺗﻢ إﻋﺎدة إﻃﻼق اﻟﮭﺪف وإرﺳﺎل ﻟـ ‪ I‬اﻟﻘﯿﻤﺔ ‪ 100‬ﺑﻤﺎ ﻣﻌﻨﻰ أن ﻣﻮﻗﻌﺔ أﻟﺬاﻛﺮي ﻗﺪ‬
‫ﺗﻐـﯿـﺮ‪.‬‬

‫‪ 9.4.6‬ﺗﻤﺮﯾﺮ اﻟﻜﺎﺋﻨﺎت إﻟﻰ اﻟﻤﻨﺎھﺞ‬

‫ﻟﻘﺪ ﺗﻌﻠﻤﻨﺎ ﻣﺴﺒﻘﺎً ﻛﯿﻒ ﻧﻤﺮر اﻟﺒﺎراﻣﺘﺮات اﻟﺘﻲ ﺗﻨﺘﻤﻲ إﻟﻰ اﻵﻧ ﻤﺎط اﻷوﻟﯿﺔ واﻟﻤﺼﻔﻮﻓﺎت إﻟﻰ‬
‫اﻟﻤﻨﺎھﺞ ‪ ،‬ﯾﻤﻜﻨﻚ أﯾﻀﺎ ﺗﻤﺮﯾﺮ اﻟﻜﺎﺋﻦ إﻟﻰ اﻟﻤﻨﮭﺞ ‪ ،‬ﯾﻘﻮم اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﺑﺘﻤﺮﯾﺮ اﻟﻜﺎﺋﻦ ﻛﺒﺎراﻣﺘﺮإﻟﻰ‬
‫)‪ (fun‬اﻟﻤﻨﮭﺞ ‪.‬‬

‫‪1. // this used implicitly and explicitly to refer to members of an object.‬‬

‫‪2. public class Chp9_11‬‬
‫{ ‪3.‬‬
‫‪4.‬‬ ‫{)‪static void fun(Chp9__11 x‬‬
‫‪5.‬‬ ‫;) )(‪System.out.println( x.Simple_fun‬‬
‫‪6.‬‬ ‫‪}//end function fun‬‬
‫‪7.‬‬
‫‪8.‬‬ ‫) ][‪public static void main( String args‬‬
‫‪9.‬‬ ‫{‬
‫‪10.‬‬ ‫;)(‪Chp9__11 exp = new Chp9__11‬‬
‫‪11.‬‬ ‫;)‪fun(exp‬‬
‫‪12.‬‬ ‫‪} // end main‬‬
‫‪13. } // end class Chp9_11‬‬
‫‪14.‬‬
‫‪15. // class Simple‬‬
‫‪16. class Chp9__11‬‬
‫{ ‪17.‬‬
‫‪18.‬‬ ‫)(‪public String Simple_fun‬‬
‫‪19.‬‬ ‫{‬
‫‪20.‬‬ ‫;"‪return "Simpe‬‬
‫‪21.‬‬ ‫‪} // end SimpleTime constructor‬‬
‫‪22. } // end class Chp9__11‬‬

‫ﺷﺮح اﻟﻤﺜﺎل‪:‬‬
‫ﯾﺴﺘﺪﻋﻲ اﻟﻤﻨﮭﺞ ‪ main‬اﻟﻤﻨﮭﺞ ‪ fun‬ﺣﯿﺚ ﯾﻤﺮر ﻟﮫ اﻟﻜﺎﺋﻦ )‪ (exp‬ﻛﺒﺮاﻣﺘﺮ ﻛﻤﺎ ﻓﻲ اﻟﺴﻄﺮ‬
‫اﻟﺬي ﺑﺪاﺧﻞ اﻟﺼﻨﻒ‬ ‫ﺑﺎﺳﺘﺪﻋﺎء اﻟﻤﻨﮭﺞ ‪Simple_fun‬‬ ‫ﻓﯿﻘﻮم اﻟﻤﻨﮭﺞ ‪fun‬‬ ‫‪، 11‬‬
‫‪ ، Chp9__11‬ﺣﯿﺚ ﺗﻌﯿﺪ ﻗﯿﻤﺔ رﻣﺰﯾﺔ ﻣﻦ ﻧﻮع ‪ String‬ﻛﻤﺎ ﻓﻲ اﻟﺴﻄﺮ ‪.20‬‬
‫ﻓﯿﻜﻮن ﻧﺎﺗﺞ ﺗﻨﻔﯿﺬ اﻟﺒﺮﻧﺎﻣﺞ ‪:‬‬

‫‪[email protected]‬‬ ‫‪317‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ ﻣﺼﻔﻮﻓﺔ ﻣﻦ اﻟﻜﺎﺋﻨﺎت‬9.4.7
‫ واﺣﺪ وﺗﺘﻢ ﺑﺨﻄﻮﺗﯿﻦ‬Class ‫واﻟﻘﺼﺪ ھﻨﺎ ﺗﻜﻮﯾﻦ ﻋﺪة ﻛﺎﺋﻨﺎت ﻣﻦ‬
. ‫( ﺗﻌﺮﯾﻒ ﻋﺪد اﻟﻜﺎﺋﻨﺎت اﻟﻤﺮاد ﺗﻜﻮﯾﻨﮭﺎ‬1
. ‫( اﺷﺘﻘﺎق اﻟﻜﺎﺋﻨﺎت‬2
:‫ﻛﻤﺎ ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬
1. // ‫ﺑﺮﻧﺎﻣﺞ ﻣﺼﻔﻮﻓﺔ اﻟﻔﺌﺎت‬
2. class Chp9__12 {static int count;
3. int j;
4. Chp9__12() {
5. j=count;
6. count++;
7. }
8. }
9.
10. class Chp9_12 {
11. public static void main(String[] args) {
12. int i=10,j;
13. // Create Objeact
14. Chp9__12 p[] =new Chp9__12[i];
15.
16. for(j=0;j<i;j++)
17. p[j]=new Chp9__12();
18.
19. System.out.println("j"+" "+"count");
20.
21. for(j=0;j<i;j++)
22. System.out.println(p[j].j+" "+p[j].count);
23. }
24. }

[email protected] 318 ‫ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬/‫م‬

 ‫ﺷﺮح اﻟﻤﺜﺎل‪:‬‬
‫اﻟﺴﻄﺮ ‪ 14‬ﺗﻢ ﺗﺤﺪﯾﺪ ﻋﺪد اﻟﻔﺌﺎت اﻟﻤﺮاد ﺗﻜﻮﯾﻨﮭﺎ ‪.‬‬
‫اﻷﺳﻄﺮ ‪ 16 , 17‬ﺗﻢ اﺷﺘﻘﺎق اﻟﻔﺌﺎت ‪.‬‬

‫اﻟﻤﺘﺤﻮل ‪ count‬ﻓﻲ اﻟﺴﻄﺮ ‪ 2‬ﻣﺘﺤﻮل ﻋﺎم ﻟﺠﻤﯿﻊ اﻟﻔﺌﺎت اﻟﻤﺸﺘﻘﺔ أي إي ﺗﻐﯿﺮ ﻟﺔ ﻓﻲ‬
‫أي ﻓﺌﺔ ﺗﺘﻐﯿﺮ ﻗﯿﻤﺘﮫ ﻓﻲ ﺟﻤﯿﻊ اﻟﻔﺌﺎت ﺑﺴﺒﺐ ﻛﻮﻧﮫ ﻣﻦ ﻧﻮع ‪.static‬‬

‫‪ 9.4.8‬اﻟﻜﻠﻤﺔ أﻟﻤﻔﺘﺎﺣﯿﮫ )‪:( this‬‬

‫اﺳﺘﺨﺪاﻣﺎت اﻟﻜﻠﻤﺔ أﻟﻤﻔﺘﺎﺣﯿﮫ )‪ / ( this‬ﻟﮫ دور ﻛﺒﯿﺮ ﻣﻊ دوال اﻟﺒﻨﺎء وﻋﻤﻮﻣﺎَ ھﺬه اﻟﻜﻠﻤﺔ ﺗﺸﯿﺮ‬
‫إﻟﻰ ‪ Class‬ﻧﻔﺴﮫ وﻟﮭﺎ اﺳﺘﺨﺪاﻣﺎت ‪.‬‬
‫‪ .1‬ﺗﺴﺘﺪﻋﻲ دوال اﻟﺒﻨﺎء ﻛﻤﺎ ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‪:‬‬
‫ﺑﺮﻧﺎﻣﺞ ﯾﺴﺘﺪﻋﻲ داﻟﺔ اﻟﺒﻨﺎء ‪1. //‬‬
‫{‪2. class Chp9__13‬‬
‫‪3.‬‬ ‫};)"‪Chp9__13(){System.out.println("start‬‬
‫‪4.‬‬ ‫)‪Chp9__13(int b‬‬
‫‪5.‬‬ ‫};)‪{this();System.out.println(b*b‬‬
‫‪6.‬‬ ‫}‬
‫‪7.‬‬
‫{ ‪8. class Chp9_13‬‬
‫‪9.‬‬ ‫{)][‪public static void main(String args‬‬
‫‪10.‬‬ ‫;)‪Chp9__13 b=new Chp9__13(100‬‬
‫‪11.‬‬ ‫}‬
‫} ‪12.‬‬

‫‪[email protected]‬‬ ‫‪319‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ ﻗﺒﻞ أي ﺟﻤﻠﺔ وإﻻ اﻟﻤﺘﺮﺟﻢ‬this ‫ﻋﻨﺪ اﺳﺘﺪﻋﺎء ﺑﺎﻧﻲ ﯾﺠﺐ وﺿﻊ اﻟﻜﻠﻤﺔ أﻟﻤﻔﺘﺎﺣﯿﮫ‬
. ‫ﺳﯿﺼﺪر ﺧﻄﺎء‬
. (Constructor invocation must be the first thing in a method this())

.‫وﺗﻌﺘﺒﺮ ﻣﻦ اﻷﺧﻄﺎء اﻟﺸﺎﺋﻌﺔ‬

. ‫ﻓﮭﺬا اﻟﻜﻮد ﻟﻦ ﯾﻨﻔﺪ إﻃﻼﻗﺎ‬
1. //Error This
2. class Chp9__14{
3. Chp9__14(){System.out.println("start");}
4. Chp9__14(int b)
5. {System.out.println(b*b);
6. //Error
7. this();
8. }
9. }
10.
11. class Chp9_14 {
12. public static void main(String args[]){
13. Chp9__14 b=new Chp9__14(100);
14. }
15. }

. ‫ ﺗﺤﻞ ﻣﺸﻜﻠﺔ أﺳﻤﺎء اﻷﻋﻀﺎء اﻟﻤﺘﺸﺎﺑﮭﺔ‬.2

1. // ‫ﺑﺮﻧﺎﻣﺞ ﯾﺤﻞ ﻣﺸﻜﻠﺔ ﺗﺸﺎﺑﺔ اﻷﻋﻀﺎء‬
2. class Chp9__15 {int b;
3. Chp9__15 (int b){ this.b=b;}
4. }
5.
6. class Chp9_15 {
7. public static void main(String[] args) {
8. Chp9__15 a = new Chp9__15(10);
9. System.out.println(a.b);
10. }
11. }

[email protected] 320 ‫ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬/‫م‬

 ‫ﺷﺮح اﻟﻤﺜﺎل‪:‬‬
‫ﻓﻲ ﺑﻌﺾ اﻷﺣﯿﺎن ﻗﺪ ﯾﺘﺸﺎﺑﮫ اﺳﻢ اﻟﺒﺎرﻣﺘﺮ اﻟﻤﺮﺳﻞ ﻟﻠﺪاﻟﺔ ﻛﻤﺎ ﻓﻲ اﻟﺴﻄﺮ ‪ 3‬واﺳﻢ اﻟﻤﺘﻐﯿﺮ ﻓﻲ‬
‫داﺧﻞ ‪ Class‬ﻛﻤﺎ ﻓﻲ اﻟﺴﻄﺮ ‪ 4‬ﻓﺠﻤﻠﺔ ‪ this‬ﺗﻌﻨﻲ اﻟﻤﺘﻐﯿﺮ اﻟﺨﺎص ﺑﺎﻟﻔﺌﺔ ﻧﻔﺴﮭﺎ‪.‬‬

‫‪ -3‬ﺗﻌﯿﺪ ﻗﯿﻤﺔ ﻣﻦ ﻧﻮع ‪ Class‬ﻧﻔﺴﮫ ﻣﺜﻞ اﻟﺪاﻟﺔ ﻋﻨﺪﻣﺎ ﺗﻌﯿﺪ ﻗﯿﻤﺔ‪.‬‬

‫وھﺬا اﻟﻤﺜﺎل ﯾﺒﯿﻦ ذﻟﻚ ‪:‬‬
‫ﺑﺮﻧﺎﻣﺞ ﯾﻌﯿﺪ ﻗﯿﻤﺔ ﻣﻦ ﻧﻮع اﻟﻜﻼس ‪1. //‬‬
‫{‪2. class Chp9__16‬‬
‫‪3.‬‬ ‫;‪int b=0‬‬
‫‪4.‬‬ ‫}{)( ‪Chp9__16‬‬
‫‪5.‬‬ ‫‪// Return This Object‬‬
‫‪6.‬‬ ‫};‪Chp9__16 a(){b++;return this‬‬
‫‪7.‬‬ ‫};)‪void print(){System.out.println(b‬‬
‫‪8.‬‬ ‫}‬
‫‪9.‬‬
‫{ ‪10. class Chp9_16‬‬
‫‪11.‬‬ ‫{)][‪public static void main(String args‬‬
‫‪12.‬‬ ‫;)(‪Chp9__16 q=new Chp9__16‬‬
‫‪13.‬‬ ‫;)(‪q.a().a().a().a().a().print‬‬
‫‪14.‬‬ ‫}‬
‫} ‪15.‬‬

‫ﻻ ﻧﺴﺘﻄﯿﻊ اﺳﺘﺨﺪام اﻟﻜﻠﻤﺔ ‪ this‬ﻓﻲ اﺳﺘﺪﻋﺎء أﻛﺜﺮ ﻣﻦ داﻟﺔ ﺑﻨﺎء ‪.‬‬

‫‪ 9.4.9‬اﻟﻜﻠﻤﺔ ) ‪- : ( final‬‬
‫ﺑﻤﺎ ﻣﻌﻨﻰ ﺛﺎﺑﺖ أي ﻻ ﻧﺴﺘﻄﯿﻊ ﺗﻐﯿﺮه وﻟﮭﺎ ﻋﺪة اﺳﺘﻌﻤﺎﻻت ﻓﺎن ذﻛﺮت ﻣﻊ‬
‫‪ / Final class‬ﻓﺈﻧﻨﺎ ﻻ ﻧﺴﺘﻄﯿﻊ ﺗﻮرﯾﺚ ‪. Class‬‬ ‫•‬
‫‪ / Final function‬ﻓﺈﻧﻨﺎ ﻻ ﻧﺴﺘﻄﯿﻊ ﻋﻤﻞ ‪. override‬‬ ‫•‬

‫‪[email protected]‬‬ ‫‪321‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ ﻓﺈﻧﻨﺎ ﻻ ﻧﺴﺘﻄﯿﻊ ﺗﻐﯿﺮ ﻣﺤﺘﻮى اﻟﻤﺘﻐﯿﺮات‬/ Final variable •
:‫وھﺬا ﻣﺜﺎل ﻋﻠﻰ ذﻟﻚ‬
1. // final instance variable in a class.
2. class Increment
3. {
4. private int total = 0; // total of all increments
5. private final int INCREMENT; // constant variable (uninitialized)
6.
7. // constructor initializes final instance variable INCREMENT
8. public Increment( int incrementValue )
9. {
10. INCREMENT = incrementValue; // initialize constant variable (once)
11. } // end Increment constructor
12.
13. // add INCREMENT to total
14. public void addIncrementToTotal()
15. {
16. total += INCREMENT;
17. } // end method addIncrementToTotal
18.
19. // return String representation of an Increment object's data
20. public String toString()
21. { String s="total = "+total;
22. return s;
23. } // end method toIncrementString
24. } // end class Increment
25.
26. // final variable initialized with a constructor argument.
27. public class Chp9_17
28. {
29. public static void main( String args[] )
30. {
31. Increment value = new Increment( 5 );
32.
33. System.out.println( "Before incrementing: \n\n"+ value );
34.
35. for ( int i = 1; i <= 3; i++ )
36. {
37. value.addIncrementToTotal();
38. System.out.println( "After increment :\n"+ i+" "+ value );
39. } // end for
40. } // end main
41. } // end class IncrementTest

[email protected] 322 ‫ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬/‫م‬

 . ‫ﻛﮭﺬا اﻟﻜﻮد ﺧﺎﻃﺊ‬
1. //Error Class
2. public class Chp9_18 {
3. public static void main(String[] args) {
4. ammar++;//error
5. System.out.println(ammar);
6. }
7. static final int ammar=20;
8. }

:‫وھﺬا ﻧﺎﺗﺞ اﻟﺘﻨﻔﯿﺬ‬

Can't assign a value to a final variable: ammar

‫ھﺬا اﻟﻜﻮد ﺧﺎﻃﺊ ﻟﻤﺎذا ؟‬

1. // Syntax Error
2. class Chp9_19 {
3. int i=10;
4. public static void main(String args[]){
5. int j=i;
6. System.out.println(j);
7. System.out.println(i);
8. }
9. }

Can't make a static reference to nonstatic variable i in class Chp9_19.

:‫ﺷﺮح اﻟﻤﺜﺎل‬
‫ إﻻ إذا‬3 ‫ اﻟﺬي ﻓﻲ اﻟﺴﻄﺮ‬I ‫وھﻮ اﺳﺘﺨﺪام ﻣﺘﻐﯿﺮ ﻣﺤﺠﻮب ﻋﻦ اﻟﻤﺘﺮﺟﻢ ﻓﻠﻦ ﯾﻘﺪر أن ﯾﺼﻞ إﻟﻰ‬
.static ‫ ﻣﻦ ﻧﻮع‬I ‫ أو ﻧﺠﻌﻞ‬Class ‫أﻃﻠﻘﻨﺎ ھﺪف ﻣﻦ ﻧﻮع‬

[email protected] 323 ‫ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬/‫م‬

 ‫ﻋﻨﺪ اﻟﺘﺼﺮﯾﺢ ﻋﻠﻰ ﻣﺘﻐﯿﺮ ﻣﻦ ﻧﻮع ‪ static‬داﺧﻞ ‪ Class‬ﻓﮭﺬا ﯾﻌﻨﻲ أن ھﺬا اﻟﻤﺘﻐﯿﺮ‬
‫ﻣﺸﺘﺮك ﻟﺠﻤﯿﻊ اﻟﻔﺌﺎت اﻟﻤﺸﺘﻘﺔ ﻣﻦ ‪ Class‬وھﺬا اﻟﻜﻮد ﯾﺸﺮح ذﻟﻚ‬
‫ﺑﺮﻧﺎﻣﺞ اﻟﺘﺼﺮﯾﺢ ﻋﻠﻰ ﻣﺘﻐﯿﺮ ﻣﻦ ﻧﻮع ﺳﺘﺎﺗﻚ داﺧﻞ اﻟﻜﻼس ‪1. //‬‬
‫{‪2. class Chp9__20‬‬
‫‪3.‬‬ ‫;‪static int i‬‬
‫‪4.‬‬ ‫;‪int j‬‬
‫‪5.‬‬ ‫};‪Chp9__20(int i,int j){this.i=i;this.j=j‬‬
‫‪6.‬‬ ‫}‬
‫‪7.‬‬
‫{ ‪8. class Chp9_20‬‬
‫‪9.‬‬ ‫{)][‪public static void main(String args‬‬
‫‪10.‬‬
‫‪11.‬‬ ‫;)‪Chp9__20 c =new Chp9__20(10,20),d=new Chp9__20(30,40‬‬
‫‪12.‬‬ ‫;)‪System.out.println(c.i+" "+c.j‬‬
‫‪13.‬‬ ‫;)‪System.out.println(d.i+" "+d.j‬‬
‫‪14.‬‬ ‫}‬
‫} ‪15.‬‬

‫ﺷﺮح اﻟﻤﺜﺎل‪:‬‬
‫ﻧﻼﺣﻆ اﻧﮫ ﻋﻨﺪﻣﺎ أرﺳﻠﻨﺎ اﻟﻘﯿﻤﺔ ‪ 30‬إﻟﻰ ‪ I‬ﻟﻠﻔﺌﺔ ‪ d‬ﻓﺎن ﻗﯿﻤﺔ ‪ I‬ﻗﺪ ﺗﻐـﯿـﺮت ﻣﻦ ‪ 20‬إﻟﻰ ‪ 30‬ﺗﺒﻌ ًﺎ‬
‫ﻓﺄﻧﺔ ﺗـﺘـﻐـﯿﺮ ﺟﻤﯿﻊ‬ ‫ﻟﻠﻘﯿﻤﺔ اﻷﺧﯿﺮة ﻓﮭﺬا ﯾﻌﻨﻲ أن أي ﺗﻐﯿﺮ ﻟﻠﻤﺘﻐﯿﺮات ﻣﻦ ﻧﻮع ‪static‬‬
‫ﻣﺘـﻐـﯿﺮات اﻟﻔﺌﺎت اﻟﺘﻲ ﻣﻦ ﻧﻮع ‪ static‬ﻛﻤﺎ ﻓﻲ اﻟﺴﻄﺮ ‪.11‬‬

‫ھﺬا اﻟﻤﺜﺎل ﯾﻌﺘﺒﺮ ﻏﺮﯾﺐ ﻧﻮﻋﺎً ﻣﺎ !!‬

‫ﺑﺮﻧﺎﻣﺞ ﯾﺒﯿﻦ اﻷﺧﺘﻼف ﺑﯿﻦ اﻟﻤﺘﻐﯿﺮات اﻟﻤﺤﻠﯿﺔ واﻟﻌﺎﻣﺔ ﻟﻠﻜﻼس ‪1. //‬‬
‫{ ‪2. class Chp9__21‬‬
‫‪3.‬‬ ‫;‪int x, y, Count‬‬
‫‪4.‬‬ ‫} ;‪Chp9__21(int x, int y) { this.x = x; this.y = y‬‬
‫‪5.‬‬ ‫;)‪static Chp9__21 origin = new Chp9__21(0, 0‬‬
‫‪6.‬‬ ‫}‬
‫{ ‪7. class Chp9_21‬‬
‫‪8.‬‬ ‫{ )‪public static void main(String[] args‬‬
‫‪9.‬‬ ‫;)‪Chp9__21 p = new Chp9__21(1,1‬‬
‫‪10.‬‬ ‫;)‪Chp9__21 q = new Chp9__21(2,2‬‬
‫‪11.‬‬ ‫;‪p.Count++; p.origin.Count++‬‬
‫‪12.‬‬ ‫;) ‪System.out.println( p.x + "," + p.y‬‬
‫‪13.‬‬ ‫;)‪System.out.println(q.Count‬‬

‫‪[email protected]‬‬ ‫‪324‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫‪14.‬‬ ‫;)‪System.out.println(q.origin == Chp9__21.origin‬‬
‫‪15.‬‬ ‫;)‪System.out.println(q.origin.Count‬‬
‫} ‪16.‬‬
‫} ‪17.‬‬

‫ﺷﺮح اﻟﻤﺜﺎل‪:‬‬
‫ﻋﻨﺪ ﺗﺘﺒﻊ أي ﺑﺮﻧﺎﻣﺞ ﻓﻌﻠﯿﻚ أن ﺗﺮﺳﻢ ھﯿﻜﻞ ‪ Class‬ﻛﻤﺎ ﻓﻲ اﻟﺸﻜﻞ ‪ 9-6‬ﻟﻜﻲ ﯾﺴﮭﻞ ﻋﻠﯿﻚ إﯾﺠﺎد‬
‫ﺧﺮج اﻟﺒﺮﻧﺎﻣﺞ ‪:‬‬

‫‪p‬‬ ‫‪q‬‬
‫‪x‬‬ ‫‪y‬‬ ‫‪Count‬‬ ‫‪x‬‬ ‫‪y‬‬ ‫‪Count‬‬
‫‪Origin‬‬ ‫‪Origin‬‬

‫‪x‬‬ ‫‪y Count‬‬

‫ﺷﻜﻞ ‪9-6‬‬
‫ﻓﻤﻦ اﻟﻤﻼﺣﻆ إﻧﻨﺎ ﻟﺪﯾﻨﺎ ﻓﺌﺘﺎن ‪ q , p‬وﺗﻢ إﺳﻨﺎد ﻟﮭﻢ )‪ (1,1‬و )‪ (2,2‬وداﺧﻞ ﻛﻞ ﻓﺌﺔ ﻓﺌﺔ داﺧﻠﯿﺔ‬
‫ﻟﮭﺎ ھﯿﻜﻞ ﺑﻨﻔﺲ ھﯿﻜﻞ اﻟﻔﺌﺔ اﻟﺨﺎرﺟﯿﺔ ﻓﺒﻌﺪ اﺷﺘﻘﺎق اﻟﻔﺌﺎت وإرﺳﺎل اﻟﻘﯿﻢ ﻟﮭﺎ ﻛﻤﺎ ﻓﻲ اﻷﺳﻄﺮ ) ‪10‬‬
‫‪ (- 9‬ﺗﻜﻮن اﻟﻔﺌﺎت ﻛﻤﺎ ﻓﻲ اﻟﺸﻜﻞ ‪: 9-7‬‬

‫‪[email protected]‬‬ ‫‪325‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ﺷﻜﻞ ‪9-7‬‬

‫ﺑﻌﺪ ﺗﻨﻔﯿﺬ اﻟﺴﻄﺮ ‪ 11‬ﺗﺼﺒﺢ أﺷﻜﺎل اﻟﻔﺌﺎت وﻗﯿﻤﮭﺎ داﺧﻞ اﻟﺬاﻛﺮة ﻛﻤﺎ ﻓﻲ اﻟﺸﻜﻞ ‪:9-8‬‬

‫ﺷﻜﻞ ‪9-8‬‬

‫وﻣﻦ ﺧﻼل اﻹﺷﻜﺎل اﻟﺴﺎﺑﻘﺔ ﯾﺘﻀﺢ ﺧﺮج اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬

‫‪ 9.5‬اﻟﻜﺒﺴﻠﺔ ‪.Encapsulation‬‬
‫إن ﻋﻤﻠﯿﺔ ﺗﻐﻠﯿﻒ أو ﻟﻒ اﻟﺒﯿﺎﻧﺎت واﻟﺪوال ﻓﻲ وﺣﺪة واﺣﺪة ﺗﺴﻤﻰ اﻟﺘﻐﻠﯿﻒ )‪(Encapsulation‬‬
‫وﺑﺬﻟﻚ ﻓﺈن ﺧﻮاص اﻟﺸﻲء وﻣﻨﮭﺠﯿﺘﮫ ﺗﻜﻮن داﺧﻞ اﻟﺼﻨﺪوق وﺑﺸﻜﻞ ﺣﺰﻣﺔ واﺣﺪة وﯾﺘﻀﺢ‬ ‫‪،‬‬
‫ﺷﻜﻞ أﻋﻼه أن اﻟﺼﻨﺪوق ﻣﻘﺴﻢ إﻟﻰ ﺟﺰﯾﺌﯿﻦ‪:‬‬

‫‪[email protected]‬‬ ‫‪326‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫اﻟﺠﺰء اﻟﻌﻠﻮي ﯾﻀﻢ اﻟﺨﻮاص وﻓﻲ ﺣﯿﻦ أن اﻟﺠﺰء اﻟﺴﻔﻠﻲ ﯾﻀﻢ ﻣﻨﮭﺠﯿﺘﮫ‪ .‬وﻣﻦ اﻟﺠﺪﯾﺮ ﺑﺎﻟﺬﻛﺮ‬
‫اﻟﺒﯿﺎﻧﺎت ﻣﻦ اﻟﻤﺤﯿﻂ اﻟﺨﺎرﺟﻲ وﻟﻜﻦ ﻓﻘﻂ اﻟﺪوال اﻟﻤﻮﺟﻮدة داﺧﻞ‬ ‫أﻧﺔ ﻻ ﯾﻤﻜﻦ اﻟﻮﺻﻮل إﻟﻰ‬
‫إن ھﺬه اﻟﺪوال ﺗﺠﮭﺰ ﺑﻮاﺳﻄﺔ اﺗﺼﺎل ﻣﺎﺑﯿﻦ ﺑﯿﺎﻧﺎت‬ ‫اﻟﺼﻨﻒ ‪ class‬ﯾﻤﻜﻦ أن ﺗﺼﻞ إﻟﯿﺔ ‪،‬‬
‫واﻟﻄﺮﯾﻘﺔ اﻟﻮﺣﯿﺪة ﻟﻠﺤﺼﻮل ﻋﻠﻰ ﻣﻌﻠﻮﻣﺎت ﻣﻦ اﻟﺸﻲء ﺗﻜﻮن ﻋﻦ ﻃﺮﯾﻖ‬ ‫اﻟﺸﻲء واﻟﺒﺮاﻣﺞ ‪،‬‬
‫إرﺳﺎل رﺳﺎﻟﺔ إﻟﻰ ھﺬا اﻟﺸﻲء وﺗﻜﻮن اﻟﻤﻌﻠﻮﻣﺎت واﻟﻘﻮ اﻋﺪ اﻟﺘﻲ ﯾﺴﺘﺨﺪﻣﮭﺎ اﻟﺸﻲء ﻛﺎﺳﺘﺠﺎﺑﺔ‬
‫اﻟﺮﺳﺎﻟﺔ ﻣﺨﻔﯿﺔ ﻋﻦ اﻟﻌﺎﻟﻢ اﻟﺨﺎرﺟﻲ ‪.information hiding‬‬
‫أن أﺳﻤﺎء ﻣﻨﮭﺠﯿﺔ اﻟﺸﻲء ﺗﻜﻮن ﺑﺸﻜﻞ ﻣﺴﺘﻄﯿﻞ ﻗﺪ ﺗﺘﺤﺪى ﺣﺪود‬ ‫وﯾﺘﻀﺢ وﻣﻦ اﻟﺸﻜﻞ ‪9-9‬‬
‫اﻟﺼﻨﺪوق )اﺟﺘﯿﺎزھﺎ( ﻟﺬﻟﻚ ﻓﮭﻲ ﯾﻤﻜﻦ أن ﺗﻤﺜﻞ ﺑﺄزرار ‪ button‬ﻋﻠﻰ اﻟﺸﻲء وﯾﺘﺼﻞ ﻛﻞ واﺣﺪ‬
‫ﻣﻨﮭﺎ ﺑﻤﻨﮭﺠﯿﺔ اﻟﺸﻲء ﺑﺎﻟﻀﺒﻂ ‪ .‬وﯾﺸﻤﻞ اﻷزرار اﻟﻤﻮﺟﻮدة ﻋﻠﻰ اﻟﺸﻲء اﻟﺴﻄﺢ اﻟﺒﯿﻨﻲ ﻟﻠﺸﻲء‬
‫‪ Object Interface‬وﻛﻤﺎ ﯾﻼﺣﻆ ﻣﻦ ﺧﺎرج اﻟﺸﻲء ‪.‬‬

‫ﺷﻜﻞ ‪9-9‬‬

‫ﻗﺪ ﺗﻜﻮن ﻋﺰﯾﺰي اﻟﻘﺎرئ ﻋﺪﻧﻚ ﺧﺒﺮة ﺳﺎﺑﻘﺔ ﻓﻲ اﻟﺒﺮﻣﺠﺔ وﺗﻘﻮل أﻧﻨﺎ ﻓﻲ اﻟﺒﺮﻣﺠﺔ‬
‫اﻟﻤﮭﯿﻜﻠﺔ ﻧﺴﺘﻄﯿﻊ أن ﻧﺨﻔﻲ وﻧﻐﻠﻒ اﻟﺒﯿﺎﻧﺎت ﻓﻲ اﻟﺪاﻟﺔ ﺑﺠﻌﻠﮭﺎ ﺧﺎﺻﺔ ‪ private‬ﺑﮭﺬه اﻟﺪاﻟﺔ ﻓﻘﻂ‬
‫وﻣﻌﻚ ﺣﻖ ﻓﻲ ذﻟﻚ وﻟﻜﻦ ﻣﺎذا ﻟﻮ أردﻧﺎ ﺟﻌﻞ ھﺬه اﻟﺒﯿﺎﻧﺎت ‪ Global‬وھﺬا ﺻﺤﯿﺢ وﻟﻜﻦ ﻣﺎ اﻟﺤﻞ‬
‫إذا أردﻧﺎ ﺟﻌﻞ ﺗﻠﻚ اﻟﺒﯿﺎﻧﺎت ﻣﺘﺎﺣﺔ ﻟﺒﻌﺾ اﻟﺪوال وﻏﯿﺮ ﻣﺘﺎﺣﺔ ﻟﻸﺧﺮى واﻟﺤﻞ أن ﯾﻜﻮن ﻋﻨﺪﻧﺎ‬
‫‪ Multiple Scope‬وھﺬا ﻣﺎ ﺗﺆدﯾﮫ ﻟﻨﺎ ﻋﻤﻠﯿﺔ ‪ Encapsulation‬ﻓﻤﻦ ﺧﻼل اﻟﻔﺼﻠﯿ ﺔ اﺳﺘﻄﯿﻊ‬
‫أن اﺟﻌﻞ اﻟﺒﯿﺎﻧﺎت ‪ Global‬ﻟﻠﺪوال اﻟﺘﻲ أرﯾﺪ أن ﺗﺘﻮﺻﻞ ‪ Access‬ﻟﮭﺬه اﻟﺒﯿﺎﻧﺎت ﺑﺎن أﺿﻌﮭﻢ‬
‫ﺳﻮﯾﺎ ﻓﻲ ﻓﺼﯿﻠﺔ واﺣﺪة ‪.‬‬

‫‪[email protected]‬‬ ‫‪327‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫• إﺧﻔﺎء اﻟﺒﯿﺎﻧﺎت ‪ Data Hiding‬و ﻣﻌﺪﻻت اﻟﺮؤﯾﺔ واﻟﻮﺻﻮل ‪:‬‬

‫ﻟﻘﺪ ﺧﻠﻖ اﻟﻤﺒﺪع واﻷول واﻵﺧﺮ ﺳﺒﺤﺎﻧﮫ ال‪ class‬اﻹﻧﺴﺎن وﺟﻌﻞ ﻟﮫ ﺻﻔﺎت ) = ‪members‬‬
‫‪ (variables‬ﻣﻦ ﻋﯿﻨﯿﻦ وأﻧﻒ وأذن و ﻗﻠﺐ و اﻟﻜﺜﯿﺮ ﻣﻦ اﻟﺼﻔﺎت اﻷﺧﺮى وﻗﺪ ﺟﻌﻞ اﷲ ھﺬه‬
‫اﻟﺼﻔﺎت ﻣﻦ اﻟﻤﻤﻜﻦ أن ﻧﺼﻞ ﻟﮭﺎ وﻧﻤﺴﻜﮭﺎ ﻓﻨﺴﺘﻄﯿﻊ أن ﻧﻤﺴﻚ أﻋﯿﻨﻨﺎ و ھﻨﺎك اﻟﻄﺒﯿﺐ اﻟﺠﺮاح‬
‫اﻟﺬي ﯾﻤﺴﻚ اﻟﻘﻠﺐ ﺑﯿﺪﯾﮫ ﻓﮭﺬه اﻟﺼﻔﺎت ﯾﺴﺘﻄﯿﻊ أن ﯾﺼﻞ ﻟﮭﺎ أي ﺷﻲء ﻓﮭﻲ ﻋﺎﻣﺔ )‪، (public‬‬
‫وﺧﻠﻖ اﷲ أﯾﻀﺎً ﺻﻔﺎت )‪ (members‬ﻓﻲ اﻹﻧﺴﺎن ﻣﺜﻞ اﻟﺮوح وﻟﻜﻨﻨﺎ ﻻ ﻧﺴﺘﻄﯿﻊ أن ﻧﺼﻞ ﻟﮭﺎ‬
‫و ﻧﻤﺴﻚ ﺑﮭﺎ‪ .‬ﯾﻘﻮل ﺗﻌﺈﻟﻰ ) و ﯾﺴﺄﻟﻮﻧﻚ ﻋﻦ اﻟﺮوح ﻗﻞ اﻟﺮوح ﻣﻦ أﻣﺮ رﺑﻲ( ﻓﮭﻲ ﺻﻔﺎت ﺧﺎﺻﺔ‬
‫)‪ (private‬ﻣﻤﻨﻮع أن ﺗﺼﻞ ﻟﮭﺎ أي )‪ (class‬أﺧﺮى ‪ .‬و ﺗﺨﯿﻞ ﻟﻮ ﻛﺎﻧﺖ اﻟﺮوح ﻣﻦ اﻟﻤﻤﻜﻦ أن‬
‫ﻧﺼﻞ ﻟﮭﺎ وﻧﻤﺴﻜﮭﺎ ﻣﺜﻞ اﻟﻌﯿﻦ ﻓﻜﻤﺎ إﻧﮫ ھﻨﺎك ﻣﻦ ﺗﻤﺮض ﻋﯿ ﻨﮫ ﻓﯿﻘﻮم ﺑﻨﻘﻞ ﻋﯿﻦ إﻧﺴﺎن آﺧﺮ ﻓﻠﻮ‬
‫ﻛﺎﻧﺖ اﻟﺮوح ﻣﻦ اﻟﻤﻤﻜﻦ أن ﻧﺼﻞ ﻟﮭﺎ )‪ (public‬ﻟﻮﺟﺪﻧﺎ ﻣﻦ ﻻ ﺗﻌﺠﺒﮫ روﺣﮫ ﻓﯿﻨﻘﻞ وﯾﺴﺘﺒﺪل‬
‫روح إﻧﺴﺎن آﺧﺮ ! إذن ﻓﮭﻨﺎك )‪ (members‬ﻓﻲ ال ‪ class‬ﺗﻜﻮن ‪ public‬وأﺧﺮى‬
‫‪ private‬ﻻ ﺗﺴﺘﻄﯿﻊ ‪ class‬أﺧﺮى أن ﺗﺼﻞ ﻟﮭﺎ ﻣﺒﺎﺷﺮة‪.‬‬
‫وﻟﻜﻦ ﻗﺪ ﯾﻘﻮم ﺻﺎﻧﻊ ال ‪ class‬ﺑﻌﻤ ﻞ ‪ methods‬ﺗﺆﺛﺮ ﻓﻲ ھﺬه ال ‪private members‬‬
‫ودون أن ﺗﺼﻞ ﻟﮭﺎ‪ .‬ﻓﻤﺜﻼ ﺟﻌﻞ اﷲ اﻟﺨﺎﻟﻖ اﻟﻌﻈﯿﻢ ‪ methods‬ﻓﻲ اﻹﻧﺴﺎن ﯾﺴﺘﻄﯿﻊ ﺑﮭﺎ أن‬
‫ﯾﺆﺛﺮ ﻓﻲ اﻟﺮوح وﻣﻦ ھﺬه ال ‪ methods‬ﯾﺼﻠﻲ و ﯾﺰﻛﻲ وﯾﺼﻮم ‪.‬‬
‫وﺧﻠﻖ اﻟﺨﺎﻟﻖ ﺳﺒﺤﺎﻧﮫ وﺗﻌﺈﻟﻰ أﯾﻀﺎ ﺟﯿﻨﺎت ﻧﻤﺘﻠﻜﮭﺎ ﻣﻦ أﺑﻮﯾﻨﺎ وﻻ ﯾﺴﺘﻄﯿﻊ ﻓﺮد ﺧﺎرج اﻟﻌﺎﺋﻠﺔ أن‬
‫ﯾﻤﺘﻠﻜﮭﺎ أو أن ﯾﺤﺼﻞ ﻋﻠﯿﮭﺎ ﻣﺜﻞ اﻟﻨﺨﺎع ‪...‬‬
‫ﻓﻲ ‪ Java‬ﯾﺴﺘﻄﯿﻊ ال ‪ class creator‬أن ﯾﺤﺪد ﻗﻮاﻋﺪ اﻟﻮﺻﻮل )‪ (access control‬ﻟﻞ‬
‫‪ members‬ﻓﻲ ال ‪ class‬ﻣﻦ ‪ variables‬و ‪ .methods‬ھﺬه ‪ access control‬ھﻲ‬
‫‪ public) :‬و ‪ private‬و ‪ protected‬و ‪. (default‬‬

‫‪ / Public‬وھﻲ ﻋﺎﻣﺔ أي ﺗﺴﺘﻄﯿﻊ اﻟﻮﺻﻮل إﻟﯿﮭﺎ ﻣﻦ ﺧﺎرج ‪ Class‬وﻣﻦ ﺧﺎرج‬

‫اﻟﺒﺮﻧﺎﻣﺞ أﯾﻀﺎ ﺑﻮاﺳﻄﺔ اﻟﺤﺰم أو اﻟﻮاﺟﮭﺎت وھﺬه ﻣﻮاﺿﯿﻊ ﺳﯿﺘﻢ ﺷﺮﺣﮭﺎ ﺑﺎﻟﺘﻔﺼﯿﻞ ﻓﻲ‬
‫اﻟﻔﺼﻮل اﻟﻘﺎدﻣﺔ‬
‫‪ / Private‬أي ﺑﻤﻌﻨﻰ ﻣﺨﻔﯿﺔ ﺗﺴﺘﻄﯿﻊ اﻟﻮﺻﻮل ﻟﮫ ﻣﻦ داﺧﻞ ‪ Class‬ﻓﻘﻂ وﻻ ﯾﻤﻜﻦ‬
‫إﻃﻼﻗﺎ إﻻ ﻋﻦ ﻃﺮﯾﻖ ﺣﯿﻠﺔ ﺳﯿﺘﻢ ذﻛﺮھﺎ ﻻﺣﻘﺎً‬ ‫أن ﺗﻮﺻﻞ ﻟﮫ ﻣﻦ ﺧﺎرج ‪Class‬‬
‫وﺗﺴﺘﺨﺪم ﻓﻲ ﺣﺎﻻت‬
‫ﻋﻨﺪﻣﺎ ﺗﻜﻮن اﻟﻔﺼﺎﺋﻞ اﻷﺧﺮى ﻻ ﺗﺤﺘﺎج إﻟﻰ اﺳﺘﺨﺪام ﺗﻠﻚ‬ ‫‪-1‬‬
‫اﻟﻤﺘﻐﯿﺮات ‪.‬‬
‫‪ -2‬ﻋﻨﺪﻣﺎ ﺗﺨﺸﻰ ﻓﺼﯿﻠﺔ ﺧﺎرﺟﯿﺔ ﻣﻦ أﻟﻌﺒﺖ ﺑﺎﻟﺒﯿﺎﻧﺎت ‪.‬‬
‫‪ / Protected‬أي ﺑﻤﻌﻨﻰ ﻣﺤﻤﻲ أي اﻧﻚ ﺗﺴﺘﻄﯿﻊ اﻟﻮﺻﻮل ﻟ ﮫ ﻣﻦ داﺧﻞ ‪ Class‬أو‬
‫ﻣﻦ ﺧﺎرج ‪ Class‬إذا ﻛﺎن ‪ Class‬ﯾﺮث ﻣﻨﺔ وﻻ ﺗﺴﺘﻄﯿﻊ إﻃﻼﻗﺎ اﻟﻮﺻﻮل ﻟﮭﺬا اﻟﻨﻮع‬
‫ﻣﻦ ﺧﺎرج اﻟﻔﺼﯿﻠﺔ دون وراﺛﺔ وﺳﯿﺘﻢ ذﻛﺮھﺎ ﻓﻲ ﻓﺼﻞ اﻟﻮراﺛﺔ ‪.‬‬

‫‪[email protected]‬‬ ‫‪328‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ ﺗﻌﺘﺒﺮ اﻟﻤﺘﻐﯿﺮات واﻟﺪوال و‬Java ‫إذا ﻟﻢ ﯾﺘﻢ ذﻛﺮ أي ﻣﺤﺪد ﻣﻦ اﻟﺘﻲ ذﻛﺮت ﻓﺎن ﻟﻐﺔ‬
. private ‫ ﻋﺎم ﻓﻲ داﺧﻞ اﻟﺤﺰﻣﺔ ﻓﻘﻂ ﺑﺨﻼف ﻟﻐﺔ اﻟﺴﻲ ﺗﻌﺘﺒﺮھﺎ ﻣﻦ ﻧﻮع‬Class

9-2 ‫ﺟﺪول‬
‫ﻣﻜﺎن اﻟﻮﺻﻮل‬ public default Protected Private

‫ﻣﻦ داﺧﻞ اﻟﻔﺼﯿﻠﺔ‬ ü ü ü ü

‫ﻣﻦ أي ﻓﺼﯿﻠﺔ داﺧﻞ اﻟﺤﺰﻣﺔ‬ ü ü ü û
‫ﻣﻦ أي ﻓﺼﯿﻠﺔ ﺧﺎرج اﻟﺤﺰﻣﺔ‬ ü û û û
‫ﻣﻦ أي ﻓﺼﯿﻠﺔ ﻓﺮﻋﯿﺔ أي ﻣﻮرﺛﺔ‬ ü ü ü û
‫داﺧﻞ اﻟﺤﺰﻣﺔ‬
‫ﻣﻦ أي ﻓﺼﯿﻠﺔ ﻓﺮﻋﯿﺔ ﺧﺎرج‬ ü û ü û
‫اﻟﺤﺰﻣﺔ‬

:‫وھﺬا اﻟﻤﺜﺎل ﯾﺸﺮح ﻣﺎ ﺳﺒﻖ‬

1. // ‫ﺑﺮﻣﺎﻣﺞ ﯾﻮﺿﺢ ﻣﺤﺪدات اﻟﻮﺻﻮل‬
2. class Chp9__22 {
3. private int x, y;
4. public int Count;
5. Chp9__22(int x, int y) { this.x = x; this.y = y; }
6. int get_x(){return x;}
7. private int get_y(){return y;}
8. void show(){System.out.println(get_y());}
9. }
10.
11. class Chp9_22 {
12. public static void main(String[] args) {
13. Chp9__22 p = new Chp9__22(1,10);
14. p.Count++;
15. //p.x++;//error
16. //p.y++;//error
17. //System.out.println( p.x + "," + p.y );//error
18. System.out.println(p.get_x());
19. //System.out.println(p.get_y());//error
20. System.out.println(p.Count);
21. p.show();
22. }
23. }

[email protected] 329 ‫ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬/‫م‬

 ، ‫ أﻛﺜﺮ ﻣﻦ ﻣﺮة‬public , private ‫ﻋﻠﻰ اﻟﺮﻏﻢ ﻣﻦ أﻧﮫ ﯾﻤﻜﻦ اﺳﺘﺨﺪم اﻟﻤﺤﺪدﯾﻦ‬
.ً‫ﻓﯿﻨﺼﺢ ﺑﺬﻛﺮ اﻟﻤﺘﻐﯿﺮات اﻟﻌﺎﻣﺔ أوﻻً ﺛﻢ اﻟﻤﺘﻐﯿﺮات اﻟﺨﺎﺻﺔ ﺛﺎﻧﯿﺎ‬

‫ وﻣﻄﻠﻮب ﻣﻨﻚ ﺗﻨﻔﯿﺬ اﻟﻜﻮد دون اﻟﻤﺴﺎس‬private ‫ھﺬا اﻟﻤﺜﺎل ﺗﻮﺟﺪ ﺑﮫ داﻟﮫ ﺑﻨﺎء ﻣﻦ ﻧﻮع ﻣﺤﻤﻲ‬
‫ﺑﻤﺤﺪدات اﻟﻮﺻﻮل ﻓﻜﯿﻒ ﺳﺘﻌﺎﻟﺞ ھﺬه اﻟﻤﺸﻜﻠﺔ ؟‬

1. // Invalid method declaration; return type required.

2. class Chp9__23 {
3. private Chp9__23() { System.out.println("Start");}
4. }
5. class Chp9_23 {
6. public static void main(String[] args) {
7. // Error No constructor matching Chp9__22() found in class Chp9__23.
8. Chp9__23 p = new Chp9__23();
9. System.out.println("End");
10.
11. }
12. }

:‫ﺣﻞ اﻟﻤﺜﺎل‬
‫ﻟﺪﯾﻚ ﻃﺮﯾﻘﺘﯿﻦ‬
‫ﺗﻌﯿﺪ ﻟﻨﺎ ﻗﯿﻤﺔ ﻣﻦ ﻧﻮع داﻟﺔ اﻟﺒﻨﺎء اﻟﻤﺤﻤﯿﺔ‬ static ‫ أن ﻧﺼﻨﻊ داﻟﺔ ﻣﻦ ﻧﻮع‬:‫اﻷوﻟﻰ‬
:‫ ﻣﻦ ھﺬا اﻟﻤﺜﺎل‬4 ‫ﻛﺎﻟﺴﻄﺮ رﻗﻢ‬
1. // Chp9_23 ‫ﺣﻞ ﺑﺮﻧﺎﻣﺞ‬
2. class Chp9__24 {
3. private Chp9__24() { System.out.println("Start");}
4. static Chp9__24 dop(){return new Chp9__24();}
5. }
6.
7. class Chp9_24 {
8. public static void main(String[] args) {
9. Chp9__24 p = Chp9__24.dop();
10. System.out.println("End");
11. }
12. }

.9 ‫ اﺳﻢ اﻟﺪاﻟﺔ اﻻﺻﻄﻨﺎﻋﯿﺔ ﻛﻤﺎ ﻓﻲ اﻟﺴﻄﺮ‬.Class ‫وﻋﻨﺪ إﻧﺸﺎء اﻟﮭﺪف ﻧﺬﻛﺮ اﺳﻢ‬

[email protected] 330 ‫ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬/‫م‬

 ‫ﻧﻼﺣﻆ أن ھﺬه اﻟﻄﺮﯾﻘﺔ ﻣﺮﺑﻜﺔ ﻧﻮﻋﺎً ﻣﺎ وﻃﻮﯾﻠﺔ ﺑﻌﺾ اﻟﺸﻲء ‪.‬‬
‫ﻓﺈﻟﯿﻜﻢ ھﺬه اﻟﻄﺮﯾﻘﺔ اﻟﺜﺎﻧﯿﺔ واﻟﺒﺴﯿﻄﺔ‪:‬‬
‫ﻧﺼﻨﻊ داﻟﺔ اﺻﻄﻨﺎﻋﯿﺔ ﻣﻦ ﻧﻮع ‪ static‬وﺑﺪاﺧﻠﮭﺎ إﻃﻼق ﻟﺪاﻟﺔ اﻟﺒﻨﺎء اﻟﻤﺤﻤﯿﺔ ‪ .‬ﻛﻢ ﻓﻲ اﻟﺴﻄﺮ‬
‫‪ 5‬ﻣﻦ ھﺬا اﻟﻤﺜﺎل‪:‬‬
‫ﺣﻞ ااﻟﻤﺜﺎل ﺑﻄﺮﯾﻘﺔ أﺧﺮى ‪1. //‬‬
‫{ ‪2. class Chp9__25‬‬
‫‪3.‬‬ ‫‪// Constructors‬‬
‫‪4.‬‬ ‫};)"‪private Chp9__25() { System.out.println("Start‬‬
‫‪5.‬‬ ‫};)(‪static void dop(){ new Chp9__25‬‬
‫‪6.‬‬ ‫}‬
‫{ ‪7. class Chp9_25‬‬
‫‪8.‬‬ ‫{ )‪public static void main(String[] args‬‬
‫‪9.‬‬ ‫;‪Chp9__25 p =null‬‬
‫‪10.‬‬ ‫;)(‪p.dop‬‬
‫‪11.‬‬ ‫;)"‪System.out.println("End‬‬
‫‪12.‬‬ ‫}‬
‫} ‪13.‬‬

‫ﺛﻢ ﻋﻨﺪ إﻧﺸﺎء اﻟﻔﺌﺔ ﻧﺠﻌﻠﮭﺎ ﺗﺴﺎوي ‪ null‬ﻛﻤﺎ ﻓﻲ اﻟﺴﻄﺮ ‪ .9‬ﻓﺒﮭﺬا اﻟﺸﻜﻞ ﻟﻦ ﯾﺘﻢ ﺗﻨﻔﯿﺬ داﻟﺔ ا ﻟﺒﻨﺎء‬
‫إﻃﻼﻗﺎ‪.‬‬
‫ﺛﻢ ﻧﺬﻛﺮ اﺳﻢ اﻟﻔﺌﺔ‪ .‬اﺳﻢ اﻟﺪاﻟﺔ اﻻﺻﻄﻨﺎﻋﯿﺔ ‪ ،‬ﻛﻤﺎ ﻓﻲ اﻟﺴﻄﺮ ‪.10‬‬
‫ﻓﺎﻟﺴﺆال ھﻨﺎ أﯾﮭﻤﺎ أﻓﻀﻞ اﻟﻤﺜﺎل ‪ Chp9_24‬أم اﻟﻤﺜﺎل ‪ Chp9_25‬وﻟﻤﺎذا ؟‬

‫‪ 9.6‬ﻣﺠﺎل ﺗﻐﻄﯿﺔ اﻟﻤﺘﻐﯿﺮات ﺑﺸﻜﻞ أوﺳﻊ‬

‫ﺑﺸﻜﻞ ﻋﺎم ﻟﻜﻲ ﺗﻔﮭﻢ ﻣﻌﻨﻰ ﻣﺠﺎل ﺗﻐﻄﯿﺔ اﻟﻤﺘﻐﯿﺮات ﺗﺘﺒﻊ ھﺬا اﻟﻤﺜﺎل‪:‬‬
‫ﺑﺮﻧﺎﻣﺞ ﯾﻮﺿﺢ ﻣﺠﺎل ﺗﻐﻄﯿﺔ اﻟﻤﺘﺤﻮﻻت ‪1. //‬‬
‫{ ‪2. class Chp9_26‬‬
‫‪3.‬‬ ‫;‪static int i=10‬‬
‫;)‪4. static void print(int i){System.out.println(i‬‬
‫‪5.‬‬ ‫;)‪System.out.println(Chp9_26.i‬‬
‫‪6.‬‬ ‫}‬
‫{)][‪7. public static void main(String args‬‬

‫‪[email protected]‬‬ ‫‪331‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 8. int i=100;
9. System.out.println(Chp9_26.i);
10. System.out.println(i);
11. print(1000);
12. }
13. }

:‫ﺷﺮح اﻟﻤﺜﺎل‬
.print() ‫ ﺗﺸﯿﺮ إﻟﻰ اﻟﺒﺎراﻣﺘﺮ اﻟﺪاﺧﻞ ﻟﻠﺪاﻟﺔ‬4 ‫ﺟﻤﻠﺔ اﻟﻄﺒﺎﻋﺔ اﻟﻤﻮﺟﻮدة ﻓﻲ اﻟﺴﻄﺮ‬
.3 ‫( ﺗﺸﯿﺮ إﻟﻰ اﻟﻤﺘﺤﻮل اﻟﻤﻮﺟﻮد ﻓﻲ اﻟﺴﻄﺮ‬5,9) ‫ﺟﻤﻠﺔ اﻟﻄﺒﺎﻋﺔ اﻟﻤﻮﺟﻮدة ﻓﻲ اﻟﺴﻄﺮ‬
.8 ‫ ﺗﺸﯿﺮ إﻟﻰ اﻟﻤﺘﺤﻮل اﻟﻤﻮﺟﻮد ﻓﻲ اﻟﺴﻄﺮ‬10 ‫ﺟﻤﻠﺔ اﻟﻄﺒﺎﻋﺔ اﻟﻤﻮﺟﻮدة ﻓﻲ اﻟﺴﻄﺮ‬

‫ﺻﺪﯾﻘﻲ اﻟﻘﺎرئ إﻻ أن ﺗﺮﻛﺰ ﻓﻲ ھﺬا اﻟﻜﻮد‬ ‫أم اﻵن وﺑﻌﺪ أن ﺗﻌﻠﻤﻨﺎ اﻷﺳﺎﺳﯿﺎت ﻓﻤﺎ ﻋﻠﯿﻚ اﻵن‬
!‫ﻓﮭﻮ ﻣﮭﻢ ﺟﺪا‬
1. // ‫ﻣﺜﺎل ﺗﻄﺒﯿﻘﻲ‬
2. class Bowl {
3. Bowl(int marker) { System.out.println("Bowl(" + marker + ")"); }
4. void f(int marker) { System.out.println("f(" + marker + ")"); }
5. }
6. class Table {
7. static Bowl b1 = new Bowl(1);
8. Table() { System.out.println("Table()"); b2.f(1);
9. }
10. void f2(int marker) { System.out.println("f2(" + marker + ")"); }
11. static Bowl b2 = new Bowl(2);
12. }
13. class Cupboard {
14. Bowl b3 = new Bowl(3);
15. static Bowl b4 = new Bowl(4);
16. Cupboard() { System.out.println("Cupboard()"); b4.f(2); }
17. void f3(int marker) { System.out.println("f3(" + marker + ")");}
18. static Bowl b5 = new Bowl(5);
19. }
20. public class Chp9_27 {

[email protected] 332 ‫ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬/‫م‬

 ‫{ )‪21. public static void main(String[] args‬‬
‫;)"‪22. System.out.println("Creating new Cupboard() in main‬‬
‫;)(‪23. new Cupboard‬‬
‫;)"‪24. System.out.println( "Creating new Cupboard() in main‬‬
‫;)(‪25. new Cupboard‬‬
‫;)‪26. t2.f2(1‬‬
‫;)‪27. t3.f3(1‬‬
‫} ‪28.‬‬
‫;)(‪29. static Table t2 = new Table‬‬
‫;)(‪30. static Cupboard t3 = new Cupboard‬‬
‫} ‪31.‬‬

‫ﺷﺮح اﻟﻤﺜﺎل‪:‬‬
‫ﯾﺘﻢ ﺗﻨﻔﯿﺬ اﻟﺠﻤﻞ اﻻﺳﺘﺎﺗﯿﻜﯿﺔ ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﯿﺴﻲ ﻛﻤﺎ ﻓﻲ اﻷﺳﻄﺮ )‪.(29,30‬‬ ‫‪(1‬‬
‫ﺑﺪاﺧﻞ ﻛﻞ ‪ Class‬ﻛﺘـﻞ اﺳﺘﺎﺗﯿﻜﻲ ﯾﻘﻮم ﺑﺘﻨﻔﯿﺬه أوﻻً ﻛﻤﺎ ﻓﻲ اﻷﺳﻄﺮ )‪ (7,11,15,18‬ﺛﻢ‬ ‫‪(2‬‬
‫اﻟﺠﻤﻞ اﻟﻐﯿﺮ اﺳﺘﺎﺗﯿﻜﯿﺔ ﻣﺜﻞ ﺟﻤﻞ إﻧﺸﺎء اﻟﻔﺌﺎت ﻛﻤﺎ ﻓﻲ اﻟﺴﻄﺮ ‪. 14‬‬
‫ﯾﻘﻮم ﺑﺘﻨﻔﯿﺬ دوال اﻟﺒﻨﺎء داﺧﻞ ﻛـﻞ ‪. Class‬‬ ‫‪(3‬‬
‫أن ﻋﺎود اﺳﺘﺪﻋﺎء ‪ Class‬ﻣﺮة أﺧﺮى ﻓﺄﻧﺔ ﻻ ﯾﻨﻔﺬ اﻟﻜﺘﻞ اﻻﺳﺘﺎﺗﯿﻜﯿﺔ ﺑﻞ ﯾﻨﻔﺬ‬ ‫‪(4‬‬
‫‪ (1‬اﻟﻜﺘﻞ اﻟﻌﺎدﯾﺔ ‪.‬‬
‫‪ (2‬دوال اﻟﺒﻨﺎء ‪.‬‬

‫وھﺬا ﻧﺎﺗﺞ ﺗﻨﻔﯿﺬ اﻟﺒﺮﻧﺎﻣﺞ‪:‬‬

‫‪[email protected]‬‬ ‫‪333‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫• اﻷﺻﻨﺎف اﻟﺪاﺧﻠﯿﺔ‬
‫اﻟﺼﻨﻒ اﻟﺪاﺧﻠﻲ او اﻟﺼﻨﻒ اﻟﻤﻌﺸﺶ ھﻮ اﻟﺼﻨﻒ اﻟﺬي ﯾﺘﻢ ﺗﻌﺮﯾﻔﺔ ﺿﻤﻦ ﻣﺠﺎل اﻟﺘﻐﻄﯿﺔ اﻟﺘﺎﺑﻊ‬
‫ﻟﺼﻨﻒ أﺧﺮ ‪ .‬واﻟﯿﻚ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﻋﻦ اﻟﺼﻨﻒ اﻟﺪاﺧﻠﻲ‪:‬‬
‫اﻷﺻﻨﺎف اﻟﺪاﺧﻠﯿﺔ ‪1. //‬‬
‫{‪2. class Chp9__28‬‬
‫‪3.‬‬ ‫};)"‪Chp9__28(){System.out.println("Star Chp9__28‬‬
‫‪4.‬‬ ‫‪// local class‬‬
‫‪5.‬‬ ‫{‪static class Chp9___28‬‬
‫‪6.‬‬ ‫‪Chp9___28(){System.out.println("Star‬‬
‫};)"‪Chp9___28local‬‬
‫‪7.‬‬ ‫}‬
‫‪8.‬‬ ‫}‬
‫‪9.‬‬
‫{ ‪10. class Chp9_28‬‬
‫{ )‪11. public static void main(String[] args‬‬
‫;)(‪12. new Chp9__28.Chp9___28‬‬
‫‪13.‬‬ ‫}‬
‫};)"‪14. static{System.out.println("Star Chp9_28‬‬
‫} ‪15.‬‬

‫إذا ﺗﻢ إﺑﻌﺎد ﺟﻤﻠﺔ ‪ static‬ﻓﻤﺎذا ﯾﻜﻮن ﺧﺮج اﻟﺒﺮﻧﺎﻣﺞ ؟‬

‫ﻣﻦ اﻟﻤﻤﻜﻦ اﻟﺼﻨﻒ اﻟﺪاﺧﻠﻲ اﻟﺤﺼﻮل ﻋﻠﻰ ﻣﺮﺟﻊ اﻟﺒﯿﺎﻧﺎت واﻟﻤﻨﺎھﺞ اﻟﻤﻮﺟﻮدة ﻓﻲ‬
‫اﻟﺼﻨﻒ اﻟﺨﺎرﺟﻲ اﻟﺬي ﯾﻌﺸﺶ ﻓﯿﮫ ‪ .‬ﻟﺬﻟﻚ ﻻ ﺗﺤﺘﺎج إﻟﻰ ﺗﻤﺮﯾﺮ ﻣﺮﺟﻊ ﻟﻠﺼﻨﻒ اﻟﺨﺎرﺟﻲ‬
‫ﺿﻤﻦ ﺑﺎﻧﻲ اﻟﺼﻨﻒ اﻟﺪاﺧﻠﻲ ‪ .‬ﻛﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‪:‬‬

‫ﺣﺼﻮل اﻟﻜﻼس اﻟﺪاﺧﻠﻲ ﻋﻠﻰ ﻗﯿﻢ ﻣﺘﺤﻮﻻت اﻟﻜﻼس اﻟﺨﺎرﺟﻲ ‪1. //‬‬
‫;‪2. class Chp9__29{static int i=20‬‬
‫‪3.‬‬ ‫};)"‪Chp9__29(){System.out.println("Star Chp9__29‬‬
‫‪4.‬‬
‫‪5.‬‬ ‫;‪static class Chp9___29{static int i=40‬‬
‫‪6.‬‬ ‫;‪Chp9___29(){int i=50‬‬
‫‪7.‬‬ ‫;)‪System.out.println(i+" "+this.i‬‬
‫‪8.‬‬ ‫;)‪System.out.println(Chp9___29.i+" "+Chp9__29.i‬‬

‫‪[email protected]‬‬ ‫‪334‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫‪9.‬‬ ‫}‬
‫‪10.‬‬ ‫}‬
‫‪11.‬‬ ‫}‬
‫{ ‪12. public class Chp9_29‬‬
‫{ )‪13. public static void main(String[] args‬‬
‫;)(‪14. new Chp9__29.Chp9___29‬‬
‫‪15.‬‬ ‫}‬
‫} ‪16.‬‬

‫اﺳﺘﺨﺪام اﻷﺻﻨﺎف اﻟﺪاﺧﻠﯿﺔ ﺗﺠﻌﻞ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺴﯿﻄﺎً وﻣﺨﺘﺼﺮاً‪.‬‬

‫ﻣﻦ اﻟﻤﻤﻜﻦ اﻟﺘﺼﺮﯾﺢ ﻋﻦ اﻟﺼﻨﻒ اﻟﺪاﺧﻠﻲ ﻋﻠﻰ أﻧﮫ ) ‪public , private ,‬‬
‫‪ (protected‬ﺣﯿﺚ ﯾﺨﻀﻊ ﻟﻨﻔﺲ ﻗﻮاﻋﺪ اﻟﺮؤﯾﺔ اﻟﻤﻄﺒﻘﺔ ﻋﻠﻰ ﻋﻨﺎﺻﺮ اﻟﺼﻨﻒ‪.‬‬

‫ﻟﻤﻤﻜﻦ اﻟﺘﺼﺮﯾﺢ ﻋﻠﻰ ﻋﻨﺎﺻﺮ اﻟﺼﻨﻒ اﻟﺪاﺧﻠﻲ ﻋﻠﻰ أﻧﮫ ‪ static‬ﺣﯿﺚ ﻣﻦ‬ ‫ﻣﻦ ا‬
‫اﻟﻤﻤﻜﻦ اﻟﻮﺻﻮل إﻟﻰ اﻟﺼﻨﻒ اﻻﺳﺘﺎﺗﯿﻜﻲ ﺑ ﺎﺳﺘﺨﺪام اﻟﺼﻨﻒ اﻟﺨﺎرﺟﻲ‪ .‬ﻓﺴﺘﺨﺪم اﻟﺼﯿﻐﺔ‬
‫اﻟﺘﺎﻟﯿﺔ‪:‬‬
‫;)(‪Otherclass.innerclass innerobject =new Otherclass.innerclass‬‬

‫اﻟﻌﻨﺎﺻﺮ اﻟﺴﺘﺎﺗﯿﻜﯿﺔ اﻟﺘﺎﺑﻌﺔ ﻟﻠﺼﻨﻒ اﻟﺨﺎرﺟﻲ ﻣﻦ اﻟﺼﻨﻒ‬ ‫ﻣﺤﺎوﻟﺔ اﻟﻮﺻﻮل إﻟﻰ‬

‫اﻟﺪاﺧﻠﻲ اﻻﺳﺘﺎﺗﯿﻜﻲ ﯾﻌﺘﺒﺮ ﺧﻄﺎء ﺷﺎﺋﻌﺎً‪.‬‬

‫ﻟﻠﻘﺎرئ اﻟﻨﺒﯿﻞ ﻓﻘﻂ ﻣﺎ ﺧﺮج ھﺬا اﻟﻜﻮد وﻟﻤﺎذا ؟‬

‫ﻣﺜﺎل ﻟﻠﻠﻘﺎرئ اﻟﻨﺒﯿﻞ ‪1. //‬‬
‫{‪2. class Chp9__30‬‬
‫‪3.‬‬ ‫};)"‪Chp9__30(){System.out.println("Star Chp9__30‬‬
‫‪4.‬‬

‫‪[email protected]‬‬ ‫‪335‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 5. static class Chp9___30{
6. Chp9___30(){System.out.println("Star Chp9___30");}
7. }
8. Chp9___30 b= new Chp9___30();
9. }
10. public class Chp9_30 {
11. public static void main(String[] args) {
12. new Chp9__30.Chp9___30();
13. }
14. static{System.out.println("Star Chp9_30");}
15. }

‫وھﻞ ھﺬا اﻟﻜﻮد ﯾﺸﺒﮫ اﻟﻜﻮد اﻟﺴﺎﺑﻖ؟‬

1. // ‫ﻣﺜﺎل ﻟﻠﻘﺎرئ اﻟﻨﺒﯿﻞ‬
2. class Chp9__31{
3. Chp9__31(){System.out.println("Star Chp9__31");}
4. static class Chp9___31{
5. Chp9___31(){System.out.println("Star Chp9___31");}
6. }
7. Chp9___31 b= new Chp9___31();
8. {Chp9__31 b= new Chp9__31();}
9. }
10. public class Chp9_31 {
11. public static void main(String[] args) {
12. new Chp9__31.Chp9___31();
13. }
14. static{System.out.println("Star Chp9_31");}
15. }

‫ھﻞ ﻧﺎﺗﺞ ھﺬا اﻟﻤﺜﺎل ﺻﺤﯿﺢ؟‬

1. // ‫ﻣﺜﺎل ﻟﻠﻘﺎرئ اﻟﻨﺒﯿﻞ‬
2. class Chp9__32{
3. Chp9__32(){System.out.println("Star Chp9__32");}
4. static class Chp9___32{
5. Chp9___32(){System.out.println("Star Chp9___32");}
6. static void show(){System.out.println("show Chp9___32");}
7. }
8. static{Chp9__32 b= new Chp9__32();}
9. }
10. public class Chp9_32 {
11. public static void main(String[] args) {
12. Chp9__32.Chp9___32.show();
13. }
14. }

[email protected] 336 ‫ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬/‫م‬

 ‫إن ﻗﻠﺖ ﻧﺎﺗﺞ اﻟﻜﻮد ﺻﺤﯿﺢ ﻓﻘﺪ أﺧﻄﺄت !!‬
‫واﻟﺴﺒﺐ ‪:‬‬
‫ﺻﺤﯿﺢ إﻧﻨﺎ أﺧﺒﺮﻧﺎك ﺑﺄن اﻟﻤﺘﺮﺟﻢ ﯾﻨﻔﺬ اﻟﺠﻤﻞ ‪ static‬أوﻻً‪ ،‬وﻟﻜﻦ ﻓﻲ ﺣﺎﻟﮫ إﻃﻼق اﻟﮭﺪف‪.‬‬
‫اﻟﺪاﺧﻠﻲ وﻟﻢ ﻧﻨﺸﻂ داﻟﮫ اﻟﺒﻨﺎء ‪Class‬‬ ‫ﻓﻔﻲ ﻣﺜﺎﻟﻨﺎ اﻟﺴﺎﺑﻖ وﺻﻠﻨﺎ وﺻﻮل ﻣﺒﺎﺷﺮ ‪Class‬‬
‫اﻟﺨﺎرﺟﻲ ﻓﮭﺬا ھﻮ اﻟﺴﺒﺐ‪.‬‬

‫‪[email protected]‬‬ ‫‪337‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫ﺗﻤﺎرﯾﻦ اﻟﻔﺼﻞ‪:‬‬

‫‪ .1‬اﻣﻸ اﻟﻔﺮاﻏﺎت اﻟﺘﺎﻟﯿﺔ‪:‬‬

‫ﺑﻌﻤﻠﯿﺎت اﻟﺤﺠﺰ اﻟﺪﯾﻨﺎﻣﯿﻜﻲ ﻟﻠﺬاﻛﺮة ﻣﻦ أﺟﻞ إﻧﺸﺎء ﺻﻨﻒ ﻣﺎ ﻣﻦ‬ ‫• ﺗﻘﻮم اﻟﻌﻤﻠﯿﺔ ‪.....‬‬
‫ﻧﻤﻂ ﻣﻌﯿﻦ‪.‬‬
‫• ﺗﻤﺜﻞ اﻟﻤﻌﻄﯿﺎت اﻷﻋﻀﺎء اﻟﺘﻲ ھﻲ ﻣﻦ ﺻﻒ اﻟﺘﺨﺰﯾﻦ ‪ .....‬اﻟﻤﻌﻠﻮﻣﺎت اﻟﻤﺘﻮﻓﺮة ﻋﻠﻰ‬
‫ﻣﺴﺘﻮى اﻟﺼﻨﻒ ﺑﺄﻛﻤﻠﮫ‪.‬‬
‫• ﻻ ﯾﻤﻜﻦ اﻟﻮﺻﻮل إﻟﻰ أﻋﻀﺎء اﻟﺼﻨﻒ ‪ ......‬إﻻ ﻣﻦ ﺧﻼل ﻣﻨﺎھﺞ اﻷﻋﻀﺎء اﻟﻤﺮﺗﺒﻄﺔ‬
‫ﺑﺎﻟﺼﻨﻒ‪.‬‬
‫• ﯾﻌﺘﺒﺮ اﻟﺘﺎﺑﻊ ‪ ....‬أﺣﺪ اﻟﺘﻮاﺑﻊ اﻷﻋﻀﺎء اﻟﺘﻲ ﺗﺴﺘﺨﺪم ﻹﻋﻄﺎء ﻗﯿﻢ اﺑﺘﺪاﺋﯿﺔ إﻟﻰ اﻟﻤﻌﻄﯿﺎت‬
‫اﻷﻋﻀﺎء اﻟﻤﺮﺗﺒﻄﺔ ﺑﺎﻟﺼﻨﻒ‪.‬‬
‫• ﯾﻤﻜﻦ اﻟﻮﺻﻮل إﻟﻰ اﻷﻋﻀﺎء ‪ ....‬اﻟﻤﺮﺗﺒﻄﺔ ﺑﺼﻨﻒ ﻣﻦ أي ﻧﻘﻄﺔ ﯾﻤﻜﻦ ﻓﯿﮭﺎ إﻧﺸﺎء‬
‫ﺻﻨﻒ ﺗﺎﺑﻊ ﻟﮭﺬا اﻟﺼﻨﻒ‪.‬‬
‫‪ .2‬ﻣﺎھﻮ اﻟﮭﺪف ﻣﻦ ﻋﻤﻠﯿﺔ ﺗﺤﺪﯾﺪ ﻣﺠﺎل اﻟﺮؤﯾﺔ ؟‬
‫اﻛﺘﺸﻒ اﻟﺨﻄﺎء ﻓﻲ ھﺬا اﻟﺒﺮﻧﺎﻣﺞ واﺟﻌﻞ ﻧﺎﺗﺞ ﺗﻨﻔﯿﺬه ﻧﻔﺲ اﻟﻤﺜﺎل ‪ Chp9_32‬دون‬ ‫‪.3‬‬
‫اﻟﻤﺴﺎس ﺑﻤﺤﺪد اﻟﻮﺻﻮل ؟‬
‫‪1. // EXP 1‬‬
‫;‪2. class Chp9__33{static int i=20‬‬
‫‪3.‬‬ ‫};)"‪Chp9__33(){System.out.println("Star Chp9__33‬‬
‫‪4.‬‬
‫‪5.‬‬ ‫;‪private static class Chp9___33{static int i=40‬‬
‫‪6.‬‬ ‫;‪Chp9___33(){int i=50‬‬
‫‪7.‬‬ ‫;)‪System.out.println(i+" "+this.i‬‬
‫‪8.‬‬ ‫;)‪System.out.println(Chp9___33.i+" "+Chp9__33.i‬‬
‫‪9.‬‬ ‫}‬
‫‪10.‬‬ ‫}‬
‫‪11.‬‬ ‫}‬
‫{ ‪12. public class Chp9_33‬‬
‫{ )‪13. public static void main(String[] args‬‬
‫;)(‪14. new Chp9__33.Chp9___33‬‬
‫‪15.‬‬ ‫}‬
‫} ‪16.‬‬

‫‪ .4‬اﻛﺘﺸﻒ اﻟﺨﻄﺎء ﻓﻲ ھﺬا اﻟﺒﺮﻧﺎﻣﺞ ‪:‬‬

‫‪1. // EXP 2‬‬
‫;‪2. class Chp9__34{int i=20‬‬
‫‪3.‬‬ ‫};)(‪Chp9__34(){new Chp9___34‬‬
‫‪4.‬‬ ‫;‪static class Chp9___34{static int i=40‬‬
‫‪5.‬‬ ‫;‪Chp9___34(){ int i=50‬‬
‫‪6.‬‬ ‫;)‪System.out.println(i+" "+this.i‬‬
‫‪7.‬‬ ‫;)‪System.out.println(Chp9___34.i+" "+Chp9__34.i‬‬

‫‪[email protected]‬‬ ‫‪338‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬

 ‫‪8.‬‬ ‫}‬
‫‪9.‬‬ ‫}‬
‫‪10.‬‬ ‫}‬
‫{ ‪11. public class Chp9_34‬‬
‫{ )‪12. public static void main(String[] args‬‬
‫;)(‪13. new Chp9__34‬‬
‫‪14.‬‬ ‫}‬
‫} ‪15.‬‬

‫‪ .5‬ﻣﺎ ﺧﺮج ھﺬا اﻟﺒﺮﻧﺎﻣﺞ ‪:‬‬

‫‪1. // EXP 3‬‬
‫{‪2. class Chp9__35‬‬
‫‪3.‬‬ ‫};‪static int a(){return j‬‬
‫‪4.‬‬ ‫;)(‪static int i=a‬‬
‫‪5.‬‬ ‫;‪static int j=1‬‬
‫‪6.‬‬ ‫}‬
‫{‪7. class Chp9_35‬‬
‫{ )][‪8. public static void main(String args‬‬
‫‪9.‬‬ ‫;)‪System.out.println(Chp9__35.i‬‬
‫‪10.‬‬ ‫}‬
‫} ‪11.‬‬

‫ﺑﺤﯿﺚ ﺗﺤﺘﻮي ﻋﻠﻰ اﻟﻤﺘﻐﯿﺮات اﻟﺘﺎﻟﯿﺔ‪:‬‬ ‫أﻧﺸﺊ ﻓﺌﺔ ﺗﻤﺜﻞ ﻣﺮﺑﻊ وﺳﻤﮫ ‪، Rectengle‬‬ ‫‪.6‬‬
‫‪ width ،length‬ﯾﺄﺧﺬ ﻛﻞ واﺣﺪ ﻣﻨﮭﻢ ﻗﯿﻤﺔ اﺑﺘﺪاﺋﯿﺔ ﺗﺴﺎوي ‪ ،1‬وﯾﺤ ﺘﻮي ﻋﻠﻰ ﻣﻨﮭﺠﯿﻦ ‪،‬‬
‫ﯾﻘﻮم اﻟﻤﻨﮭﺞ اﻷول ﺑﺤﺴﺎب ﻣﺴﺎﺣﺔ اﻟﻤﺮﺑﻊ‪ ،‬ﺑﯿﻨﻤﺎ ﯾﻘﻮم اﻟﻤﻨﮭﺞ اﻟﺜﺎﻧﻲ ﺑﺤﺴﺎب ﻣﺤﯿﻂ اﻟﻤﺮﺑﻊ‪.‬‬
‫ﺛﻢ أﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺘﻄﺒﯿﻖ ھﺬه اﻟﻔﺌﮫ‪.‬‬

‫‪[email protected]‬‬ ‫‪339‬‬ ‫م‪/‬ﻋﻤﺎر ﻣﺤﻤﺪ ﻋﯿﺴﻰ اﻟﺪﺑﻌﻲ‬