www.rasekhoon.

net/software

BlueJ ‫ﺁﻣﻮزش‬

Persian Translator: Mehdi shahdoost

Persian Support by: JEIC SOFT (Jafzar Engineering and Investigation Company)

Michael Kölling
Mærsk Institute
University of Southern Denmark

www.rasekhoon.net
‫‪www.rasekhoon.net/software‬‬

‫ﺻﻔﺤﻪ‬ ‫ﻓﻬﺮﺳﺖ ﻣﻄﺎﻟﺐ‬

‫ﻓﺼﻞ ا – ﻣﻘﺪﻣﻪ‬
‫‪۵‬‬ ‫‪ ( ١ -١‬درﺑﺎرﻩ ‪............................................................................................................BlueJ‬‬

‫‪۵‬‬ ‫‪ ( ٢ -١‬ﻣﻄﺎﻟﺐ ﭘﻮﺷﺶ دادﻩ ﺷﺪﻩ ﺗﻮﺳﻂ ﮐﺘﺎب و ﺧﻮاﻧﻨﺪﮔﺎن ‪............................................................................‬‬

‫‪۵‬‬ ‫‪ ( ٣ -١‬ﺡﻖ ﺗﺎﻟﻴﻒ ‪ ،‬ﻟﻴﺴﺎﻧﺲ و ﺗﻮزﻳﻊ ﻣﺠﺪد ‪..............................................................................................‬‬

‫‪۵‬‬ ‫‪ ( ۴ -١‬ﺑﺎزﺗﺎب و واﮐﻨﺶ ﺷﻤﺎ ‪................................................................................................................‬‬

‫‪۶‬‬ ‫ﻓﺼﻞ ‪ – ٢‬ﻧﺼﺐ ﮐﺮدن‬

‫‪۶‬‬ ‫‪ ( ١-٢‬ﻧﺼﺐ در وﻳﻨﺪوز ‪........................................................................................................‬‬

‫‪٧‬‬ ‫‪ ( ٢-٢‬ﻧﺼﺐ در ﻣﮑﻴﻨﺘﺎش ‪.....................................................................................................‬‬

‫‪٧‬‬ ‫‪ (٣ -٢‬ﻧﺼﺐ در ﻟﻴﻨﻮﮐﺲ ‪ /‬ﻳﻮﻧﻴﮑﺲ و ﺳﻴﺴﺘﻢ هﺎی دﻳﮕﺮ‪...............................................................‬‬

‫‪٧‬‬ ‫‪ ( ۴-٢‬ﻣﺸﮑﻼت ﻧﺼﺐ ﮐﺮدن ‪................................................................................................‬‬

‫‪٨‬‬ ‫ﻓﺼﻞ ‪ – ٣‬ﺷﺮوع ﮐﺮدن ) وﻳﺮاﻳﺶ ﮐﺮدن‪ -‬ﮐﺎﻣﭙﺎﻳﻞ ﮐﺮدن – اﺝﺮاﻳﯽ ﮐﺮدن (‬

‫‪٨‬‬ ‫‪ (١ -٣‬ﺷﺮوع ‪......................................................................................................BlueJ‬‬

‫‪٩‬‬ ‫‪ (٢-٣‬ﺑﺎز ﮐﺮدن ﭘﺮوژﻩ ‪.....................................................................................................‬‬

‫‪٩‬‬ ‫‪ (٣-٣‬اﻳﺠﺎد اﺷﻴﺎ ‪.............................................................................................................‬‬

‫‪١١‬‬ ‫‪ (۴ -٣‬اﺝﺮاﻳﯽ ﮐﺮدن ‪.......................................................................................................‬‬

‫‪١٣‬‬ ‫‪ (۵-٣‬وﻳﺮاﻳﺶ ﮐﻼس هﺎ ‪...................................................................................................‬‬

‫‪١۴‬‬ ‫‪ (۶-٣‬ﮐﺎﻣﭙﺎﻳﻞ ﮐﺮدن ‪........................................................................................................‬‬

‫‪١۵‬‬ ‫‪ (٧-٣‬راهﻨﻤﺎﻳﯽ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺧﻄﺎهﺎﻳﯽ ﮐﺎﻣﭙﺎﻳﻠﺮ ‪....................................................................‬‬

‫‪١۶‬‬ ‫ﻓﺼﻞ ‪ – ۴‬اﻧﺠﺎم ﮐﺎرهﺎی ﺑﻴﺸﺘﺮ‬

‫‪١۶‬‬ ‫‪ (١-۴‬ﺑﺮرﺳﯽ ﮐﺮدن و ﺑﺎزﺑﻴﻨﯽ ‪.........................................................................................‬‬

‫‪١٨‬‬ ‫‪ (٢ -۴‬ارﺳﺎل اﺷﻴﺎ ﺑﻪ ﻋﻨﻮان ﭘﺎراﻣﺘﺮهﺎ ‪..............................................................................‬‬

‫‪٢‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫‪٢٠‬‬ ‫ﻓﺼﻞ ‪ – ۵‬اﻳﺠﺎد ﻳﮏ ﭘﺮوژﻩ ﺝﺪﻳﺪ‬

‫‪٢٠‬‬ ‫‪ (١-۵‬اﻳﺠﺎد ﭘﻮﺷﻪ ﭘﺮوژﻩ ‪..............................................................................................‬‬

‫‪٢٠‬‬ ‫‪ (٢-۵‬اﻳﺠﺎد ﮐﻼس هﺎ ‪...................................................................................................‬‬

‫‪٢٠‬‬ ‫‪ (٣-۵‬اﻳﺠﺎد واﺑﺴﺘﻪ هﺎ ‪..................................................................................................‬‬

‫‪٢١‬‬ ‫‪ ( ۴-۵‬ﺝﺎﺑﺠﺎ ﮐﺮدن ﻋﻨﺎﺻﺮ )‪..........................................................................(elements‬‬

‫‪٢٢‬‬ ‫ﻓﺼﻞ ‪ – ۶‬اﺳﺘﻔﺎدﻩ از ﻣﺤﻴﻂ ﮐﺪﻧﻮﻳﺴﯽ‬

‫‪٢٢‬‬ ‫‪ ( ١-۶‬ﻧﻤﺎﻳﺶ ‪...........................................................................................code pad‬‬

‫‪٢٢‬‬ ‫‪ (٢-۶‬ارزﻳﺎﺑﯽ ﻋﺒﺎرات ﺳﺎدﻩ ‪.........................................................................................‬‬

‫‪٢٣‬‬ ‫‪ (٣-۶‬درﻳﺎﻓﺖ اﺷﻴﺎ ‪....................................................................................................‬‬

‫‪٢۴‬‬ ‫‪ (۴-۶‬ﺑﺮرﺳﯽ اﺷﻴﺎ ‪...................................................................................................‬‬

‫‪٢۴‬‬ ‫‪ (۵-۶‬اﺝﺮاﻳﯽ ﮐﺮدن دﺳﺘﻮرات ‪......................................................................................‬‬

‫‪٢۴‬‬ ‫‪ (۶-۶‬دﺳﺘﻮرات ﭼﻨﺪ ﺧﻄﯽ و ﺗﻮاﻟﯽ دﺳﺘﻮرات ‪..................................................................‬‬

‫‪٢۴‬‬ ‫‪ (٧-۶‬ﮐﺎر ﺑﺎ ﻣﺘﻐﻴﻴﺮهﺎ ‪...............................................................................................‬‬

‫‪٢۵‬‬ ‫‪ (٨-۶‬ﺗﺎرﻳﺨﭽﻪ دﺳﺘﻮرات ‪..........................................................................................‬‬

‫‪٢۶‬‬ ‫ﻓﺼﻞ ‪ – ٧‬ﺑﺮﻃﺮف ﮐﺮدن ﺧﻄﺎهﺎ‬

‫‪٢۶‬‬ ‫‪ (١-٧‬ﺗﻨﻈﻴﻢ ﮐﺮدن ‪ Breakpoint‬هﺎ ‪.............................................................................‬‬

‫‪٢٨‬‬ ‫‪ (٢-٧‬ﻋﺒﻮر ﻣﺮﺡﻠﻪ ای از ﻣﻴﺎن ﮐﺪهﺎ ‪..............................................................................‬‬

‫‪٢٨‬‬ ‫‪ (٣-٧‬ﺑﺮرﺳﯽ ﻣﺘﻐﻴﻴﺮهﺎ ‪..............................................................................................‬‬

‫‪٢٩‬‬ ‫‪ (۴-٧‬ﺗﻮﻗﻒ ﮐﺮدن و ﺗﻤﺎم ﮐﺮدن ‪...................................................................................‬‬

‫‪٣٠‬‬ ‫ﻓﺼﻞ ‪ – ٨‬اﻳﺠﺎد ﺑﺮﻧﺎﻣﻪ هﺎی ﮐﺎرﺑﺮدی‬

‫‪٣٢‬‬ ‫ﻓﺼﻞ ‪ - ٩‬اﻳﺠﺎد اﭘﻠﺖ هﺎ‬

‫‪٣٢‬‬ ‫‪ (١-٩‬اﺝﺮا ﮐﺮدن اﭘﻠﺖ ‪.................................................................................................‬‬

‫‪٣٣‬‬ ‫‪ (٢-٩‬اﻳﺠﺎد ﮐﺮدن اﭘﻠﺖ ‪................................................................................................‬‬

‫‪٣‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫‪٣٣‬‬ ‫‪ (٣-٩‬ﺗﺴﺖ ﮐﺮدن اﭘﻠﺖ ‪................................................................................................‬‬

‫‪٣۴‬‬ ‫ﻓﺼﻞ ‪ -١٠‬اﻋﻤﺎل دﻳﮕﺮ‬

‫‪٣۴‬‬ ‫‪ (١-١٠‬ﺑﺎز ﮐﺮدن ﭘﮑﻴﺞ هﺎی ﻏﻴﺮ ‪ BlueJ‬در ‪............................................................BlueJ‬‬

‫‪٣۴‬‬ ‫‪ (٢-١٠‬اﺿﺎﻓﻪ ﮐﺮدن ﮐﻼس هﺎی ﻣﻮﺝﻮد ﺑﻪ ﭘﺮوژﻩ ﺗﺎن ‪..........................................................‬‬

‫‪٣۴‬‬ ‫‪ (٣-١٠‬ﻓﺮاﺧﻮاﻧﯽ ﻣﺘﺪهﺎی اﺳﺘﺎﺗﻴﮏ و ‪......................................................................main‬‬

‫‪٣۵‬‬ ‫‪ (۴-١٠‬ﺗﻮﻟﻴﺪ اﺳﻨﺎد ) ‪........................................................................(Documentation‬‬

‫‪٣۵‬‬ ‫‪ (۵-١٠‬ﮐﺎر ﺑﺎ ﮐﺘﺎﺑﺨﺎﻧﻪ هﺎ ‪..............................................................................................‬‬

‫‪٣۵‬‬ ‫‪ (۶-١٠‬اﻳﺠﺎد اﺷﻴﺎ از ﮐﻼس هﺎی ﮐﺘﺎﺑﺨﺎﻧﻪ ای ‪.....................................................................‬‬

‫‪٣۶‬‬ ‫ﻓﺼﻞ ‪ – ١١‬ﻓﻘﻂ ﺧﻼﺻﻪ هﺎ‬

‫‪Copyright © M. Kölling‬‬

‫‪۴‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﻣﻘﺪﻣﻪ‬

‫‪ ( ١-١‬درﺑﺎرﻩ ‪BlueJ‬‬

‫اﻳﻦ اﻣﻮزش ﻣﻘﺪﻣﻪ ای ﺑﺮای اﺳﺘﻔﺎدﻩ از ﻣﺤﻴﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ‪ BlueJ‬ﻣﻴﺒﺎﺷﺪ‪ BlueJ .‬ﻣﺤﻴﻂ ﺗﻮﺳﻌﻪ ﺝﺎوا ﻣﻴﺒﺎﺷﺪ ﮐﻪ ﺑﻪ ﻃﻮر وﻳﮋﻩ‬

‫ﺑﺮای ﺁﻣﻮزش ﺝﺎوا در ﺳﻄﻮح ﻣﻘﺪﻣﺎﺗﯽ ﻃﺮاﺡﯽ ﺷﺪﻩ اﺳﺖ‪ .‬اﻳﻦ ﻧﺮم اﻓﺰار ﺗﻮﺳﻂ ﺗﻴﻢ ﻃﺮاﺡﯽ و ﭘﻴﺎدﻩ ﺳﺎز در داﻧﺸﮕﺎﻩ ‪Deakin‬‬

‫ﺷﻬﺮ ﻣﻠﺒﻮرن اﺳﺘﺮاﻟﻴﺎ و هﻤﭽﻨﻴﻦ داﻧﺸﮕﺎﻩ ﮐﻨﺖ ) ‪ (Kent‬ﺷﻬﺮ ﮐﺎﻧﺘﺮﺑﺮی اﻧﮕﻠﺴﺘﺎن اﻳﺠﺎد ﺷﺪﻩ اﺳﺖ‪.‬‬

‫ﺑﺮای ﺑﺪﺳﺖ ﺁوردن اﻃﻼﻋﺎت ﺑﻴﺸﺘﺮ ﺑﻪ وب ﺳﺎﻳﺖ اﻳﻦ ﻧﺮم اﻓﺰار ﺑﻪ ﺁدرس زﻳﺮ ﻣﺮاﺝﻌﻪ ﻧﻤﺎﻳﻴﺪ ‪:‬‬

‫‪Http://www.bluej.org‬‬

‫‪ (٢-١‬ﻣﻄﺎﻟﺐ ﭘﻮﺷﺶ دادﻩ ﺷﺪﻩ و ﺧﻮاﻧﻨﺪﮔﺎن ﮐﺘﺎب‬

‫اﻳﻦ ﺁﻣﻮزش ﺑﺮای ﺗﻌﻠﻴﻢ دادن ﺝﺎوا ﻧﻤﯽ ﺑﺎﺷﺪ و در اﺻﻞ ﻣﺤﻴﻄﯽ ﺑﺮای اﻣﻮزش ﺝﺎوا ﻣﯽ ﺑﺎﺷﺪ‪.‬‬

‫‪ ( ٣-١‬ﺡﻖ ﺗﺎﻟﻴﻒ ‪ ،‬ﻟﻴﺴﺎﻧﺲ و ﺗﻮزﻳﻊ ﻣﺠﺪد‬

‫ﻧﺮم اﻓﺰار ‪ BlueJ‬و هﻤﭽﻨﻴﻦ اﻳﻦ ﺁﻣﻮزش هﻤﺎﻧﮕﻮﻧﻪ ﮐﻪ هﺴﺘﻨﺪ )‪ (as-is‬ﺑﺮای اﺳﺘﻔﺎدﻩ هﺎی ﺷﺨﺼﯽ و ﻏﻴﺮ ﺗﺠﺎری ﺑﺼﻮرت راﻳﮕﺎن‬

‫ﻗﺮار دارد‪.‬‬ ‫اراﺋﻪ ﻣﯽ ﺷﻮﻧﺪ‪ .‬ﺡﻖ ﺗﺎﻟﻴﻒ ‪ BlueJ‬در اﺧﺘﻴﺎر‬

‫‪ (۴-١‬ﺑﺎزﺗﺎب و واﮐﻨﺶ ﺷﻤﺎ‬

‫ﻧﻈﺮات ‪ ،‬ﺳﻮاﻻت ‪ ،‬اﺻﻼﺡﺎت و اﻧﺘﻘﺎدات ﺷﻤﺎ در ﺧﺼﻮص ﻧﺮم اﻓﺰار و ﻳﺎ اﻣﻮزش ‪ BlueJ‬ﺑﺎﻋﺚ ﺧﻮﺷﺤﺎﻟﯽ و ﺗﺸﻮﻳﻖ ﻣﺎ‬

‫ﺧﻮاهﺪ ﺷﺪ‪ .‬ﻟﻄﻔﺎ ﻣﻴﻞ ﮐﻨﻴﺪ ﺑﻪ ﻣﺎﻳﮑﻞ ﮐﻮﻟﻴﻨﮓ )‪ ( Michael Kolling‬ﺑﻪ ﺁدرس زﻳﺮ ‪:‬‬

‫‪mik@mip.sdu.dk‬‬

‫‪ (۵-١‬ﺳﺨﻦ ﻣﺘﺮﺝﻢ‬

‫ﺁﻣﻮزﺷﯽ ﮐﻪ هﻤﺎﮐﻨﻮن در اﺧﺘﻴﺎر دارﻳﺪ ﺗﺮﺝﻤﻪ ﻣﺘﻦ اﻧﮕﻠﻴﺴﯽ ﺁﻣﻮزش ‪ BlueJ‬ﻣﯽ ﺑﺎﺷﺪ‪.‬ﮐﻪ در ﺳﺎﻳﺖ رﺳﻤﯽ اﻳﻦ ﻧﺮم اﻓﺰار ﻣﻮﺝﻮد‬

‫اﺳﺖ‪ .‬اﻟﺒﺘﻪ اﻳﻦ ﻣﺘﻦ ﺗﺮﺝﻤﻪ ﻟﻐﺖ ﺑﻪ ﻟﻐﺖ ﺁﻣﻮزش اﻧﮕﻠﻴﺴﯽ ﻧﺮم اﻓﺰار ﻧﻴﺴﺖ ﺑﻠﮑﻪ ﺑﺮداﺷﺘﯽ ﺁزاد از ﺁن ﻣﺘﻦ اﺳﺖ ﮐﻪ ﮐﻮﺷﺶ ﺷﺪﻩ‬

‫ﺗﻤﺎم ﻣﺘﻦ اﺻﻠﯽ را ﭘﻮﺷﺶ دهﺪ‪ .‬اﻣﻴﺪوارم ﮐﻪ اﻳﻦ اﺛﺮ ﮐﻪ از ﻃﺮف ﺷﺮﮐﺖ ﺗﺤﻘﻴﻘﺎﺗﯽ و ﻣﻬﻨﺪﺳﯽ ﺝﯽ اﻓﺰار ﭘﺸﺘﻴﺒﺎﻧﯽ ﻣﯽ ﺷﻮد ﻣﻘﺒﻮل‬

‫ﺷﻤﺎ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﺎن و ﺗﻮﺳﻌﻪ دهﻨﺪﮔﺎن اﻳﺮاﻧﯽ ﻗﺮار ﺑﮕﻴﺮد‪ .‬در ﺻﻮرﺗﯽ ﮐﻪ ﺷﻤﺎ دوﺳﺘﺎن ﻋﺰﻳﺰ ﮐﺎﺳﺘﯽ در اﻳﻦ اﺛﺮ دﻳﺪﻳﺪ ﻟﻄﻔ ًﺎ‬

‫ﺑﺮای ﺑﺮﻃﺮف ﮐﺮدن ﺁن در ﻧﺴﺨﻪ هﺎی ﺑﻌﺪی اﻳﻦ ﺁﻣﻮزش ﺁﻧﺮا ﺑﺎ اﺳﺘﻔﺎدﻩ از اﻳﻤﻴﻞ زﻳﺮ ﺑﻪ ﺑﻨﺪﻩ اﻃﻼع دهﻴﺪ‪.‬‬

‫‪Persianshadow2003@yahoo.com‬‬

‫‪۵‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﻓﺼﻞ دوم ‪ -‬ﻧﺼﺐ ﮐﺮدن‬

‫‪ BlueJ‬در ﺳﻪ ﻓﺮﻣﺖ ﺗﻮزﻳﻊ ﺷﺪﻩ اﺳﺖ‪ :‬ﻳﮑﯽ ﺑﺮای ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ وﻳﻨﺪوز ‪ ،‬ﻳﮑﯽ ﺑﺮای ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﻣﮑﻴﻨﺘﺎش و ﻳﮏ ﻧﺴﺨﻪ هﻢ‬

‫ﺑﺮای دﻳﮕﺮ ﺳﻴﺴﺘﻢ هﺎ ‪ .‬ﻣﺮاﺡﻞ ﻧﺼﺐ اﻳﻦ ﻧﺮم اﻓﺰار ﮐﺎﻣﻼ ﺳﺮ راﺳﺖ و ﻣﺸﺨﺺ ﻣﯽ ﺑﺎﺷﺪ‪.‬‬

‫ﭘﻴﺶ ﻧﻴﺎزهﺎ ‪:‬‬

‫ﺷﻤﺎ ﺑﺮای اﺳﺘﻔﺎدﻩ از ‪ BlueJ‬ﺑﺎﻳﺪ ‪ J2SE1.4‬ﻳﺎ ﻧﺴﺨﻪ هﺎی ﺑﺎﻻﺗﺮ را ﻧﺼﺐ داﺷﺘﻪ ﺑﺎﺷﻴﺪ‪ .‬ﻣﺎ ﺗﻮﺻﻴﻪ ﻣﯽ ﮐﻨﻴﻢ ﮐﻪ از ﻧﺴﺨﻪ هﺎی‬

‫ﻏﻴﺮ ﺑﺘﺎ ) ‪ (Beta‬ﺝﺎوا اﺳﺘﻔﺎدﻩ ﮐﻨﻴﺪ‪ .‬اﮔﺮ ﺷﻤﺎ ﺝﺎوا )‪ (JDK‬را ﻧﺪارﻳﺪ‪ .‬ﻣﯽ ﺗﻮاﻧﻴﺪ از ﻃﺮﻳﻖ وب ﺳﺎﻳﺖ ﺷﺮﮐﺖ ﺳﺎن ﺁﻧﺮا ﺑﺼﻮرت‬

‫راﻳﮕﺎن درﻳﺎﻓﺖ ﮐﻨﻴﺪ‪: .‬‬

‫‪http://java.sun.com/j2se‬‬

‫در ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ‪ MacOS X‬ﺁﺧﺮﻳﻦ ﻧﺴﺨﻪ ﺝﺎوا ﺑﺼﻮرت ﭘﻴﺶ ﻓﺮض ﻧﺼﺐ ﻣﻴﺒﺎﺷﺪ‪ .‬و ﺷﻤﺎ ﻧﻴﺎز ﺑﻪ ﻧﺼﺐ ﻣﺠﺪد ﺝﺎوا ﺗﻮﺳﻂ‬

‫ﺧﻮدﺗﺎن ﻧﺪارﻳﺪ‪ .‬در ﺿﻤﻦ اﮔﺮ در ﺻﻔﺤﻪ داﻧﻠﻮد ﺷﻤﺎ ﺑﺎ دو ﭘﻴﺸﻨﻬﺎد ‪ JRE‬و ﻳﺎ ‪ SDK‬ﺑﺮﺧﻮرد ﮐﺮدﻳﺪ‪ .‬ﺷﻤﺎ ﺑﺎﻳﺪ ‪ SDK‬را داﻧﻠﻮد‬

‫ﮐﻨﻴﺪ‪ .‬و ‪ JRE‬ﮐﺎﻓﯽ ﻧﻤﯽ ﺑﺎﺷﺪ‪.‬‬

‫‪ ( ١-٢‬ﻧﺼﺐ ﺑﺮای وﻳﻨﺪوز‬

‫ﻓﺎﻳﻞ ﺗﻮزﻳﻊ ﺷﺪﻩ ﺑﺮای ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ وﻳﻨﺪوز ﺑﺎ اﻳﻦ ﻧﺎم ﻣﯽ ﺑﺎﺷﺪ ‪ . bluejsetup-xxx.exe :‬ﮐﻪ ﮐﻠﻤﺎت ‪ xxx‬ﺷﻤﺎرﻩ ﻧﺴﺨﻪ‬

‫‪ BlueJ‬را ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﺪ‪ .‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻓﺎﻳﻞ ﻧﺼﺐ ﮐﻨﻨﺪﻩ ‪ BlueJ‬ﻧﺴﺨﻪ ‪ 2.0.0‬ﺑﺪﻳﻦ ﺻﻮرت‬

‫ﻣﻴﺒﺎﺷﺪ ‪. bluejsetup-200.exe :‬‬

‫ﺷﻤﺎ اﻳﻦ ﻓﺎﻳﻞ رو ﻣﯽ ﺗﻮاﻧﻴﺪ از ﻃﺮﻳﻖ ﻳﮏ دﻳﺴﮏ درﻳﺎﻓﺖ ﮐﺮدﻩ و ﻳﺎ اﻳﻨﮑﻪ از وب ﺳﺎﻳﺖ ‪ BlueJ‬درﻳﺎﻓﺖ ﮐﻨﻴﺪ‪ .‬ﺑﺎ اﺳﺘﻔﺎدﻩ از اﻳﻦ‬

‫ﻧﺼﺐ ﮐﻨﻨﺪﻩ )‪ ( installer‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ‪ .‬ﭘﻮﺷﻪ ای را ﮐﻪ ﻗﺼﺪ دارﻳﺪ‪ BlueJ .‬در ﺁن ﻧﺼﺐ ﺷﻮد ﻣﺸﺨﺺ ﮐﻨﻴﺪ‪ .‬هﻤﭽﻨﻴﻦ اﻳﻦ‬

‫ﻧﺼﺐ ﮐﻨﻨﺪﻩ ﮔﺰﻳﻨﻪ هﺎی ﺑﺮای ﻧﺼﺐ ﻣﻴﺎﻧﺒﺮ )‪ (shortcut‬در ﻣﻨﻮی ﺷﺮوع و دﺳﮑﺘﺎپ ﺑﻪ ﺷﻤﺎ اراﺋﻪ ﻣﯽ دهﺪ‪.‬‬

‫ﺑﻌﺪ از اﻳﻨﮑﻪ ﻧﺼﺐ ﺗﻤﺎم ﺷﺪ‪ .‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﺮﻧﺎﻣﻪ ‪ BlueJ.exe‬را در ﭘﻮﺷﻪ ای ﮐﻪ ‪ BlueJ‬ﻧﺼﺐ ﺷﺪﻩ ﭘﻴﺪا ﮐﻨﻴﺪ‪.‬‬

‫اوﻟﻴﻦ ﺑﺎری ﮐﻪ ﺷﻤﺎ ﺑﺮﻧﺎﻣﻪ ‪ BlueJ‬را اﺝﺮا ﮐﻨﻴﺪ‪ BlueJ .‬ﮐﺎﻣﭙﻴﻮﺗﺮ ﺷﻤﺎ را ﺑﺮای ﭘﻴﺪا ﮐﺮدن ﺝﺎوا )‪ (JDK‬ﺝﺴﺘﺠﻮ‬

‫ﻣﯽ ﻧﻤﺎﻳﺪ‪ .‬و اﮔﺮ ﭼﻨﺪ ورژن ﻣﻨﺎﺳﺐ از ﺝﺎوا ) ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ‪ JDK1.4‬و ‪ ( JDK1.5‬را روی ﺳﻴﺴﺘﻢ ﺷﻤﺎ ﭘﻴﺪا ﮐﺮد‪.‬‬

‫ﭘﻨﺠﺮﻩ ای را ﺑﺎز ﻣﯽ ﮐﻨﺪ ﮐﻪ ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﻳﮑﯽ از ﺁن ﻧﺴﺨﻪ هﺎی ﺝﺎوا را اﻧﺘﺨﺎب ﮐﻨﻴﺪ‪.‬‬

‫در ﺿﻤﻦ اﮔﺮ ‪ BlueJ‬ﻧﺘﻮاﻧﺴﺖ‪ JDK .‬را روی ﺳﻴﺴﺘﻢ ﺷﻤﺎ ﭘﻴﺪا ﮐﻨﺪ‪ .‬ﻣﺴﻴﺮ ﺁﻧﺮا از ﺷﻤﺎ ﺳﻮال ﺧﻮاهﺪ ﮐﺮد‪ ) .‬دﻟﻴﻞ اﻳﻦ اﻣﺮ‬

‫ﻣﯽ ﺗﻮاﻧﺪ اﻳﻦ ﺑﺎﺷﺪ ﮐﻪ ‪ JDK‬روی ﺳﻴﺴﺘﻢ ﺷﻤﺎ ﻧﺼﺐ ﺷﺪﻩ ﺑﺎﺷﺪ‪ .‬وﻟﯽ ﻣﻘﺪار ﻣﻮرد ﻧﻴﺎز از ‪ Registry‬وﻳﻨﺪوز ﭘﺎک ﺷﺪﻩ ﺑﺎﺷﺪ‪.‬‬

‫ﻧﺼﺐ ﮐﻨﻨﺪﻩ ‪ BlueJ‬هﻤﭽﻨﻴﻦ ﺑﺮﻧﺎﻣﻪ ‪ vmselect.exe‬را ﻧﺼﺐ ﻣﯽ ﮐﻨﺪ‪ .‬و ﺷﻤﺎ ﺑﺎ اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺑﺮﻧﺎﻣﻪ ﻣﯽ ﺗﻮاﻧﻴﺪ ﻧﺴﺨﻪ‬

‫ﺝﺎواﻳﯽ ﮐﻪ ‪ BlueJ‬از ﺁن اﺳﺘﻔﺎدﻩ ﻣﯽ ﮐﻨﺪ را ﺗﻐﻴﻴﺮ دهﻴﺪ‪.‬‬

‫‪۶‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫‪ (٢-٢‬ﻧﺼﺐ ﺑﺮای ﻣﮑﻴﻨﺘﺎش‬

‫ﻟﻄﻔ ًﺎ ﺗﻮﺝﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﮐﻪ ‪ BlueJ‬ﺗﻨﻬﺎ در ‪ MacOS X‬اﺝﺮا ﻣﯽ ﺷﻮد‪.‬‬

‫ﻓﺎﻳﻞ هﺎی ﺗﻮزﻳﻊ ﺷﺪﻩ ﺑﺮای ﻣﮑﻴﻨﺘﺎش ﺑﻪ ﺷﮑﻞ ‪ blueJ-xxx.zip‬ﻧﺎﻣﻴﺪﻩ ﻣﯽ ﺷﻮﻧﺪ‪ xxx ،‬هﺎ ﺷﻤﺎرﻩ ﻧﺴﺨﻪ ﻧﺮم اﻓﺰار را ﻣﺸﺨﺺ‬

‫ﻣﯽ ﮐﻨﻨﺪ‪.‬ﺑﺮای ﻣﺜﺎل ﻧﺴﺨﻪ ‪ ، blueJ 2.0.0‬ﻓﺎﻳﻞ هﺎی ﺗﻮزﻳﻊ ﺷﺪﻩ اش ﺑﺼﻮرت ‪ BlueJ-200.zip‬ﻣﻴﺒﺎﺷﺪ‪.‬ﺷﻤﺎ اﻳﻦ ﻓﺎﻳﻞ را‬

‫ﻣﯽ ﺗﻮاﻧﻴﺪ در ﻳﮏ دﻳﺴﮑﺖ درﻳﺎﻓﺖ ﮐﺮدﻩ و ﻳﺎ از وب ﺳﺎﻳﺖ ‪ BlueJ‬ﺑﻪ ﺁدرس زﻳﺮ داﻧﻠﻮد ﻧﻤﺎﻳﻴﺪ‪:‬‬

‫‪http://www.bluej.org‬‬

‫ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ‪ MacOS‬ﺑﻌﺪ از داﻧﻠﻮد ﻓﺎﻳﻞ ﺑﺼﻮرت ﺧﻮدﮐﺎر ﻓﺎﻳﻞ را از ﺡﺎﻟﺖ زﻳﭗ ﺷﺪﻩ ﺧﺎرج ﻣﯽ ﮐﻨﺪ‪ .‬واﮔﺮ اﻳﻦ ﮐﺎر ﺻﻮرت‬

‫ﻧﮕﺮﻓﺖ‪.‬ﺑﺮ روی ﻓﺎﻳﻞ دوﺑﺎر ﮐﻠﻴﮏ ﮐﻨﻴﺪ ﺗﺎ ﻓﺎﻳﻞ از ﺡﺎﻟﺖ زﻳﭗ ﺧﺎرج ﺷﻮد‪.‬‬

‫ﺑﻌﺪ از اﻳﻦ ﮐﻪ ﻓﺎﻳﻞ از ﺡﺎﻟﺖ ﻓﺸﺮدﻩ ﺧﺎرج ﺷﺪ‪.‬ﺷﻤﺎ ﭘﻮﺷﻪ ای ﺑﺎ ﻧﺎم ‪ BlueJ-xxx‬ﺧﻮاهﻴﺪ داﺷﺖ‪ .‬اﻳﻦ ﭘﻮﺷﻪ را ﺑﻪ ﭘﻮﺷﻪ‬

‫ﺑﺮﻧﺎﻣﻪ هﺎی ﮐﺎرﺑﺮدی ﺗﺎن ﻣﻨﺘﻘﻞ ﻧﻤﺎﻳﻴﺪ) ﻳﺎ هﺮ ﭘﻮﺷﻪ ای ﮐﻪ ﺗﻤﺎﻳﻞ دارﻳﺪ در ﺁن ﻧﮕﻪ دارﻳﺪ(‪.‬ﺷﻤﺎ ﻧﻴﺎزی ﺑﻪ ﻧﺼﺐ ﻧﺪارﻳﺪ‪.‬‬

‫‪ (٣-٢‬ﻧﺼﺐ ﮐﺮدن ﺑﺮای ﻟﻴﻨﻮﮐﺲ ‪ ،‬ﻳﻮﻧﻴﮑﺲ و ﺳﻴﺴﺘﻢ هﺎی دﻳﮕﺮ‬

‫ﻓﺎﻳﻞ هﺎی ﻋﻤﻮﻣﯽ ﺗﻮزﻳﻊ ﺷﺪﻩ ﺑﺮای اﻳﻨﮑﺎر ﻳﮏ ﻓﺎﻳﻞ ‪ Jar‬اﺝﺮاﻳﯽ ﻣﯽ ﺑﺎﺷﺪ‪ .‬اﻳﻦ ﻓﺎﻳﻞ ‪ BlueJ-xxx.jar‬ﺧﻮاﻧﺪﻩ ﻣﯽ ﺷﻮد‪ .‬ﮐﻪ‬

‫در ﺁن ‪ xxx‬ﺷﻤﺎرﻩ ﻧﺴﺨﻪ ﻧﺮم اﻓﺰار ﻣﻴﺒﺎﺷﺪ‪.‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻓﺎﻳﻞ هﺎی ﺗﻮزﻳﻊ ﺷﺪﻩ ‪ BlueJ 2.0.0‬ﺑﺎ ﻧﺎم ‪BlueJ-200.jar‬‬

‫ﻣﺸﺨﺺ ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ اﻳﻦ ﻓﺎﻳﻞ را در ﻳﮏ دﻳﺴﮑﺖ و ﻳﺎ از ﻃﺮﻳﻖ وب ﺳﺎﻳﺖ ‪ BlueJ‬ﺑﻪ ﺁدرس زﻳﺮ درﻳﺎﻓﺖ ﻧﻤﺎﻳﻴﺪ‪:‬‬

‫‪http://www.bluej.org‬‬

‫ﺑﺮﻧﺎﻣﻪ ﻧﺼﺐ ﮐﻨﻨﺪﻩ را ﺑﺎ اﺝﺮای دﺳﺘﻮر زﻳﺮ ﻓﺮاﺧﻮاﻧﯽ ﮐﻨﻴﺪ‪ .‬ﺗﻮﺝﻪ‪ :‬ﻣﺎ ﺑﺮای اﻳﻦ ﻣﺜﺎل از ﻓﺎﻳﻞ ﺗﻮزﻳﻊ ﺷﺪﻩ ‪BlueJ-200.jar‬‬

‫اﺳﺘﻔﺎدﻩ ﮐﺮدﻩ اﻳﻢ –ﺷﻤﺎ ﻧﻴﺎز دارﻳﺪ ﺗﺎ از ﻧﺎم ﻓﺎﻳﻠﯽ ﮐﻪ در ﻳﺎﻓﺖ ﮐﺮدﻩ اﻳﺪ اﺳﺘﻔﺎدﻩ ﮐﻨﻴﺪ‪.‬‬

‫‪< j2se-path>/bin/java -jar bluej-200.jar‬‬

‫>‪ < j2se-path‬ﻣﺴﻴﺮ ﭘﻮﺷﻪ ای ﻣﻴﺒﺎﺷﺪ ﮐﻪ در ﺁن ‪ J2se‬ﻧﺼﺐ ﻣﻴﺒﺎﺷﺪ‪ .‬ﭘﻨﺠﺮﻩ ای ﺑﺎز ﻣﯽ ﺷﻮد ﮐﻪ ﺑﻪ ﺷﻤﺎ اﺝﺎزﻩ ﻣﯽ دهﺪ‬

‫ﺗﺎ ﻣﺤﻞ ﻧﺼﺐ ﺑﺮﻧﺎﻣﻪ و هﻤﭽﻨﻴﻦ ﻧﺴﺨﻪ ﺝﺎوای ﮐﻪ ﺑﺮای اﺝﺮاﻳﯽ ‪ BlueJ‬ﻣﯽ ﺧﻮاهﻴﺪ از ﺁن اﺳﺘﻔﺎدﻩ ﮐﻨﻴﺪ ﺗﻌﻴﻴﻦ ﻧﻤﺎﻳﻴﺪ‪ .‬دﮐﻤﻪ‬

‫‪ Install‬را ﻓﺸﺎر دهﻴﺪ‪ .‬ﺑﻌﺪ از اﺗﻤﺎم ‪ BlueJ ،‬ﺑﺮ روی ﺳﻴﺴﺘﻢ ﺷﻤﺎ ﻧﺼﺐ ﺷﺪﻩ اﺳﺖ‪.‬‬

‫‪ (۴-٢‬اﺷﮑﺎﻻت در ﻧﺼﺐ ﺑﺮﻧﺎﻣﻪ‬

‫اﮔﺮ ﺷﻤﺎ ﺑﺎ ﻣﺸﮑﻠﯽ ﺑﺮﺧﻮرد ﮐﺮدﻳﺪ‪ .‬ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﻪ ﺑﺨﺶ ‪ FAQ‬ﺳﺎﻳﺖ ‪ BlueJ‬ﻣﺮاﺝﻌﻪ ﮐﻨﻴﺪ ‪:‬‬

‫‪http://www.bluej.org/help/faq.html‬‬
‫و ﻳﺎ اﻳﻨﮑﻪ ﺑﺨﺶ " ﭘﺮﺳﺶ ﺑﺮای ﮐﻤﮏ " را ﻣﻄﺎﻟﻌﻪ ﻧﻤﺎﻳﻴﺪ‪:‬‬

‫‪http://www.bluej.org/help/ask-help.html‬‬

‫‪٧‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﻓﺼﻞ ﺳﻮم ‪ -‬ﺷﺮوع ﮐﺮدن – وﻳﺮاﻳﺶ ﮐﺮدن – ﮐﺎﻣﭙﺎﻳﻞ ﮐﺮدن – اﺝﺮاﻳﯽ ﮐﺮدن‬

‫‪ ( ١-٣‬ﺁﻏﺎز ﺑﻪ ﮐﺎر ﺑﺎ ‪BlueJ‬‬

‫در ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ وﻳﻨﺪوز و ﻣﮑﻴﻨﺘﺎش ﺑﺮﻧﺎﻣﻪ ﺑﺎ ﻧﺎم ‪ BlueJ‬ﻧﺼﺐ ﺷﺪﻩ ‪ .‬ﺑﺮای ﺷﺮوع ﺷﻤﺎ ﺑﺎﻳﺪ اﻳﻦ ﺑﺮﻧﺎﻣﻪ را اﺝﺮا ﮐﻨﻴﺪ‪.‬‬

‫در ﺳﻴﺴﺘﻢ هﺎی ﻳﻮﻧﻴﮑﺲ ﺑﺮﻧﺎﻣﻪ ﻧﺼﺐ ﮐﻨﻨﺪﻩ اﺳﮑﺮﻳﭙﺘﯽ ﺑﺎ ﻧﺎم ‪ BlueJ‬را ﻧﺼﺐ ﮐﺮدﻩ ﮐﻪ ﺷﻤﺎ ﺑﺮای اﺝﺮای ﻣﺤﻴﻂ ﮔﺮاﻓﻴﮑﯽ‬

‫روی اﻳﻦ ﻓﺎﻳﻞ دو ﺑﺎر ﮐﻠﻴﮏ ﮐﻨﻴﺪ‪ .‬در ﺿﻤﻦ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺧﻂ ﻓﺮﻣﺎن هﻢ ﻣﯽ ﺗﻮاﻧﻴﺪ ‪ BlueJ‬را ﺑﺎ ﺁرﮔﻮﻣﺎن و ﻳﺎ ﺑﺪون ﺁرﮔﻮﻣﺎن‬

‫ﻓﺮاﺧﻮاﻧﯽ ﮐﻨﻴﺪ‪:‬‬

‫‪$ BlueJ‬‬

‫و ﺑﺎ ﺁرﮔﻮﻣﺎن ‪:‬‬

‫‪$ BlueJ examples/people‬‬

‫ﻣﻨﻈﻮر از ارﮔﻮﻣﺎن هﻢ ﭘﺮوژﻩ ای اﺳﺖ ﮐﻪ ﻗﺼﺪ دارﻳﺪ ﺑﺎ ‪ BlueJ‬ﺑﺎز ﺷﻮد هﺴﺖ‪.‬‬

‫) ﻋﮑﺲ ‪ : ١‬ﭘﻨﺠﺮﻩ اﺻﻠﯽ ﺑﺮﻧﺎﻣﻪ ‪( BlueJ‬‬

‫‪٨‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫‪ ( ٢ -٣‬ﺑﺎز ﮐﺮدن ﭘﺮوژﻩ‬

‫ﺑﻪ ﻃﻮر ﺧﻼﺻﻪ ﺑﺮای ﺑﺎز ﮐﺮدن ﭘﺮوژﻩ از ﻣﻨﻮی ‪ Project‬ﮔﺰﻳﻨﻪ ‪ Open‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﭘﺮوژﻩ هﺎی ‪ BlueJ‬ﻣﺎﻧﻨﺪ ﭘﮑﻴﺞ هﺎی اﺳﺘﺎﻧﺪارد ﺝﺎوا از ﭘﻮﺷﻪ هﺎی ﮐﻪ ﺷﺎﻣﻞ ﻓﺎﻳﻞ هﺎی ﭘﺮوژﻩ هﺴﺘﻨﺪ ﺗﺸﮑﻴﻞ ﺷﺪﻩ اﺳﺖ ‪.‬‬

‫ﺑﻌﺪ از اﻳﻨﮑﻪ ﺑﺮﻧﺎﻣﻪ ‪ BlueJ‬ﺑﺎز ﺷﺪ‪ .‬ﺑﺎ اﺳﺘﻔﺎدﻩ از ﻣﻨﻮی ‪ Project‬و ﮔﺰﻳﻨﻪ ‪ Open‬ﭘﺮوژﻩ ﻣﻮرد ﻧﻈﺮ ﺧﻮد را ﺑﺎز ﮐﻨﻴﺪ‪.‬‬

‫ﭼﻨﺪ ﭘﺮوژﻩ ﻧﻤﻮﻧﻪ ﺑﻪ هﻤﺮاﻩ ‪ BlueJ‬ﺗﻮزﻳﻊ ﺷﺪﻩ اﺳﺖ ﮐﻪ ﺷﻤﺎ اﻳﻦ ﭘﺮوژﻩ هﺎی ﻧﻤﻮﻧﻪ را ﻣﯽ ﺗﻮاﻧﻴﺪ در ﭘﻮﺷﻪ ‪examples‬‬

‫ﭘﻴﺪا ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﺑﺮای اﻳﻦ ﺑﺨﺶ اﻣﻮزش ﺷﻤﺎ ﭘﺮوژﻩ ‪ People‬را ﮐﻪ در ﭘﻮﺷﻪ ‪ example‬ﻗﺮار دارد‪.‬ﺑﺎز ﮐﻨﻴﺪ‪ .‬ﭘﻮﺷﻪ ‪ example‬در ﭘﻮﺷﻪ ای‬

‫ﮐﻪ ‪ BlueJ‬ﻧﺼﺐ ﺷﺪﻩ ﻗﺮار دارد‪ .‬ﺑﻌﺪ از اﻳﻨﮑﻪ ﺷﻤﺎ ﭘﺮوژﻩ را ﺑﺎز ﮐﺮدﻳﺪ‪ .‬ﭘﻨﺠﺮﻩ ﺷﻤﺎ ﺷﺒﻴﻪ ﻋﮑﺲ ‪ ١‬ﻣﯽ ﺷﻮد‪ .‬اﻟﺒﺘﻪ ﺑﺮ اﺳﺎس‬

‫ﺳﻴﺴﺘﻢ ﺷﻤﺎ اﺧﺘﻼﻓﺎﺗﯽ وﺝﻮد ﺧﻮاهﺪ داﺷﺖ‪.‬‬

‫‪ (٣-٣‬اﻳﺠﺎد اﺷﻴﺎ‬

‫ﺧﻼﺻﻪ‪ :‬ﺑﺮای اﻳﺠﺎد ﻳﮏ ﺷﯽ ‪ ،‬ﺳﺎزﻧﺪﻩ ﻣﺮﺑﻮﻃﻪ را از ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ ﮐﻼس اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﻳﮑﯽ از اﻋﻤﺎل ﭘﺎﻳﻪ و اﺑﺘﺪاﻳﯽ در ‪ BlueJ‬اﻳﻦ اﺳﺖ ﮐﻪ ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﺪون اﻳﻦ ﮐﻪ ﮐﻞ ﭘﺮوژﻩ را اﺝﺮا ﻧﻤﺎﻳﻴﺪ‪ .‬ﺑﺎ ﻳﮏ ﺷﯽ از هﺮ ﮐﻼس‬

‫در ارﺗﺒﺎط ﺑﻮدﻩ و ﻣﺘﺪهﺎی ﻋﻤﻮﻣﯽ اﻧﺮا اﺝﺮا ﻧﻤﺎﻳﻴﺪ‪ .‬ﻣﺮﺡﻠﻪ اﺝﺮا ﮐﺮدن در ‪ BlueJ‬ﻣﻌﻤﻮﻻ ﺑﺎ اﻳﺠﺎد ﻳﮏ ﺷﯽ و ﻓﺮاﺧﻮاﻧﯽ ﻳﮑﯽ از‬

‫ﻣﺘﺪهﺎی ﺷﯽ اﻧﺠﺎم ﻣﯽ ﺷﻮد‪ .‬اﻳﻦ ﻣﻮرد در ﻃﻮل ﺗﻮﺳﻌﻪ ﻳﮏ ﺑﺮﻧﺎﻣﻪ ﻣﯽ ﺗﻮاﻧﺪ ﺧﻴﻠﯽ ﻣﻔﻴﺪ ﺑﺎﺷﺪ‪ .‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﮐﻼس هﺎی را ﮐﻪ‬

‫ﻣﯽ ﻧﻮﻳﺴﻴﺪ‪ .‬ﺑﻪ ﻃﻮر ﻣﺠﺰا ﺁزﻣﺎﻳﺶ ﮐﻨﻴﺪ و ﻧﻴﺎزی ﺑﻪ ﻧﻮﺷﺘﻦ ﮐﺎﻣﻞ ﺑﺮﻧﺎﻣﻪ از اﺑﺘﺪا ﻧﺪارد‪.‬‬

‫ﻧﮑﺘﻪ ‪ :‬ﻣﺘﺪهﺎی ‪ Static‬ﻣﯽ ﺗﻮاﻧﻨﺪ ﺑﺪون اﻳﺠﺎد ﺷﯽ از اﺑﺘﺪا اﺝﺮا ﺷﻮﻧﺪ‪ .‬ﻧﻤﻮﻧﻪ ای از اﻳﻦ ﻣﺘﺪهﺎی ‪ ، static‬ﻣﺘﺪ ‪ main‬ﻣﻴﺒﺎﺷﺪ‪.‬‬

‫ﺑﻨﺎﺑﺮاﻳﻦ ﻣﺎ ﻣﯽ ﺗﻮاﻧﻴﻢ هﻤﭽﻴﻦ ﮐﺎری را اﻧﺠﺎم دهﻴﻢ‪.‬هﻤﺎﻧﮕﻮﻧﻪ ﮐﻪ در ﺑﺮﻧﺎﻣﻪ هﺎی ﮐﺎرﺑﺮدی ﺝﺎوا اﺗﻔﺎق ﻣﯽ اﻓﺘﺪ‪ .‬ﺑﺮای اﺝﺮا ﻳﮏ‬

‫ﺑﺮﻧﺎﻣﻪ ﮐﺎرﺑﺮدی ‪ ،‬ﺗﻨﻬﺎ ﮐﺎﻓﻴﺴﺖ ﺗﺎ ﻣﺘﺪ ‪ main ، static‬را اﺝﺮا ﻧﻤﺎﻳﻴﻢ‪.‬‬

‫ﻣﺎ ﺑﻌﺪا ﺑﻪ اﻳﻦ ﻣﻮﺿﻮع ﺑﺮ ﺧﻮاهﻴﻢ ﮔﺸﺖ‪ .‬اﺑﺘﺪا ﻣﺎ ﻗﺼﺪ دارﻳﻢ ﺗﺎ ﮐﺎرهﺎی ﺝﺎﻟﺒﯽ را اﻧﺠﺎم دهﻴﻢ ﮐﻪ ﺑﻪ ﺻﻮرت ﻋﺎدی در ﺝﺎوا‬

‫ﻧﻤﯽ ﺗﻮان اﻧﺠﺎم داد‪.‬‬

‫ﻣﺮﺑﻊ هﺎی ﮐﻪ ﺷﻤﺎ در وﺳﻂ ﭘﻨﺠﺮﻩ اﺻﻠﯽ ﺑﺮﻧﺎﻣﻪ ﻣﯽ ﺑﻴﻨﻴﺪ ) ‪ (Database,person,staff,student‬ﺁﻳﮑﻮن هﺎی هﺴﺘﻨﺪ ﮐﻪ‬

‫ﮐﻼس هﺎی ﻣﻮﺝﻮد در اﻳﻦ ﭘﺮوژﻩ را ﻧﻤﺎﻳﺶ ﻣﯽ دهﻨﺪ‪ .‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﺎ ﮐﻠﻴﮏ راﺳﺖ ﮐﺮدن ) در ﻣﮑﻴﻨﺘﺎش ‪ ( Ctrl-click :‬ﺑﺮ‬

‫روی اﻳﻦ ﺁﻳﮑﻮن هﺎ ﻣﻨﻮی از ﻋﻤﻠﻴﺎت ﻣﻮﺝﻮد ﺑﺮای ان ﮐﻼس را ﺑﺪﺳﺖ ﺁورﻳﺪ‪ ) .‬ﺷﮑﻞ ‪( ٢‬‬

‫‪٩‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫اﻳﻦ اﻋﻤﺎل ﻧﻤﺎﻳﺶ دادﻩ ﺷﺪﻩ ﺷﺎﻣﻞ دﺳﺘﻮر ‪ new‬ﺑﻪ هﻤﺮاﻩ ﺳﺎزﻧﺪﻩ هﺎی ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺑﺮای ﮐﻼس و هﻤﭽﻨﻴﻦ دﻳﮕﺮ اﻋﻤﺎﻟﯽ ﮐﻪ‬

‫ﺗﻮﺳﻂ ﻣﺤﻴﻂ ‪ BlueJ‬ﻓﺮاهﻢ اﻣﺪﻩ اﺳﺖ‪.‬‬

‫ﺷﮑﻞ ‪ : ٢‬اﻋﻤﺎل ﻣﺮﺑﻮط ﺑﻪ ﮐﻼس ) ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ ﮐﻼس (‬

‫ﻣﺎ ﻗﺼﺪ دارﻳﻢ ﺗﺎ از ﮐﻼس ‪ Staff‬ﻳﮏ ﺷﯽ اﻳﺠﺎد ﻧﻤﺎﻳﻴﻢ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ ﺑﺮ روی ﺁﻳﮑﻮن ‪ Staff‬ﮐﻠﻴﮏ راﺳﺖ ﮐﺮدﻩ‪ ) .‬هﻤﺎﻧﻨﺪ ﻣﻨﻮی‬

‫ﺑﺎزﺷﻮﻧﺪﻩ ﺷﮑﻞ ‪ .(٢‬ﻣﻨﻮی ﻧﻤﺎﻳﺶ دادﻩ ﺷﺪﻩ ﺷﺎﻣﻞ دو ﺳﺎزﻧﺪﻩ ﺑﺮای ﺳﺎﺧﺘﻦ ﺷﯽ ‪ Staff‬ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﻳﮑﯽ ﺑﺎ ﭘﺎراﻣﺘﺮ و ﻳﮑﯽ ﺑﺪون‬

‫ﭘﺎراﻣﺘﺮ‪ .‬ﻣﺎ در اﺑﺘﺪا ﺳﺎزﻧﺪﻩ ﺑﺪون ﭘﺎراﻣﺘﺮ را اﻧﺘﺨﺎب ﻣﯽ ﻧﻤﺎﻳﻴﻢ‪ .‬ﭘﻨﺠﺮﻩ ﻧﺸﺎن دادﻩ ﺷﺪﻩ در ﺷﮑﻞ ‪ ٣‬ﻧﻤﺎﻳﺶ دادﻩ ﻣﯽ ﺷﻮد‪.‬‬

‫‪١٠‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﺷﮑﻞ ‪ : ٣‬ﺳﺎزﻧﺪﻩ ﺷﯽ ﺑﺪون ﭘﺎراﻣﺘﺮ‬

‫اﻳﻦ ﭘﻨﺠﺮﻩ ﻧﺎم ﺷﯽ زا ﮐﻪ ﻗﺼﺪ دارﻳﺪ اﻳﺠﺎد ﮐﻨﻴﺪ ﻣﯽ ﭘﺮﺳﺪ‪.‬ﻣﺎ دراﻳﻦ زﻣﺎن ﺑﺎ ﻧﺎم ﭘﻴﺶ ﻓﺮض )‪ (staff1‬ﻣﻮاﻓﻘﺖ ﻣﯽ ﻧﻤﺎﻳﻴﻢ‪.‬‬

‫اﻳﻦ ﻧﺎم ﺑﺮای ﺡﺎﻻ ﻣﻨﺎﺳﺐ ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﺷﻤﺎ ﺗﻨﻬﺎ ﮐﺎﻓﻴﺴﺖ دﮐﻤﻪ ‪ Ok‬را ﻓﺸﺎر دهﻴﺪ‪.‬ﺡﺎﻻ ﺷﯽ از ﮐﻼس ‪ Staff‬اﻳﺠﺎد ﻣﯽ ﺷﻮد‪.‬‬

‫هﻨﮕﺎﻣﯽ ﮐﻪ ﺷﻤﺎ ﺷﯽ را اﻳﺠﺎد ﮐﺮدﻳﺪ‪.‬ﺷﯽ در ﻗﺴﻤﺖ ‪ object bench‬ﻗﺮار ﻣﯽ ﮔﻴﺮد )ﺷﮑﻞ ‪.(۴‬‬

‫ﺷﮑﻞ‪ :۴‬ﺷﯽ ﻗﺮار ﮔﺮﻓﺘﻪ در ﻗﺴﻤﺖ ‪object bench‬‬

‫ﭘﺲ روش اﻳﺠﺎد ﺷﯽ ‪ :‬از ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ ﮐﻼس ﺳﺎزﻧﺪﻩ را اﻧﺘﺨﺎب ﮐﺮدﻩ ‪ ،‬ﺁﻧﺮا اﺝﺮا ﮐﻨﻴﺪ‪ .‬ﺡﺎﻻ ﺷﻤﺎ ﻳﮏ ﺷﯽ در ﻗﺴﻤﺖ‬

‫‪ Object bench‬ﺧﻮاهﻴﺪ داﺷﺖ‪ .‬ﺷﻤﺎ ﺑﺎﻳﺪ دﻗﺖ ﮐﻨﻴﺪ ﮐﻪ ﮐﻼس ‪ Person‬ﺑﺎ ﻧﺸﺎن >>‪ <<abstract‬ﻋﻼﻣﺖ ﮔﺬاری ﺷﺪﻩ‬

‫) ﻳﻌﻨﯽ ﮐﻼس ‪ abstract‬هﺴﺖ ( ﺷﻤﺎ ﺑﺎﻳﺪ دﻗﺖ ﮐﻨﻴﺪ ﮐﻪ ﺷﻤﺎ از ﻳﮏ ﮐﻼس ‪ abstract‬ﻧﻤﯽ ﺗﻮاﻧﻴﺪ ﻳﮏ ﺷﯽ اﻳﺠﺎد ﮐﻨﻴﺪ‬

‫) هﻤﺎﻧﮕﻮﻧﻪ ﮐﻪ در ﺝﺎوا ﺗﻌﺮﻳﻒ ﺷﺪﻩ اﺳﺖ (‬

‫‪ (۴-٣‬اﺝﺮا ﮐﺮدن‬

‫ﺧﻼﺻﻪ ‪ :‬ﺑﺮای اﻳﺠﺎد ﻳﮏ ﺷﯽ ‪ ،‬از ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ ﺷﯽ ﻣﺘﺪ ﻣﺮﺑﻮﻃﻪ را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﺡﺎﻻ ﮐﻪ ﺷﻤﺎ ﻳﮏ ﺷﯽ اﻳﺠﺎد ﮐﺮدﻳﺪ‪ .‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﻋﻤﻠﻴﺎت ﻋﻤﻮﻣﯽ را روی ﺁن اﺝﺮا ﻧﻤﺎﻳﻴﺪ‪ .‬روی ﺁﻳﮑﻮن ﺷﯽ ﮐﻠﻴﮏ راﺳﺖ ﮐﺮدﻩ‬

‫ﺗﺎ ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ ﺷﯽ ﻧﻤﺎﻳﺶ دادﻩ ﺷﻮد)ﺷﮑﻞ ‪ .(۵‬ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ ﻣﺘﺪهﺎی ﻣﻮﺝﻮد ﺑﺮای اﻳﻦ ﺷﯽ را ﺑﻪ هﻤﺮاﻩ دو ﻋﻤﻠﯽ ﮐﻪ ﺗﻮﺳﻂ‬

‫ﻣﺤﻴﻂ ‪ BlueJ‬ﺗﻮﺳﻌﻪ ﻳﺎﻓﺘﻪ اﻧﺪ )‪ (Inspect and Remove‬را ﻧﻤﺎﻳﺶ ﻣﯽ دهﺪ‪ .‬ﻣﺎ ﺑﻌﺪا ﺁﻧﻬﺎ را ﺗﻮﺿﻴﺢ ﺧﻮاهﻴﻢ داد ‪.‬اﺑﺘﺪا اﺝﺎزﻩ‬

‫دهﻴﺪ ﺗﺎ ﺑﺮ روی ﻣﺘﺪهﺎ ﺗﻤﺮﮐﺰ ﻧﻤﺎﻳﻴﻢ‪.‬‬

‫‪١١‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﺷﮑﻞ ‪ : ۵‬ﻣﻨﻮی ﺷﯽ‬

‫ﺷﻤﺎ در ﺁﻧﺠﺎ ﻣﺘﺪهﺎی ‪ setRoom‬و ‪ getRoom‬را ﻣﺸﺎهﺪﻩ ﻣﯽ ﻧﻤﺎﻳﻴﺪ‪.‬ﮐﻪ هﺮ ﮐﺪام ﺗﻨﻈﻴﻢ ﻣﯽ ﮐﻨﺪ و ﺑﺮ ﻣﯽ ﮔﺮداﻧﻨﺪ ﺷﻤﺎرﻩ‬

‫ﺧﺎﻧﻪ ﻣﺮﺑﻮط ﺑﻪ ‪ staff‬را‪ .‬ﺳﻌﯽ ﮐﻨﻴﺪ ﺗﺎ ﻣﺘﺪ ‪ getRoom‬را ﻓﺮاﺧﻮاﻧﯽ ﻧﻤﺎﻳﻴﺪ‪ .‬ﺑﺮای اﻳﻦ ﮐﺎر از ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ ﺷﯽ ﻣﺘﺪ‬

‫را اﻧﺘﺨﺎب ﮐﻨﻴﺪ ﺗﺎ اﺝﺮا ﺷﻮد‪ .‬ﭘﻨﺠﺮﻩ ای ﻧﻤﺎﻳﺶ دادﻩ ﻣﯽ ﺷﻮد ﮐﻪ ﻧﺘﻴﺠﻪ اﻳﻦ ﻓﺮاﺧﻮاﻧﯽ را ﺑﻪ ﺷﻤﺎ ﻧﻤﺎﻳﺶ ﻣﯽ دهﺪ‪) .‬ﺷﮑﻞ ‪(۶‬‬

‫در اﻳﻦ ﻣﻮرد ؛ ﻧﺎم ﺑﺮﮔﺸﺖ دادﻩ ﺷﺪﻩ "‪ "unknown room‬ﻣﯽ ﺑﺎﺷﺪ‪ .‬زﻳﺮا ﻣﺎ ﻳﮏ ﻧﺎم ﺧﺎص ﺑﺮای ‪ room‬اﻳﻦ ﺷﺨﺺ‬

‫در ﻧﻈﺮ ﻧﮕﺮﻓﺘﻪ اﻳﻢ‪.‬‬

‫ﺷﮑﻞ‪ :۶‬ﻧﻤﺎﻳﺶ ﻧﺘﻴﺠﻪ ﺗﺎﺑﻊ‬

‫ﻣﺘﺪهﺎی ﮐﻪ از ﮐﻼس هﺎی دﻳﺮ ارث ﺑﺮدﻩ اﻧﺪ در زﻳﺮ ﻣﻨﻮ ﻣﻮﺝﻮد ﻣﯽ ﺑﺎﺷﻨﺪ‪ .‬در ﺑﺎﻻی ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ ﺷﯽ دو زﻳﺮ‬

‫ﻣﻨﻮ ﻣﻮﺝﻮد ﻣﻴﺒﺎﺷﺪ‪ .‬ﻳﮑﯽ ﺑﺮای ﻣﺘﺪهﺎی اﺳﺖ ﮐﻪ ازﮐﻼس ‪ Object‬ارث ﺑﺮدﻩ اﺗﺪ‪ .‬و ﻳﮑﯽ ﺑﺮای ﻣﺘﺪهﺎی ﮐﻪ از ﮐﻼس ‪. Person‬‬

‫ﺷﻤﺎ ﻣﻴﺘﻮاﻧﻴﺪ ﻣﺘﺪهﺎی ﮐﻼس ‪ ) Person‬ﻣﺎﻧﻨﺪ ‪ (getName :‬را ﺑﺎ اﻧﺘﺨﺎب اﻧﻬﺎ از زﻳﺮ ﻣﻨﻮ ﻓﺮاﺧﻮاﻧﯽ ﻧﻤﺎﻳﻴﺪ‪ .‬اﻳﻦ ﮐﺎر را اﻧﺠﺎم دهﻴﺪ‪.‬‬

‫اﮔﺮ ﺗﻮﺝﻪ ﮐﻨﻴﺪ ﺧﻮاهﻴﺪ دﻳﺪ ﮐﻪ ﺝﻮاب ﺗﻮﻟﻴﺪ ﺷﺪﻩ ﻧﺎم ﻣﺸﺨﺺ ﻣﯽ ﺑﺎﺷﺪ ﻳﻌﻨﯽ ﭘﺎﺳﺦ ﺑﺮاﺑﺮ ﺑﺎ "‪ "unknown name‬ﻣﻴﺒﺎﺷﺪ‪.‬‬

‫دﻟﻴﻞ ﺁن هﻢ اﻳﻦ اﺳﺖ ﮐﻪ ﻣﺎ ﺑﻪ اﺷﺨﺎص ﻣﺎن ﻧﺎﻣﯽ ﻧﺪادﻩ اﻳﻢ ‪.‬‬

‫ﺡﺎﻻ ﺑﻪ ﻣﺎ اﺝﺎزﻩ ﺑﺪهﻴﺪ ﺗﺎ ﺑﺮای ﻳﮏ اﺗﺎق )‪ (room‬ﻳﮏ ﺷﻤﺎرﻩ ﺗﻌﻴﻴﻦ ﮐﻨﻴﻢ‪ .‬اﻳﻦ ﮐﺎر ﺑﻪ ﻣﺎ ﻧﺸﺎن ﻣﯽ دهﺪ ﮐﻪ ﭼﮕﻮﻧﻪ ﻣﯽ ﺗﻮاﻧﻴﻢ‬

‫‪١٢‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﻳﮏ ﻓﺮاﺧﻮاﻧﯽ ﺑﺎ ﭘﺎراﻣﺘﺮ داﺷﺘﻪ ﺑﺎﺷﻴﻢ‪ ) .‬ﻓﺮاﺧﻮاﻧﯽ ‪ getRoom‬و ‪ getName‬ﻓﻘﻂ ﻳﮏ ﻣﻘﺪار را ﺑﺮ ﻣﯽ ﮔﺮداﻧﺪ‪ .‬اﻣﺎ ﭘﺎراﻣﺘﺮ‬

‫ﭘﺎراﻣﺘﺮ ﭘﺬﻳﺮ ﻧﻴﺴﺖ ( ﺗﺎﺑﻊ ‪ setRoom‬را ﺑﺎ اﻧﺘﺨﺎب ﺁن از ﻣﻨﻮ ﻓﺮاﺧﻮاﻧﯽ ﻧﻤﺎﻳﻴﺪ‪ .‬ﭘﻨﺠﺮﻩ ای ﺑﺎز ﻣﯽ ﺷﻮد ﮐﻪ ﺑﻪ ﺷﻤﺎ اﺝﺎزﻩ ﻣﯽ دهﺪ‬

‫ﺗﺎ ﭘﺎراﻣﺘﺮ را وارد ﻧﻤﺎﻳﻴﺪ ) ﺷﮑﻞ ‪(٧‬‬

‫ﺷﮑﻞ ‪ : ٧‬ﭘﻨﺠﺮﻩ ﻓﺮاﺧﻮاﻧﯽ ﺗﺎﺑﻊ ﺑﺎ ﭘﺎراﻣﺘﺮ‬

‫در ﺑﺎﻻی ﭘﻨﺠﺮﻩ ای ﮐﻪ ﻧﻤﺎﻳﺶ دادﻩ ﻣﯽ ﺷﻮد‪ .‬راﺑﻂ ﻣﺘﺪ ﻓﺮاﺧﻮاﻧﯽ ﺷﺪﻩ ﻧﻤﺎﻳﺶ دادﻩ ﻣﯽ ﺷﻮد‪).‬ﺷﺎﻣﻞ ﮐﺎﻣﻨﺖ و اﻣﻀﺎ ﻣﺘﺪ (‬

‫در زﻳﺮ اﻳﻦ ﻗﺴﻤﺖ ﻣﺤﻞ ورود ﻣﺘﻦ ﻣﯽ ﺑﺎﺷﺪ ﮐﻪ ﺷﻤﺎ ﺑﺎ اﺳﺘﻔﺎدﻩ از ان ﻣﯽ ﺗﻮاﻧﻴﺪ ﭘﺎراﻣﺘﺮ ﻣﺮﺑﻮﻃﻪ را وارد ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫اﻣﻀﺎ ﻣﺘﺪ ﮐﻪ در ﻗﺴﻤﺖ ﺑﺎﻻی ﭘﻨﺠﺮﻩ ﻗﺮار دارد‪ .‬ﺑﻪ ﻣﺎ ﻣﯽ ﮔﻮﻳﺪ ﮐﻪ ﺷﻤﺎ ﻳﮏ ﭘﺎراﻣﺘﺮ از ﻧﻮع رﺷﺘﻪ دارﻳﺪ‪.‬‬

‫ﻳﮏ اﺗﺎق ﺝﺪﻳﺪ از ﻧﻮع رﺷﺘﻪ ) ﺷﺎﻣﻞ ﮐﻮﺗﻴﺸﻦ هﺎ ( در ﻣﺤﻞ ورود ﻣﺘﻦ وارد ﻧﻤﺎﻳﺪ و دﮐﻤﻪ ‪ Ok‬را ﻓﺸﺎر دهﻴﺪ‪.‬‬

‫اﻳﻦ ﻣﺘﺪ ﻣﻘﺪار ﺑﺎزﮔﺸﺘﯽ ﻧﺪارد و در ﻧﺘﻴﺠﻪ ﭘﻨﺠﺮﻩ ای ﺑﻪ ﻋﻨﻮان ﻧﺘﻴﺠﻪ ﺑﺎز ﻧﺨﻮاهﺪ ﺷﺪ‪.‬ﺑﻠﮑﻪ ﺑﺮای اﻳﻦ ﮐﻪ ﺷﻤﺎ ﺗﻐﻴﻴﺮات‬

‫را ﺑﺒﻴﻨﻴﺪ ﺑﺎﻳﺪ ﻳﮑﺒﺎر دﻳﮕﺮ ﻣﺘﺪ ‪ getRoom‬را ﻓﺮاﺧﻮاﻧﯽ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﺳﻌﯽ ﮐﻨﻴﺪ اﺷﻴﺎی را اﻳﺠﺎد ﮐﻨﻴﺪ و ﻣﺘﺪهﺎی اﻧﻬﺎ را ﻓﺮاﺧﻮاﻧﯽ ﻧﻤﺎﻳﻴﺪ‪ .‬ﺳﻌﯽ ﮐﻨﻴﺪ ﮐﻪ ﺳﺎزﻧﺪﻩ را ﺑﺎ ﺁرﮔﻮﻣﺎن هﺎﻳﺶ ﻓﺮاﺧﻮاﻧﯽ‬

‫ﻧﻤﺎﻳﻴﺪ‪ .‬هﻤﭽﻨﻴﻦ ﻣﺘﺪهﺎی ﻣﺮﺑﻮط ﺑﻪ اﻧﻬﺎ را ﻓﺮاﺧﻮاﻧﯽ ﻧﻤﺎﻳﻴﺪ ﺗﺎ ﺑﺎ اﻧﺠﺎم اﻳﻢ ﮐﺎرهﺎ ﺑﺎ اﻳﻦ اﻋﻤﺎل ﺁﺷﻨﺎﻳﯽ ﺑﻴﺸﺘﺮی ﭘﻴﺪا ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ (۵-٣‬وﻳﺮاﻳﺶ ﮐﻼس‬

‫ﺧﻼﺻﻪ ‪ :‬ﺑﺮای وﻳﺮاﻳﺶ ﮐﺪ ﮐﻼس ‪ ،‬ﺑﺮ روی ﺁﻳﮑﻮن ﮐﻼس دو ﺑﺎر ﮐﻠﻴﮏ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﺗﺎ اﻳﻨﺠﺎ ‪ ،‬ﻣﺎ ﻓﻘﻂ ﺑﺎ راﺑﻂ اﺷﻴﺎ ﺳﺮو ﮐﺎر داﺷﺘﻴﻢ‪ .‬اﻣﺎ ﺡﺎﻻ وﻗﺖ اوﻧﻪ ﮐﻪ ﻧﮕﺎهﯽ ﺑﻪ ﺑﺨﺶ داﺧﻠﯽ ﺑﺮﻧﺎﻣﻪ داﺷﺘﻪ ﺑﺎﺷﻴﻢ‪.‬‬

‫ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﭘﻴﺎدﻩ ﺳﺎزی ﻳﮏ ﮐﻼس را ﺑﺎ اﻧﺘﺨﺎب ‪ Open Editor‬از ﺗﻮاﺑﻊ ﮐﻼس ﺑﺒﻴﻨﻴﺪ‪.‬‬

‫) ﻳﺎد ﺁوری‪ :‬ﺑﺎ ﮐﻠﻴﮏ راﺳﺖ ﮐﺮدن ﺑﺮ روی ﺁﻳﮑﻮن ﮐﻼس ﻣﯽ ﺗﻮاﻧﻴﺪ ﺗﻮاﺑﻊ و اﻋﻤﺎل ﻣﺮﺑﻮط ﺑﻪ ﮐﻼس را ﻣﺸﺎهﺪﻩ ﻧﻤﺎﻳﺪ(‬

‫ﺑﺎ دوﺑﺎر ﮐﻠﻴﮏ ﮐﺮدن ﺑﺮ روی ﺁﻳﮑﻮن ﮐﻼس ﺷﻤﺎ ﺑﻪ ﻃﻮر ﻣﻴﺎن ﺑﺮ ﺑﻪ ﺗﻮاﺑﻊ ﻣﺸﺎﺑﻬﯽ دﺳﺘﺮﺳﯽ ﺧﻮاهﻴﺪ ﻳﺎﻓﺖ‪ .‬ﺝﺰﺋﻴﺎت ﻣﺮﺑﻮط‬

‫ﺑﻪ اﺳﺘﻔﺎدﻩ از ادﻳﺘﻮر در اﻳﻦ ﺁﻣﻮزش ﺑﻪ ﺷﺮح دادﻩ ﻧﺸﺪﻩ وﻟﯽ اﺳﺘﻔﺎدﻩ از ان ﺑﺴﻴﺎر ﺳﺮ راﺳﺖ ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﺝﺰﺋﻴﺎت ادﻳﺘﻮر ﺑﻪ ﻃﻮر‬

‫ﻣﺸﺨﺺ ﺑﻌﺪا ﺗﻮﺿﻴﺢ دادﻩ ﺧﻮاهﺪ ﺷﺪ‪ .‬ﺑﺮای ﺡﺎﻻ ‪ ،‬ﭘﻴﺎدﻩ ﺳﺎزی ﻣﺮﺑﻮط ﺑﻪ ﮐﻼس ‪ Staff‬را ﺑﺎز ﻧﻤﺎﻳﻴﺪ‪ .‬ﭘﻴﺎدﻩ ﺳﺎزی ﻣﺮﺑﻮط ﺑﻪ‬

‫ﻣﺘﺪ ‪ getRoom‬را ﭘﻴﺪا ﻧﻤﺎﻳﻴﺪ‪ .‬اﻳﻦ ﻣﺘﺪ ﺷﻤﺎرﻩ اﺗﺎق اﻋﻀﺎ ﻋﻀﻮ را ﺑﺮ ﻣﯽ ﮔﺮداﻧﺪ‪ .‬ﺑﻪ ﻣﺎ اﺝﺎزﻩ دهﻴﺪ ﺗﺎ ﺑﺎ اﺿﺎﻓﻪ ﮐﺮدن ﭘﻴﺸﻮﻧﺪ‬

‫"‪ "room‬ﺑﻪ ﻣﺘﺪ ﻧﺘﻴﺠﻪ ﻧﻬﺎﻳﯽ ﺗﺎﺑﻊ را ﺗﻐﻴﻴﺮ دهﻴﻢ )ﺑﻨﺎﺑﺮاﻳﻦ ﻣﺘﺪ ﻣﻘﺪار "‪ "room M.3.18‬را ﺑﻪ ﺝﺎی ﻣﻘﺪار "‪ "M.3.18‬ﺑﺮ ﻣﯽ‬

‫‪١٣‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﮔﺮداﻧﺪ(‪ .‬ﻣﺎ اﻳﻨﮑﺎر را ﺑﺎ ﺗﻐﻴﻴﺮ اﻳﻦ ﺧﻂ ﺑﺮﻧﺎﻣﻪ اﻧﺠﺎم ﺧﻮاهﻴﻢ داد ‪:‬‬

‫;‪Return room‬‬

‫و ﺗﻐﻴﻴﺮ ان ﺑﻪ ‪:‬‬

‫;‪Return "room"+room‬‬

‫ﺑﺮﻧﺎﻣﻪ ‪ BlueJ‬ﺑﻄﻮر ﮐﺎﻣﻞ ‪ ،‬دﺳﺘﻮرات ﺝﺎوا را ﭘﺸﺘﻴﺒﺎﻧﯽ ﻣﯽ ﮐﻨﺪ‪.‬در ﻧﺘﻴﺠﻪ در اﻳﻦ ﺝﺎ ﭼﻴﺰ ﺧﺎﺻﯽ ﺑﺮای ﻧﺤﻮﻩ ﭘﻴﺎدﻩ ﺳﺎزی ﮐﻼس‬

‫ﻧﻴﺴﺖ‪ .‬و هﻤﻪ ﭼﻴﺰ ﺑﺮ اﺳﺎس ﻗﻮاﻋﺪ ﺝﺎوا اﻧﺠﺎم ﻣﯽ ﭘﺬﻳﺮد‪.‬‬

‫‪ (۶-٣‬ﮐﺎﻣﭙﺎﻳﻞ ﮐﺮدن‬

‫ﺧﻼﺻﻪ‪ :‬ﺑﺮای ﮐﺎﻣﭙﺎﻳﻞ ﻳﮏ ﮐﻼس‪ ،‬دﮐﻤﻪ ‪ Compile‬در وﻳﺮاﻳﺶ ﮔﺮ را ﻓﺸﺎر دهﻴﺪ‪ .‬و ﺑﺮای ﮐﺎﻣﭙﺎﻳﻞ ﻳﮏ ﭘﺮوژﻩ دﮐﻤﻪ ‪Compile‬‬

‫واﻗﻊ در ﭘﻨﺠﺮﻩ ﭘﺮوژﻩ را ﻓﺸﺎر دهﻴﺪ‪.‬‬

‫ﺑﻌﺪ از اﻳﻨﮑﻪ ﺷﻤﺎ ﻣﺘﻦ را وارد ﮐﺮدﻳﺪ )و ﻗﺒﻞ از اﻳﻦ ﮐﻪ ﮐﺎر دﻳﮕﺮی اﻧﺠﺎم دهﻴﺪ( ‪.‬ﻧﻤﺎی ﭘﺮوژﻩ ﺗﺎن را ﺑﺮرﺳﯽ ﻧﻤﺎﻳﻴﺪ ) ﭘﻨﺠﺮﻩ اﺻﻠﯽ(‬

‫ﺷﻤﺎ اﮔﺮ دﻗﺖ ﮐﻨﻴﺪ ﺧﻮاهﻴﺪ دﻳﺪ ﮐﻪ ﺁﻳﮑﻮن ﮐﻼس ‪ Staff‬ﺗﻐﻴﻴﺮ ﮐﺮدﻩ اﺳﺖ‪ .‬و ﺁﻳﮑﻮن ﮐﻼس ﺷﺎﻣﻞ ﺧﻄﻮط راﻩ راهﯽ ﺷﺪﻩ اﺳﺖ‪.‬‬

‫اﻳﻦ ﺧﻄﻮط را ﻩ راﻩ ﻧﺸﺎن ﻣﯽ دهﻨﺪ ﮐﻪ ﮐﻼس ﺑﻌﺪ از ﺁﺧﺮﻳﻦ ﺗﻐﻴﻴﺮات ﮐﺎﻣﭙﺎﻳﻞ ﻧﺸﺪﻩ اﺳﺖ‪.‬‬

‫ﺗﻮﺝﻪ ‪ :‬ﺷﺎﻳﺪ ﺷﻤﺎ ﺗﻌﺠﺐ ﮐﻨﻴﺪ ﮐﻪ ﭼﺮا ﺑﺮای اوﻟﻴﻦ ﺑﺎر ﮐﻪ اﻳﻦ ﭘﺮوژﻩ را ﺑﺎز ﮐﺮدﻳﺪ ﺁﻳﮑﻮن هﺎی ﮐﻼس ﺧﻂ دار ﻧﺒﻮدن ‪.‬اﻳﻦ‬

‫ﻣﻮﺿﻮع ﺑﻪ اﻳﻦ دﻟﻴﻞ ﻣﯽ ﺑﺎﺷﺪ ﮐﻪ ﮐﻼس هﺎی ﭘﺮوژﻩ ‪ people‬ﺑﺼﻮرت ﮐﺎﻣﭙﺎﻳﻞ ﺷﺪﻩ ﺗﻮزﻳﻊ ﺷﺪﻩ اﻧﺪ‪ .‬اﻟﺒﺘﻪ اﮐﺜﺮ ﭘﺮوژﻩ‬

‫هﺎی ‪ BlueJ‬ﺑﺼﻮرت ﮐﺎﻣﭙﺎﻳﻞ ﻧﺸﺪﻩ ﺗﻮزﻳﻊ ﻣﯽ ﺷﻮﻧﺪ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ از اﻳﻦ ﺑﻪ ﺑﻌﺪ‪ ،‬ﺑﻪ ﺁﻳﮑﻮن ﮐﻼس هﺎی ﭘﺮوژﻩ هﺎی ﮐﻪ ﺑﺎز‬

‫ﻣﯽ ﮐﻨﻴﺪ دﻗﺖ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫در ﻣﻨﻮی اﺑﺰار واﻗﻊ در ﺑﺎﻻی وﻳﺮاﻳﺸﮕﺮ ﭼﻨﺪﻳﻦ دﮐﻤﻪ ﻗﺮار دارﻧﺪ ﮐﻪ ﻣﺎ از ﺁﻧﻬﺎ ﻣﺮﺗﺒﺎ اﺳﺘﻔﺎدﻩ ﻣﯽ ﮐﻨﻴﻢ‪ .‬ﻳﮑﯽ از اﻳﻦ دﮐﻤﻪ هﺎ‬

‫دﮐﻤﻪ ‪ Compile‬ﻣﯽ ﺑﺎﺷﺪ‪ .‬اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺷﻤﺎ اﺝﺎزﻩ ﻣﯽ دهﺪ ﺗﺎ ﮐﻼس ﺗﺎن را ﻣﺴﺘﻘﻴﻤﺎ از درون وﻳﺮاﻳﺸﮕﺮ ﮐﺎﻣﭙﺎﻳﻞ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﺡﺎﻻ دﮐﻤﻪ ‪ Compile‬را ﻓﺸﺎر دهﻴﺪ‪ .‬اﮔﺮ ﺷﻤﺎ اﺷﺘﺒﺎهﯽ ﻣﺮﺗﮑﺐ ﻧﺸﺪﻩ ﺑﺎﺷﻴﺪ ‪.‬ﭘﻴﻐﺎم "‪ " the class has been compiled‬در‬

‫ﺑﺨﺶ اﻃﻼﻋﺎت واﻗﻊ در اﻧﺘﻬﺎی وﻳﺮاﻳﺸﮕﺮ ﺑﻪ ﻧﻤﺎﻳﺶ در ﻣﯽ ﺁﻳﺪ‪ .‬اﮔﺮ ﺷﻤﺎ ﺧﻄﺎﻳﯽ اﻧﺠﺎم دهﻴﺪ ﮐﻪ ﻣﻨﺠﺮ ﺑﻪ ﺗﻮﻟﻴﺪ ﻳﮏ ﺧﻄﺎی ﻧﺤﻮی‬

‫ﺷﻮد‪ .‬ﺧﻂ ﮐﺪی ﮐﻪ ﺧﻄﺎ در ﺁن اﺗﻔﺎق اﻓﺘﺎدﻩ ﻣﺸﺨﺺ )( ﻣﯽ ﺷﻮد و هﻤﭽﻨﻴﻦ ﭘﻴﻐﺎم ﺧﻄﺎﻳﯽ در ﺑﺨﺶ اﻃﻼﻋﺎت ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﻧﻤﺎﻳﺶ‬

‫در ﻣﯽ ﺁﻳﺪ‪ ) .‬در ﻣﻮرد اوﻟﯽ ﮐﻪ ﮐﺎﻣﭙﺎﻳﻞ ﮐﺮدﻳﺪ‪.‬ﺳﻌﯽ ﮐﻨﻴﺪ ﻳﮏ ﺧﻄﺎی ﻧﺤﻮی اﻳﺠﺎد ﮐﻨﻴﺪ ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻳﮏ ﺳﻴﻤﯽ ﮐﻠﻮن را ﺡﺬف‬

‫ﮐﻨﻴﺪ‪ .‬ﺡﺎﻻ ﺁﻧﺮا ﻣﺠﺪدا ﮐﺎﻣﭙﺎﻳﻞ ﻧﻤﺎﻳﻴﺪ ﺗﺎ ﺑﺒﻴﻨﻴﺪ ﭼﻪ اﺗﻔﺎﻗﯽ ﻣﯽ اﻓﺘﺪ‪ ( .‬ﺑﻌﺪ از اﻳﻦ ﮐﻪ ﮐﻼس را ﺑﺎ ﻣﻮﻓﻘﻴﺖ ﮐﺎﻣﭙﺎﻳﻞ ﻧﻤﻮدﻳﺪ‪.‬‬

‫وﻳﺮاﻳﺸﮕﺮ را ﺑﺒﻨﺪﻳﺪ‪.‬‬

‫‪١۴‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﺗﻮﺝﻪ ‪ :‬ﺷﻤﺎ ﻧﻴﺎز ﺑﻪ ذﺧﻴﺮﻩ ﮐﺪ ﮐﻼس ﻧﺪارﻳﺪ ﮐﺪهﺎ در زﻣﺎن هﺎی ﻣﻮرد ﻧﻴﺎز ﻳﻪ ﺻﻮرت ﺧﻮدﮐﺎر ذﺧﻴﺮﻩ ﻣﯽ ﺷﻮﻧﺪ‪ ) .‬ﻣﺎﻧﻨﺪ هﻨﮕﺎﻣﯽ‬

‫ﮐﻪ وﻳﺮاﻳﺸﮕﺮ را ﻣﯽ ﺑﻨﺪﻳﺪ و ﻳﺎ ﻗﺒﻞ از اﻳﻦ ﮐﻪ ﮐﻼس را ﮐﺎﻣﭙﺎﻳﻞ ﻧﻤﺎﻳﻴﺪ‪ .‬ﺷﻤﺎ اﮔﺮ دوﺳﺖ دارﻳﺪ ﻣﯽ ﺗﻮاﻧﻴﺪ ﮐﺪهﺎ را ذﺧﻴﺮﻩ ﮐﻨﻴﺪ‬

‫) ﺗﺎﺑﻊ ﻣﻮرد ﻧﻴﺎز در وﻳﺮاﻳﺸﮕﺮ ﻣﺮﺑﻮط ﺑﻪ ﮐﻼس وﺝﻮد دارد ( اﻟﺒﺘﻪ ﺷﻤﺎ در ﺡﺎﻟﺘﯽ ﺑﻪ اﻳﻦ ﮐﺎر ﻧﻴﺎز دارﻳﺪ ﮐﻪ ﮐﺎﻣﭙﻴﻮﺗﺮ ﺗﺎن ﺑﻪ ﺻﻮرت‬

‫ﻣﮑﺮر ﮐﺮش )‪ (crash‬ﻣﯽ ﮐﻨﺪ‪ .‬و ﺷﻤﺎ ﻧﮕﺮاﻧﻴﺪ ﮐﻪ ﮐﺎرﺗﺎن از ﺑﻴﻦ ﺑﺮود‪.‬‬

‫ﻣﻨﻮی اﺑﺰار ﭘﻨﺠﺮﻩ ﭘﺮوژﻩ ﻧﻴﺰ ﺷﺎﻣﻞ دﮐﻤﻪ ‪ Compile‬ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﺑﺎ ﻓﺸﺮدن اﻳﻦ دﮐﻤﻪ ﮐﻞ ﭘﺮوژﻩ ﮐﺎﻣﭙﺎﻳﻞ ﻣﯽ ﺷﻮد‪ ) .‬اﻳﻦ دﮐﻤﻪ‬

‫ﺗﺸﺨﻴﺺ ﻣﯽ دهﺪ ﮐﻪ ﮐﺪاﻣﻴﮏ از ﮐﻼس هﺎ ﻧﻴﺎز ﺑﻪ ﮐﺎﻣﭙﺎﻳﻞ ﻣﺠﺪد دارﻧﺪ‪ .‬و ﺳﭙﺲ ﺑﻌﺪ از ﮐﺎﻣﭙﺎﻳﻞ ﻣﺠﺪد اﻧﻬﺎ را ﻣﺮﺗﺐ ﻣﯽ ﮐﻨﺪ ( ‪.‬اﻳﻦ‬

‫ﮐﺎر را ﺑﺎ اﻳﺠﺎد ﺗﻐﻴﻴﺮ در دو ﻳﺎ ﭼﻨﺪ ﮐﻼس )ﺑﻨﺎﺑﺮاﻳﻦ ﺷﻤﺎ ﺑﺎﻳﺪ دو ﻳﺎ ﭼﻨﺪ ﮐﻼس در ﺻﻔﺤﻪ ﺗﺮﺳﻴﻢ ﮐﻼس هﺎ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﮐﻪ‬

‫ﺑﺎ ﺧﻄﻮط راﻩ راﻩ ﻣﺸﺨﺺ ﺷﺪﻩ ﺑﺎﺷﺪ (اﻣﺘﺤﺎن ﮐﻨﻴﺪ وﺳﭙﺲ دﮐﻤﻪ ‪ Compile‬را ﻓﺸﺎر دهﻴﺪ‪ .‬اﮔﺮ در ﺡﻴﻦ ﮐﺎﻣﭙﺎﻳﻞ ﺧﻄﺎﻳﯽ در ﻳﮑﯽ از‬

‫ﮐﻼس هﺎ ﺗﺸﺨﻴﺺ دادﻩ ﺷﻮد‪ .‬وﻳﺮاﻳﺸﮕﺮ ﺑﺎز ﺷﺪﻩ و ﻣﺤﻞ ﺧﻄﺎ و هﻤﭽﻨﻴﻦ ﭘﻴﻐﺎم ﻣﻨﺎﺳﺐ را ﻧﻤﺎﻳﺶ ﻣﯽ دهﺪ‪ .‬ﺷﻤﺎ اﮔﺮ دﻗﺖ ﮐﻨﻴﺪ ﺧﻮاهﻴﺪ‬

‫دﻳﺪ ﮐﻪ ﻣﺤﻞ اﺷﻴﺎ )‪ (object bench‬ﻣﺠﺪدا ﺧﺎﻟﯽ ﻣﯽ ﺷﻮد‪ .‬هﻨﮕﺎﻣﯽ ﮐﻪ در ﭘﻴﺎدﻩ ﺳﺎزی ﺗﻐﻴﻴﺮ اﻳﺠﺎد ﺷﻮد اﺷﻴﺎ ﭘﺎک ﻣﯽ ﺷﻮﻧﺪ‪ .‬چ‬

‫‪ (٧-٣‬راهﻨﻤﺎﻳﯽ ﺑﻮﺳﻴﻠﻪ ﺧﻄﺎهﺎی ﮐﺎﻣﭙﺎﻳﻠﺮ‬

‫ﺧﻼﺻﻪ ‪ :‬ﺑﺮای راهﻨﻤﺎﻳﯽ ﮔﺮﻓﺘﻦ درﺑﺎرﻩ ﭘﻴﻐﺎم ﺧﻄﺎﻳﯽ ﮐﺎﻣﭙﺎﻳﻠﺮ ‪ ،‬ﺑﺮ روی ﻋﻼﻣﺖ ﺳﻮال ﮐﻪ ﺑﻌﺪ از ﭘﻴﻐﺎم ﺧﻄﺎ ﻗﺮار دارد ﮐﻠﻴﮏ ﮐﻨﻴﺪ‪.‬‬

‫اﻏﻠﺐ اوﻗﺎت ‪ ،‬داﻧﺸﺠﻮﻳﺎن ﻣﺒﺘﺪی ﺑﻪ ﺳﺨﺘﯽ ﻣﺘﻮﺝﻪ ﭘﻴﻐﺎم هﺎی ﺧﻄﺎ ﻣﯽ ﺷﻮﻧﺪ‪ .‬ﻣﺎ ﺗﻼش ﮐﺮدﻳﻢ ﺗﺎ ﻳﮏ راهﻨﻤﺎ ﻧﻴﺰ اﻳﺠﺎد ﻧﻤﺎﻳﻴﻢ‪.‬‬

‫وﻳﺮاﻳﺸﮕﺮ را ﻣﺠﺪدا ﺑﺎز ﮐﻨﻴﺪ و در ان ﻳﮏ ﺧﻄﺎ اﻳﺠﺎد ﮐﺮدﻩ و ﮐﻼس را دوﺑﺎرﻩ ﮐﺎﻣﭙﺎﻳﻞ ﻧﻤﺎﻳﻴﺪ ‪.‬در ﺑﺨﺶ اﻃﻼﻋﺎت وﻳﺮاﻳﺸﮕﺮ ﺑﺎﻳﺪ‬

‫ﭘﻴﻐﺎم ﺧﻄﺎ ﻧﻤﺎﻳﺶ دادﻩ ﺷﻮد‪ .‬در اﻧﺘﻬﺎی ﺳﻤﺖ راﺳﺖ ﺑﺨﺶ اﻃﻼﻋﺎت ﻋﻼﻣﺖ ﺳﻮال ﻣﺸﺨﺺ ﻣﯽ ﺑﺎﺷﺪ ﮐﻪ ﺷﻤﺎ ﺑﺎ ﮐﻠﻴﮏ ﮐﺮدن ﺑﺮ روی‬

‫ﺁن ﻣﯽ ﺗﻮاﻧﻴﺪ اﻃﻼﻋﺎت ﺑﻴﺸﺘﺮی درﺑﺎرﻩ ان ﺧﻄﺎ ﺑﺪﺳﺖ ﺁورﻳﺪ‪ ).‬ﻋﮑﺲ ﺷﻤﺎرﻩ ‪(٨‬‬

‫ﻋﮑﺲ ‪ : ٨‬ﺧﻄﺎی ﮐﺎﻣﭙﺎﻳﻠﺮ و دﮐﻤﻪ راهﻨﻤﺎ‬

‫در اﻳﻦ ﻣﺮﺡﻠﻪ ‪ ،‬ﻣﺘﻦ هﺎی راهﻨﻤﺎ ﺑﺮای ﺗﻤﺎم ﭘﻴﻐﺎم هﺎی ﺧﻄﺎ ﻣﻮﺝﻮد ﻧﻤﯽ ﺑﺎﺷﺪ‪ .‬ﻣﻘﺪاری از ﻣﺘﻦ هﺎی راهﻨﻤﺎ هﻨﻮز در ﺡﺎل‬

‫ﻧﻮﺷﺘﻪ ﺷﺪن ﻣﯽ ﺑﺎﺷﻨﺪ ‪.‬اﻣﺎ اﻳﻦ ﺧﺎﺻﻴﺖ ارزش اﻣﺘﺤﺎن ﮐﺮدن را دارد‪.‬ﺗﻌﺪاد زﻳﺎدی از ﺧﻄﺎ هﺎ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻩ اﻧﺪ‪ .‬ﻣﻮارد‬

‫ﺑﺎﻗﯽ ﻣﺎﻧﺪﻩ ﻧﻴﺰ ﻧﮕﺎﺷﺘﻪ ﺷﺪﻩ و در وﻳﺮاﻳﺶ هﺎی ﺑﻌﺪی ‪ BlueJ‬ﺑﻪ ﺁن اﺿﺎﻓﻪ ﺧﻮاهﻨﺪ ﺷﺪ‪.‬‬

‫‪١۵‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﻓﺼﻞ‪ -۴‬اﻧﺠﺎم اﻋﻤﺎﻟﯽ ﺑﻴﺸﺘﺮ‬

‫در اﻳﻦ ﻓﺼﻞ ﻣﺎ ﺑﻴﺸﺘﺮ ﺑﺮ روی ﮐﺎرهﺎی ﮐﻪ ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺗﻮﺳﻂ ﻣﺤﻴﻂ ‪ BlueJ‬اﻧﺠﺎم دهﻴﺪ‪ .‬ﺑﺤﺚ ﺧﻮاهﻴﻢ ﮐﺮد اﻳﻦ ﻣﻮارد‬

‫ﭘﺎﻳﻪ ای ﻧﻴﺴﺘﻨﺪ وﻟﯽ ﺑﻪ ﻃﻮر ﻓﺮاوان ﻣﻮرد اﺳﺘﻔﺎدﻩ ﻗﺮار ﻣﯽ ﮔﻴﺮﻧﺪ‪.‬‬

‫‪ (١-۴‬ﻧﺎﻇﺮ‬

‫ﺧﻼﺻﻪ‪ :‬ﻧﺎﻇﺮ ﺷﯽ ﺑﻪ ﺷﻤﺎ اﺝﺎزﻩ ﻣﯽ دهﺪ ﺗﺎ ﺑﻪ رﻓﻊ ﺧﻄﺎهﺎی ﺳﺎدﻩ ﺑﭙﺮدازﻳﺪ ﺑﺎ ﻧﺸﺎن دادن وﺿﻌﻴﺖ داﺧﻠﯽ ﺷﯽ‪.‬‬

‫هﻨﮕﺎﻣﯽ ﮐﻪ ﺷﻤﺎ ﻣﺘﺪهﺎی ﻳﮏ ﺷﯽ را اﺝﺮا ﻣﯽ ﮐﻨﻴﺪ ‪.‬ﺷﻤﺎ ﻣﯽ ﺑﻴﻨﻴﺪ ﮐﻪ ﺗﺎﺑﻊ ‪ Inspect‬ﺑﺮای اﺷﻴﺎی ﮐﻪ ﺷﺎﻣﻞ ﻣﺘﺪهﺎی ﺗﻌﺮﻳﻒ‬

‫ﺷﺪﻩ ﺗﻮﺳﻂ ﮐﺎرﺑﺮ هﺴﺘﻨﺪ ﻣﻮﺝﻮد اﺳﺖ)ﺷﮑﻞ ‪ .(۵‬اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺷﻤﺎ اﺝﺎزﻩ ﻣﯽ دهﺪ ﺗﺎ وﺿﻌﻴﺖ ﻣﺘﻐﻴﺮهﺎی ) ﻓﻴﻠﺪهﺎ ( ﺷﯽ را ﺑﺮرﺳﯽ‬

‫ﻧﻤﺎﻳﻴﺪ ‪.‬ﻳﮏ ﺷﯽ ﺑﺎ ﭼﻨﺪ ﻣﻘﺪار ﺗﻌﺮﻳﻔﯽ ﺗﻮﺳﻂ ﮐﺎرﺑﺮ اﻳﺠﺎد ﻧﻤﺎﻳﻴﺪ ) ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺷﯽ ‪ Staff‬ﺑﺎ ﺳﺎزﻧﺪﻩ هﺎی ﮐﻪ ﭘﺎراﻣﺘﺮ‬

‫ﻣﯽ ﭘﺬﻳﺮﻧﺪ( ‪.‬ﺳﭙﺲ ﺗﺎﺑﻊ ‪ Inspect‬را از ﻣﻨﻮی ﺷﯽ اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪ .‬ﭘﻨﺠﺮﻩ ای ﻧﻤﺎﻳﺶ دادﻩ ﻣﯽ ﺷﻮد ﮐﻪ ﻓﻴﻠﺪ هﺎی ﺷﯽ را‬

‫ﺑﺎ ﻧﻮع و ﻣﻘﺪار ﺷﺎن ﻧﻤﺎﻳﺶ ﻣﯽ دهﺪ )ﺷﮑﻞ ‪.(٩‬‬

‫ﺷﮑﻞ ‪ :٩‬ﭘﻨﺠﺮﻩ ﻧﺎﻇﺮ‬

‫ﻧﺎﻇﺮ ﺑﺮای ﺑﺮرﺳﯽ ﺳﺮﻳﻊ اﻋﻤﺎﻟﯽ ﮐﻪ ﺗﻐﻴﻴﺮ ﻣﯽ ﮐﻨﻨﺪ ﺑﺴﻴﺎر ﻣﻔﻴﺪ ﻣﯽ ﺑﺎﺷﺪ) اﻋﻤﺎﻟﯽ ﮐﻪ ﻣﻮﻗﻌﻴﺖ اﺷﻴﺎ در ان ﺗﻐﻴﻴﺮ ﻣﯽ ﻧﻤﺎﻳﺪ(‬

‫ﺑﻨﺎﺑﺮاﻳﻦ ‪ ،‬ﻧﺎﻇﺮ ﻳﮏ اﺑﺰار رﻓﻊ ﺧﻄﺎ ﺳﺎدﻩ ﻣﯽ ﺑﺎﺷﺪ‪.‬‬

‫در ﻣﺜﺎل ‪ ، Staff‬هﻤﻪ ﻓﻴﻠﺪ هﺎ از ﻧﻮع ﺳﺎدﻩ ﻣﯽ ﺑﺎﺷﻨﺪ ) ﻏﻴﺮ ﺷﯽ ﻳﺎ رﺷﺘﻪ هﺎ ( ‪ .‬ﻣﻘﺪار اﻳﻦ اﻧﻮاع ﻣﯽ ﺗﻮاﻧﺪ ﻣﺴﺘﻘﻴﻤﺎ ﻧﻤﺎﻳﺶ‬

‫دادﻩ ﺷﻮد‪ .‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﻓﻮرا ﺑﺒﻴﻨﻴﺪ ﮐﻪ ﮐﺪام ﺳﺎزﻧﺪﻩ ﺷﺎﻣﻞ ﻣﺘﻐﻴﺮ ﻧﻬﺎﻳﯽ ﻣﯽ ﺑﺎﺷﺪ‪.‬‬

‫در ﺑﺴﻴﺎری از ﻧﻤﻮﻧﻪ ای ﭘﻴﭽﻴﺪﻩ ‪ ،‬ﻣﻘﺎدﻳﺮ ﻓﻴﻠﺪ هﺎ ﻣﯽ ﺗﻮاﻧﺪ ﺑﻪ اﺷﻴﺎ ﮐﻪ ﺗﻮﺳﻂ ﮐﺎرﺑﺮان ﺗﻌﺮﻳﻒ ﮐﺮدﻩ اﻧﺪ ﻣﺮاﺝﻌﻪ ﮐﻨﺪ‪ .‬ﺑﺮای ﻣﺸﺎهﺪﻩ‬

‫ﭼﻨﻴﻦ ﺡﺎﻟﺘﯽ ﻣﺎ ﺑﺎﻳﺪ از ﻳﮏ ﭘﺮوژﻩ دﻳﮕﺮ اﺳﺘﻔﺎدﻩ ﮐﻨﻴﻢ‪ .‬ﭘﺮوژﻩ ‪ people2‬را ﺑﺎز ﮐﻨﻴﺪ‪.‬اﻳﻦ ﭘﺮوژﻩ هﻤﺮاﻩ ﺗﻮزﻳﻊ اﺳﺘﺎﻧﺪارد ‪BlueJ‬‬

‫ﻣﻮﺝﻮد ﻣﻴﺒﺎﺷﺪ‪ .‬ﺑﻌﺪ از ﺑﺎز ﮐﺮدن ﭘﺮوژﻩ ‪ people2‬ﻧﻤﺎی ﭘﻨﺠﺮﻩ ﭘﺮوژﻩ ﺷﺒﻴﻪ ﺷﮑﻞ ‪ ١٠‬ﺧﻮاهﺪ ﺷﺪ‪.‬‬

‫در ﻣﺜﺎل دوم ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﺒﻴﻨﻴﺪ ﮐﻪ ﮐﻼس ‪ Address‬ﺑﻪ ﮐﻼس هﺎی ﻣﺜﺎل ﻗﺒﻠﯽ اﺿﺎﻓﻪ ﺷﺪﻩ اﺳﺖ‪ .‬ﻳﮑﯽ از ﻓﻴﻠﺪهﺎی ﮐﻼس‬

‫‪ Person‬از ﻧﻮع ﺗﻌﺮﻳﻒ ﮐﺎرﺑﺮ ﮐﻼس ‪ Address‬ﻣﯽ ﺑﺎﺷﺪ‪.‬‬

‫‪١۶‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﺷﮑﻞ ‪ :١٠‬ﭘﻨﺠﺮﻩ ﭘﺮوژﻩ ‪people2‬‬

‫ﮐﺎر ﺑﻌﺪی ﮐﻪ ﻗﺮار اﺳﺖ ﮐﺎ اﻧﺠﺎم دهﻴﻢ ‪ .‬ﻧﺎﻇﺮ ﺑﺎ ﻓﻴﻠﺪهﺎی ﻧﻮع ﺷﯽ ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﻳﮏ ﺷﯽ ‪ Staff‬اﻳﺠﺎد ﮐﻨﻴﺪ و ﺳﭙﺲ ﻣﺘﺪ‬

‫)(‪ setAddress‬اﻳﻦ ﺷﯽ را ﻓﺮاﺧﻮاﻧﯽ ﻧﻤﺎﻳﻴﺪ ) ﺷﻤﺎ اﻳﻦ ﻣﺘﺪ را ﻣﯽ ﺗﻮاﻧﻴﺪ در زﻳﺮ ﻣﻨﻮی ‪ person‬ﭘﻴﺪا ﻧﻤﺎﻳﻴﺪ (‪.‬‬

‫ﺁدرس را وارد ﻧﻤﺎﻳﻴﺪ‪ .‬ﺑﻪ ﻃﻮر داﺧﻠﯽ ‪ ،‬ﮐﺪ ‪ Staff‬ﺷﯽ ﮐﻼس ‪ Address‬را اﻳﺠﺎد ﻣﯽ ﮐﻨﺪ‪.‬و ﺁﻧﺮا در ﻓﻴﻠﺪ ‪address‬‬

‫ذﺧﻴﺮﻩ ﻣﯽ ﻧﻤﺎﻳﺪ‪ .‬ﺡﺎﻻ ‪ ،‬ﻧﺎﻇﺮ ﺷﯽ ‪ Staff‬را ﻓﺮاﺧﻮاﻧﯽ ﻧﻤﺎﻳﺪ‪ .‬ﺷﮑﻞ ﺷﻤﺎرﻩ ‪ ١١‬ﻧﺘﻴﺠﻪ را ﺑﻪ ﻣﺎ ﻧﺸﺎن ﻣﯽ دهﺪ‪.‬‬

‫ﺡﺎﻻ ﻓﻴﻠﺪهﺎی درون ﺷﯽ ‪ Staff‬ﺷﺎﻣﻞ ‪ address‬ﻣﯽ ﺑﺎﺷﻨﺪ‪ .‬ﺷﻤﺎ هﻤﭽﻨﻴﻦ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﺒﻴﻨﻴﺪ ﮐﻪ ﻣﻘﺪار اﻳﻦ ﻓﻴﻠﺪ ﺑﺎ ﻳﮏ‬

‫ﭘﻴﮑﺎن ﻧﻤﺎﻳﺶ دادﻩ ﺷﺪﻩ ﮐﻪ اﻳﻦ ﺑﺪﻳﻦ ﻣﻌﻨﯽ اﺳﺖ ﮐﻪ ﻣﻘﺪار ان ﺑﻪ ﻳﮏ ﺷﯽ دﻳﮕﺮ ﻣﺮاﺝﻌﻪ ﻣﯽ ﻧﻤﺎﻳﺪ‪ .‬ﺧﺐ ﺗﺎ اﻳﻨﺠﺎ اﻳﻦ ﻣﻮﺿﻮع‬

‫ﭘﻴﭽﻴﺪﻩ ﻣﯽ ﺑﺎﺷﺪ‪ .‬زﻳﺮا ﻣﻘﺪار ﺷﯽ هﺎی ﺗﻌﺮﻳﻔﯽ ﺗﻮﺳﻂ ﮐﺎرﺑﺮ را ﻧﻤﯽ ﺗﻮان ﻣﺴﺘﻘﻴﻤﺎ در اﻳﻦ ﻟﻴﺴﺖ ﻣﺸﺎهﺪﻩ ﮐﺮد‪.‬‬

‫ﺑﺮای اﻣﺘﺤﺎن ﮐﺮدن ﻣﻘﺎدﻳﺮ ﻣﺮﺑﻮط ﺑﻪ ‪ ، address‬ﻓﻴﻠﺪ ‪ Address‬را در ﻟﻴﺴﺖ اﻧﺘﺨﺎب ﮐﺮدﻩ و دﮐﻤﻪ ‪ Inspect‬ﻣﺮﺑﻮط ﺑﻪ‬

‫ﭘﻨﺠﺮﻩ را ﻓﺸﺎر دهﻴﺪ ) ﺷﻤﺎ هﻤﭽﻨﻴﻦ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﺮ روی ﻓﻴﻠﺪ ‪ address‬دو ﺑﺎر ﮐﻠﻴﮏ ﮐﻨﻴﺪ ( ﭘﻨﺠﺮﻩ ﻧﺎﻇﺮ دﻳﮕﺮی ﺑﺎز ﺷﺪﻩ و‬

‫ﺝﺰﺋﻴﺎت ﺷﯽ ‪ Address‬را ﻧﻤﺎﻳﺶ ﻣﯽ دهﺪ ) ﺷﮑﻞ ‪.(١٢‬‬

‫‪١٧‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﺷﮑﻞ ‪ :١١‬ﻧﺎﻇﺮ ﺑﺎ ﻣﺮاﺝﻌﻪ ﺑﻪ ﺷﯽ‬

‫ﺷﮑﻞ ‪ :١٢‬ﻧﺎﻇﺮ ﺷﯽ داﺧﻠﯽ‬

‫اﮔﺮ ﻓﻴﻠﺪ اﻧﺘﺨﺎب ﺷﺪﻩ از ﻧﻮع ‪ public‬ﻣﻴﺒﺎﺷﺪ ﺷﻤﺎ ﺑﻪ ﺝﺎی ﻓﺸﺎر دادن دﮐﻤﻪ ‪ Inspect‬ﻣﯽ ﺗﻮاﻧﻴﺪ ‪ ،‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﻓﻴﻠﺪ‬

‫‪ Address‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ و دﮐﻤﻪ ‪ Get‬را ﻓﺸﺎر دهﻴﺪ‪ .‬ﺑﺎ اﻳﻦ ﻋﻤﻞ ﺷﯽ اﻧﺘﺨﺎب ﺷﺪﻩ در ‪ object bench‬ﻣﺸﺨﺺ‬

‫ﻣﯽ ﺷﻮد‪.‬ﺷﻤﺎ در اﻧﺠﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﺎ ﻓﺮاﺧﻮاﻧﯽ ﻣﺘﺪهﺎی ﺷﯽ ﺑﻪ ﺁزﻣﺎﻳﺶ ﺧﻮد اداﻣﻪ دهﻴﺪ‪.‬‬

‫‪ (٢-۴‬ارﺳﺎل اﺷﻴﺎ ﺑﻪ ﻋﻨﻮان ﭘﺎراﻣﺘﺮ‬

‫ﺧﻼﺻﻪ‪ :‬ﻳﮏ ﺷﯽ را ﻣﯽ ﺗﻮان ﺑﻪ ﻋﻨﻮان ﭘﺎراﻣﺘﺮ ﺑﺮای ﻓﺮاﺧﻮاﻧﯽ ﻳﮏ ﻣﺘﺪ ارﺳﺎل ﮐﺮد ‪.‬ﺑﺮای اﻳﻨﮑﺎر ﺑﺮ روی ﺁﻳﮑﻮن ﺷﯽ ﮐﻠﻴﮏ ﮐﻨﻴﺪ‪.‬‬

‫‪١٨‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫اﺷﻴﺎ ﻣﯽ ﺗﻮاﻧﻨﺪ ﺑﻪ ﻋﻨﻮان ﭘﺎراﻣﺘﺮهﺎ ﺑﻪ ﻣﺘﺪهﺎی ﭘﺮوژﻩ هﺎی دﻳﮕﺮ ارﺳﺎل ﺷﻮﻧﺪ‪ .‬اﺝﺎزﻩ دهﻴﺪ ﺗﺎ ﺑﺎ ﻳﮏ ﻣﺜﺎل اﻳﻦ ﮐﺎر را اﻧﺠﺎم دهﻴﻢ‬

‫ﻳﮏ ﺷﯽ از ﮐﻼس ‪ Database‬اﻳﺠﺎد ﻧﻤﺎﻳﻴﺪ ) ﺷﻤﺎ ﺑﺎﻳﺪ ﺗﻮﺝﻪ ﻧﻤﺎﻳﻴﺪ ﮐﻪ ﮐﻼس ‪ Database‬ﺷﺎﻣﻞ ﻳﮏ ﺳﺎزﻧﺪﻩ ﻣﯽ ﺑﺎﺷﺪ ﮐﻪ ﭘﺎراﻣﺘﺮی‬

‫را درﻳﺎﻓﺖ ﻧﻤﯽ ﮐﻨﺪ ﺑﻨﺎﺑﺮاﻳﻦ ﺳﺎﺧﺖ ﺷﯽ ﺳﺮ راﺳﺖ ﻣﻴﺒﺎﺷﺪ ( ﺷﯽ ‪ Database‬ﻗﺎدر اﺳﺖ ﺗﺎ ﻟﻴﺴﺘﯽ از اﺷﺨﺎص را در ﺧﻮد ﻧﮕﻪ دارد‪.‬‬

‫اﻳﻦ ﺷﯽ ﺷﺎﻣﻞ اﻋﻤﺎﻟﯽ ﺑﺮای اﺿﺎﻓﻪ ﮐﺮدن اﺷﻴﺎ ﺷﺨﺺ و هﻤﭽﻨﻴﻦ ﻧﻤﺎﻳﺶ ﺷﺨﺺ هﺎی ﮐﻪ ﺗﺎ ﮐﻨﻮن ذﺧﻴﺮﻩ ﺷﺪﻩ اﻧﺪ ﻣﯽ ﺑﺎﺷﺪ‪.‬‬

‫) در ﺡﻘﻴﻘﺖ ﻧﺎم ‪ Database‬ﻳﮏ اﻏﺮاق ﮐﻮﭼﮏ ﻣﯽ ﺑﺎﺷﺪ !!! ( اﮔﺮ ﺷﻤﺎ در ﺡﺎل ﺡﺎﺿﺮ ﺷﯽ ‪ Staff‬و ﻳﺎ ‪ Student‬را در‬

‫‪ Object bench‬ﻧﺪارﻳﺪ‪ .‬ﻳﮑﯽ از اﻳﻦ دو ﺷﯽ را اﻳﺠﺎد ﻧﻤﺎﻳﻴﺪ‪ .‬ﺑﺮای اداﻣﻪ ﺷﻤﺎ ﻧﻴﺎز دارﻳﺪ ﺗﺎ ﺷﯽ ‪ Database‬و ﺷﯽ‬

‫‪Staff‬و ﻳﺎ ‪ Student‬در ﻳﮏ زﻣﺎن در ‪ object bench‬ﻗﺮار داﺷﺘﻪ ﺑﺎﺷﻨﺪ‪.‬ﺡﺎﻻ ﻣﺘﺪ ‪ addPerson‬را از ﺷﯽ ‪Database‬‬

‫ﻓﺮاﺧﻮاﻧﯽ ﻧﻤﺎﻳﻴﺪ اﻣﻀﺎ ﻣﺘﺪ ﺑﻪ ﺷﻤﺎ ﻣﯽ ﮔﻮﻳﺪ ﮐﻪ ﭘﺎراﻣﺘﺮ ﻧﻮع ‪ Person‬ﻣﻮرد اﻧﺘﻈﺎر ﻣﯽ ﺑﺎﺷﺪ‪ ) .‬ﻳﺎد ﺁوری‪ :‬ﮐﻼس ‪ Person‬از ﻧﻮع‬

‫اﻧﺘﺰاﻋﯽ )‪ (abstract‬ﻣﯽ ﺑﺎﺷﺪ ﺑﻨﺎﺑﺮاﻳﻦ اﻧﺠﺎ اﺷﻴﺎﻳﯽ ﮐﻪ ﻣﺴﺘﻘﻴﻤﺎ از ﻧﻮع ‪ person‬ﺑﺎﺷﻨﺪ ﻧﻴﺴﺖ ‪.‬اﻣﺎ ﻳﮑﯽ از‬

‫زﻳﺮ اﻧﻮاع ﺷﯽ ‪ Staff‬و ﻳﺎ ‪ Student‬ﻣﯽ ﺗﻮاﻧﺪ ﺝﺎﻳﮕﺰﻳﻦ ﻣﻨﺎﺳﺒﯽ ﺑﺮای ﺷﯽ ‪ Person‬ﺑﺎﺷﺪ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ اﻳﻦ ﻗﺎﻧﻮﻧﯽ اﺳﺖ ﮐﻪ ﻣﺎ‬

‫اﺷﻴﺎ ‪ Staff‬و ﻳﺎ ‪ Student‬را ﺑﻪ ﻋﻨﻮان ﭘﺎراﻣﺘﺮ ارﺳﺎل ﮐﻨﻴﻢ هﺮ ﺝﺎ ﮐﻪ ‪ Person‬ﻣﻮرد اﻧﺘﻈﺎر ﻣﯽ ﺑﺎﺷﺪ (‪.‬ﺑﺮای ارﺳﺎل ﺷﯽ‬

‫ﺑﻪ ﻋﻨﻮان ﭘﺎراﻣﺘﺮ ﺑﺮ روی ﺷﯽ ﻣﻮﺝﻮد در ‪ object bench‬ﮐﻠﻴﮏ ﮐﺮدﻩ و از ﭘﻨﺠﺮﻩ ﺑﺎز ﺷﺪﻩ ﻧﺎم ﮐﻼس ﻣﻮرد ﻧﻈﺮ را در ﻓﻴﻠﺪهﺎی‬

‫ﻣﺮﺑﻮﻃﻪ وارد ﻣﯽ ﻧﻤﺎﻳﻴﻢ‪ .‬دﮐﻤﻪ ‪ Ok‬را ﻓﺸﺎر دهﻴﺪ ﺗﺎ ﻓﺮاﺧﻮاﻧﯽ ﻣﺮﺑﻮﻃﻪ اﻧﺠﺎم ﭘﺬﻳﺮد‪.‬از ﺁﻧﺠﺎﻳﯽ ﮐﻪ اﻳﻦ ﻣﺘﺪ ﻣﻘﺪار ﺑﺎزﮔﺸﺘﯽ ﻧﺪارد ﻣﺎ‬

‫ﻧﻤﯽ ﺗﻮاﻧﻴﻢ ﻓﻮرا ﻧﺘﻴﺠﻪ را ﻣﺸﺎهﺪﻩ ﻧﻤﺎﻳﻴﻢ‪ .‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﻣﺘﺪ ‪ listAll‬را از ﺷﯽ ‪ Database‬ﻓﺮاﺧﻮاﻧﯽ ﻧﻤﺎﻳﻴﺪ ﺗﺎ ﺑﺮرﺳﯽ ﮐﻨﻴﺪ ﮐﻪ‬

‫اﻳﻦ ﻋﻤﻞ ﺑﺮای ﺷﯽ اﻧﺠﺎم ﺷﺪﻩ اﺳﺖ‪.‬دﺳﺘﻮر ‪ listAll‬اﻃﻼﻋﺎت ﺷﺨﺺ را در ﺧﺮوﺝﯽ اﺳﺘﺎﻧﺪارد ﭼﺎپ ﻣﯽ ﮐﻨﺪ ﺷﻤﺎ ﺑﺎﻳﺪ ﺗﻮﺝﻪ ﮐﻨﻴﺪ‬

‫ﮐﻪ ﺻﻔﺤﻪ ﻣﺘﻦ )( ﺑﻪ ﻃﻮر ﺧﻮدﮐﺎر ﺑﺎز ﺷﺪﻩ و ﻣﺘﻦ را ﻧﻤﺎﻳﺶ ﻣﯽ دهﺪ‪.‬‬

‫اﻳﻦ ﮐﺎر را ﺑﺎ وارد ﮐﺮدن اﺷﺨﺎص ﺑﻴﺸﺘﺮی در ‪ Database‬ﺗﻤﺮﻳﻦ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪١٩‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﻓﺼﻞ ‪ -۵‬اﻳﺠﺎد ﭘﺮوژﻩ ﺝﺪﻳﺪ‬

‫اﻳﻦ ﻓﺼﻞ ﺑﻪ ﺷﻤﺎ ﻳﮏ ﺁﻣﻮزش ﺳﺮﻳﻊ ﺑﺮای ﺗﻨﻈﻴﻢ ﻳﮏ ﭘﺮوژﻩ ﺝﺪﻳﺪ ﻣﯽ دهﺪ‪.‬‬

‫‪ (١-۵‬اﻳﺠﺎد ﭘﺮوژﻩ ﺝﺪﻳﺪ‬

‫ﺧﻼﺻﻪ‪ :‬ﺑﺮای اﻳﺠﺎد ﻳﮏ ﭘﺮوژﻩ از ﻣﻨﻮی ‪ Project‬ﮔﺰﻳﻨﻪ ‪ New….‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﺑﺮای اﻳﺠﺎد ﻳﮏ ﭘﺮوژﻩ ﺝﺪﻳﺪ از ﻣﻨﻮی ‪ Project‬ﮔﺰﻳﻨﻪ ‪ New….‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪ .‬ﭘﻨﺠﺮﻩ اﻧﺘﺨﺎب ﻓﺎﻳﻞ ﺑﺎز ﺷﺪﻩ و ﺑﻪ ﺷﻤﺎ اﺝﺎزﻩ‬

‫ﻣﯽ دهﺪ ﺗﺎ ﻧﺎم و ﻣﺤﻞ ذﺧﻴﺮﻩ ﺳﺎزی ﭘﺮوژﻩ ﺝﺪﻳﺪ را ﻣﺸﺨﺺ ﻧﻤﺎﻳﻴﺪ‪.‬اﻳﻦ ﮐﺎر را ﺡﺎﻻ اﻣﺘﺤﺎن ﻧﻤﺎﻳﻴﺪ‪.‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ هﺮ ﮔﻮﻧﻪ ﻧﺎﻣﯽ‬

‫ﺑﺮای ﭘﺮوژﻩ ﺗﺎن اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬ﺑﻌﺪ از اﻳﻨﮑﻪ ﺷﻤﺎ دﮐﻤﻪ ‪ Ok‬را ﻓﺸﺎر دادﻳﺪ‪ .‬در ﻣﺴﻴﺮ ﻣﻮرد ﻧﻈﺮ ﭘﻮﺷﻪ ای هﻤﻨﺎم ﺑﺎ ﻧﺎﻣﯽ ﮐﻪ ﺷﻤﺎ‬

‫اﻧﺘﺨﺎب ﮐﺮدﻩ اﻳﺪ اﻳﺠﺎد ﻣﯽ ﺷﻮد‪ .‬و ﭘﻨﺠﺮﻩ اﺻﻠﯽ ﺑﺮﻧﺎﻣﻪ ﺑﺼﻮرت ﺧﺎﻟﯽ ﻧﻤﺎﻳﺶ دادﻩ ﻣﯽ ﺷﻮد‪.‬‬

‫‪ (٢-۵‬اﻳﺠﺎد ﮐﻼﺳﻬﺎ‬

‫ﺧﻼﺻﻪ‪ :‬ﺑﺮای اﻳﺠﺎد ﻳﮏ ﮐﻼس ‪ ،‬دﮐﻤﻪ ‪ New Class‬را ﻓﺸﺎر ﻣﯽ دهﻴﻢ‪.‬و ﺑﺮای ﮐﻼس ﻳﮏ ﻧﺎم ﻗﺮار ﻣﯽ دهﻴﻢ‪.‬‬

‫ﺷﻤﺎ اﮐﻨﻮن ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﺎ ﮐﻠﻴﮏ ﮐﺮدن ﺑﺮ روی دﮐﻤﻪ ‪ New Class‬واﻗﻊ در ﻣﻨﻮی اﺑﺰار ﻳﮏ ﮐﻼس ﺝﺪﻳﺪ اﻳﺠﺎد ﮐﻨﻴﺪ‪.‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ‬

‫ﺳﻮال ﮐﻨﻴﺪ ﺑﺮای ﺗﻬﻴﻪ ﮐﺮدن ﻳﮏ ﻧﺎم ﺑﺮای ﮐﻼس‪ -‬اﻳﻦ ﻧﺎم ﻣﯽ ﺗﻮاﻧﺪ ﻳﮏ ﺷﻨﺎﺳﻪ ﻣﻌﺘﺒﺮ ﺝﺎوا ﺑﺎﺷﺪ‪.‬‬

‫ﺷﻤﺎ هﻤﭽﻨﻴﻦ ﻣﯽ ﺗﻮاﻧﻴﺪ ‪۴‬ﻧﻮع ﮐﻼس را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ ‪standard ، applet ، abstract ، interface :‬‬

‫اﻳﻦ اﻧﺘﺨﺎب ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﺪ ﮐﻪ ﺑﺪﻧﻪ اوﻟﻴﻪ ﮐﺪهﺎی ﮐﻪ ﺑﺮاﻳﺘﺎن ﺗﻮﻟﻴﺪ ﻣﯽ ﺷﻮد ﭼﮕﻮﻧﻪ ﺑﺎﺷﺪ‪ .‬ﺷﻤﺎ ﺑﻌﺪا ﻣﯽ ﺗﻮاﻧﻴﺪ ﻧﻮع ﮐﻼس را ﺑﺎ‬

‫ﺗﻐﻴﻴﺮ در ﮐﺪهﺎی ان وﻳﺮاﻳﺶ ﮐﻨﻴﺪ )ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ‪ ،‬ﺑﺎ اﺿﺎﻓﻪ ﮐﺮدن ﮐﻠﻤﻪ ﮐﻠﻴﺪی ‪ abstract‬در ﺑﻴﻦ ﮐﺪهﺎ ( ‪.‬‬

‫ﺑﻌﺪ از اﻳﻦ ﮐﻪ ﺷﻤﺎ ﮐﻼس را اﻳﺠﺎد ﻧﻤﻮدﻳﺪ‪.‬ﮐﻼس ﺑﻪ وﺳﻴﻠﻪ ﻳﮏ ﺁﻳﮑﻮن در ﺻﻔﺤﻪ ﻧﻤﺎﻳﺶ ‪ ،‬ﻧﻤﺎﻳﺶ دادﻩ ﻣﯽ ﺷﻮد‪ .‬اﮔﺮ ﮐﻼس ﺷﻤﺎ از‬

‫ﻧﻮع اﺳﺘﺎﻧﺪارد ﻧﻴﺴﺖ )‪ ( abstract,applet,interface‬اﻳﻦ ﻣﻮﺿﻮع در ﺁﻳﮑﻮن ﮐﻼس ﻧﻤﺎﻳﺶ دادﻩ ﺧﻮاهﺪ ﺷﺪ‪.‬‬

‫هﻨﮕﺎﻣﯽ ﮐﻪ وﻳﺮاﻳﺸﮕﺮ را ﺑﺮای ﮐﻼس ﺝﺪﻳﺪ ﺑﺎز ﻣﯽ ﮐﻨﻴﺪ ﺧﻮاهﻴﺪ دﻳﺪ ﮐﻪ ﮐﺪهﺎی اوﻟﻴﻪ ﺑﺮای اﻳﻦ ﮐﻼس اﻳﺠﺎد ﺷﺪﻩ اﺳﺖ‪.‬‬

‫اﻳﻦ ﻣﻮﺿﻮع ‪ ،‬ﮐﺎر ﺷﻤﺎ ﺑﺮای ﺷﺮوع را ﺁﺳﺎن ﺗﺮ ﺧﻮاهﺪ ﮐﺮد‪ .‬ﮐﺪهﺎی ﭘﻴﺶ ﻓﺮض از ﻟﺤﺎظ ﻧﺤﻮی ﺻﺤﻴﺢ ﻣﯽ ﺑﺎﺷﺪ‪.‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ‬

‫ﺁﻧﺮا ﮐﺎﻣﭙﺎﻳﻞ ﻧﻤﺎﻳﺪ ) اﻣﺎ اﻳﻦ ﮐﻼس هﺎ ﮐﺎری اﻧﺠﺎم ﻧﻤﯽ دهﻨﺪ ( ‪.‬ﺳﻌﯽ ﮐﻨﻴﺪ ﭼﻨﺪ ﮐﻼس اﻳﺠﺎد ﮐﻨﻴﺪ و ﺁﻧﻬﺎ را ﮐﺎﻣﭙﺎﻳﻞ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ (٣-۵‬اﻳﺠﺎد واﺑﺴﺘﮕﯽ هﺎ‬

‫ﺧﻼﺻﻪ‪ :‬ﺑﺮای اﻳﺠﺎد ﻳﮏ ﭘﻴﮑﺎن ‪ ،‬ﺑﺮ روی دﮐﻤﻪ ﭘﻴﮑﺎن ﮐﻠﻴﮏ ﮐﺮدﻩ و ﺁﻧﺮا ﺑﺮ روی ﺻﻔﺤﻪ ﺗﺮﺳﻴﻢ درگ ﻧﻤﺎﻳﺪ‪ .‬و ﻳﺎ ﻓﻘﻂ در‬

‫وﻳﺮاﻳﺸﮕﺮ ﮐﺪ ﻣﺮﺑﻮﻃﻪ را ﺗﺎﻳﭗ ﻧﻤﺎﻳﺪ‪.‬‬

‫در ﺻﻔﺤﻪ ﺗﺮﺳﻴﻢ ﮐﻼس هﺎ ‪ ،‬ﻋﻼﻣﺖ ﭘﻴﮑﺎن رواﺑﻂ ﻣﺎ ﺑﻴﻦ ﮐﻼس هﺎ را ﻣﺸﺨﺺ ﻣﯽ ﻧﻤﺎﻳﺪ‪.‬‬

‫رواﺑﻂ ارث ﺑﺮی ) ‪ ( Implement ، extend‬ﺑﻮﺳﻴﻠﻪ ﭘﻴﮑﺎﻧﯽ ﺑﺎ ﺳﺮ ﺗﻮ ﺧﺎﻟﯽ )ﺳﺮ ﺑﺴﺘﻪ( ﻣﺸﺨﺺ ﻣﯽ ﺷﻮد‪ .‬رواﺑﻂ "‪"uses‬‬

‫ﺑﺎ ﻳﮏ ﭘﻴﮑﺎن ﻧﻘﻄﻪ ﭼﻴﻦ ﺑﺎ ﺳﺮ ﺑﺎز ﻣﺸﺨﺺ ﻣﯽ ﺷﻮد‪.‬‬

‫ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ رواﺑﻂ را ﻣﺴﺘﻘﻴﻤﺎ در ﺻﻔﺤﻪ ﺗﺮﺳﻴﻢ و ﻳﺎ ﺑﻮﺳﻴﻠﻪ ﻧﻮﺷﺘﻦ ﮐﺪ در وﻳﺮاﻳﺸﮕﺮ ﻣﺸﺨﺺ ﻧﻤﺎﻳﺪ‪ .‬ﺷﻤﺎ اﮔﺮ واﺑﺴﺘﮕﯽ هﺎ‬

‫را ﺑﻮﺳﻴﻠﻪ ﮔﺮاﻓﻴﮑﯽ اﻳﺠﺎد ﮐﻨﻴﺪ‪ .‬ﮐﺪهﺎ ﺑﺼﻮرت ﺧﻮدﮐﺎر ﺑﺮوز رﺳﺎﻧﯽ ﻣﯽ ﺷﻮﻧﺪ و اﮔﺮ ﺷﻤﺎ واﺑﺴﺘﮕﯽ هﺎ را ﺑﻮﺳﻴﻠﻪ ﮐﺪهﺎ اﻳﺠﺎد ﮐﻨﻴﺪ‪.‬‬

‫ﺑﺨﺶ ﮔﺮاﻓﻴﮑﯽ ﺑﻪ ﺻﻮرت ﺧﻮدﮐﺎر ﺑﺮوز رﺳﺎﻧﯽ ﻣﯽ ﺷﻮد‪.‬‬

‫‪٢٠‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﺑﺮای اﺿﺎﻓﻪ ﮐﺮدن ﻳﮏ ﭘﻴﮑﺎن ﺑﺼﻮرت ﮔﺮاﻓﻴﮑﯽ ‪ ،‬ﺑﺮ روی دﮐﻤﻪ ﭘﻴﮑﺎن ﻣﻘﺘﻀﯽ)ﭘﻴﮑﺎن ﺳﺮ ﺑﺴﺘﻪ ﺑﺮای رواﺑﻂ ارث ﺑﺮی و ﭘﻴﮑﺎن‬

‫ﻧﻘﻄﻪ ﺝﻴﻦ ﺑﺮای ‪ (uses‬ﮐﻠﻴﮏ ﮐﺮدﻩ و ﺁﻧﺮا از ﺑﻴﻦ دو ﮐﻼس ﻣﺮﺑﻮﻃﻪ درگ ﻣﯽ ﻧﻤﺎﻳﻴﻢ‪.‬‬

‫ﺑﺎ اﺿﺎﻓﻪ ﮐﺮدن ﻳﮏ ﭘﻴﮑﺎن ﻣﺮﺑﻮط ﺑﻪ ارث ﺑﺮی ﮐﺪ ﺗﻮﺿﻴﺤﯽ ﻣﺮﺑﻮط ﺑﻪ ‪ extend‬و ﻳﺎ ‪ implement‬ﺑﻪ ﮐﺪهﺎی ﮐﻼس ﺗﺎن اﺿﺎﻓﻪ‬

‫ﻣﯽ ﺷﻮد‪ ) .‬اﻳﻦ ﺑﺴﺘﮕﯽ ﺑﻪ ﻣﻘﺼﺪ دارد ﮐﻪ از ﻧﻮع ﮐﻼس ﺑﺎﺷﺪ و ﻳﺎ ‪.( interface‬‬

‫اﺿﺎﻓﻪ ﮐﺮدن ﭘﻴﮑﺎن ‪ uses‬ﺑﻼﻓﺎﺻﻠﻪ ﺗﻐﻴﻴﺮی در ﮐﺪهﺎ اﻳﺠﺎد ﻧﻤﯽ ﮐﻨﺪ )ﻣﮕﺮ اﻳﻨﮑﻪ ﻣﻘﺼﺪ ﮐﻼﺳﯽ در ﻳﮏ ﭘﮑﻴﺞ دﻳﮕﺮ ﺑﺎﺷﺪ‪ ،‬در اﻳﻦ‬

‫ﻧﻤﻮﻧﻪ دﺳﺘﻮر ‪ Import‬ﺗﻮﻟﻴﺪ ﻣﯽ ﺷﻮد‪ .‬اﻣﺎ ﻣﺎ ﻓﻌﻼ ﺁﻧﺮا در ﺑﻴﻦ ﻣﺜﺎل هﺎﻳﻤﺎن ﻧﺪارﻳﻢ (‪.‬اﺳﺘﻔﺎدﻩ از ﭘﻴﮑﺎن ‪ uses‬ﺑﺮای ﮐﻼﺳﯽ ﮐﻪ‬

‫ﻣﻮرد اﺳﺘﻔﺎدﻩ ﻗﺮار ﻧﮕﺮﻓﺘﻪ در ﺡﻴﻦ ﮐﺎﻣﭙﺎﻳﻞ اﺧﻄﺎری اﻳﺠﺎد ﻣﯽ ﮐﻨﺪ ﻣﺒﻨﯽ ﺑﺮ اﻳﻦ ﮐﻪ ﺷﻤﺎ از ارﺗﺒﺎط ‪ uses‬ﺑﻴﻦ ﮐﻼس هﺎ ﺗﻌﺮﻳﻒ ﺷﺪﻩ‬

‫وﻟﯽ ﮐﻼس ﻣﻮرد اﺳﺘﻔﺎدﻩ ﻗﺮار ﻧﮕﺮﻓﺘﻪ اﺳﺖ‪.‬‬

‫اﺿﺎﻓﻪ ﮐﺮدن ﭘﻴﮑﺎن هﺎ ﺑﺮای ارﺗﺒﺎط در ﺡﺎﻟﺖ ﻣﺘﻨﯽ ﺑﺴﻴﺎر ﺳﺎدﻩ ﻣﯽ ﺑﺎﺷﺪ‪ :‬ﺷﻤﺎ ﮐﺎﻓﯽ اﺳﺖ ﮐﻪ ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮﻟﯽ ﮐﺪهﺎ را ﺗﺎﻳﭗ‬

‫ﻧﻤﺎﻳﺪ‪.‬هﻨﮕﺎﻣﯽ ﮐﻪ ﮐﻼس را ذﺧﻴﺮﻩ ﮐﻨﻴﺪ‪.‬ﺻﻔﺤﻪ ﺗﺮﺳﻴﻢ ﺑﺮوز رﺳﺎﻧﯽ ﻣﯽ ﺷﻮد)ﻳﺎدﺁوری ‪ :‬ﺑﺎ ﺑﺴﺘﻦ وﻳﺮاﻳﺸﮕﺮ ‪ ،‬ﮐﻼس ﺑﻪ ﺻﻮرت‬

‫ﺧﻮدﮐﺎر ذﺧﻴﺮﻩ ﻣﯽ ﺷﻮد (‪.‬‬

‫‪ (۴-۵‬ﺡﺬف ﮐﺮدن ﻋﻨﺎﺻﺮ‬

‫ﺧﻼﺻﻪ ‪ :‬ﺑﺮای ﺡﺬف ﻳﮏ ﮐﻼس و ﻳﺎ ﻳﮏ ﭘﻴﮑﺎن ‪ ،‬از ﻣﻨﻮی ﺑﺎز ﺷﻮﻧﺪﻩ ﮔﺰﻳﻨﻪ ‪ remove‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﺪ‪.‬‬

‫ﺑﺮای ﺡﺬف ﻳﮏ ﮐﻼس از ﺻﻔﺤﻪ ﺗﺮﺳﻴﻢ ‪ ،‬ﮐﻼس را اﻧﺘﺨﺎب ﻧﻤﺎﻳﺪ و از ﻣﻨﻮی ‪ ، Edit‬ﮔﺰﻳﻨﻪ ‪ remove‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﺪ‪ .‬ﺷﻤﺎ هﻤﭽﻨﻴﻦ‬

‫ﻣﯽ ﺗﻮاﻧﻴﺪ از ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ ﮐﻼس ﮔﺰﻳﻨﻪ ‪ remove‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪ .‬هﺮ دو ﻣﻮرد ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻩ ﺑﺮای ﮐﻼس ﺑﺮای ﻳﮏ ﭘﻴﮑﺎن‬

‫ﻧﻴﺰ ﮐﺎرﺑﺮد دارد‪.‬‬

‫‪٢١‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﻓﺼﻞ ‪ – ۶‬اﺳﺘﻔﺎدﻩ از ‪code pad‬‬

‫ﺑﺎاﺳﺘﻔﺎدﻩ از ‪ Code Pad‬ﻣﺤﻴﻂ ‪ BlueJ‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﺎ ﺳﺮﻋﺖ و ﺑﻪ ﺳﺎدﮔﯽ ﺑﻪ ﺁزﻣﺎﻳﺶ دﺳﺘﻮرات و ﻋﺒﺎرات ﻳﮏ ﺗﮑﻪ ﮐﺪ ﺝﺎوا‬

‫ﺑﭙﺮدازﻳﺪ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ ‪ ،‬ﮐﺪ ﭘﺪ ﻣﯽ ﺗﻮاﻧﺪ ﺑﺮای ﺑﺮرﺳﯽ دﺳﺘﻮرات و ﻗﻮاﻋﺪ زﺑﺎن ﺝﺎوا ﻣﻮرد اﺳﺘﻔﺎدﻩ ﻗﺮار ﺑﮕﻴﺮد‪.‬‬

‫‪ (١-۶‬ﻧﻤﺎﻳﺶ ﮐﺪ ﭘﺪ‬

‫ﺧﻼﺻﻪ ‪ :‬ﺑﺮای ﻧﻤﺎﻳﺶ ﮐﺪ ﭘﺪ از ﻣﻨﻮی ‪ View‬ﮔﺰﻳﻨﻪ ‪ Show Code Pad‬را ﻓﺸﺎر دهﻴﺪ‪.‬‬

‫ﮐﺪ ﭘﺪ ﺑﺼﻮرت ﭘﻴﺶ رض ﻧﻤﺎﻳﺶ دادﻩ ﻧﻤﯽ ﺷﻮد‪.‬ﺑﺮای دﻳﺪن ﺁن از ﻣﻨﻮی ‪ View‬ﮔﺰﻳﻨﻪ ‪ Show Code Pad‬را ﻓﺸﺎر دهﻴﺪ‪.‬‬

‫ﭘﻨﺠﺮﻩ اﺻﻠﯽ ﺡﺎﻻ ﺷﺎﻣﻞ ﮐﺪ ﭘﺪ در ﮔﻮﺷﻪ ﺳﻤﺖ راﺳﺖ و ﺑﻌﺪ از ‪ object bench‬ﺧﻮد ﻣﯽ ﺑﺎﺷﺪ ) ﺷﮑﻞ ‪( ١٣‬‬

‫ﺷﮑﻞ ‪ : ١٣‬ﭘﺘﺠﺮﻩ اﺻﻠﯽ ﺑﻪ هﻤﺮاﻩ ﮐﺪ ﭘﺪ‬

‫اﻧﺪازﻩ ﭘﻨﺠﺮﻩ ﮐﺪ ﭘﺪ و هﻤﭽﻨﻴﻦ ‪ Object Bench‬ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺧﻄﻮط ﻋﻤﻮدی و اﻓﻘﯽ ﻗﺎﺑﻞ ﺗﻐﻴﻴﺮ ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﮐﺪ ﭘﺪ ﺡﺎﻻ ﻣﯽ ﺗﻮاﻧﺪ‬

‫ﺑﺮای ورود دﺳﺘﻮرات و ﻋﺒﺎرات ﻣﻮرد اﺳﺘﻔﺎدﻩ ﻗﺮار ﺑﮕﻴﺮد‪ .‬ب اﻓﺸﺎر دادن دﮐﻤﻪ ‪ Enter‬هﺮ ﺧﻂ اﺝﺮا ﺷﺪﻩ و ﻧﺘﻴﺠﻪ ان ﻧﻤﺎﻳﺶ‬

‫دادﻩ ﻣﯽ ﺷﻮد‪.‬‬

‫‪ (٢-۶‬اﺝﺮای ﻳﮏ ﻋﺒﺎرت ﺳﺎدﻩ‬

‫ﺧﻼﺻﻪ ‪ :‬ﺑﺮای اﺝﺮای ﻳﮏ ﻋﺒﺎرت ﺝﺎوا ؛ ﺗﻨﻬﺎ ﮐﺎﻓﻴﺴﺖ ﮐﻪ اﻧﺮا در ﮐﺪ ﭘﺪ ﺗﺎﻳﭗ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﮐﺪ ﭘﺪ ﻣﯽ ﺗﻮاﻧﺪ ﺑﺮای اﺝﺮا و اﻣﺘﺤﺎن ﮐﺮدن ﻋﺒﺎرات ﺳﺎدﻩ ﺑﮑﺎر ﺑﺮود‪ .‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ‪ ،‬ﻋﺒﺎرات زﻳﺮ را اﻣﺘﺤﺎن ﻧﻤﺎﻳﻴﺪ‪:‬‬

‫‪٢٢‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫‪4 + 45‬‬
‫)(‪"hello".length‬‬
‫)‪Math.max(33, 4‬‬
‫‪(int) 33.7‬‬
‫)"‪javax.swing.JOptionPane.showInputDialog(null, "Name:‬‬

‫ﻋﺒﺎرات ﻣﯽ ﺗﻮاﻧﻨﺪ ﺑﻪ ﻣﻘﺪارهﺎی اﺳﺘﺎﻧﺪارد ﺝﺎوا ﻣﺮاﺝﻌﻪ ﮐﻨﻨﺪ و اﺷﻴﺎ ﻣﯽ ﺗﻮاﻧﻨﺪ ﺑﻪ ﮐﻼس هﺎی ﻣﻮﺝﻮد در ﭘﺮوژﻩ ﻣﺮاﺝﻌﻪ داﺷﺘﻪ‬

‫ﺑﺎﺷﻨﺪ‪.‬ﮐﺪ ﭘﺪ ﻧﺘﺎﻳﺞ را ﻧﻤﺎﻳﺶ ﺧﻮاهﺪ داد و اﮔﺮ ﻋﺒﺎرت ﺷﻤﺎ اﺷﺘﺒﺎﻩ ﺑﺎﺷﺪ ﭘﻴﺎم ﺧﻄﺎﻳﯽ ﻧﺸﺎن ﺧﻮاهﺪ داد‪.‬‬

‫ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ از اﺷﻴﺎﻳﯽ ﮐﻪ در ‪ object bench‬ﻗﺮار دارﻧﺪ ﻧﻴﺰ اﺳﺘﻔﺎدﻩ ﮐﻨﻴﺪ‪.‬ﺑﺮای ﻧﻤﻮﻧﻪ ‪ :‬ﻳﮏ ﺷﯽ از ﮐﻼس ‪ student‬در‬

‫‪ Object bench‬ﻗﺮار دهﻴﺪ )ﺑﺎاﺳﺘﻔﺎدﻩ از ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ ﮐﻼس ﮐﻪ ﻗﺒﻼ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪ ( ‪.‬ﻧﺎم ﺷﯽ ‪ student1‬هﺴﺖ‪.‬‬

‫ﺡﺎﻻ ﺷﻤﺎ در ﻣﺤﻴﻂ ﮐﺪ ﭘﺪ ﺗﺎﻳﭗ ﻧﻤﺎﻳﻴﺪ‪:‬‬

‫)(‪student1.getName‬‬

‫ﺑﻪ ﻃﻮر ﻣﺸﺎﺑﻪ ‪ ،‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﻪ ﺗﻤﺎم ﻣﺘﺪهﺎی در دﺳﺘﺮس ﮐﻼس هﺎی ﭘﺮوژﻩ ﺗﺎن دﺳﺘﺮﺳﯽ ﭘﻴﺪا ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ (٣-۶‬درﻳﺎﻓﺖ اﺷﻴﺎ‬

‫ﺧﻼﺻﻪ ‪ :‬ﺑﺮای اﻧﺘﻘﺎل اﺷﺒﺎ از ﮐﺪ ﭘﺪ ﺑﻪ ﻣﺤﻴﻂ ‪ ، object bench‬ﺁﻳﮑﻮن ﮐﻮﭼﮏ ﺷﯽ را ﺑﻪ ﺁن ﻣﺤﻴﻂ درگ ﮐﻨﻴﺪ‪.‬‬

‫ﻧﺘﻴﺠﻪ ﺑﻌﻀﯽ از ﻋﺒﺎرات )دﺳﺘﻮرات( ﻳﮏ ﺷﯽ ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﮐﻪ ﺷﺎﻣﻞ ﻣﻘﺪارهﺎی ﺳﺎدﻩ ای هﺴﺘﻨﺪ‪ .‬در اﻳﻦ ﻣﺜﺎل ‪ ،‬ﻧﺘﻴﺠﻪ‬

‫ﻧﻤﺎﻳﺶ دادﻩ ﺷﺪﻩ >‪ <object reference‬ﻳﮏ ﻧﻮع ﺷﯽ ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﮐﻪ ﺑﻪ وﺳﻴﻠﻪ ﺁﻳﮑﻮﻧﯽ ﮐﻪ در ﮐﻨﺎر ﺁن ﺗﺮﺳﻴﻢ ﺷﺪﻩ در ﺧﻂ ﺑﻌﺪ از‬

‫ﻋﺒﺎرت ﻣﺸﺨﺺ ﻣﯽ ﺑﺎﺷﺪ‪.‬‬

‫ﺷﮑﻞ ‪ :١۴‬ﻧﺘﻴﺠﻪ ﻳﮏ ﻋﺒﺎرت در ﮐﺪﭘﺪ ‪ ،‬ﻳﮏ ﺷﯽ ﻣﯽ ﺑﺎﺷﺪ‬

‫اﮔﺮ ﻧﺘﻴﺠﻪ ﻳﮏ رﺷﺘﻪ ﺑﺎﺷﺪ ﺷﻤﺎ ﻣﻘﺪار اﻧﺮا ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﺒﻴﻨﺪ‪ .‬در ﺿﻤﻦ ﺑﺎز هﻢ ﻳﮏ اﻳﮑﻮن در ﮐﻨﺎر ان ﺗﺮﺳﻴﻢ ﺷﺪﻩ اﺳﺖ‬

‫) زﻳﺮا رﺷﺘﻪ هﺎ ﻧﻴﺰ ﺷﯽ هﺴﺘﻨﺪ ( ‪.‬ﺗﻌﺪادی از دﺳﺘﻮراﺗﯽ ﮐﻪ ﺷﻤﺎ ﺑﺎ اﺳﺘﻔﺎدﻩ از ان هﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺷﯽ اﻳﺠﺎد ﻧﻤﺎﻳﻴﺪ‪:‬‬

‫)(‪new Student‬‬
‫)‪"marmelade".substring(3,8‬‬
‫)(‪new java.util.Random‬‬
‫"‪"hello" + "world‬‬

‫ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺁﻳﮑﻮن ﮐﻮﭼﮏ ﺷﯽ را درون ‪ Object Bench‬درگ ﮐﻨﻴﺪ ﺗﺎ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺷﯽ ﻧﺘﻴﺠﻪ ﺷﺪﻩ ﮐﺎر را اداﻣﻪ دهﻴﺪ‪.‬‬

‫‪٢٣‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫)ﺷﮑﻞ ‪( ١۵‬‬

‫ﺷﮑﻞ ‪ : ١۵‬درگ ﮐﺮدن ﺷﯽ درون ‪object bench‬‬

‫‪ ( ۴-۶‬ﺑﺮرﺳﯽ اﺷﻴﺎ‬

‫ﺧﻼﺻﻪ ‪ :‬ﺑﺮای ﺑﺮرﺳﯽ ﻧﺘﻴﺠﻪ اﺷﻴﺎ در ﮐﺪ ﭘﺪ ﺑﺮ روی ﺁﻳﮑﻮن ﮐﻮﭼﮏ ﺷﯽ دوﺑﺎر ﮐﻠﻴﮏ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫اﮔﺮ ﺷﻤﺎ ﻣﯽ ﺧﻮاهﻴﺪ ﻳﮏ ﺷﯽ را ﮐﻪ ﺑﻪ ﻋﻨﻮان ﻧﺘﻴﺠﻪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﺪﻩ را از ﻃﺮﻳﻖ ﮐﺪ ﭘﺪ ﺑﺮرﺳﯽ ﻧﻤﺎﻳﺪ ﺑﺪون اﻳﻨﮑﻪ ﺷﯽ را در‬

‫‪ Object bench‬ﻗﺮار دهﻴﺪ‪ .‬ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﺮ روی ﺁﻳﮑﻮن ﺷﯽ دوﺑﺎر ﮐﻠﻴﮏ ﮐﺮدﻩ ﺗﺎ ﻧﺎﻇﺮ ﺷﯽ ﺑﺎز ﺷﻮد‪.‬‬

‫‪ (۵-۶‬اﺝﺮا ﮐﺮدن دﺳﺘﻮرات‬

‫ﺧﻼﺻﻪ ‪ :‬دﺳﺘﻮراﺗﯽ ﮐﻪ در درون ﮐﺪ ﭘﺪ ﺗﺎﻳﭗ ﻣﯽ ﺷﻮﻧﺪ‪ .‬اﺝﺮا ﻣﯽ ﮔﺮدﻧﺪ‬

‫ﺷﻤﺎ هﻤﭽﻨﻴﻦ ﻣﯽ ﺗﻮاﻧﻴﺪ از ﮐﺪ ﭘﺪ ﺑﺮای اﺝﺮا ﮐﺮدن دﺳﺘﻮرات اﺳﺘﻔﺎدﻩ ﻧﻤﺎﻳﻴﺪ ) اﻳﻦ ﻣﻮﺿﻮع ﺑﺮای دﺳﺘﻮرات ﺝﺎوای ﻣﯽ ﺑﺎﺷﺪ ﮐﻪ‬

‫ﻣﻘﺪاری را ﺑﺮ ﻧﻤﯽ ﮔﺮداﻧﺪ ( ‪.‬اﻳﻦ ﮐﺎر را اﻧﺠﺎم دهﻴﺪ‪.‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ‪:‬‬

‫;)"‪System.out.println("Gurkensalat‬‬
‫;))‪System.out.println(new java.util.Random().nextInt(10‬‬

‫دﺳﺘﻮراﺗﯽ ﮐﻪ اﺝﺮا ﻣﯽ ﺷﻮﻧﺪ ﺑﻪ درﺳﺘﯽ اﺝﺮا ﻣﯽ ﺷﻮﻧﺪ ﺧﻮاﻩ در اﻧﺘﻬﺎی اﻧﻬﺎ ﺳﻴﻤﯽ ﮐﺎﻟﻮن ﺑﺎﺷﺪ ﺑﺎ ﻧﻪ‪.‬‬

‫‪ (۶-۶‬دﺳﺘﻮرات ﭼﻨﺪ ﺧﻄﯽ و دﺳﺘﻮرات ﺗﻮاﻟﯽ دار‬

‫ﺧﻼﺻﻪ ‪ :‬ﺑﺮای دﺳﺘﻮرات ﭼﻨﺪ ﺧﻄﯽ در اﻧﺘﻬﺎی هﺮ ﺧﻂ از ‪ Enter-shift‬اﺳﺘﻔﺎدﻩ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺗﻮاﻟﯽ از دﺳﺘﻮرات و ﻳﺎ دﺳﺘﻮرات ﭼﻨﺪ ﺧﻄﯽ را ﺑﺎ اﺳﺘﻔﺎدﻩ از ‪ Enter-shift‬در اﻧﺘﻬﺎی هﺮ ﺧﻂ اﻳﺠﺎد ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﺑﺎ ﻓﺸﺮدن ‪ enter-shift‬ﻧﺸﺎﻧﮕﺮ ﻣﻮس ﺑﻪ اﺑﺘﺪای ﺧﻂ ﺑﻌﺪی ﻣﻨﺘﻘﻞ ﻣﯽ ﺷﻮد ﺑﺪون اﻳﻦ ﮐﻪ ﺧﻂ ﻗﺒﻠﯽ اﺝﺮا ﺷﻮد ‪.‬در اﻧﺘﻬﺎی ﺧﻂ اﺧﺮ‬

‫‪ Enter‬را ﻓﺸﺎر دهﻴﺪ ﺗﺎ ﮐﻞ ﺧﻂ هﺎی ﺑﺎ هﻢ اﺝﺮا ﺷﻮﻧﺪ‪ .‬ﺑﺮای ﻧﻤﻮﻧﻪ ﮐﺪ زﻳﺮ را اﺝﺮا ﻧﻤﺎﻳﻴﺪ‪:‬‬

‫{ )‪for (int i=0; i<5; i++‬‬

‫;)‪System.out.println("number: " + i‬‬
‫}‬

‫‪ (٧-۶‬ﮐﺎر ﺑﺎ ﻣﺘﻐﻴﻴﺮهﺎ‬

‫‪٢۴‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﺧﻼﺻﻪ ‪ :‬ﻣﺘﻐﻴﻴﺮهﺎی ﻣﺤﻠﯽ را ﻣﯽ ﺗﻮان در دﺳﺘﻮرات ﻳﮏ ﺧﻄﯽ و ﻳﺎ ﭼﻨﺪ ﺧﻄﯽ ﻣﻮرد اﺳﺘﻔﺎدﻩ ﻗﺮار داد‪ .‬اﺳﺎﻣﯽ اﺷﻴﺎ ﻣﻮﺝﻮد‬

‫در ‪ object bench‬در ﻓﻴﻠﺪهﺎی ﺷﯽ ﺑﻪ ﮐﺎر ﮔﺮﻓﺘﻪ ﻣﯽ ﺷﻮﻧﺪ‪.‬‬

‫ﻣﺘﻐﻴﻴﺮهﺎ )ﻣﺤﻠﯽ و ﻳﺎ ﺷﯽ ( ﻣﯽ ﺗﻮاﻧﻨﺪ ﺑﻪ ﺻﻮرت ﻣﺤﺪود در ﮐﺪ ﭘﺪ ﻣﻮرد اﺳﺘﻔﺎدﻩ ﻗﺮار ﺑﮕﻴﺮﻧﺪ‪ .‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﻣﺘﻐﻴﻴﺮهﺎی ﻣﺤﻠﯽ‬

‫را در ﮐﺪ ﭘﺪ ﺗﻌﺮﻳﻒ ﻧﻤﺎﻳﻴﺪ‪ -‬اﻣﺎ اﻳﻦ ﻓﻘﻂ ﺑﺮای ﺑﺨﺸﯽ از دﺳﺘﻮرات ﺗﻮاﻟﯽ ﭼﻨﺪ ﺧﻄﯽ ﻣﻨﺎﺳﺐ ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﺑﺮای ﻣﺜﺎل ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ‬

‫ﺑﻠﻮک دﺳﺘﻮرات زﻳﺮ را وارد ﻧﻤﺎﻳﻴﺪ و اﻳﻦ دﺳﺘﻮرات درﺳﺖ ﮐﺎر ﮐﻨﻨﺪ ‪:‬‬

‫;‪int sum‬‬
‫;‪sum = 0‬‬
‫{ )‪for (int i=0; i<100; i++‬‬
‫;‪sum += i‬‬
‫}‬
‫;)‪System.out.println("The sum is: " + sum‬‬

‫ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﺎ درگ ﮐﺮدن ﺷﯽ از ﮐﺪ ﭘﺪ ﺑﻪ ‪ object bench‬ﻳﮏ ﻓﻴﻠﺪ ﺷﯽ ﺝﺪﻳﺪ اﻳﺠﺎد ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ (٨-۶‬ﺗﺎرﻳﺨﭽﻪ دﺳﺘﻮرات )‪(command history‬‬

‫ﺧﻼﺻﻪ‪ :‬ﺑﺎ اﺳﺘﻔﺎدﻩ از دﮐﻤﻪ هﺎی ﺑﺎﻻ و ﭘﺎﻳﻴﻦ روی ﺻﻔﺤﻪ ﮐﻠﻴﺪ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﻪ ﺗﺎرﻳﺨﭽﻪ ورودی هﺎ در ﮐﺪ ﭘﺪ دﺳﺖ ﭘﻴﺪا ﮐﻨﻴﺪ‪.‬‬

‫ﮐﺪ ﭘﺪ ﺳﺎﺑﻘﻪ ای از ورودی هﺎی ﻗﺒﻠﯽ ﺷﻤﺎ را ﻧﮕﻪ داری ﻣﯽ ﮐﻨﺪ‪ .‬ﺷﻤﺎ ﺑﺎ اﺳﺘﻔﺎدﻩ از دﮐﻤﻪ هﺎی ﺑﺎﻻ و ﭘﺎﻳﻴﻦ روی ﺻﻔﺤﻪ ﮐﻠﻴﺪ‬

‫ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﻪ ﺧﻂ هﺎی ورودی ﻗﺒﻠﯽ دﺳﺖ ﭘﻴﺪا ﮐﻨﻴﺪ و ﻣﯽ ﺗﻮاﻧﻴﺪ ﻗﺒﻞ از اﺝﺮا ﻣﺠﺪد ﺁﻧﻬﺎ ﺑﻪ وﻳﺮاﻳﺶ ﺁﻧﻬﺎ ﺑﭙﺮدازﻳﺪ‪.‬‬

‫ﻓﺼﻞ‪ – ٧‬رﻓﻊ ﺧﻄﺎ‬

‫‪٢۵‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫اﻳﻦ ﺑﺨﺶ ﻣﻘﺪﻣﻪ ای اﺳﺖ ﺑﺮ ﻣﻬﻤﺘﺮﻳﻦ اﻋﻤﺎل ﻣﺮﺑﻮط ﺑﻪ رﻓﻊ ﺧﻄﺎ در ‪. BlueJ‬‬

‫ﺑﺴﻴﺎری از اﺳﺎﺗﻴﺪ ﻋﻠﻮم ﮐﺎﻣﭙﻴﻮﺗﺮ ﻣﻌﺘﻘﺪﻧﺪ ﮐﻪ اﺳﺘﻔﺎدﻩ از ﻧﺮم اﻓﺰارهﺎی رﻓﻊ ﺧﻄﺎ )‪ (Debugger‬در ﺳﺎل اول ﺁﻣﻮزش ﻣﯽ ﺗﻮاﻧﺪ‬

‫ﺝﺎﻟﺐ و ﻣﻔﻴﺪ ﺑﺎﺷﺪ‪ .‬اﻣﺎ ﻓﺮﺻﺘﯽ ﺑﺮای ﻣﻌﺮﻓﯽ ﭼﻨﻴﻦ ﭼﻴﺰی را ﺑﻪ داﻧﺸﺠﻮﻳﺎن ﻧﺪارﻧﺪ‪ .‬داﻧﺸﺠﻮﻳﺎن ﺑﻪ ﺳﺨﺘﯽ در ﺗﻘﻼی ﮐﺎر ﮐﺮدن ﺑﺎ‬

‫وﻳﺮاﻳﺸﮕﺮ ‪ ،‬ﮐﺎﻣﭙﺎﻳﻠﺮ و اﺝﺮا ﮐﻨﻨﺪﻩ هﺴﺘﻨﺪ ‪ .‬و ﻓﺮﺻﺘﯽ ﺑﺮای ﺁﺷﻨﺎﻳﯽ ﺑﺎ ﻳﮏ اﺑﺰار ﭘﻴﭽﻴﺪﻩ دﻳﮕﺮ را ﻧﺪارﻧﺪ‪.‬‬

‫ﺑﺮ هﻤﻴﻦ اﺳﺎس ﻣﺎ ﻣﺼﻤﻢ ﺷﺪﻳﻢ ﺗﺎ ﻳﮏ دﻳﺒﺎﮔﺮ ﺳﺎدﻩ ﻃﺮاﺡﯽ ﮐﻨﻴﻢ‪ .‬هﺪف اﻳﻦ ﺑﻮد ﮐﻪ دﻳﺒﺎﮔﺮ ﺗﻬﻴﻪ ﺷﻮد ﮐﻪ ﺷﻤﺎ ﻇﺮف‬

‫‪ ١۵‬دﻗﻴﻘﻪ ﮐﻞ ﺧﺼﻮﺻﻴﺎت ﺁن را ﺷﺮح دهﻴﺪ‪.‬و داﻧﺸﺠﻮﻳﺎن ﺑﺘﻮاﻧﻨﺪ ﺑﺪون اﻣﻮزش ﺧﺎﺻﯽ از ان اﺳﺘﻔﺎدﻩ ﻧﻤﺎﻳﻨﺪ‪.‬‬

‫ﺡﺎل ﺑﺒﻴﻨﻴﺪ ﮐﻪ ﺁﻳﺎ ﻣﺎ ﻣﻮﻓﻖ ﺑﻮدﻩ اﻳﻢ‪.‬‬

‫در اﺑﺘﺪا اﻣﺮ ‪ ،‬ﻣﺎ اﻋﻤﺎل دﻳﺒﺎﮔﺮ هﺎی ﻗﺪﻳﻤﯽ را ﺑﻪ ‪ ٣‬وﻇﻴﻔﻪ ﮐﺎهﺶ دادﻳﻢ ‪:‬‬

‫‪ .١‬ﺗﻨﻈﻴﻢ ‪breakpoint‬‬

‫‪ .٢‬ﮐﺎﻣﭙﺎﻳﻞ ﺧﻂ ﺑﻪ ﺧﻂ ﮐﺪهﺎ‬

‫‪ .٣‬ﻧﻈﺎرت ﺑﺮ ﻣﺘﻐﻴﻴﺮهﺎ ) ﺑﺮرﺳﯽ ﻣﺘﻐﻴﻴﺮهﺎ (‬

‫در واﻗﻊ اﻳﻦ ‪ ٣‬ﻋﻤﻞ ﺑﺴﻴﺎر ﺳﺎدﻩ ﻣﯽ ﺑﺎﺷﻨﺪ‪ .‬در اداﻣﻪ ﻣﺎ ﺑﺎ ﺁﻧﻬﺎ ﮐﺎر ﺧﻮاهﻴﻢ ﮐﺮد‪.‬‬

‫ﺑﺮای ﺷﺮوع ﮐﺎر ‪ ،‬ﭘﺮوژﻩ ‪ debug demo‬را از ﭘﻮﺷﻪ ‪ examples‬اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪ .‬اﻳﻦ ﭘﺮوژﻩ ﺷﺎﻣﻞ ﮐﻼس هﺎی ﺑﺮای‬

‫ﺁزﻣﺎﻳﺶ ﮐﺮدن ﺗﻮاﺑﻊ و اﻋﻤﺎل دﻳﺒﺎﮔﺮ ﻣﯽ ﺑﺎﺷﻨﺪ‪ .‬و ﻧﻤﯽ ﺗﻮاﻧﻨﺪ ﮐﺎر دﻳﮕﺮی اﻧﺠﺎم دهﻨﺪ‪.‬‬

‫‪ (١-٧‬ﺗﻨﻈﻴﻢ ‪ break point‬هﺎ ‪:‬‬

‫ﺧﻼﺻﻪ‪ :‬ﺑﺮای ﻗﺮار دادن ﻳﮏ ‪ ، break point‬در ﻣﺤﻞ ﻣﺮﺑﻮط ﺑﻪ ‪ break point‬هﺎ در ﺳﻤﺖ ﭼﭗ ﻣﺤﻴﻂ ﮐﺪﻧﻮﻳﺴﯽ‬

‫ﮐﻠﻴﮏ ﮐﻨﻴﺪ‪.‬‬

‫ﺑﺎ ﺗﻨﻈﻴﻢ ﻳﮏ ‪ break point‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ در اﺝﺮای ﺑﺮﻧﺎﻣﻪ در اﻳﻦ ﻧﻘﻄﻪ ﻣﻌﻴﻦ از ﮐﺪ وﻗﻔﻪ اﻳﺠﺎد ﮐﻨﻴﺪ‪ .‬و ﺑﺮﻧﺎﻣﻪ در ان‬

‫ﻗﺴﻤﺖ ﻣﺘﻮﻗﻒ ﺷﻮد‪ .‬هﻨﮕﺎﻣﯽ ﮐﻪ اﺝﺮا ﺑﺮﻧﺎﻣﻪ ﻣﺘﻮﻗﻒ ﺷﺪ ‪ .‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ وﺿﻌﻴﺖ اﺷﻴﺎ ﺑﺮﻧﺎﻣﻪ ﺧﻮد را ﺑﺮرﺳﯽ ﮐﻨﻴﺪ‪ .‬اﻳﻦ‬

‫ﮐﺎر در اﻏﻠﺐ اوﻗﺎت ﺑﻪ ﺷﻤﺎ ﮐﻤﮏ ﻣﯽ ﮐﻨﺪ‪ .‬ﺗﺎ ﺑﺘﻮاﻧﻴﺪ ﺑﻔﻬﻤﻴﺪ ﮐﻪ در ﮐﺪهﺎی ﺷﻤﺎ ﭼﻪ اﺗﻔﺎﻗﯽ ﻣﯽ اﻓﺘﺪ‪.‬‬

‫هﻤﺎﻧﮕﻮﻧﻪ ﮐﻪ در ﺷﮑﻞ ‪ ١۶‬ﻣﺸﺨﺺ ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﺳﻤﺖ ﭼﭗ ﻣﺤﻴﻂ ﮐﺪﻧﻮﻳﺴﯽ ﻣﺤﻞ ﻣﺮﺑﻮط ﺑﻪ ‪ break point‬هﺎ ﻣﯽ ﺑﺎﺷﺪ‪.‬‬

‫ﺷﻤﺎ ﺑﺎ ﮐﻠﻴﮏ ﮐﺮدن در اﻳﻦ ﻣﺤﻴﻂ ﻣﯽ ﺗﻮاﻧﻴﺪ ﻳﮏ ‪ break point‬اﻳﺠﺎد ﻧﻤﺎﻳﻴﺪ‪ .‬ﻋﻼﻣﺖ ﮐﻮﭼﮏ "‪ " stop‬ﻧﻘﻄﻪ‬

‫‪ Break point‬ﺷﻤﺎ را ﻣﺸﺨﺺ ﻣﯽ ﻧﻤﺎﻳﺪ‪ .‬ﻣﯽ ﺗﻮاﻧﻴﺪ هﻤﻴﻦ ﺡﺎﻻ اﻣﺘﺤﺎن ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﮐﻼس ‪ Demo‬را ﺑﺎز ﮐﻨﻴﺪ‪ .‬ﻣﺘﺪ ‪ loop‬را ﭘﻴﺪا ﻧﻤﺎﻳﺪ‪ .‬و ﻧﻘﻄﻪ ‪ breakpoint‬ﺧﻮد را در ﺝﺎﻳﯽ از ﻣﺘﺪ ﮐﻪ ﺷﺎﻣﻞ ﺡﻠﻘﻪ‬

‫‪ For‬ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﻗﺮار دهﻴﺪ‪ .‬ﻋﻼﻣﺖ "‪ " stop‬در ﻣﺤﻴﻂ ﮐﺪﻧﻮﻳﺴﯽ ﻧﻤﺎﻳﺶ دادﻩ ﺧﻮاهﺪ ﺷﺪ‪.‬‬

‫‪٢۶‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﺷﮑﻞ ‪ : ١۶‬ﻳﮏ ﻧﻘﻄﻪ ‪break point‬‬

‫هﻨﮕﺎﻣﯽ ﮐﻪ ﺧﻄﻮط ﺑﺮﻧﺎﻣﻪ را ﺑﻮﺳﻴﻠﻪ ﻧﻘﺎط ‪ break point‬ﻣﺸﺨﺺ ﮐﺮدﻳﺪ‪ .‬اﺝﺮا ﺑﺮﻧﺎﻣﻪ در ان ﻗﺴﻤﺖ هﺎ ﻣﺘﻮﻗﻒ ﻣﯽ ﺷﻮد‪ .‬اﺝﺎزﻩ‬

‫ﺑﺪﻳﺪ اﻳﻦ ﮐﺎر رو اﻧﺠﺎم ﺑﺪهﻴﻢ‪ .‬ﺷﯽ ای از ﮐﻼس ‪ Demo‬اﻳﺠﺎد ﮐﻨﻴﺪ‪ .‬و ﻣﺘﺪ ‪ Loop‬ﺁﻧﺮا ﺑﺎ ﭘﺎراﻣﺘﺮ ‪ ١٠‬ﻓﺮاﺧﻮاﻧﯽ ﻧﻤﺎﻳﻴﺪ‪ .‬ﺑﻪ زودی‬

‫ﻧﻘﻄﻪ ‪ break point‬اﺛﺮ ﮐﺮدﻩ‪ .‬ﻣﺤﻴﻂ ﮐﺪ ﻧﻮﻳﺴﯽ ﺑﺮﻧﺎﻣﻪ ﺑﺎز ﻣﯽ ﺷﻮد‪ .‬و ﺧﻂ ﺝﺎری را ﻧﻤﺎﻳﺶ ﻣﯽ دهﺪ‪ .‬هﻤﭽﻨﻴﻦ دﻳﺒﺎﮔﺮ ﺑﺮﻧﺎﻣﻪ ﻧﻴﺰ‬

‫ﺑﺎز ﻣﯽ ﺷﻮد‪ .‬اﻳﻦ وﺿﻌﻴﺖ را ﻣﯽ ﺗﻮاﻧﻴﺪ در ﺷﮑﻞ ‪ ١٧‬ﺑﺒﻴﻨﻴﺪ‪.‬‬

‫ﺷﮑﻞ ‪ : ١٧‬ﭘﻨﺠﺮﻩ دﻳﺒﺎﮔﺮ ﺑﺮﻧﺎﻣﻪ‬

‫ﺧﻄﯽ از ﺑﺮﻧﺎﻣﻪ ﮐﻪ در ﻣﺤﻴﻂ ﮐﺪﻧﻮﻳﺴﯽ ﻣﺸﺨﺺ )‪ (high Light‬ﺷﺪﻩ ‪ ،‬ﺧﻄﯽ اﺳﺖ ﮐﻪ ﻗﺮار اﺳﺖ اﺝﺮا ﺷﻮد‪ .‬ﻳﻌﻨﯽ ﺑﺮﻧﺎﻣﻪ در ﺧﻂ‬

‫ﻗﺒﻠﯽ ﻣﺘﻮﻗﻒ ﺷﺪﻩ اﺳﺖ‪.‬‬

‫‪٢٧‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫‪ ( ٢-٧‬اﺝﺮا ﺧﻂ ﺑﻪ ﺧﻂ ﮐﺪهﺎ‬

‫ﺑﺮای اﺝﺮا ﺧﻂ ﺑﺦ ﺧﻂ ﮐﺪهﺎ ﻳﺘﺎن دﮐﻤﻪ ‪ Step and Step Into‬را در دﻳﺒﺎﮔﺮ ﻓﺸﺎر دهﻴﺪ‪ .‬ﺡﺎل ﮐﻪ ﻣﺎ ﺑﺮﻧﺎﻣﻪ را ﻣﺘﻮﻗﻒ ﮐﺮدﻳﻢ‪.‬‬

‫ﻣﯽ ﺗﻮاﻧﻴﻢ اﺝﺮا ﻳﮏ ﻣﺮﺡﻠﻪ از ﮐﺪهﺎ را ﻣﺸﺎهﺪﻩ ﮐﻨﻴﻢ‪ .‬و ﺑﺒﻴﻨﻴﻢ ﮐﻪ در ﺡﻴﻦ اﺝﺮا ﭼﻪ اﺗﻔﺎﻗﯽ ﻣﯽ اﻓﺘﺪ‪ .‬ﺑﺮای اﻧﺠﺎم اﻳﻦ ﮐﺎر ‪ ،‬ﺑﺼﻮرت‬

‫ﺗﮑﺮاری ‪ ،‬دﮐﻤﻪ ‪ Step‬را از ﭘﻨﺠﺮﻩ دﻳﺒﺎﮔﺮ ﻓﺸﺎر دهﻴﺪ‪ .‬ﺷﻤﺎ ﺑﺎﻳﺪ ﺗﻐﻴﻴﺮاﺗﯽ در ﺧﻄﻮط ﺑﺮﻧﺎﻣﻪ ﺗﺎن ﺑﺒﻴﻨﻴﺪ ) ﺧﻂ واﺿﺢ ﺷﺪﻩ ﺑﻪ ﺧﻄﯽ ﮐﻪ‬

‫اﺝﺮا ﺷﺪﻩ ﻣﻨﺘﻘﻞ ﻣﯽ ﺷﻮد ( هﺮ وﻗﺖ ﮐﻪ ﺷﻤﺎ دﮐﻤﻪ ‪ Step‬را ﻓﺸﺎر دهﻴﺪ‪ .‬ﻳﮏ ﺧﻂ از ﺑﺮﻧﺎﻣﻪ اﺝﺮا ﺷﺪﻩ و اﺝﺮا ﺑﺮﻧﺎﻣﻪ ﻣﺘﻮﻗﻒ ﻣﯽ‬

‫ﺷﻮد‪ .‬ﺗﻮﺝﻪ ﮐﻨﻴﺪ ﮐﻪ ﻣﻘﺪار ﻣﺘﻐﻴﻴﺮهﺎی درون ﭘﻨﺠﺮﻩ دﻳﺒﺎﮔﺮ ﻧﻴﺰ ﺗﻐﻴﻴﺮ ﻣﯽ ﮐﻨﺪ ) ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻣﻘﺪار ﻣﺘﻐﻴﻴﺮ ‪( sum‬‬

‫ﺑﻨﺎﺑﺮاﻳﻦ ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﻣﺮﺡﻠﻪ ﺑﻪ ﻣﺮﺡﻠﻪ ﺑﺮﻧﺎﻣﻪ ﺗﺎن را اﺝﺮا ﮐﻨﻴﺪ و ﺑﺒﻴﻨﻴﺪ ﮐﻪ ﭼﻪ اﺗﻔﺎﻗﯽ ﻣﯽ اﻓﺘﺪ‪ .‬ﺑﺮای اﻳﻦ ﮐﻪ ﺑﻪ اﻳﻦ ﮐﺎر ﺧﺎﺗﻤﻪ‬

‫دهﻴﺪ‪ .‬ﺑﺮ روی ﻧﻘﺎط ‪ breakpoint‬ﮐﻠﻴﮏ ﮐﻨﻴﺪ‪ .‬ﺗﺎ ﭘﺎک ﺷﻮﻧﺪ و هﻤﭽﻨﻴﻦ دﮐﻤﻪ ‪ Continue‬ﻣﻮﺝﻮد در دﻳﺒﺎﮔﺮ را ﻓﺸﺎر دهﻴﺪ ﺗﺎ اﺝﺮا‬

‫ﺑﺮﻧﺎﻣﻪ ﺑﺼﻮرت ﻋﺎدی ﭘﻴﮕﻴﺮی ﺷﻮد‪ .‬اﺝﺎزﻩ دهﻴﺪ ﺗﺎ اﻳﻦ ﻣﺮاﺡﻞ را ﺑﺎ ﻳﮏ ﻣﺘﺪ دﻳﮕﺮ اﻣﺘﺤﺎن ﻧﻤﺎﻳﻴﻢ‪ .‬ﻧﻘﻄﻪ ‪ Breakpoint‬را ﺑﺮ روی‬

‫ﺧﻂ‬

‫;)( ‪Places = myCar.seats‬‬

‫ﻣﺮﺑﻮط ﺑﻪ ﻣﺘﺪ )(‪ carTest‬از ﮐﻼس ‪ Demo‬ﺗﻨﻈﻴﻢ ﻣﯽ ﻧﻤﺎﻳﻴﻢ‪.‬‬

‫‪ ( ٣-٧‬ﺑﺮرﺳﯽ ﻣﺘﻐﻴﻴﺮهﺎ‬

‫ﺧﻼﺻﻪ ‪ :‬ﺑﺮرﺳﯽ ﻣﺘﻐﻴﻴﺮهﺎ ﺑﺴﻴﺎر ﺳﺎدﻩ ﻣﯽ ﺑﺎﺷﻨﺪ‪ .‬ﻣﺘﻐﻴﻴﺮهﺎ ﺑﺼﻮرت ﺧﻮدﮐﺎر در دﻳﺒﺎﮔﺮ ﺑﻪ ﻧﻤﺎﻳﺶ در ﻣﯽ ﺁﻳﻨﺪ‪ .‬هﻨﮕﺎﻣﯽ ﮐﻪ ﺷﻤﺎ‬

‫ﮐﺪهﺎﻳﺘﺎن را رﻓﻊ ﺧﻄﺎ )‪ (debug‬ﻣﯽ ﻧﻤﺎﻳﺪ‪ .‬ﺑﺴﻴﺎر ﻣﻬﻢ ﻣﯽ ﺑﺎﺷﺪ ﮐﻪ ﻗﺎدر ﺑﺎﺷﻴﺪ‪ .‬از وﺿﻌﻴﺖ اﺷﻴﺎ ﺑﺎﺧﺒﺮ ﺑﺎﺷﻴﺪ ) ﻣﺜﻼ ‪ :‬ﻣﺘﻐﻴﻴﺮهﺎی‬

‫ﻣﺤﻠﯽ و ﻣﺘﻐﻴﻴﺮهﺎی ﻧﻤﻮﻧﻪ ( ‪ .‬اﻧﺠﺎم اﻳﻦ ﮐﺎر ﺑﺴﻴﺎر ﺳﺎدﻩ و ﺝﺰﺋﯽ ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﺷﻤﺎ ﻧﻴﺎز ﺑﻪ ﻳﮏ دﺳﺘﻮر ﺧﺎص ﺑﺮای ﺑﺮرﺳﯽ ﻣﺘﻐﻴﻴﺮهﺎ‬

‫ﻧﺪارﻳﺪ‪ .‬ﻣﺘﻐﻴﻴﺮهﺎی اﺳﺘﺎﺗﻴﮏ ‪ ،‬ﻣﺘﻐﻴﻴﺮهﺎی ﻧﻤﻮﻧﻪ از ﺷﯽ ﺝﺎری ‪ ،‬ﻣﺘﻐﻴﻴﺮهﺎی ﻣﺤﻠﯽ ﻣﺘﺪ ﺝﺎری هﻤﻮارﻩ ﺑﻪ ﺻﻮرت ﺧﻮدﮐﺎر ﻧﻤﺎﻳﺶ دادﻩ‬

‫ﺷﺪﻩ و هﻤﭽﻨﻴﻦ ﺑﺮوز رﺳﺎﻧﯽ ﻧﻴﺰ ﻣﯽ ﺷﻮﻧﺪ‪ .‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﻣﺘﺪهﺎ را در ﻓﺮاﺧﻮاﻧﯽ ﻣﺘﻮاﻟﯽ اﻧﺘﺨﺎب ﮐﻨﻴﺪ‪ .‬ﺗﺎ ﻣﺘﻐﻴﻴﺮهﺎی دﻳﮕﺮ اﺷﻴﺎ و‬

‫ﻣﺘﺪهﺎی ﻓﻌﺎل ﺝﺎری را ﻣﺸﺎهﺪﻩ ﻧﻤﺎﻳﻴﺪ‪ .‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ‪ ،‬ﻣﺠﺪدا ﻳﮏ ﻧﻘﻄﻪ ‪ break point‬در ﻣﺘﺪ )(‪ carTest‬ﻗﺮار دهﻴﺪ‪ .‬در ﺳﻤﺖ‬

‫ﭼﭗ ﭘﻨﺠﺮﻩ دﻳﺒﺎﮔﺮ ﺷﻤﺎ ﻓﺮاﺧﻮاﻧﯽ ﻣﺘﻮاﻟﯽ )‪ ( call sequence‬را ﻣﺸﺎهﺪﻩ ﺧﻮاهﻴﺪ ﮐﺮد‪ .‬ﮐﻪ در ﺡﺎل ﺡﺎﺿﺮ ﻣﻮارد زﻳﺮ را ﻧﻤﺎﻳﺶ‬

‫ﻣﯽ دهﺪ‪:‬‬

‫‪Car.seats‬‬
‫‪Demo.carTest‬‬

‫اﻳﻦ اﺷﺎرﻩ ﻣﯽ ﮐﻨﺪ ﺑﻪ اﻳﻦ ﮐﻪ ‪ Car.Seats‬ﺑﻮﺳﻴﻠﻪ ‪ Demo.carTest‬ﻓﺮاﺧﻮاﻧﯽ ﺷﺪﻩ اﺳﺖ‪ .‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ از اﻳﻦ ﻟﻴﺴﺖ ﮔﺰﻳﻨﻪ‬

‫‪ Demo.carTest‬را ﺑﺮای ﺑﺮرﺳﯽ ﮐﺪ ﻣﺮﺑﻮﻃﻪ و هﻤﭽﻨﻴﻦ ﻣﻘﺪار ﻣﺘﻐﻴﻴﺮهﺎی ﺝﺎری اﻳﻦ ﻣﺘﺪ اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫اﮔﺮ ﺷﻤﺎ از ﺧﻄﯽ ﮐﻪ ﺷﺎﻣﻞ ﺳﺎﺧﺘﺎر )…(‪ new Car‬ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﻋﺒﻮر ﮐﻨﻴﺪ ﻣﯽ ﺗﻮاﻧﻴﺪ ﻣﻘﺪار ﻣﺘﻐﻴﻴﺮ ﻣﺤﻠﯽ ‪ my car‬را ﮐﻪ ﺑﺼﻮرت‬

‫>‪ <object refrence‬ﻣﯽ ﺑﺎﺷﺪ ﻣﺸﺎهﺪﻩ ﻧﻤﺎﻳﻴﺪ‪ .‬ﻣﻘﺪار ﺗﻤﺎم اﻧﻮاع اﺷﻴﺎ ) ﺑﻪ ﺝﺰ رﺷﺘﻪ هﺎ ( از اﻳﻦ راﻩ ﻧﻤﺎﻳﺶ دادﻩ ﻣﯽ ﺷﻮد‪ .‬ﺷﻤﺎ‬

‫ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﺎ دو ﺑﺎر ﮐﻠﻴﮏ ﮐﺮدن ﺑﺮ روی ﻣﺘﻐﻴﻴﺮهﺎ اﻧﻬﺎ را ﺑﺮرﺳﯽ ﻧﻤﺎﻳﻴﺪ‪ .‬اﻧﺠﺎم اﻳﻦ ﮐﺎر ﺷﺒﻴﻪ ﺑﺎز ﮐﺮدن ﭘﻨﺠﺮﻩ ﺑﺮرﺳﯽ ﺷﯽ‬

‫ﻣﯽ ﺑﺎﺷﺪ ‪ .‬ﮐﻪ در ﺑﺨﺶ ‪ 4-1‬ﻣﻮرد ﺑﺮرﺳﯽ ﻗﺮار ﮔﺮﻓﺖ‪.‬‬

‫‪٢٨‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫‪ ( ۴-٧‬ﻣﺘﻮﻗﻒ ﮐﺮدن و ﺧﺎﺗﻤﻪ دادن ﺑﺮﻧﺎﻣﻪ‬

‫ﺧﻼﺻﻪ ‪ :‬ﮔﺰﻳﻨﻪ هﺎی ‪ Halt‬و ‪ Terminate‬ﻣﻮﺝﻮد در دﻳﺒﺎﮔﺮ ﺑﺮای اﻳﺠﺎد ﺗﻮﻗﻒ ﺑﻄﻮر ﻣﻮﻗﺖ ﻳﺎ داﺋﻢ در ﺑﺮﻧﺎﻣﻪ ﺑﮑﺎر ﻣﯽ روﻧﺪ‪.‬‬

‫ﮔﺎهﯽ اوﻗﺎت اﺝﺮا ﺑﺮﻧﺎﻣﻪ ﺑﺴﻴﺎر ﻃﻮل ﻣﯽ ﮐﺸﺪ‪ .‬و ﻣﺎ ﻣﺘﻌﺠﺐ از اﻳﻦ ﮐﻪ هﻤﻪ ﭼﻴﺰ درﺳﺖ هﺴﺖ‪ .‬ﺷﺎﻳﺪ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ در ﻳﮏ ﺡﻠﻘﻪ‬

‫ﻧﺎﻣﺘﻨﻬﺎهﯽ ﮔﺮﻓﺘﺎر اﻣﺪﻩ و ﺑﻪ هﻤﻴﻦ دﻟﻴﻞ اﺝﺮا ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﻃﻮل ﻣﯽ اﻧﺠﺎﻣﺪ‪ .‬ﺧﺐ ﻣﺎ اﻳﻦ ﻣﻮرد را ﺑﺮرﺳﯽ ﻣﯽ ﮐﻨﻴﻢ‪ .‬ﻣﺘﺪ )(‪ longloop‬را‬

‫از ﮐﻼس ‪ Demo‬اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪ .‬ﺡﺎﻻ ﻣﺎ ﻗﺼﺪ دارﻳﻢ ﺑﺒﻴﻨﻴﻢ ﮐﻪ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﮐﺠﺎ ﻣﻨﺘﻘﻞ ﻣﯽ ﺷﻮد‪ .‬ﭘﻨﺠﺮﻩ دﻳﺒﺎﮔﺮ را ﻧﮕﺎﻩ ﮐﻨﻴﺪ اﮔﺮ هﻨﻮز ﺑﺮ‬

‫روی ﺻﻔﺤﻪ ﻧﻤﺎﻳﺶ ﻇﺎهﺮ ﻧﺸﺪﻩ اﺳﺖ‪ .‬ﺡﺎﻻ دﮐﻤﻪ ‪ Halt‬را ﻓﺸﺎر دهﻴﺪ ‪.‬اﺝﺮا ﺑﺮﻧﺎﻣﻪ اﮔﺮ ﻣﺎ ﻧﻘﻄﻪ ‪ break point‬ﺗﻌﻴﻴﻦ ﮐﺮدﻩ ﺑﺎﺷﻴﻢ‬

‫ﻣﺘﻮﻗﻒ ﻣﯽ ﺷﻮد‪ .‬ﺷﻤﺎ ﺡﺎﻻ ﻣﯽ ﺗﻮاﻧﻴﺪ ﻣﺮﺡﻠﻪ ﺑﻪ ﻣﺮﺡﻠﻪ ﭘﻴﺶ ﺑﺮوﻳﺪ و از ﻣﺘﻐﻴﻴﺮهﺎ رو ﻣﺸﺎهﺪﻩ ﮐﻨﻴﺪ ﮐﻪ هﻤﻪ ﻣﻘﺪار درﺳﺘﯽ دارﻧﺪ‪.‬اﻳﻦ‬

‫ﻋﻤﻞ ﻓﻘﻂ ﻧﻴﺎز ﺑﻪ ﻣﻘﺪاری زﻣﺎن ﺑﺮای ﺗﮑﻤﻴﻞ ﺷﺪن دارد‪ .‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﻪ دﻓﻌﺎت زﻳﺎد از دﮐﻤﻪ هﺎی ‪ Continue‬و ‪ Halt‬اﺳﺘﻔﺎدﻩ‬

‫ﮐﻨﻴﺪ ﺗﺎ ﺑﺘﻮاﻧﻴﺪ ﺳﺮﻳﻌﺘﺮ ﭘﻴﺶ ﺑﺮوﻳﺪ‪.‬اﮔﺮ ﺷﻤﺎ ﻗﺼﺪ ﻧﺪارﻳﺪ ﮐﻪ اداﻣﻪ دهﻴﺪ )ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺝﺎی واﻗﻌﯽ ﺡﻠﻘﻪ ﺑﯽ ﻧﻬﺎﻳﺖ را ﭘﻴﺪا ﮐﺮدﻩ اﻳﺪ (‬

‫ﻣﯽ ﺗﻮاﻧﻴﺪ دﮐﻤﻪ ‪ terminate‬را ﻓﺸﺎر دهﻴﺪ ﺗﺎ اﺝﺮای ﺑﺮﻧﺎﻣﻪ ﻣﺘﻮﻗﻒ ﺷﻮد‪ .‬ﺷﻤﺎ ﻧﻤﯽ ﺗﻮاﻧﻴﺪ ازدﮐﻤﻪ ‪ Terminate‬ﻣﮑﺮرا اﺳﺘﻔﺎدﻩ‬

‫ﻧﻤﺎﻳﺪ‪.‬‬

‫ﻓﺼﻞ ‪ - ٨‬اﻳﺠﺎد ﻳﮏ ﺑﺮﻧﺎﻣﻪ ﮐﺎرﺑﺮدی ﺧﻮد اﺗﮑﺎ‬

‫‪٢٩‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﺧﻼﺻﻪ ‪ :‬ﺑﺮای اﻳﺠﺎد ﻳﮏ ﺑﺮﻧﺎﻣﻪ ﺧﻮد اﺗﮑﺎ از ﻣﻨﻮی ‪ project‬ﮔﺰﻳﻨﻪ ‪ create jar file‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ BlueJ‬ﻣﯽ ﺗﻮاﻧﺪ ﻓﺎﻳﻞ هﺎی ‪ Jar‬ﻗﺎﺑﻞ اﺝﺮا ﺗﻮﻟﻴﺪ ﻧﻤﺎﻳﺪ‪ .‬ﻓﺎﻳﻞ هﺎی ‪ Jar‬اﺝﺮاﻳﯽ ‪ ،‬در ﺳﻴﺴﺘﻢ هﺎی ﻧﻈﻴﺮ وﻳﻨﺪوز و ﻣﮑﻴﻨﺘﺎش ﺑﺎ‬

‫دو ﺑﺎر ﮐﻠﻴﮏ ﮐﺮدن ﺑﺮ روی ﻓﺎﻳﻞ اﺝﺮا ﻣﯽ ﺷﻮﻧﺪ‪ .‬و در ﺳﻴﺴﺘﻢ هﺎی ﻧﻈﻴﺮ ‪ Dos‬و ‪ Unix‬ﺑﺎ ﺗﺎﻳﭗ دﺳﺘﻮر زﻳﺮ ‪:‬‬

‫‪Java –jar <file name>.jar‬‬

‫ﻣﺎ اﻳﻦ ﮐﺎر را ﺑﺮای ﭘﺮوژﻩ ‪ people‬ﮐﻪ در ﭘﻮﺷﻪ ‪ examples‬ﻗﺮار دارد‪ .‬اﻧﺠﺎم ﻣﯽ دهﻴﻢ‪ .‬ﭘﺮوژﻩ را ﺑﺎز ﮐﻨﻴﺪ‪ .‬ﻣﻄﻤﺌﻦ ﺷﻮﻳﺪ ﮐﻪ ﭘﺮوژﻩ‬

‫ﮐﺎﻣﭙﺎﻳﻞ ﺷﺪﻩ و ﺑﻌﺪ از ﻣﻨﻮی ‪ Project‬ﮔﺰﻳﻨﻪ ‪ create jar file‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﭘﻨﺠﺮﻩ ای ﺑﺎز ﻣﯽ ﺷﻮد‪.‬ﮐﻪ ﺑﻪ ﺷﻤﺎ اﺝﺎزﻩ ﻣﯽ دهﺪ ﺗﺎ ﮐﻼس ‪ main‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ ) ﻋﮑﺲ ‪. (١٨‬اﻳﻦ ﮐﻼس ﺑﺎﻳﺪ ﺷﺎﻣﻞ ﻳﮏ‬

‫ﻣﺘﺪ ‪ ) main‬ﮐﻪ اﻣﻀﺎ ﺁن ﺑﺪﻳﻦ ﺷﮑﻞ ﺑﺎﺷﺪ ‪ ( public static void main(String[] args) :‬ﺑﺎﺷﺪ‪.‬‬

‫ﻋﮑﺲ ‪ : ١٨‬ﭘﻨﺠﺮﻩ " ‪"create jar file‬‬

‫در ﻣﺜﺎل ﻣﺎ اﻧﺘﺨﺎب ﮐﻼس ‪ main‬ﺳﺎدﻩ ﻣﯽ ﺑﺎﺷﺪ‪ .‬زﻳﺮا ﻣﺎ ﺗﻨﻬﺎ ﻳﮏ ﮐﻼس دارﻳﻢ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ از ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ ‪ Hello‬را اﻧﺘﺨﺎب‬

‫ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﻣﻌﻤﻮﻻ ﺷﻤﺎ ﺳﻮرس ﺑﺮﻧﺎﻣﻪ را ﺑﻪ هﻤﺮاﻩ ﻓﺎﻳﻞ اﺝﺮاﻳﯽ ﻗﺮار ﻧﻤﯽ دهﻴﺪ‪ .‬وﻟﯽ اﮔﺮ ﻗﺼﺪ دارﻳﺪ ﮐﻪ ﺑﺮﻧﺎﻣﻪ ﺗﺎن ﺷﺎﻣﻞ ﺳﻮرس ﺑﺮﻧﺎﻣﻪ هﻢ‬

‫ﺑﺎﺷﺪ ‪ .‬ﻣﯽ ﺗﻮاﻧﻴﺪ ﮔﺰﻳﻨﻪ ‪ include source‬را ﺗﻴﮏ ﺑﺰﻧﻴﺪ‪ ) .‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﮐﻞ ﭘﺮوژﻩ ﺗﺎن را ﺑﺎ اﺳﺘﻔﺎدﻩ از ﻓﺮﻣﺖ‬

‫‪ jar‬در ﻗﺎﻟﺐ ﻳﮏ ﻓﺎﻳﻞ ﺑﻮﺳﻴﻠﻪ اﻳﻤﻴﻞ ﺑﺮای دﻳﮕﺮان ارﺳﺎل ﻧﻤﺎﻳﻴﺪ ( ‪.‬‬

‫اﮔﺮ ﺷﻤﺎ ‪ BlueJ‬را ﺑﻪ ﮔﻮﻧﻪ ای ﺗﻨﻈﻴﻢ ﮐﺮدﻩ اﻳﺪ‪ .‬ﮐﻪ‬

‫از ‪ ) user library‬ﺑﺮای اﻳﻨﮑﺎر ﻣﺴﻴﺮ ‪ Tools / performance / libraries‬را ﻃﯽ ﮐﻨﻴﺪ ( اﺳﺘﻔﺎدﻩ ﮐﻨﺪ‪ .‬در وﺳﻂ اﻳﻦ‬

‫ﭘﻨﺠﺮﻩ ﺷﻤﺎ ﻧﺎﺡﻴﻪ ای را ﺑﺎ اﻳﻦ ﻋﻨﻮان ﻣﺸﺎهﺪﻩ ﺧﻮاهﻴﺪ ﮐﺮد ‪ ) . "Include user libraries" :‬اﮔﺮ ﺷﻤﺎ از ﮐﺘﺎﺑﺨﺎﻧﻪ هﺎ اﺳﺘﻔﺎدﻩ‬

‫‪٣٠‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﻧﮑﺮدﻩ اﻳﺪ‪ .‬اﻳﻦ ﻧﺎﺡﻴﻪ ﻧﻤﺎﻳﺶ دادﻩ ﻧﻤﯽ ﺷﻮد ( ‪.‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ اﻧﺘﺨﺎب ﮐﻨﻴﺪ ﮐﺘﺎﺑﺨﺎﻧﻪ هﺎی ﻣﺨﺘﻠﻔﯽ را ﮐﻪ ﭘﺮوژﻩ ﺷﻤﺎ از ان هﺎ اﺳﺘﻔﺎدﻩ‬

‫ﻣﯽ ﮐﻨﺪ‪ Continue .‬را ﻓﺸﺎر دهﻴﺪ ﺗﺎ ﺑﻪ ﻣﺮﺡﻠﻪ ﺑﻌﺪ ﺑﺮوﻳﺪ‪ .‬در اﻳﻦ ﺑﺨﺶ ﻳﮏ ﭘﻨﺠﺮﻩ اﻧﺘﺨﺎب ﮐﻨﻨﺪﻩ ﻓﺎﻳﻞ )‪ (file chooser‬ﻧﻤﺎﻳﺶ‬

‫دادﻩ ﻣﯽ ﺷﻮد‪ .‬ﮐﻪ ﺷﻤﺎ ﺑﺎ اﺳﺘﻔﺎدﻩ از ان ﻧﺎم ﻓﺎﻳﻞ ‪ Jar‬را ﺗﺎﻳﭗ ﮐﺮدﻩ و دﮐﻤﻪ ‪ Create‬را ﻓﺸﺎر دهﻴﺪ‪ .‬ﺑﺮای اﻳﻦ ﻣﺜﺎل ﺷﻤﺎ ﺗﺎﻳﭗ ﮐﻨﻴﺪ‪:‬‬

‫‪ Hello‬و دﮐﻤﻪ ‪ create‬را ﻓﺸﺎر دهﻴﺪ‪ .‬اﮔﺮ ﺷﻤﺎ ﺑﻪ ﻓﺎﻳﻞ ﺗﺎن ﮐﺘﺎﺑﺨﺎﻧﻪ ای را اﺿﺎﻓﻪ ﻧﮑﺮدﻩ ﺑﺎﺷﻴﺪ‪ .‬ﻓﺎﻳﻞ ‪ hello.jar‬اﻳﺠﺎد ﻣﯽ ﺷﻮد‪.‬‬

‫و اﮔﺮ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺷﺎﻣﻞ ﮐﺘﺎﺑﺨﺎ ﻧﻪ ای ﺑﺎﺷﺪ‪ .‬ﭘﻮﺷﻪ ای ﺑﺎ ﻧﺎم ‪ hello‬اﻳﺠﺎد ﺷﺪﻩ ﮐﻪ ﻓﺎﻳﻞ ‪ hello.jar‬در ﺁن ﻗﺮار دارد‪ .‬هﻤﭽﻨﻴﻦ اﻳﻦ‬

‫ﭘﻮﺷﻪ ﺷﺎﻣﻞ ﺗﻤﺎﻣﯽ ﮐﺘﺎﺑﺨﺎﻧﻪ هﺎی ﻣﻮرد ﻧﻴﺎز ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﻓﺎﻳﻞ ‪ Jar‬ﺷﻤﺎ ﮐﺘﺎﺑﺨﺎﻧﻪ هﺎی ﻣﻮرد ﻧﻴﺎز ﺧﻮد را در ﭘﻮﺷﻪ ای هﻤﻨﺎم ﺑﺎ ﺧﻮدش‬

‫ﻣﯽ ﻳﺎﺑﺪ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ هﻤﻮارﻩ ﻓﺎﻳﻞ ‪ Jar‬را ﻳﺎ اﻳﻦ ﭘﻮﺷﻪ ﺝﺎﺑﺠﺎ ﮐﻨﻴﺪ‪ .‬ﺗﺎ ﻓﺎﻳﻞ ‪ Jar‬ﺑﺘﻮاﻧﺪ ﮐﺘﺎﺑﺨﺎﻧﻪ هﺎی ﻣﻮرد ﻧﻴﺎز را ﭘﻴﺪا ﻧﻤﺎﻳﺪ‪.‬‬

‫اﮔﺮ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺷﺎﻣﻞ ﻳﮏ راﺑﻂ ﮔﺮاﻓﻴﮑﯽ ﮐﺎرﺑﺮ )‪ (GUI‬ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﺑﺎ دو ﺑﺎر ﮐﻠﻴﮏ ﺑﺮ روی ﻓﺎﻳﻞ ‪ Jar‬ﻣﯽ ﺗﻮاﻧﻴﺪ ﺁﻧﺮا اﺝﺮا ﮐﻨﻴﺪ‪.‬‬

‫و اﮔﺮ ﻣﺎﻧﻨﺪ ﻣﺜﺎل ﻣﺎ ﻓﺎﻳﻞ ‪ Jar‬ﺗﻨﻬﺎ ﺷﺎﻣﻞ ﻳﮏ ‪ I/O‬ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﺷﻤﺎ ﺑﺎ اﺳﺘﻔﺎدﻩ از ‪ Text Terminal‬و ﻳﺎ ﭘﻨﺠﺮﻩ داس ﻣﯽ ﺗﻮاﻧﻴﺪ اﻧﺮا‬

‫اﺝﺮا ﮐﻨﻴﺪ‪ .‬ﺑﺮای اﻳﻨﮑﺎر ﻣﺮاﺡﻞ زﻳﺮ را ﻃﯽ ﮐﻨﻴﺪ‪:‬‬

‫در ﭘﻨﺠﺮﻩ داس ﻳﺎ ‪ Text Terminal‬ﺑﻪ ﻣﺤﻠﯽ ﮐﻪ ﻓﺎﻳﻞ ‪ .jar‬ﻗﺮار دارد رﻓﺘﻪ و دﺳﺘﻮر زﻳﺮ را ﺗﺎﻳﭗ ﮐﻨﻴﺪ‪:‬‬

‫‪Java –jar hello.jar‬‬

‫ﺑﺪﻳﻦ ﮔﻮﻧﻪ ﻓﺎﻳﻞ ﺷﻤﺎ اﺝﺮا ﻣﯽ ﺷﻮد‪.‬‬

‫ﻓﺼﻞ ‪ – ٩‬اﻳﺠﺎد اﭘﻠﺖ هﺎ‬

‫‪٣١‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫‪ (١-٩‬اﺝﺮا ﮐﺮدن اﭘﻠﺖ هﺎ‬

‫ﺧﻼﺻﻪ ‪ :‬ﺑﺮای اﺝﺮا ﮐﺮدن اﭘﻠﺖ هﺎ از ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ ‪ applet‬ﮔﺰﻳﻨﻪ ‪ Run Applet‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ BlueJ‬ﺑﻪ ﺷﻤﺎ اﺝﺎزﻩ ﻣﯽ دهﺪ ﮐﻪ اﭘﻠﺖ هﺎ را ﻣﺎﻧﻨﺪ اﭘﻠﻴﮑﻴﺸﻦ هﺎ اﻳﺠﺎد و اﺝﺮا ﮐﻨﻴﺪ‪ .‬ﺑﻪ هﻤﺮاﻩ ‪ BlueJ‬و در ﭘﻮﺷﻪ ‪ Examples‬ﻳﮏ‬

‫ﻧﻤﻮﻧﻪ اﭘﻠﺖ وﺝﻮد دارد‪ .‬ﻣﺎ در اﺑﺘﺪا ﻗﺼﺪ دارﻳﻢ ﺗﺎ اﭘﻠﺖ را اﺝﺮا ﻧﻤﺎﻳﻴﻢ ‪ .‬ﺑﺮای اﻳﻨﮑﺎر ﭘﺮوژﻩ ‪ Appletdemo‬را از ﭘﻮﺷﻪ‬

‫‪ examples‬اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﺷﻤﺎ ﺧﻮاهﻴﺪ دﻳﺪ ﮐﻪ اﻳﻦ ﭘﺮوژﻩ ﺗﻨﻬﺎ ﺷﺎﻣﻞ ﻳﮏ ﮐﻼس ﺑﺎ ﻧﺎم ‪ CaseConvertor‬ﻣﻴﺒﺎﺷﺪ‪ .‬اﻳﻦ ﮐﻼس ﺑﻮﺳﻴﻠﻪ ﺗﮓ >>‪<<applet‬‬

‫ﻣﺸﺨﺺ ﺷﺪﻩ اﺳﺖ‪ .‬ﺑﻌﺪ از ﮐﺎﻣﭙﺎﻳﻞ ﭘﺮوژﻩ ‪ ،‬ﮔﺰﻳﻨﻪ ‪ Run Applet‬را از ﻣﻨﻮی ﺑﺎز ﺷﻮﻧﺪﻩ ﮐﻼس اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﭘﻨﺠﺮﻩ ای ﺑﺎز ﻣﯽ ﺷﻮد ﮐﻪ ﺑﻪ ﺷﻤﺎ ﻳﮏ ﺳﺮی ﮔﺰﻳﻨﻪ اراﺋﻪ ﻣﯽ دهﺪ ) ﻋﮑﺲ ‪.( ١٩‬‬

‫ﻋﮑﺲ ‪ : ١٩‬ﭘﻨﺠﺮﻩ ‪Run Applet‬‬

‫ﺷﻤﺎ در اﻳﻦ ﭘﻨﺠﺮﻩ ﻣﯽ ﺑﻴﻨﻴﺪ ﮐﻪ ﻣﯽ ﺗﻮاﻧﻴﺪ اﻧﺘﺨﺎب ﮐﻨﻴﺪ ﮐﻪ اﭘﻠﺖ در ﻳﮏ ﻣﺮورﮔﺮ ﻧﻤﺎﻳﺶ دادﻩ ﺷﻮد و ﻳﺎ اﻳﻨﮑﻪ در ‪Applet viewer‬‬

‫وﻳﺎ اﻳﻨﮑﻪ ﺗﻨﻬﺎ ‪ webpage‬ﻣﺮﺑﻮﻃﻪ ﺗﻮﻟﻴﺪ ﺷﺪﻩ و اﭘﻠﺖ اﺝﺮا ﻧﺸﻮد‪ .‬ﺗﻨﻈﻴﻤﺎت ﭘﻴﺶ ﻓﺮض را دﺳﺖ ﻧﺰﻧﻴﺪ و دﮐﻤﻪ ‪ Ok‬را ﻓﺸﺎر دهﻴﺪ‪.‬‬

‫ﺑﻌﺪ از ﭼﻨﺪ ﺛﺎﻧﺒﻪ ‪ Applet viewer‬ﻧﻤﺎﻳﺶ دادﻩ ﺷﺪﻩ و اﭘﻠﺖ ﺷﻤﺎ را ﻧﻤﺎﻳﺶ ﻣﯽ دهﺪ‪.‬‬

‫‪ Applet Viewer‬ﺑﻬﻤﺮاﻩ ‪ j2se‬ﺑﺮ روی ﺳﻴﺴﺘﻢ ﺷﻤﺎ ﻧﺼﺐ ﺷﺪﻩ و هﻤﻮارﻩ اﻳﻦ ﺗﻀﻤﻴﻦ وﺝﻮد دارد ﮐﻪ ﻧﺴﺨﻪ ﮐﺎﻣﭙﺎﻳﻠﺮ ﺝﺎوای‬

‫ﺷﻤﺎ و ‪ Applet viewer‬ﻳﮑﺴﺎن ﺑﺎﺷﺪ‪ .‬در ﻣﻮرد ﻣﺮورﮔﺮ وب ﺷﻤﺎ اﻣﮑﺎن دارد‪ .‬ﮐﻪ ﻣﺮورﮔﺮ از ﻧﺴﺨﻪ دﻳﮕﺮی از ﺝﺎوا اﺳﺘﻔﺎدﻩ‬

‫ﮐﻨﺪ و اﻳﻦ ﻣﻮرد ﺑﺎﻋﺚ ﺑﺮوز ﻳﮏ ﺳﺮی ﻣﺸﮑﻞ ﺷﻮد‪ .‬اﻟﺒﺘﻪ در ﺡﺎل ﺡﺎﺿﺮ اﮐﺜﺮ ﻣﺮورﮔﺮ هﺎ ﺑﺨﻮﺑﯽ ﺑﺎ ﺝﺎوا ﮐﺎر ﻣﯽ ﮐﻨﻨﺪ‪.‬‬

‫در ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ وﻳﻨﺪوز و ﻣﮑﻴﻨﺘﺎش ‪ BlueJ ،‬از ﻣﺮورﮔﺮ ﭘﻴﺶ ﻓﺮض ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ اﺳﺘﻔﺎدﻩ ﻣﯽ ﮐﻨﺪ‪ .‬اﻣﺎ در ﺳﻴﺴﺘﻢ هﺎی‬

‫‪ ، Unix‬ﻣﺮورﮔﺮ در ﺗﻨﻈﻴﻤﺎت ‪ BlueJ‬ﻣﺸﺨﺺ ﺷﺪﻩ اﺳﺖ‪.‬‬

‫‪ ( ٢-٩‬اﻳﺠﺎد ﮐﺮدن اﭘﻠﺖ‬

‫‪٣٢‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﺧﻼﺻﻪ‪ :‬ﺑﺮای اﻳﺠﺎد اﭘﻠﺖ ﺑﺮ روی دﮐﻤﻪ ‪ New Class‬ﮐﻠﻴﮏ ﮐﺮدﻩ و ‪ Applet‬را از ﻧﻮع ﮐﻼس اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﺑﻌﺪ از اﻳﻦ ﮐﻪ ﻣﺸﺎهﺪﻩ ﮐﺮدﻳﺪ ﭼﮕﻮﻧﻪ ﻣﯽ ﺗﻮان ﻳﮏ اﭘﻠﺖ را اﺝﺮا ﮐﺮد‪ .‬ﺡﺎﻻ ﻗﺼﺪ دارﻳﻢ ﺗﺎ ﺧﻮدﻣﺎن ﻳﮏ اﭘﻠﺖ اﻳﺠﺎد ﻧﻤﺎﻳﻴﻢ‪.‬‬

‫ﻳﮏ ﮐﻼس ﺝﺪﻳﺪ ﺑﺎ ﻓﺮﻣﺖ ‪ Applet‬اﻳﺠﺎد ﮐﻨﻴﺪ‪ .‬اﻧﺮا ﮐﺎﻣﭙﺎﻳﻞ ﮐﻨﻴﺪ‪ .‬و در ﻧﻬﺎﻳﺖ اﺝﺮا ﮐﻨﻴﺪ‪ .‬اﻳﻦ ﮐﺎر اﻧﺠﺎم ﺷﺪ !!!‬

‫ﺡﺎﻻ ﻣﯽ ﺗﻮاﻧﻴﺬ ﮐﺪهﺎی اﭘﻠﺖ را در ادﻳﺘﻮر ﺑﺒﻴﻨﻴﺪ‪.‬و ﻣﺸﺎهﺪﻩ ﮐﻨﻴﺪ ﮐﻪ ﺷﺎﻣﻞ ﺗﻤﺎﻣﯽ ﮐﺪهﺎی ﻣﻮرد ﻧﻴﺎز ﺑﺮای اﭘﻠﺖ ﻣﯽ ﺑﺎﺷﺪ‪.‬‬

‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻣﺘﺪ ‪. paint‬‬

‫‪ (٣-٩‬ﺁزﻣﺎﻳﺶ ﮐﺮدن اﭘﻠﺖ‬

‫در ﺑﺴﻴﺎری از ﺡﺎﻟﺖ هﺎ اﻳﺠﺎد ﺷﯽ اﭘﻠﺖ ﺑﺮ روی ﻣﻴﺰ ﮐﺎر اﺷﻴﺎ ﺑﺴﻴﺎر ﻣﻔﻴﺪ ﺧﻮاهﺪ ﺑﻮد‪ .‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ از ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ اﭘﻠﺖ‬

‫ﺳﺎزﻧﺪﻩ اﭘﻠﺖ را ﻣﺸﺎهﺪﻩ ﻧﻤﺎﻳﻴﺪ‪ .‬از ﻣﻴﺰ ﮐﺎر اﺷﻴﺎ ﺷﻤﺎ ﻧﻤﯽ ﺗﻮاﻧﻴﺪ ﻳﮏ اﭘﻠﺖ را ﺑﻪ ﻃﻮر ﮐﺎﻣﻞ اﺝﺮا ﮐﻨﻴﺪ‪ .‬ﺑﻠﮑﻪ ﺑﻌﻀﯽ از ﻣﺘﺪهﺎی‬

‫ﺁن را ﻣﯽ ﺗﻮاﻧﻴﺪ ﻓﺮاﺧﻮاﻧﯽ ﻧﻤﺎﻳﻴﺪ‪ .‬اﻳﻦ ﻣﻮﺿﻮع ﺑﺮای ﺗﺴﺖ ﮐﺮدن ﻳﮏ ﻣﺘﺪ ﮐﻪ ﺷﻤﺎ در ﺑﻴﻦ ﮐﺪهﺎی اﭘﻠﺖ ﻧﻮﺷﺘﻪ اﻳﺪ ﻣﯽ ﺗﻮاﻧﺪ ﻣﻔﻴﺪ‬

‫ﺑﺎﺷﺪ‪ .‬اﮔﺮ ﺷﻤﺎ ﺑﺮای اﭘﻠﺖ ﺗﺎن ﻧﻘﺎط ‪ break point‬ﺗﻌﻴﻦ ﮐﺮدﻩ اﻳﺪ‪ .‬در ﺡﺎﻟﺘﯽ ﮐﻪ اﭘﻠﺖ در ‪ Applet viewer‬و ﻳﺎ ﻣﺮورﮔﺮ‬

‫وب اﺝﺮا ﻣﯽ ﺷﻮد‪ .‬هﻴﭻ ﮔﻮﻧﻪ ﺗﺎﺛﻴﺮی ﻧﺪارد‪ .‬زﻳﺮا اﻧﻬﺎ از ﻣﺎﺷﻴﻦ هﺎی ﻣﺠﺎزی ﻣﺮﺑﻮط ﺑﻪ ﺧﻮد ﺑﻬﺮﻩ ﻣﯽ ﺑﺮﻧﺪ‪ .‬و ﻧﻤﯽ ﺗﻮاﻧﻨﺪ ﻣﻌﻨﺎی‬

‫ﻧﻘﺎط ‪ break point‬را ﮐﻪ ﻧﺮم اﻓﺰار ‪ BlueJ‬ﻗﺮار دادﻩ درک ﮐﻨﻨﺪ‪.‬‬

‫اﮔﺮ ﺷﻤﺎ ﻗﺼﺪ دارﻳﺪ ﺗﺎ از ‪ Break point‬هﺎ و هﻤﭽﻨﻴﻦ ﮐﺎﻣﭙﺎﻳﻞ ﻣﺮﺡﻠﻪ ﺑﻪ ﻣﺮﺡﻠﻪ در اﭘﻠﺖ ﺗﺎن اﺳﺘﻔﺎدﻩ ﮐﻨﻴﺪ‪ .‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ‬

‫از ﮐﻼس ‪ AppletWindow‬ﮐﻪ ﺑﻮﺳﻴﻠﻪ ﻣﺎﻳﮑﻞ ﺗﺮﻳﮑﻮﺑﻮف ﻧﻮﺷﺘﻪ ﺷﺪﻩ اﺳﺘﻔﺎدﻩ ﻧﻤﺎﻳﻴﺪ‪ .‬اﻳﻦ ﮐﻼس ﺑﺮای ﺷﻤﺎ ﻓﺮﻳﻤﯽ را‬

‫ﺑﻮﺝﻮد ﻣﯽ اورد‪ .‬ﮐﻪ ﺑﺎ اﺳﺘﻔﺎدﻩ از ان ﻣﯽ ﺗﻮاﻧﻴﺪ اﭘﻠﺖ هﺎ را ﻣﺴﺘﻘﻴﻤﺎ در درون ‪ BlueJ‬اﺝﺮا ﻧﻤﺎﻳﺪ‪ .‬ﺑﻪ ﮔﻮﻧﻪ ای ﮐﻪ ﻣﺘﺪهﺎی‬

‫ﻋﺎدی ﻣﺮﺑﻮط ﺑﻪ رﻓﻊ ﺧﻄﺎ ﮐﺎر ﮐﻨﻨﺪ‪ .‬ﺷﻤﺎ اﻳﻦ ﮐﻼس و ﻳﮏ ﻧﺴﺨﻪ ﻧﻤﻮﻧﻪ از ان را ﻣﯽ ﺗﻮاﻧﻴﺪ در ﺑﺨﺶ ‪ Resource‬ﺳﺎﻳﺖ‬

‫‪ BlueJ‬ﺑﻴﺎﺑﻴﺪ‪.‬‬

‫ﻓﺼﻞ ‪ - ١٠‬اﻋﻤﺎل دﻳﮕﺮ‬

‫‪٣٣‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫‪ ( ١-١٠‬ﺑﺎز ﮐﺮدن ﭘﮑﻴﺞ هﺎی ﻏﻴﺮ ‪ BlueJ‬در ‪BlueJ‬‬

‫ﺧﻼﺻﻪ ‪ :‬ﺑﺮای ﺑﺎز ﮐﺮدن ﭘﮑﻴﺞ هﺎی ﻏﻴﺮ ‪ BlueJ‬از ﻣﻨﻮی ‪ Project‬ﮔﺰﻳﻨﻪ ‪ Open Non-BlueJ‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ BlueJ‬ﺑﻪ ﺷﻤﺎ اﺝﺎزﻩ ﻣﯽ دهﺪ ﺗﺎ ﭘﮑﻴﺞ هﺎی را ﮐﻪ در ﺧﺎرج از ﻣﺤﻴﻂ ‪ BlueJ‬اﻳﺠﺎد ﺷﺪﻩ در درون ‪ BlueJ‬ﻣﺸﺎهﺪﻩ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﺑﺮای اﻧﺠﺎم اﻳﻨﮑﺎر از ﻣﻨﻮی ‪ Project‬ﮔﺰﻳﻨﻪ ‪ Open Non BlueJ‬را اﻧﺘﺨﺎب ﮐﺮدﻩ ‪ .‬ﺳﻴﺴﺘﻢ از ﺷﻤﺎ ﻣﮑﺎن و ﭘﻮﺷﻪ ای را ﮐﻪ‬

‫ﻗﺼﺪ دارﻳﺪ اﻧﺮا ﺑﺎز ﮐﻨﻴﺪ‪ .‬ﺳﻮال ﺧﻮاهﺪ ﮐﺮد‪.‬‬

‫‪ ( ٢-١٠‬اﺿﺎﻓﻪ ﮐﺮدن ﮐﻼس هﺎی ﻣﻮﺝﻮد ﺑﻪ ﭘﺮوژﻩ ﺗﺎن‬

‫ﺧﻼﺻﻪ ‪ :‬ﮐﻼس هﺎ را ﻣﯽ ﺗﻮاﻧﻴﺪ از ﺝﺎﻳﯽ ﺧﺎرج از ﭘﺮوژﻩ ‪ ،‬ﺑﻪ ﭘﺮوژﻩ اﺿﺎﻓﻪ ﮐﻨﻴﺪ ‪ .‬ﺑﺮای اﻳﻨﮑﺎر از ﮔﺰﻳﻨﻪ ‪Add Class From file‬‬

‫ﺑﻬﺮﻩ ﺧﻮاهﻴﻢ ﺝﺴﺖ‪.‬‬

‫ﮔﺎهﯽ اوﻗﺎت ﺷﻤﺎ ﻧﻴﺎز دارﻳﺪ ﺗﺎ از ﮐﻼﺳﯽ اﺳﺘﻔﺎدﻩ ﮐﻨﻴﺪ ﮐﻪ در ﺧﺎرج از ﻣﺤﻴﻂ ‪ BlueJ‬ﻗﺮار دارد‪ .‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﺳﺘﺎد ﺷﻤﺎ ﺑﻪ ﺷﻤﺎ‬

‫ﮐﻼس ﺝﺎوای دادﻩ ﺗﺎ از ﺁن در ﭘﺮوژﻩ ﺗﺎن اﺳﺘﻔﺎدﻩ ﮐﻨﻴﺪ‪ .‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﻪ ﺳﺎدﮔﯽ ﺑﺎ اﻧﺘﺨﺎب ﮔﺰﻳﻨﻪ ‪ Add Class Form file‬از‬

‫ﻣﻨﻮی ‪ Edit‬ﺑﺮﻧﺎﻣﻪ ‪ ،‬ﮐﻼﺳﯽ را ﮐﻪ در ﺧﺎرج از ﭘﺮوژﻩ ﺗﺎن ﻗﺮار دارد‪ .‬ﺑﻪ ﭘﺮوژﻩ اﺿﺎﻓﻪ ﻧﻤﺎﻳﻴﺪ‪ .‬ﺷﻤﺎ ﺑﺎ اﻳﻦ روش ﻓﺎﻳﻞ هﺎی‬

‫ﺳﻮرس ﺝﺎوا ) ﻳﻌﻨﯽ ﻓﺎﻳﻞ هﺎی ﮐﻪ ﺑﻪ ‪ .java‬ﺧﺘﻢ ﺷﺪﻩ اﻧﺪ ( را ﺑﻪ ﭘﺮوژﻩ ﺗﺎن وارد ﻧﻤﺎﻳﻴﺪ‪ .‬هﻨﮕﺎﻣﯽ ﮐﻪ ﺷﻤﺎ ﮐﻼس ﻣﻮرد ﻧﻈﺮ را‬

‫ﺑﻪ ﭘﺮوژﻩ ﺗﺎن اﺿﺎﻓﻪ ﻣﯽ ﮐﻨﻴﺪ‪ .‬ﻳﮏ ﻧﺴﺨﻪ از ان در ﭘﻮﺷﻪ ﭘﺮوژﻩ ﮐﭙﯽ ﻣﯽ ﺷﻮد‪ .‬اﻳﻦ ﻋﻤﻞ دﻗﻴﻘﺎ ﺷﺒﻴﻪ ﺑﻪ اﻳﻦ اﺳﺖ ﮐﻪ ﺷﻤﺎ‬

‫ﻳﮏ ﮐﻼس اﻳﺠﺎد ﮐﺮدﻩ وﺗﻤﺎم ﮐﺪهﺎی ﺁﻧﺮا ﺧﻮدﺗﺎن ﺗﻮﻟﻴﺪ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫روش دﻳﮕﺮ ﺑﺮای اﺿﺎﻓﻪ ﮐﺮدن ﻳﮏ ﮐﻼس ﺑﻪ ﭘﺮوژﻩ ‪ ،‬ﺑﺪﻳﻦ ﺻﻮرت ﻣﯽ ﺑﺎﺷﺪ ﮐﻪ ﺷﻤﺎ ﻓﺎﻳﻞ ﺳﻮرس ﺝﺎوا را در ﭘﻮﺷﻪ ﭘﺮوژﻩ‬

‫ﮐﭙﯽ ﮐﻨﻴﺪ‪ .‬هﻨﮕﺎﻣﯽ ﮐﻪ دوﺑﺎرﻩ ﭘﺮوژﻩ را ﺑﻮﺳﻴﻠﻪ ‪ BlueJ‬ﺑﺎز ﮐﻨﻴﺪ‪ .‬ﺧﻮاهﻴﺪ دﻳﺪ ﮐﻪ ‪ BlueJ‬ﮐﻼس ﻣﻮرد ﻧﻈﺮ را در ﻧﻤﺎﻳﺶ‬

‫ﺗﺮﺳﻴﻤﯽ ﻧﻤﺎﻳﺶ ﺧﻮاهﺪ داد‪.‬‬

‫‪ (٣-١٠‬ﻓﺮاﺧﻮاﻧﯽ ﻣﺘﺪهﺎی ‪ main‬و ‪: static‬‬

‫ﺧﻼﺻﻪ ‪:‬ﻣﺘﺪهﺎی ‪ static‬را ﻣﯽ ﺗﻮان از ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ ﮐﻼس ﻓﺮاﺧﻮاﻧﯽ ﮐﺮد‪.‬‬

‫ﭘﺮوژﻩ ‪ hello‬را از ﭘﻮﺷﻪ ‪ examples‬ﺑﺎز ﮐﻨﻴﺪ‪ .‬ﺗﻨﻬﺎ ﮐﻼس اﻳﻦ ﭘﺮوژﻩ ) ‪ ( Hello Class‬ﺑﻮﺳﻴﻠﻪ ﻳﮏ ﻣﺘﺪ ‪ main‬اﺳﺘﺎﻧﺪارد‬

‫ﺗﻌﺮﻳﻒ ﺷﺪﻩ اﺳﺖ‪ .‬ﺑﺮ روی ﮐﻼس ﮐﻠﻴﮏ راﺳﺖ ﮐﺮدﻩ ‪ ،‬ﻣﻨﻮی ﮐﻼس ﺗﻨﻬﺎ ﺷﺎﻣﻞ ﺳﺎزﻧﺪﻩ ﮐﻼس ﻧﻴﺴﺖ ‪ .‬ﺑﻠﮑﻪ ﻣﺘﺪ اﺳﺘﺎﺗﻴﮏ ‪main‬‬

‫هﻢ ﻧﻤﺎﻳﺶ دادﻩ ﻣﯽ ﺷﻮد‪ .‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﻣﺘﺪ ‪ mian‬را از اﻳﻦ ﻣﻨﻮ ﻓﺮاﺧﻮاﻧﯽ ﻧﻤﺎﻳﻴﺪ‪ .‬ﺗﻤﺎم ﻣﺘﺪهﺎی اﺳﺘﺎﺗﻴﮏ را ﻣﯽ ﺗﻮان ﺷﺒﻴﻪ ﺑﻪ‬

‫هﻤﻴﻦ ﻣﻮرد ﻓﺮاﺧﻮاﻧﯽ ﻧﻤﻮد‪.‬‬

‫ﻣﺘﺪ اﺳﺘﺎﻧﺪارد ‪ main‬ﺷﺎﻣﻞ ﺁراﻳﻪ ای از رﺷﺘﻪ هﺎ ﺑﻪ ﻋﻨﻮان ﭘﺎراﻣﺘﺮ ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺁراﻳﻪ ای از رﺷﺘﻪ هﺎ را ﺑﺮ اﺳﺎس‬

‫ﻗﻮاﻋﺪ ﺝﺎوا ﺑﺮای اﻳﻦ ﻣﺘﺪ ارﺳﺎل ﮐﻨﻴﺪ‪ .‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ‪:‬‬

‫}"‪{"one", "two", "three‬‬

‫در ﺿﻤﻦ ﺑﺎﻳﺪ ﺑﺮاﮐﺖ هﺎ را هﻢ ﺑﻪ ﻋﻨﻮان ﭘﺎراﻣﺘﺮ ارﺳﺎل ﮐﻨﻴﺪ‪.‬‬

‫‪٣۴‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﺗﻮﺝﻪ‪ :‬در ﺝﺎوا اﺳﺘﺎﻧﺪارد ﺷﻤﺎ ﻧﻤﯽ ﺗﻮاﻧﻴﺪ از ﺁراﻳﻪ هﺎی ﺛﺎﺑﺖ ﺑﻪ ﻋﻨﻮان ﺁرﮔﻮﻣﺎن ﺑﺮای ﻓﺮاﺧﻮاﻧﯽ ﻣﺘﺪهﺎ اﺳﺘﻔﺎدﻩ ﮐﻨﻴﺪ‪ .‬ﺷﻤﺎ از ﺁن هﺎ‬

‫ﻓﻘﻂ ﺑﺮای دادن ﻣﻘﺪار اوﻟﻴﻪ ﻣﯽ ﺗﻮاﻧﻴﺪ اﺳﺘﻔﺎدﻩ ﮐﻨﻴﺪ‪ .‬در ‪ BlueJ‬ﻣﺎ ﺑﻪ ﺷﻤﺎ اﺝﺎزﻩ ﻣﯽ دهﻴﻢ ﮐﻪ ﺷﻤﺎ ﺑﺮای ﺗﻌﺎﻣﻞ و ﻓﺮاﺧﻮاﻧﯽ ﻣﺘﺪ‬

‫‪ Main‬از ﺁراﻳﻪ هﺎی ﺛﺎﺑﺖ ﺑﻪ ﻋﻨﻮان ﭘﺎراﻣﺘﺮ اﺳﺘﻔﺎدﻩ ﻧﻤﺎﻳﺪ‪.‬‬

‫‪ (۴-١٠‬ﺗﻮﻟﻴﺪ اﺳﻨﺎد‬

‫ﺧﻼﺻﻪ ‪ :‬ﺑﺮای ﺗﻮﻟﻴﺪ ﺳﻨﺪ ﺑﺮای ﭘﺮوژﻩ ﺗﺎن ‪ ،‬از ﻣﻨﻮی ‪ Tools‬ﮔﺰﻳﻨﻪ ‪ Project Documentation‬را اﻧﺘﺨﺎب ﮐﻨﻴﺪ‪.‬‬

‫ﺷﻤﺎ ﺑﻮﺳﻴﻠﻪ ‪ BlueJ‬ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﺮای ﭘﺮوژﻩ ﺗﺎن در ﻓﺮﻣﺖ اﺳﺘﺎﻧﺪارد ‪ javadoc‬ﺳﻨﺪ ﺗﻮﻟﻴﺪ ﻧﻤﺎﻳﻴﺪ‪ .‬ﺑﺮای اﻧﺠﺎم اﻳﻦ ﮐﺎر از ﻣﻨﻮی‬

‫‪ Tools‬ﮔﺰﻳﻨﻪ ‪ Project Documentation‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫ﺑﺎ اﻳﻦ ﮐﺎر ﺑﺮﻧﺎﻣﻪ ﺑﺮای ﺗﻤﺎم ﮐﻼس هﺎی ﻣﻮﺝﻮد در ﭘﺮوژﻩ ﺗﺎن ﺑﺎ اﺳﺘﻔﺎدﻩ ﮐﻼس هﺎی ﺳﻮرس ﺷﺎن ﺳﻨﺪ ﺗﻮﻟﻴﺪ ﻣﯽ ﮐﻨﺪ و ﻣﺮورﮔﺮ وب‬

‫را ﺑﺮای ﻧﻤﺎﻳﺶ اﻧﻬﺎ ﺑﺎز ﻣﯽ ﻧﻤﺎﻳﺪ‪.‬‬

‫ﺷﻤﺎ هﻤﭽﻨﻴﻦ ﻣﯽ ﺗﻮاﻧﻴﺪ ﺳﻨﺪ را ﺑﺮای ﻳﮏ ﮐﻼس ﺗﻮﻟﻴﺪ ﮐﺮدﻩ و ﺑﺒﻴﻨﻴﺪ‪ .‬ﺑﺮای اﻧﺠﺎم اﻳﻦ ﮐﺎر ﺑﻪ ﻣﺤﻴﻂ ﮐﺪ ﻧﻮﻳﺴﯽ ﮐﻼس ﻣﺮﺑﻮﻃﻪ ﺑﺮوﻳﺪ‪.‬‬

‫و ﺡﺎﻟﺖ ‪ Implementation‬را ﺑﻪ ‪ Interface‬ﺗﻐﻴﻴﺮ دهﻴﺪ‪ .‬در اﻳﻦ ﺡﺎﻟﺖ ﺷﻤﺎ ﺳﻨﺪ ‪ javadoc‬ﮐﻼس ﻣﺮﺑﻮﻃﻪ را ﺧﻮاهﻴﺪ دﻳﺪ‪.‬‬

‫‪ (۵-١٠‬ﮐﺎر ﮐﺮدن ﺑﺎ ﮐﺘﺎﺑﺨﺎﻧﻪ هﺎ‬

‫ﺧﻼﺻﻪ ‪ :‬ﺷﻤﺎ ﺑﺎ اﻧﺘﺨﺎب ﮔﺰﻳﻨﻪ ‪ Java Class Liberies‬از ‪ Help‬ﻣﯽ ﺗﻮاﻧﻴﺪ ﮐﻼس هﺎی اﺳﺘﺎﻧﺪارد ﺝﺎوا را ﻣﺸﺎهﺪﻩ ﮐﻨﻴﺪ‪.‬‬

‫هﻤﺎﻧﻄﻮر ﮐﻪ ﻣﯽ داﻧﻴﺪ ؛ هﻨﮕﺎﻣﯽ ﮐﻪ ﺷﻤﺎ ﺑﺎ ﺝﺎوا ﻳﮏ ﺑﺮﻧﺎﻣﻪ ﻣﯽ ﻧﻮﻳﺴﻴﺪ‪ .‬ﺷﻤﺎ ﺑﻪ ﮐﺘﺎﺑﺨﺎﻧﻪ اﺳﺘﺎﻧﺪارد ﺝﺎوا ﻣﺮاﺝﻌﻪ ﻣﯽ ﮐﻨﻴﺪ‪.‬‬

‫ﺷﻤﺎ ﺑﺮای دﻳﺪن اﺳﻨﺎد ﻣﺮﺑﻮط ﺑﻪ اﻳﻦ ﮐﺘﺎﺑﺨﺎﻧﻪ هﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ از ﻣﻨﻮی ‪ Help‬ﮔﺰﻳﻨﻪ ‪ Java Class Libraries‬را اﻧﺘﺨﺎب‬

‫ﮐﻨﻴﺪ‪ ) .‬اﻟﺒﺘﻪ ﺷﻤﺎ ﺑﺎﻳﺪ ‪ Online‬ﺑﺎﺷﻴﺪ (‬

‫اﻟﺒﺘﻪ اﮔﺮ اﺳﻨﺎد ﺝﺎوا را ﺑﻪ ﻃﻮر ﻣﺤﻠﯽ ﻧﺼﺐ ﮐﺮدﻩ اﻳﺪ در ﺡﺎﻟﺖ ‪ offline‬هﻢ ﻣﯽ ﺗﻮاﻧﻴﺪ اﻳﻦ ﮐﺎر را اﻧﺠﺎم دهﻴﺪ‪ .‬ﺑﺮای دﻳﺪن‬

‫ﺝﺰﺋﻴﺎت اﻳﻦ ﮐﺎر ﺑﻪ ﺳﺎﻳﺖ ‪ BlueJ‬ﻣﺮاﺝﻌﻪ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ ( ۶-١٠‬اﻳﺠﺎد اﺷﻴﺎ از ﮐﻼس هﺎی ﮐﺘﺎﺑﺨﺎﻧﻪ ای‬

‫ﺧﻼﺻﻪ ‪ :‬ﺑﺮای اﻳﺠﺎد اﺷﻴﺎ از ﮐﻼس هﺎی ﮐﺘﺎﺑﺨﺎﻧﻪ ای از ﻣﻨﻮی ‪ Tools‬ﮔﺰﻳﻨﻪ ‪ Use Library Class‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ BlueJ‬هﻤﭽﻨﻴﻦ ﺗﻮاﺑﻌﯽ را اراﺋﻪ ﻣﯽ دهﺪ ﺗﺎ ﺷﻤﺎ ﺑﺘﻮاﻧﻴﺪ از ﮐﻼس هﺎی ﮐﻪ ﺝﺰ ﭘﺮوژﻩ ﺗﺎن ﻧﻴﺴﺖ وﻟﯽ در ﮐﺘﺎﺑﺨﺎﻧﻪ ﻣﻮﺝﻮد اﺳﺖ‬

‫اﺷﻴﺎی اﻳﺠﺎد ﮐﻨﻴﺪ‪ .‬ﺑﺮای ﻣﺜﺎل ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﻴﺪ اﺷﻴﺎﻳﯽ از ﮐﻼس هﺎی ‪ String‬و ﻳﺎ ‪ ArrayList‬اﻳﺠﺎد ﮐﻨﻴﺪ‪ .‬اﻳﻦ ﻣﻮرد ﺑﺮای‬

‫ﺗﺠﺮﺑﻪ ﮐﺮدن ﮐﺎر ﮐﺮدن اﺷﻴﺎ اﻳﻦ ﮐﻼس هﺎ ﻣﯽ ﺗﻮاﻧﺪ ﺧﻴﻠﯽ ﻣﻔﻴﺪ ﺑﺎﺷﺪ‪.‬‬

‫ﺷﻤﺎ ﺑﺎ اﻧﺘﺨﺎب ‪ Use Library Class‬از ﻣﻨﻮی ‪ Tools‬ﻣﯽ ﺗﻮاﻧﻴﺪ از ﮐﺘﺎﺑﺨﺎﻧﻪ ﻳﮏ ﺷﯽ اﻳﺠﺎد ﮐﻨﻴﺪ‪ .‬ﭘﻨﺠﺮﻩ ای ﺑﺎز ﻣﯽ ﺷﻮد‬

‫ﮐﻪ ﺑﻪ ﺷﻤﺎ اﺝﺎزﻩ ﻣﯽ دهﺪ ﺗﺎ ﻧﺎم ﮐﺎﻣﻞ ﮐﻼس را وارد ﮐﻨﻴﺪ‪ ،‬ﻣﺎﻧﻨﺪ ‪ ) java.lang.String‬ﺑﺎﻳﺪ ﺗﻮﺝﻪ ﮐﻨﻴﺪ ﮐﻪ ﻧﺎم ﮐﺎﻣﻞ ﮐﻼس ﺑﺎﻳﺪ‬

‫ﺷﺎﻣﻞ ﭘﮑﻴﺞ هﺎی ﮐﻪ ﮐﻼس ﺝﺰ ﺁن اﺳﺖ ﺑﺎﺷﺪ (‬

‫ﻣﺤﻞ ورود ﻣﺘﻦ )( ﺷﺎﻣﻞ ﻳﮏ ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ اﺳﺖ ﮐﻪ ﺷﺎﻣﻞ ﻧﺎم ﺁﺧﺮﻳﻦ ﮐﻼس هﺎی اﺳﺖ ﮐﻪ ﺷﻤﺎ اﺳﺘﻔﺎدﻩ ﮐﺮدﻩ اﻳﺪ ﺑﺎ اﻧﺘﺨﺎب‬

‫‪٣۵‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫ﻳﮑﯽ از اﻳﻦ ﮐﻼس هﺎ و ﻓﺸﺎر دادن دﮐﻤﻪ ‪ ، Enter‬ﺗﻤﺎم ﺳﺎزﻧﺪﻩ هﺎ و ﻣﺘﺪهﺎی ‪ static‬ﮐﻼس ﻣﺮﺑﻮﻃﻪ ﻟﻴﺴﺖ ﻣﯽ ﺷﻮد‪.‬‬

‫هﺮ ﮐﺪام از اﻳﻦ ﺳﺎزﻧﺪﻩ هﺎ و ﻳﺎ ﻣﺘﺪهﺎی ‪ static‬را ﺑﺎ اﻧﺘﺨﺎب ﮐﺮدن ﻣﯽ ﺗﻮان ﻣﻮرد اﺳﺘﻔﺎدﻩ ﻗﺮار داد‪.‬‬

‫ﻓﺼﻞ ‪ --١١‬ﺧﻼﺻﻪ هﺎ‬

‫ﺷﺮوع ﮐﺮدن‬

‫‪ .١‬ﺑﺮای ﺑﺎز ﮐﺮدن ﭘﺮوژﻩ از ﻣﻨﻮی ‪ Project‬ﮔﺰﻳﻨﻪ ‪ open‬را اﻧﺘﺨﺎب ﮐﻨﻴﺪ‪.‬‬

‫‪ .٢‬ﺑﺮای اﻳﺠﺎ ﻳﮏ ﺷﯽ ‪ ،‬ﺳﺎزﻧﺪﻩ )‪ (constructor‬را از ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ )‪ Class (popup‬اﻧﺘﺨﺎب ﮐﻨﻴﺪ‪.‬‬

‫‪ .٣‬ﺑﺮای اﺝﺮاﻳﯽ ﮐﺮدن ﻳﮏ ﻣﺘﺪ ‪ ،‬ﺁﻧﺮا از ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ ﺷﯽ )‪ (object‬اﻧﺘﺨﺎب ﮐﻨﻴﺪ‪.‬‬

‫‪ .۴‬ﺑﺮای وﻳﺮاﻳﺶ ﮐﺮدن ﺳﻮرس ﻳﮏ ﮐﻼس ﺑﺮ روی ﺁﻳﮑﻮن ﮐﻼس دو ﺑﺎر ﮐﻠﻴﮏ ﮐﻨﻴﺪ‪.‬‬

‫‪ .۵‬ﺑﺮای ﮐﺎﻣﭙﺎﻳﻞ ﻳﮏ ﮐﻼس ‪ ،‬دﮐﻤﻪ ‪ compile‬ادﻳﺘﻮر را ﻓﺸﺎر دهﻴﺪ‪ .‬و ﺑﺮای ﮐﺎﻣﭙﺎﻳﻞ ﻳﮏ ﭘﺮوژﻩ دﮐﻤﻪ ‪ compile‬ﭘﻨﺠﺮﻩ‬

‫ﭘﺮوژﻩ را ﻓﺸﺎر دهﻴﺪ‪.‬‬

‫‪ .۶‬اﮔﺮ در هﻨﮕﺎم ﮐﺎﻣﭙﺎﻳﻞ ﮐﺮدن ﺑﺎ ﭘﻴﺎم ﺧﻄﺎﻳﯽ ﻣﻮاﺝﻪ ﺷﺪﻳﺪ‪ .‬ﺑﺎ ﻓﺸﺎر دادن ﻋﻼﻣﺖ ﺳﻮال ) ؟ ( در ﻣﺤﻴﻂ ﮐﺪﻧﻮﻳﺴﯽ اﻃﻼﻋﺎت‬

‫ﺑﻴﺸﺘﺮی در ﻣﻮرد ﺁن ﺧﻄﺎ ﺑﺪﺳﺖ اورﻳﺪ‪.‬‬

‫اﻧﺠﺎم اﻋﻤﺎل ﺑﻴﺸﺘﺮ‬

‫‪ .٧‬ﻧﺎﻇﺮ اﺷﻴﺎ ﺑﻪ ﺷﻤﺎ اﺝﺎزﻩ ﻣﯽ دهﺪ ﺑﺎ ﭼﮏ ﮐﺮدن ﻣﻮﻗﻌﻴﺖ دروﻧﯽ اﺷﻴﺎ ﻳﮏ ﺳﺮی از رﻓﻊ ﺧﻄﺎهﺎی ﺳﺎدﻩ را اﻧﺠﺎم دهﻴﺪ‪.‬‬

‫‪ .٨‬ﺑﺎ ﮐﻠﻴﮏ ﮐﺮدن ﺑﺮ روی ﺁﻳﮑﻮن اﺷﻴﺎ ﻣﯽ ﺗﻮان ﭘﺎراﻣﺘﺮهﺎی را ﺑﻪ ﻣﺘﺪهﺎی اﻧﻬﺎ ارﺳﺎل ﻧﻤﻮد‪.‬‬

‫اﻳﺠﺎد ﭘﺮوژﻩ ﺝﺪﻳﺪ‬

‫‪ .٩‬ﺑﺮای اﻳﺠﺎد ﭘﺮوژﻩ ﺝﺪﻳﺪ از ﻣﻨﻮی ‪ Project‬ﮔﺰﻳﻨﻪ ‪ New….‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ .١٠‬ﺑﺮای اﻳﺠﺎد ﮐﻼس ﺝﺪﻳﺪ دﮐﻤﻪ ‪ New class‬را ﻓﺸﺎر دهﻴﺪ‪ .‬ﻧﺎم ﻣﺸﺨﺼﯽ ﺑﺮای ﮐﻼس ﻗﺮار دهﻴﺪ‪.‬‬

‫‪ .١١‬ﺑﺮای اﻳﺠﺎد ﻳﮏ ﭘﻴﮑﺎن )‪ . (Arrow‬دﮐﻤﻪ ‪ Arrow‬را ﻓﺸﺎر دهﻴﺪ‪ .‬و ﺁﻧﺮا ﺑﺮ روی ﺻﻔﺤﻪ ﻃﺮاﺡﯽ ‪ Drag‬ﮐﻨﻴﺪ‪.‬‬

‫ﻳﺎ اﻳﻨﮑﻪ ﻣﯽ ﺗﻮاﻧﻴﺪ ﻣﺴﺘﻘﻴﻤﺎ در ﻣﺤﻴﻂ ﮐﺪﻧﻮﻳﺴﯽ ‪ ،‬ﮐﺪ ﻣﺮﺑﻮﻃﻪ را وارد ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ .١٢‬ﺑﺮای ﺡﺬف ﮐﻼس و ﻳﺎ ﻳﮏ ﭘﻴﮑﺎن ‪ ،‬از ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ ﮔﺰﻳﻨﻪ ‪ remove‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫اﺳﺘﻔﺎدﻩ از ﻣﺤﻴﻂ ﮐﺪﻧﻮﻳﺴﯽ‬

‫‪ .١٣‬ﺑﺮای ﺷﺮوع ﮐﺎر ﺑﺎ ﻣﺤﻴﻂ ﮐﺪﻧﻮﻳﺴﯽ ‪ ،‬از ﻣﻨﻮی ‪ view‬ﮔﺰﻳﻨﻪ ‪ Show Code Pad‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ .١۴‬ﺑﺮای اﻣﺘﺤﺎن ﮐﺮدن دﺳﺘﻮرات ﺝﺎوا ‪ ،‬ﺁﻧﻬﺎ را در ﻣﺤﻴﻂ ﮐﺪﻧﻮﻳﺴﯽ ﺗﺎﻳﭗ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ .١۵‬ﺑﺮای اﻧﺘﻘﺎل اﺷﻴﺎ از ﻣﺤﻴﻂ ﮐﺪﻧﻮﻳﺴﯽ ﺑﻪ ﺷﺎﺧﻪ اﺷﻴﺎ ‪ ،‬ﺁﻳﮑﻮن ﮐﻮﭼﮏ اﺷﻴﺎ را درگ ﮐﻨﻴﺪ‪.‬‬

‫‪٣۶‬‬

‫‪www.rasekhoon.net‬‬
‫‪www.rasekhoon.net/software‬‬

‫‪.١۶‬ﺑﺮای دﻳﺪن اﺷﻴﺎ در ﻣﺤﻴﻂ ﮐﺪﻧﻮﻳﺴﯽ ‪ ،‬ﺑﺮ روی ﺁﻳﮑﻮن ﮐﻮﭼﮏ اﺷﻴﺎ دوﺑﺎر ﮐﻠﻴﮏ ﮐﻨﻴﺪ‪.‬‬

‫‪ .١٧‬دﺳﺘﻮراﺗﯽ ﮐﻪ در ﻣﺤﻴﻂ ﮐﺪﻧﻮﻳﺴﯽ ﺗﺎﻳﭗ ﻣﯽ ﻧﻤﺎﻳﻴﺪ‪ .‬اﺝﺮاﻳﯽ هﺴﺘﻨﺪ‪.‬‬

‫‪ .١٨‬ﺑﺮای وارد ﮐﺮدن دﺳﺘﻮرات ﭼﻨﺪ ﺧﻄﯽ در ﭘﺎﻳﺎن ﺧﻂ ‪ enter+shift‬را ﻓﺸﺎر دهﻴﺪ‪.‬‬

‫‪ .١٩‬ﻣﺘﻐﻴﻴﺮهﺎی ﻣﺤﻠﯽ ﻣﯽ ﺗﻮاﻧﻨﺪ در دﺳﺘﻮرات ﺗﮏ ﺧﻄﯽ ﻳﺎ ﭼﻨﺪ ﺧﻄﯽ اﺳﺘﻔﺎدﻩ ﺷﻮﻧﺪ‪ .‬ﻧﺎم هﺎی اﺷﻴﺎ در ﻓﻴﻠﺪهﺎی ﻧﻤﻮﻧﻪ اﺷﻴﺎ‬

‫ذﺧﻴﺮﻩ ﻣﯽ ﺷﻮﻧﺪ‪.‬‬

‫‪ .٢٠‬ﺑﺎ اﺳﺘﻔﺎدﻩ از ﻧﺸﺎﻧﮕﺮهﺎی ﺑﺎﻻ و ﭘﺎﻳﻴﻦ ﺻﻔﺤﻪ ﮐﻠﻴﺪ ﺑﺮای دﻳﺪن ﺗﺎرﻳﭽﻪ ورودی هﺎ اﺳﺘﻔﺎدﻩ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫رﻓﻊ ﺧﻄﺎ‬

‫‪ .٢١‬ﺑﺮای اﻳﺠﺎد ‪ Breakpoint‬در ﻣﻨﻄﻘﻪ ‪ breakpoint‬در ﺳﻤﺖ ﭼﭗ ﻣﺤﻴﻂ ﮐﺪﻧﻮﻳﺴﯽ ﮐﻠﻴﮏ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ .٢٢‬ﺑﺮای دﻳﺪن ﮐﺎﻣﭙﺎﻳﻞ ﺧﻂ ﺑﻪ ﺧﻂ ﺑﺮﻧﺎﻣﻪ از ﮔﺰﻳﻨﻪ هﺎی ‪ Step‬و ‪ Step into‬در دﻳﺒﺎﮔﺮ ﺑﺮﻧﺎﻣﻪ اﺳﺘﻔﺎدﻩ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ .٢٣‬ﻧﻈﺎرت ﮐﺮدن ﺑﺮ ﻣﺘﻐﻴﻴﺮهﺎ ﺳﺎدﻩ اﺳﺖ – ﺗﻤﺎم اﻧﻬﺎ ﺑﺼﻮرت اﺗﻮﻣﺎﺗﻴﮏ در دﻳﺒﺎﮔﺮ ﻧﻤﺎﻳﺶ دادﻩ ﻣﯽ ﺷﻮﻧﺪ‪.‬‬

‫‪ .٢۴‬اﻳﺠﺎد ﺗﻮﻗﻒ ﻳﺎ ﺧﺎﺗﻤﻪ دادن ﺑﻪ ﺑﺮﻧﺎﻣﻪ را ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﺎ ﮔﺰﻳﻨﻪ هﺎی ‪ Halt‬و ‪ Terminate‬دﻳﺒﺎﮔﺮ اﻧﺠﺎم دهﻴﺪ‪.‬‬

‫اﻳﺠﺎد ﺑﺮﻧﺎﻣﻪ هﺎی ﺧﻮد اﺗﮑﺎ ) ﺧﻮد اﺝﺮا (‬

‫‪ .٢۵‬ﺑﺮای اﻳﺠﺎد ﺑﺮﻧﺎﻣﻪ هﺎی ﺧﻮد اﺝﺮا از ﻣﻨﻮی ‪ project‬ﮔﺰﻳﻨﻪ …‪ create jar file‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫اﻳﺠﺎد اﭘﻠﺖ هﺎ‬

‫‪ .٢۶‬ﺑﺮای اﺝﺮا اﭘﻠﺖ هﺎ از ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ اﭘﻠﺖ ﮔﺰﻳﻨﻪ ‪ Run Applet‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ .٢٧‬ﺑﺮای اﻳﺠﺎد اﭘﻠﺖ هﺎ دﮐﻤﻪ ‪ New class‬را ﻓﺸﺎر دادﻩ و ﮔﺰﻳﻨﻪ ‪ Applet‬را از اﻧﻮاع ﮐﻼس اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫اﻋﻤﺎل دﻳﮕﺮ‬

‫‪ .٢٨‬ﭘﮑﻴﺞ هﺎی ﻏﻴﺮ ‪ blueJ‬را ﻣﯽ ﺗﻮان ﺑﺎ اﺳﺘﻔﺎدﻩ از ﻣﻨﻮی ‪ Project‬و اﻧﺘﺨﺎب ﮔﺰﻳﻨﻪ ‪ Open Non BlueJ‬ﺑﺎز ﮐﺮد‪.‬‬

‫‪ .٢٩‬ﮐﻼس هﺎی ﮐﻪ ﺧﺎرج از ﻣﺤﻴﻂ ‪ BlueJ‬هﺴﺘﻨﺪ را ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﻣﻨﻮی ‪ Edit‬و اﻧﺘﺨﺎب ﮔﺰﻳﻨﻪ‬

‫‪ Add Class from file…..‬اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ .٣٠‬ﻣﺘﺪهﺎی ‪ static‬ﮐﻼس را ﻣﯽ ﺗﻮاﻧﻴﺪ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﻣﻨﻮی ﺑﺎزﺷﻮﻧﺪﻩ ﮐﻼس ﻓﺮاﺧﻮاﻧﯽ ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ .٣١‬ﺑﺮای ﺗﻮﻟﻴﺪ ﺳﻨﺪ ﺑﺮای ﭘﺮوژﻩ ﺗﺎن از ﻣﻨﻮی ‪ Tools‬ﮔﺰﻳﻨﻪ ‪ Project Documentation‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ .٣٢‬ﺑﺮای دﻳﺪن ﮐﻼس هﺎی اﺳﺘﺎﻧﺪارد ﺝﺎوا از ﻣﻨﻮی ‪ Help‬ﮔﺰﻳﻨﻪ ‪ java standard Libraries‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪ .٣٣‬ﺑﺮای اﻳﺠﺎد اﺷﻴﺎ از ﮐﻼس هﺎی ﮐﺘﺎﺑﺨﺎﻧﻪ ای از ﻣﻨﻮی ‪ Tools‬ﮔﺰﻳﻨﻪ ‪ Use Class Library‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ‪.‬‬

‫‪٣٧‬‬

‫‪www.rasekhoon.net‬‬