.Archivetempjava Be Zabane Sade

‫جاوا به زبان ساده‬
‫‪ :‬ابراهیمی‪ ،‬یونس ‪0631 -‬‬ ‫سر شناسه‬
‫‪ :‬جاوا به زبان ساده ‪ /‬مؤلف‪ :‬یونس ابراهیمی‬ ‫عنوان و نام پدید آورنده‬
‫‪ :‬نبض دانش‪ ،‬تهران ‪0613 -‬‬ ‫مشخصات نشر‬
‫‪ 303 :‬صفحه مصور‬ ‫مشخصات ظاهری‬
‫‪:‬‬ ‫شابک‬
‫‪ :‬فیبا‬ ‫وضعیت فهرست نویسی‬
‫‪ :‬جاوا (زبان برنامه نویسی کامپیوتر)‬ ‫موضوع‬
‫‪:‬‬ ‫رده بندی دیویی‬
‫‪:‬‬ ‫رده بندی کنگره‬
‫‪:‬‬ ‫شماره کتاب شناسی ملی‬
‫این اثر مشمول قانون حمایت مؤلفان‪ ،‬مصنفان و هنرمندان مصوب ‪ 0631‬است‪ .‬هر کس تمام یا قسمتی از این اثر را بدون اجازه ناشر‪ ،‬نشر یا پخش کند‬
‫مورد پیگرد قانی قرار خواهد گرفت‪.‬‬
‫‪ :‬جاوا به زبان ساده‬ ‫عنوان‬
‫‪ :‬یونس ابراهیمی‬ ‫مؤلف‬
‫‪ :‬نبض دانش‬ ‫ناشر‬
‫‪0613 :‬‬ ‫سال چاپ‬
‫‪ :‬دوم‬ ‫نوبت چاپ‬
‫‪011 :‬‬ ‫تیراژ‬
‫‪ 00555 :‬ناموت‬ ‫قیمت‬

‫تقدیم به‬
‫همسر و پسر عزیزم‬

‫مبانی زبان جاوا‬
‫جاوا چیست؟ ‪31 ...........................................................................................................................................................‬‬
‫‪ JVM‬چیست ؟ ‪31 ....................................................................................................................................................‬‬
‫‪ NetBeans‬و ‪31 .................................................................................................................................................. JDK‬‬
‫نصب ‪ NetBeans‬و ‪31 ...................................................................................................................................... JDK‬‬
‫پیکربندی‪51 .................................................................................................................................................... JDK‬‬
‫ساخت یک برنامه ساده در‪13 ................................................................................................................................ JAVA‬‬
‫استفاده از ‪ IntelliSense‬در ‪31 ...................................................................................................................... NetBeans‬‬
‫رفع خطاها ‪31 ..........................................................................................................................................................‬‬
‫کاراکترهای کنترلی ‪13.................................................................................................................................................‬‬
‫توضیحات ‪15 ...........................................................................................................................................................‬‬
‫متغیر ‪11 .....................................................................................................................................................................‬‬
‫انواع ساده ‪11 ..........................................................................................................................................................‬‬
‫استفاده از متغیرها ‪11 ...............................................................................................................................................‬‬
‫ثابت ‪13 ..................................................................................................................................................................‬‬
‫تبدیل ضمنی ‪15........................................................................................................................................................‬‬
‫تبدیل صریح ‪11 .......................................................................................................................................................‬‬
‫عبارات و عملگرها ‪11.......................................................................................................................................................‬‬
‫عملگرهای ریاضی ‪11..................................................................................................................................................‬‬
‫عملگرهای تخصیصی ‪16..............................................................................................................................................‬‬
‫عملگرهای مقایسه ای ‪13 .............................................................................................................................................‬‬
‫عملگرهای منطقی ‪15 .................................................................................................................................................‬‬
‫عملگرهای بیتی ‪13 ....................................................................................................................................................‬‬
‫تقدم عملگرها ‪03.......................................................................................................................................................‬‬
‫گرفتن ورودی از کاربر ‪05..................................................................................................................................................‬‬
‫ساختارهای تصمیم ‪03 ...................................................................................................................................................‬‬
‫دستور ‪01 ............................................................................................................................................................ if‬‬
‫دستور‪00 ..................................................................................................................................................... if else‬‬
‫دستور ‪ if‬تو در تو ‪06 ..................................................................................................................................................‬‬

‫عملگر شرطی ‪63 ........................................................................................................................................................‬‬
‫دستور ‪ if‬چندگانه ‪63 ...................................................................................................................................................‬‬
‫استفاده از عملگرهای منطقی ‪61 ...................................................................................................................................‬‬
‫دستور ‪61..................................................................................................................................................... switch‬‬
‫تکرار ‪333 ......................................................................................................................................................................‬‬
‫حلقه ‪333 ....................................................................................................................................................... While‬‬
‫حلقه‪335 .................................................................................................................................................. do While‬‬
‫حلقه ‪331 ............................................................................................................................................................ for‬‬
‫آرایهها ‪331 ...............................................................................................................................................................‬‬
‫حلقه ‪336 .................................................................................................................................................... foreach‬‬
‫آرایههای چند بعدی ‪333...............................................................................................................................................‬‬
‫آرایه دندانه دار ‪331 .....................................................................................................................................................‬‬
‫متد ‪336........................................................................................................................................................................‬‬
‫مقدار برگشتی از یک متد ‪353 .......................................................................................................................................‬‬
‫پارامتر و آرگومان ‪351 .................................................................................................................................................‬‬
‫ارسال آرگومان به روش مقدار ‪351..................................................................................................................................‬‬
‫ارسال آرایه به عنوان آرگومان ‪351...................................................................................................................................‬‬
‫محدوده متغیر ‪356.....................................................................................................................................................‬‬
‫آرگومان های متغیر)‪313.............................................................................................................................. (VarArgs‬‬
‫سربارگذاری متدها ‪315 ...............................................................................................................................................‬‬
‫بازگشت)‪311 ........................................................................................................................................ (Recursion‬‬
‫شمارش)‪311 ........................................................................................................................................ (Enumeration‬‬
‫آرگومان های خط فرمان)‪310 ............................................................................................ (Command Line Arguments‬‬
‫برنامه نویسی شیء گرا)‪316 ................................................................................................................................... (OOP‬‬
‫کالس ‪333................................................................................................................................................................‬‬
‫سازنده ‪331 ..............................................................................................................................................................‬‬
‫سطح دسترسی ‪330 ...................................................................................................................................................‬‬
‫کپسوله سازی)‪313 ........................................................................................................................... (Encapsulation‬‬
‫خواص)‪311 .......................................................................................................................................... (Properties‬‬
‫‪311 ......................................................................................................................................................... Package‬‬

‫وراثت ‪311 ...............................................................................................................................................................‬‬
‫سطح دسترسی ‪311...................................................................................................................................... Protect‬‬
‫اعضای ‪310 ................................................................................................................................................... static‬‬
‫‪316.......................................................................................................................................................... Override‬‬
‫کالس آبجکت)‪315........................................................................................................................ (java.lang.Object‬‬
‫‪ Boxing‬و‪311 ......................................................................................................................................... Unboxing‬‬
‫‪311 ................................................................................................................................................... aggregation‬‬
‫عملگر ‪316............................................................................................................................................. instanceof‬‬
‫رابط)‪303 ................................................................................................................................................ (Interface‬‬
‫کالسهای انتزاعی)‪303 ...................................................................................................................... (Abstract Class‬‬
‫کالس ‪ final‬و متد ‪301 ....................................................................................................................................... final‬‬
‫چند ریختی)‪301 ............................................................................................................................. (Polymorphism‬‬
‫کالسهای تو در تو)‪365 ....................................................................................................................... (nested classes‬‬
‫کالس داخلی استاتیک و غیر استاتیک ‪365 .......................................................................................................................‬‬
‫کالسهای محلی)‪361........................................................................................................................ (Local Classes‬‬
‫کالس داخلی بی نام)‪361................................................................................................... (Anonymous Inner Class‬‬
‫ایجاد آرایه ای از کالسها ‪360 ........................................................................................................................................‬‬
‫عبارات المبدا ‪366 .......................................................................................................................................................‬‬
‫مدیریت استثناءها و خطایابی ‪531 ....................................................................................................................................‬‬
‫استثناءهای اداره نشده ‪533 .........................................................................................................................................‬‬
‫دستور ‪ try‬و ‪531 ............................................................................................................................................. catch‬‬
‫بلوک ‪530 ...................................................................................................................................................... finally‬‬
‫ایجاد استثناء ‪536 ......................................................................................................................................................‬‬
‫تعریف یک استثناء توسط کاربر ‪533 ................................................................................................................................‬‬
‫مقایسه اشیاء با استفاده از رابط های ‪ Comparable‬و‪535............................................................................ Comparator‬‬
‫کلکسیونها)‪536....................................................................................................................................... (Collections‬‬
‫کالس ‪553 ................................................................................................................................................ ArrayList‬‬
‫‪ Iterator‬و‪553 ...................................................................................................................................... ListIterator‬‬
‫‪550............................................................................................................................................................ Vector‬‬
‫‪513................................................................................................................................................................. List‬‬
515................................................................................................................................................................ Map
511.................................................................................................................................................................. Set
516......................................................................................................................................................... HashSet
533....................................................................................................................................................... LinkedList
531............................................................................................................................................................ Queue
513 ....................................................................................................................................................... HashMap
511 ....................................................................................................................................................... TreeMap
516.......................................................................................................................................................... TreeSet
511 .............................................................................................................................................................. Stack
510................................................................................................................................................. PriorityQueue
511 ..................................................................................................................................................... Hashtable
511............................................................................................................................................................. BitSet
505 .................................................................................................................................................... ArrayDeque
501...................................................................................................................................................... Properties
563............................................................................................................................................. (Generics)‫جنریک ها‬
565 .................................................................................................................................................. ‫متدهای جنریک‬
563 ..................................................................................................................................................... ‫کالس جنریک‬
561 ............................................................................................................... (Generic Collection)‫کلکسیون عمومی‬
561 ................................................................................................................................................. Object Initializer
SWING
135 ................................................................................................................................................ ‫برنامه نویسی ویژوال‬
131...................................................................................................................................................... ‫ چیست ؟‬AWT
131 ................................................................................................................................................. ‫ چیست ؟‬SWING
130 .................................................................................................................................. ‫ ساده‬Swing ‫ایجاد یک برنامه‬
133.............................................................................................................................................. JOptionPane‫کالس‬
133 ................................................................................................................................................... ‫کنترل کننده رویداد‬
153 ................................................................................................................................................................. ‫کنترلها‬
113 .............................................................................................................................................. ‫نامگذاری کنترلها‬

111 ................................................................................................................................................. JFrame‫کنترل‬
133 .......................................................................................................................... ‫مدیریت الیهها و چیدمان کنترلها‬
135 ................................................................................................................................................ BorderLayout
131 ................................................................................................................................................... CardLayout
130 ................................................................................................................................................... FlowLayout
113 ..................................................................................................................................................... GridLayout
115 ..................................................................................................................................................... BoxLayout
111 ................................................................................................................................... ‫ایجاد حاشیه برای کنترلها‬
111 ........................................................................................................................................... TitleBorder‫کالس‬
113 .......................................................................................................................................... MatteBorder‫کالس‬
115.................................................................................................................................................. JButton‫کنترل‬
111 ................................................................................................................................................... JLabel‫کنترل‬
111 ............................................................................................................... JPasswordField‫ و‬JTextField ‫کنترل‬
113 .............................................................................................................................................. JTextArea‫کنترل‬
111 ....................................................................................................................................... JRadioButton‫کنترل‬
111 ........................................................................................................................................... JCheckBox‫کنترل‬
116 .................................................................................................................................................. JPanel‫کنترل‬
103 ......................................................................................................................................... JComboBox‫کنترل‬
101 ...................................................................................................................................................... JList‫کنترل‬
100 ............................................................................................................................................... JSpinner‫کنترل‬
163 ................................................................................................................................................... JSlider‫کنترل‬
161........................................................................................................................................ JTabbedPane‫کنترل‬
335 .............................................................................................................................................. JMenuBar‫کنترل‬
336 ................................................................................................................................................ JToolBar‫کنترل‬
331 ..................................................................................................................................................... JTree‫کنترل‬
331 ...................................................................................................................................... JToggleButton‫کنترل‬
353................................................................................................................................... (Dialogs)‫کادرهای محاوره ای‬
355 ......................................................................................................................................... JFileChooser‫کنترل‬
313 ...................................................................................................................................... JColorChooser‫کنترل‬

‫کار با تاریخ‪ ،‬فایل و رشته‬
‫کالس‪311 .......................................................................................................................................................... Date‬‬
‫کالس‪331 ......................................................................................................................................................... Math‬‬
‫ایجاد عدد تصادفی ‪331 .................................................................................................................................................‬‬
‫رشتهها و عبارات با قاعده ‪313 ..........................................................................................................................................‬‬
‫کالس‪313 ..................................................................................................................................................... String‬‬
‫مقایسه رشتهها ‪315 .................................................................................................................................................‬‬
‫الحاق یا چسباندن رشتهها ‪313 ...................................................................................................................................‬‬
‫تکه تکه کردن رشتهها ‪311 .........................................................................................................................................‬‬
‫جستجوی رشتهها ‪311 ..............................................................................................................................................‬‬
‫تغییر بزرگی و کوچکی حروف یک رشته ‪316.....................................................................................................................‬‬
‫استخراج و جایگزین کردن رشتهها ‪313...........................................................................................................................‬‬
‫جایگزین کردن رشتهها با استفاده از متد‪315 ..................................................................................................... replace‬‬
‫فرمت بندی رشتهها و اعداد ‪311 ......................................................................................................................................‬‬
‫کالس‪310 ........................................................................................................................................ StringBuilder‬‬
‫‪313 ........................................................................................................................................................ File System‬‬
‫پکیج‪313 ................................................................................................................................................... Java IO‬‬
‫کالسهای ‪ Reader‬و‪315................................................................................................................................ Writer‬‬
‫کالسهای ‪ InputStream‬و‪313 ......................................................................................................... OutputStream‬‬
‫کالس‪311 ........................................................................................................................................................ File‬‬
‫کالس‪301 .............................................................................................................................. InputStreamReader‬‬
‫کالس‪300 ............................................................................................................................. OutputStreamWriter‬‬
‫کالس‪306............................................................................................................................... RandomAccessFile‬‬
‫کالس‪361 .......................................................................................................................... ByteArrayInputStream‬‬
‫کالس‪361........................................................................................................................ ByteArrayOutputStream‬‬
‫کالسهای ‪ ObjectInputStream‬و‪366 ..................................................................................... ObjectOutputStream‬‬
‫کالس‪131 ..................................................................................................................................... BufferedReader‬‬
‫کالس‪133........................................................................................................................................ BufferedWriter‬‬
‫کالس‪135 ......................................................................................................................................... StringReader‬‬

‫کالس‪133 ........................................................................................................................................... StringWriter‬‬
‫کالس‪131 ............................................................................................................................................. PrintWriter‬‬
‫زبان نشانه گذاری توسعه پذیر)‪153 ......................................................................................................................... (XML‬‬
‫مدیریت فایلهای‪151 ...................................................................................................................................... XML‬‬
‫ساخت ‪ XML‬با روش مبتنی بر‪113 ...................................................................................................................... DOM‬‬
‫ساخت ‪ XML‬با روش مبتنی بر‪111 ................................................................................................................. Stream‬‬
‫پرس و جوی محتوای ‪ XML‬با‪111 .................................................................................................................... XPath‬‬
‫استفاده از ‪111 .............................................................................................................................................. XPath‬‬
‫کار با بانک اطالعاتی‬

‫‪ MYSQL‬چیست؟ ‪135 ..................................................................................................................................................‬‬
‫مبانی‪131 .................................................................................................................................................. MYSQL‬‬
‫دستورات ‪131 ............................................................................................................................................. MYSQL‬‬
‫نصب سرور‪130 .............................................................................................................................................. MYSQL‬‬
‫نصب نرم افزار ‪ MYSQL Administrator‬و آشنایی با محیط آن ‪116 ......................................................................................‬‬
‫آشنایی با محیط‪111 ................................................................................................................ MYSQL Administrator‬‬
‫ایجاد جدول و دیتابیس با استفاده از محیط کنسول‪111.......................................................................................... MYSQL‬‬
‫ایجاد جدول و دیتابیس با استفاده از محیط‪111 ............................................................................ MYSQL Administrator‬‬
‫‪ JDBC‬چیست؟ ‪103 ......................................................................................................................................................‬‬
‫‪ JDBC Driver‬چیست؟ ‪101 ..........................................................................................................................................‬‬
‫ارتباط با بانک ‪101 ........................................................................................................................................................‬‬
‫اجرای دستورات بر روی بانک ‪100 .....................................................................................................................................‬‬
‫پاک کردن اشیاء بی استفاده و آزاد کردن حافظه ‪133..............................................................................................................‬‬
‫ثبت‪ ،‬حذف‪ ،‬ویرایش و انتخاب اطالعات با استفاده از‪135 ...................................................................................... NetBeans‬‬

‫مقدمه‬
‫همگام با پیشرفت فناوریهای دیگر‪ ،‬زبانهای برنامه نویسی نیز ارتقا پیدا کردند‪ .‬وقتی زبان ‪ JAVA‬طراحی و پیاده سازی شد‪ ،‬تحول بزرگی در‬
‫دنیای برنامه نویسی به وجود آمد‪ .‬این زبان برنامه نویسی موفق که در سال ‪ ۵۹۹۱‬به طور رسمی به بازار معرفی شد‪ ،‬توانست چنان محبوبیتی در‬
‫جهان پیدا کند که در حال حاضر در بیش از ‪ ۳‬میلیارد سیستم مورد استفاده قرار گرفته و تاکنون بیش از ‪ ۵۱۱۱‬جلد کتاب پیرامون آن به رشته تحریر‬
‫درآمده است‪ .‬خوشبختانه ‪ JAVA‬این روزها به عنوان یکی از دروس رشتههای کامپیوتر در دانشگاههای کشور تدریس میشود و این نشان از‬
‫تواناییها و اهمیت این زبان است‪ .‬منابع متعددی برای معرفی و به کارگیری زبان ‪ JAVA‬عرضه شده است که جای تقدیر و تشکر دارد‪ .‬اما کتاب‬
‫حاضر دارای ویژگیهای بارزی از جمله‪ ،‬بیان ساده مطالب‪ ،‬ارائه مثالهای متنوع‪ ،‬بررسی دقیق و موشکا فانه موضوعات و سلسله مراتب آموزشی‬
‫است‪ .‬مثالهایی که در کتاب ارائه شدهاند همگی دارای هدف خاصی هستند به طوریکه هر کدام‪ ،‬یک یا چند نکته زبان جاوا را به خواننده آموزش‬
‫میدهند ‪ .‬در این کتاب ما به شما نحوه برنامه نویسی به زبان جاوا را به صورت تصویری آموزش میدهیم‪ .‬سعی کنید حتما بعد از خواندن مباحث ‪،‬‬
‫آنها را به صورت عملی تمرین کنید و اینکه قابلیت و مفهوم کدها را بفهمید نه آنها را حفظ کنید ‪.‬‬
‫برای دریافت فایلها و آپدیتهای جدید این کتاب به سایت ‪ www.w3-farsi.com‬مراجعه فرمایید‪.‬‬
‫راههای ارتباط با نویسنده‬

‫‪www.w3-farsi.com :‬‬ ‫وب سایت‬
‫‪https://telegram.me/ebrahimi_younes :‬‬ ‫لینک تلگرام‬
‫‪@ebrahimi_younes :‬‬ ‫‪ ID‬تلگرام‬
‫‪younes.ebrahimi.1391@gmail.com :‬‬ ‫پست الکترونیکی‬

‫فصل اول‬
‫مبانی زبان جاوا‬

‫‪۵۳‬‬ ‫مبانی زبان جاوا‬
‫جاوا چیست؟‬
‫جاوا )‪ (JAVA‬یک زبان برنامه نویسی شیءگراست که نخستین بار توسط ‪( James Gosling‬جیمز گاسلینگ) در شرکت ‪Sun‬‬
‫‪ Microsystems‬ایجاد گردید‪ .‬در سال ‪ 3663‬شرکت ‪ Sun Microsystems‬در حال توسعه نرمافزاری برای استفاده ابزارهای الکترونیکی‬
‫بود که مسئولیت تیم‪ ،‬که آن را‪ ،‬تیم پروژه ‪ Green‬نامیدند‪ ،‬جیمز گاسلینگ بر عهده گرفت‪.‬‬
‫در سال ‪ 3663‬تیم تصمیم گرفت که زبان جدید را ‪ ( OAK‬بلوط) بنامند‪ .‬علت این نام گذاری وجود درختان بلوط در محوطه اطراف‬
‫ساختمان محل کار اعضای تیم ‪ Green‬بود‪ .‬در سال ‪ 3665‬تیم پروژه ‪ Green‬زبان جدیدی را معرفی کرد که با ابزارهای مختلف خانگی‬
‫و لمسی کار میکرد‪ .‬در سال ‪ 3661‬وب جهانی توسعه یافت و زبان ‪ OAK‬با معرفی ‪ Applet‬که قابلیت های زیادی به کامپیوترهای‬
‫متصل به وب میافزود‪ ،‬مشهور شد ‪.‬‬
‫در سال ‪ 3661‬زبان ‪ OAK‬به ‪ JAVA‬تغییر نام پیدا کرد و توسط ‪ Microsoft‬و ‪ Netscape‬پشتیبانی شد‪ .‬از آنجا که مراسم تغییر‬
‫نام در کافی شاپ برگزار شده بود و همچنین عالقه اعضای تیم ‪ Green‬به قهوه‪ ،‬یک فنجان قهوه داغ به عنوان نماد جاوا در نظر‬
‫گرفته شد‪ .‬معتبرترین داستان درباره دلیل این نامگذاری این است که‪ ،‬جیمز گاسلینگ به نوعی قهوه عالقه داشت‪ ،‬که در جزیرهای‬
‫به نام جاوا‪ ،‬که در اندونزی در جنوب شرقی آسیا است‪ ،‬می روید‪ .‬کال زبان برنامه نویسی جاوا به سه دسته کلی تقسیم می شود‪:‬‬
‫‪ JAVA SE‬یا ‪ JAVA Standard Edition‬برای نوشتن برنامه های کوچک دسکتاپی کاربرد دارد‪.‬‬ ‫‪‬‬
‫‪ JAVA ME‬یا ‪ JAVA Micro Edition‬برای برنامه نویسی برای منابع سخت افزاری (‪ )MEMORY ،CPU‬محدود‪ ،‬مثل‬ ‫‪‬‬
‫موبایل و لوازم خانگی کاربرد دارد‪.‬‬
‫‪ JAVA EE‬یا ‪ JAVA Enterprised Edition‬برای برنامه های بزرگ که معموال بر روی شبکه های بزرگ مخصوصا‬ ‫‪‬‬
‫اینترنت نصب و اجرا می شوند کاربرد دارد‪.‬‬

‫‪ w3-farsi.com‬تخصصی ترین سایت آموزش جاوا در ایران‬ ‫‪33‬‬
‫تاریخچه جاوا‬
‫از زمان انتشار اولین نسخه جاوا )‪ (java 1.0‬تا به امروز‪ ،‬شرکت ‪ Sun‬تقریبا هر دو سال یکبار نسخه ای جدیدی از این زبان را‬
‫منتشر می نماید‪ .‬در این نسخه تازه‪ ،‬معموال قابلیت های جدیدی افزوده شده و ایرادهای نسخه قبل رفع می شوند‪ .‬نکته قابل توجه‬
‫در مورد شماره گذاری نسخه های مختلف جاوا آن است که تا چهارمین نسخه آن شماره گذاری بصورت ‪ Java 1.x‬بود که ‪ x‬همان‬
‫شماره نسخه مورد نظر می باشد‪ .‬از نسخه پنجم به بعد شماره گذاری بصورت ‪ Java x‬تغییر یافت‪ .‬یعنی بجای اینکه نسخه پنجم‬
‫را بصورت ‪ Java 1.5‬نامگذاری کنند‪ ،‬بصورت ‪ java 5.0‬نامگذاری کردند‪ .‬در ادامه به معرفی نسخه های مختلف جاوا بر اساس‬
‫نسخه پایه ای آن یا همان نسخه استاندارد ))‪ (Standard Edition(SE‬می پردازیم‪ .‬این نسخه شامل همه ملزومات مورد نیاز‬
‫جهت ‪ Desktop Programming‬می باشد‪ .‬در جدول زیر نسخه های مختلف جاوا و ویژگی های آنها ذکر شده است‪:‬‬
‫تاریخ پیدایش‬ ‫نام کد‬ ‫نسخه‬
‫‪January 1996‬‬ ‫‪Oak‬‬ ‫‪java 1.0‬‬
‫‪February 1997‬‬ ‫‪java 1.1‬‬
‫‪December 1998‬‬ ‫‪playground‬‬ ‫‪J2SE 1.2‬‬
‫‪May 2000‬‬ ‫‪Kestrel‬‬ ‫‪J2SE 1.3‬‬
‫‪February 2002‬‬ ‫‪Merlin‬‬ ‫‪J2SE 1.4‬‬
‫‪September 2004‬‬ ‫‪Tiger‬‬ ‫‪J2SE 5.0‬‬
‫‪December 2006‬‬ ‫‪Mustang‬‬ ‫‪Java SE 6‬‬
‫‪July 2011‬‬ ‫‪Dolphin‬‬ ‫‪Java SE 7‬‬
‫‪March 2014‬‬ ‫‪Java SE 8‬‬
‫برای آشنایی بیشتر با این زبان به لینک های زیر مراجعه کنید‪:‬‬
‫)‪https://en.wikipedia.org/wiki/Java_(programming_language‬‬
‫‪https://en.wikipedia.org/wiki/Java_version_history‬‬
‫‪۵۱‬‬ ‫مبانی زبان جاوا‬
‫ضریب اطمینان عملکرد برنامههای نوشته شده به این زبان باال است و وابسته به سیستم عامل خاصی نیست‪ ،‬به عبارت دیگر‬
‫میتوان آن را روی هر رایانه با هر نوع سیستم عاملی اجرا کرد و این‪ ،‬همان شعار جاوا است‪“ :‬یک بار بنویس‪ ،‬همه جا اجرا کن"‪.‬‬
‫‪ JVM‬چیست ؟‬
‫برای اجرای برنامههای نوشته شده و کامپایل شده به زبان جاوا نیاز به سکویی یا برنامهای است که به آن ماشین مجازی جاوا‬
‫)‪(Java Virtual Machine‬یا به اختصار ‪ JVM‬گفته می شود‪ .‬این ماشین کدهای کامپایل شده به زبان جاوا را گرفته و آنها را‬
‫اجرا می کند‪ .‬شاید این جمله را شنیده باشید که کدهای زبان جاوا بر روی هر ماشین قابل اجرا میباشند و اصطالحا جاوا ‪Multi‬‬
‫‪Platform‬است‪.‬شخصی که دستگاهی با سیستم عامل ویندوز دارد‪ ،‬از سایت سان میکروسیستمز ‪ JVM‬مربوط به سیستم عامل‬
‫ویندوز را نصب میکند‪ .‬سپس برنامهای را به زبان جاوا مینویسد و آن را کامپایل مینماید‪ .‬پس از آن برنامه کامپایل شده را برای‬
‫دوست خود که دستگاه دیگری با سیستم عامل لینوکس دارد ارسال میکند‪ .‬این شخص قبال ‪ JVM‬مخصوص سیستم عامل لینوکس‬
‫را از سایت سان برداشته و بر روی دستگاه خود نصب نموده است‪ .‬به همین دلیل هیچکدام از این دو نفر الزم نیست نگران باشد‬
‫که سیستم عامل دستگاهایشان با یکدیگر متفاوت است‪ .‬می توان نحوه اجرای کدهای جاوا را به صورت زیر خالصه کرد‪:‬‬
‫همانطور که در شکل باال مشاهده می کنید‪:‬‬
‫برنامهنویس کدهای خود را درون فایلی با پسوند ‪ .java‬مینویسید‪.‬‬ ‫‪‬‬
‫وقتی برنامه نویس برنامه خود را اجرا می کند‪ ،‬کدهای برنامه توسط کمپایلر جاوا به ‪ bytecode‬تبدیل میشوند و‬ ‫‪‬‬
‫درون فایلی با همان نام قبلی اما این بار با پسوند ‪ .class‬ذخیره میشوند‪.‬‬
‫ماشین مجازی جاوا )‪ (Java Virtual Machine‬فایل ‪ .class‬را اجرا میکند‪.‬‬ ‫‪‬‬
‫ماشین مجازی جاوا یا ‪ JVM‬بر روی تمام سیستمعاملهای مطرح (ویندوز‪ ،‬مکینتاش و لینوکس) قابل نصب است‪ .‬به همین دلیل‬
‫فایل ‪ .class‬برنامه شما در تمام این سیستم عاملها میتواند اجرا شود و به همین دلیل است که به جاوا زبان مستقل از سیستم‬
‫عامل گفته میشود‪ .‬شعار جاوا این است‪« :‬یک بار بنویس‪ ،‬همه جا اجرا کن»!‬
‫‪ NetBeans‬و ‪JDK‬‬
‫‪ Netbeans‬محیط توسعه یکپارچه ای است که دارای ابزارهایی برای کمک به شما برای توسعه برنامههای ‪ JAVA‬میباشد‪ .‬توصیه‬
‫میکنیم که از محیط ‪ Netbeans‬برای ساخت برنامه استفاده کنید‪ ،‬چون این محیط دارای ویژگیهای زیادی برای کمک به شما‬
‫جهت توسعه برنامههای ‪ JAVA‬میباشد‪ .‬توسط ‪ Netbeans‬میتوان در استانداردهای مختلف جاوا مانند ‪ J2EE ،J2SE‬و ‪J2ME‬‬
‫برنامه نویسی کرد‪ .‬همچنین از محیط زبانهای ‪ C ،HTML ،PHP‬و نیز ‪ Groovy‬پشتیبانی میکند‪ .‬قبل از نصب ‪Netbeans‬‬
‫میبایست ‪ JDK‬را نصب نمایید‪ ،‬در غیر این صورت برای نصب دچار مشکل خواهید شد‪ JDK .‬که مخفف عبارت ‪Java‬‬
‫‪ Development Toolkit‬میباشد ترکیبی از کمپایلر زبان جاوا‪ ،‬کالسهای کتابخانه ای (‪ )Java Class Libraries‬و ‪ JVM‬و‬
‫فایلهای راهنمای آنها میباشد‪ .‬برای اینکه ما بتوانیم با استفاده از زبان برنامه نویسی جاوا‪ ،‬برنامه بنویسیم به این مجموعه نیاز‬
‫داریم‪ .‬تعداد زیادی از پردازشها که وقت شما را هدر میدهند به صورت خودکار توسط ‪ NetBeans‬انجام میشوند‪ .‬یکی از این‬
‫ویژگیها اینتلی سنس )‪ (Intellisense‬است که شما را در تایپ سریع کدهایتان کمک میکند‪ NetBeans .‬برنامه شما را خطایابی‬
‫میکند و حتی خطاهای کوچک (مانند بزرگ یا کوچک نوشتن حروف) را برطرف میکند‪ .‬با این برنامههای قدرتمند بازدهی شما‬
‫افزایش مییابد و در وقت شما با وجود این ویژگیهای شگفت انگیز صرفه جویی میشود ‪ NetBeans‬آزاد است و میتوان آن را‬
‫دانلود و از آن استفاده کرد‪ .‬این برنامه ویژگیهای کافی را برای شروع برنامه نویسی ‪ JAVA‬در اختیار شما قرار میدهد‪.‬در آموزشها‬
‫از ‪ NetBeans‬نسخه ‪ 0.3.5‬استفاده شده است و استفاده از این نسخه برای انجام تمرینات این سایت کافی میباشد‪ .‬برای دانلود‬
‫نرم افزارهای مورد نیاز به سایت ‪ w3-farsi.com‬و لینک زیر مراجعه کنید‪:‬‬
‫‪http://www.w3-farsi.com/?p=7529‬‬
‫‪۵1‬‬ ‫مبانی زبان جاوا‬
‫در درس آینده مراحل نصب و راه اندازی دو نرم افزار ‪ JDK‬و ‪ NetBeans‬را توضیح میدهیم‪.‬‬
‫نصب ‪ NetBeans‬و ‪JDK‬‬
‫در درس قبل در مورد نرم افزارهای ‪ NetBeans‬و ‪ JDK‬توضیحات مختصری ارائه دادیم‪ .‬در این درس میخواهیم شما را با نحوه‬
‫نصب این دو نرم افزار آشنا کنیم‪ .‬نصب این نرم افزارها مانند اکثر نرم افزارهای دیگر بسیار آسان بود و بعد از زدن چند دکمه ‪Next‬‬
‫نصب میشوند‪ .‬در زیر مراحل تصویری نصب این دو نرم افزار نشان داده شده است‪.‬‬
‫نصب ‪JDK‬‬
‫‪۵۹‬‬ ‫مبانی زبان جاوا‬
‫‪1۵‬‬ ‫مبانی زبان جاوا‬
‫نصب ‪NetBeans‬‬
‫‪1۳‬‬ ‫مبانی زبان جاوا‬
‫وقتی برای اولین بار بر روی آیکون ‪ NetBeans‬بر روی دسکتاپ کلیک کرده و آن را اجرا میکنید‪ ،‬صفحه اول برنامه به صورت زیر‬
‫نمایش داده میشود که نشان دهنده نصب کامل آن است‪:‬‬

‫‪1۱‬‬ ‫مبانی زبان جاوا‬
‫در درس آینده درباره ایجاد پروژه در ‪ NetBeans‬توضیح میدهیم‪.‬‬
‫پیکربندی ‪JDK‬‬
‫در درس قبل ما نسخه نهایی ‪ JDK‬یا ‪ Java Development Kit‬را بر روی سیستم عامل مان نصب کردیم‪ .‬ولی این پایان کار‬
‫نیست‪ .‬برای اجرای برنامه های جاوا الزم است که مسیر پوشه ‪ bin‬این نرم افزار را در متغیر ‪ path‬معرفی کنیم‪ .‬برای این کار ابتدا‬
‫مسیر پوشه ‪ bin‬را کپی کنید‪:‬‬

‫سپس بر روی ‪ MyComputer‬راست کلیک کرده و روی گزینه ‪ Properties‬کلیک کنید‪:‬‬
‫از پنل سمت چپ این صفحه ‪ Advanced system settings‬را باز کنید‪:‬‬
‫‪11‬‬ ‫مبانی زبان جاوا‬
‫به تب ‪ Advanced‬روی ‪ …Environment Variables‬کلیک کنید‪.‬‬
‫در قسمت پایین و بخش ‪ System Variables‬روی گزینه ‪ Path‬کلیک کرده و سپس گزینه ‪ Edit‬را بزنید‪:‬‬
‫در پنجره باز شده اگر قسمت ‪ Variable Value‬خالی بود مسیر پوشه ‪ bin‬را در آن کپی کنید‪:‬‬
‫و اگر از قبل مسیرهای دیگری وجود داشت ابتدا عالمت سمیکالن (;) را در انتهای آنها گذاشته و سپس مسیر پوشه ‪ bin‬را کپی‬
‫می کنید‪:‬‬
‫‪1۹‬‬ ‫مبانی زبان جاوا‬
‫حال ‪ cmd‬را اجرا می کنیم‪:‬‬
‫و کد زیر را در داخل آن می نویسیم و دکمه ‪ Enter‬را می زنیم‪:‬‬
‫‪Javac –version‬‬
‫مشاهده می کنید که خطا برطرف شده و نسخه ‪ JDK‬نمایش داده می شود که نشان دهنده این است که مراحل را درست انجام‬
‫داده اید‪:‬‬
‫]‪Microsoft Windows [Version 6.1.7601‬‬

‫‪Copyright (c) 2009 Microsoft Corporation.‬‬ ‫‪All rights reserved.‬‬
‫‪C:\Users\JavaTutorials>javac -version‬‬
‫‪javac 1.7.0_25‬‬
‫>‪C:\Users\JavaTutorials‬‬
‫ساخت یک برنامه ساده در ‪JAVA‬‬

‫اجازه بدهید یک برنامه بسیار ساده به زبان جاوا بنویسیم‪ .‬این برنامه یک پیغام را نمایش میدهد‪ .‬در این درس میخواهم ساختار‬
‫و دستور زبان یک برنامه ساده جاوا را توضیح دهم‪ .‬قبل از ایجاد برنامه به این نکته توجه کنید که کدهای جاوا را میتوان در داخل‬
‫یک ویرایشگر متن ساده مانند ‪ NotePad‬نوشت و اجرا کرد‪ .‬فقط کافیست که ‪ JDK‬بر روی سیستم شما نصب باشد‪ .‬استفاده از‬
‫نرم افزارهایی مانند ‪ NetBeans‬فقط برای راحتی در کدنویسی و کاهش خطا میباشد‪.‬‬
‫بدون استفاده از ‪NetBeans‬‬
‫همانطور که گفته شد‪ ،‬شما برای کامپایل و اجرای برنامههای جاوا به ابزاری به نام ‪ JDK‬نیاز دارید‪ JDK .‬مخفف عبارت ‪Java‬‬
‫‪ Development Kit‬است و شامل ابزارهای مورد نیاز شما برای اجرای برنامههای جاوا میشود‪ .‬این مجموعه شامل ابزاری به نام‬
‫‪ JVM‬یا ‪ Java Virtual Machine‬است که ماشین مجازی جاوا نام دارد و وظیفهی کامپایل و اجرای کدهای شما را برعهده دارد‪.‬‬
‫خود ‪ JVM‬هم شامل ابزارهای دیگری است‪ .‬مثال ‪ javac‬یا ‪ java compiler‬اختصاصا وظیفهی کامپایل کردن برنامهها را برعهده‬
‫دارد‪ .‬در درس قبل ‪ JDK‬را نصب کردیم و االن فرض میکنیم که شما هیچ ‪ IDE‬مانند ‪ netbeans‬و یا ‪ eclipse‬در اختیار ندارید‬
‫و میخواهید یک برنامه جاوا بنویسید‪ .‬در این برنامه میخواهیم پیغام ‪ Welcome to JAVA Tutorials‬چاپ شود‪ .‬ابتدا یک‬
‫ویرایشگر متن مانند ‪ Notepad‬را باز کرده و کدهای زیر را در داخل آن نوشته ‪:‬‬
‫‪public class MyFirstProgram‬‬

‫{‬
‫)‪public static void main(String[] args‬‬
‫{‬
‫;)"!‪System.out.println("Welcome to JAVA Tutorials‬‬
‫}‬
‫}‬
‫و در درایو ‪ D‬و با نام و پسوند ‪ MyFirstProgram.java‬ذخیره می کنیم ‪:‬‬

‫‪۳۵‬‬ ‫مبانی زبان جاوا‬
‫نگران توضیح کدهای باال نباشید‪ ،‬در ادامه در مورد آنها توضیح می دهیم‪ .‬پس شکل نهایی برنامه‪ ،‬باید به صورت زیر باشد‪:‬‬
‫حال نوبت به اجرای برنامه می رسد‪:‬‬
‫فایل ما در درایو ‪ D‬قرار دارد‪ .‬ابتدا ‪ cmd‬را باز کرده و کد زیر را در داخل آن نوشته و دکمه ‪ Enter‬را می زنید‪:‬‬

‫‪۳۳‬‬ ‫مبانی زبان جاوا‬
‫‪C:\Users\JavaTutorials>d:‬‬
‫‪D:\>javac MyFirstProgram.java‬‬
‫>\‪D:‬‬
‫با اجرای کد باال هیچ پیغامی چاپ نمی شود چون که دستور ‪ javac‬برنامه را کامپایل کرده و یک فایل همنام با کالس‬
‫‪ MyFirstProgram‬و با پسوند ‪ .class‬ایجاد می کند‪:‬‬
‫اگر فایل ایجاد شده یعنی ‪ MyFirstProgram.class‬را با برنامه ‪ NotePad‬باز کنید مشاهده می کنید که شامل کدهایی نا مفهوم‬
‫می باشد‪:‬‬
‫به این کدهای نامفهوم که برای ماشین مجازی جاوا )‪ (JVM‬قابل فهم می باشد‪ ByteCode ،‬گفته می شود‪ .‬حال برای اجرای‬
‫فایل ‪ MyFirstProgram.class‬باید دستور زیر را بنویسیم‪:‬‬

‫‪C:\Users\JavaTutorials>d:‬‬
‫‪D:\>java MyFirstProgram‬‬
‫!‪Welcome to JAVA Tutorials‬‬
‫>\‪D:‬‬
‫مشاهده می کنید که فایل جاوا اجرا و پیغام ‪ Welcome to JAVA Tutorials‬چاپ شد‪.‬‬
‫یک نکته را متذکر می شویم و آن این است که نام فایل دارای پسوند ‪ java‬باید با نام کالسی که در داخل آن است‪ ،‬یکی باشد‪،‬‬
‫در غیر اینصورت با خطا مواجه می شوید‪ .‬فرض کنید ما نام فایل باال را به ‪ Program.java‬تغییر داده و آن را کامپایل می کنیم‪.‬‬
‫در اینصورت خطای زیر به ما نمایش داده می شود‪:‬‬
‫‪Program.java:3: error: class MyFirstProgram is public,‬‬

‫‪should be declared in a file named MyFirstProgram.java‬‬
‫^‬
‫‪۳۱‬‬ ‫مبانی زبان جاوا‬
‫‪1 error‬‬
‫خطای باال به این معنی است که کالسی با نام ‪ MyFirstProgram‬باید در فایلی با نام ‪ MyFirstProgram.java‬تعریف شود‪.‬‬
‫با استفاده از ‪NetBeans‬‬
‫برنامه ‪ NetBeans‬را اجرا کنید‪ .‬از مسیری که در شکل زیر نشان داده شده است یک پروژه جدید ایجاد کنید‪:‬‬
‫حال با یک صفحه مواجه میشوید‪ .‬طبق شمارههایی که در شکل زیر نمایش داده شدهاند گزینهها را انتخاب کرده و به مرحله بعد‬
‫بروید‪:‬‬
‫با زدن دکمه ‪ Next‬صفحه ای به صورت زیر نمایش داده میشود‪ .‬در این پنجره نام پروژهتان )‪ (MyFirstProgram‬را نوشته و‬
‫سپس بر روی دکمه ‪ Finish‬کلیک کنید‪:‬‬
‫بعد از فشردن دکمه ‪ ،Finish‬وارد محیط کدنویسی برنامه به صورت زیر میشویم‪:‬‬
‫‪۳1‬‬ ‫مبانی زبان جاوا‬
‫محیط کدنویسی یا ‪ IDE‬جایی است که ما کدها را در آن تایپ میکنیم‪.‬کدها در محیط کدنویسی به صورت رنگی تایپ میشوند‬
‫در نتیجه تشخیص بخشهای مختلف کد را راحت میکند‪ .‬همانطور که در شکل باال مشاهده میکنید ما کدهای پیشفرض را به سه‬
‫قسمت تقسیم کردهایم‪ .‬قسمت اول ‪ ،Package‬قسمت دوم کالس و قسمت سوم متد )(‪ .main‬نگران اصطالحاتی که به کار بردیم‬
‫نباشید آنها را در فصول بعد توضیح خواهم داد‪ .‬در محل کد نویسی کدهایی از قبل نوشته شده که برای شروع شما آنها را پاک‬
‫کنید و کدهای زیر را در محل کدنویسی بنویسید‪:‬‬
‫‪1‬‬ ‫;‪package myfirstprogram‬‬

‫‪2‬‬
‫‪3‬‬ ‫‪public class MyFirstProgram‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬ ‫)‪public static void main(String[] args‬‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;)"!‪System.out.println("Welcome to JAVA Tutorials‬‬
‫‪8‬‬ ‫}‬
‫‪9‬‬ ‫}‬
‫ساختار یک برنامه در جاوا‬
‫مثال باال سادهترین برنامه ای است که شما میتوانید در جاوا بنویسید‪ .‬هدف در مثال باال نمایش یک پیغام در صفحه نمایش‬
‫است‪ .‬هر زبان برنامه نویسی دارای قواعدی برای کدنویسی است‪ .‬اجازه بدهید هر خط کد را در مثال باال توضیح بدهیم‪ .‬در خط‬
‫اول ‪ Package‬تعریف شده است که شامل کدهای نوشته شده توسط شما است و از تداخل نامها جلوگیری میکند‪ .‬درباره‬
‫‪ Package‬در درسهای آینده توضیح خواهیم داد‪ .‬در خط ‪ ،3‬آکوالد ( } ) نوشته شده است‪ .‬آکوالد برای تعریف یک بلوک کد به‬
‫کار میرود‪ .‬جاوا یک زبان ساخت یافته است که شامل کدهای زیاد و ساختارهای فراوانی میباشد‪ .‬هر آکوالد باز ( { ) در جاوا باید‬
‫دارای یک آکوالد بسته )}( نیز باشد‪ .‬همه کدهای نوشته شده از خط ‪ 3‬تا خط ‪ 6‬یک بلوک کد است‪.‬‬
‫در خط ‪ 3‬یک کالس تعریف شده است‪.‬درباره کالسها در فصلهای آینده توضیح خواهیم داد‪ .‬در مثال باال کدهای شما باید در‬
‫داخل یک کالس نوشته شود‪.‬بدنه کالس شامل کدهای نوشته شده از خط ‪ 3‬تا ‪ 6‬میباشد‪ .‬خط ‪ 1‬متد )(‪ main‬یا متد اصلی نامیده‬
‫میشود‪ .‬هر متد شامل یک سری کد است که وقتی اجرا میشوند که متد را صدا بزنیم‪ .‬در باره متد و نحوه صدا زدن آن در فصول‬
‫بعدی توضیح خواهیم داد‪ .‬متد )(‪ main‬نقطه آغاز اجرای برنامه است‪ .‬این بدان معناست که ابتدا تمام کدهای داخل متد )(‪main‬‬
‫و سپس بقیه کدها اجرا میشود‪.‬درباره متد )(‪ main‬در فصول بعدی توضیح خواهیم داد‪ .‬متد )(‪ main‬و سایر متدها دارای آکوالد‬
‫و کدهایی در داخل آنها میباشند و وقتی کدها اجرا میشوند که متدها را صدا بزنیم‪ .‬هر خط کد در جاوا به یک سیمیکولن ( ; )‬
‫ختم میشود‪ .‬اگر سیمیکولن در آخر خط فراموش شود برنامه با خطا مواجه میشود‪ .‬مثالی از یک خط کد در جاوا به صورت زیر‬
‫است‪:‬‬
‫این خط کد پیغام !‪ Welcome to JAVA Tutorials‬را در صفحه نمایش نشان میدهد‪.‬از متد )(‪ println‬برای چاپ یک‬
‫رشته استفاده میشود‪ .‬یک رشته گروهی از کاراکترها است که به وسیله دابل کوتیشن (“) محصور شده است‪ ،‬مانند ‪:‬‬
‫”!‪. “Welcome to Visual C# Tutorials‬‬
‫یک کاراکتر میتواند یک حرف‪ ،‬عدد‪ ،‬عالمت یا …‪.‬باشد‪.‬در کل مثال باال نحوه استفاده از متد )(‪ println‬نشان داده شده است‪.‬‬
‫این متد یک متد از کالس ‪ PrintStream‬بوده و از آن برای چاپ مقدیر استفاده میشود‪ out .‬یک فیلد استاتیک کالس ‪System‬‬
‫‪۳۹‬‬ ‫مبانی زبان جاوا‬
‫و کالس ‪ System‬هم یک کالس از پیش تعریف شده در جاوا میباشد‪ .‬جاوا فضای خالی و خطوط جدید را نادیده میگیرد‪ .‬بنابراین‬
‫شما میتوانید همه برنامه را در یک خط بنویسید‪ .‬اما اینکار خواندن و اشکال زدایی برنامه را مشکل میکند‪ .‬یکی از خطاهای معمول‬
‫در برنامه نویسی فراموش کردن سیمیکولن در پایان هر خط کد است‪ .‬به مثال زیر توجه کنید‪:‬‬
‫جاوا فضای خالی باال را نادیده میگیرد و از کد باال اشکال نمیگیرد‪ .‬اما از کد زیر ایراد میگیرد ‪:‬‬
‫;(‪System.out.println‬‬
‫;)"!‪"Welcome to JAVA Tutorials‬‬
‫به سیمیکولن آخر خط اول توجه کنید‪.‬برنامه با خطای نحوی مواجه میشود چون دو خط کد مربوط به یک برنامه هستند و شما‬
‫فقط باید یک سیمیکولن در آخر آن قرار دهید‪ .‬همیشه به یاد داشته باشید که جاوا به بزرگی و کوچکی حروف حساس است‪.‬یعنی‬
‫به طور مثال ‪ MAN‬و ‪ man‬در جاوا با هم فرق دارند‪ .‬رشتهها و توضیحات از این قاعده مستثنی هستند که در درسهای آینده‬
‫توضیخ خواهیم داد‪ .‬مثال کدهای زیر با خطا مواجه میشوند و اجرا نمیشوند‪:‬‬
‫;)"!‪system.out.println("Welcome to JAVA Tutorials‬‬

‫;)"!‪SYSTEM.OUT.PRINTLN("Welcome to JAVA Tutorials‬‬
‫;)"!‪sYsTem.oUt.pRinTLn("Welcome to JAVA Tutorials‬‬
‫تغییر در بزرگی و کوچکی حروف از اجرای کدها جلوگیری میکند‪ .‬اما کد زیر کامال بدون خطا است‪:‬‬
‫همیشه کدهای خود را در داخل آکوالد بنویسید‪.‬‬
‫{‬
‫;‪statement1‬‬
‫}‬
‫این کار باعث میشود که کدنویسی شما بهتر به چشم بیاید و تشخیص خطاها راحت تر باشد‪ .‬یکی از ویژگیهای مهم جاوا نشان‬
‫دادن کدها به صورت تو رفتگی است بدین معنی که کدها را به صورت تو رفتگی از هم تفکیک میکند و این در خوانایی برنامه‬
‫بسیار مؤثر است‪.‬‬

‫ذخیره پروژه و اجرای برنامه‬
‫برای ذخیره پروژه و برنامه میتوانید به مسیر ‪ File > Save All‬بروید یا از کلیدهای میانبر ‪ Ctrl+Shift+S‬استفاده کنید‪.‬‬
‫همچنین میتوانید از قسمت ‪Toolbar‬بر روی شکل زیر کلیک کنید‪:‬‬
‫و برای اجرای برنامه هم از فلش سبزرنگ موجود در ‪ Toolbar‬و یا دکمه ‪ F6‬استفاده کنید‪:‬‬
‫با اجرای برنامه باال مشاهده میکنید که رشته !‪ Welcome to JAVA Tutorials‬در خروجی برنامه به صورت زیر نمایش داده‬
‫میشود‪:‬‬
‫وجود خط سبز در پایین فلش قرمز در شکل باال نشان دهنده اجرای بدون نقص برنامه میباشد‪ .‬حال که با خصوصیات و ساختار‬
‫اولیه جاوا آشنا شدید در درسهای آینده مطالب بیشتری از این زبان برنامه نویسی قدرتمند خواهید آموخت‪.‬‬
‫استفاده از ‪Package‬‬
‫برای دسته بندی کالسها و قرار دادن کالسهای مرتیط با هم در یک مکان‪ ،‬جاوا از مفهومی به نام بسته یا ‪ package‬استفاده‬
‫میکند‪ .‬پکیج معادل فضای نام در سی شارپ می باشد‪ .‬یک دلیل برای گروه بندی کالسها در ‪ package‬این است که امکان دارد‬
‫دو برنامه نویس از دو کالس هم نام استفاده کنند‪ .‬با این کار از چنین برخوردهایی جلوگیری به عمل میآید‪ .‬یعنی اگر دو کالس هم‬
‫نام در دو ‪ Package‬غیر همنام باشند مشکلی به وجود نمیآید‪ .‬همانطور که در مثال باال دیدید به طور پیشفرض ‪NetBeatns‬‬
‫هنگام ایجاد برنامه یک ‪ Package‬همنام با اسمی که برای برنامه انتخاب کردهایم با حروف کوچک و در داخل این ‪ Package‬هم‬
‫کالسی به همین اسم ایجاد میکند‪:‬‬
‫;‪package myfirstprogram‬‬

‫{‬
‫‪...‬‬
‫}‬
‫برای وارد کردن کالس یک ‪ Package‬در داخل ‪ Package‬دیگر از کلمه کلیدی ‪ import‬به صورت زیر استفاده میشود‪:‬‬
‫‪import PackageName.ClassName‬‬
‫همانطور که در مثال باال مشاهده میکنید برای استفاده از کالسی که در یک ‪ Package‬قرار دارد در ‪ Package‬دیگر ابتدا کلمه‬
‫‪ import‬سپس نام ‪ ،Package‬بعد عالمت نقطه و در آخر نام کالس را مینویسیم‪ .‬مثال برای استفاده از کالس ‪MyFirstProgram‬‬
‫مربوط به پکیج ‪ myfirstprogram‬به صورت زیر عمل میشود‪:‬‬
‫;‪import myfirstprogram.MyFirstProgram‬‬
‫بستهها را میتوان به صورت تو در تو تعریف کرد‪ .‬در این حالت در تعریف بسته یک کالس‪ ،‬از بیرونیترین بسته شروع کرده و هر‬
‫بسته را با نقطه (‪ ).‬به بسته بعدی متصل میکنیم‪:‬‬
‫‪import firstPackage.secondPackage.ClassName‬‬
‫نکته ای که بهتر است در همین جا به آن اشاره کنم این است که اگر بخواهید کد زیر را بدون استفاده از ‪ NetBeans‬کامپایل و‬
‫اجرا کنید‪ ،‬کامپایل می شود ولی در زمان اجرا با خطای ‪Error: Could not find or load main class MyFirstProgram‬‬
‫مواجه می شوید‪:‬‬

‫{‬
‫{‬
‫}‬
‫}‬
‫کد باال را با نام و پسوند ‪ MyFirstProgram.java‬و در درایو ‪ D‬ذخیره کنید‪ .‬حال ‪ cmd‬را اجرا کرده و سعی کنید کد باال را کامپایل‬
‫و اجرا نمایید‪:‬‬

‫‪C:\Users\YounesJava>d:‬‬
‫‪D:\>java MyFirstProgram‬‬
‫‪Error: Could not find or load main class MyFirstProgram‬‬
‫‪D:\>java -cp . myfirstprogram.MyFirstProgram‬‬

‫!‪Welcome to JAVA Tutorials‬‬
‫همانطور که مشاهده می کنید برای کامپایل کد باال به صورت زیر عمل کرده ایم‪:‬‬
‫‪javac MyFirstProgram.java‬‬
‫اما برای اجرای کد‪ ،‬اگر از دستور زیر استفاده کنیم با خطا مواجه می شویم‪:‬‬
‫‪java MyFirstProgram‬‬
‫دلیل وجود خطا‪ ،‬خط اول کد‪ ،‬یعنی ;‪ package myfirstprogram‬می باشد‪ .‬برای رفع این مشکل یا باید خط مذکور را از برنامه‬
‫حذف و برنامه را مجددا کامپایل و اجرا کرد یا اگر آن را پاک نکنید باید از کد زیر برای اجرای کد استفاده کنید‪:‬‬
‫‪java -cp . myfirstprogram.MyFirstProgram‬‬
‫که در این صورت برنامه اجرا و پیغام !‪ Welcome to JAVA Tutorials‬چاپ می شود‪ .‬در درس های آینده توصیه می کنیم که‬
‫اگر می خواهید از ‪ NotePad‬و ‪ cmd‬برای اجرای کدها استفاده کنید این خط را از اول هم فایل ها حذف و سپس برنامه را کامپایل‬
‫و اجرا کنید‪.‬‬
‫استفاده از ‪ IntelliSense‬در ‪NetBeans‬‬

‫شاید یکی از ویژگیهای مهم ‪ ،NetBeans‬اینتلی سنس باشد‪ IntelliSense .‬ما را قادر میسازد که به سرعت به کالسها و متدها‬
‫و…‪.‬دسترسی پیدا کنیم‪ .‬وقتی که شما در محیط کدنویسی حرفی را تایپ کنید ‪ IntelliSense‬فورا فعال میشود‪ .‬کد زیرا را در‬
‫داخل متد )(‪ main‬بنویسید‪.‬‬
‫اولین حرف را تایپ کرده و سپس دکمههای ترکیبی ‪ Ctrl+Space‬را فشار دهید تا ‪ IntelliSense‬فعال شود‪:‬‬
‫‪ IntelliSense‬لیستی از کلمات به شما پیشنهاد میدهد که بیشترین تشابه را با نوشته شما دارند‪ .‬شما میتوانید با زدن دکمه‬
‫‪ tab‬گزینه مورد نظرتان را انتخاب کنید‪ .‬با تایپ نقطه ( ‪ ) .‬شما با لیست پیشنهادی دیگری مواجه میشوید‪:‬‬
‫اگر بر روی گزینه ای که میخواهید انتخاب کنید لحظه ای مکث کنید توضیحی در رابطه با آن مشاهده خواهید کرد مانند شکل‬
‫زیر‪:‬‬
‫هر چه که به پایان کد نزدیک میشوید لیست پیشنهادی محدود تر میشود‪ .‬برای مثال با تایپ ‪ ،p‬اینتل الیسنس فقط کلماتی را‬
‫که دارای حرف ‪ p‬هستند را نمایش میدهد‪:‬‬
‫با تایپ حرفهای بیشتر لیست محدودتر میشود‪ .‬اگر ‪ IntelliSense‬نتواند چیزی را که شما تایپ کردهاید پیدا کند هیچ چیزی‬
‫را نمایش نمیدهد‪ .‬برای ظاهر کردن ‪ IntelliSense‬کافیست دکمه ترکیبی ‪ Ctrl+Space‬را فشار دهید‪ .‬برای انتخاب یکی از‬
‫متدهایی که دارای چند حالت هستند‪ ،‬میتوان با استفاده از دکمههای مکان نما (باال و پایین) یکی از حالتها را انتخاب کرد‪ .‬مثال‬
‫متد )(‪ println‬همانطور که در شکل زیر مشاهده میکنید دارای چندین حالت نمایش پیغام در صفحه است‪:‬‬
‫‪ IntelliSense‬به طور هوشمند کدهایی را به شما پیشنهاد میدهد و در نتیجه زمان نوشتن کد را کاهش میدهد‪.‬‬
‫رفع خطاها‬
‫بیشتر اوقات هنگام برنامه نویسی با خطا مواجه میشویم‪ .‬تقریبا همه برنامههایی که امروزه میبینید حداقل از داشتن یک خطا‬
‫رنج میبرند‪ .‬خطاها میتوانند برنامه شما را با مشکل مواجه کنند‪ .‬در جاوا سه نوع خطا وجود دارد‪:‬‬
‫خطای کمپایلر ی‬
‫این نوع خطا از اجرای برنامه شما جلوگیری میکند‪ .‬این خطاها شامل خطای دستور زبان میباشد‪ .‬این بدین معنی است که شما‬
‫قواعد کد نویسی را رعایت نکردهاید‪ .‬یکی دیگر از موارد وقوع این خطا هنگامی است که شما از چیزی استفاده میکنید که نه وجود‬
‫دارد و نه ساخته شده است‪ .‬حذف فایلها یا اطالعات ناقص در مورد پروژه ممکن است باعث به وجود آمدن خطای کمپایلری‬
‫شود‪.‬استفاده از برنامه بوسیله برنامه دیگر نیز ممکن است باعث جلوگیری از اجرای برنامه و ایجاد خطای کمپایلر ی شود‪.‬‬
‫خطاهای منطقی‬
‫این نوع خطا در اثر تغییر در یک منطق موجود در برنامه به وجود میآید‪ .‬رفع این نوع خطاها بسیار سخت است چون شما برای‬
‫یافتن آنها باید کد را تست کنید‪.‬نمونه ای از یک خطای منطقی برنامه ای است که دو عدد را جمع میکند ولی حاصل تفریق دو‬
‫عدد را نشان میدهد‪.‬در این حالت ممکن است برنامه نویس عالمت ریاضی را اشتباه تایپ کرده باشد‪.‬‬
‫استثناء‬
‫این نوع خطاها هنگامی رخ میدهند که برنامه در حال اجراست‪ .‬این خطا هنگامی روی میدهد که کاربر یک ورودی نامعتبر به‬
‫برنامه بدهد و برنامه نتواند آن را پردازش کند‪ NetBeans .‬دارای ابزارهایی برای پیدا کردن و برطرف کردن خطاها هستند‪ .‬وقتی در‬
‫محیط کدنویسی در حال تایپ کد هستیم یکی از ویژگیهای ‪ NetBeans‬تشخیص خطاهای ممکن قبل از اجرای برنامه است‪.‬زیر‬
‫کدهایی که دارای خطای کمپایلر ی هستند خط قرمز کشیده میشود‪.‬‬
‫هنگامی که شما با ماوس روی این خطوط توقف کنید توضیحات خطا را مشاهده میکنید‪ .‬شما ممکن است با خط سبز هم مواجه‬
‫شوید که نشان دهنده اخطار در کد است ولی به شما اجازه اجرای برنامه را میدهند‪ .‬به عنوان مثال ممکن است شما یک متغیر را‬
‫تعریف کنید ولی در طول برنامه از آن استفاده نکنید‪( .‬در درسهای آینده توضیح خواهیم داد)‪.‬‬
‫در باره رفع خطاها در آینده توضیح بیشتری میدهیم‪ .‬پنجره ‪ Output‬که در شکل زیر با فلش قرمز نشان داده شده است به شما‬
‫امکان مشاهده خطاها‪ ،‬هشدارها و رفع آنها را میدهد‪.‬‬
‫همانطور که در شکل زیر مشاهده میکنید هرگاه برنامه شما با خطا مواجه شود لیست خطاها در پنجره ‪ Output‬نمایش داده‬
‫میشود‪.‬‬
‫در شکل باال علت به وجود آمدن خطا و شماره خطی که خطا در آن رخ داده است‪ ،‬نمایش داده شده است‪ .‬اگر برنامه شما دارای‬
‫خطا باشد و آن را اجرا کنید با پنجره زیر روبرو میشوید‪:‬‬

‫مربع کوچک داخل پنجره باال را تیک زنید چون دفعات بعد که برنامه شما با خطا مواجه شود دیگر این پنجره به عنوان هشدار نشان‬
‫داده نخواهد شد‪ .‬با کلیک بر روی دکمه ‪ Run Anyway‬برنامه با وجود خطا نیز اجرا میشود‪ .‬اما با کلیک بر روی دکمه ‪Cancel‬‬
‫اجرای برنامه متوقف میشود و شما باید خطاهای موجود در پنجره ‪ Output‬را بر طرف نمایید‪.‬‬
‫کاراکترهای کنترلی‬
‫کاراکترهای کنترلی کاراکترهای ترکیبی هستند که با یک بک اسلش )\( شروع میشوند و به دنبال آنها یک حرف یا عدد میآید‬
‫و یک رشته را با فرمت خاص نمایش میدهند‪ .‬برای مثال برای ایجاد یک خط جدید و قرار دادن رشته در آن میتوان از کاراکتر‬
‫کنترلی ‪ \n‬استفاده کرد‪:‬‬
‫;)"!‪System.out.println("Hello\nWorld‬‬
‫‪Hello‬‬
‫‪World‬‬
‫مشاهده کردید که کمپایلر بعد از مواجهه با کاراکتر کنترلی ‪ \n‬نشانگر ماوس را به خط بعد برده و بقیه رشته را در خط بعد نمایش‬
‫میدهد‪ .‬متد )(‪ Println‬هم مانند کاراکتر کنترلی ‪ \n‬یک خط جدید ایجاد میکند‪ ،‬البته بدین صورت که در انتهای رشته یک‬
‫کاراکتر کنترلی ‪ \n‬اضافه میکند‪:‬‬
‫;)"!‪System.out.println("Hello World‬‬
‫کد باال و کد زیر هیچ فرقی با هم ندارند‪:‬‬
‫;)"‪System.out.print("Hello World!\n‬‬
‫متد )(‪ Print‬کارکردی شبیه به )(‪ Println‬دارد با این تفاوت که نشان گر ماوس را در همان خط نگه میدارد و خط جدید ایجاد‬
‫نمیکند‪ .‬جدول زیر لیست کاراکترهای کنترلی و کارکرد آنها را نشان میدهد‪:‬‬
‫عملکرد‬ ‫کاراکتر کنترلی‬ ‫عملکرد‬ ‫کاراکتر کنترلی‬
‫چاپ کوتیشن‬ ‫’\‬ ‫‪Form Feed‬‬ ‫‪\f‬‬

‫‪۱۵‬‬ ‫مبانی زبان جاوا‬
‫چاپ دابل کوتیشن‬ ‫”\‬ ‫خط جدید‬ ‫‪\n‬‬
‫چاپ بک اسلش‬ ‫\\‬ ‫سر سطر رفتن‬ ‫‪\r‬‬
‫حرکت به عقب‬ ‫‪\b‬‬ ‫حرکت به صورت افقی‬ ‫‪\t‬‬
‫ما برای استفاده از کاراکترهای کنترلی از بک اسلش )\( استفاده میکنیم‪.‬از آنجاییکه \ معنای خاصی به رشتهها میدهد برای‬
‫چاپ بک اسلش )\( باید از )\\( استفاده کنیم‪:‬‬
‫;)"‪System.out.println("We can print a \\ by using the \\\\ escape sequence.‬‬
‫‪We can print a \ by using the \\ escape sequence.‬‬
‫یکی از موارد استفاده از \\‪ ،‬نشان دادن مسیر یک فایل در ویندوز است‪:‬‬
‫;)"‪System.out.println("C:\\Program Files\\Some Directory\\SomeFile.txt‬‬
‫‪C:\Program Files\Some Directory\SomeFile.txt‬‬
‫از آنجاییکه از دابل کوتیشن )“( برای نشان دادن رشتهها استفاده میکنیم برای چاپ آن از ”\ استفاده میکنیم‪:‬‬
‫;)"‪System.out.println("I said, \"Motivate yourself!\".‬‬
‫‪I said, "Motivate yourself!".‬‬
‫همچنین برای چاپ کوتیشن )‘( از ’\ استفاده میکنیم‪:‬‬
‫;)"‪System.out.println("The programmer\'s heaven.‬‬
‫‪The programmer's heaven.‬‬
‫برای ایجاد فاصله بین حروف یا کلمات از ‪ \t‬استفاده میشود‪:‬‬
‫;)"‪System.out.println("Left\tRight‬‬
‫‪Left‬‬ ‫‪Right‬‬
‫هر تعداد کاراکتر که بعد از کاراکتر کنترلی ‪ \r‬بیایند به اول سطر منتقل و جایگزین کاراکترهای موجود میشوند‪:‬‬
‫;)"‪System.out.println("Mitten\rK‬‬
‫‪K‬‬
‫مثال در مثال باال کاراکتر ‪ K‬بعد از کاراکتر کنترلی ‪ \r‬آمده است‪.‬کاراکتر کنترلی حرف ‪ K‬را به ابتدای سطر برده و جایگزین ‪Mitten‬‬
‫میکند‪ .‬برای مشاهده لیست مقادیر مبنای ‪ 31‬برای کاراکترهای یونیکد به لینک زیر مراجعه نمایید ‪:‬‬
‫‪http://www.ascii.cl/htmlcodes.htm‬‬
‫اگر کمپایلر به یک کاراکتر کنترلی غیر مجاز برخورد کند‪ ،‬برنامه پیغام خطا میدهد‪.‬بیشترین خطا زمانی اتفاق میافتد که برنامه‬
‫نویس برای چاپ اسلش (\) از \\ استفاده میکند‪.‬‬
‫توضیحات‬
‫وقتی که کد ی تایپ می کنید شاید بخواهید که متنی جهت یادآوری وظیفه آن کد به آن اضافه کنید‪ .‬در جاوا (و بیشتر زبانهای‬
‫برنامه نویسی) می توان این کار را با استفاده از توضیحات انجام داد‪ .‬توضیحات متونی هستند که توسط کمپایلر نادیده گرفته می‬
‫شوند و به عنوان بخشی از کد محسوب نمی شوند‪.‬‬
‫هدف اصلی از ایجاد توضیحات‪ ،‬باال بردن خوانایی و تشخیص نقش کدهای نوشته شده توسط شما‪ ،‬برای دیگران است‪ .‬فرض کنید‬
‫که می خواهید در مورد یک کد خاص‪ ،‬توضیح بدهید‪ ،‬می توانید توضیحات را در باالی کد یا کنار آن بنویسید‪ .‬از توضیحات برای‬
‫مستند سازی برنامه هم استفاده می شود‪ .‬در برنامه زیر نقش توضیحات نشان داده شده است‪:‬‬

‫‪2‬‬ ‫{‬
‫‪4‬‬ ‫{‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫‪// This line will print the message hello world‬‬
‫‪8‬‬ ‫;)"!‪System.out.println("Hello World‬‬
‫‪9‬‬ ‫}‬
‫‪10‬‬ ‫}‬
‫‪11‬‬ ‫}‬
‫‪۱۳‬‬ ‫مبانی زبان جاوا‬
‫در کد باال‪ ،‬خط ‪ 1‬یک توضیح درباره خط ‪ 0‬است که به کاربر اعالم می کند که وظیفه خط ‪ 0‬چیست ؟ با اجرای کد باال فقط جمله‬
‫‪Hello World‬چاپ شده و خط ‪ 1‬در خروجی نمایش داده نمی شود چون کمپایلر توضیحات را نادیده می گیرد ‪.‬توضیحات بر‬
‫سه نوعند‪:‬‬
‫توضیحات تک خطی‬
‫‪// single line comment‬‬
‫توضیحات چند خطی‬
‫‪/* multi‬‬
‫‪line‬‬
‫‪comment */‬‬
‫توضیحات مستند سازی‬
‫**‪/‬‬
‫‪Documentation Comments‬‬
‫‪*/‬‬
‫توضیحات تک خطی همانگونه که از نامش پیداست‪ ،‬برای توضیحاتی در حد یک خط به کار می روند‪ .‬این توضیحات با عالمت ‪//‬‬
‫شروع می شوند و هر نوشته ای که در سمت راست آن قرار بگیرد جز توضیحات به حساب می آید‪ .‬این نوع توضیحات معموال در‬
‫باال یا کنار کد قرار می گیرند‪ .‬اگر توضیح درباره یک کد به بیش از یک خط نیاز باشد از توضیحات چند خطی استفاده می شود‪.‬‬
‫توضیحات چند خطی با *‪ /‬شروع و با ‪ */‬پایان می یابند‪ .‬هر نوشته ای که بین این دو عالمت قرار بگیرد جز توضیحات محسوب‬
‫می شود‪ .‬نوع دیگری از توضیحات ‪ ،‬توضیحات مستند سازی نامیده می شوند‪ .‬این نوع با **‪ /‬شروع و به ‪ */‬ختم می شوند‪ .‬از این‬
‫نوع برای مستند سازی برنامه استفاده می شود و در درس های آینده در مورد آنها توضیح خواهیم داد‪.‬‬
‫متغیر‬
‫متغیر مکانی از حافظه است که شما میتوانید مقادیری را در آن ذخیره کنید‪ .‬میتوان آن را به عنوان یک ظرف تصور کرد که دادههای‬
‫خود را در آن قرار دادهاید‪ .‬محتویات این ظرف میتواند پاک شود یا تغییر کند‪ .‬هر متغیر دارای یک نام نیز هست‪.‬که از طریق آن‬
‫میتوان متغیر را از دیگر متغیرها تشخیص داد و به مقدار آن دسترسی پیدا کرد‪ .‬همچنین دارای یک مقدار میباشد که میتواند‬
‫توسط کاربر انتخاب شده باشد یا نتیجه یک محاسبه باشد‪ .‬مقدار متغیر میتواند تهی نیز باشد‪ .‬متغیر دارای نوع نیز هست بدین‬
‫معنی که نوع آن با نوع داده ای که در آن ذخیره میشود یکی است‪ .‬متغیر دارای عمر نیز هست که از روی آن میتوان تشخیص‬
‫داد که متغیر باید چقدر در طول برنامه مورد استفاده قرار گیرد‪ .‬و در نهایت متغیر دارای محدوده استفاده نیز هست که به شما‬
‫میگوید که متغیر در چه جای برنامه برای شما قابل دسترسی است‪ .‬ما از متغیرها به عنوان یک انبار موقتی برای ذخیره داده استفاده‬
‫میکنیم‪ .‬هنگامی که یک برنامه ایجاد میکنیم احتیاج به یک مکان برای ذخیره داده‪ ،‬مقادیر یا دادههایی که توسط کاربر وارد‬
‫میشوند داریم‪ .‬این مکان همان متغیر است‪ .‬برای این از کلمه متغیر استفاده میشود چون ما میتوانیم بسته به نوع شرایط هر‬
‫جا که الزم باشد مقدار آن را تغییر دهیم‪ .‬متغیرها موقتی هستند و فقط موقعی مورد استفاده قرار میگیرند که برنامه در حال‬
‫اجراست و وقتی شما برنامه را میبندید محتویات متغیرها نیز پاک میشود‪ .‬قبال ذکر شد که به وسیله نام متغیر میتوان به آن‬
‫دسترسی پیدا کرد‪ .‬برای نامگذاری متغیرها باید قوانین زیر را رعایت کرد‪:‬‬
‫نام متغیر باید با یک از حروف الفبا )‪ (a-z or A-Z‬شروع شود‪.‬‬ ‫‪‬‬
‫نمیتواند شامل کاراکترهای غیرمجاز مانند ‪#, ?, ^, $.‬باشد‪.‬‬ ‫‪‬‬
‫نمیتوان از کلمات رزرو شده در جاوا برای نام متغیر استفاده کرد‪.‬‬ ‫‪‬‬
‫نام متغیر نباید دارای فضای خالی )‪ (spaces‬باشد‪.‬‬ ‫‪‬‬
‫اسامی متغیرها نسبت به بزرگی و کوچکی حروف حساس هستند‪ .‬در جاوا دو حرف مانند ‪ a‬و ‪ A‬دو کاراکتر مختلف به‬ ‫‪‬‬
‫حساب میآیند‪.‬‬
‫دو متغیر با نامهای ‪ myNumber‬و ‪ MyNumber‬دو متغیر مختلف محسوب میشوند چون یکی از آنها با حرف کوچک ‪ m‬و دیگری با‬
‫حرف بزرگ ‪ M‬شروع میشود‪ .‬شما نمیتوانید دو متغیر را که دقیق شبیه هم هستند را در یک ‪( scope‬محدوده) تعریف کنید‪Scope .‬‬
‫به معنای یک بلوک کد است که متغیر در آن قاب ل دسترسی و استفاده است‪ .‬در مورد ‪ Scope‬در فصلهای آینده بیشتر توضیح‬
‫خواهیم داد‪ .‬متغیر دارای نوع هست که نوع داده ای را که در خود ذخیره میکند را نشان میدهد‪ .‬معمولترین انواع داده ‪،int‬‬
‫‪ Boolean ،char ،float ،double ،byte ،long ،short‬میباشند‪ .‬برای مثال شما برای قرار دادن یک عدد صحیح در متغیر باید‬
‫از نوع ‪ int‬استفاده کنید‪.‬‬

‫‪۱۱‬‬ ‫مبانی زبان جاوا‬
‫انواع ساده‬
‫انواع ساده انواعی از دادهها هستند که شامل اعداد‪ ،‬کاراکترها و مقادیر بولی میباشند‪ .‬به انواع ساده انواع اصلی نیز گفته میشود‬
‫چون از آنها برای ساخت انواع پیچیده تری مانند کالسها و ساختارها استفاده میشود‪ .‬انواع ساده دارای مجموعه مشخصی از‬
‫مقادیر هستند و محدوده خاصی از اعداد را در خود ذخیره میکنند‪ .‬در جدول زیر انواع ساده و محدوده آنها آمده است‪:‬‬
‫دامنه‬ ‫نوع‬
‫اعداد صحیح بین ‪ -350‬تا ‪351‬‬ ‫‪byte‬‬
‫اعداد صحیح بین ‪ -15110‬تا ‪15111‬‬ ‫‪short‬‬
‫اعداد صحیح بین ‪ -5331301130‬تا ‪5331301131‬‬ ‫‪int‬‬
‫اعداد صحیح بین ‪ -6551115311013111030‬تا ‪655111531101311031‬‬ ‫‪long‬‬
‫جدول زیر انواعی که مقادیر با ممیز اعشار را میتوانند در خود ذخیره کنند را نشان میدهد‪:‬‬
‫دقت‬ ‫دامنه تقریبی‬ ‫نوع‬
‫‪ 1‬رقم‬ ‫‪±1.5E-45 to ±3.4E38‬‬ ‫‪float‬‬
‫‪ 31-31‬رقم‬ ‫‪±5.0E-324 to ±1.7E308‬‬ ‫‪double‬‬
‫برای به خاطر سپردن آنها باید از نماد علمی استفاده شود‪ .‬نوع دیگری از انواع ساده برای ذخیره دادههای غیر عددی به کار میروند‬
‫و در جدول زیر نمایش داده شدهاند‪:‬‬
‫مقادیر مجاز‬ ‫نوع‬
‫کاراکترهای یونیکد‬ ‫‪char‬‬
‫مقدار ‪ true‬یا ‪false‬‬ ‫‪boolean‬‬

‫نوع ‪ char‬برای ذخیره کاراکترهای یونیکد استفاده میشود‪.‬کاراکترها باید داخل یک کوتیشن ساده قرار بگیرند مانند (’‪ .)‘a‬نوع‬
‫‪ bool‬فقط میتواند مقادیر درست )‪ (true‬یا نادرست )‪ (false‬را در خود ذخیره کند و بیشتر در برنامههایی که دارای ساختار‬
‫تصمیم گیری هستند مورد استفاده قرار میگیرد‪.‬‬
‫استفاده از رشتهها‬
‫از رشته برای ذخیره گروهی از کاراکترها مانند یک پیغام استفاده میشود‪.‬مقادیر ذخیره شده در یک رشته باید داخل دابل کوتیشن‬
‫قرار گیرند تا توسط کمپایلر به عنوان یک رشته در نظر گرفته شوند‪ ،‬مانند (”‪ .)“massage‬جاوا دارای نوعی به نام رشته نیست‪ ،‬بلکه‬
‫رشتهها اشیایی هستند که از روی کالس ‪( String‬حرف ‪ S‬به صورت بزرگ نوشته میشود) ساخته میشوند‪ .‬با مفاهیم شیء و‬
‫کالس در درسهای آینده آشنا میشوید‪ .‬فقط در همین حد کافی است که بدانید که از رشتهها برای نمایش متن استفاده میشود‪.‬‬
‫مثال برای نمایش متن ‪ Hello World‬میتوان به صورت زیر عمل کرد ‪:‬‬
‫;"‪String str ="Hello World‬‬
‫دلیل اینکه در این قسمت درباره رشتهها مختصری توضیح دادیم این است که ممکن است در آموزشهای بعدی با آنها سر و کار‬
‫داشته باشیم‪ .‬در آینده به طور مفصل در مورد رشتهها توضیح میدهیم‪.‬‬
‫استفاده از متغیرها‬
‫در مثال زیر نحوه تعریف و مقدار دهی متغیرها نمایش داده شده است‪:‬‬

‫‪2‬‬
‫‪3‬‬ ‫;‪import java.text.MessageFormat‬‬
‫‪4‬‬
‫‪6‬‬ ‫{‬
‫‪8‬‬ ‫{‬
‫‪9‬‬ ‫‪//Declare variables‬‬
‫‪10‬‬ ‫;‪int num1‬‬
‫‪11‬‬ ‫;‪int num2‬‬
‫‪12‬‬ ‫;‪double num3‬‬
‫‪13‬‬ ‫;‪double num4‬‬
‫‪14‬‬ ‫;‪boolean boolVal‬‬
‫‪15‬‬ ‫;‪char myChar‬‬
‫‪16‬‬
۱1 ‫مبانی زبان جاوا‬
17 //Assign values to variables

18 num1 = 1;
19 num2 = 2;
20 num3 = 3.54;
21 num4 = 4.12;
22 boolVal = true;
23 myChar = 'R';
24
25 //Show the values of the variables
26 System.out.println(MessageFormat.format("num1 = {0}", num1));
29 System.out.println(MessageFormat.format("boolVal = {0}", boolVal));
31 System.out.println(MessageFormat.format("myChar = {0}", myChar));
32 }
33 }
num1 = 1
num2 = 2
num3 = 3.54
num4 = 4.12
boolVal = true
myChar = R
‫تعریف متغیر‬
‫ ابتدا باید نوع دادههایی را که این متغیرها قرار است در خود ذخیره‬.‫ متغیرهایی با نوع و نام متفاوت تعریف شدهاند‬33-31 ‫در خطوط‬
‫همیشه به یاد داشته باشید که قبل از‬.‫کنند را مشخص کنیم و سپس یک نام برای آنها در نظر بگیریم و در آخر سیمیکولن بگذاریم‬
.‫مقدار دهی و استفاده از متغیر باید آن را تعریف کرد‬
int num1;
int num2;
double num3;
double num4;
boolean boolVal;
char myChar;
:‫نحوه تعریف متغیر به صورت زیر است‬
data_type identifier;
‫ نیز نام متغیر است که به ما امکان استفاده و دسترسی‬Identifier . ... ‫ و‬double ،int ‫ همان نوع داده است مانند‬date_type
:‫ برای تعریف چند متغیر از یک نوع میتوان به صورت زیر عمل کرد‬.‫به مقدار متغیر را میدهد‬
data_type identifier1, identifier2, ... indentifierN;

‫مثال‬
‫;‪int num1, num2, num3, num4, num5‬‬
‫در مثال باال ‪ 1‬متغیر از نوع صحیح تعریف شده است‪ .‬توجه داشته باشید که بین متغیرها باید عالمت کاما )‪ (,‬باشد‪.‬‬
‫نامگذاری متغیرها‬
‫نام متغیر باید با یک حرف یا زیرخط و به دنبال آن حرف یا عدد شروع شود‪.‬‬ ‫‪‬‬
‫نمیتوان از کاراکترهای خاص مانند ‪ & ،% ،#‬یا عدد برای شروع نام متغیر استفاده کرد مانند ‪.2numbers‬‬ ‫‪‬‬
‫نام متغیر نباید دارای فاصله باشد‪ .‬برای نامهای چند حرفی میتوان به جای فاصله از عالمت زیرخط یا ‪ ...‬استفاده‬ ‫‪‬‬
‫کرد‪.‬‬
‫نامهای مجاز‪:‬‬
‫‪num1‬‬ ‫‪myNumber‬‬ ‫‪studentCount‬‬ ‫‪total‬‬ ‫‪first_name‬‬ ‫‪_minimum‬‬

‫‪num2‬‬ ‫‪myChar‬‬ ‫‪average‬‬ ‫‪amountDue‬‬ ‫‪last_name‬‬ ‫‪_maximum‬‬
‫‪name‬‬ ‫‪counter‬‬ ‫‪sum‬‬ ‫‪isLeapYear‬‬ ‫‪color_of_car‬‬ ‫‪_age‬‬
‫نامهای غیر مجاز‪:‬‬
‫‪123‬‬ ‫‪#numbers#‬‬ ‫‪#ofstudents‬‬ ‫‪1abc2‬‬

‫‪123abc‬‬ ‫‪$money‬‬ ‫‪first name‬‬ ‫‪ty.np‬‬
‫‪my number‬‬ ‫‪this&that‬‬ ‫‪last name‬‬ ‫‪1:00‬‬
‫اگر به نامهای مجاز در مثال باال توجه کنید متوجه قراردادهای به کار رفته در نامگذاری آنها خواهید شد‪ .‬یکی از روشهای نامگذاری‪،‬‬
‫نامگذاری کوهان شتری است‪ .‬در این روش که برای متغیرهای دو کلمه ای به کار میرود‪ ،‬اولین حرف اولین کلمه با حرف کوچک و‬
‫اولین حرف دومین کلمه با حرف بزرگ نمایش داده میشود مانند ‪ .myNumber :‬توجه کنید که اولین حرف کلمه ‪ Number‬با حرف‬
‫بزرگ شروع شده است‪ .‬مثال دیگر کلمه ‪ numberOfStudents‬است‪ .‬اگر توجه کنید بعد از اولین کلمه حرف اول سایر کلمات با‬
‫حروف بزرگ نمایش داده شده است‪.‬‬

‫‪۱۹‬‬ ‫مبانی زبان جاوا‬
‫محدوده متغیر‬
‫در کد ابتدای درس‪ ،‬متغیرها در داخل متد )(‪ main‬تعریف شده اند‪ .‬در نتیجه‪ ،‬این متغیرها فقط در داخل متد )(‪ main‬قابل‬
‫دسترسی و استفاده هستند‪ .‬محدوده یک متغیر مشخص میکند که متغیر در کجای کد قابل دسترسی است‪ .‬هنگامیکه برنامه به‬
‫پایان متد )(‪ main‬میرسد متغیرها از محدوده خارج و بدون استفاده میشوند تا زمانی که برنامه در حال اجراست‪.‬محدوده متغیرها‬
‫انواعی دارد که در درسهای بعدی با آنها آشنا میشوید‪ .‬تشخیص محدوده متغیر بسیار مهم است چون به وسیله آن میفهمید‬
‫که در کجای کد میتوان از متغیر استفاده کرد‪ .‬باید یاد آور شد که دو متغیر در یک محدوده نمیتوانند دارای نام یکسان باشند‪ .‬مثال‬
‫کد زیر در برنامه ایجاد خطا میکند‪:‬‬
‫;‪int num1‬‬
‫از آنجاییکه جاوا به بزرگی و کوچک بودن حروف حساس است میتوان از این خاصیت برای تعریف چند متغیر هم نام ولی با حروف‬
‫متفاوت (از لحاظ بزرگی و کوچکی) برای تعریف چند متغیر از یک نوع استفاده کرد مانند‪:‬‬
‫;‪int Num1‬‬
‫;‪int NUM1‬‬
‫مقداردهی متغیرها‬
‫میتوان فورا بعد از تعریف متغیرها مقادیری را به آنها اختصاص داد‪ .‬این عمل را مقداردهی مینامند‪ .‬در زیر نحوه مقدار دهی‬
‫متغیرها نشان داده شده است‪:‬‬
‫;‪data_type identifier = value‬‬
‫به عنوان مثال‪:‬‬
‫;‪int myNumber = 7‬‬
‫همچنین میتوان چندین متغیر را فقط با گذاشتن کاما بین آنها به سادگی مقدار دهی کرد‪:‬‬
‫;‪data_type variable1 = value1, varaible2 = value2, ... variableN, valueN‬‬
‫;‪int num1 = 1, num2 = 2, num3 = 3‬‬

‫تعریف متغیر با مقدار دهی متغیرها متفاوت است‪ .‬تعریف متغیر یعنی انخاب نوع و نام برای متغیر ولی مقدار دهی یعنی اختصاص‬
‫یک مقدار به متغیر‪.‬‬
‫اختصاص مقدار به متغیر‬
‫در زیر نحوه اختصاص مقادیر به متغیرها نشان داده شده است‪:‬‬
‫;‪num1 = 1‬‬
‫;‪num2 = 2‬‬
‫;‪num3 = 3.54‬‬
‫;‪num4 = 4.12‬‬
‫;‪boolVal = true‬‬
‫;'‪myChar = 'R‬‬
‫به این نکته توجه کنید که شما به متغیری که هنوز تعریف نشده نمیتوانید مقدار بدهید‪ .‬شما فقط میتوانید از متغیرهایی استفاده‬
‫کنید که هم تعریف و هم مقدار دهی شده باشند‪ .‬مثال متغیرهای باال همه قابل استفاده هستند‪ .‬در این مثال ‪ num1‬و ‪ num2‬هر دو‬
‫تعریف شدهاند و مقادیری از نوع صحیح به آنها اختصاص داده شده است‪ .‬اگر نوع داده با نوع متغیر یکی نباشد برنامه پیغام‬
‫خطا میدهد‪.‬‬
‫جانگهدار)‪(Placeholders‬‬
‫به متد )(‪ format‬از کالس ‪ MessageFormat‬در خطوط (‪ )51-15‬توجه کنید‪ .‬برای استفاده از متد )(‪ format‬و کالس‬
‫‪ MessageFormat‬ابتدا باید ‪ Package‬مربوط به آنها را در برنامه وارد کنید (خط ‪:)1‬‬
‫;‪import java.text.MessageFormat‬‬
‫این متد دو آرگومان قبول میکند‪ .‬آرگومانها اطالعاتی هستند که متد با استفاده از آنها کاری انجام میدهد‪ .‬آرگومانها به وسیله‬
‫کاما از هم جدا میشوند ‪ .‬آرگومان اول یک رشته قالب بندی شده است و آرگومان دوم مقداری است که توسط رشته قالب بندی‬
‫شده مورد استفاده قرار میگیرد‪ .‬اگر به دقت نگاه کنید رشته قالب بندی شده دارای عدد صفری است که در داخل دو آکوالد محصور‬
‫شده است‪ .‬البته عدد داخل دو آکوالد میتواند از صفر تا ‪ n‬باشد‪ .‬به این اعداد جانگهدار می گویند‪ .‬این اعداد بوسیله مقدار آرگومان‬
‫بعد جایگزین میشوند‪ .‬به عنوان مثال جانگهدار }‪ {0‬به این معناست که اولین آرگومان (مقدار) بعد از رشته قالب بندی شده در آن‬
‫قرار میگیرد‪ .‬متد )(‪ format‬عمال میتواند هر تعداد آرگومان قبول کند اولین آرگومان همان رشته قالب بندی شده است که جانگهدار‬
‫در آن قرار دارد و دومین آرگومان مقداری است که جایگزین جانگهدار میشود‪ .‬در مثال زیر از ‪ 3‬جانگهدار استفاده شده است‪:‬‬
‫‪System.out.println(MessageFormat.format("The values are {0}, {1}, {2}, and {3}.", value1, value2,‬‬
‫;)‪value3, value4‬‬
‫جانگهدارها از صفر شروع میشوند‪ .‬تعداد جانگهدارها باید با تعداد آرگومانهای بعد از رشته قالب بندی شده برابر باشد‪ .‬برای مثال‬
‫اگر شما چهار جانگهدار مثل باال داشته باشید باید چهار مقدار هم برای آنها بعد از رشته قالب بندی شده در نظر بگیرید‪ .‬اولین جا‬
‫نگهدار با دومین آرگومان و دومین جا نگهدار با سومین آرگومان جایگزین میشود‪ .‬در ابتدا فهمیدن این مفهوم برای کسانی که تازه‬
‫برنامه نویسی را شروع کردهاند سخت است‪ .‬اما در درسهای آینده مثالهای زیادی در این مورد مشاهده خواهید کرد‪.‬‬
‫ثابت‬
‫ثابتها انواعی از متغیرها هستند که مقدار آنها در طول برنامه تغییر نمیکند‪ .‬ثابتها حتما باید مقدار دهی اولیه شوند و اگر‬
‫مقدار دهی آنها فراموش شود در برنامه خطا به وجود میآید‪ .‬بعد از این که به ثابتها مقدار اولیه اختصاص داده شد هرگز در‬
‫زمان اجرای برنامه نمیتوان آن را تغییر داد‪ .‬برای تعریف ثابتها باید از کلمه کلیدی ‪ final‬استفاده کرد‪ .‬معموال نام ثابتها را‬
‫طبق قرارداد با حروف بزرگ مینویسند تا تشخیص آنها در برنامه راحت باشد‪ .‬نحوه تعریف ثابت در زیر آمده است‪:‬‬
‫;‪final data_type identifier = initial_value‬‬
‫مثال‪:‬‬

‫{‬
‫{‬
‫;‪final int NUMBER = 1‬‬
‫‪NUMBER = 10; //ERROR, Cant modify a constant‬‬

‫}‬
‫}‬
‫در این مثال میبینید که مقدار دادن به یک ثابت‪ ،‬که قبال مقدار دهی شده برنامه را با خطا مواجه میکند‪ .‬نکتهی دیگری که نباید‬
‫فراموش شود این است که‪ ،‬نباید مقدار ثابت را با مقدار دیگر متغیرهای تعریف شده در برنامه برابر قرار داد‪ .‬مثال‪:‬‬
‫;‪int someVariable‬‬
‫;‪final int MY_CONST = someVariable‬‬
‫ممکن است این سؤال برایتان پیش آمده باشد که دلیل استفاده از ثابتها چیست؟ اگر مطمئن هستید که مقادیری در برنامه‬
‫وجود دارند که هرگز در طول برنامه تغییر نمیکنند بهتر است که آنها را به صورت ثابت تعریف کنید‪ .‬این کار هر چند کم‪ ،‬کیفیت‬
‫برنامه شما را باال میبرد‪.‬‬
‫تبدیل ضمنی‬
‫تبدیل ضمنی یا تبدیل بزرگ کننده یا ‪ widening conversion‬یک نوع تبدیل است که به طور خودکار انجام میشود‪ .‬در این نوع‬
‫تبدیل در صورتی یک متغیر از یک نوع داده میتواند به یک نوع دیگر تبدیل شود که مقدار آن از مقدار داده ای که میخواهد به‬
‫آن تبدیل شود کمتر باشد‪ .‬به عنوان مثال نوع داده ای ‪ byte‬میتواند مقادیر ‪ 3‬تا ‪ 511‬را در خود ذخیره کند و نوع داده ای ‪int‬‬
‫مقادیر ‪ -5331301130‬تا ‪ 5331301131‬را شامل میشود‪ .‬پس میتوانید یک متغیر از نوع ‪ byte‬را به یک نوع ‪ int‬تبدیل کنید‬
‫‪:‬‬
‫;‪byte number1 = 5‬‬
‫;‪int number2 = number1‬‬
‫در مثال باال مقدار ‪ number1‬برابر ‪ 1‬است در نتیجه متغیر ‪ number2‬که یک متغیر از نوع صحیح است میتواند مقدار ‪number1‬‬
‫را در خود ذخیره کند چون نوع صحیح از نوع بایت بزرگتر است‪ .‬پس متغیر ‪ number1‬که یک متغیر از نوع بایت است میتواند‬
‫به طور ضمنی به ‪ number2‬که یک متغیر از نوع صحیح است تبدیل شود‪ .‬اما عکس مثال باال صادق نیست‪.‬‬
‫‪int‬‬ ‫;‪number1 = 5‬‬
‫;‪byte number2 = number1‬‬

‫در این مورد ما با خطا مواجه میشویم‪ .‬اگر چه مقدار ‪ 1‬متغیر ‪ number1‬در محدوده مقادیر ‪ byte‬یعنی اعداد بین ‪ 3-511‬قرار دارد‬
‫اما متغیر ی از نوع بایت حافظه کمتری نسبت به متغیری از نوع صحیح اشغال میکند‪ .‬نوع ‪ byte‬شامل ‪ 0‬بیت یا ‪ 0‬رقم دودویی‬
‫است در حالی که نوع ‪ int‬شامل ‪ 15‬بیت یا رقم باینری است‪.‬یک عدد باینری عددی متشکل از ‪ 3‬و ‪ 3‬است‪ .‬برای مثال عدد ‪ 1‬در‬
‫کامپیوتر به عدد باینری ‪ 333‬ترجمه میشود‪ .‬بنابراین وقتی ما عدد ‪ 1‬را در یک متغیر از نوع بایت ذخیره میکنیم‪ ،‬عددی به صورت‬
‫زیر نمایش داده میشود‪:‬‬
‫‪00000101‬‬
‫و وقتی آن را در یک متغیر از نوع صحیح ذخیره میکنیم‪ ،‬به صورت زیر نمایش داده میشود‪:‬‬
‫‪00000000000000000000000000000101‬‬
‫بنابراین قرار دادن یک مقدار ‪ int‬در یک متغیر ‪ byte‬درست مانند این است که ما سعی کنیم که یک توپ فوتبال را در یک‬
‫سوراخ کوچک گلف جای دهیم‪ .‬برای قرار دادن یک مقدار ‪ int‬در یک متغیر از نوع ‪ byte‬میتوان از تبدیل صریح استفاه کرد که‬
‫در درسهای آینده توضیح داده میشود‪ .‬نکته دیگری که نباید فراموش شود این است که شما نمیتوانید اعداد با ممیز اعشار را به‬
‫یک نوع ‪ int‬تبدیل کنید چون این کار باعث از بین رفتن بخش اعشاری این اعداد میشود‪.‬‬
‫;‪double number1 = 5.25‬‬
‫‪int number2 = number1; //Error‬‬
‫تبدیالتی که جاوا به صورت ضمنی میتواند انجام دهد در زیر آمده است‪:‬‬
‫‪byte > short > int > long > float > double‬‬
‫تبدیل صریح‬
‫تبدیل صریح یا تبدیل کوچک کننده یا ‪ Narrowing Casting‬نوعی تبدیل است که برنامه را مجبور میکند که یک نوع داده را به‬
‫نوعی دیگر تبدیل کند اگر این نوع تبدیل از طریق تبدیل ضمنی انجام نشود‪ .‬در هنگام استفاده از این تبدیل باید دقت کرد‪ .‬چون‬
‫در این نوع تبدیل ممکن است‪ ،‬مقادیر اصالح یا حذف شوند‪ .‬ما میتوانیم این عملیات را با استفاده از ‪ Cast‬انجام دهیم‪Cast .‬‬
‫فقط نام دیگر تبدیل صریح است و دستور آن به صورت زیر است‪:‬‬
‫;‪datatypeA variableA = value‬‬
‫;‪datatypeB variableB = (datatypeB)variableA‬‬
‫همانطور که قبال مشاهده کردید نوع ‪ int‬را نتوانستیم به نوع ‪ byte‬تبدیل کنیم اما اکنون با استفاده از عمل ‪ Cast‬این تبدیل‬
‫انجام خواهد شد‪:‬‬
‫;‪int number1 = 5‬‬
‫;‪byte number2 = (byte)number1‬‬
‫حال اگر برنامه را اجرا کنید با خطا مواجه نخواهید شد‪ .‬همانطور که پیشتر اشاره شد ممکن است در هنگام تبدیالت مقادیر اصلی‬
‫تغییر کنند‪ .‬برای مثال وقتی که یک عدد با ممیز اعشار مثال از نوع ‪ double‬را به یک نوع ‪ int‬تبدیل میکنیم مقدار اعداد بعد از‬
‫ممیز از بین میروند‪:‬‬
‫;‪double number1 = 5.25‬‬
‫;‪int number2 = (int)number1‬‬
‫;)‪System.out.println(number2‬‬
‫‪5‬‬
‫خروجی کد باال عدد ‪ 1‬است چون نوع داده ای ‪ int‬نمیتواند مقدار اعشار بگیرد‪ .‬حالت دیگر را تصور کنید‪ .‬اگر شما بخواهید یک‬
‫متغیر را که دارای مقداری بیشتر از محدوده متغیر مقصد هست تبدیل کنید چه اتفاقی میافتد؟ مانند تبدیل زیر که میخواهیم‬
‫متغیر ‪ number1‬را که دارای مقدار ‪ 133‬است را به نوع بایت تبدیل کنیم که محدود اعداد بین ‪ 3-511‬را پوشش میدهد‪.‬‬
‫;‪int number1 = 300‬‬
‫;‪byte number2 = (byte)number1‬‬
‫;))‪System.out.println(MessageFormat.format("Value of number2 is {0}.", number2‬‬
‫‪Value of number2 is 44.‬‬
‫خروجی کد باال عدد ‪ 33‬است‪ Byte .‬فقط میتواند شامل اعداد ‪ 3‬تا ‪ 511‬باشد و نمیتواند مقدار ‪ 133‬را در خود ذخیره کند‪ .‬حال‬
‫میخواهیم ببینیم که چرا به جای عدد ‪ 133‬ما عدد ‪ 33‬را در خروجی میگیریم‪ .‬این کار به تعداد بیتها بستگی دارد‪ .‬یک ‪byte‬‬
‫دارای ‪ 0‬بیت است در حالی که ‪ int‬دارای ‪ 15‬بیت است‪ .‬حال اگر به مقدار باینری ‪ 5‬عدد توجه کنید متوجه میشوید که چرا‬
‫خروجی عدد ‪ 33‬است‪.‬‬

‫‪300 = 00000000000000000000000100101100‬‬
‫= ‪255‬‬ ‫‪11111111‬‬
‫= ‪44‬‬ ‫‪00101100‬‬
‫خروجی باال نشان میدهد که بیشترین مقدار ‪ byte‬که عدد ‪ 511‬است میتواند فقط شامل ‪ 0‬بیت باشد (‪ )33333333‬بنابراین فقط ‪0‬‬
‫بیت اول مقدار ‪ int‬به متغیر ‪ byte‬انتقال مییابد که شامل (‪ )33333333‬یا عدد ‪ 33‬در مبنای ‪ 33‬است‪.‬‬
‫عبارات و عملگرها‬
‫ابتدا با دو کلمه آشنا شوید‪:‬‬
‫عملگر ‪ :‬نمادهایی هستند که اعمال خاص انجام میدهند‪.‬‬ ‫‪‬‬
‫عملوند ‪ :‬مقادیری که عملگرها بر روی آنها عملی انجام میدهند‪.‬‬ ‫‪‬‬
‫مثال ‪ X+Y‬یک عبارت است که در آن ‪ X‬و ‪ Y‬عملوند و عالمت ‪ +‬عملگر به حساب میآیند‪ .‬زبانهای برنامه نویسی جدید دارای‬
‫عملگرهایی هستند که از اجزاء معمول زبان به حساب میآیند‪ .‬جاوا دارای عملگرهای مختلفی از جمله عملگرهای ریاضی‪ ،‬تخصیصی‪،‬‬
‫مقایسه ای‪ ،‬منطقی و بیتی میباشد‪ .‬از عملگرهای ساده ریاضی میتوان به عملگر جمع و تفریق اشاره کرد‪ .‬سه نوع عملگر در جاوا‬
‫وجود دارد‪:‬‬
‫یگانی)‪ - (Unary‬به یک عملوند نیاز دارد‬ ‫‪‬‬
‫دودویی)‪ - (Binary‬به دو عملوند نیاز دارد‬ ‫‪‬‬
‫سه تایی)‪ - (Ternary‬به سه عملوند نیاز دارد‬ ‫‪‬‬
‫انواع مختلف عملگر که در ای بخش مورد بحث قرار میگیرند‪ ،‬عبارتاند از‪:‬‬
‫عملگرهای ریاضی‬ ‫‪‬‬
‫عملگرهای تخصیصی‬ ‫‪‬‬
‫عملگرهای مقایسه ای‬ ‫‪‬‬
‫عملگرهای منطقی‬ ‫‪‬‬

‫عملگرهای بیتی‬ ‫‪‬‬
‫عملگرهای ریاضی‬
‫جاوا از عملگرهای ریاضی برای انجام محاسبات استفاده میکند‪ .‬جدول زیر عملگرهای ریاضی جاوا را نشان میدهد‪:‬‬
‫نتیجه‬ ‫مثال‬ ‫دسته‬ ‫عملگر‬
‫‪ Var1‬برابر است با حاصل جمع ‪ var2‬و ‪var3‬‬ ‫;‪var1 = var2 + var3‬‬ ‫‪Binary‬‬ ‫‪+‬‬
‫‪ Var1‬برابر است با حاصل تفریق ‪ var2‬و ‪var3‬‬ ‫;‪var1 = var2 – var3‬‬ ‫‪Binary‬‬ ‫‪-‬‬
‫‪ Var1‬برابر است با حاصلضرب ‪ var2‬در ‪var3‬‬ ‫;‪var1 = var2 * var3‬‬ ‫‪Binary‬‬ ‫*‬
‫‪ Var1‬برابر است با حاصل تقسیم ‪ var2‬بر ‪var3‬‬ ‫;‪var1 = var2 / var3‬‬ ‫‪Binary‬‬ ‫‪/‬‬
‫‪ Var1‬برابر است با باقیمانده تقسیم ‪ var2‬و ‪var3‬‬ ‫;‪var1 = var2 % var3‬‬ ‫‪Binary‬‬ ‫‪%‬‬
‫‪ Var1‬برا بر است با مقدار ‪var2‬‬ ‫;‪var1 = +var2‬‬ ‫‪Unary‬‬ ‫‪+‬‬
‫‪ Var1‬برابر است با مقدار ‪ var2‬ضربدر ‪- 3‬‬ ‫;‪var1 = -var2‬‬ ‫‪Unary‬‬ ‫‪-‬‬
‫دیگر عملگرهای جاوا عملگرهای کاهش و افزایش هستند‪.‬این عملگرها مقدار ‪ 3‬را از متغیرها کم یا به آنها اضافه میکنند‪ .‬از این‬
‫متغیرها اغلب در حلقهها استفاده میشود‪:‬‬
‫مقدار ‪ var1‬برابر است با ‪ var2‬بعالوه ‪3‬‬ ‫;‪var1 = ++var2‬‬ ‫‪Unary‬‬ ‫‪++‬‬
‫مقدار ‪ var1‬برابر است با ‪ var2‬منهای ‪3‬‬ ‫;‪var1 = --var2‬‬ ‫‪Unary‬‬ ‫‪--‬‬
‫مقدار ‪ var1‬برابر است با ‪ .var2‬به متغیر ‪ var2‬یک واحد اضافه میشود ‪.‬‬ ‫;‪var1 = var2++‬‬ ‫‪Unary‬‬ ‫‪++‬‬
‫مقدار ‪ var1‬برابر است با ‪ .var2‬از متغیر ‪ var2‬یک واحد کم میشود ‪.‬‬ ‫;‪var1 = var2--‬‬ ‫‪Unary‬‬ ‫‪--‬‬
11 ‫مبانی زبان جاوا‬
‫ بیاید افزایش‬var2 ‫ اگر عملگر قبل از متغیر‬.‫به این نکته توجه داشته باشید که محل قرار گیری عملگر در نتیجه محاسبات تأثیر دارد‬
‫ میشود و سپس متغیر‬var2 ‫ برابر‬var1 ‫ قرار بگیرند ابتدا‬var2 ‫ چنانچه عملگرها بعد از متغیر‬.‫ اتفاق میافتد‬var1 ‫یا کاهش‬
:‫ به مثالهای زیر توجه کنید‬.‫افزایش یا کاهش مییابد‬var2
package myfirstprogram;
import java.text.MessageFormat;
public class MyFirstProgram

{
public static void main(String[] args)
{
int x = 0;
int y = 1;
x = ++y;
System.out.println(MessageFormat.format("x= {0}",x));
System.out.println(MessageFormat.format("y= {0}", y));
}
}
x=2
y=2

{
{
int x = 0;
int y = 1;
x = --y;
}
}
x=0
y=0
‫ کم‬y ‫ باعث میشود که ابتدا یک واحد از‬y ‫ قبل از عملوند‬++ ‫ و‬-- ‫درج عملگرهای‬،‫همانطور که در دو مثال باال مشاهده میکنید‬
:‫ حال به دو مثال زیر توجه کنید‬.‫ قرار بگیرد‬x ‫ اضافه شود و سپس نتیجه در عملوند‬y ‫و یا یک واحد به‬
‫ تخصصی ترین سایت آموزش جاوا در ایران‬w3-farsi.com 10

{
{
int x = 0;
int y = 1;
x = y--;
}
}
x=1
y=0

{
{
int x = 0;
int y = 1;
x = y++;
}
}
x=1
y=2
‫ در داخل‬y ‫ باعث میشود که ابتدا مقدار‬y ‫ بعد از عملوند‬++ ‫ و‬-- ‫در عملگرهای‬،‫همانطور که در دو مثال باال مشاهده میکنید‬
‫ حال میتوانیم با ایجاد یک برنامه نحوه عملکرد‬.‫ کم و یا یک واحد به آن اضافه شود‬y ‫ قرار بگیرد و سپس یک واحد از‬x ‫متغیر‬
:‫عملگرهای ریاضی در جاوا را یاد بگیریم‬

{
{
//Variable declarations
int num1, num2;
‫‪//Assign test values‬‬

‫;‪num1 = 5‬‬
‫;‪num2 = 3‬‬
‫‪System.out.println(MessageFormat.format("The sum of {0} and {1} is {2}.",‬‬

‫;)))‪num1, num2, (num1 + num2‬‬
‫‪System.out.println(MessageFormat.format("The difference of {0} and {1} is {2}.",‬‬
‫;)))‪num1, num2, (num1 - num2‬‬
‫‪System.out.println(MessageFormat.format("The product of {0} and {1} is {2}.",‬‬
‫;)))‪num1, num2, (num1 * num2‬‬
‫‪System.out.println(MessageFormat.format("The quotient of {0} and {1} is {2}.",‬‬
‫;)))‪num1, num2, ((double)num1 / num2‬‬
‫‪System.out.println(MessageFormat.format("The remainder of {0} and {1} is {2}.",‬‬
‫;)))‪num1, num2, (num1 % num2‬‬
‫}‬
‫}‬
‫‪The‬‬ ‫‪sum of 5 and 3 is 8.‬‬

‫‪The‬‬ ‫‪difference of 5 and 3 is 2.‬‬
‫‪The‬‬ ‫‪product of 5 and 3 is 15.‬‬
‫‪The‬‬ ‫‪quotient of 5 and 3 is 1.67.‬‬
‫‪The‬‬ ‫‪remainder of 5 divided by 3 is 2‬‬
‫برنامه باال نتیجه هر عبارت را نشان میدهد‪ .‬در این برنامه از متد )(‪ println‬برای نشان دادن نتایج در سطرهای متفاوت استفاده‬
‫شده است‪ .‬در این مثال با یک نکته عجیب مواجه میشویم و آن حاصل تقسیم دو عدد صحیح است‪ .‬وقتی که دو عدد صحیح را‬
‫بر هم تقسیم کنیم حاصل باید یک عدد صحیح و فاقد بخش کسری باشد‪ .‬اما همانطور که مشاهده میکنید اگر فقط یکی از اعداد‬
‫را به نوع اعشاری ‪ double‬تبدیل کنیم (در مثال میبینید) حاصل به صورت اعشار نشان داده میشود‪.‬‬
‫عملگرهای تخصیصی‬
‫نوع دیگر از عملگرهای جاوا عملگرهای جایگزینی نام دارند‪.‬این عملگرها مقدار متغیر سمت راست خود را در متغیر سمت چپ قرار‬
‫میدهند‪ .‬جدول زیر انواع عملگرهای تخصیصی در جاوا را نشان میدهد‪:‬‬
‫نتیجه‬ ‫مثال‬ ‫عملگر‬
‫مقدار ‪ var1‬برابر است با مقدار ‪var2‬‬ ‫;‪var1 = var2‬‬ ‫=‬
‫مقدار ‪ var1‬برابر است با حاصل جمع ‪ var1‬و ‪var2‬‬ ‫;‪var1 += var2‬‬ ‫=‪+‬‬
‫مقدار ‪ var1‬برابر است با حاصل تفریق ‪ var1‬و ‪var2‬‬ ‫;‪var1 -= var2‬‬ ‫=‪-‬‬
‫مقدار ‪ var1‬برابر است با حاصل ضرب ‪ var1‬در ‪var2‬‬ ‫;‪var1 *= var2‬‬ ‫=*‬
‫مقدار ‪ var1‬برابر است با حاصل تقسیم ‪ var1‬بر ‪var2‬‬ ‫;‪var1 /= var2‬‬ ‫=‪/‬‬
‫مقدار ‪ var1‬برابر است با باقیمانده تقسیم ‪ var1‬بر ‪var2‬‬ ‫;‪var1 %= var2‬‬ ‫=‪%‬‬
‫از عملگر =‪ +‬برای اتصال دو رشته نیز میتوان استفاده کرد‪.‬استفاده از این نوع عملگرها در واقع یک نوع خالصه نویسی در کد است‪.‬‬
‫مثال شکل اصلی کد ‪ var1 += var2‬به صورت ‪ var1 = var1 + var2‬میباشد‪ .‬این حالت کدنویسی زمانی کارایی خود را نشان‬
‫میدهد که نام متغیرها طوالنی باشد‪ .‬برنامه زیر چگونگی استفاده از عملگرهای تخصیصی و تأثیر آنها را بر متغیرها نشان میدهد‪.‬‬

‫{‬
‫{‬
‫;‪int number‬‬
‫;)"‪System.out.println("Assigning 10 to number...‬‬
‫;‪number = 10‬‬
‫;))‪System.out.println(MessageFormat.format("Number = {0}", number‬‬
‫;)"‪System.out.println("Adding 10 to number...‬‬
‫;‪number += 10‬‬
‫;)"‪System.out.println("Subtracting 10 to number...‬‬
‫;‪number -= 10‬‬
‫}‬
‫}‬
‫‪Assigning 10 to number...‬‬
‫‪Number = 10‬‬
‫‪Adding 10 to number...‬‬
‫‪Subtracting 10 from number...‬‬
‫در برنامه از ‪ 1‬عملگر تخصیصی استفاده شده است‪ .‬ابتدا یک متغیر و مقدار ‪ 33‬با استفاده از عملگر = به آن اختصاص داده شده‬
‫است‪ .‬سپس به آن با استفاده از عملگر =‪ +‬مقدار ‪ 33‬اضافه شده است‪.‬و در آخر به وسیله عملگر =‪ -‬عدد ‪ 33‬از آن کم شده است‪.‬‬
‫عملگرهای مقایسه ای‬

‫از عملگرهای مقایسه ای برای مقایسه مقادیر استفاده میشود‪ .‬نتیجه این مقادیر یک مقدار بولی(منطقی) است‪ .‬این عملگرها اگر‬
‫نتیجه مقایسه دو مقدار درست باشد مقدار ‪ true‬و اگر نتیجه مقایسه اشتباه باشد مقدار ‪ false‬را نشان میدهند‪ .‬این عملگرها‬
‫به طور معمول در دستورات شرطی به کار میروند به این ترتیب که باعث ادامه یا توقف دستور شرطی میشوند‪ .‬جدول زیر عملگرهای‬
‫مقایسه ای در جاوا را نشان میدهد‪:‬‬
‫‪ var1‬در صورتی ‪ true‬است که مقدار ‪ var2‬با مقدار ‪var3‬‬ ‫‪var1 = var2 == var3‬‬ ‫‪Binary‬‬ ‫==‬
‫برابر باشد در غیر اینصورت ‪ false‬است‬
‫‪ var1‬در صورتی ‪ true‬است که مقدار ‪ var2‬با مقدار ‪var3‬‬ ‫‪var1 = var2 != var3‬‬ ‫‪Binary‬‬ ‫=!‬
‫برابر نباشد در غیر اینصورت ‪ false‬است‬
‫‪ var1‬در صورتی ‪ true‬است که مقدار ‪ var2‬کوچکتر از ‪var3‬‬ ‫‪var1 = var2 < var3‬‬ ‫‪Binary‬‬ ‫<‬
‫مقدار باشد در غیر اینصورت ‪ false‬است‬
‫‪ var1‬در صورتی ‪ true‬است که مقدار ‪ var2‬بزرگتر ازمقدار ‪var3‬‬ ‫‪var1 = var2 > var3‬‬ ‫‪Binary‬‬ ‫>‬
‫باشد در غیر اینصورت ‪ false‬است‬
‫‪ var1‬در صورتی ‪ true‬است که مقدار ‪ var2‬کوچکتر یا مساوی‬ ‫‪var1 = var2 <= var3‬‬ ‫‪Binary‬‬ ‫=<‬
‫مقدار ‪ var3‬باشد در غیر اینصورت ‪ false‬است‬
‫‪ var1‬در صورتی ‪ true‬است که مقدار ‪ var2‬بزرگتر یا مساوی‬ ‫‪var1 = var2 >= var3‬‬ ‫‪Binary‬‬ ‫=>‬
‫‪ var3‬مقدار باشد در غیر اینصورت ‪ false‬است‬
‫برنامه زیر نحوه عملکرد این عملگرها را نشان میدهد‪:‬‬

‫{‬
‫{‬
‫;‪int num1 = 10‬‬
‫;‪int num2 = 5‬‬
‫}‪System.out.println(MessageFormat.format("{0‬‬ ‫==‬ ‫}‪{1‬‬ ‫‪:‬‬ ‫‪{2}",‬‬ ‫‪num1,‬‬ ‫‪num2,‬‬ ‫‪num1‬‬ ‫==‬ ‫;))‪num2‬‬
‫}‪System.out.println(MessageFormat.format("{0‬‬ ‫=!‬ ‫}‪{1‬‬ ‫‪:‬‬ ‫‪{2}",‬‬ ‫‪num1,‬‬ ‫‪num2,‬‬ ‫‪num1‬‬ ‫=!‬ ‫;))‪num2‬‬
‫}‪System.out.println(MessageFormat.format("{0‬‬ ‫<‬ ‫}‪{1‬‬ ‫‪:‬‬ ‫‪{2}",‬‬ ‫‪num1,‬‬ ‫‪num2,‬‬ ‫‪num1‬‬ ‫<‬ ‫;))‪num2‬‬
‫}‪System.out.println(MessageFormat.format("{0‬‬ ‫>‬ ‫}‪{1‬‬ ‫‪:‬‬ ‫‪{2}",‬‬ ‫‪num1,‬‬ ‫‪num2,‬‬ ‫‪num1‬‬ ‫>‬ ‫;))‪num2‬‬
‫}‪System.out.println(MessageFormat.format("{0‬‬ ‫=<‬ ‫}‪{1‬‬ ‫‪:‬‬ ‫‪{2}",‬‬ ‫‪num1,‬‬ ‫‪num2,‬‬ ‫‪num1‬‬ ‫=<‬ ‫;))‪num2‬‬
‫}‪System.out.println(MessageFormat.format("{0‬‬ ‫=>‬ ‫}‪{1‬‬ ‫‪:‬‬ ‫‪{2}",‬‬ ‫‪num1,‬‬ ‫‪num2,‬‬ ‫‪num1‬‬ ‫=>‬ ‫;))‪num2‬‬
‫}‬
‫}‬
‫‪10‬‬ ‫==‬ ‫‪5‬‬ ‫‪:‬‬ ‫‪False‬‬

‫‪10‬‬ ‫=!‬ ‫‪5‬‬ ‫‪:‬‬ ‫‪True‬‬
‫‪10‬‬ ‫<‬ ‫‪5‬‬ ‫‪:‬‬ ‫‪False‬‬
‫‪10‬‬ ‫>‬ ‫‪5‬‬ ‫‪:‬‬ ‫‪True‬‬
‫‪10‬‬ ‫=<‬ ‫‪5‬‬ ‫‪:‬‬ ‫‪False‬‬
‫‪10‬‬ ‫=>‬ ‫‪5‬‬ ‫‪:‬‬ ‫‪True‬‬
‫در مثال باال ابتدا دو متغیر را که میخواهیم با هم مقایسه کنیم را ایجاد کرده و به آنها مقادیری اختصاص میدهیم‪.‬سپس با‬
‫استفاده از یک عملگر مقایسه ای آنها را با هم مقایسه کرده و نتیجه را چاپ میکنیم‪ .‬به این نکته توجه کنید که هنگام مقایسه‬
‫دو متغیر از عملگر == به جای عملگر = باید استفاده شود‪ .‬عملگر = عملگر تخصیصی است و در عبارتی مانند ‪ x = y‬مقدار ‪ y‬را‬
‫در به ‪ x‬اختصاص میدهد‪ .‬عملگر == عملگر مقایسه ای است که دو مقدار را با هم مقایسه میکند مانند ‪ x==y‬و اینطور خوانده‬
‫میشود ‪ x‬برابر است با ‪. y‬‬
‫عملگرهای منطقی‬
‫عملگرهای منطقی بر روی عبارات منطقی عمل میکنند و نتیجه آنها نیز یک مقدار بولی است‪ .‬از این عملگرها اغلب برای شرطهای‬
‫پیچیده استفاده میشود‪ .‬همانطور که قبال یاد گرفتید مقادیر بولی میتوانند ‪ false‬یا ‪ true‬باشند‪ .‬فرض کنید که ‪ var2‬و‬
‫‪ var3‬دو مقدار بولی هستند‪.‬‬
‫مثال‬ ‫دسته‬ ‫نام‬ ‫عملگر‬
‫;‪var1 = var2 && var3‬‬ ‫‪Binary‬‬ ‫منطقی ‪AND‬‬ ‫&&‬
‫;‪var1 = var2 || var3‬‬ ‫‪Binary‬‬ ‫منطقی ‪OR‬‬ ‫||‬
‫;‪var1 = !var1‬‬ ‫‪Unary‬‬ ‫منطقی ‪NOT‬‬ ‫!‬

‫عملگر منطقی )&&(‪AND‬‬
‫اگر مقادیر دو طرف عملگر ‪ true ،AND‬باشند عملگر ‪ AND‬مقدار ‪ true‬را بر میگرداند‪ .‬در غیر اینصورت اگر یکی از مقادیر یا هر‬
‫دوی آنها ‪ false‬باشند مقدار ‪ false‬را بر میگرداند‪ .‬در زیر جدول درستی عملگر ‪ AND‬نشان داده شده است‪:‬‬
‫‪X‬‬ ‫‪Y‬‬ ‫‪X && Y‬‬
‫‪true‬‬ ‫‪true‬‬ ‫‪true‬‬
‫‪true‬‬ ‫‪false‬‬ ‫‪false‬‬
‫‪false‬‬ ‫‪true‬‬ ‫‪false‬‬
‫‪false‬‬ ‫‪false‬‬ ‫‪false‬‬
‫برای درک بهتر تأثیر عملگر ‪ AND‬یادآوری میکنم که این عملگر فقط در صورتی مقدار ‪ true‬را نشان میدهد که هر دو عملوند‬
‫مقدارشان ‪ true‬باشد‪.‬در غیر اینصورت نتیجه تمام ترکیبهای بعدی ‪ false‬خواهد شد‪ .‬استفاده از عملگر ‪ AND‬مانند استفاده از‬
‫عملگرهای مقایسه ای است‪ .‬به عنوان مثال نتیجه عبارت زیر درست )‪ (true‬است اگر سن )‪ (age‬بزرگتر از ‪ 30‬و ‪salary‬‬
‫کوچکتر از ‪ 3333‬باشد‪.‬‬
‫;)‪result = (age > 18) && (salary < 1000‬‬
‫عملگر ‪ AND‬زمانی کارامد است که ما با محدود خاصی از اعداد سرو کار داریم‪ .‬مثال عبارت ‪ 10 <= x <= 100‬بدین معنی است‬
‫که ‪ x‬میتواند مقداری شامل اعداد ‪ 33‬تا ‪ 333‬را بگیرد‪ .‬حال برای انتخاب اعداد خارج از این محدوده میتوان از عملگر منطقی ‪AND‬‬
‫به صورت زیر استفاده کرد‪.‬‬
‫;)‪inRange = (number <= 10) && (number >= 100‬‬
‫عملگر منطقی )||(‪OR‬‬
‫اگر یکی یا هر دو مقدار دو طرف عملگر ‪ ،OR‬درست )‪ (true‬باشد‪ ،‬عملگر ‪ OR‬مقدار ‪ true‬را بر میگرداند‪ .‬جدول درستی عملگر‬
‫‪ OR‬در زیر نشان داده شده است ‪:‬‬

‫‪X‬‬ ‫‪Y‬‬ ‫‪X || Y‬‬
‫‪true‬‬ ‫‪true‬‬ ‫‪true‬‬
‫‪true‬‬ ‫‪false‬‬ ‫‪true‬‬
‫‪false‬‬ ‫‪true‬‬ ‫‪true‬‬
‫‪false‬‬ ‫‪false‬‬ ‫‪false‬‬
‫در جدول باال مشاهده میکنید که عملگر ‪ OR‬در صورتی مقدار ‪ false‬را بر میگرداند که مقادیر دو طرف آن ‪ false‬باشند‪ .‬کد‬
‫زیر را در نظر بگیرید‪.‬نتیجه این کد در صورتی درست )‪ (true‬است که رتبه نهایی دانش آموز )‪ (finalGrade‬بزرگتر از ‪ 11‬یا‬
‫نمره نهایی امتحان آن ‪ 333‬باشد‪.‬‬
‫;)‪isPassed = (finalGrade >= 75) || (finalExam == 100‬‬
‫عملگر منطقی )!(‪NOT‬‬
‫برخالف دو اپراتور ‪ OR‬و ‪ AND‬عملگر منطقی ‪ NOT‬یک عملگر یگانی است و فقط به یک عملوند نیاز دارد‪ .‬این عملگر یک مقدار یا‬
‫اصطالح بولی را نفی میکند‪ .‬مثال اگر عبارت یا مقدار ‪ true‬باشد آنرا ‪ false‬و اگر ‪ false‬باشد‪ ،‬آنرا ‪ true‬میکند‪ .‬جدول زیر‬
‫عملکرد اپراتور ‪ NOT‬را نشان میدهد ‪:‬‬
‫‪X‬‬ ‫‪!X‬‬
‫‪true‬‬ ‫‪false‬‬
‫‪false‬‬ ‫‪true‬‬
‫نتیجه کد زیر در صورتی درست است که ‪( age‬سن) بزرگتر یا مساوی ‪ 30‬نباشد‪.‬‬
‫;)‪isMinor = !(age >= 18‬‬
‫عملگرهای بیتی‬
‫عملگرهای بیتی به شما اجازه میدهند که شکل باینری انواع دادهها را دستکاری کنید‪ .‬برای درک بهتر این درس توصیه میشود که‬
‫شما سیستم باینری و نحوه تبدیل اعداد دهدهی به باینری را از لینک زیر یاد بگیرید ‪:‬‬
‫در سیستم باینری (دودویی) که کامپیوتر از آن استفاده میکند‪ ،‬وضعیت هر چیز یا خاموش است یا روشن‪ .‬برای نشان دادن حالت‬
‫روشن از عدد ‪ 3‬و برای نشان دادن حالت خاموش از عدد ‪ 3‬استفاده میشود‪.‬بنابراین اعداد باینری فقط میتوانند صفر یا یک باشند‪.‬‬
‫اعداد باینری را اعداد در مبنای ‪ 5‬و اعداد اعشاری را اعداد در مبنای ‪ 33‬می گویند‪ .‬یک بیت نشان دهنده یک رقم باینری است و هر‬
‫بایت نشان دهنده ‪ 0‬بیت است‪ .‬به عنوان مثال برای یک داده از نوع ‪ int‬به ‪ 15‬بیت یا ‪ 0‬بایت فضا برای ذخیره آن نیاز داریم‪،‬‬
‫این بدین معناست که اعداد از ‪ 15‬رقم ‪ 3‬و ‪ 3‬برای ذخیره استفاده میکنند‪ .‬برای مثال عدد ‪ 333‬وقتی به عنوان یک متغیر از نوع‬
‫‪int‬ذخیره میشود در کامپیوتر به صورت زیر خوانده میشود‪:‬‬
‫‪000000000000000000000000000001100100‬‬
‫عدد ‪ 333‬در مبنای ده معادل عدد ‪ 3333333‬در مبنای ‪ 5‬است‪ .‬در اینجا ‪ 1‬رقم سمت راست نشان دهنده عدد ‪ 333‬در مبنای ‪ 5‬است و‬
‫مابقی صفرهای سمت راست برای پر کردن بیتهایی است که عدد از نوع ‪ int‬نیاز دارد‪ .‬به این نکته توجه کنید که اعداد باینری‬
‫از سمت راست به چپ خوانده میشوند‪ .‬عملگرهای بیتی جاوا در جدول زیر نشان داده شدهاند‪:‬‬
‫;‪x = y & z‬‬ ‫‪Binary‬‬ ‫بیتی ‪AND‬‬ ‫&‬
‫;‪x = y | z‬‬ ‫‪Binary‬‬ ‫بیتی ‪OR‬‬ ‫|‬
‫;‪x = y ^ z‬‬ ‫‪Binary‬‬ ‫بیتی ‪XOR‬‬ ‫^‬
‫;‪x = ~y‬‬ ‫‪Unary‬‬ ‫بیتی ‪NOT‬‬ ‫~‬
‫;‪x &= y‬‬ ‫‪Binary‬‬ ‫بیتی تخصیصی ‪AND‬‬ ‫=&‬
‫;‪x |= y‬‬ ‫‪Binary‬‬ ‫بیتی تخصیصی ‪OR‬‬ ‫=|‬

‫;‪x ^= y‬‬ ‫‪Binary‬‬ ‫بیتی تخصیصی ‪XOR‬‬ ‫=^‬
‫عملگر بیتی )&(‪AND‬‬
‫عملگر بیتی ‪ AND‬کاری شبیه عملگر منطقی ‪ AND‬انجام میدهد با این تفاوت که این عملگر بر روی بیتها کار میکند‪.‬اگر مقادیر‬
‫دو طرف آن ‪ 3‬باشد مقدار ‪ 3‬را بر میگرداند و اگر یکی یا هر دو طرف آن صفر باشد مقدار صفر را بر میگرداند‪ .‬جدول درستی عمگر‬
‫بیتی ‪ AND‬در زیر آمده است‪:‬‬
‫‪X‬‬ ‫‪Y‬‬ ‫‪X AND Y‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫در زیر نحوه استفاده از عملگر بیتی ‪ AND‬آمده است‪:‬‬
‫;‪int result = 5 & 3‬‬
‫;)‪System.out.println(result‬‬
‫‪1‬‬
‫همانطور که در مثال باال مشاهده میکنید نتیجه عملکرد عملگر ‪ AND‬بر روی دو مقدار ‪ 1‬و ‪ 1‬عدد یک میشود‪.‬اجازه بدهید ببینیم‬
‫که چطور این نتیجه را به دست میآید‪:‬‬
‫‪5: 00000000000000000000000000000101‬‬
‫‪3: 00000000000000000000000000000011‬‬
‫‪------------------------------------‬‬
‫‪1: 00000000000000000000000000000001‬‬
‫ابتدا دو عدد ‪ 1‬و ‪ 1‬به معادل باینریشان تبدیل میشوند‪ .‬از آنجاییکه هر عدد صحیح ‪ 15‬بیت است از صفر برای پر کردن بیتهای‬
‫خالی استفاده میکنیم‪ .‬با استفاده از جدول درستی عملگر بیتی ‪ AND‬میتوان فهمید که چرا نتیجه عدد یک میشود‪.‬‬
‫عملگر بیتی )|(‪OR‬‬
‫اگر مقادیر دو طرف عملگر بیتی ‪ OR‬هر دو صفر باشند نتیجه صفر در غیر اینصورت ‪ 3‬خواهد شد‪ .‬جدول درستی این عملگر در زیر‬
‫آمده است‪:‬‬
‫‪X‬‬ ‫‪Y‬‬ ‫‪X OR Y‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫نتیجه عملگر بیتی ‪ OR‬در صورتی صفر است که عملوندهای دو طرف آن صفر باشند‪ .‬اگر فقط یکی از دو عملوند یک باشد نتیجه‬
‫یک خواهد شد‪ .‬به مثال زیر توجه کنید‪:‬‬
‫;‪int result = 7 | 9‬‬
‫‪15‬‬
‫وقتی که از عملگر بیتی ‪ OR‬برای دو مقدار در مثال باال (‪ 1‬و ‪ )6‬استفاده میکنیم نتیجه ‪ 31‬میشود‪.‬حال بررسی میکنیم که چرا این‬
‫نتیجه به دست آمده است؟‬
‫‪7: 00000000000000000000000000000111‬‬
‫‪9: 00000000000000000000000000001001‬‬
‫‪-----------------------------------‬‬
‫‪15: 00000000000000000000000000001111‬‬
‫با استفاده از جدول درستی عملگر بیتی ‪ OR‬میتوان نتیجه استفاده از این عملگر را تشخیص داد‪.‬عدد ‪ 3333‬باینری معادل عدد ‪31‬‬
‫صحیح است‪.‬‬
‫عملگر بیتی )^(‪XOR‬‬
‫جدول درستی این عملگر در زیر آمده است‪:‬‬

‫‪X‬‬ ‫‪Y‬‬ ‫‪X XOR Y‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫در صورتیکه عملوندهای دو طرف این عملگر هر دو صفر یا هر دو یک باشند نتیجه صفر‪ ،‬در غیر اینصورت نتیجه یک میشود‪ .‬در‬
‫مثال زیر تأثیر عملگر بیتی ‪ XOR‬را بر روی دو مقدار مشاده میکنید‪:‬‬
‫;‪int result = 5 ^ 7‬‬
‫‪2‬‬
‫در زیر معادل باینری اعداد باال (‪ 1‬و ‪ )1‬نشان داده شده است‪.‬‬
‫‪5: 00000000000000000000000000000101‬‬
‫‪7: 00000000000000000000000000000111‬‬
‫‪-----------------------------------‬‬
‫‪2: 00000000000000000000000000000010‬‬
‫با نگاه کردن به جدول درستی عملگر بیتی‪ ،XOR‬میتوان فهمید که چرا نتیجه عدد ‪ 5‬میشود‪.‬‬
‫عملگر بیتی )~(‪NOT‬‬
‫این عملگر یک عملگر یگانی است و فقط به یک عملوند نیاز دارد‪.‬در زیر جدول درستی این عملگر آمده است‪:‬‬
‫‪X‬‬ ‫‪NOT X‬‬
‫‪1‬‬ ‫‪0‬‬
‫‪0‬‬ ‫‪1‬‬
‫عملگر بیتی ‪ NOT‬مقادیر بیتها را معکوس میکند‪.‬در زیر چگونگی استفاده از این عملگر آمده است‪:‬‬
‫;‪int result = ~7‬‬

‫به نمایش باینری مثال باال که در زیر نشان داده شده است توجه نمایید‪:‬‬
‫‪7: 00000000000000000000000000000111‬‬
‫‪------------------------------------‬‬
‫‪-8: 11111111111111111111111111111000‬‬
‫عملگر بیتی تغییر مکان)‪(shift‬‬
‫این نوع عملگرها به شما اجازه میدهند که بیتها را به سمت چپ یا راست جا به جا کنید‪ .‬دو نوع عملگر بیتی تغییر مکان وجود‬
‫دارد که هر کدام دو عملوند قبول میکنند‪ .‬عملوند سمت چپ این عملگرها حالت باینری یک مقدار و عملوند سمت راست تعداد‬
‫جابه جایی بیتها را نشان میدهد‪.‬‬
‫;‪x = y << 2‬‬ ‫‪Binary‬‬ ‫تغییر مکان به سمت چپ‬ ‫>>‬
‫;‪x = y >> 2‬‬ ‫‪Binary‬‬ ‫تغییر مکان به سمت راست‬ ‫<<‬
‫عملگر تغییر مکان به سمت چپ‬
‫این عملگر بیتهای عملوند سمت چپ را به تعداد ‪ n‬مکان مشخص شده توسط عملوند سمت راست‪ ،‬به سمت چپ منتقل میکند‪.‬‬
‫;‪int result = 10 << 2‬‬
‫‪40‬‬
‫در مثال باال ما بیتهای مقدار ‪ 33‬را دو مکان به سمت چپ منتقل کردهایم‪ ،‬حال بیایید تأثیر این انتقال را بررسی کنیم‪:‬‬
‫‪10: 00000000000000000000000000001010‬‬
‫‪------------------------------------‬‬
‫‪40: 00000000000000000000000000101000‬‬
‫مشاهده میکنید که همه بیتها به اندازه دو واحد به سمت چپ منتقل شدهاند‪ .‬در این انتقال دو صفر از صفرهای سمت چپ کم‬
‫میشود و در عوض دو صفر به سمت راست اضافه میشود‪.‬‬
‫عملگر تغییر مکان به سمت راست‬
‫این عملگر شبیه به عمگر تغییر مکان به سمت چپ است با این تفاوت که بیتها را به سمت راست جا به جا میکند‪ .‬به عنوان‬
‫مثال‪:‬‬
‫;‪int result = 100 >> 4‬‬
‫‪6‬‬
‫با استفاده از عملگر تغییر مکان به سمت راست بیتهای مقدار ‪ 333‬را به اندازه ‪ 3‬واحد به سمت چپ جا به جا میکنیم‪ .‬اجازه بدهید‬
‫تأثیر این جا به جایی را مورد بررسی قرار دهیم‪:‬‬
‫‪100: 00000000000000000000000001100100‬‬
‫‪------------------------------------‬‬
‫‪6: 00000000000000000000000000000110‬‬
‫هر بیت به اندازه ‪ 3‬واحد به سمت راست منتقل میشود‪ ،‬بنابراین ‪ 3‬بیت اول سمت راست حذف شده و چهار صفر به سمت چپ‬
‫اضافه میشود‪.‬‬
‫تقدم عملگرها‬
‫تقدم عملگرها مشخص میکند که در محاسباتی که بیش از دو عملوند دارند ابتدا کدام عملگر اثرش را اعمال کند‪ .‬عملگرها در جاوا‬
‫در محاسبات دارای حق تقدم هستند‪.‬به عنوان مثال‪:‬‬
‫;‪number = 1 + 2 * 3 / 1‬‬
‫اگر ما حق تقدم عملگرها را رعایت نکنیم و عبارت باال را از سمت چپ به راست انجام دهیم نتیجه ‪ 6‬خواهد شد (‪ 3+5=1‬سپس‬
‫‪ 1×1=6‬و در آخر ‪ .)6/3=6‬اما کمپایلر با توجه به تقدم عملگرها محاسبات را انجام میدهد‪.‬برای مثال عمل ضرب و تقسیم نسبت به‬
‫جمع و تفریق تقدم دارند‪ .‬بنابراین در مثال فوق ابتدا عدد ‪ 5‬ضربدر ‪ 1‬و سپس نتیجه آنها تقسیم بر ‪ 3‬میشود که نتیجه ‪ 1‬به دست‬
‫میآید‪.‬در آخر عدد ‪ 1‬با ‪ 3‬جمع میشود و عدد ‪ 1‬حاصل میشود‪ .‬در جدول زیر تقدم برخی از عملگرهای جاوا آمده است‪:‬‬
‫تقدم‬ ‫عملگر‬
‫باالترین‬ ‫)‪++, –, (used as prefixes); +, – (unary‬‬
‫‪*, /, %‬‬
‫‪+, -‬‬
‫>> ‪<<,‬‬
‫=> ‪<, >, <=,‬‬
‫=! ‪==,‬‬
‫&‬
‫^‬
‫|‬
‫&&‬
‫||‬
‫=‪=, *=, /=, %=, +=, -‬‬
‫پایینتری ن‬ ‫)‪++, — (used as suffixes‬‬
‫ابتدا عملگرهای با باالترین و سپس عملگرهای با پایینترین حق تقدم در محاسبات تأثیر میگذارند‪.‬به این نکته توجه کنید که تقدم‬
‫عملگرها ‪ ++‬و ‪ --‬به مکان قرارگیری آنها بستگی دارد (در سمت چپ یا راست عملوند باشند)‪ .‬به عنوان مثال‪:‬‬
‫;‪int number = 3‬‬
‫‪number1 = 3 + ++number; //results to 7‬‬

‫‪number2 = 3 + number++; //results to 6‬‬
‫در عبارت اول ابتدا به مقدار ‪ number‬یک واحد اضافه شده و ‪ 3‬میشود و سپس مقدار جدید با عدد ‪ 1‬جمع میشود و در نهایت‬
‫عدد ‪ 1‬به دست میآید‪ .‬در عبارت دوم مقدار عددی ‪ 1‬به مقدار ‪ number‬اضافه میشود و عدد ‪ 1‬به دست میآید‪ .‬سپس این مقدار‬
‫در متغیر ‪ number2‬قرار میگیرد‪ .‬و در نهایت مقدار ‪ number‬به ‪ 3‬افزایش مییابد‪ .‬برای ایجاد خوانایی در تقدم عملگرها و انجام‬
‫محاسباتی که در آنها از عملگرهای زیادی استفاده میشود از پرانتز استفاده میکنیم‪:‬‬
‫;)) ‪number = ( 1 + 2 ) * ( 3 / 4 ) % ( 5 - ( 6 * 7‬‬
‫در مثال باال ابتدا هر کدام از عباراتی که داخل پرانتز هستند مورد محاسبه قرار میگیرند‪ .‬به نکته ای در مورد عبارتی که در داخل‬
‫پرانتز سوم قرار دارد‪ ،‬توجه کنید‪.‬در این عبارت ابتدا مقدار داخلیترین پرانتز مورد محاسبه قرار میگیرد‪ .‬یعنی مقدار ‪ 1‬ضربدر ‪ 1‬شده‬
‫و سپس از ‪ 1‬کم میشود‪ .‬اگر دو یا چند عملگر با حق تقدم یکسان موجود باشد ابتدا باید هر کدام از عملگرها را که در ابتدای‬
‫عبارت میآیند مورد ارزیابی قرار دهید‪ .‬به عنوان مثال‪:‬‬
‫;‪number = 3 * 2 + 8 / 4‬‬
‫هر دو عملگر * و ‪ /‬دارای حق تقدم یکسانی هستند‪ .‬بنابر این شما باید از چپ به راست آنها را در محاسبات تأثیر دهید‪ .‬یعنی‬
‫ابتدا ‪ 1‬را ضربدر ‪ 5‬میکنید و سپس عدد ‪ 0‬را بر ‪ 3‬تقسیم میکنید‪ .‬در نهایت نتیجه دو عبارت را جمع کرده و در متغیر ‪number‬‬
‫قرار میدهید‪.‬‬
‫گرفتن ورودی از کاربر‬

‫جاوا تعدادی متد برای گرفتن ورودی از کاربر در اختیار شما قرار میدهد‪ .‬این متدها در کالس ‪ Scanner‬قرار دارند‪ .‬این کالس در‬
‫پکیج ‪ java.util‬قرار دارد و در نتیجه برای استفاده از آن باید آن را در برنامه به صورت زیر وارد کنید‪:‬‬
‫;‪import java.util.Scanner‬‬
‫از کالس ‪ MessageFormat‬هم برای قالب بندی خروجی استفاده میکنیم‪ .‬این دو کالس را در خطوط ‪ 1‬و ‪ 3‬وارد کردهایم‪ .‬متدهای‬
‫کالس ‪ Scanner‬که مقادیر وارد شده توسط کاربر را از صفحه کلید میخوانند عبارتاند از‪:‬‬
‫توضیح‬ ‫متد‬
‫برای دریافت یک نوع داده از نوع ‪ byte‬به کار میرود‪.‬‬ ‫)(‪nextByte‬‬
‫برای دریافت یک نوع داده از نوع ‪ short‬به کار میرود‪.‬‬ ‫)(‪nextShort‬‬

1۳ ‫مبانی زبان جاوا‬
.‫ به کار میرود‬int ‫برای دریافت یک ن وع داده از نوع‬ nextInt()
.‫ به کار میرود‬long ‫برای دریافت یک نوع داده از نوع‬ nextLong()
.‫برای دریافت یک کلمه ساده به کار میرود‬ next()
.‫برای دریافت یک خط رشته به کار میرود‬ nextLine()
.‫ به کار میرود‬boolean ‫برای دریافت یک نوع داده از نوع‬ nextBoolean()
.‫ به کار میرود‬float ‫برای دریافت یک نوع داده از نوع‬ nextFloat()
.‫ به کار میرود‬double ‫برای دریافت یک نوع داده از نوع‬ nextDouble()
:‫به برنامه زیر توجه کنید‬
1 package myfirstprogram;
2
3 import java.text.MessageFormat;
4 import java.util.Scanner;
5
6 public class MyFirstProgram
7 {
8 public static void main(String[] args)
9 {
10 String name;
11 int age;
12 double height;
13
14 Scanner input = new Scanner(System.in);
15
16 System.out.print("Enter your Name: ");
17 name = input.next();
18
19 System.out.print("Enter your Age: ");
20 age = input.nextInt();
21
22 System.out.print("Enter your Height:");
23 height = input.nextDouble();
24
25 System.out.println();
26
27 System.out.println(MessageFormat.format("Name is {0}.", name));
28 System.out.println(MessageFormat.format("Age is {0}.", age));
29 System.out.println(MessageFormat.format("Height is {0}.", height));
30 }
31 }
Enter your Name: john

Enter your Age: 18
Enter your Height:160.5
‫‪Name is john.‬‬
‫‪Age is 18.‬‬
‫‪Height is 160.5.‬‬
‫اجازه دهید که برنامه را تشریح کنیم‪ .‬ابتدادر خطوط ‪ 1‬و ‪ 3‬برنامه‪ ،‬کالس ‪ Scanner‬و ‪ MessageFormat‬را با استفاده از کلمه‬
‫‪ import‬به برنامه اضافه کردهایم‪ .‬در خطوط ‪ 33‬و ‪ 33‬و ‪ 35‬یک شیء برای دریافت نام‪ ،‬یک متغیر از نوع صحیح به نام ‪ age‬برای‬
‫دریافت سن و یک متغیر از نوع ‪ double‬برای دریافت قد شخص تعریف نمودهایم‪ .‬درباره خط ‪ 33‬زیاد توضیح نمیدهم‪ ،‬فقط‬
‫کافیست که این رابدانید که وجود این خط برای دریافت ورودی از کاربر اجباری است‪ .‬در درسهای آینده با مفاهیم متد‪ ،‬شیء و‬
‫کالس آشنا خواهید شد‪ .‬برنامه از کاربر میخواهد که نام خود را وارد کند (خط ‪ .)31‬در خط ‪ 31‬شما به عنوان کاربر نام خود را وارد‬
‫میکنید‪ .‬مقدار متغیر ‪ ،name‬برابر مقداری است که توسط متد )(‪ next‬خوانده میشود‪.‬از آنجاییکه ‪ name‬از نوع رشته است باید‬
‫از متد )(‪ next‬برای دریافت استفاده کنیم‪ .‬در خط ‪ 36‬برنامه از شما میخواهد که سن خود را وارد کند‪ .‬در خط ‪ 53‬شما سن خود را‬
‫وارد میکنید‪ .‬مقدار متغیر ‪ ،age‬برابر مقداری است که توسط متد )(‪ nextInt‬خوانده میشود‪.‬از آنجاییکه ‪ Age‬از نوع صحیح‬
‫است باید از متد )(‪ nextInt‬برای دریافت استفاده کنیم‪ .‬سپس برنامه از ما قد را سؤال میکند (خط ‪ .)55‬چون ‪ height‬از نوع‬
‫‪ double‬است پس برای خواندن آن از متد )(‪ nextDouble‬استفاده کردهایم‪ .‬حال شما میتوانید با اجرای برنامه و وارد کردن‬
‫مقادیر نتیجه را مشاهده کنید‪.‬‬
‫ساختارهای تصمیم‬
‫تقریبا همه زبانهای برنامه نویسی به شما اجازه اجرای کد را در شرایط مطمئن میدهند‪ .‬حال تصور کنید که یک برنامه دارای ساختار‬
‫تصمیم گیری نباشد و همه کدها را اجرا کند‪ .‬این حالت شاید فقط برای چاپ یک پیغام در صفحه مناسب باشد ولی فرض کنید که‬
‫شما بخواهید اگر مقدار یک متغیر با یک عدد برابر باشد سپس یک پیغام چاپ شود آن وقت با مشکل مواجه خواهید شد‪ .‬جاوا‬
‫راههای مختلفی برای رفع این نوع مشکالت ارائه میدهد‪ .‬در این بخش با مطالب زیر آشنا خواهید شد‪:‬‬
‫دستور ‪if‬‬ ‫‪‬‬
‫دستور ‪if…else‬‬ ‫‪‬‬
‫عملگر سه تایی‬ ‫‪‬‬

‫دستور ‪ if‬چندگانه‬ ‫‪‬‬
‫دستور ‪ if‬تو در تو‬ ‫‪‬‬
‫عملگرهای منطقی‬ ‫‪‬‬
‫دستور ‪switch‬‬ ‫‪‬‬
‫دستور ‪if‬‬
‫میتوان با استفاده از دستور ‪ if‬و یک شرط خاص که باعث ایجاد یک کد میشود یک منطق به برنامه خود اضافه کنید‪.‬دستور ‪if‬‬
‫سادهترین دستور شرطی است که به برنامه میگوید‪ ،‬اگر شرطی برقرار است کد معینی را انجام بده‪ .‬ساختار دستور ‪if‬به صورت‬
‫زیر است‪:‬‬
‫)‪if (condition‬‬
‫;‪code to execute‬‬
‫قبل از اجرای دستور ‪ if‬ابتدا شرط بررسی میشود‪.‬اگر شرط برقرار باشد یعنی درست باشد سپس کد اجرا میشود‪ .‬شرط یک عبارت‬
‫مقایسه ای است‪ .‬میتوان از عملگرهای مقایسه ای برای تست درست یا اشتباه بودن شرط استفاده کرد‪ .‬اجازه بدهید که نگاهی‬
‫به نحوه استفاده از دستور ‪ if‬در داخل برنامه بیندازیم‪ .‬برنامه زیر پیغام ‪ Hello World‬را اگر مقدار ‪ number‬کمتر از ‪ 33‬و ‪Goodbye‬‬
‫‪ World‬را اگر مقدار ‪ number‬از ‪ 33‬بزرگتر باشد در صفحه نمایش میدهد‪.‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫‪//Declare a variable and set it a value less than 10‬‬
‫‪8‬‬ ‫;‪int number = 5‬‬
‫‪9‬‬
‫‪10‬‬ ‫‪//If the value of number is less than 10‬‬
‫‪11‬‬ ‫)‪if (number < 10‬‬
‫‪12‬‬ ‫;)"‪System.out.println("Hello World.‬‬
‫‪13‬‬
‫‪14‬‬ ‫‪//Change the value of a number to a value which‬‬
‫‪15‬‬ ‫‪// is greater than 10‬‬
‫‪16‬‬ ‫;‪number = 15‬‬
‫‪17‬‬
‫‪18‬‬ ‫‪//If the value of number is greater than 10‬‬
‫‪19‬‬ ‫)‪if (number > 10‬‬

‫‪20‬‬ ‫;)"‪System.out.println("Goodbye World.‬‬
‫‪21‬‬ ‫}‬
‫‪22‬‬ ‫}‬
‫‪Hello World.‬‬
‫‪Goodbye World.‬‬
‫در خط ‪ 0‬یک متغیر با نام ‪ number‬تعریف و مقدار ‪ 1‬به آن اختصاص داده شده است‪ .‬وقتی به اولین دستور ‪ if‬در خط ‪ 33‬میرسیم‬
‫برنامه تشخیص میدهد که مقدار ‪ number‬از ‪ 33‬کمتر است یعنی ‪ 1‬کوچکتر از ‪ 33‬است‪.‬‬
‫منطقی است که نتیجه مقایسه درست میباشد بنابراین دستور ‪ if‬دستور را اجرا میکند(خط ‪ )35‬و پیغام ‪ Hello World‬چاپ‬
‫میشود‪ .‬حال مقدار ‪ number‬را به ‪ 31‬تغییر میدهیم (خط ‪ .)31‬وقتی به دومین دستور ‪ if‬در خط ‪ 36‬میرسیم برنامه مقدار ‪number‬‬
‫را با ‪ 33‬مقایسه میکند و چون مقدار ‪ number‬یعنی ‪ 31‬از ‪ 33‬بزرگتر است برنامه پیغام ‪ Goodbye World‬را چاپ میکند(خط ‪.)53‬‬
‫به این نکته توجه کنید که دستور ‪ if‬را میتوان در یک خط نوشت‪:‬‬
‫;)"‪if ( number > 10 ) System.out.println("Goodbye World.‬‬
‫شما میتوانید چندین دستور را در داخل دستور ‪ if‬بنویسید‪ .‬کافیست که از یک آکوالد برای نشان دادن ابتدا و انتهای دستورات‬
‫استفاده کنید‪ .‬همه دستورات داخل بین آکوالد جز بدنه دستور ‪ if‬هستند‪ .‬نحوه تعریف چند دستور در داخل بدنه ‪ if‬به صورت زیر‬
‫است‪:‬‬
‫{‬
‫‪.‬‬
‫‪.‬‬
‫‪.‬‬
‫;‪statementN‬‬
‫}‬
‫این هم یک مثال ساده‪:‬‬
‫)‪if (x > 10‬‬

‫{‬
‫;)"‪System.out.println("x is greater than 10.‬‬
‫;)"‪System.out.println("This is still part of the if statement.‬‬
‫}‬
‫در مثال باال اگر مقدار ‪ x‬از ‪ 33‬بزرگتر باشد دو پیغام چاپ میشود‪ .‬حال اگر به عنوان مثال آکوالد را حذف کنیم و مقدار ‪ x‬از ‪33‬‬
‫بزرگتر نباشد مانند کد زیر‪:‬‬
‫)‪if (x > 10‬‬

‫;)")?‪System.out.println("This is still part of the if statement. (Really‬‬
‫کد باال در صورتی بهتر خوانده میشود که بین دستورات فاصله بگذاریم ‪:‬‬
‫)‪if (x > 10‬‬

‫;)")?‪System.out.println("This is still part of the if statement. (Really‬‬
‫میبیند که دستور دوم (خط ‪ )1‬در مثال باال جز دستور ‪ if‬نیست‪ .‬اینجاست که چون ما فرض را بر این گذاشتهایم که مقدار ‪ x‬از ‪33‬‬
‫کوچکتر است پس خط )?‪ This is still part of the if statement. (Really‬چاپ میشود‪ .‬در نتیجه اهمیت وجود‬
‫آکوالد مشخص میشود‪ .‬به عنوان تمرین همیشه حتی اگر فقط یک دستور در بدنه ‪ if‬داشتید برای آن یک آکوالد بگذارید‪ .‬فراموش‬
‫نکنید که از قلم انداختن یک آکوالد باعث به وجود آمدن خطا شده و یافتن آن را سخت میکند‪ .‬یکی از خطاهای معمول کسانی‬
‫که برنامه نویسی را تازه شروع کردهاند قرار دادن سیمیکولن در سمت راست پرانتز ‪ if‬است‪ .‬به عنوان مثال‪:‬‬
‫;)‪if (x > 10‬‬

‫;)"‪System.out.println("x is greater than 10‬‬
‫به یاد داشته باشید که ‪ if‬یک مقایسه را انجام میدهد و دستور اجرایی نیست‪ .‬بنابراین برنامه شما با یک خطای منطقی مواجه‬
‫میشود‪ .‬همیشه به یاد داشته باشید که قرار گرفتن سیمیکولن در سمت راست پرانتز ‪ if‬به منزله این است که بلوک کد در اینجا به‬
‫پایان رسیده است‪ .‬به این نکته توجه داشته باشید که شرطها مقادیر بولی هستند‪ ،‬بنابراین شما میتوانید نتیجه یک عبارت را در‬
‫داخل یک متغیر بولی ذخیره کنید و سپس از متغیر به عنوان شرط در دستور ‪ if‬استفاده کنید‪ .‬اگر مقدار ‪ year‬برابر ‪ 5333‬باشد‬
‫سپس حاصل عبارت در متغیر ‪ isNewMillenium‬ذخیره میشود‪.‬میتوان از متغیر برای تشخیص کد اجرایی بدنه دستور ‪ if‬استفاده‬
‫کرد خواه مقدار متغیر درست باشد یا نادرست‪.‬‬
‫;‪boolean isNewMillenium = year == 2000‬‬
‫)‪if (isNewMillenium‬‬
‫{‬
‫;)"!‪System.out.println("Happy New Millenium‬‬
‫}‬
if else ‫دستور‬
‫ اما زمانی که شما‬.‫ یعنی اگر حالتی برقرار بود کارخاصی انجام شود‬.‫ فقط برای اجرای یک حالت خاص به کار میرود‬if ‫دستور‬
.‫ استفاده کنید‬if else ‫ باید از دستور‬،‫ دستور دیگر اجرا شود‬،‫بخواهید اگر شرط خاصی برقرار شد یک دستور و اگر برقرار نبود‬
:‫ در زیر آمده است‬if else ‫ساختار دستور‬
if (condition)
{
code to execute if condition is true;
}
else
{
code to execute if condition is false;
}
‫ اگر فقط یک کد اجرایی در داخل بدنه‬.‫ به کار برده شود‬if ‫ نمیتوان به تنهایی استفاده کرد بلکه حتما باید با‬else ‫از کلمه کلیدی‬
‫ فقط در صورتی اجرا میشود که شرط داخل دستور‬else ‫ کد داخل بلوک‬.‫ دارید استفاده از آکوالد اختیاری است‬else ‫ و بدنه‬if
.‫ آمده است‬if…else ‫ در زیر نحوه استفاده از دستور‬.‫نادرست باشد‬if
2
4 {
6 {
7 int number = 5;
8
9 //Test the condition
10 if (number < 10)
11 {
12 System.out.println("The number is less than 10.");
13 }
14 else
15 {
16 System.out.println("The number is either greater than or equal to 10.");
17 }
18
19 //Modify value of number
20 number = 15;
21
22 //Repeat the test to yield a different result
23 if (number < 10)
24 {
25 System.out.println("The number is less than 10.");
26 }
27 else
28 {
29 System.out.println("The number is either greater than or equal to 10.");
30 }
31 }
‫‪32‬‬ ‫}‬
‫در خط ‪ 1‬یک متغیر به نام ‪ number‬تعریف کردهایم و در خط ‪ 33‬تست میکنیم که آیا مقدار متغیر ‪ number‬از ‪ 33‬کمتر است یا نه‬
‫و چون کمتر است در نتیجه کد داخل بلوک ‪ if‬اجرا میشود (خط ‪ )35‬و اگر مقدار ‪ number‬را تغییر دهیم و به مقداری بزرگتر از‬
‫‪ 33‬تغییر دهیم (خط ‪ ،)53‬شرط نادرست میشود (خط ‪ )51‬و کد داخل بلوک ‪ else‬اجرا میشود (خط ‪ .)56‬مانند بلوک ‪ if‬نباید‬
‫به آخر کلمه کلیدی ‪ else‬سیمیکولن اضافه شود‪.‬‬
‫دستور ‪ if‬تو در تو‬
‫میتوان از دستور ‪ if‬تو در تو در جاوا استفاده کرد‪ .‬یک دستور ساده ‪ if‬در داخل دستور ‪ if‬دیگر‪.‬‬
‫{‬
‫{‬
‫}‬
‫)‪else if (condition‬‬
‫{‬
‫{‬
‫}‬
‫}‬
‫}‬
‫‪else‬‬
‫{‬
‫{‬
‫}‬
‫}‬
‫اجازه بدهید که نحوه استفاده از دستور ‪ if‬تو در تو را نشان دهیم‪:‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;‪int age = 21‬‬
‫‪8‬‬
‫‪9‬‬ ‫)‪if (age > 12‬‬
‫‪10‬‬ ‫{‬
‫‪11‬‬ ‫)‪if (age < 20‬‬
‫‪12‬‬ ‫{‬
‫‪13‬‬ ‫;)"‪System.out.println("You are teenage‬‬
‫‪14‬‬ ‫}‬
‫‪15‬‬ ‫‪else‬‬
‫‪16‬‬ ‫{‬
‫‪17‬‬ ‫;)"‪System.out.println("You are already an adult.‬‬
‫‪18‬‬ ‫}‬
‫‪19‬‬ ‫}‬
‫‪20‬‬ ‫‪else‬‬
‫‪21‬‬ ‫{‬
‫‪22‬‬ ‫;)"‪System.out.println("You are still too young.‬‬
‫‪23‬‬ ‫}‬
‫‪24‬‬ ‫}‬
‫‪25‬‬ ‫}‬
‫‪You are already an adult.‬‬
‫اجازه بدهید که برنامه را کالبد شکافی کنیم‪ .‬ابتدا در خط ‪ 1‬یک متغیر به نام ‪ age‬تعریف میکنیم و مقدار آن را برابر ‪ 53‬قرار‬
‫میدهیم‪.‬سپس به اولین دستور ‪ if‬میرسیم (خط ‪ .)6‬در این قسمت اگر سن شما بیشتر از ‪ 35‬سال باشد برنامه وارد بدنه دستور‬
‫‪ if‬میشود در غیر اینصورت وارد بلوک ‪( else‬خط ‪ )53‬مربوط به همین دستور ‪ if‬میشود‪ .‬حال فرض کنیم که سن شما بیشتر‬
‫از ‪ 35‬سال است و شما وارد بدنه اولین ‪ if‬شدهاید‪ .‬در بدنه اولین ‪ if‬یک دستور ‪ if‬دیگر را مشاهده میکنید‪ .‬اگر سن کمتر ‪53‬‬
‫باشد دستور ‪ You are teenage‬چاپ میشود (خط ‪ )31‬در غیر اینصورت دستور ‪( You are already an adult‬خط ‪ )31‬و‬
‫چون مقدار متغیر تعریف شده در خط ‪ 1‬بزرگتر از ‪ 53‬است پس دستور مربوط به بخش ‪ else‬خط ‪ 31‬چاپ میشود‪ .‬حال فرض‬
‫کنید که مقدار متغیر ‪ age‬کمتر از ‪ 35‬بود‪ ،‬در این صورت دستور بخش ‪ else‬خط ‪ 53‬یعنی ‪ You are still too young‬چاپ‬
‫میشد‪ .‬پیشنهاد میشود که از ‪ if‬تو در تو در برنامه کمتر استفاده کنید چون خوانایی برنامه را پایین میآورد‬
‫عملگر شرطی‬
‫عملگر شرطی )‪ (?:‬در جاوا مانند دستور شرطی ‪ if…else‬عمل میکند‪ .‬در زیر نحوه استفاده از این عملگر آمده است‪:‬‬
‫>‪<condition> ? <result if true> : <result if false‬‬
‫عملگر شرطی تنها عملگر سه تایی جاوا است که نیاز به سه عملوند دارد‪ ،‬شرط‪ ،‬یک مقدار زمانی که شرط درست باشد و یک مقدار‬
‫زمانی که شرط نادرست باشد‪ .‬اجازه بدهید که نحوه استفاده این عملگر را در داخل برنامه مورد بررسی قرار دهیم‪.‬‬

‫‪2‬‬
‫‪۹۵‬‬ ‫مبانی زبان جاوا‬

‫‪4‬‬ ‫{‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;‪int number = -10‬‬
‫‪8‬‬
‫‪9‬‬ ‫‪int‬‬ ‫;)‪ABS = (number > 0) ? (number) : -(number‬‬
‫‪10‬‬
‫‪11‬‬ ‫‪System.out.println("ABS‬‬ ‫;)‪= " + ABS‬‬
‫‪12‬‬ ‫}‬
‫‪13‬‬ ‫}‬
‫‪10‬‬
‫برنامه باال نحوه استفاده از این عملگر شرطی را نشان میدهد ‪ .‬در این برنامه قصد ما به دست آوردن قدر مطلق یک عدد است‪.‬‬
‫ابتدا در خط ‪ 1‬یک متغیر از نوع ‪ int‬تعریف کرده و مقدار آن را ‪ -33‬میگذاریم‪ .‬در خط ‪ 6‬یک متغیر از نوع صحیح تعریف کردهایم‬
‫تا نتیجه را در آن قرار دهیم‪ .‬خط ‪ 6‬به این صورت تعریف میشود ‪ ” :‬اگر مقدار ‪ number‬از ‪ 33‬بزرگتر باشد خود مقدار را در متغیر‬
‫‪ ABS‬قرار بده در غیر اینصورت آن را در منفی ضرب کرده و آن را در متغیر ‪ ABS‬قرار بده”‪ .‬حال برنامه باال را با استفاده از دستور ‪if‬‬
‫‪ else‬مینویسیم‪:‬‬
‫;‪int number = -10‬‬
‫)‪if(number > 10‬‬

‫{‬
‫;)‪System.out.println(number‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;))‪System.out.println(-(number‬‬
‫}‬
‫هنگامی که چندین دستور در داخل یک بلوک ‪ if‬یا ‪ else‬دارید از عملگر شرطی استفاده نکنید چون خوانایی برنامه را پایین‬
‫میآورد‪.‬‬
‫دستور ‪ if‬چندگانه‬
‫اگر بخواهید چند شرط را بررسی کنید چکار میکنید؟ میتوانید از چندین دستور ‪ if‬استفاده کنید و بهتر است که این دستورات ‪if‬‬
‫را به صورت زیر بنویسید‪:‬‬
‫{‬
‫}‬
‫‪else‬‬
‫{‬
‫{‬
‫}‬
‫‪else‬‬
‫{‬
‫{‬
‫}‬
‫‪else‬‬
‫{‬
‫}‬
‫}‬
‫}‬
‫خواندن کد باال سخت است‪ .‬بهتر است دستورات را به صورت تو رفتگی در داخل بلوک ‪ else‬بنویسید‪ .‬میتوانید کد باال را ساده‬
‫تر کنید‪:‬‬
‫{‬
‫}‬
‫{‬
‫}‬
‫{‬
‫}‬
‫‪else‬‬
‫{‬
‫}‬
‫حال که نحوه استفده از دستور ‪ else if‬را یاد گرفتید باید بدانید که مانند ‪ else if ،else‬نیز به دستور ‪ if‬وابسته است‪.‬دستور‬
‫‪ else if‬وقتی اجرا میشود که اولین دستور ‪ if‬اشتباه باشد حال اگر ‪ else if‬اشتباه باشد دستور ‪ else if‬بعدی اجرا میشود‪.‬‬
‫و اگر آن نیز اجرا نشود در نهایت دستور ‪ else‬اجرا میشود‪ .‬برنامه زیر نحوه استفاده از دستور ‪ if else‬را نشان میدهد‪:‬‬

‫{‬
‫{‬
‫;‪int choice = 2‬‬

‫‪۹۳‬‬ ‫مبانی زبان جاوا‬
‫)‪if (choice == 1‬‬

‫{‬
‫;)"‪System.out.print("You might like my black t-shirt.‬‬
‫}‬
‫)‪else if (choice == 2‬‬
‫{‬
‫;)"‪System.out.print("You might be a clean and tidy person.‬‬
‫}‬
‫)‪else if (choice == 3‬‬
‫{‬
‫;)"‪System.out.print("You might be sad today.‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;)"‪System.out.print("Sorry, your favorite color is not in the choices above.‬‬
‫}‬
‫}‬
‫}‬
‫‪You might be a clean and tidy person‬‬
‫خروجی بنامه باال به متغیر ‪ choice‬وابسته است‪ .‬بسته به اینکه شما چه چیزی انتخاب میکنید پیغامهای مختلفی چاپ میشود‪.‬‬
‫اگر عددی که شما تایپ میکنید در داخل حالتهای انتخاب نباشد کد مربوط به بلوک ‪ else‬اجرا میشود‪.‬‬
‫استفاده از عملگرهای منطقی‬
‫عملگرهای منطقی به شما اجازه میدهند که چندین شرط را با هم ترکیب کنید‪ .‬این عملگرها حداقل دو شرط را درگیر میکنند و در‬
‫آخر یک مقدار بولی را بر میگردانند‪ .‬در جدول زیر برخی از عملگرهای منطقی آمده است‪:‬‬
‫تأثیر‬ ‫مثال‬ ‫تلفظ‬ ‫عملگر‬
‫مقدار ‪ Z‬در صورتی ‪ true‬است که هر دو شرط دو طرف عملگر‬ ‫)‪z = (x > 2) && (y < 10‬‬ ‫‪And‬‬ ‫&&‬
‫مقدارشان ‪ true‬باشد ‪ .‬اگر فقط مقدار یکی از شروط ‪ false‬باشد‬
‫مقدار ‪ z ،false‬خواهد شد ‪.‬‬
‫مقدار ‪ Z‬در صورتی ‪ true‬است که یکی از دو شرط دو طرف عملگر‬ ‫)‪z = (x > 2) || (y < 10‬‬ ‫‪Or‬‬ ‫||‬
‫مقدارشان ‪ true‬باشد‪ .‬اگر هر دو شرط مقدارشان ‪ false‬باشد‬
‫مقدار ‪ z ،false‬خواهد شد ‪.‬‬

‫مقدار ‪ Z‬در صورتی ‪ true‬است که مقدار شرط ‪ false‬باشد و در‬ ‫)‪z = !(x > 2‬‬ ‫‪Not‬‬ ‫!‬
‫صورتی ‪ false‬است که مقدار شرط ‪ true‬باشد ‪.‬‬
‫به عنوان مثال جمله )‪ z = (x > 2) && (y < 10‬را به این صورت بخوانید ‪“ :‬در صورتی مقدار ‪ z‬برابر ‪ true‬است که مقدار‬
‫‪ x‬بزرگتر از ‪ 5‬و مقدار‪ y‬کوچکتر از ‪ 33‬باشد در غیر اینصورت ‪ false‬است”‪ .‬این جمله بدین معناست که برای اینکه مقدار کل‬
‫دستور ‪ true‬باشد باید مقدار همه شروط ‪ true‬باشد‪ .‬عملگر منطقی )||( ‪ OR‬تأثیر متفاوتی نسبت به عملگر منطقی )&&( ‪AND‬‬
‫دارد‪ .‬نتیجه عملگر منطقی ‪ OR‬برابر ‪ true‬است اگر فقط مقدار یکی از شروط ‪ true‬باشد‪ .‬و اگر مقدار هیچ یک از شروط ‪true‬‬
‫نباشد نتیجه ‪ false‬خواهد شد‪ .‬میتوان عملگرهای منطقی ‪ AND‬و ‪ OR‬را با هم ترکیب کرده و در یک عبارت به کار برد مانند‪:‬‬
‫) ) )‪if ( (x == 1) && ( (y > 3) || z < 10‬‬

‫{‬
‫‪//do something here‬‬
‫}‬
‫در اینجا استفاده از پرانتز مهم است چون از آن در گروه بندی شرطها استفاده میکنیم‪ .‬در اینجا ابتدا عبارت < ‪(y > 3) || (z‬‬
‫)‪ 10‬مورد بررسی قرار میگیرد (به علت تقدم عملگرها)‪ .‬سپس نتیجه آن بوسیله عملگر ‪ AND‬با نتیجه )‪ (x == 1‬مقایسه میشود‪.‬‬
‫حال بیایید نحوه استفاده از عملگرهای منطقی در برنامه را مورد بررسی قرار دهیم‪:‬‬

‫‪2‬‬
‫‪3‬‬ ‫;‪import java.util.Scanner‬‬
‫‪4‬‬
‫‪6‬‬ ‫{‬
‫‪8‬‬ ‫{‬
‫‪9‬‬ ‫;‪int age‬‬
‫‪10‬‬ ‫;‪String gender‬‬
‫‪11‬‬
‫‪12‬‬ ‫;)‪Scanner input = new Scanner(System.in‬‬
‫‪13‬‬
‫‪14‬‬ ‫;)" ‪System.out.print("Enter your age:‬‬
‫‪15‬‬ ‫;)(‪age = input.nextInt‬‬
‫‪16‬‬
‫‪17‬‬ ‫;)"‪System.out.print("Enter your gender (male/female):‬‬
‫‪18‬‬ ‫;)(‪gender = input.next‬‬
‫‪19‬‬
‫‪20‬‬ ‫)‪if (age > 12 && age < 20‬‬
‫‪21‬‬ ‫{‬
‫‪22‬‬ ‫)"‪if (gender == "male‬‬
‫‪23‬‬ ‫{‬
‫‪24‬‬ ‫;)"‪System.out.println("You are a teenage boy.‬‬
‫‪25‬‬ ‫}‬
‫‪26‬‬ ‫‪else‬‬
‫‪27‬‬ ‫{‬
‫‪۹۱‬‬ ‫مبانی زبان جاوا‬
‫‪28‬‬ ‫;)"‪System.out.println("You are not a teenage girl.‬‬

‫‪29‬‬ ‫}‬
‫‪30‬‬ ‫}‬
‫‪31‬‬ ‫‪else‬‬
‫‪32‬‬ ‫{‬
‫‪33‬‬ ‫;)"‪System.out.println("You are not a teenager.‬‬
‫‪34‬‬ ‫}‬
‫‪35‬‬ ‫}‬
‫‪36‬‬ ‫}‬
‫‪Enter your age: 18‬‬

‫‪Enter your gender (male/female): female‬‬
‫‪You are a teenage girl.‬‬
‫‪Enter you age: 10‬‬
‫‪Enter your gender (male/female): male‬‬
‫‪You are not a teenager.‬‬
‫برنامه باال نحوه استفاده از عملگر منطقی ‪ AND‬را نشان میدهد (خط ‪ .)53‬وقتی به دستور ‪ if‬میرسید (خط ‪ )53‬برنامه سن شما‬
‫را چک میکند‪ .‬اگر سن شما بزرگتر از ‪ 35‬و کوچکتر از ‪ 53‬باشد (سنتان بین ‪ 35‬و ‪ 53‬باشد) یعنی مقدار هر دو ‪ true‬باشد‪ ،‬سپس‬
‫کدهای داخل بلوک ‪ if‬اجرا میشوند‪ .‬اگر نتیجه یکی از شروط ‪ false‬باشد کدهای داخل بلوک ‪ else‬اجرا میشود‪ .‬عملگر ‪AND‬‬
‫عملوند سمت چپ را مرود بررسی قرار میدهد‪ .‬اگر مقدار آن ‪ false‬باشد دیگر عملوند سمت راست را بررسی نمیکند و مقدار‬
‫‪ false‬را بر میگرداند‪ .‬بر عکس عملگر || عملوند سمت چپ را مورد بررسی قرار میدهد و اگر مقدار آن ‪ true‬باشد سپس عملوند‬
‫سمت راست را نادیده میگیرد و مقدار ‪ true‬را بر میگرداند‪.‬‬
‫)‪if (x == 2 & y == 3‬‬

‫{‬
‫‪//Some code here‬‬
‫}‬
‫)‪if (x == 2 | y == 3‬‬
‫{‬
‫‪//Some code here‬‬
‫}‬
‫نکته مهم اینجاست که شما میتوانید از عملگرهای & و | به عنوان عملگر بیتی استفاده کنید‪ .‬تفاوت جزئی این عملگرها وقتی که‬
‫به عنوان عملگر بیتی به کار میروند این است که دو عملوند را بدون در نظر گرفتن مقدار عملوند سمت چپ مورد بررسی قرار‬
‫میدهند‪ .‬به عنوان مثال حتی اگر مقدار عملوند سمت چپ ‪ false‬باشد عملوند سمت چپ به وسیله عملگر بیتی )&( ‪ AND‬ارزیابی‬
‫میشود‪ .‬اگر شرطها را در برنامه ترکیب کنید استفاده از عملگرهای منطقی )&&( ‪ AND‬و )||( ‪ OR‬به جای عملگرهای بیتی )&(‪AND‬‬
‫و )|( ‪ OR‬بهتر خواهد بود‪ .‬یکی دیگر از عملگرهای منطقی عملگر )!( ‪ NOT‬است که نتیجه یک عبارت را خنثی یا منفی میکند‪ .‬به‬
‫مثال زیر توجه کنید‪:‬‬

‫))‪if (!(x == 2‬‬

‫{‬
‫;)"‪System.out.println("x is not equal to 2.‬‬
‫}‬
‫اگر نتیجه عبارت ‪ x == 2‬برابر ‪ false‬باشد عملگر ! آن را ‪ True‬میکند‪.‬‬
‫دستور ‪switch‬‬
‫در جاوا ساختاری به نام ‪ switch‬وجود دارد که به شما اجازه میدهد که با توجه به مقدار ثابت یک متغیر چندین انتخاب داشته‬
‫باشید‪ .‬دستور ‪ switch‬معادل دستور ‪ if‬تو در تو است با این تفاوت که در دستور ‪ switch‬متغیر فقط مقادیر ثابتی از اعداد‪،‬‬
‫رشتهها و یا کاراکترها را قبول میکند‪ .‬مقادیر ثابت مقادیری هستند که قابل تغییر نیستند‪ .‬در زیر نحوه استفاده از دستور ‪switch‬‬
‫آمده است‪:‬‬
‫)‪switch (testVar‬‬
‫{‬
‫‪case compareVal1:‬‬
‫‪code to execute‬‬ ‫;‪if testVar == compareVa11‬‬
‫;‪break‬‬
‫‪case compareVa12:‬‬
‫‪code to execute‬‬ ‫;‪if testVar == compareVa12‬‬
‫;‪break‬‬
‫‪.‬‬
‫‪.‬‬
‫‪.‬‬
‫‪case compareVa1N:‬‬
‫‪code to execute‬‬ ‫;‪if testVer == compareVa1N‬‬
‫;‪break‬‬
‫‪default:‬‬
‫‪code to execute‬‬ ‫;‪if none of the values above match the testVar‬‬
‫;‪break‬‬
‫}‬
‫ابتدا یک مقدار در متغیر ‪ switch‬که در مثال باال ‪ testVar‬است قرار میدهید‪ .‬این مقدار با هر یک از عبارتهای ‪ case‬داخل‬
‫بلوک ‪ switch‬مقایسه میشود‪ .‬اگر مقدار متغیر با هر یک از مقادیر موجود در دستورات ‪ case‬برابر بود کد مربوط به آن ‪ case‬اجرا‬
‫خواهد شد‪ .‬به این نکته توجه کنید که حتی اگر تعداد خط کدهای داخل دستور ‪ case‬از یکی بیشتر باشد نباید از آکوالد استفاده‬
‫کنیم‪ .‬آخر هر دستور ‪ case‬با کلمه کلیدی ‪ break‬تشخیص داده میشود که باعث میشود برنامه از دستور ‪ switch‬خارج شده و‬
‫دستورات بعد از آن اجرا شوند‪ .‬اگر این کلمه کلیدی از قلم بیوفتد برنامه با خطا مواجه میشود‪ .‬دستور ‪ switch‬یک بخش‬
‫‪ default‬دارد‪ .‬این دستور در صورتی اجرا میشود که مقدار متغیر با هیچ یک از مقادیر دستورات ‪ case‬برابر نباشد‪ .‬دستور ‪default‬‬
۹1 ‫مبانی زبان جاوا‬
‫ مکان این دستور هم مهم نیست اما بر طبق تعریف آن را در‬.‫ حذف شود هیچ اتفاقی نمیافتد‬switch ‫اختیاری است و اگر از بدنه‬
:‫ توجه کنید‬switch ‫ به مثالی در مورد دستور‬.‫پایان دستورات مینویسند‬
2
4
6 {
8 {
10
11 int choice;
12
13 System.out.println("What's your favorite pet?");
14 System.out.println("[1] Dog");
15 System.out.println("[2] Cat");
16 System.out.println("[3] Rabbit");
17 System.out.println("[4] Turtle");
18 System.out.println("[5] Fish");
19 System.out.println("[6] Not in the choices");
20 System.out.print("Enter your choice: ");
21
22 choice = input.nextInt();
23
24 switch (choice)
25 {
26 case 1:
27 System.out.println("Your favorite pet is Dog.");
28 break;
29 case 2:
30 System.out.println("Your favorite pet is Cat.");
31 break;
32 case 3:
33 System.out.println("Your favorite pet is Rabbit.");
34 break;
35 case 4:
36 System.out.println("Your favorite pet is Turtle.");
37 break;
38 case 5:
39 System.out.println("Your favorite pet is Fish.");
40 break;
41 case 6:
42 System.out.println("Your favorite pet is not in the choices.");
43 break;
44 default:
45 System.out.println("You don't have a favorite pet.");
46 break;
47 }
48 }
49 }
What's your favorite pet?

[1] Dog
[2] Cat
[3] Rabbit
[4] Turtle
[5] Fish
[6] Not in the choices
Enter your choice: 2

Your favorite pet is Cat.
What's your favorite pet?
[1] Dog
[2] Cat
[3] Rabbit
[4] Turtle
[5] Fish
[6] Not in the choices

You don't have a favorite pet.
‫ شما عدد را‬.‫ به اسم هر حیوان یک عدد نسبت داده شده است‬.‫برنامه باال به شما اجازه انتخاب حیوان مورد عالقهتان را میدهد‬
‫ مقایسه میشود و با هر کدام از آن مقادیر که برابر بود پیغام مناسب‬case ‫ با مقادیر‬switch ‫وارد میکنید و این عدد در دستور‬
‫ یکی دیگر از ویژگیهای‬.‫ اجرا میشود‬default ‫ ها برابر نبود دستور‬case ‫ اگر هم با هیچ کدام از مقادیر‬.‫نمایش داده خواهد شد‬
‫ در مثال زیر اگر مقدار‬.‫ برای نشان داده یک مجموعه کد استفاده کنید‬case ‫ این است که شما میتوانید از دو یا چند‬switch ‫دستور‬
.‫ ها باید پشت سر هم نوشته شوند‬case ‫ توجه کنید که‬.‫ باشد یک کد اجرا میشود‬1 ‫ یا‬5 ،3 ،number
switch(number)
{
case 1:
case 2:
case 3:
System.out.println("This code is shared by three values.");
break;
}
:‫ برنامه باال را به صورت زیر نیز میتوان نوشت‬.‫ تو در تو است‬if ‫ معادل دستور‬switch ‫همانطور که قبال ذکر شد دستور‬
if (choice == 1)
System.out.println("Your favorite pet is Dog.");
else if (choice == 2)
System.out.println("Your favorite pet is Cat.");
System.out.println("Your favorite pet is Rabbit.");
System.out.println("Your favorite pet is Turtle.");
System.out.println("Your favorite pet is Fish.");
System.out.println("Your favorite pet is not in the choices.");
else
System.out.println("You don't have a favorite pet.");
‫‪۹۹‬‬ ‫مبانی زبان جاوا‬
‫کد باال دقیقا نتیجه ای مانند دستور ‪ switch‬دارد‪ .‬دستور ‪ default‬معادل دستور ‪ else‬میباشد‪ .‬حال از بین این دو دستور‬
‫(‪ switch‬و ‪ )if else‬کدامیک را انتخاب کنیم‪ .‬از دستور ‪ switch‬موقعی استفاده میکنیم که مقداری که میخواهیم با دیگر‬
‫مقادیر مقایسه شود ثابت باشد‪ .‬مثال در مثال زیر هیچگاه از ‪ switch‬استفاده نکنید‪.‬‬

‫;‪int x = 5‬‬
‫)‪switch (myNumber‬‬
‫{‬
‫‪case x:‬‬
‫‪System.out.println("Error, you can't use variables as a value" +‬‬
‫;)"‪" to be compared in a case statment.‬‬
‫;‪break‬‬
‫}‬
‫مشاهده میکنید که با اینکه مقدار ‪ x‬عدد ‪ 1‬است و به طور واضح با متغیر ‪ myNumber‬مقایسه شده است برنامه خطا میدهد‬
‫چون ‪ x‬یک ثابت نیست بلکه یک متغیر است یا به زبان ساده تر‪ ،‬قابلیت تغییر را دارد‪ .‬اگر بخواهید از ‪ x‬استفاده کنید و برنامه خطا‬
‫ندهد باید از کلمه کلیدی ‪ final‬به صورت زیر استفاده کنید‪.‬‬

‫;‪final int x = 5‬‬
‫{‬
‫‪case x:‬‬
‫;)"!‪System.out.println("Error has been fixed‬‬
‫;‪break‬‬
‫}‬
‫از کلمه کلیدی ‪ final‬برای ایجاد ثابتها استفاده میشود‪.‬توجه کنید که بعد از تعریف یک ثابت نمیتوان مقدار آن را در طول‬
‫برنامه تغییر داد‪ .‬به یاد داشته باشید که باید ثابتها را حتما مقداردهی کنید‪ .‬دستور ‪ switch‬یک مقدار را با مقادیر ‪ case‬ها‬
‫مقایسه میکند و شما الزم نیست که به شکل زیر مقادیر را با هم مقایسه کنید‪:‬‬
‫{‬
‫‪case x > myNumber:‬‬
‫‪System.out.println("switch staments can't test if a value is less than " +‬‬
‫;)"‪"or greater than the other value.‬‬
‫;‪break‬‬
‫}‬
‫تکرار‬
‫ساختارهای تکرار به شما اجازه میدهند که یک یا چند دستور کد را تا زمانی که یک شرط برقرار است تکرار کنید‪.‬بدون ساختارهای‬
‫تکرار شما مجبورید همان تعداد کدها را بنویسید که بسیار خسته کننده است‪.‬مثال شما مجبورید ‪ 33‬بار جمله ”‪“Hello World.‬‬
‫را تایپ کنید مانند مثال زیر‪:‬‬
‫‪System.out.println("Hello‬‬ ‫;)"‪World.‬‬
‫البته شما میتوانید با کپی کردن این تعداد کد را راحت بنویسید ولی این کار در کل کیفیت کدنویسی را پایین میآورد‪ .‬راه بهتر‬
‫برای نوشتن کدهای باال استفاده از حلقهها است‪ .‬ساختارهای تکرار در جاوا عبارتاند از‪:‬‬
‫‪while‬‬ ‫‪‬‬
‫‪do while‬‬ ‫‪‬‬
‫‪for‬‬ ‫‪‬‬
‫حلقه ‪While‬‬
‫ابتداییترین ساختار تکرار در جاوا حلقه ‪ while‬است‪.‬ابتدا یک شرط را مورد بررسی قرار میدهد و تا زمانیکه شرط برقرار باشد‬
‫کدهای درون بلوک اجرا میشوند‪ .‬ساختار حلقه ‪ while‬به صورت زیر است‪:‬‬
‫)‪while(condition‬‬
‫{‬
‫;‪code to loop‬‬
‫}‬
‫‪۵۱۵‬‬ ‫مبانی زبان جاوا‬
‫میبینید که ساختار ‪ while‬مانند ساختار ‪ if‬بسیار ساده است‪ .‬ابتدا یک شرط را که نتیجه آن یک مقدار بولی است مینویسیم‬
‫اگر نتیجه درست یا ‪ true‬باشد سپس کدهای داخل بلوک ‪ while‬اجرا میشوند‪ .‬اگر شرط غلط یا ‪ false‬باشد وقتی که برنامه به‬
‫حلقه ‪ while‬برسد هیچکدام از کدها را اجرا نمیکند‪ .‬برای متوقف شدن حلقه باید مقادیر داخل حلقه ‪ while‬اصالح شوند‪.‬‬
‫به یک متغیر شمارنده در داخل بدنه حلقه نیاز داریم‪ .‬این شمارنده برای آزمایش شرط مورد استفاده قرار میگیرد و ادامه یا توقف‬
‫حلقه به نوعی به آن وابسته است‪ .‬این شمارنده را در داخل بدنه باید کاهش یا افزایش دهیم‪ .‬در برنامه زیر نحوه استفاده از حلقه‬
‫‪ while‬آمده است‪:‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;‪int counter = 1‬‬
‫‪8‬‬
‫‪9‬‬ ‫)‪while (counter <= 10‬‬
‫‪10‬‬ ‫{‬
‫‪12‬‬ ‫;‪counter++‬‬
‫‪13‬‬ ‫}‬
‫‪14‬‬ ‫}‬
‫‪15‬‬ ‫}‬
‫‪Hello‬‬ ‫!‪World‬‬
‫برنامه باال ‪ 33‬بار پیغام !‪ Hello World‬را چاپ میکند‪ .‬اگر از حلقه در مثال باال استفاده نمیکردیم مجبور بودیم تمام ‪ 33‬خط را‬
‫تایپ کنیم‪ .‬اجازه دهید که نگاهی به کدهای برنامه فوق بیندازیم‪ .‬ابتدا در خط ‪ 1‬یک متغیر تعریف و از آن به عنوان شمارنده حلقه‬
‫استفاده شده است‪.‬سپس به آن مقدار ‪ 3‬را اختصاص میدهیم چون اگر مقدار نداشته باشد نمیتوان در شرط از آن استفاده کرد‪.‬‬
‫در خط ‪ 6‬حلقه ‪ while‬را وارد میکنیم‪ .‬در حلقه ‪ while‬ابتدا مقدار اولیه شمارنده با ‪ 33‬مقایسه میشود که آیا از ‪ 33‬کمتر است یا با‬
‫آن برابر است‪ .‬نتیجه هر بار مقایسه ورود به بدنه حلقه ‪ while‬و چاپ پیغام است‪ .‬همانطور که مشاهده میکنید بعد از هر بار‬
‫مقایسه مقدار شمارنده یک واحد اضافه میشود (خط ‪ .)35‬حلقه تا زمانی تکرار میشود که مقدار شمارنده از ‪ 33‬کمتر باشد‪.‬‬
‫اگر مقدار شمارنده یک بماند و آن را افزایش ندهیم و یا مقدار شرط هرگز ‪ false‬نشود یک حلقه بینهایت به وجود میآید‪ .‬به‬
‫این نکته توجه کنید که در شرط باال به جای عالمت < از =< استفاده شده است‪ .‬اگر از عالمت < استفاده میکردیم کد ما ‪ 6‬بار تکرار‬
‫میشد چون مقدار اولیه ‪ 3‬است و هنگامی که شرط به ‪ 33‬برسد ‪ false‬میشود چون ‪ 33 < 33‬نیست‪ .‬اگر میخواهید یک حلقه بی‬
‫نهایت ایجاد کنید که هیچگاه متوقف نشود باید یک شرط ایجاد کنید که همواره درست )‪ (true‬باشد‪.‬‬
‫)‪while(true‬‬
‫{‬
‫‪//code to loop‬‬
‫}‬
‫این تکنیک در برخی موارد کارایی دارد و آن زمانی است که شما بخواهید با استفاده از دستورات ‪ break‬و ‪ return‬که در آینده‬
‫توضیح خواهیم داد از حلقه خارج شوید‪.‬‬
‫حلقه‪do While‬‬
‫حلقه ‪ do while‬یکی دیگر از ساختارهای تکرار است‪ .‬این حلقه بسیار شبیه حلقه ‪ while‬است با این تفاوت که در این حلقه ابتدا‬
‫کد اجرا می شودو سپس شرط مورد بررسی قرار میگیرد‪ .‬ساختار حلقه ‪ do while‬به صورت زیر است‪:‬‬
‫‪do‬‬
‫{‬
‫;‪code to repeat‬‬
‫;)‪} while (condition‬‬
‫همانطور که مشاهده میکنید شرط در آخر ساختار قرار دارد‪ .‬این بدین معنی است که کدهای داخل بدنه حداقل یکبار اجرا میشوند‪.‬‬
‫برخالف حلقه ‪ while‬که اگر شرط نادرست باشد دستورات داخل بدنه اجرا نمیشوند‪ .‬یکی از موراد برتری استفاده از حلقه ‪do‬‬
‫‪ while‬نسبت به حلقه ‪ while‬زمانی است که شما بخواهید اطالعاتی از کاربر دریافت کنید‪ .‬به مثال زیر توجه کنید‪:‬‬
‫استفاده از ‪while‬‬
‫‪//while version‬‬
‫;)" ‪System.out.print("Enter a number greater than 10:‬‬

‫;)(‪number = input.nextInt‬‬
‫)‪while(number < 10‬‬

‫‪۵۱۳‬‬ ‫مبانی زبان جاوا‬
‫{‬
‫;)" ‪System.out.println("Enter a number greater than 10:‬‬
‫}‬
‫استفاده از‪do while‬‬
‫‪//do while version‬‬
‫‪do‬‬
‫{‬
‫;)" ‪System.out.println("Enter a number greater than 10:‬‬
‫}‬
‫)‪while(number < 10‬‬
‫مشاهده میکنید که از کدهای کمتری در بدنه ‪ do while‬نسبت به ‪ while‬استفاده شده است‪.‬‬
‫حلقه ‪for‬‬
‫یکی دیگر از ساختارهای تکرار حلقه ‪ for‬است‪.‬این حلقه عملی شبیه به حلقه ‪ while‬انجام میدهد و فقط دارای چند خصوصیت‬
‫اضافی است‪ .‬ساختار حلقه ‪ for‬به صورت زیر است‪:‬‬
‫)‪for(initialization; condition; operation‬‬

‫{‬
‫;‪code to repeat‬‬
‫}‬
‫مقدار دهی اولیه )‪ (initialization‬اولین مقداری است که به شمارنده حلقه میدهیم‪.‬شمارنده فقط در داخل حلقه ‪for‬‬
‫قابل دسترسی است‪ .‬شرط )‪ (condition‬در اینجا مقدار شمارنده را با یک مقدار دیگر مقایسه میکند و تعیین میکند که حلقه‬
‫ادامه یابد یا نه‪ .‬عملگر )‪ (operation‬که مقدار اولیه متغیر را کاهش یا افزایش میدهد‪ .‬در زیر یک مثال از حلقه ‪ for‬آمده‬
‫است‪:‬‬

‫{‬
‫{‬
‫)‪for(int i = 1; i <= 10; i++‬‬
‫{‬
‫;)‪System.out.println("Number " + i‬‬
‫}‬
‫}‬
‫}‬
‫‪Number‬‬ ‫‪1‬‬
‫‪Number‬‬ ‫‪2‬‬
‫‪Number‬‬ ‫‪3‬‬
‫‪Number‬‬ ‫‪4‬‬
‫‪Number‬‬ ‫‪5‬‬
‫‪Number‬‬ ‫‪6‬‬
‫‪Number‬‬ ‫‪7‬‬
‫‪Number‬‬ ‫‪8‬‬
‫‪Number‬‬ ‫‪9‬‬
‫‪Number‬‬ ‫‪10‬‬
‫برنامه باال اعداد ‪ 3‬تا ‪ 33‬را با استفاده از حلقه ‪ for‬میشمارد‪ .‬ابتدا یک متغیر به عنوان شمارنده تعریف میکنیم و آن را با مقدار ‪3‬‬
‫مقدار دهی اولیه میکنیم‪ .‬سپس با استفاده از شرط آن را با مقدار ‪ 33‬مقایسه میکنیم که آیا کمتر است یا مساوی؟ توجه کنید که‬
‫قسمت سوم حلقه )‪ (i++‬فورا اجرا نمیشود‪ .‬کد اجرا میشود و ابتدا رشته ‪ Number‬و سپس مقدار جاری ‪ i‬یعنی ‪ 3‬را چاپ میکند‪.‬‬
‫آنگاه یک واحد به مقدار ‪ i‬اضافه شده و مقدار ‪ i‬برابر ‪ 5‬میشود و بار دیگر ‪ i‬با عدد ‪ 33‬مقایسه میشود و این حلقه تا زمانی که‬
‫مقدار شرط ‪ true‬شود ادامه مییابد‪ .‬حال اگر بخواهید معکوس برنامه باال را پیاده سازی کنید یعنی اعداد از بزرگ به کوچک چاپ‬
‫شوند باید به صورت زیر عمل کنید‪:‬‬
‫)‪for (int i = 10; i > 0; i--‬‬

‫{‬
‫‪//code omitted‬‬
‫}‬
‫کد باال اعداد را از ‪ 33‬به ‪ 3‬چاپ میکند (از بزرگ به کوچک)‪ .‬مقدار اولیه شمارنده را ‪ 33‬میدهیم و با استفاده از عملگر کاهش (‪)--‬‬
‫برنامه ای که شمارش معکوس را انجام میدهد ایجاد میکنیم‪ .‬میتوان قسمت شرط و عملگر را به صورتهای دیگر نیز تغییر داد‪.‬‬
‫به عنوان مثال میتوان از عملگرهای منطقی در قسمت شرط و از عملگرهای تخصیصی در قسمت عملگر افزایش یا کاهش استفاده‬
‫کرد‪ .‬همچنین میتوانید از چندین متغیر در ساختار حلقه ‪ for‬استفاده کنید‪.‬‬
‫)‪for (int i = 1, y = 2; i < 10 && y > 20; i++, y -= 2‬‬

‫{‬
‫‪//some code here‬‬
‫}‬
‫به این نکته توجه کنید که اگر از چندین متغیر شمارنده یا عملگر در حلقه ‪ for‬استفاده میکنید باید آنها را با استفاده از کاما از هم‬
‫جدا کنید‪ .‬گاهی اوقات با وجود درست بودن شرط میخواهیم حلقه متوقف شود‪ .‬سؤال اینجاست که چطور این کار را انجام دهید؟‬
۵۱۱ ‫مبانی زبان جاوا‬
‫ میتوان بخشی از حلقه را رد کرد و‬continue ‫ حلقه را متوقف کرده و با استفاده از کلمه کلیدی‬break ‫با استفاده از کلمه کلیدی‬
:‫ را نشان میدهد‬break ‫ و‬continue ‫ برنامه زیر نحوه استفاده از‬.‫به مرحله بعد رفت‬
2
4 {
6 {
7 System.out.println("Demonstrating the use of break\n");
8
9 for (int x = 1; x < 10; x++)
10 {
11 if (x == 5)
12 break;
13
14 System.out.println("Number " + x);
15 }
16
17 System.out.println("\nDemonstrating the use of continue\n");
18
19 for (int x = 1; x < 10; x++)
20 {
21 if (x == 5)
22 continue;
23
24 System.out.println("Number "+ x);
25 }
26 }
27 }
Demonstrating the use of break.
Number 1
Number 2
Number 3
Number 4
Demonstrating the use of continue.
Number 1
Number 2
Number 3
Number 4
Number 6
Number 7
Number 8
Number 9
‫ و‬while ‫ از حلقههای‬for ‫ برای نشان دادن کاربرد دو کلمه کلیدی فوق استفاده شده است اگر به جای‬for ‫در این برنامه از حلقه‬
‫ به‬x ‫) آمده است وقتی که مقدار‬33 ‫ همانطور که در شرط برنامه (خط‬.‫ استفاده میشد نتیجه یکسانی به دست میآمد‬do…while
‫از طرف‬.‫ برقرار باشد‬x < 10 ‫ حلقه بالفاصله متوقف میشود حتی اگر شرط‬.)35 ‫ اجرا شود(خط‬break ‫ رسید سپس دستور‬1 ‫عدد‬
‫دیگر در خط ‪ 55‬حلقه ‪ for‬فقط برای یک تکرار خاص متوقف شده و سپس ادامه مییابد‪ .‬وقتی مقدار ‪ x‬برابر ‪ 1‬شود حلقه از ‪ 1‬رد‬
‫شده و مقدار ‪ 1‬را چاپ نمیکند و بقیه مقادیر چاپ میشوند‪.‬‬
‫آرایهها‬
‫آرایه نوعی متغیر است که لیستی از آدرسهای مجموعه ای از دادههای هم نوع را در خود ذخیره میکند‪ .‬تعریف چندین متغیر از‬
‫یک نوع برای هدفی یکسان بسیار خسته کننده است‪ .‬مثال اگر بخواهید صد متغیر از نوع اعداد صحیح تعریف کرده و از آنها‬
‫استفاده کنید‪ .‬مطمئنا تعریف این همه متغیر بسیار کسالت آور و خسته کننده است‪ .‬اما با استفاده از آرایه میتوان همه آنها را در‬
‫یک خط تعریف کرد‪ .‬در زیر راهی ساده برای تعریف یک آرایه نشان داده شده است‪:‬‬
‫;]‪datatype[] arrayName = new datatype[length‬‬
‫‪ Datatype‬نوع دادههایی را نشان میدهد که آرایه در خود ذخیره میکند‪ .‬کروشه که بعد از نوع داده قرار میگیرد و نشان دهنده‬
‫استفاده از آرایه است‪ arrayName .‬که نام آرایه را نشان میدهد‪ .‬هنگام نامگذاری آرایه بهتر است که نام آرایه نشان دهنده نوع‬
‫آرایه باشد‪ .‬به عنوان مثال برای نامگذاری آرایه ای که اعداد را در خود ذخیره میکند از کلمه ‪ number‬استفاده کنید‪ .‬طول آرایه که‬
‫به کمپایلر میگوید شما قصد دارید چه تعداد داده یا مقدار را در آرایه ذخیره کنید‪ .‬از کلمه کلیدی ‪ new‬هم برای اختصاص فضای‬
‫حافظه به اندازه طول آرایه استفاده میشود‪ .‬برای تعریف یک آرایه که ‪ 1‬مقدار از نوع اعداد صحیح در خود ذخیره میکند باید به‬
‫صورت زیر عمل کنیم‪:‬‬
‫;]‪int[] numbers = new int[5‬‬
‫در این مثال ‪ 1‬آدرس از فضای حافظه کامپیوتر شما برای ذخیره ‪ 1‬مقدار رزرو میشود‪ .‬حال چطور مقادیرمان را در هر یک از این‬
‫آدرسها ذخیره کنیم؟ برای دسترسی و اصالح مقادیر آرایه از اندیس یا مکان آنها استفاده میشود‪.‬‬
‫]‪numbers[0‬‬ ‫=‬ ‫;‪1‬‬

‫]‪numbers[1‬‬ ‫=‬ ‫;‪2‬‬
‫]‪numbers[2‬‬ ‫=‬ ‫;‪3‬‬
‫]‪numbers[3‬‬ ‫=‬ ‫;‪4‬‬
‫]‪numbers[4‬‬ ‫=‬ ‫;‪5‬‬
‫‪۵۱1‬‬ ‫مبانی زبان جاوا‬
‫اندیس یک آرایه از صفر شروع شده و به یک واحد کمتر از طول آرایه ختم میشود‪ .‬به عنوان مثال شما یک آرایه ‪ 1‬عضوی دارید‪،‬‬
‫اندیس آرایه از ‪ 3‬تا ‪ 3‬میباشد چون طول آرایه ‪ 1‬است پس ‪ 1-3‬برابر است با ‪ .3‬این بدان معناست که اندیس ‪ 3‬نشان دهنده اولین‬
‫عضو آرایه است و اندیس ‪ 3‬نشان دهنده دومین عضو و الی آخر‪ .‬برای درک بهتر مثال باال به شکل زیر توجه کنید‪:‬‬
‫به هر یک از اجزاء آرایه و اندیسهای داخل کروشه توجه کنید‪ .‬کسانی که تازه شروع به برنامه نویسی کردهاند معموال در گذاشتن‬
‫اندیس دچار اشتباه میشوند و مثال ممکن است در مثال باال اندیسها را از ‪ 3‬شروع کنند‪ .‬اگر بخواهید به یکی از اجزائ آرایه با‬
‫خطای‬ ‫پیغام‬ ‫با‬ ‫نباشد‬ ‫شما‬ ‫آرایه‬ ‫اندیسهای‬ ‫محدوده‬ ‫در‬ ‫که‬ ‫کنید‬ ‫پیدا‬ ‫دسترسی‬ ‫اندیسی‬ ‫از‬ ‫استفاده‬
‫‪ ArrayIndexOutOfBoundsException‬مواجه میشوید و بدین معنی است که شما آدرسی را میخواهید که وجود ندارد‪ .‬یک راه‬
‫بسیار ساده تر برای تعریف آرایه به صورت زیر است‪:‬‬
‫;} ‪int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10‬‬
‫به سادگی و بدون احتیاج به کلمه کلیدی ‪ new‬میتوان مقادیر را در داخل آکوالد قرار داد‪ .‬کمپایلر به صورت اتوماتیک با شمارش‬
‫مقادیر طول آرایه را تشخیص میدهد‪.‬‬
‫دستیابی به مقادیر آرایه با استفاده از حلقه ‪for‬‬
‫در زیر مثالی در مورد استفاده از آرایهها آمده است‪ .‬در این برنامه ‪ 1‬مقدار از کاربر گرفته شده و میانگین آنها حساب میشود‪:‬‬

‫‪2‬‬
‫‪5‬‬
‫‪7‬‬ ‫{‬

‫‪9‬‬ ‫{‬
‫‪11‬‬
‫‪12‬‬ ‫;]‪int[] numbers = new int[5‬‬
‫‪13‬‬ ‫;‪int total = 0‬‬
‫‪14‬‬ ‫;‪double average‬‬
‫‪15‬‬
‫‪16‬‬ ‫)‪for (int i = 0; i < numbers.length; i++‬‬
‫‪17‬‬ ‫{‬
‫‪18‬‬ ‫;)" ‪System.out.print("Enter a number:‬‬
‫‪19‬‬ ‫;)(‪numbers[i] = input.nextInt‬‬
‫‪20‬‬ ‫}‬
‫‪22‬‬ ‫{‬
‫‪23‬‬ ‫;]‪total += numbers[i‬‬
‫‪24‬‬ ‫}‬
‫‪25‬‬
‫‪26‬‬ ‫;‪average = total / (double)numbers.length‬‬
‫‪27‬‬
‫‪28‬‬ ‫;))‪System.out.println(MessageFormat.format("Average = {0}", average‬‬
‫‪29‬‬ ‫}‬
‫‪30‬‬ ‫}‬
‫‪Enter a‬‬ ‫‪number:‬‬ ‫‪90‬‬

‫‪Average‬‬ ‫‪= 86‬‬
‫در خط ‪ 35‬یک آرایه تعریف شده است که میتواند ‪ 1‬عدد صحیح را در خود ذخیره کند‪ .‬خطوط ‪ 31‬و ‪ 33‬متغیرهایی تعریف شدهاند‬
‫که از آنها برای محاسبه میانگین استفاده میشود‪ .‬توجه کنید که مقدار اولیه ‪ total‬صفر است تا از بروز خطا هنگام اضافه شدن‬
‫مقدار به آن جلوگیری شود‪ .‬در خطوط ‪ 31‬تا ‪ 53‬حلقه ‪ for‬برای تکرار و گرفتن ورودی از کاربر تعریف شده است‪.‬از خاصیت طول‬
‫)‪ (length‬آرایه برای تشخیص تعداد اجزای آرایه استفاده میشود‪.‬اگر چه میتوانستیم به سادگی در حلقه ‪ for‬مقدار ‪ 1‬را برای‬
‫شرط قرار دهیم ولی استفاده از خاصیت طول آرایه کار راحت تری است و میتوانیم طول آرایه را تغییر دهیم و شرط حلقه ‪ for‬با‬
‫تغییر جدید هماهنگ میشود‪ .‬در خط ‪ 36‬ورودی دریافت شده از کاربر با استفاده از متد )(‪ nextInt‬دریافت و در آرایه ذخیره‬
‫میشود‪ .‬اندیس استفاده شده در ‪( number‬خط ‪ )36‬مقدار ‪ i‬جاری در حلقه است‪ .‬برای مثال در ابتدای حلقه مقدار ‪ i‬صفر است‬
‫بنابراین وقتی در خط ‪ 36‬اولین داده از کاربر گرفته میشود‪ ،‬اندیس آن برابر صفر میشود‪ .‬در تکرار بعدی ‪ i‬یک واحد اضافه میشود‬
‫و در نتیجه در خط ‪ 36‬و بعد از ورود دومین داده توسط کاربر اندیس آن برابر یک میشود‪ .‬این حالت تا زمانی که شرط در حلقه‬
‫‪ for‬برقرار است ادامه مییابد‪ .‬در خطوط ‪ 53-53‬از حلقه ‪ for‬دیگر برای دسترسی به مقدار هر یک از دادههای آرایه استفاده شده‬
‫است‪ .‬در این حلقه نیز مانند حلقه قبل از مقدار متغیر شمارنده به عنوان اندیس استفاده میکنیم‪.‬‬
‫‪۵۱۹‬‬ ‫مبانی زبان جاوا‬
‫هر یک از اجزای عددی آرایه به متغیر ‪ total‬اضافه میشوند‪ .‬بعد از پایان حلقه میتوانیم میانگین اعداد را حساب کنیم (خط‬
‫‪ .)51‬مقدار ‪ total‬را بر تعداد اجزای آرایه ( تعداد عددها) تقسیم میکنیم‪ .‬برای دسترسی به تعداد اجزای آرایه میتوان از خاصیت‬
‫‪ length‬آرایه استفاده کرد‪ .‬توجه کنید که در اینجا ما مقدار خاصیت ‪ length‬را به نوع ‪ double‬تبدیل کردهایم بنابراین نتیجه‬
‫عبارت یک مقدار از نوع ‪ double‬خواهد شد و دارای بخش کسری میباشد‪ .‬حال اگر عملوندهای تقسیم را به نوع ‪double‬‬
‫تبدیل نکنیم نتیجه تقسیم یک عدد از نوع صحیح خواهد شد و دارای بخش کسری نیست‪ .‬خط ‪ 50‬مقدار میانگین را در صفحه‬
‫نمایش چاپ میکند‪ .‬طول آرایه بعد از مقدار دهی نمیتواند تغیر کند‪ .‬به عنوان مثال اگر یک آرایه را که شامل ‪ 1‬جز است مقدار‬
‫دهی کنید دیگر نمیتوانید آن را مثال به ‪ 33‬جز تغییر اندازه دهید‪ .‬البته تعداد خاصی از کالسها مانند آرایهها عمل میکنند و توانایی‬
‫تغییر تعداد اجزای تشکیل دهنده خود را دارند‪ .‬آرایهها در برخی شرایط بسیار پر کاربرد هستند و تسلط شما بر این مفهوم و اینکه‬
‫چطور از آنها استفاده کنید بسیار مهم است‪.‬‬
‫حلقه ‪foreach‬‬
‫حلقه ‪ foreach‬یکی دیگر از ساختارهای تکرار در جاوا میباشد که مخصوصا برای آرایهها‪ ،‬لیستها و مجموعهها طراحی شده‬
‫است‪ .‬حلقه ‪ foreach‬با هر بار گردش در بین اجزاء‪ ،‬مقادیر هر یک از آنها را در داخل یک متغیر موقتی قرار میدهد و شما‬
‫میتوانید بواسطه این متغیر به مقادیر دسترسی پیدا کنید‪ .‬در زیر نحوه استفاده از حلقه ‪ foreach‬آمده است‪:‬‬
‫)‪for (datatype temporaryVar : array‬‬

‫{‬
‫}‬
‫‪ temporaryVar‬متغیری است که مقادیر اجزای آرایه را در خود نگهداری میکند‪ temporaryVar .‬باید دارای نوع باشد تا بتواند‬
‫مقادیر آرایه را در خود ذخیره کند‪ .‬به عنوان مثال آرایه شما دارای اعدادی از نوع صحیح باشد باید نوع متغیر موقتی از نوع اعداد‬
‫صحیح باشد یا هر نوع دیگری که بتواند اعداد صحیح را در خود ذخیره کند مانند ‪ double‬یا ‪ .long‬سپس عالمت دو نقطه (‪ ):‬و‬
‫بعد از آن نام آرایه را مینویسیم‪ .‬در زیر نحوه استفاده از حلقه ‪ foreach‬آمده است‪:‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;} ‪int[] numbers = { 1, 2, 3, 4, 5‬‬
‫‪8‬‬
‫‪9‬‬ ‫)‪for (int n : numbers‬‬
‫‪10‬‬ ‫{‬
‫‪11‬‬ ‫;)‪System.out.println(n‬‬
‫‪12‬‬ ‫}‬
‫‪13‬‬ ‫}‬
‫‪14‬‬ ‫}‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪5‬‬
‫در برنامه آرایه ای با ‪ 1‬جزء تعریف شده و مقادیر ‪ 3‬تا ‪ 1‬در آنها قرار داده شده است (خط ‪ .)1‬در خط ‪ 6‬حلقه ‪ foreach‬شروع‬
‫میشود‪ .‬ما یک متغیر موقتی تعریف کردهایم که اعداد آرایه را در خود ذخیره میکند‪ .‬در هر بار تکرار از حلقه ‪ foreach‬متغیر موقتی‬
‫‪ ،n‬مقادیر عددی را از آرایه استخراج میکند‪ .‬حلقه ‪ foreach‬مقادیر اولین تا آخرین جزء آرایه را در اختیار ما قرار میدهد‪.‬‬
‫حلقه ‪ foreach‬برای دریافت هر یک از مقادیر آرایه کاربرد دارد‪ .‬بعد از گرفتن مقدار یکی از اجزای آرایه‪ ،‬مقدار متغیر موقتی را چاپ‬
‫میکنیم‪ .‬حلقه ‪ foreach‬ما را قادر میسازد که به دادهها دسترسی یابیم و یا آنها را بخوانیم و اصالح کنیم‪ .‬برای درک این مطلب‬
‫در مثال زیر مقدار هر یک از اجزا آرایه افزایش یافته است‪:‬‬
‫;} ‪int[] numbers = { 1, 2, 3‬‬
‫)‪for(int n : numbers‬‬
‫{‬
‫;‪n++‬‬
‫;)‪System.out.println(n‬‬
‫}‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪5‬‬
‫‪6‬‬
‫آرایههای چند بعدی‬
‫آرایههای چند بعدی‪ ،‬آرایههایی هستند که برای دسترسی به هر یک از عناصر آنها باید از چندین اندیس استفاده کنیم‪ .‬یک آرایه‬
‫چند بعدی را میتوان مانند یک جدول با تعدای ستون و ردیف تصور کنید‪ .‬با افزایش اندیسها اندازه ابعاد آرایه نیز افزایش مییابد‬
‫و آرایههای چند بعدی با بیش از دو اندیس به وجود میآیند‪ .‬نحوه ایجاد یک آرایه با دو بعد به صورت زیر است‪:‬‬
‫‪۵۵۵‬‬ ‫مبانی زبان جاوا‬
‫;]‪datatype[][] arrayName = new datatype[lengthX][lengthY‬‬
‫و یک آرایه سه بعدی به صورت زیر ایجاد میشود‪:‬‬
‫;]‪datatype[][][] arrayName = new datatype[lengthX][lengthY][lengthZ‬‬
‫می توان یک آرایه با تعداد زیادی بعد ایجاد کرد به شرطی که هر بعد دارای طول مشخصی باشد‪ .‬به دلیل اینکه آرایههای سه بعدی‬
‫یا آرایههای با بیشتر از دو بعد بسیار کمتر مورد استفاده قرار میگیرند‪ .‬اجازه بدهید که در این درس بر روی آرایههای دو بعدی‬
‫تمرکز کنیم‪ .‬در تعریف این نوع آرایه ابتدا نوع آرایه یعنی اینکه آرایه چه نوعی از انواع داده را در خود ذخیره میکند را‪ ،‬مشخص‬
‫میکنیم‪ .‬سپس دو جفت کروشه قرار میدهیم‪ .‬به تعداد کروشهها توجه کنید‪ .‬اگر آرایه ما دو بعدی است باید ‪ 5‬جفت کروشه و اگر‬
‫سه بعدی است باید ‪ 1‬جفت کروشه قرار دهیم‪.‬سپس یک نام برای آرایه انتخاب کرده و بعد تعریف آنرا با گذاشتن کلمه ‪ ،new‬نوع‬
‫داده و طول هر بعد آن کامل میکنیم‪ .‬در یک آرایه دو بعدی برای دسترسی به هر یک از عناصر به دو مقدار نیاز داریم یکی مقدار‬
‫‪X‬و دیگری مقدار ‪ Y‬که مقدار ‪ x‬نشان دهنده ردیف و مقدار ‪ Y‬نشان دهنده ستون آرایه است البته اگر ما آرایه دو بعدی را به‬
‫صورت جدول در نظر بگیریم‪.‬یک آرایه سه بعدی را میتوان به صورت یک مکعب تصور کرد که دارای سه بعد است و ‪ x‬طول‪Y ،‬‬
‫عرض و ‪ z‬ارتفاع آن است‪ .‬یک مثال از آرایه دو بعدی در زیر آمده است‪:‬‬
‫;]‪int[][] numbers = new int[3][5‬‬
‫کد باال به کمپایلر میگوید که فضای کافی به عناصر آرایه اختصاص بده (در این مثال ‪ 31‬خانه)‪ .‬در شکل زیر مکان هر عنصر در یک‬
‫آرایه دو بعدی نشان داده شده است‪.‬‬

‫مقدار ‪ 1‬را به ‪ x‬اختصاص میدهیم چون ‪ 1‬سطر و مقدار ‪ 1‬را به ‪ Y‬چون ‪ 1‬ستون داریم اختصاص میدهیم‪ .‬چطور یک آرایه چند‬
‫بعدی را مقدار دهی کنیم؟ چند راه برای مقدار دهی به آرایهها وجود دارد‪ .‬یک راه این است که مقادیر عناصر آرایه را در همان زمان‬
‫تعریف آرایه‪ ،‬مشخص کنیم‪:‬‬
‫‪datatype[][] arrayName = { { r0c0, r0c1, ... r0cX },‬‬

‫‪{ r1c0, r1c1, ... r1cX },‬‬
‫‪.‬‬
‫‪.‬‬
‫‪.‬‬
‫;} } ‪{ rYc0, rYc1, ... rYcX‬‬
‫{ = ‪int[][] numbers‬‬
‫‪{ 1, 2, 3, 4, 5 },‬‬
‫‪{ 6, 7, 8, 9, 10 },‬‬
‫} ‪{ 11, 12, 13, 14, 15‬‬
‫;}‬
‫و یا میتوان مقدار دهی به عناصر را به صورت دستی انجام داد مانند‪:‬‬
‫]‪array[0][0‬‬ ‫=‬ ‫;‪value‬‬

‫]‪array[0][1‬‬ ‫=‬ ‫;‪value‬‬
‫]‪array[0][2‬‬ ‫=‬ ‫;‪value‬‬
‫]‪array[1][0‬‬ ‫=‬ ‫;‪value‬‬
‫]‪array[1][1‬‬ ‫=‬ ‫;‪value‬‬
‫]‪array[1][2‬‬ ‫=‬ ‫;‪value‬‬
‫]‪array[2][0‬‬ ‫=‬ ‫;‪value‬‬
‫]‪array[2][1‬‬ ‫=‬ ‫;‪value‬‬
‫]‪array[2][2‬‬ ‫=‬ ‫;‪value‬‬
‫‪۵۵۳‬‬ ‫مبانی زبان جاوا‬
‫همانطور که مشاهده میکنید برای دسترسی به هر یک از عناصر در یک آرایه دو بعدی به سادگی میتوان از اندیسهای ‪ X‬و ‪Y‬‬
‫و یک جفت کروشه مانند مثال استفاده کرد‪.‬‬
‫گردش در میان عناصر آرایههای چند بعدی‬
‫گردش در میان عناصر آرایههای چند بعدی نیاز به کمی دقت دارد‪ .‬یکی از راههای آسان استفاده از حلقه ‪ foreach‬و یا حلقه‬
‫‪ for‬تو در تو است‪ .‬اجازه دهید ابتدا از حلقه ‪ foreach‬استفاده کنیم‪.‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫‪int[][] numbers = { { 1, 2, 3, 4, 5 },‬‬
‫‪8‬‬ ‫‪{ 6, 7, 8, 9, 10 },‬‬
‫‪9‬‬ ‫} ‪{ 11, 12, 13, 14, 15‬‬
‫‪10‬‬ ‫;}‬
‫‪11‬‬
‫‪12‬‬ ‫)‪for (int[] number : numbers‬‬
‫‪13‬‬ ‫{‬
‫‪14‬‬ ‫)‪for (int num : number‬‬
‫‪15‬‬ ‫{‬
‫‪16‬‬ ‫;)" " ‪System.out.print(num +‬‬
‫‪17‬‬ ‫}‬
‫‪18‬‬ ‫}‬
‫‪19‬‬ ‫}‬
‫‪20‬‬ ‫}‬
‫‪1 2 3 4 5 6 7 8 9 10 11 12 13 14 15‬‬
‫مشاهده کردید که گردش در میان مقادیر عناصر یک آرایه چند بعدی چقدر راحت است‪ .‬به وسیله حلقه ‪ foreach‬نمیتوانیم‬
‫انتهای ردیفها را مشخص کنیم‪ .‬برنامه زیر نشان میدهد که چطور از حلقه ‪ for‬برای خواندن همه مقادیر آرایه و تعیین انتهای‬
‫ردیفها استفاده کنید‪.‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫‪int[][] numbers = { { 1, 2, 3, 4, 5 },‬‬
‫‪8‬‬ ‫‪{ 6, 7, 8, 9, 10 },‬‬
‫‪9‬‬ ‫} ‪{ 11, 12, 13, 14, 15‬‬
‫‪10‬‬ ‫;}‬
‫‪11‬‬
‫‪12‬‬ ‫)‪for (int row = 0; row < numbers.length; row++‬‬
‫‪13‬‬ ‫{‬
‫‪14‬‬ ‫)‪for (int col = 0; col < numbers[row].length; col++‬‬
‫‪15‬‬ ‫{‬
‫‪16‬‬ ‫;)" " ‪System.out.print(numbers[row][col] +‬‬
‫‪17‬‬ ‫}‬
‫‪18‬‬
‫‪19‬‬ ‫‪//Go to the next line‬‬
‫‪20‬‬ ‫;)(‪System.out.println‬‬
‫‪21‬‬ ‫}‬
‫‪22‬‬ ‫}‬
‫‪23‬‬ ‫}‬
‫‪1 2 3 4 5‬‬
‫‪6 7 8 9 10‬‬
‫‪11 12 13 14 15‬‬
‫همانطور که درمثال باال نشان داده شده است با استفاده از یک حلقه ساده ‪ for‬نمیتوان به مقادیر دسترسی یافت بلکه به یک‬
‫حلقه ‪ for‬تو در تو نیاز داریم‪ .‬در اولین حلقه ‪( for‬خط ‪ )35‬یک متغیر تعریف شده است که در میان ردیفهای آرایه )‪(row‬‬
‫گردش میکند‪ .‬این حلقه تا زمانی ادامه مییابد که مقدار ردیف کمتر از طول اولین بعد باشد‪ .‬در این مثال از خاصیت ‪lenght‬‬
‫کالس ‪ Array‬استفاده کردهایم‪ .‬این خاصیت طول آرایه را در یک بعد خاص نشان میدهد‪ .‬به عنوان مثال برای به دست آوردن‬
‫طول اولین بعد آرایه که همان تعداد ردیفها میباشد از دستور ‪ numbers.length‬استفاده کردهایم‪.‬‬
‫در داخل اولین حلقه ‪ for‬حلقه ‪ for‬دیگری تعریف شده است (خط ‪ .)33‬در این حلقه یک شمارنده برای شمارش تعداد ستونهای‬
‫)‪ (columns‬هر ردیف تعریف شده است و در شرط داخل آن بار دیگر از خاصیت ‪ lenght‬استفاده شده است‪ ،‬ولی این بار به‬
‫نوعی دیگر از آن استفاده میکنیم‪ .‬همانطور که مشاهده میکنید ابتدا نام آرایه را نوشتهایم و سپس یک اندیس به آن اختصاص‬
‫دادهایم و بعد از خاصیت ‪ lenght‬استفاده نمودهایم‪:‬‬
‫‪numbers[row].length‬‬
‫استفاده از ‪ row‬به عنوان اندیس باعث میشود که به عنوان مثال وقتی که مقدار ردیف )‪ (row‬صفر باشد‪ ،‬حلقه دوم از [‪ ]3[]3‬تا‬
‫[‪ ]3[]3‬اجرا شود‪ .‬سپس مقدار هر عنصر از آرایه را با استفاده از حلقه نشان میدهیم‪ ،‬اگر مقدار ردیف )‪ (row‬برابر ‪ 3‬و مقدار ستون‬
‫)‪ (col‬برابر ‪ 3‬باشد مقدار عنصری که در ستون ‪ 3‬و ردیف ‪ (numbers[0][0]) 3‬قرار دارد‪ ،‬نشان داده خواهد شد که در مثال باال‬
‫عدد ‪ 3‬است‪.‬‬
‫بعد از اینکه دومین حلقه تکرار به پایان رسید‪ ،‬فورا دستورات بعد از آن اجرا خواهند شد‪ ،‬که در اینجا دستور‬
‫)(‪ System.out.println‬که به برنامه اطالع میدهد که به خط بعد برود‪ .‬سپس حلقه با اضافه کردن یک واحد به مقدار ‪row‬‬
۵۵۱ ‫مبانی زبان جاوا‬
‫ این فرایند تا‬.‫ اجرا شده و مقادیر دومین ردیف نمایش داده میشود‬for ‫ سپس دومین حلقه‬.‫این فرایند را دوباره تکرار میکند‬
.‫ حال بیایید آنچه را از قبل یاد گرفتهایم در یک برنامه به کار بریم‬.‫ کمتر از طول اولین بعد باشد‬row ‫زمانی اجرا میشود که مقدار‬
.‫این برنامه نمره چهار درس مربوط به سه دانش آموز را از ما میگیرد و معدل سه دانش آموز را حساب میکند‬
2
5
7 {
9 {
11
12 double[][] studentGrades = new double[3][4];
13 double total;
14
15 for (int student = 0; student < studentGrades.length; student++)
16 {
17 total = 0;
18
19 System.out.println(MessageFormat.format("Enter grades for Student {0}", student + 1));
20
21 for (int grade = 0; grade < studentGrades[student].length; grade++)
22 {
23 System.out.print(MessageFormat.format("Enter Grade #{0}: ", grade + 1));
24 studentGrades[student][grade] = input.nextDouble();
25 total += studentGrades[student][grade];
26 }
27
28 System.out.print(
29 MessageFormat.format("Average is {0}", (total / studentGrades[student].length)));
30 System.out.println();
31 }
32 }
33 }
Enter grades for Student 1

Enter Grade #1: 92
Enter Grade #2: 87
Enter Grade #3: 89
Enter Grade #4: 95
Average is 90.75

Enter Grade #1: 85
Enter Grade #2: 85
Enter Grade #3: 86
Enter Grade #4: 87
Average is 85.75

Enter Grade #1: 90
Enter Grade #2: 90
Enter Grade #3: 90
Enter Grade #4: 90
Average is 90.00
‫در برنامه باال یک آرایه چند بعدی از نوع ‪ double‬تعریف شده است (خط ‪ .)35‬همچنین یک متغیر به نام ‪ total‬تعریف میکنیم‬
‫که مقدار محاسبه شده معدل هر دانش آموز را در آن قرار دهیم‪ .‬حال وارد حلقه ‪ for‬تو در تو میشویم (خط ‪ .)31‬در اولین حلقه‬
‫‪ for‬یک متغیر به نام ‪ sudent‬برای تشخیص پایه درسی هر دانش آموز تعریف کردهایم‪ .‬از خاصیت ‪ lenght‬هم برای تشخیص‬
‫تعداد دانش آموزان استفاده شده است‪ .‬وارد بدنه حلقه ‪ for‬میشویم‪.‬در خط ‪ 31‬مقدار متغیر ‪ total‬را برابر صفر قرار میدهیم‪.‬‬
‫بعدا مشاهده میکنید که چرا این کار را انجام دادیم‪ .‬سپس برنامه یک پیغام را نشان میدهد و از شما میخواهد که شماره دانش‬
‫آموز را وارد کنید (‪ .)student + 1‬عدد ‪ 3‬را به ‪ student‬اضافه کردهایم تا به جای نمایش ‪ ،Student 0‬با ‪ Student 1‬شروع‬
‫شود‪ ،‬تا طبیعی تر به نظر برسد‪ .‬سپس به دومین حلقه ‪ for‬در خط ‪ 53‬میرسیم‪ .‬در این حلقه یک متغیر شمارنده به نام ‪grade‬‬
‫تعریف میکنیم که طول دومین بعد آرایه را با استفاده از ‪ studentGrades[student].length‬به دست میآورد‪ .‬این طول تعداد‬
‫نمراتی را که برنامه از سؤال میکند را نشان میدهد‪ .‬برنامه چهار نمره مربوط به دانش آموز را میگیرد‪ .‬هر وقت که برنامه یک نمره‬
‫را از کاربر دریافت میکند‪ ،‬نمره به متغیر ‪ total‬اضافه میشود‪.‬‬
‫وقتی همه نمرهها وارد شدند‪ ،‬متغیر ‪ total‬هم جمع همه نمرات را نشان میدهد‪ .‬در خط ‪ 50‬معدل دانش آموز نشان داده‬
‫میشود‪ .‬معدل از تقسیم کردن ‪( total‬جمع) بر تعداد نمرات به دست میآید‪ .‬از ‪ studentGrades[student].length‬هم‬
‫برای به دست آوردن تعداد نمرات استفاده میشود‪.‬‬
‫آرایه دندانه دار‬
‫آرایه دندانه دار یا ‪ jagged array‬آرایه ای چند بعدی است که دارای سطرهای با طول متغیر میباشد‪ .‬نمونه ساده ای از آرایههای‬
‫چند بعدی‪ ،‬آرایههای مستطیلی است که تعداد ستونها و سطرهای آنها برابر است‪ .‬اما آرایههای دندانه دار دارای سطرهای‬
‫(آرایههای) با طول متفاوت میباشند‪ .‬بنابر این آرایههای دندانه دار را میتوان آرایه ای از آرایهها فرض کرد‪ .‬دستور نوشتن این‬
‫نوع آرایهها به صورت زیر است‪:‬‬
‫;‪datatype[][] arrayName‬‬
‫ابتدا ‪ datatype‬که نوع آرایه است و سپس چهار کروشه باز و بسته و بعد از آن نام آرایه را مینویسیم‪ .‬مقداردهی به این آرایهها‬
‫کمی گیج کننده است‪ .‬به مثال زیر توجه کنید‪:‬‬

‫‪۵۵1‬‬ ‫مبانی زبان جاوا‬
‫;][]‪int[][] myArrays = new int[3‬‬
‫;]‪myArrays[0] = new int[3‬‬

‫در کد باال سه آرایه تعریف شده است که اندیس آنها از صفر شروع میشود‪ .‬اعداد ‪ 1‬و ‪ 1‬و ‪ 5‬هم به تعداد عناصری که هر کدام از‬
‫آنها در خود میتوانند جای دهند اشاره دارند‪ .‬برای مقداردهی هر آرایه هم باید ابتدا اندیس آرایه و سپس اندیس عناصر آن را‬
‫بنویسیم‪ .‬مثال مقداردهی اولین عنصر اولین آرایه مثال باال به صورت زیر عمل میکنیم‪:‬‬
‫;‪myArrays[0][0] = 1‬‬
‫و برای مثال دومین عنصر دومین آرایه هم به صورت زیر‪:‬‬
‫;‪myArrays[1][1] = 4‬‬
‫شکل زیر هم اندیس عناصر آرایه ای که در باال تعریف کردهایم را نشان میدهد‪:‬‬
‫با توجه به توضیحاتی که داده شد میتوان عناصر آرایه ای که در ابتدای درس ایجاد کردیم را به صورت زیر مقداردهی کرد‪:‬‬
‫;‪myArrays[0][0] = 1‬‬
‫;‪myArrays[0][1] = 2‬‬
‫;‪myArrays[0][2] = 3‬‬
‫]‪myArrays[1][0‬‬ ‫=‬ ‫;‪5‬‬

‫]‪myArrays[1][1‬‬ ‫=‬ ‫;‪4‬‬
‫]‪myArrays[1][2‬‬ ‫=‬ ‫;‪3‬‬
‫]‪myArrays[1][3‬‬ ‫=‬ ‫;‪2‬‬
‫]‪myArrays[1][4‬‬ ‫=‬ ‫;‪1‬‬
‫;‪myArrays[2][0] = 11‬‬
‫;‪myArrays[2][1] = 22‬‬
‫یک روش بهتر برای مقدار دهی آرایههای دندانه دار به صورت زیر است که در آن میتوان طول سطرها را هم مشخص نکرد‪:‬‬
‫;}}‪int[][] myArrays = {{1,2,3}, {5,4,3,2,1}, {11,22‬‬
‫برای دسترسی به مقدار عناصر یک آرایه دندانه دار باید اندیس سطر و ستون آن را در اختیار داشته باشیم‬
‫(]‪:)array[row][column‬‬
‫;)]‪System.out.println(myArrays[1][2‬‬
‫نمیتوان از حلقه ‪ foreach‬برای دسترسی به عناصر آرایه دندانه دار استفاده کرد‪:‬‬
‫)‪for(int array : myArrays‬‬

‫{‬
‫;)‪System.out.println(array‬‬
‫}‬
‫اگر از حلقه ‪ foreach‬استفاده کنیم با خطا مواجه میشویم چون عناصر این نوع آرایهها‪ ،‬آرایه هستند نه عدد یا رشته یا… ‪ .‬برای‬
‫حل این مشکل باید نوع متغیر موقتی )‪ (array‬را تغییر داده و از حلقه ‪ foreach‬دیگری برای دسترسی به مقادیر استفاده کرد‪.‬‬
‫)‪for(int[] array : myArrays‬‬

‫{‬
‫)‪for(int number : array‬‬
‫{‬
‫}‬
‫}‬
‫همچنین میتوان از یک حلقه ‪ for‬تو در تو به صورت زیر استفاده کرد‪:‬‬
‫)‪for (int row = 0; row < myArrays.length; row++‬‬

‫{‬
‫)‪for (int col = 0; col < myArrays[row].length; col++‬‬
‫{‬
‫;)]‪System.out.println(myArrays[row][col‬‬
‫}‬
‫}‬
‫در اولین حلقه از ‪ length‬برای به دست آوردن تعداد سطرها (که همان آرایههای یک بعدی هستند) و در دومین حلقه از‬
‫‪ length‬برای به دست آوردن عناصر سطر جاری استفاده میشود‪.‬‬

‫‪۵۵۹‬‬ ‫مبانی زبان جاوا‬
‫متد‬
‫متدها به شما اجازه میدهند که یک رفتار یا وظیفه را تعریف کنید و مجموعه ای از کدها هستند که در هر جای برنامه میتوان از‬
‫آنها استفاده کرد‪.‬متدها دارای آرگومانهایی هستند که وظیفه متد را مشخص میکنند‪ .‬متد در داخل کالس تعریف میشود‪.‬‬
‫نمیتوان یک متد را در داخل متد دیگر تعریف کرد‪ .‬وقتی که شما در برنامه یک متد را صدا میزنید برنامه به قسمت تعریف متد‬
‫رفته و کدهای آن را اجرا میکند‪ .‬در جاوا متدی وجود دارد که نقطه آغاز هر برنامه است و بدون آن برنامهها نمیدانند با ید از کجا‬
‫شروع شوند‪ ،‬این متد )(‪ main‬نام دارد‪ .‬پارامترها همان چیزهایی هستند که متد منتظر دریافت آنها است‪ .‬آرگومانها مقادیری‬
‫هستند که به پارامترها ارسال میشوند‪ .‬گاهی اوقات دو کلمه پارامتر و آرگومان به یک منظور به کار میروند‪ .‬سادهترین ساختار یک‬
‫متد به صورت زیر است‪:‬‬
‫)(‪returnType MethodName‬‬
‫{‬
‫}‬
‫به برنامه ساده زیر توجه کنید‪ .‬در این برنامه از یک متد برای چاپ یک پیغام در صفحه نمایش استفاده شده است‪:‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬ ‫)(‪static void PrintMessage‬‬
‫‪6‬‬ ‫{‬
‫‪8‬‬ ‫}‬
‫‪9‬‬
‫‪11‬‬ ‫{‬
‫‪12‬‬ ‫;)(‪PrintMessage‬‬
‫‪13‬‬ ‫}‬
‫‪14‬‬ ‫}‬
‫!‪Hello World‬‬
‫در خطوط ‪ 1-0‬یک متد تعریف کردهایم‪ .‬مکان تعریف آن در داخل کالس مهم نیست‪ .‬به عنوان مثال میتوانید آن را زیر متد‬
‫)(‪ main‬تعریف کنید‪ .‬میتوان این متد را در داخل متد دیگر صدا زد (فراخوانی کرد)‪ .‬متد دیگر ما در اینجا متد )(‪ main‬است که‬
‫میتوانیم در داخل آن نام متدی که برای چاپ یک پیغام تعریف کردهایم (یعنی متد )(‪ )PrintMessage‬را صدا بزنیم‪ .‬متد‬
‫)(‪ main‬به صورت ‪ static‬تعریف شده است‪ .‬برای اینکه بتوان از متد )(‪ PrintMessage‬در داخل متد )(‪ main‬استفاده کنیم‬
‫باید آن را به صورت ‪ static‬تعریف کنیم‪ .‬کلمه ‪ static‬به طور ساده به این معناست که میتوان از متد استفاده کرد بدون‬
‫اینکه از کالس نمونه ای ساخته شود‪ .‬متد )(‪ main‬همواره باید به صورت ‪ static‬تعریف شود چون برنامه فورا و بدون نمونه‬
‫سازی از کالس از آن استفاده میکند‪ .‬وقتی به مبحث برنامه نویسی شیء گرا رسیدید به طور دقیق کلمه ‪ static‬مورد بحث قرار‬
‫به‬ ‫میگیرد‪ .‬برنامه ‪( class‬مثال باال) زمانی اجرا میشود که برنامه دو متدی را که تعریف کردهایم را اجرا کند و متد )(‪main‬‬
‫صورت ‪ static‬تعریف شود‪ .‬در باره این کلمه کلیدی در درسهای آینده مطالب بیشتری میآموزیم‪.‬‬
‫در تعریف متد باال بعد از کلمه ‪ static‬کلمه کلیدی ‪ void‬آمده است که نشان دهنده آن است که متد مقدار برگشتی ندارد‪ .‬در‬
‫درس آینده در مورد مقدار برگشتی از یک متد و استفاده از آن برای اهداف مختلف توضیح داده خواهد شد‪ .‬نام متد ما‬
‫)(‪ PrintMessage‬است‪ .‬به این نکته توجه کنید که در نامگذاری متد از روش پاسکال (حرف اول هر کلمه بزرگ نوشته میشود)‬
‫استفاده کردهایم‪ .‬این روش نامگذاری قراردادی است و میتوان از این روش استفاده نکرد‪ ،‬اما پیشنهاد میشود که از این روش‬
‫برای تشخیص متدها استفاده کنید‪.‬‬
‫بهتر است در نامگذاری متدها از کلماتی استفاده شود که کاران متد را مشخص میکند مثال نامهایی مانند ‪ GoToBed‬یا ‪OpenDoor‬‬
‫‪ .‬همچنین به عنوان مثال اگر مقدار برگشتی متد یک مقدار بولی باشد میتوانید اسم متد خود را به صورت یک کلمه سوالی انتخاب‬
‫کنید‪ ،‬مانند ‪ IsLeapyear‬یا ‪ ،IsTeenager‬ولی از گذاشتن عالمت سؤال در آخر اسم متد خودداری کنید‪ .‬دو پرانتزی که بعد از نام‬
‫میآید نشان دهنده آن است که نام متعلق به یک متد است‪ .‬در این مثال در داخل پرانتزها هیچ چیزی نوشته نشده چون پارامتری‬
‫ندارد‪ .‬در درسهای آینده در مورد متدها بیشتر توضیح میدهیم‪.‬‬
‫بعد از پرانتزها دو آکوالد قرار میدهیم که بدنه متد را تشکیل میدهد و کدهایی را که میخواهیم اجرا شوند را در داخل این‬
‫آکوالدها مینویسیم‪ .‬در داخل متد )(‪ main‬متدی را که در خط ‪ 35‬ایجاد کردهایم را صدا میزنیم‪ .‬برای صدا زدن یک متد کافیست‬
‫نام آن را نوشته و بعد از نام پرانتزها را قرار دهیم‪ .‬اگر متد دارای پارامتر باشد باید شما آراگومانها را به ترتیب در داخل پرانتزها قرار‬
‫دهید‪ .‬در این مورد نیز در درسهای آینده توضیح بیشتری میدهیم‪ .‬با صدا زدن یک متد کدهای داخل بدنه آن اجرا میشوند‪.‬‬
‫برای اجرای متد )(‪ PrintMessage‬برنامه از متد )(‪ main‬به محل تعریف متد )(‪ PrintMessage‬میرود‪ .‬مثال وقتی ما متد‬
‫)(‪ PrintMessage‬را در خط ‪ 35‬صدا میزنیم برنامه از خط ‪ 35‬به خط ‪ ،1‬یعنی جایی که متد تعریف شده میرود‪ .‬اکنون ما یک متد‬
‫در برنامه ‪ class‬داریم و همه متدهای این برنامه میتوانند آن را صدا بزنند‪.‬‬
‫‪۵1۵‬‬ ‫مبانی زبان جاوا‬
‫مقدار برگشتی از یک متد‬
‫متدها میتوانند مقدار برگشتی از هر نوع داده ای داشته باشند‪ .‬این مقادیر میتوانند در محاسبات یا به دست آوردن یک داده‬
‫مورد استفاده قرار بگیرند‪ .‬در زندگی روزمره فرض کنید که کارمند شما یک متد است و شما او را صدا میزنید و از او میخواهید که‬
‫کار یک سند را به پایان برساند‪ .‬سپس از او میخواهید که بعد از اتمام کارش سند را به شما تحویل دهد‪ .‬سند همان مقدار برگشتی‬
‫متد است‪ .‬نکته مهم در مورد یک متد‪ ،‬مقدار برگشتی و نحوه استفاده شما از آن است‪ .‬برگشت یک مقدار از یک متد آسان است‪.‬‬
‫کافیست در تعریف متد به روش زیر عمل کنید‪:‬‬
‫)(‪returnType MethodName‬‬
‫{‬
‫;‪return value‬‬
‫}‬
‫‪ returnType‬در اینجا نوع داده ای مقدار برگشتی را مشخص میکند (‪ .)…،bool ،int‬در داخل بدنه متد کلمه کلیدی ‪ return‬و‬
‫بعد از آن یک مقدار یا عبارتی که نتیجه آن یک مقدار است را مینویسیم‪ .‬نوع این مقدار برگشتی باید از انواع ساده بوده و در‬
‫هنگام نامگذاری متد و قبل از نام متد ذکر شود‪ .‬اگر متد ما مقدار برگشتی نداشته باشد باید از کلمه ‪ void‬قبل از نام متد استفاده‬
‫کنیم‪ .‬مثال زیر یک متد که دارای مقدار برگشتی است را نشان میدهد‪.‬‬

‫‪2‬‬
‫‪4‬‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫)(‪static int CalculateSum‬‬
‫‪8‬‬ ‫{‬
‫‪9‬‬ ‫;‪int firstNumber = 10‬‬
‫‪10‬‬ ‫;‪int secondNumber = 5‬‬
‫‪11‬‬
‫‪12‬‬ ‫;‪int sum = firstNumber + secondNumber‬‬
‫‪13‬‬
‫‪14‬‬ ‫;‪return sum‬‬
‫‪15‬‬ ‫}‬
‫‪16‬‬
‫‪18‬‬ ‫{‬
‫‪19‬‬ ‫;)(‪int result = CalculateSum‬‬
‫‪20‬‬
‫‪21‬‬ ‫;))‪System.out.println(MessageFormat.format("Sum is {0}.", result‬‬
‫‪22‬‬ ‫}‬
‫‪23‬‬ ‫}‬
‫‪Sum is 15.‬‬
‫همانطور که در خط ‪ 1‬مثال فوق مشاهده میکنید هنگام تعریف متد از کلمه ‪ int‬به جای ‪ void‬استفاده کردهایم که نشان دهنده‬
‫آن است که متد ما دارای مقدار برگشتی از نوع اعداد صحیح است‪ .‬در خطوط ‪ 6‬و ‪ 33‬دو متغیر تعریف و مقدار دهی شدهاند‪.‬‬
‫توجه کنید که این متغیرها‪ ،‬متغیرهای محلی هستند‪ .‬و این بدان معنی است که این متغیرها در سایر متدها مانند متد )(‪ main‬قابل‬
‫دسترسی نیستند و فقط در متدی که در آن تعریف شدهاند قابل استفاده هستند‪ .‬در خط ‪ 35‬جمع دو متغیر در متغیر ‪ sum‬قرار‬
‫میگیرد‪ .‬در خط ‪ 33‬مقدار برگشتی ‪ sum‬توسط دستور ‪ return‬فراخوانی میشود‪ .‬در داخل متد )(‪ main‬یک متغیر به نام‬
‫‪ result‬در خط ‪ 36‬تعریف میکنیم و متد )(‪ CalculateSum‬را فراخوانی میکنیم‪.‬‬
‫متد )(‪ CalculateSum‬مقدار ‪ 31‬را بر میگرداند که در داخل متغیر ‪ result‬ذخیره میشود‪ .‬در خط ‪ 53‬مقدار ذخیره شده در متغیر‬
‫‪ result‬چاپ میشود‪ .‬متدی که در این مثال ذکر شد متد کاربردی و مفیدی نیست‪ .‬با وجودیکه کدهای زیادی در متد باال نوشته‬
‫شده ولی همیشه مقدار برگشتی ‪ 31‬است‪ ،‬در حالیکه میتوانستیم به راحتی یک متغیر تعریف کرده و مقدار ‪ 31‬را به آن اختصاص‬
‫دهیم‪ .‬این متد در صورتی کارآمد است که پارامترهایی به آن اضافه شود که در درسهای آینده توضیح خواهیم داد‪ .‬هنگامی که‬
‫میخواهیم در داخل یک متد از دستور ‪ if‬یا ‪ switch‬استفاده کنیم باید تمام کدها دارای مقدار برگشتی باشند‪ .‬برای درک بهتر‬
‫این مطلب به مثال زیر توجه کنید‪:‬‬

‫‪2‬‬
‫‪5‬‬
‫‪7‬‬ ‫{‬
‫‪8‬‬ ‫)(‪static int GetNumber‬‬
‫‪9‬‬ ‫{‬
‫‪11‬‬
‫‪12‬‬ ‫;‪int number‬‬
‫‪13‬‬
‫‪14‬‬ ‫;)" ‪System.out.print("Enter a number greater than 10:‬‬
‫‪15‬‬ ‫;)(‪number = input.nextInt‬‬
‫‪16‬‬
‫‪17‬‬ ‫)‪if (number > 10‬‬
‫‪18‬‬ ‫{‬
‫‪19‬‬ ‫;‪return number‬‬
‫‪20‬‬ ‫}‬
‫‪21‬‬ ‫‪else‬‬
‫‪22‬‬ ‫{‬
‫‪23‬‬ ‫;‪return 0‬‬
‫‪24‬‬ ‫}‬
‫‪۵1۳‬‬ ‫مبانی زبان جاوا‬
‫‪25‬‬ ‫}‬
‫‪26‬‬
‫‪28‬‬ ‫{‬
‫‪29‬‬ ‫;)(‪int result = GetNumber‬‬
‫‪30‬‬
‫‪31‬‬ ‫;))‪System.out.println(MessageFormat.format("Result = {0}.", result‬‬
‫‪32‬‬ ‫}‬
‫‪33‬‬ ‫}‬
‫‪Enter a number greater than 10: 11‬‬

‫‪Result = 11‬‬
‫‪Enter a number greater than 10: 9‬‬
‫‪Result = 0‬‬
‫در خطوط ‪ 0-51‬یک متد با نام )(‪ GetNumber‬تعریف شده است که از کاربر یک عدد بزرگتر از ‪ 33‬را میخواهد‪ .‬اگر عدد وارد شده‬
‫توسط کاربر درست نباشد متد مقدار صفر را بر میگرداند‪ .‬و اگر قسمت ‪ else‬دستور ‪ if‬و یا دستور ‪ return‬را از آن حذف کنیم‬
‫در هنگام اجرای برنامه با پیغام خطا مواجه میشویم‪.‬‬
‫چون اگر شرط دستور ‪ if‬نادرست باشد (کاربر مقداری کمتر از ‪ 33‬را وارد کند) برنامه به قسمت ‪ else‬میرود تا مقدار صفر را‬
‫برگرداند و چون قسمت ‪ else‬حذف شده است برنامه با خطا مواجه میشود و همچنین اگر دستور ‪ return‬حذف شود چون‬
‫برنامه نیاز به مقدار برگشتی دارد پیغام خطا میدهد‪.‬‬
‫پارامتر و آرگومان‬
‫پارامترها دادههای خامی هستند که متد آنها را پردازش میکند و سپس اطالعاتی را که به دنبال آن هستید در اختیار شما قرار‬
‫میدهد‪ .‬فرض کنید پارامترها مانند اطالعاتی هستند که شما به یک کارمند میدهید که بر طبق آنها کارش را به پایان برساند‪ .‬یک‬
‫متد میتواند هر تعداد پارامتر داشته باشد‪ .‬هر پارامتر میتواند از انواع مختلف داده باشد‪ .‬در زیر یک متد با ‪ N‬پارامتر نشان داده‬
‫شده است‪:‬‬
‫)‪returnType MethodName(datatype param1, datatype param2, ... datatype paramN‬‬

‫{‬
‫}‬
‫پارامترها بعد از نام متد و بین پرانتزها قرار میگیرند‪ .‬بر اساس کاری که متد انجام میدهد میتوان تعداد پارامترهای زیادی به متد‬
‫اضافه کرد‪ .‬بعد از فراخوانی یک متد باید آرگومانهای آن را نیز تأمین کنید‪ .‬آرگومانها مقادیری هستند که به پارامترها اختصاص‬
‫داده میشوند‪ .‬ترتیب ارسال آرگومانها به پارامترها مهم است‪ .‬عدم رعایت ترتیب در ارسال آرگومانها باعث به وجود آمدن خطای‬
‫منطقی و خطای زمان اجرا میشود‪ .‬اجازه بدهید که یک مثال بزنیم‪:‬‬

‫‪2‬‬
‫‪5‬‬
‫‪7‬‬ ‫{‬
‫‪8‬‬ ‫)‪static int CalculateSum(int number1, int number2‬‬
‫‪9‬‬ ‫{‬
‫‪10‬‬ ‫;‪return number1 + number2‬‬
‫‪11‬‬ ‫}‬
‫‪12‬‬
‫‪14‬‬ ‫{‬
‫‪16‬‬ ‫;‪int num1, num2‬‬
‫‪17‬‬
‫‪18‬‬ ‫;)" ‪System.out.print("Enter the first number:‬‬
‫‪19‬‬ ‫;)(‪num1 = input.nextInt‬‬
‫‪20‬‬ ‫;)" ‪System.out.print("Enter the second number:‬‬
‫‪21‬‬ ‫;)(‪num2 = input.nextInt‬‬
‫‪22‬‬
‫‪23‬‬ ‫;)))‪System.out.println(MessageFormat.format("Sum = {0}", CalculateSum(num1, num2‬‬
‫‪24‬‬ ‫}‬
‫‪25‬‬ ‫}‬
‫‪Enter the first number: 10‬‬

‫‪Enter the second number: 5‬‬
‫‪Sum = 15‬‬
‫در برنامه باال یک متد به نام )(‪( CalculateSum‬خطوط ‪ )0-33‬تعریف شده است که وظیفه آن جمع مقدار دو عدد است‪ .‬چون‬
‫این متد مقدار دو عدد صحیح را با هم جمع میکند پس نوع برگشتی ما نیز باید ‪ int‬باشد‪ .‬متد دارای دو پارامتر است که اعداد‬
‫را به آنها ارسال میکنیم‪ .‬به نوع داده ای پارامترها توجه کنید‪ .‬هر دو پارامتر یعنی ‪ number1‬و ‪ number2‬مقادیری از نوع اعداد‬
‫صحیح )‪ (int‬دریافت میکنند‪ .‬در بدنه متد دستور ‪ return‬نتیجه جمع دو عدد را بر میگرداند‪ .‬در داخل متد )(‪ main‬برنامه از‬
‫کاربر دو مقدار را درخواست میکند و آنها را داخل متغیرها قرار میدهد‪ .‬حال متد را که آرگومانهای آن را آماده کردهایم فراخوانی‬
‫میکنیم‪ .‬مقدار ‪ num1‬به پارامتر اول و مقدار ‪ num2‬به پارامتر دوم ارسال میشود‪ .‬حال اگر مکان دو مقدار را هنگام ارسال به متد‬
‫تغییر دهیم (یعنی مقدار ‪ num2‬به پارامتر اول و مقدار ‪ num1‬به پا رامتر دوم ارسال شود) هیچ تغییری در نتیجه متد ندارد چون‬
‫جمع خاصیت جابه جایی دارد‪.‬‬

‫‪۵1۱‬‬ ‫مبانی زبان جاوا‬
‫فقط به یاد داشته باشید که باید ترتیب ارسال آرگومانها هنگام فراخوانی متد دقیقا با ترتیب قرار گیری پارامترها تعریف شده در‬
‫متد مطابقت داشته باشد‪ .‬بعد از ارسال مقادیر ‪ 33‬و ‪ 1‬به پارامترها‪ ،‬پارامترها آنها را دریافت میکنند‪ .‬به این نکته نیز توجه کنید‬
‫که نام پارامترها طبق قرارداد به شیوه کوهان شتری یا ‪( camelCasing‬حرف اول دومین کلمه بزرگ نوشته میشود) نوشته میشود‪.‬‬
‫در داخل بدنه متد (خط ‪ )33‬دو مقدار با هم جمع میشوند و نتیجه به متد فراخوان (متدی که متد )(‪ CalculateSum‬را فراخوانی‬
‫میکند) ارسال میشود‪ .‬در درس آینده از یک متغیر برای ذخیره نتیجه محاسبات استفاده میکنیم ولی در اینجا مشاهده میکنید‬
‫که میتوان به سادگی نتیجه جمع را نشان داد (خط ‪ .)33‬در داخل متد )(‪ main‬از ما دو عدد که قرار است با هم جمع شوند‬
‫درخواست میشود‪.‬‬
‫در خط ‪ 51‬متد )(‪ CalculateSum‬را فراخوانی میکنیم و دو مقدار صحیح به آن ارسال میکنیم‪ .‬دو عدد صحیح در داخل متد با‬
‫هم جمع شده و نتیجه آنها برگردانده میشود‪ .‬مقدار برگشت داده شده از متد به وسیله متد )(‪ format‬از کالس ‪MessageFormat‬‬
‫نمایش داده میشود (خط ‪ .)51‬در برنامه زیر یک متد تعریف شده است که دارای دو پارامتر از دو نوع داده ای مختلف است‪:‬‬

‫‪2‬‬
‫‪4‬‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫)‪static void ShowMessageAndNumber(String message, int number‬‬
‫‪8‬‬ ‫{‬
‫‪9‬‬ ‫;)‪System.out.println(message‬‬
‫‪10‬‬ ‫;))‪System.out.println(MessageFormat.format("Number = {0}", number‬‬
‫‪11‬‬ ‫}‬
‫‪12‬‬
‫‪14‬‬ ‫{‬
‫‪15‬‬ ‫;)‪ShowMessageAndNumber("Hello World!", 100‬‬
‫‪16‬‬ ‫}‬
‫‪17‬‬ ‫}‬
‫‪Number = 100‬‬
‫در مثال باال یک متدی تعریف شده است که اولین پارامتر آن مقداری از نوع رشته و دومین پارامتر آن مقداری از نوع ‪ int‬دریافت‬
‫میکند‪ .‬متد به سادگی دو مقداری که به آن ارسال شده است را نشان میدهد‪ .‬در خط ‪ 31‬متد را اول با یک رشته و سپس یک عدد‬
‫خاص فراخوانی میکنیم ‪ .‬حال اگر متد به صورت زیر فراخوانی میشد‪:‬‬
‫;)"!‪ShowMessageAndNumber(100, "Welcome to Gimme JAVA‬‬

‫در برنامه خطا به وجود میآمد چون عدد ‪ 333‬به پارامتری از نوع رشته و رشته !‪ Hello World‬به پارامتری از نوع اعداد صحیح‬
‫ارسال میشد‪.‬این نشان میدهد که ترتیب ارسال آرگومانها به پارامترها هنگام فراخوانی متد مهم است‪ .‬به مثال ‪ 3‬توجه کنید در‬
‫آن مثال دو عدد از نوع ‪ int‬به پارامترها ارسال کردیم که ترتیب ارسال آنها چون هردو پارامتر از یک نوع بودند مهم نبود‪ .‬ولی‬
‫اگر پارامترهای متد دارای اهداف خاصی باشند ترتیب ارسال آرگومانها مهم است‪.‬‬
‫)‪void ShowPersonStats(int age, int height‬‬

‫{‬
‫;))‪System.out.println(MessageFormat.format("Age = {0}", age‬‬
‫;))‪System.out.println(MessageFormat.format("Height = {0}", height‬‬
‫}‬
‫‪//Using the proper order of arguments‬‬

‫;)‪ShowPersonStats(20, 160‬‬
‫‪//Acceptable, but produces odd results‬‬

‫;)‪ShowPersonStats(160, 20‬‬
‫در مثال باال نشان داده شده است که حتی اگر متد دو آرگومان با یک نوع داده ای قبول کند باز هم بهتر است ترتیب بر اساس‬
‫تعریف پارامترها رعایت شود‪ .‬به عنوان مثال در اولین فراخوانی متد باال اشکالی به چشم نمیآید چون سن شخص ‪ 53‬و قد او ‪313‬‬
‫سانتی متر است‪ .‬اگر آرگومانها را به ترتیب ارسال نکنیم سن شخص ‪ 313‬و قد او ‪ 53‬سانتی متر میشود که به واقعیت نزدیک‬
‫نیست‪ .‬دانستن مبانی مقادیر برگشتی و ارسال آرگومانها باعث میشود که شما متدهای کارآمد تری تعریف کنید‪ .‬تکه کد زیر‬
‫نشان میدهد که شما حتی میتوانید مقدار برگشتی از یک متد را به عنوان آرگومان به متد دیگر ارسال کنید‪.‬‬
‫)(‪int MyMethod‬‬
‫{‬
‫;‪return 5‬‬
‫}‬
‫)‪void AnotherMethod(int number‬‬

‫{‬
‫}‬
‫‪// Codes skipped for demonstration‬‬
‫;))(‪AnotherMethod(MyMethod‬‬
‫چون مقدار برگشتی متد )(‪ MyMethod‬عدد ‪ 1‬است و به عنوان آرگومان به متد )(‪ AnotherMethod‬ارسال میشود خروجی کد‬
‫باال هم عدد ‪ 1‬است‪.‬‬
‫ارسال آرگومان به روش مقدار‬

‫ارسال آرگومانها به روش مقدار بدان معناست که شما یک کپی از مقدار متغیر را ارسال میکنید نه اصل متغیر یا ارجاع به آن را‪.‬‬
‫در این حالت وقتی که آرگومان ارسال شده را در داخل متد اصالح میکنیم مقدار اصلی آرگومان در خارج از متد تغییر نمیکند‪ .‬اجازه‬
‫دهید که ارسال با مقدار آرگومان را با یک مثال توضیح دهیم‪:‬‬

‫‪2‬‬
‫‪4‬‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫)‪static void ModifyNumberVal(int number‬‬
‫‪8‬‬ ‫{‬
‫‪9‬‬ ‫;‪number += 10‬‬
‫‪10‬‬ ‫(‪System.out.println‬‬
‫‪11‬‬ ‫;))‪MessageFormat.format("Value of number inside method is {0}.", number‬‬
‫‪12‬‬ ‫}‬
‫‪13‬‬
‫‪15‬‬ ‫{‬
‫‪16‬‬ ‫;‪int num = 5‬‬
‫‪17‬‬ ‫;))‪System.out.println(MessageFormat.format("num = {0}\n",num‬‬
‫‪18‬‬
‫‪19‬‬ ‫;)"‪System.out.println("Passing num by value to method ModifyNumberVal() ...‬‬
‫‪20‬‬ ‫;)‪ModifyNumberVal(num‬‬
‫‪21‬‬ ‫(‪System.out.println‬‬
‫‪22‬‬ ‫;))‪MessageFormat.format("Value of num after exiting the method is {0}", num‬‬
‫‪23‬‬ ‫}‬
‫‪24‬‬ ‫}‬
‫‪num = 5‬‬
‫‪Passing num by value to method ModifyNumberVal() ...‬‬

‫‪Value of number inside method is 15.‬‬
‫‪Value of num after exiting the method is 5.‬‬
‫در برنامه باال متدی تعریف شده است که کار آن اضافه کردن عدد ‪ 33‬به مقداری است که به آنها ارسال میشود (خطوط ‪ .)1-33‬این‬
‫متد دارای یک پارامتر است که نیاز به یک مقدار آرگومان (از نوع ‪ )int‬دارد‪ .‬وقتی که متد را صدا میزنیم و آرگومانی به آن اختصاص‬
‫میدهیم (خط ‪ ،)36‬کپی آرگومان به پارامتر متد ارسال میشود‪ .‬بنابراین مقدار اصلی متغیر خارج از متد هیچ ارتباطی به پارامتر متد‬
‫ندارد‪ .‬سپس مقدار ‪ 33‬را به متغیر پارامتر )‪ (number‬اضافه کرده و نتیجه را چاپ میکنیم‪ .‬برای اثبات اینکه متغیر ‪ num‬هیچ تغییری‬
‫نکرده است مقدار آن را یکبار قبل از ارسال به متد (خط ‪ )31‬و بار دیگر بعد از ارسال به متد (خط ‪ )53‬چاپ کرده و مشاهده میکنیم‬
‫که تغییر ی نکرده است ‪.‬‬
‫ارسال آرایه به عنوان آرگومان‬

‫میتوان آرایهها را به عنوان آرگومان به متد ارسال کرد‪ .‬ابتدا شما باید پارامترهای متد را طوری تعریف کنید که آرایه دریافت کنند‪.‬‬
‫به مثال زیر توجه کنید‪.‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬ ‫)‪static void TestArray(int[] numbers‬‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫)‪for(int number : numbers‬‬
‫‪8‬‬ ‫{‬
‫‪9‬‬ ‫;)‪System.out.println(number‬‬
‫‪10‬‬ ‫}‬
‫‪11‬‬ ‫}‬
‫‪12‬‬
‫‪14‬‬ ‫{‬
‫‪15‬‬ ‫;} ‪int[] array = { 1, 2, 3, 4, 5‬‬
‫‪16‬‬ ‫;)‪TestArray(array‬‬
‫‪17‬‬ ‫}‬
‫‪18‬‬ ‫}‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪5‬‬
‫مشاهده کردید که به سادگی میتوان با گذاشتن کروشه بعد از نوع داده ای پارامتر یک متد ایجاد کرد که پارامتر آن‪ ،‬آرایه دریافت‬
‫میکند‪ .‬وقتی متد در خط ‪ 31‬فراخوانی میشود ‪ ،‬آرایه را فقط با استفاده از نام آن و بدون استفاده از اندیس ارسال میکنیم‪ .‬پس‬
‫آرایهها به روش ارجاع به متدها ارسال میشوند‪ .‬در خطوط ‪ 1-33‬از حلقه ‪ foreach‬برای دسترسی به اجزای اصلی آرایه که به عوان‬
‫آرگومان به متد ارسال کردهایم استفاده میکنیم‪ .‬در زیر نحوه ارسال یک آرایه به روش ارجاع نشان داده شده است‪.‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬ ‫)‪static void IncrementElements(int[] numbers‬‬
‫‪6‬‬ ‫{‬
‫‪8‬‬ ‫{‬
‫‪9‬‬ ‫;‪numbers[i]++‬‬
‫‪10‬‬ ‫}‬
‫‪11‬‬ ‫}‬
‫‪12‬‬
‫‪14‬‬ ‫{‬
‫‪15‬‬ ‫;} ‪int[] array = { 1, 2, 3, 4, 5‬‬
‫‪16‬‬
‫‪17‬‬ ‫;)‪IncrementElements(array‬‬
‫‪18‬‬
‫‪19‬‬ ‫)‪for (int num : array‬‬
‫‪۵1۹‬‬ ‫مبانی زبان جاوا‬
‫‪20‬‬ ‫{‬
‫‪21‬‬ ‫;)‪System.out.println(num‬‬
‫‪22‬‬ ‫}‬
‫‪23‬‬ ‫}‬
‫‪24‬‬ ‫}‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪5‬‬
‫‪6‬‬
‫برنامه باال یک متد را نشان میدهد که یک آرایه را دریافت میکند و به هر یک از عناصر آن یک واحد اضافه میکند‪ .‬به این نکته‬
‫توجه کنید که از حلقه ‪ foreach‬نمیتوان برای افزایش مقادیر آرایه استفاده کنیم چون این حلقه برای خواندن مقادیر آرایه مناسب‬
‫است نه اصالح آنها‪ .‬در داخل متد ما مقادیر هر یک از اجزای آرایه را افزایش دادهایم‪ .‬سپس از متد خارج شده و نتیجه را نشان‬
‫میدهیم‪ .‬مشاهده میکنید که هر یک از مقادیر اصلی متد هم اصالح شدهاند‪ .‬راه دیگر برای ارسال آرایه به متد‪ ،‬مقدار دهی‬
‫مستقیم به متد فراخوانی شده است‪ .‬به عنوان مثال‪:‬‬
‫;) } ‪IncrementElements( new int[] { 1, 2, 3, 4, 5‬‬
‫در این روش ما آرایه ای تعریف نمیکنیم بلکه مجموعه ای از مقادیر را به پارامتر ارسال میکنیم که آنها را مانند آرایه قبول کند‪ .‬از‬
‫آنجاییکه در این روش آرایه ای تعریف نکردهایم نمیتوانیم در متد )(‪ Main‬نتیجه را چاپ کنیم‪ .‬اگر از چندین پارامتر در متد استفاده‬
‫میکنید‪ ،‬همیشه برای هر یک از پارامترهایی که آرایه قبول میکنند از یک جفت کروشه استفاده کنید‪ .‬به عنوان مثال‪:‬‬
‫)‪void MyMethod(int[] param1, int param2‬‬

‫{‬
‫‪//code here‬‬
‫}‬
‫به پارامترهای متد باال توجه کنید‪ ،‬پارامتر اول )‪ (param1‬آرگومانی از جنس آرایه قبول میکند ولی پارامتر دوم )‪ (param2‬یک‬
‫عدد صحیح‪ .‬حال اگر پارامتر دوم )‪ (param2‬هم آرایه قبول میکرد باید برای آن هم از کروشه استفاده میکردیم‪:‬‬
‫)‪void MyMethod(int[] param1, int[] param2‬‬

‫{‬
‫‪//code here‬‬
‫}‬
‫محدوده متغیر‬
‫متدها در جاوا دارای محدوده هستند‪ .‬محدوده یک متغیر به شما میگوید که در کجای برنامه میتوان از متغیر استفاده کرد و یا‬
‫متغیر قابل دسترسی است‪ .‬به عنوان مثال متغیری که در داخل یک متد تعریف میشود فقط در داخل بدنه متد قابل دسترسی‬
‫است‪ .‬میتوان دو متغیر با نام یکسان در دو متد مختلف تعریف کرد‪ .‬برنامه زیر این ادعا را اثبات میکند‪:‬‬

‫‪2‬‬
‫‪4‬‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫)(‪static void DemonstrateScope‬‬
‫‪8‬‬ ‫{‬
‫‪9‬‬ ‫;‪int number = 5‬‬
‫‪10‬‬
‫‪11‬‬ ‫(‪System.out.println(MessageFormat.format‬‬
‫‪12‬‬ ‫;))‪"number inside method DemonstrateScope() = {0}", number‬‬
‫‪13‬‬ ‫}‬
‫‪14‬‬
‫‪16‬‬ ‫{‬
‫‪17‬‬ ‫;‪int number = 10‬‬
‫‪18‬‬
‫‪19‬‬ ‫;)(‪DemonstrateScope‬‬
‫‪20‬‬
‫‪21‬‬ ‫(‪System.out.println(MessageFormat.format‬‬
‫‪22‬‬ ‫;))‪"number inside the Main method() = {0}", number‬‬
‫‪23‬‬ ‫}‬
‫‪24‬‬ ‫}‬
‫‪number inside method DemonstrateScope() = 5‬‬

‫‪number inside the Main method() = 10‬‬
‫مشاهده میکنید که حتی اگر ما دو متغیر با نام یکسان تعریف کنیم که دارای محدودههای متفاوتی هستند‪ ،‬میتوان به هر کدام‬
‫از آنها مقادیر مختلفی اختصاص داد‪ .‬متغیر تعریف شده در داخل متد )(‪ Main‬در خط ‪ 6‬هیچ ارتباطی به متغیر داخل متد‬
‫)(‪ DemonstrateScope‬در خط ‪ 31‬ندارد‪ .‬وقتی به مبحث کالسها رسیدیم در این باره بیشتر توضیح خواهیم داد‪.‬‬
‫آرگومان های متغیر )‪(VarArgs‬‬
‫آرگومان های متغیر )‪ ،(VarArgs‬در ‪ JDK 5‬اضافه شده است و به شما اجازه می دهد تعداد آرگومان های دلخواه (متغیر ) و البته‬
‫همنوع را به متد ارسال کنید‪ .‬برای ایجاد متدی که به تعداد دلخواه پارامتر دریافت کند از عالمت سه نقطه (…) به صورت زیر استفاده‬
‫می شود‪:‬‬
‫)‪public static void MethodName(int ... argument‬‬

‫‪۵۳۵‬‬ ‫مبانی زبان جاوا‬
‫{‬
‫‪// method body‬‬
‫}‬
‫به مثال زیر توجه کنید‪:‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬ ‫)‪static int CalculateSum(int ... numbers‬‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;‪int total = 0‬‬
‫‪8‬‬
‫‪9‬‬ ‫)‪for (int number : numbers‬‬
‫‪10‬‬ ‫{‬
‫‪11‬‬ ‫;‪total += number‬‬
‫‪12‬‬ ‫}‬
‫‪13‬‬
‫‪14‬‬ ‫;‪return total‬‬
‫‪15‬‬ ‫}‬
‫‪16‬‬
‫‪18‬‬ ‫{‬
‫‪19‬‬ ‫;))‪System.out.println("1 + 2 + 3 = " + CalculateSum(1, 2, 3‬‬
‫‪20‬‬ ‫;))‪System.out.println("1 + 2 + 3 + 4 = " + CalculateSum(1, 2, 3, 4‬‬
‫‪21‬‬ ‫;))‪System.out.println("1 + 2 + 3 + 4 + 5 = " + CalculateSum(1, 2, 3, 4, 5‬‬
‫‪22‬‬ ‫}‬
‫‪23‬‬ ‫}‬
‫‪1 + 2 + 3 = 6‬‬
‫‪1 + 2 + 3 + 4 = 10‬‬
‫‪1 + 2 + 3 + 4 + 5 = 15‬‬
‫همانطور که در مثال باال مشاهده می کنید یک متد به نام )(‪ CalculateSum‬در خط ‪ 1‬تعریف شده است‪ .‬برای اینکه این متد‬
‫تعداد دلخواه پارامتر دریافت کند‪ ،‬از عالمت سه نقطه (…) بعد از نوع داده ای پارامتر آن استفاده شده است‪ .‬در اصل کلمه‬
‫‪ numbers‬یک آرایه است‪ ،‬که وقتی ما آرگومان ها را به متد ارسال می کنیم در این آرایه ذخیره می شوند‪ .‬حال متد را سه بار با‬
‫تعداد مختلف آرگومانها فراخوانی می کنیم و سپس با استفاده از حلقه ‪ foreach‬این آرگومانها را جمع و به متد فراخوان برگشت‬
‫می دهیم‪ .‬وقتی از چندین پارامتر در یک متد استفاده می کنید فقط یکی از آنها باید دارای عالمت سه نقطه )…( بوده و همچنین‬
‫از لحاظ مکانی باید آخرین پارامتر باشد‪ .‬اگر این پارامتر (پارامتری که دارای سه نقطه است) در آخر پارامترهای دیگر قرار نگیرد و یا‬
‫از چندین پارامتر سه نقطه دار استفاده کنید با خطا مواجه می شوید‪ .‬به مثالهای اشتباه و درست زیر توجه کنید‪:‬‬
‫‪void SomeFunction(int ... x, int ... y) //ERROR‬‬
‫‪void SomeFunction(int ... x, int y, int z) //ERROR‬‬
‫‪void SomeFunction(int x, int y, int ... z) //Correct‬‬

‫سربارگذاری متدها‬
‫سربارگذاری متدها به شما اجازه میدهد که چندین متد با نام یکسان تعریف کنید که دارای امضا و تعداد پارامترهای مختلف‬
‫هستند‪ .‬برنامه از روی آرگومانهایی که شما به متد ارسال میکنید به صورت خودکار تشخیص میدهد که کدام متد را فراخوانی‬
‫کردهاید یا کدام متد مد نظر شماست‪ .‬امضای یک متد نشان دهنده ترتیب و نوع پارامترهای آن است‪ .‬به مثال زیر توجه کنید‪:‬‬
‫)‪void MyMethod(int x, double y, string z‬‬
‫که امضای متد باال )‪ MyMethod(int, double, string‬میباشد‪ .‬به این نکته توجه کنید که نوع برگشتی و نام پارامترها شامل‬
‫امضای متد نمیشوند‪ .‬در مثال زیر نمونه ای از سربارگذاری متدها آمده است‪.‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬ ‫)‪static void ShowMessage(double number‬‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;)"‪System.out.println("Double version of the method was called.‬‬
‫‪8‬‬ ‫}‬
‫‪9‬‬
‫‪10‬‬ ‫)‪static void ShowMessage(int number‬‬
‫‪11‬‬ ‫{‬
‫‪12‬‬ ‫;)"‪System.out.println("Integer version of the method was called.‬‬
‫‪13‬‬ ‫}‬
‫‪14‬‬
‫‪16‬‬ ‫{‬
‫‪17‬‬ ‫;)‪ShowMessage(9.99‬‬
‫‪18‬‬ ‫;)‪ShowMessage(9‬‬
‫‪19‬‬ ‫}‬
‫‪20‬‬ ‫}‬
‫‪Double version of the method was called.‬‬

‫‪Integer version of the method was called.‬‬
‫در برنامه باال دو متد با نام مشابه تعریف شدهاند‪ .‬اگر سربارگذاری متد توسط جاوا پشتیبانی نمیشد برنامه زمان زیادی برای انتخاب‬
‫یک متد از بین متدهایی که فراخوانی میشوند الزم داشت‪ .‬رازی در نوع پارامترهای متد نهفته است‪ .‬کمپایلر بین دو یا چند متد‬
‫در صورتی فرق میگذارد که پارامترهای متفاوتی داشته باشند‪ .‬وقتی یک متد را فراخوانی میکنیم‪ ،‬متد نوع آرگومانها را تشخیص‬
‫میدهد‪ .‬در فراخوانی اول (خط ‪ )31‬ما یک مقدار ‪ double‬را به متد )(‪ ShowMessage‬ارسال کردهایم در نتیجه متد‬
‫‪۵۳۳‬‬ ‫مبانی زبان جاوا‬
‫)(‪( ShowMessage‬خطوط ‪ )1-0‬که دارای پارامتری از نوع ‪ double‬اجرا میشود‪ .‬در بار دوم که متد فراخوانی میشود (خط ‪ )30‬ما‬
‫یک مقدار ‪ int‬را به متد )(‪ ShowMessage‬ارسال میکنیم متد )(‪( ShowMessage‬خطوط ‪ )33-31‬که دارای پارامتری از نوع ‪int‬‬
‫است اجرا میشود‪ .‬معنای اصلی سربارگذاری متد همین است که توضیح داده شد‪.‬‬
‫هدف اصل ی از سربارگذاری متدها این است که بتوان چندین متد که وظیفه یکسانی انجام میدهند را تعریف کرد تعداد زیادی از‬
‫متدها در جاوا سربارگذاری میشوند مانند متد )(‪ println‬از کالس ‪ .out‬قبال مشاهده کردید که این متد میتواند یک آرگومان از‬
‫نوع رشته دریافت کند و آن را نمایش دهد‪ ،‬و در حالت دیگر میتواند دو یا چند آرگومان قبول کند‪.‬‬
‫بازگشت)‪(Recursion‬‬
‫بازگشت فرایندی است که در آن متد مدام خود را فراخوانی میکند تا زمانی که به یک مقدار مورد نظر برسد‪ .‬بازگشت یک مبحث‬
‫پیچیده در برنامه نویسی است و تسلط به آن کار راحتی نیست‪ .‬به این نکته هم توجه کنید که بازگشت باید در یک نقطه متوقف‬
‫شود وگرنه برای بی نهایت بار‪ ،‬متد‪ ،‬خود را فراخوانی میکند‪ .‬در این درس یک مثال ساده از بازگشت را برای شما توضیح میدهیم‪.‬‬
‫فاکتوریل یک عدد صحیح مثبت )!‪ (n‬شامل حاصل ضرب همه اعداد مثبت صحیح کوچکتر یا مساوی آن میباشد‪ .‬به فاکتوریل‬
‫عدد ‪ 1‬توجه کنید‪.‬‬
‫‪5! = 5 * 4 * 3 * 2 * 1 = 120‬‬
‫بنابراین برای ساخت یک متد بازگشتی باید به فکر توقف آن هم باشیم‪ .‬بر اساس توضیح بازگشت‪ ،‬فاکتوریل فقط برای اعداد مثبت‬
‫صحیح است‪ .‬کوچکترین عدد صحیح مثبت ‪ 3‬است‪ .‬در نتیجه از این مقدار برای متوقف کردن بازگشت استفاده میکنیم‪.‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬ ‫)‪static long Factorial(int number‬‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫)‪if (number == 1‬‬
‫‪8‬‬ ‫;‪return 1‬‬
‫‪9‬‬
‫‪10‬‬ ‫;)‪return number * Factorial(number - 1‬‬
‫‪11‬‬ ‫}‬
‫‪12‬‬
‫‪14‬‬ ‫{‬
‫‪15‬‬ ‫;))‪System.out.println(Factorial(5‬‬
‫‪16‬‬ ‫}‬
‫‪17‬‬ ‫}‬
‫‪120‬‬
‫متد مقدار بزرگی را بر میگرداند چون محاسبه فاکتوریل میتواند خیلی بزرگ باشد‪ .‬متد یک آرگومان که یک عدد است و میتواند‬
‫در محاسبه مورد استفاده قرار گیرد را میپذیرد‪ .‬در داخل متد یک دستور ‪ if‬مینویسیم و در خط ‪ 1‬می گوییم که اگر آرگومان‬
‫ارسال شده برابر ‪ 3‬باشد سپس مقدار ‪ 3‬را برگردان در غیر اینصورت به خط بعد برو‪ .‬این شرط باعث توقف تکرارها نیز میشود‪ .‬در‬
‫خط ‪ 33‬مقدار جاری متغیر ‪ number‬در عددی یک واحد کمتر از خودش )‪ (number – 1‬ضرب میشود‪ .‬در این خط متد ‪Factorial‬‬
‫خود را فراخوانی میکند و آرگومان آن در این خط همان ‪ number – 1‬است‪ .‬مثال اگر مقدار جاری ‪ number‬برابر ‪ 33‬باشد‪ ،‬یعنی اگر‬
‫ما بخواهیم فاکتوریل عدد ‪ 33‬را به دست بیاوریم آرگومان متد )(‪ Factorial‬در اولین ضرب ‪ 6‬خواهد بود‪ .‬فرایند ضرب تا زمانی‬
‫ادامه مییابد که آرگومان ارسال شده با عدد ‪ 3‬برابر نشود‪ .‬شکل زیر فاکتوریل عدد ‪ 1‬را نشان میدهد‪.‬‬
‫کد باال را به وسیله یک حلقه ‪ for‬نیز میتوان نوشت‪.‬‬
‫;‪factorial = 1‬‬
‫) ‪for ( int counter = number; counter >= 1; counter--‬‬

‫‪factorial *= counter‬‬
‫‪۵۳۱‬‬ ‫مبانی زبان جاوا‬
‫این کد از کد معادل بازگشتی آن آسان تر است‪ .‬از بازگشت در زمینههای خاصی در علوم کامپیوتر استفاده میشود‪ .‬استفاده از‬
‫بازگشت حافظه زیادی اشغال میکند پس اگر سرعت برای شما مهم است از آن استفاده نکنید‪.‬‬
‫شمارش)‪(Enumeration‬‬
‫شمارش راهی برای تعریف دادههایی است که میتوانند مقادیر محدودی که شما از قبل تعریف کردهاید را بپذیرند‪ .‬به عنوان مثال‬
‫شما میخواهید یک متغیر تعریف کنید که فقط مقادیر جهت (جغرافیایی) مانند ‪ north ،west ،east‬و ‪ south‬را در خود ذخیره‬
‫کند‪ .‬ابتدا یک ‪ enumeration‬تعریف میکنید و برای آن یک اسم انتخاب کرده و بعد از آن تمام مقادیر ممکن که میتوانند در‬
‫داخل بدنه آن قرار بگیرند تعریف میکنید‪ .‬به نحوه تعریف یک ‪ enumeration‬توجه کنید‪:‬‬
‫‪enum enumName‬‬
‫{‬
‫‪value1,‬‬
‫‪value2,‬‬
‫‪value3,‬‬
‫‪.‬‬
‫‪.‬‬
‫‪.‬‬
‫‪valueN‬‬
‫}‬
‫ابتدا کلمه کلیدی ‪ enum‬و سپس نام آن را به کار میبریم‪ .‬در جاوا برای نامگذاری ‪ enumeration‬از روش پاسکال استفاده کنید‪.‬‬
‫در بدنه ‪ enum‬مقادیری وجو د دارند که برای هر کدام یک نام در نظر گرفته شده است و به وسیله کاما از هم جدا شدهاند‪ .‬به یک‬
‫مثال توجه کنید‪:‬‬
‫‪enum Direction‬‬
‫{‬
‫‪North,‬‬
‫‪East,‬‬
‫‪South,‬‬
‫‪West‬‬
‫}‬
‫به نحوه استفاده از ‪ enumeration‬در یک برنامه جاوا توجه کنید‪.‬‬

‫‪2‬‬
4
5 enum Direction
6 {
7 North,
8 East,
9 South,
10 West
11 }
12
14 {
16 {
17 Direction myDirection;
18
19 myDirection = Direction.North;
20
21 System.out.println(MessageFormat.format("Direction: {0}", myDirection));
22 }
23 }
Direction: North
‫ این کار باعث‬.‫ را خارج از کالس قرار دادهایم‬enumeration ‫ توجه کنید که‬.‫ تعریف میکنیم‬1-33 ‫ را در خطوط‬enumeration ‫ابتدا‬
‫ را در داخل کالس هم تعریف کرد ولی در‬enumeration ‫ میتوان‬.‫ در سراسر برنامه در دسترس باشد‬enumeration ‫میشود که‬
.‫این صورت فقط در داخل کالس قابل دسترس است‬

{
enum Direction
{
//Code omitted
}

{
//Code omitted
}
}
‫ یک متغیر‬31 ‫ در خط‬.)1-33 ‫ نام چهار جهت جغرافیایی وجود دارد (خطوط‬enumeration ‫ در داخل بدنه‬.‫برنامه را ادامه میدهیم‬
:‫ نحوه تعریف آن به صورت زیر است‬.‫تعریف شده است که مقدار یک جهت را در خود ذخیره میکند‬
enumType variableName;
۵۳1 ‫مبانی زبان جاوا‬
‫ نیز نامی است که برای آن انتخاب‬variableName ‫ یا مسیر) میباشد و‬Direction ‫ نوع داده شمارشی (مثال‬enuType ‫در اینجا‬
‫ برای‬.)36 ‫ اختصاص میدهیم (خط‬myDirection ‫ سپس یک مقدار به متغیر‬.‫ است‬myDirection ‫کردهایم که در مثال قبل‬
:‫اختصاص یک مقدار به صورت زیر عمل میکنیم‬
variable = enumType.value;
‫ به روش زیر‬،‫ میتوان یک متغیر را فورا‬.‫) را مینویسیم‬North ‫ سپس عالمت نقطه و بعد مقدار آن (مثال‬Enumeration ‫ابدا نوع‬
:‫مقدار دهی کرد‬
Direction myDirection = Direction.North;
‫ ها مانند کالسها و اینترفیس ها از انواع‬enum .‫ را چاپم کنیم‬myDirection ‫ مقدار‬println() ‫ با استفاده از‬53 ‫حال در خط‬
‫ میتوان یک عدد‬enum ‫ به هر عضو از یک‬.‫ارجاعی به حساب میآیند و بنابر این میتوانند دارای سازنده و فیلد و متد باشند‬
:‫ به مثال زیر توجه کنید‬.‫اختصاص داد‬
2
3 enum Direction
4 {
5 North(3),
6 East(5),
7 South(7),
8 West(4);
9
10 private final int directionindex;
11
12 Direction(int index)
13 {
14 this.directionindex = index;
15 }
16
17 public int GetDirectionIndex()
18 {
19 return this.directionindex;
20 }
21 }
22
24 {
26 {
27 Direction myDirection = Direction.East;
28 System.out.println(myDirection.GetDirectionIndex());
29 }
30 }
5
‫همانطور که در کد باال مشاهده میکنید یک نوع شمارشی با نام ‪ Direction‬در خطوط ‪ 1-53‬تعریف کردهایم‪ .‬به مقادیر این نوع‬
‫شمارشی در خطوط ‪ 1-0‬مقادیری را اختصاص دادهایم‪ .‬در خط ‪ 33‬یک فیلد با نام ‪ directionindex‬تعریف کردهایم تا مقدار هر‬
‫یک از عناصر شمارشی را که میخواهیم به وسیله سازنده ای که در خطوط ‪ 35-31‬تعریف شده است در آن قرار دهیم‪ .‬برای به دست‬
‫آوردن این مقادیر هم از متد )(‪( GetDirectionIndex‬خطوط ‪ )31-53‬استفاده میکنیم‪ .‬حال فرض کنید میخواهیم مقدار عددی‬
‫که به ‪ East‬اختصاص داده شده است را به دست آوریم‪ .‬برای این کار همانطور که در خط ‪ 51‬مشاهده میکنید ابتدا یک نمونه‬
‫از ‪ Direction‬ایجاد کرده و ‪ Direction.East‬را به آن اختصاص میدهیم‪ ،‬سپس در خط ‪ 50‬با فراخوانی متد‬
‫)(‪ GetDirectionIndex‬مقدار عددی ‪ East‬را به دست میآوریم‪ .‬از همین عدد ‪ 1‬به دست آمده در مثال باال میتوان در‬
‫ساختارهایی مانند ‪ if‬و ‪ switch‬استفاده کرد‪:‬‬
‫;‪Direction myDirection = Direction.East‬‬
‫))(‪switch(myDirection.GetDirectionIndex‬‬
‫{‬
‫;)"!‪case 1 : System.out.println("incorrect‬‬
‫;‪break‬‬
‫;)"‪case 5 : System.out.println("That is Correct.‬‬
‫;‪break‬‬
‫}‬
‫آرگومان های خط فرمان )‪(Command Line Arguments‬‬

‫برای اجرای موفق یک برنامه جاوا باید یک متد مهم به نام متد )(‪ main‬وجود داشته باشد که نقطه آغاز برنامه است‪ .‬این متد‬
‫باید به صورت ‪ public static‬تعریف شود‪ .‬همه ما می دانیم که برای متدها می توان آرگومان ارسال کرد‪ ،‬اما برای متد‬
‫)‪ main(String[] args‬چطور؟ جواب مثبت است‪ .‬شما می توانید از طریق دستور خط فرمان ویندوز یا همان ‪ CMD‬آرگومان‬
‫هایی را برای این متد ارسال کنید‪ .‬برای روشن شدن مطلب یک برنامه کنسول به نام ‪ Sample‬ایجاد کنید‪ ،‬سپس کدهای برنامه را‬
‫به صورت زیر بنویسید ‪:‬‬
‫‪public class Sample‬‬

‫{‬
‫{‬
‫;)]‪System.out.println("First Name is " + args[0‬‬
‫‪۵۳۹‬‬ ‫مبانی زبان جاوا‬
‫‪System.out.println("Last‬‬ ‫;)]‪Name is " + args[1‬‬

‫}‬
‫}‬
‫به پارامتر ‪ args‬توجه کنید‪ .‬در حقیقت این پارامتر یک آرایه رشته ای است که می تواند چندین آرگومان از نوع رشته قبول کند‪.‬‬
‫فایل ‪ Sample.java‬را به یک درایو یا پوشه مشخص که مسیر گیج کننده ای نداشته باشد انتقال دهید‪ .‬در این مثال ما فایل آن‬
‫را مستقیما در درایو ‪ C‬قرار می دهیم‪ .‬حال ‪ CMD‬ویندوز را اجرا کنید‪ ،‬سپس کدهای زیر (خطوط قرمز) را در داخل ‪ CMD‬نوشته و‬
‫دکمه ‪ Enter‬را بزنید ‪:‬‬

‫‪C:\Users\VisualCsharp>cd/‬‬
‫‪C:\>javac Sample.java‬‬
‫‪C:\>java Sample Steven Clark‬‬

‫‪First Name is Steven‬‬
‫‪Last Name is Clark‬‬
‫>\‪C:‬‬
‫همانطور که در کد باال مشاهده می کنید‪ ،‬بعد از نوشتن نام فایل‪ ،‬عبارت ‪ Steven Clark‬را نوشته ایم‪ .‬دو کلمه این عبارت جایگزین‬
‫دو متغیر به نام های ]‪ args[0‬و ]‪ args[1‬که تعریف کرده ایم‪ ،‬می شوند‪ .‬این دو متغیر‪ ،‬به ترتیب خانه های اول و دوم آرایه‬
‫هستند‪ .‬کلمه ‪ Steven‬در متغیر رشته ای ]‪ args[0‬که اولین عنصر آرایه و کلمه ‪ Clark‬را در متغیر رشته ای ]‪ args[1‬که‬
‫دومین عنصر آرایه است ذخیره و سپس با استفاده از متد )(‪ println‬آنها را چاپ می کنیم‪ .‬در حقیقت بسیاری از برنامه ها از‬
‫این تکنیک استفاده می کنند‪ .‬شما می توانید با ارسال آرگومان هایی به متد )(‪ main‬نحوه اجرای برنامه را تغییر دهید‪.‬‬
‫برنامه نویسی شیء گرا)‪(OOP‬‬

‫برنامه نویسی شیء گرا یا ‪ ،Object Oriented Programming‬شامل تعریف کالسها و ساخت اشیاء مانند ساخت اشیاء در دنیای‬
‫واقعی است‪ .‬برای مثال یک ماشین را در نظر بگیرید‪ .‬این ماشین دارای خواصی مانند رنگ‪ ،‬سرعت‪ ،‬مدل‪ ،‬سازنده و برخی خواص‬
‫دیگر است‪ .‬همچنین دارای رفتارها و حرکاتی مانند شتاب و پیچش به چپ و راست و ترمز است‪ .‬اشیاء در جاوا تقلیدی از یک شیء‬
‫مانند ماشین در دنیای واقعی هستند‪ .‬برنامه نویسی شیء گرا با استفاده از کدهای دسته بندی شده کالسها و اشیاء را بیشتر قابل‬
‫کنترل میکند‪.‬‬
‫در ابتدا ما نیاز به تعریف یک کالس برای ایجاد اشیاء مان داریم‪ .‬شیء در برنامه نویسی شیء گراء از روی کالسی که شما تعریف‬
‫کردهاید ایجاد میشود‪ .‬برای مثال نقشه ساختمان شما یک کالس است که ساختمان از روی آن ساخته شده است‪.‬کالس شامل‬
‫خواص یک ساختمان مانند مساحت‪،‬بلندی و مواد مورد استفاده در ساخت خانه میباشد‪ .‬در دنیای واقعی ساختمانها نیز بر اساس‬
‫یک نقشه (کالس) پایه گذاری (تعریف) شدهاند‪ .‬برنامه نویسی شیء گرا یک روش جدید در برنامه نویسی است که بوسیله برنامه‬
‫نویسان مورد استفاده قرار میگیرد و به آنها کمک میکند که برنامههایی با قابلیت استفاده مجدد‪ ،‬خوانا و راحت طراحی کنند‪.‬جاوا‬
‫نیز یک برنامه شیء گراست‪ .‬در درس زیر به شما نحوه تعریف کالس و استفاده از اشیاء آموزش داده خواهد شد‪ .‬همچنین شما با‬
‫دو مفهوم وراثت و چند ریختی که از مباحث مهم در برنامه نویسی شیء گرا هستند در آینده آشنا میشوید‪.‬‬
‫کالس‬
‫کالس به شما اجازه میدهد یک نوع داده ای که توسط کاربر تعریف میشود و شامل فیلدها و خواص )‪ (properties‬و متدها‬
‫است را ایجاد کنید‪ .‬کالس در حکم یک نقشه برای یک شیء میباشد‪ .‬شیء یک چیز واقعی است که از ساختار‪ ،‬خواص و یا رفتارهای‬
‫کالس پیروی میکند‪.‬‬
‫وقتی یک شیء میسازید یعنی اینکه یک نمونه از کالس ساختهاید (در درس ممکن است از کلمات شیء و نمونه به جای هم‬
‫استفاده شود)‪ .‬ابتدا ممکن است فکر کنید که کالسها و ساختارها شبیه هم هستند‪ .‬تفاوت مهم بین این دو این است که کالسها‬
‫از نوع مرجع و ساختارها از نوع داده ای هستند‪ .‬در درسهای آینده این موضوع شرح داده خواهد شد‪ .‬اگر یادتان باشد در بخشهای‬
‫اولیه این آموزش کالسی به نام ‪ MyFirstProgram‬تعریف کردیم که شامل متد )(‪ main‬بود و ذکر شد که این متد نقطه آغاز هر‬
‫برنامه است‪ .‬برای تعریف یک کالس از کلمه کلیدی ‪ class‬به صورت زیر استفاده میشود‪:‬‬
‫‪class ClassName‬‬
‫{‬
‫;‪field1‬‬
‫;‪field2‬‬
‫‪...‬‬
‫;‪fieldN‬‬
‫;‪method1‬‬
‫;‪method2‬‬
‫‪...‬‬
‫;‪methodN‬‬
‫}‬
۵1۵ ‫مبانی زبان جاوا‬
Pascal ‫ در نامگذاری کالسها هم از روش نامگذاری‬.‫این کلمه کلیدی را قبل از نامی که برای کالسمان انتخاب میکنیم مینویسیم‬
‫ فیلدها اعضای داده ای خصوصی هستند که کالس از‬.‫ در بدنه کالس فیلدها و متدهای آن قرار داده میشوند‬.‫استفاده میکنیم‬
‫ متدها رفتارها یا کارهایی هستند که یک کالس‬.‫( استفاده میکند‬property) ‫آنها برای رفتارها و ذخیره مقادیر خاصیتهایش‬
.‫ نشان داده شده است‬person ‫ در زیر نحوه تعریف و استفاده از یک کالس ساده به نام‬.‫میتواند انجام دهد‬
2
4
5 class Person
6 {
7 public String name;
8 public int age;
9 public double height;
10
11 public void TellInformation()
12 {
13 System.out.println(MessageFormat.format("Name: {0}", name));
14 System.out.println(MessageFormat.format("Age: {0} years old", age));
15 System.out.println(MessageFormat.format("Height: {0}cm", height));
16 }
17 }
18
20 {
22 {
23 Person firstPerson = new Person();
24 Person secondPerson = new Person();
25
26 firstPerson.name = "Jack";
27 firstPerson.age = 21;
28 firstPerson.height = 160;
29 firstPerson.TellInformation();
30
31 System.out.println(); //Separator
32
33 secondPerson.name = "Mike";
34 secondPerson.age = 23;
35 secondPerson.height = 158;
36 secondPerson.TellInformation();
37 }
38 }
Name: Jack
Age: 21 years old
Height: 160cm
Name: Mike
Age: 23 years old
Height: 158cm
‫ می دانیم که کالس‬.‫) میباشد‬36-10 ‫ (خطوط‬MyFirstProgram ‫) و‬1-31 ‫ (خطوط‬Person ‫برنامه باال شامل دو کالس‬
Person ‫ است که برنامه برای اجرا به آن احتیاج دارد ولی اجازه دهید که بر روی کالس‬main() ‫ شامل متد‬MyFirstProgram
‫تمرکز کنیم‪ .‬در خطوط ‪ 1-31‬کالس ‪ Person‬تعریف شده است‪ .‬در خط ‪ 1‬یک نام به کالس اختصاص دادهایم تا به وسیله آن قابل‬
‫دسترسی باشد‪ .‬در داخل بدنه کالس فیلدهای آن تعریف شدهاند (خطوط ‪.)6-1‬‬
‫این سه فیلد تعریف شده خصوصیات واقعی یک فرد در دنیای واقعی را در خود ذخیره میکنند‪ .‬یک فرد در دنیای واقعی دارای نام‪،‬‬
‫سن‪ ،‬و قد میباشد‪ .‬در خطوط ‪ 33-31‬یک متد هم در داخل کالس به نام )(‪ TellInformation‬تعریف شده است که رفتار کالسمان‬
‫است و مثال اگر از فرد سوالی بپرسیم در مورد خودش چیزهایی میگوید‪ .‬در داخل متد کدهایی برای نشان دادن مقادیر موجود در‬
‫فیلدها نوشته شده است‪ .‬نکته ای درباره فیلدها وجود دارد و این است که چون فیلدها در داخل کالس تعریف و به عنوان اعضای‬
‫کالس در نظر گرفته شدهاند محدوده آنها یک کالس است‪.‬‬
‫این بدین معناست که فیلدها فقط میتوانند در داخل کالس یعنی جایی که به آن تعلق دارند و یا به وسیله نمونه ایجاد شده از‬
‫کالس مورد استفاده قرار بگیرند‪ .‬در داخل متد )(‪ main‬و در خطوط ‪ 51‬و ‪ 53‬دو نمونه یا دو شیء از کالس ‪ Person‬ایجاد میکنیم‪.‬‬
‫برای ایجاد یک نمونه از یک کالس باید از کلمه کلیدی ‪ new‬و به دنبال آن نام کالس و یک جفت پرانتز قرار دهیم‪ .‬وقتی نمونه کالس‬
‫ایجاد شد‪ ،‬سازنده را صدا میزنیم‪ .‬یک سازنده متد خاصی است که برای مقداردهی اولیه به فیلدهای یک شیء به کار میرود‪ .‬وقتی‬
‫هیچ آرگومانی در داخل پرانتزها قرار ندهید‪ ،‬کالس یک سازنده پیشفرض بدون پارامتر را فراخوانی میکند‪ .‬درباره سازندهها در‬
‫درسهای آینده توضیح خواهیم داد‪ .‬در خطوط ‪ 51-56‬مقادیری به فیلدهای اولین شیء ایجاد شده از کالس ‪Person (first‬‬
‫)‪ Person‬اختصاص داده شده است‪ .‬برای دسترسی به فیلدها یا متدهای یک شیء از عالمت نقطه (دات) استفاده میشود‪ .‬به‬
‫عنوان مثال کد ‪ firstPerson.name‬نشان دهنده فیلد ‪ name‬از شیء ‪ firstPerson‬میباشد‪ .‬برای چاپ مقادیر فیلدها باید متد‬
‫)(‪ TellInformation‬شیء ‪ firstPerson‬را فراخوانی میکنیم‪.‬‬
‫در خطوط ‪ 11-11‬نیز مقادیری به شیء دومی که قبال از کالس ایجاد شده تخصیص میدهیم و سپس متد )(‪TellInformation‬‬
‫را فراخوانی میکنیم‪ .‬به این نکته توجه کنید که ‪ firstPerson‬و ‪ secondPerson‬نسخههای متفاوتی از هر فیلد دارند بنابراین‬
‫تعیین یک نام برای ‪ secondPerson‬هیچ تاثیری بر نام ‪ firstPerson‬ندارد‪ .‬در مورد اعضای کالس در درسهای آینده توضیح‬
‫خواهیم داد‪.‬‬
۵1۳ ‫مبانی زبان جاوا‬
‫سازنده‬
‫ آنها به شما اجازه میدهند که مقادیری را به هر‬.‫سازندهها متدهای خاصی هستند که وجود آنها برای ساخت اشیاء الزم است‬
‫یک از اعضای داده ای یک آرایه اختصاص دهید و کدهایی که را که میخواهید هنگام ایجاد یک شیء اجرا شوند را به برنامه اضافه‬
‫ کمپایلر از سازنده پیشفرض که یک سازنده بدون پارامتر است استفاده‬،‫ اگر از هیچ سازنده ای در کالستان استفاده نکنید‬.‫کنید‬
‫در مثال زیر یک کالس که‬.‫ میتوانید در برنامهتان از تعداد زیادی سازنده استفاده کنید که دارای پارامترهای متفاوتی باشند‬.‫میکند‬
:‫شامل سازنده است را مشاهده میکنید‬
2
4
5 class Person
6 {
8 public int age;
10
11 //Explicitly declare a default constructor
12 public Person()
13 {
14 }
15
16 //Constructor that has 3 parameters
17 public Person(String n, int a, double h)
18 {
19 name = n;
20 age = a;
21 height = h;
22 }
23
24 public void ShowInformation()
25 {
28 System.out.println(MessageFormat.format("Height: {0}cm", height));
29 }
30 }
31
33 {
35 {
37 Person secondPerson = new Person("Mike", 23, 158);
38
39 firstPerson.name = "Jack";
40 firstPerson.age = 21;
41 firstPerson.height = 160;
42 firstPerson.ShowInformation();
43
44 System.out.println(); //Seperator
45
‫‪46‬‬ ‫;)(‪secondPerson.ShowInformation‬‬
‫‪47‬‬ ‫}‬
‫‪48‬‬ ‫}‬
‫‪Name: Jack‬‬
‫‪Age: 21 years old‬‬
‫‪Height: 160cm‬‬
‫‪Name: Mike‬‬
‫همانطور که مشاهده میکنید در مثال باال دو سازنده را به کالس ‪ Person‬اضافه کردهایم‪ .‬یکی از آنها سازنده پیشفرض (خطوط‬
‫‪ )35-33‬و دیگری سازنده ای است که سه آرگومان قبول میکند (خطوط ‪ .)36-53‬به این نکته توجه کنید که سازنده درست شبیه به یک‬
‫متد است با این تفاوت که‬
‫نه مقدار برگشتی دارد و نه از نوع ‪ void‬است‪.‬‬ ‫‪‬‬
‫نام سازنده باید دقیقا شبیه نام کالس باشد‪.‬‬ ‫‪‬‬
‫سازنده پیشفرض در داخل بدنهاش هیچ چیزی ندارد و وقتی فراخوانی میشود که ما از هیچ سازنده ای در کالس مان استفاده‬
‫نکنیم‪ .‬در آینده متوجه میشوید که چطور میتوان مقادیر پیشفرضی به اعضای داده ای اختصاص داد‪ ،‬وقتی که از یک سازنده‬
‫پیشفرض استفاده میکنید‪ .‬به دومین سازنده توجه کنید‪ .‬اوال که نام آن شبیه نام سازنده اول است‪ .‬سازندهها نیز مانند متدها‬
‫میتوانند سربارگذاری شوند‪ .‬حال اجازه دهید که چطور میتوانیم یک سازنده خاص را هنگام تعریف یک نمونه از کالس فراخوانی‬
‫کنیم‪.‬‬
‫;)(‪Person firstPerson = new Person‬‬

‫;)‪Person secondPerson = new Person("Mike", 23, 158‬‬
‫در اولین نمونه ایجاد شده از کالس ‪ Person‬از سازنده پیشفرض استفاده کردهایم چون پارامتری برای دریافت آرگومان ندارد‪ .‬در‬
‫دومین نمونه ایجاد شده‪ ،‬از سازنده ای استفاده میکنیم که دارای سه پارامتر است‪ .‬کد زیر تأثیر استفاده از دو سازنده مختلف را‬
‫نشان میدهد‪:‬‬
‫;"‪firstPerson.name = "Jack‬‬
‫;‪firstPerson.age = 21‬‬
‫;‪firstPerson.height = 160‬‬
‫;)(‪firstPerson.ShowInformation‬‬
‫‪System.out.println(); //Seperator‬‬
‫;)(‪secondPerson.ShowInformation‬‬
‫همانطور که مشاهده میکنید الزم است که به فیلدهای شیء ای که از سازنده پیشفرض استفاده میکند مقادیری اختصاص داده‬
‫شود تا این شیء نیز با فراخوانی متد )(‪ ShowInformation‬آنها را نمایش دهد‪ .‬حال به شیء دوم که از سازنده دارای پارامتر‬
‫استفاده میکند توجه کنید‪ ،‬مشاهده میکنید که با فراخوانی متد )(‪ ShowInformation‬همه چیز همانطور که انتظار میرود اجرا‬
‫میشود‪ .‬این بدین دلیل است که شما هنگام تعریف نمونه و از قبل مقادیری به هر یک از فیلدها اختصاص دادهاید بنابراین آنها‬
‫نیاز به مقدار دهی مجدد ندارند‪ ،‬مگر اینکه شما بخواهید این مقادیر را اصالح کنید‪.‬‬
‫اختصاص مقادیر پیشفرض به سازنده پیشفرض‬
‫در مثالهای قبلی یک سازنده پیشفرض با بدنه خالی نشان داده شد‪ .‬شما میتوانید به بدنه این سازنده پیشفرض کدهایی اضافه‬
‫کنید‪ .‬همچنین میتوانید مقادیر پیشفرضی به فیلدهای آن اختصاص دهید‪.‬‬
‫)(‪public Person‬‬
‫{‬
‫;"‪this.name = "No Name‬‬
‫;‪this.age = 0‬‬
‫;‪this.height = 0‬‬
‫}‬
‫همانطور که در مثال باال میبینید سازنده پیشفرض ما چیزی برای اجرا دارد‪ .‬اگر نمونه ای ایجاد کنیم که از این سازنده پیشفرض‬
‫استفاده کند‪ ،‬نمونه ایجاد شده مقادیر پیشفرض سازنده پیشفرض را نشان میدهد‪.‬‬
‫;)(‪Person person1 = new Person‬‬
‫;)(‪person1.ShowInformation‬‬
‫‪Name: No Name‬‬
‫استفاده از کلمه کلیدی ‪this‬‬
‫راهی دیگر برای ایجاد مقادیر پیشفرض استفاده از کلمه کلیدی ‪ this‬است‪ .‬مثال زیر اصالح شده مثال قبل است و نحوه استفاده‬
‫از ‪ 3‬سازنده با تعداد پارامترهای مختلف را نشان میدهد‪.‬‬

2
4
5 class Person
6 {
8 public int age;
10
11 public Person()
12 {
13 this.name = "No Name";
14 this.age = 0;
15 this.height = 0;
16 }
17
18 public Person(String n)
19 {
20 this.name = n;
21 }
22
23 public Person(String n, int a)
24 {
25 this.name = n;
26 this.age = a;
27 }
28
29 public Person(String n, int a, double h)
30 {
31 this.name = n;
32 this.age = a;
33 this.height = h;
34 }
35
36 public void ShowInformation()
37 {
40 System.out.println(MessageFormat.format("Height: {0}cm\n", height));
41 }
42 }
43
45 {
47 {
49 Person secondPerson = new Person("Jack");
50 Person thirdPerson = new Person("Mike", 23);
51 Person fourthPerson = new Person("Chris", 18, 152);
52
53 firstPerson.ShowInformation();
54 secondPerson.ShowInformation();
55 thirdPerson.ShowInformation();
56 fourthPerson.ShowInformation();
57 }
58 }
Name: No Name
Age: 0 years old
Height: 0cm
‫‪Name: Jack‬‬
‫‪Name: Mike‬‬
‫‪Name: Chris‬‬
‫ما چهار سازنده بری اصالح کالسمان تعریف کردهایم (خطوط ‪ .)15 ،51 ،30 ،33‬شما میتوانید تعداد زیادی سازنده برای مواقع لزوم‬
‫در کالس داشته باشید‪ .‬اولین سازنده یک سازنده پیشفرض است‪ .‬دومین سازنده یک پارامتر از نوع رشته دریافت میکند‪ .‬سومین‬
‫سازنده دو پارامتر و چهارمین سازنده سه پارامتر میگیرد‪ .‬به چارمین سازنده در خطوط ‪ 15-11‬توجه کنید‪ .‬سه سازنده دیگر به این‬
‫سازنده وابسته هستند‪ .‬در خطوط ‪ 33-31‬یک سازنده پیشفرض بدون پارامتر تعریف شده است‪ .‬به کلمه کلیدی ‪ this‬توجه کنید‪.‬‬
‫این کلمه کلیدی به شما اجازه میدهد که یک سازنده دیگر موجود در داخل کالس را فراخوانی کنید‪ .‬مقادیر پیشفرضی به فیلدها‬
‫از طریق سازنده پیشفرض اختصاص میدهیم‪ .‬چون ما سه مقدار پیشفرض برای فیلدها بعد از کلمه کلیدی ‪ this‬سازنده پیشفرض‬
‫(خطوط ‪ )31-31‬در نظر گرفتهایم‪ ،‬در نتیجه سازنده ای که دارای سه پارامتر است (چهارمین سازنده) فراخوانی شده و سه آرگومان به‬
‫پارامترهای آن ارسال میشود‪ .‬کدهای داخل بدنه چهارمین سازنده اجرا میشوند و مقادیر پارامترهای آن به هر یک از اعضای داده‬
‫ای یه همان فیلدهای تعریف شده در خطوط ‪ 1-6‬اختصاص داده میشود‪ .‬اگر کدی در داخل بدنه سازنده پیشفرض بنویسیم قبل از‬
‫بقیه کدها اجرا میشود‪ .‬دومین سازنده (خطوط ‪ )30-51‬به یک آرگومان نیاز دارد که همان فیلد ‪ name‬کالس ‪ Person‬است‪ .‬وقتی‬
‫این پارامتر با یک مقدار رشته ای پر شد‪ ،‬سپس به پارامترهای سازنده چهارم ارسال شده و در کنار دو مقدار پیشفرض دیگر ( ‪ 3‬برای‬
‫‪ age‬و ‪ 3‬برای ‪ )height‬قرار میگیرد‪ .‬در خط ‪ 51-13‬سومین سازنده تعریف شده است که بسیار شبیه دومین سازنده است با این‬
‫تفاوت که دو پارامتر دارد‪ .‬مقدار دو پارامتر سومین سازنده به اضافهی یک مقدار پیشفرض صفر برای سومین آرگومان‪ ،‬به چهارمین‬
‫سازنده با استفاده از کلمه کلیدی ‪ this‬ارسال میشود‪.‬‬
‫‪Person‬‬ ‫‪firstPerson‬‬ ‫=‬ ‫‪new‬‬ ‫;)(‪Person‬‬

‫‪Person‬‬ ‫‪secondPerson‬‬ ‫=‬ ‫‪new‬‬ ‫;)"‪Person("Jack‬‬
‫‪Person‬‬ ‫‪thirdPerson‬‬ ‫=‬ ‫‪new‬‬ ‫;)‪Person("Mike", 23‬‬
‫‪Person‬‬ ‫‪fourthPerson‬‬ ‫=‬ ‫‪new‬‬ ‫;)‪Person("Chris", 18, 152‬‬
‫همانطور که مشاهده میکنید با ایجاد چندین سازنده برای یک کالس‪ ،‬چندین راه برای ایجاد یک شیء بر اساس دادههایی که نیاز‬
‫داریم به وجود میآید‪ .‬در مثال باال ‪ 3‬نمونه از کالس ‪ Person‬ایجاد کردهایم و چهار تغییر در سازنده آن به وجود آوردهایم‪ .‬سپس‬
‫مقادیر مربوط به فیلدهای هر نمونه را نمایش میدهیم‪ .‬یکی از موارد استفاده از کلمه کلیدی ‪ this‬به صورت زیر است‪ .‬فرض کنید‬
‫نام پارامترهای متد کالس شما یا سازنده‪ ،‬شبیه نام یکی از فیلدها باشد‪.‬‬
‫)‪public Person(String name, int age, double height‬‬

‫{‬
‫;‪name = name‬‬
‫;‪age = age‬‬
‫;‪height = height‬‬
‫}‬
‫این نوع کدنویسی ابهام بر انگیز است و کمپایلر نمیتواند متغیر را تشخیص داده و مقداری به آن اختصاص دهد‪ .‬اینجاست که از‬
‫کلمه کلیدی ‪ this‬استفاده میکنیم‪.‬‬
‫)‪public Person(String name, int age, double height‬‬

‫{‬
‫;‪this.name = name‬‬
‫;‪this.age = age‬‬
‫;‪this.height = height‬‬
‫}‬
‫قبل از هر فیلدی کلمه کلیدی ‪ this‬را مینویسیم و نشان میدهیم که این همان چیزی است که میخواهیم به آن مقداری اختصاص‬
‫دهیم‪ .‬کلمه کلیدی ‪ this‬ارجاع یک شیء به خودش را نشان میدهد‪.‬‬
‫سطح دسترسی‬
‫سطح دسترسی مشخص میکند که متدها یک کالس یا اعضای داده ای در چه جای برنامه قابل دسترسی هستند‪ .‬در این درس‬
‫میخواهیم به سطح دسترسی ‪ private‬و ‪ public‬نگاهی بیندازیم‪ .‬سطح دسترسی ‪ public‬زمانی مورد استفاده قرار میگیرد‬
‫که شما بخواهید به یک متد یا فیلد در خارج از کالس و حتی پروژه دسترسی یابید‪ .‬به عنوان مثال به کد زیر توجه کنید‪:‬‬

‫‪2‬‬
‫‪4‬‬
‫‪5‬‬ ‫‪class Test‬‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;‪public int number‬‬
‫‪8‬‬ ‫}‬
‫‪9‬‬
‫‪11‬‬ ‫{‬
‫‪13‬‬ ‫{‬
‫‪14‬‬ ‫;)(‪Test x = new Test‬‬
‫‪15‬‬
‫‪16‬‬ ‫;‪x.number = 10‬‬
‫‪17‬‬ ‫}‬
‫‪18‬‬ ‫}‬
‫در این مثال یک کالس به نام ‪ Test‬تعریف کردهایم (خطوط ‪ .)1-0‬سپس یک فیلد یا عضو داده ای به صورت ‪ public‬در داخل‬
‫کالس ‪ Test‬تعریف میکنیم (خط ‪ .)1‬با تعریف این عضو به صورت ‪ public‬میتوانیم آن را در خارج از کالس ‪ Test‬و در داخل‬
‫متد )(‪ main‬کالس ‪ MyFirstProgram‬مقدار دهی کنیم‪ .‬حال سطح دسترسی ‪ public‬را به ‪ private‬تغییر میدهیم‪:‬‬

‫‪2‬‬
‫‪4‬‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;‪private int number‬‬
‫‪8‬‬ ‫}‬
‫‪9‬‬
‫‪11‬‬ ‫{‬
‫‪13‬‬ ‫{‬
‫‪14‬‬ ‫;)(‪Test x = new Test‬‬
‫‪15‬‬
‫‪16‬‬ ‫;‪x.number = 10‬‬
‫‪17‬‬ ‫}‬
‫‪18‬‬ ‫}‬
‫همانطور که در مثال باال مشاهده میکنید این بار از کلمه ‪ private‬در تعریف فیلد ‪ number‬استفاده کردهایم (خط ‪ .)1‬وقتی که‬
‫برنامه را کامپایل میکنیم با خطا مواجه میشویم چون ‪ number‬در داخل کالس ‪ MyFirstProgram‬و یا هر کالس دیگر قابل‬
‫دسترسی نیست‪.‬‬
‫نکته دیگر اینکه اگر شما برای یک کالس سطح دسترسی تعریف نکنید آن کالس دارای سطح دسترسی داخلی ‪(default‬‬
‫)‪ modifier‬میشود به این معنی که فقط کالسهای داخل پروژه ای که با آن کار میکنید و میتوانند به آن کالس دسترسی یابند‪.‬‬
‫اگر یک کالس را به صورت ‪ public‬و اعضای آن را به صورت ‪ private‬تعریف کنیم‪ ،‬آنگاه میتوان یک نمونه از کالس را در‬
‫داخل کالسهای دیگر ایجاد کرد ولی اعضای آن قابل دسترسی نیستند‪ .‬اعضای داده ای ‪ private‬فقط به وسیله متد داخل کالس‬
‫‪ Test‬قابل دسترسی هستند‪.‬‬

‫‪2‬‬
‫‪4‬‬
‫‪5‬‬ ‫‪public class Test‬‬

‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;‪private int number‬‬
‫‪8‬‬ ‫}‬
‫‪9‬‬
‫‪11‬‬ ‫{‬
‫‪13‬‬ ‫{‬
‫‪14‬‬ ‫;)(‪Test x = new Test‬‬
‫‪15‬‬
‫‪16‬‬ ‫;‪x.number = 10‬‬
‫‪17‬‬ ‫}‬
‫‪18‬‬ ‫}‬
‫کد باال کامپایل نمی شود‪ ،‬چون جاوا به شما اجازه استفاده از دو کالس عمومی در یک فایل را نمی دهد‪ .‬برای حل این مشکل یا‬
‫باید کلمه ‪ public‬را مثال از ابتدای کالس ‪ Test‬حذف کنیم و یا اینکه چون ما می خواهیم حتما کالس به صورت ‪public‬‬
‫تعریف شود و اعضای آن به صورت ‪ private‬آن را باید در یک فایل جدا به صورت زیر تعریف و با پسوند ‪ .java‬تعریف کنیم‬
‫‪:‬‬
‫همانطور که در شکل باال و پایین مشاهده می کنید باید دو کالس در داخل یک ‪ Package‬باشند‪:‬‬
‫‪۵۱۵‬‬ ‫مبانی زبان جاوا‬
‫حال اگر از کالس ‪ Test‬در کالس ‪ MyFirstProgram‬نمونه ای ایجاد کرده و بخواهیم از فیلد ‪ number‬استفاده کنیم با خطا‬
‫مواجه می شویم‪ ،‬چون که اعضای با سطح دسترسی ‪ private‬در خارج از کالسی که به آن تعلق دارند‪ ،‬غیر قابل دسترس هستند‬
‫‪:‬‬

‫{‬
‫{‬
‫;)(‪Test x = new Test‬‬
‫;‪x.number = 10‬‬
‫}‬
‫}‬
‫سطوح دسترسی دیگری هم در جاوا وجود دارد که بعد از مبحث وراثت در درسهای آینده در مورد آنها توضیح خواهیم داد‪.‬‬
‫کپسوله سازی)‪(Encapsulation‬‬
‫کپسوله سازی (تلفیق دادهها با یکدیگر) یا مخفی کردن اطالعات فرایندی است که طی آن اطلالعات حساس یک موضوع از دید‬
‫کاربر مخفی میشود و فقط اطالعاتی که الزم باشد برای او نشان داده میشود‪.‬‬
‫وقتی که یک کالس تعریف میکنیم معموال تعدادی اعضای داده ای (فیلد) برای ذخیره مقادیر مربوط به شیء نیز تعریف میکنیم‪.‬‬
‫برخی از این اعضای داده ای توسط خود کالس برای عملکرد متدها و برخی دیگر از آنها به عنوان یک متغیر موقت به کار میروند‪.‬‬
‫به این اعضای داده ای‪ ،‬اعضای مفید نیز می گویند چون فقط در عملکرد متدها تأثیر دارند و مانند یک داده قابل رویت کالس‬
‫نیستند‪ .‬الزم نیست که کاربر به تمام اعضای داده ای یا متدهای کالس دسترسی داشته باشد‪ .‬اینکه فیلدها را طوری تعریف کنیم‬
‫که در خارج از کالس قابل دسترسی باشند بسیار خطرناک است چون ممکن است کاربر رفتار و نتیجه یک متد را تغییر دهد‪ .‬به‬
‫برنامه ساده زیر توجه کنید‪:‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬ ‫;‪public int five = 5‬‬
‫‪6‬‬
‫‪7‬‬ ‫)‪public int AddFive(int number‬‬
‫‪8‬‬ ‫{‬
‫‪9‬‬ ‫;‪number += five‬‬
‫‪10‬‬ ‫;‪return number‬‬
‫‪11‬‬ ‫}‬
‫‪12‬‬ ‫}‬
‫‪13‬‬
‫‪15‬‬ ‫{‬
‫‪17‬‬ ‫{‬
‫‪18‬‬ ‫;)(‪Test x = new Test‬‬
‫‪19‬‬
‫‪20‬‬ ‫;‪x.five = 10‬‬
‫‪21‬‬ ‫;))‪System.out.println(x.AddFive(100‬‬
‫‪22‬‬ ‫}‬
‫‪23‬‬ ‫}‬
‫‪110‬‬
‫متد داخل کالس ‪ Test‬به نام )(‪ AddFive‬دارای هدف ساده ای است و آن اضافه کردن مقدار ‪ 1‬به هر عدد میباشد‪ .‬در داخل متد‬
‫)(‪ main‬یک نمونه از کالس ‪ Test‬ایجاد کردهایم و مقدار فیلد آن را از ‪ 1‬به ‪ 33‬تغییر میدهیم (در اصل نباید تغییر کند چون ما از‬
‫برنامه خواستهایم هر عدد را با ‪ 1‬جمع کند ولی کاربر به راحتی آن را به ‪ 33‬تغییر میدهد)‪ .‬همچنین متد )(‪ AddFive‬را فراخوانی و‬
‫مقدار ‪ 333‬را به آن ارسال میکنیم‪ .‬مشاهده میکنید که قابلیت متد )(‪ AddFive‬به خوبی تغییر میکند و شما نتیجه متفاوتی‬
‫مشاهده میکنید‪ .‬اینجاست که اهمیت کپسوله سازی مشخص میشود‪ .‬اینکه ما در درسهای قبلی فیلدها را به صورت ‪public‬‬
‫تعریف کردیم و به کاربر اجازه دادیم که در خارج از کالس به آنها دسترسی داشته باشد کار اشتباهی بود‪ .‬فیلدها باید همیشه به‬
‫صورت ‪ private‬تعریف شوند‪.‬‬

۵۱۳ ‫مبانی زبان جاوا‬
(Properties)‫خواص‬
‫ در داخل یک کالس‬private ‫ (خصوصیت) استانداردی در جاوا برای دسترسی به اعضای داده ای با سطح دسترسی‬Property
‫) و یک بخش برای دسترسی به مقدار‬set ‫ یک بخش جهت مقدار دهی (بلوک‬،‫ دارای دو بخش میباشد‬property ‫ هر‬.‫میباشد‬
‫ تعریف شوند تا در کالسهای دیگر نیز قابل‬public ‫ ها باید به صورت‬property .‫ میباشد‬private ‫) یک داده‬get ‫(بلوک‬
:‫ آمده است‬property ‫ در مثال زیر نحوه تعریف و استفاده از‬.‫دسترسی میباشند‬
2
4
5 class Person
6 {
7 private String name;
8 private int age;
9 private double height;
10
11 public void setName(String name)
12 {
13 this.name = name;
14 }
15
16 public String getName()
17 {
18 return name;
19 }
20
21 public void setAge(int age)
22 {
23 this.age = age;
24 }
25
26 public int getAge()
27 {
28 return age;
29 }
30
31 public void setHeight(double height)
32 {
33 this.height = height;
34 }
35
36 public double getHeight()
37 {
38 return height;
39 }
40
41
42 public Person(String name, int age, double height)
43 {
44 this.name = name;
45 this.age = age;
46 this.height = height;
47 }
48
49 }
50
52 {
54 {
55 Person person1 = new Person("Jack", 21, 160);
56 Person person2 = new Person("Mike", 23, 158);
57
58 System.out.println(MessageFormat.format("Name: {0}", person1.getName()));
59 System.out.println(MessageFormat.format("Age: {0} years old", person1.getAge()));
60 System.out.println(MessageFormat.format("Height: {0}cm", person1.getHeight()));
61
63
67
68
69 person1.setName("Frank");
70 person1.setAge(19);
71 person1.setHeight(162);
72
73 person2.setName("Ronald");
74 person2.setAge(25);
75 person2.setHeight(174);
76
78
82
84
88 }
89 }
Name: Jack
Age: 21 years old
Height: 160cm
Name: Mike
Age: 23 years old
Height: 158cm
Name: Frank
Age: 19 years old
Height: 162cm
Name: Ronald
Age: 25 years old
Height: 174cm
‫‪۵۱۱‬‬ ‫مبانی زبان جاوا‬
‫در برنامه باال نحوه استفاده از ‪ property‬آمده است‪.‬همانطور که مشاهده میکنید در این برنامه ما سه خصوصیت که هر کدام‬
‫مربوط به اعضای داده ای هستند تعریف کردهایم (سه فیلد با سطح دسترسی ‪.)private‬‬
‫;‪private String name‬‬

‫;‪private int age‬‬
‫;‪private double height‬‬
‫دسترسی به مقادیر این فیلدها فقط از طریق ‪ property‬های ارائه شده امکان پذیر است‪.‬‬
‫‪11:‬‬ ‫)‪public void setName(String name‬‬

‫‪12:‬‬ ‫{‬
‫‪13:‬‬ ‫;‪this.name = name‬‬
‫‪14:‬‬ ‫}‬
‫‪15:‬‬
‫‪16:‬‬ ‫)(‪public String getName‬‬
‫‪17:‬‬ ‫{‬
‫‪18:‬‬ ‫;‪return name‬‬
‫‪19:‬‬ ‫}‬
‫‪20:‬‬
‫‪21:‬‬ ‫)‪public void setAge(int age‬‬
‫‪22:‬‬ ‫{‬
‫‪23:‬‬ ‫;‪this.age = age‬‬
‫‪24:‬‬ ‫}‬
‫‪25:‬‬
‫‪26:‬‬ ‫)(‪public int getAge‬‬
‫‪27:‬‬ ‫{‬
‫‪28:‬‬ ‫;‪return age‬‬
‫‪29:‬‬ ‫}‬
‫‪30:‬‬
‫‪31:‬‬ ‫)‪public void setHeight(double height‬‬
‫‪32:‬‬ ‫{‬
‫‪33:‬‬ ‫;‪this.height = height‬‬
‫‪34:‬‬ ‫}‬
‫‪35:‬‬
‫‪36:‬‬ ‫)(‪public double getHeight‬‬
‫‪37:‬‬ ‫{‬
‫‪38:‬‬ ‫;‪return height‬‬
‫‪39:‬‬ ‫}‬
‫وقتی یک خاصیت ایجاد میکنیم‪ ،‬باید سطح دسترسی آن را ‪ public‬تعریف کرده و نوع داده ای را که بر میگرداند یا قبول‬
‫میکند را مشخص کنیم‪ .‬به این نکته توجه کنید که نام ‪ property‬ها همانند نام فیلدهای مربوطه میباشد با این تفاوت که حرف‬
‫اول آنها بزرگ نوشته میشود‪ .‬البته قبل از نام آنها کلمات ‪ set‬و ‪ get‬هم نوشته میشود‪ .‬مثال برای فیلد ‪( name‬خط ‪ )1‬دو متد‬
‫با نامهای ‪ setName‬و ‪( getName‬خطوط ‪ )33-36‬ایجاد شدهاند‪ .‬البته یادآور میشویم که شباهت نام ‪ property‬ها و فیلدها اجبار‬
‫نیست و یک قرارداد میباشد‪ .‬در داخل بدنه دو بخش میبینید‪ ،‬یکی بخش ‪ set‬و دیگری بخش ‪: get‬‬
‫بخش ‪ ،get‬که با کلمه ‪ get‬نشان داده شده است به شما اجازه میدهد که یک مقدار را از فیلدها (اعضای داده ای)‬ ‫‪‬‬
‫استخراج کنید‪.‬‬
‫بخش ‪ ،set‬که با کلمه ‪ set‬نشان داده شده است برای مقدار دهی به فیلدها (اعضای داده ای) به کار میرود‪.‬‬ ‫‪‬‬
‫به عنوان مثال به عبارت زیر توجه کنید‪:‬‬
‫;‪this.name = name‬‬
‫این عبارت که در خط ‪ 31‬کد باال آمده است برای مقداردهی به فیلد ‪ name‬به کار رفته است‪ this .‬به شئ جاری ایجاد شده از‬
‫کالس اشاره دارد‪ ،‬کلمه ‪ name‬بعد آن همان فیلد تعریف شده در خط ‪ 1‬کد ابتدای آموزش و کلمه ‪ name‬سمت راست عالمت‬
‫مساوی هم پارامتر تعریف شده در خط ‪ 33‬است‪ .‬برای دسترسی به یک خاصیت میتوانید از عالمت دات (‪ ).‬استفاده کنید‪.‬‬
‫;)))(‪System.out.println(MessageFormat.format("Name: {0}", person1.getName‬‬

‫;)))(‪System.out.println(MessageFormat.format("Age: {0} years old", person1.getAge‬‬
‫;)))(‪System.out.println(MessageFormat.format("Height: {0}cm", person1.getHeight‬‬
‫فراخوانی یک خاصیت باعث اجرای کد داخل بدنه بلوک ‪ get‬آن میشود‪ .‬سپس این بلوک مانند یک متد مقداری به فراخوان‬
‫برگشت میدهد‪ .‬مقدار دهی به یک ‪ property‬بسیار آسان است‪.‬‬
‫;)"‪person1.setName("Frank‬‬
‫;)‪person1.setAge(19‬‬
‫;)‪person1.setHeight(162‬‬
‫دستورات باال بخش ‪ set‬مربوط به هر ‪ property‬را فراخوانی کرده و مقادیری به هر یک از فیلدها اختصاص میدهد‪ .‬استفاده‬
‫از ‪ property‬ها کد نویسی را انعطاف پذیر میکند‪ ،‬مخصوصا اگر بخواهید یک اعتبارسنجی برای اختصاص یک مقدار به فیلدها‬
‫یا استخراج یک مقدار از آنها ایجاد کنید‪ .‬مثال شما میتوانید یک محدودیت ایجاد کنید که فقط اعداد مثبت به فیلد ‪( age‬سن)‬
‫اختصاص داده شود‪ .‬میتوانید با تغییر بخش ‪ set‬خاصیت ‪ Age‬این کار را انجام دهید‪:‬‬
‫)‪public void setAge(int age‬‬

‫{‬
‫)‪if (age > 0‬‬
‫{‬
‫;‪this.age = age‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;‪this.age = 0‬‬
‫}‬
‫}‬
‫حال اگر کاربر بخواهد یک مقدار منفی به فیلد ‪ age‬اختصاص دهد مقدار ‪ age‬صفر خواهد شد‪.‬‬
‫‪۵۱1‬‬ ‫مبانی زبان جاوا‬
‫‪Package‬‬
‫‪( Package‬پکیج) راهی برای دسته بندی کدهای برنامه میباشد‪ .‬هر چیز در جاوا حداقل در یک ‪ Package‬قرار دارد‪ .‬وقتی برای‬
‫یک کالس اسمی انتخاب میکنید ممکن است برنامه نویسان دیگر به صورت اتفاقی اسمی شبیه به آن برای کالسشان انتخاب کنند‪.‬‬
‫وقتی شما از آن کالسها در برنامهتان استفاده کنید از آنجاییکه از کالسهای همنام استفاده میکنید در برنامه ممکن است خطا به‬
‫وجود آید‪.‬‬
‫‪ Package‬از وقوع این خطاها جلوگیری کرده یا آنها را کاهش میدهند‪ .‬تاکنون و در درسهای قبلی ما فقط با یک پکیج آشنا‬
‫شدهایم و آن پکیجی به نام ‪ myfirstprogram‬بود که کالسی به همین نام )‪ (MyFirstProgram‬و متد )(‪ main‬را در خود‬
‫داشت‪ .‬هنگامی که یک پروژه جدید ایجاد کنید به صورت پیشفرض یک فضای نام برای شما ایجاد خواهد شد که نام آن شبیه به‬
‫نام پروژهتان میباشد‪ .‬در این درس به شما نشان میدهیم که چگونه کالسهایتان در در کدهای جداگانه بنویسید و سپس از آنها‬
‫در فایلهای جدا استفاده کنید‪ .‬برنامه ‪ NetBeans‬را اجرا و یک پروژه جدید ایجاد کنید‪:‬‬
‫بعد از کلیک بر روی گزینه ‪ New Project‬و یا زدن دکمههای ترکیبی ‪ Ctrl+Shfit+N‬پنجره ای به صورت زیر به نمایش در میآید‬
‫که بر طبق شکل گزینهها را نتخاب کنید‪:‬‬

‫بعد از طی مراحل شکل باال صفحه زیر به نمایش در میآید‪ .‬در این صفحه و در قسمت ‪ Project Name‬نام پروژهتان را انتخاب‬
‫کنید‪ .‬مشاهده میکنید که در کادری پایین تر از آن بسته به نام پروژه یک ‪ Package‬به همراه نام کالس ایجاد میکند‪:‬‬
‫‪۵۱۹‬‬ ‫مبانی زبان جاوا‬
‫بعد از زدن دکمه ‪ finish‬در شکل باال‪ ،‬یک ‪ Package‬یک ‪ class‬به صورت زیر ایجاد میشود‪:‬‬
‫توجه کنید که پسوند کالس در جاوا به صورت ‪ .java‬میباشد‪ .‬پس تا اینجا ما یک ‪ Package‬و یک کالس و یک متد داریم‪ .‬حال‬
‫میخواهیم یک پکیج دیگر ایجاد و از کالسها و متدهای آن در داخل این پکیج استفاده کنیم‪ .‬برای این کار بر روی گزینه ‪Source‬‬
‫‪ Package‬مانند شکل زیر راست کلیک کرده و یک پکیج جدید به نام ‪ MySecondPackage‬ایجاد میکنیم‪:‬‬
‫بعد از ایجاد این ‪ Package‬یک کالس به نام ‪ MyClass‬به آن‪ ،‬به روش زیر اضافه میکنیم‪:‬‬
‫بعد از اضافه کردن کالس یک متد به نام )(‪ sayHello‬به شکل زیر به کالس اضافه نمایید‪:‬‬
‫حال فرض کنید که میخواهید از این کالس و متد در کالس ‪ MyFirstProgram‬استفاده کنید‪ .‬برای این کار بر روی کالس مذکور‬
‫دو بار کلیک کرده و سپس مانند شکل زیر و با استفاده از کلمه ‪ import‬کالس را در ‪ Package‬اولی وارد نمایید و سپس با ایجاد‬
‫یک شیء از کالس متد مربوط به آن را فراخوانی کنید‪:‬‬
‫پس در کل میتوان نتیجه گرفت که با استفاده از کلمه کلیدی ‪ import‬میتوان همه محتویات یک پکیج را در داخل پکیج دیگر‬
‫وا رد کرد‪ .‬اگر قصد وارد کردن فقط یک کالس از یک پکیج را در داخل پکیج دیگر داشته باشیم به صورت زیر عمل میکنیم‪:‬‬
‫;‪import Package.Class‬‬
‫و اگر بخواهیم تمامی کالسهای یک ‪ Package‬را وارد ‪ Package‬دیگر کنیم به صورت زیر عمل مینماییم‪:‬‬
‫;*‪import Package.‬‬
‫اگر از کلمه ‪ import‬استفاده نکنیم مجبوریم که در ابتدای نام هر کالس ‪ Package‬مربوط به آن را به صورت زیر ذکر کنیم‪:‬‬
‫;)(‪MySecondPackage.MyClass MC = new MySecondPackage.MyClass‬‬
‫شما محدود به دسته بندی کدهای کالستان در داخل یک ‪ Package‬نیستید‪ .‬میتوانید یک ‪ Package‬تو در تو ایجاد کنید و‬
‫کدهایتان را در درون آن بنویسید‪ .‬برای دسترسی به کالس ‪ ،Sample‬مجبورید اول نام تمام ‪ Package‬هایی را که کالس ‪Sample‬‬
‫در آنها قرار دارد بنویسید‪.‬‬

‫‪Package1.Package2.Sample‬‬
‫یا میتوان از کلمه کلیدی ‪ import‬استفاده کرد‪:‬‬
‫‪import Package1.Package2.Sample‬‬
‫وراثت‬
‫وراثت به یک کالس اجازه میدهد که خصوصیات یا متدهایی را از کالس دیگر به ارث برد‪ .‬وراثت مانند رابطه پدر و پسری میماند‬
‫به طوریکه فرزند خصوصیاتی از قبیل قیافه و رفتار را از پدر خود به ارث برده باشد‪.‬‬
‫کالس پایه یا کالس والد کالسی است که بقیه کالسها از آن ارث میبرند‪.‬‬ ‫‪‬‬
‫کالس مشتق یا کالس فرزند کالسی است که از کالس پایه ارث بری میکند‪.‬‬ ‫‪‬‬
‫همه متد و خصوصیات کالس پایه میتوانند در کالس مشتق مورد استفاده قرار بگیرند به استثنای اعضا و متدهای با سطح دسترسی‬
‫‪ .private‬همه کالسها در جاوا از کالس ‪ Object‬ارث بری میکنند‪ .‬مفهوم اصلی وراثت در مثال زیر نشان داده شده است‪:‬‬

‫‪2‬‬
‫‪3‬‬ ‫‪class Parent‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬ ‫;‪private String message‬‬
‫‪6‬‬
‫‪7‬‬ ‫)‪public void setMessage(String message‬‬
‫‪8‬‬ ‫{‬
‫‪9‬‬ ‫;‪this.message = message‬‬
‫‪10‬‬ ‫}‬
‫‪11‬‬
‫‪12‬‬ ‫)(‪public String getMessage‬‬
‫‪13‬‬ ‫{‬
‫‪14‬‬ ‫;‪return message‬‬
‫‪15‬‬ ‫}‬
‫‪16‬‬
‫‪17‬‬ ‫)(‪public void ShowMessage‬‬
‫‪18‬‬ ‫{‬
‫‪20‬‬ ‫}‬
‫‪21‬‬
‫‪22‬‬ ‫)‪public Parent(String message‬‬
‫‪23‬‬ ‫{‬
‫‪24‬‬ ‫;‪this.message = message‬‬
‫‪25‬‬ ‫}‬
‫‪26‬‬ ‫}‬
‫‪27‬‬
‫‪28‬‬ ‫‪class Child extends Parent‬‬

‫‪29‬‬ ‫{‬
‫‪30‬‬ ‫)‪public Child(String message‬‬
‫‪31‬‬ ‫{‬
‫‪32‬‬ ‫;)‪super(message‬‬
‫‪33‬‬ ‫}‬
‫‪34‬‬ ‫}‬
‫در این مثال دو کالس با نامهای ‪ Parent‬و ‪ Child‬تعریف شده است‪ .‬در این مثال یک فیلد را با سطح دسترسی ‪( private‬خط‬
‫‪ )1‬و خاصیت مربوط به آن را با سطح دسترسی ‪( public‬خط ‪ )1-31‬تعریف کردهایم‪ .‬سپس یک متد را برای نمایش پیام تعریف‬
‫کردهایم‪ .‬یک سازنده در کالس ‪ Parent‬تعریف شده است که یک آرگومان از نوع رشته قبول میکند و یک پیغام نمایش میدهد‬
‫(خطوط ‪ .)55-51‬حال به کالس ‪ Child‬توجه کنید (خط ‪ .)50-13‬این کالس تمام متدها و خاصیتهای کالس ‪ Parent‬را به ارث‬
‫برده است‪ .‬نحوه ارث بری یک کالس به صورت زیر است‪:‬‬
‫‪class DerivedClass extends BaseClass‬‬
‫براحتی میتوان با قرار دادن کلمه کلیدی ‪ extends‬بعد از نام کالس و سپس نوشتن نام کالسی که از آن ارث بری میشود (کالس‬
‫پایه) این کار را انجام داد‪ .‬در داخل کالس ‪ Child‬هم یک سازنده ساده وجود دارد که یک آرگومان رشته ای قبول میکند‪ .‬وقتی از‬
‫وراثت در کالسها استفاده میکنیم ‪ ،‬هم سازنده کالس مشتق و هم سازنده پیشفرض کالس پایه هر دو اجرا میشوند‪ .‬سازنده‬
‫پیشفرض یک سازنده بدون پارامتر است‪ .‬اگر برای یک کالس سازنده ای تعریف نکنیم کمپایلر به صورت خودکار یک سازنده برای‬
‫آن ایجاد میکند‪ .‬اگر هنگام صدا زدن سازنده کالس مشتق بخواهیم سازنده کالس پایه را صدا بزنیم باید از کلمه کلیدی ‪super‬‬
‫استفاده کنیم‪ .‬کلمه کلیدی ‪ super‬یک سازنده از کالس پایه را صدا می زند ‪.‬‬
‫در مثال باال به وسیله تأمین مقدار پارامتر ‪ message‬سازنده کالس مشتق و ارسال آن به داخل پرانتز کلمه کلیدی ‪ ،super‬سازنده‬
‫معادل آن در کالس پایه فراخوانی شده و مقدار ‪ message‬را به آن ارسال میکند‪ .‬سازنده کالس ‪ Parent‬هم این مقدار (مقدار‬
‫‪ )message‬را در یک عضو داده ای (فیلد) ‪ private‬قرار میدهد‪ .‬میتوانید کدهایی را به داخل بدنه سازنده ‪ Child‬اضافه کنید تا‬
‫بعد از سازنده ‪ Parent‬اجرا شوند‪ .‬اگر از کلمه کلیدی ‪ super‬استفاده نشود به جای کالس پایه سازنده پیشفرض فراخوانی میشود‪.‬‬
‫اجازه بدهید که اشیایی از کالسهای ‪ Parent‬و ‪ Child‬بسازیم تا نشان دهیم که چگونه کالس ‪ Child‬متدها و خواص کالس ‪Parent‬‬
‫را به ارث میبرد‪.‬‬

‫‪2‬‬ ‫{‬
‫‪3‬‬
‫‪5‬‬ ‫{‬
‫‪6‬‬ ‫;)"‪Parent myParent = new Parent("Message from parent.‬‬
‫‪7‬‬ ‫;)"‪Child myChild = new Child("Message from child.‬‬
‫‪8‬‬
‫‪9‬‬ ‫;)(‪myParent.ShowMessage‬‬
‫‪10‬‬
‫‪11‬‬ ‫;)(‪myChild.ShowMessage‬‬
‫‪12‬‬
‫‪13‬‬ ‫;)"‪myParent.setMessage("Modified message of the parent.‬‬
‫‪15‬‬
‫‪16‬‬ ‫;)"‪myChild.setMessage("Modified message of the child.‬‬
‫‪18‬‬
‫‪19‬‬ ‫‪//myChild.message; ERROR: can't access private members of base class‬‬
‫‪20‬‬ ‫}‬
‫‪21‬‬ ‫}‬
‫‪Message from parent.‬‬

‫‪Message from child.‬‬
‫‪Modified message of the parent.‬‬
‫‪Modified message of the child.‬‬
‫هر دو شیء را با ستفاده از سازندههای مربوط به خودشان مقدار دهی میکنیم (خطوط ‪ .)1-1‬سپس با استفاده از ارث بری و از‬
‫طریق شیء ‪ Child‬به اعضا و متدهای کالس ‪ Parent‬دسترسی مییابیم‪ .‬حتی اگر کالس ‪ Child‬از کالس ‪ Parent‬ارث ببرد باز هم‬
‫اعضای با سطح دسترسی ‪ private‬در کالس ‪ Child‬قابل دسترسی نیستند(خط ‪ .)30‬سطح دسترسی ‪ Protect‬که در درس آینده‬
‫توضیح داده خواهد شد به شما اجازه دسترسی به اعضا و متدهای کالس پایه را میدهد‪ .‬به نکته دیگر توجه کنید‪ .‬اگر کالس دیگری‬
‫بخواهد از کالس ‪ Child‬ارث بری کند‪ ،‬باز هم تمام متدها و خواص کالس ‪ Child‬که از کالس ‪ Parent‬به ارث برده است را به ارث‬
‫میبرد‪.‬‬
‫‪class GrandChild extends Child‬‬

‫{‬
‫‪//Empty Body‬‬
‫}‬
‫این کالس هیچ چیزی در داخل بدنه ندارد‪ .‬وقتی کالس ‪ GrandChild‬را ایجاد میکنید و یک خاصیت از کالس ‪ Parent‬را فراخوانی‬
‫میکنید با خطا مواجه میشوید‪ .‬چون هیچ سازنده ای که یک آرگومان رشته ای قبول کند در داخل بدنه ‪ GrandChild‬تعریف نشده‬
‫است بنابراین شما میتوانید فقط از سازنده پیشفرض یا بدون پارامتر استفاده کنید‪.‬‬
‫;)(‪GrandChild myGrandChild = new GrandChild‬‬
‫;)"!‪myGrandChild.setMessage("Hello my grandchild‬‬
myGrandChild.ShowMessage();
‫ فراخوانی میشود و سپس‬Parent ‫ را فراخوانی میکنیم ابتدا سازنده کالس‬GrandChild ‫وقتی یک کالس ایجاد میکنیم و سازنده‬
‫ دوباره کالسها‬.‫ برنامه زیر ترتیب اجرای سازندهها را نشان میدهد‬.‫ اجرا میشود‬GrandChild ‫ و در نهایت سازنده‬Child ‫سازنده‬
.‫را برای خوانایی بیشتر در داخل کدهای جدا قرار میدهیم‬
2
3 class Parent
4 {
5 public Parent()
6 {
7 System.out.println("Parent constructor was called!");
8 }
9 }
10
11 class Child extends Parent
12 {
13 public Child()
14 {
15 System.out.println("Child constructor was called!");
16 }
17 }
18
19 class GrandChild extends Child
20 {
21 public GrandChild()
22 {
23 System.out.println("GrandChild constructor was called!");
24 }
25 }
26
28 {
29
31 {
32 GrandChild myGrandChild = new GrandChild();
33 }
34 }
Parent constructor was called!

Child constructor was called!
GrandChild constructor was called!
Protect ‫سطح دسترسی‬

‫سطح دسترسی ‪ protect‬اجازه میدهد که اعضای کالس‪ ،‬فقط در کالسهای مشتق شده از کالس پایه قابل دسترسی باشند‪ .‬بدیهی‬
‫است که خود کالس پایه هم میتواند به این اعضا دسترسی داشته باشد‪ .‬کالسهایی که از کالس پایه ارث بری نکردهاند نمیتوانند‬
‫به اعضای با سطح دسترسی ‪ protect‬یابند‪ .‬در مورد سطوح دسترسی ‪ public‬و ‪ private‬قبال توضیح دادیم‪ .‬در جدول زیر نحوه‬
‫دسترسی به سه سطح ذکر شده نشان داده شده است‪:‬‬
‫قابل دسترسی در‬ ‫‪public‬‬ ‫‪private‬‬ ‫‪protected‬‬
‫داخل کالس‬ ‫‪true‬‬ ‫‪true‬‬ ‫‪true‬‬
‫خارج از کالس‬ ‫‪true‬‬ ‫‪false‬‬ ‫‪false‬‬
‫کالس مشتق‬ ‫‪true‬‬ ‫‪false‬‬ ‫‪true‬‬
‫مشاهده میکنید که ‪ public‬بیشترین سطح دسترسی را داراست‪ .‬صرف نظر از مکان‪ ،‬اعضای ‪ public‬در هر جا فراخوانی میشوند‬
‫و قابل دسترسی هستند‪ .‬اعضای ‪ private‬فقط در داخل کالسی که به آن تعلق دارند قابل دسترسی هستند‪ .‬کد زیر رفتار اعضای‬
‫دارای این سه سطح دسترسی را نشان میدهد‪:‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬ ‫;‪protected int protectedMember = 10‬‬
‫‪6‬‬ ‫‪private‬‬ ‫;‪int privateMember = 10‬‬
‫‪7‬‬ ‫‪public‬‬ ‫;‪int publicMember = 10‬‬
‫‪8‬‬ ‫}‬
‫‪9‬‬
‫‪11‬‬ ‫{‬
‫‪12‬‬ ‫)(‪public Child‬‬
‫‪13‬‬ ‫{‬
‫‪14‬‬ ‫;‪protectedMember = 100‬‬
‫‪15‬‬ ‫;‪privateMember = 100‬‬
‫‪16‬‬ ‫;‪publicMember = 100‬‬
‫‪17‬‬ ‫}‬
‫‪18‬‬ ‫}‬
‫‪19‬‬
‫‪21‬‬ ‫{‬
‫‪23‬‬ ‫{‬
‫‪24‬‬ ‫;)(‪Parent myParent = new Parent‬‬
‫‪25‬‬
‫‪26‬‬ ‫;‪myParent.protectedMember = 100‬‬
‫‪27‬‬ ‫;‪myParent.privateMember = 100‬‬
‫‪28‬‬ ‫;‪myParent.publicMember = 100‬‬
‫‪29‬‬ ‫}‬
‫‪30‬‬ ‫}‬
‫کدهایی که با خط قرمز نشان داده شدهاند نشان دهنده وجود خطا هستند چون آنها اجازه دسترسی به فیلدهای ‪ protect‬کالس‬
‫‪ Parent‬را ندارند‪ .‬همانطور که در خط ‪ 31‬مشاهده میکنید کالس ‪ Child‬سعی میکند که به عضو ‪ private‬کالس ‪Parent‬‬
‫دسترسی یابد‪ .‬از آنجاییکه اعضای ‪ private‬در خارج از کالس قابل دسترسی نیستند‪ ،‬حتی کالس مشتق در خط ‪ 31‬نیز ایجاد خطا‬
‫میکند‪ .‬اگر شما به خط ‪ 33‬توجه کنید کالس ‪ Child‬میتواند به عضو ‪ protect‬کالس ‪ Parent‬دسترسی یابد چون کالس ‪Child‬‬
‫از کالس ‪ Parent‬مشتق شده است‪.‬‬
‫حال به خط ‪ 51‬جاییکه میخواهیم در کالس ‪ MyFirstProgram‬به فیلد ‪ protect‬کالس ‪ Parent‬دسترسی یابیم نگاهی بیندازید‪.‬‬
‫میبینید که برنامه پیغام خطا میدهد چون کالس ‪ MyFirstProgram‬از کالس ‪ Parent‬مشتق نشده است‪ .‬همچنین کالس‬
‫‪ MyFirstProgram‬به اعضای ‪ private‬کالس ‪ Parent‬نیز نمیتواند دسترسی یابد‪.‬‬
‫اعضای ‪static‬‬
‫اگر بخواهیم عضو داده ای (فیلد) یا خاصیتی ایجاد کنیم که در همه نمونههای کالس قابل دسترسی باشد از کلمه کلیدی ‪static‬‬
‫استفاده میکنیم‪ .‬کلمه کلیدی ‪ static‬برای اعضای داده ای و خاصیتهایی به کار میرود که میخواهند در همه نمونههای کالس‬
‫تقسیم شوند‪ .‬وقتی که یک متد یا خاصیت به صورت ‪ static‬تعریف شود‪ ،‬میتوانید آنها را بدون ساختن نمونه ای از شی‪،‬‬
‫فراخوانی کنید‪ .‬به چند مثال توجه کنید‪:‬‬

‫‪2‬‬
‫‪3‬‬ ‫‪class SampleClass‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬ ‫‪public static String StaticMessage‬‬ ‫;"!‪= "This is the static message‬‬
‫‪6‬‬ ‫}‬
‫‪7‬‬
‫‪9‬‬ ‫{‬
‫‪11‬‬ ‫{‬
‫‪12‬‬ ‫;) ‪System.out.println(SampleClass.StaticMessage‬‬
‫‪13‬‬ ‫}‬
‫‪14‬‬ ‫}‬
‫!‪This is the static message‬‬

‫در مثال باال یک شیء استاتیک به نام ‪( StaticMessage‬خط ‪ )1‬تعریف کردهایم‪ .‬مقدار شیء ‪ StaticMessage‬در همه نمونههای‬
‫کالس ‪ SampleClass‬قابل دسترسی است‪ .‬برای فراخوانی یک متد‪ ،‬خاصیت و یا یک متغیر استاتیک‪ ،‬به سادگی میتوان نام کالس‬
‫و بعد از آن عالمت دات )‪ (.‬و در آخر نام متد یا خاصیت را نوشت‪ .‬این موضوع را میتوان در خط (‪ )35‬مشاهده کرد‪ .‬مشاهده‬
‫میکنید که الزم نیست هیچ نمونه ای از کالس ایجاد شود‪ .‬یکی دیگر از کاربردهای این کلمه کلیدی در شمارش اشیاء است‪ .‬به‬
‫مثال زیر توجه کنید‪:‬‬

‫‪2‬‬
‫‪3‬‬ ‫‪class SampleClass‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬ ‫‪public static int number‬‬ ‫;‪= 1‬‬
‫‪6‬‬
‫‪7‬‬ ‫)(‪public SampleClass‬‬
‫‪8‬‬ ‫{‬
‫‪9‬‬ ‫;)‪System.out.println("Number is : " + number++‬‬
‫‪10‬‬ ‫}‬
‫‪11‬‬ ‫}‬
‫‪12‬‬
‫‪14‬‬ ‫{‬
‫‪16‬‬ ‫{‬
‫‪17‬‬ ‫;)( ‪SampleClass Sample1 = new SampleClass‬‬
‫‪20‬‬ ‫}‬
‫‪21‬‬ ‫}‬
‫‪Number is : 1‬‬
‫همانطور که در خط ‪ 1‬کد باال مشاهده میکنید یک متغیر استاتیک با مقدار اولیه ‪ 3‬ایجاد کردهایم و در داخل سازنده کالس در خط‬
‫‪ 6‬ابتدا مقدار آن را چاپ و سپس یک واحد به آن اضافه کردهایم‪ .‬حال در خطوط ‪ 31-36‬سه شیء از روی کالس ‪SampleClass‬‬
‫ایجاد میکنیم‪ .‬همانطور که در خروجی مشاهده میکنید با هر بار ایجاد شیء یک بار سازنده کالس فراخوانی و در نتیجه مقدار‬
‫متغیر چاپ میشود‪ .‬یکی از خواص متغیرهای استاتیک این است که مقدار قبلی خود را حفظ میکنند‪ .‬و از این خاصیت در مثال‬
‫باال برای شمارش اشیاء ساخته شده از کالس استفاده کردهایم‪.‬‬
‫‪Override‬‬
‫فرض کنید شما متد ‪ A‬را در کالس ‪ A‬دارید و کالس ‪ B‬از کالس ‪ A‬ارث بری میکند‪ ،‬در این صورت متد ‪ A‬در کالس ‪ B‬در دسترس‬
‫خواهد بود‪ .‬اما متد ‪ A‬دقیقأ همان متدی است که از کالس ‪ A‬به ارث برده شده است‪ .‬حال اگر بخواهید که این متد رفتار متفاوتی‬
‫از خود نشان دهد چکار میکنید؟ برای حل این مشکل باید متد کالس پایه را ‪ Override‬کنید‪ .‬به تکه کد زیر توجه کنید‪:‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;)"‪System.out.println("Message from Parent.‬‬
‫‪8‬‬ ‫}‬
‫‪9‬‬ ‫}‬
‫‪10‬‬
‫‪12‬‬ ‫{‬
‫‪14‬‬ ‫{‬
‫‪15‬‬ ‫;)"‪System.out.println("Message from Child.‬‬
‫‪16‬‬ ‫}‬
‫‪17‬‬ ‫}‬
‫‪18‬‬
‫‪20‬‬ ‫{‬
‫‪22‬‬ ‫{‬
‫‪24‬‬ ‫;)(‪Child myChild = new Child‬‬
‫‪25‬‬
‫‪28‬‬ ‫}‬
‫‪29‬‬ ‫}‬
‫‪Message from Parent.‬‬

‫‪Message from Child.‬‬
‫همانطور که در کد باال مشاهده میکنید دو کالس یه نام ‪( Parent‬خطوط ‪ )1-6‬و ‪( Child‬خطوط ‪ )33-31‬تعریف کردهایم‪ .‬کالس‬
‫‪Child‬که از کالس‪ Parent‬ارث میبرد شامل متدی است که متد )(‪ ShowMessage‬از کالس پایه را ‪ override‬یا به صورت‬
‫دیگری پیاده سازی میکند‪ .‬همانطور که مشاهده میکنید این دو متد دقیقا شبیه به هم هستند و تنها اختالف آنها در پیامی است‬
‫که نشان میدهند‪ .‬برای ‪ Override‬کردن یک متد قواعدی وجود دارد که در زیر به آنها اشاره شده است‪:‬‬
‫تابع ‪ override‬شده یکی باشد‪.‬‬ ‫‪‬‬
‫نوع مقدار بازگشتی تابع باید همانند یا فرزندی از نوع مقدار بازگشتی تابع ‪ override‬شده کالس پدر باشد‪.‬‬ ‫‪‬‬
‫سطح دسترسی تابع نمیتواند محدودتر از سطح دسترسی تابع ‪ override‬شده باشد‪ .‬برای مثال‪ :‬اگر تابع کالس پدر به‬ ‫‪‬‬
‫صورت ‪ public‬تعریف شده باشد‪ ،‬در این صورت تابع کالس فرزند نمیتواند ‪ private‬یا ‪ protected‬باشد‪.‬‬
‫تنها توابعی از کالس پدر که توسط کالس فرزند ارث بری شدهاند میتوانند ‪ override‬شوند‪.‬‬ ‫‪‬‬
‫توابع ‪ static‬نمیتوانند ‪ override‬شوند‪ ،‬ولی میتوانند دوباره در کالس فرزند تعریف شوند‪.‬‬ ‫‪‬‬
‫اگر تابعی نمیتواند ارث برده شود‪ ،‬همانطور هم نمیتواند ‪ override‬شود‪.‬‬ ‫‪‬‬
‫کالس فرزند موجود در پکیج یکسان با کالس پدر‪ ،‬میتواند تمامی توابعی از کالس پدر را که به صورت ‪ private‬یا‬ ‫‪‬‬
‫‪final‬تعریف نشده باشند را ‪ override‬کند‪.‬‬
‫کالس فرزند در یک پکیج دیگر از کالس پدر تنها میتواند توابع ‪ public‬یا ‪ protected‬کالس پدر را که ‪ final‬نیستند‬ ‫‪‬‬
‫را ‪ override‬کند‪.‬‬
‫سازندهها نمیتوانند ‪ override‬شوند‪.‬‬ ‫‪‬‬
‫با استفاده از کلمه کلیدی ‪( super‬خط ‪ )31‬میتوانید متد کالس پایه را در داخل متد ‪ override‬شده فراخوانی کنید‪:‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪6‬‬ ‫{‬
‫‪8‬‬ ‫}‬
‫‪9‬‬ ‫}‬
‫‪10‬‬
‫‪12‬‬ ‫{‬
‫‪14‬‬ ‫{‬
‫‪15‬‬ ‫;)(‪super.ShowMessage‬‬
‫‪17‬‬ ‫}‬
‫‪18‬‬ ‫}‬
‫‪19‬‬
‫‪21‬‬ ‫{‬
‫‪23‬‬ ‫{‬
‫‪25‬‬ ‫;)(‪Child myChild = new Child‬‬
‫‪26‬‬
‫‪29‬‬ ‫}‬
‫‪30‬‬ ‫}‬

‫‪Message from Child.‬‬
‫م توان یک کالس دیگر که از کالس ‪ Child‬ارث بری میکند ایجاد کرده و دوباره متد )(‪ ShowMessage‬را ‪ override‬کرده و آنرا به‬
‫صورت دیگر پیاده سازی کنیم‪ .‬اگر بخواهید متدی را که ایجاد کردهاید به وسیله سایر کالسها ‪ override‬نشود کافیست که از کلمه‬
‫کلیدی ‪ final‬به صورت زیر استفاده کنید‪:‬‬
‫)(‪public final void ShowMessage‬‬
‫حال اگر کالس دیگری از کالس ‪ Child‬ارث ببرد نمیتواند متد )(‪ ShowMessage‬را ‪ override‬کند‪.‬‬
‫کالس آبجکت )‪(java.lang.Object‬‬
‫همه کالسهای جاوا به طور مستقیم یا غیر مستقیم از کالس ‪ Object‬که در پکیج ‪ java.lang‬قرار دارد‪ ،‬ارث می برند‪ .‬کالس‬
‫نشان داده می شود‪ .‬برای راحتی در این درس از کلمه آبجکت به جای‬ ‫‪Object‬‬ ‫آبجکت در جاوا با کلمه کلیدی‬
‫‪ java.lang.Object‬استفاده می کنیم‪ .‬در زیر لیست برخی از متدهای معمول در کالس آبجکت آمده است‪:‬‬
‫کاربرد‬ ‫متد‬
‫یک شیء از کالس ‪ Class‬را بر می گرداند که نشان دهنده کالس زمان اجرای شیء است‪.‬‬ ‫)(‪getClass‬‬
‫کد هش شیء انتخاب شده بر می گرداند‪.‬‬ ‫)(‪hashCode‬‬
‫مشخص می کند که آیا یک شیئ با شیء دیگر برابر است یا نه؟‬ ‫)(‪equals‬‬
‫یک نسخه از شیء جاری را بر می گرداند‪.‬‬ ‫)(‪clone‬‬
‫یک نمایش رشته ای از شیء جاری را بر می گرداند‪.‬‬ ‫)(‪toString‬‬
‫با برنامه های چند نخی به کار می رود و نخ منتظر شیء جاری را فعال می کند‪.‬‬ ‫)(‪notify‬‬
‫با برنامه های چند نخی به کار می رود و تمام نخ های منتظر شیء جاری را فعال می کند‪.‬‬ ‫)(‪notifyAll‬‬
‫باعث می شود نخ شیء منتظر شود تا نخ دیگر ‪ notify‬یا ‪ notifyAll‬را فراخوانی کند‪.‬‬ ‫)(‪wait‬‬
‫با ابزار زباله روب )‪ (Garbage Collector‬در زمان از بین بردن شیئ فراخوانی می شود‪.‬‬ ‫)(‪finalize‬‬
‫همه متدهای این کالس معموال مورد استفاده قرار نمی گیرند‪ .‬از آنجاییکه همه کالسهای جاوا از این کالس ارث می برند‪ ،‬آنها نیز‬
‫دارای این متدها به جز متدهای ‪ Static‬می باشند‪ .‬وقتی یک کالس ایجاد می کنید‪ ،‬این کالس به صورت ضمنی از کالس آبجکت‬
‫ارث می برد‪ .‬بنابراین وقتی یک کالس تعریف می کنید کدها در حقیقت به صورت زیر به وسیله کمپایلر خوانده می شوند‪:‬‬
‫‪class MyClass extends java.lang.Object‬‬

‫{‬
‫}‬
‫اینکه چرا همه کالسها در جاوا از ‪ Object‬ارث بری می کنند به دلیل امکان استفاده از چندریختی است که در درس آینده درباره آن‬
‫توضیح می دهیم‪ .‬به عنوان مثال یکی از سربارگذاری های متد )(‪ System.out.println‬قبول نوع آبجکت به عنوان آرگومان‬
‫است‪ .‬به همین دلیل است که شما می توانید تقریبا هر چیز را به عنوان آرگومان به متد )(‪ System.out.println‬ارسال کنید‪.‬‬
‫نکته ای که باید در اینجا به آن اشاره کنیم این است که انواع داده های اصلی شیء نیستند و از کالس ‪ Object‬ارث بری نمی کنند‬
‫و در نتیجه نمی توانند از متدهای این کالس هم استفاده کنند‪ .‬مثال اجرای کد زیر باعث بروز خطا می شود‪:‬‬
‫;))(‪System.out.println(number.toString‬‬
‫اگر بخواهید یک نوع ‪ int‬را به نوع رشته ای به صورت باال تبدیل کنید و متد )(‪ toString‬را فراخوانی کنید باید از کالس‬
‫پوششی به صورت زیر استفاده نمایید‪:‬‬
‫;))(‪System.out.println(new Integer(number).toString‬‬
‫کد باال را به صورت زیر هم می توانید بنویسید‪:‬‬
‫;))‪System.out.println(Integer.toString(number‬‬
‫همانطور که در باال هم اشاره شد یکی از متدهای کالس ‪ Object‬متد )(‪ toString‬است‪ .‬این متد کد هش شده شیء جاری را‬
‫بر می گرداند‪ .‬به مثال زیر توجه کنید‪:‬‬
‫‪class Person‬‬
{
private String name, family;
public Person(String n, String f)

{
this.name = n;
this.family = f;
}
}

{

{
Person person1 = new Person("John", "SKith");
System.out.println(person1.toString());
}
}
object.Person@5cd622e5
‫ البته این کد ممکن است در‬.‫ یک کد هش شده تولید می شود‬toString() ‫همانطور که مشاهده می کنید با فراخوانی متد‬
:‫ به صورت زیر است‬toString() ‫ رفتار پیشفرض متد‬.‫سیستم شما متفاوت باشد‬
public String toString()

{
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
Override ‫خروجی این متد یک کد هش شده است ولی شاید شما بخواهید این رفتار پیشفرض را تغییر داده و متد را اصطالحا‬
:‫ فرض کنید در مثال باال شما می خواهید با فراخوانی این متد مقدار فیلدهای این کالس چاپ شوند‬.‫کنید‬
2
3 class Person
4 {
5 private String name, family;
6
7 public Person(String n, String f)
8 {
9 this.name = n;
11 this.family = f;
11 }
12
13 @Override
14 public String toString()
15 {
16 return name + " " + family;
17 }
18 }
19
‫‪21‬‬ ‫{‬
‫‪23‬‬ ‫{‬
‫‪24‬‬ ‫;)"‪Person person1 = new Person("John", "SKith‬‬
‫‪25‬‬
‫‪26‬‬ ‫;))(‪System.out.println(person1.toString‬‬
‫‪27‬‬ ‫}‬
‫}‬
‫‪John SKith‬‬
‫همانطور که مشاهده می کنید با ‪ Override‬کردن متد )(‪ toString‬در خطوط ‪ 31-31‬و تغییر رفتار پیشفرض آن (خط ‪ )31‬باعث‬
‫شدیم که با فراخوانی آن در خط ‪ 51‬خروجی متفاوتی را دریافت کنیم‪ .‬خط ‪ 51‬را به صورت زیر هم می توان نوشت‪:‬‬
‫;)‪System.out.println(person1‬‬
‫این بدان خاطر است که متد )(‪ println‬متد )(‪ toString‬شئ ارسال شده به آن را به طور خودکار فراخوانی می کند‪.‬‬
‫‪ Boxing‬و ‪Unboxing‬‬
‫در زبان برنامه نویسی جاوا‪ 0 ،‬نوع داده اصلی وجود دارد که هر کدام از آنها دارای یک کتابخانه کالس )‪ (library class‬از نوع‬
‫مرجع‪ ،‬مربوط به خود هستند‪ .‬به عنوان مثال کالس ‪ java.lang.Integer‬کتابخانه مربوط به نوع اصلی ‪ int‬می باشد‪ .‬این‬
‫نوع کالس ها را ‪ wrapper class‬یا کالس های پوششی می نامند‪ .‬این نوع کالس ها غیر قابل تغییر بوده‪ ،‬و وقتی ایجاد می‬
‫شوند نمی توان مقدار آنها را عوض کرد‪ .‬همچنین چون از نوع ‪ final‬هستند‪ ،‬در نتیجه نمی توانند دارای زیر کالس هم باشند‪ .‬در‬
‫جدول زیر انواع اصلی و کالس های ‪ Wrapper‬مربوط به آنها آمده است‪:‬‬
‫نوع مرجع‬ ‫نوع اصلی‬
‫‪Byte‬‬ ‫‪byte‬‬
‫‪Short‬‬ ‫‪short‬‬
‫‪Integer‬‬ ‫‪int‬‬
‫‪Long‬‬ ‫‪long‬‬
‫‪Float‬‬ ‫‪float‬‬
‫‪Double‬‬ ‫‪double‬‬
‫‪Boolean‬‬ ‫‪boolean‬‬
‫‪Character‬‬ ‫‪char‬‬
‫قبل از ‪ Java SE 5‬برای مقدار دهی به یک متغییر از نوع ‪ Integer‬باید حتما یک شئ از کالس ‪ Integer‬ایجاد می کردیم و‬
‫همچنین برای مقدار دهی به یک متغییر از نوع ‪ int‬با استفاده از یک شئ ‪ Integer‬باید حتما از متد )(‪ intValue‬کالس‬
‫‪ Integer‬استفاده می کردیم‪ ،‬اما بعد از ‪ Java SE 5‬و با افزوده شدن قابلیت ‪ Boxing‬و ‪ Unboxing‬این مشکل برطرف و به‬
‫طور خودکار این تبدیل ها انجام شد‪.‬‬
‫‪ Boxing‬فرایندی است که طی آن یک نوع اصلی مانند ‪ int‬به یک نوع مرجع مانند ‪ Integer‬تبدیل می شود ‪. Unboxing‬‬
‫برعکس‪ ،‬عمل تبدیل یک نوع مرجع به یک نوع مقداری می باشد‪ .‬کد زیر فرایند ‪ boxing‬را نشان می دهد ‪:‬‬
‫;‪int i = 100‬‬
‫;‪Integer number = i‬‬
‫در پس زمینه‪ ،‬کمپایلر کد باال را به صورت زیر به نوع مرجع تبدیل می کند ‪:‬‬
‫;)‪Integer number = Integer.valueOf(i‬‬
‫در فرایند ‪ boxing‬نوع مقداری به سادگی با یک متغیر از نوع مرجع برابر قرار داده می شود‪ .‬در زیر نحوه تبدیل یک نوع مرجع به‬
‫نوع مقداری به وسیله ‪ unboxing‬نشان داده شده است ‪.‬‬
‫;‪Integer number = 100‬‬
‫;‪int i = number‬‬
‫در پس زمینه‪ ،‬کمپایلر کد باال را به صورت زیر به نوع اصلی تبدیل می کند ‪:‬‬
‫;)‪Integer number= Integer.valueOf(12‬‬
‫;)(‪int i = number.intValue‬‬
۵11 ‫مبانی زبان جاوا‬
aggregation
‫ به عنوان مثال کالس‬.‫ فرایندی است که طی آن یک کالس به عنوان یک عضو به کالس دیگر اضافه می شود‬aggregation
:‫ به کد زیر توجه کنید‬.‫ داشته باشد‬Name ‫ می تواند یک فیلد از نوع کالس‬Person
2
3 class Name
4 {
5 public String FirstName;
6 public String LastName;
7
8 public Name(String f, String l)
9 {
10 this.FirstName = f;
11 this.LastName = l;
12 }
13 }
14
15 class Person
16 {
17 private Name myName;
18
19 public Person(Name name)
02 {
02 myName = new Name(name.FirstName, name.LastName);
22 }
23
24 @Override
25 public String toString()
26 {
27 return myName.FirstName + " " + myName.LastName;
28 }
29 }
30
32 {
34 {
35 Person person1 = new Person(new Name("John", "Smith"));
36
37 System.out.println(person1.toString());
38 }
39 }
John Smith
: ‫حال برنامه را به صورت بخش بخش توضیح می دهیم‬
class Name
{
public String FirstName;
public String LastName;
public Name(String f, String l)

{
‫;‪this.FirstName = f‬‬
‫;‪this.LastName = l‬‬
‫}‬
‫}‬
‫یک کالس که قرار است به عنوان یک فیلد در کالس دیگر به کار رود را تعریف می کنیم (خطوط ‪ .)1-31‬این کالس دارای یک سازنده‬
‫است که نام )‪ (f‬و نام خانوادگی )‪ (l‬را از شخص دریافت می کند‪ .‬سپس این مقادیر را در خصوصیت های متناظر با آنها قرار‬
‫می دهیم(خطوط ‪.)0-35‬‬
‫{‬
‫;‪private Name myName‬‬
‫)‪public Person(Name name‬‬

‫{‬
‫;)‪myName = new Name(name.FirstName, name.LastName‬‬
‫}‬
‫‪@Override‬‬
‫)(‪public String toString‬‬
‫{‬
‫;‪return myName.FirstName + " " + myName.LastName‬‬
‫}‬
‫}‬
‫این کالس شامل یک فیلد از نوع ‪ Name‬و خاصیت متناضر با آن است‪ .‬این خصوصیت مقدار نام هر شی ‪ Person‬را در خود‬
‫نگهداری می کند‪ .‬به این نکته توجه کنید که سازنده یک شیء ‪ Name‬را می پذیرد و سپس با استفاده از این شیء فیلد ‪myName‬‬
‫را مقداردهی می کند‪ .‬به این فرایند ترکیب )‪ (aggregation‬می گویند‪ .‬همچنین در کالس ‪ Person‬متد )(‪ toString‬از‬
‫کالس ‪ Object‬را بازنویسی )‪ (override‬می کنیم به طوری که در هنگام فراخوانی نام کامل شخص را نمایش دهد ‪.‬‬

‫{‬
‫{‬
‫;))"‪Person person1 = new Person(new Name("John", "Smith‬‬
‫;))(‪System.out.println(person1.toString‬‬
‫}‬
‫}‬
‫در باال یک شی ‪ Person‬را ایجاد و از سازنده ای که یک شی از نوع کالس ‪ Name‬به عنوان آرگومان قبول می کند استفاده کرده ایم‪.‬‬
‫این شی را مستقیما در داخل پرانتز ها تعریف و همچنین مقادیر خصوصیات ‪ firstname‬و ‪ lastname‬را به آن ارسال کرده ایم‪.‬‬
‫در نهایت ‪ ،‬با استفاده از متد سفارشی )(‪ toString‬نتیجه را چاپ می کنیم‪ .‬به این نکته توجه کنید که کالس ها می توانند شی‬
‫هایی از نوع خود کالس داشته باشند‪ .‬به عنوان نمونه کالس ‪ Person‬می تواند یک عضو با نوع ‪ Person‬داشته باشد‪ .‬به کد زیر‬
‫توجه نمایید ‪:‬‬
‫{‬
‫;‪public Person Sibling‬‬
‫;‪public String Name‬‬
‫}‬
‫مشاهده می کنید که چگونه خصوصیتی از نوع ‪ Person‬در داخل کالس ‪ Person‬تعریف شده است‪ .‬پس هنگامی که یک شی‬
‫‪ Person‬تعریف می کنید ‪ ،‬شی ایجاد شده یک شی از نوع ‪ Person‬در داخل خود دارد ‪.‬‬
‫;)(‪Person person1 = new Person‬‬

‫;)(‪person1.Sibling = new Person‬‬
‫;"‪person1.Name = "John Smith‬‬
‫;"‪person1.Sibling.Name = "Mike Smith‬‬
‫کد باال چگونگی دسترسی و مقدار دهی به عضو ‪ (Sibling)Person‬را نشان داده است‪ .‬از آنجایی که خصوصیت ‪ Sibling‬از‬
‫نوع ‪ Person‬است پس می تواند یک شی ‪ Person‬در داخل خود داشته باشد‪ .‬بنابراین می توان هر تعداد ‪ sibling‬که می‬
‫خواهید در داخل شی ‪ person1‬داشته باشید ‪:‬‬
‫;)(‪person1.Sibling.Sibling = new Person‬‬

‫;"‪person1.Sibling.Sibling.Name = "Franc Smith‬‬
‫;)(‪person1.Sibling.Sibling.Sibling = new Person‬‬
‫;"‪person1.Sibling.Sibling.Sibling.Name = "Bob Smith‬‬
‫‪//And so on...‬‬
‫عملگر ‪instanceof‬‬
‫عملگر ‪ instanceof‬در جاوا به شما اجازه میدهد که تست کنید که آیا یک شیء یک نمونه از یک نوع خاص (کالس‪ ،‬زیر کالس‪،‬‬
‫اینترفیس) است یا نه‪ .‬عملگر ‪ instanceof‬به دو عملوند نیاز دارد و یک مقدار بولی را برمی گرداند‪ .‬به عنوان مثال‪ ،‬فرض کنید یک‬
‫کالس به نام ‪ Animel‬داریم‪ ،‬سپس یک نمونه از آن ایجاد میکنیم‪:‬‬

‫‪2‬‬
‫‪3‬‬ ‫‪class Animal‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬
‫‪6‬‬ ‫}‬
‫‪7‬‬
‫‪9‬‬ ‫{‬
‫‪11‬‬ ‫{‬
‫‪12‬‬ ‫;)(‪Animal myAnimal = new Animal‬‬
‫‪13‬‬
‫‪14‬‬ ‫)‪if (myAnimal instanceof Animal‬‬
‫‪15‬‬ ‫{‬
‫‪16‬‬ ‫;)"!‪System.out.println("myAnimal is an Animal‬‬
‫‪17‬‬ ‫}‬
‫‪18‬‬ ‫}‬
‫‪19‬‬ ‫}‬
‫‪myAnimal is an Animal‬‬
‫رفتار عملگر ‪ instanceof‬را در این مثال مشاهده کردید‪ .‬همانطور که میبینید از آن به عنوان شرط در عبارت ‪ if‬استفاده شده‬
‫است‪ .‬کاربرد آن در مثال باال این است که چک میکند که آیا شیء ‪ myAnimal‬یک نمونه از ‪ Animal‬است و چون نتیجه درست‬
‫است کدهای داخل دستور ‪ if‬اجرا میشود‪ .‬این عملگر همچنین میتواند چک کند که آیا یک شیء خاص در سلسله مراتب وراثت‬
‫یک نوع خاص است‪ .‬به این مثال توجه کنید‪:‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬
‫‪6‬‬ ‫}‬
‫‪7‬‬
‫‪8‬‬ ‫‪class Dog extends Animal‬‬
‫‪9‬‬ ‫{‬
‫‪10‬‬
‫‪11‬‬ ‫}‬
‫‪12‬‬
‫‪14‬‬ ‫{‬
‫‪16‬‬ ‫{‬
‫‪17‬‬ ‫;)(‪Dog myDog = new Dog‬‬
‫‪18‬‬
‫‪19‬‬ ‫)‪if (myDog instanceof Animal‬‬
‫‪20‬‬ ‫{‬
‫‪21‬‬ ‫;)"!‪System.out.println("myDog is an Animal‬‬
‫‪22‬‬ ‫}‬
‫‪23‬‬ ‫}‬
‫‪24‬‬ ‫}‬
‫!‪myDog is an Animal‬‬
‫همانطور که در مثال باال میبینید ما یک کالس به نام ‪ Dog‬ایجاد کردهایم که از کالس ‪ Animal‬ارث میبرد‪ .‬سپس یک نمونه از این‬
‫کالس )‪ (Dog‬ایجاد میکنیم و سپس با استفاده از عملگر ‪ instanceof‬تست میکنیم که آیا نمونه ایجاد شده جز کالس ‪Animal‬‬
‫است یا یک کالس مشتق شده از کالس ‪ Animal‬میباشد‪ .‬از آنجاییکه کالس ‪ Dog‬از کالس ‪ Animal‬ارث میبرد (سگ من یک‬
‫حیوان است‪ ،).‬نتیجه عبارت درست )‪ (true‬است‪ .‬حال جمله باال را تغییر دهیم ‪ ” :‬حیوان من یک سگ است” ‪ .‬وقتی جمله‬
‫برعکس میشود چه اتفاقی میافتد؟‬
‫;)(‪Animal myAnimal = new Animal‬‬
‫)‪if (myAnimal instanceof Dog‬‬

‫{‬
‫;)"!‪System.out.println("myAnimal is a Dog‬‬
‫}‬
‫این باعث خطا نمیشود و عبارت فقط نتیجه ‪ false‬را بر میگرداند‪ .‬میتوان از کد باال این را درک کرد که همه حیوانات سگ نیستند‬
‫ولی همه سگها حیوان هستند ‪.‬‬
‫رابط)‪(Interface‬‬
‫اینترفیس ها شبیه به کالسها هستند اما فقط شامل تعاریفی برای متدها و خواص )‪ (Property‬میباشند‪ .‬اینترفیس ها را‬
‫میتوان به عنوان پالگین های کالسها در نظر گرفت‪ .‬کالسی که یک اینترفیس خاص را پیاده سازی میکند الزم است که کدهایی‬
‫برای اجرا توسط اعضا و متدهای آن فراهم کند چون اعضا و متدهای اینترفیس هیچ کد اجرایی در بدنه خود ندارند‪ .‬اجازه دهید‬
‫که نحوه تعریف و استفاده از یک اینترفیس در کالس را توضیح دهیم‪:‬‬

‫‪2‬‬
‫‪3‬‬ ‫‪interface ISample‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬ ‫;)‪public void ShowMessage(String message‬‬
‫‪6‬‬ ‫}‬
‫‪7‬‬
‫‪8‬‬ ‫‪class Sample implements ISample‬‬
‫‪9‬‬ ‫{‬
‫‪10‬‬ ‫)‪public void ShowMessage(String message‬‬
‫‪11‬‬ ‫{‬
‫‪13‬‬ ‫}‬
‫‪14‬‬ ‫}‬
‫‪15‬‬
‫‪17‬‬ ‫{‬
‫‪19‬‬ ‫{‬
‫‪20‬‬ ‫;)(‪Sample sample = new Sample‬‬
‫‪21‬‬
‫‪22‬‬ ‫;)"!‪sample.ShowMessage("Implemented the ISample Interface‬‬
‫‪23‬‬ ‫}‬
‫‪24‬‬ ‫}‬
‫!‪Implemented the ISample Interface‬‬
‫در خطوط ‪ 1-1‬یک اینترفیس به نام ‪ Isample‬تعریف کردهایم‪ .‬بر طبق قراردادهای نامگذاری‪ ،‬اینترفیس ها به شیوه پاسکال‬
‫نامگذاری میشوند و همه آنها باید با حرف ‪ I‬شروع شوند‪ .‬همچنین در تعریف آنها باید از کلمه کلیدی ‪ interface‬استفاده‬
‫شود‪ .‬یک متد در داخل بدنه اینترفیس تعریف میکنیم (خط ‪ .)1‬به این نکته توجه کنید که متد تعریف شده فاقد بدنه است و در‬
‫آخران باید از سیمیکولن استفاده شود‪ .‬وقتی که متد را در داخل اینترفیس تعریف میکنید فقط الزم است که عنوان متد (نوع‪ ،‬نام‬
‫و پارامترهای آن) را بنویسید‪ .‬به این نکته نیز توجه کنید که متدها و خواص تعریف شده در داخل اینترفیس سطح دسترسی ندارند‬
‫چون باید همیشه هنگام اجرای کالسها در دسترس باشند‪ .‬برای پیاده سازی یک ‪ interface‬توسط یک کالس از کلمه کلیدی‬
‫‪ implements‬استفاده میشود‪ .‬کالسی که اینترفیس را اجرا میکند کدهای واقعی را برای اعضای آن فراهم میکند‪ .‬همانطور که در‬
‫مثال باال میبینید کالس ‪ ،Sample‬متد )(‪ ShowMessage‬اینترفیس ‪ Isample‬را اجرا و تغذیه میکند‪ .‬میتوان چند اینترفیس را‬
‫در کالس اجرا کرد‪.‬‬
‫‪class Sample implements ISample1, ISample2, ISample3‬‬

‫{‬
‫‪//Implement all interfaces‬‬
‫}‬

‫‪2‬‬
‫‪3‬‬ ‫‪interface IFirstinterface‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬ ‫;)‪public void FirstMessage(String message‬‬
‫‪6‬‬ ‫}‬
‫‪7‬‬
‫‪8‬‬ ‫‪interface ISecondinterface‬‬
‫‪9‬‬ ‫{‬
‫‪10‬‬ ‫;)‪public void SecondMessage(String message‬‬
‫‪11‬‬ ‫}‬
‫‪12‬‬
‫‪13‬‬
‫‪14‬‬ ‫‪class Sample implements IFirstinterface , ISecondinterface‬‬
‫‪15‬‬ ‫{‬
‫‪16‬‬ ‫‪@Override‬‬
‫‪17‬‬ ‫)‪public void FirstMessage(String message‬‬
‫‪18‬‬ ‫{‬
‫‪20‬‬ ‫}‬
‫‪21‬‬
‫‪23‬‬ ‫)‪public void SecondMessage(String message‬‬
‫‪24‬‬ ‫{‬
‫‪26‬‬ ‫}‬
‫‪27‬‬ ‫}‬
‫‪28‬‬
‫‪30‬‬ ‫{‬
‫‪32‬‬ ‫{‬
‫‪33‬‬ ‫;)(‪Sample sample = new Sample‬‬
‫‪34‬‬
‫‪35‬‬ ‫;)"!‪sample.FirstMessage("Implemented the IFirstinterface Interface‬‬
‫‪36‬‬ ‫;)"!‪sample.SecondMessage("Implemented the ISecondinterface Interface‬‬
‫‪37‬‬ ‫}‬
‫‪38‬‬ ‫}‬
‫!‪Implemented the IFirstinterface Interface‬‬

‫!‪Implemented the ISecondinterface Interface‬‬
‫درست است که میتوان از چند اینترفیس در کالس استفاده کرد ولی باید مطمئن شد که کالس میتواند همه اعضای اینترفیسها را‬
‫تغذیه کند‪ .‬همانطور که در کد باال مشاهده میکنید دو اینترفیس به نامهای ‪ IFirstinterface‬و ‪ ISecondinterface‬در‬
‫خطوط ‪ 1-33‬تعریف شدهاند که به ترتیب دارای دو متد به نامهای )(‪ FirstMessage‬و )(‪ SecondMessage‬میباشند‪ .‬در خط‬
‫‪ 33‬کالس ‪ Sample‬این دو اینترفیس را پیاده سازی کرده است و در نتیجه همانطور که اشاره شد الزم است که کدهای بدنه دو متد‬
‫موجود در این دو رابط را تغذیه کند‪ .‬که این کار در خطوط ‪ 31-51‬انجام شده است‪ .‬عبارت ‪ @Override‬موجود در خطوط ‪ 31‬و ‪55‬‬
‫به این دلیل قرار داده شده است که به کمپایلر اعالم کند که این دو متد ‪ Override‬شدهاند و به نوعی یک اخطار به کمپایلر هست‬
‫که میگوید این تایع مربوط به کالس یا اینترفیسی است که کالس جاری از آن مشتق شده و یا پیاده سازی کرده است‪ .‬وجود @‬
‫هم به خاطر قرار داد خود زبان میباشد ‪ .‬اگر یک کالس از کالس پایه ارث ببرد و در عین حال از اینترفیس ها هم استفاده کند‪ ،‬در‬
‫این صورت باید نام کالس پایه قبل از نام اینترفیس ها ذکر شود‪ .‬به شکل زیر‪:‬‬
‫‪class Sample extends BaseClass, ISample1, ISample2‬‬

‫{‬
‫}‬
‫نکته دیگر اینکه نمیتوان از یک اینترفیس نمونه ای ایجاد کرد چون اینترفیس ها دارای سازنده نیستند‪ ،‬مثال کد زیر اشتباه است‬
‫‪:‬‬
‫;)(‪ISample sample = new ISample‬‬

:‫ به مثال زیر توجه کنید‬.‫ ارث بری کنند‬extends ‫اینترفیسها حتی میتوانند از اینترفیسهای دیگر با استفاده از کلمه کلیدی‬
2
3 interface IBase
4 {
5 void BaseMethod();
6 }
7
8 interface ISample extends IBase
9 {
10 void ShowMessage(String message);
11 }
12
13 class Sample implements ISample
14 {
15 @Override
16 public void ShowMessage(String message)
17 {
18 System.out.println(message);
19 }
20
21 @Override
22 public void BaseMethod()
23 {
24 System.out.println("Method from base interface!");
25 }
26 }
27
29 {
31 {
32 Sample sample = new Sample();
33
34 sample.ShowMessage("Implemented the ISample Interface!");
35 sample.BaseMethod();
36 }
37 }
Implemented the ISample Interface!

Method from base interface!
Sample ‫ ارث بری کرده است پس حتی اگر کالس‬IBase ‫ از رابط‬ISample ‫ کد باال مشاهده میکنید رابط‬0 ‫همانطور که در خط‬
‫ از آن ارث‬ISample ‫ را هم پیاده سازی کند چون‬Ibase ‫ الزم است که همه اعضای‬،‫ را پیاده سازی کند‬ISample ‫فقط اینترفیس‬
.‫بری میکند‬
(Abstract Class)‫کالسهای انتزاعی‬

‫کالسهای مجرد )‪ (abstract‬کالسهایی هستند که کالس پایه سایر کالسها هستند‪.‬این نوع کالسها میتوانند مانند کالسهای‬
‫عادی دارای سازنده باشند‪ .‬شما نمیتوانید از کالسهای انتزاعی نمونه ایجاد کنید چون که هدف اصلی از به کار بردن کالسهای انتزاعی‬
‫استفاده از آنها به عنوان کالس پایه برای کالسهای مشتق است‪ .‬برای تعریف یک کالس انتزاعی از کلمه کلیدی ‪ abstract‬استفاده‬
‫میشود‪ .‬به مثال زیر در مورد استفاده از کالسهای انتزاعی توجه کنید‪:‬‬
‫‪1‬‬ ‫‪abstract class Base‬‬

‫‪2‬‬ ‫{‬
‫‪3‬‬ ‫;‪protected int number‬‬
‫‪4‬‬ ‫;‪protected String name‬‬
‫‪5‬‬
‫‪6‬‬ ‫;)(‪public abstract void ShowMessage‬‬
‫‪7‬‬
‫‪8‬‬ ‫)‪public Base(int number, String name‬‬
‫‪9‬‬ ‫{‬
‫‪10‬‬ ‫;‪this.number = number‬‬
‫‪11‬‬ ‫;‪this.name = name‬‬
‫‪12‬‬ ‫}‬
‫‪13‬‬ ‫}‬
‫‪14‬‬
‫‪15‬‬ ‫‪class Derived extends Base‬‬
‫‪16‬‬ ‫{‬
‫‪19‬‬ ‫{‬
‫‪21‬‬ ‫}‬
‫‪22‬‬
‫‪23‬‬ ‫)‪public Derived(int number, String name‬‬
‫‪24‬‬ ‫{‬
‫‪25‬‬ ‫;)‪super(number, name‬‬
‫‪26‬‬ ‫}‬
‫‪27‬‬ ‫}‬
‫در داخل کالس انتزاعی دو فیلد محافظت شده )‪ (protected‬تعریف کردهایم (خطوط ‪ )1-3‬که میخواهیم آنها را توسط سازنده‬
‫کالس مقدار دهی کنیم (خطوط ‪ .)0-35‬یک متد هم را به صورت انتزاعی )‪ (abstract‬تعریف کردهایم (خط ‪ .)1‬به این نکته توجه‬
‫کنید که برای تعریف این متد کلمه کلیدی ‪ abstract‬را به کار بردهایم‪.‬‬
‫این متد باید به وسیله کالسهایی که از این کالس ارث میبرند ‪ override‬یا به صورت دیگر پیاده سازی شود‪ ،‬ولی از آن جاییکه‬
‫به صورت ‪ abstract‬تعریف شده است فاقد بدنه میباشد‪ .‬میبینید که کالسهای ‪ abstract‬میتوانند شامل ‪ property‬های‬
‫معمولی مانند ‪ Name ،property‬مثال باال باشند‪ .‬کالسهای ‪ abstract‬حداقل باید یک عضو ‪ abstract‬داشته باشند‪.‬‬
‫یک کالس دیگر تعریف میکنید که از کالس ‪ Base‬ارث بری کند‪ .‬سپس در خطوط ‪ 31-53‬متد ‪ abstract‬را به صورت دیگر پیاده‬
‫سازی میکنیم (‪ override‬کنیم)‪ .‬همچنین یک سازنده تعریف میکنیم (خطوط ‪ )51-51‬و با استفاده از کلمه کلیدی ‪ super‬مقادیر‬
‫پارامترها را به سازنده پایه ارسال میکنیم‪ .‬نمیتوان از یک کالس ‪ abstract‬نمونه ایجاد کرد ولی از کالسهایی که از این نوع‬
‫کالسها مشتق میشوند‪ ،‬میتوان نمونه ایجاد کرد‪.‬‬
‫کالس ‪ final‬و متد ‪final‬‬
‫کالس ‪( final‬کالس نهایی)‪ ،‬کالسی است که دیگر کالسها نمیتوانند از آن ارث بری کنند و چون قابلیت ارث بری ندارد نمیتواند‬
‫مجرد )‪ (abstract‬هم باشد‪ .‬مثال زیر یک کالس ‪ final‬را نشان میدهد‪:‬‬
‫‪final class Base‬‬

‫{‬
‫;‪private int someField‬‬
‫)(‪public void SomeMethod‬‬

‫{‬
‫‪//Do something here‬‬
‫}‬
‫‪//Constructor‬‬
‫)(‪public Base‬‬
‫{‬
‫‪//Do something here‬‬
‫}‬
‫}‬
‫‪class Derived extends Base‬‬

‫{‬
‫‪//This class cannot inherit the Base class‬‬
‫}‬
‫برای تعریف این کالسها از کلمه کلیدی ‪ final‬استفاده میشود‪ .‬مشاهده میکنید که کالس نهایی مانند کالسهای عادی‪ ،‬دارای‬
‫فیلد‪ ،‬خواص‪ ،‬و متد میباشند‪ .‬کالس مشتق )‪ (Derived‬در مثال باال با خط قرمز نشان داده شده است چون نمیتواند از کالس‬
‫نهایی )‪ (Base‬ارث بری کند‪ .‬وقتی یک کالس را نهایی میکنیم‪ ،‬تمام متدهای آن نیز نهایی میشوند‪ .‬استفاده از این کالسها‬
‫همانطور که ذکر شد زمانی مفید است که بخواهید کالسی ایجاد کنید که دیگر کالسها نتوانند از آن ارث بری کنند‪.‬‬
‫متد ‪Final‬‬
‫متد ‪ final‬به متدی گفته میشود که هیچ زیر کالسی نتواند آن را بازنویسی یا ‪ Override‬کند‪ .‬به مثال زیر توجه کنید‪:‬‬
‫‪class Parent‬‬
‫{‬
‫)(‪final void ShowMessage‬‬
‫{‬
‫;)"!‪System.out.println("This is a final method‬‬
‫}‬
‫}‬
‫‪class Child extends Parent‬‬

‫{‬
‫)(‪void ShowMessage‬‬
‫{‬
‫;)"!‪System.out.println("This is a final method that Overriden‬‬
‫}‬
‫}‬

‫{‬
‫{‬
‫}‬
‫}‬
‫اگر به کدهای باال توجه کنید و آن را در محیط ‪ NetBeans‬بنویسید مشاهده میکنید که در خط ‪ 33‬کد باال خطا به وجود میآید‪.‬‬
‫چون کالس ‪ Child‬از کالس ‪ Parent‬ارث بری کرده است و زیر کالس محسوب میشود و طبق تعریف هیچ زیر کالسی نمیتواند‬
‫متدهای ‪ final‬را بازنویسی کند‪.‬‬
‫چند ریختی)‪(Polymorphism‬‬
‫چند ریختی به کالسهایی که در یک سلسله مراتب وراثتی مشابه هستند اجازه تغییر شکل و سازگاری مناسب میدهد و همچنین‬
‫به برنامه نویس این امکان را میدهد که به جای ایجاد برنامههای خاص‪ ،‬برنامههای کلی و عمومی تری ایجاد کند‪ .‬به عنوان مثال‬
‫در دنیای واقعی همه حیوانات غذا میخورند‪ ،‬اما روشهای غذا خوردن آنها متفاوت است‪ .‬در یک برنامه برای مثال‪ ،‬یک کالس به‬
‫نام ‪ Animal‬ایجاد میکنید‪ .‬بعد از ایجاد این کالس میتوانید آن را چند ریخت (تبدیل) به کالس ‪ Bird‬کنید و متد )(‪ Fly‬را‬
‫فراخوانی کنید‪ .‬به مثالی در باره چند ریختی توجه کنید‪:‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬ ‫)(‪public void Eat‬‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;)"!‪System.out.println("The animal ate‬‬
‫‪8‬‬ ‫}‬
9 }
10
11 class Dog extends Animal
12 {
13 @Override
14 public void Eat()
15 {
16 System.out.println("The dog ate!");
17 }
18 }
19
20 class Bird extends Animal
21 {
22 @Override
24 {
25 System.out.println("The bird ate!");
26 }
27 }
28
29 class Fish extends Animal
30 {
31 @Override
33 {
34 System.out.println("The fish ate!");
35 }
36 }
37
39 {
41 {
42 Dog myDog = new Dog();
43 Bird myBird = new Bird();
44 Fish myFish = new Fish();
45 Animal myAnimal = new Animal();
46
47 myAnimal.Eat();
48
49 myAnimal = myDog;
50 myAnimal.Eat();
51 myAnimal = myBird;
52 myAnimal.Eat();
53 myAnimal = myFish;
54 myAnimal.Eat();
55 }
56 }
The animal ate!

The dog ate!
The bird ate!
The fish ate!
.‫ کالس پایه است و سه کالس دیگر از آن مشتق میشوند‬Animal .‫ کالس مختلف تعریف کردهایم‬3 ‫همانطور که مشاهده میکنید‬
‫ را به وسیله نمونه‬Eat() ‫ حال متد‬.)35-31( ‫ نمونه ای از هر کالس ایجاد کردهایم‬.‫ مربوط به خود را دارد‬Eat() ‫هر کالس متد‬
:‫ به صورت زیر فراخوانی میکنیم‬Animal ‫ایجاد شده از کالس‬

‫;)(‪Animal myAnimal = new Animal‬‬
‫;)(‪myAnimal.Eat‬‬
‫در مرحله بعد چندریختی روی میدهد‪ .‬همانطور که در مثال باال مشاهده میکنید شیء ‪ Dog‬را برابر نمونه ایجاد شده از کالس‬
‫‪ Animal‬قرار میدهیم (خط ‪ )36‬و متد )(‪ Eat‬را بار دیگر فراخوانی میکنیم (خط ‪ .)13‬حال با وجود اینکه ما از نمونه کالس ‪Animal‬‬
‫استفاده کردهایم ولی متد )(‪ Eat‬کالس ‪ Dog‬فراخوانی میشود‪ .‬این به دلیل تأثیر چند ریختی است‪.‬‬
‫سپس دو شیء دیگر (‪ Bird‬و ‪ )Fish‬را برابر نمونه ایجاد شده از کالس ‪ Animal‬قرار میدهیم و متد )(‪ Eat‬مربوط به هر یک را‬
‫فراخوانی میکنیم (خطوط ‪ .)13-13‬به این نکته توجه کنید که وقتی در مثال باال اشیاء را برابر نمونه کالس ‪ Animal‬قرار میدهیم از‬
‫عمل ‪ Cast‬استفاده نکردهایم چون این کار )‪ (cast‬وقتی که بخواهیم یک شیء از کالس مشتق (مثال ‪ )Dog‬را در شیی از کالس‬
‫پایه )‪ (Animal‬ذخیره کنیم الزم نیست‪ .‬همچنین میتوان کالس ‪ Animal‬را با سازنده هر کالس مشتق دیگر مقدار دهی اولیه‬
‫کرد‪:‬‬
‫;)(‪Animal myDog = new Dog‬‬

‫;)(‪Animal myBird = new Bird‬‬
‫;)(‪Animal myFish = new Fish‬‬
‫;)(‪myDog.Eat‬‬
‫;)(‪myBird.Eat‬‬
‫;)(‪myFish.Eat‬‬
‫اجازه دهید که برنامه باال را اصالح کنیم تا مفهوم چند ریختی را بهتر متوجه شوید‪:‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫)"!‪System.out.println("The animal ate‬‬
‫‪8‬‬ ‫}‬
‫‪9‬‬ ‫}‬
‫‪10‬‬
‫‪11‬‬ ‫‪class Dog extends Animal‬‬
‫‪12‬‬ ‫{‬
‫‪15‬‬ ‫{‬
‫‪16‬‬ ‫;)"!‪System.out.println("The dog ate‬‬
‫‪17‬‬ ‫}‬
‫‪18‬‬
‫‪19‬‬ ‫)(‪public void Run‬‬
‫‪20‬‬ ‫{‬
‫‪21‬‬ ‫;)"!‪System.out.println("The dog ran‬‬
‫‪22‬‬ ‫}‬
23 }
24
25 class Bird extends Animal
26 {
27 @Override
29 {
31 }
32
33 public void Fly()
34 {
35 System.out.println("The bird flew!");
36 }
37 }
38
39 class Fish extends Animal
40 {
41 @Override
43 {
45 }
46
47 public void Swim()
48 {
49 System.out.println("The fish swam!");
50 }
51 }
52
54 {
56 {
57 Animal animal1 = new Dog();
58 Animal animal2 = new Bird();
59 Animal animal3 = new Fish();
60
61 Dog myDog = (Dog)animal1;
62 Bird myBird = (Bird)animal2;
63 Fish myFish = (Fish)animal3;
64
65 myDog.Run();
66 myBird.Fly();
67 myFish.Swim();
68 }
69 }
The dog ran!

The bird flew!
The fish swam!
.)11-16 ‫ ایجادو آنها را بوسیله سه سازنده از کالسهای مشتق مقدار دهی اولیه کردهایم (خطوط‬Animal ‫در باال سه شیء از کالس‬
‫ را در نمونههایی از کالسهای مشتق ذخیره میکنیم (خطوط‬Animal ‫ اشیا ایجاد شده از کالس‬cast ‫سپس با استفاده از عمل‬
.)11-11 ‫ وقتی این کار را انجام دادیم میتوانیم متدهای مخصوص به هر یک از کالسهای مشتق را فراخوانی کنیم (خطوط‬.)13-11
۵۹۵ ‫مبانی زبان جاوا‬
‫ را در‬Animal ‫یک را میانبر دیگر به وسیله کد زیر مشخص شده است ولی در این روش شما نمیتوانید اشیا ایجاد شده از کالس‬
.‫نمونههایی از کالسهای مشتق ذخیره میکنید‬
((Dog)animal1).Run();
((Bird)animal2).Fly();
((Fish)animal3).Swim();
:‫ به کد زیر توجه کنید‬.‫از چند ریختی میتوان در رابطها هم استفاده کرد‬
2
3 interface IAnimal
4 {
5 public void Eat();
6 }
7
8 class Dog implements IAnimal
9 {
10 @Override
12 {
13 System.out.println("The dog ate!");
14 }
15
16 }
17
18 class Bird implements IAnimal
19 {
20 @Override
22 {
24 }
25 }
26
27 class Fish implements IAnimal
28 {
29 @Override
31 {
33 }
34 }
35
37 {
39 {
40 IAnimal myDog = new Dog();
41 IAnimal myBird = new Bird();
42 IAnimal myFish = new Fish();
43
44 myDog.Eat();
45 myBird.Eat();
46 myFish.Eat();
47 }
48 }
‫!‪The dog ate‬‬

‫!‪The bird ate‬‬
‫!‪The fish ate‬‬
‫تسلط کامل بر چند ریختی و وراثت برای درک بهتر شیء گرایی ضروری است‪.‬‬
‫کالسهای تو در تو)‪(nested classes‬‬

‫به کالسی که در داخل کالس دیگر تعریف شود کالس تو در تو گفته میشود‪ .‬از کالسهای تو در تو برای گروه بندی منطقی کالسها‬
‫در یک مکان استفاده میشود‪ ،‬با این کار خوانایی کدها بیشتر و دستکاری آنها راحت تر میشود‪ .‬کالس تو در تو عضوی از کالسی‬
‫است که در داخل آن قرار دارد‪ ،‬بنابراین میتواند به صورت ‪ protect ،public‬و ‪ private‬تعریف شود‪ .‬این کالسها میتوانند‬
‫توسط زیر کالس )‪ (subclass‬هم به ارث برده شوند‪ .‬نحوه ایجاد یک کالس تو در تو به صورت زیر میباشد‪.‬‬
‫‪class OuterClass‬‬
‫{‬
‫‪class InnerClass‬‬
‫{‬
‫}‬
‫}‬
‫در جاوا چند نوع کالس تو در تو وجود دارد که در زیر به آنها اشاره شده است‪:‬‬
‫کالسهای داخلی استاتیک‬ ‫‪‬‬
‫کالسهای داخلی غیر استایک‬ ‫‪‬‬
‫کالسهای محلی‬ ‫‪‬‬
‫کالسهای بی نام‬ ‫‪‬‬
‫در درسهای آینده در باره این کالسها توضیح میدهیم‪.‬‬
‫کالس داخلی استاتیک و غیر استاتیک‬

‫‪۵۹۳‬‬ ‫مبانی زبان جاوا‬
‫همانطور که در درس قبل اشاره شده در جاوا ‪ 3‬نو ع کالس تو در تو وجود دارد که در این درس به دو نوع از آنها میپردازیم‪.‬‬
‫کالسهای داخلی استاتیک‬
‫این نوع کالسها به صورت زیر تعریف میشوند‪:‬‬
‫‪public class Outer‬‬

‫{‬
‫‪public static class Nested‬‬
‫{‬
‫}‬
‫}‬
‫برای ایجاد شیء از این نوع کالسها ابتدا باید نام کالس بیرونی و سپس عالمت نقطه و بعد نام کالس داخلی استاتیک را بنویسید‪.‬‬
‫به کد زیر توجه کنید‪:‬‬
‫;)(‪Outer.Nested instance = new Outer.Nested‬‬
‫یک کالس داخلی استاتیک یک کالس عادی است که در داخل یک کالس دیگر قرار دارد‪ .‬کالسهای استاتیک داخلی فقط به اعضای‬
‫استاتیک کالسی که در آن قرار دارند‪ ،‬دسترسی دارند‪ .‬به مثال زیر توجه کنید‪:‬‬
‫‪class Outer‬‬
‫{‬
‫‪static String‬‬ ‫;"!‪message = "Hello World‬‬
‫‪public static class Nested‬‬

‫{‬
‫)(‪void ShowMessage‬‬
‫{‬
‫;)‪System.out.println(message‬‬
‫}‬
‫}‬
‫}‬

‫{‬
‫{‬
‫;)(‪Outer.Nested instance = new Outer.Nested‬‬
‫;)(‪instance.ShowMessage‬‬
‫}‬
‫}‬
‫همانطور ک در مثال باال متغیر ‪ message‬یک عضو استاتیک از کالس ‪ Outer‬است و برای دسترسی به آن باید به صورتی که در‬
‫خطوط مشاهده میکنید‪ ،‬عمل نمایید‪.‬‬
‫کالسهای داخلی غیر استاتیک یا‪Inner Classes‬‬
‫کالسهای داخلی غیر استاتیک در جاوا به نام ‪ inner classes‬معروفاند‪ .‬برای ایجاد یک نمونه از این کالسها ابتدا باید یک‬
‫نمونه از کالس خارجی ایجاد کنید‪ .‬نحوه تعریف این نوع کالسها به صورت زیر است‪:‬‬
‫‪public class Outer‬‬

‫{‬
‫‪public class Inner‬‬
‫{‬
‫}‬
‫}‬
‫در زیر نحوه ایجاد نمونه از یک کالس داخلی آمده است‪:‬‬
‫;)(‪Outer outer = new Outer‬‬
‫;)(‪Outer.Inner inner = outer.new Inner‬‬
‫به نحوه قرار داده کلمه ‪ new‬بعد از شیء ایجاد شده از کالس خارجی در کد باال توجه کنید‪ .‬کالس داخلی غیر استاتیک به فیلدهای‬
‫کالس خارجی دسترسی دارد‪ ،‬حتی اگر این فیلدها به صورت ‪ private‬تعریف شده باشند‪ .‬به کد زیر توجه کنید‪:‬‬
‫{‬
‫;"!‪private String text = "I am private‬‬
‫‪public class Inner‬‬

‫{‬
‫)(‪public void ShowMessage‬‬
‫{‬
‫;)‪System.out.println(text‬‬
‫}‬
‫}‬
‫}‬

‫{‬
‫{‬
‫;)(‪Outer outerClass = new Outer‬‬
‫;)(‪Outer.Inner innerClass = outerClass.new Inner‬‬
‫;)(‪innerClass.ShowMessage‬‬
‫‪۵۹۱‬‬ ‫مبانی زبان جاوا‬
‫}‬
‫}‬
‫!‪I am private‬‬
‫کالسهای محلی)‪(Local Classes‬‬
‫کالسهای محلی در جاوا شبیه به کالسهای داخلی غیر استاتیک )‪ (inner class‬هستند‪ .‬این نوع کالسها در داخل یک متد‬
‫یا محدوده ({…}) در داخل متد تعریف میشوند‪ .‬به مثال زیر توجه کنید‪:‬‬
‫{‬
‫)(‪public void printText‬‬
‫{‬
‫‪class Local‬‬
‫{‬
‫}‬
‫;)(‪Local local = new Local‬‬

‫}‬
‫}‬
‫کالسهای محلی تنها در داخل متد و یا بلوکی که در آن تعریف شدهاند قابل دسترسی هستند‪ .‬این کالسها همانند کالسهای غیر‬
‫استاتیک میتوانند به فیلدها و متدهای کالسی که در داخل آن قرار دارند دسترسی داشته باشند‪ .‬از نسخه ‪ 0‬جاوا این کالسها‬
‫میتوانند به متغیرهای محلی و پارامترهای متدی که در آن تعریف شدهاند دسترسی داشته باشند‪ .‬پارامترها باید به صورت ‪final‬‬
‫تعریف شده باشند‪ .‬کالسهای محلی میتوانند در داخل متدهای استاتیک تعریف شوند که در این صورت فقط به قسمتهای‬
‫استاتیک کالسی که در آن تعریف شدهاند دسترسی خواهند داشت‪ .‬این کالسها نمیتوانند دارای انواع استاتیک باشند (میتوانند‬
‫شامل ثابتها باشند و متغیرهای آنها به صورت ‪ static final‬تعریف میشوند)‪ ،‬چون کالسهای محلی در حالت عادی غیر‬
‫استاتیک هستند حتی اگر در داخل متد استاتیک تعریف شوند‪.‬‬
‫کالس داخلی بی نام )‪(Anonymous Inner Class‬‬

‫به کالس داخلی که نام نداشته باشد‪ ،‬کالس داخلی بی نام یا ‪ Anonymous Inner Class‬گفته می شود‪ .‬از این کالس ها برای‬
‫‪ Override‬کردن متد یک کالس یا یک رابط )‪ (interface‬استفاده می شود‪ .‬نحوه تعریف کالس های داخلی بی نام به صورت‬
‫زیر است‪:‬‬
‫)(‪AnonymousInner ObjectName = new AnonymousInner‬‬

‫{‬
‫)(‪Modifier ReturnType MethodName‬‬
‫{‬
‫‪//Some Code‬‬
‫}‬
‫;}‬
‫همانطور که احتتماال از کد باال متوجه شده اید‪ ،‬تعریف و ایجاد شیء از این نوع کالس ها به صورت همزمان می باشد‪ .‬به این نکته‬
‫هم توجه کنید که بعد از عالمت آکوالد بسته از عالمت سمیکالن (;) استفاده می شود‪ .‬همانطور که در درس زیر ذکر شد‪ ،‬برای پیاده‬
‫سازی یا ‪ Override‬یک متد از کالس پایه توسط کالس فرزند باید دو کالس ایجاد شود که یکی از دیگری ارث بری کند‪:‬‬
‫حال همین مثال اول لینک باال را با استفاده از کالس های بی نام پیاده سازی می کنیم ‪:‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪6‬‬ ‫{‬
‫‪8‬‬ ‫}‬
‫‪9‬‬ ‫}‬
‫‪10‬‬
‫‪12‬‬ ‫{‬
‫‪14‬‬ ‫{‬
‫‪15‬‬
‫‪16‬‬ ‫)(‪Parent parent = new Parent‬‬
‫‪17‬‬ ‫{‬
‫‪19‬‬ ‫{‬
‫‪21‬‬ ‫}‬
‫‪22‬‬ ‫;}‬
‫‪23‬‬
‫‪24‬‬ ‫;)(‪parent.ShowMessage‬‬
‫‪25‬‬ ‫}‬
‫‪26‬‬ ‫}‬
‫‪۵۹1‬‬ ‫مبانی زبان جاوا‬
‫در کد باال‪ ،‬یک کالس تعریف شده است(خطوط ‪ )3-1‬که دارای یک متد می باشد(‪ .)1-1‬این متد را به وسیله کالس بی نام(‪) 33-53‬‬
‫‪Override‬کرده ایم(‪ .)31-36‬خطوط ‪ 3-1‬کد باال می تواند یک کالس انتزاعی )‪ (abstract class‬باشد ‪:‬‬
‫‪abstract class Base‬‬

‫{‬
‫;)(‪abstract void ShowMessage‬‬
‫}‬
‫و یا یک رابط‪(interface) :‬‬
‫‪interface IBase‬‬
‫{‬
‫;)(‪void ShowMessage‬‬
‫}‬
‫می توان کالس بی نام را به عنوان آرگومان به یک متد هم ارسال کرد ‪:‬‬

‫‪2‬‬
‫‪3‬‬ ‫‪interface MyInterface‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬ ‫;)(‪String Message‬‬
‫‪6‬‬ ‫}‬
‫‪7‬‬
‫‪8‬‬ ‫‪class MyClass‬‬
‫‪9‬‬ ‫{‬
‫‪10‬‬ ‫)‪public void ShowMessage(MyInterface m‬‬
‫‪11‬‬ ‫{‬
‫‪12‬‬ ‫;))(‪System.out.println(m.Message‬‬
‫‪13‬‬ ‫}‬
‫‪14‬‬ ‫}‬
‫‪15‬‬
‫‪16‬‬ ‫‪class MyFirstProgram‬‬
‫‪17‬‬ ‫{‬
‫‪18‬‬ ‫)][‪public static void main(String args‬‬
‫‪19‬‬ ‫{‬
‫‪20‬‬ ‫;)(‪MyClass MC = new MyClass‬‬
‫‪21‬‬
‫‪22‬‬ ‫)(‪MC.ShowMessage(new MyInterface‬‬
‫‪23‬‬ ‫{‬
‫‪25‬‬ ‫)(‪public String Message‬‬
‫‪26‬‬ ‫{‬
‫‪27‬‬ ‫;"!‪return "Hello World‬‬
‫‪28‬‬ ‫}‬
‫‪29‬‬ ‫;)}‬
‫‪30‬‬ ‫}‬
‫‪31‬‬ ‫}‬
‫در خط ‪ 1-1‬کد باال یک رابط که دارای یک متد است را نوشته ایم‪ .‬در خطوط ‪ 0-33‬هم کالسی داریم که دارای یک متد می باشد که‬
‫یک آرگومان از نوع رابط ‪ MyInterface‬دریافت می کند‪ .‬برای پیاده سازی یا ‪ Override‬متد مربوط به راط همانطور که مشاهده‬
‫می کنید در خط ‪ 55‬متد )(‪ ShowMessage‬مربوط به کالس ‪ MyClass‬را فراخوانی کرده و یک کالس بی نام به آن ارسال می کنیم‪.‬‬
‫سپس در داخل همین کالس بی نام متد )(‪ Message‬مربوط به رابط را ‪ Override‬می کنیم‪ .‬ارسال کالس بی نام به عنوان‬
‫آرگومان همانطور که در آینده خواهید دید در مبحث ‪ Swing‬کاربرد دارد‪.‬‬
‫ایجاد آرایه ای از کالسها‬
‫در این درس به شما نشان می دهیم که چگونه می توان آرایه ای از کالس ها ایجاد کرد‪ .‬ساخت آرایه ای از کالس ها تقریبا شبیه‬
‫به ایجاد آرایه ای از انواع داده ای مانند ‪ int‬است‪ .‬به عنوان مثال می توان آرایه ای از کالس ‪ Person‬ایجاد کرد ‪:‬‬

‫‪2‬‬
‫‪3‬‬ ‫‪class Person‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬ ‫;‪public String Name‬‬
‫‪6‬‬
‫‪7‬‬ ‫)‪public Person(String name‬‬
‫‪8‬‬ ‫{‬
‫‪9‬‬ ‫;‪this.Name = name‬‬
‫‪10‬‬ ‫}‬
‫‪11‬‬ ‫}‬
‫‪12‬‬
‫‪14‬‬ ‫{‬
‫‪16‬‬ ‫{‬
‫‪17‬‬ ‫;]‪Person[] people = new Person[3‬‬
‫‪18‬‬
‫‪19‬‬ ‫;)"‪people[0] = new Person("Johnny‬‬
‫‪20‬‬ ‫;)"‪people[1] = new Person("Mike‬‬
‫‪21‬‬ ‫;)"‪people[2] = new Person("Sonny‬‬
‫‪22‬‬
‫‪23‬‬ ‫)‪for (Person person : people‬‬
‫‪24‬‬ ‫{‬
‫‪25‬‬ ‫;)‪System.out.println(person.Name‬‬
‫‪26‬‬ ‫}‬
‫‪27‬‬ ‫}‬
‫‪28‬‬ ‫}‬
‫ابتدا یک کالس که دارای یک فیلد است تعریف می کنیم‪ .‬سپس یک آرایه از کالس ایجاد شده را تعریف و سپس عناصر آن را مانند‬
‫باال مقدار دهی می کنیم‪ .‬سپس مقدار فیلد هر یک از نمونه ها را با استفاده از یک حلقه ‪ foreach‬نمایش می دهیم‪ .‬می توان‬
‫از تکنیک های دیگر که قبال در مورد ایجاد آرایه آموختید هم استفاده کنید‪ .‬مثال خطوط ‪ 31-53‬کد باال را می توان به صورت زیر هم‬
‫نوشت ‪:‬‬
‫‪۵۹۹‬‬ ‫مبانی زبان جاوا‬
‫][‪Person[] people = new Person‬‬

‫{‬
‫‪new Person("Johnny"),‬‬
‫‪new Person("Mike"),‬‬
‫)"‪new Person("Sonny‬‬
‫;}‬
‫در اینجا‪ ،‬تعداد عناصر آرایه ‪ 1 ،people‬می باشد و کمپایلر هم با شمارش تعداد نمونه ها آن را تشخیص می دهد‪ .‬از این تکنیک‬
‫برای ساخت آرایه های چند بعدی و دندانه دار هم می توان استفاده کرد‪.‬‬
‫عبارات المبدا‬
‫عبارت المبدا )‪ (Lambda expressions‬در اصل یک متد بی نا م است‪ .‬این متد ناشناس به تنهایی قابل اجرا نیست و برای‬
‫پیادهسازی متدی که در یک رابط تابعی یا ‪ functional interface‬تعریف شده به کار میرود‪ .‬رابط تابعی‪ ،‬اینترفیسی است که‬
‫فقط و فقط یک متد در آن تعریف شده است‪ .‬فرض کنید یک رابط تابعی به صورت زیر داریم ‪:‬‬
‫‪interface MyMessage‬‬
‫{‬
‫;)‪void ShowMessage(String message‬‬
‫}‬
‫یک راه برای ‪ Override‬کردن متد این رابط استفاده از کالس های داخلی بی نام به صورت زیر می باشد ‪:‬‬

‫{‬
‫{‬
‫}‬

‫{‬
‫)(‪MyMessage m = new MyMessage‬‬
‫{‬
‫)‪public void ShowMessage(String message‬‬
‫{‬
‫}‬
‫;}‬
‫;)"!‪m.ShowMessage("Hello World‬‬
‫}‬
‫}‬
‫ولی یک راه ساده تر هم وجود دارد و آن استفاده از عبارات المبدا است‪ .‬در کد زیر متد )(‪ ShowMessage‬با استفاده از عبارات‬
‫المبدا پیاده سازی شده است ‪:‬‬

‫{‬
‫{‬
‫}‬

‫{‬
‫;)‪MyMessage m = (message) -> System.out.println(message‬‬
‫;)"!‪m.ShowMessage("Hello World‬‬
‫}‬
‫}‬
‫‪Hello World‬‬
‫روش کلی استفاده از عبارات المبدا به صورت زیر است ‪:‬‬
‫‪parameter -> expression body‬‬
‫در عبارت المبدا ابتدا پارامترها را بدون ذکر نوعشان می نویسیم و بعد از عملگر >‪ -‬استفاده می کنیم‪ .‬سپس دستوراتی را که قرار‬
‫است اجرا شوند را می نویسیم‪ .‬نوع پارامترها به صورت خودکار به وسیله کمپایلر تشخیص داده می شود‪ .‬البته امضاء عبارات المبدا‬
‫باید شبیه به امضاء متد باشد‪ .‬عبارات المبدا دارای اشکال زیادی هستند‪ .‬به عنوان مثال در مثال باال از یک عبارت المبدایی استفاده‬
‫کرده ایم که دارای یک دستور ساده اجرایی است‪ .‬اگر متد شما برای عبارت المبدا هیچ پارامتری نداشته باشد‪ ،‬همه کاری که الزم‬
‫است نجام دهید این است که هیچ پارامتری در داخل عبارت المبدا قرار ندهید ‪:‬‬

‫{‬
‫{‬
‫;)(‪void ShowMessage‬‬
‫}‬
1۱۵ ‫مبانی زبان جاوا‬

{
MyMessage m = () -> System.out.println("Hello World!");
m.ShowMessage();
}
}
Hello World!
. ‫به این نکته توجه کنید که شما می توانید نوع پارامترهای عبارت المبدا را نشان دهید‬

{
interface MyMessage
{
void ShowMessage(String message);
}

{
MyMessage m = (String message) -> System.out.println(message);
m.ShowMessage("Hello World!");
}
}
Hello World!
‫ به عبارت المبدایی که دارای‬.‫اگر عبارات المبدای شما دارای چندین دستور اجرایی باشند می توانید آنها را داخل آکوالد قرار دهید‬
.‫آکوالد باشد بالک المبدا می گویند‬

{
interface MyMessage
{
void ShowMessage(String message);
}

{
MyMessage m = (message) ->
{
System.out.println(message);
System.out.println("Some more message");
};
m.ShowMessage("Hello World!");
}
}
‫‪Some more message‬‬
‫در زیر مثالی از یک عبارت المبدا که دارای مقدار برگشتی است نشان داده شده است ‪:‬‬
‫;} ;)‪SampleInterface GetSquare = (number) -> { return (number * number‬‬
‫به این نکته توجه کنید که هنگام استفاده از دستور ‪ return‬باید همیشه از دستورات المبدایی استفاده کنید که دارای آکوالد می‬
‫باشند‪ .‬اگر یک عبارت المبدا فقط دارای یک دستور ‪ return‬ساده باشد می توانید به سادگی آن را به ‪expression lambda‬‬
‫تبدیل کنید‪.‬‬
‫;)‪SampleInterface GetSquare = (number) -> (number * number‬‬
‫به این نکته توجه کنید که استفاده از پرانتز در کد باال برای فه م بهتر آن است‪ .‬اگر یک عبارت المبدا دارای یک پارامتر ساده و یک‬
‫دستور ‪ return‬است‪ ،‬می توانید برای سادگی بیشتر پرانتزها را حذف نمایید ‪:‬‬
‫;‪SampleInterface GetSquare = (number) -> number * number‬‬
‫عبارت المبدای باال دارای دو پارامتر است و حاصل جمع آنها را بر می گرداند‪.‬‬
‫یک مثال از عبارت المبدا‬
‫می توان عبارات المبدا را به عنوان آرگومان به دیگر متد ها ارسال کرد‪ .‬به مثال زیر توجه کنید ‪:‬‬

‫‪2‬‬
‫‪4‬‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫‪interface Arithmetic‬‬
‫‪8‬‬ ‫{‬
‫‪9‬‬ ‫;)‪int Operation(int x, int y‬‬
‫‪10‬‬ ‫}‬
‫‪11‬‬
‫‪12‬‬ ‫)‪public static int GetResult(Arithmetic arithmetic, int num1, int num2‬‬
‫‪13‬‬ ‫{‬
‫‪14‬‬ ‫;)‪return arithmetic.Operation(num1, num2‬‬
‫‪15‬‬ ‫}‬
‫‪16‬‬
‫‪18‬‬ ‫{‬
‫‪1۱۳‬‬ ‫مبانی زبان جاوا‬

‫‪20‬‬
‫‪21‬‬ ‫;)" ‪System.out.print("Enter first number:‬‬
‫‪22‬‬ ‫;)(‪int num1 = input.nextInt‬‬
‫‪23‬‬ ‫;)" ‪System.out.print("Enter second number:‬‬
‫‪24‬‬ ‫;)(‪int num2 = input.nextInt‬‬
‫‪25‬‬
‫‪26‬‬ ‫‪System.out.println(); // Separator‬‬
‫‪27‬‬
‫‪28‬‬ ‫‪System.out.println("Sum‬‬ ‫=‬ ‫"‬ ‫‪+‬‬ ‫‪GetResult((x,‬‬ ‫‪y)->x‬‬ ‫‪+‬‬ ‫‪y,‬‬ ‫‪num1,‬‬ ‫;))‪num2‬‬
‫‪29‬‬ ‫‪System.out.println("Difference‬‬ ‫=‬ ‫"‬ ‫‪+‬‬ ‫‪GetResult((x,‬‬ ‫‪y)->x‬‬ ‫‪-‬‬ ‫‪y,‬‬ ‫‪num1,‬‬ ‫;))‪num2‬‬
‫‪30‬‬ ‫‪System.out.println("Product‬‬ ‫=‬ ‫"‬ ‫‪+‬‬ ‫‪GetResult((x,‬‬ ‫‪y)->x‬‬ ‫*‬ ‫‪y,‬‬ ‫‪num1,‬‬ ‫;))‪num2‬‬
‫‪31‬‬ ‫‪System.out.println("Quotient‬‬ ‫=‬ ‫"‬ ‫‪+‬‬ ‫‪GetResult((x,‬‬ ‫‪y)->x‬‬ ‫‪/‬‬ ‫‪y,‬‬ ‫‪num1,‬‬ ‫;))‪num2‬‬
‫‪32‬‬ ‫}‬
‫‪33‬‬ ‫}‬
‫ابتدا در خطوط ‪ 1-33‬یک رابط ایجاد می کنیم که دارای متدی است که دو آرگومان از نوع اعداد صحیح را قبول کرده و یک مقدار‬
‫صحیح را بر می گرداند‪ .‬سپس از این رابط به عنوان یکی از پارامترهای متد )(‪ GetResult‬استفاده می کنیم(خطوط ‪ )35-31‬دو‬
‫پارامتر دیگر‪ ،‬دو عدد هستند که همانطور که خواهیم دید در عملیاتهای مختلف نقش دارند‪ .‬از آنجاییکه اولین پارامتر یک رابط‬
‫است‪ ،‬آرگومانی که به آن ارسال می شود باید پیاده سازی متد آن باشد‪ .‬با استفاده از عبارت المبدا می توان کدهای خواناتری نوشت‬
‫و همچنین کدنویسی را کاهش داد‪ .‬در خطوط ‪ 50-13‬متد )(‪ GetResult‬را فراخوانی می کنیم‪ .‬توجه کنید که متد در هر فراخوانی‬
‫یک عبارت المبدا را به عنوان اولین آرگومان قبول می کند‪.‬‬
‫مدیریت استثناءها و خطایابی‬

‫بهترین برنامه نویسان در هنگام برنامه نویسی با خطاها و باگها در برنامهشان مواجه میشوند‪ .‬درصد زیادی از برنامهها هنگام‬
‫تست برنامه با خطا مواجه میشوند‪ .‬بهتر است برای از بین بردن یا به حداقل رساندن این خطاها‪ ،‬به کاربر در مورد دالیل به وجود‬
‫آمدن آنها اخطار داده شود‪ .‬خوشبختانه جاوا برای این مشکل راه حلی ارائه داده است‪ .‬جاوا دارای مجموعه بزرگی از کالسهایی‬
‫است که برای برطرف کردن خطاهای خاص از آنها استفاده میکند‪ .‬استثناءها در جاوا راهی برای نشان دادن دلیل وقوع خطا در‬
‫هنگام اجرای برنامه است‪.‬‬
‫جاوا دارای مجموعه بزرگی از کالسهای استثناء است که شما میتوانید با استفاده از آنها خطاهایی که در موقعیتهای مختلف روی‬
‫میدهند را برطرف کنید‪ .‬حتی میتوانید یک کالس استثناء شخصی ایجاد کنید‪ .‬استثناءها توسط برنامه به وجود میآیند و شما‬
‫الزم است که آنها را اداره کنید‪ .‬به عنوان مثال در دنیای کامپیوتر یک عدد صحیح هرگز نمیتواند بر صفر تقسیم شود‪ .‬اگر بخواهید‬
‫این کار را انجام دهید (یک عدد صحیح را بر صفر تقسیم کنید)‪ ،‬با خطا مواجه میشوید‪ .‬اگر یک برنامه در جاوا با چنین خطایی‬
‫مواجه شود پیغام خطای ”‪ “java.lang.ArithmeticException: / by zero‬نشان داده میشود که بدین معنا است که عدد‬
‫را نمیتوان بر صفر تقسیم کرد‪.‬‬
‫باگ )‪ (Bug‬صطالحا خطا یا کدی است که رفتارهای ناخواسته ای در برنامه ایجاد میکند‪ .‬خطایابی فرایند برطرف کردن باگها‬
‫است‪ ،‬بدین معنی که خطاها را از برنامه پاک کنیم‪ Netbeans .‬دارای ابزارهایی برای خطایابی هستند‪ ،‬که خطاها را یافته و به شما‬
‫اجازه میدهند آنها را برطرف کنید‪ .‬در درسهای آینده خواهید آموخت که چگونه از این ابزارهای کارآمد جهت برطرف کردن‬
‫باگها استفاده کنید‪ .‬قبل از اینکه برنامه را به پایان برسانید الزم است که برنامهتان را اشکال زدایی کنید‪.‬‬
‫استثناءهای اداره نشده‬
‫استثناءهای اداره نشده‪ ،‬استثناءهایی هستند که به درستی توسط برنامه اداره نشدهاند و باعث میشوند که برنامه به پایان برسد‪.‬‬
‫در اینجا میخواهیم به شما نشان دهیم که وقتی یک برنامه در زمان اجرا با یک استثناء مواجه میشود و آن را اداره نمیکند چه‬
‫اتفاقی میافتد‪ .‬در آینده خواهید دید که یک استثناء چگونه به صورت بالقوه باعث نابودی جریان و اجرای برنامه شما میشود‪ .‬به‬
‫برنامه زیر توجه کنید‪:‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;‪int five = 5‬‬
‫‪8‬‬ ‫;‪int zero = 0‬‬
‫‪9‬‬
‫‪10‬‬ ‫‪//Generate an exception by dividing 5 by 0‬‬
‫‪11‬‬ ‫;‪int result = five / zero‬‬
‫‪12‬‬ ‫}‬
‫‪13‬‬ ‫}‬
‫همانطور که در مثال باال مشاهده میکنید تقسیم یک عدد صحیح بر صفر غیر مجاز است و باعث ایجاد خطای‬
‫‪ java.lang.ArithmeticException: / by zero‬میشود‪ .‬برنامه را با زدن دکمه ‪ F6‬اجرا میکنیم‪ .‬برنامه با موفقیت اجرا‬
‫شده ولی با پیغام خطای زیر مواجه میشوید‪:‬‬

‫‪1۱۱‬‬ ‫مبانی زبان جاوا‬
‫‪Exception in thread "main" java.lang.ArithmeticException: / by zero‬‬

‫)‪at myfirstprogram.MyFirstProgram.main(MyFirstProgram.java:11‬‬
‫همانطور که مشاهده میکنید با اجرای برنامه اطالعاتی در باره خروجیها و یا خطاهای آن در پنجره ‪ Output‬نمایش داده میشود‬
‫‪:‬‬
‫پنجره ‪ Output‬پنجره ای مفید است که در مورد استثناء اطالعاتی در اختیار شما میگذارد و معموال محل دقیق خطا را به شما‬
‫نشان میدهد که در شکل باال خط ‪ (MyFirstProgram.java:11) 33‬نشان داده شده است‪.‬‬
‫دستور ‪ try‬و ‪catch‬‬
‫میتوان خطاها را با استفاده از دستور ‪ try…catch‬اداره کرد‪ .‬بدین صورت که کدی را که احتمال میدهید ایجاد خطا کند در داخل‬
‫بلوک ‪ try‬قرار میدهید‪ .‬بلوک ‪ catch‬هم شامل کدهایی است که وقتی اجرا میشوند که برنامه با خطا مواجه شود‪ .‬تعریف سادهی‬
‫این دو بلوک به این صورت است که بلوک ‪ try‬سعی میکند که دستورات را اجرا کند و اگر در بین دستورات خطایی وجود داشته‬
‫باشد برنامه دستورات مربوط به بخش ‪ catch‬را انجام میدهد‪ .‬برنامه زیر نحوه استفاده از دستور ‪ try…catch‬را نمایش میدهد‬
‫‪:‬‬
2
4 {
6 {
7 int result;
8 int x = 5;
9 int y = 0;
10
11 try
12 {
13 result = x / y; //ERROR
14 }
15 catch(ArithmeticException e)
16 {
17 System.out.println("An attempt to divide by 0 was detected.");
18 }
19 }
20 }
An attempt to divide by 0 was detected.
/ by ‫ نتیجه محاسبه به وجود آمدن خطای‬.‫ است تقسیم کردهایم‬3 ‫ که مقدار آن‬y ‫ است بر‬1 ‫ را که‬x ‫ مقدار‬،try ‫در داخل بلوک‬
.‫ اجرا میشوند‬catch ‫ از آنجاییکه در برنامه باال خطایی به وجود آمده است کدهای داخل بلوک‬.‫ ( عدد تقسیم بر صفر) است‬zero
:‫بنابراین‬
try
{
result = x / y; //Error: Jump to catch block
System.out.println("This line will not be executed.");
}
catch(ArithmeticException e)
{
System.out.println("An attempt to divide by 0 was detected.");
}
‫ که کالس‬catch ‫همانطور که در مثال باال مشاهده میکنید از یک نوع استثناء مخصوص به یک خطا در داخل بلوک‬
‫ همچنین میتوانید مقدار استثنا را در داخل یک متغیر قرار داده و سپس آن را‬.‫ است استفاده کردهایم‬ArithmeticException
:‫نمایش دهید‬
try
{
result = x / y; //ERROR
}
catch(ArithmeticException error)
{
System.out.println(error.getMessage());
}
‫‪1۱1‬‬ ‫مبانی زبان جاوا‬
‫‪/ by zero‬‬
‫متغیر دارای اطالعات مفیدی در مورد استثناء به وجود آمده است‪ .‬برای نمایش اطالعاتی در مورد استثناء هم از متد )(‪getMessage‬‬
‫استفاده میکنیم‪ .‬همه کالسهای استثناء توضیحاتی در مورد خطاها میدهند‪ .‬در درسهای آینده در مورد خصوصیات استثناءها‬
‫بیشتر توضیح میدهیم‪ .‬اگر فکر میکنید که در بلوک ‪ try‬ممکن است با چندین خطا مواجه شوید میتوانید از چندین بلوک ‪catch‬‬
‫استفاده نمایید ولی به یاد داشته باشید که برای هر کدام از آن خطاها از کالس استثناء مربوط به هر یک استفاده کنید‪:‬‬
‫;‪int result‬‬
‫;‪int x = 5‬‬
‫;‪int y‬‬
‫‪try‬‬
‫{‬
‫;)(‪y = input.nextInt‬‬
‫‪result = x / y; //ERROR‬‬
‫}‬
‫)‪catch(ArithmeticException error‬‬
‫{‬
‫;))(‪System.out.println(error.getMessage‬‬
‫}‬
‫)‪catch(InputMismatchException error‬‬
‫{‬
‫}‬
‫از انجاییکه مقدار ‪ y‬به وسیله ورودی که از کاربر گرفته میشود‪ ،‬تعیین میشود‪ ،‬مقدار آن باید با توجه به مثال باال غیر صفر باشد‬
‫(عدد تقسیم بر صفر تعریف نشده است)‪ .‬اما یک مشکل وجود دارد‪.‬چون ممکن است که کاربر یک مقدار غیر عددی وارد کند (مثال‬
‫یک حرف) که در این صورت برنامه نمیتواند حرف را به عدد تبدیل کند و خطای نوع )‪ (InputMismatchException‬اتفاق‬
‫میافتد‪ .‬وقتی استثناء اتفاق افتاد بلوک ‪ catch‬مربوط به این خطا اجرا میشود و محاسبه خارج قسمت تقسیم ‪ x‬بر ‪ y‬نادیده گرفته‬
‫میشود‪ .‬قسمت ‪ catch‬کد باال را به صورت زیر هم میتوان نوشت‪:‬‬
‫)‪catch(ArithmeticException | InputMismatchException error‬‬

‫{‬
‫}‬
‫حال فرض کنید شما میخواهید تمام خطاهای احتمالی که ممکن است در داخل بلوک ‪ try‬اتفاق می افتند را فهمیده و اداره کنید‬
‫این کار چگونه امکانپذیر است؟ به راحتی و با استفاده از کالس عمومی ‪ Exception‬میتوانید این کار را انجام داد‪ .‬هر کالس‬
‫استثناء در جاوا از این کالس ارث بری میکند بنابراین شما میتوانید هر نوع استثناءیی را در شیئی از کالس ‪ Exception‬ذخیره‬
‫نمایید‪.‬‬
‫‪try‬‬
‫{‬
‫‪//Put your codes to test here‬‬
‫}‬
‫)‪catch (Exception error‬‬
‫{‬
‫;)‪System.out.println(error.Message‬‬
‫}‬
‫با استفاده از این روش دیگر الزم نیست نگران اتفاق خطاهای احتمالی باشید چون بلوک ‪ catch‬برای هر گونه خطایی که در داخل‬
‫بلوک ‪ try‬تشخیص داده شود پیغام مناسبی نشان میدهد‪ .‬به این نکته توجه کنید که اگر بخواهید از کالس پایه ‪Exception‬‬
‫همراه با سایر کالسهای استثناء دیگر که از آن مشتق میشوند در برنامه استفاده کنید باید کالس پایه ‪ Exception‬در آخرین بلوک‬
‫‪ catch‬قرار گیرد‪.‬‬
‫‪try‬‬
‫{‬
‫‪//Put your codes to test here‬‬
‫}‬
‫)‪catch (ArithmeticException e‬‬
‫{‬
‫;)"‪System.out.println("Division by zero is not allowed.‬‬
‫}‬
‫)‪catch (InputMismatchException e‬‬
‫{‬
‫;)"‪System.out.println("Error on converting the data to proper type.‬‬
‫}‬
‫)‪catch (Exception e‬‬
‫{‬
‫;)"‪System.out.println("An error occured.‬‬
‫}‬
‫اگر کالس پایه ‪ Exception‬را در اولین بلوک ‪ catch‬قرار دهیم و خطایی در برنامه رخ دهد چون تمام کالسهای استثناء از این‬
‫کالس مشتق میشوند در نتیجه اولین بلوک ‪ catch‬اجرا شده و سایر بلوکها حتی با وجود اینکه خطای مورد نظر به آنها مربوط‬
‫باشد اجرا نمیشوند‪.‬‬
‫بلوک ‪finally‬‬
‫گاهی اوقات میخواهید برخی کدها همیشه اجرا شوند خواه استثنا رخ دهد‪ ،‬خواه رخ ندهد‪ ،‬در این صورت از بلوک ‪finally‬‬
‫استفاده میشود‪ .‬قبال یاد گرفتیم که اگر در بلوک ‪ try‬یک استثناء رخ دهد همه کدهای موجود در این بلوک نادیده گرفته شده و‬
‫برنامه به قسمت ‪ catch‬میرود‪ .‬کدهای نادیده گرفته شده ممکن است در برنامه نقش حیاتی داشته باشند‪.‬‬
‫‪1۱۹‬‬ ‫مبانی زبان جاوا‬
‫هدف بلوک ‪ finally‬هم حفظ نقش این کدها به صورت غیر مستقیم است‪ .‬کدهایی را که فکر میکنید کدهای پایه ای هستند و‬
‫برای اجرای برنامه الزم هستند را در داخل بلوک ‪ finally‬قرار دهید‪ .‬برنامه زیر نحوه استفاده از این بلوک را نشان میدهد‪:‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;‪int result‬‬
‫‪8‬‬ ‫;‪int x = 5‬‬
‫‪9‬‬ ‫;‪int y = 0‬‬
‫‪10‬‬
‫‪11‬‬ ‫‪try‬‬
‫‪12‬‬ ‫{‬
‫‪13‬‬ ‫‪result = x / y; //ERROR‬‬
‫‪14‬‬ ‫}‬
‫‪15‬‬ ‫)‪catch(ArithmeticException error‬‬
‫‪16‬‬ ‫{‬
‫‪17‬‬ ‫;))(‪System.out.println(error.getMessage‬‬
‫‪18‬‬ ‫}‬
‫‪19‬‬ ‫‪finally‬‬
‫‪20‬‬ ‫{‬
‫‪21‬‬ ‫;)"‪System.out.println("finally blocked was reached.‬‬
‫‪22‬‬ ‫}‬
‫‪23‬‬ ‫}‬
‫‪24‬‬ ‫}‬
‫‪\ by zero.‬‬
‫‪finally blocked was reached.‬‬
‫بلوک ‪ finally‬بعد از بلوک ‪ catch‬نوشته میشود‪ .‬اگر از چندین بلوک ‪ catch‬در برنامه استفاده میکنید بلوک ‪ finally‬باید بعد‬
‫از همه آنها قرار گیرد‪ .‬میتوان از بلوک ‪ try‬و ‪ finally‬در صورتی که بلوک ‪ catch‬نداشته باشیم به صورت زیر استفاده کرد‪.‬‬
‫‪try‬‬
‫{‬
‫‪//some code‬‬
‫}‬
‫‪finally‬‬
‫{‬
‫}‬
‫از این بلوک معموال برای بستن یک اتصال پایگاه داده یا بستن یک فایل استفاده میشود‪.‬‬
‫ایجاد استثناء‬
‫شما میتوانید در هر جای برنامه یک خطای ساختگی ایجاد کنید‪ .‬همچنین اگر پیغام پیشفرض استثناءها را دوست ندارید میتوانید‬
‫به دلخواه خودتان یک پیغام برای نمایش ایجاد کنید‪ .‬به مثال زیر توجه کنید‪:‬‬
2
4
6 {
8 {
10
11 int firstNumber, secondNumber, result;
12
13 System.out.print("Enter the first number: ");
14 firstNumber = input.nextInt();
15
16 System.out.print("Enter the second number: ");
17 secondNumber = input.nextInt();
18
19 try
20 {
21 if (secondNumber == 0)
22 {
23 throw new ArithmeticException();
24 }
25 else
26 {
27 result = firstNumber / secondNumber;
28 }
29 }
30 catch (ArithmeticException error)
31 {
32 System.out.println(error.getMessage());
33 }
34
35 }
36 }
Enter the first number: 10

Enter the second number: 0
null
‫ میتوان مستقیما‬.‫ استفاده کردهایم‬throw ‫ از کلمه کلیدی‬exception ‫ و درست قبل از یک نمونه ایجاد شده از کالس‬51 ‫در خط‬
:‫ به مثال زیر توجه کنید‬.‫ ایجاد و یک خطا را به دام انداخت‬exception ‫یک نمونه از کالس‬
ArithmeticException error = new ArithmeticException();
throw error;
‫ که یک رشته را دریافت‬Exception ‫همچنین میتوان یک پیغام خطای سفارشی را به وسیله یکی دیگر از سربارگذاری های کالس‬
.‫ نمایش داد‬،‫و آن را به عنوان پیغام خطا نمایش میدهد‬
throw new ArithmeticException("Cannot divide by zero!");

1۵۵ ‫مبانی زبان جاوا‬
‫ ایجاد استثناء بیشتر در مواقعی به کار‬.‫ ذخیره میشود‬getMessag() ‫در این حالت پیغام خطای پیشفرض تغییر کرده و در متد‬
.‫میرود که یک کد در حالت عادی خطا ندارد ولی شما میخواهید در هر صورت به عنوان یک خطا در نظر گرفته شود‬
‫تعریف یک استثناء توسط کاربر‬
‫ استثنایی است که توسط کاربر تعریف میشود و باید از کالس‬،‫ استثناء سفارشی‬.‫در جاوا میتوان یک استثناء سفارشی ایجاد کرد‬
‫ به کد زیر‬.‫ ارث میبرد ایجاد میکنیم‬Exception ‫ برای این کار یک کالس جداگانه که از کالس پایه‬.‫ ارث بری کند‬Exception ‫پایه‬
:‫توجه کنید‬
2
4
5
6 class NegativeNumberException extends Exception
7 {
8 public NegativeNumberException()
9 {
10 super("The operation will result to a negative number.");
11 }
12
13 public NegativeNumberException(String message)
14 {
15 super(message);
16 }
17
18 public NegativeNumberException(String message, Exception inner)
19 {
20 super(message, inner);
21 }
22 }
23
25 {
26
28 {
30
31 int firstNumber, secondNumber, difference;
32
33 System.out.print("Enter the first number: ");
34 firstNumber = input.nextInt();
35
36 System.out.print("Enter the second number: ");
37 secondNumber = input.nextInt();
38
39 difference = firstNumber - secondNumber;
40
41 try
42 {
‫‪43‬‬ ‫)‪if (difference < 0‬‬

‫‪44‬‬ ‫{‬
‫‪45‬‬ ‫;)(‪throw new NegativeNumberException‬‬
‫‪46‬‬ ‫}‬
‫‪47‬‬ ‫}‬
‫‪48‬‬ ‫)‪catch (NegativeNumberException error‬‬
‫‪49‬‬ ‫{‬
‫‪50‬‬ ‫;))(‪System.out.println(error.getMessage‬‬
‫‪51‬‬ ‫}‬
‫‪52‬‬ ‫}‬
‫‪53‬‬ ‫}‬
‫‪Enter the first number: 10‬‬

‫‪Enter the second number: 11‬‬
‫‪The operation will result to a negative number.‬‬
‫در خط ‪ 1‬مشاهده میکنید کالس ایجاد شده توسط ما از کالس ‪ Exception‬ارث بری کرده است‪ .‬به عنوان یک قرارداد باید به آخر‬
‫نام کالسهای استثنایی که توسط کاربر تعریف میشوند کلمه ‪ Exception‬اضافه شده و ‪ 1‬سازنده برای آنها تعریف شود‪.‬‬
‫اولین سازنده بدون پارامتر میباشد‪.‬‬ ‫‪‬‬
‫دومین سازنده یک آرگومان از نوع رشته برای نمایش پیغام خطا قبول میکند‪.‬‬ ‫‪‬‬
‫سومین سازنده که دو آرگومان قبول میکند‪ ،‬یکی پیغام خطا را نمایش داده و یکی بخش ‪ inner‬است آن برای نشان‬ ‫‪‬‬
‫دادن علت وقوع استثناء میباشد‪.‬‬
‫حال میخواهیم یک کالس استثناء خیلی سفارشی ایجاد کنیم‪ .‬به خطوط ‪ 56-13‬توجه کنید‪ .‬چون که قرار است که از کاربر ورودی‬
‫دریافت کنیم از کالس ‪ Scanner‬در خط ‪ 56‬استفاده کردهایم‪ .‬از آنجاییکه تولید یک عدد منفی در هیچ برنامه ای یک استثناء‬
‫محسوب نمیشود‪ ،‬ما به صورت دستی و برای خودمان یک استثناء ایجاد کردهایم‪ .‬ابتدا از کاربر میخواهیم که دو مقدار را وارد کند‬
‫(خطوط ‪ .)11-11‬سپس تفاوت دو عدد را محاسبه میکنیم (خط ‪ .)16‬در داخل بلوک ‪ try‬تست میکنیم که آیا حاصل تفریق دو‬
‫عدد‪ ،‬یک عدد منفی است (خط ‪ .)33-31‬اگر یک عدد منفی بود سپس یک نمونه از کالس ‪ NegativeNumberException‬ایجاد‬
‫میکنیم (خط ‪ .)31‬بعد از ایجاد نمونه به وسیله بلوک ‪ catch‬و برای نشان داده پیغام خطا آن را اداره میکنیم (خطوط ‪.)30-13‬‬
‫مقایسه اشیاء با استفاده از رابط های ‪ Comparable‬و ‪Comparator‬‬

1۵۳ ‫مبانی زبان جاوا‬
‫ می‬Comparator ‫ و‬Comparable ‫ این دو رابط‬.‫دو رابط مفید برای مقایسه اشیایی که توسط کاربر تعریف شده اند وجود دارد‬
‫ در یک کالس پیاده سازی می شود و اجازه می دهد کالس یا شی ایجاد شده از کالس با اشیاء دیگر از‬Comparable ‫ رابط‬.‫باشند‬
‫ پیاده‬،‫ همانطور که از نام این رابط پیداست‬.‫ در یک کالس جداگانه پیاده سازی می شود‬Comparator.‫همین کالس مقایسه شوند‬
‫ گاهی اوقات الزم است که بخواهید دو شیء را بر اساس یک فیلد یا‬.‫سازی آن باعث ایجاد یک کالس مقایسه پذیر می شود‬
‫ حال به نحوه استفاده از‬.‫ انجام دهید‬Comparator ‫ این کار را می توانید با استفاده از پیاده سازی رابط‬،‫خاصیت مقایسه کنید‬
. ‫ می پردازیم‬Comparable ‫رابط‬
Comparable ‫رابط‬
: ‫ را پیاده سازی می کند‬Comparable ‫در مثال زیر یک کالس نشان داده شده است که رابط‬
2
3 class Person implements Comparable<Person>
4 {
7 public int Age;
8
9 public Person(String FirstName, String LastName, int Age)
10 {
11 this.FirstName = FirstName;
12 this.LastName = LastName;
13 this.Age = Age;
14 }
15
16 @Override
17 public int compareTo(Person other)
18 {
19 if (this.Age > other.Age)
20 return 1;
21 else if (this.Age < other.Age)
22 return -1;
23 else
24 return 0;
25 }
26 }
27
29 {
31 {
32 Person person1 = new Person("John", "Smith", 21);
33 Person person2 = new Person("Mark", "Logan", 19);
34 Person person3 = new Person("Luke", "Adams", 20);
35
36 Person youngest = GetYoungest(person1, person2, person3);
37 Person oldest = GetOldest(person1, person2, person3);

38
39 System.out.println(String.format("The youngest person is %s %s",
40 youngest.FirstName, youngest.LastName));
41 System.out.println(String.format("The oldest person is %s %s",
42 oldest.FirstName, oldest.LastName));
43 }
44
45 private static Person GetYoungest(Person person1, Person person2, Person person3)
46 {
47 Person youngest = person1;
48
49 if (person2.compareTo(youngest) == -1)
50 youngest = person2;
51
52 if (person3.compareTo(youngest) == -1)
53 youngest = person3;
54
55 return youngest;
56 }
57
58 private static Person GetOldest(Person person1, Person person2, Person person3)
59 {
60 Person oldest = person1;
61
62 if (person2.compareTo(oldest) == 1)
63 oldest = person2;
64
65 if (person3.compareTo(oldest) == 1)
66 oldest = person3;
67
68 return oldest;
69 }
70 }
The youngest person is Mark Logan

The oldest person is John Smith
‫ را نیز‬compareTo() ‫ الزم است که تنها متد آن یعنی متد‬،)1 ‫ استفاده می کند (خط‬Comparable ‫وقتی که یک کالس از رابط‬
‫ این متد همچنین یک آرگومان قبول می‬.‫ یک مقدار صحیح را بر می گرداند‬compareTo() ‫) متد‬31-51 ‫پیاده سازی کند (خطوط‬
‫( شخص‬age) ‫ در مثال باال ما سن‬compareTo() ‫ در داخل متد‬.‫کند که همان شیی است که قرار است با شی جاری مقایسه شود‬
‫ طبق قرارداد اگر سن شخص مورد نظر ما از سن شخص دیگر بیشتر بود مقداری‬.‫فعلی را با سن شخص دیگر مقایسه کرده ایم‬
‫ پیاده سازی‬50-16 ‫ خطوط‬.‫ اگر کمتر بود مقداری کمتر از صفر و اگر مساوی بود مقدار صفر برگشت داده می شود‬،‫بزرگتر از صفر‬
.‫ برنامه جوانترین و پیرترین شخص را تشخیص می دهد‬.‫ را نشان می دهد‬Person ‫ توسط شی‬Comparable ‫رابط‬
‫‪1۵۱‬‬ ‫مبانی زبان جاوا‬
‫در خطوط ‪ 15-13‬سه شی ‪ Person‬با مقادیر کامال اختیاری ایجاد شده است‪ .‬در خطوط ‪ 11-11‬متغیرهایی برای نگهداری جوانترین‬
‫و پیرترین شخص تعریف شده اند‪ .‬در خط ‪ 11‬متد )(‪ GetYoungest‬را فراخوانی کرده ایم‪ .‬این متد در خطوط ‪ 31-11‬تعریف‬
‫شده است و سه شخص را که قرار است از لحاظ سنی با هم مقایسه شوند را قبول می کند‪.‬‬
‫در خط ‪ 31‬فرض را بر این گذاشته ایم که اولین شخص )‪ (person1‬جوانترین شخص است‪ .‬سپس با استفاده از پیاده سازی متد‬
‫)(‪ compareTo‬تست می کنیم که آیا شخص دوم )‪ (person2‬از شخص اول جوانتر است یا نه‪ .‬در داخل متد مذکور سن شخص‬
‫دوم و اول را با هم مقایسه می کنیم‪ .‬اگر سن شخص دوم کمتر بود‪ ،‬باید مقدار ‪ -3‬برگشت داده شده و در خط ‪ person2 ،13‬به‬
‫عنوان جوانترین شخص معرفی شود‪ .‬در خطوط ‪ 15-11‬از تکنیکی مشابه برای شخص سوم استفاده کرده ایم‪ .‬بعد از مقایسه‬
‫جوانترین شخص در خط ‪ 11‬به عنوان نتیجه برگشت داده می شود‪ .‬در خط ‪ 11‬متد )(‪ GetOldest‬که در خطوط ‪ 10-16‬تعریف‬
‫شده است فراخوانی می شود‪ .‬کد های داخل این متد شبیه به متد )(‪ GetYoungest‬است با این تفاوت که تست می شود که‬
‫آیا سن شخص دیگر بزرگتر از سن شخص مورد نظر ماست یا نه؟ بنابراین باید انتظار داشته باشیم که مقدار ‪ 3‬به جای ‪ -3‬توسط متد‬
‫برگشت داده شود‪ .‬در خطوط ‪ 16‬و ‪ 33‬نام جوانترین و پیرترین شخص چاپ می شود‪.‬‬
‫نکته ‪ :‬پیاده سازی رابط ‪ Comparable‬یک مشکل دارد و آن این است که اشیاء فقط به یک طریق مرتب می شوند مثال بر حسب‬
‫نام‪ .‬با این روش نمی توان یک بار بر حسب نام ‪ ،‬یک بار دیگر بر حسب مثال فامیلی و … اشیاء را مرتب کرد ‪.‬‬
‫رابط ‪Comparator‬‬
‫‪ Comparator‬در یک کالس جداگانه پیاده سازی می شود‪ .‬همانطور که از نام این رابط پیداست‪ ،‬پیاده سازی آن باعث ایجاد یک‬
‫کالس مقایسه پذیر می شود‪ .‬به وسیله این رابط می توان چندین مقایسه برای کالس ‪ Person‬ایجاد کرد‪.‬یعنی می توان مقایسه‬
‫های مختلفی بر روی اشیاء یک کالس انجام داد‪ .‬روش کار به صورت زیر است‪:‬‬
‫ابتدا کالس اصلی یعنی که کالسی که می خواهیم مقایسه بر روی آن انجام شود‪ ،‬باید رابط ‪ Comparable‬را پیاده سازی‬ ‫‪‬‬
‫کند‪.‬‬
‫در چند کالس جدا که رابط ‪ Comparator‬را پیاده سازی کرده اند‪ ،‬و در داخل متد )(‪ compare‬این رابط‪ ،‬مقایسه های‬ ‫‪‬‬
‫مختلف را انجام می دهیم‪.‬‬

sort() ‫با ایجاد لیست می توانیم از متد‬. ‫یک لیست از می سازیم و اشیاء مختلف کالس اصلی را در آن قرار می دهیم‬ 
‫ چون این متد دو پارامتر می گیرد اولین پرامتر یک لیست است که همان اشیاء کالس‬.‫ استفاده کنیم‬Collection‫کالس‬
‫ را پیاده سازی کرده است و کار مرتب‬Comparator ‫اصلی می باشند و دومین پارامتر هم یک شیء از کالسی که رابط‬
.‫سازی را انجام می دهد‬
. ‫ نام و یا نام خانوادگی مورد مقایسه قرار می گیرند‬،(age)‫ بر اساس سن‬Person ‫ اشیاء ایجاد شده از کالس‬،‫در مثال زیر‬
2
3 import java.util.ArrayList;
4 import java.util.Collections;
5 import java.util.Comparator;
6 import java.util.List;
8
9 class Person implements Comparable<Person>
10 {
13 public int Age;
14
15 public Person(String FirstName, String LastName, int Age)
16 {
17 this.FirstName = FirstName;
18 this.LastName = LastName;
19 this.Age = Age;
20 }
21
22 @Override
23 public int compareTo(Person other)
24 {
25 if (this.Age > other.Age)
26 return 1;
27 else if (this.Age < other.Age)
28 return -1;
29 else
30 return 0;
31 }
32 }
33
34 class FirstNameComparer implements Comparator<Person>
35 {
36 @Override
37 public int compare(Person person1, Person person2)
38 {
39 return person1.FirstName.compareTo(person2.FirstName);
40 }
41 }
42
43 class LastNameComparer implements Comparator<Person>
44 {
45 @Override
47 {
48 return person1.LastName.compareTo(person2.LastName);
49 }
50 }
51
52 class AgeComparer implements Comparator<Person>
53 {
54 @Override
1۵1 ‫مبانی زبان جاوا‬

56 {
57 return person1.compareTo(person2);
58 }
59 }
60
62 {
64 {
65 ArrayList<Person> persons = new ArrayList<Person>();
66 persons.add(new Person("John", "Smith", 21));
67 persons.add(new Person("Mark", "Logan", 19));
68 persons.add(new Person("Luke", "Adams", 20));
69
70 System.out.println("Original Order");
71 for(Person p : persons)
72 System.out.println(String.format("%s %s, Age: %s", p.FirstName, p.LastName, p.Age));
73
74 System.out.println("\nSort persons based on their:");
75 System.out.println("[1] FirstNamen[2] LastNamen[3]Age");
76
77 System.out.print("Enter your choice: ");
79 int choice = input.nextInt();
80
81 ReorderPersons(choice, persons);
82
83 System.out.println("\nNew Order");
84 for(Person p : persons)
85 System.out.println(String.format("%s %s, Age: %s", p.FirstName, p.LastName, p.Age));
86 }
87
88 private static void ReorderPersons(int choice, List persons)
89 {
90 Comparator comparer;
91
92 if (choice == 1)
93 comparer = new FirstNameComparer();
94 else if (choice == 2)
95 comparer = new LastNameComparer();
96 else
97 comparer = new AgeComparer();
98
99 Collections.sort(persons, comparer);
100 }
101 }
Original Order
John Smith, Age: 21
Mark Logan, Age: 19
Luke Adams, Age: 20
Sort persons based on their:

[1]
FirstName
[2] LastName
[3]Age
New Order
John Smith, Age: 21
Luke Adams, Age: 20
Mark Logan, Age: 19
Original Order
‫‪John Smith, Age: 21‬‬

‫‪Mark Logan, Age: 19‬‬
‫‪Luke Adams, Age: 20‬‬
‫‪Sort persons based on their:‬‬

‫]‪[1‬‬
‫‪FirstName‬‬
‫‪[2] LastName‬‬
‫‪[3]Age‬‬
‫‪Enter your choice: 2‬‬
‫‪New Order‬‬
‫‪Luke Adams, Age:‬‬ ‫‪20‬‬
‫‪Mark Logan, Age:‬‬ ‫‪19‬‬
‫‪John Smith, Age:‬‬ ‫‪21‬‬
‫‪Original Order‬‬
‫‪John Smith, Age:‬‬ ‫‪21‬‬
‫‪Mark Logan, Age:‬‬ ‫‪19‬‬
‫‪Luke Adams, Age:‬‬ ‫‪20‬‬
‫‪Sort persons based on their:‬‬

‫]‪[1‬‬
‫‪FirstName‬‬
‫‪[2] LastName‬‬
‫‪[3]Age‬‬
‫‪Enter your choice: 3‬‬
‫‪New Order‬‬
‫‪Mark Logan, Age: 19‬‬
‫‪Luke Adams, Age: 20‬‬
‫‪John Smith, Age: 21‬‬
‫هنگام استفاده از این رابط الزم است یک متد به نام )(‪ compare‬که دو شیء قبول می کند و یک عدد صحیح را به عنوان نتیجه‬
‫بر می گرداند را پیاده سازی کند‪ .‬از آنجاییکه از رابط ‪ Comparator‬استفاده کرده ایم متد )(‪ compare‬به طور خودکار دو شئ‬
‫‪ Person‬قبول می کند‪ .‬همانطور ک ه اشاره شد‪ ،‬این رابط به وسیله کالس جداگانه پیاده سازی می شود و ما این کار روا در خطوط‬
‫‪ 13-۱۹‬انجام داده ایم‪ .‬در این خطوط سه کالس تعریف کرده ایم که این رابط را پیاده سازی کرده (خطوط ‪ 31 ،13‬و ‪ )13‬و در نتیجه‬
‫وظیفه دارند که متد )(‪ compare‬این رابط را هم ‪ Override‬کنند‪ .‬در داخل بدنه این متد هم مقایسه های مختلف را می نویسیم‪.‬‬
‫در مثال باال با استفاده از کالس ‪ FirstNameComparer‬که رابط ‪ Comparator‬را پیاده سازی می کند‪ ،‬دو شئ ‪ Person‬بر اساس‬
‫نام مقایسه می شوند‪ .‬در متد )(‪ Compare‬به سادگی و با استفاده از متد )(‪ compareTo‬از رابط ‪ Comparable‬استفاده کرده ایم‬
‫(چون خاصیت ‪ FirstName‬یک رشته است) و یک مقدار را به عنوان نتیجه بر می گردانیم‪.‬‬
‫به روشی مشابه از کالس های ‪ LastNameComparer‬و ‪ AgeComparer‬برای مقایسه اشیاء بر اساس نام خانوادگی و سن استفاده‬
‫می کنیم‪ .‬متد )(‪ compare‬در صورتی که دو پارامتر با هم برابر باشند‪ ،‬مقدار ‪ ، 3‬اگر پارامتر اول از پارامتر دوم بزرگتر باشد‪ ،‬مقداری‬
‫‪1۵۹‬‬ ‫مبانی زبان جاوا‬
‫بزرگتر از ‪ 3‬و اگر پارامتر اول از پارامتر دوم کوچکتر باشد مقداری کوچکتر از ‪ 3‬را بر می گرداند‪ .‬در مثال باال از کاربر سوال می شود که‬
‫لیستی از اشیاء را قرار است بر اساس کدام خاصیت مرتب کند‪.‬در خطوط ‪ 13-11‬اشیا با مقادیر از پیش تعریف شده ای برای هر یک‬
‫از خاصیت هایشان ایجاد شده است‪.‬در خطوط ‪ 10-13‬ترتیب عادی و اصلی این اشیاء نمایش داده شده است‪ .‬در خطوط ‪13-11‬‬
‫لیستی از انتخاب هایی که کاربر بر اساس آنها می تواند عملیات مرتب سازی را انجام دهد آورده شده است‪ .‬در خطوط ‪ 11-16‬از‬
‫کاربر در مورد انتخابش سوال می شود‪ .‬در خط ‪ 03‬متد )(‪ ReorderPersons‬متد از پیش تعریف شده ی خطوط ‪ 00-333‬را‬
‫فراخوانی می کنیم‪ .‬این متد انتخاب کاربر و لیستی از اشیا که قرار است بر اساس خاصیتی که کاربر انتخاب کرده است مرتب شوند‬
‫را قبول می کند‪ .‬در داخل متد یک متغیر تعریف کرده ایم که از نوع ‪ Comparator‬است و در نتیجه می تواند هر نوع کالسی که‬
‫رابط مذکور را پیاده سازی می کند را شامل شود‪ .‬در خطوط ‪ 65-61‬چک می کنیم که اگر کاربر یک مقدار عددی خاص را انتخاب کرد‪،‬‬
‫چه کارهایی انجام شود‪ .‬در خط ‪ 33‬از متد )(‪ sort‬کالس ‪ Collections‬استفاده کرده ایم‪ .‬این متد دارای یک نسخه سربارگذاری‬
‫شده است که یک شی ‪ Comparator‬را قبول می کند‪ .‬ما در خط ‪ 66‬کالس مقایسه کننده بر اساس نوع انتخاب کاربر را به این متد‬
‫می دهیم و سپس متد )(‪ ،sort‬شی ‪ Person‬را بر اساس این کالس مرتب می کند‪.‬‬
‫به طور خالصه کالسی که رابط ‪ Comparable‬را پیاده سازی کند‪ ،‬به کالسی مقایسه پذیر تبدیل می شود و کالسی که رابط‬
‫‪Comparator‬را پیاده سازی کند‪ ،‬می تواند به وسیله متدهای )(‪ Collections.sort‬یا )(‪ Arrays.sort‬مرتب شود‪ ،‬کاری‬
‫که ما در خط ‪ 66‬کد باال انجام داده ایم‪.‬‬
‫کلکسیونها)‪(Collections‬‬
‫قبال یاد گرفتیم که آرایهها به ما اجازه ذخیره چندین مقدار از یک نوع را میدهند‪ .‬آرایهها از کالس ‪ Java.util.Arrays‬ارث بری‬
‫میکنند که این کالس دارای خواص و متدهایی برای کار با دادههای ساده ای مانند طول آرایه میباشد‪ .‬آرایههای ساده در جاوا‬
‫دارای طول ثابتی هستند که یک بار تعریف و مقدار دهی میشوند و شما نمیتوانید طول یک آرایه خاص را افزایش یا کاهش‬
‫دهید‪ .‬جاوا گزینه بهتری برای جایگزین کردن با آرایهها پیشنهاد میدهد و بیشتر آنها کالسها و رابطهایی هستند که در پکیج‬
‫و کالس ‪ java.util.ArrayList‬قرار دارند‪ .‬به عنوان مثال کالس ‪ ArrayList‬رفتاری شبیه به یک آرایه معمولی دارد با این‬
‫تفاوت که به شما اجازه میدهد که طول آن را به صورت پویا تغییر داده یا یک عنصر را در طول اجرای برنامه به آن اضافه کرده و یا‬
‫از آن حذف نمایید‪ .‬در درس بعد پی میبرید که چگونه یک کالس که شامل مجموعه ای از اشیاء است را به وسیله اجرا کردن و یا‬
‫ارث بری از رابطها و متدها ایجاد کنیم‪.‬‬
‫کالس ‪ArrayList‬‬
‫کالس ‪ ArrayList‬به شما اجازه ذخیره مقادیر انواع داده ای مختلف‪ ،‬و توانایی حذف و اضافه عناصر آرایه در هر لحظه را میدهد‪.‬‬
‫در مثال زیر به سادگی کاربرد کالس ‪ ArrayList‬آمده است‪.‬‬
‫;‪import java.util.ArrayList‬‬

‫{‬
‫{‬
‫;)(‪ArrayList myArray = new ArrayList‬‬
‫;)"‪myArray.add("John‬‬
‫;)‪myArray.add(5‬‬
‫;)‪myArray.add(true‬‬
‫;)‪myArray.add(3.65‬‬
‫;)'‪myArray.add('R‬‬
‫)‪for (Object element : myArray‬‬

‫{‬
‫;)‪System.out.println(element‬‬
‫}‬
‫}‬
‫}‬
‫‪John‬‬
‫‪5‬‬
‫‪true‬‬
‫‪3.65‬‬
‫‪R‬‬
‫برای استفاده از این کالس ابتدا باید در قسمت فضاهای نامی‪ ،‬فضای نام ‪ java.util.ArrayList‬را وارد کنیم (خط ‪ .)1‬همانطور‬
‫که در مثال مشاهده میکنید یک نمونه از کالس ‪ ArrayList‬ایجاد میکنیم‪ .‬برای اضافه کردن یک عنصر به آرایه باید از متد‬
‫)(‪ add‬استفاده کنیم‪ .‬از آنجاییکه شیء ایجاد شده از کالس ‪ ArrayList‬آرگومانی از نوع ‪ Object‬قبول میکند بنابراین میتوان‬
‫مقادیری از هر نوع داده ای به آن ارسال کرد چون هر چیز در جاوا از ‪ Object‬ارث بری میکند‪.‬‬
‫حال برای نمایش توانایی این کالس در نگهداری انواع داده ای مختلف پنج مقدار از پنج نوع مختلف داده را به آن اضافه میکنیم‪.‬‬
‫سپس همه مقادیر را با استفاده از دستور ‪ foreach‬میخوانیم‪ .‬چون کالس ‪ ArrayList‬دارای انواع داده ای مختلفی است‬
‫نمیتوانیم از یک نوع داده ای خاص برای خواندن مقادیر استفاده کنیم‪ .‬لذا برای این کار باید از نوع ‪ Object‬که میتواند هر نوع‬
‫داده ای در خود ذخیره کند استفاده نمود‪ .‬به این نکته توجه کنید که برای دسترسی به هر عنصر میتوانید از طریق اندیس آن اقدام‬
‫نمایید‪ .‬کد زیر نحوه استفاده از حلقه ‪ for‬برای دسترسی به هر یک از اعضا را نشان میدهد‪.‬‬
‫)‪for (int i = 0; i < myArray.size(); i++‬‬

‫{‬
‫;))‪System.out.println(myArray.get(i‬‬
‫}‬
‫به متد )(‪ size‬در کد باال توجه کنید‪ .‬این متد درست شبیه به خاصیت ‪ length‬آرایه معمولی است و کار آن شمارش تعداد‬
‫عناصر شیء ‪ ArrayList‬میباشد‪ .‬در کد باال همانطور که نشان داده شده است میتوان به هر یک از عناصر با استفاده از اندیسشان‬
‫دست یافت ()‪ .)get(i‬نکته دیگر این است که شما میتوانید به کالس ‪ ArrayList‬یک ظرفیت ابتدایی بدهید‪ .‬به عنوان مثال‬
‫شما میتوانید با استفاده از یک سازنده سربارگذاری شده نشان دهید که یک شیء ‪ ArrayList‬میتواند دارای ‪ 1‬عنصر باشد‪.‬‬
‫;)‪ArrayList myArray = new ArrayList(5‬‬
‫کد باال ‪ 1‬مکان خالی به وجود میآورد و شما میتوانید با استفده از متد )(‪ add‬یکی دیگر به آنها اضافه کنید‪ .‬میتوان با استفاده‬
‫از متد )(‪ remove‬کالس ‪ ArrayList‬عناصر را پاک کرد‪ .‬متد )(‪ remove‬یک شیء که مطابق مقدار یک عنصر در آرایه است را‬
‫قبول میکند‪ .‬این متد به محض رسیدن به مقدار مورد نظر آن را حذف میکند‪ .‬اگر عنصری را که مکانی غیر از مکان آخر آرایه باشد‬
‫حذف کنید بقیه عناصر بعد از آن عنصر مکان خود را تنظیم میکنند به این معنی که فرض کنید آرایه ای دارای ‪ 1‬عنصر است و شما‬
‫عنصر ‪ 1‬را حذف میکنید‪ ،‬در این صورت جای خالی این عنصر توسط عنصر ‪ 3‬و جای عنصر ‪ 3‬توسط عنصر ‪ 1‬پر میشود‪ .‬به تکه کد‬
‫زیر توجه کنید‪:‬‬

‫‪2‬‬
‫‪3‬‬ ‫;‪import java.util.ArrayList‬‬
‫‪5‬‬
‫‪7‬‬ ‫{‬
‫‪9‬‬ ‫{‬
‫‪10‬‬ ‫;)(‪ArrayList myArray = new ArrayList‬‬
‫‪11‬‬
12 myArray.add("John");
13 myArray.add(5);
14 myArray.add(true);
15 myArray.add(3.65);
16 myArray.add('R');
17
18 for (int i = 0; i < myArray.size(); i++)
19 {
20 System.out.println(MessageFormat.format("myArray[{0}] = {1}", i, myArray.get(i)));
21 }
22
23 myArray.remove(2);
24
25 System.out.println("\nAfter removing myArray[1] (The value true)...\n");
26
27 for (int i = 0; i < myArray.size(); i++)
28 {
29 System.out.println(MessageFormat.format("myArray[{0}] = {1}", i, myArray.get(i)));
30 }
31 }
32 }
myArray[0] = John
myArray[1] = 5
myArray[2] = true
myArray[3] = 3.65
myArray[4] = R
After removing myArray[2] (The value 5)...
myArray[0] = John
myArray[1] = 5
myArray[2] = 3.65
myArray[3] = R
‫) همه عناصر متوالی در آرایه باال مکان خود را تغییر‬51 ‫ را حذف کردهایم (خط‬myArray[2] ‫از آنجاییکه در مثال باال مقدار عنصر‬
.‫ و …را میگیرد‬myArray[3] ‫ جای‬myArray[4] ‫ عنصر‬،myArray[2] ‫ جای‬myArray[3] ‫ بنابراین عنصر‬.‫میدهند‬
‫ جایگزینی و به دست آوردن اندیس مقادیر‬،‫جستجو‬
‫ این متد یک آرگومان‬.‫ میتوان چک کرد که آیا یک مقدار خاص در داخل آرایه وجود دارد یا خیر‬contains() ‫با استفاده از متد‬
‫ و‬indexOf() ‫ از متدهای‬،‫ را بر میگرداند‬true ‫از نوع شیء را قبول کرده و اگر یک مقدار را در داخل لیست عناصر پیدا کند‬
.‫ برای تشخیص اندیس یک مقدار خاص استفاده میشود‬lastIndexOf()
.‫ اندیس اولین محل وقوع یک مقدار خاص را بر میگرداند‬IndexOf() ‫متد‬ 
.‫ اندیس آخرین محل وقوع یک مقدار خاص را بر میگرداند‬LastIndexOf() ‫متد‬ 

‫هر دو متد‪ ،‬در صورتیکه مقدار مورد نظر را پیدا نکنند مقدار ‪ -3‬را بر میگردانند‪.‬‬ ‫‪‬‬
‫برای جایگزین کردن یک مقدار با یک مقدار موجود در ‪ ArrayList‬از متد )(‪ set‬استفاده میشود‪ .‬فرض کنید که میخواهید عدد‬
‫‪ 31‬را جایگزین عدد ‪ 1‬در مثال باال کنید برای اینکار باید به صورت زیر عمل کنید‪:‬‬
‫;)‪myArray.set(2,15‬‬
‫عدد ‪ 5‬در مثال باال نشان دهنده اندیس مقداری از ‪ ArrayList‬است که ما میخواهیم مقداری دیگر را جایگزین آن کنیم‪ .‬در این‬
‫مثال اندیس ‪ 5‬نشان دهنده مقدار ‪ 1‬است‪ .‬برای به دست آوردن تعداد عناصر در یک ‪ Arraylist‬از متد )(‪size‬‬
‫)(‪myArray.size‬‬
‫و برای پاک کردن همه عناصر از متد )(‪ clear‬استفاده میشود‪:‬‬
‫;)(‪myArray.clear‬‬
‫مرتب سازی مقادیر ‪ArrayList‬‬
‫مرتب سازی در ‪ ArrayList‬زمانی معنا دارد که همه آیتمها از یک نوع مثال عدد صحیح باشند‪ .‬برای ایجاد یک کالس ‪ArrayList‬‬
‫از یک نوع خاص به صورت زیر عمل میشود‪:‬‬
‫;)(‪ArrayList <type> CollectionName = new ArrayList‬‬
‫که در آن ‪ type‬نوع داده ای مجموعه و ‪ CollectionName‬نامی است که برای مجموعه انتخاب کردهایم‪ .‬فرض کنید که میخواهیم‬
‫یک مجموعه از نوع اعداد صحیح ایجاد و مرتب کنیم‪ .‬به مثال زیر توجه کنید‪:‬‬

‫‪2‬‬
‫‪3‬‬ ‫;‪import java.util.ArrayList‬‬
‫‪4‬‬ ‫;‪import java.util.Collections‬‬
‫‪6‬‬
‫‪8‬‬ ‫{‬
‫‪10‬‬ ‫{‬
‫‪11‬‬ ‫;)(‪ArrayList <Integer> myArray = new ArrayList‬‬
‫‪12‬‬
‫‪13‬‬ ‫;)‪myArray.add(1‬‬
‫‪14‬‬ ‫;)‪myArray.add(5‬‬
‫‪15‬‬ ‫;)‪myArray.add(3‬‬
‫‪16‬‬ ‫;)‪myArray.add(2‬‬
‫‪17‬‬
‫‪18‬‬ ‫;)‪Collections.sort(myArray‬‬
‫‪19‬‬
‫‪20‬‬ ‫)‪for (int i = 0; i < myArray.size(); i++‬‬
‫‪21‬‬ ‫{‬
‫‪22‬‬ ‫;)))‪System.out.println(MessageFormat.format("myArray[{0}] = {1}", i, myArray.get(i‬‬
‫‪23‬‬ ‫}‬
‫‪24‬‬ ‫}‬
‫‪25‬‬ ‫}‬
‫]‪myArray[0‬‬ ‫=‬ ‫‪1‬‬

‫]‪myArray[1‬‬ ‫=‬ ‫‪2‬‬
‫]‪myArray[2‬‬ ‫=‬ ‫‪3‬‬
‫]‪myArray[3‬‬ ‫=‬ ‫‪5‬‬
‫همانطور که در مثال بال مشاهده میکنید در خط ‪ 3‬پکیج ‪ Collections‬را وارد برنامه کردهایم‪ .‬وجود این پکیج برای مرتب سازی‬
‫الزامی است‪ .‬در خط ‪ 33‬یک مجموعه از نوع اعداد صحیح ایجاد و در خطوط ‪ 31-36‬به صورت نامرتب چند آیتم به آن اضافه کردهایم‪.‬‬
‫سپس در خط ‪ 30‬با استفاده از متد )(‪ sort‬کالس ‪ Collections‬مجموعه را مرتب نمودهایم‪.‬‬
‫با استفاده از متد )(‪ sort‬میتوان مقادیر یک آرایه را مرتب نمود‪ .‬اعداد از بزرگ به کوچک و رشته بر اساس حروف الفبا مرتب‬
‫میشوند‪ .‬اگر از این متد استفاده کنید همه اجزا با هم مقایسه میشوند‪ .‬به عنوان مثال نمیتوان یک رشته و یک عدد از نوع ‪int‬‬
‫را در داخل ‪ ArrayList‬قرار داد و آنها را با متد )(‪ Sort‬مرتب نمود‪ .‬در درس آینده یاد خواهید گرفت که چگونه از یک مقایسه‬
‫گر سفارشی برای مرتب کردن عناصر استفاده نمود‪.‬‬
‫‪ Iterator‬و ‪ListIterator‬‬
‫برای دسترسی‪ ،‬ویرایش و حذف هر یک از عناصر یک کلکسیون ابتدا باید عنصر مورد نظر را پیدا کنیم‪ .‬برای این کار الزم است که‬
‫در میان عناصر بگردیم‪ .‬سه راه برای گردش در میان عناصر یک کلکسیون یا مجموعه وجود دارد‪:‬‬
‫با استفاده از رابط ‪Iterator‬‬ ‫‪.3‬‬
‫با استفاده از رابط ‪ListIterator‬‬ ‫‪.5‬‬
‫با استفاده از حلقه ‪foreach‬‬ ‫‪.1‬‬

11۱ ‫مبانی زبان جاوا‬
Iterator ‫دسترسی به عناصر مجموعه با استفاده از رابط‬
.‫ یک مجموعه یا کلکسیون را رو به جلو پیمایش کرده و شما را قادر می سازد که عناصر را حذف و ویرایش کنید‬Iterator ‫رابط‬
‫ می سازیم می‬Iterator ‫ وقتی یک شیء از‬.‫ می باشد‬iterator() ‫هر کلکسیون برای ایجاد یک پیمایشگر دارای متدی به نام‬
:‫توانیم به متدهای آن که در جدول زیر آمده اند نیز دست یابیم‬
‫چک می کند که آیا عنصری بعد از عنصر فعلی وجود دارد یا نه؟‬ hasNext
.‫عنصر بعدی را بر می گرداند‬ next
:‫به مثال زیر توجه کنید‬
import java.util.*;

{
{
ArrayList<String> arraylist = new ArrayList<>();
arraylist.add("A");
arraylist.add("B");
arraylist.add("C");
arraylist.add("D");
Iterator iterator = arraylist.iterator(); //Declaring Iterator
while (iterator.hasNext())
{
System.out.println(iterator.next());
}
}
}
A
B
C
D
:‫مهمترین خط کد باال خط زیر است‬
Iterator iterator = arraylist.iterator();

‫در کد باال با فراخوانی متد )(‪ iterator‬از کلکسیونمان که در اینجا ‪ arraylist‬است آن را به مجموعه ای قابل پیمایش توسط‬
‫‪ Itrator‬می کنیم و سپس با استفاده از متدهای این رابط آن را پیمایش می کنیم‪.‬‬
‫دسترسی به عناصر مجموعه با استفاده از رابط ‪ListIterator‬‬
‫رابط ‪ ListIterator‬یک مجموعه را با استفاده از متدهایی که در جدول زیر آمده اند‪ ،‬هم رو به جلو و هم رو به عقب پیمایش‬
‫می کند‪:‬‬
‫چک می کند که آیا عنصری بعد از عنصر فعلی وجود دارد یا نه؟‬ ‫‪hasNext‬‬
‫عنصر بعد از عنصر فعلی را بر می گرداند‪.‬‬ ‫‪next‬‬
‫چک می کند که آیا عنصری قبل از عنصر فعلی وجود دارد یا نه؟‬ ‫‪hasPrevious‬‬
‫عنصر قبل از عنصر فعلی را بر می گرداند‪.‬‬ ‫‪previous‬‬
‫این رابط فقط در مجموعه هایی قابل دسترسی است که رابط ‪ List‬را پیاده سازی کرده باشند‪:‬‬
‫;*‪import java.util.‬‬

‫{‬
‫{‬
‫;)(><‪ArrayList<String> arraylist = new ArrayList‬‬
‫;)"‪arraylist.add("A‬‬
‫;)"‪arraylist.add("B‬‬
‫;)"‪arraylist.add("C‬‬
‫;)"‪arraylist.add("D‬‬
‫;)(‪ListIterator listiterator = arraylist.listIterator‬‬
‫))(‪while (listiterator.hasNext‬‬ ‫‪//In forward direction‬‬

‫{‬
‫;))(‪System.out.println(listiterator.next‬‬
‫}‬
‫;)"‪System.out.println("\n\n‬‬
‫))(‪while (listiterator.hasPrevious‬‬ ‫‪//In backward direction‬‬

‫{‬
111 ‫مبانی زبان جاوا‬
System.out.println(listiterator.previous());
}
}
}
A
B
C
D
D
C
B
A
foreach‫دسترسی به عناصر مجموعه با استفاده از حلقه‬
‫ از این حقله نمی توان برای ویرایش‬.‫ است که می تواند در میان عناصر یک مجموعه گردش کند‬for ‫ نسخه ای از حلقه‬Foreach
‫ را پیاده سازی‬Iterable ‫ می تواند در میان هر مجموعه ای از اشیاء که رابط‬foreach ‫ حلقه‬.‫عناصر یک مجموعه استفاده کرد‬
: ‫کرده باشد گردش کند‬
import java.util.*;

{
{
ArrayList<String> arraylist = new ArrayList<>();
arraylist.add("A");
arraylist.add("B");
arraylist.add("C");
arraylist.add("D");
for (String str : arraylist)

{
System.out.println(str);
}
}
}
A
B
C
D
‫‪Vector‬‬
‫کالس ‪ Vector‬هم‪ ،‬رابط ‪ List‬را پیاده سازی می کند‪ .‬همانند ‪ ArrayList‬می تواند تعداد نامشخصی عنصر داشته باشد ولی‬
‫سرعت آن در جستجو‪ ،‬اضافه و حذف عناصر نسبت به ‪ ArrayList‬کمتر است‪ .‬سه روش برای ایجاد یک شیء از کالس ‪Vector‬‬
‫وجود دارد‪ .‬در روش اول تعداد عناصر را مشخص نمی کنیم‪ .‬در این حالت ظرفیت پیشفرض ‪ vector‬ده عنصر می باشد ‪:‬‬
‫;)(‪Vector myVector = new Vector‬‬
‫نکته ای که در این روش وجود دارد این است که وقتی شما بخواهید یازدهمین عنصر را وارد کنید‪ ،‬ظرفیت ‪ Vector‬دو برابر می‬
‫شود‪ .‬در روش دوم یک ظرفیت برای ‪ Vector‬تعریف می کنیم ‪:‬‬
‫)‪Vector myVector = new Vector(int initialCapacity‬‬
‫در مثال باال ‪ Vector‬سه عنصر را می تواند در خود جای دهد‪ .‬و روش سوم هم دو آرگومان برای ‪ Vector‬در نظر می گیریم‪.‬‬
‫آرگومان اول به معنای ظرفیت پیشفرض و آرگومان دوم هم به معنای ظرفیت نهایی می باشد ‪:‬‬
‫)‪Vector myVector = new vector(int initialcapacity, capacityIncrement‬‬
‫یعنی در مثال فوق بعد از وارد کردن پنجمین عنصر سایز ‪ Vector‬به ‪ 33‬و بعد از وارد کردن یازدهمین عنصر ظرفیت ‪ Vector‬به‬
‫‪ 31‬افزایش می یابد‪ .‬متدهای مهم کالس ‪ Vector‬در زیر آمده است‪:‬‬
‫یک عنصر را به آخر ‪ Vector‬اضافه می کند‪.‬‬ ‫‪addElement‬‬
‫ظرفیت فعلی ‪ Vector‬را بر می گرداند‪.‬‬ ‫‪capacity‬‬
‫اندازه فعلی (تعداد عناصر) ‪ Vector‬را بر می گرداند‪.‬‬ ‫‪size‬‬
‫چک می کند که آیا یک عنصر خاص در ‪ Vector‬وجود دارد یا نه؟‬ ‫‪contains‬‬
‫چک می کند که آیا همه عناصر یک مجموعه در داخل ‪ Vector‬هستند یا خیر؟‬ ‫‪containsAll‬‬
‫چک می کند که آیا یک عنصر خاص در موقعیتی خاص از ‪ Vector‬وجود دارد یا نه؟‬ ‫‪elementAt‬‬
11۹ ‫مبانی زبان جاوا‬
.‫ را بر می گرداند‬Vector ‫اولین عنصر‬ firstElement
.‫ را بر می گرداند‬Vector ‫آخرین عنصر‬ lastElement
.‫ را بر می گرداند‬،‫ است‬Vector ‫یک عنصر که در موقعیت یا اندیسی خاص از‬ get
.‫ را بر می گرداند‬true ‫ دارای هیچ عنصری نباشد مقدار‬Vector ‫اگر‬ isEmpty
.‫ را حذف می کند‬Vector ‫یک عنصر خاص از‬ removeElement
.‫ را که در یک مجموعه هستند حذف می کند‬Vector ‫همه عناصر‬ removeAll
.‫یک عنصر را جایگزین یک عنصر با اندیس خاص می کند‬ setElementAt
: ‫ به مثال زیر توجه کنید‬Vector ‫برای نحوه کار با کالس‬
2
3 import java.util.*;
4
6 {
8 {
9 /* Vector of initial capacity(size) of 2 */
10 Vector<String> myVector = new Vector<String>(2);
11
12 /* Adding elements to a vector*/
13 myVector.addElement("Apple");
14 myVector.addElement("Orange");
15 myVector.addElement("Mango");
16 myVector.addElement("Fig");
17
18 /* check size */
19 System.out.println("Size is: "+ myVector.size());
20 System.out.println("Default capacity increment is: " + myVector.capacity());
21
22 /* capacityIncrement */
23 myVector.addElement("fruit1");
26
27 /*size and capacityIncrement after two insertions*/
28 System.out.println("Size after addition: " + myVector.size());
29 System.out.println("Capacity after increment is: " + myVector.capacity());
30
31 /*Display Vector elements*/
32 System.out.println("\nElement are: ");
33 for(String vector : myVector)
34 {
35 System.out.println(vector);
‫‪36‬‬ ‫}‬
‫‪37‬‬ ‫}‬
‫‪38‬‬ ‫}‬
‫‪Size is: 4‬‬

‫‪Default capacity increment is: 4‬‬
‫‪Size after addition: 7‬‬
‫‪Capacity after increment is: 8‬‬
‫‪Element are:‬‬
‫‪Apple‬‬
‫‪Orange‬‬
‫‪Mango‬‬
‫‪Fig‬‬
‫‪fruit1‬‬
‫‪fruit2‬‬
‫‪fruit3‬‬
‫همانطور که در کد باال مشاهده می کنید‪ ،‬ظرفیت ‪ Vector‬برابر عدد ‪ 5‬است (خط ‪ )33‬ولی چون ما در خطوط ‪ 31-31‬چهار عنصر به‬
‫آن اضافه کرده ایم‪ ،‬ظرفیت آن به ‪ 3‬تغییر می کند‪ .‬به این نکته توجه کنید که متد )(‪ size‬تعداد عناصر و متد )(‪capacity‬‬
‫حجم ‪ Vector‬را نشان می دهد‪ .‬به ادامه کد توجه کنید‪ .‬در خطوط ‪ 51-51‬سه عنصر دیگر به ‪ Vector‬اضافه کرده ایم‪ .‬در نتیجه‬
‫خروجی تعداد عناصر را ‪ 1‬و حجم ‪ Vector‬را ‪ 0‬نشان می دهد‪ .‬در آخر هم با استفاده از یک حلقه ‪ foreach‬تمام عناصر ‪Vector‬‬
‫را چپ کرده ایم‪.‬‬
‫‪List‬‬
‫‪ List‬یکی از ‪ interface‬های اصلی ‪ Collection Framework‬جاواست که برای نگه داری یک لیست از آن استفاده میشود‪،‬‬
‫زیر کالسهای مختلفی همچون ‪ Vector ،ArrayList ،LinkedList‬در جاوا وجود دارند که هر کدام با استفاده از ساختمان‬
‫دادههای متفاوت به نحوی مفهوم لیست را پیاده سازی کردهاند‪ .‬یک لیست باید حداقل شرایط زیر را بر آورده کند‪:‬‬
‫بتوان به آن عناصری را اضافه یا حذف کرد‪.‬‬ ‫‪‬‬
‫بتواند اعضای تکراری را نگه داری کند‪.‬‬ ‫‪‬‬
‫بتوان با استفاده از اندیس (با شروع از صفر) به عناصر داخل آن دسترسی داشت‪.‬‬ ‫‪‬‬
‫کاربردهای‪ List‬به صورت کلی عبارتاند از‪:‬‬

‫‪1۳۵‬‬ ‫مبانی زبان جاوا‬
‫نگه داری یک لیست و مجاز بودن اعضای تکراری‬ ‫‪‬‬
‫نگه داری یک مجموعه با اندازه پویا و قابل افزایش‬ ‫‪‬‬
‫کاربرد ساده تر نسبت به آرایه‬ ‫‪‬‬
‫متدهای ‪ List‬در جدول زیر آمدهاند‪ ،‬کالسهایی که از کالس ‪ List‬ارث بری دارند موظف هستند این متدها را پیاده سازی‬
‫کنند‪.‬‬
‫یک عنصر جدید به ‪ List‬اضافه میکند‪.‬‬ ‫)‪add(Object o‬‬
‫یک عنصر جدید را در اندیس مورد نظر درج میکند‪.‬‬ ‫)‪add(index,Object o‬‬
‫تمام اعضای یک کالکشن دیگر را به لیست اضافه میکند‪.‬‬ ‫)‪addAll(Collection c‬‬
‫تمام اعضای داخل لیست را حذف میکند‪.‬‬ ‫)(‪clear‬‬
‫وجود یک عنصر در لیست را بررسی میکند‪.‬‬ ‫)‪contains(Object o‬‬
‫اگر تمام اعضای کالکشن ‪ c‬در لیست فعلی وجود داشته باشند ‪ true‬بر میگرداند‪.‬‬ ‫)‪containsAll(Collection c‬‬
‫لیست فعلی را با لیست دیگری مقایسه میکند‪.‬‬ ‫)‪equals(Ojbect o‬‬
‫عنصر موجود در اندیس ‪ index‬را بر میگرداند‪.‬‬ ‫)‪get(index‬‬
‫‪ HashCode‬کل لیسترا محاسبه میکند‪.‬‬ ‫)(‪hashCode‬‬
‫اولین اندیس یک عنصر را بر می گرداند‪.‬‬ ‫)‪indexOf(Ojbect o‬‬
‫بررسی میکند که لیستخالی است یا خیر؟‬ ‫)(‪isEmpty‬‬
‫یک ‪ iterator‬برای پیمایش لیست بر میگرداند‪.‬‬ ‫)(‪Iterator iterator‬‬
‫در صورت وجود عناصر تکراری آخرین اندیس یک عنصر را بر میگرداند‪.‬‬ ‫)‪lastIndexOf(Object o‬‬
‫یک ‪ ListIterator‬در اختیار ما قرار میدهد‪.‬‬ ‫)(‪ListIterator‬‬
‫یک عنصر را از لیست حذف میکند‪.‬‬ ‫)‪remove(Object o‬‬
‫تمام عناصر یک کالکشن دیگر را از لیست فعلی حذف میکند‪.‬‬ ‫)‪removeAll(Collection c‬‬
‫اشتراک لیست فعلی را با کالکشن دیگر محاسبه میکند و سایر اعضا را حذف میکند‪.‬‬ ‫)‪retainAll(Collection c‬‬
‫عنصر داخل اندیس ‪ index‬را به مقدار ‪ o‬تغییر میدهد‪.‬‬ ‫)‪set(index,Object o‬‬

‫تعداد عناصر داخل لیست را بر میگرداند‪.‬‬ ‫)(‪size‬‬
‫یک زیر‪-‬لیست از اندیس ‪ fromIndex‬تا ‪ toIndex‬در اختیار ما قرار میدهد‪.‬‬ ‫)‪subList(fromIndex,toIndex‬‬
‫عناصر را در داخل یک آرایه در اختیار ما قرار میدهد‪.‬‬ ‫)(‪Object[] toArray‬‬
‫در ادامه با یک مثال با ‪ List‬آشنا میشویم و مثالهای بیشتر را به آموزشهای بعدی موکول میکنیم‪.‬‬
‫;‪import java.util.List‬‬
‫;‪import java.util.LinkedList‬‬

‫{‬
‫{‬
‫;)(‪List list = new LinkedList‬‬
‫;)"‪list.add("A‬‬
‫;)"‪list.add("B‬‬
‫;)"‪list.add("C‬‬
‫;)"‪list.add("D‬‬
‫;)‪System.out.println(list‬‬
‫;)"‪int indexOfC = list.indexOf("C‬‬

‫;)‪System.out.println(indexOfC‬‬
‫;)"‪list.set(indexOfC, "X‬‬
‫;)‪System.out.println(list‬‬
‫}‬
‫}‬
‫]‪[A, B, C, D‬‬
‫‪2‬‬
‫]‪[A, B, X, D‬‬
‫در مثال باال ابتدا یک ‪ List‬ایجاد میکنیم‪ ،‬چون ‪ List‬یک ‪ interface‬است برای ساخت یک شیء جدید از آن باید از یکی‬
‫از زیر کالسهای پیاده سازی شده آن استفاده کنیم که در اینجا ‪ LinkedList‬را انتخاب کردیم‪ .‬سپس با استفاده از متد )(‪add‬‬
‫چندین عضو به لیست اضافه کردیم‪ .‬سپس از چاپ لیست‪ ،‬با استفاده از متد )(‪ indexOf‬اندیس عنصر ‪ C‬را به دست آورده و‬
‫آن را در متغیر ‪ indexOfC‬ذخیره میکنیم‪ .‬بعد از چاپ ‪ indexOfC‬با استفاده از متد )(‪ set‬عنصر موجود در اندیس ‪indexOfC‬‬
‫را به ‪ X‬تغییر میدهیم و در انتها مجددا لیست را چاپ میکنیم‪.‬‬
‫‪Map‬‬
‫‪1۳۳‬‬ ‫مبانی زبان جاوا‬
‫‪ Map‬یکی از ‪ interface‬های اصلی ‪ Collection Framework‬جاواست که برای نگه داری زوج کلید‪-‬مقدار )‪ (key-value‬از‬
‫آن استفاده میشود و در پکیج ‪ java.util.Map‬قرار دارد‪ .‬زیر کالسهای مختلفی همچون ‪،IdenentityHashMap ،HashMap‬‬
‫‪ WeakHashMap ،LinkedHashMap‬و ‪ TreeMap‬در جاوا وجود دارند که هر کدام با استفاده از الگوریتمها و ساختمان دادههای‬
‫متفاوت به نحوی مفهوم نگه داری زوج کلید‪-‬مقدار را پیاده سازی کردهاند‪ .‬به هر زوج کلید‪-‬مقدار در ‪ Map‬یک ‪ entry‬گفته میشود‬
‫که با استفاده از ‪ Map.Entry‬میتوان به آنها دسترسی داشت و کلید )‪ (key‬یا مقدار )‪ (value‬را استخراج کرد‪ .‬کلید در ‪Map‬‬
‫یک عنصر یکتاست ولی مقدار متناظر با آن میتواند یک ‪ Object‬ساده یا پیچده (مثال یک لیست) و یا حتی ‪ null‬باشد‪ ،‬به‬
‫عالوه ممکن است برای چند کلید مختلف مقادیر تکراری داشته باشیم‪ null .‬نیز میتواند یک کلید منحصر به فرد در نظر گرفته‬
‫شود لذا هر ‪ Map‬میتواند حداکثر یک کلید با مقدار ‪ null‬نیز داشته باشد‪ .‬کاربردهای ‪ Map‬به صورت کلی عبارتاند از‪:‬‬
‫قادر باشیم زوج کلید‪-‬مقدار را در ‪ Map‬ذخیره کنیم و هر زمان که الزم شد تنها با داشت کلید بتوانیم مقدار متناظر با آن را‬ ‫‪‬‬
‫استخراج کنیم‪.‬‬
‫راهکاری برای تشخیص وجود یا عدم وجود کلید در ‪ Map‬داشته باشیم‪.‬‬ ‫‪‬‬
‫راهکاری برای تشخیص وجود یا عدم وجود یک مقدار در ‪ Map‬داشته باشیم‪.‬‬ ‫‪‬‬
‫قادر باشیم مقدار متناظر با یک کلید را تغییر دهیم‪.‬‬ ‫‪‬‬
‫قادر باشیم تمام اعضای ‪ Map‬را لیست کنیم‪.‬‬ ‫‪‬‬
‫متدهای ‪ Map‬در جدول زیر آمدهاند‪ ،‬کالسهایی که از کالس ‪ Map‬ارث بری دارند موظف هستند این متدها را پیاده سازی کنند‪.‬‬
‫تمام عناصر داخل ‪ Map‬را پاک میکند‪.‬‬ ‫)(‪clear‬‬
‫بررسی میکند که آیا کلید )‪ (key‬مورد نظر در ‪ Map‬وجود دارد یا خیر؟‬ ‫)‪containsKey(Object key‬‬
‫بررسی میکند که آیا مقدار مورد نظر در ‪ Map‬وجود دارد یا خیره؟‬ ‫‪containsValue(Object‬‬
‫)‪val‬‬
‫تمام زوجهای کلید‪-‬مقدار را در داخل یک به ما ارائه میدهد‪.‬‬ ‫)(‪entrySet‬‬

‫تساوی این ‪ Map‬با ‪ Map‬دیگری را بررسی میکند‪.‬‬ ‫)‪equals(Object obj‬‬
‫مقدار متناظر با یک کلید )‪ (key‬را بر میگرداند‪.‬‬ ‫)‪get(Object key‬‬
‫‪ HashCode‬کل ‪ Map‬را محاسبه میکند‪.‬‬ ‫)(‪hashCode‬‬
‫بررسی میکند که ‪ Map‬خالی است یا خیر؟‬ ‫)(‪isEmpty‬‬
‫تمام کلیدها را در داخل یک در اختیار ما قرار میدهد‪.‬‬ ‫)(‪keySet‬‬
‫یک زوج کلید‪-‬مقدار را در ‪ Map‬قرار میدهد‪.‬‬ ‫‪put(Object key,Object‬‬

‫)‪val‬‬
‫تمام عناصر یک ‪ Map‬دیگر را به ‪ Map‬فعلی اضافه میکند‪.‬‬ ‫)‪putAll(Map m‬‬
‫یک کلید )‪ (key‬را حذف میکند که این عمل باعث حذف مقدار متناظر با آن نیز میشود‪.‬‬ ‫)‪remove(Object key‬‬
‫تعداد کلیدهای موجود را بر میگرداند‪.‬‬ ‫)(‪size‬‬
‫یک ‪ Collection‬از روی مقادیر ایجاد کرده و بر میگرداند‪.‬‬ ‫)(‪Collection values‬‬
‫‪Map.Entry‬‬
‫‪ Map.Entry‬یک ‪ interface‬برای دسترسی به زوج کلید‪-‬مقدار )‪ (entry‬است که متدهایی را برای استخراج کلید یا مقدار در‬
‫اختیار ما قرار میدهد‪ .‬متدهای )(‪ Map.Entry‬عبارتاند از‪:‬‬
‫تصاوی یک ‪ entry‬را با ‪ entry‬دیگری بررسی میکند‪.‬‬ ‫)‪equals(Object o‬‬
‫از داخل یک زوج کلید‪-‬مقدار‪ ،‬کلید را استخراج میکند‪.‬‬ ‫)(‪getKey‬‬
‫از داخل یک زوج کلید‪-‬مقدار‪ ،‬مقدار را استخراج میکند‪.‬‬ ‫)(‪getValue‬‬

‫‪1۳۱‬‬ ‫مبانی زبان جاوا‬
‫‪ HashCode‬متناظر با ‪ entry‬را محاسبه میکند‪.‬‬ ‫)(‪hashCode‬‬
‫به کلید فعلی یک مقدار جدید نسبت میدهد‪.‬‬ ‫)‪setValue(Object o‬‬
‫در ادامه با دو مثال با ‪ Map‬آشنا میشویم و مثالهای بیشتر را به آموزشهای بعدی موکول میکنیم‪ .‬در مثال اول یک ‪ Map‬به‬
‫صورت زوجهای نام‪-‬نمره ایجاد میکنیم که در آن کلید نام افراد و مقدار نمره آنهاست‪.‬‬
‫;‪import java.util.Map‬‬
‫;‪import java.util.HashMap‬‬

‫{‬
‫{‬
‫;)(><‪Map myMap = new HashMap‬‬
‫;)‪myMap.put("Jenny", 85‬‬
‫;)"‪myMap.put("Peter", "No Score‬‬
‫;)‪myMap.put("Mary Jane", 64‬‬
‫;)‪myMap.put("Azhar", 87‬‬
‫;)‪System.out.println(myMap‬‬
‫}‬
‫}‬
‫}‪{Azhar=79, Jenny=87, Mary Jane = 64, Peter = No Score‬‬
‫در مثال باال ابتدا یک شیء از ‪ Map‬ایجاد کردیم‪ ،‬چون ‪ Map‬تنها یک ‪ interface‬است برای استفاده از ‪ new‬و ساخت یک شیء‬
‫واقعی باید از یکی از زیر کالسهای آن استفاده کنیم که در اینجا از ‪ HashMap‬که بعدا با آشنا میشویم استفاده کردیم‪ .‬پس از‬
‫ساخت ‪ Map‬با استفاده از متد )(‪ put‬زوجهای کلید و مقدار را در ‪ Map‬قرار دادیم‪ ،‬چون کلید نمیتواند تکراری باشد پس از‬
‫فراخوانی )‪ (“Jenny”, 85‬مقدار قبلی متناظر با ‪ Jenny‬یعنی ‪ 01‬از ‪ Map‬پاک میشود ولی دقت کنید که مقادیر میتوانند‬
‫تکراری باشند (بر خالف کلید)‪ ،‬به عنوان مثال ‪ Azhar‬و ‪ Jenny‬هر دو دارای مقدار ‪ 01‬هستند‪ .‬در مثال دوم با ‪ Map.Entry‬آشنا‬
‫میشویم و برای سادگی بیشتر از همان کد مثال قبلی استفاده میکنیم‪.‬‬
‫;‪import java.util.Set‬‬

‫{‬
‫{‬
‫;)(><‪Map myMap = new HashMap‬‬
‫;)"‪myMap.put("Peter", "No Score‬‬
‫;)‪myMap.put("Mary Jane", 64‬‬
‫;)‪myMap.put("Azhar", 87‬‬
‫;)(‪Set<Map.Entry> s = myMap.entrySet‬‬
‫)‪for (Map.Entry me : s‬‬

‫{‬
‫;)")" ‪System.out.println("[" + me.getKey() + "]=(" + me.getValue() +‬‬
‫}‬
‫}‬
‫}‬
‫)‪[Azhar] = (79‬‬
‫)‪[Jenny] = (87‬‬
‫)‪[Mary Jane] = (64‬‬
‫)‪[Peter] = (No Score‬‬
‫همانطور که مشاهده میکنید کلیدها را بین ][ و مقادیر را بین )( قرار میدهیم‪ .‬پس از ساخت ‪ Map‬متد )(‪ entry‬را فراخوانی‬
‫میکنیم و نتیجه را در یک ‪ Set‬میریزیم‪ ،‬باید مشخص کنیم که عناصر این از نوع ‪ Map.Entry‬هستند‪ .‬پس از آن در داخل یک‬
‫حلقه ‪ for‬هر کدام از ‪ Map.Entry‬ها را استخراج میکنیم و سپس با فراخوانی متد )(‪ getKey‬کلید و با فراخوانی متد‬
‫)(‪ getValue‬مقدار را به دست آورده و چاپ میکنیم‪.‬‬
‫‪Set‬‬
‫‪ Set‬یکی از ‪interface‬های اصلی ‪ Collection Framework‬جاواست که برای نگه داری یک مجموعه بدون تکرار از آن استفاده‬
‫میشود‪ ،‬زیر کالسهای مختلفی همچون ‪ HashSet ،TreeSet‬و ‪ LinkedHashSet‬در جاوا وجود دارند که هر کدام با استفاده از‬
‫الگوریتمها و ساختمان دادههای متفاوت به نحوی مفهوم “مجموعه بدون تکرار” را پیاده سازی کردهاند‪ null .‬نیز میتواند یک‬
‫مقدار منحصر به فرد در نظر گرفته شود لذا هر ‪ Set‬میتواند حداکثر یک مقدار ‪ null‬نیز داشته باشد‪ .‬کاربردهای‪ Set‬به صورت‬
‫کلی عبارتاند از‪:‬‬
‫نگه داری یک مجموعه بدون تکرار‬ ‫‪‬‬

‫‪1۳1‬‬ ‫مبانی زبان جاوا‬
‫صرفه جویی حافظه در الگوریتمهای جست و جوی پیشرفته (با تشخیص گرههای تکراری)‬ ‫‪‬‬
‫تشخیص عضویت یک شیء در مجموعه با بار محاسباتی کم‪.‬‬ ‫‪‬‬
‫محاسبه سریع اشتراک دو مجموعه‬ ‫‪‬‬
‫متدهای ‪ Set‬در جدول زیر آمدهاند‪ ،‬کالسهایی که از کالس ‪ Set‬ارث بری دارند موظف هستند این متدها را پیاده سازی کنند‪.‬‬
‫یک عنصر جدید به ‪ Set‬اضافه میکند‪.‬‬ ‫)‪add(Object o‬‬
‫تمام اعضای یک کالکشن دیگر را به ‪ Set‬اضافه میکند‪.‬‬ ‫)‪addAll(Collection c‬‬
‫تمام اعضای داخل ‪ Set‬را حذف میکند‪.‬‬ ‫)(‪clear‬‬
‫وجود یک عنصر در ‪ Set‬را بررسی میکند‪.‬‬ ‫)‪contains(Object o‬‬
‫اگر تمام اعضای کالکشن ‪ c‬در ‪ Set‬فعلی وجود داشته باشند ‪ true‬بر میگرداند‪.‬‬ ‫)‪containsAll(Collection c‬‬
‫‪ Set‬فعلی را با ‪ Set‬دیگری مقایسه میکند‪.‬‬ ‫)‪equals(Ojbect o‬‬
‫‪ HashCode‬کل‪ Set‬را محاسبه میکند‪.‬‬ ‫)(‪hashCode‬‬
‫بررسی میکند که ‪ Set‬خالی است یا خیر؟‬ ‫)(‪isEmpty‬‬
‫یک ‪ iterator‬برای پیمایش ‪ Set‬بر میگرداند‪.‬‬ ‫)(‪iterator‬‬
‫یک عنصر را از ‪ Set‬حذف میکند‪.‬‬ ‫)‪remove(Object o‬‬
‫تمام عناصر یک کالکشن دیگر را از ‪ Set‬فعلی حذف میکند‪.‬‬ ‫)‪removeAll(Collection c‬‬
‫اشتراک ‪ Set‬فعلی را با کالکشن دیگر محاسبه میکند و سایر اعضا را حذف میکند‪.‬‬ ‫)‪retainAll(Collection c‬‬
‫تعداد عناصر داخل ‪ Set‬را بر میگرداند‪.‬‬ ‫)(‪size‬‬
‫عناصر را در داخل یک آرایه در اختیار ما قرار میدهد‪.‬‬ ‫)(‪Object[] toArray‬‬

‫در ادامه با دو مثال با‪ Set‬آشنا میشویم و مثالهای بیشتر را به آموزشهای بعدی موکول میکنیم‪ .‬در مثال اول یک ‪ Set‬ایجاد‬
‫میکنیم و در انتها متوجه میشویم که عنصر تکراری در آن نگه داری نمیشود‪.‬‬
‫;‪import java.util.HashSet‬‬

‫{‬
‫{‬
‫;)(‪Set set = new HashSet‬‬
‫;)‪set.add(null‬‬
‫;)"‪set.add("Jenny‬‬
‫;)"‪set.add("Azhar‬‬
‫;)‪set.add(null‬‬
‫;)"‪set.add("Azhar‬‬
‫;)‪System.out.println(set‬‬
‫}‬
‫}‬
‫]‪[null, Jenny, Azhar‬‬
‫همانطور که مشاهده میکنید با اینکه عنصر ”‪ “Jenny‬سه بار و عنصر ‪ null‬دوبار به مجموعه اضافه شدند در نتیجه نهایی از هر‬
‫عنصر تنها یک نمونه وجود دارد‪ .‬در مثال باال ابتدا یک شیء از ‪ Set‬ایجاد کردیم‪ ،‬چون ‪ Set‬تنها یک ‪ interface‬است برای‬
‫استفاده از ‪ new‬و ساخت یک شیء واقعی باید از یکی از زیر کالسهای آن استفاده کنیم که در اینجا از ‪ HashSet‬که بعدا با آشنا‬
‫میشویم استفاده کردیم‪ .‬پس از ساخت ‪ Set‬با استفاده از متد )(‪ add‬عناصری را به آن اضافه کردیم‪ .‬در مثال دوم با ‪retainAll‬‬
‫آشنا میشویم‪.‬‬

‫{‬
‫{‬
‫;)(‪Set A = new HashSet‬‬
‫;)(‪Set B = new HashSet‬‬
‫;)‪A.add(2‬‬
‫;)‪A.add(4‬‬
‫;)‪A.add(6‬‬
‫;)‪B.add(2‬‬
‫‪1۳۹‬‬ ‫مبانی زبان جاوا‬
‫;)‪B.add(4‬‬
‫;)‪B.add(5‬‬
‫;)‪System.out.println(A‬‬
‫;)‪System.out.println(B‬‬
‫;)‪A.retainAll(B‬‬
‫;)‪System.out.println(A‬‬
‫}‬
‫}‬
‫]‪[2, 4, 6‬‬
‫]‪[2, 4, 5‬‬
‫]‪[2, 4‬‬
‫در کد قبل دو مجموعه به نامهای ‪ A‬و ‪ B‬ایجاد میکنیم‪ ،‬مجموعه اول شامل اعداد ‪ 1 ،3 ،5‬و مجموعه دوم شامل اعداد ‪1 ،3 ،5‬‬
‫خواهد بود‪ ،‬پس از استفاده از ‪ retainAll‬اعضایی از ‪ A‬که در مجموعه ‪ B‬قرار ندارند از ‪ A‬حذف میشوند و نتیجه به صورت‬
‫اشتراک دو مجموعه خواهد بود‪.‬‬
‫‪HashSet‬‬
‫کالس ‪ HashSet‬زیر کالس ‪ AbstractSet‬است و مفهوم ‪ Set‬یعنی یک مجموعه بدون تکرار را پیاده سازی میکند و در پکیج‬
‫‪ java.util.HashSet‬قرار دارد‪ .‬قبال با مفهوم ‪ Set‬آشنا شدیم‪ ،‬کالس ‪ HashSet‬برای پیاده سازی ‪ Set‬از الگوریتم درهم سازی‬
‫)‪ (hashing‬استفاده میکند‪ .‬مهمترین کاربرد ‪ HashSet‬این است که تشخیص دهیم شی خاصی در مجموعه وجود دارد یا خیر ؟‬
‫چون ‪ HashSet‬از جدول ‪ Hash‬و الگوریتم درهم سازی استفاده می کند عمل جست و جو در آن بسیار سریع است و از این ویژگی‬
‫آن در جست و جوهای پیشرفته مانند الگوریتمهای جست و جوی هوش مصنوعی استفاده میشود‪ .‬برای ساخت ‪ HashSet‬باید‬
‫از یکی از سازندههای زیر استفاده کنیم‪:‬‬
‫)(‪HashSet‬‬
‫یک ‪ HashSet‬خالی با جدول نگه دارنده ای با اندازه پیش فرض ایجاد میکند‪.‬‬
‫)‪HashSet(Collection c‬‬
‫یک ‪ HashSet‬جدید ایجاد میکند و اعضای کالکشن ‪ c‬را به آن اضافه میکند‪.‬‬
‫)‪HashSet(int Capacity‬‬
‫یک ‪ HashSet‬خالی با جدول نگه دارنده ای با اندازه ‪ Capacity‬ایجاد میکند‪ ،‬هر زمان که الزم باشد اندازه جدول نگه دارنده به‬
‫صورت خودکار افزایش مییابد‪.‬‬
‫)‪HashSet(int Capacity,float fillRatio‬‬
‫یک ‪ HashSet‬خالی با جدول نگه دارنده ای با اندازه ‪ Capacity‬ایجاد میکند‪ ،‬هر زمان که الزم باشد اندازه جدول نگه دارنده به‬
‫صورت خودکار افزایش مییابد‪ ،‬پارامتر ‪ fillRation‬عددی بین ‪ 3.3‬و ‪ 3.3‬است و مشخص میکند که جدول نگه دارنده چه زمان‬
‫باید تغییر اندازه داده شود‪ ،‬به عنوان مثال ‪ 3.0‬به معنی آن است که هنگامی که ظرفیت جدول به بیش از هشتاد درصد رسید اندازه‬
‫جدول افزایش یابد‪ .‬متدهای مهم ‪ HashSet‬در جدول زیر آمدهاند‪:‬‬
‫یک عنصر جدید به مجموعه اضافه میکند‪.‬‬ ‫)‪add(Object o‬‬
‫کل مجموعه را پاک میکند‪.‬‬ ‫)(‪clear‬‬
‫وجود یا عدم وجود یک عنصر در مجموعه را بررسی میکند‪.‬‬ ‫)‪contains(Object o‬‬
‫خالی بودن مجموعه را بررسی میکند‪.‬‬ ‫)(‪isEmpty‬‬
‫یک ‪ Iterator‬برای پیمایش اعضای مجموعه در اختیار ما قرار میدهد‪.‬‬ ‫)(‪iterator‬‬
‫یک عنصر را از مجموعه حذف میکند‪.‬‬ ‫)‪remove(Object o‬‬
‫اندازه مجموعه را بر میگرداند‪.‬‬ ‫)(‪size‬‬
‫یک آرایه از روی اعضای مجموعه بر میگرداند‪.‬‬ ‫)(‪toArray‬‬
‫مهمترین ویژگیهای‪ HashSet‬عبارتاند از‪:‬‬
‫متدهای )(‪ add‬و )(‪ remove‬و )(‪ contains‬در ‪ HashSet‬فوق العاده سریع هستند و این مهمترین ویژگی‬ ‫‪‬‬
‫‪ HashSet‬است‪.‬‬
‫در ‪ HashSet‬عضو تکراری وجود ندارد‪.‬‬ ‫‪‬‬

‫اعضای داخل مجموعه ‪ HashSet‬ترتیب خاصی ندارند‪.‬‬ ‫‪‬‬
‫در مثال زیر با استفاده از متد )(‪ add‬چند عضو به ‪ HashSet‬اضافه میکنیم و سپس کل مجموعه را چاپ میکنیم‪ ،‬با متد‬
‫)(‪ remove‬عنصری را حذف میکنیم و مجددا کل مجموعه را چاپ می کنیم‪ ،‬در انتها نیز وجود یا عدم وجود دو مورد در مجموعه را‬
‫با متد )(‪ contains‬بررسی میکنیم‪.‬‬

‫{‬
‫{‬
‫;)(‪HashSet mySet = new HashSet‬‬
‫;)"‪mySet.add("A‬‬
‫;)"‪mySet.add("B‬‬
‫;)"‪mySet.add("C‬‬
‫;)"‪mySet.add("A‬‬
‫;)"‪mySet.add("D‬‬
‫;)"‪mySet.add("E‬‬
‫;)‪System.out.println(mySet‬‬
‫;)"‪mySet.remove("D‬‬
‫;)‪System.out.println(mySet‬‬
‫;))"‪System.out.println(mySet.contains("D‬‬
‫;))"‪System.out.println(mySet.contains("E‬‬
‫}‬
‫}‬
‫]‪[A, B, C, D, E‬‬
‫]‪[A, B, C, E‬‬
‫‪false‬‬
‫‪true‬‬
‫در کد باال مشاهده میکنید که ‪ HashSet‬عضو تکراری نگه داری نمی کند‪ ،‬به عالوه هنگامی که عضوی در مجموعه وجود نداشته‬
‫باشد متد )(‪ contains‬مقدار ‪false‬را بر میگرداند‪.‬‬
‫‪LinkedList‬‬
‫کالس ‪ LinkedList‬پیاده سازی ‪ interface‬های ‪ Deque‬و ‪ List‬است و برای همین صفات لیست و صف را با هم داراست‪،‬‬
‫این کالس به صورت ساختمان داده لیست دو پیوندی )‪ (Doubly-LinkedList‬پیاده سازی شده است و برای همین میتوان به‬
‫سادگی و در زمان کم به ابتدا و انتهای عنصر جدید اضافه کرد‪ ،‬به عالوه به دلیل دو پیوندی بودن عمل حذف به صورت بهینه تری‬
‫انجام میپذیرد‪ .‬از این کالس میتوان به عنوان یک لیست ساده با دسترسی تصادفی‪ ،‬صف دو طرفه‪ ،‬صف ‪ FIFO‬یا حتی صف‬
‫‪ LIFO‬استفاده کرد‪.‬این کالس از لحاظ عملکرد بسیار شبیه ‪ ArrayList‬است و تفاوت آنها در ساختمان داده ای است که به کار‬
‫میبرند‪ ،‬شباهتها و تفاوت این دو کالس عبارتاند از‪:‬‬
‫‪ ArrayList‬از یک آرایه پویا و ‪ LinkedList‬از ساختمان داده لیست دو پیوندی استفاده میکند‪.‬‬ ‫‪‬‬
‫عمل درج یا حذف عنصر در ابتدای در ‪ LinkedList‬بسیار سریع است ولی در ‪ ArrayList‬ممکن است سریع نباشد‪.‬‬ ‫‪‬‬
‫عمل درج یا حذف عنصر در انتها در هر دو کالس به سرعت انجام میشود‪.‬‬ ‫‪‬‬
‫عمل جست و جو در هر دو کالس به صورت خطی است و چندان بهینه نیست‪.‬‬ ‫‪‬‬
‫عمل حذف با داشتن گره‪ ،‬در ‪ LinkedList‬سریع تر است ولی اگر گره در دسترس نباشد و مجبور به عمل جست و جو‬ ‫‪‬‬
‫قبل از حذف گره باشیم هر دو کالس تقریبا یکسان هستند و چندان بهینه نیستند‪.‬‬
‫دسترسی تصادفی در ‪ ArrayList‬بسیار سریع است ولی در ‪ LinkedList‬سریع نیست‪.‬‬ ‫‪‬‬
‫کالس ‪ LinkedList‬از طریق مسیر ‪ java.util.LinkedList‬قابل دستیابی است‪ .‬برای ساخت شیء از کالس ‪LinkedList‬‬
‫باید از یکی از سازندههای زیر استفاده کنیم‪:‬‬
‫)(‪LinkedList‬‬
‫این سازنده یک ‪ LinkedList‬خالی ایجاد میکند‪.‬‬
‫)‪LinkedList(Collection c‬‬
‫این سازنده یک ‪ LinkedList‬جدید ایجاد میکند و اعضای کالکشن ‪ c‬را به عنوان آیتمهای اولیه به ‪ LinkedList‬اضافه‬
‫میکند‪ .‬متدهای مهم ‪ LinkedList‬در جدول زیر آمدهاند‪:‬‬
‫عنصر جدید را به انتهای لیست اضافه میکند‪.‬‬ ‫)‪add(Object o‬‬
‫عنصر جدید را در اندیس مورد نظر درج میکند‪.‬‬ ‫)‪add(int index,Object o‬‬
‫اعضای یک کالکشن دیگر را به انتهای لیست اضافه میکند‪.‬‬ ‫)‪addAll(Collection c‬‬
‫عنصر جدید را به ابتدای لیست اضافه میکند‪.‬‬ ‫)‪addFirst(Object o‬‬
‫عنصر جدید را به انتهای لیست اضافه میکند‪.‬‬ ‫)‪addLast(Object o‬‬
‫تمام عناصر داخل لیست را پاک میکند‪.‬‬ ‫)(‪clear‬‬
‫بررسی می کند که عنصر مورد نظر در لیست وجود دارد یا خیر؟‬ ‫)‪contains(Object o‬‬
‫عنصر ابتدای لیست را بر میگرداند ولی آن را حذف نمیکند‪.‬‬ ‫)(‪element‬‬
‫عنصر موجود در اندیس مورد نظر را بر میگرداند‪.‬‬ ‫)‪get(int index‬‬
‫عنصر ابتدای لیست را بر میگرداند ولی آن را حذف نمیکند‪.‬‬ ‫)(‪getFirst‬‬
‫عنصر انتهای لیست را بر میگرداند ولی آن را حذف نمیکند‪.‬‬ ‫)(‪getLast‬‬
‫اولین اندیس مورد نظر یک عنصر را پیدا میکند‪.‬‬ ‫)‪indexOf(Object o‬‬
‫آخرین اندیس یک عنصر خاص را پیدا میکند‪.‬‬ ‫)‪lastIndexOf(Object o‬‬
‫یک عنصر به انتهای لیست اضافه میکند‪.‬‬ ‫)‪offer(Object o‬‬
‫یک عنصر به ابتدای لیست اضافه میکند‪.‬‬ ‫)‪offerFirst(Object o‬‬
‫یک عنصر به انتهای لیست اضافه میکند‪.‬‬ ‫)‪offerLast(Object o‬‬
‫عنصر ابتدای لیست را بر میگرداند ولی آن را حذف نمیکند‪.‬‬ ‫)(‪peek‬‬
‫عنصر ابتدای لیست را بر میگرداند ولی آن را حذف نمیکند‬ ‫)(‪peekFirst‬‬
‫عنصر انتهای لیست را بر میگرداند ولی آن را حذف نمیکند‬ ‫)(‪peekLast‬‬
‫عنصر ابتدای لیست را بر میگرداند و آن را حذف میکند‬ ‫)(‪poll‬‬

‫عنصر ابتدای لیست را بر میگرداند و آن را حذف میکند‬ ‫)(‪pollFirst‬‬
‫عنصر انتهای لیست را بر میگرداند و آن را حذف میکند‬ ‫)(‪Object pollLast‬‬
‫عنصر ابتدای لیست را بر میگرداند و آن را حذف میکند‬ ‫)(‪pop‬‬
‫اگر از ‪ LinkedList‬به عنوان ‪ Stack‬استفاده کرده باشیم عنصری را به باالی آن اضافه‬ ‫)‪push(Object o‬‬
‫میکند‪.‬‬
‫عنصر ابتدای لیست را بر میگرداند و آن را حذف میکند‬ ‫)(‪remove‬‬
‫عنصر موجود در اندیس مورد نظر را بر میگرداند و حذف میکند‪.‬‬ ‫)‪remove(int index‬‬
‫عنصر مورد نظر را پیدا کرده و حذف میکند‪.‬‬ ‫)‪remove(Object o‬‬
‫عنصر ابتدای لیست را بر میگرداند و آن را حذف میکند‬ ‫)(‪removeFirst‬‬
‫عنصر انتهای لیست را بر میگرداند و آن را حذف میکند‬ ‫)(‪removeLast‬‬
‫عنصر موجود در اندیس مورد نظر را به شی دیگری تغییر میدهد‪.‬‬ ‫)‪set(int index,Object o‬‬
‫اندازه لیست را بر میگرداند‪.‬‬ ‫)(‪size‬‬
‫یک آرایه معادل از روی عناصر لیست بر میگرداند‪.‬‬ ‫)(‪toArray‬‬
‫بسیاری از متدهای فوق عمل یکسانی انجام می دهند و اینکه در عین کاربرد از کدام یک از آنها استفاده کنیم بیشتر به سالیق‬
‫برنامه نویس مربوط میشود‪ .‬در ادامه با چند مثال با ‪ LinkedList‬آشنا میشویم‪ .‬در این مثال با کاربرد ‪ LinkedList‬به عنوان‬
‫یک لیست با دسترسی تصادفی آشنا میشویم‪:‬‬

‫{‬
‫{‬
‫;)(‪LinkedList myLL = new LinkedList‬‬
myLL.add("A");
myLL.add("B");
myLL.add("C");
System.out.println(myLL);
System.out.println(myLL.get(1));
System.out.println(myLL.remove(1));
System.out.println(myLL.indexOf("C"));
}
}
[A, B, C]
B
[A, B, C]
B
[A, C]
1
‫ می دانیم که‬،‫ عناصری را به آن اضافه میکنیم‬add() ‫ ایجاد میکنیم و سپس با استفاده از متد‬LinkedList ‫در کد باال ابتدا یک‬
‫ عنصر‬get() ‫ با استفاده از متد‬.‫ پس از ساخت لیست یک بار آن را چاپ میکنیم‬.‫این متد عناصر را به انتهای لیست اضافه میکند‬
‫ عنصر موجود در اندیس یک را با متد‬.‫ را به دست آورده و آن را چاپ کرده و سپس کل لیست را چاپ میکنیم‬3 ‫موجود در اندیس‬
‫ اندیس از صفر شروع‬LinkedList ‫ حذف میشود زیرا در‬B ‫ میبینیم که عنصر‬،‫ حذف کرده و آن را چاپ میکنیم‬remove()
‫ به ابتدا و انتهای‬،‫ در مثال دوم‬.‫ را به دست آورده و چاپ میکنیم‬C ‫ اندیس عنصر‬indexOf() ‫ در انتها با استفاده از متد‬.‫میشود‬
:‫لیست عنصر اضافه کرده و سپس آنها را حذف میکنیم‬
import java.util.LinkedList;

{
{
LinkedList myLL = new LinkedList();
myLL.add("O");
myLL.addFirst("A1");
myLL.addLast("B1");
myLL.addFirst("A2");
myLL.addLast("B2");
‫;)(‪myLL.removeFirst‬‬
‫;)‪System.out.println(myLL‬‬
‫;)(‪myLL.removeLast‬‬
‫;)‪System.out.println(myLL‬‬
‫}‬
‫}‬
‫‪[A1,‬‬ ‫]‪O, B1‬‬

‫‪[A2,‬‬ ‫]‪A1, O, B1, B2‬‬
‫‪[A1,‬‬ ‫]‪O, B1, B2‬‬
‫‪[A1,‬‬ ‫]‪O, B1‬‬
‫در کد باال ابتدا با استفاده از متد )(‪ add‬یک عنصر به لیست اضافه میکنیم‪ ،‬سپس عنصر ‪ A1‬را با استفاده از متد )(‪addFirst‬‬
‫به ابتدای لیست و عنصر ‪ B1‬را با استفاده از متد )(‪ addLast‬به انتهای لیست اضافه میکنیم و بعد لیست را چاپ میکنیم‪.‬‬
‫عنصر ‪ A2‬را به ابتدای لیست و عنصر ‪ B2‬را به انتهای لیست اضافه میکنیم و لیست را چاپ میکنیم‪ .‬با استفاده از متد‬
‫)(‪ removeFirst‬عنصر ابتدای لیست را حذف میکنیم‪ .‬با استفاده از متد )(‪ removeLast‬عنصر انتهای لیست را حذف میکنیم‪.‬‬
‫میتوانیم به اشکال زیر از ‪ LinkedList‬به عنوان پیاده سازی ‪ Deque ،Queue‬و ‪ List‬استفاده کنیم‪:‬‬
‫;)(‪Queue queue = new LinkedList‬‬
‫;)(‪Deque deque = new LinkedList‬‬
‫‪List list‬‬ ‫;)(‪= new LinkedList‬‬
‫استفاده از ‪ LinkedList‬به عنوان صف )‪ LIFO‬یا همان ‪)Stack‬‬
‫از ‪ LinkedList‬میتوانیم به عنوان صف ‪ LIFO‬نیز استفاده کنیم‪ ،‬کلمه ‪ LIFO‬مخفف عبارت ‪ Last in First Out‬است و‬
‫بدین معنی است که عنصری که دیرتر اضافه میشود زودتر خارج میشود‪ ،‬به چنین صفی ‪ Stack‬نیز گفته میشود‪ .‬در جاوا کالس‬
‫اختصاصی برای ‪ Stack‬نیز وجود دارد ولی میتوانیم از ‪ LinkedList‬نیز به جای آن استفاده کنیم‪:‬‬

‫{‬
‫{‬
‫;)(‪LinkedList myLIFO = new LinkedList‬‬
‫;)"‪myLIFO.push("A‬‬
‫;)"‪myLIFO.push("B‬‬
‫;)"‪myLIFO.push("C‬‬
‫;)‪System.out.println(myLIFO‬‬
‫;))(‪System.out.println(myLIFO.pop‬‬
‫}‬
‫}‬
‫]‪[C, B, A‬‬
‫‪C‬‬
‫]‪[B, A‬‬
‫‪B‬‬
‫]‪[A‬‬
‫‪A‬‬
‫][‬
‫در کد باال با استفاده از متد )(‪ push‬عناصر را به صف ‪ LIFO‬اضافه میکنیم‪ ،‬در انتها عنصر ‪ C‬در باالی صف قرار خواهد داشت‪.‬‬
‫در ادامه با استفاده از متد )(‪ pop‬عنصر باالی صف را حذف میکنیم‪ ،‬می دانیم که در این شیوه عنصری که دیرتر اضافه شده زودتر‬
‫حذف میشود لذا ابتدا ‪ C‬و سپس ‪ B‬و در انتها ‪ A‬از صف حذف میشوند‪ .‬هر بار پس از عمل حذف صف را نیز چاپ میکنیم‪.‬‬
‫‪Queue‬‬
‫‪ Queue‬یکی از ‪ interface‬های مهم در ‪ Collection Framework‬جاواست که برای تعریف مفهوم صفاز آن استفاده میشود‪،‬‬
‫صف ساختمان داده ای است که بتوان اشیایی را با ترتیبی خاص به آن وارد کرد و با الگوریتم مشخصی از آن استخراج یا حذف‬
‫نمود‪ ،‬الگوریتم ها و پیاده سازی های مختلفی از انواع صف وجود دارند که در مباحث بسیار پیشرفته ای همچون تئوری صفها‬
‫)‪ (Queueing Theory‬مطرح میشوند‪ ،‬سه پیاده سازی ساده و مهم صف در جاوا عبارتاند از‪:‬‬
‫‪ :LinkedList‬صفی با ساختار ‪ FIFO‬را پیاده سازی میکند که از لیست پیوندی استفاده میکند‪.‬‬ ‫‪‬‬
‫‪ :ArrayDeque‬صفی با ساختار ‪ FIFO‬است که نحوه پیاده سازی آن با ‪ LinkedList‬متفاوت است‪.‬‬ ‫‪‬‬

‫‪ :PriorityQueue‬صف اولویت را پیاده سازی میکند‪.‬‬ ‫‪‬‬
‫کلمه ‪ FIFO‬مخفف عبارت ‪ First In First Out‬است‪ ،‬صف ‪ FIFO‬صفی است که در آن عنصری که ابتدا وارد شود اولین‬
‫عنصری خواهد بود که خارج میشود‪ ،‬مشابه صف نانوایی و بسیاری از صفهای دیگر که در زندگی روزمره تجربه میکنیم‪ .‬در کنار‬
‫ساختمان دادههای ساده و معمولی فوق کالسهای پیشرفته تری برای کار در مباحثی همچون شبکه‪ ،‬چند نخی‬
‫)‪ ،(multithreading‬مسائل همزمانی )‪(concurrency‬مانند ‪،LinkedTransferQueue ،SynchronosQueue ،DelayQueue‬‬
‫‪ ConcurrentLinkedDeque‬و … نیز وجود دارند‪ .‬به صورت کلی یک صف صرف نظر از ساختمان داده داخلی آن و الگوریتم ورود‬
‫یا خروج اعضا باید دارای ویژگیهای کلی زیر باشد‪:‬‬
‫صف دارای بخشی به نام سر )‪ (head‬باشد‪.‬‬ ‫‪‬‬
‫بتوان مواردی را به آن اضافه یا حذف کرد‪.‬‬ ‫‪‬‬
‫بتوان عنصر سر را بدون حذف استخراج کرد (برای تست)‬ ‫‪‬‬
‫‪ Queue‬از طریق مسیر ‪ java.util.Queue‬قابل دسترسی است و متدهای زیر را تعریف میکند‪ .‬کالسهایی که از این کالس ارث‬
‫بری داشته باشند موظف هستند این متدها را پیاده سازی کنند‪ :‬متدهای مربوط به مفهوم صف‪:‬‬
‫یک عنصر جدید به صف اضافه میکند‪ .‬اگر قادر به این کار نباشد یک خطا پرتاب میکند‪.‬‬ ‫)‪add(Object o‬‬
‫عنصر سر )‪ (head‬را بر میگرداند ولی آن را از صف حذف نمیکند‪.‬‬ ‫)(‪element‬‬
‫یک عنصر جدید به صف اضافه میکند اگر قادر به این کار نباشد تنها ‪ false‬بر میگرداند‪.‬‬ ‫)‪offer(Object o‬‬
‫عنصر سر را بر میگرداند‪ ،‬اگر صف خالی شده باشد ‪ null‬بر میگرداند‪.‬‬ ‫)(‪peek‬‬
‫عنصر سر را بر میگرداند و آن را از صف حذف میکند‪ ،‬اگر صف خالی باشد ‪ null‬بر میگرداند‪.‬‬ ‫)(‪poll‬‬
‫عنصر سر را حذف میکند‪.‬‬ ‫)(‪remove‬‬
‫متدهایی که از ‪ Collection‬به ارث رفتهاند‪:‬‬

‫تمام اعضای یک کالکشن دیگر را به صف اضافه میکند‪.‬‬ ‫)‪addAll(Collection c‬‬
‫تمام اعضای داخل صف را حذف میکند‪.‬‬ ‫)(‪clear‬‬
‫وجود یک عنصر در صف را بررسی میکند‪.‬‬ ‫)‪contains(Object o‬‬
‫اگر تمام اعضای کالکشن ‪ c‬در صف فعلی وجود داشته باشند ‪ true‬بر میگرداند‪.‬‬ ‫)‪containsAll(Collection c‬‬
‫صف فعلی را با صف دیگری مقایسه میکند‪.‬‬ ‫)‪equals(Ojbect o‬‬
‫‪ HashCode‬کل صف را محاسبه میکند‪.‬‬ ‫)(‪hashCode‬‬
‫بررسی میکند که صف خالی است یا خیر؟‬ ‫)(‪isEmpty‬‬
‫یک ‪ iterator‬برای پیمایش صف بر میگرداند‪.‬‬ ‫)(‪iterator‬‬
‫یک عنصر را از صف حذف میکند‪.‬‬ ‫)‪remove(Object o‬‬
‫تمام عناصر یک کالکشن دیگر را از صف فعلی حذف میکند‪.‬‬ ‫)‪removeAll(Collection c‬‬
‫اشتراک صف فعلی را با کالکشن دیگر محاسبه میکند و سایر اعضا را حذف میکند‪.‬‬ ‫)‪retainAll(Collection c‬‬
‫تعداد عناصر داخل صف را بر میگرداند‪.‬‬ ‫)(‪size‬‬
‫عناصر را در داخل یک آرایه در اختیار ما قرار میدهد‪.‬‬ ‫)(‪toArray‬‬
‫در مثال زیر یک صف ساده ایجاد میکنیم‪ ،‬عناصری به آن اضافه میشوند و سپس تک تک عناصر را از صف خارج میکنیم‪.‬‬
‫;‪import java.util.Queue‬‬

‫{‬
‫{‬
‫;)(‪Queue q = new LinkedList‬‬
‫;)‪q.add(1‬‬
‫;)‪q.add(8‬‬
‫;)‪q.add(3‬‬
‫;)‪System.out.println(q‬‬
‫;))(‪System.out.println(q.poll‬‬
‫}‬
‫}‬
‫]‪[1, 8, 3‬‬
‫‪1‬‬
‫]‪[8, 3‬‬
‫‪8‬‬
‫]‪[3‬‬
‫‪3‬‬
‫][‬
‫در کد باال یک ‪ Queue‬ایجاد کردیم‪ ،‬چون ‪ Queue‬تنها یک ‪ interface‬است برای ساخت شیء جدید باید از یکی از زیر کالسهای‬
‫پیاده سازی شده آن استفاده کنیم‪ ،‬در این مثال از ‪ LinkedList‬استفاده کردیم‪ ،‬با استفاده از متد )(‪ add‬عناصر ‪ 0 ،3‬و ‪ 1‬را به‬
‫صف اضافه کرده و سپس کل صف را چاپ نمودیم‪ .‬در ادامه با استفاده متد )(‪ poll‬عنصر سر صف را حذف و چاپ کرده و پس‬
‫از آن صف باقی مانده را نیز چاپ میکنیم‪ ،‬مشاهده میکنیم عناصر با همین ترتیبی که وارد صف شدهاند از صف نیز خارج میشود‬
‫زیرا ‪ LinkedList‬صفی با ساختار ‪ FIFO‬است‪.‬‬
‫‪HashMap‬‬
‫قبال با مفهوم ‪ Map‬به عنوان وسیله ای برای نگه داری زوجهای کلید‪-‬مقدار آشنا شدیم‪ ،‬کالس ‪ HashMap‬زیر کالس ‪AbstractMap‬‬
‫است و از الگوریتم درهم سازی برای نگه داری زوجها نگه داری میکند‪ .‬مهمترین مزیت ‪ HashMap‬این است که دسترسی به کلیدها‬
‫در زمان بسیار کوتاهی صورت میگیرد و با داشتن کلید به سرعت میتوانیم مقدار را به دست بیاوریم‪ .‬از ‪ HashMap‬میتوان برای‬
‫ساخت جداولی همچون دفترچه تلفن‪ ،‬لیست نمرات و غیره استفاده کرد‪.‬به عالوه در بسیاری از کاربردهای هوش مصنوعی از‬
‫‪ HashMap‬برای شناسایی گرههای تکراری در جست و جوهای پیشرفته استفاده میشود‪ .‬در ‪ HashMap‬مقدار ‪ null‬هم به عنوان‬
‫‪1۱۵‬‬ ‫مبانی زبان جاوا‬
‫کلید و هم به عنوان مقدار مجاز است ولی حداکثر یک کلید با مقدار ‪ null‬میتواند در آن وجود داشته باشد‪ .‬کالس ‪ HashMap‬از‬
‫طریق مسیر ‪ java.util.HashMap‬قابل دستیابی است‪ .‬برای ساخت شیء جدید از کالس ‪ HashMap‬باید از یکی از سازندههای‬
‫زیر استفاده کنیم‪:‬‬
‫)(‪HashMap‬‬
‫یک ‪ HashMap‬جدید با جدول نگه دارنده خالی ایجاد میکند‪.‬‬
‫)‪HashMap(int capacity‬‬
‫یک ‪ HashMap‬جدید با جدول نگه دارنده ای با اندازه ‪ capacity‬ایجاد میکند‪ ،‬البته هر زمان که الزم باشد جدول نگه دارنده به‬
‫صورت خودکار افزایش اندازه خواهد داشت‪.‬‬
‫)‪HashMap(int capacity,float loadFactor‬‬
‫مشابه سازنده قبلی است با این تفاوت که پارامتر ‪ loadFactor‬تعیین میکند که چه زمان اندازه جدول نگه دارنده باید افزایش‬
‫یابد‪.‬‬
‫)‪HashMap(Map mp‬‬
‫یک ‪ HashMap‬جدید ایجاد میکند و اعضای ‪ mp‬را به آن اضافه میکند‪ .‬متدهای مهم ‪ HashMap‬در جدول زیر آمدهاند‪:‬‬
‫بررسی میکند که شی مورد نظر در بخش کلیدها قرار دارد یا خیر؟‬ ‫)‪containsKey(Object key‬‬
‫بررسی میکند که شی مورد نظر رد بخش مقادیر قرار دارد یا خیر؟‬ ‫)‪containsValue(Object value‬‬
‫یک مجموعه از کل مقادیر موجود در ‪ HashMap‬بر میگرداند‪.‬‬ ‫)(‪entrySet‬‬
‫مقدار متناظر با یک کلید را بر میگرداند‪.‬‬ ‫)‪get(Object key‬‬
‫بررسی میکند که مجموعه خالی است یا خیر؟‬ ‫)(‪isEmpty‬‬

‫مجموعه کلیدها را بر میگرداند‪.‬‬ ‫)(‪keySet‬‬
‫مقدار ‪ v‬را به کلید ‪ k‬نسبت میدهد‪.‬‬ ‫)‪put(Object k,Object v‬‬
‫تمام اعضای ‪ mp‬را به مجموعه اضافه میکند‪.‬‬ ‫)‪putAll(Map mp‬‬
‫کلید مورد نظر و مقدار متناظر با آن را از مجموعه حذف میکند‪.‬‬ ‫)‪remove(Object key‬‬
‫اندازه مجموعه (تعداد کلیدها) را بر میگرداند‪.‬‬ ‫)(‪size‬‬
‫مجموعه مقادیر را به صورت یک کالکشن بر میگرداند‪.‬‬ ‫)(‪Collection values‬‬
‫در مثال زیر یک دفترچه تلفن ساده طراحی میکنیم که کلید نام افراد و مقدار شماره آنهاست‪ ،‬هدف آن است که با داشتن نام‬
‫اشخاص به سرعت بتوانیم شماره آنها را بازیابی کنیم‪.‬‬

‫{‬
‫{‬
‫;)(‪HashMap myHashMap = new HashMap‬‬
‫;)"‪myHashMap.put("Jenny", "0916532365‬‬
‫;)"‪myHashMap.put("Peter", "0912534689‬‬
‫;)"‪myHashMap.put("Mary Jane", "09152136458‬‬
‫;)"‪myHashMap.put("Azhar", "09132536489‬‬
‫;))"‪System.out.println(myHashMap.get("Jenny‬‬
‫}‬
‫}‬
‫‪0916532365‬‬
‫در کد باال ابتدا یک سری داده با استفاده از متد )(‪ put‬به ‪ HashMap‬اضافه میکنیم‪ ،‬کلید نام افراد و مقدار شماره آنهاست‪ .‬در‬
‫ادامه با استفاده از متد )(‪ get‬شماره شخصی با نام ‪ Jenny‬را از مجموعه استخراج کرده و چاپ میکنیم‪ .‬می دانیم که در ساختار‬
‫‪ HashMap‬کلید منحصر به فرد است و کلید تکراری وجود ندارد ولی در یک دفترچه تلفن است ممکن است برای یک نفر چندین‬
‫شماره ثبت کرده باشیم‪ ،‬برای اینکه بتوانیم به یک کلید چندین مقدار نسبت دهیم باید از راهکاری ابتکاری استفاده کنیم‪ .‬برای این‬
‫منظور میتوانیم مقدار را به صورت یک کالکشن در نظر بگیریم‪ .‬در ادامه با این روش آشنا میشویم ‪.‬‬
‫‪1۱۳‬‬ ‫مبانی زبان جاوا‬

‫‪2‬‬
‫‪3‬‬ ‫;‪import java.util.HashMap‬‬
‫‪4‬‬ ‫;‪import java.util.TreeSet‬‬
‫‪5‬‬
‫‪7‬‬ ‫{‬
‫‪8‬‬ ‫;)(‪static HashMap myHashMap = new HashMap‬‬
‫‪9‬‬
‫‪10‬‬ ‫)‪static void putNumber(String name, String phoneNumber‬‬
‫‪11‬‬ ‫{‬
‫‪12‬‬ ‫;‪TreeSet list‬‬
‫‪13‬‬
‫‪14‬‬ ‫)‪if (myHashMap.get(name) == null‬‬
‫‪15‬‬ ‫{‬
‫‪16‬‬ ‫;)(‪list = new TreeSet‬‬
‫‪17‬‬ ‫}‬
‫‪18‬‬ ‫‪else‬‬
‫‪19‬‬ ‫{‬
‫‪20‬‬ ‫;)‪list = (TreeSet) myHashMap.get(name‬‬
‫‪21‬‬ ‫}‬
‫‪22‬‬
‫‪23‬‬ ‫;)‪list.add(phoneNumber‬‬
‫‪24‬‬
‫‪25‬‬ ‫;)‪myHashMap.put(name, list‬‬
‫‪26‬‬ ‫}‬
‫‪27‬‬
‫‪29‬‬ ‫{‬
‫‪30‬‬ ‫;)"‪putNumber("Jenny", "0916532365‬‬
‫‪31‬‬ ‫;)"‪putNumber("Peter", "0912534689‬‬
‫‪32‬‬ ‫;)"‪putNumber("Jenny", "09152136458‬‬
‫‪33‬‬ ‫;)"‪putNumber("Azhar", "09132536489‬‬
‫‪34‬‬
‫‪35‬‬ ‫;))"‪System.out.println(myHashMap.get("Jenny‬‬
‫‪36‬‬ ‫}‬
‫‪37‬‬ ‫}‬
‫]‪[09152136458, 0916532365‬‬
‫در کد باال از ‪ HashMap‬به شیوه ای استفاده کردیم که کلید در آن از نوع ‪ String‬و مقدار در آن ‪ TreeSet‬است لذا مقدار در آن‬
‫میتواند شامل چندین عضو باشد مهمترین قسمت کد باال متد ‪ phoneNumber‬است‪ .‬در ابتدای این متد با استفاده از یک ‪if‬‬
‫مشخص میکنیم که آیا قبال مقداری برای کلید ‪ name‬نسبت داده شد است؟ اگر خروجی متد )(‪ get‬برابر با ‪ null‬باشد یعنی‬
‫قبال به این کلید )‪ (name‬هیچ مقداری نسبت داده نشده است لذا یک لیست خالی از جنس ‪ TreeSet‬ایجاد میکنیم‪ ،‬در غیر‬
‫این صورت (کد داخل بخش ‪ ،)else‬لیست نمراتی که قبال به کلید )‪ (name‬نسبت داده شده بود را استخراج میکنیم‪ .‬بعد از‬
‫بررسی باال میتوانیم شماره جدید را با استفاده از متد )(‪ add‬به لیست اضافه کنیم (می دانیم که ‪ TreeSet‬مقدار تکراری نگه‬
‫داری نمیکند و به عالوه اعضا در آن به صورت مرتب نگه داری میشوند)‪ ،‬پس از آن با استفاده از متد )(‪ put‬لیست جدید را به‬
‫کلید )‪ (name‬نسبت میدهیم‪ .‬همانطور که در خروجی میکنید هنگامی که عبارت ”‪ “Jenny‬را به عنوان کلید ‪ myHashMap‬به‬
‫ در این مثال‬.)‫ چاپ میشود‬TreeSet ‫کار میبریم خروجی به صورت یک لیست دو عنصری چاپ میشود (در حقیقت محتوای یک‬
. ‫ آشنا میشویم‬HashMap ‫با بعضی از متدهای مهم‬
import java.util.Map;
import java.util.Set;
import java.util.HashMap;

{
{
HashMap myHashMap = new HashMap();
myHashMap.put("A", "10");
myHashMap.put("B", "20");
myHashMap.put("C", "30");
myHashMap.put("D", "40");
myHashMap.put("E", "50");
//containsKey
System.out.println(myHashMap.containsKey("A"));
System.out.println(myHashMap.containsKey("10"));
//containsValue
System.out.println(myHashMap.containsValue("A"));
System.out.println(myHashMap.containsValue("10"));
Set<Map.Entry<String, String>> allValue = myHashMap.entrySet();
for (Map.Entry<String, String> x : allValue)

{
System.out.println(x.getKey() + " : " + x.getValue());
}
}
}
true
false
false
true
D : 40
E : 50
A : 10
B : 20
C : 30
‫ سپس‬.‫ زوجهای کلید و مقداری را در آن درج کردیم‬put() ‫ جدید ایجاد کردیم و با استفاده از متد‬HashMap ‫در کد باال ابتدا یک‬
‫ وجود‬A ‫ میبینیم که کلید‬،‫ این متد وجود یا عدم وجود کلیدها را بررسی میکند‬،‫ را مورد بررسی قرار دادیم‬containsKey() ‫متد‬
‫ این متد وجود یا عدم وجود مقدار‬،‫ را مورد بررسی قرار دادیم‬containsValue() ‫ سپس از آن متد‬. ‫ وجود ندارد‬33 ‫دارد ولی کلید‬
‫ در‬33( ‫ وجود دارد‬33 ‫ در بخش کلیدها وجود داشت) ولی مقدار‬A( ‫ وجود ندارد‬A ‫ میبینیم که مقدار‬،‫(و نه کلید) را بررسی میکند‬
‫‪1۱۱‬‬ ‫مبانی زبان جاوا‬
‫بخش کلیدها وجود نداشت)‪ .‬پس از آن با استفاده از متد )(‪ entrySet‬تمام زوجهای کلید‪-‬مقدار مجموعه را در یک ‪ Set‬با‬
‫اعضایی از نوع ‪ Map.Entry‬ریختیم‪ .‬در داخل یک حلقه ‪ for‬هر آیتم از ‪ allValue‬را در متغیر ‪ x‬استخراج کرده سپس با متد‬
‫)(‪ getKey‬کلید و با متد )(‪ getValue‬مقدار متناظر با آن را به دست آورده و چاپ کردیم‪.‬‬
‫‪TreeMap‬‬
‫کالس ‪ TreeMap‬زیر کالس ‪ AbstractMap‬است و مفهوم ‪ Map‬را پیاده سازی میکند‪ ،‬قبال با مفهوم ‪ Map‬آشنا شدیم‪ ،‬کالس‬
‫‪ TreeMap‬از درخت موازنه ‪ Red-Black‬برای نگه داری زوج کلید‪-‬مقدار استفاده میکند و درخت مربوطه از روی کلیدها ساخته‬
‫میشود‪ ،‬برای خالف ‪ HashMap‬که نظم خاصی را برای کلیدها حفظ نمیکند در ‪ TreeMap‬کلیدها به صورت پیش فرض بر اساس‬
‫ترتیب الفبایی نگه داری میشوند‪ .‬عملیات درج‪ ،‬حذف و جست و جو در ‪ TreeMap‬بسیار سریع است و این ویژگی آن باعث‬
‫میشود به عنوان یک ابزار بهینه سازی از آن استفاده شود‪ .‬کالس ‪ TreeMap‬از طریق مسیر ‪ java.util.TreeMap‬قابل دستیابی‬
‫است‪ .‬برای ساخت یک شیء جدید از ‪ TreeMap‬میتوانیم از یکی از سازندههای زیر استفاده کنیم‪:‬‬
‫)(‪TreeMap‬‬
‫این سازنده یک ‪ TreeMap‬خالی ایجاد میکند ‪.‬‬
‫)‪TreeMap(Comparator cmp‬‬
‫اگر بخواهیم کلیدها بر اساس یک ترتیب اختصاصی نگه داری شوند میتوانیم برای اینکار یک ‪ Comparator‬ایجاد کنیم و آن را‬
‫به سازنده ‪ TreeMap‬ارسال کنیم ‪.‬‬
‫)‪TreeMap(Collection c‬‬
‫این سازنده یک ‪ TreeMap‬جدید ایجاد میکند و اعضای کالکشن ‪ c‬را به آن اضافه میکند‪.‬‬
‫)‪TreeMap(SortedMap sm‬‬
‫مشابه سازنده قبلی است با این تفاوت که در اینجا آیتمها با همان ترتیب ‪ sm‬در ‪ TreeMap‬نگه داری میشوند‪ .‬متدهای مهم‬
‫‪ TreeMap‬در جدول زیر آمدهاند ‪:‬‬

‫یک زوج کلید‪-‬مقدار که کلید آن بزرگتر یا مساوی با ‪ key‬باشد بر میگرداند‪.‬‬ ‫)‪ceilingEntry(Object key‬‬
‫یک کلید که بزرگتر یا مساوی با ‪ key‬باشد بر میگرداند‪.‬‬ ‫)‪ceilingKey(Object key‬‬
‫‪ Comparator‬ای که برای مقایسه کلیدها به کار میرود را بر میگرداند اگر‬ ‫)(‪comparator‬‬
‫مجموعه از ترتیب طبیعی پیروی کند و ‪ Comparator‬نداشته باشد خروجی‬
‫این متد ‪ null‬خواهد بود‪.‬‬
‫بررسی میکند که کلید مورد نظر وجود دارد یا خیره؟‬ ‫)‪containsKey(Object key‬‬
‫بررسی میکند که مقدار مورد نظر وجود دارد یا خیر؟‬ ‫)‪containsValue(Object value‬‬
‫یک لیست معکوس از کلیدهای مجموعه را بر میگرداند‪.‬‬ ‫)(‪descendingKeySet‬‬
‫معکوس مپ فعلی را بر میگرداند‪(.‬ترتیب کلیدها معکوس خواهد بود)‬ ‫)(‪NavigableMap descendingMap‬‬
‫تمامی زوجهای کلید‪-‬مقدار را به صورت یک ‪ Set‬بر میگرداند‪.‬‬ ‫)(‪entrySet‬‬
‫اولین زوج کلید‪-‬مقدار با کوچکترین کلید را بر میگرداند‪.‬‬ ‫)(‪Map.Entry firstEntry‬‬
‫کوچکترین کلید را بر میگرداند‪.‬‬ ‫)(‪firstKey‬‬
‫یک زوج کلید‪-‬مقدار بر میگرداند که در آن کلید کوچکتر یا مساوی با ‪key‬‬ ‫)‪Map.Entry floorKey(Object key‬‬
‫باشد‪.‬‬
‫کلیدی که کوچکتر یا مساوی با ‪ key‬باشد بر میگرداند‪.‬‬ ‫)‪floorKey(Object key‬‬
‫مقدار متناظر با یک کلید را بر میگرداند‪.‬‬ ‫)‪Object get(Object key‬‬
‫یک زیر مجموعه به صورت ‪ SortedMap‬بر میگرداند که در آن کلیدها از‬ ‫)‪headMap(Object toKey‬‬
‫‪ toKey‬کوچکتر هستند‪.‬‬
‫‪1۱1‬‬ ‫مبانی زبان جاوا‬
‫یک زوج کلید‪-‬مقدار بر میگرداند که در آن کلید از ‪ key‬بزرگتر باشد‪.‬‬ ‫)‪higherEntry(Object key‬‬
‫کلیدی که از ‪ key‬بزرگتر باشد را بر میگرداند‪.‬‬ ‫)‪higherkey(Object key‬‬
‫کل کلیدها را بر میگرداند‪.‬‬ ‫)(‪keySet‬‬
‫آخرین زوج کلید‪-‬مقدار با بزرگترین کلید را بر میگرداند‪.‬‬ ‫)(‪Map.Entry lastEntry‬‬
‫بزرگترین کلید را بر میگرداند‪.‬‬ ‫)(‪Object lastKey‬‬
‫یک زوج کلید‪-‬مقدار بر میگرداند که در آن کلید از ‪ key‬کوچکتر باشد‪.‬‬ ‫)‪lowerEntry(Object key‬‬
‫اولین زوج کلید‪-‬مقدار با کوچکترین کلید را حذف میکند‪.‬‬ ‫)(‪pollFirstEntry‬‬
‫آخرین زوج کلید‪-‬مقدار با بزرگترین کلید را حذف میکند‪.‬‬ ‫)(‪pollLastEntry‬‬
‫مقدار ‪ value‬را به کلید ‪ key‬نسبت میدهد‪.‬‬ ‫)‪put(Object key,Object value‬‬
‫کل اعضای ‪ mp‬را به مجموعه اضافه میکند‪.‬‬ ‫)‪void putAll(Map mp‬‬
‫زوج کلید‪-‬مقدار متناظر با کلید ‪ key‬را حذف میکند‪.‬‬ ‫)‪remove(Object key‬‬
‫تعداد کلیدها را بر میگرداند‪.‬‬ ‫)(‪size‬‬
‫یک زیر مجموعه بر میگرداند‪.‬‬ ‫‪subMap(Object fromKey,Object‬‬

‫)‪toKey‬‬
‫زیر مجموعه ای را بر میگرداند که در آن کلیدها بزرگتر یا مساوی ‪fromkey‬‬ ‫)‪SortedMap tailMap(Object fromKey‬‬
‫هستند‪.‬‬
‫مجموعه ای از مقادیر را بر میگرداند‪.‬‬ ‫)(‪values‬‬
‫به مثال زیر توجه کنید ‪:‬‬
‫;‪import java.util.TreeMap‬‬

{
{
TreeMap treemap = new TreeMap();
treemap.put(2, "A");
treemap.put(9, "B");
treemap.put(3, "A");
treemap.put(7, "D");
treemap.put(7, "X");
treemap.put(12, "C");
System.out.println(treemap);
Map.Entry first = treemap.pollFirstEntry();

System.out.println(first.getKey() + " , " + first.getValue());
System.out.println(treemap);
System.out.println(treemap.get(3));
System.out.println(treemap.keySet());
System.out.println("<=7 :" + treemap.floorKey(7));

System.out.println(">=7 :" + treemap.ceilingKey(7));
System.out.println("<7 :" + treemap.lowerKey(7));
System.out.println(">7 :" + treemap.higherKey(7));
System.out.println("<=5 :" + treemap.floorKey(5));

System.out.println(">=5 :" + treemap.ceilingKey(5));
System.out.println("<5 :" + treemap.lowerKey(5));
System.out.println(">5 :" + treemap.higherKey(5));
}
}
{2=A, 3=A, 7=X, 9=B, 12=C}

2 , A
{3=A, 7=X, 9=B, 12=C}
A
[3, 7, 9, 12]
<=7 :7
>=7 :7
<7 :3
>7 :9
<=5 :3
>=5 :7
<5 :3
>5 :7
،‫ ایجاد کرده و به صورت نامنظم دادههایی را به آن اضافه کرده و سپس آن را چاپ میکنیم‬TreeMap ‫در مثال باال ابتدا یک‬
‫ به عالوه چون کلیدها منحصر به فرد است برای‬،‫مشاهده میکنیم که مجموعه به صورت مرتب (بر اساس کلیدها) چاپ میشود‬
‫ همچنین میبینیم که مقادیر میتوانند تکراری‬.‫ (آخرین مقداری که برای این کلید درج شد) نگه داری میشود‬X ‫ فقط مقدار‬1 ‫کلید‬
‫مقدار را حذف و چاپ میکنیم و بعد از آن کل مجموعه را‬-‫ سپس اولین زوج کلید‬.)‫ است‬A ‫ برابر با‬1 ‫ و‬5 ‫باشند (مقادیر کلیدهای‬
‫‪1۱۹‬‬ ‫مبانی زبان جاوا‬
‫مجددا چاپ میکنیم‪ .‬مقدار متناظر با کلید ‪ 1‬را چاپ میکنیم‪ .‬مجموعه کل کلیدها را با متد )(‪ keySet‬به دست آورده و چاپ‬
‫میکنیم‪ .‬در ادامه یک بار با کلید ‪ 1‬که جز کلیدهای مجموعه است و یک بار با کلید ‪ 1‬که جز کلیدهای مجموعه نیست متدهای‬
‫)(‪ floorKey‬و )(‪ ceilingKey‬و )(‪ lowerKey‬و )(‪ higherKey‬را مورد بررسی قرار میدهیم‪.‬‬
‫‪TreeSet‬‬
‫کالس ‪ TreeSet‬زیر کالس ‪ AbstractSet‬است و مفهوم ‪ Set‬یعنی یک مجموعه بدون تکرار را پیاده سازی میکند‪ ،‬قبال با‬
‫مفهوم ‪ Set‬آشنا شدیم‪ ،‬کالس ‪ TreeSet‬از ساختمان داده درخت موازنه برای نگه داری اعضای مجموعه استفاده میکند‪ ،‬لذا‬
‫اعضای این مجموعه به صورت مرتب نگه داری میشوند و عملیات درج‪ ،‬حذف‪ ،‬جست و جو در زمان کوتاهی (زمان لگاریتمی)‬
‫صورت میپذیرد‪.‬‬
‫در حقیقت ‪ TreeSet‬از ‪ TreeMap‬استفاده میکند و کالس ‪ TreeMap‬با استفاده از ساختمان داده ‪ Red-Black Tree‬پیاده‬
‫سازی شده است که بسیار سریع است‪.‬‬
‫اشیای داخل ‪ TreeSet‬به صورت پیش فرض بر اساس ترتیب الفبایی مرتب هستند مگر آنکه در سازنده آن صریحا از یک‬
‫‪ Comparator‬اختصاصی استفاده کنیم‪ .‬مهمترین ویژگیهای ‪ TreeSet‬عبارتاند از‪:‬‬
‫همیشه مجموعه مورد نظر مرتب است و برای مرتب سازی نیاز به استفاده از الگوریتمهای ‪ sort‬نداریم‪.‬‬ ‫‪‬‬
‫عملیات درج‪ ،‬حذف و جست و جو همگی با سرعت بسیار باالیی اجرا میشوند‪.‬‬ ‫‪‬‬
‫به دلیل بهینه بودن ‪ TreeSet‬از آن در الگوریتمهای پیشرفته ای همچون الگوریتمهای مسیر یابی استفاده میشود‪.‬از طریق مسیر‬
‫‪ java.util.TreeSet‬میتوانیم به این کالس دسترسی داشته باشیم‪.‬برای ساخت شیء جدید از ‪ TreeSet‬میتوانیم از یکی از‬
‫سازندههای زیر استفاده کنیم‪:‬‬
‫)(‪TreeSet‬‬
‫یک ‪ TreeSet‬خالی ایجاد میکند ‪.‬‬

‫)‪TreeSet(Collection c‬‬
‫یک ‪ TreeSet‬ایجاد میکند و اعضای کالکشن ‪ c‬را به آن اضافه میکند ‪.‬‬
‫)‪TreeSet(Comparator cmp‬‬
‫از ‪ cmp‬برای مقایسه و مرتب سازی اعضا استفاده میکند ‪.‬‬
‫)‪TreeSet(SortedSet ss‬‬
‫یک ‪ TreeSet‬جدید ایجاد کرده و اعضای ‪ ss‬را به آن اضافه میکند به عالوه ترتیب اعضا را نیز به همان شکل قبلی نگه‬
‫میدارد‪.‬متدهای مهم ‪ TreeSet‬در جدول زیر آمدهاند‪:‬‬
‫یک عضو جدید به مجموعه اضافه‬ ‫)‪boolean add(Object o‬‬
‫اعضای یک کالکشن دیگر را به‬ ‫)‪boolean addAll(Collection c‬‬
‫مجموعه اضافه میکند‪.‬‬
‫عضوی از مجموعه که از شی ‪o‬‬ ‫)‪Object ceiling(Object o‬‬
‫بزرگتر یا مساوی باشد را بر‬
‫میگرداند‪ ،‬اگر چنینشی ای وجود‬
‫نداشته باشد خروجی ‪null‬‬
‫خواهد بود‪.‬‬
‫کل مجموعه را پاک میکند‪.‬‬ ‫)(‪void clear‬‬
‫‪ Comparator‬مجموعه را بر‬ ‫)(‪Comparator comparator‬‬
‫میگرداند‪ ،‬اگر از ترتیب طبیعی‬
‫استفاده شده باشد خروجی‪null‬‬
‫وجود یا عدم وجود یک شیء در‬ ‫)‪boolean contains(Object o‬‬
‫مجموعه را بررسی میکند‪.‬‬
‫یک ‪ Iterator‬معکوس در‬ ‫)(‪Iterator descendingIterator‬‬
‫اختیار ما قرار میدهد که میتوانیم‬
‫مجموعه را از انتها به ابتدا پیمایش‬
‫کنیم‪.‬‬
‫معکوس مجموعه فعلی را در اختیار‬ ‫)(‪NavigableSet descendingSet‬‬
‫ما قرار میدهد‪.‬‬
‫عضو ابتدایی ( کوچکترین عضو)‬ ‫)(‪Object first‬‬
‫مجموعه را بر میگرداند‪.‬‬
‫عضوی از مجموعه که از شی ‪o‬‬ ‫)‪Object floor(Object o‬‬
‫کوچکتر یا مساوی باشد را بر‬
‫میگرداند‪ ،‬اگر چنین موردی وجود‬
‫نداشته باشد خروجی ‪null‬‬
‫زیر مجموعه ای را بر میگرداند که‬ ‫)‪SortedSet headSet(Object to‬‬
‫اعضای آن از ‪ to‬کوچکتر باشند‪.‬‬
‫مانند متد قبلی است با این تفاوت‬ ‫)‪NavigableSet headSet(Object to,boolean include‬‬
‫که پارامتر دوم مشخص میکند که‬
‫اشیا منحصرا از ‪ to‬کوچکتر‬
‫باشند یا کوچکتر مساوی؟‬
‫شی ای از مجموعه را بر میگرداند‬ ‫)‪Object higher(Object o‬‬
‫که از ‪ o‬بزرگتر باشد‪.‬‬

‫خالی بودن مجموعه را بررسی‬ ‫)(‪boolean isEmpty‬‬
‫یک ‪ Iterator‬برای پیمایش‬ ‫)(‪Iterator iterator‬‬
‫ابتدا تا انتهای لیست در اختیار ما‬
‫قرار میدهد‪.‬‬
‫آخرین (بزرگترین) عضو مجموعه‬ ‫)(‪Object last‬‬
‫را بر میگرداند‪.‬‬
‫عضوی از مجموعه که از شی ‪O‬‬ ‫)‪Object lower(Object o‬‬
‫کوچکتر باشد را بر میگرداند‪.‬‬
‫عضو ابتدایی ( کوچکترین عضو)‬ ‫)(‪Object pollFirst‬‬
‫را از مجموعه حذف میکند‪.‬‬
‫عضو انتهایی (بزرگترین عضو) را‬ ‫)(‪Object pollLast‬‬
‫از مجموعه حذف میکند‪.‬‬
‫شی مورد نظر را از مجموعه حذف‬ ‫)‪boolean remove(Object o‬‬
‫اندازه مجموعه را بر میگرداند‪.‬‬ ‫)(‪int size‬‬
‫یک زیر مجموعه که اعضای آن از‬ ‫)‪NavigableSet subSet(Object from,boolean fi,Object to,boolean ti‬‬
‫‪from‬بزرگتر و از ‪ to‬کوچکتر‬
‫باشند بر میگرداند‪.‬پارامترهای‬
‫‪ti‬و ‪ fi‬تعیین میکنند که‬
‫اعضای مساوی با ‪ to‬و ‪from‬‬
‫نیز در زیر مجموعه قرار گیرند یا‬
‫خیر؟‬
‫یک زیر مجموعه که اعضای آن از‬ SortedSet subSet(Object from,Object to)
to ‫مساوی و از‬-‫بزرگتر‬from
.‫کوچکتر باشند بر میگرداند‬
‫یک زیر مجموعه بر میگرداند که‬ SortedSet tailSet(Object from)
‫ بزرگتر‬from ‫اعضای آن از‬
.‫باشند‬
‫یک زیر مجموعه بر میگرداند که‬ NavigableSet tailSet(Object from,boolean include)
‫ بزرگتر‬from ‫اعضای آن از‬
‫پارامتر دوم مشخص میکند‬.‫باشند‬
‫ بزرگتر باشند یا‬from ‫که اشیا از‬
‫بزرگتر مساوی؟‬
‫ ساده ایجاد میکنیم و چند متد بسیار مهم آن را‬TreeSet ‫در مثال زیر یک‬.‫ بیشتر آشنا میشویم‬TreeSet ‫در ادامه با چند مثال با‬
.‫مورد بررسی قرار میدهیم‬
import java.util.TreeSet;

{
{
TreeSet treeset = new TreeSet();
treeset.add(5);
treeset.add(1);
treeset.add(4);
treeset.add(9);
treeset.add(1);
treeset.add(6);
treeset.add(5);
System.out.println(treeset);
//first and last

System.out.println(treeset.first());
System.out.println(treeset.last());
//higher
System.out.println(">5 :" + treeset.higher(5));
System.out.println(">8 :" + treeset.higher(8));
‫‪//ceiling‬‬
‫;))‪System.out.println(">=5 :" + treeset.ceiling(5‬‬
‫;))‪System.out.println(">=8 :" + treeset.ceiling(8‬‬
‫‪//lower‬‬
‫;))‪System.out.println("<5 :" + treeset.lower(5‬‬
‫;))‪System.out.println("<8 :" + treeset.lower(8‬‬
‫‪//floor‬‬
‫;))‪System.out.println("<=5 :" + treeset.floor(5‬‬
‫;))‪System.out.println("<=8 :" + treeset.floor(8‬‬
‫}‬
‫}‬
‫]‪[1, 4, 5, 6, 9‬‬
‫‪1‬‬
‫‪9‬‬
‫‪>5 :6‬‬
‫‪>8 :9‬‬
‫‪>=5 :5‬‬
‫‪>=8 :9‬‬
‫‪<5 :4‬‬
‫‪<8 :6‬‬
‫‪<=5 :5‬‬
‫‪<=8 :6‬‬
‫در کد باال ابتدا یک ‪ TreeSet‬ایجاد میکنیم و سپس اعدادی را با استفاده از متد ‪ add‬به آن اضافه میکنیم و سپس مجموعه را‬
‫چاپ میکنیم مشاهده میکنیم که مجموعه دارای عضو تکراری نیست و به صورت مرتب نگه داری میشود‪ .‬پس از آن با استفاده‬
‫از متدهای ‪ first‬و ‪ last‬اعضای ابتدایی ( کوچکترین) و انتهایی (بزرگترین) مجموعه را چاپ میکنیم‪ .‬سپس متد ‪higher‬‬
‫را مورد بررسی قرار میدهیم‪ ،‬مشاهده میکنیم که این متد عضوی را بر میگرداند که حتما از شی مورد نظر بزرگتر باشد‪ .‬سپس‬
‫متد )(‪ ceiling‬را مورد بررسی قرار میدهیم‪ ،‬مشاهده میکنیم که این متد عضوی را بر میگرداند که بزرگتر یا مساوی با شی‬
‫مورد نظر باشد‪ .‬سپس متد )(‪ lower‬را مورد بررسی قرار میدهیم‪ ،‬مشاهده میکنیم که این متد عضوی را بر میگرداند که حتما‬
‫از شی مورد نظر کوچکتر باشد‪ .‬سپس متد )(‪ floor‬را مورد بررسی قرار میدهیم‪ ،‬مشاهده میکنیم که این متد عضوی را بر‬
‫میگرداند که کوچکتر یا مساوی با شی مورد نظر باشد ‪.‬‬
‫;‪import java.util.TreeSet‬‬

‫{‬
‫{‬
‫;)(‪TreeSet treeset = new TreeSet‬‬
‫;)‪treeset.add(5‬‬
‫;)‪System.out.println(treeset‬‬
‫;))‪System.out.println(treeset.subSet(4, 8‬‬
‫;))(‪System.out.println(treeset.pollFirst‬‬
‫;))(‪System.out.println(treeset.pollLast‬‬
‫;)‪System.out.println(treeset‬‬
‫;))(‪System.out.println(treeset.descendingSet‬‬
‫}‬
‫}‬
‫‪[1,‬‬ ‫]‪4, 5, 6, 8, 9‬‬

‫‪[4,‬‬ ‫]‪5, 6‬‬
‫‪1‬‬
‫‪9‬‬
‫‪[4,‬‬ ‫]‪5, 6, 8‬‬
‫‪[8,‬‬ ‫]‪6, 5, 4‬‬
‫در کد باال مشابه کد قبلی یک ‪ TreeSet‬ایجاد میکنیم و سپس آن را چاپ میکنیم‪ ،‬سپس متد ‪ subSet‬را با پارامترهای ‪ 3‬و ‪0‬‬
‫فراخوانی میکنیم مشاهده میکنیم که اعضای زیر مجموعه مورد نظر بزرگتر مساوی ‪ 3‬و کوچکتر از ‪ 0‬هستند ‪.‬سپس عنصر‬
‫ابتدایی را حذف و چاپ میکنیم‪ .‬سپس عنصر انتهایی را حذف و چاپ میکنیم‪ .‬مجددا کل مجموعه را چاپ میکنیم‪ .‬سپس با‬
‫استفاده از متد )(‪ descendingSet‬عکس مجموعه را به دست آورده و آن را چاپ میکنیم‪.‬‬
‫‪Stack‬‬
‫‪ Stack‬زیر کالس ‪ Vector‬است و ساختمان داده ای با همین نام را پیاده سازی میکند‪ ،‬در حقیقت ‪ Stack‬یک صف ‪LIFO‬‬
‫محسوب میشود‪ ،‬به ساختمان داده ‪ Stack‬پشته نیز گفته میشود‪ .‬عبارت ‪ LIFO‬مخفف ‪ Last In First Out‬میباشد و‬
‫صف ‪ LIFO‬صفی است که عضوی که آخر وارد میشود اول خارج میشود‪ Stack.‬کاربردهای زیادی در برنامه نویسی دارد که از‬
‫جمله آنها میتوان به موارد زیر اشاره کرد‪:‬‬
‫تبدیل ‪ infix‬به‪postfix‬‬ ‫‪‬‬
‫تبدیل الگوریتمهای بازگشتی به غیر بازگشتی‬ ‫‪‬‬

‫فرم غیر بازگشتی جست و جوی اول عمق)‪(Depth First Search‬‬ ‫‪‬‬
‫بعضی از الگوریتمهای زمان بندی‬ ‫‪‬‬
‫یکی از موارد روزمره ای که با آن رو به رو میشویم حافظه مرورگرها در مورد ‪ url‬هاست‪ ،‬هنگامی که دکمه بازگشت را میزنیم‬
‫همیشه به آخرین مورد قبلی باز میگردیم‪.‬کالس ‪ Stack‬از طریق مسیر ‪ java.util.Stack‬قابل دستیابی است‪.‬برای ساخت‬
‫یک شیء جدید از کالس ‪ Stack‬باید از سازنده زیر استفاده کنیم‪:‬‬
‫)(‪Stack‬‬
‫متدهای مهم ‪ Stack‬در جدول زیر آمدهاند ولی مهمترین آنها ‪ push ،peek‬و ‪ pop‬هستند‪.‬‬
‫یک عنصر به انتهای مجموعه اضافه میکند‪.‬‬ ‫)‪add(Object o‬‬
‫یک عنصر در اندیس مورد نظر درج میکند‪.‬‬ ‫)‪add(int index,Object o‬‬
‫اعضای یک کالکشن دیگر را به انتهای مجموعه اضافه میکند‪.‬‬ ‫)‪addAll(Collection c‬‬
‫یک عنصر به انتهای مجموعه اضافه میکند‪.‬‬ ‫)‪AddElement(Object o‬‬
‫ظرفیت مجموعه را بر میگرداند‪.‬‬ ‫)(‪capacity‬‬
‫وجود یا عدم وجود یک عنصر را بررسی میکند‪.‬‬ ‫)‪contains(Object o‬‬
‫عنصر موجود در اندیس ‪ index‬را بر میگرداند‪.‬‬ ‫)‪elementAt(int index‬‬
‫یک ‪ Enumeration‬از اعضای مجموعه بر میگرداند‪.‬‬ ‫)(‪elements‬‬
‫خالی بودن یا نبودن مجموعه را بررسی میکند‪.‬‬ ‫)(‪boolean empty‬‬
‫اولین عنصر مجموعه را بر میگرداند‪.‬‬ ‫)(‪firstElement‬‬

‫عنصر موجود در اندیس مورد نظر را بر میگرداند‪.‬‬ ‫)‪get(int index‬‬
‫اندیس یک عنصر را پیدا میکند‪.‬‬ ‫)‪int indexOf(Object o‬‬
‫خالی بودن مجموعه را بررسی میکند‪.‬‬ ‫)(‪boolean isEmpty‬‬
‫یک ‪ Iterator‬برای پیمایش مجموعه بر میگرداند‪.‬‬ ‫)(‪iterator‬‬
‫آخرین عضو مجموعه را بر میگرداند‪.‬‬ ‫)(‪Object lastElement‬‬
‫عنصر باالی پشته (آخرین عنصر) را بر میگرداند ولی آن را از پشته حذف نمیکند‪.‬‬ ‫)(‪peek‬‬
‫عنصر باالی پشته را بر گردانده و آن را از پشته حذف میکند‪.‬‬ ‫)(‪pop‬‬
‫عنصر جدید را به باالی پشته اضافه میکند‪.‬‬ ‫)‪Object push(Object o‬‬
‫عنصر موجود در اندیس ‪ index‬را حذف میکند‪.‬‬ ‫)‪remove(int index‬‬
‫اندیس یک شیء را بر میگرداند (در این حالت شروع اندیس از ‪ 3‬تعبیر میشود)‬ ‫)‪search(Object o‬‬
‫عنصر موجود در اندیس ‪ index‬را به شی ‪ o‬تغییر میدهد‪.‬‬ ‫‪Object set(int index,Object‬‬

‫)‪o‬‬
‫کل مجموعه را به صورت آرایه بر میگرداند‪.‬‬ ‫)(‪toArray‬‬
‫به مثال زیر توجه کنید ‪:‬‬
‫;‪import java.util.Stack‬‬

‫{‬
‫{‬
‫;)(‪Stack stack = new Stack‬‬
‫;)"‪stack.push("URL_1‬‬
‫))(‪while (!stack.empty‬‬
‫{‬
‫;))(‪System.out.println(stack.pop‬‬
‫}‬
‫}‬
‫}‬
‫‪URL_4‬‬
‫‪URL_3‬‬
‫‪URL_2‬‬
‫‪URL_1‬‬
‫مثال باال عملکرد یک مرورگر را به صورت خیلی ساده شبیه سازی میکند‪ ،‬ابتدا ‪ URL_1‬و سپس ‪ URL_2‬و … را مشاهده میکنیم‪.‬‬
‫عمل مشاهده را با عمل ‪ push‬شبیه سازی میکنیم‪ .‬سپس عمل فشردن دکمه بازگشت را شبیه سازی میکنیم‪ ،‬هر بار که دکمه‬
‫بازگشت زده میشود مرورگر باید آخر ین صفحه مشاهده شده قبلی را نمایش دهد‪ ،‬به عنوان مثال هنگامی که در حال مشاهده‬
‫‪ URL_4‬هستیم اگر کاربر دکمه بازگشت را فشار دهد مرورگر باید ‪ URL_3‬را نمایش دهد‪ ،‬اگر کاربر در حال مشاهده ‪ URL_3‬باشد‬
‫با زدن دکمه بازگشت مروگر باید ‪ URL_2‬را نمایش دهد‪.‬این عمل تا زمانی قابل انجام است که آدرسی برای نمایش وجود داشته‬
‫باشد‪ ،‬به عبارتی پشته خالی نباشد (‪ empty‬نباشد)در کد باال هر بار که متد )(‪ pop‬فراخوانی میشود عنصر باالی پشته حذف‬
‫میشود ‪ .‬البته پیاده سازی عملکرد دکمه بازگشت در مرورگر کمی پیچیده تر است و مثال باال یک نمونه بسیار بسیار ساده از این‬
‫عمل میباشد‪.‬‬
‫‪PriorityQueue‬‬
‫کالس ‪ PriorityQueue‬یک صف اولویت را با استفاده از ساختمان داده ‪ Min-Heap‬پیاده سازی میکند‪ ،‬لذا در کاربردهایی که‬
‫نیاز داریم به صورت پیوسته به عنصر کمینه دستیابی داشته باشیم مفید واقع میشود‪ ،‬برای نمونه میتوان به پیاده سازی الگوریتم‬
‫مرتب سازی ‪ Heap Sort‬اشاره کرد‪ .‬به صورت پیش فرض این کالس از ترتیب طبیعی (الفبایی) پیروی میکند مگر آنکه در سازنده‬
‫آن از یک ‪ Comparator‬اختصاصی برای تعریف نوع خاصی از ترتیب استفاده کنیم‪ .‬به دلیل استفاده از ساختار ‪ Min-Heap‬بیشتر‬
‫عملیات این کالس مانند ‪ poll ،offer‬و … در زمانی لگاریتمی یا حتی ثابت انجام میشوند‪ ،‬به عبارت دیگر این عملیات بسیار‬
‫سریع انجام میشوند‪ .‬این کالس از طریق مسیر ‪ java.util.PriorityQueue‬قابل دستیابی است‪.‬‬
‫‪ PriorityQueue‬میتواند عضو تکراری داشته باشد‪.‬‬ ‫‪‬‬

‫‪ PriorityQueue‬نمیتواند عضو ‪ null‬داشته باشد‪.‬‬ ‫‪‬‬
‫برای ساخت شیء جدید از این کالس میتوانیم از یکی از سازندههای زیر استفاده کنیم‪:‬‬
‫)(‪PriorityQueue‬‬
‫یک صف اولویت خالی ایجاد میکند ‪.‬‬
‫)‪PriorityQueue(Collection c‬‬
‫یک صف اولویت جدید ایجاد میکند و اعضای کالکشن ‪ c‬را به آن اضافه میکند ‪.‬‬
‫)‪PriorityQueue(int capacity‬‬
‫یک صف اولویت جدید ایجاد میکند‪ ،‬چون کالس ‪ PriorityQueue‬به صورت ‪ Min Heap‬پیاده سازی میشود برای ابتدای کار‬
‫یک آرایه برای آن در نظر گرفته میشود که پارامتر ‪ capacity‬اندازه این آرایه را مشخص میکند البته در عین کار ممکن است‬
‫اندازه آرایه افزایش یابد‪.‬‬
‫)‪PriorityQueue(int capacity,Comparator cmp‬‬
‫مشابه سازنده قبلی است با این تفاوت که در اینجا برای مقایسه اشیای داخل صف اولویت از یک ‪ Comparator‬اختصاصی‬
‫استفاده میکنیم‪.‬‬
‫)‪PriorityQueue(PriorityQueue other‬‬
‫یک صف اولویت جدید ایجاد میکند و اعضای یک صف اولویت دیگر را به آن اضافه میکند‪.‬‬
‫)‪PriorityQueue(SortedSet ss‬‬
‫یک صف اولویت جدید ایجاد میکند و اعضای یک مجموعه مرتب را به آن اضافه میکند‪ .‬متدهای مهم کالس ‪PriorityQueue‬‬
‫در جدول زیر آمدهاند‪:‬‬
‫یک عنصر جدید به صف اولویت اضافه میکند‪ ،‬این متد بسیار سریع است و در زمانی لگاریتمی انجام‬ ‫)‪add(Object o‬‬
‫اگر از یک ‪ Comparator‬اختصاصی استفاده کرده باشیم آن را بر میگرداند اما اگر از ترتیب طبیعی‬ ‫)(‪comparator‬‬
‫استفاده کرده باشیم خروجی این متد ‪ null‬خواهد بود‪.‬‬
‫بررسی میکند که یک شیء مورد نظر در این مجموعه قرار دارد یا خیر؟ این متد در زمانی خطی انجام‬ ‫‪contains(Object‬‬
‫)‪o‬‬
‫میشود و چندان بهینه نیست‪.‬‬
‫مشخص میکند که صف اولویت خالی است یا خیر‪.‬‬ ‫)(‪isEmpty‬‬
‫یک ‪ Iterator‬از روی مجموعه بر میگرداند که دارای نظ م خاصی نیست و فقط اعضای مجموعه را‬ ‫)(‪iterator‬‬
‫پیمایش میکند‪.‬‬
‫مانند متد ‪ add‬عمل میکند‪.‬‬ ‫)‪offer(Object o‬‬
‫عنصر سر ( کوچکترین عضو) صف را بر میگرداند ولی آن را حذف نمیکند‪ ،‬اگر صف خالی باشد خروجی‬ ‫)(‪peek‬‬
‫این متد ‪ null‬خ واهد بود‪ ،‬این متد در زمان ثابت اجرا میشود و فوق العاده سریع است‪.‬‬
‫عنصر سر ( کوچکترین عضو) صف را حذف میکند و آن را بر میگرداند‪ ،‬اگر صف خالی باشد خروجی این‬ ‫)(‪poll‬‬
‫متد ‪ null‬خواهد بود‪ ،‬این متد در زمان لگاریتمی انجام میشود و سریع است‪.‬‬
‫یک شیء خاص را در زمان خطی از مجموعه حذف میکند‪ ،‬این متد چندان بهینه نیست‪.‬‬ ‫‪remove(Object‬‬
‫)‪o‬‬
‫مانند متد ‪ poll‬عمل میکند‪.‬‬ ‫)(‪remove‬‬
‫اندازه مجموعه را بر میگرداند‪.‬‬ ‫)(‪size‬‬
‫اعضای مجموعه را به صورت یک آرایه بر میگرداند‪.‬‬ ‫)(‪toArray‬‬
‫ابتدا با یک مثال ساده با ‪ PriorityQueue‬آشنا میشویم ‪.‬‬
‫;‪import java.util.PriorityQueue‬‬

‫{‬
‫{‬
‫;)(‪PriorityQueue priorityqueue = new PriorityQueue‬‬
‫;)‪priorityqueue.add(1‬‬
‫;)‪System.out.println(priorityqueue‬‬
‫;))(‪System.out.println(priorityqueue.peek‬‬
‫;))(‪System.out.println(priorityqueue.poll‬‬
‫}‬
‫}‬
‫]‪[1, 5, 2, 10, 9‬‬

‫‪1‬‬
‫]‪[1, 5, 2, 10, 9‬‬
‫‪1‬‬
‫]‪[2, 5, 9, 10‬‬
‫در کد باال ابتدا یک ‪ PriorityQueue‬ایجاد میکنیم و سپس اعضایی را به آن اضافه میکنیم‪ ،‬سپس آن را چاپ میکنیم‪ ،‬مشاهده‬
‫میکنیم که اعضای داخل آن دارای نظم قابل تشخیصی نیستند فقط عنصر ابتدای لیست کمینه است‪ .‬سپس با استفاده از متد‬
‫)(‪ peek‬کوچکترین عنصر را به دست آورده و چاپ میکنیم و سپس لیست را چاپ میکنیم‪ .‬مشاهده میکنیم که استفاده از متد‬
‫)(‪ peek‬تغییری در صف اولویت ایجاد نمیکند‪ .‬سپس با استفاده از متد )(‪ poll‬کوچکترین عنصر را به دست آورده‪ ،‬آن را چاپ‬
‫میکنیم و بعد از آن کل لیست را چاپ میکنیم‪ .‬مشاهده میکنیم که متد )(‪ poll‬عنصر کمینه را از لیست حذف کرده است و در‬
‫لیست جدید مجددا کوچکترین عنصر در ابتدای لیست قرار دارد‪ .‬در ‪ PriorityQueue‬عنصر کمینه همیشه در ابتدای لیست قرار‬
‫دارد ‪.‬‬
‫مرتب سازی ‪Heap Sort‬‬
‫در این مثال به سادگی الگوریتم مرتب سازی ‪ Heap Sort‬را با استفاده از ‪ PriorityQueue‬پیاده سازی میکنیم ‪.‬‬
import java.util.PriorityQueue;

{
{
PriorityQueue priorityqueue = new PriorityQueue();
LinkedList result = new LinkedList();
priorityqueue.add(1);
while (!priorityqueue.isEmpty())
{
result.add(priorityqueue.poll());
}
System.out.println(result);
}
}
[1, 2, 5, 9, 10, 18]
PriorityQueue ‫ سپس اعضای نامرتبی را به‬،‫ خالی ایجاد میکنیم‬LinkedList ‫ و یک‬PriorityQueue ‫در کد باال ابتدا یک‬
‫ خالی نشده است عنصر کمینه آن را حذف‬PriorityQueue ‫ تا زمانی که‬while ‫ در ادامه در داخل یک حلقه‬. ‫اضافه میکنیم‬
‫ اضافه میکنیم لذا در هر مرحله کوچکترین عضو از صف اولویت خارج شده و به لیست پیوندی اضافه‬LinkedList ‫میکنیم و به‬
.‫ الگوریتم مرتب سازی فوق بسیار سریع است‬.‫میشود و در نتیجه لیست پیوندی در نهایت مرتب خواهد بود‬
‫ترتیب معکوس‬
‫اگر بخواهیم صف اولویت به صورت معکوس نگه داری شود یعنی عنصر ابتدای لیست بزرگترین آیتم آن باشد (به عبارتی به‬
‫ اختصاصی‬Comparator ‫ به عنوان‬Collections.reverseOrder() ‫ پیاده سازی شود) میتوانیم از‬Max Heap ‫صورت‬
‫ مثال قبل را با این نکته بازنویسی میکنیم‬.‫ عنصر بیشینه را بر میگرداند‬poll() ‫ و‬peek() ‫ در این صورت متدهای‬.‫استفاده کنیم‬
import java.util.Collections;
import java.util.PriorityQueue;

{
{
PriorityQueue priorityqueue = new PriorityQueue(Collections.reverseOrder());
LinkedList result = new LinkedList();
while (!priorityqueue.isEmpty())
{
result.add(priorityqueue.poll());
}
}
}
[18, 10, 9, 5, 2, 1]
Hashtable
‫ ارث بری‬Serializable ‫ و‬Clonable ‫ و‬Map ‫ های‬interface ‫ است و از‬Dictionary ‫ زیر کالس‬Hashtable ‫کالس‬
‫ همانطور که از نام آن پیداست این کالس‬،‫مقدار به کار میرود‬-‫ این کالس نیز برای نگه داری زوج کلید‬HashMap ‫ همانند‬.‫میکند‬
‫ برخی از تفاوتهای‬.‫مقدار استفاده میکند‬-‫ از الگوریتم درهم سازی برای نگه داری زوجهای کلید‬HashMap ‫نیز همچون کالس‬
:‫ عبارتاند از‬HashMap ‫ و‬Hashtable
.‫ چنین محدودیتی وجود ندارد‬HashMap ‫ نیستیم ولی در‬null ‫ مجاز به استفاده از کلید یا مقدار‬Hashtable ‫در‬ 
.‫ نیست‬HashMap ‫ است ولی‬Thread-safe ‫( و در نتیجه‬synchronized) ‫ کالسی سنکرون شده‬Hashtable 
.‫ سریع تر است‬HashMap ‫در برنامهها معمولی که چند ریسمانی نیستند‬ 

‫در برنامههای پیشرفته چند ریسمانی بهتر است از ‪ ConcurrentHashMap‬به جای ‪ Hashtable‬استفاده شود‪ .‬کالس ‪Hashtable‬‬
‫از طریق مسیر ‪ java.util.Hashtable‬قابل دستیابی است‪ .‬برای ساخت یک شیء جدید از این کالس میتوانیم از یکی از‬
‫سازندههای زیر استفاده کنیم‪:‬‬
‫)(‪Hashtable‬‬
‫یک ‪ Hashtable‬خالی جدید با ظرفیت اولیه پیش فرض (‪ 33‬درایه) و ‪ load factor=0.75‬ایجاد میکند‪.‬‬
‫)‪Hashtable(int capacity‬‬
‫مشابه سازنده قبلی است با این تفاوت که در اینجا خودمان اندازه جدول اولیه را تعریف میکنیم‪.‬‬
‫)‪Hashtable(int capacity,float loadFactor‬‬
‫یک ‪ Hashtable‬خالی ایجاد میکند که اندازه جدول و ‪ loadFactor‬آن را خودمان تعیین میکنیم (پارامتر ‪loadFactor‬‬
‫مشخص میکند که چه زمانی اندازه ‪ Hashtable‬باید تغییر کند)‪.‬‬
‫)‪Hashtable(Map mp‬‬
‫یک ‪ Hashtable‬جدید ایجاد میکند و اعضای ‪ mp‬را به آن اضافه میکند‪ .‬متدهای مهم این کالس در جدول زیر آمدهاند‪:‬‬
‫وجود یک مقدار را در مجموعه بررسی میکند‪.‬‬ ‫)‪contains(Object value‬‬
‫وجود یک کلید را در مجموعه بررسی میکند‪.‬‬ ‫)‪containsKey(Object key‬‬
‫وجود یک مقدار را بررسی میکند‪.‬‬ ‫)‪containsValue(Object value‬‬
‫یک ‪ Enumeration‬از مقدارها بر میگرداند‪.‬‬ ‫)(‪elements‬‬
‫یک ‪ Set‬از زوجهای کلید‪-‬مقدار بر میگرداند‪.‬‬ ‫)(‪Set entrySet‬‬
‫تساوی این مجموعه را با مجموعه دیگری بررسی میکند‪.‬‬ ‫)‪equals(Object o‬‬

.‫مقدار متناظر با یک کلید را در اختیار ما قرار میدهد‬ get(Object key)
.‫خالی بودن مجموعه را بررسی میکند‬ boolean isEmpty()
.‫ از کلیدها بر میگرداند‬Enumeration ‫یک‬ keys()
.‫ از کلیدها بر میگرداند‬Set ‫یک‬ keySet()
.‫ نسبت میدهد‬key ‫ را به کلید‬value ‫مقدار‬ put(Object key,Object value)
.‫ دیگر را به مجموعه اضافه میکند‬Map ‫اعضای یک‬ putAll(Map mp)
.‫( و مقدار متناظر با آن را از مجموعه پاک میکند‬key) ‫کلید مورد نظر‬ remove(Object key)
.‫تعداد کلیدها را بر میگرداند‬ size()
.‫کل مجموعه را به صورت یک رشته متنی بر میگرداند‬ toString()
.‫مقدارها را به صورت یک کالکشن بر میگرداند‬ Collection values()
: ‫به مثال زیر توجه کنید‬
import java.util.Hashtable;

{
{
Hashtable hashtable = new Hashtable();
hashtable.put(1, "one");
hashtable.put(2, "two");
hashtable.put(3, "three");
System.out.println(hashtable);
System.out.println(hashtable.get(2));
System.out.println(hashtable.keySet());
System.out.println(hashtable.values());
}
}
{3 = three, 2 = two, 1 = one}

two
[3, 2, 1]
[three, two, one]
‫سپس کل‬.‫ مقداری اطالعات به آن اضافه میکنیم‬put() ‫ جدید ایجاد میکنیم و با استفاده از متد‬Hashtable ‫در کد باال ابتدا یک‬
‫ مجموعه کلیدها و با‬keySet() ‫ را چاپ کرده و سپس با استفاده از متد‬5 ‫ در ادامه مقدار متناظر با کلید‬.‫مجموعه را چاپ میکنیم‬
.‫ مجموعه مقادیر را چاپ میکنیم‬values() ‫استفاده از متد‬
Enumeration ‫پیمایش با‬
‫ مربوط‬Enumeration ‫ برای به دست آوردن‬keys() ‫ را ترجیح میدهید میتوانید از متد‬Enumeration ‫اگر برای پیمایش اعضا‬
‫ کد زیر کلیدها و مقدارها را‬.‫ مربوط به مقادیر استفاده کنید‬Enumeration ‫ برای به دست آوردن‬elements() ‫به کلیدها و از متد‬
. ‫ پیمایش میکند‬Enumeration ‫با استفاده از‬
import java.util.Hashtable;
import java.util.Enumeration;

{
{
Hashtable hashtable = new Hashtable();
hashtable.put(1, "one");
hashtable.put(2, "two");
hashtable.put(3, "three");
for (Enumeration key = hashtable.keys(); key.hasMoreElements();)

{
System.out.print(key.nextElement() + " ");
}
System.out.println();
for (Enumeration value = hashtable.elements(); value.hasMoreElements();)

{
System.out.print(value.nextElement() + " ");
}
}
}
3 2 1
three two one
‫در داخل حلقه ‪ for‬ابتدا یک ‪ Enumeration‬به دست میآوریم‪ ،‬سپس با متد )(‪ hasMoreElements‬بررسی میکنیم که عنصر‬
‫بعدی ای وجود دارد یا خیر؟ در صورت که عنصر دیگری وجود داشته باشد عنصر بعدی را با متد )(‪ nextElement‬به دست آورده‬
‫و آن را چاپ میکنیم‪.‬‬
‫‪BitSet‬‬
‫کالس ‪ BitSet‬کالسی است که آرایه ای از بیتها را شبیه سازی میکند و میتوان از آن در الگوریتمهای مختلفی مانند غربال‬
‫اراتستن‪ ،‬بزرگترین زیر مجموعه مشترک و … استفاده کرد‪ ،‬به عالوه این کالس عملگرهای بیتی همچون ‪ OR ،AND‬و غیره را نیز‬
‫در اختیار ما قرار میدهد‪.‬‬
‫مهمترین ویژگی ‪ BitSet‬این است که مصرف حافظه آن بهینه سازی شده است و برای کاربردهایی که در آن به تعداد زیادی عنصر‬
‫صفر و یک نیاز داریم مناسبت است ‪.‬‬
‫به صورت پیشفرض تمام خانههای ‪ BitSet‬صفر هستند‪ .‬این کالس از طریق مسیر ‪ java.util.BitSet‬قابل دستیابی است‪.‬‬
‫برای استفاده از این کالس میتوانیم از یکی از سازندههای زیر استفاده کنیم‪.‬‬
‫)(‪BitSet‬‬
‫این کالس یک ‪ BitSet‬خالی ایجاد میکند و اندازه آن در طی زمان بر حسب نیاز افزایش مییابد‪.‬‬
‫)‪BitSet(int nbits‬‬
‫این کالس یک ‪ BitSet‬با تعداد بیتهای مورد نیاز ما ایجاد میکند که البته در طول زمان ممکن است اندازه آن نیز افزایش یابد‪.‬‬
‫متدهای مهم این کالس در جدول زیر آمدهاند‪:‬‬
‫بیتهای ‪ BitSet‬فعلی را با بیتهای ‪ BitSet‬دیگری ‪ AND‬میکند‪.‬‬ ‫)‪and(BitSet other‬‬

‫ابتدا بیتهای ‪ BitSet‬دیگر را معکوس کرده و سپس با ‪ BitSet‬فعلی ‪AND‬‬ ‫)‪andNot(BitSet other‬‬
‫میکند‪( .‬یعنی )‪)AND(NOT B‬‬
‫تعداد بیتهایی که یک هستند را بر میگرداند‪.‬‬ ‫)(‪cardinality‬‬
‫کل بیتها را صفر میکند‪.‬‬ ‫)(‪clear‬‬
‫یک بیت خاص را صفر میکند‪.‬‬ ‫)‪clear(int bitIndex‬‬
‫تمام بیتهای داخل یک باز خاص (از اندیس ‪ from‬تا اندیس ‪ )to‬را صفر‬ ‫)‪clear(int from,int to‬‬
‫برابری ‪ BitSet‬با شی دیگری را بررسی میکند‪.‬‬ ‫)‪equals(Object o‬‬
‫بیت مشخص شده در اندیس ‪ bitIndex‬را معکوس میکند‪.‬‬ ‫)‪flip(int bitIndex‬‬
‫بیتهای یک باز مشخص را معکوس میکند‪.‬‬ ‫)‪flip(int from,int to‬‬
‫مشخص میکند که بیت یک اندیس خاص صفر )‪ (false‬است یا یک‬ ‫)‪get(int index‬‬
‫)‪(true‬‬
‫یک زیر مجموعه از ‪ BitSet‬فعلی بر میگرداند‪.‬‬ ‫)‪BitSet(int from,int to‬‬
‫اگر ‪ BitSet‬فعلی با ‪ BitSet‬دیگر حداقل یک بیت ‪ (true) 3‬مشترک داشته‬ ‫)‪intersetcts(BitSet other‬‬
‫باشد‪ true‬بر میگرداند‪.‬‬
‫اگر ‪ BitSet‬هیچ بیت یکی نداشته باشد ‪ true‬بر میگرداند‪.‬‬ ‫)(‪isEmpty‬‬
‫اندیس سمت راستترین یک موجود در ‪ BitSet‬را بر میگرداند‪.‬‬ ‫)(‪length‬‬
‫اندیس اولین بیت صفر بعد از اندیس ‪ from‬را بر میگرداند‪.‬‬ ‫)‪nexClearBit(int from‬‬
‫اندیس اولین بیت یک بعد از اندیس ‪ from‬را بر میگرداند‪.‬‬ ‫)‪nextSetBit(int from‬‬
‫‪ BitSet‬فعلی را با ‪ BitSet‬دیگر ‪ OR‬میکند‪.‬‬ ‫)‪or(BitSet other‬‬

‫اندیس اولین بیت صفر قبل از اندیس ‪ from‬را بر میگرداند‪.‬‬ ‫)‪previousClearBit(int from‬‬
‫اندیس اولین بیت یک قبل از اندیس ‪ from‬را بر میگرداند‪.‬‬ ‫)‪previousSetBit(int from‬‬
‫بیت مشخص در اندیس ‪ index‬را یک )‪ (true‬میکند‪.‬‬ ‫)‪set(int index‬‬
‫بیتهای بازه ‪ from‬تا ‪ to‬را یک )‪ (true‬میکند‪.‬‬ ‫)‪set(int from,int to‬‬
‫بیت موجود در اندیس ‪ index‬را بر اساس مقدار ‪ value‬مقداری دهی‬ ‫)‪set(int index,boolean value‬‬
‫میکند(‪ true‬برابر یک و ‪ false‬معادل صفر)‪.‬‬
‫تمام بیتهای یک بازه مشخص را به مقدار ‪ value‬تغییر میدهد‪.‬‬ ‫‪set(int from,int to,boolean‬‬
‫)‪value‬‬
‫تعداد کل بیتهای ‪ BitSet‬را نمایش میدهد‪.‬‬ ‫)(‪size‬‬
‫معادل ‪ BitSet‬را به صورت آرایه ای از بایتها بر میگرداند‪.‬‬ ‫)(‪toByteArray‬‬
‫معادل ‪ BitSet‬را به صورت آرایه ای از ‪ Long‬ها بر میگرداند‪.‬‬ ‫)(‪toLongArray‬‬
‫‪ BitSet‬فعلی را با ‪ BitSet‬دیگری ‪ xor‬میکند‪.‬‬ ‫)‪xor(BitSet other‬‬
‫تبدیل ‪ String‬به ‪BitSet‬‬
‫متاسفانه کالس ‪ BitSet‬ابزاری برای تبدیل یک رشته صفر و یک به ‪ BitSet‬را ندارد و خودمان باید کد الزم برای این کار را به‬
‫صورت زیر بنویسیم ‪:‬‬
‫)‪static void fromString(BitSet bs, String str‬‬

‫{‬
‫)‪for (int i = 0; i < str.length(); i++‬‬
‫{‬
‫)'‪if (str.charAt(i) == '1‬‬
‫;)‪bs.set(i, true‬‬
‫}‬
‫}‬
‫در کد باال در داخل یک حلقه ‪ for‬به ازای هر کاراکتری از رشته ‪ str‬که ‪ 3‬باشد اندیس متناظر با آن در ‪ BitSet‬را یک )‪(true‬‬
‫میکنیم‪.‬‬
‫نمایش دودویی ‪BitSet‬‬
‫متاسفانه کالس ‪ BitSet‬ابزار مناسبی برای نمایش دودویی ‪ BitSet‬نیز در اختیار ما قرار نمیدهد و مجددا خودمان باید کد الزم‬
‫را بنویسیم‪ ،‬کد زیر با داشتن تعداد بیتها )‪ (nbits‬یک ‪ String‬از روی بیتهای ‪ BitSet‬میسازد و بر میگرداند ‪.‬‬
‫)‪static String toString(BitSet bs, int nbits‬‬

‫{‬
‫;"" = ‪String result‬‬
‫)‪for (int i = 0; i < nbits; i++‬‬
‫{‬
‫))‪if (bs.get(i‬‬
‫{‬
‫;"‪result += "1‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;"‪result += "0‬‬
‫}‬
‫}‬
‫;‪return result‬‬
‫}‬
‫منطق کد باال بسیار ساده است‪ ،‬اگر بیت اندیس ‪ i‬در ‪ BitSet‬یک باشد یک ‪ 3‬به انتهای رشته ‪ result‬اضافه میکنیم در غیر‬
‫این صورت یک ‪ 3‬به انتهای رشته اضافه میکنیم‪ .‬با کمک دو متد باال آمادهایم تا مثالی از کالس ‪ BitSet‬مشاهده کنیم ‪.‬‬
‫;‪import java.util.BitSet‬‬

‫{‬
‫)‪static void fromString(BitSet bs, String str‬‬
‫{‬
‫)‪for (int i = 0; i < str.length(); i++‬‬
‫{‬
‫)'‪if (str.charAt(i) == '1‬‬
‫;)‪bs.set(i, true‬‬
‫}‬
‫}‬
‫)‪static String toString(BitSet bs, int nbits‬‬
‫{‬
‫;"" = ‪String result‬‬
‫)‪for (int i = 0; i < nbits; i++‬‬
‫{‬
‫))‪if (bs.get(i‬‬
11۵ ‫مبانی زبان جاوا‬
{
result += "1";
}
else
{
result += "0";
}
}
return result;
}
{
int nbits = 6;
BitSet A = new BitSet(nbits);
BitSet B = new BitSet(nbits);
fromString(A, "110011");
fromString(B, "100111");
System.out.println("A :\t" + toString(A, nbits));

System.out.println("B :\t" + toString(B, nbits));
B.flip(0, 6); //B=Not(B)

System.out.println("B :\t" + toString(B, nbits));
A.or(B); //A=A OR B
A.and(B); //A=A AND B

A.set(0); //A[0]=1
A.set(4, 6, true); //A[4]=1,A[5]=1

}
}
A : 110011
B : 100111
B : 011000
A : 111011
A : 011000
A : 111000
A : 111011
‫ آن دو را مقدار دهی‬fromString() ‫ ایجاد کردیم و سپس با متدهای کمکی‬B ‫ و‬A ‫ خالی به نام‬BitSet ‫در کد باال ابتدا دو‬
flip() ‫ را با کمک متد‬B 1 ‫ تا‬3 ‫ سپس بیتهای اندیس‬.‫ چاپ کردیم‬toString() ‫کرده و برای اطمینان آنها را کمک متد کمی‬
‫ سایر خطوط نیز مشابه هستند و همراه آنها در کد‬.‫ کردیم‬OR ‫ را با بیتست دوم‬A ‫ بیتست‬or ‫معکوس و بعد با کمک متد‬
.‫توضیحات کافی ارائه شده است‬

‫‪ArrayDeque‬‬
‫کالس ‪ ArrayDeque‬زیر کالس ‪ AbstractCollection‬است و مفهوم صف دو طرفه را با استفاده از ساختمان داده آرایه حلقوی‬
‫(‪ )circular array‬پیاده سازی کرده است و کالسی فوق العاده سریع و بهینه است این کالس برای پیاده سازی صف دو طرفه به‬
‫جای لیست پیوندی از آرایه استفاده میکند و دارای مزایای زیر است‪:‬‬
‫اگر به عنوان صف ‪ FIFO‬از آن استفاده شود از ‪ LinkedList‬سریعتر خواهد بود‪.‬‬ ‫‪‬‬
‫اگر به عنوان صف ‪ LIFO‬یا همان پشته از آن استفاده شود از کالس ‪ Stack‬سریعتر خواهد بود‪.‬‬ ‫‪‬‬
‫میتوان به عنوان یک آرایه پویا (آرایه قابل رشد) به جای ‪ ArrayList‬هم از آن استفاده کرد‪.‬‬ ‫‪‬‬
‫در بعضی از کاربردها که نیاز به حذف گره میانی در عین پیمایش لیست داریم ممکن است ‪ LinkedList‬از ‪ ArrayDeque‬بهینه‬
‫تر باشد‪.‬‬
‫این کالس از طریق مسیر ‪ java.util.ArrayDeque‬قابل دستیابی است‪.‬برای ساخت شیء جدید از این کالس میتوانیم از یکی‬
‫از سازندههای زیر استفاده کنیم‪:‬‬
‫)(‪ArrayDeque‬‬
‫یک صف دو طرفه خالی ایجاد میکند ‪.‬‬
‫)‪ArrayDeque(Collection c‬‬
‫یک صف دو طرفه جدید ایجاد میکند و اعضای کالکشن ‪ c‬را به آن اضافه میکند ‪.‬‬
‫)‪ArrayDeque(int numElements‬‬
‫به صورت پیش فرض ‪ ArrayDeque‬با یک آرایه با اندازه ‪ 31‬شروع به کار میکند و در صورت نیاز اندازه آن افزایش مییابد‪ ،‬با‬
‫استفاده از سازنده فوق میتوانیم آرایه اولیه ای با اندازه ای به غیر از ‪ 31‬به اندازه ‪ numElements‬در آن ایجاد کنیم که البته باز هم‬
‫اندازه آن در صورت نیاز افزایش خواهد یافت‪.‬متدهای مهم این کالس در جدول زیر آمدهاند‪:‬‬
‫یک شیء جدید به انتهای صف اضافه میکند‪.‬‬ ‫)‪add(Object o‬‬
‫یک شیء جدید به ابتدای صف اضافه میکند‪.‬‬ ‫)‪addFirst(Object o‬‬
‫یک شیء جدید به انتهای صف اضافه میکند‪.‬‬ ‫)‪addLast(Object o‬‬
‫وجود یا عدم وجود یک شیء را بررسی میکند‪.‬‬ ‫)‪contains(Object o‬‬
‫یک ‪ Iterator‬معکوس برای پیمایش از انتها به ابتدای لیست بر میگرداند‪.‬‬ ‫)(‪descendingIterator‬‬
‫عنصر ابتدای صف را بر میگرداند ولی آن را حذف نمیکند‪.‬‬ ‫)(‪element‬‬
‫مانند متد قبل عمل میکند‪.‬‬ ‫)(‪getFirst‬‬
‫عنصر انتهای صف را بر میگرداند ولی آن را حذف نمیکند‪.‬‬ ‫)(‪getLast‬‬
‫خالی بودن یا نبودن مجموعه را بررسی میکند‪.‬‬ ‫)(‪isEmpty‬‬
‫یک ‪ iterator‬برای پیمایش ابتدا تا انتهای لیست بر میگرداند‪.‬‬ ‫)(‪iterator‬‬
‫یک عنصر به انتهای صف اضافه میکند‪.‬‬ ‫)‪offer(Object o‬‬
‫یک عنصر به ابتدای صف اضافه میکند‪.‬‬ ‫)‪offerFirst(Object o‬‬
‫یک عنصر به انتهای صف اضافه میکند‪.‬‬ ‫)‪offerLast(Object o‬‬
‫عنصر ابتدای صف را بر میگرداند ولی آن را حذف نمیکند‪.‬‬ ‫)(‪peek‬‬
‫عنصر ابتدای صف را بر میگرداند ولی آن را حذف نمیکند‪.‬‬ ‫)(‪peekFirst‬‬
‫عنصر انتهای صف را بر میگرداند ولی آن را حذف نمیکند‪.‬‬ ‫)(‪peekLast‬‬
‫عنصر ابتدای صف را حذف کرده و بر میگرداند‪.‬‬ ‫)(‪poll‬‬

‫عنصر ابتدای صف را حذف کرده و بر میگرداند‪.‬‬ ‫)(‪pollFirst‬‬
‫عنصر انتهای صف را حذف کرده و بر میگرداند‪.‬‬ ‫)(‪pollLast‬‬
‫عنصر باالی پشته را حذف کرده و بر میگرداند‪.‬‬ ‫)(‪pop‬‬
‫یک عنصر به باالی پشته اضافه میکند‪.‬‬ ‫)‪push(Object o‬‬
‫عنصر ابتدای صف را حذف میکند‪.‬‬ ‫)(‪remove‬‬
‫یک شیء را از صف حذف میکند‪.‬‬ ‫)‪remove(Object o‬‬
‫عنصر ابتدای صف را حذف میکند‬ ‫)(‪removeFirst‬‬
‫عنصر انتهای صف را حذف میکند‪.‬‬ ‫)(‪removeLast‬‬
‫ابتداییترین نمونه از یک شیء را حذف میکند‪.‬‬ ‫)‪removeFirstOccurrance(Objcet o‬‬
‫عنصر انتهای صف را حذف میکند‪.‬‬ ‫)(‪removeLast‬‬
‫انتهایی ترین نمونه از یک شیء را حذف میکند‪.‬‬ ‫)‪removeLastOccurance(Object o‬‬
‫تعداد اعضای مجموعه را بر میگرداند‪.‬‬ ‫)(‪size‬‬
‫اعضای مجموعه را به صورت یک آرایه بر میگرداند‪.‬‬ ‫)(‪toArray‬‬
‫بسیاری از متدهای فوق مشابه هم عمل میکنند و برنامه نویس باید طبق سلیقه خود یکی از آنها را انتخاب کند ‪.‬‬
‫استفاده از ‪ ArrayDeque‬به عنوان صف ‪FIFO‬‬
‫;‪import java.util.ArrayDeque‬‬

‫{‬
‫{‬
‫;)(‪ArrayDeque fifo = new ArrayDeque‬‬
‫;)"‪fifo.add("A‬‬
‫;)"‪fifo.add("B‬‬
‫;)"‪fifo.add("C‬‬
‫;)"‪fifo.add("D‬‬
‫))(‪while (!fifo.isEmpty‬‬
‫{‬
‫;))(‪System.out.println(fifo.poll‬‬
‫}‬
‫}‬
‫}‬
‫‪A‬‬
‫‪B‬‬
‫‪C‬‬
‫‪D‬‬
‫درکد قبل از ‪ ArrayDeque‬به عنوان صف ‪ FIFO‬استفاده کردیم و مشاهده میکنید که شی ای که اول وارد صف اول هم از صف‬
‫خارج شده‪ ،‬برای خروج اشیا از صف از یک حلقه ‪ while‬استفاده کردیم و تا زمانی که صف خالی نشد (متد )(‪ isEmpty‬مقدار‬
‫‪true‬بر نگرداند) عنصر ابتدای صف را با متد )(‪ poll‬خارج کرده و چاپ نمودیم‪.‬‬
‫استفاده از ‪ ArrayDeque‬به عنوان صف ‪LIFO‬‬
‫اگر قصد داشته باشیم از ‪ ArrayDeque‬به عنوان پشته (صف ‪ )LIFO‬استفاده کنیم بهتر است از متدهای )(‪ pop() ،push‬و‬
‫)(‪ peek‬استفاده کنیم‪ ،‬دقت کنید که در این حالت متد )(‪ peek‬عنصر باالی پشته را بر میگرداند ولی آن را حذف نمیکند و متد‬
‫)(‪ pop‬عنصر باالی پشته را حذف میکند و بر میگرداند‪.‬‬
‫;‪import java.util.ArrayDeque‬‬

‫{‬
‫{‬
‫;)(‪ArrayDeque stack = new ArrayDeque‬‬
‫;)"‪stack.push("A‬‬
‫;)"‪stack.push("B‬‬
‫;)"‪stack.push("C‬‬
‫;)"‪stack.push("D‬‬
‫))(‪while (!stack.isEmpty‬‬
‫{‬
‫;))(‪System.out.println(stack.peek‬‬
‫;))(‪System.out.println(stack.pop‬‬
‫}‬
‫}‬
‫}‬
‫‪D‬‬
‫‪D‬‬
‫‪C‬‬
‫‪C‬‬
‫‪B‬‬
‫‪B‬‬
‫‪A‬‬
‫‪A‬‬
‫همانطور که مشاهده میکنید این بارشی ای که آخر وارد شده اول خارج شده است‪ ،‬همچنین مشاهده میکنید که خروجی‬
‫متدهای )(‪ peek‬و )(‪ pop‬یکسان است‪ .‬حلقه ‪ while‬تا زمانی خالی شدن صف (بر قرار شد شرط ‪ )isEmpty‬اجرا میشود‪.‬‬
‫‪Properties‬‬
‫کالس ‪ Properties‬زیر کالس ‪ Hashtable‬است و برای نگه داری جداولی به کار میرود که در آن کلید و مقدار هر دو از نوع‬
‫متنی هستند‪ ،‬مهم ویژگی این کالس این است که به ما اجازه خواندن و نوشتن فایلهای تنظیمات )‪ (configuration files‬و‬
‫دسترسی به تنظیمات سیستمی را میدهد‪ .‬مهمترین متدهای این کالس متدهای )(‪ load‬و )(‪ store‬برای خواندن و نوشتن‬
‫برای خواندن و نوشتن در فایل تنظیمات ‪ XML‬هستند‪ .‬این کالس توسط‬ ‫تنظیمات در فایل و ‪ loadFromXML‬و‪storeToXML‬‬
‫بسیاری از کالسهای دیگر برای ارائه اطالعات یا تغییر تنظیمات استفاده میشود‪.‬این کالس از مسیر ‪java.util.Properties‬‬
‫قابل دستیابی است‪.‬برای ساخت یک شیء از این کالس باید از یکی از سازندههای زیر استفاده کنیم‪:‬‬
‫)(‪Properties‬‬
‫یک جدول خالی ایجاد میکند ‪.‬‬
‫)(‪Properties‬‬
‫از روی یک ‪ Properties‬دیگر یک لیست اولیه ایجاد میکند‪ .‬متدهای مهم این کالس در جدول زیر آمدهاند‪:‬‬
‫کلید را دریافت کرده و مقدار متناظر با‬ ‫)‪getProperty(String key‬‬
‫آن را در صورت وجود بر میگرداند‪.‬‬
‫مانند متد قبلی است با این تفاوت که‬ ‫)‪getProperty(String key,String default‬‬
‫اگر مقدار مورد نظر پیدا نشد مقدار‬
‫‪defaule‬را بر میگرداند‪.‬‬
‫لیست را بر روی یک استریم خروجی‬ ‫)‪list(PrintStream out‬‬
‫مینویسد‪.‬‬
‫لیست را بر روی یک استریم خروجی‬ ‫)‪list(PrintWriter out‬‬
‫جدول را از روی یک استریم ورودی‬ ‫)‪load(InputStream in‬‬
‫بارگذاری میکند‪.‬‬
‫جدول را از روی یک ‪Reader‬‬ ‫)‪load(Reader reader‬‬
‫میخواند‪.‬‬
‫جدول را از روی یک جریان ورودی‬ ‫)‪loadFromXML(InputStream in‬‬
‫‪XML‬میخواند‪.‬‬
‫لیست کلیدها را به صورت یک‬ ‫)(‪propertyNames‬‬
‫‪Enumeration‬بر میگرداند‪.‬‬
‫یک مقدار را به یک کلید خاص نسبت‬ ‫)‪setProperty(String key,String value‬‬
‫میدهد‪.‬‬
‫عمل ذخیره سازی جدول را به همراه‬ ‫)‪store(OutputStream out,String comments‬‬
‫توضیحات انجام میدهد‪.‬‬

‫مانند متد قبلی عمل میکند با این‬ store(Writer writer,String comments)
Writer ‫تفاوت که بر روی یک‬
.‫مینویسد‬
XML ‫برای ذخیره جدول بر روی فایل‬ storeToXML(OutputStream out,String comments)
.‫همراه با توضیحات به کار میرود‬
‫مانند متد قبل عمل میکند با این‬ storeToXML(OutputStream out,String comments,String encoding)
‫تفاوت که در اینجا قادر به تعیین‬
.‫نیز هستیم‬encoding
‫ بر‬Set ‫کلیدها را به صورت یک‬ stringPropertyNames()
.‫میگرداند‬
put() ‫ و‬get() ‫ همچون‬Hashtable ‫ است عالوه بر متدهای قبلی از متدهای کالس‬Hashtable ‫چون کالس فوق زیر کالس‬
. ‫و … نیز میتوانیم استفاده کنیم‬
!‫چاپ اطالعات سیستمی‬
‫ میتوانیم اطالعات مفیدی را در مورد سیستمی که از آن استفاده میکنیم به دست‬System.getProperties() ‫با استفاده از‬
. ‫ کاربر و نام سیستم عامل را چاپ میکند‬home ‫ مسیر‬،‫ ساختار سیستم عامل‬،‫ کد زیر مسیر جاوا‬،‫بیاوریم‬
import java.util.Properties;

{
{
Properties myProperty = System.getProperties();
System.out.println(myProperty.get("java.home"));
System.out.println(myProperty.get("os.arch"));
System.out.println(myProperty.get("user.home"));
System.out.println(myProperty.get("os.name"));
}
}
11۹ ‫مبانی زبان جاوا‬
‫ذخیره در فایل‬
: ‫ (یا به عبارتی فایل تنظیمات) را در یک فایل ذخیره کنیم‬Properties ‫در این مثال یاد میگیریم که چگونه یه فایل‬
import java.io.*;

{
public static void main(String[] args) throws Exception
{
FileOutputStream fileoutputstream = new FileOutputStream("D:/Sample.config");
Properties myProperty = new Properties();
myProperty.setProperty("username","root");
myProperty.setProperty("password","123456");
myProperty.setProperty("database","localhost");
myProperty.store(fileoutputstream,"Database Config!");
}
}
‫ دادههایی را در آن مینویسیم و در‬setProperty() ‫ خالی ایجاد میکنیم و سپس با استفاده از متد‬Properties ‫در کد باال یک‬
: ‫ اگر فایل مورد نظر را باز کنید به صورت زیر خواهد بود‬.‫ آن را در فایل مینویسیم‬store() ‫آخربه سادگی با استفاده از متد‬
#Database Config!
#Mon May 01 08:04:02 IRDT 2017
password=123456
database=localhost
username=root
.‫البته در فایل مورد نظر تاریخ نیز درج میشود که در این مثال آن را حذف کردیم‬
‫خواندن از فایل‬
. ‫ در این مثال قصد داریم همان فایل را بخوانیم و در خروجی چاپ کنیم‬،‫ را در فایل نوشتیم‬Properties ‫در مثال قبل یک‬
import java.io.*;

{
{
FileInputStream fileinputstream = new FileInputStream("D:/Sample.config");
myProperty.load(fileinputstream);
System.out.println("username :" + myProperty.getProperty("username"));

System.out.println("password :" + myProperty.getProperty("password"));
System.out.println("database :" + myProperty.getProperty("database"));
}
}
username :root
password :123456
database :localhost
‫ خواندیم و مقادیر مورد‬Properties ‫ محتوای فایل را در یک‬load() ‫همانطور که مشاهده میکنید به سادگی با استفاده از متد‬
.‫نظر را به سادگی چاپ کردیم‬
XML‫ذخیره در فایل‬
: ‫ ذخیره میکند‬XML ‫ مثال قبل را در یک فایل‬Properties ‫کد زیر همان‬
import java.io.*;

{
{
FileOutputStream fileoutputstream = new FileOutputStream("D:/Sample.xml");
myProperty.setProperty("username","root");
myProperty.setProperty("password","123456");
myProperty.setProperty("database","localhost");
myProperty.storeToXML(fileoutputstream,"Database Config!!");
}
}
xml ‫ اگر فایل‬،‫ هستیم‬xml ‫ به سادگی قادر به نوشتن تنظیمات در فایل‬storeToXML() ‫مشاهده میکنید که با استفاده از متد‬
: ‫مورد نظر را باز کنید مشاهده میکنید که محتوای آن به صورت زیر است‬
1۹۵ ‫مبانی زبان جاوا‬
<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<comment>Database Config!!</comment>
<entry key="password">123456</entry>
<entry key="database">localhost</entry>
<entry key="username">root</entry>
</properties>
XML‫خواندن از فایل‬
. ‫ قبلی خوانده و نتایج را در خروجی چاپ میکنیم‬XML ‫در این مثال از فایل‬
import java.io.*;

{
{
FileInputStream fileinputstream = new FileInputStream("D:/Sample.xml");
myProperty.loadFromXML(fileinputstream);
System.out.println("username :" + myProperty.getProperty("username"));

System.out.println("password :" + myProperty.getProperty("password"));
System.out.println("database :" + myProperty.getProperty("database"));
}
}
username :root
password :123456
database :localhost
.‫ هستیم‬xml ‫ به سادگی قادر به خواندن از فایل‬loadFromXML() ‫همانطور که مشاهده میکنید با استفاده از متد‬
(Generics)‫جنریک ها‬
‫ متدها یا رابطهایی هستند که بسته به نوع داده ای که به آنها اختصاص داده میشود رفتارشان را سازگار‬،‫ کالسها‬،‫جنریک ها‬
‫ همچنین میتوان یک متد ایجاد کرد‬.‫ به عنوان مثال میتوان یک متد جنریک تعریف کرد که هر نوع داده ای را قبول کند‬.‫میکنند‬
‫که بسته به نوع دریافتی‪ ،‬مقادیری از انواع داده ای مانند ‪ double ،int‬یا ‪ String‬را نشان دهد‪ .‬اگر از جنریک ها استفاده نکنید‬
‫باید چند متد و یا حتی چندین متد سربارگذاری شده برای نمایش هر نوع ممکن ایجاد کنید‪.‬‬
‫)‪public void Show(int number‬‬

‫{‬
‫}‬
‫)‪public void Show(double number‬‬

‫{‬
‫}‬
‫)‪public void Show(String message‬‬

‫{‬
‫}‬
‫با استفاده از جنریک ها میتوان متد جنریکی ایجاد کرد که هر نوع داده ای را قبول کند‪.‬‬
‫)‪public <E> void Show(E item‬‬

‫{‬
‫;)‪System.out.println(item‬‬
‫}‬
‫متدهای جنریک را در درسهای آینده توضیح خواهیم داد‪ .‬حتما این سؤال را از خودتان میپرسید که چرا نباید از نوع آبجکت که‬
‫هر نوع داده ای را قبول میکند استفاده کنیم؟ در آینده مشاهده میکنید که با استفاده از جنریک ها نیاز به عمل ‪( cast‬تبدیل‬
‫صریح) ندارید‪ .‬درباره جنریک ها در درسهای بعد مطالب بیشتری توضیح میدهیم‪.‬‬
‫متدهای جنریک‬
‫اگر بخواهید چندین متد با عملکرد مشابه ایجاد کنید و فقط تفاوت آنها در نوع داده ای باشد که قبول میکنند (مثال یکی نوع‬
‫‪ int‬و دیگری نوع ‪ double‬را قبول کند) میتوان از متدهای جنریک برای صرفه جویی در کدنویسی استفاده کرد‪ .‬ساختار عمومی‬
‫یک متد جنریک به شکل زیر است‪:‬‬
‫)‪<type> returnType methodName(type argument1‬‬

‫{‬
‫;‪type someVariable‬‬
‫}‬
‫‪1۹۳‬‬ ‫مبانی زبان جاوا‬
‫مشاهده میکنید که قبل از نوع برگشتی متد یک نوع در داخل دو عالمت بزرگتر و کوچکتر آمده است )>‪ (<type‬که همه انواع‬
‫در جاوا میتوانند جایگزین آن شوند‪ .‬برنامه زیر مثالی از نحوه استفاده از متد جنریک میباشد‪:‬‬

‫{‬
‫)‪public static <X> void Show(X val‬‬
‫{‬
‫;)‪System.out.println(val‬‬
‫}‬

‫{‬
‫;‪int intValue = 5‬‬
‫;‪double doubleValue = 10.54‬‬
‫;"‪String stringValue = "Hello‬‬
‫;‪boolean boolValue = true‬‬
‫;)‪Show(intValue‬‬
‫;)‪Show(doubleValue‬‬
‫;)‪Show(stringValue‬‬
‫;)‪Show(boolValue‬‬
‫}‬
‫}‬
‫‪5‬‬
‫‪10.54‬‬
‫‪Hello‬‬
‫‪true‬‬
‫یک متد جنریک ایجاد کردهایم که هر نوع داده ای راقبول کرده و مقادیر آنها را نمایش میدهد (خطوط ‪ .)1-0‬سپس دادههای‬
‫مختلفی با وظایف یکسان به آن ارسال میکنیم‪ .‬متد نیز نوع ‪ X‬را بسته به نوع داده ای که به عنوان آرگومان ارسال شده است تغییر‬
‫میدهد‪ .‬به عنوان مثال وقتی یک داده از نوع ‪ int‬ارسال میکنیم‪ ،‬همه مکانهایی که ‪ X‬در آنها وجود دارد به ‪ int‬تبدیل میشوند‬
‫و متد به صورت زیر در میآید‪:‬‬
‫)‪public static void Show (int val‬‬

‫{‬
‫;)‪System.out.println(val‬‬
‫}‬
‫به یک نکته در مورد استفاده از متدهای جنریک توجه کنید و آن این است که شما نمیتوانید در داخل کدهای مربوط به متد‬
‫محاسبات انجام دهید مثال دو عدد را با هم جمع کنید چون کمپایلر نمیتواند نوع واقعی عملوندها را تشخیص دهد‪ ،‬ولی به سادگی‬
‫میتوان مقادیر را در داخل متد نشان داد چون کمپایلر هر نوع داده ای را که توسط متد )(‪ System.out.println‬استفاده‬
‫میشود را میتواند تشخیص دهد‪.‬‬

‫)‪public static <X> void Show(X val1, X val2‬‬

‫{‬
‫;)‪System.out.println(val1 + val2‬‬
‫}‬
‫شما میتوانید چندین نوع خاص را برای متد جنریک ارسال کنید‪ ،‬برای این کار هر نوع را به وسیله کاما از دیگری جدا کنید‪.‬‬
‫)‪public static <X, Y> void Show(X val1, Y val2‬‬

‫{‬
‫;)‪System.out.println(val1‬‬
‫;)‪System.out.println(val2‬‬
‫}‬
‫به مثال زیر که در آن دو مقدار مختلف به متد ارسال شده است توجه کنید‪:‬‬
‫;)‪Show(5, true‬‬
‫مشاهده میکنید که ‪ X‬با نوع ‪ int‬و ‪ Y‬با نوع ‪ bool‬جایگزین میشود‪ .‬این نکته را نیز یادآور شویم که شما میتوانید دو آرگومان‬
‫هم نوع را هم به متد ارسال کنید‪:‬‬
‫;)‪Show(5, 10‬‬
‫کالس جنریک‬
‫تعریف یک کالس جنریک بسیار شبیه به تعریف یک متد جنریک است‪ .‬کالس جنریک دارای یک عالمت بزرگتر و کوچک تر و یک‬
‫نوع پارامتر خاص میباشد‪ .‬برنامه زیر مثالی از یک کالس جنریک میباشد‪:‬‬

‫‪2‬‬
‫‪4‬‬
‫‪5‬‬ ‫‪class GenericClass‬‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;‪private T someField‬‬
‫‪8‬‬
‫‪9‬‬ ‫)‪public GenericClass(T someVariable‬‬
‫‪10‬‬ ‫{‬
‫‪11‬‬ ‫;‪someField = someVariable‬‬
‫‪12‬‬ ‫}‬
‫‪13‬‬
‫‪14‬‬ ‫)‪public void SetSomeProperty(T value‬‬
‫‪15‬‬ ‫{‬
‫‪16‬‬ ‫;‪this.someField = value‬‬
‫‪17‬‬ ‫}‬
‫‪18‬‬
‫‪19‬‬ ‫)(‪public T GetSomeProperty‬‬
1۹۱ ‫مبانی زبان جاوا‬
20 {
21 return someField;
22 }
23 }
24
26 {
28 {
29 GenericClass genericDouble = new GenericClass(30.50);
30 GenericClass genericString = new GenericClass("Hello World!");
31
32 System.out.println(MessageFormat.format("Double Value : {0}",
33 genericDouble.GetSomeProperty()));
34 System.out.println(MessageFormat.format("String Value : {0}",
35 genericString.GetSomeProperty()));
36 }
37 }
Double Value : 30.5

String Value : Hello World!
-35 ‫) و یک سازنده (خطوط‬33-55 ‫ یک خاصیت (خطوط‬،)1 ‫) که دارای یک فیلد (خط‬1-51 ‫در مثال باال یک کالس جنریک (خطوط‬
.‫ در آنها قرار دارد بعدا توسط انواعی که مد نظر شما است جایگزین میشوند‬T ‫ تمام مکانهایی که ورودی‬.‫) است را ایجاد میکنیم‬6
‫ مانند متدهای جنریک میتوانید‬.)<int>( ‫ یک نوع هم برای آن در نظر بگیرید‬،‫وقتی یک نمونه از کالس جنریک تان ایجاد میکنید‬
.‫چندین نوع پارامتر به کالسهای جنریک اختصاص دهید‬
public class GenericClass<T1, T2, T3>

{
private T1 someField1;
}
.‫ از چه نوعی هستند نمیتوانید مانند مثال زیر از آنها نمونه جدید ایجاد کنید‬T3 ‫ و‬T2 ،T1 ‫چون نمیدانید‬
public GenericClass //Constructor

{
someField1 = new T1();
}
.‫ اما باید یک نوع برای پارامتر کالس پایه جنریک تعریف کنید‬،‫کالسهای غیر جنریک میتوانند از کالسهای جنریک ارث بری کنند‬
public class MyClass extends GenericClass<Integer>

{
}
.‫یک کالس جنریک هم میتواند از یک کالس غیر جنریک ارث بری کند‬
(Generic Collection) ‫کلکسیون عمومی‬
List<T> ‫ برای ایجاد یک کلکسیون عمومی از کالس‬.‫می توان یک کلکسیون عمومی تعریف کرد که شامل هر نوع داده ای باشد‬
‫ در نتیجه‬.‫ باشد‬T ‫ می تواند مجموعه ای از اشیاء نوع‬List<T> .‫ استفاده می شود‬java.util.List ‫مربوط به فضای نامی‬
‫ و دیگر‬add() ،remove() ،removeAll() ‫ دارای متدهای‬List<T> ‫ کالس‬.‫ مجموعه ای از مقادیر صحیح است‬List<int>
. ‫متدهایی است که می توانیم از آنها برای حذف و اضافه کردن عناصر استفاده کنیم‬
import java.util.List;
import java.util.ArrayList;
class Animal
{
public String Type;
public Animal(String type)

{
this.Type = type;
}
}
{
{
List<Animal> animals = new ArrayList<>();
animals.add(new Animal("Dog"));
animals.add(new Animal("Cat"));
animals.add(new Animal("Rat"));
for (Animal animal : animals)

{
System.out.println(animal.Type);
}
}
}
Dog
Cat
Rat
‫ نوع کلید و‬Tkey .‫ قرار دارد استفاده کنید‬java.util.HashMap; ‫ که در پکیج‬HashMap<TKey, TVal> ‫می توانید از کالس‬
. ‫ نوع مقدار را مشخص می کند‬Tval

1۹1 ‫مبانی زبان جاوا‬
import java.util.HashMap;
class Animal
{
public String Type;
public Animal(String type)

{
this.Type = type;
}
}
{
{
HashMap<String, Animal> animals = new HashMap<>();
animals.put("Animal1", new Animal("Dog"));

animals.put("Animal2", new Animal("Cat"));
animals.put("Animal3", new Animal("Rat"));
for (Animal animal : animals.values())

{
System.out.println(animal.Type);
}
}
}
Dog
Cat
Rat
‫ برای به دست‬.‫ می باشد‬Animal ‫ و مقادیری از نوع کالس‬String ‫ تعریف کرده ایم که دارای کلیدهایی از نوع‬HashMap ‫یک‬
.‫ که شامل همه آیتم های دیکشنری است استفاده کرد‬values() ‫ می توان از متد‬HashMap ‫آوردن مقدار آیتم های‬
Object Initializer
‫ اگر به عنوان مثال چندین خاصیت‬.‫ به شما اجازه می دهند خاصیت ها را در داخل کالس مقداردهی کنید‬Object Initializer
‫ استفاده‬object initializer ‫ می توانید از‬،‫داشته باشید و نخواهید که یک سازنده را جهت مقداردهی به آنها تعریف کنید‬
: ‫ به عنوان مثال به کد زیر توجه کنید‬.‫نمایید‬
class Sample
{
public int Property1;
public String Property2;
‫;‪public boolean Property3‬‬

‫}‬

‫{‬
‫{‬
‫;)(‪Sample sampleClass = new Sample‬‬
‫;‪sampleClass.Property1 = 100‬‬
‫;"‪sampleClass.Property2 = "Sample‬‬
‫;‪sampleClass.Property3 = true‬‬
‫}‬
‫}‬
‫همانطور که مشاهده می کنید‪ ،‬الزم است که مقادیر را تک به تک به خاصیت ها اختصاص دهیم‪ .‬با استفاده از ‪object‬‬
‫‪ initializers‬می توان کد را ساده تر کرد ‪:‬‬
‫‪class Sample‬‬
‫{‬
‫‪public int‬‬ ‫;‪Property1‬‬
‫;‪public String Property2‬‬
‫;‪public boolean Property3‬‬
‫}‬

‫{‬
‫{‬
‫)(‪Sample sampleClass = new Sample‬‬
‫{{‬
‫;‪Property1 = 100‬‬
‫;"‪Property2 = "Hello‬‬
‫;‪Property3 = true‬‬
‫;}}‬
‫}‬
‫}‬
‫مشاهده می کنید که بعد از ایجاد یک شی از کالس به جای پرانتز از دو آکوالد ( }} ) استفاده کرده و سپس با لیست کردن خاصیت‬
‫ها مقادیری را که الزم داریم به آنها اختصاص می دهیم‪ .‬به این نکته نیز توجه کنید که خواص به وسیله سمیکالن (;) از هم جدا‬
‫می شوند‪ .‬هنگام استفاده از ‪ object initializers‬سازنده پیشفرض بدون پارامتر قبل از هر خاصیت مقداردهی شده فراخوانی‬
‫می شود‪ .‬از آنجاییکه سازنده پیشفرض قبل از اختصاص مقادیر به خاصیت ها اجرا می شود‪ ،‬می توانید مقادیری پیشفرضی به هر‬
‫یک از خواص اختصاص بدهید‪ ،‬با این کار الزم نیست که حتما به همه خواص با استفاده از ‪ initializer‬مقدار اختصاص داده‬
‫شود‪ .‬اگر یک سازنده غیر پیشفرض )‪ (non-default constructor‬به کالس اضافه کنید باز هم باید یک سازنده بدون پارامتر‬
‫پیشفرض برای قدرت استفاده از ‪ object initializers‬وجود داشته باشد‪ .‬می توان از ‪ object initializers‬تو در تو‬
1۹۹ ‫مبانی زبان جاوا‬
‫ هست را دارا‬Age ‫ و‬Name ‫ که دارای دو خاصیت‬Animal ‫ مان یک خاصیت از نوع‬Sample ‫ فرض کنید کالس‬.‫نیز استفاده نمود‬
: ‫می باشد‬
class Animal
{
public String Name;
public int Age;
}
class Sample
{
public int Property1;
public String Property2;
public boolean Property3;
public Animal Property4;
}

{
{
Sample sampleClass = new Sample()
{{
Property1 = 100;
Property2 = "Hello";
Property3 = true;
Property4 = new Animal()
{{
Name = "Kitty";
Age = 3;
}};
}};
}
}
‫( استفاده می‬generic) ‫ که در کلکسیون های عمومی‬،‫ می باشند‬collection initializers ‫نوع دیگر از مقداردهنده ها‬
: ‫شوند‬
import java.util.List;
import java.util.ArrayList;
class Person
{
public String FirstName;
public Person(String f)
{
this.FirstName = f;
}
}

{
{
List<Person> people = new ArrayList<Person>()
{{
add(new Person("John"));
add(new Person("Jenny"));
add(new Person("Joe"));
}};
for (Person person : people)

{
System.out.println(MessageFormat.format("{0}", person.FirstName));
}
}
}
John
Jenny
Joe
‫فصل دوم‬
‫‪SWING‬‬
‫برنامه نویسی ویژوال‬

‫رابط گرافیکی کاربر یا )‪ Graphical User Interface (GUI‬به کاربر اجازه میدهد که با استفاده از اجزای بصری مختلف با‬
‫برنامه ارتباط برقرار کند‪.‬در روزهای اولیه دنیای کامپیوتر برنامهها مبتنی بر متن بودند‪ ،‬بدین معنی که شما باید دستورات متنی‬
‫زیادی برای ایجاد یک برنامه مفید تایپ میکردید و این کار مستلزم حفظ کردن یک لیست طوالنی از دستورات بود‪.‬برنامههای نرم‬
‫افزاری امروزی دارای رابط گرافیکی هستند‪ .‬این رابط گرافیکی تقریبا در همه برنامههایی که امروزه با آنها سر و کار دارید به چشم‬
‫میخورد‪ .‬یک رابط گرافیکی حرفه ای باید جذاب و ساده باشد‪ .‬ایجاد یک برنامه با رابط کاربری قبال یک کار سخت و کسل کننده‬
‫بود‪ .‬مثال برای ایجاد یک پنجره ساده که یک متن را نمایش دهد نیاز بود که تعداد زیادی کد تایپ شود‪ .‬اما با ورود برنامه نویسی‬
‫ویژوال این کار راحت شد‪ .‬برنامه نویسی ویژوال ایجاد برنامههای گرافیکی را راحت کرد‪ ،‬به طوری که شما میتوانید محیط برنامه‬
‫خود را با کشیدن کنترلهای الزم از جعبه ابزار به نوعی “نقاشی” کنید‪ .‬کنترلها اجزای بصری هستند که ‪ GUI‬یا رابط گرافیکی را‬
‫تشکیل میدهند‪ .‬نمونه ای از کنترلها عبارتاند از ‪check boxes ،labels ،text boxes ،buttons‬و ‪.radio buttons‬‬
‫‪ NetBeans‬نیز محیطی را برای ایجاد و طراحی فرمها به صورت زیر برای شما فراهم میآورد‪:‬‬
‫‪131‬‬ ‫‪SWING‬‬
‫شکل باال حالت طراحی )‪ (Design‬در ‪ NetBeans‬را نشان میدهد‪ .‬در این شکل فرم ویندوزی و کنترلهایی که بر روی آن کشیده‬
‫شدهاند نشان داده شده است‪ .‬در حالت طراحی‪ ،‬شما میتوانید چگونگی به نظر رسیدن فرم را در حین اجرای برنامه مشاهده کنید‪.‬‬
‫کدهایی که باعث ایجاد و مقداردهی به کنترلها میشوند از دید کاربر مخفی هستند‪ ،‬بنابراین شما میتوانید بر روی کارکرد برنامه‬
‫بیشتر تمرکز کنید‪ .‬همچنین میتوانید از ابزارهای ‪ NetBeans‬مانند چپ چین یا راست چین کردن‪ ،‬تغییر اندازه و …‪ ..‬برای طراحی‬
‫کنترلها استفاده کرد‪.‬‬
‫‪ AWT‬چیست ؟‬
‫‪ AWT‬یا ‪ Abstract Window Toolkit‬یا جعبه ابزار انتزاعی‪ ،‬مجموعه ای از کالسهاست‪ ،‬که توسط برنامه نویسان جاوا برای‬
‫ایجاد اشیاء رابط گرافیکی کاربر )‪ (GUI‬مانند دکمههای‪ ،‬اسکرول بارها و پنجرهها به کار میروند‪ AWT .‬قسمتی از کالسهای پایه‬
‫ای جاوا )‪ (JFC‬است که توسط شرکت ‪ Sun Microsystems‬برنامه نویسی شدهاند‪ JFC .‬مجموعه ای جامع از کتابخانههای‬
‫کالس ‪ GUI‬است که با استفاده از آنها به راحتی میتوانید رابط کاربری برنامه را ایجاد کرده و توسعه دهید‪ .‬پکیج ‪java.awt‬‬
‫دارای کالسهایی برای کار با رابط گرافیکی است که در زیر نحوه ارث بری آنها نشان داده شده است‪:‬‬
‫همانطور که در شکل باال مشاهده میکنید در پکیج ‪ ،AWT‬کالسهای ‪ Label ،Button‬و … از کالس ‪ Component‬ارث بری میکنند‬
‫و اشیاء ساخته شده از این کالسها کنترلهای بصری ‪ AWT‬را که در شکل زیر مشاهده میکنید به وجود میآورند‪:‬‬
‫‪131‬‬ ‫‪SWING‬‬
‫کنترلهای ‪ AWT‬یک مجموعه از اولین کنترلها برای پلت فرم جاوا هستند که از آنها برای ایجاد برنامههای جاوای قابل استفاده‬
‫در محیطهای ‪ Windows‬و ‪ Linux‬استفاده میشود‪ .‬این کامپوننتها خیلی کند و غیر قابل اطمینان بوده و برای تمام پلت فرمهای‬
‫جاوا نیز نمیتوانند مورد استفاده قرار گیرند‪ .‬با توجه به مشکالت کنترلهای ‪ AWT‬در ایجاد برنامههای کاربردی‪ ،‬شرکت ‪ Sun‬با‬
‫همکاری ‪ Netscape‬و سایر شرکتهای دیگر مجموعه ایای دیگر از کامپوننتها و کتابخانهها را بنام ‪Java Foundation Class‬‬
‫با نام اختصاری ‪ JFC‬بوجود آورند که کنترلهای ‪ Swing‬نیز بخشی از آنها هستند‪ .‬از آنجاییکه در این سری آموزشی میخواهیم‬
‫کنترلها و در کل کتابخانه ‪ Swing‬را آموزش دهیم به همین توضیحات در مورد ‪ AWT‬بسنده میکنیم و در درس آینده شما را با‬
‫‪ Swing‬آشنا میکنیم‪.‬‬
‫‪ SWING‬چیست ؟‬
‫کلمه ‪ Swing‬از یک موزیک محبوب و معروف در آمریکا که در طی سالهای ‪ 3613 – 3631‬پخش میشده است‪ ،‬الهام گرفته شده‬
‫است‪ .‬در این زمان هنوز جاوا وجود نیامده بود‪ .‬کامپوننتهای ‪ AWT‬یک مجموعه از اولین کامپوننتها برای پلت فرم جاوا بودند که از‬
‫آنها برای ایجاد برنامههای جاوا‪ ،‬قابل استفاده در محیطهای ‪ Windows‬و ‪ Linux‬استفاده میشده است‪ .‬این کامپوننتها خیلی‬
‫کند و غیر قابل اطمینان بودند و برای تمام پلت فرمهای جاوا نیز نمی توانسند مورد استفاده قرار گیرند‪ .‬با توجه به مشکالت‬
‫کامپوننتهای ‪ AWT‬در ایجاد برنامههای کاربردی‪ ،‬شرکت ‪ Sun‬با همکاری ‪ Netscape‬و سایر شرکتهای دیگر مجموعه هایی دیگر‬
‫از کامپوننتها و کتابخانهها را بنام ‪ Java Foundation Class‬با نام اختصاری ‪ JFC‬بوجود آورند که کنترلهای ‪ Swing‬نیز بخشی‬
‫از آنها بودند‪ .‬کنترلهای ‪ Swing‬بر خالف کنترلهای‪ ،AWT‬هماهنگی کاملی با سایر فریم ورکهای جاوا داشته و بر روی تمام پلت‬
‫فرمها قابل استفاده میباشند‪ .‬این کنترلهای عالوه بر خواص کنترلهای ‪ AWT‬دارای خواص جدیدی تری نیز بوده و معایب‬
‫کنترلهای ‪ AWT‬را در آنها بر طرف شده است‪ .‬به عنوان مثال در کامپوننت ‪ Button‬از مجموعه کامپوننتهای ‪ AWT‬نمیتوان از‬
‫عکس استفاده کرد ولی این قابلیت در کنترل ‪ Button‬از کتابخانه ‪ Swing‬گنجانده شده است‪.‬‬
‫مهمترین وجه تمایز بین کنترلهای ‪ Swing‬و ‪ AWT‬این است که کامپوننتهای ‪ Swing‬همگی با حرف ‪ J‬شروع میشوند‪ .‬به عنوان‬
‫مثال کنترل ‪ Jbutton‬از کنترلهای ‪ Swing‬معادل کنترل ‪ Button‬از ‪ AWT‬است‪ ،‬و یا کنترل ‪ JComboBox‬معادل کنترل ‪Choice‬‬
‫از مجموعه کنترلهای ‪ AWT‬است‪ .‬جدول زیر لیست کنترلهای ‪ AWT‬و معادل آنها را در کامپوننتهای ‪ Swing‬نشان میدهد‪.‬‬
‫‪SWING‬‬ ‫‪AWT‬‬
‫‪JButton‬‬ ‫‪Button‬‬
‫‪JPanel‬‬ ‫‪Canvas‬‬
‫‪JCheckBox‬‬ ‫‪CheckBox‬‬
‫‪JRadioButton in ButtonGroup‬‬ ‫‪CheckBox in CheckBoxGroup‬‬
‫‪JComboBox‬‬ ‫‪Choice‬‬
‫‪JComponent‬‬ ‫‪Component‬‬
‫‪JPanel‬‬ ‫‪Container‬‬
‫‪JLabel‬‬ ‫‪Label‬‬
‫‪JList‬‬ ‫‪List‬‬
‫‪JMenu‬‬ ‫‪Menu‬‬
‫‪JMenuBar‬‬ ‫‪MenuBar‬‬
‫‪JMenuItem‬‬ ‫‪MenuItem‬‬
131 SWING
JPanel Panel
JPopupMenu PopupMenu
JScrollBar Scrollbar
JScrollPane ScrollPane
JTextArea TextArea
JTextField TestField
JApplet Applet
JDialog Dialog
JFileChooser FileDialog
JFrame Frame
JWindow Window
‫ وجود‬AWT ‫ دارای کنترلهای جدید دیگری نیز هست که هیچ جایگزینی برای آنها در کنترلهای‬Swing ،‫عالوه بر کنترلهای فوق‬
:‫ دارای کالسهایی برای کار با رابط گرافیکی است که در زیر نحوه ارث بری آنها نشان داده شده است‬java.swing ‫ پکیج‬.‫ندارد‬
‫همانطور که در شکل باال مشاهده میکنید در پکیج ‪ ،swing‬کالسهای ‪ JLabel ،JButton‬و … از کالس ‪ JComponent‬و این‬
‫کالس هم از کالس ‪ Component‬ارث بری میکنند و اشیاء ساخته شده از این کالسها‪ ،‬کنترلهای بصری ‪ Swing‬را که در شکل‬
‫زیر مشاهده میکنید به وجود میآورند‪:‬‬
‫حال که مختصری با سویینگ آشنا شدید در درسهای آینده با کنترلهای آن و نحوه استفاده از هر یک آشنا میشوید‪.‬‬
‫ایجاد یک برنامه ‪ Swing‬ساده‬

‫وقت آن رسیده است که کار با کنترلهای ‪ Swing‬را تجربه کنید‪ .‬به این نکته توجه کنید که این درس به شما نحوه ایجاد یک‬
‫برنامه ویندوزی که در آن از یک اداره کننده رویداد )‪ (event-handling‬استفاده شده است‪ ،‬را نشان میدهد‪.‬من هر مرحله را به‬
‫صورت گام به گام انجام داده و به طور مختصر در مورد هر کدام توضیح میدهم‪.‬مفاهیم فریم‪ ،‬کنترل‪ ،‬کنترل کننده رویداد‪(event-‬‬
‫)‪ handling‬و برخی قسمتهای ‪ Swing‬در طراحی یک برنامه ویندوزی مورد استفاده قرار میگیرد و در مورد هر کدام از آنها در‬
‫درسهای مربوطهشان بحث خواهد شد‪ .‬قبل از پرداختن به ادامه درس لینک زیر را مشاهده کنید تا نحوه پیکربندی ‪ JDK‬برای‬
‫اجرای فایلهای ‪ java‬یاد بگیرید و دلیل استفاده از نرم افزار ‪ NetBeans‬در آموزشها را بفهمید‪.‬‬
136 SWING
‫ساخت یک برنامه در جاوا‬
‫ یک ویرایشگر‬.‫حال میخواهیم یک برنامه ایجاد کنیم که در این برنامه وقتی بر روی یک دکمه کلیک شد متن داخل آن تغییر کند‬
:‫ باز کرده و کدهای زیر را در داخل آن بنویسید‬NotePad++ ‫متن مانند‬
2
3 import javax.swing.*;
4 import java.awt.event.*;
5
7 {
9 {
10 JFrame frame = new JFrame("Swing first program");
11
12 final JButton button = new JButton("Click ME!");
13
14 button.addMouseListener(new MouseListener()
15 {
16 @Override
17 public void mouseClicked(MouseEvent e)
18 {
19 button.setText("You clicked the button!");
20 }
21
22 @Override
23 public void mousePressed(MouseEvent e)
24 {
25
26 }
27
28 @Override
29 public void mouseReleased(MouseEvent e)
30 {
31
32 }
33
34 @Override
35 public void mouseEntered(MouseEvent e)
36 {
37
38 }
39
40 @Override
41 public void mouseExited(MouseEvent e)
42 {
43
44 }
45 });
46
47 frame.add(button);
48 frame.setSize(337, 255);
49 frame.setVisible(true);
50 }
51 }
‫با اجرای کد باال پنجره ای به صورت زیر نمایش داده میشود که با کلیک بر روی آن متن داخل دکمه تغییر میکند‪:‬‬
‫برنامه باال یکی از سادهترین برنامههایی بود که جهت آشنایی شما به ‪ Swing‬آموزش دادیم‪ .‬در این کتاب قصد داریم که ‪Swing‬‬
‫را از طریق کدنویسی نه از طریق برنامههایی مانند ‪ NetBeans‬به شما آموزش دهیم تا شما بیشتر با مفاهیم کدها آشنا شوید‪.‬‬
‫کالس ‪JOptionPane‬‬
‫‪ JOptionPane‬کالسی از جاواست است که از آن برای نشان دادن یک پیغام فوری‪ ،‬اطالعات و یا یک هشدار به کاربران استفاده‬
‫میشود‪ .‬برای نشان دادن یک پیغام به راحتی میتوان از متد )(‪ showMessageDialog‬کالس ‪ JOptionPane‬استفاده نمایید‪.‬‬
‫سادهترین حالت متد )(‪ showMessageDialog‬این است که یک رشته متنی را به عنوان آرگومان قبول میکند و آن را نمایش‬
‫میدهد‪ .‬یک فایل با پسوند ‪ java‬توسط ‪ Notepad++‬ایجاد کرده و کدهای زیر را در داخل آن نوشته و با نام ‪MyFirstProgram‬‬
‫ذخیره کنید‪:‬‬
‫;*‪import javax.swing.‬‬

‫{‬
‫{‬
‫;)"! ‪JOptionPane.showMessageDialog(null, "Hello World‬‬
‫}‬
‫}‬
‫‪133‬‬ ‫‪SWING‬‬
‫بین دو پرانتز مقابل آن اول کلمه ‪ null‬را داریم که کلمه ای کلیدی در جاواست و اینجا فقط به این معناست که جعبه پیام به هیچ‬
‫چیز دیگری در برنامه وابسته نیست‪ .‬برنامه را اجرا کرده و نتیجه را مشاهده نمایید‪:‬‬
‫شما همچنین میتوانید به راحتی و با استفاده از یکی دیگر از سربارگذاریهای متد )(‪ showMessageDialog‬یک عنوان و یک آیکون‬
‫برای جعبه پیامتان بگذارید‪.‬‬
‫;)‪JOptionPane.showMessageDialog (null, "Hello World !", "A Message", JOptionPane.WARNING_MESSAGE‬‬
‫نتیجه اجرای کد باال به صورت زیر است‪.‬‬
‫همانطور که در باال مشاهده کردید‪ ،‬میتوان به جعبه پیام برای نشان دادن معنی و مفهوم آن یک آیکون اضافه کرد‪ .‬در جدول زیر‬
‫انواع آیکونها و کاربرد آنها در جعبه پیام نشان داده شده است‪:‬‬
‫استفاده‬ ‫عضو‬ ‫آیکون‬
‫برای نشان دادن اطالعات به کاربر‬ ‫‪AINFORMATION_MESSAGE‬‬

‫برای نشان دادن یک پیغام خطا‬ ‫‪ERROR_MESSAGE‬‬
‫برای نشان دادن یک هشدار‬ ‫‪WARNING_MESSAGE‬‬
‫برای سؤال کردن از کاربر‬ ‫‪QUESTION_MESSAGE‬‬
‫اگر بخواهید که جعبه متن هیچ گونه آیکونی نداشته باشد میتوانید از متد )(‪ showConfirmDialog‬استفاده کنید‪ .‬برای استفاده‬
‫از این متد میتوانید به صورت زیر عمل نمایید‪:‬‬
‫‪JOptionPane.showConfirmDialog(null, "Hello World !", "A‬‬

‫;)‪Message",JOptionPane.YES_NO_CANCEL_OPTION‬‬
‫خروجی کد باال به صورت زیر است‪:‬‬
‫جدول زیر دکمههایی را که میتوان با این متد نمایش داد را نشان میدهد‪:‬‬
‫عضو‬ ‫دکمههایی که نمایش میدهد‬
‫‪OK_CANCEL_OPTION‬‬ ‫‪OK, Cancel‬‬
‫‪YES_NO_OPTION‬‬ ‫‪Yes, No‬‬
‫‪YES_NO_CANCEL_OPTION‬‬ ‫‪Yes, No, Cancel‬‬

131 SWING
‫ تشخیص اینکه چه دکمه ای توسط شما در جعبه‬.‫ یا عدد صحیح بر میگرداند‬int ‫ یک مقدار را از‬showConfirmDialog() ‫متد‬
3 ،3 ‫ این متد به ترتیب مقادیر‬Cancel ‫ و‬Yes ،NO ‫ به عنوان مثال با کلیک بر روی دکمههای‬.‫متن فشار داده میشود مفید است‬
.‫ را بر میگرداند‬5 ‫و‬
int result =
JOptionPane.showConfirmDialog(null, "Are You Sure ?", "Qestion",
JOptionPane.YES_NO_CANCEL_OPTION);
if (result == 0)
{
//You pressed the Yes button
}
if (result == 1)
{
//You pressed the No button
}
if (result == 2)
{
//You pressed the Cancel button
}
.‫ میتوان از مقادیری که در کد زیر آمده است هم استفاده کنید‬1 ‫ و‬5 ‫ و‬3 ‫برای تشخیص دکمه فشرده شده به جای اعداد‬
if (result == JOptionPane.YES_OPTION)
{
//You pressed the Yes button
}
if (result == JOptionPane.NO_OPTION)
{
//You pressed the No button
}
if (result == JOptionPane.CANCEL_OPTION)
{
//You pressed the Cancel button
}
‫ میباشد که از آن برای دریافت ورودی از کاربر استفاده‬showInputDialog() ‫ متد‬JOptionPane ‫یکی دیگر از متدهای کالس‬
.‫ خروجی این متد از نوع رشته است‬.‫میشود‬
String Name = JOptionPane.showInputDialog(null, "Please Enter Your Name...", "Login",

JOptionPane.INFORMATION_MESSAGE);
.‫خروجی کد باال به صورت زیر است‬

‫کنترل کننده رویداد‬

‫‪ Swing‬از مکانیزم کنترل کننده رویداد )‪ (Event Handler‬برای کنترل رویدادها که در هنگام اجرای برنامه به وقوع میپیوندند‬
‫استفاده میکند‪ .‬رویدادها رفتارهایی یا اتفاقاتی هستند که هنگام اجرای برنامه به وقوع میپیوندند‪ .‬کنترل رویداد فرایند نظارت بر‬
‫وقوع یک رویداد مشخص میباشد‪ .‬فرمهای ویندوزی از کنترل کننده رویداد برای اضافه کردن یک قابلیت و پاسخ به کاربر استفاده‬
‫میکنند‪.‬بدون کنترل کننده رویداد‪ ،‬فرمها و رابط گرافیکی تا حد زیادی بدون استفاده هستند‪ .‬کنترل رویداد در ‪ Swing‬دارای سه‬
‫جزء است‪:‬‬
‫رویداد)‪ :(Event‬یک رویداد تغییر حالت یک شیء (مثال یک جعبه متن) است‪.‬‬ ‫‪‬‬
‫منبع رویداد)‪ :(Event Source‬شیئی است که رویداد را تولید میکند (مثال دکمه ای که رویداد کلیک را تولید میکند)‪.‬‬ ‫‪‬‬
‫شنونده رویداد)‪ :(Event Listener‬اینترفیسی است که منتظر وقوع رویداد است‪.‬‬ ‫‪‬‬
‫مکانیسم کنترل رویداد در جاوا به این صورت است‪:‬‬
‫یک کالس تولید میکنیم که شنونده رویداد مربوطه را پیاده سازی میکند‪.‬‬ ‫‪.3‬‬
‫چون این کالس شنونده روی داد که یک رابط است را پیاده سازی کرده است‪ ،‬پس باید کدهای بدنه متدهای این رابط که‬ ‫‪.5‬‬
‫همان کدهایی هستند که ما میخواهیم بعد از وقوع رویداد اجرا شوند را تأمین کند‪.‬‬
‫کالسی که شنونده را پیاده سازی میکند را به کنترل وصل میکنیم‪.‬‬ ‫‪.1‬‬

131 SWING
‫ این کالسها‬.‫ اینترفیس ها و متدهای این اینترفیس ها که در کنترل رویدادها به کار برده میشوند‬،‫در جدول زیر کالسهای رویداد‬
.‫ قرار دارند‬java.awt.event ‫ و‬java.awt ،java.util ‫و اینترفیس ها در پکیجهای‬
‫متد اضافه کننده‬ ‫کالس رویداد‬ ‫متدهای شنونده رویداد‬ ‫شنونده رویداد‬
addActionListener ActionEvent actionPerformed ActionListener
addAdjustmentListener AdjustmentEvent adjustmentValueChanged AdjustmentListener
addComponentListener ComponentEvent componentHidden ComponentListener
componentMoved
componentResized
componentShown
addContainerListener ContainerEvent componentAdded ContainerListener
componentRemoved
addFocusListener FocusEvent focusGained FocusListener
focusLost
addItemListener ItemEvent itemStateChanged ItemListener
addKeyListener KeyEvent keyPressed KeyListener
keyReleased
keyTyped
addMouseListener MouseEvent mouseClicked MouseListener
mouseEntered
mouseExited
mousePressed
mouseReleased
addMouseMotionListener MouseEvent mouseDragged MouseMotionListener

‫‪mouseMoved‬‬
‫‪addTextListener‬‬ ‫‪TextEvent‬‬ ‫‪textValueChanged‬‬ ‫‪TextListener‬‬
‫‪addWindowListener‬‬ ‫‪WindowEvent‬‬ ‫‪windowActivated‬‬ ‫‪WindowListener‬‬
‫‪windowClosed‬‬
‫‪windowClosing‬‬
‫‪windowDeactivated‬‬
‫‪windowDeiconified‬‬
‫‪windowIconified‬‬
‫‪windowOpened‬‬
‫به ستون آخر سمت چپ جدول باال توجه کنید‪.‬همانطور که در ابتدای درس اشاره کردیم بعد از پیاده سازی شنونده توسط یک‬
‫کالس باید آن کالس را به کنترل مورد نظرمان وصل کنیم این کار را با متدهایی انجام میدهیم که اسم آنها با کلمه ‪ add‬شروع‬
‫میشود که در جدول باال و در ست ون (متد اضافه کننده) نام این متدها ذکر شده است‪ .‬به علت کمبود فضا در جدول باال در جداول‬
‫زیر کاربرد کالسهای رویداد و متدها (ستون دوم و سوم) آمده است‪:‬‬
‫وقتی یک رویداد اکشن اتفاق میافتد فراخوانی میشود‬ ‫‪actionPerformed‬‬
‫‪adjustmentValueChanged‬‬
‫وقت ی که یک کنترل مخفی شود فراخوانی میشود‬ ‫‪componentHidden‬‬
‫وقتی که یک کنترل حرکت کند فراخوانی میشود‬ ‫‪componentMoved‬‬
‫وقتی که اندازه یک کنترل تغییر کند فراخوانی میشود‬ ‫‪componentResized‬‬
‫وقتی که یک کنترل نمایش داده شود فراخوانی میشود‬ ‫‪componentShown‬‬
‫وقتی که یک کنترل اضافه شود فراخوانی میشود‬ ‫‪componentAdded‬‬

‫‪131‬‬ ‫‪SWING‬‬
‫وقتی که یک کنترل حذف شود فراخوانی میشود‬ ‫‪componentRemoved‬‬
‫وقتی کنترل فوکوس میگیرد فراخوانی میشود‬ ‫‪focusGained‬‬
‫وقتی کنترل فوکوس از دست میدهد فراخوانی میشود‬ ‫‪focusLost‬‬
‫وقتی آیتم انتخاب شده تغییر میکند فراخوانی میشود‬ ‫‪itemStateChanged‬‬
‫وقتی کاربر یک کلید را فشار میدهد فراخوانی میشود‬ ‫‪keyPressed‬‬
‫وقتی کاربر کلید را آزاد میکند فراخوانی میشود‬ ‫‪keyReleased‬‬
‫وقتی کاربر کلید را فشرده و سپس رها میکند فراخوانی میشود‬ ‫‪keyTyped‬‬
‫وقتی کاربر با ماوس کلیک میکند فراخوانی میشود‬ ‫‪mouseClicked‬‬
‫وقتی کاربر با ماوس روی یک کنترل میکند رود فراخوانی میشود‬ ‫‪mouseEntered‬‬
‫وقتی ماوس از محدود یک کنترل خارج میشود فراخوانی میشود‬ ‫‪mouseExited‬‬
‫وقتی کاربر دکمه ماوس را فشار میدهد فراخوانی میشود‬ ‫‪mousePressed‬‬
‫وقتی کاربر دکمه ماوس را رها میکند فراخوانی میشود‬ ‫‪mouseReleased‬‬
‫وقتی با ماوس یک کنترل را ‪ Drag‬میکنید فراخوانی میشود‬ ‫‪mouseDragged‬‬
‫وقتی نشانگر ماوس جابجا شود فراخوانی میشود‬ ‫‪mouseMoved‬‬
‫وقتی مقدار متن کنترل تغییر کند فراخوانی میشود‬ ‫‪textValueChanged‬‬
‫هنگام فعال شدن پنجره فراخوانی میشود‪.‬‬ ‫‪windowActivated‬‬
‫هنگام بسته شدن پنجره فراخوانی میشود‬ ‫‪windowClosed‬‬
‫وقتی پنجره در حال بسته شدن است فراخوانی میشود‬ ‫‪windowClosing‬‬
‫وقتی پنجره غیر فعال میشود فراخوانی میشود‬ ‫‪windowDeactivated‬‬

‫وقتی پنجره از حال آیکون به حالت عادی تغییر میکند فراخوانی میشود‬ ‫‪windowDeiconified‬‬
‫وقتی پنرجه مینیمایز میشود فراخوانی میشود‬ ‫‪windowIconified‬‬
‫وقتی پنجره باز میشود فراخوانی میشود‬ ‫‪windowOpened‬‬
‫توضیحات‬ ‫کالس رویداد‬
‫وقتی تولید میشود که بر روی یک دکمه کلیک‪ ،‬یک آیتم انتخاب و یا بر روی لیست آیتم کلیک شود‪.‬‬ ‫‪ActionEvent‬‬
‫وقتی تولید میشود که ماوس ‪ Drag‬یا کلیک شود و یا از یک کنترل خارج و یا وارد یک کنترل شود‪.‬‬ ‫‪MouseEvent‬‬
‫وقتی تولید میشود که یک دکمه از صفحه کلید توسط کاربر فشرده شود‪.‬‬ ‫‪KeyEvent‬‬
‫وقتی تولید میشود که ‪ check-box‬یا ‪ list item‬کلیک شود‪.‬‬ ‫‪ItemEvent‬‬
‫وقتی تولید میشود که مقدار ‪ textarea‬یا ‪ textfield‬تغییر کند‪.‬‬ ‫‪TextEvent‬‬
‫وقتی تولید میشود کهدکمه وسط ماوس حرکت داده شود‪.‬‬ ‫‪MouseWheelEvent‬‬
‫وقتی تولید میشود که پنجره فعال‪ ،‬غیرفعال‪ ،‬بسته و … شود‪.‬‬ ‫‪WindowEvent‬‬
‫وقتی تولید میشود که یک کنترل مخفی شود‪ ،‬حرکت کند‪ ،‬اندازهاش تغییر کند‪.‬‬ ‫‪ComponentEvent‬‬
‫وقتی تولید میشود که یک کنترل به پنجره اضافه و یا از آن حذف شود‪.‬‬ ‫‪ContainerEvent‬‬
‫وقتی تولید میشود که اسکرول تغییر کند‪.‬‬ ‫‪AdjustmentEvent‬‬
‫وقتی تولید میشود که یک کنترل فوکوس گرفته و یا فوکوس خود را از دست بدهد‪.‬‬ ‫‪FocusEvent‬‬
‫برای درک بهتر کنترل رویداد )‪ (Event handling‬به یک مثال توجه کنید‪ .‬فرض کنید که میخواهیم وقتی بر روی یک دکمه‬
‫کلیک شد یک پیام نمایش داده شود‪ .‬برنامه ‪ NotePad‬را باز کرده و کدهای زیر را در داخل آن نوشته و سپس با نام‬
‫‪ MyFirstProgram‬ذخیره کنید‪:‬‬
‫‪136‬‬ ‫‪SWING‬‬

‫‪2‬‬
‫‪3‬‬ ‫;*‪import javax.swing.‬‬
‫‪4‬‬ ‫;*‪import java.awt.event.‬‬
‫‪5‬‬
‫‪7‬‬ ‫{‬
‫‪9‬‬ ‫{‬
‫‪10‬‬ ‫;)"‪JFrame frame1 = new JFrame("Event Handling in JAVA‬‬
‫‪11‬‬ ‫;)‪frame1.setSize(356 , 263‬‬
‫‪12‬‬ ‫;)‪frame1.setVisible(true‬‬
‫‪13‬‬
‫‪14‬‬ ‫;)"!‪JButton button1 = new JButton("Click Me‬‬
‫‪15‬‬ ‫;)‪frame1.add(button1‬‬
‫‪16‬‬
‫‪17‬‬ ‫‪class ListenToClick implements ActionListener‬‬ ‫‪//Step 1‬‬
‫‪18‬‬ ‫{‬
‫‪20‬‬ ‫)‪public void actionPerformed(ActionEvent e‬‬
‫‪21‬‬ ‫{‬
‫‪22‬‬ ‫;)"!‪JOptionPane.showMessageDialog(null, "Hello world‬‬ ‫‪//Step 2‬‬
‫‪23‬‬ ‫}‬
‫‪24‬‬ ‫}‬
‫‪25‬‬
‫‪26‬‬ ‫;))(‪button1.addActionListener(new ListenToClick‬‬ ‫‪//Step 3‬‬
‫‪27‬‬ ‫}‬
‫‪28‬‬ ‫}‬
‫در مثال باال چون ما قرار است از کنترلهای ‪ Swing‬استفاده و همچنین رویدادها را کنترل کنیم ابتدا کالسها و پکیجهای مربوطه‬
‫را در خطوط ‪ 3‬و ‪ 5‬اضافه میکنیم‪ .‬سپس در خطوط ‪ 33-31‬یک فریم ایجاد و یک دکمه به آن اضافه میکنیم‪ .‬در درسهای بعد در‬
‫مورد این دو کنترل و همچنین این کدها بیشتر توضیح میدهیم ‪.‬حال نوبت به سه مرحله ای میرسد که در ابتدای درس توضیح‬
‫دادیم‪:‬‬
‫در خطوط ‪ 31-53‬یک کالس به نام ‪ ListenToClick‬ایجاد میکنیم و به وسیله آن شنونده ‪ ActionListener‬را پیاده‬ ‫‪.3‬‬
‫سازی میکنیم ‪.‬‬
‫شنونده ‪ ActionListener‬دارای یک متد به نام )(‪ actionPerformed‬است‪ .‬این متد باید توسط کالس‬ ‫‪.5‬‬
‫‪ ListenToClick‬پیاده سازی )‪ (Override‬شود‪ .‬پس باید کدهایی که میخواهیم بعد از کلیک بر روی دکمه یعنی‬
‫رویدادمان اجرا شوند را در داخل بدنه متد )(‪ actionPerformed‬مینویسیم (خط ‪.)55‬‬
‫در خط ‪ 51‬با استفاده از متد )(‪ addActionListener‬کالس ‪ ListenToClick‬را به دکمه وصل میکنیم‪.‬‬ ‫‪.1‬‬
‫حال برنامه را اجرا کرده و با کلیک بر روی دکمه نتیجه را مشاهده نمایید‪:‬‬
:‫ کد باال را به دو صورت زیر هم میتوان نوشت‬31-51 ‫خطوط‬
ActionListener ListenToClick = new ActionListener() //Step 1

{
@Override
public void actionPerformed(ActionEvent e)
{
JOptionPane.showMessageDialog(null, "Hello world!"); //Step 2
}
};
button1.addActionListener(ListenToClick); //Step 3
:‫یا به صورت خالصه تر زیر‬
button1.addActionListener(new ActionListener() //Step 1 , Step3

{
@Override
public void actionPerformed(ActionEvent e)
{
JOptionPane.showMessageDialog(null, "Hello world!"); //Step 2
}
});
‫‪153‬‬ ‫‪SWING‬‬
‫در آخر این نکته را یادآور میشوم که ما در مثال باال برخی از موارد مانند تعیین اندازه و محل قرار گیری دکمه و … را توضیح ندادهایم‬
‫تا شما اصل مطلب که همان کنترل رویداد است را یاد بگیرید‪ .‬در درسهای آینده در مورد کنترلهای ‪ Swing‬بیشتر توضیح‬
‫میدهیم‪.‬‬
‫کنترلها‬
‫کنترلها اجزای بصری هستند که به وسیلهی آنها محیطهای گرافیکی )‪ (GUI‬ساخته میشود‪ .‬هرچیزی که شما در یک محیط‬
‫گرافیکی میبینید یک کنترل است‪ ،‬حتی ‪ Frame‬نیز یک کنترل است‪ .‬کنترلها در دستههای مختلفی در قسمت نوار ابزار قرار دارند‬
‫که در محیط ‪ Netbeans‬و در قسمت ‪ Palette‬قائل مشاهده هستند‪:‬‬
‫بیشتر کنترلها از کالس ‪ JComponent‬ارث بری میکنند که دارای خواص‪ ،‬متدها و رویدادهای متفاوتی برای آنها میباشد‪.‬‬
‫خواص کنترلها‬
‫در قسمت زیر بعضی از خاصیتهای مفید کالس ‪ JComponent‬را مشاهده میکنید‪.‬‬
‫توضیح‬ ‫خاصیت‬
‫نامی که کنترل به وسیله آن قابل دسترسی است‪.‬‬ ‫‪accessible name‬‬
‫نام والد کنترل را نشان میدهد‪.‬‬ ‫‪accessible parent‬‬
‫رنگ قسمت زمینهی کنترل را مشخص میکند‪.‬‬ ‫‪background‬‬
‫حاشیه کنترل را مشخص میکند‪.‬‬ ‫‪border‬‬
‫مشخص میکند که آیا کنترل رنگ پس زمینه داشته باشد یا ‪ transparent‬باشد‪.‬‬ ‫‪contentareafilled‬‬
‫نوع نشانگر ماوس را مشخص میکند‬ ‫‪cursor‬‬
‫آیکون کنترل را زمانی که کنترل غیر فعال است تعیین میکند‪.‬‬ ‫‪disabledicon‬‬
‫این قسمت مشخص میکند که کنترل فعال است یا نه‪ .‬اگر مقدار آن ‪ False‬باشد کنترل غیرفعال میشود‪.‬‬ ‫‪enabled‬‬
‫رنگ پیش زمینهی کنترل و همچنین رنگ قلم کنترل را مشخص میکند‪.‬‬ ‫‪foreground‬‬
‫مشخص میکند که یک کنترل میتواند توسط دکمهی ‪ Tab‬مورد دستیابی قرار گیرد یا خیر‪.‬‬ ‫‪focusable‬‬
‫نوع و اندازه فونت کنترل را مشخص میکند‪.‬‬ ‫‪font‬‬
‫حداکثر اندازه ای که کنترل میتواند داشته باشد را مشخص میکند‪.‬‬ ‫‪maximumsize‬‬
‫فاصلهی بین لبههای کنترل مربوطه و لبهی کنترل دیگر را مشخص میکند‪.‬‬ ‫‪margin‬‬
‫کمترین سایز کنترل را مشخص میکند‪.‬‬ ‫‪minimumsize‬‬
‫نام کنترل را مشخص میکند ‪.‬این نام برای اشاره به کنترل در زمان کد نویسی استفاده میشود‪.‬‬ ‫‪name‬‬
‫والد کنترل را مشخص میکند‪.‬‬ ‫‪parent‬‬
‫متنی که در داخل کنترل قرار میگیرد‪.‬‬ ‫‪text‬‬
‫عرض کنترل براساس پیکسل را مشخص میکند‪.‬‬ ‫‪Horizontal Size‬‬
‫ارتفاع کنترل براساس پیکسل را مشخص میکند‪.‬‬ ‫‪Vertical Size‬‬

‫‪151‬‬ ‫‪SWING‬‬
‫مهمترین خاصیت در جدول باال خاصیت ‪ name‬است‪ .‬این خاصیت به شما اجازه میدهد که از آن نام برای ارجاع به کنترل در‬
‫قسمت کد نویسی استفاده کنید‪ .‬در این قسمت به بحث در مورد بعضی از خاصیت هایی که در بیشتر کنترلها وجود دارند‬
‫میپردازیم‪.‬‬
‫رویدادهای کنترل‬
‫در جدول پایین شما برخی از رویدادهای مفید که بین بیشتر کنترلهای رایج هستند را مشاهده میکنید‪.‬‬
‫توضیح‬ ‫رویداد‬
‫این رویداد وقتی رخ میدهد که بر روی کنترل با دکمهی سمت چپ ماوس کلیک شود‪.‬‬ ‫‪actionPerformed‬‬
‫این رویداد وقتی رخ میدهد که اندازه کنترل تغییر کند‪.‬‬ ‫‪componentResized‬‬
‫این رویداد وقتی رخ میدهد که کنترل حرکت داده شود‪.‬‬ ‫‪componentMoved‬‬
‫زمانی که عملیات ‪ Drag & Drop‬بر روی کنترل انجام میشود این رویداد رخ میدهد‪.‬‬ ‫‪mouseDragged‬‬
‫زمانی رخ میدهد که ‪ Focus‬روی کنترل قرار گیرد‪.‬‬ ‫‪focusGained‬‬
‫این رویداد زمانی رخ میدهد که ‪ focus‬بر روی کنترل باشد و کلیدی از روی صفحه کلید فشرده و رها‬ ‫‪keyPressed‬‬
‫شود‪.‬‬
‫این رویداد زمانی رخ میدهد که ‪ focus‬بر روی کنترل باشد و کلیدی که از روی صفحه کلید فشرده شده‪،‬‬ ‫‪keyReleased‬‬
‫رها شود‪.‬این رویداد بعد از دو رویداد قبلی رخ میدهد‪.‬‬
‫وقتی که کنترل ‪ Focus‬خود را از دست بدهد این رویداد رخ میدهد‪.‬‬ ‫‪focusLost‬‬
‫یک حالت پیشرفته تر از رویداد ‪ actionPerformed‬است‪.‬کلیک کردن میتواند شامل فشردن کلیدهای‬ ‫‪mouseClicked‬‬
‫صفحهی کلید نیز باشد ‪ .‬ولی اگر شما نیاز به اطالعاتی نظیر ‪ :‬تعداد کلیک بر روی کنترل‪ ،‬چرخیدن دکمه‬
‫چرخندهی ماوس و … باشید باید از این رویداد استفاده کنید‬
‫این رویداد زمانی رخ میدهد که دکمه ای از ماوس در داخل کنترل پایین نگه داشته شود‪.‬‬ ‫‪mousePressed‬‬
‫زمانی که مکان نما به یک کنترل وارد میشود این رویداد رخ میدهد‪.‬‬ ‫‪mouseEntered‬‬
‫این رویداد زمانی رخ میدهد که مکان نما کنترل را ترک کند‪.‬‬ ‫‪mouseExited‬‬
‫این رویداد زمانی رخ میدهد که مکان نما وقتی در داخل محدودهی کنترل است حرکت کند‪.‬‬ ‫‪mouseMoved‬‬
‫این رویداد زمانی رخ میدهد که دکمه ای از ماوس را که قبال فشردهایم‪ ،‬در داخل کنترل رها کنیم‪.‬‬ ‫‪mouseReleased‬‬
‫این رویداد زمانی رخ میدهد که بر روی کنترل ‪ Focus‬باشد و دکمه چرخنده ماوس حرکت کند‪.‬‬ ‫‪mouseWheelMoved‬‬
‫در مورد بیشتر رویدادهای باال در بخشهای آینده صحبت خواهیم کرد‪.‬‬
‫متدهای کنترل‬
‫به استثنای ‪ container‬های سطح باال‪ ،‬همه کنترلهای ‪ Swing‬ی که نام آنها با حرف ‪ J‬شروع میشود از کالس ‪JComponent‬‬
‫ارث بری میکنند‪ .‬به عنوان مثال ‪ JButton ،JScrollPane ،JPanel‬و ‪ .JTable‬به این نکته توجه کنید که ‪ JFrame‬و ‪JDialog‬‬
‫از ‪ container‬های سطح باال ارث بری میکنند‪ .‬کالس ‪ JComponent‬از کالس ‪ Container‬و این کالس هم به نوبه خود از‬
‫کالس ‪ Component‬مشتق میشود‪ .‬از آنجاییکه کالس ‪ JComponent‬کالس پایه کنترلهای ‪ Swing‬است در نتیجه کنترلهای‬
‫‪Swing‬از متدهای این کالس استفاده میکنند‪ .‬در جدول زیر متدهای پر کاربرد این کالس ذکر شده است‪:‬‬
‫برای به دست آوردن و تعیین حاشیه )‪ (Border‬کنترل به کار میرود‪.‬‬ ‫)(‪setBorder‬‬

‫)(‪getBorder‬‬
‫برای تعیین رنگ فونت و پس زمینه کنترل به کار میرود‪.‬‬ ‫)(‪setForeground‬‬

‫)(‪setBackground‬‬
‫برای به دست آوردن رنگ فونت و پس زمینه کنترل به کار میرود‪.‬‬ ‫)(‪getForeground‬‬
‫)(‪getBackground‬‬
‫برای به دست آوردن و تعیین فونت کنترل به کار میرود ‪ .‬اگر کنترل فونت نداشته باشد از فونت کنترل‬ ‫)(‪setFont‬‬
‫)(‪getFont‬‬
‫والد آن استفاده میشود‪.‬‬
‫برای به دست آوردن و تعیین نشانگر ماوس زمانیکه ماوس بر روی کنترل میرود به کار میرود‪.‬‬ ‫)(‪setCursor‬‬
‫)(‪getCursor‬‬
‫‪151‬‬ ‫‪SWING‬‬
‫برای نمایش یک متن در ‪ tooltip‬کنترل به کار میرود‪.‬‬ ‫)(‪setToolTipText‬‬
‫برای به دست آوردن و تعیین نام کنترل به کار میرود‪.‬‬ ‫)(‪setName‬‬

‫)(‪getName‬‬
‫تشخیص میدهد که آیا کنترل در صفحه نمایش داده شده است یا نه؟ این بدین معناست که‬ ‫)(‪isShowing‬‬
‫خاصیت ‪ visible‬کنترل و والد آن باید ‪ true‬باشد‪.‬‬
‫برای تشخیص و تعیین فعال بودن کنترل به کار میرود‪.‬‬ ‫)(‪setEnabled‬‬

‫)(‪isEnabled‬‬
‫برای تشخیص و تعیین نمایش و عدم نمایش کنترل به کار میرود‪.‬‬ ‫)(‪setVisible‬‬
‫)(‪isVisible‬‬
‫برای اضافه کردن یک کنترل به ‪ container‬به کار میرود‪.‬‬ ‫)(‪add‬‬
‫برای حذف یکی از یا همه کنترلهای یک ‪ container‬به کار میرود‪.‬‬ ‫)(‪remove‬‬

‫)(‪removeAll‬‬
‫برای به دست آوردن باالترین یک کنترل به کار میرود‪.‬‬ ‫)(‪getTopLevelAncestor‬‬
‫برای به دست آوردن اولین یک کنترل به کار میرود‪.‬‬ ‫)(‪getParent‬‬
‫برای به دست آوردن تعداد کنترلهای یک ‪ container‬به کار میرود‪.‬‬ ‫)(‪getComponentCount‬‬
‫برای به دست آوردن یکی از یا همه کنترلهای یک به کار میرود‪.‬‬ ‫)(‪getComponent‬‬

‫)(‪getComponents‬‬
‫بعد سوم )‪ (z-order‬یک کنترل در داخل یک را بر میگرداند‪ .‬باالترین کنترل دارای بعد سوم‬ ‫)(‪getComponentZOrder‬‬
‫کوچکتر (عدد کمتر) و پایینترین کنترل دارای بعد سوم بزرگتر ی است‪.‬‬
‫برای تعیین بهترین اندازه کنترل در مقیاس پیکسل به کار میرود‪ .‬اندازه کنترل نباید بزرگتر از‬ ‫)(‪setPreferredSize‬‬
‫)(‪setMaximumSize‬‬
‫‪ maximum size‬و یا کوچکتر از ‪ minimum size‬باشد‪.‬‬
‫)(‪setMinimumSize‬‬
‫برای به دست آوردن ‪ maximum size‬و ‪ minimum size‬کنترل در مقیاس پیکسل به کار‬ ‫)(‪getPreferredSize‬‬
‫)(‪getMaximumSize‬‬
‫میرود‪.‬‬
‫)(‪getMinimumSize‬‬
‫برای تعیین تراز بندی کنترل نسبت به کنترلهای دیگر به کار میرود‪ .‬مقداری کهایم متد میگیرد عددی‬ ‫)(‪setAlignmentX‬‬
‫)(‪setAlignmentY‬‬
‫بین ‪ 3‬و ‪ 3‬است‪.‬‬
‫برای به دست آوردن تراز بندی کنترل نسبت به کنترلهای دیگر به کار میرود‪.‬‬ ‫)(‪getAlignmentX‬‬
‫)(‪getAlignmentY‬‬
‫برای به دست آوردن عرض و ارتفاع یک کنترل بر حسب پیکسل به کار میرود‪.‬‬ ‫)(‪getWidth‬‬
‫)(‪getHeight‬‬
‫برای به دست آوردن اندازه کنترل بر حسب پیکسل به کار میرود‪.‬‬ ‫)(‪getSize‬‬
‫)(‪getSize‬‬
‫برای به دست آوردن نقطه ‪ x‬و ‪ y‬کنترل نسبت به گوشه باال و سمت چپ کنترل والد آن بر حسب‬ ‫)(‪getX‬‬
‫)(‪getY‬‬
‫پیکسل به کار میرود‪.‬‬
‫برای به دست آوردن محدوده یک کنترل (عرض و ارتفاع) بر حسب پیکسل به کار میرود‪.‬‬ ‫)(‪getBounds‬‬
‫برای به دست آوردن مکان یک کنترل نسبت به گوشه باال سمت چپ کنتر ل والد آن بر حسب پیکسل‬ ‫)(‪getLocation‬‬
‫به کار میرود‪.‬‬
‫مکان نسبی را نسبت به گوشه باال سمت چپ صفحه نمایش بر میگرداند‪.‬‬ ‫)(‪getLocationOnScreen‬‬
‫اندازه حاشیه کنترل را بر میگرداند‪.‬‬ ‫)(‪getInsets‬‬
‫مکان کنترل را نسب به گوشه باال سمت چپ کنترل والد تعیین میکند‪.‬‬ ‫)‪setLocation(Point‬‬
‫اندازه کنترل را بر مبنای پیکسل تعیین میکند‪.‬‬ ‫)(‪setSize‬‬
‫اندازه و مکان نسبی کنترل را نسبت به گوشه باال سمت چپ کنترل والدش مشخص میکند‪.‬‬ ‫)(‪setBounds‬‬
‫به این نکته توجه کنید که این کالس دارای متدهای بیشتری است که در این درس به این تعداد بسنده کردهایم‪.‬در درسهای آینده‬
‫با کاربرد این متدها بیشتر آشنا میشوید‪.‬‬

‫‪151‬‬ ‫‪SWING‬‬
‫کار با برخی از متدها و خاصیتهای کنترلها‬
‫در این درس میخواهیم شما را با برخی از متدها و خاصیتهایی که در درس قبل نام بردیم آشنا کنیم‪ .‬ولی ابتدا باید یک نکته ای‬
‫را یادآور شویم که چون کنترلها همه کالس هستند باید برای استفاده از هر یک از این کالسها باید یک نمونه از آنها ایجاد کرد‪.‬‬
‫در این درس ما به سه کالس برای توضیح بیشتر خاصیتها و متدها نیاز داریم که عبارتاند از ‪ JButton ،JFrame‬و ‪ .JPanel‬در‬
‫مورد این سه کنترل در درسهای آینده بیشتر توضیح میدهیم‪ .‬فقط در این درس میخواهیم یک دکمه را به پنل و پنل را فریم‬
‫اضافه کنیم و سپس خاصیتها و متدهای پر کاربرد را تست کنیم‪ .‬برای شروع برنامه ‪ NotePad‬را باز کرده و کدهای زیر را در داخل‬
‫آن بنویسید‪:‬‬

‫‪2‬‬
‫‪3‬‬ ‫;*‪import java.awt.‬‬
‫‪5‬‬
‫‪7‬‬ ‫{‬
‫‪9‬‬ ‫{‬
‫‪10‬‬ ‫;)"‪JFrame frame1 = new JFrame("Properties and Methods Demo‬‬
‫‪11‬‬ ‫;)(‪JPanel panel1 = new JPanel‬‬
‫‪12‬‬ ‫;)"‪JButton button1 = new JButton("Button1‬‬
‫‪13‬‬
‫‪14‬‬ ‫;)‪panel1.add(button1‬‬
‫‪15‬‬ ‫;)‪frame1.add(panel1‬‬
‫‪16‬‬
‫‪17‬‬ ‫;)‪frame1.setSize(330 , 250‬‬
‫‪19‬‬ ‫}‬
‫‪20‬‬ ‫}‬
‫در همین کد باال کاربرد چندین متد را میتوان فهمید‪ .‬در خطوط ‪ 33-35‬یک ‪ ،Frame‬یک ‪ Panel‬و دو ‪ Button‬ایجاد کردهایم‪ .‬در‬
‫خط ‪ 33‬دکمه را به پنل و در خط ‪ 31‬هم ‪ Panel‬را به ‪ Frame‬اضافه کردهایم‪ .‬این کار را با استفاده از متد )(‪ add‬انجام دادهایم‪.‬‬
‫پس فعال با کاربرد متد )(‪ add‬آشنا شدید‪ .‬در خط ‪ 31‬با استفاده از متد )(‪ setSize‬یک اندازه برای ‪ Frame‬تعیین کرده و در‬
‫‪ 30‬با استفاده از متد )(‪ setVisible‬فریم را نمایش میدهیم‪ .‬با اجرای برنامه باال پنجره ای به صورت زیر ایجاد میشود‪:‬‬
‫به این نکته توجه کنید که تمام کدهای پایین را میتوانید در خط ‪ 31‬کد باال نوشته و بعد از تست و مشاهده نتیجه پاک کرده و کد‬
‫بعدی را بنویسید‪ .‬فرض کنید که میخواهیم رنگ پس زمینه ‪ Panel‬را تغییر دهیم‪ .‬برای این کار از متد )(‪setBackground‬‬
‫استفاده میکنیم‪ .‬این متد برای تغییر رنگ پس زمینه‪ ،‬یک شیء از کالس ‪ Color‬با عنوان پارامتر قبول میکند‪ .‬در خط ‪ 31‬کد زیر‬
‫را بنویسید‪:‬‬
‫;))‪panel1.setBackground(Color.getHSBColor(10, 20, 50‬‬
‫اعدادی که در داخل متد )(‪ getHSBColor‬نوشته شدهاند میتوانند اعدادی بین ‪ 3-511‬باشند‪ .‬برنامه را اجرا و نتیجه را مشاهده‬
‫کنید‪:‬‬
‫البته به جای کد باال میتوانید از نام رنگها هم به صورت زیر استفاده کنید‪:‬‬
‫‪156‬‬ ‫‪SWING‬‬
‫;)‪panel1.setBackground(Color.BLUE‬‬
‫حال فرض کنید که میخواهیم رنگ نوشته ‪ Button1‬را به قرمز تغییر دهیم ‪.‬برای این کار از متد )(‪ setForeground‬استفاده‬
‫میکنیم‪ .‬برای این کار به صورت زیر عمل میکنیم‪:‬‬
‫;)‪button1.setForeground(Color.red‬‬
‫کد را اجرا و نتیجه را مشاهده کنید‪:‬‬
‫برای تغییر فونت دکمه هم میتوان از متد )(‪ setFont‬و یک شیء از کالس ‪ Font‬استفاده کرد‪ .‬برای این کار به صورت زیر عمل‬
‫میکنیم‪:‬‬
‫;))‪button1.setFont(new Font("Times New Roman", Font.ITALIC , 20‬‬
‫همانطور که مشاهده میکنید شیء ‪ Font‬سه پارامتر میگیرد که اولی نام‪ ،‬دومی حالت و سومی اندازه فونت را مشخص میکند‪.‬‬
‫برنامه را اجرا و نتیجه را مشاهده کنید‪:‬‬

‫برای تغییر نام یا اختصاص یک نام به یک کنترل هم میتوان از متد )(‪ setText‬استفاده کرد‪ .‬فرض کنید که میخواهیم نام‬
‫دکمه ‪ button2‬را به ‪ SecondButton‬تغییر بدم‪ .‬برای این کار به صورت زیر عمل میکنیم‪:‬‬
‫;)"‪button2.setText("Second Button‬‬
‫برای غیر فعال کردن یک کنترل هم از متد )(‪ setEnabled‬استفاده میشود‪ .‬فرض کنید که میخواهیم نام دکمه ‪ button1‬را غیر‬
‫فعال کنیم‪ .‬برای این کار کد زیر را بنویسید‪:‬‬
‫;)‪button1.setEnabled(false‬‬

‫‪113‬‬ ‫‪SWING‬‬
‫برای تغییر نشانگر ماوس هم میتوان از متد )(‪ setCursor‬به همراه یک شیء از کالس ‪ Cursor‬استفاده کرد‪ .‬این کالس دارای‬
‫ثابتهایی هست که در زیر یک مثال از آنها را مشاهده میکنید‪:‬‬
‫;))‪button1.setCursor(new Cursor(Cursor.WAIT_CURSOR‬‬
‫حال اگر برنامه را اجرا کرده و بر روی دکمه با ماوس توقف کنید‪ ،‬مشاهده میکنید که شکل نشانگر ماوس تغییر میکند‪ .‬برای‬
‫اختصاص آیکون به یک کنترل مثال دکمه هم از کالس ‪ ImageIcon‬استفاده میشود‪ .‬من از قبل یک آیکون را در داخل پوشه برنامه‬
‫قرار دادهام‪ .‬برای اختصاص این آیکون به دکمه بعد از خط ‪ 6‬کد زیر را بنویسید‪:‬‬
‫;)‪ImageIcon icon = new ImageIcon("C:/FrameDemo/icon.gif", null‬‬
‫من در کد باال از آدرس مطلق آیکون استفاده کردهام و ممکن است که این آدرس برای شما به نحو دیگری باشد‪ .‬سپس سازنده‬
‫کالس ‪ Button‬را به صورت زیر تغییر دهید‪:‬‬
‫;)‪JButton button1 = new JButton("Button1", icon‬‬

‫حال اگر بخواهید آیکون در سمت راست و متن در سپ چپ باشد میتوانید از متد )(‪ setHorizontalTextPosition‬و رابط‬
‫‪ SwingConstants‬استفاده کنید‪ .‬این رابط مقادیر مختلفی برای تراز بندی دارد که یکی از آنها ‪ LEFT‬است و متن را در سمت‬
‫چپ آیکون قرار میدهد‪ .‬کد زیر را بعد از ایجاد دکمه بنویسید‪:‬‬
‫;)‪button1.setHorizontalTextPosition(SwingConstants.LEFT‬‬
‫برنامه را اجرا کنید‪:‬‬
‫برای ایجاد فاصله بین متن و آیکون هم از متد )(‪ setIconTextGap‬استفاده میشود‪:‬‬
‫;)‪button1.setIconTextGap(50‬‬
‫کد باال بین متن و آیکون ‪ 13‬پیکسل فاصله میاندازد‪:‬‬

‫‪111‬‬ ‫‪SWING‬‬
‫برای تغییر اندازه کنترل از متد )(‪ setSize‬استفاده میشود ‪ .‬با فرض اینکه همان کد ابتدای درس را در اختیار دارید بعد از خط‬
‫‪ 35‬کدهای زیر را بنویسید ‪:‬‬
‫;)‪panel1.setLayout(null‬‬
‫;)‪button1.setSize(200,150‬‬
‫در مورد متد )(‪ setLayout‬الزم نیست چیزی بدانید چون در مورد آن در قسمت کار با الیهها توضیح خواهیم داد‪ .‬فقط در این‬
‫حد بدانید که پارامتر این متد باید ‪ null‬باشد تا عملکرد متد )(‪ setSize‬قابل مشاهده باشد‪ .‬حال برنامه را اجرا و نتیجه را‬
‫مشاهده کنید‪:‬‬
‫مشاهده میکنید که دکمه نسبت به گوشه باال و سمت چپ کنترل تراز میشود‪ .‬حال اگر بخواهیم دکمه را به طرف چپ یا راست‬
‫بکشیم باید از متد )(‪ setBounds‬استفاده کنیم‪:‬‬
‫;)‪button1.setBounds(60,30,200,150‬‬
‫دو عدد اول به ترتیب مختصات ‪ x‬و ‪ y‬نسبت به گوشه باال و سمت چپ ‪ Panel‬و دو عدد بعدی هم عرض و ارتفاع کنترل را‬
‫مشخص میکنند‪:‬‬
‫نامگذاری کنترلها‬
‫همیشه کنترلها را نامگذاری کنید‪ .‬ما از خاصیت ‪ name‬برای نامگذاری کنترلها استفاده میکنیم‪ .‬نامگذاری کنترلها از قواعد‬
‫نامگذاری متغیرها استفاده میکند‪ ،‬برای مثال فاصلهها‪ ،‬کاراکترهای ویژه‪ ،‬و استفاده از کلمات کلیدی در نامگذاری کنترلها نیز‬
‫ممنوع است‪ .‬یک سری قرار داد در نامگذاری کنترلها وجود دارد که در ادامه به آنها اشاره میکنیم‪.‬‬
‫شما میتوانید بسته به نوع استفاده ای که از کنترل میکنید آنرا نامگذاری نمایید‪ .‬برای مثال‪ ،‬وقتی که قرار است در داخل یک‬
‫تکست باکس نام یک شخص یا کاربر وارد شود میتوانید نام آن تکست باکس را برای خوانایی بیشتر ‪ firstname‬قرار دهید‪.‬اما‬
‫در نامگذاری کنترلها بهتر است که نام واقعی آن کنترل قبل از نامی که برای آن انتخاب کردهایم بیاید‪ .‬برای مثال به جای‬
‫‪111‬‬ ‫‪SWING‬‬
‫‪ firstname‬در نامگذاری ‪ ،Text Field‬میتوانید از ‪ TextFieldFirstName‬استفاده کنید‪.‬با توجه به این قرار دادها‪ ،‬ما‬
‫میتوانیم در داخل ‪ Intellisense‬ی که با آن کار میکنیم هر کنترلی را شناسایی کنیم‪.‬‬
‫تکنیک دیگری که برای نامگذاری کنترلها به کار میرود‪ ،‬خالصه کردن نام آنها است‪.‬برای مثال‪ ،‬به جای استفاده از کلمهی‬
‫‪ ،TextFieldFirstName‬شما میتوانید از ‪ txtFirstName‬استفاده کنید‪ .‬کلمهی ‪ txt‬فرم کوتاه شدهی کلمهی ‪Text Field‬‬
‫است‪.‬تعداد زیادی کلمهی کوتاه شده برای هر کنترل وجود دارد و شما حتی میتوانید از کلمهی کوتاه شده ای که خود برای آن کنترل‬
‫انتخاب کردهاید استفاده کنید‪.‬البته این باید گویا باشد ‪ .‬به طوری که برای کسانی که به کد شما نگاه میکنند واضح باشد‪.‬‬
‫تکنیک دیگری که برای نامگذاری کنترلها بکار میرود جابجا کردن نام اصلی کنترل با نامی که ما برای آن انتخاب کردهایم و همچنین‬
‫استفاده از روش کوهان شتری )‪ (Camel case‬است‪.‬برای مثال یک تکست باکس داریم که نام کاربر یا شخصی را از ورودی‬
‫میگیرد‪ ،‬میتوانید آنرا به صورت ‪ firstNameTextField‬نامگذاری کنید و یا یک دکمه دارید که عملیات محاسباتی را انجام‬
‫میدهد‪ ،‬میتوانید نام آنرا ‪ calculateButton‬بگذارید‪.‬‬
‫در درسهای آینده از تکنیک سوم )‪ (Camel Case‬استفاده میکنیم‪ .‬نیازی به این نیست که شما تمامی کلمات اختصاری کنترلها‬
‫را حفظ کنید‪.‬وقتی که شما یک کنترل را ایجاد میکنید‪ ،‬تنها کافیست عدد پسوندی آنرا حذف کنید و به جای آن‪ ،‬نامی را با توجه‬
‫به کاربرد کنترل به آن اضافه کنید‪.‬وقتی که شما در حال تایپ کردن هستید و قصد پیدا کردن کنترل خاصی را دارید کافیست براحتی‬
‫نام کنترل را تایپ کرده تا پنجرهی ‪ intellisence‬نام آن کنترل و تمامی کنترلهای مشابه آنرا را برای شما نمایش دهد‪.‬برای‬
‫مثال‪ ،‬یک تکست باکس و تمامی کنترلهای تکست باکس در ‪ intellisence‬برنامه نمایش داده میشوند‪ ،‬فقط قسمتی که‬
‫مربوط به نامی که شما برای آن کنترل انتخاب میکنید ممکن است طوالنی باشد‪ ،‬که شما با توجه به قواعدی که پیشتر ذکر شد‬
‫میتوانید نسبت به نامگذاری و کوتاه کردن نام کنترلها اقدام کنید‪ .‬در زیر مثالهایی از نامگذاری کنترلها بسته به کاربرد آنها ذکر‬
‫کاربرد‬ ‫نام پیشنهادی‬
‫کلیدی که برای نشان دادن یک پیغام به کار میرود ‪.‬‬ ‫‪buttonConfirm, confirmButton, btnConfirm‬‬
‫یک تکست باکس که یک ایمیل را از کاربر دریافت میکند ‪.‬‬ ‫‪textFieldAddress, addressTextBox, txtAddress‬‬
‫یک فرم که اطالعات شخصی را از کاربر دریافت میکند ‪.‬‬ ‫‪formPersonalInformation,‬‬

‫‪personalInformationForm,‬‬
‫‪frmPersonalInformation‬‬
‫یک ‪ ComboBox‬که لیستی از محصوالت را نمایش میدهد ‪.‬‬ ‫‪comboBoxProducts, productsComboBox,‬‬

‫‪cmbProducts‬‬
‫یک ‪ RadioButton‬که نشان دهندهی مذکر بودن یک کاربر‬ ‫‪radioButtonMale, maleRadioButton, radMale‬‬
‫است ‪.‬‬
‫یک ‪ MenuItem‬برای ذخیره کردن یک فایل ‪.‬‬ ‫‪menuItemSave, saveMenuItem, mnuSave‬‬
‫یک ‪ CheckBox‬برای فرستادن یک نامه ‪.‬‬ ‫‪checkBoxSubscribe, subscribeCheckBox,‬‬

‫‪chkSubscribe‬‬
‫الزم نیست که تمامی کنترلهای یک فرم را نام گذاری کنید‪ .‬کنترلهایی که هیچوقت در کدنویسی مورد استفاده قرار نمیگیرند‪،‬‬
‫میتوانند از نام پیش فرض خود استفاده کنند‪ .‬برای مثال‪ ،‬اکثر ‪ Lable‬ها صرفا برای نامگذاری بکار میروند و در کد نویسی مورد‬
‫استفاده قرار نمیگیرند‪ .‬لذا الزم نیست خاصیت ‪ name‬آنها را تغییر دهیم‪ .‬همیشه عادت کنید که کنترلهای خود را نامگذاری‬
‫کنید‪.‬‬
‫کنترل ‪JFrame‬‬
‫‪ Frame‬پنجره ای است که شما در برنامههایتان‪ ،‬کنترلهای دیگر را بر روی آن قرار میدهید‪ .‬شما میتوانید در یک برنامه بیش از‬
‫یک ‪ Frame‬داشته باشید‪ .‬هر ‪ Frame‬از خواص و متدهای کالس ‪ Window‬ارث میبرد‪ Frame .‬از لحاظ ویژوالی یا بصری‪ ،‬در‬
‫باالترین سطح کالسهای ‪ Swing‬قرار دارند‪ Frame .‬دارای دو بعد است‪:‬‬
‫بعد ظاهری‬ ‫‪‬‬
‫بعد الیه بندی‬ ‫‪‬‬
‫ظاهر ‪Frame‬‬
‫در شکل زیر شما نام قسمتهای مختلف ‪ Frame‬را مشاهده میکنید‪.‬‬
‫‪111‬‬ ‫‪SWING‬‬
‫در قسمت باال‪ ،‬نوار عنوان )‪ (Title Bar‬قرار دارد‪ .‬نوار عنوان از یک آیکن )‪ ،(Icon‬یک عنوان )‪ ،(Title‬و یک جعبهی کنترل‬
‫)‪ (Control Box‬تشکیل شده است‪ .‬جعبهی کنترل )‪ (Control Box‬دکمههای کوچکنمایی )‪ ،(Minimizing‬بزرگنمایی‬
‫)‪ ،(Maxmizing‬و بستن )‪ (Closing‬را در بر دارد‪ .‬قسمت داخلی یا همان ‪ Content Area‬مکانی است که ما کنترلها را در آن‬
‫قرار میدهیم‪ .‬قسمت حاشیه یا‪ Border‬که شامل قسمت ‪ Title Bar‬نیز میشود‪ ،‬به شما اجازه میدهد که سایز فرم را تغییر‬
‫دهید‪ ،Frame .‬نمونه ای از کالس ‪ JFrame‬میباشد و دارای دو سازنده اصلی میباشد‪ .‬که یکی از آنها برای ایجاد یک ‪Frame‬‬
‫بدون عنوان و دیگری برای ایجاد ‪ Frame‬همراه با عنوان به کار میرود‪:‬‬
‫;)(‪JFrame frame = new JFrame‬‬
‫;)"‪JFrame frame = new JFrame("Title Bar‬‬
‫حال اجازه دهید که یک ‪ Frame‬مانند شکل باال و با استفاده از کدنویسی ایجاد کنیم‪ .‬به کدهای زیر توجه کنید‪:‬‬

‫‪2‬‬
‫‪4‬‬
‫‪6‬‬ ‫{‬
‫‪8‬‬ ‫{‬
‫‪9‬‬ ‫;)"‪JFrame frame1 = new JFrame("FrameDemo‬‬

‫‪10‬‬ ‫;)‪frame1.setSize(430 ,315‬‬
‫‪11‬‬ ‫}‬
‫‪12‬‬ ‫}‬
‫در خط ‪ 3‬کد باال چون قرار است که یک ‪ Frame‬ایجاد کنیم در نتیجه کالسهای ‪ Swing‬را وارد برنامه کردهایم‪ .‬در خط ‪ 1‬یک کالس‬
‫به نام ‪ MyFirstProgram‬ایجاد کردهایم ‪ .‬در خط ‪ 6‬یک نمونه از کالس ‪ JFrame‬ایجاد کرده و در داخل سازنده آن یک عنوان برای‬
‫‪ Frame‬مینویسیم‪ .‬در خط ‪ 33‬با استفاده از متد ‪ setSize‬یک اندازه برای فریم تعیین میکنیم و در خط ‪ 33‬با استفاده از متد‬
‫)(‪ setVisible‬هم آن را نمایش میدهیم‪ .‬به این نکته توجه کنید که ما در کد باال فقط اندازه و عنوان را تعیین کردیم و با اجرای‬
‫کد قسمت ‪ ControlBox‬به صورت پیشفرض در ‪ Frame‬وجود دارد‪ .‬در حالت پیشفرض وقتی که یک ‪ Frame‬را میبندید در اصل‬
‫مخفی میشود‪ .‬کالس ‪ JFrame‬دارای ثابتهایی برای بستن یا مخفی کردن ‪ Frame‬میباشد که در زیر لیست انها آمده است‪:‬‬
‫توضیح‬ ‫ثابت‬
‫)‪ System.exit(0‬فراخوانی میشود‪.‬‬ ‫‪EXIT_ON_CLOSE‬‬
‫)(‪ dispose‬فراخوانی میشود‪.‬‬ ‫‪DISPOSE_ON_CLOSE‬‬
‫پنجره بسته نمیشود‪.‬‬ ‫‪DO_NOTHING_ON_CLOSE‬‬
‫در حکم مخفی شدن ))‪ (setVisible(false‬پنجره میباشد‪ .‬این ثابت پیشفرض است‪.‬‬ ‫‪HIDE_ON_CLOSE‬‬
‫برای استفاده از این ثابتها بعد از ایجاد یک نمونه از کالس ‪ JFrame‬متد )(‪ setDefaultCloseOperation‬را فراخوانی کرده و‬
‫یکی از ثابتهای باال را به آن ارسال میکنیم‪ .‬مثال بعد از خط ‪ 1‬کد باال میتوانیم خط زیر را بنویسیم‪:‬‬
‫;)‪frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE‬‬
‫با اجرای کد باال فریمی به صورت زیر ایجاد میشود‪:‬‬

‫‪116‬‬ ‫‪SWING‬‬
‫الیه بندی ‪Frame‬‬
‫ظاهر ساده ‪ Frame‬دارای چهار الیه اصلی‪ ،‬قاب یا ‪ pan‬میباشد‪:‬‬
‫‪Root‬‬ ‫‪Pane‬‬ ‫‪‬‬

‫‪Layered‬‬ ‫‪Pane‬‬ ‫‪‬‬
‫‪Content‬‬ ‫‪Pane‬‬ ‫‪‬‬
‫‪Glass‬‬ ‫‪Pane‬‬ ‫‪‬‬
‫الیههای تشکیل دهنده یک ‪ Frame‬به صورت زیر میباشند‪:‬‬

‫یک ‪ JFrame‬دارای یک نمونه از کامپوننت ‪ JRootPane‬میباشند‪ .‬خود ‪ JRootPane‬شامل دو کامپوننت ‪JPanel glassPane‬‬
‫و ‪ JLayeredPane‬میباشد‪ JLayeredPane .‬نیز به نوبه خود از دو کامپوننت ‪ JMenuBar‬و ‪ JPanel contentPane‬تشکیل‬
‫معموال کامپوننت های ‪ swing‬به ‪ Content Pane‬اضافه میشوند و بطور مستقیم به خود ‪ JFrame‬اضافه نمیشوند و بهتر‬
‫‪133‬‬ ‫‪SWING‬‬
‫است که در هنگام اضافه کردن کنترلها به ‪ Frame‬مشخص کنیم که این کنترل در کدام قاب قرار بگیرد‪ .‬مثال برای اضافه کردن یک‬
‫کنترل به فریمی که در مثال باال ایجاد کردیم از دو متد )(‪ add‬و )(‪ getContentPane‬به صورت زیر عمل میکنیم‪:‬‬
‫;)‪frame1.getContentPane().add(...‬‬
‫فرض کنید که میخواهیم یک کنترل ‪ Label‬به فریم اضافه کنیم در این صورت بعد از خط ‪ 1‬کد ابتدای درس کدهای زیر را‬
‫بنویسید‪:‬‬
‫;)‪JLabel label = new JLabel("Add A JLable To contentPane", JLabel.CENTER‬‬

‫;)‪frame1.getContentPane().add(label‬‬
‫در کد باال ما یک کنترل ‪ Label‬را به الیه ‪ ContentPane‬اضافه کردهایم‪ .‬همانطور که مشاهده میکنید ابتدا یک کنترل ‪Label‬‬
‫ایجاد کرده و سپس در سازنده کالس آن یک متن برای آن انتخاب کرده و آن را در وسط فریم قرار دادهایم‪ .‬برای اضافه کردن این‬
‫کنترل به الیه ‪ ContentPane‬هم از متد )(‪ getContentPane‬استفاده نمودهایم‪ .‬خروجی کد باال به صورت زیر است‪:‬‬
‫مدیریت الیهها و چیدمان کنترلها‬
‫یکی از بحثهای مهم در ساختن یک ‪ Graphical User Interface‬یا یک )‪ (GUI‬یا به زبان ساده تر یکی از مهمترین و پر‬
‫کاربردترین مسأله ای که در هنگام ایجاد یک فریم با آن رو برو هستیم‪ ،‬مدیریت الیهها و چیدمان کنترلهای آن فریم )‪(Layout‬‬
‫است‪ .‬اینکه بتوانیم فریمی بسازیم که در آن کنترلهای مختلف در جاهای متفاوت در فریم قرار گیرند‪ ،‬به زیبایی و کارایی برنامه ما‬
‫میافزاید‪ .‬توصیه میکنیم که درس قبل را که در آن در مورد الیهها توضیح دادیم مطالعه بفرمایید‪.‬‬
‫مدیر الیه با ‪ layout manager‬شیء است که اندازه و مکان کنترلها را در داخل یک جعبه )‪ (container‬کنترل میکند‪ .‬منظور‬
‫از جعبه در جاوا کنترلهایی مانند ‪ Frame‬یا ‪ Panel‬است‪ ،‬چون که کنترلهای دیگر در داخل این دو کنترل قرار میگیرند‪ .‬در این‬
‫بخش ما از کلمه ‪ Container‬به جای جعبه استفاده میکنیم‪ .‬هر ‪ Container‬دارای یک شیء مدیر الیه پیشفرض است که آن‬
‫الیه را کنترل میکند‪ .‬در جاوا پنج مدیر الیه وجود دارد ‪:‬‬
‫‪FlowLayout‬‬ ‫‪‬‬
‫‪GridLayout‬‬ ‫‪‬‬
‫‪BorderLayout‬‬ ‫‪‬‬
‫‪CardLayout‬‬ ‫‪‬‬
‫‪GridBagLayout‬‬ ‫‪‬‬
‫‪BoxLayout‬‬ ‫‪‬‬
‫‪GroupLayout‬‬ ‫‪‬‬
‫‪SpringLayout‬‬ ‫‪‬‬
‫برای استفاده از یک مدیر الیه کافیست که یک شیء از مدیر الیه ایجاد و آن را به متد )(‪ setLayout‬ارسال کنیم‪:‬‬
‫;))(‪aContainer.setLayout(new LayoutManager‬‬
‫در درسهای بعدی به توضیح کار با مدیران الیه میپردازیم‪.‬‬
‫‪BorderLayout‬‬
‫‪ BorderLayout‬مدیر الیه پیشفرض ‪ contentPan‬کالسهای ‪ JinternalFrame ،JDialog ،JWindow ،JFrame‬و ‪JApplet‬‬
‫بوده و دارای پنج منطقه چپ‪ ،‬راست‪ ،‬باال‪ ،‬پایین و مرکز میباشد‪ .‬یعنی کنترلها را میتوان در این پنج منطقه قرار داد‪ .‬بسته به‬
‫اندازه ویندوز این پنج منطقه تغییر اندزاه میدهند و کل صفحه را پوشش میدهند‪ .‬اگر یک کنترل به ‪ Frame‬اضافه کرده و منطقه‬
131 SWING
‫آن را مشخص نکنید به طور پیشفرض در وسط فریم قرار میگیرد و اگر چندین کنترل را به یک منطقه اضافه کنید آخرین کنترل‬
:‫ دارای دو سازنده زیر میباشد‬BorderLayout ‫ کالس‬.‫اضافه شده نمایش داده میشود‬
public BorderLayout()
public BorderLayout(int hgap, int vgap)
:‫ عبارتاند از‬،‫ مشخص کرد‬Container ‫مناطقی که میتوان هنگام اضافه کردن کنترل به‬
CENTER 
EAST 
NORTH 
SOUTH 
WEST 
:‫برای آشنایی بیشتر با عملکرد این کالس به کد زیر توجه کنید‬
2
3 import java.awt.*;
5
7 {
9 {
10 JFrame frame1 = new JFrame("BorderLayout Demo");
11 frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
12
13 frame1.setLayout(new BorderLayout());
14 frame1.setFont(new Font("Helvetica", Font.PLAIN, 14));
15 frame1.add(new JButton("North"), BorderLayout.NORTH);
16 frame1.add(new JButton("South"), BorderLayout.SOUTH);
17 frame1.add(new JButton("East"), BorderLayout.EAST);
18 frame1.add(new JButton("West"), BorderLayout.WEST);
19 frame1.add(new JButton("Center"), BorderLayout.CENTER);
20
21 frame1.setSize(430 ,315);
22 frame1.setVisible(true);
23 }
24 }
:‫نتیجه اجرای کد باال به صورت زیر است‬

‫برای ایجاد فاصله بین این قسمتها هم در قسمت سازنده مقادیری از نوع عدد صحیح مینویسید‪ ،vgap .‬فاصله عمودی و ‪hgap‬‬
‫فاصله افقی از دیگر کنترلها میباشد‪ .‬مثال خط ‪ ۵۳‬کد باال را به صورت زیر تغییر دهید‪:‬‬
‫;))‪setLayout(new BorderLayout(5,8‬‬
‫بعد از اجرای دوباره برنامه فاصلههایی که تعیین کردهاید در بین قسمتها قابل مشاهده است‪:‬‬
131 SWING
‫ اضافه کرده و ناحیه آنها را در آن مشخص‬Container ‫ ابتدا باید آنها را به یک‬،‫اگر بخواهید چند کنترل را در یک ناحیه قرار دهید‬
‫ و‬Label ‫ فرض کنید که میخواهیم یک‬.‫ اضافه کرده و ناحیه آن را مشخص کنید‬Frame ‫ را به مثال‬Container ‫کنید و سپس‬
Frame ‫ را به‬Panel ‫ اضافه کرده و سپس‬Panel ‫ ابتدا باید آنها را به یک‬.‫ را در ناحیه باالی فریم اضافه کنیم‬textfield ‫یک‬
:‫ به کد زیر توجه کنید‬.‫اضافه کنیم‬
2
5
7 {
9 {
10 JFrame frame1 = new JFrame("BorderLayout Demo");
14
15 JPanel topPanel = new JPanel(new BorderLayout());
16 JLabel label = new JLabel("Name: ");
17 JTextField text = new JTextField();
18 topPanel.add(label, BorderLayout.WEST);
19 topPanel.add(text, BorderLayout.CENTER);
20 frame1.add(topPanel, BorderLayout.NORTH);
21
24 }
25 }
.‫ قرار میدهیم‬BorderLayout ‫ ایجاد کرده و مدیر الیه آن را‬Panel ‫ یک‬31 ‫همانطور که در کد باال مشاهده میکنید ابتدا در خط‬
Panel ‫ در قسمت چپ و وسط‬36 ‫ و‬30 ‫ ایجاد کرده و آنها را در خط‬TextField ‫ و یک‬Label ‫ یک‬31 ‫ و‬31 ‫سپس در خطوط‬
:‫ خروجی کد باال به صورت زیر است‬.‫ اضافه کردهایم‬Frame ‫ به قسمت باالی‬53 ‫ را در خط‬Panel ‫ سپس‬.‫قرار میدهیم‬
‫‪CardLayout‬‬
‫با استفاده از ‪ CardLayout‬شما میتوانید چندین کنترل را در یک فضا نمایش دهید‪ .‬برای درک بهتر برگههای پاسور را در نظر‬
‫بگیرید که همه روی هم قراردارند و در لحظه فقط یکی از آنها قابل مشاهده است یا تبهای مرورگرتان را در نظر بگیرید‪.‬زمانی که‬
‫شما یکی از تبها کلیک میکنید محتوای پنجره تغییر میکند‪ ،‬در حقیقت تمامی محتویات یک تب قبال بارگذاری شده و در باالی‬
‫یکدیگر قرار گرفتهاند‪ .‬زمانی که شما روی یکی از تبها کلیک میکند فقط یکی از آنها نمایش داده میشود و مابقی تبها غیرقابل‬
‫مشاهده میشوند‪ .‬کتابخانه ‪ Swing‬شامل کنترلهای آماده برای پنجرههای همراه با تبها بنام ‪ JTabbedPane‬میباشد‪.‬برای درک‬
‫بهتر عملکرد این کالس به کد زیر توجه کنید‪:‬‬

‫‪2‬‬
‫‪6‬‬
‫‪8‬‬ ‫{‬
‫‪10‬‬ ‫{‬
‫‪11‬‬ ‫‪// main window‬‬
‫‪12‬‬ ‫;)"‪JFrame Frame1 = new JFrame("CardLayout Example‬‬
‫‪13‬‬ ‫;)‪Frame1.setSize(430,315‬‬
‫‪14‬‬
‫‪15‬‬ ‫;)(‪final CardLayout cardLayout = new CardLayout‬‬
‫‪16‬‬ ‫;)‪final JPanel cardPanel = new JPanel(cardLayout‬‬
‫‪17‬‬
‫‪18‬‬ ‫‪// create two dummy panels (the "cards") to show‬‬
‫‪19‬‬ ‫;)(‪JPanel card1 = new JPanel‬‬
‫‪20‬‬ ‫;)‪card1.setBackground(Color.red‬‬
‫‪21‬‬
‫‪22‬‬ ‫;)(‪JPanel card2 = new JPanel‬‬
‫‪23‬‬ ‫;)‪card2.setBackground(Color.blue‬‬
‫‪131‬‬ ‫‪SWING‬‬
‫‪24‬‬
‫‪25‬‬ ‫;)"‪cardPanel.add(card1,"RedCard‬‬
‫‪26‬‬ ‫;)"‪cardPanel.add(card2,"BlueCard‬‬
‫‪27‬‬
‫‪28‬‬ ‫‪// create two buttons‬‬
‫‪29‬‬ ‫;)(‪JPanel buttonPanel = new JPanel‬‬
‫‪30‬‬ ‫;)"‪JButton b1 = new JButton("Red‬‬
‫‪31‬‬ ‫;)"‪JButton b2 = new JButton("Blue‬‬
‫‪32‬‬ ‫;)‪buttonPanel.add(b1‬‬
‫‪33‬‬ ‫;)‪buttonPanel.add(b2‬‬
‫‪34‬‬
‫‪35‬‬ ‫;)‪Frame1.add(cardPanel, BorderLayout.CENTER‬‬
‫‪36‬‬ ‫;)‪Frame1.add(buttonPanel, BorderLayout.SOUTH‬‬
‫‪37‬‬
‫‪38‬‬ ‫‪// create action listeners for buttons‬‬
‫‪39‬‬ ‫)(‪b1.addActionListener(new ActionListener‬‬
‫‪40‬‬ ‫{‬
‫‪41‬‬ ‫)‪public void actionPerformed(ActionEvent event‬‬
‫‪42‬‬ ‫{‬
‫‪43‬‬ ‫;)"‪cardLayout.show(cardPanel, "RedCard‬‬
‫‪44‬‬ ‫}‬
‫‪45‬‬ ‫;)}‬
‫‪46‬‬
‫‪47‬‬ ‫)(‪b2.addActionListener(new ActionListener‬‬
‫‪48‬‬ ‫{‬
‫‪49‬‬ ‫)‪public void actionPerformed(ActionEvent event‬‬
‫‪50‬‬ ‫{‬
‫‪51‬‬ ‫;)"‪cardLayout.show(cardPanel, "BlueCard‬‬
‫‪52‬‬ ‫}‬
‫‪53‬‬ ‫;)}‬
‫‪54‬‬
‫‪55‬‬ ‫‪// Show main Frame1‬‬
‫‪56‬‬ ‫;)‪Frame1.setVisible(true‬‬
‫‪57‬‬ ‫}‬
‫‪58‬‬ ‫}‬
‫هدف کلی کد باال این است که با با کلیک بر روی دو دکمه دو کارت با رنگهای قرمز و آبی که بر روی هم قرار دارند را نمایان کنیم‪.‬‬
‫یا فرض کنید که این دو دکمه حکم تب دارند‪ .‬ابتدا یک کالس در در خطوط ‪ 1-11‬تعریف کردهایم ‪.‬سپس در داخل متد )(‪main‬‬
‫و در خطوط ‪ 35‬و ‪ 31‬یک ‪ Frame‬ایجاد میکنیم‪ .‬در خط ‪ 31‬یک نمونه از کالس ‪ CardLayout‬ایجاد و آن را در خط ‪ 31‬به یک‬
‫‪ Panel‬وصل میکنیم‪ .‬این پنل همان پنلی است که کارتهای قرمز و آبی در آن قرار میگیرند‪ .‬برای ایجاد این دو کارت دو پنل ‪-51‬‬
‫‪ 36‬ایجاد کرده و آنها را به پنل اصلی یعنی ‪ cardPanel‬در خط ‪ 51‬و ‪ 51‬اضافه میکنیم‪ .‬به پارامتر دوم متد )(‪ add‬در این دو‬
‫خط توجه کنید‪ .‬این پارامترها نامهایی هستند که ما به این دو کارت اختصاص دادهایم‪ .‬حال نوبت به اضافه کردن دو دکمه میرسد‪.‬‬
‫در خط ‪ 56‬یک ‪ Panel‬دیگر ایجاد کرده و دو دکمه به نامهای ‪ Red‬و ‪ Blue‬به این پنل اضافه میکنیم (خطوط ‪ .)13-11‬حال‬
‫نوبت به اضافه کردن دو پنل که یکی از آنها حاوی کارتها و دیگری حاوی دکمهها است به ‪ Frame‬میرسد‪ .‬این دو پنل را در‬
‫خطوط ‪ 11‬و ‪ 11‬به فریم اضافه میکنیم‪ .‬چون ‪ layout manager‬فریم به صورت پیشفرض ‪ BorderLayout‬است میتوانیم یکی‬
‫از پنل ها را در وسط و دیگری را در پایین فریم قرار دهیم‪ .‬در خطوط ‪ 16-11‬هم دو کنترل کننده رویداد برای دو دکمه ایجاد میکنیم‬
‫تا با کلیک بر روی دکمهها کارت مربوط به آن نمایش داده شود‪ .‬در خطوط ‪ 31‬و ‪ 13‬هم با استفاده از متد )(‪ show‬کالس‬
‫‪ CardLayout‬دو کارت را نمایش میدهیم‪ .‬حال برنامه را اجرا و با کلیک بر روی دو دکمه نتیجه را مشاهده نمایید‪:‬‬
‫‪FlowLayout‬‬
136 SWING
‫ اگر عرض‬.‫ کنترلها را در یک سطر تراز میکنیم‬FlowLayout ‫ با استفاده از‬.‫ است‬JPanel ‫ مدیر الیه پیشفرض‬FlowLayout
‫ کمتر از عرض همه کنترلهای باشد یعنی کنترلها نتوانند در یک سطر قرار بگیرند به صورت خودکار در دو یا چند سطر‬container
:‫ به کد زیر توجه کنید‬.‫قرار میگیرند‬
import java.awt.*;
import javax.swing.*;

{
{
JFrame frame1 = new JFrame("FlowLayout Demo");
frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame1.setLayout(new FlowLayout());
frame1.setFont(new Font("Helvetica", Font.PLAIN, 14));
frame1.add(new JButton("Button 1"));

frame1.setSize(430, 315);
frame1.setVisible(true);
}
}
:‫خروجی کد باال به صورت زیر است‬

‫حال پنجره را کوچک و بزرگ کرده و نتیجه را مشاهده نمایید‪:‬‬
‫سازنده کالس ‪ FlowLayout‬را در سه حالت زیر میتوان مقداردهی کرد‪:‬‬
‫)(‪public FlowLayout‬‬
‫)‪public FlowLayout(int alignment‬‬
‫)‪public FlowLayout(int alignment, int hgap, int vgap‬‬
‫در حالت پیشفرض کنترلها در وسط قرار میگیرند مگر اینکه نحوه تراز بندی آنها را با استفاده از ثابتهای زیر مشخص کنیم‪:‬‬
‫‪LEFT‬‬ ‫‪‬‬
‫‪FCENTER‬‬ ‫‪‬‬
‫‪RIGHT‬‬ ‫‪‬‬
‫حال خط ‪ 33‬کد باال را به صورت زیر تغییر دهید‪:‬‬
‫;))‪frame1.setLayout(new FlowLayout(FlowLayout.LEFT‬‬
‫با اجرای کد مشاهده میکنید که کنترلها نسبه به سمت چپ ‪ container‬تراز شدهاند‪:‬‬

113 SWING
GridLayout
‫ سازنده‬.‫ برای تنطیم کنترلها را در ردیف و ستونهای هم اندازه و منظم و از چپ به راست در کنار هم قرار میدهد‬GridLayout
:‫این کالس را به سه صورت میتوان مقداردهی کرد‬
public GridLayout()
public GridLayout(int rows, int columns)
public GridLayout(int rows, int columns, int hgap, int vgap)
‫ به کد زیر توجه‬.‫مثال در سازنده میتوان تعداد سطر و ستونهایی که قرار است کنترلها درون آنها قرار بگیرند را مشخص کنید‬
:‫کنید‬
import java.awt.*;
import javax.swing.*;

{
{
JFrame frame1 = new JFrame("GridLayout Demo");
frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame1.setLayout(new GridLayout(4, 3));
frame1.setFont(new Font("Helvetica", Font.PLAIN, 14));
frame1.add(new JButton("January"));
frame1.add(new JButton("February"));
frame1.add(new JButton("March"));
frame1.add(new JButton("April"));
frame1.add(new JButton("May"));
frame1.add(new JButton("June"));
frame1.add(new JButton("July"));
frame1.add(new JButton("August"));
frame1.add(new JButton("September"));
frame1.add(new JButton("October"));
frame1.add(new JButton("November"));
frame1.add(new JButton("December"));
frame1.setSize(430, 315);
frame1.setVisible(true);
}
}
‫ گذاشتهایم و‬1 ‫ در کد باال تعداد ستون رو‬.‫اعداد صفر و دو در خط پررنگ شده کد باال به ترتیب نشان دهنده سطر و ستون هستند‬
:‫ کد را اجرا و نتیجه را مشاهده کنید‬.3 ‫تعداد سطر را‬
.‫ مواجه میشوید‬IllegalArgumentException ‫ قرار دهید در هنگام اجرای برنامه با خطای‬3 ‫اگر تعداد سطرها و ستونها را برابر‬
BoxLayout
111 SWING
‫ دارای یک سازنده است و‬BoxLayout ‫ کالس‬.‫ کنترلها در یک ردیف یا یک ستون قرار میگیرند‬BoxLayout ‫در مدل الیه بندی‬
:‫به صورت زیر مقداردهی میشود‬
public BoxLayout(Container target, int axis)
‫ است که‬Container ‫ هم نحوه قرارگیری کنترل در‬axis ‫ همان کنترلی است که دیگر کنترلها در آن قرار میگیرند و‬Container
:‫به دو صورت زیر مقدار دهی میشود‬
BoxLayout.X_AXIS 
BoxLayout.Y_AXIS 
:‫برای درک بهتر عملکرد این کالس به کد زیر توجه کنید‬
2
5
7 {
9 {
10 JFrame frame1 = new JFrame("BoxLayout Demo");
13
14 Container container = frame1.getContentPane();
15 container.add(new JButton("Button1"));
19
20 frame1.setLayout(new BoxLayout(container, BoxLayout.X_AXIS));
21
24 }
25 }
Container ‫ یک‬33 ‫ اضافه نمیشوند در خط‬Frame ‫نکته ای که در کد باال وجود دارد این است که چون کنترلها به طور مستقیم به‬
53 ‫ سپس در خط‬.‫ چهار دکمه را به آن اضافه میکنیم‬31-30 ‫ سپس در خطوط‬.‫ دارد‬ContentPane ‫ایجاد کردهایم که اشاره به الیه‬
:‫ خروجی کد باال به صورت زیر است‬.‫ را مشخص میکنیم‬Container ‫نحوه قرارگیری کنترلها در این‬
‫حال خط ‪ 53‬کد باال را به صورت زیر تغییر دهید‪:‬‬
‫;))‪frame1.setLayout(new BoxLayout(container, BoxLayout.Y_AXIS‬‬
‫یک بار دیگر برنامه را اجرا و نتیجه را مشاهده نمایید‪:‬‬

‫‪111‬‬ ‫‪SWING‬‬
‫به این نکته توجه کنید که میتوان خط ‪ 33‬کد باال را کامال حذف کرد و برای اضافه کردن دکمهها به ‪ Frame‬به صورت زیر عمل کرد‬
‫‪:‬‬
‫;))"‪frame1.getContentPane().add(new JButton("...‬‬
‫و همچنین خط ‪ 53‬کد باال را به صورت زیر تغییر داد‪:‬‬
‫;))‪frame1.setLayout(new BoxLayout(frame1.getContentPane(), BoxLayout.Y_AXIS‬‬
‫ایجاد حاشیه برای کنترلها‬
‫در ‪ java‬کالسهایی برای کار با حاشیه کنترلها وجود دارد‪ .‬از این کالسها میتوان برای کشیدن خط به دور کنترلها‪ ،‬پر کردن‬
‫فضای خالی اطراف آنها و همچنین اضافه کردن یک عنوان به کنترلها استفاده کرد‪ .‬این کالسها در پکیج ‪ border‬قرار دارند و‬
‫برای کار با آنها باید این ‪ Package‬را ‪ import‬کرد‪:‬‬
‫*‪import javax.swing.border.‬‬
‫در زیر لیست برخی از این کالسهای پکیج ‪ border‬ذکر شده است‪:‬‬
‫‪BevelBorder‬‬ ‫‪‬‬
‫‪CompoundBorder‬‬ ‫‪‬‬
‫‪EtchedBorder‬‬ ‫‪‬‬
‫‪LineBorder‬‬ ‫‪‬‬
‫‪MatteBorder‬‬ ‫‪‬‬
‫‪SoftBevelBorder‬‬ ‫‪‬‬
‫‪TitledBorder‬‬ ‫‪‬‬
‫برای ایجاد حاشیه با استفاده از کالسهای باال یک شیء از آنها را به عنوان آرگومان به متد )(‪ setBorder‬ارسال میکنیم‪ .‬به کد‬
‫زیر توجه کنید‪:‬‬

‫‪2‬‬
5 import javax.swing.border.*;
6
8 {
10 {
11 JFrame frame1 = new JFrame("Border Demo");
12 frame1.setLayout(new GridLayout(2, 4));
13 frame1.setSize(450 , 315);
14
15 JPanel Panel1 = new JPanel();
16 Panel1.setBorder(new TitledBorder("Title"));
17
19 Panel2.setBorder(new EtchedBorder());
20
22 Panel3.setBorder(new LineBorder(Color.BLUE));
23
25 Panel4.setBorder(new MatteBorder(5, 5, 5, 5, Color.GREEN));
26
28 Panel5.setBorder(new BevelBorder(BevelBorder.RAISED));
29
31 Panel6.setBorder(new SoftBevelBorder(BevelBorder.LOWERED));
32
34 Panel7.setBorder(new CompoundBorder(new EtchedBorder(),new LineBorder(Color.RED)));
35
36 frame1.add(Panel1);
43
45 }
46 }
‫ پنل را حاشیه دار کردهایم و در ادامه در مورد آنها بیشتر توضیح‬1 ‫در کد و برای آشنایی شما با نحوه استفاده از کالسهای مذکور‬
:‫ خروجی کد به صورت زیر است‬.‫میدهیم‬

111 SWING
TitleBorder ‫کالس‬
‫ سازنده این کالس به صورت زیر‬.‫ برای کشیدن خط به دور کنترل به همراه یک عنوان استفاده میشود‬TitleBorder ‫از کالس‬
:‫مقداردهی میشود‬
TitledBorder(Border border)
TitledBorder(String string)
TitledBorder(Border border, String string)
TitledBorder(Border border, String string, titleJustification, titlePosition)
TitledBorder(Border border, String string, titleJustification, titlePosition, Font font)
TitledBorder(Border border, String string, titleJustification, titlePosition, Font font,
Color.yellow)
‫ راست چین یا وسط چین بودن عنوان را‬،‫ چپ چین‬،titleJustification .‫ نوع حاشیه کنترل را مشخص میکند‬Border
:‫مشخص میکند و مقادیر زیر را میپذیرد‬
LEFT 
CENTER 
RIGHT 
:‫ باال یا پایین قرار گرفتن عنوان را مشخص میکند و مقادیر زیر را میپذیرد‬titlePosition
TOP 
ABOVE_TOP 
BELOW_TOP 
BOTTOM 
ABOVE_BOTTOM 
BELLOW_BOTTOM 
‫ برای درک بهتر استفاده از کالس فوق و ثابتهای آن به مثال‬.‫ رنگ آن را مشخص میکند‬Color ‫ نوع و اندازه فونت عنوان و‬Font
:‫زیر توجه کنید‬
2
6
8 {
10 {
11 JFrame frame1 = new JFrame("TitledBorder Demo");
12 frame1.setLayout(new GridLayout(3, 3));
14
16 Panel1.setBorder(new TitledBorder
17 (null, "Title", TitledBorder.LEFT, TitledBorder.TOP));
20 (null, "Title", TitledBorder.LEFT, TitledBorder.ABOVE_TOP));
23 (null, "Title", TitledBorder.LEFT, TitledBorder.BELOW_TOP));
26 (null, "Title", TitledBorder.CENTER, TitledBorder.TOP));
29 (null, "Title", TitledBorder.CENTER, TitledBorder.ABOVE_TOP));
32 (null, "Title", TitledBorder.CENTER, TitledBorder.BELOW_TOP));
35 (null, "Title", TitledBorder.RIGHT, TitledBorder.TOP));
38 (null, "Title", TitledBorder.RIGHT, TitledBorder.ABOVE_TOP));
41 (null, "Title", TitledBorder.RIGHT, TitledBorder.BELOW_TOP));
42
‫‪116‬‬ ‫‪SWING‬‬
‫‪46‬‬ ‫;)‪frame1.add(Panel4‬‬
‫‪52‬‬
‫‪54‬‬ ‫}‬
‫‪55‬‬ ‫}‬
‫در کد باال عنوان ‪ 6‬پنل را به حاالت مختلف مشخص کردهایم‪ .‬خروجی کد باال به صورت زیر است‪:‬‬
‫با توجه به شکل متوجه میشوید که اگر بخواهید مثال عنوان شم ا در باالی پنل و سمت راست آن نمایش داده شود باید از کد زیر‬
‫استفاده کنید‪:‬‬
‫;)‪new TitledBorder(null, "Title", TitledBorder.RIGHT, TitledBorder.TOP‬‬
‫کلمههای ‪ TOP‬در کد ابتدای درس را به ‪ BOTTOM‬تغییر داده و برنامه را اجرا و نتیجه را مشاهده کنید‪ .‬رنگ و نوع فونت عنوان و‬
‫حاشیه کنترل را هم میتوان مشخص کرد‪:‬‬

Panel1.setBorder(new TitledBorder(new MatteBorder(5, 5, 5, 5, Color.BLUE),

"Title", TitledBorder.RIGHT, TitledBorder.TOP,new Font("Serif", Font.BOLD,
15),Color.PINK));
MatteBorder ‫کالس‬
‫ به‬.‫ هم میتوان یک خط به دور کنترل کشید و هم به جای خط میتوان از آیکون استفاده کرد‬MatteBorder ‫با استفاده از کالس‬
‫ سازنده این کالس به روشهای زیر‬.‫این نکته توجه کنید که قسمتی از فضای اصلی کنترل به وسیله خط یا آیکون اشغال میشود‬
:‫مقدار دهی میشود‬
MatteBorder(Icon)
MatteBorder(Inset, Color)
MatteBorder(Inset, Icon)
MatteBorder(top, left, bottom, right, Color)
MatteBorder(top, left, bottom, right, Icon)
:‫برای درک عملکرد این کالس به کد زیر توجه کنید‬
2
113 SWING
6
8 {
10 {
11 JFrame frame1 = new JFrame("Properties and Methods Demo");
12 frame1.setLayout(null);
13 JPanel panel1 = new JPanel();
15
16 panel1.setBounds(60, 40, 200, 150);
17 panel1.setBackground(Color.LIGHT_GRAY);
18
19 panel2.setBounds(270, 40, 200, 150);
20 panel2.setBackground(Color.LIGHT_GRAY);
21
22 frame1.add(panel1);
24
25 panel1.setBorder(new MatteBorder(10, 10, 10, 10, Color.GREEN));
26
27 panel2.setBorder(new MatteBorder(new ImageIcon("C:\\FrameDemo\\icon.gif")));
28
31 }
32 }
‫ مهمترین خطوط‬.‫ با اندازه و پس زمینه یکسان به آن اضافه کردهایم‬Panel ‫ ایجاد کرده و دو‬Frame ‫ کد باال یک‬33-51 ‫در خطوط‬
‫ هم به‬51 ‫ در خط‬.‫ اولی کشیدهایم‬Panel ‫ پیکسل به دور‬33 ‫ یک خط سبز با پهنای‬51 ‫ میباشند که در خط‬51 ‫ و‬51 ‫کد باال خطوط‬
:‫ برنامه را اجرا و نتیجه را مشاهده کنید‬.‫ آیکون را من از قبل در پوشه برنامه قرار دادهام‬.‫جای خط از آیکون استفاده کردهایم‬
‫کنترل ‪JButton‬‬
‫وقتی که بر روی کنترل ‪ Button‬کلیک میکنیم دستوراتی اجرا میشود‪ ،‬و این معمولترین استفاده ای است که از این کنترل‬
‫میشود‪ .‬دکمهها به نوعی برای تأیید یا لغو یک عمل و یا باز کردن کادرهای محاوره ای به کار میروند‪ .‬سازنده این کالس به‬
‫صورتهای زیر مقداردهی میشود‪:‬‬
‫;)‪JButton(Action‬‬
‫;)‪JButton(String‬‬
‫;)‪JButton(Icon‬‬
‫;)‪JButton(String, Icon‬‬
‫کنترل ‪ Button‬دارای خواصی است که در جدول زیر تعدادی از این آنها ذکر شده است‪:‬‬
‫توضیح‬ ‫خواص‬
‫اگر مقدار این خاصیت ‪ false‬باشد بر روی ‪ button‬نمیتوان کلیک کرد‪.‬‬ ‫‪enabled‬‬
‫عنوانی است که به کنترل اختصاص داده میشود‪.‬‬ ‫‪text‬‬
‫مشخص میکند که آیا کنترل ‪ button‬در روی فرم قابل رویت باشد یا نه‬ ‫‪visible‬‬
‫فقط با ویرایش خواص یک ‪ button‬نمیتوان از آن استفاده کرد‪ .‬بلکه کنترل دکمه برای انجام برخی اعمال نیاز به واکنش به‬
‫رویدادها دارد‪ .‬در زیر معمولترین رویدادهای کنترل ‪ button‬آمده است‪.‬‬
‫توضیح‬ ‫رویداد‬
‫وقتی روی میدهد که بر روی دکمه کلیک کنید‪.‬‬ ‫‪actionPerformed‬‬
‫وقتی روی میدهد که ماوس کنترل را ترک کند‪.‬‬ ‫‪mouseExited‬‬
‫وقتی روی میدهد که مکان دکمه تغییر کند‪.‬‬ ‫‪stateChanged‬‬
‫وقتی روی میدهد که نشانگر ماوس بر روی کنترل باشد و دکمه ماوس رو به پایین فشار داده شود‪.‬‬ ‫‪mousePressed‬‬
‫وقتی روی میدهد که ماوس وارد کنترل دکمه میشود‪.‬‬ ‫‪mouseEntered‬‬

111 SWING
.‫وقتی روی میدهد که دکمه ماوس فشار داده شده و رها شود‬ mouseReleased
‫ اجازه دهید که با ایجاد‬.‫ میباشد‬actionPerformed ‫همانطور که قبال مشاهده کردید رویداد پیشقرض کنترل دکمه رویداد‬
‫ میخواهیم برنامه ای بنویسیم که در آن وقتی که با ماوس بر روی یک دکمه رفتیم و‬.‫برنامههایی با رویدادهای دیگر نیز آشنا شویم‬
:‫ به کد زیر توجه کنید‬.‫یا نشانگر ماوس را از آن خارج کردیم متن داخل دکمه تغییر کند‬
2
5
7 {
9 {
10 JFrame frame1 = new JFrame("Button Demo");
12 final JButton button1 = new JButton("buttonSample");
13
14 button1.setBounds(85, 80, 157, 60);
15
16 MouseAdapter MouseAdapter1 = new MouseAdapter()
17 {
18 @Override
19 public void mouseEntered(MouseEvent evt)
20 {
21 button1.setText("Mouse has entered!");
22 }
23
24 @Override
25 public void mouseExited(MouseEvent evt)
26 {
27 button1.setText("Mouse has Left!");
28 }
29 };
30
31 button1.addMouseListener(MouseAdapter1);
32
33 frame1.add(button1);
34
37 }
38 }
‫ آن را‬33 ‫ یک دکمه ایجاد کرده و در خط‬35 ‫ در خط‬.‫ یک فریم ایجاد کرده و هیچ الیه بندی برای آن در نظر نمیگیریم‬33 ‫ و‬33 ‫در خط‬
‫ همانطور که می دانید برای اینکه‬.‫ حال نوبت به قسمت مهم برنامه میرسد‬.‫نسبت به گوشه باال و سمت چپ فریم تراز میکنیم‬
‫ کالسی که قرار است رابط را پیاده سازی کند کالس‬.‫ توسط یک کالس پیاده سازی شود‬Interface ‫رویدادی اتفاق بیفتد باید یک‬
.‫ را پیاده سازی میکند‬MouseMotionListener ‫ و‬MouseListener ،MouseWheelListener ‫ است که سه رابط‬MouseAdapter

‫در نتیجه این پیاده سازی باید کدهایی برای بدنه متدهای این رابطها هم در نظر گرفته شود‪ .‬چون ما با دو متد )(‪MouseEntered‬‬
‫و )(‪ MouseExited‬سر و کار داریم پس باید کدهای بدنه این دو متد را هم فراهم کنیم‪ .‬پس در کل یک شیء از کالس‬
‫‪ MouseAdapter‬در خط ‪ 31‬ایجاد کرده و در دو متد )(‪ MouseEntered‬و )(‪ MouseExited‬در خطوط ‪ 53‬و ‪ 51‬متن داخل دکمه‬
‫را تغییر میدهیم‪ .‬حال میخواهیم این شیء را به دکمه بچسبانیم‪ .‬این کار را با استفاده از متد )(‪ addMouseListener‬در خط‬
‫‪ 13‬انجام میدهیم‪ .‬در خط ‪ 11‬هم دکمه را به فریم اضافه میکنیم‪ .‬حال برنامه را اجرا کنید‪ .‬مشاهده میکنید که با قرار گرفت اشاره‬
‫گر ماوس بر روی کنترل ‪ button‬خاصیت ‪ text‬آن تغییر میکند‪ .‬و از طرف دیگر وقتی که اشاره گر از کنترل دکمه دور میشود این‬
‫خاصیت دوباره تغییر میکند‪.‬‬

‫‪111‬‬ ‫‪SWING‬‬
‫کنترل ‪JLabel‬‬
‫کنترل ‪ Label‬برای اضافه کردن یک متن به فرم بکار میرود‪ .‬این متن میتواند حاوی یک پیام و یا توضیحی در باره عملکرد سایر‬
‫کنترلها باشد‪ .‬سازنده این کالس به روشهای زیر مقداردهی میشود‪:‬‬
‫)‪JLabel(Icon‬‬
‫)‪JLabel(String‬‬
‫)‪JLabel(Icon, horizontalAlignment‬‬
‫)‪JLabel(String, horizontalAlignment‬‬
‫)‪JLabel(String, Icon, horizontalAlignment‬‬
‫خاصیت ‪ text‬مهمترین خاصیت آن میباشد چون هدف اصلی از استفاده از این کنترل نشان دادن متن در فرم است‪ .‬این متن را‬
‫هم میتوانیم در سازنده فرم بنویسیم‪:‬‬
‫;)"!‪JLabel Label1 = new JLabel("Hello World‬‬
‫و هم با استفاده از متد )(‪ setText‬به آن اختصاص دهیم‪:‬‬
‫;)(‪JLabel Label1 = new JLabel‬‬

‫;)"!‪Label1.setText("Hello World‬‬
‫برای ترازبندی ‪ Label‬هم میتوان از رابط ‪ SwingConstants‬به صورت زیر استفاده کرد‪:‬‬
‫;)‪JLabel Label1 = new JLabel("Hello World!", SwingConstants.CENTER‬‬
‫و یا به صورت‬
‫;)(‪JLabel Label1 = new JLabel‬‬

‫;)"!‪Label1.setText("Hello World‬‬
‫;)‪Label1.setHorizontalAlignment(SwingConstants.CENTER‬‬
‫رویدادهایی هم برای این کنترل وجود دارد که اکثر مواقع به آن نیازی نیست و در نتیجه در مورد آنها بحث نمیکنیم‪.‬‬
‫کنترل ‪ JTextField‬و ‪JPasswordField‬‬
‫کنترل ‪ TextField‬ابتداییترین وسیله برای ورود اطالعات در یک فرم ویندوزی میباشد‪ .‬این کار را با تایپ آنها (اطالعات) در‬
‫‪ TextField‬انجام میدهید‪ .‬سازنده این کالس به روشهای زیر مقداردهی میشود‪:‬‬
‫)(‪JTextField‬‬
‫)‪JTextField(String‬‬
‫)‪JTextField(Column‬‬
‫)‪JTextField(String,Column‬‬
‫)‪JTextField(Document,String,Column‬‬
‫میخواهیم با یک مثال نحوه استفاده از ‪ TextField‬را به شما نشان دهیم‪ .‬برنامه از شما میخواهد که دو عدد را وارد کنید و با‬
‫زدن دکمه جمع آنها در ‪ TextField‬سومی نشان دهید‪ .‬حال به طراحی برنامه میپردازیم‪ .‬به کد زیر توجه کنید‪:‬‬

‫‪2‬‬
‫‪6‬‬
111 SWING

8 {
10 {
11 //Create Frame
12 JFrame frame1 = new JFrame("TextFiled Demo");
14
15 //Create Panel
17 panel1.setLayout(new GridLayout(4,2));
18 panel1.setBounds(40, 60, 270, 80);
19
20 //Create Textfield and Button
21 final JTextField firstNumber = new JTextField(15);
22 final JTextField SecondNumber = new JTextField(15);
23 final JTextField Result = new JTextField(15);
24 JButton Calculate = new JButton("Calculate");
25
26 //Add Textfield and Button to Panel
27 panel1.add(new Label("First Number"));
28 panel1.add(firstNumber);
29 panel1.add(new Label("Second Number"));
30 panel1.add(SecondNumber);
31 panel1.add(new Label("SUM"));
32 panel1.add(Result);
33 panel1.add(Calculate);
34
35 //Add Panel to Frame
37
38 class MyActionListener implements ActionListener
39 {
40 @Override
41 public void actionPerformed(ActionEvent e)
42 {
43 double firstnumber = Double.parseDouble(firstNumber.getText());
44 double secondnumber = Double.parseDouble(SecondNumber.getText());
45 Result.setText(String.valueOf(firstnumber + secondnumber));
46 }
47 }
48
49 Calculate.addActionListener(new MyActionListener());
50
51 //Show Frame
54 }
55 }
‫ آن را به چهار سطر و دو ستون تقسیم‬31 ‫ ایجاد و در خط‬Panel ‫ یک‬31 ‫ در خط‬.‫ ایجاد کردهایم‬Frame ‫ یک‬35 ‫در کد باال و در خط‬
‫ ها و دکمه محاسبه را ایجاد و‬TextField ‫ هم‬53-11 ‫ در خطوط‬.‫ پنل را تقریبا به وسط فریم انتقال دادهایم‬30 ‫ در خط‬.‫نمودهایم‬
‫ یک کالس به نام‬10-31 ‫ ابتدا در خطوط‬.‫ میباشد‬10-36 ‫ بخس مهم کد باال خطوط‬.‫ اضافه کردهایم‬Panel ‫به‬
‫ این رابط دارای متدی به نام‬.‫ را پیاده سازی میکند‬ActionListener ‫ تعریف کردهایم که رابط‬MyActionListener
‫ فراهم‬MyActionListener ‫ حال وظیفه کالس‬.‫ که زمانی فراخوانی میشود که بر روی کنترلی کلیک شود‬actionPerformed()
‫کردن کدهایی برای بدنه این متد میباشد‪ .‬این کدها که در خطوط ‪ 31-31‬مشاهده میکنید همان عملیان جمع ‪ TextField‬ها‬
‫میباشند‪ .‬در خطوط ‪ 31‬و ‪ 33‬با استفاده از متد )(‪ getText‬مقادیر ورودی کاربر را دریافت کرده و برای اینکه بتوان بر روی آنها‬
‫عملیات جمع را انجام داد با استفاده از متد )(‪ parseDouble‬از کالس ‪ Double‬آنها را به نوع اعشار تبدیل میکنیم‪ .‬چون قرار‬
‫است که نتیجه در ‪ TextField‬نمایش داده شود در خط ‪ 31‬و با استفاده از متد و کالس )(‪ String.valueOf‬حاصل جمع را‬
‫به نوع رشته تبدیل و در ‪ TextField‬سوم نمایش میدهیم‪ .‬در خط ‪ 36‬هم شیئ از کالس ‪ MyActionListener‬را به‬
‫متد )(‪ addActionListener‬ارسال میکنیم تا دکمه درست کار کند‪ .‬حال برنامه را اجرا و با وارد کردن دو عدد نتیجه را مشاهده‬
‫در ادامه آموزش کنترل ‪ JTextField‬میخواهیم رویداد ‪ TextChanged‬زبان سی شارپ را به وسیله جاوا پیاده سازی کنیم‪ .‬برنامه‬
‫به این صورت است که وقتی متنی در داخل ‪ JTextField‬نوشته میشود‪ ،‬همزمان در داخل یک کنترل ‪ JLabel‬هم نوشته شود‪.‬‬

‫‪2‬‬
‫‪5‬‬ ‫;*‪import javax.swing.event.‬‬
‫‪6‬‬
‫‪8‬‬ ‫{‬
‫‪10‬‬ ‫{‬
‫‪11‬‬ ‫;)"‪JFrame frame1 = new JFrame("TextFiled Demo‬‬
‫‪12‬‬ ‫;)‪frame1.setLayout(null‬‬
116 SWING

14 panel1.setLayout(new GridLayout(2,1));
15 panel1.setBounds(40, 80, 270, 50);
16 final JTextField TextField1 = new JTextField();
17 final JLabel Label1 = new JLabel();
18 panel1.add(TextField1);
19 panel1.add(Label1);
21
22 class MydocumentListener implements DocumentListener
23 {
24 public void changedUpdate(DocumentEvent documentEvent)
25 {
26
27 }
28 public void insertUpdate(DocumentEvent documentEvent)
29 {
30 Label1.setText(TextField1.getText());
31 }
32 public void removeUpdate(DocumentEvent documentEvent)
33 {
34 Label1.setText(TextField1.getText());
35 }
36 }
37
38 TextField1.getDocument().addDocumentListener(new MydocumentListener());
39
42 }
43 }
‫ برای‬.‫ است را به آن اضافه کردهایم‬Label ‫ و یک‬TextField ‫ که حاوی یک‬Panel ‫ یک فریم ایجاد و یک کنترل‬33-53 ‫در خطوط‬
‫ توسط یک کالس پیاده سازی شود که ما این کار را در خط‬DocumentListener ‫کار با متن یا به عبارتی تغییرات متن باید رابط‬
:‫ این رابط دارای سه متد زیر میباشد‬.‫ انجام دادهایم‬55
changedUpdate() 
insertUpdate() 
removeUpdate() 
:‫ در داخل بدنه دو متد آخر کد زیر را مینویسیم‬.‫که ما برای پیاده سازی رویداد مذکور به دو به دو متد آخر نیاز داریم‬
Label1.setText(TextField1.getText());
‫ به متد‬10 ‫ را در خط‬MydocumentListener ‫ سپس یک نمونه از کالس‬.‫ انجام دادهایم‬13 ‫ و‬13 ‫کاری که در خطوط‬
‫ نوشته و نتیجه را مشاهده نمایید‬TextField ‫ حال برنامه را اجرا و متنی را در داخل‬.‫ ارسال میکنیم‬addDocumentListener()
:
‫ استفاده‬JTextField ‫ به جای‬JPasswordField ‫ شما باید از کنترل‬،‫ شما میخواهد یک پسورد را بپذیرد‬TextField ‫اگر‬
:‫ سازنده این کالس به روشهای زیر مقداردهی میشود‬.‫کنید‬
public JPasswordField()
public JPasswordField(String text)
public JPasswordField(int columnWidth)
public JPasswordField(String text, int columnWidth)
public JPasswordField(Document model, String text, int columnWidth)
:‫هر کاراکتری را که در داخل این کنترل بنویسید آن را به صورت ستاره ( * ) نمایش میدهد‬
JTextArea ‫کنترل‬
‫‪113‬‬ ‫‪SWING‬‬
‫کنترل ‪ JTextArea‬را به نوعی میتوان یک ‪ JTextField‬در نظر گرفت با این تفاوت که در ‪ JTextField‬ورودیهای کاربر در‬
‫یک خط نوشته میشدند در حالیکه در ‪ JTextArea‬میتوان ورودیها را در چند خط نوشت‪ JTextArea .‬دارای یک خاصیت و‬
‫آن هم ‪ text‬میباشد‪ .‬در ا ین کنترل به صورت توکار دارای اسکرول نیست و اگر متن وارد شده توسط کاربر زیاد باشد برای مشاهده‬
‫تمام متن باید از کنترل ‪ JScrollPane‬استفاده کرد‪ .‬سازنده این کالس به روشهای زیر مقدار دهی میشود‪:‬‬
‫‪public‬‬ ‫)(‪JTextArea‬‬
‫‪public‬‬ ‫)‪JTextArea(Document document‬‬
‫‪public‬‬ ‫)‪JTextArea(String text‬‬
‫‪public‬‬ ‫)‪JTextArea(int rows, int columns‬‬
‫‪public‬‬ ‫)‪JTextArea(String text, int rows, int columns‬‬
‫‪public‬‬ ‫)‪JTextArea(Document document, String text, int rows, int columns‬‬
‫این کنترل دارای خاصیتهای مهم زیر میباشد‪:‬‬
‫توضیح‬ ‫خاصیت‬
‫تعداد ستونهای ‪ Textarea‬را مشخص میکند‬ ‫‪Columns‬‬
‫تعداد خطوط ‪ Textarea‬را مشخص میکند‬ ‫‪lineCount‬‬
‫مشخص میکند که زمانیکه به آخر یک سطر در ‪ Textarea‬رسیدیم بقیه متن در سطر بعدی نوشته شود یا نه‬ ‫‪lineWrap‬‬
‫تعداد سطرهای ‪ Textarea‬را مشخص میکند‬ ‫‪rows‬‬
‫مشخص میکند که با هر بار زدن دکمه ‪ Tab‬نشانگر ماوس چند کاراکتر به جلو رانده شود‪.‬‬ ‫‪tabSize‬‬
‫متدهای مهم این کنترل هم عبارتاند از‪:‬‬
‫رنگ متن انتخاب شده را مشخص میکند‪.‬‬ ‫)(‪setSelectedTextColor‬‬
‫رنگ پس زمینه متن انتخاب شده را مشخص میکند‪.‬‬ ‫)(‪setSelectionColor‬‬
‫قسمتی از متن ‪ Textarea‬را انتخاب میکند‪ .‬این متد دو عدد میگیرد که یکی نشان دهنده نقطه‬ ‫)(‪select‬‬
‫شروع و دیگری نشان دهنده نقطه پایان متن انتخابی است‪.‬‬

‫ متنی را که توسط کاربر‬select() ‫ متد‬،‫برای مثال‬.‫ برای متن انتخاب شده استفاده میشوند‬Textarea ‫بیشتر متدهای کنترل‬
:‫انتخاب شده است را مشخص میکند‬
select(selectionStart, selectionEnd)
:‫به کد زیر توجه کنید‬
2
5
7 {
9 {
10 JFrame frame1 = new JFrame("JTextArea Demo");
11
12 JTextArea TextArea1 = new JTextArea("JAVA programming is fun!");
13
14 TextArea1.select(5, 16);
15
17 Panel1.setLayout(new BorderLayout());
18 Panel1.add(TextArea1, BorderLayout.CENTER);
22 }
23 }
‫ برنامه را‬.‫ آن را انتخاب کردهایم‬31 ‫ تا اندیس‬1 ‫ از اندیس‬33 ‫ اضافه و در خط‬TextArea ‫ کد باال یک متن پیشفرض به‬35 ‫در خط‬
:‫اجرا کنید‬
‫‪111‬‬ ‫‪SWING‬‬
‫وقتی ما یک متن را انتخاب میکنیم‪ ،‬میتوانیم متن انتخاب شده را به وسیلهی تعدادی متد که بر روی متن انتخاب شده کار‬
‫میکنند قالب بندی کنیم‪ .‬برای مثال‪ ،‬شما میتوانید برای تغییر رنگ متن انتخاب شده از متد )(‪ setSelectedTextColor‬استفاده‬
‫کنید‪.‬همچنین میتوانید برای تغییر رنگ پس زمینهی آن از متد )(‪ setSelectionColor‬استفاده کنید‪ .‬بعد از خط ‪ 33‬کد باال‬
‫کدهای زیر را نوشته و برنامه را اجرا کنید‪:‬‬
‫;)‪TextArea1.setSelectedTextColor(Color.RED‬‬
‫;)‪TextArea1.setSelectionColor(Color.YELLOW‬‬
‫کنترل ‪JRadioButton‬‬
‫کنترل ‪ JRadioButton‬یا دکمه رادیویی دکمه ای است که دارای دو حالت خاموش و روشن میباشد‪ .‬دکمهی ‪JRadioButton‬‬
‫یک دکمهی دایره ای شکل به همراه یک برچسب است‪ .‬شما با کلیک کردن بر روی دکمهی ‪ JRadioButton‬میتوانید آنرا از حالت‬
‫خاموش به روشن ویا بلعکس تغییر دهید‪ .‬وقتی که یک دکمهی ‪ JRadioButton‬روشن باشد‪ ،‬یک نقطه در وسط آن قرار میگیرد‪،‬‬
‫و زمانی که خاموش باشد‪ ،‬دایرهی آن خالی است‪.‬‬
‫دکمههای رادیویی معموال زمانی استفاده میشوند که یک کاربر میبایست از بین چند گزینه یکی از آنها را انتخاب کند‪ .‬برای مثال‪:‬‬
‫زمانی که شما بخواهید جنسیت کاربر را مشخص کنید‪ ،‬میتوانید از دو دکمه رادیویی با نامهای مرد و زن استفاده کنید‪ .‬وقتی که‬
‫ به‬JRadioButton ‫ سازنده کالس‬.‫ فقط میتوانید یکی از آن دو را انتخاب کنید‬،‫شما از دکمههای رادیویی استفاده کردید‬
:‫روشهایی زیر مقداردهی میشود‬
public JRadioButton()
public JRadioButton(Icon icon)
public JRadioButton(Icon icon, boolean selected)
public JRadioButton(String text)
public JRadioButton(String text, boolean selected)
public JRadioButton(String text, Icon icon)
public JRadioButton(String text, Icon icon, boolean selected)
public JRadioButton(Action action)
:‫برای آشنایی با کاربرد دکمههای رادیویی به مثال زیر توجه کنید‬
2
6
8 {
10 {
11 final JFrame frame1 = new JFrame("JRadioButton Demo");
12
14 Panel1.setLayout(new GridLayout(3,1));
15
16 final JRadioButton radioButtonYes = new JRadioButton("Yes");
17 final JRadioButton radioButtonNo = new JRadioButton("NO");
18 JButton buttonShow = new JButton("Show Choice");
19
20 ButtonGroup ButtonGroup1 = new ButtonGroup();
21 ButtonGroup1.add(radioButtonYes);
22 ButtonGroup1.add(radioButtonNo);
23
24 Panel1.add(radioButtonYes);
25 Panel1.add(radioButtonNo);
26 Panel1.add(buttonShow);
27
29
30 class SelectedRadio implements ActionListener
31 {
32 @Override
34 {
35 if (radioButtonYes.isSelected())
36 {
37 JOptionPane.showMessageDialog(frame1, "You choosed Yes!");
38 }
39 else if (radioButtonNo.isSelected())
40 {
41 JOptionPane.showMessageDialog(frame1,"You choosed No!");
42 }
43 }
44 }
‫‪111‬‬ ‫‪SWING‬‬
‫‪45‬‬
‫‪46‬‬ ‫;))(‪buttonShow.addActionListener(new SelectedRadio‬‬
‫‪47‬‬
‫‪48‬‬ ‫;)‪frame1.setSize(356 , 263‬‬
‫‪50‬‬ ‫}‬
‫‪51‬‬ ‫}‬
‫هدف از کد باال این است که با کلیک بر روی یک دکمه یک پیام مبنی بر انتخاب یک دکمه به کاربر نمایش داده شود‪ .‬در خطوط ‪-33‬‬
‫‪ 33‬یک ‪ Frame‬و یک ‪ Panel‬و در خطوط ‪ 31-30‬دو عدد دکمهی رادیویی با نامهای ‪ radioButtonYes‬و ‪ radioButtonNo‬و یک‬
‫کنترل ‪ Button‬با نام ‪ buttonShow‬ایجاد کردهایم‪ .‬این دکمهها را در خطوط ‪ 53-51‬به ‪ Panel‬اضافه میکنیم‪ .‬در جاوا به طور‬
‫همزمان میتوان دو دکمه رادیویی را در حالت انتخاب قرار داد‪ ،‬در حالیکه انتظاری که ما از دکمههای رادیویی داریم این است که‬
‫همزمان یکی از آنها قابل انتخاب باشد‪ .‬برای رفع این مشکل در جاوا کالسی به نام ‪ ButtonGroup‬وجود دارد که با اضافه کردن‬
‫دکمهها به یک شیء از این کالس (خطوط ‪ )53-55‬این امکان را به وجود میآوریم که همزمان یکی از دکمهها انتخاب شود‪ .‬برای‬
‫اداره رویداد کلیک دکمه در خطوط ‪ 13-33‬یک کالس ایجاد میکنیم که رابط ‪ ActionListener‬را پیاده سازی میکند‪ .‬سپس در‬
‫داخل بدنه متد )(‪ actionPerformed‬مربوط به این رابط هم کدهای خطوط ‪ 11-35‬را مینویسیم‪.‬‬
‫وقتی که شما بر روی ‪ buttonShow‬کلیک میکنید‪ ،‬برنامه تعیین میکند که کدام ‪ JRadioButton‬انتخاب شده است‪ .‬شما‬
‫میتوانید این کار را به وسیلهی متد )(‪ isSelected‬انجام دهید‪ .‬این متد در صورتیکه یک کنترل انتخاب شده باشد مقدار ‪true‬‬
‫در غیر اینصورت ‪ false‬را بر میگرداند‪ .‬ما از یک عبارت شرطی ‪ if‬برای تعیین اینکه ‪ JRadioButton‬انتخاب شده است یا خیر‬
‫استفاده میکنیم‪ .‬اگر آن انتخاب نشده باشد‪ ،‬پس دکمهی ‪ JRadioButton‬ی دیگر انتخاب شده است‪ .‬چون ما فقط دو دکمهی‬
‫‪ JRadioButton‬بر روی فرم دارم و نهایتا یکی از آنها انتخاب میشود‪.‬‬

‫کنترل ‪JCheckBox‬‬
‫کنترل ‪ JCheckBox‬یک دکمه است و به شکل یک جعبهی خالی به همراه یک برچسب در کنار آن نمایش داده میشود‪ .‬در حالت‬
‫عادی‪ ،‬زمانی که بر روی جعبهی خالی کلیک شود‪ ،‬یک تیک در داخل جعبه نمایان میشود که به ما میگوید کنترل ‪JCheckBox‬‬
‫در حالت ‪ Selected‬قرار دارد‪ .‬برخالف دکمهی ‪ Radio‬که فقط اجازهی انتخاب یکی از ‪ Radio‬های فرم را به ما میداد‪ ،‬شما‬
‫میتوانید چند عدد ‪ CheckBox‬و یا همهی آنها را تیک بزنید‪ .‬سازنده کالس ‪ JCheckBox‬به روشهای زیر مقداردهی میشود‬
‫‪:‬‬
111 SWING
public JCheckBox()
public JCheckBox(Icon icon)
public JCheckBox(Icon icon, boolean selected)
public JCheckBox(String text)
public JCheckBox(String text, boolean selected)
public JCheckBox(String text, Icon icon)
public JCheckBox(String text, Icon icon, boolean selected)
public JCheckBox(Action action)
‫ در نتیجه شما به سادگی میتوانید از متد‬،‫ (تیک خورده و تیک نخورده) را قبول کند‬Off ‫ یا‬On ‫ دو حالت‬JCheckBox
‫ تیک نخورده‬JCheckBox ‫ به معنی اینکه‬False ‫ تیک خورده و‬JCheckBox ‫ به معنی اینکه‬True ‫ که دو مقدار‬isSelected()
:‫ را مشاهده میکنید‬CheckBox ‫ در مثال زیر نحوهی کاربرد کنترل‬.‫ استفاده کنید‬،‫است را بر میگرداند‬
2
6
8 {
10 {
11 final JFrame frame1 = new JFrame("JCheckBox Demo");
12
15
16 final JCheckBox CheckBox1 = new JCheckBox("Soap");
17 final JCheckBox CheckBox2 = new JCheckBox("Shampoo");
18 final JCheckBox CheckBox3 = new JCheckBox("Toothpaste");
19 JButton buttonShow = new JButton("Show Choice");
20
21 Panel1.add(CheckBox1);
24 Panel1.add(buttonShow);
25
27
28 class SelectedCheckBox implements ActionListener
29 {
30 @Override
32 {
33 String items = "";
34 if (CheckBox1.isSelected())
35 {
36 items += "\n Soap";
37 }
39 {
40 items += "\n Shampoo";
41 }
43 {
44 items += "\n Toothpaste";
‫‪45‬‬ ‫}‬
‫‪46‬‬ ‫;)‪JOptionPane.showMessageDialog(frame1, items‬‬
‫‪47‬‬ ‫}‬
‫‪48‬‬ ‫}‬
‫‪49‬‬
‫‪50‬‬ ‫;))(‪buttonShow.addActionListener(new SelectedCheckBox‬‬
‫‪51‬‬
‫‪52‬‬ ‫;)‪frame1.setSize(356 , 263‬‬
‫‪54‬‬ ‫}‬
‫‪55‬‬ ‫}‬
‫در کد باال قرار است که وقتی کاربر چک باکسها را انتخاب و سپس بر روی دکمه کلیک کرد نام چک باکسهای انتخاب شده‬
‫نمایش داده شود‪ .‬در خطوط ‪ 33-51‬یک ‪ Frame‬ایجاد کردهایم‪ .‬سپس سه کنترل ‪ JCheckBox‬و یک دکمه را به یک ‪ Panel‬و‬
‫خود ‪ Panel‬را به ‪ Frame‬اضافه نمودهایم‪ .‬برای اداره رویداد کلیک دکمه در خطوط ‪ 13-33‬یک کالس ایجاد میکنیم که رابط‬
‫‪ ActionListener‬را پیاده سازی میکند‪ .‬سپس در داخل بدنه متد )(‪ actionPerformed‬مربوط به این رابط هم کدهای خطوط‬
‫‪ 11-31‬را مینویسیم‪ .‬در این کد‪ ،‬یک متغیر از نوع رشته ای تعریف کردهایم و آنرا با یک رشتهی تهی مقدار دهی کردهایم‪ .‬سپس‬
‫چک میکنیم که کدام یک از چک باکسها تیک خوردهاند‪ ،‬هر کدام از آنها که تیک خوردهاند نامشان به وسیلهی عملگر ‪ =+‬در‬
‫رشته ای که قبال به صورت تهی تعریف کردهایم قرار میگیرد‪ .‬سپس به وسیلهی یک پیغام )‪ (JOptionPane‬نتایج را در خروجی‬
‫نمایش میدهیم‪.‬‬
116 SWING
JPanel ‫کنترل‬
:‫ سازنده این کالس به روشهای زیر مقداردهی میشود‬.‫ معموال برای گروه بندی کنترلهای فرم بکار میرود‬JPanel ‫کنترل‬
public JPanel()
public JPanel(boolean isDoubleBuffered)
public JPanel(LayoutManager manager)
public JPanel(LayoutManager manager, boolean isDoubleBuffered)
‫ با توجه به اینکه فقط یکی از‬.‫ را گروه بندی کنید‬Radio ‫ این است که شما میخواهید دکمههای‬Panel ‫یکی از کاربردهای خوب‬
‫شما میتوانید با گروه بندی کردن آنها بیش از یک دکمهی‬ ،‫ در فرم میتواند فعال باشد‬JRadioButton ‫دکمههای‬
JPanel ‫ آن کنترل به فرزند‬،‫ قرار میدهید‬JPanel ‫ وقتی که شما کنترلی را در داخل یک‬.‫ فعال داشته باشید‬JRadioButton
،‫ بر درک این مساله کافیست‬،‫ بر درک این مساله کافیست به عنوان مثال‬.‫ به والد کنترل تبدیل میشود‬JPanel ‫تبدیل میشود و‬
:‫ به کد زیر توجه کنید‬.‫ قرار دارد به همراه آن حرکت میکند‬JPanel ‫ هر کنترلی که در داخل‬.‫ را تغییر اندازه دهید‬JPanel
2
6
8 {
10 {
11 JFrame frame1 = new JFrame("JCheckBox Demo");
12 frame1.setLayout(new GridLayout(1,2));
13
17 (new MatteBorder(1, 1, 1, 1, Color.lightGray),"Group One"));
18
22 (new MatteBorder(1, 1, 1, 1, Color.lightGray),"Group Two"));
23
24 JRadioButton JRadioButton1 = new JRadioButton("JRadioButton1");
28
30 ButtonGroup1.add(JRadioButton1);
32
‫‪36‬‬
‫‪37‬‬ ‫;)‪Panel1.add(JRadioButton1‬‬
‫‪39‬‬
‫‪42‬‬
‫‪45‬‬
‫‪46‬‬ ‫;)‪frame1.setSize(356 , 263‬‬
‫‪48‬‬ ‫}‬
‫‪49‬‬ ‫}‬
‫در کد باال و در خطوط ‪ 33-55‬یک ‪ Frame‬و دو ‪ Panel‬و در خطوط ‪ 31‬و ‪ 53‬دو حاشیه هم به ‪Panel‬ها همراه با عنوان برای آنها‬
‫ایجاد کردهایم‪ .‬در خطوط ‪ 53-11‬چهار دکمه رادیویی ایجاد کرده و آنها را در دو گروه‪ ،‬گروه بندی میکنیم (خطوط ‪ .)56-11‬گروه‬
‫اول (‪ JRadioButton1‬و ‪ )JRadioButton2‬را در ‪ Panel1‬و گروه دوم (‪ JRadioButton1‬و ‪ )JRadioButton2‬را در ‪Panel2‬‬
‫قرار میدهیم (خطوط ‪ .)11-33‬حال برنامه را اجرا و نتیجه را با انتخاب دکمهها مشاهده کنید ‪:‬‬
‫کنترل ‪JComboBox‬‬
103 SWING
‫ کنترل‬.‫ (نوار کرکره ای ) روش دیگری است که به کاربر اجازه دهید از بین گزینههای مختلف یکی را انتخاب کند‬JComboBox ‫کنترل‬
،‫ وقتی بر روی دکمهی آن کلیک شود‬.‫ است که در سمت راست آن یک دکمه قرار دارد‬TextBox ‫ شبیه یک کنترل‬JComboBox
‫ کاربر میتواند از بین این‬.‫ یک نوار کرکره ای را که حاوی یک لیست از گزینههای مختلف است را نمایش میدهد‬JComboBox
‫ سازنده این کالس به روشهای زیر‬.‫ تبدیل میشود‬JComboBox ‫ مورد انتخاب شده به متن داخل‬.‫گزینهها یکی را انتخاب کند‬
:‫مقداردهی میشود‬
public JComboBox()
public JComboBox(Object listData[])
public JComboBox(Vector listData)
public JComboBox(ComboBoxModel model)
:‫ آشنا میشوید‬JComboBox ‫در مثال زیر با کاربرد‬
2
5
7 {
9 {
10 final JFrame frame1 = new JFrame("JComboBox Demo");
12 final JComboBox ComboBox1 = new JComboBox();
13 Panel1.add(ComboBox1);
15
16 ComboBox1.addItem("Johnny");
17 ComboBox1.addItem("Kenneth");
18 ComboBox1.addItem("Mark");
19 ComboBox1.addItem("Ralph");
20 ComboBox1.addItem("Sussie");
21
22 class MyItemListener implements ActionListener
23 {
25 {
26 String selectedName = ComboBox1.getSelectedItem().toString();
27 JOptionPane.showMessageDialog(frame1, selectedName);
28 }
29 }
30
31 ComboBox1.addActionListener(new MyItemListener() );
32
35 }
36 }
‫کال هدف از برنامه باال این است که با کلیک بر روی هر آیتم از ‪ JComboBox‬مقدار آن به صورت پیام نمایش داده شود‪ .‬در خطوط‬
‫‪ 33-33‬کد باال یک ‪ ،Frame‬یک ‪ Panel‬و یک ‪ ComboBox‬ایجاد کردهایم‪ .‬در خطوط ‪ 31-53‬آیتمهایی را که قرار است به ‪JComboBox‬‬
‫اضافه شوند را با استفاده از متد )(‪ addItem‬اضافه میکنیم‪ .‬چون که قرار است با کلیک بر روی آیتمهای کمبوباکس پیام نمایش‬
‫داده شود پس باید رابط ‪ ActionListener‬توسط یک کالس پیاده سازی شود‪ .‬این کار را در خط ‪ 55‬انجام دادهایم‪ .‬در خطوط‬
‫‪ 51-51‬هم کدهای بدنه متد )(‪ actionPerformed‬این رابط را فراهم میکنیم‪ .‬در خط ‪ 51‬یک رشته تعریف کردهایم و با استفاده‬
‫از متد )(‪ getSelectedItem‬کنترل ‪ JComboBox‬مقدار آیتم انتخاب شده را در داخل این رشته میریزیم‪ .‬در خط ‪ 51‬هم با‬
‫استفاده از کالس ‪ JOptionPane‬مقدار این رشته که همان آیتم انتخاب شده کمبوباکس است را نمایش میدهیم‪:‬‬
‫برای اضافه کردن آیتمها به کمبوباکس به صورت زیر هم میتوان عمل کرد‪:‬‬
‫;} "‪String[] items = { "Johnny", "Kenneth", "Mark", "Ralph", "Sussie‬‬
‫;)‪JComboBox ComboBox1 = new JComboBox(items‬‬
‫در این روش یک آرایه از نوع رشته تعریف و سپس آیتمهای مورد نظرتان را به آن اضافه میکنید‪ .‬سپس نام آرایه را به سازنده‬
‫کالس ‪ JComboBox‬ارسال میکنید‪ .‬آیتمهای کمبوباکس دارای اندیس هستند و این اندیسها از صفر شروع میشوند‪ .‬اندیس‬
‫‪101‬‬ ‫‪SWING‬‬
‫اولین آیتم ‪ ،3‬اندیس دومین آیتم ‪ 3‬و ‪ … .‬برای به دست آوردن اندیس آیتم انتخاب شده از متد )(‪getSelectedIndex‬‬
‫استفاده میشود‪ .‬خط ‪ 51‬کد باال را به صورت زیر تغییر دهید‪:‬‬
‫;))(‪String selectedName = String.valueOf(ComboBox1.getSelectedIndex‬‬
‫برنامه را اجرا و با انتخاب یک آیتم نتیجه را مشاهده کنید‪:‬‬
‫کنترل ‪JList‬‬
‫کنترل ‪ JList‬برای نمایش لیستی از آیتمها که قابل انتخاب هستند استفاده میشود‪.‬این آیتمها را میتوانید به صورت تکی و‬
‫گروهی انتخاب کنید‪ .‬کنترل ‪ JList‬بهترین گزینه برای مواقعی است که شما میخواهید تعداد زیادی آیتم را در ستونهای افقی‬
‫و عمودی نمایش دهید‪ .‬سازنده این کالس به روشهای زیر مقداردهی میشود‪:‬‬
‫)(‪public JList‬‬
‫)][‪public JList(Object listData‬‬
‫)‪public JList(Vector listData‬‬
public JList(ListModel model)
:‫برای آشنایی بیشتر با خاصیتها و متدهای این کنترل به مثال زیر توجه کنید‬
2
4
6 {
8 {
9 JFrame frame1 = new JFrame("JList Demo");
11 JList List1 = new JList();
12 Panel1.add(List1);
14
15 String[] items = { "Johnny", "Kenneth", "Mark", "Ralph", "Sussie" };
16 List1.setListData(items);
17
20 }
21 }
JList ‫ حال نوبت به اضافه کردن آیتمها به‬.‫ ایجاد کردهایم‬JList ‫ و‬Panel ،Frame ‫ سه کنترل‬6-31 ‫در کد باال و در خطوط‬
setListData() ‫ این آرایه را به متد‬31 ‫ در خط‬.‫ یک آرایه رشته ای تعریف و آیتمها را به آن اضافه میکنیم‬31 ‫ در خط‬.‫میرسد‬
:‫ میتوان از کد زیر استفاده کرد‬31 ‫ و‬31 ‫ به جای خطوط‬.‫ اضافه میکند‬JList ‫ارسال میکنیم و این متد آیتمها را به‬
DefaultListModel DefaultListModel1 = new DefaultListModel();

DefaultListModel1.addElement("Johnny");
DefaultListModel1.addElement("Kenneth");
DefaultListModel1.addElement("Mark");
DefaultListModel1.addElement("Ralph");
DefaultListModel1.addElement("Sussie");
List1.setModel(DefaultListModel1);
‫ با استفاده‬.‫ میباشد‬JList ‫ کالسی است که دارای متدهایی برای حذف و اضافه و در کل دستکاری آیتمهای‬DefaultListModel
‫ ارسال‬setListData() ‫ آیتمها را به یک شیء از کالس مذکور اضافه و سپس این شیء را به متد‬addElement() ‫از متد‬
:‫برنامه را اجرا و نتیجه را مشاهده کنید‬. ‫میکنیم‬

‫‪101‬‬ ‫‪SWING‬‬
‫کالس ‪ DefaultListModel‬دارای متد )(‪ remove‬برای حذف یک آیتم میباشد این متد اندیس آیتمی را که میخواهید حذف‬
‫کنید را دریافت میکند‪:‬‬
‫;)‪DefaultListModel1.remove(2‬‬
‫برای حذف چند آیتم از ‪ JList‬هم میتوان از متد )(‪ removeRange‬که اندیس شروع و پایان آیتمهایی که پشت سر هم هستند‬
‫و میخواهید حذف کنید را میگیرد‪:‬‬
‫;)‪DefaultListModel1.removeRange(2,4‬‬
‫در حالت پیشفرض با گرفتن دکمه ‪ Ctrl‬کیبورد و کلیک بر روی آیتمها میتوان چند آیتم را به طور همزمان انتخاب کرد ولی اگر‬
‫بخواهید فقط یک آیتم قابل انتخاب باشد میتوانید از متد )(‪ setSelectionMode‬و ارسال مقدار ثابت ‪SINGLE_SELECTION‬‬
‫از رابط ‪ ListSelectionModel‬به آن استفاده کرد‪.‬همان کد ابتدای درس را در در نظر بگیرید‪ .‬در خط ‪ 31‬کد فوق کدهای زیر را‬
‫بنویسید‪:‬‬
‫;)‪List1.setSelectionMode(ListSelectionModel.SINGLE_SELECTION‬‬
‫برای تعیین عرض و ارتفاع آیتمها از متدهای )(‪ setFixedCellWidth‬برای تعیین عرض و )(‪ setFixedCellHeight‬برای‬
‫تعیین ارتفاع سلولها استفاده میشود‪:‬‬

‫;)‪List1.setFixedCellWidth(100‬‬
‫;)‪List1.setFixedCellHeight(50‬‬
‫برای نمایش سطری و ستونی آیتمها میتوان از متدهای )(‪ setLayoutOrientation‬برای تعیین نحوه چیدمان افقی یا عمودی‬
‫آیتمها و )(‪ setVisibleRowCount‬برای تعیین سطرهای ‪ JList‬که قرار است آیتمها در آنها نمایش داده شوند استفاده کرد‪.‬‬
‫در ادامه کدهای باال کدهای زیر را بنویسید‪:‬‬
‫;)‪List1.setLayoutOrientation(JList. HORIZONTAL_WRAP‬‬
‫;)‪List1.setVisibleRowCount(2‬‬
‫مقدار ‪ HORIZONTAL_WRAP‬باعث چینش افقی آیتمها میشود‪ .‬آیتمها به طور خودکار طوری در ستونها قرار میگیرند که تعداد‬
‫سطرها بیشتر از آن مقداری که تعیین کردهایم نشود‪:‬‬

‫‪101‬‬ ‫‪SWING‬‬
‫حال مقدار را به ‪ VERTICAL_WRAP‬تغییر داده و برنامه را اجرا و نتیجه را مشاهده کنید‪:‬‬
‫و‬ ‫)(‪setSelectionBackground‬‬ ‫متدهای‬ ‫از‬ ‫هم‬ ‫آیتمها‬ ‫فونت‬ ‫رنگ‬ ‫و‬ ‫زمینه‬ ‫پس‬ ‫رنگ‬ ‫تعیین‬ ‫برای‬
‫)(‪ setSelectionForeground‬استفاده میشود‪ .‬کدهای زیر را هم به کد باال اضافه کنید‪:‬‬
‫;)‪List1.setSelectionBackground(Color.RED‬‬
‫;)‪List1.setSelectionForeground(Color.WHITE‬‬
‫کنترل ‪JSpinner‬‬
‫کنترل ‪ JSpinner‬عموما برای دریافت اعداد از ورودی و محدود کردن کاربران برای وارد کردن مقادیر عددی بکار میرود‪ .‬کنترل‬
‫‪ JSpinner‬از لحاظ شکل ظاهری شبیه به کنترل ‪ TextBox‬است با این تفاوت که دکمههایی به شکل پیکان در سمت چپ یا‬
‫راست آن برای افزایش و یا کاهش مقدار کنترل وجود دارند‪ .‬مقدار عددی کنترل ‪ JSpinner‬میتواند از نوع اعشاری یا صحیح‬
‫باشد‪ .‬سازنده این کالس به روشهای زیر مقداردهی میشود‪:‬‬
‫)(‪public JSpinner‬‬
‫)‪public JSpinner(SpinnerModel model‬‬
‫حال میخواهیم یک برنامه بسازیم که کنترل ‪ JSpinner‬در آن بکار رفته باشد‪ .‬به کد زیر توجه کنید‪:‬‬

‫‪2‬‬
‫‪6‬‬
‫‪8‬‬ ‫{‬
‫‪10‬‬ ‫{‬
‫‪11‬‬ ‫;)"‪final JFrame frame1 = new JFrame("JSpinner Demo‬‬
‫‪12‬‬ ‫;))(‪frame1.setLayout(new BorderLayout‬‬
‫‪13‬‬
106 SWING

17
18 JLabel label1 = new JLabel("Price");
19 JLabel label2 = new JLabel("Quantity");
20
21 SpinnerNumberModel Pricemodel = new SpinnerNumberModel(0, 0, 10000, 0.5);
22 final JSpinner SpinnerUpDownPrice = new JSpinner(Pricemodel);
23 SpinnerNumberModel Quantitymodel = new SpinnerNumberModel(0, 0, 100, 1);
24 final JSpinner SpinnerUpDownQuantity = new JSpinner(Quantitymodel);
25
26 JButton Button1 = new JButton("Culculate");
27
28 Panel1.add(label1);
29 Panel1.add(SpinnerUpDownPrice);
30 Panel1.add(label2);
31 Panel1.add(SpinnerUpDownQuantity);
32 Panel2.add(Button1);
33 frame1.add(Panel1, BorderLayout.CENTER);
34 frame1.add(Panel2, BorderLayout.SOUTH);
35
36 class MyItemListener implements ActionListener
37 {
39 {
40 double price = (double)SpinnerUpDownPrice.getValue();
41 int quantity = (int)SpinnerUpDownQuantity.getValue();
42 double total;
43
44 total = price* quantity;
45
46 JOptionPane.showMessageDialog(frame1,"The total price is " + total);
47 }
48 }
49
50 Button1.addActionListener(new MyItemListener() );
51
54 }
55 }
‫ با نامهای‬JSpinner ‫ دو‬،Label ‫ دو‬،Panel ‫ دو‬،Frame ‫ فقط یک‬.‫ کار خاصی انجام ندادهایم‬33-13 ‫در کد باال و در خطوط‬
‫ میتوان گفت که تنها نکته کد باال در خطوط‬.‫ و یک دکمه ایجاد کردهایم‬SpinnerUpDownQuantity ‫ و‬SpinnerUpDownPrice
،‫ یک واحد از مقدار پیشفرض آن یعنی صفر‬JSpinner ‫ در حالت پیشفرض با زدن دکمههای پایین و باالی‬.‫ نهفته است‬51 ‫ و‬53
SpinnerNumberModel ‫ برای محدود کردن کاربران به یک محدود خاص از اعداد از کالس‬.‫کم یا یک واحد به آن اضافه میشود‬
‫ همانطور که در کد باال‬.‫ وارد میشود را محدود میکند‬JSpinner ‫ این کالس ورودیهایی که توسط کاربر در‬.‫استفاده میشود‬
‫ دو عدد بعدی‬،JSpinner ‫ پارامتر میگیرد که اولین عدد مبنای شروع افزایش و کاهش عدد‬3 ‫مشاهده میکنید سازنده این کالس‬
‫ این‬.‫ است‬JSpinner ‫محدوده ای است که ورودیهای کاربر در آن قرار میگیرند و چهارمین عدد هم مقدار افزایش و کاهش عدد‬
‫اعداد همگی میتوانند هم ‪ double‬و هم ‪ int‬باشند‪ .‬در خطوط ‪ 55‬و ‪ 53‬هم اشیاء ساخته شده از این کالس را به سازنده کنترل‬
‫‪ JSpinner‬ارسال کردهایم تا محدودیتها را بر روی آنها اعمال کند‪.‬‬
‫در خط ‪ 53‬آخرین پارامتر ‪ Pricemodel‬برابر با ‪ 3.13‬قرار دادهایم‪ ،‬بنابراین مقدار ‪ SpinnerUpDownPrice‬به اندازه ‪ 3.13‬واحد‬
‫کم یا زیاد میشود‪ .‬مقدار سومین پرامتر یعنی نهایت عددی که کاربر میتواند وارد کند ‪ 3333‬است‪ ،‬پس قیمت )‪ (Price‬به آن‬
‫محدود میشود و کاربر نمیتواند رقمی باالتر از آنرا وارد کند‪.‬‬
‫از آنجاییکه نهایت مقدار ‪ Quantitymodel‬را برابر ‪ 333‬قرار دادهایم بنابراین شما میتوانید فقط مقادیری نهایتا تا ‪ 333‬را در‬
‫‪ SpinnerUpDownQuantity‬وارد کنید‪ .‬چون میخواهیم با وارد کردن دو مقدار در دو ‪ JSpinner‬و سپس زدن دکمه پیامی نمایش‬
‫داده شود باید رویداد کلیک دکمه را مدیریت کنیم‪ .‬این کار را در خطوط ‪ 11-13‬انجام دادهایم‪ .‬در خطوط ‪ 33‬و ‪ 33‬مقادیری را که در‬
‫دو ‪ JSpinner‬توسط کاربر وارد شده است را توسط متد )(‪ getValue‬به دست میآوریم و سپس با عمل ‪ cast‬به نوع ‪double‬‬
‫و ‪ int‬تبدیل میکنیم‪ .‬سپس در خط ‪ 33‬حاصلضرب این دو مقدار را در متغیر ‪ total‬ریخته و مقدار این متغیر را در خط ‪ 31‬چاپ‬
‫میکنیم‪:‬‬
163 SWING
JSlider ‫کنترل‬
‫ ناحیه‬.‫ شبیه یک نوار لغزنده با یک دستگیره است که با استفاده از این دستگیره میتوان مقدار آن را تعیین کنید‬JSlider ‫کنترل‬
‫ کاربر میتواند دستگیره به در جهت افقی حرکت دهد و‬. ‫ای که دستگیره به آن اشاره میکند نشان دهنده مقدار جاری کنترل است‬
‫ مقدار این کنترل در حالت افقی از سمت چپ به راست و در حالت‬.‫همچنین میتوان جهت حرکت را به صورت عمودی تغییر داد‬
:‫ سازنده این کالس به روشهای زیر مقداردهی میشود‬.‫عمودی از پایین به باال افزایش مییابد‬
public JSlider()
public JSlider(int orientation)
public JSlider(int minimum, int maximum)
public JSlider(int minimum, int maximum, int value)
public JSlider(int orientation, int minimum, int maximum, int value)
public JSlider(BoundedRangeModel model)
:‫ و استفاده از متدهای آن آمده است‬JSlider ‫در زیر نحوه ایجاد و استفاده از‬
2
4
6 {
8 {
9 final JFrame frame1 = new JFrame("JSpinner Demo");
11 JSlider Slider = new JSlider(JSlider.HORIZONTAL, 0, 255, 0);
12 Panel1.add(Slider);
14
15 Slider.setMinorTickSpacing(10);
16 Slider.setMajorTickSpacing(50);
17
18 Slider.setPaintLabels(true);
19 Slider.setPaintTicks(true);
20
23 }
24 }
(JSlider.HORIZONTAL) ‫ به صورت افقی‬Slider ‫ ایجاد کردهایم و در داخل سازنده نحوه نمایش‬Slider ‫ کد باال یک‬33 ‫در خط‬
‫ در خطوط‬.‫ آخر هم نقطه شروع اسالیدر میباشد‬3 ‫ هم بازه ای است که اسالیدر میگیرد و عدد‬511 ‫ و‬3 ‫ عدد‬. ‫مشخص شده است‬
‫ و از متد‬Slider ‫ ایجاد درجههای بزرگ بر روی‬setMajorTickSpacing() ‫ از متد‬.‫ هم این اسالیدر را درجه بندی کردهایم‬31-36
‫ و‬setPaintLabels() ‫ برای ایجاد درجههای کوچک در بین دو درجه بزرگ و از متدهای‬setMinorTickSpacing()
:‫ برنامه را اجرا و نتیجه را مشاهده کنید‬.‫ برای نمایش درجهها و برچسبهای آنها استفاده میشود‬setPaintTicks()
.‫ را تغییر داده تا عملکرد این آنها را بهتر درک کنید‬31 ‫ و‬31 ‫) و متدهای خطوط‬33 ‫توصیه میشود که مقادیر موجود در سازنده (خط‬
‫ حال اجازه دهید که یک‬.‫ تغییر داده تا کاربرد این دو متد را متوجه شوید‬false ‫ را به‬30 ‫ و‬36 ‫ خطوط‬true ‫همچنین مقادیر‬
‫ به کد زیر توجه‬.‫ تغییر کند‬Panel ‫ ها رنگ پس زمینه یک‬Slider ‫ باشد و با تغییر مقادیر‬Slider ‫برنامه بنویسیم که دارای سه‬
:‫کنید‬
2
5 import javax.swing.event.*;
6
8 {
10 {
11 final JFrame frame1 = new JFrame("JSlider Demo");
13
16
17 JLabel Label1 = new JLabel("RED");
18 JLabel Label2 = new JLabel("GREEN");
19 JLabel Label3 = new JLabel("BLUE");
20
21 final JSlider SliderGreen = new JSlider(JSlider.HORIZONTAL,0,255,0);
22 final JSlider SliderRed = new JSlider(JSlider.HORIZONTAL,0,255,0);
23 final JSlider SliderBlue = new JSlider(JSlider.HORIZONTAL,0,255,0);
24 SliderGreen.setMinorTickSpacing(15);
25 SliderRed.setMinorTickSpacing(15);
26 SliderBlue.setMinorTickSpacing(15);
27 SliderGreen.setPaintTicks(true);
28 SliderRed.setPaintTicks(true);
29 SliderBlue.setPaintTicks(true);
30
31 Panel1.add(Label1);
32 Panel1.add(SliderRed);
161 SWING
34 Panel1.add(SliderGreen);
36 Panel1.add(SliderBlue);
37
38 final JPanel Panel2 = new JPanel();
39 Panel2.setPreferredSize(new Dimension(0,150));
40 Panel2.setBackground(Color.BLACK);
41
42 frame1.add(Panel1, BorderLayout.CENTER);
43 frame1.add(Panel2, BorderLayout.SOUTH);
44
45 class ColorPicker implements ChangeListener
46 {
47 public void stateChanged(ChangeEvent changeEvent)
48 {
49 int red = SliderRed.getValue();
50 int green = SliderGreen.getValue();
51 int blue = SliderBlue.getValue();
52 Color color = new Color(red, green, blue);
53 Panel2.setBackground(color);
54 }
55 }
56
57 SliderGreen.addChangeListener(new ColorPicker());
58 SliderRed.addChangeListener(new ColorPicker());
59 SliderBlue.addChangeListener(new ColorPicker());
60
63 }
64 }
‫ قرار دادهایم تا بتوانیم دو پنل را‬BorderLayout ‫ نحوه الیه بندی آن را‬35 ‫ ایجاد کردهایم و در خط‬Frame ‫ کد باال یک‬33 ‫در خط‬
‫ در خطوط‬.‫ سطر و دو ستون تقسیم کردهایم‬1 ‫ آن را به‬31 ‫ اولین پنل را ایجاد و در خط‬33 ‫ در خط‬.‫در وسط و پایین آن قرار دهیم‬
‫ چون کد رنگها‬.‫ قرار دادهایم‬3-511 ‫ ایجاد و مقادیر آنها را بین‬Slider ‫ سه‬53-56 ‫ در خطوط‬.‫ ایجاد کردهایم‬Label ‫ سه‬31-36
‫ و‬Label 13-11 ‫ در خطوط‬.‫) میباشد‬511,511,511( ‫) و کد رنگ سفید‬3,3,3( ‫ مثال رنگ کد سیاه‬.‫در همین بازه قرار دارند‬
‫ دوم را ایجاد کرده و یک ارتفاع به ان میدهیم و رنگ‬Panel 10-33 ‫ در خطوط‬.‫ اولی اضافه میکنیم‬Panel ‫ ها را به‬Slider
‫ دارند‬3 ‫ ها مقدار‬Slider ‫ چون زمانی که برنامه را اجرا میکنیم در حالت پیشفرض کل‬.‫پیشفرض پس زمینه آن را سیاه میدهیم‬
:‫و این کد رنگ سیاه است‬

‫هنگام که دستگیره ‪ Slider‬به دو طرف حرکت میدهیم در اصل رابط ‪ ChangeListener‬پیاده سازی میشود‪ .‬این رابط را در خط‬
‫‪ 31‬توسط یک کالس پیاده سازی می کنیم و در داخل بدنه متد )(‪ stateChanged‬این رابط کدهای زیر را مینویسیم‪:‬‬
‫;)(‪int red = SliderRed.getValue‬‬

‫;)(‪int green = SliderGreen.getValue‬‬
‫;)(‪int blue = SliderBlue.getValue‬‬
‫;)‪Color color = new Color(red, green, blue‬‬
‫;)‪Panel2.setBackground(color‬‬
‫در کدهای باال با استفاده از متد )(‪ getValue‬مقادیر هر یک از ‪ Slider‬ها را میگیریم‪ .‬این مقادیر از نوع صحیح هستند‪ .‬سپس‬
‫همین مقادیر را در خط ‪ 15‬به به سازنده کالس ‪ Color‬ارسال میکنیم‪ .‬وظیفه این کالس ایجاد رنگ است‪ .‬سپس یک شیء از این‬
‫کالس را به متد )(‪ setBackground‬در خط ‪ 11‬میدهیم تا رنگ را بر روی ‪ Panel‬دومی اعمال کند‪ .‬و در آخر یک شیء از کالسی‬
‫که رابط را پیاده سازی میکند یعنی ‪( ColorPicker‬خط ‪ )31‬به متد )(‪ addChangeListener‬در خطوط ‪ 11-16‬ارسال میکنیم‪.‬‬
‫برنامه را اجرا و دستگیرههای ‪ Slider‬ها را جابه جا و نتیجه را مشاهده کنید‪.‬‬

‫‪161‬‬ ‫‪SWING‬‬
‫کنترل ‪JTabbedPane‬‬
‫کنترل ‪ JTabbedPane‬به شما اجازه میدهد که برای پنجرههای خود سربرگ )‪ (Tab‬بسازید‪ ،‬شما در برنامههای زیادی این نوع‬
‫پنجرهها را مشاهده کردهاید‪ .‬برای مثال پنجرهی ‪ Properties‬فایلها‪.‬‬

‫‪ JTabbedPane‬میتواند حاوی کنترلهای دیگر باشد‪ .‬با کلیک بر روی هر سربرگ )‪ (Tab‬میتوانید محتویات آنرا مشاهده کنید‪.‬‬
‫ظاهر یک سربرگ فعال با دیگر سربرگها متفاوت است‪ ،‬بنابراین شما میتوانید متوجه شوید که کدام یک از سربرگها فعال است‪.‬‬
‫زمانی که شما بر روی یک سربرگ کلیک میکنید‪ ،‬کنترلهایی که به آن تعلق دارند نمایش داده میشوند‪ JTabbedPane .‬به شما‬
‫اجازه میدهد که یک فرم را در داخل سربرگهای مختلف سازماندهی کنید‪ ،‬به طوری که هر سربرگ یک دسته را نمایش دهد‪ .‬برای‬
‫مثال‪،‬میتوانید یک فرم که حاوی اطالعات شخصی را در سربرگ ‪ Personal Info‬و پیش زمینهی آموزشی را در سربرگ‬
‫‪ Educational Background‬قرار دهید‪ .‬سازنده این کالس به روشهای زیر مقداردهی میشود‪:‬‬
‫)(‪public JTabbedPane‬‬
‫)‪public JTabbedPane(int tabPlacement‬‬
‫)‪public JTabbedPane(int tabPlacement, int tabLayoutPolicy‬‬
‫برای اضافه کردن یک کنترل ‪ TabContorl‬میتوان به صورت زیر عمل نمود‪:‬‬

‫‪2‬‬
‫‪3‬‬ ‫;‪import java.awt.GridLayout‬‬
‫‪5‬‬
‫‪7‬‬ ‫{‬
‫‪9‬‬ ‫{‬
‫‪10‬‬ ‫;)"‪JFrame frame1 = new JFrame("JTabbedPane Demo‬‬
‫‪13‬‬
‫‪14‬‬ ‫;)(‪JTabbedPane TabbedPane1 = new JTabbedPane‬‬
‫‪15‬‬ ‫;)‪TabbedPane1.addTab("Tab1",panel1‬‬
‫‪16‬‬ ‫;)‪TabbedPane1.addTab("Tab2",panel2‬‬
‫‪17‬‬
‫‪18‬‬ ‫;)‪frame1.add(TabbedPane1‬‬
‫‪19‬‬ ‫;)‪frame1.setSize(355 , 286‬‬
‫‪21‬‬ ‫}‬
‫‪22‬‬ ‫}‬
‫همانطور که در خط ‪ 33‬کد باال مشاهده میکنید ابتدا یک شیء از ‪ JTabbedPane‬ایجاد و سپس در خطوط ‪ 31‬و ‪ 31‬دو سربرگ یا‬
‫تب به آن با استفاده از متد )(‪ addTab‬اضافه میکنیم‪ .‬هر تب حداقل باید یک عنوان داشته باشد و یک کنترل دیگر را در خود جای‬
‫دهد‪ .‬که ما در هر تب یک کنترل ‪ Panel‬قرار دادهایم‪:‬‬

161 SWING
‫ ذخیره کنید‬D ‫ ابتدا دو عکس زیر را در درایو‬.‫ آیکونی را مشخص کنید‬tab ‫ به شما اجازه میدهد که برای هر‬ImageIcon ‫کالس‬
:‫ کد باال را با کدهای زیر جایگزین کنید‬31 ‫ تا‬33 ‫سپس خطوط‬
JTabbedPane TabbedPane1 = new JTabbedPane();

ImageIcon Icon1 = new ImageIcon("D:\\img1.jpg");
ImageIcon Icon2 = new ImageIcon("D:\\img2.jpg");
TabbedPane1.addTab("Tab1",Icon1,panel1);
TabbedPane1.addTab("Tab2",Icon2,panel2);
:‫حال برنامه را اجرا و نتیجه را مشاهده کنید‬

‫سازنده کالس ‪( JTabbedPane‬خط ‪ )33‬دو پارامتر میگیرد‪:‬‬
‫;)‪JTabbedPane TabbedPane1 = new JTabbedPane(tabPlacement, tabLayoutPolicy‬‬
‫با استفاده از پارامتر اول میتوان کنترل ‪ JTabbedPane‬را در قسمت باال‪ ،‬راست‪ ،‬چپ و پایین فریم قرار داد‪ .‬برای این کار کافیست‬
‫یکی از مقادیر زیر را در خط ‪ ۵1‬و در داخل پرانتز بنویسید‪:‬‬
‫‪JTabbedPane.TOP‬‬ ‫‪‬‬
‫‪JTabbedPane.RIGHT‬‬ ‫‪‬‬
‫‪JTabbedPane.LEFT‬‬ ‫‪‬‬
‫‪JTabbedPane.BOTTOM‬‬ ‫‪‬‬
‫خروجی پس از قرار دادن این مقادیر میتواند هر یک از حاالت زیر باشد‪:‬‬

‫‪166‬‬ ‫‪SWING‬‬
‫با استفاده از پارامتر دوم هم میتوان ‪ Tab‬ها را در یک یا چند خط نمایش داد‪ .‬پارامتر دوم میتواند شامل مقادیر زیر باشد‪:‬‬
‫‪JTabbedPane.SCROLL_TAB_LAYOUT‬‬ ‫‪‬‬
‫‪JTabbedPane.WRAP_TAB_LAYOUT‬‬ ‫‪‬‬
‫خروجی پس از قرار دادن این مقادیر میتواند هر یک از حاالت زیر باشد‪:‬‬
‫حال فرض کنید که میخواهیم کنترلهای دیگری در داخل این دو تب قرار دهیم‪ .‬چون از قبل دو ‪ Panel‬به هر دو تب اضافه‬
‫کردهایم کافیست که کنترلهای دیگر را در این دو ‪ Panel‬قرار دهیم‪ .‬در خط ‪ 31‬کد باال کدهای زیر را بنویسید‪:‬‬
‫;))‪panel1.setLayout(new GridLayout(2,2,10,10‬‬
panel2.setLayout(new GridLayout(2,2,10,10));
JButton button1 = new JButton("Button1");

JCheckBox checkbox1 = new JCheckBox("CheckBox1");

panel1.add(button1);
panel2.add(checkbox1);
‫ چهار چک‬panel2 ‫ چهار دکمه و در داخل‬panel1 ‫ را به دو سطر و دو ستون تقسیم کرده و در داخل‬Panel ‫در این کدهای دو‬
:‫باکس قرار دادهایم‬

‫‪333‬‬ ‫‪SWING‬‬
‫و در آخر هم این نکته را یاد آور شویم که برای راست چین کردن کنترل ‪ JTabbedPane‬میتوان از متد‬
‫)(‪ setComponentOrientation‬به صورت زیر استفاده کرد‪:‬‬
‫;)‪TabbedPane1.setComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT‬‬
‫خروجی بعد از اعمال کد باال میتواند به صورت زیر باشد‪:‬‬

‫کنترل ‪JMenuBar‬‬
‫از کنترل ‪ JMenuBar‬برای ساخت نوار منو استفاده میشود‪ .‬در شکل زیر نمایی کلی از یک نوار منو را مشاهده میکنید‪:‬‬
‫در جاوا برای ایجاد یک نوار منو کامل از کالسهایی که در شکل زیر مشاهده میکنید استفاده میشود‪:‬‬
331 SWING
:‫ به کد زیر توجه کنید‬.‫حال اجازه دهید که وارد قسمت کدنویسی شده و نوار منوی باال را شبیه سازی کنیم‬
2
6
8 {
10 {
11 JFrame frame1 = new JFrame("JMenu Demo");
13
14 JMenuBar menubar1 = new JMenuBar();
15 frame1.add(menubar1, BorderLayout.NORTH);
16
17 JMenu menu1 = new JMenu("File");
18 JMenu menu2 = new JMenu("Edit");
19 JMenu menu3 = new JMenu("Format");
20 JMenu menu4 = new JMenu("Help");
21
22 menubar1.add(menu1);
26
29 }
30 }
‫در کد باال و در خطوط ‪ 33‬یک فریم ایجاد کرده و در خط ‪ 35‬از کالس ‪ BorderLayout‬برای الیه بندی آن استفاده میکنیم‪ .‬در خط ‪33‬‬
‫یک نوار منو با استفاده از کالس ‪ JMenuBar‬ایجاد کرده و آن را در خط ‪ 31‬به باالی فریم میچسبانیم‪ .‬اگر خطوط ‪ 31-51‬را پاک‬
‫کرده و برنامه را اجرا کنید مشاهده میکنید که هنوز کار خاصی انجام نشده است‪ .‬برای اضافه کردن منو به منوبار از کالس ‪JMenu‬‬
‫استفاده میشود‪ .‬در خطوط ‪ 31-53‬چهار منو ایجاد کرده و در خطوط ‪ 55-51‬آنها را به منوبار اضافه میکنیم‪ .‬حال برنامه را اجرا و‬
‫نتیجه را مشاهده کنید‪:‬‬
‫اکنون نوبت به زیر منوها میرسد‪ .‬برای ایجاد زیر منو از کالس ‪ JMenuItem‬استفاده میشود‪ .‬فرض کنید که میخواهیم دو زیر منو‬
‫به منوی ‪ File‬اضافه کنیم‪ .‬برای این کار کدهای زیر از ‪ 53‬به بعد کد باال بنویسید (تمامی کدهایی که در ادامه آموزش داده میشود‬
‫را از همین خط به بعد بنویسید‪ .‬شما میتوانید بعد از تکمیل کدها آنها را منظم کنید)‪:‬‬
‫;)"‪JMenuItem menuItem1 = new JMenuItem("Open‬‬

‫;)‪menu1.add(menuItem1‬‬
‫;)"‪JMenuItem menuItem2 = new JMenuItem("Exit‬‬

‫حال برنامه را اجرا و نتیجه را مشاهده کنید‪:‬‬

331 SWING
‫ کافیست که یک شیء از این کالس را در بین دو زیر منو‬.‫ استفاده میشود‬JSeparator ‫برای ایجاد خط جدا کننده هم از کالس‬
:‫قرار دهید‬
JMenuItem menuItem1 = new JMenuItem("Open");

menu1.add(menuItem1);
menu1.add(new JSeparator());
JMenuItem menuItem2 = new JMenuItem("Exit");

menu1.add(menuItem2);
:‫برنامه را دوباره اجرا و نتیجه را مشاهده کنید‬

‫همانطور که مشاهده کردید برای ایجاد زیر منو از کالس ‪ JMenuItem‬استفاده میشود ولی اگر بخواهیم برای یک زیر منو‪ ،‬زیر‬
‫منوی دیگری تعریف کنیم باید زیر منوی اصلی را با استفاده از کالس ‪ JMenu‬ایجاد کنیم‪ .‬برای درک بهتر کد باال را با کدهای زیر‬
‫جایگزین کنید ‪:‬‬
‫;)"‪JMenu menuItem1 = new JMenu("Open‬‬

‫;)"‪JMenuItem submenuItem1 = new JMenuItem("New Document‬‬
‫;)‪menuItem1.add(submenuItem1‬‬
‫;))(‪menu1.add(new JSeparator‬‬
‫;)"‪JMenuItem menuItem2 = new JMenuItem("Exit‬‬

‫همانطور که در کد باال مشاهده میکنید ابتدا منوی ‪ Open‬را با استفاده از کالس ‪ JMenu‬ایجاد و سپس با استفاده از کالس‬
‫‪ JMenuItem‬زیر منوی ‪ New Document‬را به آن اضافه کردهایم‪:‬‬
‫سازنده کالس ‪ JMenuItem‬یک پارامتر دوم هم دریافت میکند که با استفاده از آن میتوان یک آیکون به زیر منو اختصاص داد‬
‫‪:‬‬
‫;))"‪JMenuItem submenuItem1 = new JMenuItem("New Document", new ImageIcon("D:\\images\\new.png‬‬

‫‪331‬‬ ‫‪SWING‬‬
‫برای ایجاد کلید میانبر و استفاده از کلیدهای ترکیبی هم از متد )(‪ setMnemonic‬استفاده میشود‪ .‬فرض کنید که میخواهیم با‬
‫زدن دکمههای ‪ Alt+F‬زیر منوهای منوی فایل نمایش داده شود‪ .‬برای این کار کد زیر را مینویسید‪:‬‬
‫;)‪menu1.setMnemonic(KeyEvent.VK_F‬‬
‫اگر برنامه را اجرا کنید مشاهده میکنید که یک خط تیره زیر حرف ‪ F‬کشیده شده است که نشان دهنده این است که شما میتوانید‬
‫از کلید ‪ Alt‬به همراه حرف ‪ F‬برای باز شدن منو استفاده کنید‪ .‬برنامه را اجرا و دکمه ‪ Alt+F‬را بزنید‪:‬‬
‫برای ایجاد ایجاد کلید میانبر با استفاده از دکمه کنترل )‪ (Ctrl‬هم میتوانید از کالس ‪ KeyStroke‬استفاده کنید‪ .‬فرض کنید که‬
‫میخواهیم با زدن دکمههای ‪ Ctrl+O‬زیر منوی ‪( Exit‬یا همان ‪ )menuitem2‬عمل کند‪ .‬برای این کار از کد زیر استفاده میکنیم‬
‫‪:‬‬
‫;)"‪KeyStroke keystroke = KeyStroke.getKeyStroke("control X‬‬

‫;)‪menuItem2.setAccelerator(keystroke‬‬
‫برای ایجاد یک زیر منو از نوع ‪ CheckBox‬هم از کالس ‪ JCheckBoxMenuItem‬استفاده میشود‪ .‬فرض کنید که میخواهیم یک‬
‫زیر منو از همین نوع به منوی ‪( Format‬یا همان ‪ )menu3‬اضافه کنیم‪ .‬برای اینکار به صورت زیر عمل میکنیم ‪:‬‬
‫;)"‪JCheckBoxMenuItem checkboxmenuitem1 = new JCheckBoxMenuItem("Word_Wrap‬‬

‫;)‪menu3.add(checkboxmenuitem1‬‬
‫برنامه را اجر و بر روی منوی ‪ Format‬کلیک کنید‪:‬‬

‫‪336‬‬ ‫‪SWING‬‬
‫کنترل ‪JToolBar‬‬
‫از کنترل ‪ JToolBar‬برای ایجاد نوار ابزار استفاده میشود‪ .‬سازنده این کالس به روشهای زیر مقداردهی میشود‪:‬‬
‫)(‪JToolBar‬‬
‫)‪JToolBar(int orientation‬‬
‫)‪JToolBar(String name‬‬
‫)‪JToolBar(String name, int orientation‬‬
‫نوار ابزار شامل دکمهها و اجزای مفیدی برای راحتی کار کاربر میباشد ‪.‬مانند منو‪ ،‬نوار ابزار هم در تعداد زیادی از نرم افزارهای‬
‫مشهور مانند ‪ Microsoft Office 2003‬به چشم میخورد‪ .‬در زیر نوار ابزار ‪ Microsoft Office 2003‬را مشاهده میکنید‪:‬‬
‫در اصل نوار ابزار را میتوان منو و زیر منوهایی فرض کرد که به دلیل کاربرد زیاد آنها‪ ،‬برای در دسترس بودن همیشگی‪ ،‬آنها را به‬
‫صورت دکمه و در زیر نوار قرار میدهند‪ .‬قبل از هر چیز ابتدا آیکونهای برنامه را از لینک زیر دانلود کرده و در پوشه ای به نام‬
‫‪ images‬در درایو ‪ D‬ذخیره کنید‪:‬‬

http://www.w3-farsi.com/?p=15248
:‫ در جاوا به کد زیر توجه کنید‬JToolBar ‫برای درک بهتر کار با نوار ابزار و کنترل‬
2
5
7 {
9 {
10 JFrame frame1 = new JFrame("JToolBar Demo");
12
13 JToolBar firstToolbar = new JToolBar();
14 JToolBar secondToolbar = new JToolBar();
15
16 JPanel panel = new JPanel();
17 panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
18
19 JButton New = new JButton(new ImageIcon("D:\\images\\new.png"));
20 JButton Open = new JButton(new ImageIcon("D:\\images\\open.png"));
21 JButton Save = new JButton(new ImageIcon("D:\\images\\save.png"));
22 JButton Cut = new JButton(new ImageIcon("D:\\images\\cut.png"));
23 JButton Copy = new JButton(new ImageIcon("D:\\images\\copy.png"));
24 JButton Print = new JButton(new ImageIcon("D:\\images\\print.png"));
25 JButton Left2right = new JButton(new ImageIcon("D:\\images\\left2right.png"));
26 JButton Right2left = new JButton(new ImageIcon("D:\\images\\right2left.png"));
27 JButton Center = new JButton(new ImageIcon("D:\\images\\center.png"));
28 JButton Right = new JButton(new ImageIcon("D:\\images\\right.png"));
29 JButton Left = new JButton(new ImageIcon("D:\\images\\left.png"));
30
31 firstToolbar.add(New);
32 firstToolbar.add(Open);
33 firstToolbar.add(Save);
34 firstToolbar.add(Cut);
35 firstToolbar.add(Copy);
36 firstToolbar.add(Print);
37 firstToolbar.setAlignmentX(0);
38
39 secondToolbar.add(Left2right);
40 secondToolbar.add(Right2left);
41 secondToolbar.add(Center);
42 secondToolbar.add(Right);
43 secondToolbar.add(Left);
44 secondToolbar.setAlignmentX(0);
45
46 panel.add(firstToolbar);
47 panel.add(secondToolbar);
48 frame1.add(panel, BorderLayout.NORTH);
49
50 frame1.setSize(416, 313);
52 }
53 }
‫‪333‬‬ ‫‪SWING‬‬
‫در کد باال و در خطوط ‪ 31‬و ‪ 33‬دو نوار ابزار ایجاد کردهایم‪ .‬در خط ‪ 31‬و ‪ 31‬یک ‪ Panel‬ایجاد و نحوه الیه بندی آن را ‪BoxLayout‬‬
‫و در راستای محور ‪ Y‬ها قرار دادهایم‪ .‬چون که میخواهیم دو نوار در زیر هم قرار گیرند‪ .‬در خطوط ‪ 36-56‬چندین دکمه ایجاد کرده‬
‫و با استفاده از کالس ‪ ImageIcon‬به هر کدام از آنها یکی از عکسهایی که در درایو ‪ D‬ذخیره کردیم را اختصاص میدهیم‪ .‬در‬
‫خطوط ‪ 13-11‬چندین دکمه را در نوار ابزار اول و در خطوط ‪ 16-31‬مابقی دکمهها را در نوار ابزار دوم قرار میدهیم‪ .‬بدون خطوط ‪11‬‬
‫و ‪ 33‬نوار ابزارها در وسط ‪ Panel‬قرار میگیرند که ما در این دو خط و با استفاده از متد )(‪ setAlignmentX‬آنها را به سمت‬
‫چپ ‪ Panel‬منتقل میکنیم‪ .‬در خطوط ‪ 31‬و ‪ 31‬دو نوار ابزار را به ‪ Panel‬و در خط ‪ 30‬خود ‪ Panel‬را به قسمت باالی ‪Frame‬‬
‫اضافه میکنیم‪ .‬برنامه را اجرا و نتیجه را مشاهده کنید‪:‬‬
‫اگر بخواهید که نوارهای ابزارتان در یک خط نمایش داده شوند کافیست که خط ‪ 31‬کد باال را به صورت زیر تغییر دهید‪:‬‬
‫;))‪panel.setLayout(new BoxLayout(panel, BoxLayout.X_AXIS‬‬
‫حال برنامه را اجرا و نتیجه را مشاهده کنید‪:‬‬

‫نوار ابزار را به صورت عمودی هم میشود ایجاد کرد‪ .‬برای این کار کافیست که خطوط ‪ 31‬و ‪ 33‬کد باال را به صورت زیر تغییر دهید‬
‫‪:‬‬
‫;)‪JToolBar firstToolbar = new JToolBar(JToolBar.VERTICAL‬‬

‫;)‪JToolBar secondToolbar = new JToolBar(JToolBar.VERTICAL‬‬
‫برنامه را اجرا کنید‪:‬‬
‫مشاهده میکنید که نوار ابزارها در زیر هم قرار گرفتند و این به خاطر الیه بندی ‪ Panel‬در خط ‪ 31‬میباشد‪ .‬حال خطوط ‪ 11 ،31‬و‬
‫‪ 33‬را به صورت زیر تغییر دهید‪:‬‬

‫‪331‬‬ ‫‪SWING‬‬
‫;))‪panel.setLayout(new BoxLayout(panel, BoxLayout.X_AXIS‬‬
‫;)‪firstToolbar.setAlignmentY(0‬‬
‫;)‪secondToolbar.setAlignmentY(0‬‬
‫بار دیگر برنامه را اجرا و نتیجه را مشاهده کنید‪:‬‬
‫کنترل ‪JTree‬‬
‫کنترل ‪ JTree‬برای نمایش درختی آیتمها به کار میرود‪ .‬برای درک بهتر عملکرد این کنترل میتوان به فهرست مطالب یک کتاب‬
‫و یا نمایش فایلها و یا پوشههای درون هارد اشاره کرد‪ .‬هر شاخه از کنترل ‪ JTree‬را یک گره یا ‪ Node‬مینامند‪ .‬پس به جای‬
‫شاخه میتوان کلمه گره را هم به کار برد‪.‬‬
‫هر شاخه در این کنترل شامل یک برچسب و یک عکس اختیاری است و هر شاخه خود میتواند شامل زیر شاخههای دیگر باشد‪.‬‬
‫با کلیک بر روی عالمت کنار شاخه‪ ،‬کاربر میتواند زیر شاخههای مربوطه را مشاهده کند‪ .‬در شکل زیر یک کنترل ‪ JTree‬ساده با‬
‫چند شاخه نمایش داده شده است‪ .‬همانطور که مشاهده میکنید شاخه اصلی یا ‪ ،Root‬شاخه اصلی )‪ (Root Node‬است که‬
‫دارای دو زیر شاخه به نامهای ‪ NodeA‬و ‪ NodeB‬میباشد‪ NodeA .‬نیز به نوبه خود دارای دو زیر شاخه به نامهای ‪ ChildA‬و‬
‫‪ ChildB‬است‪:‬‬
‫ استفاده‬DefaultMutableTreeNode ‫ و برای ایجاد شاخههای آن از کالس‬JTree ‫برای ایجاد یک درخت در جاوا از کنترل‬
:‫ در مثال زیر میخواهیم همین شکل باال را ایجاد کنیم‬.‫ برای روشن شدن مطلب به مثال زیر توجه کنید‬.‫میشود‬
2
4 import javax.swing.tree.*;
5
7 {
9 {
10 JFrame frame = new JFrame("JTree Demo");
11
12 DefaultMutableTreeNode RootNode = new DefaultMutableTreeNode("Root");
13
14 DefaultMutableTreeNode NodeA = new DefaultMutableTreeNode("NodeA");
15 RootNode.add(NodeA);
16
17 DefaultMutableTreeNode NodeB = new DefaultMutableTreeNode("NodeB");
18 RootNode.add(NodeB);
19
20 JTree Tree = new JTree(RootNode);
21
22 frame.add(Tree);
23 frame.setSize(430 , 315);
24 frame.setVisible(true);
25 }
26 }
‫ حال میخواهیم دو زیر‬.‫ ایجاد کردهایم‬RootNod ‫همانطور که در کد باال مشاهده میکنید ابتدا یک شاخه اصلی یا گره ریشه به نام‬
‫ ایجاد (خطوط‬NodeB ‫ و‬NodeA ‫ دو شاخه به نامهای‬DefaultMutableTreeNode ‫ با استفاده از کالس‬.‫شخه به آن اضافه کنیم‬

‫‪331‬‬ ‫‪SWING‬‬
‫‪ 33‬و ‪ )31‬و این دو شاخه را با استفاده از متد )(‪ add‬در خطوط ‪ 31‬و ‪ 30‬به شاخه اصلی اضافه میکنیم‪ .‬سپس در خط ‪ 53‬شاخه‬
‫اصلی را به درخت و خود درخت را در خط ‪ 55‬به فریم اضافه میکنیم‪:‬‬
‫حال فرض کنید که میخواهیم دو زیر شاخه به شاخه ‪ NodeA‬در شکل باال اضافه کنیم‪:‬‬
‫;)"‪DefaultMutableTreeNode ChildA = new DefaultMutableTreeNode("ChildA‬‬

‫;)‪NodeA.add(ChildA‬‬
‫;)"‪DefaultMutableTreeNode ChildB = new DefaultMutableTreeNode("ChildB‬‬

‫;)‪NodeA.add(ChildB‬‬
‫همانطور که در کد باال مشاهده میکنید ابتدا با استفاده از کالس ‪ DefaultMutableTreeNode‬دو زیر شاخه ایجاد و سپس با‬
‫استفاده از متد )(‪ add‬آنها را به ‪ NodeA‬اضافه میکنیم‪:‬‬

‫اگر بخواهید به هر یک از شاخههای بدون زیر شاخه و شاخههایی که دارای زیر شاخه هستند یک آیکون اختصاص دهید میتوانید‬
:‫ به همراه سه متد زیر استفاده کنید‬DefaultTreeCellRenderer ‫از‬
.‫ برای نمایش آیکون شاخههای بدون زیر شاخه به کار میرود‬: setLeafIcon() 
.‫ برای نمایش آیکون شاخههای دارای زیر شاخه در حالت بسته به کار میرود‬: setClosedIcon() 
.‫ برای نمایش آیکون شاخههای دارای زیر شاخه در حالت باز به کار میرود‬: setOpenIcon() 
:‫ کد ابتدای درس کدهای زیر را بنویسید‬53 ‫بعد از خط‬
ImageIcon leafIcon = new ImageIcon("D:\\images\\node.png");

ImageIcon openIcon = new ImageIcon("D:\\images\\sub.png");
ImageIcon closedIcon = new ImageIcon("D:\\images\\sum.png");
DefaultTreeCellRenderer DefaultTreeCellRenderer1 =
(DefaultTreeCellRenderer)tree.getCellRenderer();
DefaultTreeCellRenderer1.setLeafIcon(leafIcon);
DefaultTreeCellRenderer1.setClosedIcon(closedIcon);
DefaultTreeCellRenderer1.setOpenIcon(openIcon);
‫ سپس این سه شیء را به سه متد از کالس‬.‫ قرار دادهایم‬ImageIcon ‫در خطوط باال ابتدا مسیر سه آیکون را در سه شیء از کالس‬
:‫ برنامه را اجرا کنید‬.‫ ارسال کردهایم‬DefaultTreeCellRenderer

‫‪331‬‬ ‫‪SWING‬‬
‫کنترل ‪JToggleButton‬‬
‫کنترل ‪ JToggleButton‬دکمه ای دو انتخابه یا دو حالته میباشد‪ .‬این دکمهها با کلیک بر روی آنها به حالت انتخاب در آمده و‬
‫رنگ پس زمینه آنها تغییر میکند و اگر بخواهید آنها را از حالت انتخاب خارج کنید باید دوباره بر روی آنها کلیک کنید‪ .‬یک‬
‫نمونه از این نوع دکمهها را در شکل زیر مشاهده میکنید‪:‬‬

:‫سازنده این کالس به روشهای زیر مقداردهی میشود‬
public JToggleButton()
public JToggleButton(Icon icon)
public JToggleButton(Icon icon, boolean selected)
public JToggleButton(String text)
public JToggleButton(String text, boolean selected)
public JToggleButton(String text, Icon icon)
public JToggleButton(String text, Icon icon, boolean selected)
public JToggleButton(Action action)
:‫ به مثال زیر توجه کنید‬JToggleButton ‫برای درک بهتر عملکرد کنترل‬
2
6
8 {
10 {
11 JFrame frame = new JFrame("JToggleButton Demo");
12
14
15 final JLabel label = new JLabel();
16 label.setPreferredSize(new Dimension(200, 200));
17 label.setBackground(Color.red);
18 label.setOpaque(true);
19
20 JToggleButton toggleButton = new JToggleButton("Toggle Button");
21
‫‪336‬‬ ‫‪SWING‬‬
‫‪22‬‬ ‫;)‪panel.add(label‬‬
‫‪23‬‬ ‫;)‪panel.add(toggleButton‬‬
‫‪24‬‬
‫‪25‬‬ ‫;)‪frame.add(panel‬‬
‫‪26‬‬
‫‪27‬‬ ‫‪class stateChange implements ItemListener‬‬
‫‪28‬‬ ‫{‬
‫‪29‬‬ ‫)‪public void itemStateChanged(ItemEvent itemEvent‬‬
‫‪30‬‬ ‫{‬
‫‪31‬‬ ‫;)(‪int state = itemEvent.getStateChange‬‬
‫‪32‬‬
‫‪33‬‬ ‫)‪if (state == ItemEvent.SELECTED‬‬
‫‪34‬‬ ‫{‬
‫‪35‬‬ ‫;)‪label.setSize(50, 50‬‬
‫‪36‬‬ ‫}‬
‫‪37‬‬ ‫‪else‬‬
‫‪38‬‬ ‫{‬
‫‪39‬‬ ‫;)‪label.setSize(200, 200‬‬
‫‪40‬‬ ‫}‬
‫‪41‬‬ ‫}‬
‫‪42‬‬ ‫}‬
‫‪43‬‬
‫‪44‬‬ ‫;))(‪toggleButton.addItemListener(new stateChange‬‬
‫‪45‬‬
‫‪46‬‬ ‫;)‪frame.setSize(500, 500‬‬
‫‪47‬‬ ‫;)‪frame.setVisible(true‬‬
‫‪48‬‬ ‫}‬
‫‪49‬‬ ‫}‬
‫هدف از برنامه باال این است که با کلیک بر روی یک دکمه ‪ JToggleButton‬اندازه ‪ Label‬تغییر کرده و با کلیک دوباره به حالت‬
‫قبل بر گردد‪ .‬در خطوط ‪ 31-30‬یک ‪ Label‬ایجاد کرده و یک اندازه و رنگ پس زمینه هم به آن اختصاص میدهیم‪ .‬در خط ‪ 53‬یک‬
‫کنترل ‪ JToggleButton‬ایجاد کرده و این دو کنترل را در خطوط ‪ 55‬و ‪ 51‬به ‪ Panel‬و ‪ Panel‬را در خط ‪ 51‬به ‪ Frame‬اضافه‬
‫میکنیم ‪.‬همانطور که اشاره کردیم این دکمهها دو وضعیت )‪ (state‬دارند ‪ -3 :‬انتخاب شده ‪ -5‬انتخاب نشده‪.‬‬
‫برای کار با این کنترل میتوان رابط ‪ ItemListener‬را پیاده سازی کرد‪ .‬در خطوط ‪ 51-35‬یک کالس با نام ‪stateChanege‬‬
‫ایجاد کرده و رابط مذکور را پیاده سازی میکنیم‪ .‬این رابط دارای متدی به نام )(‪ itemStateChanged‬که باید پیاده سازی شود‪.‬‬
‫همانطور که در خط ‪ 56‬مشاهده میکنید این متد یک شیء از کالس ‪ ItemEvent‬در یافت میکند‪ .‬کالس ‪ ItemEvent‬دارای متدی‬
‫به نام )(‪ getStateChange‬که وضعیت دکمه را میتوان با آن مشخص کرد‪ .‬در خط ‪ 13‬وضعیت دکمه را به دست میآوریم‪ .‬در‬
‫خطوط ‪ 11-33‬با استفاده از یک دستور ‪ if‬چک میکنیم که آیا دکمه انتخاب شده است؟ اگر انتخاب شده باشد اندازه ‪ Label‬را‬
‫تغییر داده و در غیر اینصورت به همان اندازه قبل که در خط ‪ 31‬مشخص کردهایم بر میگردانیم‪:‬‬
‫همانطور که در اشکال باال مشاهده میکنید با انتخاب دکمه (شکل اول) رنگ پس زمینه ‪ JToggleButton‬تغییر میکند که نشان‬
‫دهنده در حالت انتخاب بودن آن است و با کلیک دوباره بر روی آن یعنی خروج از حالت انتخاب رنگ پس زمینه به حالت عادی بر‬
‫میگردد‪.‬‬
‫‪353‬‬ ‫‪SWING‬‬
‫کادرهای محاوره ای )‪(Dialogs‬‬

‫کادرهای محاوره ای یا ‪ Dialog‬ها پنجرههایی هستند که دارای وظایف مشخصی مانند ذخیره یا باز کردن یک فایل‪ ،‬انتخاب یک‬
‫رنگ و یا چاپ یک سند میباشند‪ .‬جاوا دارای کنترلهایی میباشد که به شما اجازه میدهند با فراخوانی کادرهای محاوره ای امور‬
‫خاصی را انجام دهید‪ .‬کادرهای محاوره ای را میتوان با استفاده از خواص این کنترلها سفارشی کرد‪.‬‬
‫کادر محاوره ای انتخاب رنگ‬

‫کادر محاوره ای جستجوی پوشهها و فایلها‬
‫بنابراین میتوانید با اسنتفاده از این کادرهای محاوره ای برنامههای ویژوال استانداردتری ایجاد کنید‪ .‬این کادرها معموال در تمام‬
‫برنامههای ویندوزی مورد استفاده قرار میگیرند‪.‬‬
‫کنترل ‪JFileChooser‬‬
‫از کنترل ‪ JFileChooser‬برای کار با فایلها و پوشهها استفاده میشود‪ .‬با استفاده از این کنترل میتوان یک فایل یا یک پوشه‬
‫را از بین لیستی از فایلها و پوشهها انتخاب کرد‪ .‬سازنده این کالس به روشهای زیر مقداردهی میشود‪:‬‬
‫‪public‬‬ ‫)(‪JFileChooser‬‬
‫‪public‬‬ ‫)‪JFileChooser(File currentDirectory‬‬
‫‪public‬‬ ‫)‪JFileChooser(File currentDirectory, FileSystemView fileSystemView‬‬
‫‪public‬‬ ‫)‪JFileChooser(FileSystemView fileSystemView‬‬
‫‪public‬‬ ‫)‪JFileChooser(String currentDirectoryPath‬‬
‫‪public‬‬ ‫)‪JFileChooser(String currentDirectoryPath, FileSystemView fileSystemView‬‬
‫کادر انتخاب یا ذخیره فایل‪ ،‬به وسیله سه متد نمایش داده میشود‪:‬‬
‫)(‪showDialog‬‬ ‫‪‬‬
‫‪351‬‬ ‫‪SWING‬‬
‫)(‪showOpenDialog‬‬ ‫‪‬‬
‫)(‪showSaveDialog‬‬ ‫‪‬‬
‫در جدول زیر هم لیست متدهایی که برای سفارشی سازی کادر محاوره ای ‪ JfileChooser‬به کار میروند به همراه کاربرد آنها‬
‫ذکر شده است‪:‬‬
‫به کاربر اجازه انتخاب همزمان چند فایل یا پوشه را میدهد و دو مقدار ‪ true‬و ‪false‬‬ ‫‪setMultiSelectionEnabled‬‬
‫میگیرد‪.‬‬
‫به وسیله این متد میتوان پوشه یا درایو پیشفرضی که هنگام باز شدن کادر محاوره ای نمایش‬ ‫‪setCurrentDirectory‬‬
‫داده میشود را مشخص کرد‪ .‬اگر مقدار ‪ null‬به آن بدهیم بسته به نوع سیستم عامل یک‬
‫مسیر پیشفرض تعیین میشود که مثال در ویندوز ‪ My Document‬است‪.‬‬
‫این متد سه مقدار میگیرد که در حالتی که کاربر اجازه انتخاب چند فایل یا پوشه را دارد کاربر را‬ ‫‪setFileSelectionMode‬‬
‫محدود میکند‪:‬‬
‫‪ :FILES_AND_DIRECTORIES‬کاربر اجازه انتخاب همزمان فایل و پوشه را دارد‪.‬‬
‫‪ :FILES_ONLY‬کاربر اجازه انتخاب فقط فایل را دارد‪.‬‬
‫‪ :DIRECTORIES_ONLY‬کاربر اجازه انتخاب فقط پوشه را دارد‪.‬‬
‫به وسیله این متد میتوان پسوند فایلهای قابل نمایش در پنجره را مشخص کرد‪.‬‬ ‫‪setFileFilter‬‬
‫مشخص میکند که گزینه ‪ AllFiles‬در بین لیست پسوندها نمایش داده شود یا نه؟‬ ‫‪setAcceptAllFileFilterUsed‬‬
‫از متد )(‪ showDialog‬به همراه یک شیء از کالس ‪ JFileChooser‬میتوان یک کادر محاوره ای سفارشی برای باز یا ذخیره‬
‫کردن یک فایل ایجاد کرد‪ .‬این متد دو آرگومان میگیرد که اولین آرگومان کنترل والد و دومین آرگومان عنوان دکمه و کادر را مشخص‬
‫میکند‪ .‬برای روشن شدن نحوه استفاده از این متد‪ ،‬کد زیر را در یک فایل با پسوند جاوا نوشته و اجرا کنید‪:‬‬

‫{‬
‫{‬
‫;)(‪JFileChooser filechooser = new JFileChooser‬‬
‫;)"‪filechooser.showDialog(null, "Open‬‬
‫}‬
‫}‬
‫نتیجه اجرای کد باال به صورت زیر است‪:‬‬
‫در شکل باال آرگومان دوم متد )(‪ showDialog‬هم به جای نام دکمه و هم به جای عنوان پنجره به کار رفته است‪ .‬حال آرگومانهای‬
‫متد )(‪ showDialog‬کد باال را به صورت زیر تغییر دهید‪:‬‬
‫;)"‪filechooser.showDialog(null,"Save‬‬

‫‪351‬‬ ‫‪SWING‬‬
‫همانطور که احتماال متوجه شدهاید میتوان از این متد هم به جای کادر محاوره ای باز و هم به جای کادر محاوره ای ذخیره فایل‬
‫استفاده کرد‪ .‬البته کالس ‪ JFileChooser‬دارای متدی به نام ‪ setDialogType‬میباشد که با دریافت سه مقدار ثابت زیر نوع‬
‫کادر محاوره ای را مشخص میکند‪:‬‬
‫‪JFileChooser.OPEN_DIALOG‬‬ ‫‪‬‬
‫‪JFileChooser.SAVE_DIALOG‬‬ ‫‪‬‬
‫‪JFileChooser.CUSTOM_DIALOG‬‬ ‫‪‬‬
‫در کد باال ما الزم بود که یک عنوان به پنجره و دکمه اختصاص دهیم ولی با استفاده از این متد و ثابتها به طور خودکار نوع کادر‬
‫محاوره ای تشخیص داده شده و مقادیری برای دکمه و عنوان اختصاص داده میشود‪ .‬به کد زیر توجه کنید‪:‬‬

‫{‬
‫{‬
‫;)(‪JFileChooser filechooser = new JFileChooser‬‬
‫;)‪filechooser.setDialogType(JFileChooser.SAVE_DIALOG‬‬
‫;)‪filechooser.showDialog(null, null‬‬
‫}‬
‫}‬
‫در کد باال مقدار عنوان پنجره و دکمه را ‪ null‬قرار دادهایم ولی چون در خط قبل از آن نوع پنجره را ‪JFileChooser.SAVE_DIALOG‬‬
‫را گذاشتهایم در نتیجه عنوان دکمه و پنجره به ‪ Save‬تغییر میکند‪:‬‬
‫تشخیص اینکه چه دکمه ای توسط کاربر فشرده شده است بسیار مهم است‪ .‬متد )(‪ showDialog‬وقتی که کاربر بر روی دکمههای‬
‫‪ Open‬یا ‪ Save‬کلیک میکند مقدار ‪ 3‬و وقتی بر روی ‪ Cancel‬کلیک میکند‪ ،‬مقدار ‪ 3‬و اگر خطایی در هنگام کار با کادر محاوره ای‬
‫رخ دهد مقدار ‪ -3‬را بر میگرداند‪ .‬با مقایسه این سه مقدار برگشتی با سه ثابت از کالس ‪ JFileChooser‬میتوان کدهای کارامد‬
‫تری نوشت‪:‬‬
‫‪JFileChooser.APPROVE_OPTION‬‬ ‫‪‬‬
‫‪CANCEL_OPTION‬‬ ‫‪‬‬
‫‪JFileChooser.ERROR_OPTION‬‬ ‫‪‬‬
‫به برنامه زیر توجه کنید‪:‬‬

351 SWING
2
4
6 {
8 {
9 final JFileChooser filechooser = new JFileChooser();
10
11 filechooser.setDialogType(JFileChooser.SAVE_DIALOG);
12
13 int selectedNumber = filechooser.showDialog(null, null);
14
15 switch (selectedNumber)
16 {
17 case JFileChooser.APPROVE_OPTION :
18 JOptionPane.showMessageDialog(null, "You Clicked on Open or Save!");
19 break;
20 case JFileChooser.CANCEL_OPTION :
21 JOptionPane.showMessageDialog(null, "You Clicked on Cancel!");
22 break;
23 case JFileChooser.ERROR_OPTION :
24 JOptionPane.showMessageDialog(null, "An error occured !");
25 break;
26 }
27 }
28 }
‫ سپس همین مقدار را در‬.‫( قرار دادهایم‬selectedNumber) ‫ کد باال مقدار برگشتی از متد را در یک متغیر از نوع صحیح‬31 ‫در خط‬
‫ با مقادیر ثابت گفته شده مقایسه کرده و در صورت مساوی بودن با هر یک از این مقادیر پیغامهای مختلفی نمایش‬51 ‫ و‬53 ‫ و‬31
‫ به کد زیر‬.‫ حال اجازه دهید که با یک برنامه به شما نحوه استفاده از این کادرها و متدهای آنها را به شما آموزش دهیم‬. ‫دادهایم‬
:‫توجه کنید‬
2
3 import java.io.File;
6 import javax.swing.filechooser.*;
7
9 {
11 {
12 final JFrame frame = new JFrame("JFileChooser Demo");
14 JButton button = new JButton("Open File");
15 panel.add(button);
16 frame.add(panel);
17
18 final JFileChooser filechooser = new JFileChooser();
19
20 button.addActionListener(new ActionListener()
21 {

‫‪23‬‬ ‫{‬
‫‪24‬‬ ‫;)‪filechooser.showDialog(null,null‬‬
‫‪25‬‬ ‫}‬
‫‪26‬‬ ‫;)}‬
‫‪27‬‬
‫‪28‬‬ ‫;)‪frame.setSize(430,315‬‬
‫‪29‬‬ ‫;)‪frame.setVisible(true‬‬
‫‪30‬‬ ‫}‬
‫‪31‬‬ ‫}‬
‫در کد باال یک دکمه به ‪ Panel‬و ‪ Panel‬را به ‪ Frame‬اضافه کردهایم (خطوط ‪ .)35-31‬حال میخواهیم با کلیک بر روی دکمه‪ ،‬کادر‬
‫محاوره ای باز کردن فایل )‪ (OpenFileDialog‬نمایش داده شود‪ .‬این کار را در خطوط ‪ 53-51‬انجام دادهایم‪ .‬با اجرای برنامه و زدن‬
‫بر روی دکمه مشاهده میکنید که کادر محاوره ای نمایش داده میشود‪ .‬از این به بعد کدهایی را که توضیح میدهیم بین خطوط‬
‫‪ 30‬و ‪ 53‬بنویسید‪ .‬ابتدا نوع کادر محاوره ای را با استفاده از متد )(‪ setDialogType‬به صورت زیر مشخص میکنیم‪:‬‬
‫;)‪filechooser.setDialogType(JFileChooser.OPEN_DIALOG‬‬
‫مشاهده میکنید که عنوان دکمه و پنجره هر دو ‪ Open‬میباشد‪ .‬اگر بخواهید عنوان پنجره را تغییر دهید از متد‬
‫)(‪ setDialogTitle‬استفاده کنید‪:‬‬
‫;)"‪filechooser.setDialogTitle("Open a File‬‬
‫‪356‬‬ ‫‪SWING‬‬
‫فرض کنید که میخواهیم با باز شدن کادر محاوره ای مثال پوشه ‪ Program files‬درایو ‪ C‬به عنوان پوشه پیشفرض نمایش داده‬
‫شود‪ .‬برای این کار )(‪ setCurrentDirectory‬به صورت زیر استفاده میکنیم‪:‬‬
‫;))")‪filechooser.setCurrentDirectory(new File("C:\\Program Files (x86‬‬

‫اگر بخواهیم کاربر را مجبور به انتخاب یک یا چند فایل بکنیم یعنی کاربر نتواند با گرفتن دکمه ‪ Ctrl‬کیبورد هم پوشه انتخاب کند‬
‫و هم فایل از کد زیر استفاده میکنیم‪:‬‬
‫;)‪filechooser.setFileSelectionMode(JFileChooser.FILES_ONLY‬‬
‫;)‪filechooser.setMultiSelectionEnabled(true‬‬
‫در خط اول مقدار ‪ JFileChooser.FILES_ONLY‬را به متد )(‪ setFileSelectionMode‬ارسال کردهایم‪ ،‬در نتیجه فقط فایلها‬
‫قابل انتخاب هستند و برای حق انتخاب چند فایل هم مقدار ‪ true‬را به متد )(‪ setMultiSelectionEnabled‬ارسال میکنیم‪.‬‬
‫با اجرای برنامه و گرفتن دکمه ‪ Ctrl‬متوجه میشوید که نمیشود همزمان هم فایل انتخاب کرد و هم پوشه‪ .‬در حالت پیشفرض‬
‫تمامی پسوندها در کادر محاوره ای نمایش داده میشود (‪ .)All files‬ولی اگر بخواهیم گزینههای دیگری به کادر محاوره ای‬
‫اضافه کنیم که مثال به وسیله آنها فقط فایلهای متنی و یا فقط عکسها نمایش داده شوند از کالسهای ‪ FileFilter‬و‬
‫‪ FileNameExtensionFilter‬به صورت زیر برای تعیین پسوندهای دلخواه و اضافه کردن آنها به کادر محاوره ای استفاده‬
‫میکنید‪:‬‬
‫;)"‪FileFilter ImageFiles = new FileNameExtensionFilter("JPEG file", "jpg", "jpeg‬‬

‫;)"‪FileFilter TextFiles = new FileNameExtensionFilter("Text file", "txt‬‬
‫در کدهای باال‪ ،‬اولین پارامتر داخل پرانتز توضیحی درباره پسوندها و پارامترهای بعدی هم خود اسم خود پسوندها میباشند‪ .‬تا‬
‫اینجا ما فقط پسوندها را مشخص کردهایم‪ .‬برای اضافه کردن آنها به کادر محاوره ای از متد )(‪ setFileFilter‬به صورت زیر‬
‫استفاده میکنیم‪:‬‬
‫;)‪filechooser.setFileFilter(ImageFiles‬‬
‫;)‪filechooser.setFileFilter(TextFiles‬‬
‫حال برنامه را اجرا کنید‪:‬‬

‫‪313‬‬ ‫‪SWING‬‬
‫مشاهده میکنید که در جلوی کادر ‪ Files of Type‬دو گروه پسوند دیگر اضافه شده است که با انتخاب هر یک از آنها فقط‬
‫فایلهای با آن پسوند در کادر محاوره ای نمایش داده میشود‪.‬‬
‫کنترل ‪JColorChooser‬‬
‫از کنترل ‪ JColorChooser‬وقتی استفاده میشود که شما بخواهید یک رنگ انتخاب کنید‪ .‬به عنوان مثال وقتی بخواهید رنگ یک‬
‫فونت یا رنگ پس زمینه فرم را تغییر دهید میتوانید از این کنترل استفاده کنید‪ .‬سازنده این کالس به روشهای زیر مقداردهی‬
‫)(‪public JColorChooser‬‬
‫)‪public JColorChooser(Color initialColor‬‬
‫)‪public JColorChooser(ColorSelectionModel model‬‬
‫نمای کلی کنترل ‪ JColorChooser‬در شکل زیر مشاهده میکنید‪:‬‬

‫پنجره ‪ JColorChooser‬از رنگهای از پیش تعریف شده تشکیل شده است (شماره ‪ .)5‬شما میتوانید با کیلک بر روی سربرگهای‬
‫این پنجره (شماره ‪ )3‬تعداد بیشتری رنگ مشاهده کنید به طوری که در پنجره ظاهر شده هر رنگی که دوست دارید را انتخاب نمایید‪.‬‬
‫همچنین با استفاده از پنجره ‪( Preview‬شماره ‪ )1‬میتوانید پیش نمایشی از اعمال رنگ مورد نظرتان بر قسمتهای مختلف یک‬
‫کنترل (متن‪ ،‬پس زمینه متن‪ ،‬خاشیه کنترل و …) را مشاهده نمایید‪ .‬برای نشان دادن عملکرد کادر محاوره ای ‪JColorChooser‬‬

‫‪2‬‬
‫‪6‬‬
‫‪8‬‬ ‫{‬
‫‪10‬‬ ‫{‬
‫‪11‬‬ ‫;)"‪JFrame frame1 = new JFrame("JColorChooser Demo‬‬
‫‪12‬‬ ‫;)(‪final JPanel panel1 = new JPanel‬‬
‫‪13‬‬ ‫;)"‪JButton button1 = new JButton("Change Panel Color‬‬
‫‪14‬‬
‫‪15‬‬ ‫;)‪panel1.add(button1‬‬
‫‪16‬‬ ‫;)‪frame1.add(panel1‬‬
‫‪17‬‬
‫‪18‬‬ ‫)(‪button1.addActionListener(new ActionListener‬‬
‫‪311‬‬ ‫‪SWING‬‬
‫‪19‬‬ ‫{‬
‫‪21‬‬ ‫{‬
‫‪22‬‬ ‫(‪Color selectedColor = JColorChooser.showDialog‬‬
‫‪23‬‬ ‫;))(‪panel1, "Choose Background Color", panel1.getBackground‬‬
‫‪24‬‬
‫‪25‬‬ ‫)‪if(selectedColor != null‬‬
‫‪26‬‬ ‫{‬
‫‪27‬‬ ‫;)‪panel1.setBackground(selectedColor‬‬
‫‪28‬‬ ‫}‬
‫‪29‬‬ ‫}‬
‫‪30‬‬ ‫;)}‬
‫‪31‬‬
‫‪32‬‬ ‫;)‪frame1.setSize(416, 313‬‬
‫‪34‬‬ ‫}‬
‫‪35‬‬ ‫}‬
‫هدف برنامه باال اعمال رنگ به پس زمینه یه ‪ Panel‬میباشد‪ .‬در خطوط ‪ 33-31‬یک کنترل دکمه به ‪ Panel‬و ‪ Panel‬را به یک‬
‫‪ Frame‬اضافه کردهایم‪ .‬چون که قرار است با کلیک بر روی دکمه کادر محاوره ای ‪ JColorChooser‬نمایش داده شود‪ ،‬پس باید‬
‫رابط ‪ ActionListener‬را پیاده سازی کنیم‪ .‬در خطوط ‪ 30-56‬این کار را انجام داده و سپس در بدنه متد )(‪actionPerformed‬‬
‫رابط خطوط ‪ 55-50‬را مینویسید‪ .‬در خطوط ‪ 55-51‬ابتدا یک رنگ را انتخاب میکنیم‪ .‬در این خط ابتدا یک شئ از کالس ‪Color‬‬
‫ایجاد میکنیم‪ .‬این کالس یک رنگ را در اختیار ما میگذارد‪ .‬در ادامه همین خط چون ما قرار است که با استفاده از کادر محاوره ای‬
‫‪ JColorChooser‬یک رنگ انتخاب کنیم باید ابتدا کادر را نمایش دهیم‪ .‬این کار را با استفاده از متد استاتیک )(‪showDialog‬‬
‫انجام میدهیم‪ .‬این متد سه پارامتر میگیرد‪:‬‬
‫;)‪JColorChooser.showDialog(parent,title,color‬‬
‫پارامتر اول کنترل والد‪ ،‬پارامتر دوم عنوان کادر محاوره ای و پارامتر سوم رنگ پیشفرضی که هنگام نمایش کادر مشخص میشود‪،‬‬
‫میباشد‪ .‬برنامه را اجرا کنید‪:‬‬

‫مشاهده میکنید که عنوان پنجره ‪ Choose Background Color‬و در قسمت پیشنمایش هم رنگ پیشفرض سفید میباشد‪.‬‬
‫چون ما هیچ رنگی را از قبل به پس زمینه ‪ Panel‬اختصاص ندادهایم در نتیجه متد )(‪ getBackground‬که رنگ جاری کنترل را‬
‫بر میگرداند‪ ،‬رنگ سفید را بر میگرداند‪ .‬استفاده از این متد یک حسن دارد و آن این است که اگر یک رنگ انتخاب کرده و بر روی‬
‫دکمه ‪ OK‬کلیک کنید و دوباره کادر را باز کنید‪ ،‬همان رنگ قبلی را که انتخاب کردهاید به عنوان رنگ پیشفرض کادر به شما نمایش‬
‫میدهد‪ .‬حال همین خط ‪ 55‬را به صورت زیر بنویسید‪:‬‬
‫;)‪Color selectedColor = JColorChooser.showDialog(panel1,"Choose Background Color",Color.RED‬‬
‫مشاهده میکنید که به خاطر پارامتر سوم بعد از اجرای برنامه و زدن دکمه‪ ،‬رنگ پیشفرض کادر محاوره ای قرمز میباشد‪:‬‬
‫‪311‬‬ ‫‪SWING‬‬
‫حال اگر چندین بار رنگ انتخاب کرده و در هر بار دکمه ‪ OK‬را بزنید و دوباره کادر را باز کنید همیشه رنگ قرمز به شما نمایش داده‬
‫میشود‪ .‬در خطوط ‪ 53-51‬چک میکنیم که اگر رنگی انتخاب شده باشد آن را به پس زمینه ‪ Panel‬اعمال کند‪ .‬برنامه را اجرا‪ ،‬یک‬
‫رنگ را انتخاب و بر روی دکمه ‪ OK‬کلیک کنید کنید‪:‬‬

‫فصل سوم‬
‫کار با تاریخ‪ ،‬فایل و رشته‬

‫‪311‬‬ ‫کار با تاریخ‪ ،‬فایل و رشته‬
‫کالس ‪Date‬‬
‫کالس ‪ Date‬کالسی از جاوا است که در پکیج ‪ java.util‬قرار دارد و به شما اجازه استفاده‪ ،‬ذخیره‪ ،‬و دستکاری ساعت و تاریخ‬
‫را میدهد‪ .‬این کالس دارای متدهایی برای دستکاری تاریخ مانند اضافه و کم کردن روزها‪ ،‬ماهها‪ ،‬یا سالها و مطابق کردن آنها با‬
‫تاریخ جاری را میدهند‪ .‬همچنین دارای متده ایی است که تاریخ را به اشکال متفاوتی نشان میدهند‪ .‬کد زیر نحوه استفاده از‬
‫کالس ‪ Date‬را نشان میدهد‪.‬‬
‫;*‪import java.util.‬‬

‫{‬
‫{‬
‫;)(‪Date today = new Date‬‬
‫;)‪System.out.print(today‬‬
‫}‬
‫}‬
‫‪Wed Jul 08 17:52:38 IRDT 2015‬‬
‫در این مثال تاریخ و ساعتی که بنده این آموزش را قرار دادهام نمایش داده شده است‪ .‬همانطور که در کد باال مشاهده میکنید‬
‫برای استفاده از این کالس باید پکیج مربوطه )‪ (java.util‬را با کلمه کلیدی ‪ import‬وارد برنامه کنید‪ .‬کالس ‪ Date‬دارای‬
‫چندین متد است که در زیر کاربرد آنها نشان داده شده است‪:‬‬
‫توضیحات‬ ‫متد‬
‫مقدار ‪ true‬را در صورتی که تاریخ سیستم بعد از تاریخ داده شده بصورت پارامتر باشد برمی گرداند‪.‬‬ ‫)(‪after‬‬
‫مقدار ‪ true‬را در صورتی که تاریخ سیستم قبل از تاریخ داده شده بصورت پارامتر باشد برمی گرداند‪.‬‬ ‫)(‪before‬‬
‫برای کپی کردنشی تعریف شده‪.‬‬ ‫)(‪clone‬‬
‫مقایسه تاریع سیستم با تاریخ پارامتر‪ .‬در صورتی که برابر باشند مقدار ‪ 3‬در صورتی که تاریخ سیستم‬ ‫)(‪compareTo‬‬
‫قبل باشد مقدار منفی و در صورتی که بعد باشد مقدار مثبت بر میگرداند‪.‬‬
.‫چک میکند که آیا کالس داده شده در پارامتر از نوع تاریخ هست یا نه‬ compareTo()
.‫ در صورت برابر بودن‬true ‫مقایسه تاریخ موجود با تاریخ و زمان پارامتر و بازگشت مقدار‬ equals()
.3613 ‫ ژانویه‬3 ‫بازگرداندن تعداد میلی ثانیه از تاریخ‬ getTime()
.‫بازگرداندن کد هش شده شی تعریف شده‬ hashCode()
3613 ‫ ژانویه‬3 ‫تنظیم زمان با دادن تعداد میلی ثانیه از‬ setTime()
:‫به مثال زیر درباره کاربرد متدهای باال توجه کنید‬
import java.util.*;

{
{
System.out.println(new Date(2010).after(new Date(2015)));
System.out.println(new Date(2010).before(new Date(2015)));
System.out.println(new Date().clone());
System.out.println(new Date(2010).compareTo(new Date(2015)));
System.out.println(new Date(2010).equals(new Date(2015)));
System.out.println(new Date().getTime());
System.out.println(new Date().hashCode());
}
}
false
true
Wed Jul 08 18:44:03 IRDT 2015
-1
false
1436364843809
1845766767
‫قالب بندی تاریخ‬
.‫ استفاده کرد‬SimpleDateFormat ‫ و هم از کالس‬printf() ‫برای قالب بندی یا نمایش دلخواه تاریخ در جاوا هم میتوان از متد‬
.‫قبل از خواندن ادامه آموزش توصیه میشود که ابتدا این پست را بخوانید‬
http://www.w3-farsi.com/?p=8321
‫قالب بندی تاریخ با متد ‪printf‬‬
‫هنگامی که یک شئ ‪ Date‬ایجاد میکنیم برای نمایش تاریخ و زمان به صورت سفارشی میتوان از متد )(‪ printf‬و کارکترهای‬
‫خاصی که در جدول زیر لیست شدهاند استفاده کرد‪:‬‬
‫مثال‬ ‫توضیح‬ ‫کاراکتر‬
‫‪Mon May 04 09:51:52 CDT 2015‬‬ ‫نمایش تاریخ و زمان بصورت کامل‬ ‫‪c‬‬
‫‪2004-02-09‬‬ ‫نمایش تاریخ با فرمت‪iso 8601‬‬ ‫‪F‬‬
‫‪10/09/2015‬‬ ‫نمایش تاریخ با فرمت)‪(month/day/year‬‬ ‫‪D‬‬
‫‪19:25:19‬‬ ‫نمایش زمان با فرمت ‪ 53‬ساعته‬ ‫‪T‬‬
‫‪10:05:20 pm‬‬ ‫نمایش زمان با فرمت ‪ 35‬ساعته‬ ‫‪r‬‬
‫‪20:05‬‬ ‫نمایش زمان با فرمت ‪ 53‬ساعته بدون ثانیه‬ ‫‪R‬‬
‫‪2015‬‬ ‫نمایش سال با ‪ 3‬رقم‬ ‫‪Y‬‬
‫‪06‬‬ ‫نمایش سال با ‪ 5‬رقم آخر‬ ‫‪y‬‬
‫‪20‬‬ ‫نمایش ‪ 5‬رقم اول سال‬ ‫‪C‬‬
‫‪February‬‬ ‫نمایش نام کامل ماه‬ ‫‪B‬‬
‫‪Feb‬‬ ‫نمایش خالصه شده نام ماه‬ ‫‪b‬‬
‫‪04‬‬ ‫نمایش ماه با ‪ 5‬رقم‬ ‫‪m‬‬
‫‪07‬‬ ‫نمایش روز با ‪ 5‬رقم‬ ‫‪d‬‬
‫‪7‬‬ ‫نمایش روز بودن عدد ‪ 3‬درصورت یک رقمی بودن‬ ‫‪e‬‬

‫‪Monday‬‬ ‫نمایش نام کامل روز در هفته‬ ‫‪A‬‬
‫‪Mon‬‬ ‫نمایش نام اختصاری روز در هفته‬ ‫‪a‬‬
‫‪071‬‬ ‫نمایش شماره ‪ 1‬رقمی روز در سال‬ ‫‪j‬‬
‫‪19‬‬ ‫نمایش شماره ‪ 5‬رقمی نشان دهنده ساعت در فرمت ‪ 53‬ساعته ‪ 33‬تا ‪53‬‬ ‫‪H‬‬
‫‪17‬‬ ‫نمایش ساعت بدون گذاشتن ‪ 3‬قبل از ساعت یک رقمی ‪ 3‬تا ‪51‬‬ ‫‪k‬‬
‫‪07‬‬ ‫شماره ‪ 5‬رقمی نشان دهنده ساعت در فرمت ‪ 35‬ساعته ‪ 33‬تا ‪35‬‬ ‫‪I‬‬
‫‪7‬‬ ‫نمایش ساعت بودن گذاشتن ‪ 3‬قبل از ساعت یک رقمی ‪ 3‬تا ‪35‬‬ ‫‪l‬‬
‫‪07‬‬ ‫نمایش دقیقه ‪ 5‬رقمی‬ ‫‪M‬‬
‫‪20‬‬ ‫نمایش دقیقه بدون گذاشتن ‪ 3‬قبل از آن درصورت ‪ 3‬رقمی بودن‬ ‫‪S‬‬
‫‪051‬‬ ‫نمایش ‪ 1‬رقمی میلی ثانیه‬ ‫‪L‬‬
‫‪051000000‬‬ ‫نمایش ‪ 6‬رقمی نانو ثانیه‬ ‫‪N‬‬
‫‪PM‬‬ ‫نمایش نوع زمان بصورت حروف بزرگ‬ ‫‪P‬‬
‫‪pm‬‬ ‫نمایش نوع زمان با حروف کوچک‬ ‫‪p‬‬
‫‪-0800‬‬ ‫نمایش عددی انحراف از زمان واحد‪GMT‬‬ ‫‪z‬‬
‫‪PST‬‬ ‫منطقه زمانی‬ ‫‪Z‬‬
‫‪1084524320‬‬ ‫تعداد ثانیهها از تاریخ ‪3/3/3613‬‬ ‫‪s‬‬
‫‪1052334319051‬‬ ‫تعداد میلی ثانیه از زمان ‪ GMT 33:33:33‬سال ‪33/33/3613‬‬ ‫‪Q‬‬
‫برای اینکه با کاربرد کاراکترهای باال در متد و همچنین قالب بندی آشنا شوید به مثال زیر توجه کنید‪:‬‬
‫;)‪System.out.printf("%tY", today‬‬
‫‪2015‬‬
‫در مثال باال از ‪ %tY‬برای قالب بندی تاریخ استفاده کردهایم‪ .‬قالب بندی همیشه با عالمت ‪ %‬شروع میشود‪ .‬حرف ‪ t‬بعد از آن به‬
‫معنای آن است که ما میخواهیم یک مقدار زمانی را قالب بندی کنیم و حرف ‪ Y‬هم‪ ،‬همانطور که در جدول مشاهده میکنید برای‬
‫نمایش سال به صورت چهار رقمی است‪ .‬حال فرض کنید که میخواهیم یک زمان را به صورت کامل نمایش دهیم‪:‬‬
‫;)‪System.out.printf("%1$s %2$tB %2$td, %2$tY", "Due Today : ", today‬‬
‫‪Due Today :‬‬ ‫‪July 08, 2015‬‬
‫همانطور که در کد باال مشاهده میکنید‪ Due Today ،‬یک رشته است و اولین آرگومان بعد از رشته قالب بندی شده‪ ،‬در نتیجه از‬
‫‪ %1$s‬برای قالب بندی آن استفاده کردهایم‪ .‬عدد یک به معنای اولین آرگومان‪ ،‬عالمت ‪ $‬محدود کننده است و برای قالب بندیهای‬
‫چند بخشی کاربرد دارد یا به عبارت دیگر اندیس آرگومانها باید در داخل دو عالمت ‪ %$‬قرار بگیرد‪ .‬عالمت ‪ s‬کوچک هم به معنای‬
‫رشته میباشد ‪ .‬دومین آرگومان بعد از رشته قالب بندی شده هم به صورت سه بخشی قرار است نمایش داده شود پس هر بخش‬
‫با ‪ %2$t‬شروع و بعد از این عبارت هم یکی از کاراکترهای موجود در جدول باال آمده است‪ t .‬به معنای تاریخ است‪.‬‬
‫قالب بندی تاریخ با کالس‪SimpleDateFormat‬‬
‫کالس ‪ SimpleDateFormat‬هم که در پکیج ‪ java.text‬قرار دارد با دریافت کاراکترهای خاصی تاریخ را فرمت بندی میکند‪.‬‬
‫لیست کاراکترهایی که میتوانیم به سازنده این کالس بدهیم در جدول زیر آمده است‪:‬‬
‫مثال‬ ‫توضیحات‬ ‫کاراکتر‬
‫‪AD‬‬ ‫نوع فرمت تاریخ‬ ‫‪G‬‬
‫‪2015‬‬ ‫چهاررقم سال‬ ‫‪y‬‬

‫‪July or 07‬‬ ‫نام یا شماره ماه در سال‬ ‫‪M‬‬
‫‪12‬‬ ‫روز در ماه‬ ‫‪d‬‬
‫‪10‬‬ ‫ساعت در فرمت ‪ 35‬ساعته‬ ‫‪h‬‬
‫‪22‬‬ ‫ساعت در فرمت ‪ 53‬ساعته‬ ‫‪H‬‬
‫‪30‬‬ ‫دقیقه از ساعت‬ ‫‪m‬‬
‫‪55‬‬ ‫ثانیه از دقیقه‬ ‫‪s‬‬
‫‪234‬‬ ‫میلی ثانیه‬ ‫‪S‬‬
‫‪Tuesday‬‬ ‫نام روز هفته‬ ‫‪E‬‬
‫‪360‬‬ ‫روز در سال‬ ‫‪D‬‬
‫)‪2 (second Wed. in July‬‬ ‫روز از هفته در ماه‬ ‫‪F‬‬
‫‪40‬‬ ‫هفته از سال‬ ‫‪w‬‬
‫‪1‬‬ ‫هفته از ماه‬ ‫‪W‬‬
‫‪PM‬‬ ‫نوشتن قبل یا بعد ظهر‬ ‫‪a‬‬
‫‪24‬‬ ‫ساعت از روز ‪ 53‬ساعته‬ ‫‪k‬‬
‫‪10‬‬ ‫ساعت از روز ‪ 35‬ساعته‬ ‫‪K‬‬
‫‪Eastern Standard Time‬‬ ‫منطقه زمانی‬ ‫‪z‬‬
‫‪Delimiter‬‬ ‫نمایش متن‬ ‫‘‬
‫`‬ ‫نمایش تک کوتیشن‬ ‫“‬


‫‪SimpleDateFormat SDF = new SimpleDateFormat("E yyyy.MM.dd‬‬ ‫;)"‪'at' hh:mm:ss a zzz‬‬
‫‪System.out.println("Current Date: " +‬‬ ‫;))‪SDF.format(today‬‬
‫‪Current Date: Wed 2015.07.08‬‬ ‫‪at 10:39:19 PM IRDT‬‬
‫کالس ‪Math‬‬
‫از کالس ‪ Math‬برای انجام محاسبات ریاضی استفاده میشود‪ .‬از این کالس میتوان برای گرد کردن اعداد‪ ،‬گرفتن جذر یا نتیجه‬
‫توان یک عدد استفاده کرد‪ .‬این کالس یک کالس ‪ final‬است و دارای تعدادی متد ‪ static‬بوده که از آنها برای انجام اعمال‬
‫مختلف ریاضی از جمله به دست آوردن توان‪ ،‬جذر گرفتن و … استفاده میشود‪ .‬برای روشن شدن مطلب برخی از متدهای این‬
‫کالس را توضیح میدهیم‪.‬‬
‫قدر مطلق یک عدد را بر میگرداند‪.‬‬ ‫‪abs‬‬
‫کوچکترین مقدار صحیحی که بزرگتر یا مساوی با عدد مورد نظر ما باشد را بر میگرداند‪.‬‬ ‫‪ceil‬‬
‫کوسینوس یک زاویه مشخص را بر میگرداند‪.‬‬ ‫‪cos‬‬
‫بزرگترین مقدار صحیحی که کوچکتر یا مساوی با عدد مورد نظر ما باشد را بر میگرداند‪.‬‬ ‫‪floor‬‬
‫لگاریتم یک عدد در مبنای ‪ 33‬را بر میگرداند‪.‬‬ ‫‪log10‬‬
‫بزرگترین عدد در بین چندین عدد را بر میگرداند‪.‬‬ ‫‪max‬‬
‫کوچکترین عدد در بین چندین عدد را بر میگرداند‪.‬‬ ‫‪min‬‬
‫برای به توان رساندن یک عدد به کار میرود‪.‬‬ ‫‪pow‬‬
‫گرد کردن یک عدد اعشار به نزدیکترین مقدار صحیح‪.‬‬ ‫‪round‬‬

‫سینوس یک زاویه مشخص را بر میگرداند‪.‬‬ ‫‪sin‬‬
‫جذر یک عدد را بر میگرداند‪.‬‬ ‫‪sqrt‬‬
‫تانژانت یک زاویه را بر میگرداند‪.‬‬ ‫‪tan‬‬
‫گرد کردن اعداد با استفاده از کالس‪Math‬‬
‫میتوان با استفاده از )(‪ Math.ceil‬و )(‪ Math.floor‬یک عدد با قسمت اعشار را گرد کرد‪ .‬متد )(‪ Math.ceil‬یک عدد از نوع‬
‫‪ double‬را گرفته و یک مقدار از نوع ‪ double‬گرد شده را بر میگرداند‪ .‬نتیجه این متد بزرگتر یا مساوی آرگومان دریافت شده‬
‫است‪ Math.floor .‬یک عدد ‪ double‬را گرد کرده و نتیجه کوچکتر یا مساوی آرگومان گرفته شده است‪ .‬برای روشن شدن مطلب‬
‫;‪double number = 34.567‬‬

‫;)‪double ceil = Math.ceil(number‬‬
‫;)‪double floor = Math.floor(number‬‬
‫;))‪System.out.println(MessageFormat.format("Math.Ceiling({0}) = {1}", number, ceil‬‬

‫;))‪System.out.println(MessageFormat.format("Math.Ceiling({0}) = {1}", number, floor‬‬
‫‪Math.Ceiling(34.567) = 35‬‬
‫‪Math.Floor(34.567) = 34‬‬
‫اگر بخواهید یک عدد اعشاری را گرد کنید میتوانید از متد )(‪ Math.round‬استفاده کنید‪:‬‬
‫;‪double firstNumber = 3.4‬‬

‫;‪double secondNumber = 3.6‬‬
‫;))‪System.out.println(Math.round(firstNumber‬‬
‫;))‪System.out.println(Math.round(secondNumber‬‬
‫‪3‬‬
‫‪4‬‬
‫همانطور که در کد باال مشاهده میکنید اگر اولین رقم اعشار از ‪ 1‬کوچکتر باشد عدد اعشار رو به پایین و اگر بزرگتر از ‪ 1‬باشد عدد‬
‫اعشار رو به باال گرد میشود‪.‬‬

‫به توان رساندن یک عدد با استفاده از کالس‪Math‬‬
‫برای به توان رساندن یک عدد از متد )(‪ Math.pow‬استفاده میشود‪ .‬این متد دو آرگومان از نوع ‪ double‬قبول کرده که اولین‬
‫آرگومان پایه و دومی توان میباشد‪ .‬مقدار برگشتی از این متد ‪ double‬است‪ .‬به کد زیر توجه کنید‪:‬‬
‫)‪for (int i = 0; i < 10; i++‬‬

‫{‬
‫;)))‪System.out.println(MessageFormat.format("2^{0} = {1}", i, Math.pow(2, i‬‬
‫}‬
‫‪2^0‬‬ ‫=‬ ‫‪1‬‬

‫‪2^1‬‬ ‫=‬ ‫‪2‬‬
‫‪2^2‬‬ ‫=‬ ‫‪4‬‬
‫‪2^3‬‬ ‫=‬ ‫‪8‬‬
‫‪2^4‬‬ ‫=‬ ‫‪16‬‬
‫‪2^5‬‬ ‫=‬ ‫‪32‬‬
‫‪2^6‬‬ ‫=‬ ‫‪64‬‬
‫‪2^7‬‬ ‫=‬ ‫‪128‬‬
‫‪2^8‬‬ ‫=‬ ‫‪256‬‬
‫‪2^9‬‬ ‫=‬ ‫‪512‬‬
‫گرفتن ریشه یک عدد‬
‫برای محاسبه ریشه یک عدد از متد )(‪ Math.sqrt‬استفاده میشود‪ .‬این متد یک عدد به عنوان آرگومان قبول میکند که همان‬
‫عددی است که میخواهیم ریشه آن را محاسبه کنیم ‪ .‬مقدار برگشتی از این متد هم ‪ double‬میباشد‪.‬‬
‫;))‪System.out.println(Math.sqrt(25‬‬
‫‪5.0‬‬
‫یافتن بزرگتر ین و کوچکتر ین عدد با استفاده از کالس ‪Math‬‬
‫کالس ‪ Math‬دارای متدهای )(‪ Math.min‬و )(‪ Math.max‬برای یافتن بزرگترین و کوچکترین عدد از بین چندین عدد میباشد‪.‬‬
‫هر دو متد دو آرگومان از نوع عددی قبول میکنند‪ .‬در حالت پیشفرض دو عدد را میتوانید با هم مقایسه نمایید‪.‬‬
‫;))‪System.out.println(Math.min(1,2‬‬
‫;))‪System.out.println(Math.max(1,2‬‬
‫‪1‬‬
‫‪2‬‬
‫برای جلوگیری از محدودیت این متدها میتوان به صورت تو در تو از آنها به صورت زیر استفاده کرد‪:‬‬
‫‪//Get the maximum and minimum of 3 numbers‬‬

‫;)‪int max = Math.max(Math.max(1, 2), 3‬‬
int min = Math.min(Math.min(1, 2), 3);
System.out.println(MessageFormat.format("Max = {0}", max));

System.out.println(MessageFormat.format("Min = {0}", min));
Max = 3
Min = 1
:‫همچنین میتوانید یک تابع تعریف کنید که کوچکترین و بزرگترین هر تعداد عدد را به شما معرفی کند‬

{
static int GetMax(int[] numbers)
{
int maximum = numbers[0];
for (int i = 1; i < numbers.length; i++)

{
maximum = Math.max(maximum, numbers[i]);
}
return maximum;
}
static int GetMin(int[] numbers)

{
int minimum = numbers[0];
for (int i = 1; i < numbers.length; i++)

{
minimum = Math.min(minimum, numbers[i]);
}
return minimum;
}

{
int[] numbers = { 32, 17, 45, 10, 5 };
int max = GetMax(numbers);
int min = GetMin(numbers);
System.out.println(max);
System.out.println(min);
}
}
45
5
‫ در داخل توابع ما فرض را بر‬.)‫ آرایه ای از اعداد صحیح قبول میکنند (هر تعداد عدد را قبول میکنند‬GetMin() ‫ و‬GetMax() ‫توابع‬
3 ‫ ایجاد کرده که با اندیس‬for ‫ سپس یک حلقه‬.‫این گذاشتهایم که اولین مقدار بزرگترین و آخرین مقدار کوچکترین عدد است‬
‫ تعیین میکنیم که آیا عنصر جاری حلقه از مقدار جاری اعداد‬Math.max() ‫ و‬Math.min() ‫ با استفاده از متدهای‬.‫شروع میشود‬
‫بزرگتر است یا کوچکتر‪ .‬که در این صورت مقدار جاری را جایگزین متغیرهای بزرگ یا کوچک میکنیم‪ .‬سپس مقادیر نتیجه را‬
‫برگشت میدهیم‪.‬‬
‫‪Math.PI‬‬
‫از ثابت ‪ PI‬که مقدار ‪ 1.33316511110616151031‬را در خود ذخیره دارد‪ ،‬زمانی که بخواهید محیط یا مساحت یک دایره را پیدا‬
‫کنید‪ ،‬استفاده میشود‪ .‬برای یافتن محیط یک دایره به صورت زیر عمل میشود که در آن ‪ radius‬شعاع میباشد‪:‬‬
‫;)‪double area = Math.PI * Math.pow(radius, 2‬‬
‫کالس ‪ Math‬دارای متدهای بیشتری است که ما به توضیح همین چند متد بسنده کردیم‪.‬‬
‫ایجاد عدد تصادفی‬

‫برای تولید عدد تصادفی در جاوا از کالس ‪ Random‬که در پکیج ‪ java.util‬قرار دارد استفاده میشود‪ .‬پس در ابتدای برنامه الزم‬
‫است که این کالس را ‪ import‬کنید‪:‬‬
‫;‪import java.util.Random‬‬
‫سادهترین روش برای تولید اعداد تصادفی استفاده از متدهای )(‪ nextDouble ،nextInt‬و … است‪ .‬برای این کار ابتدا یک شیء‬
‫از کالس ‪ Random‬میسازیم و سپس از متدهای مذکور برای تولید اعداد تصادفی استفاده میکنیم‪ .‬به مثال زیر توجه کنید‪:‬‬

‫{‬
‫{‬
‫;)(‪Random generator = new Random‬‬
‫‪boolean‬‬ ‫‪booleanValue‬‬ ‫=‬ ‫;)(‪generator.nextBoolean‬‬

‫‪int‬‬ ‫‪intValue‬‬ ‫=‬ ‫;)(‪generator.nextInt‬‬
‫‪double‬‬ ‫‪doubleValue‬‬ ‫=‬ ‫;)(‪generator.nextDouble‬‬
‫‪float‬‬ ‫‪floatValue‬‬ ‫=‬ ‫;)(‪generator.nextFloat‬‬
‫;)‪System.out.println(booleanValue‬‬
‫;)‪System.out.println(intValue‬‬
‫;)‪System.out.println(doubleValue‬‬
‫;)‪System.out.println(floatValue‬‬
‫}‬
‫}‬
‫‪false‬‬
‫‪-240333896‬‬
‫‪0.07659793195249542‬‬
‫‪0.6878707‬‬
‫حال اگر برنامه باال را چندین بار اجرا کنید نتیجههای مختلفی در خروجی مشاهده خواهید کرد‪ .‬برای اینکه نحوه کار با این کالس‬
‫و متدهای آن را راحت درک کنید در مثالهای بعدی با اعداد صحیح کار میکنیم‪ .‬فرض میکنیم که شما میخواهید ده عدد از نوع‬
‫‪ int‬تولید کنید‪:‬‬
‫‪//Generate 10 random numbers‬‬

‫)‪for (int i = 1; i <= 10; i++‬‬
‫{‬
‫;))(‪System.out.println(generator.nextInt‬‬
‫}‬
‫‪306495489‬‬
‫‪861232443‬‬
‫‪1265448050‬‬
‫‪-30370747‬‬
‫‪499374488‬‬
‫‪-1865142177‬‬
‫‪1196801248‬‬
‫‪-1061328848‬‬
‫‪62018178‬‬
‫‪1609249893‬‬
‫خروجی شما مطمئنا متفاوت است چون همه اعداد تصادفی میباشند‪ .‬یکی دیکر از نسخههای متد )(‪ nextInt‬به شما اجازه‬
‫میدهد که تعدادی عدد تصادفی که کوچکتر از یک عدد خاص هستند‪ ،‬تولید کنید‪ .‬فرض کنید که میخواهید یک عدد صحیح در‬
‫یک بازه تولید کنید‪ ،‬مثال عددی بین ‪ 3‬و ‪( 3‬یعنی ‪ 3‬و ‪ 3‬هم جزء اعداد تولید شده باشند)‪ .‬برای این کار باید به صورت زیر عمل کنید‬
‫‪:‬‬

‫)‪for (int i = 1; i <= 10; i++‬‬
‫{‬
‫;))‪System.out.println(generator.nextInt(5‬‬
‫}‬
‫‪1‬‬
‫‪4‬‬
‫‪1‬‬
‫‪0‬‬
‫‪3‬‬
‫‪1‬‬
‫‪4‬‬
‫‪4‬‬
‫‪4‬‬
‫‪0‬‬
‫همانطور که در مثال باال مشاهده میکنید عدد ‪ 1‬را به عنوان آرگومان به متد )(‪ nextInt‬دادهایم و سپس با استفاده از حلقه‬
‫‪ for‬ده بار خروجی این متد را چاپ کردهایم‪ .‬مشاهده میکنید که عدد ‪ 1‬هرگز چاپ نمیشود‪ ،‬چون مقداری که این کالس و متد‬
‫ایجاد میکنند عددی بزرگتر مساوی با ‪ 3‬و کوچکتر از ‪ 1‬است نه خود عدد ‪ .1‬پس برای اینکه عدد ‪ 1‬هم چاپ شود باید به دو‬
‫روش عمل کنیم‪ ،‬یا به جای عدد ‪ 1‬عدد ‪ 1‬را بنویسیم‪:‬‬
‫‪int intValue‬‬ ‫;)‪= generator.nextInt(6‬‬
‫یا به صورت زیر عمل کنیم‪:‬‬

‫)‪for (int i = 1; i <= 10; i++‬‬
‫{‬
‫;)‪System.out.println(generator.nextInt(5) + 1‬‬
‫}‬
‫‪3‬‬
‫‪1‬‬
‫‪1‬‬
‫‪4‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪2‬‬
‫‪5‬‬
‫کد باال باعث تولید اعداد ‪ 3 ،1 ،5 ،3‬و ‪ 1‬میشود‪ .‬یعنی مفهوم کد باال با اضافه کردن عدد ‪ 3‬این است که کوچکترین عدد تولیدی ‪3‬‬
‫و بزرگترین عدد ‪ 1‬باشد‪ .‬حال فرض کنید به جای عدد ‪ 3‬از عدد ‪ 5‬یا عدد دیگر استفاده کنیم‪ .‬در مثال زیر از عدد ‪ 5‬استفاده میکنیم‬
‫‪:‬‬

‫)‪for (int i = 1; i <= 10; i++‬‬
‫{‬
‫;)‪System.out.println(generator.nextInt(5) + 2‬‬
‫}‬
‫در کد باال کوچکترین عدد تولیدی ‪ 5‬و بزرگترین عدد تولید ‪ )5+1(-3‬خواهد بود‪:‬‬
‫‪6‬‬
‫‪3‬‬
‫‪6‬‬
‫‪2‬‬
‫‪5‬‬
‫‪4‬‬
‫‪3‬‬
‫‪3‬‬
‫‪6‬‬
‫‪6‬‬
‫میتوان از یک مقدار هم ب رای تولید یک توالی تکراری از اعداد تصادفی استفاده کرد‪.‬بدین معنی که با هر بار اجرای برنامه توالی و‬
‫نوع اعداد تولید شده مانند سری قبلی باشد که برنامه اجرا شده است‪ .‬این مقدار هر عددی میتواند باشد‪ .‬برای اختصاص این‬
‫مقدار باید آن را در داخل پرانتز سازنده کالس ‪ Random‬قرار دهید‪.‬مانند عدد صفر در مثال زیر‪:‬‬
‫;)‪Random generator = new Random(0‬‬

‫)‪for (int i = 1; i <= 10; i++‬‬
‫{‬
‫;))‪System.out.println(generator.nextInt(5‬‬
‫}‬
‫‪0‬‬
‫‪3‬‬
‫‪4‬‬
‫‪2‬‬
‫‪0‬‬
‫‪3‬‬
‫‪1‬‬
‫‪1‬‬
‫‪4‬‬
‫‪4‬‬
‫با هر بار اجرای برنامه باال همین اعداد را مشاهده خواهید نمود‪ .‬حال اجازه بدهید که یک مثال ساده را توضیح دهیم‪ .‬این برنامه‬
‫پیغامهای متفاوتی در هر بار اجرای آن به شما نشان میدهد‪.‬‬

‫{‬
‫{‬
‫;‪int messageNumber = generator.nextInt(3) + 1‬‬
‫)‪switch (messageNumber‬‬
‫{‬
‫‪case 1:‬‬
‫;)"‪System.out.println("Hello to you my friend.‬‬

‫;‪break‬‬
‫‪case 2:‬‬
‫;)"‪System.out.println("Good day to you sir/mam.‬‬
‫;‪break‬‬
‫‪case 3:‬‬
‫;)"‪System.out.println("Have a happy day.‬‬
‫;‪break‬‬
‫}‬
‫}‬
‫}‬
‫برنامه مقادیر ‪ 3‬تا ‪ 1‬را تولید میکند‪ .‬سپس با استفاده از دستور ‪ switch‬برای نشان دادن یک پیغام برای هر مقدار ممکن استفاده‬
‫میکنیم‪ .‬بعد از چندین بار اجرای برنامه متوجه میشوید که پیغام خوش آمد گویی تغییر میکند‪.‬‬
‫رشتهها و عبارات با قاعده‬

‫رشتهها معمولترین انواع داده ای هستند که در تقریبا همه زبانهای برنامه نویسی یافت میشوند‪ .‬یک رشته گروهی از کاراکترها‬
‫مانند حروف‪ ،‬اعداد یا نشانهها میباشد‪ .‬رشته به وسیله کلمه کلیدی ‪ String‬تعریف میشود‪ .‬اهمیت این نوع داده ای زمانی‬
‫مشخص میشود که شما بخواهید اطالعاتی از قبیل نام‪ ،‬آدرس‪ ،‬جنسیت یا ایمیل خودتان را ذخیره کنید‪ .‬با استفاده از رشتهها‬
‫میتوان فورا به کاربر اطالعاتی ارائه و یا در مورد یک خطا در برنامه هشدار داد‪ .‬از عبارات با قاعده در اعتبارسنجی اطالعات استفاده‬
‫میشود‪ .‬در درسهای آینده در مورد خصوصیات مختلف رشتهها و متدهایی که به وسیله آنها شما میتوانید این خصوصیات را‬
‫دستکاری کنید توضیح داده خواهد شد‪.‬‬
‫کالس ‪String‬‬
‫رشتهها در جاوا با کالس ‪ String‬سر و کار دارند‪ .‬برای ایجاد یک رشته چندین راه وجود دارد‪:‬‬
‫;‪String myString‬‬
‫;"‪myString = "An example of a string.‬‬
‫به این نکته توجه کنید که رشتهها را باید در داخل دابل کوتیشن )”“( قرار دهید‪ .‬دابل کوتیشن به کمپایلر نشان میدهد که داده‬
‫ای را که شما میخواهید در متغیر ذخیره کنید یک رشته است‪ .‬برای تعریف و مقدار دهی به یک رشته میتوان به صورت زیر هم‬
‫عمل کرد‪:‬‬
‫;"‪String myString = "This is another string‬‬
‫همچنین میتوان از کلمه کلیدی ‪ new‬و سازنده ‪ String‬برای تخصیص یک مقدار به رشته استفاده کرد‪:‬‬
‫;)"‪String myString = new String("This is a string.‬‬
‫یک رشته مجموعه ای از کاراکترها میباشد‪ .‬کد زیر نحوه جدا سازی کاراکترهای یک رشته را به وسیله حلقه ‪ for‬نشان میدهد‪.‬‬
‫;"‪String myString = "This is a string‬‬
‫)‪for (int i = 0; i < myString.length(); i++‬‬

‫{‬
‫;))‪System.out.println(myString.charAt(i‬‬
‫}‬
‫‪T‬‬
‫‪h‬‬
‫‪i‬‬
‫‪s‬‬
‫‪i‬‬
‫‪s‬‬
‫‪a‬‬
‫‪s‬‬
‫‪t‬‬
‫‪r‬‬
‫‪i‬‬
‫‪n‬‬
‫‪g‬‬
‫در حقیقت‪ ،‬نسخه دیگر سازنده ‪ String‬یک آرایه از نوع کاراکتر قبول میکند‪.‬‬
‫;} '‪char[] charArray = { 'H', 'e', 'l', 'l', 'o‬‬
‫;)‪String myString = new String(charArray‬‬
‫در درس آینده نحوه مقایسه و مرتب سازی رشتهها را نشان خواهیم داد‪.‬‬
‫مقایسه رشتهها‬
‫میتوان رشتهها را به روشهای مختلف با هم مقایسه کرد‪ .‬به عنوان مثال با استفاده از عملگر == میتوان تست کرد که آیا دو‬
‫رشته با هم برابرند یا نه‪.‬‬
‫;"‪String str1 = "Hello‬‬

‫;"‪String str3 = "Goodbye‬‬
‫;))‪System.out.println(MessageFormat.format("str1 == str2 : {0}", str1 == str2‬‬

‫;))‪System.out.println(MessageFormat.format("str1 == str3 : {0}", str1 == str3‬‬
‫‪str1 == str2 : True‬‬

‫‪str1 == str3 : False‬‬
‫همچنین از متد )(‪ compareTo‬هم برای مقایسه دو رشته استفاده میشود‪ .‬به کد زیر توجه کنید‪:‬‬

‫;))‪System.out.println(str1.compareTo(str2‬‬
‫‪0‬‬
‫متد )(‪ compareTo‬یک رشته را میگیرد و آن را با رشته مورد نظر ما مقایسه میکند و در صورت مساوی بودن هر دو مقدار صفر‬
‫را بر میگرداند‪.‬بنابراین برای تشخیص تساوی دو رشته با استفاده از متد )(‪ compareTo‬باید مانند کد زیر تست کنید که آیا مقدار‬
‫برگشتی برابر صفر است یا نه‪:‬‬
‫)‪if(str1.compareTo(str2) == 0‬‬
‫{‬
‫‪// some code‬‬
‫}‬
‫چطور تشخیص بدهیم که یک رشته از رشته دیگر کوچکتر یا بزرگتر است؟ هر کاراکتر در رشته به یونیکد معادل خود تبدیل‬
‫میشود‪ .‬اولین کاراکتر اولین رشته با اولین کاراکتر دومین رشته مقایسه میشود‪.‬اگر برابر بودند سپس دومین کارا کترها و به همین‬
‫ترتیب بقیه کاراکترها با هم مقایسه میشوند‪ .‬متد )(‪ compareTo‬دو رشته یکسان را که فقط در بزرگی و کوچکی حروف با هم‬
‫متفاوت باشند را دو رشته متفاوت در نظر میگیرد ‪ .‬برای مقایسه دو رشته بدون در نظر گرفتن بزرگی و کوچکی حروف از متد‬
‫)(‪ compareToIgnoreCase‬استفاده میشود‪:‬‬
‫;"‪String str1 = "HELLO‬‬

‫;))‪System.out.println(str1.compareToIgnoreCase(str2‬‬
‫‪0‬‬
‫همانطور که مشاهده میکنید با وجودیکه رشته اول با حروف بزرگ نوشته شده است ولی متد )(‪ compareToIgnoreCase‬باز‬
‫هم مقدار صفر را بر میگرداند که نشان دهنده مساوی بودن دو رشته است‪ .‬یکی دیگر از متدهای مقایسه رشتهها متد )(‪equals‬‬
‫است که در صورت مساوی بودن دو رشته مقدار ‪ true‬را بر میگرداند‪:‬‬

‫;))‪System.out.println(str1.equals(str2‬‬
‫‪true‬‬
‫متد )(‪ equalsIgnoreCase‬هم دو رشته را بدون در نظر گرفتن کوچکی و بزرگی حروف با هم مقایسه و مقدار ‪ true‬یا ‪false‬‬
‫را بر میگرداند‪.‬‬
‫الحاق یا چسباندن رشتهها‬
‫چندین راه برای الحاق رشتهها به هم وجود دارد‪ .‬الحاق به معنای چسباندن چندین رشته به هم و تبدیل آنها به یک رشته است‪.‬‬
‫در جاوا یکی از راههای ساده الحاق رشتهها استفاده از عملگر ‪ +‬است‪:‬‬
‫;" ‪String str1 = "Happy‬‬

‫;"‪String str2 = "New Year‬‬
‫;‪String result = str1 + str2‬‬
‫‪Happy New Year‬‬
‫مشاهده میکنید که استفاده از این عملگر چطور باعث ترکیب دو عملوند رشته ای شد‪ .‬به این نکته توجه کنید که استفاده از عملگر‬
‫‪ +‬باعث ترکیب یک رشته با یک نوع داده ای دیگر مانند ‪ int‬میشود که در این حالت نوع ‪ int‬به صورت خودکار به نوع رشته‬
‫ای تبدیل میشود‪.‬‬
‫;)‪System.out.println("Number of Guests: " + 100‬‬
‫‪Number of Guests: 100‬‬
‫راه دیگر برای چسباندن دو رشته استفاده از متد )(‪ concat‬میباشد‪ .‬شما میتوانید تعداد بی نهایت رشته یا شیء به عنوان‬
‫آرگومان به این متد ارسال کنید‪ .‬در زیر نحوه استفاده از این متد نشان داده شده است‪:‬‬

‫;"‪String str2 = " World‬‬
‫;)‪String str3 = str1.concat(str2‬‬

‫;)‪System.out.println("String concat using String concat method : " + str3‬‬
‫‪Hello World‬‬
‫استفاده از متد )(‪ join‬نیز یکی دیگر از روشهای الحاق رشتهها است‪ .‬از این متد برای ترکیب رشتهها و ذخیره آنها در یک آرایه‬
‫از نوع رشته استفاده میشود‪.‬‬
‫;} "‪String[] words = { "Welcome", "to", "my", "site.‬‬

‫;)‪String result = String.join(" ", words‬‬
‫‪Welcome to my site.‬‬
‫متد )(‪ join‬دو آرگومان قبول میکند‪ ،‬اولین آرگومان‪ ،‬رشته ای است که در داخل هر یک از رشتههایی که قرار است با هم ترکیب‬
‫شوند قرار میگیرد‪ .‬که در مثال باال یک رشته که در اصل یک فضای خالی است( ” ” ) را بین کلمات قرار میدهیم‪ .‬دومین آرگومان‬
‫خود آرایه رشته ای است‪ .‬سربارگذاری دیگر این متد به شما اجازه میدهد به جای آرایه رشته ای‪ ،‬لیست رشتهها را ارسال کنید‪.‬‬
‫;)"‪String result = String.join(" ", "Welcome", "to", "my", "site.‬‬
‫‪Welcome to my site.‬‬
‫رشتهها در جاوا تغییر ناپذیر هستند‪ .‬این بدین معنی است که متغیر رشته ای یکبار مقدار دهی میشود و مقدار آن تغییر نمیکند‪.‬‬
‫وقتی مقدار یک رشته را در جاوا اصالح میکنید یک نسخه جدید از رشته ایجاد و نسخه قبلی دور انداخته میشود‪ .‬بنابراین همه‬
‫متدهایی که با رشتهها سر و کار دارند یک نسخه از رشته اصالح شده را بر میگردانند و نسخه اصلی دست نخورد باقی میماند‪.‬‬
‫تکه تکه کردن رشتهها‬
‫اگر بخواهید یک رشته را به چند رشته تکه تکه کنید میتوانید از متد )(‪ split‬استفاده نمایید‪ .‬اجازه دهید نگاهی به سربارگذاری‬
‫های مختلف این متد بیندازیم‪ .‬متد )(‪ Split‬آرایه ای از رشتهها را بر میگرداند که هر عنصر از این آرایه شامل یک زیر رشته‬
‫است‪ .‬اولین سربارگذاری این متد آرایه ای از کاراکترها را قبول میکند و بر اساس آنها تشخیص میدهد که رشته باید در چه جایی‬
‫به قسمتهای مختلف تقسیم شود‪.‬‬
‫;"‪String message = "The quick brown fox jumps over the lazy dog.‬‬
‫;)" "(‪String[] substrings = message.split‬‬
‫)‪for (String s : substrings‬‬

‫{‬
‫;)‪System.out.println(s‬‬
‫}‬
‫‪The‬‬
‫‪quick‬‬
‫‪brown‬‬
‫‪fox‬‬
‫‪jumps‬‬
‫‪over‬‬
‫‪the‬‬
‫‪lazy‬‬
‫‪dog.‬‬
‫در مثال باال از کاراکتر فاصله ( ‘ ‘ ) برای جدا کردن کلمات در رشته باال استفاده کردهایم چون دو کلمه متوالی به وسیله فاصله از هم‬
‫جدا میشوند‪ .‬کلمات در آرایه ‪ substrings‬ذخیره میشوند‪ .‬سپس با استفاده از دستور ‪ foreach‬آنها را در خطوط جداگانه‬
‫چاپ میکنیم‪ .‬میتوان تعداد زیررشتههای برگشتی را به وسیله سربارگذاری دیگر متد )(‪ Split‬محدود کرد‪.‬‬
‫;"‪String message = "The quick brown fox jumps over the lazy dog.‬‬
‫;)‪String[] substrings = message.split(" ", 3‬‬
‫)‪for (String s : substrings‬‬

‫{‬
‫}‬
‫‪The‬‬
‫‪quick‬‬
‫‪brown fox jumps over the lazy dog.‬‬
‫همانطور که در مثال باال مشاهده میکنید دومین آرگومان برای تشخیص تعداد زیر رشتهها به کار میرود‪ .‬خروجی نشان میدهد‬
‫که دو کلمه اول از رشته جدا شدهاند و مابقی رشته در عنصر آخر آرایه ذخیره میشود‪.‬‬
‫جستجوی رشتهها‬
311 ‫ فایل و رشته‬،‫کار با تاریخ‬
‫ اجازه بدهید که نگاهی به متدهای مختلفی که محل وقوع یک رشته‬.‫جستجوی رشتهها به وسیله متدهای جاوا بسیار راحت است‬
.‫ محل یک رشته خاص را در رشته دیگر نشان میدهند‬lastIndexOf() ‫ و‬indexOf() ‫ متدهای‬.‫خاص را پیدا میکنند بیندازیم‬
:‫ توجه کنید‬indexOf() ‫ به مثالی در مورد متد‬.‫ را بر میگردانند‬-3 ‫اگر رشته مورد نظر پیدا نشود متدهای فوق مقدار‬
String str = "The quick brown fox jumps over the lazy dog.";
int index = str.indexOf("quick");
System.out.println("quick was found at position " + index);
The quick brown fox jumps over the lazy dog.

quick was found at position 4
‫ را بر میگرداند چون اندیس‬3 ‫ در مثال باال متد مقدار‬.‫ یک رشته را که شما به دنبال آن هستید را دریافت میکند‬indexOf() ‫متد‬
‫ طول ادامه مییابد بنابراین کاراکتر‬-3 ‫ به یاد داشته باشید که اندیس یا مکان از صفر شروع شده و تا‬.‫ است‬3 ‫ عدد‬quick ‫کلمه‬
:‫ کمی متفاوت است‬lastIndexOf() ‫ متد‬.‫ است‬3 ‫پنجم دارای اندیس‬
String str = "A very very very good day.";

int index = str.lastIndexOf("very");
System.out.println("Last occurrence of very was found at position " + index);
A very very very good day.

Last occurrence of very was found at position 12
‫ در کد باال‬.‫ با این تفاوت که اندیس آخرین محل وقوع رشته را بر میگرداند‬indexOf() ‫ بسیار شبیه متد‬lastIndexOf() ‫متد‬
‫ را بر‬-3 ‫ اگر یک رشته خاص در هنگام جستجو پیدا نشود این دو متد مقدار‬.‫ است‬35 ‫“ اندیس‬very” ‫آخرین محل وقوع کلمه‬
.‫میگردانند‬
String str1 = "This is a sample string.";
System.out.println(str1);
if (str1.indexOf("Whatever") == -1)
{
System.out.println("\"Whatever\" was not found in the string.");
}
This is a sample string.

"Whatever" was not found in the string.
.‫یکی دیگر از سربارگذاری های این دو متد این است که یک آرگومان دومی را قبول میکنند محل شروع جستجو را تعیین میکند‬
:‫به تکه کد زیر توجه کنید‬
if (str1.indexOf("This", 5) == -1)
{
System.out.println("\"This\" was not found in the string.");
}

"This" was not found in the string.
‫ در جمله باال وجود دارد ولی چون ما محل شروع جستجو در رشته را از‬this ‫همانطور که مشاهده میکنید با وجودیکه کلمه‬
‫ اگر بخواهیم تمام محلهای وقوع یک کلمه را پیدا کنیم میتوان به صورت زیر عمل‬.‫ کلمه پیدا نمیشود‬،‫ انتخاب کردهایم‬1 ‫اندیس‬
:‫کنیم‬
int position = 0;
String str1 = "This is a long long long string...";
do
{
position = str1.indexOf("long", position);
if (position != -1)
System.out.println(position);
position++;
}
while (position > 0);
10
15
20
.‫ هم میتواند چک کند که آیا یک رشته در داخل رشته دیگر وجود دارد یا نه‬contains() ‫متد‬
if (str1.contains("sample"))
{
System.out.println("\"sample\" exists in the string.");
}

"sample" exist in the string.
‫این متد اگر رشته مورد نظر وجود داشته باشد مقدار ‪ true‬و اگر وجود نداشته باشد مقدار ‪ false‬را بر میگرداند‪ .‬هر دو متد‬
‫)(‪ startsWith‬و )(‪ endsWith‬برای یافتن یک رشته در ابتدا و انتهای یک رشته خاص به کار میروند‪.‬‬
‫;"‪String str1 = "Apple‬‬
‫;)‪System.out.println(str1‬‬
‫))"‪if (str1.startsWith("A‬‬
‫{‬
‫;)"‪System.out.println("The word starts with A.‬‬
‫}‬
‫))"‪if (str1.endsWith("e‬‬
‫{‬
‫;)"‪System.out.println("The word ends with e.‬‬
‫}‬
‫‪Apple‬‬
‫‪The word starts with A.‬‬
‫‪The word ends with e.‬‬
‫تغییر بزرگی و کوچکی حروف یک رشته‬
‫میتوان ب زرگی و کوچکی حروف یک رشته را تغییر داد‪ .‬به عنوان مثال یک رشته که متشکل از حروف کوچک است را میتوان به‬
‫حروف بزرگ تبدیل کرد‪ .‬با استفاده از متدهای )(‪ toUpperCase‬و )(‪ toLowerCase‬میتوان حروف رشته را بزرگ یا کوچک‬
‫کرد‪.‬‬
‫;"‪String lowercase = "abc‬‬

‫;"‪String uppercase = "ABC‬‬
‫;))(‪System.out.println("lowercase.toUpperCase() = " + lowercase.toUpperCase‬‬

‫;))(‪System.out.println("uppercase.toLowerCase() = " + uppercase.toLowerCase‬‬
‫‪lowercase.toUpperCase() = ABC‬‬
‫‪uppercase.toLowerCase() = abc‬‬
‫به این نکته توجه کنید که اگر بخو اهیم یک رشته به عنوان مثال یک جمله که از حروف بزرگ و کوچک تشکیل شده است‪ ،‬مثال‬
‫حرف اول هر کلمه بزرگ و بقیه حروف کوچک نوشته شده باشند را با استفاده از متد )(‪ toUpperCase‬تغییر دهیم فقط حروف‬
‫کوچک آن تغییر کرده و بزرگ میشوند و حروفی که از قبل بزرگ بودهاند تغییر نمیکنند‪ .‬این نکته در مورد متد )(‪toLowerCase‬‬
‫نیز صدق میکند‪ .‬حال بیایید یک متدی ایجاد کنیم که حرف اول کلمات هر رشته ای که به آن ارسال میشود را به صورت بزرگ و‬
‫بقیه را به صورت کوچک تبدیل کند‪ .‬در این برنامه از متدهای دستکاری رشته که تا به حال یاد گرفتهایم استفاده شده است‪.‬‬
2
4
5 class MyFirstProgram
6 {
7 static String ToTitleCase(String str)
8 {
9 String[] words = str.split(" ");
10
11 for(int i = 0; i<words.length; i++)
12 {
13 String firstLetter = words[i].substring(0, 1);
14 String rest = words[i].substring(1);
15 String result = firstLetter.toUpperCase() + rest.toLowerCase();
16 words[i] = result;
17 }
18
19 return String.join(" ", words);
20 }
21
23 {
25
26 String str1;
27
28 System.out.print("Enter a string: ");
29 str1 = input.nextLine();
30
31 System.out.println("Converting to Title Case...");
32 str1 = ToTitleCase(str1);
33
34 System.out.println(str1);
35 }
36 }
‫ ابتدا‬.‫) که یک رشته را به عنوان آرگومان قبول میکند‬1-53 ‫ ایجاد کردهایم (خطوط‬ToTitleCase() ‫در مثال باال یک متد به نام‬
‫ بنابراین میتوان هر رشته را به صورت‬،‫ رشته را به کلمات تشکیل دهندهاش تقسیم بندی میکنیم‬split() ‫با استفاده از متد‬
.‫جداگانه دستکاری کرد‬
String[] words = str.split(" ");
(33-31 ‫ در میان کلمات گردش میکنیم (خطوط‬for ‫سپس با استفاده از یک حلقه‬
String firstLetter = words[i].substring(0, 1);

String rest = words[i].substring(1);
‫ استخراج و در یک متغیر برای استفادههای بعدی ذخیره میکنیم (خط‬substring() ‫اولین حرف هر کلمه را با استفاده از متد‬
.‫ باقیمانده حروف کلمات را استخراج میکنیم‬.)31

‫;)(‪String result = firstLetter.ToUpper() + rest.ToLower‬‬
‫حال رشتهها را با هم ترکیب میکنیم البته از متد )(‪ toUpperCase‬برای بزرگ کردن حروف اول و از متد )(‪ toLowerCase‬برای‬
‫بزرگ کردن بقیه حروف کلمات استفاده میکنیم‪ .‬بعد از این کار عناصر آرایه را با کلمات اصالح شده جایگزین میکنیم‪.‬‬
‫;)‪return String.join(" ", words‬‬
‫سپس کلمات اصالح شده را با استفاده از متد )(‪( join‬خط ‪ )36‬ترکیب کرده و در بین آنها فضای خالی قرار میدهیم‪ .‬سپس‬
‫آنها را به متد فراخوان برگشت میدهیم‪.‬‬
‫استخراج و جایگزین کردن رشتهها‬
‫برای استخراج قسمتی از یک رشته میتوان از متد )(‪ substring‬استفاده کرد‪ .‬این متد دو آرگومان قبول میکند که یکی اندیس‬
‫شروع و دیگری طولی از رشته را که میخواهیم استخراج کنیم را نشان میدهد‪ .‬به مثال زیر توجه کنید‪.‬‬
‫;"‪String str1 = "This is a sample string.‬‬
‫;)‪String str2 = str1.substring(10, 16‬‬
‫;)‪System.out.println("str1 = " + str1‬‬

‫;)‪System.out.println("str2 = " + str2‬‬
‫‪str1 = This is a sample string.‬‬

‫‪str2 = sample‬‬
‫استخراج را از اندیس ‪ 33‬شروع کردهایم (آرگومان اول که عدد ‪ 33‬است)‪ .‬همانطور که مشاهده میکنید کلمه ”‪ “sample‬از اندیس‬
‫‪ 33‬شروع شده است (کاراکتر یازدهم)‪ .‬آرگومان دوم نشان میدهد که ما تا چندمین کاراکتر را میخواهیم استخراج کنیم‪ .‬ازآنجاییکه‬
‫قرار است کلمه ‪ sample‬را استخراج کنیم و این کلمه ‪ 1‬حرفی است پس باید آرگومان دوم را ‪ 31‬بنویسیم یعنی قرار است از ‪ 33‬تا‬
‫‪ 31‬را استخراج کنم‪ .‬اگر نخواهید که مکان قرار گرفتن کلمه ”‪ “sample‬را به صورت دستی شمارش کنید میتوانید با استفاده از‬
‫متد )(‪ indexOf‬این کار را انجام دهید‪.‬‬
‫;)‪String str2 = str1.substring(str1.indexOf("sample"), 16‬‬
‫یکی دیگر ازسربارگذاریهای متد )(‪ substirng‬فقط یک آرگومان که برای تعیین کردن اندیس شروع استخراج به کار میرود را‬
‫قبول میکند در نتیجه استخراج از این اندیس شروع شده و تا پایان رشته ادامه مییابد‪.‬‬
‫جایگزین کردن رشتهها با استفاده از متد‪replace‬‬
‫با استفاده از متد )(‪ replace‬میتوان یک رشته خاص را با یک رشته دیگر عوض کرد‪ .‬به عنوان مثال در کد زیر میتوان کلمه‬
‫”‪“dog‬را با کلمه ”‪ “cat‬عوض کرد‪.‬‬
‫;"‪String str1 = "That dog is a lovely dog.‬‬

‫;)"‪System.out.println("Replacing all dogs with cats...‬‬
‫;)"‪str1 = str1.replace("dog", "cat‬‬
‫‪That dog is a lovely dog.‬‬

‫‪Replacing all dogs with cats...‬‬
‫‪That cat is a lovely cat.‬‬
‫متد )(‪ replace‬دو آرگومان قبول میکند‪ .‬اولین آرگومان رشته ای است که میخواهیم آن را با یک رشته جدید جایگزین کنیم‬
‫(رشته قدیم) و دیگری رشته جدید است‪ .‬متد )(‪ replace‬تمام کلمات ”‪ “dog‬واقع در رشته را پیدا کرده و کلمه ”‪ “cat‬را‬
‫جایگزین آنها میکند‪ .‬حال اگر بخواهید فقط اولین کلمه ‪ dog‬به وسیله کلمه ‪ cat‬جایگزین شود میتوانید از متد‬
‫)(‪ replaceFirst‬استفاده کنید‪:‬‬
‫;"‪String str1 = "That dog is a lovely dog.‬‬

‫;)"‪System.out.println("Replacing all dogs with cats...‬‬
‫;)"‪str1 = str1.replaceFirst("dog", "cat‬‬
‫‪That dog is a lovely dog.‬‬

‫‪Replacing all dogs with cats...‬‬
‫‪That cat is a lovely dog.‬‬
‫متد )(‪ replaceAll‬هم یک سری کاراکتر به عنوان الگو میگیرد و در هر جای رشته که آنها را پیدا کند با رشته یا کاراکتری که‬
‫خودمان میخواهیم جایگزین میکند‪ .‬فرض کنید که در داخل رشته ای عالئمی مانند ‪ – ،+‬و * قرار دارند و میخواهیم آنها را حذف‬
‫کنیم برای این کار به صورت زیر عمل میکنیم‪:‬‬
‫;"***!‪String str1 = "--+Hello +World‬‬
‫;)"" ‪String result = str1.replaceAll("[*+-]",‬‬
‫همانطور که در کد باال مشاهده می کنیداین متد دو آرگومان میگیرد که اولین آرگومان کاراکترهایی هستند که آنها را در داخل‬
‫جفت کروشه به صورت رشته قرار دادهایم و دومین آرگومان هم که “” (جفت کوتیشن بدون فاصله) میباشد که برای حذف کردن‬
‫کارکترها به کار بردهایم‪.‬‬
‫فرمت بندی رشتهها و اعداد‬

‫از متد )(‪ printf‬هم میتوان برای قالب بندی رشتهها و اعداد استفاده کرد‪ .‬این متد بر اساس یک الگو و با استفاده از کاراکترهای‬
‫خاصی که در جدول زیر آمدهاند‪ ،‬قالب بندی را انجام میدهد‪ .‬الگوی کلی قالب بندی رشتهها و اعداد به صورت زیر است‪:‬‬
‫‪% [flags] [width] [.precision] conversion-character‬‬
‫در الگوی باال اجزایی که در داخل کروشه هستند اختیاری میباشند‪ .‬در حالت عادی الگو با عالمت ‪ %‬شروع میشود و بعد از آن یکی‬
‫از کاراکترهای جدول زیر میآید‪:‬‬
‫نمایش کاراکتر‬ ‫‪%c‬‬
‫نمایش اعداد در مبنای ده (صحیح(‬ ‫‪%d‬‬
‫نمایش اعداد اعشاری نمایی‬ ‫‪%e‬‬
‫نمایش اعداد اعشاری‬ ‫‪%f‬‬
‫نمایش اعداد صحیح‬ ‫‪%i‬‬
‫نمایش اعداد مبنای ‪0‬‬ ‫‪%o‬‬
‫نمایش رشته‬ ‫‪%s‬‬
‫نمایش اعداد ده دهی مثبت‬ ‫‪%u‬‬
‫نمایش اعداد مبنای ‪31‬‬ ‫‪%x‬‬
‫چاپ عالمت درصد‬ ‫‪%%‬‬

‫چاپ عالمت درصد‬ ‫‪\%‬‬
‫حال فرض کنید که میخواهیم یک عدد اعشاری را فرمت بندی کنیم‪:‬‬
‫;)‪System.out.printf("%f",34.789456‬‬
‫همانطور که مشاهده میکنید در مثال باال از ‪ %f‬برای نمایش عدد اعشار استفاده کردهایم‪ .‬همین مثال‪ ،‬مثال خوبی است که به شما‬
‫نحوه استفاده از اجزایی که در داخل کروشه هستند را نشان دهیم‪ .‬ابتدا کاربرد ‪ flag‬یا نشانه را می گوییم‪ .‬نشانههایی که بعد از‬
‫عالمت درصد میتوان استفاده کرد در جدول زیر آمدهاند‪:‬‬
‫کاربرد‬ ‫نشانه‬
‫با اضافه کردن فاصله به سمت راست یک عدد یا رشته آن را به سمت چپ میکشد‪.‬‬ ‫‪-‬‬
‫با اضافه کردن فاصله به سمت چپ یک عدد یا رشته آن را به سمت راست میکشد‪.‬‬ ‫‪+‬‬
‫تعدادی صفر که خودمان تعیین کردهایم به سمت راست یا چپ نوشته یا عدد اضافه میکند‬ ‫‪0‬‬
‫تعدادی فاصله که خودمان تعیین کردهایم به سمت راست یا چپ نوشته یا عدد اضافه میکند‬ ‫فاصله‬
‫به کار بردن نشانههای باال به تنهایی و بدون اینکه تعیین کنیم چه تعداد فاصله یا صفر میخواهیم به ابتدا یا انتهای عدد یا رشته‬
‫اضافه کنیم بی معنی میباشد‪ .‬در این صورت باید از جزء بعدی که ‪ width‬یا پهنا هست استفاده کنیم‪ [.precision] .‬هم در‬
‫صورتی که متغیر از نوع اعداد اعشاری باشد‪ ،‬برای تعیین تعداد ارقام اعشار‪ ،‬و اگر از نوع رشته باشد تعداد کارکترهایی که قرار است‬
‫نمایش داده شوند را مشخص میکند‪ .‬حال به مثال بر میگردیم‪ .‬فرض کنید که میخواهیم سه رقم از ارقام بعد از ممیز عدد اعشار‬
‫مثال باال را نشان داده و قبل از بخش صحیح آن سه عدد صفر قرار دهیم یعنی ‪ .00034.789‬انجام این کار بسیار راحت است‪:‬‬
‫;)‪System.out.printf("%09.3f",34.789456‬‬
‫‪00034.789‬‬
‫همانطور که در کد باال مشاهده میکنید الگو با عالمت ‪ %‬شروع میشود‪ .‬سپس نشانه را مینویسیم که در اینجا ‪ 3‬است‪ .‬اما اینکه‬
‫چرا عدد ‪ 6‬را نوشتهایم دلیلش این است که ‪ 13.106‬با احتساب ممیز آن برای نمایش نیاز به شش جای خالی دارد و چون قرار‬
‫است که ما سه صفر هم قبل از عدد ‪ 13‬قرار دهیم پس باید ‪ 6‬جای خالی ایجاد کنیم‪ .‬و اما [ ‪ ] .1‬هم به معنای سه رقم اعشار است‬
‫و ‪ f‬هم که برای نمایش اعداد اعشاری به کار میرود‪ .‬فرض کنید که میخواهیم سه کاراکتر اول رشته ‪ Programming‬را نمایش‬
‫دهیم‪ ،‬برای این منظور به صورت زیر عمل میکنیم‪:‬‬
‫;)"‪System.out.printf("%.3s","Programming‬‬
‫‪Pro‬‬
‫در زیر هم مثالهایی از نحوه استفاده از متد ‪ printf‬و کاراکترهای خاص آن آمده است‪:‬‬
‫چاپ یک رشته ساده‬
‫;)"‪System.out.printf("Hello Welcome to JAVA Programming‬‬
‫‪Hello Welcome to JAVA Programming‬‬
‫چاپ کاراکترهای کنترلی‬
‫;)"‪System.out.printf("Hello Welcome to\t JAVA Programming‬‬
‫‪Hello Welcome to‬‬ ‫‪JAVA Programming‬‬
‫همانطور که مشاهده میکنید در کد باال استفاده از ‪ \t‬باعث ایجاد فاصله بین رشتهها میشود‪.‬‬
‫چاپ متغیرها‬
‫;)‪System.out.printf("Addition of two Numbers : %d", sum‬‬
‫قالب بندی چند قسمتی‬
‫;)"‪System.out.printf("I Love %c %s",'c',"Programming‬‬
‫‪I Love c Programming‬‬
‫در کد باال کاراکتر ‪ C‬جایگزین ‪ %c‬و رشته یا کلمه ‪ Programming‬جایگزین ‪ %s‬میشود‪.‬‬
‫قالب بندی اعداد اعشاری‬
‫;)"‪System.out.printf("%-12s%-12s\n","Column 1","Column 2‬‬

‫;)‪System.out.printf("%-12.5f%.20f", 12.23429837482,9.10212023134‬‬
‫‪Column 1‬‬ ‫‪Column 2‬‬

‫‪12.23430‬‬ ‫‪9.10212023134000000000‬‬
‫درباره کد باال یک نکته را یادآور میشویم و آن این است که اگر تعداد کاراکترهای یک رشته از تعدادی که ما برای قالب بندی آن‬
‫استفاده کردهایم کمتر باشد تعدادی فاصله در سمت چپ یا راست رشته قرار میگیرد‪ .‬مثال تعداد کاراکترهای ‪ Column 1‬هشت‬
‫عدد میباشد و ما برای قالب بندی و ایجاد فاصله در سمت راست آن عدد ‪ -35‬را به کار بردهایم‪ .‬با این کار ‪ 3‬فاصله در سمت راست‬
‫رشته قرار میگیرد و باعث فاصله آن با رشته بعدی میشود‪ .‬حال اگر تعداد کارکترهای رشته بیشتر از تعداد باشد که ما تعیین‬
‫کردهایم ‪ ،‬کل رشته یا عدد بدون هیچ گونه فاصله ای در سمت چپ یا راست‪ ،‬نمایش داده میشود‪ .‬همین نکته در مورد مثالهای‬
‫زیر صدق میکند‪.‬‬
‫نمایش اعداد صحیح در قالب خاص‬
‫;)‪System.out.printf("%d",1234‬‬
‫;)‪System.out.printf("%3d",1234‬‬
‫;)‪System.out.printf("%-6d",1234‬‬
‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬

‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4- -‬‬
‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬
‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4 - -‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪2 3 4‬‬
‫نمایش رشتهها در قالب خاص‬
‫;"‪String str = "Programming‬‬
‫;)‪System.out.printf("%s", str‬‬
‫;)‪System.out.printf("%10s", str‬‬
‫;)‪System.out.printf("%15s", str‬‬
‫;)‪System.out.printf("%-15s", str‬‬
‫;)‪System.out.printf("%15.5s", str‬‬
‫;)‪System.out.printf("%-15.5s", str‬‬
‫‪Programming‬‬
‫‪Programming‬‬
‫‪----Programming‬‬
‫‪Programming----‬‬
‫‪----------Progr‬‬
‫‪Progr----------‬‬
‫در دو کد آخر خطهای تیره در اصل فاصله هستند که برای روشن شدن موضوع آنها را به صورت خط تیره نمایش دادهایم‪.‬برای‬
‫روشن شدن کاربرد اعداد منفی و مثبت بعد از عالمت ‪ %‬فرض کنید که شما میخواهید بین دو رشته ‪ JAVA‬و ‪ Programming‬چهار‬
‫فاصله قرار دهید‪ .‬این کار به دو صورت امکان پذیر است‪ .‬یا بعد از کلمه ‪ JAVA‬چهار فاصله قرار دهید‪:‬‬
‫;)"‪System.out.printf("%-8s%s", "JAVA","Programming‬‬
‫‪JAVA‬‬ ‫‪Programming‬‬
‫که در مثال باال ‪ -0‬بع معنای این است که ‪ 0‬مکان ایجاد شود که چهار تا از آنها توسط کلمه ‪ JAVA‬اشغال میشود و چهار تای‬
‫دیگر به خاطر عالمت منفی در سمت راست کلمه ‪ JAVA‬قرار میگیرند‪.‬حالت دوم هم این است که در سمت چپ کلمه ‪Programming‬‬
‫چهار فاصله قرار بدهیم‪:‬‬
‫;)"‪System.out.printf("%s%15s", "JAVA","Programming‬‬
‫‪JAVA‬‬ ‫‪Programming‬‬
‫که در این صورت باید عدد ‪ 31‬را بنویسیم‪ .‬چونکه کلمه ‪ Programming‬یازده حرفی است‪ ،‬پس چهار مکان دیگر به خاطر مثبت‬
‫بودن عالمت ‪ 31‬در سمت چپ آن قرار میگیرند‪ .‬روش دیگر برای قالب بندی رشتهها استفاده از متد )(‪ format‬از کالس ‪String‬‬
‫است‪ .‬این متد شبیه به متد )(‪ printf‬عمل میکند‪ .‬به مثال زیر توجه کنید‪:‬‬
‫‪String‬‬ ‫‪Str1‬‬ ‫=‬ ‫;"‪"JAVA Programming‬‬

‫‪String‬‬ ‫‪Str2‬‬ ‫=‬ ‫;)‪String.format("Str1 is %s", Str1‬‬
‫‪String‬‬ ‫‪Str3‬‬ ‫=‬ ‫;)‪String.format("value is %f", 32.33434‬‬
‫‪String‬‬ ‫‪Str4‬‬ ‫=‬ ‫;)‪String.format("value is %32.12f", 32.33434‬‬
‫;)‪System.out.println(Str2‬‬
‫‪Str1 is JAVA Programming‬‬

‫‪value is 32.334340‬‬
‫‪value is‬‬ ‫‪32.334340000000‬‬
‫نکته ای که فراموش شد و االن یادآور میشویم در مورد اعداد اعشار است‪ .‬اگر تعدادی که ما برای نمایش رقم اعشار مشخص‬
‫کردهایم بیشتر از ارقام اعشار عدد باشد بسته به تعدادی که ما مشخص کردهایم عدد صفر بعد از ارقام اعشار قرار میگیرد‪ .‬مثال در‬
‫مثال باال ]‪ [.12‬یعنی دوازده رقم اعشار نمایش داده شود و چون تعداد ارقام اعشار عدد در مثال باال ‪ 1‬تا میباشد در نتیجه هفت‬
‫عدد صفر بعد از آن نمایش داده میشود‪.‬‬

‫کالس ‪StringBuilder‬‬
‫کالس ‪ String‬میتواند با استفاده از عم لگر ‪ +‬دو رشته را به هم متصل کند‪ .‬اما این عملگر برای الحاق دو رشته مختلف کارا‬
‫نیست‪.‬چون شی رشته در جاوا تغییر ناپذیر است یعنی وقتی که یک متغیر از نوع رشته را تعریف میکنیم مقدار آن تغییر‬
‫نمیکند‪.‬هنگامی که یک رشته را به یک رشته موجود میچسبانید مقدار قبلی حذف و یک شیء جدید که شامل دو رشته به هم‬
‫چسبیده است به وجود میآید‪ ،‬مثال ‪:‬‬
‫;"‪String Animal = "Dog‬‬

‫;"‪Animal = "Cat‬‬
‫;)‪System.out.println(Animal‬‬
‫‪Cat‬‬
‫با هر بار انجام این فرایند اشیاء موقتی ایجاد و اشیاء قدیمی از بین میروند و این ایجاد و حذف شدنها هم زمان برند و هم‬
‫حافظه را اشغال میکنند‪ .‬به مثال زیر توجه کنید‪ ،‬مثال اگر بخواهید همه اعداد ‪ 3‬تا ‪ 6666‬را به هم بچسبانید‪:‬‬
‫;‪int counter = 9999‬‬

‫;"" = ‪String s‬‬
‫)‪for (int i = 0; i <= counter; i++‬‬

‫{‬
‫;‪s += i‬‬
‫}‬
‫ممکن است با نگاه کردن به کد متوجه هیچ مشکلی نشوید اما اگر از متد )(‪ currentTimeMillis‬کالس ‪ System‬استفاده کنید‬
‫متوجه میشوید که اجرای این برنامه چقدر زمان میبرد‪ .‬کد باال را به صورت زیر اصالح میکنیم‪:‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;‪int counter = 9999‬‬
‫‪8‬‬ ‫;"" = ‪String s‬‬
‫‪9‬‬
‫‪10‬‬ ‫;)(‪long startTime = System.currentTimeMillis‬‬
‫‪11‬‬
‫‪12‬‬ ‫)‪for (int i = 0; i <= counter; i++‬‬
‫‪13‬‬ ‫{‬
‫‪14‬‬ ‫;‪s += i‬‬
‫‪15‬‬ ‫}‬
‫‪16‬‬
‫‪17‬‬ ‫;)(‪long endTime = System.currentTimeMillis‬‬
‫‪18‬‬ ‫;‪long totalTime = endTime - startTime‬‬
‫‪19‬‬ ‫;)‪System.out.println(totalTime‬‬
‫‪20‬‬ ‫}‬
‫‪21‬‬ ‫}‬
‫هدف از برنامه باال تبدیل ‪ 3333‬عدد به رشته و چسباندن آنها به یکدیگر است‪ .‬با استفاده از متد )(‪ currentTimeMillis‬کالس‬
‫‪ System‬که زمان جاری را نشان میدهد یک کرونومتر ایجاد میکنیم که زمان شروع آن قبل از اجرای حلقه ‪( for‬خط ‪ )33‬و زمان‬
‫پایان آن بعد از اتمام حلقه (خط ‪ )31‬میباشد‪ .‬به طور میانگین اجرای برنامه باال ‪ 1553 ms‬زمان میبرد (البته ممکن است این زمان‬
‫در سیستم شما متفاوت باشد)‪ .‬حال اجازه دهید که با استفاده از کالس ‪ StringBuilder‬این اعداد را به هم وصل کنیم‪ .‬این کار‬
‫را با استفاده از متد )(‪ append‬این کالس انجام میدهیم‪.‬‬

‫‪2‬‬
‫‪4‬‬ ‫{‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;‪int counter = 9999‬‬
‫‪8‬‬ ‫;"" = ‪String s‬‬
‫‪9‬‬
‫‪10‬‬ ‫;)(‪long startTime = System.currentTimeMillis‬‬
‫‪11‬‬
‫‪12‬‬ ‫;)(‪StringBuilder sb = new StringBuilder‬‬
‫‪13‬‬
‫‪14‬‬ ‫)‪for (int i = 0; i <= counter; i++‬‬
‫‪15‬‬ ‫{‬
‫‪16‬‬ ‫;)‪sb.append(i‬‬
‫‪17‬‬ ‫}‬
‫‪18‬‬
‫‪19‬‬ ‫;)(‪long endTime = System.currentTimeMillis‬‬
‫‪20‬‬ ‫;‪long totalTime = endTime - startTime‬‬
‫‪21‬‬ ‫;)‪System.out.println(totalTime‬‬
‫‪22‬‬ ‫}‬
‫‪23‬‬ ‫}‬
‫مشاهده میکنید که اجرای برنامه حدود ‪ 3 ms‬طول میکشد‪ .‬همانطور که مشاهده کردید کارایی برنامه به طور چشمگیری بهبود‬
‫یافت‪ .‬کارایی برنامه با افزایش متغیر حلقه بیشتر میشود‪.‬کالس ‪ StringBuilder‬برای کار و اتصال رشتههای زیاد به هم بسیار‬
‫قدرتمند است‪ .‬این کالس دارای متدهای مختلفی است که در زیر به برخی از آنها اشاره شده است‪.‬‬
‫توضیحات‬ ‫متد‬
‫برای چسباندن رشتهها یا کارکترها به رشته جاری به کار میرود‪.‬‬ ‫)(‪append‬‬
‫یک کاراکتر خاص از یک رشته را بر میگرداند‪.‬‬ ‫)(‪charAt‬‬

‫برای حذف یک توالی از کاراکترها از رشته اصلی به کار میرود‪.‬‬ ‫)(‪delete‬‬
‫برای کپی یک توالی از کارکترهای یک رشته در یک آرایه کاراکتری به کار میرود‪.‬‬ ‫)(‪getChars‬‬
‫محلهای وقوع یک زیر رشته در رشته اصلی را بر می گداند‪.‬‬ ‫)(‪indexOf‬‬
‫برای قرار دادن یک توالی از کاراکترها در یک رشته به کار میرود‪.‬‬ ‫)(‪insert‬‬
‫آخرین محل وقوع یک زیر رشته در رشته اصلی را بر میگرداند‪.‬‬ ‫)(‪lastIndexOf‬‬
‫تعداد کاراکترهای یک رشته را بر میگرداند‪.‬‬ ‫)(‪length‬‬
‫یک توالی از کاراکترها را با توالی دیگر از کاراکترها جایگزین میکند‪.‬‬ ‫)(‪replace‬‬
‫برای معکوس کردن یک رشته به کار میرود‪.‬‬ ‫)(‪reverse‬‬
‫قرار دادن یک کاراکتر در یک اندیس خاص از رشته‬ ‫)(‪setCharAt‬‬
‫طول یک توالی از کاراکترها را بر میگرداند‪.‬‬ ‫)(‪setLength‬‬
‫برای جدا کردن یک توالی از کاراکترها از رشته اصلی به کار میرود‪.‬‬ ‫)(‪substring‬‬
‫‪File System‬‬
‫بیشتر اوقات الزم است که دادههایتان را در یک فایل دائمی ذخیره کنید‪ .‬همچنین الزم است که به سیستم فایلها یا دایرکتوری‬
‫کامپیوتر دسترسی داشته باشید به طوری که بتوانید فایلها را در آنها قرار داده و ذخیره کنید‪ ،‬مکانی را که میخواهید فایل درآن‬
‫ذخیره شود را نشان داده‪ ،‬فایلی که در یک دایرکتوری ذخیره شده را مشاهده کرده و به طور خالصه جزییاتی در مورد یک دایرکتوری‬
‫خاص را به دست آورید‪.‬‬
‫شما حتی میتوانید چک کنید که اندازه فایل چقدر است و آیا فایل از نوع فقط خواندنی است یا نه؟ اگر چه استفاده از پایگاه داده‬
‫امروزه بیشتر ترجیح داده میشود ‪ ،‬اما گاهی اوقات برای برانامه های کوچک استفاده از یک فایل متنی کارا تر است‪ .‬همچنین برخی‬
‫از برنامههای کاربردی هنوز وجود دارند که دادههایشان را در یک فایل متنی ذخیره میکنند و بنابراین الزم است که اطالعات در این‬
‫فایل نوشته و از آن خوانده شود‪ .‬جاوا دارای کالسهایی است که شما با استفاده از آنها میتوانید محتویات فایلها را بخوانید‪،‬‬
‫در داخل آنها بنویسید و صفات فایلها و دایرکتور یها را چک کنید‪ .‬در درسهای بعدی نحوه نوشتن یک داده باینری و فشرده‬
‫سازی فایلها که باعث کاهش حجم آنها میشود را خواهید آموخت‪.‬‬
‫پکیج ‪Java IO‬‬
‫پکیج ‪ Java IO‬دارای کالسهای مختلفی است که از آنها برای انجام عملیاتی مانند ایجاد و حذف فایلها‪ ،‬خواندن از فایل و‬
‫نوشتن در آن و همچنین باز و بسته کردن فایلها استفاده میشود‪ ،‬همچنین از این پکیج در مباحث پیشرفته برای کار در شبکه‬
‫نیز استفاده میشود‪ .‬قبل از توضیح این کالسها ابتدا بهتر است با دو کلمه ‪ file‬و ‪ stream‬آشنا شوید‪.‬‬
‫یک ‪ File‬مجموعه ای از دادههای ذخیره شده در دیسک با یک نام خاص‪ ،‬پسوند و یک مسیر میباشد‪ .‬وقتی فایل را با ‪JAVA‬‬
‫برای خواندن نوشتن باز میکنید‪ ،‬فایل تبدیل به ‪ Stream‬میشود‪ Stream .‬در لغت به معنای جریان است و در مجموع به یک‬
‫توالی یا سری از بایتها که بین دو مسیر مبداء و مقصد در حال حرکت هستند گفته میشود‪ .‬برای کار با کالسهای پکیج ‪Java‬‬
‫‪ IO‬ابتدا باید این پکیج را ‪ import‬کنید‪:‬‬
‫;*‪import java.io.‬‬
‫در جدول زیر لیست کالسهای معمول این پکیج آمده است‪:‬‬
‫توضیح‬ ‫کالس‬
‫از این کالس ‪ abstract‬برای خواندن کاراکتر از یک جریان بایتی به کار میرود‪.‬‬ ‫‪Reader‬‬
‫از این کالس ‪ abstract‬برای نوشتن کاراکتر در یک جریان بایتی به کار میرود‪.‬‬ ‫‪Writer‬‬
‫از این کالس ‪ abstract‬برای خواندن از یک جریان بایتی به کار میرود‪.‬‬ ‫‪InputStream‬‬
‫از این کالس ‪ abstract‬برای نوشتن در یک جریان بایتی به کار میرود‪.‬‬ ‫‪OutputStream‬‬
‫برای خواندن داده از یک جریان بایتی به کار میرود‪.‬‬ ‫‪InputStreamReader‬‬
‫برای نوشتن در یک جریان بایتی به کار میرود‪.‬‬ ‫‪OutputStreamWriter‬‬
‫برای ایجاد‪ ،‬حذف‪ ،‬انتقال و انجام اعمال مختلف بر روی فایلها و پوشهها به کار میرود‪.‬‬ ‫‪File‬‬
‫برای خواندن از فایل به کار میرود‪.‬‬ ‫‪FileInputStream‬‬
‫برای نوشتن در فایل به کار میرود‪.‬‬ ‫‪FileOutputStream‬‬
‫برای خواندن از فایل و نوشتن در فایل به شیوه دسترسی تصادفی به کار میرود‪.‬‬ ‫‪RandomAccessFile‬‬
‫برای خواندن از یک آرایه که حاوی دادههای یک جریان بایتی است به کار میرود‪.‬‬ ‫‪ByteArrayInputStream‬‬
‫برای نوشتن در یک آرایه به عنوان یک جریان بایتی به کار میرود‬ ‫‪ByteArrayOutputStream‬‬
‫برای خواندن یک شیء جاوایی از یک جریان بایتی به کار میرود‪.‬‬ ‫‪ObjectInputStream‬‬
‫برای نوشتن یک شیء جاوایی در یک جریان بایتی به کار میرود‪.‬س‬ ‫‪OjectOutputStream‬‬
‫برای خواندن کاراکتر از یک جریان بایتی به کار میرود‪.‬‬ ‫‪BufferedReader‬‬
‫برای نوشتن کاراکترها در یک جریان به کار میرود‪.‬‬ ‫‪BufferedWriter‬‬
‫برای خواندن از یک استرینگ استفاده میشود‪.‬‬ ‫‪StringReader‬‬
‫برای نوشتن روی یک استرینگ استفاده میشود‪.‬‬ ‫‪StringWriter‬‬
‫کالسی قدرتمند و کاربردی است که برای نوشتن در انواع مختلف خروجی استفاده میشود‪.‬‬ ‫‪PrintWriter‬‬
‫حال که با کالسهای معمول این پکیج آشنا شدید در درسهای آینده در مورد کار با آنها توضیح میدهیم‪.‬‬
‫کالسهای ‪ Reader‬و ‪Writer‬‬

‫اگرچه با استفاده از جریانهای بایتی میتوان هر نوع عملیات ورودی و خروجی را پیاده سازی کرد ولی استفاده مستقیم آنها برای‬
‫کار با دادههای متنی مبتنی بر یونیکد چندان آسان نیست و نیازمند تبدیالت میانی است برای راحتی کار با دادههای متنی در جاوا‬
‫از زیر کالسهای ‪ Reader‬برای خواندن و از زیر کالسهای ‪ Writer‬برای نوشتن استفاده میشود‪.‬‬
‫کالس‪Reader‬‬
‫کالس ‪ Reader‬یک کالس انتزاعی )‪ (abstract‬است که مستقیما آن را به کار نمیبریم بلکه از زیر کالسهای آن که کابرد های‬
‫متفاوتی دارند استفاده میکنیم‪ .‬در صورتی که قصد داشته باشید برای یک کاربرد خاص ویژگی جدیدی به کالس ‪ Reader‬اضافه‬
‫کنید باید یک زیر کالس از آن ایجاد کنید‪ .‬در جدول زیر لیست زیر کالسهای مهم این کالس که در آموزشهای بعدی با آنها‬
‫آشنا میشویم آمده است‪:‬‬
‫برای خواندن داده از یک جریان بایتی به کار میرود‪.‬‬ ‫‪InputStreamReader‬‬
‫برای خواندن کاراکتر از یک جریان بایتی به کار میرود‪.‬‬ ‫‪BufferedReader‬‬
‫برای خواندن از یک رشته استفاده میشود‪.‬‬ ‫‪StringReader‬‬
‫کالس‪Writer‬‬
‫برای نوشتن کاراکتر در یک جریان بایتی از زیر کالسهای ‪ Writer‬استفاده میکنیم‪ .‬کالس ‪ Writer‬یک کالس انتزاعی‬
‫)‪ (abstract‬است که مستقیما آن را به کار نمیبریم بلکه از زیر کالسهای آن که کابرد های متفاوتی دارند استفاده میکنیم‪ .‬در‬
‫صورتی که قصد داشته باشید برای یک کاربرد خاص ویژگی جدیدی به کالس ‪ Writer‬اضافه کنید باید یک زیر کالس از آن ایجاد‬
‫کنید‪ .‬در جدول زیر لیست زیر کالسهای مهم این کالس که در آموزشهای بعدی با آنها آشنا میشویم آمده است‪:‬‬
‫برای نوشتن در یک جریان بایتی به کار میرود‪.‬‬ ‫‪OutputStreamWriter‬‬
‫برای نوشتن کاراکترها در یک جریان به کار میرود‪.‬‬ ‫‪BufferedWriter‬‬

‫برای نوشتن روی یک رشته استفاده میشود‪.‬‬ ‫‪StringWriter‬‬
‫کالسی قدرتمند و کاربردی است که برای نوشتن در انواع مختلف خروجی استفاده میشود‪.‬‬ ‫‪PrintWriter‬‬
‫حال که با کالسهای معمول این پکیج آشنا شدید در درسهای آینده در مورد کار با آنها توضیح میدهیم‪.‬‬
‫کالسهای ‪ InputStream‬و ‪OutputStream‬‬
‫برای خواندن از یک جریان بایتی از زیر کالسهای ‪ InputStream‬استفاده میشود‪ .‬کالس ‪ InputStream‬یک کالس انتزاعی‬
‫صورتی که قصد داشته باشید برای یک کاربرد خاص ویژگی جدیدی به کالس ‪ InputStream‬اضافه کنید باید یک زیر کالس از آن‬
‫ایجاد کنید‪ .‬در جدول زیر لیست زیر کالسهای مهم این کالس که در آموزشهای بعدی با آنها آشنا میشویم آمده است‪:‬‬
‫برای خواندن از فایل به کار میرود‪.‬‬ ‫‪FileInputStream‬‬
‫برای خواندن از یک آرایه که حاوی دادههای یک جریان بایتی است به کار میرود‪.‬‬ ‫‪ByteArrayInputStream‬‬
‫برای خواندن یک شیء جاوایی از یک جریان بایتی به کار میرود‪.‬‬ ‫‪ObjectInputStream‬‬
‫برای نوشتن یک جریان بایتی از زیر کالسهای ‪ InputStream‬استفاده میشود‪ .‬کالس ‪ OutputStream‬یک کالس انتزاعی‬
‫صورتی که قصد داشته باشید برای یک کاربرد خاص ویژگی جدیدی به کالس ‪ OutputStream‬اضافه کنید باید یک زیر کالس از‬
‫آن ایجاد کنید‪ .‬در جدول زیر لیست زیر کالسهای مهم این کالس که در آموزشهای بعدی با آنها آشنا میشویم آمده است‪:‬‬
‫برای نوشتن در فایل به کار میرود‪.‬‬ ‫‪FileOutputStream‬‬

‫برای نوشتن در یک آرایه به عنوان یک جریان بایتی به کار میرود‬ ‫‪ByteArrayOutputStream‬‬
‫برای نوشتن یک شیء جاوایی در یک جریان بایتی به کار میرود‪.‬‬ ‫‪OjectOutputStream‬‬
‫کالس ‪File‬‬
‫در جاوا از کالس ‪ File‬برای دستکاری فایلهای موجود در یک دایرکتوری استفاده میشود‪ .‬این کالس دارای متدهایی است که به‬
‫شما اجازه کپی‪ ،‬حذف‪ ،‬بازکردن‪ ،‬انتقال و ایجاد یک فایل را میدهند‪ .‬کالس ‪ File‬در پکیج ‪ java.io‬قرار دارد و باید آن را در‬
‫برنامه وارد کنید‪:‬‬
‫;‪import java.io.File‬‬
‫برخی از متدهای پر کاربرد کالس ‪ File‬در جدول زیر آمده است‪:‬‬
‫ایجاد یک فایل در یک مسیر خاص‬ ‫)(‪createNewFile‬‬
‫حذف فایل‬ ‫)(‪delete‬‬
‫چک میکند که آیا مسیر داده شده‪ ،‬یک فایل است یا نه؟‬ ‫)(‪isFile‬‬
‫چک میکند که آیا مسیر داده شده‪ ،‬یک پوشه است یا نه؟‬ ‫)(‪isDirectory‬‬
‫چک کردن اینکه آیا یک فایل در یک مسیر خاص وجود دارد یا نه؟‬ ‫)(‪exists‬‬
‫برای انتقال و تغییر نام یک فایل به کار میرود‪.‬‬ ‫)(‪renameTo‬‬
‫نام فایل را بر میگرداند‪.‬‬ ‫)(‪getName‬‬
‫پوشه یا درایوی که فایل در آن قرار دارد را بر میگرداند‪.‬‬ ‫)(‪getParent‬‬

‫مسیر فایل را بر میگرداند‪.‬‬ ‫)(‪getPath‬‬
‫حجم فایل را بر حسب بایت بر میگرداند‪.‬‬ ‫)(‪length‬‬
‫زمان آخرین دستکاری فایل را بر میگرداند‪.‬‬ ‫)(‪lastModified‬‬
‫برای ایجاد یک پوشه به کار میرود‬ ‫)(‪mkdir‬‬
‫برای ایجاد یک پوشههای تو در تو به کار میرود‬ ‫)(‪mkdirs‬‬
‫ایجاد یک فایل‬
‫با استفاده از متد )(‪ createNewFile‬میتوان یک فایل جدید ایجاد کرد‪ .‬این متد یک مقدار بولی را بر میگرداند‪ .‬اگر فایل ایجاد‬
‫شود ‪ true‬و در غیر اینصورت ‪ false‬را بر میگرداند‪ .‬البته قبل از استفاده از این متد باید یک نمونه از کالس فایل ایجاد شده و‬
‫سپس مسیری که قرار است فایل در آنجا ساخته شود به عنوان پارامتر به سازنده کالس فایل ارسال شود‪ .‬به مثال زیر توجه کنید‪:‬‬
‫;)"‪File f = new File("C:\\Sample.txt‬‬
‫‪try‬‬
‫{‬
‫))(‪if(f.createNewFile‬‬
‫{‬
‫;)"!‪System.out.println("The File is created‬‬
‫}‬
‫}‬
‫)‪catch(IOException e‬‬
‫{‬
‫;))(‪System.out.println(e.getMessage‬‬
‫}‬
‫نکته اینجاست که اگر فایلی از قبل به این نام وجود داشته باشد حذف نشده و فایل جدید جایگزین نمیشود‪ .‬همانطور که در کد‬
‫باال مشاهده میکنید باید خطاهای ایجاد و یا عدم ایجاد فایل را مدیریت کنید‪ .‬روش دیگر برای ایجاد فایل ایجاد ‪IOExeption‬‬
‫به صورت زیر است‪:‬‬
‫‪public static void main(String[] args) throws IOException‬‬

‫{‬
‫;)(‪f.createNewFile‬‬
‫}‬
‫با استفاده از متد ‪ exists‬میتوان تست کرد که آیا مسیری که مورد نظر شماست وجود دارد‪ ،‬که در صورت پیدا کردن مسیر فایل‬
‫یا دایرکتوری‪ ،‬مقدار ‪ true‬و در غیر اینصورت مقدار ‪ false‬را بر میگرداند‪.‬‬
‫;)"‪File f = new File("C:\\text.txt‬‬
‫))(‪if (f.exists‬‬
‫{‬
‫;)"!‪System.out.println("The File found‬‬
‫}‬
‫حذف یک فایل‬
‫برای حذف یک فایل از متد )(‪ delete‬استفاده میشود‪:‬‬
‫;)(‪f.delete‬‬
‫این متد هم یک مقدار بولی را بر میگرداند‪.‬‬
‫انتقال و تغییر نام یک فایل‬
‫برای انتقال یک فایل یک از مسیر به مسیر دیگر میتوانید از متد )(‪ renameTo‬استفاده میشود‪:‬‬
‫;)"‪File Sourcesample = new File("C:\\Sample.txt‬‬
‫;)))(‪Sourcesample.renameTo(new File("D:\\" + Sourcesample.getName‬‬
‫در خط دوم کد باال ما در داخل متد )(‪ renameTo‬یک شیء جدید ایجاد کردهایم و مسیر جدید را که درایو ‪ D‬است به آن دادهایم‪.‬‬
‫برای اینکه نام فایل هم تغییر نکند از متد )(‪ getName‬برای به دست آوردن نام فایل مبدأ استفاده کردهایم‪ .‬در کل معنی کد باال‬
‫این است که فایل اصلی را به درایو ‪ D‬و با همین نام منتقل کن‪ .‬برای روشن شدن مطلب به کد زیر توجه کنید‪:‬‬
‫;)"‪File Sourcesample = new File("C:\\Sample.txt‬‬
‫;)"‪File Destsample = new File("D:\\Sample.txt‬‬
‫;)‪Sourcesample.renameTo(Destsample‬‬
‫در کد باال ما یک فایل مبدأ داریم با نام ‪ Sourcesample‬و میخواهیم آن را به درایو ‪ D‬منتقل کنیم ‪ .‬برای این کار یک شیء جدید‬
‫که نشان دهنده مکان جدید است با نام ‪ Destsample‬ایجاد کرده و به عنوان پارامتر به متد )(‪ renameTo‬ارسال میکنیم‪ .‬برای‬
‫انتقال و تغیر نام همزمان هم میتوانیم به صورت زیر مسیر و نام جدید را تعریف کنیم‪:‬‬
‫;)"‪File Destsample = new File("D:\\NewName.txt‬‬
‫به دست آوردن مسیر و والد یک فایل‬
‫برای به دست آوردن مسیر و والد یک فایل از متدهای )(‪ getParent‬و )(‪ getPath‬به صورت زیر استفاده میشود‪:‬‬
‫;))(‪System.out.println(f.getName‬‬
‫;))(‪System.out.println(f.getParent‬‬
‫;))(‪System.out.println(f.getPath‬‬
‫‪Sample.txt‬‬
‫\‪C:‬‬
‫‪C:\Sample.txt‬‬
‫همانطور که در کد باال مشاهده میکنید نام فایل‪ ،‬مکان و مسیر فایل نشان داده شده است‪ .‬کالس ‪ File‬دارای متدهای بیشتری‬
‫برای کار با فایل است که در این درس به همین چند متد اکتفا میکنیم‪.‬‬
‫ایجاد یک پوشه و پوشههای تو در تو‬
‫برای ایجاد یک پوشه از متد )(‪ mkdir‬استفاده میشود‪:‬‬
‫;)"‪File f = new File("C:\\Folder1‬‬
‫;)(‪f.mkdir‬‬
‫کد باال یک پوشه با نام ‪ Folder1‬در درایو ‪ C‬ایجاد میکند‪ .‬و برای ایجاد پوشههای تو در تو از متد )(‪ mkdirs‬میتوان استفاده‬
‫کرد‪:‬‬
‫;)"‪File f = new File("C:\\Folder1\\Folder2‬‬
‫;)(‪f.mkdirs‬‬
‫کد باال یک پوشه با نام ‪ Folder1‬در درایو ‪ C‬ایجاد میکند که در داخل آن یک پوشه دیگر ‪ Folder2‬قرار دارد‪.‬‬
‫به دست آورن فایلها و پوشههای موجود در یک پوشه‬
‫برای به دست آوردن نام پوشهها و فایلهای موجود در یک پوشه از متد )(‪ listFiles‬استفاده میشود‪ .‬یک پوشه به نام ‪Folder‬‬
‫در داخل درایو ‪ C‬ایجاد کرده و دو فایل و یک پوشه در داخل آن قرار دهید‪ .‬سپس کدهای زیر را بنویسید‪:‬‬
‫;‪import java.io.File‬‬

‫{‬
‫{‬
‫;)"‪File file = new File("C:\\Folder‬‬
‫))(‪if (file.isDirectory‬‬
‫{‬
‫;)(‪File[] files = file.listFiles‬‬
‫)‪for (File f : files‬‬
‫{‬
‫}‬
‫}‬
‫}‬
‫}‬
‫در کد باال ابتدا مسیر پوشه ای که در درایو ‪ C‬ایجاد کردهایم را در سازنده کالس ‪ File‬نوشتهایم‪ .‬در خط بعد با استفاده از متد‬
‫)(‪ isDirectory‬چک میکنیم که آیا مسیر متعلق به یک پوشه است یا نه؟ اگر چنین بود در داخل بدنه دستور ‪ if‬ابتدا یک‬
‫آرایه از کالس فایل ایجاد میکنیم‪ ،‬چون متد )(‪ listFiles‬یک آرایه از فایلها را بر می کرداند‪ .‬سپس با استفاده از یک حلقه‬
‫‪ foreach‬نام فایلها را چاپ میکنیم‪.‬‬
‫به دست آوردن لیست زیر پوشهها‬
‫همانطور که در مثال قبل دیدیم با استفاده از متد )(‪ listFiles‬میتوانیم لیست فایلها و زیر پوشههای یک پوشه خاص را به‬
‫دست بیاوریم ولی گاهی نیاز داریم تنها زیر پوشهها را لیست کنیم برای اینکار میتوانیم از ‪ FileFilter‬استفاده کنیم‪ .‬به مثال زیر‬
‫دقت کنید‪:‬‬

‫{‬
‫{‬
‫;)"‪File file = new File("G:/MyFolder‬‬
‫)(‪FileFilter myFilter = new FileFilter‬‬
‫{‬
‫)‪public boolean accept(File f‬‬
‫{‬
‫;)(‪return f.isDirectory‬‬
‫}‬
‫;}‬
‫))(‪if(file.isDirectory‬‬
‫{‬
‫;)‪File[] files = file.listFiles(myFilter‬‬
‫)‪for(File f : files‬‬
‫{‬
‫}‬
‫}‬
‫}‬
‫}‬
‫مثال باال لیست زیر پوشههای پوشه ‪ MyFolder‬را چاپ میکند‪.‬برای استفاده از ‪ FileFilter‬ابتدا یک شیء از آن ایجاد میکنیم‪،‬‬
‫چون این کالس یک ‪ Interface‬است مجبور به پیاده سازی متد )(‪ accept‬آن خواهیم بود‪ ،‬در داخل متد )(‪ accept‬مشخص‬
‫میکنیم که چه نوع فایلهایی باید لیست شوند؟ در اینجا فقط فایلهایی که شرط ‪ isDirectory‬برای آنها ‪ true‬باشد (به‬
‫عبارتی پوشه باشند و نه یک فایل معمولی) لیست خواهند شد‪ .‬برای استفاده از ‪ myFilter‬کافی است آن را به عنوان پارامتر به‬
‫متد )(‪ listFiles‬ارسال کنیم‪.‬در مثال بعد با کاربرد ‪ FileFilter‬بیشتر آشنا خواهید شد‪ .‬گاهی نیاز داریم تا فایلهای خاصی‬
‫را لیست کنیم‪ ،‬به عنوان مثال در یک برنامه مخصوص ویرایش متن ممکن است الزم داشته باشیم تنها فایلهای با پسوند ‪txt‬‬
‫چاپ شوند‪ ،‬خوشبختانه در این حالت هم میتوانیم از ‪ FileFilter‬استفاده کنیم‪ .‬مثال زیر تمام فایلهای با پسوند ‪ txt‬که در‬
‫داخل پوشه ‪ MyFolder‬قرار دارند را چاپ میکند‪:‬‬

‫{‬
‫{‬
‫{‬
‫{‬
‫;)"‪return f.getName().endsWith(".txt‬‬
‫}‬
‫;}‬
‫{‬
‫{‬
‫}‬
‫}‬
‫}‬
‫}‬
‫همانطور که مشاهده میکنید این مثال بسیار شبیه مثال قبلی است با این تفاوت که در اینجا به جای استفاده از شرط‬
‫‪ isDirectory‬از شرط متفاوت تری به صورت ‪ getName().endsWith‬استفاده میکند‪ ،‬متد )(‪ getName‬نام فایل را بر‬
‫میگرداند و متد )(‪ endsWith‬مشخص میکند آیا نام فایل با پسوند ‪ .txt‬خاتمه مییابد یا خیر؟ در نتیجه استفاده از ‪myFilter‬‬
‫به عنوان پارامتر ورودی ‪ listFiles‬باعث میشود تنها فایلهایی با پسوند ‪ txt‬چاپ شوند‪ .‬گاهی نیاز پیدا میکنیم برای لیست‬
‫کردن فایلها شرطهای متفا وتی داشته باشیم به عنوان مثال ممکن است بخواهیم تمام فایلهای ‪ txt‬و ‪ exe‬و همچنین تمام‬
‫زیر پوشههای یک پوشه خاص را لیست کنیم برای این کار کافی است از عملگر || برای ترکیب شرطها استفاده کنیم‪ .‬مثال زیر تمام‬
‫فایلهای ‪ exe‬و همچنین تمام زیر پوشههای پوشه ‪ MyFolder‬را لیست میکند‪:‬‬

‫{‬
‫{‬
‫{‬
‫{‬
‫;)(‪return f.getName().endsWith(".exe") || f.isAbsolute‬‬
‫}‬
‫;}‬
‫{‬
‫{‬
‫}‬
‫}‬
‫}‬
‫}‬
‫برای به دست آوردن نام درایوهای اصلی سیستم هم از متد )(‪ listRoots‬استفاده میکنیم ‪:‬‬

‫{‬
‫{‬
‫;)(‪File[] roots = File.listRoots‬‬
‫)‪for (File f : roots‬‬
‫{‬
‫;)‪System.out.println(f‬‬
‫}‬
‫}‬
‫}‬
‫همانطور که مشاهده میکنید متد )(‪ listRoots‬یک آرایه از نوع ‪ File‬بر میگرداند که با یک حلقه ‪ for‬میتوانیم اشیای‬
‫داخل آن را مورد بررسی قرار دهیم‪.‬دقت کنید که متد )(‪ listRoots‬یک متد ‪ static‬است و برای استفاده از آن نیاز به ساختن‬
‫یک شیء جدید از کالس ‪ File‬نداریم و میتوانیم مستقیما آن را فراخوانی کنیم‪.‬‬
‫تفاوت متدهای ‪ list‬و ‪listFiles‬‬
‫برای لیست فایلها و پوشههای داخل یک پوشه خاص میتوانیم از یکی از متدهای )(‪ list‬یا )(‪ listFiles‬استفاده کنیم‪،‬‬
‫تفاوت این دو متد در این است که متد )(‪ list‬تنها آرایه ای از ‪ String‬ها بر میگرداند که حاوی نام فایلهاست و مناسب‬
‫برنامههایی است که تنها به نام فایل نیاز داریم ولی متد )(‪ listFiles‬آرایه ای از نوع ‪ File‬بر میگرداند و این قابلیت را به ما‬
‫میدهد که مستقیما با زیر فایلها و زیر پوشههای پوشه مورد نظر به سادگی کار کنیم ‪.‬‬
‫تعیین حجم کلی و فضای خالی یک درایو‬
‫برای تعیین فضای خالی یک درایو میتوانیم از متد )(‪ getFreeSpace‬استفاده کنیم‪ ،‬این متد تعداد بایتهای آزاد یک درایو را‬
‫مشخص میکند‪ ،‬فراخوانی این متد فقط باید بر روی درایوهای اصلی انجام شود و بر روی سایر فایلها نتیجه ای نخواهد داشت‪.‬‬
‫مثال زیر فضای خالی درایو ‪ G‬را مشخص میکند‪:‬‬
‫;)"‪File f = new File("G:‬‬

‫;))(‪System.out.println(f.getFreeSpace‬‬
‫برای تعیین حجم یک درایو میتوانیم از متد )(‪ getTotalSpace‬استفاده کنیم‪ ،‬این متد حجم یک درایو را برحسب بایت در‬
‫اختیار ما قرار میدهد‪ ،‬مشابه متد قبلی این متد نیز باید روی درایوهای اصلی فراخوانی شود‪ .‬مثال زیر حجم درایو ‪ G‬را مشخص‬
‫میکند‪:‬‬
‫;)"‪File f = new File("G:/‬‬

‫;))(‪System.out.println(f.getTotalSpace‬‬
‫کالس ‪InputStreamReader‬‬
‫در آموزشهای قبلی با کالسهای انتزاعی ‪ Reader‬و ‪ InputStream‬آشنا شدیم‪ ،‬کالس ‪ InputStreamReader‬به عنوان واسط‬
‫بین این دو کالس عمل میکند‪ ،‬این کالس دادهها را به صورت جریان بایتی از ورودی میخواند و بر اساس یک ‪ charset‬مشخص‬
‫آنها را به جریان کاراکتری تبدیل میکند‪ ،‬مهمترین کاربرد این کالس استفاده از آن در کاربردهای شبکه است بدین صورت که‬
‫اطالعات به صورت جریان بایتی از شبکه خوانده میشوند و سپس به جریان متنی تبدیل میشوند‪ .‬از این کالس میتوان برای‬
‫خواندن از فایل‪ ،‬خواندن از وروردی سیستم (کنسول) و یا خواندن از یک حافظه بافر نیز استفاده کرد‪ .‬برای استفاده از این کالس‬
‫باید از یکی از سازندههای زیر برای ساخت شیء جدید از آن استفاده کنیم‪:‬‬
‫)‪InputStreamReader(InputStream in‬‬
‫)‪InputStreamReader(InputStream in,Charset cs‬‬
‫)‪InputStreamReader(InputStream in,String charsetName‬‬
‫متدهای پر کاربرد ‪ InputStreamReader‬در جدول زیر آمده است‪:‬‬
‫جریان ورودی را بسته و منابع استفاده شده را آزاد میکند‬ ‫)( ‪close‬‬
‫یک کاراکتر از جریان ورودی خوانده و آن را به صورت یک ‪ int‬بر‬ ‫)(‪read‬‬
‫میگرداند‪ ،‬در صورتی که به انتهای جریان ورودی رسیده باشیم‬
‫خروجی این متد مقدار ‪- 3‬خواهد بود‪.‬‬
‫کاراکترها را از جریان ورودی خوانده و در آرایه ‪ cbuf‬ذخیره میکند و‬ ‫)‪read(char [] cbuf,int offset,int length‬‬
‫تعداد کاراکترهای خوانده شده را بر میگرداند‪ ،‬در صورتی که کاراکتری‬
‫برای خواندن وجود نداشته باشد خروجی این متد مقدار ‪ -3‬خواهد‬
‫بود‪.‬‬
‫‪ : Cbuf‬آرایه ای است که کاراکترها در آن بافر میشوند‬
‫‪ : Offset‬اندیس شروع نوشتن در آرایه مورد نظر‬
‫‪ : Length‬حداکثر کاراکترهایی که باید خوانده شوند‬

،‫مشخص میکند که قادر به خواندن از جریان ورودی هستیم یا خیر‬ ready ()
.‫ است‬false ‫ یا‬true ‫خروجی این متد به صورت‬
read ‫خواندن از فایل با متد‬
.‫ محتوی یک فایل متنی را کاراکتر به کاراکتر خوانده و چاپ میکنیم‬read() ‫در مثال زیر با استفاده از متد‬
import java.io.*;

{
{
File myFile = new File("D:\\Test.txt");
InputStreamReader inputstreamreader = null;
FileInputStream fileinputstream = null;
try
{
fileinputstream = new FileInputStream(myFile);
inputstreamreader = new InputStreamReader(fileinputstream);
int c;
while ((c = inputstreamreader.read()) != -1)
{
System.out.print((char)c);
}
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
try
{
inputstreamreader.close();
}
{
}
}
}
}
‫ مشخص کنیم‬File ‫همانطور که در کد باال مشاهده میکنید ابتدا باید فایلی که قصد خواندن از آن داریم را با یک شیء از کالس‬
‫ فایل مورد نظر را به یک جریان بایتی تبدیل کنیم (شی‬FileInputStream ‫ در مثال باال) سپس با استفاده از‬myFile ‫(شی‬
‫‪ fileinputstream‬در مثال باال) و در آخرین مرحله از تبدیالت‪ ،‬جریان بایتی را با استفاده از ‪ InputStreamReader‬به جریان‬
‫متنی تبدیل میکنیم (شی ‪ inputstreamreader‬در مثال باال)‪ .‬در ادامه با استفاده از متد ‪ read‬کاراکتر به کاراکتر از‬
‫‪ inputstreamreader‬میخوانیم و تا زمانی که نتیجه فراخوانی این متد ‪ -3‬نباشد آن را در خروجی چاپ میکنیم‪ .‬از آنجایی که‬
‫ممکن است فایل وجود نداشته باشد یا در هنگام عملیات خواندن با خطای پیش بینی نشده مواجه شویم باید حتما از بلوک‪try-‬‬
‫‪ catch‬برای به دام انداختن خطاها استفاده کنیم‪.‬‬
‫خواندن از فایل با کمک یک آرایه‬
‫همانطور که در ابتدا دیدیم متد )(‪ read‬دیگر ی نیز وجود دارد که از یک آرایه بافر برای خواندن از جریان ورودی استفاده میکند‪،‬‬
‫در بسیاری از کاربردها خواندن کاراکتر به کاراکتر زمان بر بوده و بهتر است با استفاده از یک آرایه بافر عملیات خواندن را تسریع‬
‫بخشیم‪ .‬مثال زیر به شرح این موضوع میپردازد‪:‬‬

‫{‬
‫{‬
‫;)"‪File myFile = new File("D:\\Test.txt‬‬
‫;‪InputStreamReader inputstreamreader = null‬‬
‫;‪FileInputStream fileinputstream = null‬‬
‫;]‪char charbuffer[] = new char[200‬‬

‫;‪int readed‬‬
‫‪try‬‬
‫{‬
‫;)‪fileinputstream = new FileInputStream(myFile‬‬
‫;)‪inputstreamreader = new InputStreamReader(fileinputstream‬‬
‫;)‪readed = inputstreamreader.read(charbuffer, 0, charbuffer.length‬‬
‫)‪for (int i = 0; i < readed; i++‬‬

‫{‬
‫;)]‪System.out.print(charbuffer[i‬‬
‫}‬
‫}‬
‫)‪catch (IOException e‬‬
‫{‬
‫;)(‪e.printStackTrace‬‬
‫}‬
‫‪finally‬‬
‫{‬
‫‪try‬‬
‫{‬
‫;)(‪inputstreamreader.close‬‬
}
{
}
}
}
}
.‫ تعداد کاراکترهای خوانده شده از فایل را مشخص میکند‬readed ‫متغیر‬
)‫خواندن از ورودی سیستم (کنسول‬
‫ نداریم‬FileInputStream ‫خواندن از ورودی سیستم مشابه خواندن از فایل است با این تفاوت که در این حالت دیگری نیازی به‬
‫ مثال زیر متنی را که کاربر در ورودی سیستم تایپ میکند (و در‬.‫ مستقیما از ورودی سیستم میخوانیم‬System.in ‫و با استفاده از‬
.‫پایان کلید اینتر را می زند) در خروجی استاندارد چاپ میکند‬
import java.io.*;

{
{
char charbuffer[] = new char[200];

int readed;
try
{
inputstreamreader = new InputStreamReader(System.in);
readed = inputstreamreader.read(charbuffer, 0, charbuffer.length);
for (int i = 0; i < readed; i++)

{
System.out.print(charbuffer[i]);
}
}
{
}
finally
{
try
{
}
{
}
}
}
}
‫خواندن از یک حافظه بافر‬
‫ در مثال زیر از یک آرایه به عنوان جریان ورودی استفاده میکنیم‬.‫جریان ورودی میتواند مق ادیر ذخیره شده در یک آرایه نیز باشد‬
import java.io.*;

{
{
String test = "Test String!";
byte[] memoryBuffer = test.getBytes();

ByteArrayInputStream bytearrayinputstream = null;
char charbuffer[] = new char[200];

int readed;
try
{
bytearrayinputstream = new ByteArrayInputStream(memoryBuffer);
inputstreamreader = new InputStreamReader(bytearrayinputstream);
readed = inputstreamreader.read(charbuffer, 0, charbuffer.length);

{
System.out.print(charbuffer[i]);
}
}
{
}
finally
{
try
{
}
{
}
}
}
}
‫در مثال باال از یک حافظه بافر (‪ memoryBuffer‬در کد) به عنوان جریان ورودی استفاده کردیم‪ ،‬برای ساخت حافظه بافر ابتدا‬
‫رشته ‪ test‬را به آرایه ای از بایتها (متغیر ‪ )memoryBuffer‬تبدیل کردیم‪ ،‬سپس این آرایه از بایتها را با استفاده از‬
‫‪ ByteArrayInputStream‬به یک جریان ورودی بایتی (متغیر ‪ )bytearrayinputstream‬تبدیل کردیم و در نهایت با استفاده از‬
‫‪ InputStreamReader‬جریان ورودی را به یک جریان کاراکتری )‪ (inputstreamreader‬تبدیل کردیم‪ .‬مابقی قسمتها مشابه‬
‫کدهای قبلی است‪.‬‬
‫کالس ‪OutputStreamWriter‬‬
‫در آموزشهای قبلی با کالسهای انتزاعی ‪ Writer‬و ‪ OutputStream‬آشنا شدیم‪ ،‬کالس ‪ OutputStreamWriter‬به عنوان‬
‫واسط بین این دو کالس عمل میکند‪ ،‬با استفاده از این کالس میتوانیم یک جریان کاراکتری را به جریان بایتی تبدیل و ذخیره‬
‫کنیم‪.‬بیشترین کاربرد این کالس زمانی است که بخواهیم رشتههایی با فرمتهایی همچون ‪ UTF-16 ،UTF-8‬و … را به صورت‬
‫بایتی ذخیره کنیم و در عین حال مطمئن باشیم که عمل ‪ decode‬به درستی صورت میگیرد‪ .‬کار با این کالس دشوار است و معموال‬
‫از این کالس به عنوان ابزار کمکی در کنار کالسهای پیشرفته تر استفاده میشود‪ .‬برای استفاده از این کالس باید از یکی از‬
‫سازندههای زیر برای ساخت شیء جدید از آن استفاده کنیم‪:‬‬
‫)‪OutputStreamWriter (OutputStream out‬‬

‫)‪OutputStreamWriter (OutputStream out,Charset cs‬‬
‫)‪OutputStreamWriter (OutputStream out,String charsetName‬‬
‫متدهای پر کاربرد ‪ OutputStreamWriter‬در جدول زیر آمده است‪:‬‬
‫جریان ورودی را بسته و منابع استفاده شده را آزاد میکند‬ ‫)(‪close‬‬
‫دادههای بافر شده در حافظه را در استریم خروجی ارسال میکند‪.‬‬ ‫)(‪flush‬‬
‫کاراکتر ‪ c‬را در استریم خروجی مینویسد‪.‬‬ ‫)‪write(char c‬‬
‫قسمتی از آرایه ‪ cbuf‬را با شروع از اندیس ‪ offset‬به تعداد‬ ‫)‪write(char[] cbuf,int offset,int length‬‬
‫‪ length‬کاراکتر در استریم خروجی مینویسد‪.‬‬

‫مشابه متد قبلی است با این تفاوت که به جای آرایه ای از کاراکترها از‬ write(String str,int offset,int length)
.‫ استفاده میکند‬String ‫یک‬
‫نوشتن در فایل‬
.‫ ذخیره میکند‬Test.txt ‫ در فایل‬UTF-8 ‫مثال زیر یک متن آزمایشی را با فرمت‬
import java.io.*;

{
{
String sampleData = "Sample Test to Store";
FileOutputStream fileoutputstream = null;
OutputStreamWriter outputstreamwriter = null;
try
{
fileoutputstream = new FileOutputStream(myFile);
outputstreamwriter = new OutputStreamWriter(fileoutputstream, "UTF-8");
outputstreamwriter.write(sampleData, 0, sampleData.length());
outputstreamwriter.flush();
}
{
}
finally
{
try
{
outputstreamwriter.close();
}
{
}
}
}
}
RandomAccessFile ‫کالس‬
‫کالس ‪ RandomAccessFile‬همانطور که از نام آن پیداست کالسی با قابلیت “دسترسی تصادفی” به فایل است که به ما اجازه‬
‫میدهد به صورت همزمان هم از فایل بخوانیم و هم در آن بنویسیم‪ ،‬با استفاده از این کالس با فایل به مثابه یک آرایه بزرگ‬
‫برخورد میکنیم‪ ،‬این فایل دارای ساختاری اندیسی یا اشاره گر گونه است که در هر لحظه به آخرین مکانی که عمل خواندن یا‬
‫نوشتن در آن انجام شده است اشاره میکند‪ ،‬این کالس با متدهای مختلفی که در اختیار ما قرار میدهد کار با انواع دادههای‬
‫مختلف اعم از اعداد صحیح‪ ،‬اعداد ممیز شناور‪ ،‬رشتهها و … را بسیار آسان میسازد‪ .‬برای استفاده از این کالس باید از یکی از‬
‫)‪RandomAccessFile (File file,String mod‬‬

‫)‪RandomAccessFile (String fileName,String mod‬‬
‫پارامتر ‪mod‬‬
‫قبل از ادامه باید با پارامتر ‪ mod‬آشنا شویم‪ ،‬این پارامتر نحوه دسترسی به فایل را مشخص میکند و میتواند یکی از موارد زیر‬
‫باشد‪:‬‬
‫معنی‬ ‫مقدار‬
‫مشخص میکند که فقط قصد خواندن از فایل را داریم‪.‬‬ ‫‪r‬‬
‫مشخص میکند که قصد خواندن و نوشتن را داریم‪.‬‬ ‫‪rw‬‬
‫مشخص میکند که قصد خواندن و نوشتن داریم و تغییرات فایل یا متا دیتا باید سریعا بر روی فایل اعمال شوند‪.‬‬ ‫‪rws‬‬
‫مشابه مورد قبلی است با این تفاوت تغییر سریع متا دیتا الزامی نیست‪.‬‬ ‫‪rwd‬‬
‫متدهای پر کاربرد ‪ RandomAccessFile‬در جدول زیر آمده است‪:‬‬
‫جریان ورودی‪ -‬خروجی را بسته و منابع استفاده شده را آزاد میکند‬ ‫)( ‪close‬‬
‫اندازه فایل را بر حسب بایت بر میگرداند‪.‬‬ ‫)(‪length‬‬

‫یک بایت از فایل میخواند‪.‬‬ ‫)(‪read‬‬
‫یک آرایه از بایتها را از فایل میخواند‪.‬‬ ‫)‪read(byte[] b‬‬
‫قسمتی از آرایه ‪ b‬را با شروع از اندیس ‪ offset‬به تعداد ‪ lenght‬بایت را‬ ‫‪read(byte[] b,int offset,int‬‬
‫)‪length‬‬
‫از فایل میخواند‪.‬‬
‫سعی میکند یک مقدار ‪ boolean‬از فایل بخواند‪.‬‬ ‫)(‪readBoolean‬‬
‫یک بایت عالمت دار از فایل میخواند‪.‬‬ ‫)(‪readByte‬‬
‫یک کاراکتر از فایل میخواند‪.‬‬ ‫)(‪readChar‬‬
‫یک مقدار ‪ double‬از فایل میخواند‪.‬‬ ‫)(‪readDouble‬‬
‫یک مقدار ‪ float‬از فایل میخواند‪.‬‬ ‫)(‪readFloat‬‬
‫متدی فوق العاده سریع برای خواندن یک آرایه از بایت است‪ ،‬بهتر است از این‬ ‫)‪readFully(byte[] b‬‬
‫متد برای خواندن کل فایل در عملیاتی همچون کپی کردن فایل یا مشابه آن‬
‫استفاده کنیم‪.‬‬
‫یک مقدار ‪ int‬از فایل میخواند‪.‬‬ ‫)(‪readInt‬‬
‫یک خط کامل از فایل میخواند‪.‬‬ ‫)(‪readLine‬‬
‫یک مقدار ‪ short‬از فایل میخواند‪.‬‬ ‫)(‪readShort‬‬
‫یک هشت بیتی بی عالمت از فایل میخواند‪.‬‬ ‫)(‪readUnsignedByte‬‬
‫یک شانزده بیتی بی عالمت از فایل میخواند‪.‬‬ ‫)(‪readUnsignedShort‬‬
‫یک رشته با فرمت ‪ UTF‬را از فایل میخواند‪.‬‬ ‫)(‪readUTF‬‬
‫مکان خوان از فایل را به موقعیت ‪ pos‬تغییر میدهد‪.‬‬ ‫)‪seek(long pos‬‬

‫اندازه فایل را تغییر میدهد‪.‬‬ ‫)‪setLength(long length‬‬
‫یک آرایه از بایتها را در فایل مینویسد‪.‬‬ ‫)‪write(byte[] b‬‬
‫یک آرایه از بایتها را با شروع از اندیس ‪ off‬و به اندازه ‪ len‬در فایل‬ ‫)‪write(byte[] b,int off,int len‬‬
‫یک مقدار ‪ boolean‬در فایل مینویسد‪.‬‬ ‫)‪writeBoolean(boolean v‬‬
‫یک بایت در فایل مینویسد‪.‬‬ ‫)‪writeByte(int v‬‬
‫یک رشته را به صورت آرایه ای از بایتها در فایل مینویسد‪.‬‬ ‫)‪writeBytes(String s‬‬
‫یک کاراکتر در فایل مینویسد‪.‬‬ ‫)‪writeChar(int v‬‬
‫یک رشته را به صورت آرایه ای از کاراکترها در فایل مینویسد‪.‬‬ ‫)‪writeChars(String s‬‬
‫یک ‪ double‬در فایل مینویسد‪.‬‬ ‫)‪writeDouble(double v‬‬
‫یک مقدار ‪ float‬در فایل مینویسد‪.‬‬ ‫)‪writeFloat(float v‬‬
‫یک مقدار ‪ int‬در فایل مینویسد‪.‬‬ ‫)‪writeInt(int v‬‬
‫یک مقدار ‪ long‬در فایل مینویسد‪.‬‬ ‫)‪writeLong(long v‬‬
‫یک مقدار ‪ short‬در فایل مینویسد‪.‬‬ ‫)‪writeShort(int v‬‬
‫یک رشته با فرمت ‪ UTF‬را در فایل مینویسد‪.‬‬ ‫)‪writeUTF(String s‬‬

‫خواندن از فایل‬
‫در مثال زیر از کالس ‪ RandomAccessFile‬برای خواندن از فایل استفاده میکنیم‪ ،‬قبل از اجرای این مثال یک فایل به نام‬
‫‪Test.txt‬ایجاد کرده و یک محتوای دلخواه در داخل آن نوشه و ذخیره کنید‪ .‬سپس از کد زیر برای خواندن فایل استفاده نمایید‬
‫‪:‬‬

‫{‬
‫{‬
‫;‪RandomAccessFile randomaccessfile = null‬‬
‫‪try‬‬
‫{‬
‫;)"‪randomaccessfile = new RandomAccessFile(myFile, "r‬‬
‫;‪String line‬‬
‫)‪while ((line = randomaccessfile.readLine()) != null‬‬
‫{‬
‫;)‪System.out.println(line‬‬
‫}‬
‫}‬
‫{‬
‫}‬
‫}‬
‫}‬
‫در کد باال پارامتر دوم ‪ RandomAccessFile‬مشخص میکند که تنها قصد خواندن از فایل را داریم‪ ،‬در ادامه در یک حلقه ‪while‬‬
‫با استفاده از متد )(‪ readLine‬یک خط از فایل میخوانیم و آن را چاپ میکنیم‪.‬زمانی که متد )(‪ readLine‬مقدار ‪ null‬برگرداند‬
‫به انتهای فایل رسیدهایم و از حلقه ‪ while‬خارج میشویم‪.‬‬
‫در مثال زیر از ‪ RandomAccessFile‬برای نوشتن مقادیر مختلف در فایل استفاده میکنیم‪.‬‬

{
{
RandomAccessFile randomaccessfile = null;
try
{
randomaccessfile = new RandomAccessFile(myFile, "rw");
randomaccessfile.writeUTF("A B C\n");
randomaccessfile.writeInt(20);
randomaccessfile.writeFloat(3.14f);
randomaccessfile.writeInt(80);
randomaccessfile.close();
}
{
}
}
}
‫ است و این بدان معنی است که قصد خواندن و نوشتن در فایل را‬rw ‫ برابر با‬RandomAccessFile ‫در مثال باال پارامتر دوم‬
‫ و سپس‬float ‫ و سپس یک مقدار‬int ‫ یک رشته در فایل مینویسیم بعد از آن یک مقدار‬writeUTF() ‫با استفاده از متد‬.‫داریم‬
‫ باز کنید‬notepad ‫اگر فایلی که در مثال قبلی ذخیره شد را در یک ادیتور متنی ساده مثل‬.‫ دیگر در فایل مینویسیم‬int ‫یک مقدار‬
‫ برای اینکه از صحت کد قبل مطمئن شویم کد دیگری مینویسیم و مقادیر نوشته‬،‫مشاهده میکنید که محتوای آن خوانا نیست‬
.‫شده در فایل را میخوانیم و چاپ میکنیم‬
import java.io.*;

{
{
RandomAccessFile randomaccessfile = null;
try
{
randomaccessfile = new RandomAccessFile(myFile, "rw");
String s = randomaccessfile.readUTF();
System.out.println(s);
int a = randomaccessfile.readInt();
System.out.println(a);
float f = randomaccessfile.readFloat();
System.out.println(f);
‫;)(‪int b = randomaccessfile.readInt‬‬
‫;)‪System.out.println(b‬‬
‫;)(‪randomaccessfile.close‬‬
‫}‬
‫{‬
‫}‬
‫}‬
‫}‬
‫کد باال مشابه کد قبلی است با این تفاوت که این بار به جای عمل نوشتن از عمل خواندن برای تست استفاده میکنیم‪.‬باید دقت‬
‫کنید که ترتیب خواندن باید مشابه ترتیب نوشتن باشد‪.‬اگر قصد استفاده از ‪ RandomAccessFile‬را دارید برای ذخیره اعداد در‬
‫فایل از ادیتور های متنی مانند ‪ notepad‬استفاده نکنید زیرا این مقادیر در حقیقت متنهای ‪ ASCII‬هستند و نه اعداد واقعی‬
‫و اگر با ‪ RandomAccessFile‬خوانده شوند مقادیری بی معنی خواهند بود‪ .‬راه حل صحیح نوشتن اعداد در فایل این است که از‬
‫خود کالس ‪ RandomAccessFile‬برای نوشتن عدد استفاده کنید‪.‬‬
‫کالس ‪ByteArrayInputStream‬‬
‫کالس ‪ ByteArrayInputStream‬به ما اجازه میدهد تا با یک آرایه از بایتها که در ‪ RAM‬قرار دارد به عنوان یک جریان ورودی‬
‫عمل کنیم و بتوانیم از کالسهایی که زیر کالس ‪ InputStream‬هستند در کنار آن بهره ببریم‪.‬این کالس بیشتر به عنوان یک واسط‬
‫در کنار کالسهای دیگر استفاده میشود‪.‬کاربرد اصلی این کالس در شبکه است‪ ،‬بدین صورت که اطالعات به صورت آرایه ای از‬
‫بایتها از طریق شبکه دریافت میشوند و سپس با استفاده از ‪ ByteArrayInputStream‬به یک جریان ورودی تبدیل میشوند‪.‬‬
‫برای استفاده از این کالس باید از یکی از سازندههای زیر برای ساخت شیء جدید از آن استفاده کنیم‪:‬‬
‫)‪ByteArrayInputStream (byte[] b‬‬

‫)‪ByteArrayInputStream (byte[] b,int offset,int length‬‬
‫متدهای پر کاربرد ‪ ByteArrayInputStream‬در جدول زیر آمده است‪:‬‬
‫یک بایت از جریان ورودی خوانده و آن را به صورت یک ‪ int‬بر میگرداند‪،‬‬ ‫)(‪read‬‬
‫در صورتی که به انتهای جریان ورودی رسیده باشیم خروجی این متد مقدار ‪3-‬‬
‫بایتها را از جریان ورودی خوانده و در آرایه ‪ b‬ذخیره میکند و تعداد‬ ‫‪read(byte[] b,int offset,int‬‬
‫)‪length‬‬
‫بایتهای خوانده شده را بر میگرداند‪ ،‬در صورتی که بایتی برای خواندن‬
‫وجود نداشته باشد خروجی این متد مقدار ‪ 3-‬خواهد بود‪.‬‬
‫‪ : B‬آرایه ای است که بایتها در آن بافر میشوند‬
‫‪ : Offset‬اندیس شروع نوشتن در آرایه مورد نظر‬
‫‪ : Length‬حداکثر بایتهایی که باید خوانده شوند‬
‫تعداد بایتهایی که باقی ماند اند را مشخص میکند‪.‬‬ ‫)(‪available‬‬
‫خواندن از یک آرایه‬
‫در مثال زیر با استفاده از متد )(‪ read‬محتوی یک آرایه را بایت به بایت خوانده و چاپ میکنیم‪.‬‬

‫{‬
‫{‬
‫;} ‪byte[] buffer = { 72, 101, 108, 108, 111‬‬
‫;‪ByteArrayInputStream byteinputarraystream‬‬
‫‪try‬‬
‫{‬
‫;)‪byteinputarraystream = new ByteArrayInputStream(buffer‬‬
‫;‪int v‬‬
‫)‪while ((v = byteinputarraystream.read()) != -1‬‬
‫{‬
‫;)‪System.out.print((char)v‬‬
‫}‬
‫;)(‪byteinputarraystream.close‬‬
‫}‬
‫} { )‪catch (IOException e‬‬
‫}‬
‫}‬
‫در مثال فوق آرایه مورد نظر از قبل آماده است در کاربردهای پیشرفته ممکن است این آرایه در زمان اجرا تولید شود (مثال در‬
‫کاربردهای شبکه)‪ ،‬بعد از ساخت ‪ ByteArrayInputStream‬میتوانیم با آن به صورت یک ‪ InputStream‬معمولی بر خورد‬
‫کنیم‪ ،‬در داخل حلقه ‪ while‬هر بار یک بایت از استریم ورودی میخوانیم در صورتی که مقدار خوانده شده )‪ (v‬برابر با ‪ 3-‬نباشد‬
‫آن را به کاراکتر تبدیل و سپس چاپ میکنیم‪.‬خروجی کد باال عبارت ”‪ “Hello‬خواهد بود‪.‬‬
‫تبدیل رشته به آرایه‬
‫در بسیاری از موارد قبل از استفاده از ‪ ByteArrayInputStream‬نیاز پیدا میکنیم تا یک رشته متنی را به آرایه ای از بایتها‬
‫تبدیل کنیم که در این صورت میتوانیم از متد )(‪ getBytes‬استفاده کنیم‪:‬‬
‫;"‪String s = "Hello Java‬‬

‫;)(‪byte[] arr = s.getBytes‬‬
‫کالس ‪ByteArrayOutputStream‬‬
‫کالس ‪ ByteArrayOutputStream‬کالسی است که به ما اجازه میدهد یک استریم خروجی را به آرایه ای از بایتها تبدیل کنیم‪،‬‬
‫این کالس یک کالس واسط است و به عنوان یک ابزار کمکی در کنار کالسهای پیشرفته تر استفاده میشود‪ ،‬بیشترین کاربرد این‬
‫کالس در شبکه است که به ما اجازه میدهد انواع مختلفی از ‪ OutputStream‬ها را به آرایه ای از بایت تبدیل و در شبکه ارسال‬
‫کنیم‪ .‬برای استفاده از این کالس باید از یکی از سازندههای زیر برای ساخت شیء جدید از آن استفاده کنیم‪:‬‬
‫)( ‪ByteArrayOutputStream‬‬
‫)‪ByteArrayOutputStream (int bufferSize‬‬
‫متدهای پر کاربرد ‪ ByteArrayOutputStream‬در جدول زیر آمده است‪:‬‬
‫جریان خروجی را بسته و منابع استفاده شده را آزاد میکند‬ close ()
‫مهمترین متد این کالس است و در انتهای عملیات میتوانیم از آن برای‬ toByteArray()
.‫تبدیل استریم به آرایه استفاده کنیم‬
.‫استریم را به رشته تبدیل میکند‬ toString()
.‫ خاص استریم را به رشته تبدیل میکند‬Charset ‫بر اساس یک‬ toString(String charsetName)
.‫یک بایت در استریم مینویسد‬ write(int byte)
.‫یک آرایه از بایتها را در استریم مینویسد‬ write(byte[] b)
.‫قسمتی از یک آرایه از بایتها را در استریم مینویسد‬ write(byte[] b,int offset,int length)
.‫ دیگری مینویسد‬OutputStream ‫محتوای استریم را در‬ write(OutputStream out)
‫مثال‬
import java.io.*;

{
{
ByteArrayOutputStream baytearrayoutputstream = null;
baytearrayoutputstream = new ByteArrayOutputStream();
try
{
baytearrayoutputstream.write("Hello Java".getBytes());
baytearrayoutputstream.write(" IO".getBytes());
System.out.println(baytearrayoutputstream.toString());
byte[] result = baytearrayoutputstream.toByteArray();
baytearrayoutputstream.close();
}
{
}
}
}
‫در مثال باال ابتدا یک ‪ ByteArrayOutputStream‬ایجاد میکنیم‪ .‬سپس چند بار از متد )(‪ write‬برای نوشتن در آن استفاده‬
‫میکنیم‪ ،‬از آنجایی که متد )(‪ write‬آرایه ای از بایتها را میپذیرد لذا باید رشتهها را با استفاده از متد )(‪ getBytes‬به آرایه‬
‫ای از بایتها تبدیل کنیم‪.‬با استفاده از متد )(‪ toString‬محتوای کل استریم را به دست میآوریم و سپس آن را چاپ میکنیم و‬
‫در انتها کل استریم را به آرایه ای از بایتها )‪ (result‬تبدیل میکنیم (که البته در این مثال از ‪ result‬استفاده خاصی نمیکنیم‬
‫و هدف فقط آشنایی با نحوه استفاده از متد )(‪ toByteArray‬بود)‪.‬‬
‫کالسهای ‪ ObjectInputStream‬و ‪ObjectOutputStream‬‬
‫در این آموزش با کالسهای ‪ ObjectInputStream‬و ‪ ObjectOutputStream‬برای خواندن و نوشتن شیء از فایل آشنا میشویم‪،‬‬
‫از آنجایی که این دو کالس مکمل یکدیگر هستند با هر دوی آنها در یک آموزش آشنا میشویم‪ .‬اگر از ‪ObjectOutputStream‬‬
‫برای نوشتن شیء در فایل استفاده کنیم حتما باید از ‪ ObjectInputStream‬برای خواندن شیء از آن فایل استفاده کنیم و اگر‬
‫قصد استفاده از ‪ ObjectInputStream‬را داشته باشیم باید مطمئن شویم که فایل مورد نظر قبال با ‪ObjectOutputStream‬‬
‫ایجاد شده است‪ ،‬لذا آموزش این دو کالس در دو مبحث جدا ممکن نیست و در این آموزش با هر دو کالس آشنا میشویم‪.‬‬
‫مهمترین کاربرد این دو کالس ذخیره شی و خواندن شیء از فایل است با این حال این دو کالس متدهای کمکی دیگری نیز دارند‬
‫که کار با دادههای مختلف را ساده تر میکنند‪.‬‬
‫کالس ‪ObjectOutputStream‬‬
‫از این کالس برای ذخیره سازی شی در فایل استفاده میشود‪ .‬برای استفاده از این کالس باید از سازنده زیر برای ساخت شیء جدید‬
‫از آن استفاده کنیم‪:‬‬
‫)‪ObjectOutputStream (OutputStream out‬‬
‫متدهای پر کاربرد ‪ ObjectOutputStream‬در جدول زیر آمده است‪:‬‬

‫جریان خروجی را بسته و منابع استفاده شده را آزاد میکند‬ ‫)( ‪close‬‬
‫دادههای بافر شده را به سمت خروجی ارسال میکند‪.‬‬ ‫)(‪flush‬‬
‫یک آرایه از بایتها را در جریان خروجی مینویسد‪.‬‬ ‫)‪write(byte[] b‬‬
‫یک قسمت از یک آرایه از بایتها را در جریان خروجی مینویسد‪.‬‬ ‫)‪write(byte[] b,int offset,int length‬‬
‫یک بایت در جریان خروجی مینویسد‪.‬‬ ‫)‪write(int v‬‬
‫یک مقدار ‪ boolean‬در جریان خروجی مینویسد‪.‬‬ ‫)‪writeBoolean(boolean b‬‬
‫یک بایت هشت بیتی را در جریان خروجی مینویسد‪.‬‬ ‫)‪writeByte(int v‬‬
‫یک رشته را به آرایه ای از بایتها تبدیل کرده و در جریان خروجی‬ ‫)‪writeBytes(String str‬‬
‫یک کاراکتر شانزده بیتی را در جریان خروجی مینویسد‪.‬‬ ‫)‪writeChar(int v‬‬
‫یک مقدار ‪ double‬را در جریان خروجی مینویسد‪.‬‬ ‫)‪writeDouble(double d‬‬
‫یک مقدار ‪ float‬را در جریان خروجی مینویسد‪.‬‬ ‫)‪writeFloat(float f‬‬
‫یک مقدار ‪ int‬را در جریان خروجی مینویسد‪.‬‬ ‫)‪writeInt(int i‬‬
‫یک مقدار ‪ long‬را در جریان خروجی مینویسد‪.‬‬ ‫)‪writeLong(long l‬‬
‫مهمترین متد این کالس است و یک شیء جاوایی را در جریان خروجی‬ ‫)‪writeObject(Object obj‬‬
‫یک مقدار ‪ short‬را در جریان خروجی مینویسد‪.‬‬ ‫)‪writeShort(int v‬‬

‫کالس ‪ObjectInputStream‬‬
‫از این کالس برای خواندن یک شیء از یک جریان ورودی استفاده میشود‪ .‬برای استفاده از این کالس باید از سازنده زیر برای‬
‫ساخت شیء جدید از آن استفاده کنیم‪:‬‬
‫)‪ObjectInputStream (InputStream in‬‬
‫متدهای پر کاربرد ‪ ObjectInputStream‬در جدول زیر آمده است‪:‬‬
‫یک بایت از جریان ورودی میخواند‪.‬‬ ‫)(‪read‬‬
‫یک آرایه از بایتها را از جریان ورودی میخواند‪.‬‬ ‫)‪read(byte[] b‬‬
‫به تعداد ‪ length‬بایت از جریان ورودی میخواند و با شروع از اندیس ‪ offset‬در‬ ‫][‪read(byte‬‬
‫)‪b,offset,length‬‬
‫آرایه ‪ b‬مینویسد‪.‬‬
‫یک مقدار ‪ boolean‬را از جریان ورودی میخواند‪.‬‬ ‫)(‪readBoolean‬‬
‫یک بایت هشت بیتی را از جریان ورودی میخواند‪.‬‬ ‫)(‪readByte‬‬
‫یک کاراکتر از جریان ورودی میخواند‪.‬‬ ‫)(‪readChar‬‬
‫یک مقدار ‪ double‬را از جریان ورودی میخواند‪.‬‬ ‫)(‪readDouble‬‬
‫یک مقدار ‪ float‬را از جریان ورودی میخواند‪..‬‬ ‫)(‪readFloat‬‬
‫یک مقدار را از جریان ورودی میخواند‪.‬‬ ‫)(‪readInt‬‬
‫یک مقدار ‪ long‬را از جریان ورودی میخواند‪.‬‬ ‫)(‪long readLong‬‬
‫مهمترین متد این کالس است و یک شیء جاوایی را از جریان ورودی میخواند‪.‬‬ ‫)(‪readObjec‬‬
.‫ را از جریان ورودی میخواند‬short ‫یک مقدار‬ readShort()
.‫یک رشته متنی را از جریان ورودی میخواند‬ readUTF()
‫نوشتن شیء در فایل‬
‫ ابتدا یک کالس ساده به نام‬.‫در اولین مثال از این بخش یک شیء ساده جاوایی از یک کالس اختصاصی را در فایل مینویسیم‬
:‫ به صورت زیر ایجاد میکنیم‬Person
import java.io.*;
import java.io.Serializable;
class Person implements Serializable

{
String name;
String lastName;
int score;
public Person(String n, String ln, int i)

{
this.name = n;
this.lastName = ln;
this.score = i;
}
@Override
{
return "[" + name + " : " + lastName + " , " + score + "]";
}
}
‫ در کالس باال متد‬،‫ باشند‬Serializable ‫کالسهایی که قسمت داریم اشیایی از آن را در فایل ذخیره کنیم باید حتما از نوع‬
‫ با استفاده از کد زیر یک شیء از این‬.‫ کردیم تا در آینده چاپ هر شی از آن به سادگی صورت گیرد‬override ‫ را‬toString()
:‫کالس ساخته و آن را در فایلی ذخیره میکنیم‬

{
{
Person person = new Person("Jack", "Statham", 15);
File myFile = new File("D:\\Test.obj");

ObjectOutputStream objectoutputstream = null;
try
{
objectoutputstream = new ObjectOutputStream(fileoutputstream);
objectoutputstream.writeObject(person);
objectoutputstream.flush();
objectoutputstream.close();
}
{
}
}
}
‫ چون قصد نوشتن اینشی در یک فایل را داریم‬،)person ‫در کد باال ابتدا یک شیء نمونه از کالس مورد نظر ایجاد میکنیم (شی‬
‫ ایجاد کنیم (شی‬FileOutputStream ‫ ) و سپس از روی آن یک‬myFile‫ ایجاد کرده (شی‬File ‫باید یک نمونه از کالس‬
‫ جدید ایجاد میکنیم (شی‬ObjectOutputStream ‫ یک‬fileoutputstream ‫سپس از روی‬ ،)fileoutputstream
‫ در انتها نیز متدهای‬.‫ شی مورد نظر را در فایل مینویسیم‬writeObject ‫) و در نهایت با استفاده از متد‬objectoutputstream
.‫ را فراخوانی میکنیم‬close() ‫ و‬flush()
‫خواندن شیء از فایل‬
‫ را پاک‬main() ‫ برای اینکار کدهای داخل متد‬.‫اآلن آمادهایم تا شی ای که در مرحله قبل در فایل نوشته شده بود را از فایل بخوانیم‬
:‫کرده و به جای آنها کدهای زیر را می نویسیم‬

ObjectInputStream objectinputstream = null;
try
{
objectinputstream = new ObjectInputStream(fileinputstream);
Person objInFile = (Person)objectinputstream.readObject();
System.out.println(objInFile);
objectinputstream.close();
}
catch (IOException | ClassNotFoundException e)
{
}
‫از آنجایی که قصد خواندن از فایل را داریم باید ابتدا یک نمونه از کالس ‪File‬ایجاد کنیم‪ ،‬سپس یک ‪ FileInputStream‬از‬
‫روی آن ایجاد میکنیم (شی ‪ )fileinputstream‬و بعد از آن یک ‪ ObjectInputStream‬جدید از روی ‪fileinputstream‬‬
‫ایجاد میکنیم (شی ‪ ،)objectinputstream‬در نهایت با استفاده از متد )(‪ readObject‬یک شیء از جریان ورودی میخوانیم‬
‫ولی چون خروجی این متد از نوع کالس ‪ Object‬است باید آن را به کالس مورد نظر ‪ cast‬کنیم‪ .‬در انتها شی خوانده شده را‬
‫چاپ میکنیم و جریان ورودی را میبندیم‪ .‬خروجی کد باال به صورت زیر خواهد بود‪:‬‬
‫]‪[Jack : Statham , 15‬‬
‫نوشتن و خواندن چند شی در فایل‬
‫با استفاده از متد )(‪ writeOjbect‬میتوانیم چندین شی در فایل بنویسیم ولی هنگام خواندن از فایل باید به همان ترتیبی که‬
‫اشیا را در فایل نوشتیم آنها را از فایل بخوانیم‪ .‬برای درک بهتر یک کالس جدید به نام ‪ Book‬به صورت زیر ایجاد میکنیم‪:‬‬
‫;‪import java.io.Serializable‬‬
‫‪class Person implements Serializable‬‬

‫{‬
‫;‪String name‬‬
‫;‪String lastName‬‬
‫‪int‬‬ ‫;‪score‬‬
‫)‪public Person(String n, String ln, int i‬‬

‫{‬
‫;‪this.name = n‬‬
‫;‪this.lastName = ln‬‬
‫;‪this.score = i‬‬
‫}‬
‫)(‪public String toString‬‬
‫{‬
‫;"]" ‪return "[" + name + " : " + lastName + " , " + score +‬‬
‫}‬
‫}‬
‫‪class Book implements Serializable‬‬

‫{‬
‫;‪String title‬‬
‫;‪int pages‬‬
‫)‪public Book(String t, int p‬‬

‫{‬
‫;‪this.title = t‬‬
this.pages = p;
}
@Override
{
return "( " + this.title + " , " + this.pages + " )";
}
}
:‫ کد نوشتن در فایل را به صورت زیر تغییر میدهیم‬.‫ است و به توضیح خاصی نیاز ندارد‬Person ‫کالس فوق مشابه کالس‬

{
{
Person firstperson = new Person("John", "Scith", 15);
Person secondperson = new Person("Jason", "Obimiang", 20);
Book book = new Book("Core Java", 400);

ObjectOutputStream objectoutputstream = null;
try
{
objectoutputstream = new ObjectOutputStream(fileoutputstream);
objectoutputstream.writeObject(firstperson);
objectoutputstream.writeObject(secondperson);
objectoutputstream.writeObject(book);
objectoutputstream.flush();
objectoutputstream.close();
}
{
}
}
}
‫ کد خواندن‬.‫ در فایل نوشتیم‬Book ‫ و یک شیء از کالس‬Person ‫مشابه کد قبلی است با این تفاوت که این بار دوشی از کالس‬
:‫شیء از فایل را به صورت زیر تغییر میدهیم‬

ObjectInputStream objectinputstream = null;
try
{
objectinputstream = new ObjectInputStream(fileinputstream);
Person firstperson = (Person)objectinputstream.readObject();

‫;)(‪Person secondperson = (Person)objectinputstream.readObject‬‬
‫;)(‪Book book = (Book)objectinputstream.readObject‬‬
‫;)‪System.out.println(firstperson‬‬
‫;)‪System.out.println(secondperson‬‬
‫;)‪System.out.println(book‬‬
‫;)(‪objectinputstream.close‬‬
‫}‬
‫)‪catch (IOException | ClassNotFoundException e‬‬
‫{‬
‫}‬
‫این کد نیز بسیار مشابه کد خواندن شیء از فایل قبلی است‪ ،‬تنها نکته مهم این است که اشیا به همان ترتیبی که در فایل نوشته‬
‫شدهاند باید از فایل خوانده شوند‪ .‬خروجی کد باال به صورت زیر خواهد بود‪:‬‬
‫]‪[John : Scith , 15‬‬

‫]‪[Jason : Obimiang , 20‬‬
‫) ‪( Core Java , 400‬‬
‫کالس ‪BufferedReader‬‬
‫همانطور که می دانیم کالسهای ‪ Reader‬برای خواندن از جریان کاراکتری به کار میروند‪ ،‬از آنجایی که خواندن کاراکتر به کاراکتر‬
‫چندان بهینه نیست باید از تکنیک بافر کردن برای بهینه سازی و افزایش سرعت عمل خواندن استفاده کنیم‪ ،‬کالس‬
‫‪ BufferedReader‬با استفاده از تکنیک بافر کردن عمل خواندن را بهبود میبخشد‪ .‬از این کالس میتوان برای خواندن از فایل‪،‬‬
‫خواندن از وروردی سیستم (کنس ول) و یا خواندن از یک حافظه بافر نیز استفاده کرد‪ .‬برای استفاده از این کالس باید از یکی از‬
‫)‪BufferedReader (Reader in‬‬
‫)‪BufferedReader (Reader in,int bufferSize‬‬
‫متدهای پر کاربرد ‪ BufferedReader‬در جدول زیر آمده است‪:‬‬
‫یک کاراکتر از جریان ورودی خوانده و آن را به صورت یک بر میگرداند‪ ،‬در صورتی‬ ‫)(‪read‬‬
‫که به انتهای جریان ورودی رسیده باشیم خروجی این متد مقدار ‪ 3-‬خواهد بود‪.‬‬
‫یک آرایه از کاراکترها را از جریان ورودی میخواند‪.‬‬ ‫)‪read(char[] cbuf‬‬
‫کاراکترها را از جریان ورودی خوانده و در آرایه ‪ cbuf‬ذخیره میکند و تعداد‬ ‫][ ‪read(char‬‬
‫)‪cbuf,offset,length‬‬
‫کاراکترهای خوانده شده را بر میگرداند‪ ،‬در صورتی که کاراکتری برای خواندن وجود‬
‫نداشته باشد خروجی این متد مقدار ‪ 3-‬خواهد بود‪.‬‬
‫‪ :cbuf‬آرایه ای است که کاراکترها در آن بافر میشوند‬
‫‪ :offset‬اندیس شروع نوشتن در آرایه مورد نظر‬
‫‪ :length‬حداکثر کاراکترهایی که باید خوانده شوند‬
‫یک خط از جریان ورودی میخواند‪.‬‬ ‫)(‪String readLine‬‬
‫مشخص میکند که قادر به خواندن از جریان ورودی هستیم یا خیر‪ ،‬خروجی این‬ ‫)( ‪boolean ready‬‬
‫متد به صورت ‪ true‬یا ‪ false‬است‪.‬‬
‫خواندن از فایل با متد )(‪read‬‬
‫در مثال زیر با استفاده از متد )(‪ read‬محتوی یک فایل متنی را کاراکتر به کاراکتر خوانده و چاپ میکنیم‪ ،‬قبل از ادامه یک فایل‬
‫متنی با نام ‪ Test.txt‬در درایو ‪ D‬ایجاد کرده و یک متن دلخواه در داخل آن نوشته و از کدهای زیر برای خواندن آن استفاده‬

‫{‬
‫{‬
‫;‪InputStreamReader inputstreamreader = null‬‬

‫;‪FileInputStream fileinputstream = null‬‬
‫;‪BufferedReader bufferreader = null‬‬
‫‪try‬‬
‫{‬
‫;)‪bufferreader = new BufferedReader(inputstreamreader‬‬
‫;‪int c‬‬
‫)‪while ((c = bufferreader.read()) != -1‬‬
‫{‬
‫;)‪System.out.print((char)c‬‬
‫}‬
‫}‬
‫{‬
‫}‬
‫}‬
‫}‬
‫همانطور که در کد باال مشاهده میکنید ابتدا باید فایلی که قصد خواندن از آن داریم را با یک شیء از کالس ‪ File‬مشخص کنیم‬
‫(شی ‪ myFile‬در مثال باال) سپس با استفاده از ‪ FileInputStream‬فایل مورد نظر را به یک جریان بایتی تبدیل کنیم (شی‬
‫‪ inputstreamreader‬در مثال باال) و سپس جریان بایتی را با استفاده از ‪ InputStreamReader‬به جریان متنی تبدیل میکنیم‬
‫(شی ‪ inputstreamreader‬در مثال باال)‪ ،‬برای بهینه سازی و افزایش سرعت خواندن یک ‪ BufferedReader‬از روی‬
‫‪inputstreamreader‬ایجاد میکنیم‪ .‬در ادامه با استفاده از متد )(‪ read‬کاراکتر به کاراکتر از ‪ bufferreader‬میخوانیم و تا‬
‫زمانی که نتیجه فراخوانی این متد ‪ 3-‬نباشد آن را در خروجی چاپ میکنیم‪ .‬از آنجایی که ممکن است فایل وجود نداشته باشد یا‬
‫در هنگام عملیات خواندن با خطای پیش بینی نشده مواجه شویم باید حتما از بلوک ‪ try-catch‬برای به دام انداختن خطاها‬
‫استفاده کنیم ‪.‬‬
‫خواندن از فایل با کمک یک آرایه‬
‫همانطور که در ابتدا دیدیم متد )(‪ read‬دیگری نیز وجود دارد که از یک آرایه بافر برای خواندن از جریان ورودی استفاده میکند‪،‬‬
‫در بسیاری از کاربردها خواندن کاراکتر به کاراکتر زمان بر بوده و بهتر است با استفاده از یک آرایه بافر عملیات خواندن را تسریع‬
‫بخشیم‪ .‬مثال زیر به شرح این موضوع میپردازد ‪:‬‬

import java.io.*;

{
{
BufferedReader bufferreader = null;
char cbuf[] = new char[200];

int readed;
try
{
inputstreamreader = new InputStreamReader(fileinputstream);
bufferreader = new BufferedReader(inputstreamreader);
readed = bufferreader.read(cbuf, 0, cbuf.length);

{
System.out.print(cbuf[i]);
}
}
{
}
}
}
.‫ تعداد کاراکترهای خوانده شده از فایل را مشخص میکند‬readed ‫ متغیر‬.‫خروجی کد باال مشابه مثال قبلی است‬
readLine ‫خواندن با استفاده از متد‬
. ‫ برای خواندن خط به خط استفاده کنیم‬readLine() ‫کد زیر مشابه کدهای قبلی است با این تفاوت که این بار از متد‬
import java.io.*;

{
{
BufferedReader bufferreader = null;
‫‪try‬‬
‫{‬
‫;)‪bufferreader = new BufferedReader(inputstreamreader‬‬
‫;‪String line‬‬
‫)‪while ((line = bufferreader.readLine()) != null‬‬
‫;)‪System.out.println(line‬‬
‫}‬
‫{‬
‫}‬
‫}‬
‫}‬
‫در کد باال در داخل یک حلقه ‪ while‬تا زمانی که خروجی متد )(‪ readLine‬برابر با ‪ null‬نباشد آن را چاپ میکنیم‪ .‬مهمترین‬
‫دلیل استفاده از ‪ BufferedReader‬این است که دادههای ورودی را در حافظه بافر میکند و سرعت خواندن را به شدت افزایش‬
‫میدهد‪.‬‬
‫کالس ‪BufferedWriter‬‬
‫همانطور که می دانیم کالسهای ‪ Writer‬برای نوشتن استریم های متنی به کار میروند‪ ،‬با استفاده از کالس ‪BufferedWriter‬‬
‫میتوانیم عمل نوشتن را با تکنیک بافر کردن سریعتر سازیم‪ ،‬این کالس ابتدا دادهها را در یک بافر در حافظه اصلی نگه داری میکند‬
‫و پس از هر بار پر شدن بافر آنها را به صورت گروهی و یک جا در جریان خروجی مینویسد که این عمل سرعت نوشتن در جریان‬
‫خروجی را به شدت افزایش میدهد‪ .‬برای استفاده از این کالس باید از یکی از سازندههای زیر برای ساخت شیء جدید از آن‬
‫استفاده کنیم ‪:‬‬
‫)‪BufferedWriter (Writer out‬‬
‫)‪BufferedWriter (Writer out,int bufferSize‬‬
‫متدهای پر کاربرد ‪ BufferedWriter‬در جدول زیر آمده است‪:‬‬
‫جریان خروجی را بسته و منابع استفاده شده را آزاد میکند‬ close ()
.‫دادههای بافر شده در حافظه را در استریم خروجی ارسال میکند‬ flush()
.‫ را در استریم خروجی مینویسد‬c ‫کاراکتر‬ voir write(char c)
.‫آرایه ای از کاراکترها را در استریم خروجی مینویسد‬ write(char[] cbuf)
lenght ‫ به تعداد‬offset ‫ را با شروع از اندیس‬cbuf ‫قسمتی از آرایه‬ write(char[] cbuf,offset,length)
.‫کاراکتر در استریم خروجی مینویسد‬
‫مشابه متد قبلی است با این تفاوت که به جای آرایه ای از کاراکترها از یک‬ write(String str,offset,length)
.‫ استفاده میکند‬String
.‫یک رشته متنی را در استریم خروجی مینویسد‬ write(String s)
.‫یک جدا کننده خطوط در استریم خروجی مینویسد‬ newLine()
. ‫ ذخیره میکند‬Test.txt ‫ در فایل‬UTF-8 ‫مثال زیر یک متن آزمایشی را با فرمت‬
import java.io.*;

{
{
try
{
FileOutputStream fileoutputstream = new FileOutputStream(myFile);
OutputStreamWriter outputstreamwriter = new OutputStreamWriter(fileoutputstream, "UTF-8");
BufferedWriter bufferedwriter = new BufferedWriter(outputstreamwriter);
bufferedwriter.write("Hello BufferedWriter");
bufferedwriter.newLine();
bufferedwriter.write("Second Line");
bufferedwriter.newLine();
bufferedwriter.write("Third Line");
‫;)(‪bufferedwriter.flush‬‬
‫;)(‪bufferedwriter.close‬‬
‫}‬
‫{‬
‫}‬
‫}‬
‫}‬
‫در مثال باال ابتدا یک شیء از کالس ‪ File‬ایجاد میکنیم و سپس با استفاده از ‪ FileOutputStream‬یک جریان خروجی‬
‫)‪ (fileoutputstream‬بر روی آن ایجاد میکنیم‪ ،‬سپس یک ‪ OutputStreamWriter‬از روی ‪ fileoutputstream‬ایجاد‬
‫میکنیم تا بتوانیم به صورت کاراکتری بر روی جریان خروجی بنویسیم (شی ‪ ،)outputstreamwriter‬در نهایت از روی‬
‫‪ outputstreamwriter‬یک ‪ BufferedWriter‬ایجاد میکنیم تا مطمئن شویم عمل نوشتن با سرعت زیادی انجام میشود‪ ،‬در‬
‫ادامه کد با استفاده از متدهای )(‪ write‬و )(‪ newLine‬بر روی ‪ bufferedwriter‬مینویسم‪.‬‬
‫مهمترین دلیل استفاده از ‪ BufferedWriter‬این است که قبل از نوشتن اطالعات بر روی جریان خروجی آنها را در حافظه اصلی‬
‫)‪ (RAM‬بافر میکند و دادهها را به صورت گروهی در جریان خروجی مینویسد که این عمل سرعتن نوشتن را به شدت افزایش‬
‫میدهد ‪.‬‬
‫کالس ‪StringReader‬‬
‫می دانیم که کالسهای ‪ Reader‬برای خواندن کاراکتر از استریم های کاراکتری به کار میروند ولی همیشه منبع استریم فایل‪،‬‬
‫منبعی در شبکه یا کنسول سیستم نیست گاهی نیاز داریم تا از یک رشته متنی از نوع ‪ String‬به عنوان یک استریم استفاده کنیم‪،‬‬
‫در چنین شرایطی میتوانیم از کالس ‪ StringReader‬استفاده کنیم‪ .‬برای استفاده از این کالس باید از سازنده زیر برای ساخت‬
‫شیء جدید از آن استفاده کنیم ‪:‬‬
‫)‪StringReader (String s‬‬
‫متدهای پر کاربرد ‪ StringReader‬در جدول زیر آمده است‪:‬‬
‫یک کاراکتر از جریان ورودی خوانده و آن را به صورت یک ‪ int‬بر‬ ‫)(‪read‬‬
‫میگرداند‪ ،‬در صورتی که به انتهای جریان ورودی رسیده باشیم خروجی‬
‫این متد مقدار ‪ 3-‬خواهد بود‪.‬‬
‫کاراکترها را از جریان ورودی خوانده و در آرایه ‪ cbuf‬ذخیره میکند و‬ ‫‪read(char [] cbuf,int offset,int‬‬
‫)‪length‬‬
‫تعداد کاراکترهای خوانده شده را بر میگرداند‪ ،‬در صورتی که کاراکتری‬
‫برای خواندن وجود نداشته باشد خروجی این متد مقدار ‪ 3-‬خواهد بود‪.‬‬
‫‪ :cbuf‬آرایه ای است که کاراکترها در آن بافر میشوند‬
‫‪ :offset‬اندیس شروع نوشتن در آرایه مورد نظر‬
‫‪ :length‬حداکثر کاراکترهایی که باید خوانده شوند‬
‫یک آرایه از کاراکترها را از جریان ورودی میخواند‪.‬‬ ‫)‪read(char[] cbuf‬‬
‫مشخص میکند که قادر به خواندن از جریان ورودی هستیم یا خیر‪،‬‬ ‫)( ‪ready‬‬
‫خروجی این متد به صورت ‪ true‬یا ‪ false‬است‪.‬‬
‫از ‪ ns‬کاراکتر بعدی در استریم صرف نظر میکند‪.‬‬ ‫)‪skip(long ns‬‬
‫در مثال زیر با استفاده از متد )(‪ read‬محتوی یک رشته متنی را کاراکتر به کاراکتر خوانده و چاپ میکنیم ‪.‬‬

‫{‬
‫{‬
‫;"!‪String data = "Hello String Reader‬‬
‫;)‪StringReader sr = new StringReader(data‬‬
‫;‪int c‬‬
‫‪try‬‬
‫{‬
‫)‪while ((c = sr.read()) != -1‬‬
‫{‬
‫;)‪System.out.print((char)c‬‬
‫}‬
‫}‬
‫{‬
‫}‬
‫}‬
‫}‬
‫ابتدا از روی رشته متنی ‪ data‬یک ‪ StringReader‬جدید ایجاد میکنیم‪ ،‬سپس در داخل یک حلقه ‪ while‬با استفاده از متد‬
‫)(‪ read‬یک کاراکتر خوانده و آن را در متغیر ‪ c‬ذخیره میکنیم‪ ،‬اگر مقدار این متغیر برابر با ‪ -3‬نباشد آن را در خروجی چاپ‬
‫میکنیم‪.‬‬
‫کالس ‪StringWriter‬‬
‫کالس ‪ StringWriter‬یک استریم در حافظه اصلی )‪ (RAM‬در اختیار ما قرار میدهد که میتوانیم بر روی آن بنویسیم و در نهایت‬
‫استریم مورد نظر را به رشته متنی تبدیل کنیم‪ ،‬معموال زمانی از این کالس استفاده میشود که ما از تعداد عملیات نوشتن در زمان‬
‫کامپایل آگاه نیستیم ‪ .‬این کالس معموال به عنوان یک ابزار کمکی در کنار کالسهای دیگر استفاده میشود‪ .‬برای استفاده از این‬
‫کالس باید از سازنده زیر برای ساخت شیء جدید از آن استفاده کنیم ‪:‬‬
‫)( ‪StringWriter‬‬
‫متدهای پر کاربرد ‪ StringWriter‬در جدول زیر آمده است‪:‬‬
‫دادههای بافر شده در حافظه را در استریم خروجی ارسال‬ ‫)(‪flush‬‬
‫کاراکتر ‪ c‬را در استریم خروجی مینویسد‪.‬‬ ‫)‪write(char c‬‬
‫قسمتی از آرایه ‪ cbuf‬را با شروع از اندیس ‪ offset‬به‬ ‫)‪write(char[] cbuf,int offset,int length‬‬
‫تعداد ‪ lenght‬کاراکتر در استریم خروجی مینویسد‪.‬‬

‫مشابه متد قبلی است با این تفاوت که به جای آرایه ای از‬ write(String str,int offset,int length)
.‫ استفاده میکند‬String‫کاراکترها از یک‬
.‫آرایه ای از کاراکترها در استریم خروجی مینویسد‬ write(char[] cbuf)
.‫ را در استریم خروجی مینویسد‬s ‫رشته متنی‬ write(String s)
‫مهمترین متد این کالس است و معموال در پایان کار استفاده‬ toString()
‫ تبدیل‬String ‫ این متد کل محتوای استریم را به‬،‫میشود‬
.‫میکند‬
‫ این است که چندین رشته متنی مختلف را در آن بنویسیم و در نهایت یک رشته متنی واحد‬StringWriter ‫متداولترین کاربرد‬
: ‫ مثال زیر به شرح این موضوع میپردازد‬،‫از روی آنها ایجاد کنیم‬
import java.io.*;

{
{
StringWriter stringwriter = new StringWriter();
try
{
stringwriter.write("Hello \n");
stringwriter.write("Java \n");
stringwriter.write("IO\n");
String result = stringwriter.toString();

stringwriter.close();
}
catch (Exception e)
{
}
}
}
Hello
Java
IO
‫ را به یک رشته‬stringwriter ‫ در نهایت‬،‫ ایجاد میکنیم و چند خط در آن مینویسیم‬StringWriter ‫در کد باال ابتدا یک‬
‫ استفاده‬Reader ‫ قبال دیدیم که برای خواندن استریم متنی از فایل باید از کالسهای‬.‫( تبدیل و چاپ میکنیم‬result) ‫متنی‬
‫ محتوای یک فایل متنی را میخوانیم‬StringWriter ‫ و به کمک‬FileInputStream ‫کنیم ولی در مثال زیر تنها با استفاده از کالس‬
. ‫و چاپ میکنیم‬
import java.io.*;

{
{

StringWriter stringwriter = new StringWriter();
try
{
int c;
while ((c = fileinputstream.read()) != -1)
{
stringwriter.write(c);
}
fileinputstream.close();
System.out.println(stringwriter.toString());
stringwriter.close();
}
catch (Exception e)
{
}
}
}
FileInputStream ‫ برای خواندن هر نوع جریانی از این فایل به یک‬،‫ ایجاد میکنیم‬File ‫در کد باال ابتدا یک شیء از کالس‬
fileinputstream ‫ کاراکتر به کاراکتر از‬while ‫ در ادامه در داخل یک حلقه‬،)fileinputstream ‫نیاز خواهیم داشت (شی‬
‫ در نهایت با‬،‫ مینویسیم‬stringwriter ‫ آن را در‬write ‫ نبود با استفاده از متد‬-3 ‫میخوانیم و اگر مقدار خوانده شده برابر با‬
.‫ را به رشته متنی تبدیل میکنیم و سپس آن را چاپ میکنیم‬stringwriter‫ محتوای‬toString() ‫فراخوانی متد‬
‫کالس ‪PrintWriter‬‬
‫کالس ‪ PrintWriter‬کالسی کمکی است که امکانات زیادی را در اختیار ما قرار میدهد و به ما اجازه میدهد به صورت مستقیم‬
‫بر روی فایل یا خروجی کنسول سیستم یا هر جریان خروجی دیگری کار کنیم‪ ،‬به عالوه این کالس از کالسهای بهینه سازی شده‬
‫است و سرعت فوق العاده ای دارد‪ .‬برای استفاده از این کالس باید از یکی از سازندههای زیر برای ساخت شیء جدید از آن استفاده‬
‫کنیم ‪:‬‬
‫)‪PrintWriter (File file‬‬
‫)‪PrintWriter(File file,String charsetName‬‬
‫)‪PrintWriter(OutputStream out‬‬
‫)‪PrintWriter(OutputStream out,boolean autoFlush‬‬
‫)‪PrintWriter(String fileName‬‬
‫)‪PrintWriter(String fileName,String charset‬‬
‫)‪PrintWriter(Writer out‬‬
‫)‪PrintWriter(Writer out,boolean autoFlush‬‬
‫متدهای پر کاربرد ‪ PrintWriter‬در جدول زیر آمده است‪:‬‬
‫دادههای بافر شده در حافظه را در استریم خروجی ارسال‬ ‫)(‪flush‬‬
‫یک مقدار ‪ boolean‬را در استریم خروجی مینویسد‪.‬‬ ‫)‪print(boolean b‬‬
‫یک کاراکتر را در جریان خروجی مینویسد‪.‬‬ ‫)‪print(char c‬‬
‫یک آرایه از کاراکترها را در جریان خروجی مینویسد‪.‬‬ ‫)‪print(char[] str‬‬
‫یک مقدار ‪ double‬را در جریان خروجی مینویسد‪.‬‬ ‫)‪print(double d‬‬

‫یک مقدار ‪ float‬را در جریان خروجی مینویسد‪.‬‬ ‫)‪print(float f‬‬
‫یک مقدار ‪ int‬را در جریان خروجی مینویسد‪.‬‬ ‫)‪print(int i‬‬
‫یک مقدار ‪ long‬را در جریان خروجی مینویسد‪.‬‬ ‫)‪print(long l‬‬
‫یک شیء را در جریان خروجی مینویسد‪.‬‬ ‫)‪print(Object o‬‬
‫یک رشته متنی را در جریان خروجی مینویسد‪.‬‬ ‫)‪print(String s‬‬
‫برای قالب بندی خروجی استفاده میشود‪.‬‬ ‫)‪PrintWriter format(String format,Object..o‬‬
‫یک جدا کننده خط جدید در جریان خروجی مینویسد‪.‬‬ ‫)(‪println‬‬
‫یک مقدار ‪ boolean‬را در استریم خروجی مینویسد‪.‬‬ ‫)‪println(boolean b‬‬
‫یک کاراکتر را در جریان خروجی مینویسد‪.‬‬ ‫)‪println(char c‬‬
‫یک آرایه از کاراکترها را در جریان خروجی مینویسد‪.‬‬ ‫)‪println(char[] str‬‬
‫یک مقدار ‪ double‬را در جریان خروجی مینویسد‪.‬‬ ‫)‪println(double d‬‬
‫یک مقدار ‪ float‬را در جریان خروجی مینویسد‪.‬‬ ‫)‪println(float f‬‬
‫یک مقدار ‪ int‬را در جریان خروجی مینویسد‪.‬‬ ‫)‪println(int i‬‬
‫یک مقدار ‪ long‬را در جریان خروجی مینویسد‪.‬‬ ‫)‪println(long l‬‬
‫یک شیء را در جریان خروجی مینویسد‪.‬‬ ‫)‪println(Object o‬‬
‫یک رشته متنی را در جریان خروجی مینویسد‪.‬‬ ‫)‪println(String s‬‬
‫یک کاراکتر را در جریان خروجی مینویسد‪.‬‬ ‫)‪write(char c‬‬
‫آرایه ای از کاراکترها در جریان خروجی مینویسد‪.‬‬ ‫)‪write(char[] cbuf‬‬

.‫قسمتی از یک آرایه را در جریان خروجی مینویسد‬ write(char[] cbuf,int offset,int length)
.‫یک رشته متنی را در جریان خروجی مینویسد‬ write(String s)
.‫قسمتی از یک رشته متنی را در جریان خروجی مینویسد‬ write(String s,int offset,int length)
‫ خروجی شبکه‬،‫ این قالب بندی میتواند بر روی فایل خروجی‬،‫ میتوان برای قالب بندی خروجی استفاده کرد‬PrintWriter ‫از‬
. ‫ برای قالب بندی را نشان میدهد‬printf() ‫ مثال زیر نحوه استفاده از متد‬،‫یا حتی خروجی کنسول سیستم باشد‬
import java.io.*;

{
{
PrintWriter printwriter = new PrintWriter(System.out, true);
printwriter.printf("Hello %5d\n", 7);

}
}
Hello 7
Hello 77
Hello 777
Hello 7777
Hello 77777
n ‫ مشخص میکند که میخواهیم به اندازه‬%nd ،‫ مشخص میکنیم که قصد داریم یک عدد صحیح را چاپ کنیم‬%d ‫با استفاده از‬
. ‫ اعداد دیگری را نیز امتحان کنید‬1 ‫در مثال باال به جای مقدار‬.‫کاراکتر فاصله ایجاد کنیم‬
import java.io.*;

{
{
PrintWriter printwriter = new PrintWriter(System.out, true);
printwriter.printf("Hello %.3f\n", 5.87878787);

}
}
‫‪Hello 5.879‬‬
‫در مثال باال ‪ %f‬مشخص میکند که قصد چاپ کردن یک مقدار ممیز شناور را داریم‪ %.3f ،‬مشخص میکند که قصد داریم تا سه‬
‫رقم بعد از اعشار را چاپ کنیم‪ ،‬دقت کنید که ارقام گرد میشوند‪ .‬در مثال زیر از ‪ PrintWriter‬برای نوشتن در فایل استفاده‬
‫میکنیم ‪.‬‬

‫{‬
‫{‬
‫;‪PrintWriter printwriter = null‬‬
‫‪try‬‬
‫{‬
‫;)"‪printwriter = new PrintWriter(myFile, "UTF-8‬‬
‫;)"‪printwriter.println("Hello‬‬
‫;)"‪printwriter.println("Java‬‬
‫;)"‪printwriter.println("IO‬‬
‫;)(‪printwriter.flush‬‬
‫;)(‪printwriter.close‬‬
‫}‬
‫{‬
‫}‬
‫}‬
‫}‬
‫در مثال باال چون قصد نوشتن در یک فایل را داریم ابتدا یک شیء از کالس ‪ File‬ایجاد میکنیم‪ ،‬سپس از روی آن یک‬
‫‪ PrintWriter‬ایجاد میکنیم و در پارامتر دوم مشخص میکنیم که قصد داریم با فرمت ‪ UTF-8‬در فایل بنویسیم‪ ،‬در ادامه با‬
‫استفاده از متد )(‪ println‬سه خط در فایل مینویسیم و در انتها ‪ printwriter‬را میبندیم‪.‬‬
‫زبان نشانه گذاری توسعه پذیر )‪(XML‬‬

‫زبان نشانه گذاری توسعه پذیر )‪ (XML‬به شما اجازه میدهد که دادهها را در یک متن و قالب ساخت یافته ذخیره کنید‪ .‬این زبان‬
‫به طور گسترده به عنوان یک دیتابیس جای گزین و برای ذخیره اطالعات مربوط به پیکربندی نرم افزارها به کار میرود‪ XML .‬از لحاظ‬
‫دستوری شبیه به ‪ HTML‬بوده و اگر با ‪ HTML‬آشنایی داشته باشید یادگیری این زبان برایتان راحت تر است‪ .‬در زیر یک سند ‪XML‬‬
‫را مشاهده میکنید ‪:‬‬
‫>‪<Persons‬‬
‫>‪<Person‬‬
‫>‪<Name>John Smith</Name‬‬
‫>‪<Age>30</Age‬‬
‫>‪<Gender>Male</Gender‬‬
‫>‪</Person‬‬
‫>‪<Name>Mike Folly</Name‬‬
‫>‪<Age>25</Age‬‬
‫>‪<Name>Lisa Carter</Name‬‬
‫>‪<Age>22</Age‬‬
‫>‪<Gender>Female</Gender‬‬
‫>‪</Persons‬‬
‫سند ‪ XML‬ترکیبی از عناصر ‪ XML‬میباشد‪ .‬یک عنصر ‪ XML‬شامل یک تگ آغازی‪ ،‬یک تگ پایانی و داده ای است که در بین این‬
‫دو تگ قرار میگیرد ‪.‬‬
‫>‪<open>data</close‬‬
‫میتوان بر اساس داده ای که یک عنصر ‪ XML‬در خود نگهداری میکند یک نام برای عنصر انتخاب کرد‪ .‬به این نکته توجه کنید که‬
‫عناصر به حروف بزرگ و کوچک حساساند‪ ،‬بنابراین دو کلمه ‪ person‬و ‪ Person‬با هم متفاوتاند‪ XML .‬فضاهای خالی را نادیده‬
‫میگیرد‪ ،‬بنابراین به جای نوشتن یک فایل در یک خط میتوانید آن را در چند خط بنویسید تا خوانایی آن باالتر رود‪ .‬بین عناصر‬
‫‪ XML‬ممکن است رابطه پدر‪ -‬فرزندی وجود داشته باشد‬
‫>‪<parent‬‬
‫>‪<child1>data</child1‬‬
‫>‪<child2‬‬
‫>‪<grandchild1>data</grandchild1‬‬
‫>‪</child2‬‬
‫>‪</parent‬‬
‫سند ‪ XML‬باال دارای اطالعاتی برای سه شخص میباشد‪ .‬هر سند ‪ XML‬باید دارای یک عنصر ریشه )‪ (root‬باشد‪ .‬در مثال اول‬
‫این درس‪ ،‬عنصر ‪ ،Persons‬عنصر ریشه (پدر) و دیگر عناصر داخل آن در حکم فرزندان آن میباشند‪ .‬جزییات هر شخص در داخل‬
‫عنصر ‪ Person‬قرار دارند‪ .‬عناصر فرزند عنصر ‪ Person‬عبارتاند از ‪ Age ،Name‬و ‪ .Gender‬صفات ‪ ،XML‬روشی دیگر برای اضافه‬
‫کردن داده به یک عنصر میباشند‪.‬‬

‫>‪<Person name="John Smith">some data</Person‬‬
‫عنصر باال یک خاصیت به نام ‪ name‬دارد که مقدار آن ‪ John Smith‬میباشد‪ .‬مقادیر باید در داخل کوتیشن (‘ ‘) یا دابل کوتیشن‬
‫(“ “) قرار بگیرند‪ .‬در زیر روش اضافه کردن صفات نشان داده شده است‪.‬‬
‫>‪<element att1="value1" att2="value2" ... attN="valueN">data</element‬‬
‫همانطور که مشاهده میکنید‪ ،‬میتوان به یک عنصر چندین صفت اضافه کرد‪.‬‬
‫>‪<Person name="John Smith" age="30" gender="Male">some data</Person‬‬
‫اجازه دهید که به عناصر مثال ابتدای درس صفاتی اضافه کنیم‪.‬‬
‫>"‪<Person name="John Smith‬‬
‫>‪<Age>30</Age‬‬
‫>"‪<Person name="Mike Folly‬‬
‫>‪<Age>25</Age‬‬
‫>"‪<Person name="Lisa Carter‬‬
‫>‪<Age>22</Age‬‬
‫عنصر ‪ Name‬هر شخص )‪ (person‬را حذف و صفت معادل آن )‪ (name‬را برای هر عنصر مینویسیم‪ .‬اسناد ‪ XML‬میتوانند‬
‫دارای یک تعریف ‪ XML‬باشند‪ .‬تعریف ‪ XML‬شامل اطالعاتی درباره سند ‪ XML‬مانند نسخه (همیشه نسخه ‪ 3.3‬پیشنهاد میشود) و‬
‫نوع رمزگذاری )‪ (encode‬متن آن میباشد ‪.‬‬
‫>? "‪<?xml version="1.0" encoding="UTF-8‬‬
‫این تعریف در باالترین بخش سند و درست قبل از عنصر اصلی نوشته میشود‪ .‬برای فایل ‪ XML‬میتوان توضیحات نیز نوشت‪.‬‬
‫نحوه نوشتن توضیحات در ‪ XML‬به صورت زیر است‪.‬‬
‫>‪<!-- This is an XML comment --‬‬
‫میتوان با استفاده از یک ویرایشگر متن ساده فایلهای ‪ XML‬تولید کرد‪.‬‬

‫مدیریت فایلهای ‪XML‬‬
‫برای خواندن و نوشتن فایلهای ‪ XML‬در جاوا روشها و کتابخانههای تو کار و خارجی زیادی وجود دارند که با استفاده از آنها‬
‫میتوانیم فایلهای ‪ XML‬را بخوانیم‪ ،‬ایجاد کنیم و یا تحت پرس و جو قرار دهیم‪ ،‬به صورت کلی روشهای تجزیه فایلهای ‪XML‬‬
‫در جاوا را میتوان به دو دسته زیر تقسیم کرد‪:‬‬
‫روشهای مبتنی بر درخت تجزیه‬ ‫‪‬‬
‫روشهای مبتنی بر استریم‬ ‫‪‬‬
‫قبل از اینکه با این دو روش آشنا شویم باید با مفهوم تجزیه )‪ (parsing‬آشنا شویم‪.‬‬
‫تجزیه )‪ (Parsing‬فایلهای‪XML‬‬
‫به روشی گفته میشود که در طی آن در داخل یک فایل یا استریم مبتنی بر ‪ XML‬حرکت میکنیم و به المانها‪ ،‬ویژگیها و صفتهای‬
‫عناصر ‪ xml‬دسترسی پیدا میکنیم و میتوانیم با آنها به صورت اشیای قابل استفاده در جاوا رفتار کنیم‪.‬‬
‫تجزیه گر)‪(Parser‬‬
‫تجزیه گر )‪ (Parser‬ابزاری است که عمل تجزیه را انجام میدهد‪ ،‬این ابزار میتواند بر اساس الگوریتمهای استریمی یا الگوریتمهای‬
‫مبتنی بر درخت تجزیه پیاده سازی شود‪ ،‬از تجزیه گرهای مبتنی بر درخت تجزیه میتوان به ‪ DOM Parser‬و از تجزیه گرهای مبتنی‬
‫بر استریم میتوان به ‪ SAX Parser‬اشاره کرد‪.‬کتابخانههای دیگری همچون ‪ StAX ،JDOM‬و ‪ DOM4J‬نیز تجزیه گرهای دیگری‬
‫هستند که میتوان از آنها نام برد‪ .‬دو راهکار اصلی تجزیه و تحلیل فایلهای ‪ xml‬در جاوا عبارتاند از‪:‬‬
‫راهکار مبتنی بر‪DOM‬‬ ‫‪‬‬
‫راهکار مبتنی بر‪SAX‬‬ ‫‪‬‬

‫راهکار مبتنی بر ‪DOM‬‬
‫در این روش درخت تجزیه بر اساس ‪ Document Object Model‬یا انحصارا ‪ DOM‬که از پیشنهادات ‪ W3C‬است ساخته میشود‪،‬‬
‫درخت تجزیه ساختمان داده ای پیچیده ای است که عناصر فایل ‪ xml‬را به صورت درختی مبتنی بر ‪ DOM‬نگه داری میکند‪.‬‬
‫در این روش یک بار کل محتوای ‪ XML‬خوانده میشود و سپس ‪ Parser‬آن را به یک درخت (درخت تجزیه) تبدیل میکند‪ ،‬بعد‬
‫از آن میتوانیم با دسترسی به گرههای این درخت فایل ‪ XML‬مورد نظر را بخوانیم‪ ،‬در هنگام استفاده از این روش باید به نکات زیر‬
‫دقت کنیم‪:‬‬
‫در این روش یک بار محتوای فایل ‪ XML‬به صورت کامل خوانده میشود لذا تنها برای مواردی قابل استفاده است که‬ ‫‪‬‬
‫محتوای ‪ XML‬را به صورت کامل در اختیار داریم (مثال فایل) و برای مواردی که داده به مرور زمان قابل تغییر باشد قابل‬
‫استفاده نیست (مثال یک استریم قابل تغییر آنالین)‬
‫در این روش کل فایل یک بار از ابتدا تا انتها خوانده میشود لذا برای مواردی که حجم فایل بزرگ باشد مفید نیست‪.‬‬ ‫‪‬‬
‫در این روش یک درخت تجزیه ساخته شده و این درخت در حافظه اصلی )‪ (RAM‬قرار میگیرد که حجم آن ممکن است‬ ‫‪‬‬
‫زیاد باشد لذا ممکن است مصرف حافظه زیادی داشته باشد‪.‬‬
‫مرحله خواندن و تجزیه اولیه در این روش کند است‪.‬‬ ‫‪‬‬
‫پس از ساخت درخت تجزیه به دلیل استفاده از ساختار درختی دسترسی به عناصر ‪ XML‬با سرعت باالیی صورت میگیرد‪.‬‬ ‫‪‬‬
‫راهکار مبتنی بر ‪SAX‬‬
‫این راهکار یک راهکار استریمی است و معموال سریعتر از راهکار قبلی است‪ ،‬در این روش درخت تجزیه ساخته نمیشود و در نتیجه‬
‫مصرف حافظه کمتری دارد‪ ،‬این روش برای مواردی که استریم به مرور زمان بزرگتر میشود قابل استفاده است در هنگام استفاده‬
‫از این روش باید به موارد زیر دقت کنیم‪:‬‬
‫این روش هم با فایل و هم استریم های قابل تغییر سازگار است‪.‬‬ ‫‪‬‬
‫برای مواردی که حجم فایل بزرگ باشد قابل استفاده است‪.‬‬ ‫‪‬‬
‫نسبت به ‪ DOM‬مصرف حافظه کمتر ی دارد‪.‬‬ ‫‪‬‬

‫مرحله خواندن و تجزیه اولیه در این روش سریعتر است‪.‬‬ ‫‪‬‬
‫در این روش دستری به صورت باال به پایین است و از حالت ‪ Random Access‬پشتیبانی نمیکند و اگر قصد داشته‬ ‫‪‬‬
‫باشیم چندین بار به گرههایی خاص دسترسی داشته باشیم مفید نیست‪.‬‬
‫نکته ‪ :‬به صورت کلی ‪ SAX Parser‬از ‪ DOM Parser‬سریعتر است و تنها در مواردی که دسترسی محلی زیادی داشته باشیم از‬
‫‪ DOM Parser‬به جای ‪ SAX Parser‬استفاده میکنیم‪.‬‬
‫خواندن فایلهای ‪ XML‬با ‪DOM Parser‬‬
‫در این آموزش با خواندن فایلهای ‪ XML‬با روش مبتنی بر ‪ DOM‬آشنا میشویم‪ .‬قبل از هر کار یک فایل ‪ xml‬جدید به نام‬
‫‪ sample.xml‬در درایو ‪ D‬ایجاد میکنیم و محتوای زیر را در آن مینویسیم ‪:‬‬
‫>? "‪<?xml version="1.0" encoding="utf-8‬‬

‫>‪<Age>30</Age‬‬
‫>"‪<Person name="Mike Folley‬‬
‫>‪<Age>25</Age‬‬
‫>"‪<Person name="Lisa Carter‬‬
‫>‪<Age>22</Age‬‬
‫>"‪<Person name="Jerry Frost‬‬
‫>‪<Age>27</Age‬‬
‫>"‪<Person name="Adam Wong‬‬
‫>‪<Age>35</Age‬‬
‫این فایل یک فایل ‪ xml‬ساده است که تگ ریشه آن ‪ Persons‬است‪ .‬در داخل این تگ یک تگ ‪ Person‬و در داخل این تک‬
‫نیز دو تگ ‪ Age‬و ‪ Gender‬قرار دارند‪ .‬با استفاده از کد زیر محتوای این فایل را میخوانیم و خروجی مناسب را برای آن ایجاد‬
‫میکنیم ‪:‬‬

‫‪2‬‬
3 import java.io.*;
4 import org.w3c.dom.*;
5 import javax.xml.parsers.*;
6
8 {
9 static void printNode(Node n)
10 {
11 System.out.println("-----------------------");
12 Element e = (Element)n;
13
14 // Name
15 System.out.println(n.getNodeName() + " Name = " + e.getAttribute("name"));
16 // Age
17 String Age = e.getElementsByTagName("Age").item(0).getTextContent();
18 System.out.println(n.getNodeName() + " Age: " + Age);
19 // Gender
20 String Gender = e.getElementsByTagName("Gender").item(0).getTextContent();
21 System.out.println(n.getNodeName() + " Gender: " + Gender);
22 }
23 public static void main(String[] args) throws Exception
24 {
25 File myXMLFile = new File("D:\\sample.xml");
26 DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
27
28 DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
29
30 Document doc = dBuilder.parse(myXMLFile);
31
32 String rootName = doc.getDocumentElement().getNodeName();
33
34 System.out.println(rootName);
35
36 NodeList list = doc.getElementsByTagName("Person");
37 int listSize = list.getLength();
38 System.out.println(listSize);
39
40 for (int i = 0;i < listSize; i++)
41 {
42 Node nodeI = list.item(i);
43 printNode(nodeI);
44 }
45 }
46 }
Persons
5
-----------------------
Person name: John Smith
Person Age: 30
Person Gender: Male
-----------------------
Person name: Mike Folley
Person Age: 25
Person Gender: Male
-----------------------
Person name: Lisa Carter
Person Age: 22
Person Gender: Female
-----------------------
Person name: Jerry Frost
Person Age: 27
Person Gender: Male
‫‪-----------------------‬‬
‫‪Person name: Adam Wong‬‬
‫‪Person Age: 35‬‬
‫‪Person Gender: Male‬‬
‫در ادامه با بخش بخش کد باال آشنا میشویم‪ .‬قبل از هر کار باید ابزارهای مورد نیاز برای کار با ‪ ،xml‬تجزیه گر مبتنی بر ‪ dom‬و‬
‫کتابخانه ‪ io‬را ‪ import‬کنیم(خطوط ‪ .)1-1‬در داخل تابع ‪ main‬که نقطه شروع برنامه است یک شیء از کالس فایل ایجاد میکنیم‬
‫و به فایلی که قصد خواندن از آن را داریم اشاره میکنیم(خط ‪ .)51‬در خطوط ‪ 51-13‬یک ‪ Document‬ایجاد میکنیم که همان درخت‬
‫تجزیه مورد نظر ماست‪ .‬دقت کنید که شی ‪ myXMLFile‬پارامتر ورودی متد )(‪ parse‬است‪ .‬در خط ‪ 15‬گره ریشه )‪ (root‬را به‬
‫دست میآوریم‪ .‬متد )(‪ getDocumentElement‬به گره ‪ Person‬دسترسی پیدا میکند‪ ،‬با استفاده از متد )(‪ getNodeName‬نام‬
‫آن (یعنی عبارت ”‪ )“Person‬استخراج میشود‪ .‬سپس در خط ‪ 11‬لیست تمام گرههایی که از نوع ‪ Person‬هستند را به دست‬
‫میآوریم‪.‬‬
‫متد )(‪ getElementsByTagName‬لیستی از تمام تگها را بر اساس نامی که به آن ارسال میکنیم ب صورت یک لیست به ما‬
‫میدهد‪ .‬کالس ‪ NodeList‬یک لیست برای نگه داری ‪ Node‬هاست‪ .‬با استفاده از متد )(‪ getLength‬میتوانیم اندازه این لیست‬
‫را به دست بیاوریم‪ ،‬خطوط ‪ 11-10‬تعداد تگهای ‪ Person‬را چاپ میکند‪ .‬با استفاده از یک حلقه ‪ for‬میتوانیم به آیتمهای‬
‫داخل ‪ list‬دسترسی پیدا میکنیم و آن را در یک شیء از کالس ‪ Node‬نگه داری کنیم(خطوط ‪ .)33-33‬خط ‪ 35‬هر آیتم از ‪list‬‬
‫را در یک شیء از نوع ‪ Node‬ریخته و سپس در خط ‪ 31‬متد )(‪ printNode‬را بر روی آن فراخوانی میکنیم‪ .‬متد )(‪printNode‬‬
‫متدی است که خودمان آن را نوشتهایم(‪ ،)6-55‬در داخل این متد ابتد یک خط به عنوان جدا کننده چاپ میکنیم و سپسشی از‬
‫نوع ‪ Node‬را به شی ای از نوع ‪ Element‬تبدیل میکنیم(خطوط ‪ .)33-35‬می دانیم که تگ ‪ Person‬در فایل مورد نظر دارای صفتی‬
‫به نام ‪ name‬است‪ ،‬با استفاده از متد )(‪ getAttribute‬میتوانیم به این صفت دسترسی داشته باشیم‪ .‬خط ‪ 31‬نام ‪Element‬‬
‫و مقدار ‪ name‬آن را چاپ میکند‪ .‬با استفاده از متد )(‪ getElementsByTagName‬میتوانیم تمام تگهای داخلی را بر اساس‬
‫نامشان لیست کنیم‪ .‬با استفاده از متد )(‪ item‬میتوانیم مشخص کنیم که قصد داریم به کدام مورد دسترسی پیدا کنیم (اندیس‬
‫صفر اولین گره‪ ،‬اندیس یک دومین گره و …)‪ .‬پس از دسترسی به یک گره با استفاده از متد )(‪ getTextContent‬میتوانیم‬
‫محتوای متنی داخل گره را چاپ کنیم‪.‬‬

SAX Parser ‫ با‬XML ‫خواندن فایلهای‬
‫ جدید به نام‬xml ‫ قبل از هر کار یک فایل‬.‫ آشنا میشویم‬SAX ‫ با روش مبتنی بر‬XML ‫در این آموزش با خواندن فایلهای‬
: ‫ ایجاد میکنیم و محتوای زیر را در آن مینویسیم‬D ‫ در درایو‬sample.xml
<?xml version="1.0" encoding="utf-8" ?>

<Persons>
<Person name="John Smith">
<Age>30</Age>
<Gender>Male</Gender>
</Person>
<Person name="Mike Folley">
<Age>25</Age>
</Person>
<Person name="Lisa Carter">
<Age>22</Age>
<Gender>Female</Gender>
</Person>
<Person name="Jerry Frost">
<Age>27</Age>
</Person>
<Person name="Adam Wong">
<Age>35</Age>
</Person>
</Persons>
‫ و در داخل این تک‬Person ‫ در داخل این تگ یک تگ‬.‫ است‬Persons ‫ ساده است که تگ ریشه آن‬xml ‫این فایل یک فایل‬
‫ اگرچه سریعتر است ولی برای خواندن درست نیاز داریم که یک‬SAX ‫ روش مبتنی بر‬.‫ قرار دارند‬Gender ‫ و‬Age ‫نیز دو تگ‬
‫ ایجاد میکنیم و کد زیر را در‬MyHandler ‫ برای این کار یک کالس جدید به نام‬،‫ برای تعبیر تگها و المانها ایجاد کنیم‬Handler
: )6-31 ‫آن مینویسیم (خطوط‬
2
3 import org.xml.sax.Attributes;
4 import org.xml.sax.SAXException;
5 import org.xml.sax.helpers.DefaultHandler;
6
8 import javax.xml.parsers.SAXParser;
9 import javax.xml.parsers.SAXParserFactory;
10
11 class MyHandler extends DefaultHandler
12 {
13 boolean Age = false;
14 boolean Gender = false;
15
16 @Override
17 public void startElement(String uri, String localName, String qName, Attributes attr)
18 throws SAXException
19 {
20 if (qName.equalsIgnoreCase("Person"))
21 {
22 System.out.println("Person Name: " + attr.getValue("name"));
23 }
24 else if (qName.equalsIgnoreCase("Age"))
25 {
26 Age = true;
27 }
28 else if (qName.equalsIgnoreCase("Gender"))
29 {
30 Gender = true;
31 }
32 }
33
34 @Override
35 public void characters(char[] ch, int start, int length) throws SAXException
36 {
37 if (Age)
38 {
39 System.out.println("Person Age: " + new String(ch, start, length));
40 }
41 else if (Gender)
42 {
43 System.out.println("Person Gender: " + new String(ch, start, length));
44 System.out.println("----------------");
45 }
46
47 Age = false;
48 Gender = false;
49 }
50 }
51
53 {
55 {
56 File myXMLFile = new File("D:/sample.xml");
57
58 SAXParserFactory sFactory = SAXParserFactory.newInstance();
59
60 SAXParser saxParser = sFactory.newSAXParser();
61
62 MyHandler mHandler = new MyHandler();
63
64 saxParser.parse(myXMLFile, mHandler);
65 }
66 }
Person Name: John Smith

Person Age: 30
Person Gender: Male
----------------
Person Name: Mike Folley
Person Age: 25
Person Gender: Male
----------------
Person Name: Lisa Carter
Person Age: 22
----------------
Person Name: Jerry Frost

‫‪----------------‬‬
‫‪Person Name: Adam Wong‬‬
‫‪----------------‬‬
‫کالس ‪ MyHandler‬زیر کالس ‪ DefaultHander‬است و برای کار بار آن باید حداقل دو متد )(‪ startElement‬و‬
‫)(‪ characters‬را ‪ override‬کنیم‪ .‬در هنگام تجزیه استریمی از این هندلر استفاده شده و در هر زمان که عمل تجزیه به یک تگ‬
‫آغازین میرسد متد )(‪ startElement‬فراخوانی میشود و ه ر گاه که تجزیه گر وارد قسمتهای متنی داخل یک تگ (مثال ‪Male‬‬
‫در تگ ‪ )Gender‬میشود متد )(‪ characters‬فراخوانی میشود‪ .‬پس با توجه به موارد فوق متدهای )(‪ startElement‬و‬
‫)(‪ characters‬را به صورتی که در کد باال مشاهده میکنید‪ ،‬پیاده سازی میکنیم(خطوط ‪.)31-36‬‬
‫در داخل متد )(‪ startElement‬با استفاده از پارامتر ‪ qName‬میتوانیم نام گره را مشخص کنیم‪ ،‬اگر نام گره ‪ person‬بود مقدار‬
‫صفت ‪ id‬را چاپ میکنیم‪ ،‬پارامتر ‪ attr‬در هر گره صفتهای گره را نگه داری میکند که با فراخوانی متد )(‪ getValue‬بر روی‬
‫آن میتوانیم به یک صفت خاص دسترسی پیدا کنیم‪ ،‬در خط زیر به صفت ‪ id‬دسترسی پیدا میکنیم و مقدار آن را چاپ میکنیم‪.‬‬
‫اگر تگی که وارد آن میشویم ‪ Person‬نباشد یکی از دو ‪ if‬بعدی ممکن است اجرا شوند‪:‬‬
‫اگر نام تگ ‪ Age‬باشد مقدار بولی ‪ Age‬را برابر ‪ true‬قرار میدهیم‪.‬‬ ‫‪‬‬
‫اگر نام تگ ‪ Gender‬باشد مقدار بولی ‪ Gender‬را برابر ‪ true‬قرار میدهیم‪.‬‬ ‫‪‬‬
‫می دانیم که متد )(‪ character‬بعد از متد )(‪ startElement‬فراخوانی میشود‪ ،‬زیرا ابتدا یک تگ باز میشود‪ ،‬متن در داخل‬
‫آن قرار میگیرد و سپس تگ بسته میشود مثل >‪ .<Gender>Male</Gender‬پس هنگامی که وارد متد )(‪ character‬میشویم‪.‬‬
‫تنها یکی از موارد ‪ Age‬یا ‪ Gender‬میتواند برابر با ‪ true‬باشد‪ .‬با استفاده از ساختار شرطی خطوط ‪ 11-31‬مورد برابر با ‪true‬‬
‫را پیدا میکنیم و متن داخل آن را چاپ میکنیم‪.‬‬
‫نکته ‪ :‬در این پارامتر رشته مورد نظر به صورت یک آرایه از کاراکترها قرار دارد برای چاپ متن باید یک شیء جدید از ‪String‬‬
‫ایجاد کنیم و آرایه مورد نظر را به همراه پارامترهای ‪ start‬و ‪ length‬به آن ارسال کنیم ‪.‬‬
‫ می دانیم که با رسیدن به تگ آغازین بعدی‬.)30 ‫ و‬31 ‫ قرار میدهیم (خطوط‬false ‫در پایان تمام متغیرهای بولی را برابر با‬
‫ مان آماده است میتوانیم‬Handler ‫ حال که‬.‫ فراخوانی میشود و مجددا موارد فوق تکرار میشود‬startElement() ‫مجددا متد‬
‫ ایجاد میکنیم و فایل و‬SAXParser ‫ یک‬،‫ در این خطوط‬.)11-13 ‫ را بنویسیم (خطوط‬xml ‫کد الزم برای خواندن و تجزیه فایل‬
.‫ مابقی کارها به عهده تجزیه گر خواهد بود‬،‫هندلر مورد نظر را به آن میدهیم‬
‫ دشوار‬Handler ‫ دارای ساختار پیچده ای باشد و تگهای تو در توی زیادی داشته باشیم نوشتن‬xml ‫ در صورتی که فایل‬: ‫نکته‬
.‫ بهینه تر و کم خطا تر است‬Dom Parser ‫ در چنین موارد استفاده از‬،‫میشود و احتمال خطا افزایش مییابد‬
DOM ‫ با روش مبتنی بر‬XML ‫ساخت‬
‫ ساده ای به صورت زیر را با کد‬xml ‫در این آموزش قصد داریم فایل‬.‫ آشنا میشویم‬DOM ‫ مبتنی بر‬XML ‫در این آموزش با ساخت‬
: ‫جاوایی ایجاد کنیم‬

<Persons>
<Age>30</Age>
</Person>
</Persons>
: ‫ ایجاد کنیم‬sample.xml ‫با استفاده از کد زیر میتوانیم این ساختار را در فایلی به نام‬
2
5 import javax.xml.transform.*;
6 import javax.xml.transform.dom.DOMSource;
7 import javax.xml.transform.stream.StreamResult;
9
11 {
13 throws TransformerException, ParserConfigurationException
14 {
15 File myFile = new File("D:\\sample.xml");
16
19
20 Document doc = dBuilder.newDocument();
21
22 //Persons Root
23 Element Persons = doc.createElement("Persons");

24 doc.appendChild(Persons);
25
26 //Person Node
27 Element Person = doc.createElement("Person");
28 Persons.appendChild(Person);
29
30 //Set attribute for Person
31 Attr attr = doc.createAttribute("name");
32 attr.setValue("John Smith");
33 Person.setAttributeNode(attr);
34
35 // Age Node
36 Element Age = doc.createElement("Age");
37 Age.appendChild(doc.createTextNode("30"));
38 Person.appendChild(Age);
39
40 //Gender Node
41 Element Gender = doc.createElement("Gender");
42 Gender.appendChild(doc.createTextNode("Male"));
43 Person.appendChild(Gender);
44
45 //write to file
46 TransformerFactory tFactory = TransformerFactory.newInstance();
47 Transformer transformer = tFactory.newTransformer();
48
49 DOMSource source = new DOMSource(doc);
50 StreamResult result = new StreamResult(myFile);
51
52 //transform
53 transformer.transform(source, result);
54 }
55 }
31 ‫ سپس در خط‬.)1-0 ‫ میکنیم(خطوط‬import ‫ ابتدا ابزارهای مورد نیاز را‬.‫در ادامه با بخشهای مختلف کد باال آشنا میشویم‬
‫ با استفاده از متد‬.‫ خالی ایجاد میکنیم‬Document ‫ یک‬31 ‫در خط‬.‫فایلی که قصد نوشتن در آن را داریم مشخص میکنیم‬
‫ اضافه‬doc ‫ آن را به‬appendChild() ‫ ایجاد میکنیم و با استفاده از متد‬Persons ‫ یک المان جدید به نام‬createElement()
‫ ایجاد‬Person ‫ در ادامه گره دیگری به نام‬.)51-53 ‫ خالی است المان جدید همان گره ریشه خواهد بود(خطوط‬doc ‫ چون‬،‫میکنیم‬
Persons ‫ را بر روی شی‬appendChild() ‫ باشد لذا این بار متد‬Persons ‫ گره‬،‫ باید زیر گره‬Person ‫ می دانیم که گره‬،‫میکنیم‬
‫ همانطور که مشاهده میکنید‬.‫ میرسد‬Gender ‫ و‬Age ‫ یعنی‬Person ‫ حال نوبت به ایجاد زیر گرههای‬.)51 ‫فراخوانی میکنیم(خط‬
‫ یک مقدار متنی بین این دو تگ ایجاد‬createTextNode() ‫ ابتدا با استفاده از متد‬.‫ شبیه هم هستند‬33-31 ‫ و‬11-10 ‫خطوط‬
‫ اگر‬.‫ آنها را به صورت زیر گره این گره در میآوریم‬،Person ‫ را بر روی شی‬appendChild() ‫میکنیم و سپس با فراخوانی متد‬
‫ تنها کاری که‬.‫ به صورت ابتدای درس ایجاد شده است‬XML ‫ بروید مشاده میکنید که یک فایل‬D ‫برنامه را اجرا کرده و به درایو‬
‫ یک‬doc ‫ از روی‬،‫ استفاده میکنیم‬Transformer ‫ برای این کار از کالس‬.‫باقی مانده است ذخیره ساختار فوق در یک فایل است‬
‫شیء از کالس ‪ DOMSource‬ایجاد میکنیم و از روی فایلی که قصد نوشتن در آن را داریم نیز شی ای از کالس ‪StreamReslut‬‬
‫ایجاد میکنیم‪.‬‬
‫اشیای ‪ source‬و ‪ result‬را به متد ‪ transform‬ارسال میکنیم و کار تمام میشود‪ .‬حال اگر مثال زیر گره ‪ Age‬دارای خاصیتی‬
‫به نام ‪ age‬و مقدار ‪ Young‬باشد‪ ،‬کدهای ‪ 11-10‬را پاک کرده و کدهای زیر را جایگزین نمایید ‪:‬‬
‫;)"‪Element Age = doc.createElement("Age‬‬

‫;)"‪Attr attr1 = doc.createAttribute("age‬‬
‫;)"‪attr1.setValue("Young‬‬
‫;)‪Age.setAttributeNode(attr1‬‬
‫;))"‪Age.appendChild(doc.createTextNode("30‬‬
‫;)‪Person.appendChild(Age‬‬
‫همانطور که در کد باال مشاهده میکنید‪ ،‬با استفاده از متد )(‪ createAttribute‬خاصیت را ایجاد کرده‪ ،‬با استفاده از متد‬
‫)(‪ setValue‬یک مقدار به آن اختصاص داده و در نهایت با استفاده از متد )(‪ setAttributeNode‬آن را به گره مورد نظر‬
‫اختصاص میدهیم‪ .‬حال دوباره برنامه را اجرا و نتیجه را مشاهده کنید‪.‬‬
‫ساخت ‪ XML‬با روش مبتنی بر ‪Stream‬‬
‫در این آموزش با ساخت ‪ XML‬مبتنی بر استریم آشنا میشویم‪ .‬این روش نسبت به روش مبتنی بر ‪ DOM‬سریع تر و ساده تر است‪،‬‬
‫به عالوه نوشتن تگها و بستن آنها در کد جاوایی با ساختار ‪ xml‬مطابقت بیشتر ی دارد‪ .‬در این آموزش قصد داریم فایل ‪xml‬‬
‫ساده ای به صورت زیر را با کد جاوایی ایجاد کنیم ‪:‬‬
‫>? "‪<?xml version="1.0" encoding="utf-8‬‬

‫>‪<Age>30</Age‬‬
‫با استفاده از کد زیر میتوانیم این ساختار را در فایلی به نام ‪ sample.xml‬ایجاد کنیم‪:‬‬

‫‪2‬‬
‫‪3‬‬ ‫;*‪import java.io.‬‬
‫‪4‬‬ ‫;*‪import javax.xml.stream.‬‬
5
7 {
9 {
10 File myFile = new File("D:\\sample.xml");
11 try (FileOutputStream fos = new FileOutputStream(myFile))
12 {
13 XMLOutputFactory xmlOFactory = XMLOutputFactory.newInstance();
14 XMLStreamWriter xmlSWriter = xmlOFactory.createXMLStreamWriter(fos, "UTF-8");
15
16 xmlSWriter.writeStartDocument("UTF-8", "1.0");
17
18 xmlSWriter.writeStartElement("Persons");
19 xmlSWriter.writeStartElement("Person");
20 xmlSWriter.writeAttribute("name", "John Smith");
21
22 xmlSWriter.writeStartElement("Age");
23 xmlSWriter.writeCharacters("30");
24 xmlSWriter.writeEndElement();
25
26 xmlSWriter.writeStartElement("Gender");
27 xmlSWriter.writeCharacters("Male");
29
32
33 xmlSWriter.writeEndDocument();
34
35 xmlSWriter.flush();
36 xmlSWriter.close();
37 }
38 }
39 }
‫ در این روش به ابزارهای زیادی‬،‫ میکنیم‬import ‫ ابتدا ابزارهای مورد نیاز را‬.‫در ادامه با بخشهای مختلف کد باال آشنا میشویم‬
‫ برای نوشتن با این روش نیاز‬.‫ فایلی که قصد نوشتن در آن را داریم مشخص میکنیم‬33 ‫ با استفاده از خط‬.)1-3 ‫نیاز نداریم(خطوط‬
33 ‫ برای همین در خط‬،‫ استفاده کنیم‬FileOutputStream ‫ چون قصد ما نوشتن در فایل باید از‬،‫به یک استریم خواهیم داشت‬
‫ ایجاد میکنیم که همانطور که از نام آن پیداست‬XMLStreamWriter ‫ یک‬33 ‫ و‬31 ‫ با استفاده از خطوط‬.‫ را تعریف کردهایم‬fos
‫ را مشخص‬XML ‫ ابتدای فایل‬writeStartDocument() ‫ با استفاده از متد‬.‫ را بر روی یک استریم خروجی مینویسد‬XML ‫محتوای‬
‫ را فراخوانی کنیم تا مطمئن شویم فایل به درستی بسته‬writeEndDocument() ‫ متناظر با این متد در انتهای کار باید متد‬،‫میکنیم‬
‫ به عنوان مثال خط زیر تگ‬.)30(‫ استفاده میکنیم‬writeStartElement() ‫ برای نوشتن یک تگ آغازین از متد‬.)11 ‫میشود(خط‬
‫ استفاده میکنیم‬writeEndElement() ‫ در هر زمان که نیاز به بستن یک تگ داشتیم از متد‬.‫< را ایجاد میکند‬Person> ‫آغازین‬
‫ به سادگی میتوانیم به تگ مورد‬writeAttribute() ‫ پس از باز کردن یک تگ با استفاده از متد‬.‫و تگ مورد نظر بسته میشود‬
‫ را با‬name ‫ صفت‬53 ‫ به عنوان مثال در خط‬.‫ پارامتر اول نام صفت و پارامتر دوم مقدار صفت است‬،‫نظر صفت جدید اضافه کنیم‬
‫به تگ ‪ Person‬اضافه کردهایم‪ .‬برای نوشتن مقدار متنی داخل یک تگ به سادگی از متد‬ ‫‪John‬‬ ‫‪Smith‬‬ ‫مقدار‬
‫)(‪ writeCharacters‬استفاده میکنیم‪ ،‬به عنوان مثال در خط ‪ 51‬و ‪ 51‬مقادیر ‪ 13‬و ‪ Male‬را در بخش متن تگهای ‪ Age‬و‬
‫‪ Gender‬نوشتهایم‪ .‬در انتها برای اینکه مطمئن شویم استریم خروجی در فایل نوشته شده است متد )(‪ flush‬را فراخوانی میکنیم‬
‫و سپس استریم های مربوطه را با فراخوانی متد )(‪ close‬میبندیم‪.‬‬
‫پرس و جوی محتوای ‪ XML‬با ‪XPath‬‬
‫‪ XPath‬پیشنهاد رسمی ‪ W3C‬برای پرس و جو و جست و جو در محتوای ‪ XML‬است‪ ،‬در حقیقت ‪ XPath‬استانداری است که زبانی‬
‫را در اختیار ما قرار میدهد که با استفاده از آن میتوانیم المانها و صفتها مختلف یک فایل ‪ XML‬را مورد بررسی قرار دهیم‪XPath .‬‬
‫دارای ویژگیها و امکانات زیر است‪:‬‬
‫برای قسمتهای مختلف یک فایل ‪ XML‬مانند المانها‪ ،‬صفتها‪ ،‬متنها‪ ،‬توضیحات و غیره ساختارهای مناسب را در‬ ‫‪‬‬
‫اختیار ما قرار میدهد‪.‬‬
‫با استفاده از ‪ Path Expression‬این امکان را به ما میدهد که گره یا گرههایی که دارای شط خاصی هستند را به‬ ‫‪‬‬
‫سادگی انتخاب کنیم‪.‬‬
‫کتابخانه استاندار و کاملی را در اختیار ما قرار میدهد که از طریق قادر به کار کردن با انواع داده ای مختلف همچون اعداد‪،‬‬ ‫‪‬‬
‫تاریخ‪ ،‬رشتهها و غیره خواهیم بود‪ ،‬به عالوه توابع استانداری برای تغییر و یا مقایسه نیز در اختیار ما قرار میدهد‪.‬‬
‫‪ XPath‬از مهمترین استانداردهای ‪ XSLT‬است و یادگیری ‪ XSLT‬نیازمند یادگیری ‪ XPath‬نیز میباشد‪.‬‬ ‫‪‬‬
‫‪ Predicate‬که از ویژگیهای ‪ Path Expression‬است به ما امکان میدهد تا از بین لیست گرهها فقط گرههای‬ ‫‪‬‬
‫خاص را انتخاب کنیم‪.‬‬
‫‪ XPath‬استاندار پیشنهادی ‪ W3C‬است‪.‬‬ ‫‪‬‬

‫‪Path Expression‬‬
‫‪ Path Expression‬عبارت متنی است که به ما اجازه میدهد گره یا گرههایی را از داخل یک محتوای ‪ XML‬استخراج کنیم‪ ،‬جدول‬
‫زیر عبارات مهم و کاربردی ‪ Path Expression‬را نشان میدهد‪.‬‬
‫عملکرد‬ ‫عبارت‬
‫به کار بردن نام گره باعث میشود تا تمام گرههای با نام مورد نظر انتخاب شوند‪.‬‬ ‫‪node-name‬‬
‫مشخص می کند که انتخاب و جست و جو از ابتدای فایل صورت گیرد‪.‬‬ ‫‪/‬‬
‫تمام گرهها صرف نظر از مکان آنها انتخاب میشوند‪.‬‬ ‫‪//‬‬
‫گره فعلی را انتخاب میکند‪.‬‬ ‫‪.‬‬
‫پدر گره فعلی را انتخاب میکند‪.‬‬ ‫‪..‬‬
‫برای انتخاب بر حسب صفت به کار میرود‪.‬‬ ‫@‬
‫‪Predicates‬‬
‫پس از ساخت یک لیست توسط ‪ Path Expression‬با استفاده از ‪ Predicate‬میتوانیم گره یا گرههای خاصی را انتخاب‬
‫میکنیم‪ Predicate ،‬با عبارت ]‪ [...‬مشخص میشود که به جای … میتوانیم از توابع استاندارد‪ ،‬اندیس یا عبارات پیچیده تر‬
‫برای انتخاب گرههای خاص استفاده کنیم‪ ،‬در ادامه با مثال با این موضوع آشنا میشویم‪:‬‬
‫عملکرد‬ ‫عبارت‬
‫اولین گره ‪ student‬که زیر گره ‪ class‬باشد را انتخاب میکند‪.‬‬ ‫]‪/class/student[1‬‬
‫سومین گره ‪ student‬که زیر گره ‪ class‬باشد را انتخاب میکند‪.‬‬ ‫]‪/class/student[3‬‬
‫آخرین گره ‪ student‬که زیر گره ‪ class‬باشد را انتخاب میکند‪.‬‬ ‫])(‪/class/student[last‬‬

‫گره ماقبل آخر را با شرایط قبلی انتخاب میکند‪.‬‬ ‫]‪/class/student[last()-1‬‬
‫تمام گرههای ‪ student‬که دارای ‪ sid‬برابر با ‪ 111‬هستند را انتخاب میکند‪.‬‬ ‫]’‪//student[@sid=’333‬‬
‫تمام گرههای ‪ student‬زیر گره ‪ class‬که اندیس آنها از ‪ 1‬کمتر است را انتخاب‬ ‫]‪/class/student[position()<3‬‬
‫میکند (یعنی دو گره ابتدایی انتخاب میشوند‪ ).‬در اینجا اندیس از یک شروع‬
‫استفاده از ‪XPath‬‬
‫خوشبختانه در جاوا با استفاده از کتابخانههای توکار میتوانیم به سادگی از امکانات ‪ XPath‬استفاده کنیم‪ ،‬به صورت کلی استفاده‬
‫از ‪ XPath‬شامل مراحل زیر است‪:‬‬
‫کتابخانههای مورد نیاز را ‪ import‬کنیم که معموال موارد زیر کافی هستند‪:‬‬ ‫‪.3‬‬
‫‪import‬‬ ‫;*‪org.w3c.dom.‬‬
‫‪import‬‬ ‫;*‪org.xml.sax.‬‬
‫‪import‬‬ ‫;*‪javax.xml.parsers.‬‬
‫‪import‬‬ ‫;*‪javax.xml.xpath.‬‬
‫‪import‬‬ ‫;*‪java.io.‬‬
‫برای خواندن از فایل یک ‪ DocumentBuilder‬ایجاد کنیم‪:‬‬ ‫‪.5‬‬
‫;)(‪DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance‬‬

‫;)(‪DocumentBuilder builder = factory.newDocumentBuilder‬‬
‫‪ .1‬یک ‪ Document‬ایجاد کنیم و محتوای ‪ XML‬را از یک فایل یا استریم بخوانیم‬
‫;)‪Document doc = builder.parse(input‬‬
‫یک شیء از کالس ‪ XPath‬ایجاد کنیم‪:‬‬ ‫‪.3‬‬
‫;)(‪XPath xPath = XPathFactory.newInstance().newXPath‬‬
‫‪ Path Expression‬مورد نظر را ساخته و آن را با متد )(‪ compile‬کامپایل کنیم‪.‬‬ ‫‪.1‬‬
‫;)‪XPathExpression expr = xPath.compile(XPATH_EXPRESSION_STRING‬‬
‫با استفاده از متد )(‪ evaluate‬نتیجه مورد نظر را محاسبه کنیم‪.‬‬ ‫‪.1‬‬
NodeList nodeList = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
sample.xml ‫ به نام‬XML ‫ قبل از ادامه یک فایل‬.‫در ادامه با استفاده از چند مثال به صورت عملی با موارد فوق آشنا میشویم‬
: ‫ ذخیره میکنیم‬D ‫ایجاد میکنیم و محتوای زیر را در آن مینویسیم و در درایو‬

<Persons>
<Age>30</Age>
</Person>
<Person name="Mike Folley">
<Age>25</Age>
</Person>
<Person name="Lisa Carter">
<Age>22</Age>
<Gender>Female</Gender>
</Person>
<Person name="Jerry Frost">
<Age>27</Age>
</Person>
<Person name="Adam Wong">
<Age>35</Age>
</Person>
</Persons>
: ‫ است به صورت زیر عمل میکنیم‬John Smith ‫ آن برابری‬Name ‫برای انتخاب گره ای از فایل باال که خاصیت‬
2
5 import javax.xml.xpath.*;
6 import java.io.*;
7
9 {
10 static void printNode(Node n)
11 {
12 System.out.println("------");
13 Element e = (Element)n;
14
15 //Parent Node
16 System.out.println(n.getNodeName() + " Name: " + e.getAttribute(" Name"));
17
18 //Age
19 String Age = e.getElementsByTagName("Age").item(0).getTextContent();
20 System.out.println("Person Age: " + Age);
21
22 //Gender
23 String Gender = e.getElementsByTagName("Gender").item(0).getTextContent();
24 System.out.println("Person Gender: " + Gender);
25 }
26

28 {
29 String XPATH_EXPRESSION_STRING = "//Person[@name='John Smith']";
30
31 File myXMLFile = new File("D:/sample.xml");
32
35
36 Document doc = dBuilder.parse(myXMLFile);
37
38 XPath xPath = XPathFactory.newInstance().newXPath();
39 XPathExpression expr = xPath.compile(XPATH_EXPRESSION_STRING);
40
41 NodeList list = (NodeList)expr.evaluate(doc, XPathConstants.NODESET);
42
43 int listSize = list.getLength();
44 System.out.println(listSize);
45 for (int i = 0; i<listSize; i++)
46 {
47 Node nodeI = list.item(i);
48 printNode(nodeI);
49 }
50 }
51 }
1
------
Person Age: 30
Person Gender: Male
‫ کد باال را به‬56 ‫ کافی است که خط‬،‫( باشد‬Female) ‫( در آنها زن‬Gender) ‫ که جنسیت‬Person ‫برای انتخاب گرههای از نوع‬
: ‫صورت زیر تغییر دهیم‬
String XPATH_EXPRESSION_STRING = "//Person[Gender='Female']";
1
------
Person Name: Lisa Carter
Person Age: 22
‫ کد باال را به صورت زیر‬50 ‫ کافی است که خط‬،‫ سال باشد‬51 ‫( آنها بیشتر از‬Age) ‫ که سن‬Person ‫برای انتخاب گرههای از نوع‬
:‫تغییر دهیم‬
String XPATH_EXPRESSION_STRING = "//Person[Age > 25]";
3
------
Person Age: 30
Person Gender: Male
------
Person Name: Jerry Frost
Person Age: 27
Person Gender: Male
------
Person Name: Adam Wong
Person Age: 35
Person Gender: Male
‫فصل چهارم‬
‫کار با بانک اطالعاتی‬

‫‪ MYSQL‬چیست؟‬
‫بیشتر برنامههای امروزی از روشهای مختلفی برای ذخیره سازی دادهها استفاده میکنند‪ .‬یک برنامه میتواند دارای انواع مختلفی‬
‫از منابع داده مانند فایل ‪ text‬و فایل ‪ XML‬و همچنین یک ‪ database‬باشد‪ .‬از ‪Database‬ها معموال برای ذخیره انواع داده‬
‫مانند نام‪ ،‬آدرس‪ ،‬سن‪ ،‬جنس و شغل یک شخص‪ ،‬آهنگ‪ ،‬تصویر و بسیاری چیزهای دیگر استفاده میشود‪ .‬یک دیتابیس مجموعه‬
‫ای است از انواع مختلف دادههای ساخت یافته در داخل جداولی که شامل فیلدها و رکوردها میباشند‪ .‬بیشتر برنامههای امروزی‬
‫از دیتابیس برای ذخیره اطالعات استفاده میکنند‪ .‬دیتابیسهای رابطه ای شامل دادههای هستند که به صورت سازمان یافته با‬
‫همدیگر در ارتباط هستند‪ .‬این نوع دیتا بیس ها شامل یک یا چند جدول به هم پیوسته هستند‪ .‬جداول شامل سطر و ستون‬
‫هستند‪ .‬در دیتابیسها یک سطر نشان دهنده یک رکورد است‪ .‬به عنوان مثال در یک دیتابیس که شامل رکوردهای کارمند است‪،‬‬
‫یک سطر نشان دهنده یک رکورد از یک کارمند است‪ .‬ستون نشان دهنده فیلدها یا خواص و صفت میباشد‪ .‬به عنوان مثال یک‬
‫کارمند دارای یک فیلد مثال ‪( FirstName‬نام) و یک فیلد ‪( LastName‬نام خانوادگی) و یک فیلد ‪( Age‬سن) است‪ .‬میتوانید‬
‫بین چندین جدول ارتباط برقرار کنید‪ .‬به عنوان مثال یک جدول کارمند میتواند دارای یک فیلد به نام ‪City_ID‬باشد‪.‬سپس جدول‬
‫دیگر به نام ‪ Cities‬میتواند شامل فیلدهای ‪ City_ID‬و ‪ CityName‬باشد‪ .‬شما میتوانید بین این دو جدول ارتباط برقرار کنید‪.‬‬
‫‪ MYSQL‬یکی از استانداردترین راههای برقراری ارتباط با دیتابیس میباشد‪ .‬این زبان دارای دستوراتی است که شما به وسیله آنها‬
‫میتوانید دادههای دیتابیس را بروز کرده‪ ،‬بازیابی‪ ،‬اضافه و حذف کنید‪ .‬همچنین به شما اجازه ایجاد و تغییر دیتابیس و جداول و‬
‫ایجاد ارتباط بین جداول مختلف را میدهد‪ Database Management Systems .‬یا ‪ DBMS‬مانند ‪ MYSQL‬به شما اجازه دسترسی‬
‫سریع به دادههای دیتابیس را میدهد و شامل ابزارهای مختلفی برای پرس و جو‪ ،‬ایجاد‪ ،‬حذف و آپدیت دیتابیس میباشد‪ .‬بیشتر‬
‫‪ DBMS‬ها یک محیط گرافیکی جهت انجام امور مختلف برای شما فراهم میآورند‪ .‬مثالهایی از ‪ DBMS‬عبارتاند از ‪Oracle ،Access‬‬
‫و ‪ MYSQL .SQL SERVER‬توسط شرکت اوراکل توسعه‪ ،‬توزیع‪ ،‬و پشتیبانی میشود‪.‬‬
‫از آنجاییکه در این سری آموزشی میخواهیم در مورد نحوه ارتباط با بانک اطالعاتی ‪ MYSQL‬در زبان جاوا و انجام عملیات مختلف‬
‫از جمله ثبت و حذف و ویرایش و … بر روی دادههای آن‪ ،‬بحث کنیم‪ ،‬پس در درس بعد مباحث مقدماتی این زبان را به شما آموزش‬
‫میدهیم ‪.‬‬
‫‪131‬‬ ‫کار با بانک اطالعاتی‬
‫مبانی ‪MYSQL‬‬
‫قبل از اینکه اقدام به دسترسی و تغییر دیتابیسها کنید الزم است در مورد مبانی ‪ MYSQL‬اطالعاتی داشته باشید‪ .‬از این زبان برای‬
‫پرس و جو در دیتابیس استفاده میشود‪.‬درک ‪ MYSQL‬بسیار ساده و آسان است‪ .‬از ‪ MYSQL‬تنها برای پرس و جوی داده استفاده‬
‫نمیشود‪ ،‬بلکه تقریبا از آن برای انجام هر کاری مثال ایجاد‪ ،‬بروزرسانی و حذف دیتابیس و جداول استفاده میشود‪ MYSQL .‬همانند‬
‫سایر زبانهای برنامه نویسی دارای انواعی از دادههاست که به سه نوع متنی‪ ،‬عددی و تاریخی تقسیم میشوند و لیست آنها در‬
‫جدول زیر نمایش داده شده است‪:‬‬
‫داده‬ ‫توضیح‬ ‫نوع‬
‫‪INT‬‬ ‫داده عددی معمول که میتواند با نشانه یا بدون نشانه باشد (مثبت یا منفی) ‪ .‬اگر از نوع نشانه دار‬ ‫عددی‬
‫باشد محدوده مجاز اعداد بین ‪ 5331301130-‬تا ‪ 5331301131‬میباشد‪ ،‬اگر بدون نشانه باشد‬
‫محدوده مجاز اعداد از ‪ 3‬تا ‪ 3563611561‬میباشد ‪ .‬میتوانید تعداد ارقام اعداد را تا ‪ 33‬عدد مشخص‬
‫کنید‪.‬‬
‫‪TINYINT‬‬ ‫عدد صحیح خیلی کوچک که می تواند نشانه دار یا بدون نشانه (مثبت یا منفی) باشد ‪ .‬اگر نشانه‬ ‫عددی‬
‫دارد باشد محدوده مجاز اعداد بین ‪ 350-‬تا ‪ 351‬میباشد ‪ .‬اما اگر بدون نشانه باشد محدوده مجاز‬
‫اعداد بین ‪ 3‬تا ‪ 511‬میباشد ‪ .‬میتوانید تعداد ارقام را تا ‪ 3‬رقم مشخص کنید‪.‬‬
‫‪SMALLINT‬‬ ‫عدد صحیح کوچک می تواند نشانه دار یا بدون نشانه باشد ‪ .‬اگر نشانه دار باشد محدوده مجاز‬ ‫عددی‬
‫اعداد بین ‪ 15110-‬تا ‪ 15111‬میباشد‪ .‬اگر بدون نشانه باشد محدوده مجاز اعداد بین ‪ 3‬تا ‪11111‬‬
‫میباشد‪ .‬میتوانید تعداد ارقام را تا ‪ 1‬رقم مشخص کنید‪.‬‬
‫‪MEDIUMINT‬‬ ‫عدد صحیح متوسط که می تواند نشانه دار یا بدون نشانه باشد ‪ .‬اگر نشانه دار باشد محدوده مجاز‬ ‫عددی‬
‫اعداد بین ‪ 0100130-‬تا ‪ 0100131‬می باشد ‪ .‬اگر بدون نشانه باشد محدوده مجاز اعداد بین ‪ 3‬تا‬
‫‪ 31111531‬میباشد ‪ .‬میتوانید تعداد ارقام را تا ‪ 6‬رقم مشخص کنید‬
‫‪BIGINT‬‬ ‫عدد صحیح بزرگ می تواند نشانه دار یا بدون نشانه باشد ‪ .‬اگر نشانه دار باشد محدوده مجاز اعداد‬ ‫عددی‬
‫بین ‪ 6551115311013111030-‬تا ‪ 6551115311013111031‬میباشد‪ .‬اگر بدون نشانه باشد‬

‫محدوده مجاز اعداد بین ‪ 3‬تا ‪ 6551115311013111031‬میباشد ‪ .‬تعداد ارقام را میتوانید تا ‪ 53‬رقم‬
‫مشخص کنید‪.‬‬
‫‪FLOAT‬‬ ‫عدد اعشاری که نمیتواند بدون عالمت باشد ‪ .‬میتوان طول ارقام )‪ (M‬و تعداد اعشار )‪ (D‬را‬ ‫عددی‬
‫تعریف کرد‪ .‬تعریف طول و تعداد اعشار اجباری نمیباشد و در صورت عدم مقدار پیشفرض ‪33,5‬‬
‫اشتفاده میشود که ‪ 5‬تعداد ارقام اعشار و ‪ 33‬تعداد کل ارقام میباشد (با احتساب ارقام اعشار)‪.‬دقت‬
‫اعشار میتواند تا ‪ 53‬عدد برای ‪ FLOAT‬باشد‪.‬‬
‫‪DOUBLE‬‬ ‫عدد اعشاری با دقت مضاعف نمیتواند بدون عالمت باشد‪ .‬میتوان طول ارقام )‪ (D‬و تعداد‬ ‫عددی‬
‫اعشار)‪ (D‬را تعریف کرد‪ .‬تعریف طول و تعداد اعشار اجباری نمیباشد و در صورت عدم تعریف‬
‫مقدار پیشفرض ‪ 31,3‬اشتفاده میشود که ‪ 3‬تعداد ارقام اعشار و ‪ 31‬تعداد کل ارقام میباشد (با‬
‫احتساب اعداد اعشار) ‪ .‬دقت اعشار میتواند تا ‪ 13‬عدد برای ‪ DOUBLE‬باشد‪ REAL.‬مترادف برای‬
‫‪DOUBLE‬است‪.‬‬
‫‪DECIMAL‬‬ ‫عدد اعشاری با ممیز شناور که نمیتواند بدون عالمت باشد‪ .‬در اعشار ممیز شناور هر عدد اعشار‬ ‫عددی‬
‫معادل یک بایت میباشد‪ .‬تعریف طول ارقام )‪ (M‬و تعداد اعشار )‪ (D‬میباشد‪NUMERIC .‬‬
‫مترادف برای ‪ DECIMAL‬میباشد‪.‬‬
‫‪DATE‬‬ ‫تاریخ با فرمت ‪ ،YYYY-MM-DD‬که محدوده آن بین ‪ 33-33-3333‬تا ‪ 13-35-6666‬میباشد ‪ .‬برای مثال‬ ‫تاریخ‬
‫‪ December 30th, 1973‬به صورت ‪ .13-35-3611‬ذخیره میشود‪.‬‬
‫‪DATETIME‬‬ ‫ترکیبی از تاریخ و زمان با فرمت ‪ YYYY-MM-DD HH:MM:SS‬میباشد‪ ،‬محدوده آن بین ‪33-33-3333‬‬ ‫تاریخ‬
‫‪ 33:33:33‬و ‪9999-12-31 23:59:59‬میباشد‪ .‬برای مثال‪ 1:13 ،‬بعد از ظهر در تاریخ‬
‫‪ December 30th, 1973‬به صورت ‪ 31:13:33 13-35-3611‬ذخیره میشود‪.‬‬
‫‪TIMESTAMP‬‬ ‫محدوده زمانی بین نیمه شب ‪ January 1, 1970‬و زمانی در ‪ 5311‬میباشد‪ .‬فرمت آن شبیه‬ ‫تاریخ‬
‫فرمت ‪ DATETIME‬میباشد بودن خط تیره در میان اعداد ‪ .‬برای مثال‪ 1:13 ،‬بعد از ظهر در‬
‫تاریخ ‪ December 30th, 1973‬به صورت ‪ 36113513311333‬ذخیره میشود‪.‬‬
‫‪TIME‬‬ ‫زمان را با فرمت ‪ HH:MM:SS‬ذخیره میکند‪.‬‬ ‫تاریخ‬

‫‪YEAR‬‬ ‫سال را با فرمت ‪ 5‬رقم یا ‪ 3‬رقم ذخیره میکند‪ .‬اگر طول ‪ 5‬تعیین شود‪ YEAR ،‬میتواند بین ‪ 3613‬تا‬ ‫تاریخ‬
‫‪ 13( 5316‬تا ‪ )16‬باشد ‪ .‬اگر طول ‪ 3‬تعیین شود ‪ YEAR‬میتواند بین ‪ 3633‬تا ‪ 5311‬باشد‪ .‬طول‬
‫پیشفرض ‪ 3‬میباشد‪.‬‬
‫‪CHAR‬‬ ‫رشته با طول ثابت که طول آن بین ‪ 3‬تا ‪ 511‬میباشد (مثال ‪ )CHAR(5) :‬مقدار خالی سمت‬ ‫رشته‬
‫راست با فضای خالی پر می شود تا زمانی که به حداکثر طول تعیین شده برسد ‪ .‬تعریف طول رشته‬
‫اجباری نیست اما مقدار پیشفرض ‪ 3‬میباشد‪.‬‬
‫‪VARCHAR‬‬ ‫رشته با طول منغیر که طول آن میتواند بین ‪ 3‬تا ‪ 511‬باشد ‪ ( .‬مثال ‪ .)VARCHAR(25) :‬تعریف‬ ‫رشته‬
‫مقدار طول رشته اجباری میباشد‪.‬‬
‫‪BLOB / TEXT‬‬ ‫فیلد با حداکثز مقدار ‪ 11111‬کاراکتر ‪ BLOB .‬مخفف ”‪ “Binary Large Object‬میباشد و‬ ‫رشته‬
‫برای ذخیره مقادیر بزرگ داده باینری استفاده میشود‪ ،‬از قبیل تصویر یا انواع مختلف فایلها‪.‬‬
‫فیلدهایی که عنوان ‪ TEXT‬ذخیره شده اند نیز مقدار بزرگی از داده را ذخیره میکنند‪ .‬تفاوت آنها در‬
‫این میباشد که مرتب سازی و مقایسه در فیلدهای ‪ BLOB‬بین حروف کوچک و بزرگ تفاوت قائل‬
‫میشود اما در فیلدهای ‪ TEXT‬تفاوتی قائل نمیشود ‪ .‬برای نوعهای ‪ TEXT‬و ‪ BLOB‬طول تعریف‬
‫نمیشود‪.‬‬
‫‪TINYBLOB /‬‬ ‫یک ستون ‪ TEXT‬یا ‪ BLOB‬با حداکثر مقدار ‪ 511‬کاراکتر ‪ .‬برای نوعهای ‪ TINYTEXT‬و‬ ‫رشته‬
‫‪TINYTEXT‬‬
‫‪ ،TINYBLOB‬طول تعریف نمیشود‪.‬‬
‫‪MEDIUMBLOB /‬‬ ‫یک ستون ‪ TEXT‬یا ‪ BLOB‬با حداکثر مقدار ‪ 31111531‬کاراکتر ‪ .‬برای نوعهای‪ MEDIUMTEXT‬و‬ ‫رشته‬
‫‪MEDIUMTEXT‬‬
‫‪ ،MEDIUMBLOB‬طول تعریف نمیشود‪.‬‬
‫‪LONGBLOB /‬‬ ‫یک ستون ‪ TEXT‬یا ‪ BLOB‬با حداکثر مقدار ‪ 3563611561‬کاراکتر ‪ .‬برای نوعهای‪ LONGTEXT‬و‬ ‫رشته‬
‫‪LONGTEXT‬‬
‫‪ ،LONGBLOB‬طول تعریف نمیشود‪.‬‬
‫‪ENUM‬‬ ‫یک نوع شمارشی میباشد‪ ،‬که یک ا صطالح عامیانه برای لیست است ‪ .‬هنگامی که یک فیلد‬ ‫رشته‬
‫‪ENUM‬تعریف میکنید‪ ،‬شما لیستی از گزینهها ایجاد میکنید که یک مورد باید انتخاب شود (یا‬
‫میتواند ‪ NULL‬باشد) ‪ .‬برای مثال شما میخواهید فیلد دارای مقدار ”‪ “A‬یا ”‪ “B‬یا ”‪ “C‬باشد‪،‬‬
‫فیلد ‪ ENUM‬باید به صورت)’‪ ENUM(‘A’,’B’,’C‬تعریف شود و تنها همان مقادیر تعیین شده‬
‫(یا ‪ )NULL‬میتواند برای آن فیلد جمع آوری شود‪.‬‬
‫‪SET‬‬ ‫نوع ‪ SET‬نیز همانند ‪ ENUM‬میباشد و تنها تفاوت آن در این میباشد که امکان انتخاب چند گزینه‬ ‫رشته‬
‫از لیست را نیز میسر میسازد‪.‬‬
‫حال اکه با انواع دادهها آشنا شدید‪ ،‬در ادامه در دستورات پایه ای ‪ MYSQL‬توضیح میدهیم ‪.‬‬
‫دستورات ‪MYSQL‬‬
‫‪ MYSQL‬دارای دستوراتی برای کار با بانک اطالعاتی مانند ایجاد بانک‪ ،‬ایجاد و حذف جداول و کار با دادههای ذخیره شده در بانک‬
‫میباشد که در جدول زیر به مهمترین آنها اشاره شده است‪:‬‬
‫دستور‬ ‫نحوه استفاده‬ ‫کاربرد‬
‫‪ALTER‬‬ ‫‪ALTER TABLE table_name ADD column_name datatype‬‬ ‫برای اضافه کردن‪ ،‬حذف کردن‬
‫‪TABLE‬‬
‫یا تغییر ستونها در جدول‬
‫‪or‬‬
‫موجود استفاده میشود ‪.‬‬
‫‪ALTER TABLE table_name DROP COLUMN column_name‬‬
‫‪CREATE‬‬ ‫‪CREATE DATABASE database_name‬‬ ‫یک دیتابیس جدید ایجاد‬

‫‪DATABASE‬‬
‫‪CREATE‬‬ ‫‪CREATE TABLE‬‬ ‫‪table_name‬‬ ‫یک جدول جدید ایجاد‬

‫‪TABLE‬‬ ‫(‬
‫‪column_name1‬‬ ‫‪data_type,‬‬ ‫میکند‪.‬‬
‫‪column_name2‬‬ ‫‪data_type,‬‬
‫‪column_name3‬‬ ‫‪data_type,‬‬
‫…‬
‫)‬
‫‪DELETE‬‬ ‫‪DELETE FROM table_name WHERE some_column=some_value‬‬ ‫برای حذف یک رکورد یا همه‬
‫رکوردهای جدول به کار میرود ‪.‬‬
‫‪or‬‬
‫‪DELETE FROM table_name‬‬

‫)!!‪(Note: Deletes the entire table‬‬
‫‪DELETE * FROM table_name‬‬

‫)!!‪(Note: Deletes the entire table‬‬
‫‪DROP‬‬ ‫‪DROP DATABASE database_name‬‬ ‫برای حذف دیتابیس به کار‬

‫‪DATABASE‬‬
‫میرود ‪.‬‬
‫‪DROP‬‬ ‫‪DROP TABLE table_name‬‬ ‫برای حذف جدول به کار‬

‫‪TABLE‬‬
‫میرود ‪.‬‬
‫‪INSERT‬‬ ‫)‪INSERT INTO table_name VALUES (value1, value2, value3,….‬‬ ‫برای اضافه کردن یک یا چند‬
‫‪INTO‬‬
‫رکورد به جدول به کار میرود ‪.‬‬
‫‪or‬‬
‫‪INSERT INTO table_name (column1, column2, column3,…) VALUES‬‬

‫)‪(value1, value2, value3,….‬‬
‫‪LIKE‬‬ ‫‪SELECT column_name(s) FROM table_name WHERE column_name LIKE‬‬ ‫به همراه دستور ‪ WHERE‬برای‬
‫‪pattern‬‬
‫پیدا کردن یک الگوی خاص در‬
‫یک ستون استفاده میشود ‪.‬‬
‫‪ORDER BY‬‬ ‫‪SELECT column_name(s) FROM table_name ORDER BY column_name‬‬ ‫برای مرتب کردن نتیجه پرس‬
‫]‪[ASC|DESC‬‬
‫و جو بر اساس ستون مشخص‬
‫شده به صورت صعودی یا‬
‫نزولی به کار میرود ‪.‬‬
‫‪SELECT‬‬ ‫‪SELECT column_name(s) FROM table_name‬‬ ‫برای استخراج دادههای‬

‫ستونهای خاصی از جدول به‬
‫کار میرود ‪.‬‬
‫* ‪SELECT‬‬ ‫‪SELECT * FROM table_name‬‬ ‫برای استخراج دادههای یک‬

‫جدول به کار میرود ‪.‬‬
‫‪UPDATE‬‬ ‫‪UPDATE table_name SET column1=value, column2=value,… WHERE‬‬ ‫برای به روز رسانی رکوردهای‬
‫‪some_column=some_value‬‬
‫موجود در یک جدول استفاده‬
‫میشود ‪.‬‬
‫‪WHERE‬‬ ‫‪SELECT column_name(s) FROM table_name WHERE column_name‬‬ ‫برای استخراج رکوردهایی که‬
‫‪operator value‬‬
‫در شرط خاصی صدق میکنند‬
‫کاربرد دارد‪.‬‬
‫‪ MYSQL‬به تنهایی زبان پیشرفته و بزرگی است‪ .‬بیشتر از این در مورد آن توضیح نمیدهیم‪ .‬برای مشاهده لیست کامل دستورات‬
‫‪ MYSQL‬یه لینک زیر مراجعه کنید‪:‬‬
‫‪http://www.w3schools.com/sql/sql_quickref.asp‬‬
‫حال که با مفاهیم پایه ای آن آشنا شدید‪ ،‬در درس بعد با کاربرد این دستورات به صورت عملی آشنا میشوید‪.‬‬
‫نصب سرور ‪MYSQL‬‬

‫همانطور که در درس قبل اشاره شد‪ ،‬در این سری آموزشی قصد داریم که از ‪ MYSQL‬به عنوان منبع اصلی دادههایمان استفاده کنیم‪.‬‬
‫پس الزم است که ابتدا سرور آن را نصب کنیم‪ .‬در این درس از نسخه ‪ MYSQLSERVER 5.5‬استفاده میکنیم‪ .‬دو نسخه ‪ 13‬و ‪15‬‬
‫بیت آن را از لینک زیر دانلود کرده و بسته به نوع ویندوزتان یکی از آنها را نصب کنید‪:‬‬
‫‪http://www.dl.w3-farsi.com/Software/Java/MySQL5.5.19.zip‬‬
‫بعد از دانلود فایل باال‪ ،‬ان را از حالت فشرده خارج کنید‪ .‬با کلیک بر روی فایل اجرایی یا ‪ exe‬صفحه ای به صورت زیر نمایان‬
‫میشود که دکمه ‪ Next‬را میزنیم‪:‬‬
‫در مرحله بعد گزینهی ‪ I Accept‬را انتخاب می کنیم و سپس ‪ Next‬میکنیم‪:‬‬

‫در مرحله بعد گزینهی ‪ Complete‬را انتخاب میکنیم‪:‬‬
‫با فشردن دکمه ‪ Install‬مراحل نصب شروع میشود و بعد از زدن چند دکمه ‪ Next‬متوالی نصب به پایان میرسد‪:‬‬
‫در شکل پایین همانطور که مشاهده میکنید گزینه ‪ Launch the MYSQL Instance Configuration Wizard‬را تیک زده و‬
‫سپس دکمه‪ Finish‬را میزنیم‪:‬‬

‫با تیک زدن گزینه ‪ Launch the MYSQL Instance Configuration Wizard‬پنجره ای به صورت زیر باز میشود که با زدن‬
‫دکمه ‪ Next‬ما را وارد مراحل تنظیم زبان‪ ،‬پورت اتصال و … میکند‪:‬‬
‫بعد از زدن دکمه ‪ Next‬پنجره زیر ظاهر میشود که با انتخاب گزینه اول پیکربندی به صورت استاندارد انجام میشود‪:‬‬
‫در مرحله بعد گزینهی اول را انتخاب میکنیم که مقدار حافظه را نسبت به حالتهای دیگر مصرف میکند‪:‬‬
‫مراحل زیر را به صورت پیشفرض انجام میدهیم‪:‬‬

‫در شکل زیر نوع کاراکتر )‪ (character set‬را مشخص کنیم که ما گزینهی دوم که ‪ UTF8‬را پشتیبانی میکند را انتخاب میکنیم‪.‬‬
‫یعنی چند زبان از جمله فارسی را پشتیبانی میکند و سپس ‪ Next‬را میزنیم‪:‬‬
‫در این مرحله نامی را اختصاص میدهیم که زمانی که این سرویس ‪ Run‬میشود با این نام در لیست سرویسهای ویندوز دیده‬
‫شود که ما ‪ MySQL5.5‬را در نظر گرفتیم و گزینهی زیر آن را تیک میزنیم تا زمان باال آمدن ویندوز به طور اتوماتیک راه اندازی شود‪:‬‬
‫در مرحله بعد از آنجاییکه نمیخواهیم هنگام اتصال به سرور پسورد داشته باشیم‪ ،‬تیک گزینه ‪ Modify Security Settings‬را‬
‫بر میداریم‪:‬‬
‫البته این کار اختیاری است و شما ممکن است که دوست داشته باشید هنگام اتصال از شما پسورد درخواست شود‪ ،‬در نتیجه‬
‫میتوانید در دو کادر روبروی این گزینه پسورد دلخواه را وارد کرده و سپس در برنامه استفاده کنید (به صورت زیر)‪:‬‬
‫در مرحله آخر بر روی ‪ Execute‬کلیک کرده تا تنظیمات اعمال شود‪:‬‬
‫برای اطمینان از صحت نصب ‪ MYSQLSERVR‬به منوی ‪ Start‬ویندوز رفته و در بین برنامههای نصب شده به شکل زیر ‪MYSQL‬‬
‫را پیدا و بر روی گزینه ‪ MYSQL 5.5 Command Line Client‬کلیک کنید‪:‬‬
‫با کلیک بر روی گزینه فوق صفحه ای به صورت زیر نمایش داده میشود که از شما پسورد میخواهد و چون در مراحل قبل ما هیچ‬
‫پسوردی برای اتصال به سرور اختصاص ندادیم با زدن دکمه ‪ Enter‬از این قسمت رد میشویم‪:‬‬
‫در مرحله نهایی بعد زدن دکمه‪ ، Enter‬پنجره زیر نمایان میشود که نشان از نصب کامل ‪ MYSQSERVER‬است‪:‬‬
‫نصب نرم افزار ‪ MYSQL Administrator‬و آشنایی با محیط آن‬

‫برای اجرای دستورات ‪ MYSQL‬میتوان از محیط غیر گرافیکی یا همان محیط کنسول ‪ MYSQL SERVER‬استفاده کرد‪ .‬کار با محیط‬
‫کنسول و کدنویسی در آن در بسیاری از مواقع کسل کننده و زمان بر میباشد‪ .‬در این درس میخواهیم مراحل نصب نرم افزاری را‬
‫به شما آموزش دهیم که شما را از کدنویسی رها میکند‪ .‬نرم افزار ‪ MYSQL Administrator‬دارای محیط گرافیکی برای کار با‬
‫پایگاه داده‪ ،‬جدول و دادههای آن میباشد‪ .‬با استفاده از این محیط گرافیکی شما تنها با چند کلیک ساده میتوانید دیتابیس و‬
‫جدول ایجاد کرده و آنها را مدیریت کنید‪ .‬برای دانلود این نرم افزار از طریق لینک زیر اقدام کنید‪:‬‬
‫‪http://www.dl.w3-farsi.com/Software/Java/MYSQL%20Administrator.msi‬‬
‫بعد از دانلود بر روی فایل با پسوند ‪ msi‬دوبار کلیک کرده و تمام مراحل زیر را طی کنید‪:‬‬
‫آشنایی با محیط‪MYSQL Administrator‬‬

‫قبل از آشنایی با محیط ‪ MYSQL Administrator‬اجازه دهید‪ ،‬نحوه اجرا و ورود به آن را توضیح دهیم‪ .‬ابتدا از منوی ‪ Start‬بر‬
‫روی گزینه ‪ MYSQL Administrator‬کلیک کرده‪:‬‬

‫تا صفحه ای به صورت زیر ظاهر شود‪:‬‬
‫در صفحه باز شده در داخل کادر ‪ Server Host‬کلمهی ‪ localhost‬یا ‪ 127.0.0.1‬و در داخل کادر ‪ Username‬کلمه ‪ root‬را‬
‫مینویسیم‪ .‬در کادر پسورد هم هیچ چیزی نمینویسیم‪ .‬چون اگر به یاد داشته باشید در هنگام نصب ‪ MYSQL‬پسوردی برای اتصال‬
‫به سرور تعریف نکردیم‪ .‬سپس بر روی دکمه ‪ OK‬کلیک کرده نا وارد محیط برنامه شوید‪:‬‬
‫توضیح منوهای سمت چپ شکل باال در جدول زیر آمده است‪:‬‬
‫کاربرد‬ ‫منو‬
‫اطالعاتی دربارهی سرور‪ IP ،port ،‬و… را به ما میدهد‪.‬‬ ‫‪Server Information‬‬
‫از طریق این بخش میتوان سرویس ‪ Mysql‬را ‪ start‬و یا ‪ stop‬کنیم‪.‬‬ ‫‪Service Control‬‬
‫تنظیمات امنیتی‪ ،‬شبکه و … در این گزینه انجام میشود‪.‬‬ ‫‪Startup Variable‬‬
‫در این گزینه میتوانیم کاربرانی با سطح دسترسی مختلف به دیتابیس ایجاد کنیم‪.‬‬ ‫‪User Administration‬‬
‫کاربر ‪ root‬دسترسی کامل به دیتابیس دارد‪.‬‬
‫تعداد ارتباطات که به سرور متصل است را میتوان در اینجا مشاهده کرد‪.‬‬ ‫‪Server Connection‬‬
‫وضعیتی از عملکرد ‪ CPU‬و ‪ Ram‬و … به ما نشان میدهد‪.‬‬ ‫‪Health‬‬

‫اتفاقاتی که برای سیستم افتاده‪ ،‬مثال چه زمانی سرویس ‪ Start‬و ‪ Stop‬شده و یا‬ ‫‪Server Logs‬‬
‫چه دیتابیسی و در چه زمانی ساخته شده و …‪.‬را در یک فایل متنی ذخیره میکند‪.‬‬
‫از طریق چند سرور اطالعات را بر روی دیتابیس ذخیره میکنند‪.‬‬ ‫‪Replication Status‬‬
‫برای پشتیبان گیری از دیتابیس و بازگردانی آن مورد استفاده قرار میگیرند‪.‬‬ ‫‪Backup‬و ‪Restore‬‬
‫لیست بانکهای اطالعاتی موجود را میتوانیم از اینجا مشاهده کنیم‪.‬‬ ‫‪Catalogs‬‬
‫در شکل و جدول باال ما بیشتر با دو گزینه ‪ Catalogs‬و ‪ User Administration‬برای ایجاد دیتابیس و جدول و کاربر سرکار‬
‫داریم‪ .‬که در درسهای آینده در مورد آنها توضیح میدهیم‪.‬‬
‫ایجاد جدول و دیتابیس با استفاده از محیط کنسول ‪MYSQL‬‬

‫در این درس میخواهیم یک دیتابیس که شامل یک جدول و چندین رکورد است را ایجاد کنیم‪ .‬قصد داریم که ایجاد دیتابیس و‬
‫جدول را از دو را به شما آموزش دهیم ‪:‬‬
‫محیط کنسول ‪MYSQL‬‬ ‫‪‬‬
‫محیط گرافیکی ‪MYSQL Administrator‬‬ ‫‪‬‬
‫ابتدا روش ایجاد دیتابیس و جدول و کار با دادههای دیتابیس در محیط کنسول را توضیح میدهیم‪ .‬برای ورود به محیط کدنویسی‬
‫به منوی استارت رفته و بر روی گزینه ‪ MYSQL 5.5 Command Line Client‬کلیک کنید تا پنجره محیط کنسول به صورت زیر‬
‫نمایش داده شود‪:‬‬

‫ایجاد دیتابیس‬
‫در این بخش میخواهیم یک دیتابیس با نام ‪ University‬که شامل جدول ‪ Students‬است را ایجاد کنیم‪ .‬برای این کار در پنجره‬
‫باال دستور ‪ MYSQL‬زیر را مینویسیم‪:‬‬
‫;‪mysql> CREATE DATABASE University‬‬
‫با فشار دادن دکمه ‪ ،Enter‬اگر همه چیز به خوبی پیش رود و برنامه پیغام خطا ندهد کد زیر نمایش داده میشود‪:‬‬
‫;‪mysql> CREATE DATABASE University‬‬

‫)‪Query OK, 1 row affected (0.01 sec‬‬
‫ایجاد جدول‬
‫برای ایجاد جدول ‪ student‬که شامل جزییاتی در مورد چندین دانش آموز است ابتدا باید از ایجاد دیتابیس مطمئن شوید برای‬
‫این کار دستور زیر را تایپ کنید‪:‬‬
‫;‪mysql> USE University‬‬
‫معنای دستور باال این است که ما میخواهیم تغییراتی در دیتابیسی به نام ‪ University‬بدهیم‪ .‬همچنین یک پیغام مبنی بر اعمال‬
‫تغییرات به شما نشان داده میشود‪ .‬اجازه دهید که جدول ‪ Students‬را ایجاد کنیم‪ .‬دستور ‪ MYSQL‬زیر را مینویسیم‪:‬‬
‫‪mysql> CREATE TABLE Students‬‬

‫( >‪-‬‬
‫>‪-‬‬ ‫‪StudentID int AUTO_INCREMENT primary key,‬‬
‫>‪-‬‬ ‫‪FirstName varchar(50),‬‬
‫>‪-‬‬ ‫‪LastName varchar(50),‬‬
‫>‪-‬‬ ‫‪Gender varchar(10),‬‬
‫>‪-‬‬ ‫‪Age int,‬‬
‫>‪-‬‬ ‫)‪Address varchar(50‬‬
‫;) >‪-‬‬
‫جدول ایجاد شده دارای ‪ 1‬ستون میباشد‪ .‬ستون اول ‪ StudentID‬است‪ ،‬که آن را به عنوان کلید اصلی و از نوع ‪ int‬تعریف‬
‫کردهایم‪ .‬دیگر ستونهای آن به ترتیب عبارتاند از ‪ Age ،Gender ،LastName ،FirstName‬و ‪ Address‬که نوع آنها مشخص‬
‫شده است‪ .‬با اجرای دستور فوق جدول ایجاد میشود‪ .‬نکته ای که در کد ب اال وجود دارد و بهتر است که در همین جا به آن اشاره‬
‫کنیم مربوط به خط ‪ 1‬و کلمات ‪ AUTO_INCREMENT‬و ‪ primary key‬میباشد‪.‬‬
‫‪ ،primary key‬مقداری است که یک سطر یا رکورد را نشان میدهد ‪ .‬این مقدار باید برای هر رکورد‪ ،‬یکتا باشد و در رکورد‬ ‫‪‬‬
‫دیگری عین همین مقدار نباید وجود داشته باشد‪ .‬یکی از روشهای ایجاد کلید اصلی استفاده از یک فیلد شمارشی به عنوان‬
‫کلید اصلی است‪ .‬به هر رکورد یک فیلد شمارشی اختصاص دهید که با اضافه شدن هر رکورد یک مقدار به آن اضافه شود‪ .‬بدین‬
‫معنا که اگر شما یک رکورد به دیتابیس اضافه کردید عدد ‪ ،3‬به ازا دومین رکورد عدد ‪ 5‬و… به فیلد شمارشی اضافه شود ‪.‬‬
‫‪ ،AUTO_INCREMENT‬فیلدی است که به طور خودکار هنگام اضافه شدن یک رکورد جدید‪ ،‬مقدار میگیرد (معموال یک واحد به‬ ‫‪‬‬
‫آن اضافه میشود)‪ .‬به عنوان مثال اگر یک رکورد جدید را اضافه کنیم‪ ،‬به طور خودکار مقدار ‪ 3‬به آن اختصاص داده میشود‪ ،‬و‬
‫در هر بار اضافه شدن یک رکورد جدید این مقدار نیز یک واحد اضافه میشود‪ .‬میتوان یک کلید اصلی را به عنوان فیلد شناسه‬
‫تعریف کرد‪.‬‬
‫اضافه کردن رکوردها‬
‫حال که جدول مان را ایجاد کردهایم اجازه دهید اطالعات مربوط به چند دانش آموز را به آن اضافه کنیم‪ .‬در زیر اطالعات مربوط به‬
‫چند دانش آموز که به جدول اضافه کردهایم نشان داده شده است‪:‬‬
‫‪StudentID‬‬ ‫‪FirstName‬‬ ‫‪LastName‬‬ ‫‪Gender‬‬ ‫‪Age‬‬ ‫‪Address‬‬
‫‪1‬‬ ‫‪Edward‬‬ ‫‪Lyons‬‬ ‫‪Male‬‬ ‫‪17‬‬ ‫‪Spencer Street‬‬
‫‪2‬‬ ‫‪Jimmie‬‬ ‫‪Vargas‬‬ ‫‪Male‬‬ ‫‪18‬‬ ‫‪Blue Bay Avenue‬‬
‫‪3‬‬ ‫‪Monica‬‬ ‫‪Ward‬‬ ‫‪Female‬‬ ‫‪16‬‬ ‫‪Mapple Street‬‬

116 ‫کار با بانک اطالعاتی‬
4 Joann Jordan Female 17 Spencer Street
5 Cheryl Swanson Female 17 Wacky Street
6 Clara Webb Female 18 Spooner Street
7 Zack Norris Male 19 Blue Bay Avenue
8 Randall May Male 18 Golden Street
9 Jessica Cole Female 17 Mapple Street
10 Oscar Manning Male 18 Mapple Street
:‫ اضافه کنیم‬Students ‫ به جدول‬SQL ‫ رکورد داریم اجازه دهید آنها را با استفاده از دستورات‬01 ‫حال که‬
mysql> INSERT INTO Students(FirstName, LastName, Gender, Age, Address) VALUES

-> ('Edward', 'Lyons', 'Male', 17, 'Spencer Street'),
-> ('Jimmie', 'Vargas', 'Male', 18, 'Blue Bay Avenue'),
-> ('Monica', 'Ward', 'Female', 16, 'Mapple Street'),
-> ('Joann', 'Jordan', 'Female', 17, 'Spencer Street'),
-> ('Cheryl', 'Swanson', 'Female', 17, 'Wacky Street'),
-> ('Clara', 'Webb', 'Female', 18, 'Spooner Street'),
-> ('Zack', 'Norris', 'Male', 19, 'Blue Bay Avenue'),
-> ('Randall', 'May', 'Male', 18, 'Golden Street'),
-> ('Jessica', 'Cole', 'Female', 17, 'Mapple Street'),
-> ('Oscar', 'Manning', 'Male', 18, 'Mapple Street');
‫ استفاده‬،‫ که به ما اجازه وارد کردن چندین رکورد را به صورت یکجا میدهد‬INSERT INTO ‫از یک نسخه اصالح شده دستور‬
‫ جدول‬،MYSQL ‫ بعد از اجرای دستورات‬.‫ هر رکورد در داخل پرانتز قرار دارد و رکوردها به وسیله کاما از هم جدا شدهاند‬.‫میکنیم‬
‫ یک پیغام نشان داده میشود که نشان دهنده تعداد‬،‫ اگر همه چیز به درستی انجام شود‬.‫ رکورد باشد‬33 ‫ باید دارای‬Students
‫ نوشتهایم به صورت‬University ‫ همه کدهایی که تا االن برای ایجاد دیتابیس‬.‫رکوردهایی است که دستکاری (اضافه) شدهاند‬
:‫زیر است‬
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 2
Server version: 5.5.19 MySQL Community Server (GPL)
Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
Oracle is a registered trademark of Oracle Corporation and/or its

affiliates. Other names may be trademarks of their respective
owners.
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
mysql> CREATE DATABASE University;

Query OK, 1 row affected (0.01 sec)
mysql> USE University;

Database changed
mysql> CREATE TABLE Students
-> (
-> StudentID int AUTO_INCREMENT primary key,
-> FirstName varchar(50),
-> LastName varchar(50),
-> Gender varchar(10),
-> Age int,
-> Address varchar(50)
-> );
Query OK, 0 rows affected (0.04 sec)
mysql> INSERT INTO Students(FirstName, LastName, Gender, Age, Address) VALUES

-> ('Edward', 'Lyons', 'Male', 17, 'Spencer Street'),
-> ('Jimmie', 'Vargas', 'Male', 18, 'Blue Bay Avenue'),
-> ('Monica', 'Ward', 'Female', 16, 'Mapple Street'),
-> ('Joann', 'Jordan', 'Female', 17, 'Spencer Street'),
-> ('Cheryl', 'Swanson', 'Female', 17, 'Wacky Street'),
-> ('Clara', 'Webb', 'Female', 18, 'Spooner Street'),
-> ('Zack', 'Norris', 'Male', 19, 'Blue Bay Avenue'),
-> ('Randall', 'May', 'Male', 18, 'Golden Street'),
-> ('Jessica', 'Cole', 'Female', 17, 'Mapple Street'),
-> ('Oscar', 'Manning', 'Male', 18, 'Mapple Street');
Query OK, 10 rows affected (0.02 sec)
Records: 10 Duplicates: 0 Warnings: 0
‫ را که‬INSERT ‫ دستور‬.‫ عملیات مختلفی بر روی بانک انجام دهیم‬،‫حال میخواهیم با توجه به مطالبی که در درس قبل یاد گرفتیم‬
‫ در ادامه‬.‫ استفاده کنیم‬SELECT ‫ حال برای نمایش اطالعات میخواهیم از دستور‬.‫در باال برای وارد کردن اطالعات انجام دادهایم‬
:‫کدهای باال دستور زیر را بنویسید‬
mysql> SELECT* FROM Students;
:‫ را استخراج کرده و در خروجی نمایش میدهد‬Students ‫کد باال تمامی دادههای جدول‬
StudentID FirstName LastName Gender Age Address

-----------------------------------------------------------------------------------
1 Edward Lyons Male 17 Spencer Street
2 Jimmie Vargas Male 18 Blue Bay Avenue
3 Monica Ward Female 16 Mapple Street

‫)‪(10 rows affected‬‬

‫>‪1‬‬
‫اگر بخواهید اطالعات یک یا چند ستون خاص را نمایش دهید کافیست از کد زیر استفاده کنید‪:‬‬
‫‪mysql> SELECT FirstName, LastName‬‬ ‫;‪FROM Students‬‬
‫کد باال فقط اطالعات مربوط به ستونهای ‪ FirstName‬و ‪ LastName‬را نمایش میدهد‪:‬‬
‫‪+-----------+----------+‬‬
‫| ‪| FirstName | LastName‬‬
‫‪+-----------+----------+‬‬
‫‪| Edward‬‬ ‫‪| Lyons‬‬ ‫|‬
‫‪| Jimmie‬‬ ‫‪| Vargas‬‬ ‫|‬
‫‪| Monica‬‬ ‫‪| Ward‬‬ ‫|‬
‫‪| Joann‬‬ ‫‪| Jordan‬‬ ‫|‬
‫‪| Cheryl‬‬ ‫| ‪| Swanson‬‬
‫‪| Clara‬‬ ‫‪| Webb‬‬ ‫|‬
‫‪| Zack‬‬ ‫‪| Norris‬‬ ‫|‬
‫‪| Randall‬‬ ‫‪| May‬‬ ‫|‬
‫‪| Jessica‬‬ ‫‪| Cole‬‬ ‫|‬
‫‪| Oscar‬‬ ‫| ‪| Manning‬‬
‫‪+-----------+----------+‬‬
‫حال فرض کنید که میخواهیم نام خانوادگی و سن شخصی که اسمش ‪ Edward‬است را از جدول استخراج کنیم‪ .‬برای این کار از‬
‫دستور ‪ WHERE‬به صورت زیر استفاده میکنیم‪:‬‬
‫;'‪mysql> SELECT LastName, Age FROM Students WHERE FirstName = 'Edward‬‬
‫خروجی کد باال به صورت زیر است‪:‬‬
‫‪+----------+------+‬‬
‫| ‪| LastName | Age‬‬
‫‪+----------+------+‬‬
‫‪| Lyons‬‬ ‫|‬ ‫| ‪17‬‬
‫‪+----------+------+‬‬
‫حال میخواهیم اشخاصی که ‪ StudentID‬آنها کمتر از ‪ 1‬است را استخراج کرده و به صورت نزولی مرتب کنیم‪ .‬برای این کار به‬
‫صورت زیر عمل میکنیم‪:‬‬
‫‪mysql> SELECT StudentID, FirstName, LastName FROM Students WHERE StudentID < 5 ORDER BY studentID‬‬
‫;‪DESC‬‬
‫کد باال ‪ 3‬نفر اول را استخراج کرده و بر اساس ستون ‪ StudentID‬از بزرگ به کوچک مرتب میکند‪ .‬خروجی کد باال به صورت زیر‬
‫است‪:‬‬
‫‪+-----------+-----------+----------+‬‬
‫| ‪| StudentID | FirstName | LastName‬‬
‫‪+-----------+-----------+----------+‬‬
‫|‬ ‫‪4 | Joann‬‬ ‫‪| Jordan‬‬ ‫|‬
‫|‬ ‫‪3 | Monica‬‬ ‫‪| Ward‬‬ ‫|‬
‫|‬ ‫‪2 | Jimmie‬‬ ‫‪| Vargas‬‬ ‫|‬
‫|‬ ‫‪1 | Edward‬‬ ‫‪| Lyons‬‬ ‫|‬
‫‪+-----------+-----------+----------+‬‬
‫فرض کنید میخواهید تمامی نامهایی که در داخل آنها ‪ ar‬وجود دارد را استخراج کنید‪ .‬در این صورت از عبارت ‪ LIKE‬به صورت‬
‫زیر استفاده کنید‪:‬‬
‫;'‪mysql> SELECT FirstName FROM Students WHERE FirstName LIKE '%ar%‬‬
‫کد باال تمامی نامهایی که در آنها دو حرف ‪ a‬و ‪ r‬پشت سر هم آمدهاند را استخراجی میکند‪:‬‬
‫‪+-----------+‬‬
‫| ‪| FirstName‬‬
‫‪+-----------+‬‬
‫‪| Edward‬‬ ‫|‬
‫‪| Clara‬‬ ‫|‬
‫‪| Oscar‬‬ ‫|‬
‫‪+-----------+‬‬
‫اگر بخواهیم مثال سن شخصی به نام ‪ Edward‬را از ‪ 31‬به ‪ 53‬تغییر دهیم میتوانیم از دستور ‪ UPDATE‬استفاده کنیم‪:‬‬
‫;‪mysql> UPDATE Students SET Age = 20 WHERE StudentID = 1‬‬
‫در دستور باال گفتهایم که سن شخصی از جدول ‪ Students‬را که ‪ StudentID‬آن برابر ‪ 3‬است را به ‪ 53‬تغییر بده‪ .‬حال اگر با‬
‫استفاده از یک دستور ‪ SELECT‬همه دادهها را نمایش دهیم مشاهده میکنید که سن ‪ Edward‬به ‪ 53‬تغییر کرده است‪ .‬همانطور‬
‫که مشاهده میکنید استفاده از دستورات ‪ MYSQL‬بسیار آسان است‪ .‬شما میتوانید بقیه دستورات را که در درس قبل آموختید را‬
‫به صورت باال امتحان کنید‪.‬‬

‫ایجاد جدول و دیتابیس با استفاده از محیط ‪MYSQL‬‬

‫‪Administrator‬‬
‫در درس قبل با نحوه ایجاد دیتابیس و جدول و دستکاری اطالعات با استفاده از محیط کدنویسی آشنا شدید‪ .‬در این درس دقیقا‬
‫میخواهیم همان کارها را با استفاده محیط گرافیکی ‪ MYSQL Administrator‬انجام دهیم ‪.‬برنامه را اجرا کرده و وارد محیط آن‬
‫شوید‪ .‬برای ایجاد دیتابیس بر روی گزینه ‪ Catalogs‬کلیک کنید ‪.‬‬
‫نکته ‪ :‬چون در درس قبل ما دیتابیس ‪ university‬را ایجاد کردهایم‪ ،‬با کلیک بر روی گزینه ‪ Catalogs‬نام آن در داخل لیست‬
‫دیتابیسها وجود دارد‪ .‬بر روی ‪ university‬راست کلیک کرده و سپس گزینه ‪ DROP Schema‬و از کادر باز شده کلمه ‪ OK‬را‬
‫بزنید تا دیتابیس حذف شود‪.‬‬
‫ایجاد دیتابیس‬
‫برای ایجاد دیتابیس‪ ،‬بر روی گزینه ‪ Catalogs‬کلیک کرده و سپس در یک قسمت خالی به صورت زیر راست کلیک کرده و گزینه‬
‫‪ Create New Schema‬را بزنید‪:‬‬

‫با کلیک بر روی گزینه ‪ Create New Schema‬یک کادر نمایان میشود که شما میتوانید نام دیتابیس تان را در داخل آن بنویسید‬
‫‪:‬‬
‫بعد از نوشتن نام دیتابیس (در اینجا ‪ )university‬و زدن دکمه ‪ ،OK‬دیتابیس ساخته شده با لیست دیتابیسها اظافه میشود‬
‫‪:‬‬
‫ایجاد جدول‬
‫برای ایجاد جدول بر روی نام دیتابیس راست کلیک کرده و گزینه ‪ Create New Table‬را بزنید‪:‬‬
‫بعد از کلیک بر روی گزینه ‪ ،Create New Table‬صفحه ای به صورت زیر ظاهر میشود‪ .‬بعد از نوشتن نام جدول در کادر مربوطه‬
‫دکمه ‪ Enter‬را بزنید تا وارد قسمت نامگذاری ستونها یا همان ‪ Column Name‬در شکل باال شوید‪ .‬برای نامگذاری و وارد کردن‬
‫سایر مشخصات ستونها کافیست بر روی سلولهای مربوطه دوبار کلیک کنید تا نشانگر ماوس به حالت چشمک زن درآید و شما‬
‫بتوانید تغییرات را به صورت زیر اعمال کنید‪:‬‬
‫بعد از ردن دکمه ‪ Apply changes‬در شکل باال کادری به صورت زیر نمایش داده میشود که نشان دهنده مشخصات کلی جدول‬
‫است‪ ،‬بر روی دکمه ‪ Execute‬کلیک کنید تا جدول و ستونهای آن در داخل دیتابیس ایجاد شوند‪:‬‬
‫حال اگر بر روی دیتابیس مان یعنی ‪ university‬کلیک کنیم‪ ،‬مشاهده میکنیم که حاوی یک جدول به نام ‪ Students‬است‪:‬‬
‫وارد کردن دادهها و اجرای دستورات‪MYSQL‬‬
‫برای وارد کردن دادهها در جدول هم بر روی نام جدول راست کلیک کرده و سپس گزینه ‪ Edit Table Data‬را بزنید‪:‬‬
‫بعد از کلیک بر روی گزینه ‪ Edit Table Data‬صفحه ای به صورت زیر ظاهر میشود‪ .‬برای وارد کردن دادهها همانند شکل زیر‬
‫ابتدا گزینه ‪ Edit‬را بزنید تا به شما اجازه داده شود که اطالعات را وارد نمایید‪:‬‬
‫در شکل باال همانطور که احتماال متوجه شدهاید با دوبار کلیک بر روی هر سلول به شما اجازه داده میشود که اطالعات را وارد کنید‬
‫و بعد از اتمام کار یک سلول با زدن دکمه ‪ Tab‬اطالعات سلول بعد را وارد کنید و این کار را تا وارد کردن همه دادهها تکرار کرده و‬
‫سپس گزینه ‪ Apply Changes‬را بزنید‪:‬‬
‫الته به این نکته توجه کنید که در این محیط میتوان با استفاده از کدنویسی و به صورت زیر هم داده را وارد کرد‪:‬‬
‫برای این منظور کافیست که مانند شکل باال دستورات را در کادر باال نوشته و دکمه جرقه شکل را بفشارید‪ .‬حال برای اطمینان از‬
‫اینکه کار با دیتابیس در این محیط با محیط کنسول تفاوت ندارد چند دستور از دستورات درس قبل را در این محیط آزمایش کنید‬
‫‪:‬‬
‫‪ JDBC‬چیست؟‬
‫‪ JDBC‬یا ‪ Java Database Connectivity‬یک رابط نرم افزاری )‪ (API‬است‪ ،‬که به برنامههای جاوا اجازه اتصال و تبادل اطالعات‬
‫با بانک اطالعاتی را میدهد‪ .‬این رابط مجموعه ای از ‪ interface‬ها و کالسهای نوشته شده توسط زبان جاوا میباشد و با‬
‫استفاده از آن میتوان دستورات ‪ SQL‬و ‪ PL/SQL‬را تقریبا بر روی هر نوع پایگاه داده ای اجرا کرد‪ JDBC .‬برای اولین بار به عنوان‬
‫بخشی از ‪ JDK.1.1‬به برنامه نویسان معرفی شد‪ .‬البته ‪ JDBC‬ورژن مختص خود و مستقل از جاوا را دارد آخرین ورژن موجود از‬
‫‪ JDBC‬ورژن ‪ 3.3‬میباشد که در ‪ SE7‬وجود دارد‪ .‬قبل از شروع کار با ‪ JDBC‬باید متغیرهای زیر را در پنجره ‪Environment‬‬
‫‪ Variables‬با توجه به آموزش ایجاد یک برنامه ساده در جاوا‪ ،‬وارد کنید‪:‬‬
‫‪JAVA_HOME: C:\Program Files\Java\jdk1.7.0_25‬‬

‫‪CLASSPATH: C:\Program Files\Java\jdk1.7.0_25\jre\lib.‬‬
‫‪PATH:‬‬ ‫‪C:\Program Files\Java\jre1.7.0_25\bin.‬‬
‫به عنوان مثال متغیر ‪ CLASSPATH‬را به صورت زیر تعریف کنید‪:‬‬

‫به این نکته توجه کنید که من در سیستم خودم نسخه ‪ jdk1.7.0_25‬را نصب کردهام و ممکن است که شما از نسخه دیگر استفاده‬
‫کنید‪ .‬پس مراقب باشید که نسخه خود را جایگزین کنید‪ .‬بعد از نصب ‪ JDK‬دو پکیج ‪ java.sql‬و ‪ javax.sql‬به طور خودکار‬
‫در دسترس شما قرار میگیرد‪ .‬وارد کردن یکی از این دو ‪ Package‬در برنامه هنگام کار با دیتابیس الزامی است‪.‬‬
‫مراحل ارتباط با بانک در جاوا‬
‫در این درس میخواهیم یک مراحل ارتباط با بانک اطالعاتی در جاوا را با استفاده از یک برنامه ساده به شما آموزش دهیم‪ .‬این‬
‫ارتباط شامل مراحل زیر است‪:‬‬
‫وارد کردن پکیج *‪java.sql.‬‬ ‫‪.3‬‬
‫ثبت یا بارگذاری یک راه انداز )‪ (Driver‬در حافظه رم‪.‬‬ ‫‪.5‬‬
‫ارتباط با بانک‪.‬‬ ‫‪.1‬‬
‫اجرای دستورات بر روی بانک‪.‬‬ ‫‪.3‬‬
‫پردازش نتایج حاصل از اجرای دستورات بر روی بانک‪.‬‬ ‫‪.1‬‬
‫پاک کردن اشیاء بی استفاده و آزاد کردن حافظه‪.‬‬ ‫‪.1‬‬
‫در زیر یک مثال ساده با توجه به مراحل باال ذکر شده است‪ .‬نگران کدهای زیر نباشید‪ .‬در درسهای آینده در مورد آنها توضیح‬
‫میدهیم‪:‬‬
‫;*‪import java.sql.‬‬ ‫‪//Step 1‬‬

‫{‬
‫{‬
‫‪try‬‬
‫{‬
‫;)(‪Class.forName("com.mysql.jdbc.Driver").newInstance‬‬ ‫‪//Step 2‬‬
‫;"=‪String url = "jdbc:mysql://localhost:3306/University?user=root&password‬‬ ‫‪//Step 3‬‬

‫;)‪Connection connection = DriverManager.getConnection(url‬‬
‫;)(‪Statement statement = connection.createStatement‬‬ ‫‪//Step 4‬‬

‫;)"‪statement.executeQuery("SELECT * FROM Students‬‬
ResultSet result = statement.getResultSet(); //Step 5

result.beforeFirst();
while (result.next())
{
System.out.println(
result.getString("StudentID") + "\t" +
result.getString("FirstName") + "\t" +
result.getString("LastName") + "\t" +
result.getString("Gender") + "\t" +
result.getString("Age") + "\t" +
result.getString("Address")
);
}
result.close(); //Step 6
statement.close();
connection.close();
}
catch (Exception ex)
{
System.out.println(ex.getMessage());
}
}
}
‫ در درسهای آینده شما را به جزییات بیشتر کدهای باال‬.‫در کد باال هر مرحله را با ایجاد یک خط فاصله از مراحل دیگر جدا کردهایم‬
‫ خروجی‬،‫ اجرا کردهایم‬،‫ که در درسهای قبل ایجاد کردیم‬Students ‫ دستورات را بر روی جدول‬3 ‫ و‬1 ‫چون در مرحله‬. ‫آشنا میکنیم‬
:‫به صورت زیر خواهد بود‬

2 Jimmie Vargas Male 18 Blue Bay Avenue
3 Monica Ward Female 16 Mapple Street
‫ چیست؟‬JDBC Driver
‫ که توسط شرکتهای سازنده پایگاه داده تولید میشوند و از آنها‬،‫ هستند‬jar ‫ فایلهای با پسوند‬،‫ یا کانکتورها‬JDBC Driver
‫ چون در این سری آموزشی ما میخواهیم ارتباط بین‬.‫برای برقراری ارتباط بین برنامههای جاوا و پایگاه داده استفاده میشود‬
‫برنامههایمان با بانک اطالعاتی ‪ MYSQL‬را برقرار کنیم‪ ،‬پس باید ‪ JDBC Driver‬مربوط به این پایگاه داده را دانلود کنیم‪ .‬برای‬
‫دانلود بر روی لینک زیر کلیک کنید‪:‬‬
‫‪http://www.dl.w3-farsi.com/Software/Java/mysql-connector-java-5.1.39-bin.jar‬‬
‫بعد از دانلود فایل باال یک پوشه به نام ‪ MYSQLConnector‬در درایو ‪ C‬ایجاد کرده و فایل را در داخل آن بگذارید‪ .‬پس مسیر فایل‬
‫شما به صورت زیر خواهد بود‪:‬‬
‫‪C:\MYSQLConnector\mysql-connector-java-5.1.39-bin.jar‬‬
‫همانطور که گفتیم برای ارتباط با بانک ما به این فایل احتیاج داریم‪ .‬برای استفاده از این فایل باید مسیر آن را به متغیر ‪CLASSPATH‬‬
‫اضافه کنیم‪ .‬برای این کار قبل و بعد از مسیر فوق دو عالمت ویرگول (;) به صورت زیر اضافه کرده‪:‬‬
‫;‪;C:\MYSQLConnector\mysql-connector-java-5.1.39-bin.jar‬‬
‫و سپس آن را متغیر مذکور مانند شکل زیر کپی میکنیم‪:‬‬
‫اگر این کار را انجام ندهید‪ ،‬مجبور میشوید که در هنگام کامپایل برنامه مسیر این فایل را با استفاده از دستور ‪ -cp‬به صورت زیر‬
‫مشخص کنید‪:‬‬
‫‪java -cp C:\MYSQLConnector\mysql-connector-java-5.1.39-bin.jar; ProgramName‬‬
‫‪ ProgramName‬نام برنامه شما است‪ .‬حال که فایل ‪ JDBC Driver‬را دانلود و پیکربندی کردید نوبت به اتصال به دیتابیس میرسد‪.‬‬
‫قبل از اتصال به دیتابیس باید یک کالس را ثبت یا رجیستر کنیم‪ .‬منظور از رجیستر کردن بارگذاری کالس در داخل حافظه رم است‪.‬‬
‫کالسی که میخواهیم بارگذاری کنیم‪ ،‬کالس ‪ Driver‬میباشد که در پکیج ‪ com.mysql.jdbc‬و این پکیج هم به نوبه خود در‬
‫داخل فایل ‪ mysql-connector-java-5.1.39-bin.jar‬قرار دارد‪ .‬برای ثبت کالس ‪ Driver‬دو راه وجود دارد‪:‬‬
‫استفاده از متد )(‪ forName‬مربوط به کالس ‪java.lang.Class‬‬ ‫‪‬‬
‫استفاده از متد )(‪ registerDriver‬مربوط به کالس ‪java.sql.DriverManager‬‬ ‫‪‬‬
‫دو کد زیر برای ثبت کالس ‪ Driver‬معادل هم هستند‪:‬‬
‫‪try‬‬
‫{‬
‫;)(‪Class.forName("com.mysql.jdbc.Driver").newInstance‬‬
‫}‬
‫)‪catch (ClassNotFoundException ex‬‬
‫{‬
‫;))(‪System.out.println(ex.getMessage‬‬
‫}‬
‫‪try‬‬
‫{‬
‫;))(‪DriverManager.registerDriver(new com.mysql.jdbc.Driver‬‬
‫}‬
‫)‪catch (SQLException ex‬‬
‫{‬
‫}‬
‫همانطور که احتماال از دو کد باال متوجه شدهاید‪ ،‬استفاده از دو متد )(‪ forName‬و )(‪ registerDriver‬ممکن است به ترتیب‬
‫باعث ایجاد دو استثنای ‪ ClassNotFoundException‬و ‪ SQLException‬شود‪ .‬پس بهتر است که آنها را در داخل دستور ‪try‬‬
‫‪ catch‬بنویسید‪ .‬به عنوان آخرین نکته یادآور میشویم که در همین حد کافیست که بدانید‪ ،‬قبل از اتصال به بانک اطالعاتی باید‬
‫کالس ‪ Driver‬مربوط به بانک را در حافظه ‪ RAM‬بارگذاری کنید‪ .‬البته این کالس در پایگاههای داده مختلف دارای نام متفاوتی‬
‫است‪ .‬مثال بارگذاری کالس ‪ Driver‬در پایگاه داده‪ Oracle‬به صورت زیر است‪:‬‬
‫;)"‪Class.forName("oracle.jdbc.driver.OracleDriver‬‬
‫حال که با کاربرد ‪ JDBC Driver‬آشنا شدید در درس بعد در مورد نحوه اتصال به بانک اطالعاتی توضیح میدهیم‪.‬‬
‫ارتباط با بانک‬
‫بعد از بارگذاری ‪ Driver‬در حافظه‪ ،‬نوبت به ارتباط با بانک اطالعاتی میرسد‪ .‬برای این کار از متد دیگر کالس ‪DriverManager‬‬
‫به نام )(‪ getConnection‬استفاده میکنیم‪ .‬این متد دارای سربارگذاری های زیر است‪:‬‬
getConnection(String url)
getConnection(String url, Properties prop)
getConnection(String url, String user, String password)
‫ این متد یک رشته که در اصل مسیر بانک اطالعاتی و مشخصات اتصال به آن است‬، ‫همانطور که در کدهای باال مشاهده میکنید‬
:‫ حالت کلی این رشته به صورت زیر است‬.‫را دریافت میکند‬
jdbc:RDBMS://hostname:port Number/databaseName
:‫کد باال نمای کلی رشته و در جدول زیر شکل دقیق تر آن برای اتصال به دیتابیسهای مختلف نشان داده شده است‬
RDBMS JDBC Driver URL
MySQL com.mysql.jdbc.Driver jdbc:mysql://hostname:port Number/ databaseName
ORACLE oracle.jdbc.driver.OracleDriver jdbc:oracle:tdin:@hostname:port Number:databaseName
DB2 COM.ibm.db2.jdbc.net.DB2Driver jdbc:db2:hostname:port Number/databaseName
Sybase com.sybase.jdbc.SybDriver jdbc:sybase:Tds:hostname: port Number/databaseName
‫ اجازه‬،‫حال که با سربارگذاری های این متد و رشتههای مختلفی که این متد جهت ارتباط با دیتابیسها دریافت میکند آشنا شدید‬
‫ برای این کار به صورت زیر عمل‬.‫ متصل شویم‬،‫دهید که با استفاده از آن به دیتابیس و جدولی که در درسهای قبل ایجاد کردیم‬
:‫میکنیم‬
Connection connection =
DriverManager.getConnection("jdbc:mysql://localhost:3306/university?user=root&password=");
:‫کد باال را به صورت خواناتری هم میتوان نوشت‬
String url = "jdbc:mysql://localhost:3306/university?user=root&password=";
Connection connection = DriverManager.getConnection(url);
‫ این مقادیر‬.‫ و پسورد را خالی قرار دادهایم‬root ‫ نام کاربری را‬،1131 ‫ مشاهده میکنید که مقدار پورت را‬url ‫در تعریف رشته یا‬
:‫ همانطور که در کد باال مشاهده میکنید‬.‫ مشخص کردیم‬MYSQL ‫همان مقادیری هستند که در هنگام نصب سرور‬
‫برای اتصال نهایی به بانک باید یک شیء از ‪ Interface‬یا رابط ‪ Connection‬ایجاد کرده و مسیر بانک را از طریق متد‬
‫)(‪ getConnection‬به آن معرفی کنیم‪ .‬کد درس قبل را به صورت زیر کامل تر میکنیم‪:‬‬
‫‪try‬‬
‫{‬
‫;"=‪String url = "jdbc:mysql://localhost/university?user=root&password‬‬

‫;)(‪connection.close‬‬
‫}‬
‫{‬
‫}‬
‫تا اینجای کار ارتباط ما با بانک برقرار شد‪ .‬یک نکته را که بهتر است در همین جا یادآور شویم این است‪ ،‬بعد از اتصال به بانک و‬
‫انج ام عملیات مختلف بر روی آن بهتر است اتصال را قطع کنیم‪ .‬همانطور که در کد باال مشاهده میکنید این کار را با استفاده از‬
‫متد )(‪ close‬مربوط به‪ Connection‬انجام میدهیم‪ ،‬که همان مرحله ‪ 1‬یعنی پاک کردن اشیاء بال استفاده و آزاد کردن حافظه‬
‫میباشد‪ .‬حتی اگر شما متد )(‪ close‬را فراخوانی نکنید‪ ،‬زباله روب یا ‪ garbage collector‬جاوا اشیاء بی استفاده را پاک‬
‫میکند ولی از لحاظ برنامه نویسی بهتر است که خودتان این کار را انجام دهید‪ .‬برای اطمینان از بسته شدن ارتباط میتوان متد‬
‫)(‪ close‬را در بلوک ‪ finally‬فراخوانی کرد‪ ،‬چون کدهای این بلوک چه خطایی در برنامه رخ دهد و چه ندهد‪ ،‬اجرا میشوند‪:‬‬
‫‪try‬‬
‫{‬
‫}‬
‫{‬
‫}‬
‫‪finally‬‬
‫{‬
‫}‬
‫اجرای دستورات بر روی بانک‬

‫بعد از برقراری ارتباط با بانک‪ ،‬نوبت به ارسال دستورات ‪ SQL‬به آن میرسد‪ .‬برای این منظور سه رابط وجود دارند که دارای متدها‬
‫و خواص مفیدی هستند که شما را قادر میسازند دستورات را به بانک ارسال کرده و نتایج حاصل از آنها را دریافت و پردازش‬
‫کنید‪ .‬در جدول زیر اسم این رابطها و کاربرد آنها ذکر شده است ‪:‬‬
‫کاربرد‬ ‫رابط‬
‫برای اجرای دستورات ساده ‪ SQL‬به کار میرود‪.‬‬ ‫‪Statement‬‬
‫برای اجرای دستورات ‪ SQL‬به صورت پویا یا دینامیک به کار میرود‪ .‬یا به نوعی میتوان گفت که برای‬ ‫‪PreparedStatement‬‬
‫اجرای دستوراتی از ‪ SQL‬به کار میرود که در زمان اجرا پارامتر دریافت میکنند‪.‬‬
‫در هنگام کار با رویههای ذخیره شده یا ‪ stored procedures‬به کار میرود‪ .‬این رابط هم میتواند‬ ‫‪CallableStatement‬‬
‫در زمان اجرا پارامتر قبول کند‪.‬‬
‫قبل از استفاده از هریک از رابطهای باال باید یک شیء از آنها ایجاد و نتایج حاصل از یک متد از رابط ‪ Connection‬را در داخل‬
‫آن قرار داد‪ .‬کدهای زیر نحوه ایجاد شیء از این رابطها و فراخوانی متدهای رابط ‪ Connection‬مربوط به هریک از آنها نمایش‬
‫داده شده است‪:‬‬
‫;)(‪Statement statement = connection.createStatement‬‬
‫;)(‪PreparedStatement preparedstatement = connection.prepareStatement‬‬
‫;)(‪CallableStatement callablestatement = connection.prepareCall‬‬
‫رابط ‪Statement‬‬
‫همانطور که در باال اشاره شد قبل از استفاده از رابط ‪ Statement‬باید متد )(‪ createStatement‬از رابط ‪ Connection‬را‬
‫فراخوانی کنید‪:‬‬

‫زمانیکه یک شیء از رابط ‪ Statement‬ایجاد کردید میتوانید دستورات ‪ SQL‬را با استفاده از سه متد زیر اجرا کنید‪:‬‬
‫توضیح‬ ‫نوع برگشتی‬ ‫متد‬
‫اگر مقدار برگشتی از این متد ‪ true‬باشد یعنی شیء ‪ ResultSet‬میتواند به دست‬ ‫‪boolean‬‬ ‫)(‪execute‬‬
‫بیاید‪ ،‬در غیر اینصورت مقدار ‪ false‬را بر میگرداند‪.‬‬
‫(در مورد شیء ‪ ResultSet‬در درس آینده توضیح میدهیم)‬
‫تعداد سطرهایی را که تحت تأثیر دستور ‪ SQL‬قرار گرفتهاند را بر میگرداند ‪.‬مثال تعداد‬ ‫‪int‬‬ ‫)(‪executeUpdate‬‬
‫سطرهایی از دیتابیس را که ‪ INSERT ،DELETE‬و یا ‪ UPDATE‬شدهاند را بر میگرداند‪.‬‬
‫از این متد معموال برای اجرای دستور ‪ INSERT‬استفاده میشود و نتایج را به صورت‬ ‫‪ResultSet‬‬ ‫)(‪executeQuery‬‬
‫یک شیء ‪ ResultSet‬بر میگرداند‪ .‬اینشی نماینده سطرهای برگشت داده شده‪ ،‬حاصل‬
‫از دستور ‪ SELECT‬است که در درس بعد درباره آن توضیح میدهیم‪.‬‬
‫رابط‪PreparedStatement‬‬
‫رابط ‪ PreparedStatement‬از رابط ‪ Statement‬ارث بری میکند و این توانایی را به شما میدهد که در زمان اجرای برنامه‬
‫پارامترهایی را برای تکمیل دستور ‪ SQL‬ارسال کنید‪ .‬قبل از استفاده از رابط ‪ Statement‬باید متد )(‪ prepareStatement‬از‬
‫رابط ‪ Connection‬را فراخوانی کنید‪:‬‬
‫‪try‬‬
‫{‬
‫;"? = ‪String SQL = "Update Students SET Age = ? WHERE StudentID‬‬
‫;)‪PreparedStatement preparedstatement = connection.prepareStatement(SQL‬‬
‫}‬
‫)‪catch (SQLException e‬‬
‫{‬
‫}‬
‫همانطور که در کد باال مشاهده میکنید دستور ‪ SQL‬دارای عالمتهای ? میباشد‪ .‬این عالمتهای سؤال با مقادیر یا پارامترهایی‬
‫که ما ارسال میکنیم جایگزین میشوند‪ .‬هر کدام از این عالمتها دارای یک اندیس میباشند‪ .‬مثال اولین عالمت سؤال دارای‬
‫اندیس ‪ ،3‬دومین عالمت دارای اندیس ‪ 5‬و … میباشد‪ .‬ارسال پارامترها با استفاده از متدهایی از رابط ‪PreparedStatement‬‬
‫که به صورت )(‪ setXXX‬هستند‪ ،‬صورت میگیرد‪ ،‬که ‪ XXX‬نوع داده ای که قرار است توسط متد ارسال شود را نشان میدهد‪ .‬مثال‬
‫برای ارسال یک پارامتر از نوع اعداد صحیح از متد )(‪ setInt‬استفاده میشود‪ .‬در زیر لیست این متدها ذکر شده است‪:‬‬
‫یک مقدار صحیح را جایگزین عالمت ؟ میکند‪.‬‬ ‫)‪setInt(int paramIndex, int value‬‬
‫یک مقدار رشته ای را جایگزین عالمت ؟ میکند‪.‬‬ ‫)‪setString(int paramIndex, String value‬‬
‫یک مقدار ‪ float‬را جایگزین عالمت ؟ میکند‪.‬‬ ‫)‪setFloat(int paramIndex, float value‬‬
‫یک مقدار ‪ double‬را جایگزین عالمت ؟ میکند‪.‬‬ ‫)‪setDouble(int paramIndex, double value‬‬
‫همانطور که مشاهده میکنید‪ ،‬این متدها دو پارامتر دریافت می کنند که اولین پارامتر اندیس عالمت سؤال و دومین پارامتر مقداری‬
‫که قرار است به جای عالمت سؤال قرار بگیرد‪ ،‬میباشد‪ .‬از آنجاییکه رابط از رابط ارث بری میکند‪ ،‬در نتیجه میتواند از متدهای آن‬
‫یعنی )(‪ execute(), executeQuery‬و )(‪ executeUpdate‬برای اجرای دستورات بر روی بانک هم استفاده کند‪ .‬کد ابتدای‬
‫درس را به صورت زیر کامل تر میکنیم‪:‬‬
‫‪try‬‬
‫{‬
‫;"=‪String url = "jdbc:mysql://localhost:3306/university?user=root&password‬‬


‫;)"‪statement.executeQuery("SELECT * FROM Students‬‬
‫}‬
‫)‪catch (Exception ex‬‬
‫{‬
‫}‬
‫در مورد رابط ‪ CallableStatement‬در درسهای آینده به طور کامل توضیح میدهیم‪.‬‬
‫پردازش نتایج حاصل از اجرای دستورات بر روی بانک‬
‫دستورات ‪ SQL‬ی که دادهها را از دیتابیس میخوانند‪ ،‬آنها را در یک ‪ Interface‬به نام ‪ ResultSet‬میریزند‪ResultSet .‬‬
‫در واقع یک سری از مجموعه نتایج است و در آن واحد فقط یک سطر را نمایش میدهد‪ .‬میتوان آن را به صورت یک جدول به‬
‫صورت زیر تصور کرد‪:‬‬
‫‪ ResultSet‬با اجرای یک ‪ Statement‬یا ‪ PreparedStatement‬یعنی فراخوانی متد )(‪ executeQuery‬به روشهای زیر ایجاد‬
‫;)"‪ResultSet result = statement.executeQuery("SELECT * FROM Students‬‬
‫یا‬
‫;"‪String sql = "SELECT * FROM Students‬‬
‫;)‪PreparedStatement statement = connection.prepareStatement(sql‬‬
‫;)(‪ResultSet result = statement.executeQuery‬‬
‫‪ ResultSet‬دارای یک نشانگر )‪ (cursor‬است که به سطر جاری اشاره میکند‪ .‬متدهای این رابط به سه گروه زیر تقسیم‬
‫میشوند‪:‬‬
‫متدهای پیمایش گر ‪ :‬برای حرکت نشانگر به کار میروند‪.‬‬ ‫‪‬‬

‫متدهای دریافت کننده مقادیر ‪ :‬برای مشاهده داده یک ستون از سطر جاری به کار میروند‪.‬‬ ‫‪‬‬
‫متدهای به روز کننده مقادیر‪ :‬برای به روز کردن داده یک ستون از سطر جاری به کار میروند‪.‬‬ ‫‪‬‬
‫نشانگر بر طبق خاصیتهای ‪ ResultSet‬در بین سطرها حرکت میکند‪ .‬این خواص در زمان ایجاد دستور یا همان ‪Statement‬‬
‫یعنی قبل از ایجاد ‪ ResultSet‬تعریف میشوند و تعیین میکنند که مثال ‪ ResultSet‬فقط خواندنی باشد یا قابل بروز رسانی و‬
‫… ‪ .‬در زیر نحوه تعریف خصوصیات ‪ ResultSet‬در متدهای رابط ‪ Connection‬آمده است‪:‬‬
‫;)‪createStatement(int RSType, int RSConcurrency‬‬
‫;)‪prepareStatement(String SQL, int RSType, int RSConcurrency‬‬
‫;)‪prepareCall(String sql, int RSType, int RSConcurrency‬‬
‫در کدهای باال ‪ RSType‬نوع و ‪ RSConcurrency‬فقط‪-‬خواندنی یا قابل به روزرسانی بودن ‪ ResultSet‬را مشخص میکند‪.‬‬
‫انواع ‪ResultSet‬‬
‫انواع ‪ ResultSet‬در جدول زیر آمده است‪ .‬اگر هیچ نوعی برای ‪ ResultSet‬تعریف نکنید‪ ،‬برای آن به طور خودکار نوع‬
‫‪ TYPE_FORWARD_ONLY‬در نظر گرفته میشود‪.‬‬
‫توضیح‬ ‫نوع‬
‫نشانگر فقط میتواند رو به جلو در داخل مجموعه نتایج حرکت کند‪.‬‬ ‫‪ResultSet.TYPE_FORWARD_ONLY‬‬
‫نشانگر میتواند به عقب و جلو حرکت کند و مجموعه جواب یا‪ResultSet‬‬ ‫‪ResultSet.TYPE_SCROLL_INSENSITIVE‬‬
‫بعد از اینکه ایجاد شد‪ ،‬نسبت به تغییرات دیتابیس حساس نیست‪.‬‬
‫نشانگر میتواند به عقب و جلو حرکت کند و مجموعه جواب یا ‪ResultSet‬‬ ‫‪ResultSet.TYPE_SCROLL_SENSITIVE‬‬
‫بعد از اینکه ایجاد شد‪ ،‬نسبت به تغییرات دیتابیس حساس است‪.‬‬
‫دومین خاصیتی هم که برای ‪ ResultSet‬میتوان تعریف کرد‪ ،‬دارای مقادیر زیر است‪:‬‬
‫توضیح‬ ‫‪Concurrency‬‬
‫مجموعه نتایج را فقط‪-‬خواندنی میکند‪.‬‬ ‫‪ResultSet.CONCUR_READ_ONLY‬‬
‫با وجود این خاصیت میتوان مجموعه نتایج را بروز کرد‪.‬‬ ‫‪ResultSet.CONCUR_UPDATABLE‬‬
‫با توجه به مطالب باال برای ایجاد یک ‪ ResultSet‬که بتوان در آن فقط رو به جلو حرکت کرد و دادههای آن فقط‪-‬خواندنی و غیر‬
‫قابل ویرایش باشند باید به صورت زیر عمل کنید‪:‬‬
‫‪try‬‬
‫{‬
‫= ‪Statement statement‬‬
‫;)‪connection.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY‬‬
‫}‬
‫)‪catch(Exception ex‬‬
‫{‬
‫}‬
‫گردش در میان سطرهای ‪ResultSet‬‬
‫‪ ResultSet‬دارای متدهایی است که با استفاده از آنها میتوان در میان مجموعه جواب یا همان سطرهای ‪ ResultSet‬حرکت‬
‫کرد‪ .‬لیست این متدها در جدول زیر آمده است‪:‬‬
‫نشانگر را به قبل از اولین سطر منتقل میکند‪.‬‬ ‫)(‪beforeFirst‬‬
‫نشانگر را به بعد از آخرین سطر منتقل میکند‪.‬‬ ‫)(‪afterLast‬‬
‫نشانگر را به اولین سطر منتقل میکند‪.‬‬ ‫)(‪first‬‬
‫نشانگر را به آخرین سطر منتقل میکند‪.‬‬ ‫)(‪last‬‬
‫نشانگر را به سطر خاصی منتقل میکند‪.‬‬ ‫)(‪absolute‬‬

‫یک عدد دریافت میکند که نشان میدهد چه تعداد سطر را نسبت به مکان فعلی نشانگر میتوان رو‬ ‫)(‪relative‬‬
‫به جلو یا عقب پرش کرد ‪.‬‬
‫نشانگر را به سطر قبل منتقل میکند و اگر سطر قبلی وجود نداشته باشد مقدار ‪ false‬را بر‬ ‫)(‪previous‬‬
‫میگرداند‪.‬‬
‫نشانگر را به سطر بعد منتقل میکند و اگر سطر بعدی وجود نداشته باشد مقدار ‪ false‬را بر‬ ‫)(‪next‬‬
‫میگرداند‪.‬‬
‫شماره سطر جاری را بر میگرداند‪.‬‬ ‫)(‪getRow‬‬
‫یک سطر جدید ایجاد میکند و نشانگر را در ابتدای آن قرار میدهد‪ .‬البته جای قبلی نشانگر در حافظه‬ ‫)(‪moveToInsertRow‬‬
‫میماند‪.‬‬
‫وقتی که یک سطر توسط متد )(‪ moveToInsertRow‬ایجاد و مقداردهی شد‪ ،‬با فراخوانی این متد‬ ‫)(‪moveToCurrentRow‬‬
‫نشانگر به جای قبلی خود باز میگردد‪.‬‬
‫مشاهده مقادیر ‪ResultSet‬‬
‫رابط ‪ ResultSet‬دارای دوازده متد است که از آنها برای دریافت مقادیر از سطر جاری استفاده میکند‪ .‬به ازای هر نوع داده‪ ،‬دو‬
‫نسخه از هر متد متد موجود است‪:‬‬
‫متدهایی که نام ستون را میگیرند و مقدار آن را بر میگردانند‪.‬‬ ‫‪‬‬
‫متدهایی که اندیس ستون را میگیرند و مقدار آن را بر میگردانند‪.‬‬ ‫‪‬‬
‫به عنوان مثال برای دریافت مقدار یک ستون از نوع ‪ int‬باید از متد )(‪ getInt‬استفاده کنید‪.‬‬
‫نام یک ستون از سطر جاری را دریافت میکند و مقدار آن را بر میگرداند ‪.‬این متد برای‬ ‫)‪getInt(String columnName‬‬
‫ستونهایی که مقادیر آنها عددی است کاربرد دارد‪ .‬مثال ستون سن افراد‪.‬‬
‫اندیس یک ستون از سطر جاری را دریافت میکند و مقدار آن را بر میگرداند ‪.‬اندیس‬ ‫)‪getInt(int columnIndex‬‬
‫ستونها از ‪ 3‬شروع میشود‪ .‬این متد برای ستونهایی که مقادیر آنها عددی است کاربرد‬
‫دارد‪ .‬مثال ستون سن افراد‪.‬‬
‫همانند متدهای باال رابط ‪ ResultSet‬دارای متدهای دیگری است که برای برگرداندن هشت نوع اصلی دیگر جاوا به کار میروند‪.‬‬
‫مثال متد )(‪ ،getString‬همانند متد باال اندیس یا نام یک ستون از سطر جاری را میگیرد و مقدار آن را بر میگرداند‪ResultSet .‬‬
‫دارای متدهای مشابه دیگری برای دریافت سایر انواع داده ‪ SQL‬مانند ‪ Clob ،TimeStamp ،Time ،Date‬و ‪ Blob‬میباشد‪.‬‬
‫بروزرسانی مقادیر ‪ResultSet‬‬
‫‪ ResultSet‬دارای مجموعه ای از متدهاست که از آنها برای آپدیت مقادیر استفاده میکند‪ .‬به ازای هر نوع داده دو متد برای‬
‫بروزرسانی آن وجود دارد‪:‬‬
‫متدهایی که نام ستون را میگیرند و عملیات بروزرسانی را انجام میدهند‪.‬‬ ‫‪‬‬
‫متدهایی که اندیس ستون را میگیرند و عملیات بروزرسانی را انجام میدهند‪.‬‬ ‫‪‬‬
‫مثال برای ستونهایی که دارای نوع رشته ای هستند‪ ،‬از این متدها به صورت زیر استفاده میشود‪:‬‬
‫اندیس ستون مورد نظر ما را دریافت کرده و مقدار داخل آن را با‬ ‫)‪updateString(int columnIndex, String s‬‬
‫چیزی که مد نظر ما است‪ ،‬تغییر میدهد‪.‬‬
‫نام ستون مورد نظر ما را دریافت کرده و مقدار داخل آن را با‬ ‫)‪updateString(String columnName, String s‬‬
‫چیزی که مد نظر ما است‪ ،‬تغییر میدهد‪.‬‬
‫متدهای دیگری همانند متدهای باال برای به روزرسانی هشت داده اصلی مانند ‪ URL ،Object ،String‬و انواع دادههای ‪ SQL‬واقع‬
‫در پکیج ‪ ،java.sql‬وجود دارند‪ .‬به روز رسانی یک سطر از مجموعه نتایج‪ ،‬به منزله تغییر ستونهای سطر جاری شیء ‪ResultSet‬‬
‫میباشد‪ .‬برای اعمال این تغییرات به یک سطر از دیتابیس اصلی باید یکی از متدهای زیر را فراخوانی کنید‪:‬‬
‫وقتی یک سطر از دیتابیس را آپدیت میکنیم‪ ،‬با فراخوانی این متد سطر معادل آن در ‪ResultSet‬‬ ‫)(‪updateRow‬‬
‫به روز میشود‪.‬‬
‫سطر جاری را از دیتابیس حذف میکند‪.‬‬ ‫)(‪deleteRow‬‬
‫با ‪ Refresh‬دادههای ‪ ،ResultSet‬هر گونه تغییر در آنها را به دیتابیس اعمال میکند‪.‬‬ ‫)(‪refreshRow‬‬
‫تمام بروزرسانی های سطر جاری را لغو میکند‪.‬‬ ‫)(‪cancelRowUpdates‬‬
‫یک سطر جدید به دیتابیس اضافه میکند‪.‬‬ ‫)(‪insertRow‬‬
‫خالصه ای از کار ‪ResultSet‬‬
‫قبل از ایجاد ‪ ،ResultSet‬خصوصیات از آن را که مد نظرمان است را در داخل متد )(‪ createStatement‬مینویسیم‪:‬‬
‫= ‪Statement statement1‬‬
‫;)‪connection.createStatement(ResultSet.FETCH_FORWARD, ResultSet.CONCUR_READ_ONLY‬‬
‫برای ایجاد ‪ ،ResultSet‬متد )(‪ executeQuery‬از رابط ‪ Statement‬را فراخوانی میکنیم‪ .‬در کل کد زیر به منزله ایجاد یک کپی‬
‫از جدول ‪ Student‬میباشد‪ ،‬یعنی تمام مقادیر موجود در جدول را در داخل یک شیء ‪ ResultSet‬میریزیم‪:‬‬
‫;)"‪ResultSet result = statement1.executeQuery("SELECT * FROM Students‬‬
‫تا اینجای کار ما ‪ ResultSet‬را ایجاد کردیم‪ .‬برای پیمایش و نمایش مقادیر هم از دستور ‪ while‬و متدهای شیء ‪ResultSet‬‬
‫استفاده میکنیم‪ .‬به کد زیر توجه کنید‪:‬‬
‫;)(‪result.beforeFirst‬‬
‫))(‪while (result.next‬‬
‫{‬
‫(‪System.out.println‬‬
‫)"‪result.getInt("StudentID‬‬ ‫‪+‬‬ ‫"‪"\t‬‬ ‫‪+‬‬
‫)"‪result.getString("FirstName‬‬ ‫‪+‬‬ ‫"‪"\t‬‬ ‫‪+‬‬
‫)"‪result.getString("LastName‬‬ ‫‪+‬‬ ‫"‪"\t‬‬ ‫‪+‬‬
‫)"‪result.getString("Gender‬‬ ‫‪+‬‬ ‫"‪"\t‬‬ ‫‪+‬‬
‫)"‪result.getInt("Age‬‬ ‫‪+‬‬ ‫"‪"\t‬‬ ‫‪+‬‬
‫)"‪result.getString("Address‬‬
‫;)‬
‫}‬
‫در کد باال ابتدا نشانگر را با استفاده از متد )(‪ beforeFirst‬به قبل از سطر اول منتقل میکنیم‪ .‬در شرط حلقه هم با استفاده از‬
‫متد )(‪ next‬تست میکنیم که آیا سطری وجود دارد‪ .‬اگر وجود داشته باشد وارد بدنه حلقه میشویم‪ .‬در داخل بدنه حلقه‪ ،‬چون‬
‫که ستونهای ‪ StudentID‬و ‪ Age‬از نوع عددی هست برای دریافت مقادیر آنها از متد )(‪ getInt‬و برای دریافت مقادیر سایر‬
‫ستونها از متد )(‪ getString‬استفاده میکنیم‪ .‬حال فرض کنید که میخواهیم از یک سطر خاص به بعد را پیمایش کنیم‪ .‬برای‬
‫اینکار ابتدا نشانگر را با استفاده از متد )(‪ absolute‬به سطر مورد نظر میبریم و سپس عملیات پیمایش را انجام میدهیم‪ .‬به‬
‫جای متد )(‪ beforeFirst‬کد باال متد (‪ absolute )1‬را نوشته و کد را اجرا کنید‪:‬‬
‫;)‪result.absolute(7‬‬
‫))(‪while (result.next‬‬
‫{‬
‫}‬
‫‪8‬‬ ‫‪Randall May‬‬ ‫‪Male‬‬ ‫‪18‬‬ ‫‪Golden Street‬‬

‫‪9‬‬ ‫‪Jessica Cole‬‬ ‫‪Female 17‬‬ ‫‪Mapple Street‬‬
‫‪10‬‬ ‫‪Oscar‬‬ ‫‪Manning Male‬‬ ‫‪18‬‬ ‫‪Mapple Street‬‬
‫حال در همین حالت به جای متد )(‪ next‬در قسمت شرط متد )(‪ relative‬را به صورت زیر نوشته و کد را اجرا کنید‪:‬‬
‫))‪while (result.relative(3‬‬
‫{‬
‫}‬
‫‪10‬‬ ‫‪Oscar‬‬ ‫‪Manning Male‬‬ ‫‪18‬‬ ‫‪Mapple Street‬‬
‫در کد باال نشانگر در سطر ‪ 1‬قرار دارد‪ .‬وقتی که ما متد )(‪ relative‬را به صورت باال فراخوانی میکنیم‪ ،‬عدد ‪ 1‬یعنی نشانگر سه‬
‫سطر پرش کند‪ .‬در نتیجه نشانگر روی سطر ‪ 33‬قرار میگیرد‪ .‬حال اگر همین عدد را منفی بدهیم‪ ،‬پرش نشانگر رو به عقب خواهد‬
‫بود‪:‬‬
‫))‪while (result.relative(-3‬‬
‫{‬

ResultSet ‫ حذف و اضافه کردن سطرهای‬،‫به روز رسانی‬
‫ از متدهایی که با کلمه‬،ResultSet ‫ برای بروز رسانی مقادیر موجود در ستونهای یک سطر از‬،‫همانطور که قبال هم اشاره کردیم‬
‫ تغییر‬Zhila ‫ که در سطر سوم قرار دارد را به‬Monica ‫ فرض کنید که میخواهیم نام‬.‫ شروع میشوند استفاده میشود‬update
:‫ برای این کار به صورت زیر عمل میکنید‬.‫دهیم‬
2
3 import java.sql.*;
4
6 {
8 {
9 try
10 {
11 DriverManager.registerDriver(new com.mysql.jdbc.Driver());
12
13 String url = "jdbc:mysql://localhost/university?user=root&password=";
14 Connection connection = DriverManager.getConnection(url);
15
16 Statement statement1 = connection.createStatement(
17 ResultSet.TYPE_FORWARD_ONLY,
18 ResultSet.CONCUR_UPDATABLE
19 );
20 ResultSet result = statement1.executeQuery("SELECT * FROM Students");
21
22 if (result.getConcurrency() == ResultSet.CONCUR_UPDATABLE)
23 {
24 result.absolute(3);
25 result.updateString("FirstName", "Zhila");
26 result.updateRow();
27 }
28 else
29 {
30 System.out.println("ResultSet non-updatable.");
31 return;
32 }
33
34 result.beforeFirst();
35
36 while (result.next())
37 {
38 System.out.println(result.getString("FirstName"));
39 }
40
41 result.close();
‫‪42‬‬ ‫;)(‪statement1.close‬‬
‫‪43‬‬ ‫;)(‪connection.close‬‬
‫‪44‬‬ ‫}‬
‫‪45‬‬ ‫)‪catch (Exception ex‬‬
‫‪46‬‬ ‫{‬
‫‪47‬‬ ‫;))(‪System.out.println(ex.getMessage‬‬
‫‪48‬‬ ‫}‬
‫‪49‬‬ ‫}‬
‫‪50‬‬ ‫}‬
‫‪Edward‬‬
‫‪Jimmie‬‬
‫‪Zhila‬‬
‫‪Joann‬‬
‫‪Cheryl‬‬
‫‪Clara‬‬
‫‪Zack‬‬
‫‪Randall‬‬
‫‪Jessica‬‬
‫‪Oscar‬‬
‫درباره خطوط ‪ 33-53‬کد باال توضیح نمیدهیم چون قبال درباره آنها صحبت کردهایم‪ .‬تنها نکته موجود در این خطوط مربوط به خط‬
‫‪ 30‬است که در آنجا به برنامه اعالم کردهایم که میخواهیم یک ‪ ResultSet‬ایجاد کنیم که بتوانیم مقادیر موجود در آن را به روز‬
‫رسانی یا ویرایش کنیم‪ .‬در خط ‪ 55‬برای اطمینان از قابل ویرایش بودن ‪ ResultSet‬با استفاده از متد )(‪getConcurrency‬‬
‫چک میکنیم که آیا ‪ ResultSet‬قابل بروزرسانی است است یا نه؟ اگر بود‪ ،‬ابتدا با استفاده از متد )(‪ ،absolute‬نشانگر را به‬
‫سطر ‪ 1‬میبریم و سپس با استفاده از متد )(‪ updateString‬می گوییم که قرار است مقدار ستون ‪ FirstName‬را به ‪Zhila‬‬
‫تغییر دهیم‪ .‬سپس با فراخوانی متد )(‪ updateRow‬تغییرات نهایی را به بانک اعمال میکنیم‪ .‬در غیر اینصورت یعنی اگر‬
‫‪ ResultSet‬قابل ویرایش نبود در قسمت ‪( else‬خطوط ‪ )50-15‬پیغام ‪ ResultSet non-updatable‬را به کاربر نمایش داده‬
‫و با استفاده از دستور ‪ return‬از اجرای سایر کدها جلوگیری میکنیم‪ .‬با فرض اینکه ستون مورد نظر ما ویرایش شده است‪ ،‬برای‬
‫نمایش این ستون و مشاهده تغییرات‪ ،‬ابتدا با استفاده از متد )(‪ ،beforeFirst‬نشانگر را به ابتدای سطرهای ‪ ResultSet‬آورده‬
‫و سپس با استفاده از یک دستور ‪ while‬که قبال توضیح داده شد‪ ،‬مقادیر را نمایش میدهیم (خطوط ‪ .)13-16‬مشاهده میکنید‬
‫که مقدار ستون اول از سطر سوم تغییر کرده است‪ .‬درباره خطوط ‪ 33-31‬در درس آینده توضیح میدهیم‪ .‬برای اضافه کردن سطر‬
‫به ‪ ResultSet‬از متدهای )(‪ moveToInsertRow‬و )(‪ insertRow‬استفاده میشود‪ .‬خطوط ‪ 53-51‬کد باال را پاک کرده و‬
‫کدهای زیر را به جای آنها بنویسید‪:‬‬
‫;)(‪result.moveToInsertRow‬‬
‫;)"‪result.updateString("FirstName", "John‬‬
‫;)"‪result.updateString("LastName", "Scith‬‬
‫;)"‪result.updateString("Gender", "Male‬‬
‫;)‪result.updateInt("Age", 25‬‬
‫;)"‪result.updateString("Address", "Golden Street‬‬
‫;)(‪result.insertRow‬‬
‫در کد باال ابتدا با استفاده از متد )(‪ moveToInsertRow‬یک سطر خالی ایجاد و سپس مقادیری را در داخل هر یک از سلولهای‬
‫آن قرار میدهیم و در نهایت با فراخوانی متد )(‪ ،insertRow‬این سطر را به جدول اصلی اضافه میکنیم‪ .‬برای حذف یک سطر‬
‫خاص هم کافیست که نشانگر را به محل سطر برده و با فراخوانی متد )(‪ deleteRow‬آن را حذف کنید‪ .‬مثال کد زیر را به جای‬
‫کدهای باال بنویسید‪:‬‬
‫;)(‪result.deleteRow‬‬
‫با اجرای برنامه سطر سوم از جدول اصلی حذف میشود‪.‬‬
‫پاک کردن اشیاء بی استفاده و آزاد کردن حافظه‬

‫همانطور که در درسهای قبل مشاهده کردید‪ ،‬برای کار با رابطهای ‪ Connection ،Statement‬و ‪ ResultSet‬از آنها اشیایی‬
‫ایجاد کردیم‪ .‬این اشیا به طور خودکار بعد از مدتی توسط زباله روب یا ‪ Garbage Collector‬از حافظه پاک میشوند ولی بهتر‬
‫است که خودتان این کار را به صورت دستی و با فراخوانی متد )(‪ close‬و به صورت زیر انجام دهید ‪.‬‬
‫;*‪import java.sql.‬‬ ‫‪//Step 1‬‬

‫{‬
‫{‬
‫‪try‬‬
‫{‬
‫;)(‪statement.close‬‬
‫;)(‪result.close‬‬
‫}‬
‫{‬
‫}‬
}
}
‫ روش بهتر برای پاک کردن‬.‫ باعث حذف اشیاء ایجاد شده از رابطهای مذکور و آزاد شدن حافظه میشود‬close() ‫فراخوانی متد‬
‫ در هر‬،‫ چه برنامه با خطا مواجه شود و چه نشود‬،‫ چون کدهای این بلوک‬.‫ میباشد‬finally ‫اشیاء فراخوانی همین متد در بلوک‬
:‫صورت اجرا میشوند‬
import java.sql.*;

{
public static void main(String[] args) throws SQLException
{
Connection connection = null;
Statement statement = null;
ResultSet result = null;
try
{
//some code
}
catch (Exception ex)
{
System.out.println(ex.getMessage());
}
finally
{
statement.close();
result.close();
connection.close();
}
}
}
‫ تا این اشیاء در بلوک‬،‫ شیئ ایجاد کرد‬try catch ‫ باید از رابطها در خارج از دستور‬،‫همانطور که در کد باال مشاهده میکنید‬
‫ چون که‬،‫ را بنویسیم‬throws SQLException ‫ هم باید عبارت‬main() ‫ همچنین در جلوی متد‬.‫ در دسترس باشند‬finally
:‫ کد باال را به صورت زیر هم میتوان نوشت‬.‫ ممکن است باعث ایجاد استثناء شود‬close() ‫استفاده از متد‬
import java.sql.*; //Step 1

{
public static void main(String[] args) throws SQLException
{
Connection connection = null;
Statement statement = null;
ResultSet result = null;
‫‪try‬‬
‫{‬
‫}‬
‫{‬
‫}‬
‫‪finally‬‬
‫{‬
‫‪try‬‬
‫{‬
‫;)(‪statement.close‬‬
‫;)(‪result.close‬‬
‫}‬
‫{‬
‫}‬
‫}‬
‫}‬
‫}‬
‫ثبت‪ ،‬حذف‪ ،‬ویرایش و انتخاب اطالعات با استفاده از ‪NetBeans‬‬

‫در این درس میخواهیم سیستم ساده مدیریت دانشجو را طراحی کنیم‪ .‬در واقع تمام مطالبی که تاکنون گفته شده را در یک مثال‬
‫و در محیط بصری ‪ NetBeans‬توضیح میدهیم‪ .‬در درسهای قبلی یک دیتابیس به نام ‪ University‬و یک جدول با نام‬
‫‪ Students‬در داخل آن ایجاد کردیم‪ .‬این جدول دارای یک ستون به نام ‪ StudentID‬میباشد‪ .‬در این مثال تمرکز اصلی بر روی‬
‫این فیلد است‪ ،‬چون که برای هر دانش جو دارای یک مقدار منحصر به فرد است و میتوان بر اساس آن عملیات ثبت‪ ،‬حذف‪ ،‬درج‬
‫و ویرایش اطالعات را انجام داد‪ .‬برنامه ‪ NetBeans‬را باز کرده و به صورت زیر یک پروژه جدید به ایجاد میکنیم ‪:‬‬
‫بر روی دکمه ‪ Next‬کلیک کرده و نام پروژه را ‪ CRUDinNetBeans‬بگذارید‪:‬‬
‫روی دکمه ‪ finish‬کلیک کرده تا وارد پروژه شوید‪ .‬در صفحه باز شده به صورت زیر یک ‪ Frame‬جدید به برنامه اضافه کنید‪:‬‬
‫بعد از زدن بر روی گزینه ‪ JFrame Form‬صفحه ای به صورت زیر باز میشود که شما میتوانید با استفاده از آن یک نام برای‬
‫‪ Frame‬انتخاب کنید‪ ،‬که ما در این مثال نام آن را ‪ MainFrame‬میگذاریم و بر روی دکمه ‪ Finish‬کلیک میکنیم ‪:‬‬
‫چون در این مثال میخواهیم از بانک ‪ MYSQL‬استفاده کنیم پس باید ‪ Connector‬این بانک راه به برنامه اضافه کنیم‪ .‬برای این‬
‫منظور به صورت زیر بر روی ‪ Libraries‬کلیک راست کرده و ‪ Connector‬را به برنامه اضافه میکنیم‪:‬‬
‫بعد از اتمام مراحل فوق‪ ،‬شکل نهایی پروژه به صورت زیر میشود‪:‬‬
‫ قرار‬Frame ‫ بر روی‬JButton ‫ و‬Jlable ،JtextBox ‫ چند کنترل‬،‫ فعال است‬MainFrame.java ‫حال در حالی که سربرگ‬
:‫دهید‬
:‫سپس طبق جدول زیر خاصیتهای این کنترلها را تنظیم کنید‬
Label Variable Name Properties
1 textBoxStudentId
2 textBoxFirstName enabled: False
3 textBoxLastName enabled: False

4 textBoxGender enabled: False
5 textBoxAge enabled: False
6 textBoxAddress enabled: False
7 buttonDelete label: Delete
8 buttonEdit label: Edit
9 buttonAddNew label: Add New
10 buttonShow label: Show
:‫ کلیک کرده تا وارد محیط کدنویسی شوید‬Source ‫بعد از تنظیم خواص کنترلها بر روی دکمه‬
:‫ کدهای زیر را به برنامه اضافه کنید‬،‫بعد از ورود به محیط کدنویسی‬
1 package crudinnetbeans;
2
3 import java.sql.*;
5
6 public class MainFrame extends javax.swing.JFrame
7 {
‫‪8‬‬ ‫;‪Connection connection = null‬‬

‫‪9‬‬ ‫;‪PreparedStatement statement = null‬‬
‫‪10‬‬ ‫;‪ResultSet result = null‬‬
‫‪11‬‬
‫‪12‬‬ ‫;‪private boolean updateReady = false‬‬
‫‪13‬‬ ‫;‪private boolean insertReady = false‬‬
‫‪14‬‬
‫‪15‬‬ ‫)(‪public MainFrame‬‬
‫‪16‬‬ ‫{‬
‫‪17‬‬ ‫‪try‬‬
‫‪18‬‬ ‫{‬
‫‪19‬‬ ‫;)(‪initComponents‬‬
‫‪20‬‬
‫‪21‬‬ ‫;))(‪DriverManager.registerDriver(new com.mysql.jdbc.Driver‬‬
‫‪22‬‬ ‫;"=‪String url = "jdbc:mysql://localhost:3306/University?user=root&password‬‬
‫‪23‬‬ ‫;)‪connection=DriverManager.getConnection(url‬‬
‫‪24‬‬ ‫}‬
‫‪25‬‬ ‫)‪catch (SQLException ex‬‬
‫‪26‬‬ ‫{‬
‫‪27‬‬ ‫;))(‪System.out.println(ex.getMessage‬‬
‫‪28‬‬ ‫}‬
‫‪29‬‬ ‫}‬
‫‪30‬‬ ‫}‬
‫به یک نکته خیلی مهم توجه کنید و آن این است که‪ ،‬در کد باال برخی از خطوط مانند خطوط ‪ 1 ،3‬و ‪ 31‬از قبل توسط ‪NetBeans‬‬
‫تولید شدهاند و شما باید بقیه خطوط را بنویسید‪ .‬در خطوط ‪ 1‬و ‪ 3‬کد باال از آنجاییکه ما با کنترلهای ‪Swing‬و بانک اطالعاتی سر‬
‫و کار داریم‪ ،‬این دو پکیج را وارد برنامه کردهایم‪ .‬برای جلوگیری از تکرار کدنویسی‪ ،‬کالسها یا متغیرهایی را که در طول برنامه با‬
‫آنها زیاد سر و کار داریم‪ ،‬در خطوط ‪ 0-31‬تعریف کردهایم‪ .‬درباره متغیرهای خطوط ‪ 35‬و ‪ 31‬در ادامه توضیح میدهیم‪ .‬در این مثال‬
‫دوست داریم که هنگامی که برنامه اجرا میشود ارتباط با بانک برقرار شود‪ .‬برای اینکه به محض اجرای برنامه ارتباط با بانک برقرار‬
‫شود‪ ،‬در بدنه سازنده فرم خطوط ‪50-31‬را مینویسیم‪ .‬درباره این کدها در درسهای قبل توضیح دادهایم‪.‬‬
‫انتخاب اطالعات‬
‫برای انتخاب یا نمایش اطالعات از دکمه ‪ Show‬استفاده میکنیم‪ .‬هدف از ایجاد این دکمه این است که کاربر با وارد کردن یک‬
‫‪ID‬در جعبه متن ‪ StudentID‬و زدن این دکمه‪ ،‬اطالعات مربوط به یک دانشجو را نمایش دهد‪ .‬بر روی دکمه ‪ Show‬دو بار کلیک‬
‫کرده و در رویداد‪ ActionPerformed‬آن کدهای زیر را بنویسید‪:‬‬
‫‪1‬‬ ‫)‪private void buttonShowActionPerformed(java.awt.event.ActionEvent evt‬‬

‫‪2‬‬ ‫{‬
‫‪3‬‬ ‫‪try‬‬
‫‪4‬‬ ‫{‬
‫‪5‬‬ ‫;"? = ‪String SQL = "SELECT * FROM Students WHERE StudentID‬‬
‫‪6‬‬
‫‪7‬‬ ‫;)‪statement = connection.prepareStatement(SQL‬‬
‫‪8‬‬ ‫;)))(‪statement.setInt(1, Integer.parseInt(textBoxStudentID.getText‬‬
‫‪9‬‬
‫‪10‬‬ ‫;)(‪result = statement.executeQuery‬‬
‫‪11‬‬
‫‪12‬‬ ‫))(‪if(result.next‬‬
‫‪13‬‬ ‫{‬
‫‪14‬‬ ‫;))"‪textBoxFirstName.setText(result.getString("FirstName‬‬
‫‪15‬‬ ‫;))"‪textBoxLastName.setText(result.getString("LastName‬‬
‫‪16‬‬ ‫;))"‪textBoxGender.setText(result.getString("Gender‬‬
‫‪17‬‬ ‫;))"‪textBoxAge.setText(result.getString("Age‬‬
‫‪18‬‬ ‫;))"‪textBoxAddress.setText(result.getString("Address‬‬
‫‪19‬‬ ‫}‬
‫‪20‬‬ ‫‪else‬‬
‫‪21‬‬ ‫{‬
‫‪22‬‬ ‫;)"!‪JOptionPane.showMessageDialog(null,"StudentID not found‬‬
‫‪23‬‬ ‫}‬
‫‪24‬‬ ‫}‬
‫‪25‬‬ ‫)‪catch (NumberFormatException | SQLException ex‬‬
‫‪26‬‬ ‫{‬
‫‪27‬‬ ‫;)"‪JOptionPane.showMessageDialog(null, "Please Enter an number or check your connection‬‬
‫‪28‬‬ ‫}‬
‫‪29‬‬ ‫}‬
‫در خط ‪ 1‬ابتدا کد ‪ SQL‬مورد نظرمان را مینویسیم‪ .‬در این خط می گوییم که دانشجویی انتخاب شود که ‪ StudentID‬آن برابر‬
‫عددی باشد که در خط ‪ 0‬و از طریق جعبه متن وارد شده است‪ .‬نکته ای که در خط ‪ 0‬وجود دارد استفاده از متد‬
‫)(‪ Integer.parseInt‬برای تبدیل مقدار وارد شده از جعبه متن به عدد صحیح است‪ .‬چون جعبه متن فقط رشته دریافت‬
‫میکند پس باید آن را با استفاده از این متد به عدد تبدیل کنیم‪ .‬استفاده از این متد باعث بروز استثناء میشود چون ممکن است‬
‫که کابربر اشتباها به جای عدد‪ ،‬حرف تایپ کند‪ .‬پس در خط ‪ 51‬و در قسمت‪ catch‬این استثناء‬
‫)‪ (NumberFormatException‬را اداره میکنیم‪ .‬در خط ‪ 33‬دستور ‪ SQL‬را اجرا میکنیم و نتایج را در شیء ایجاد شد از‬
‫‪ ResultSet‬میریزیم‪ .‬اگر عدد وارد شده توسط کاربر با ‪ ID‬یکی از دانشجوها برابر باشد‪ .‬در این صورت ‪ ResultSet‬دارای یک‬
‫رکورد هست‪ .‬پس شرط خط ‪ 35‬درست بود و وارد بدنه ‪ if‬میشویم‪ .‬در آنجا مشخص میکنیم که مثال ستون نام‬
‫)‪ (FirstName‬این رکورد در جعبه متن‪ textBoxFirstName‬نمایش داده شود و … ‪ .‬و اگر عدد وارد شده توسط کاربر در بین‬
‫‪ ID‬دانشجوها نباشد پیغام ‪ StudentID not found‬نمایش داده میشود‪ .‬حال اگر کال یک مقدار غیر عددی توسط کاربر وارد‬
‫شود و یا در ارتباط با بانک اختاللی به وجود آید قسمت ‪ catch‬اجرا میشود‪ .‬به عنوان مثال عدد ‪ 3‬را وراد کرده و دکمه ‪ Show‬را‬
‫بزنید و نتیجه را مشاهده کنید‪:‬‬

‫ثبت اطالعات‬
‫ است که کار آن اضافه کردن یا ثبت دانشجو است (مثال ثبت نام‬buttonAddNew ‫کار بعدی که میکنیم اضافه کردن کد‬
:‫ آن کدهای زیر را بنویسید‬ActionPerformed ‫ دو بار کلیک کرده و در رویداد‬buttonAddNew ‫ بر روی دکمه‬.)‫دانشجو‬
1 private void ClearFields()

2 {
3 textBoxFirstName.setText("");
4 textBoxLastName.setText("");
5 textBoxGender.setText("");
6 textBoxAge.setText("");
7 textBoxAddress.setText("");
8 }
9
10 private int GetNextStudentID()
11 {
12 String sql = "SELECT MAX(StudentID) as StudentID FROM Students";
13 try
14 {
15 statement = connection.prepareStatement(sql);
16 statement.execute();
17 result = statement.getResultSet();
18
19 if (result.next())
20 {
21 int nextID = Integer.valueOf(result.getString("StudentID"));
22 return nextID + 1;
23 }
24 }
25 catch (SQLException ex)

26 {
27 JOptionPane.showMessageDialog(null, ex.getMessage());
28 }
29 return 0;
30 }
31
32 private void buttonAddNewActionPerformed(java.awt.event.ActionEvent evt)
33 {
34 if (!insertReady)
35 {
36 buttonAddNew.setText("Enroll");
37 ClearFields();
38 textBoxStudentID.setText(String.valueOf(GetNextStudentID()));
39 textBoxStudentID.setEnabled(false);
40 textBoxFirstName.setEnabled(true);
41 textBoxLastName.setEnabled(true);
42 textBoxGender.setEnabled(true);
43 textBoxAge.setEnabled(true);
44 textBoxAddress.setEnabled(true);
45 buttonShow.setEnabled(false);
46 buttonEdit.setEnabled(false);
47 buttonDelete.setEnabled(false);
48 insertReady = true;
49 }
50 else
51 {
52 String Query = "INSERT INTO Students (FirstName, LastName, Gender, Age, Address) VALUES
53 (?, ?, ?, ?, ?) ";
54 try
55 {
56 buttonAddNew.setText("Add New");
57 statement = connection.prepareStatement(Query);
58
59 statement.setString(1, textBoxFirstName.getText());
60 statement.setString(2, textBoxLastName.getText());
61 statement.setString(3, textBoxGender.getText());
62 statement.setInt(4, Integer.parseInt(textBoxAge.getText().trim()));
63 statement.setString(5, textBoxAddress.getText());
64
65 int affectedRows = statement.executeUpdate();
66
67 if(affectedRows > 0)
68 JOptionPane.showMessageDialog(null, "Student successfully enrolled.");
69 else
70 JOptionPane.showMessageDialog(null, "Failed to enroll student.");
71 }
72 catch (NumberFormatException | SQLException ex)
73 {
74 JOptionPane.showMessageDialog(null, "Exception happend!");
75 }
76
77 textBoxStudentID.setEnabled(true);
78 textBoxFirstName.setEnabled(false);
79 textBoxLastName.setEnabled(false);
80 textBoxGender.setEnabled(false);
81 textBoxAge.setEnabled(false);
82 textBoxAddress.setEnabled(false);
83 buttonShow.setEnabled(true);
84 buttonEdit.setEnabled(true);
85 buttonDelete.setEnabled(true);
86 insertReady = false;
87 }
88 }
‫در کد باال ابتدا دو متد‪ ،‬یکی برای پاک کردن محتویات جعبههای متن ))(‪ ClearFields‬و دیگری برای به دست آوردن ‪ID‬‬
‫آخرین رکورد ثبت شده در بانک ))(‪ (GetNextStudentID‬تعریف میکنیم‪ .‬در بدنه متد )(‪ ClearFields‬یعنی خطوط ‪1-1‬‬
‫مشاهده میکنید که برای پاک کردن یک جعبه متن کافیست‪ ،‬یک رشته خالی را با استفاده از متد )(‪ setText‬به جعبه متن‬
‫اختصاص دهیم‪ .‬در بدنه متد )(‪ GetNextStudentID‬هم ابتدا یک دستور ‪ SQL‬مینویسیم که آخرین ‪ ID‬وارد شده در جدول را‬
‫به ما برگرداند (خط ‪ MYSQL .)35‬دارای یک تابع به نام )(‪ MAX‬است که بزرگترین مقدار یک ستون عددی را بر میگرداند‪ .‬در خط‬
‫‪ 35‬نام ستون ‪ StudentID‬را به این تابع میدهیم‪ .‬در خطوط ‪ 31-31‬دستور ‪ SQL‬را جرا و نتیجه را در شیء ‪ ResultSet‬میریزیم‪.‬‬
‫در خط ‪ 36‬هم چک میکنیم که آیا این شیء دارای رکوردی هست‪ ،‬اگر رکوردی داشت در داخل بدنه ‪ if‬مقدار ستون ‪StudentID‬‬
‫آن را در داخل یک متغیر به نام ‪ nextID‬میریزیم‪ .‬این متغیر در اصل بزرگترین یا آخرین ‪ ID‬موجود در بانک را در خود ذخیره‬
‫میکند‪ .‬ولی چون ما میخواهیم رکورد جدیدی اضافه کنیم پس باید ‪ ID‬رکورد جدید ‪ 3‬واحد بیشتر از آخرین ‪ ID‬موجود در بانک‬
‫باشد‪ .‬پس در خط ‪ 55‬یک واحد به این متغیر اضافه میکنیم‪ .‬حال نوبت به کدهای موجود در بدنه کنترل کننده رویداد‬
‫‪ ActionPerformed‬میرسد ‪.‬همانطور که در ابتدای درس مشاهده کردید ما یک فیلد با نام ‪ insertReady‬با مقدار‪false‬‬
‫تعریف کردیم‪ .‬با استفاده از این فیلد نحوه اجرای دستورات موجود در کنترل کننده رویداد ‪ ActionPerformed‬را کنترل میکنیم‪.‬‬
‫ابتدا در خط ‪ 13‬مقدار موجود در شرط را با گذاشتن عالمت ! در کنار نام ‪ insertReady‬به ‪ true‬تغییر میدهیم‪ .‬این کار باعث‬
‫میشود که وقتی برای اولین بار بر روی دکمه ‪ Add New‬کلیک شد‪ ،‬کدهای خطوط ‪ 11-30‬اجرا شوند‪ .‬در خط ‪ 11‬ابتدا متن روی‬
‫دکمه را به ‪( Enroll‬ثبت نام) تغییر میدهیم‪ .‬در خط ‪ 11‬محتویات تمام جعبههای متن را با فراخوانی متد )(‪ClearFields‬‬
‫پاک میکنیم‪ .‬در خط ‪ 10‬یک واحد بیشتر از آخرین ‪ ID‬موجود در بانک را با فراخونی متد )(‪ GetNextStudentID‬در جعبه‬
‫متن ‪ textBoxStudentID‬قرار میدهیم‪ .‬سپس دکمهها و جعبههای متنی که برای کاربر کاربردی دارند را غیر فعال میکنیم‪ .‬شکل‬
‫نهایی برنامه بعد از اولین کلیک به صورت زیر است‪:‬‬

‫‪ True‬کردن فیلد ‪ insertReady‬در خط ‪ 30‬باعث میشود که وقتی برای بار دوم بر روی دکمه ‪ Add New‬کلیک کنیم مقدار‬
‫موجود در شرط خط ‪ 13‬برابر ‪ false‬شده و خطوط موجود در خطوط ‪ 15-01‬اجرا شوند‪ .‬اینکه در درسهای قبل گفتیم که با‬
‫استفاده از ‪ PrepareStatement‬میتوان دستوراتی را اجرا کرد که در زمان اجرای برنامه تکمیل میشوند‪ ،‬را میتوان در خطوط‬
‫‪ 15-15‬به طور کامل درک کرد‪ .‬در خط ‪ 15‬ابتدا یک دستور وارد کردن اطالعات )‪ (INSERT‬مینویسیم و به جای مقادیر عالمت‬
‫سؤال میگذاریم‪ .‬این عالمت سؤالها به ترتیب توسط مقادیر که توسط کاربر وارد جعبههای متن میشوند پر میشوند‪ .‬مثال‬
‫مقدار وارد شده در جعبه متن ‪ textBoxFirstName‬در اولین عالمت سؤال‪ ،‬مقدار وارد شده در جعبه متن دوم در دومین عالمت‬
‫سؤال و الی آخر قرار میگیرد‪ .‬در خط ‪ 13‬دستور را با فراخوانی متد )(‪ executeUpdate‬اجرا میکنیم‪ .‬این متد در صورتیکه‬
‫سطری به بانک اضافه شود مقدار ‪ 3‬را بر میگرداند‪ .‬در نتیجه در خط ‪ 11‬چک میکنیم که آیا مقدار برگشتی از متد بزرگتر از ‪3‬‬
‫است یا نه؟ اگر بزرگتر بود به این معناست که سطری به بانک اضافه شده است و این اضافه شدن را با نشان دادن یک پیغام به‬
:)11 ‫کاربر اعالم میکنیم (خط‬
.‫ اجرا شود‬if ‫ میکنیم که دفعه بعد قسمت‬false ‫ را‬insertReady ‫بعد از اتمام کارها‬
‫ویرایش اطالعات‬
.‫ کار میکند‬Add New ‫ هم مانند دکمه‬Edit ‫دکمه‬
1 private void buttonEditActionPerformed(java.awt.event.ActionEvent evt)

2 {
3 if (!updateReady)
4 {
5 buttonEdit.setText("Update");
6 textBoxStudentID.setEnabled(false);
7 textBoxFirstName.setEnabled(true);
8 textBoxLastName.setEnabled(true);
9 textBoxGender.setEnabled(true);
10 textBoxAge.setEnabled(true);
11 textBoxAddress.setEnabled(true);
12 buttonShow.setEnabled(false);
13 buttonAddNew.setEnabled(false);
14 buttonDelete.setEnabled(false);
15 updateReady = true;
16 }
17 else
18 {
19 String Query =
20 "UPDATE Students SET FirstName=?, LastName=?, Gender=?, Age=?, Address=? WHERE StudentID = ?";
21 try
22 {
23 buttonEdit.setText("Edit");
25
26 statement.setString(1, textBoxFirstName.getText());
27 statement.setString(2, textBoxLastName.getText());
28 statement.setString(3, textBoxGender.getText());
29 statement.setInt(4, Integer.parseInt(textBoxAge.getText().trim()));
30 statement.setString(5, textBoxAddress.getText());
31 statement.setInt(6, Integer.parseInt(textBoxStudentID.getText().trim()));
32
34
35 if(affectedRows>0)
36 JOptionPane.showMessageDialog(null, "Student details successfully updated.");
37 else
38 JOptionPane.showMessageDialog(null, "Update failed.");
39 }
41 {
43 }
44
45 textBoxStudentID.setEnabled(true);
46 textBoxFirstName.setEnabled(false);
47 textBoxLastName.setEnabled(false);
48 textBoxGender.setEnabled(false);
49 textBoxAge.setEnabled(false);
50 textBoxAddress.setEnabled(false);
51 buttonShow.setEnabled(true);
52 buttonAddNew.setEnabled(true);
53 buttonDelete.setEnabled(true);
54 updateReady = false;
55 }
56 }
‫ رکوردی از بانک است‬ID ‫ یک عدد که همان‬textBoxStudentID ‫کار با این دکمه به این صورت است که ابتدا کاربر در جعبه متن‬
‫ سپس در داخل جعبههای متن مقادیر مورد نظر را وارد کرده و در نهایت با زدن دکمه‬.‫که قرار است ویرایش شود را وارد میکند‬
‫ ها فعال میشوند و تمام‬textbox ‫ کلیک میکنیم همه‬Edit ‫ وقتی برای اولین بار بر روی دکمه‬.‫تغییرات را به بانک ارسال میکند‬
‫ با کمی توجه به کدهای باال متوجه میشوید که کدنویسی این دکمه بسیار شبیه به‬.‫ غیر فعال میشوند‬Edit ‫دکمهها به جز دکمه‬
.‫ است‬SQL‫ است و فقط تفاوت در دستور‬Add New ‫دکمه‬
‫حذف اطالعات‬
‫ بر روی این دکمه دو‬.‫ این کار را برای ما انجام میدهد‬Delete ‫ دکمه‬.‫و در نهایت کد مربوط به پاک کردن دانشجو را مینویسی‬
:‫بار کلیک کرده و کدهای زیر را بنویسید‬

1 private void buttonDeleteActionPerformed(java.awt.event.ActionEvent evt)

2 {
3 String Query = "DELETE FROM Students WHERE StudentID = ?";
4 try
5 {
7 statement.setInt(1, Integer.parseInt(textBoxStudentID.getText().trim()));
8
10
11 if(affectedRows > 0)
12 JOptionPane.showMessageDialog(null, "Student successfully deleted.");
13 else
14 JOptionPane.showMessageDialog(null, "Failed to delete student.");
15 }
17 {
19 }
20 }
‫ یک دستور نوشتهایم که در آن گفتهایم سطری‬1 ‫ در خط‬.‫ است‬1 ‫ و‬1 ‫ تنها توضیح مربوط به خطوط‬.‫توضیح کد باال هم تکراری است‬
.‫ وارد شده است‬textBoxStudentID ‫ آن برابر عددی باشد که توسط کاربر در جعبه متن‬StudentID ‫از جدول حذف شود که‬
‫ سطر مذکور‬Delete ‫ در نتیجه بعد از زدن دکمه‬.‫ جایگزین میشود‬1 ‫ با مقدار گرفته شده از کاربر در خط‬1 ‫یعنی عالمت سؤال خط‬
:‫حذف میشود‬

.Archivetempjava Be Zabane Sade

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

.Archivetempjava Be Zabane Sade

Uploaded by

Copyright:

Available Formats

‫جاوا به زبان ساده‬

‫‪ :‬ابراهیمی‪ ،‬یونس ‪0631 -‬‬ ‫سر شناسه‬

‫‪ :‬نبض دانش‪ ،‬تهران ‪0613 -‬‬ ‫مشخصات نشر‬

‫‪ 303 :‬صفحه مصور‬ ‫مشخصات ظاهری‬

‫‪ :‬فیبا‬ ‫وضعیت فهرست نویسی‬

‫‪ :‬جاوا (زبان برنامه نویسی کامپیوتر)‬ ‫موضوع‬

‫‪:‬‬ ‫رده بندی دیویی‬

‫‪:‬‬ ‫رده بندی کنگره‬

‫‪:‬‬ ‫شماره کتاب شناسی ملی‬

‫مورد پیگرد قانی قرار خواهد گرفت‪.‬‬

‫‪ :‬جاوا به زبان ساده‬ ‫عنوان‬

‫‪ :‬یونس ابراهیمی‬ ‫مؤلف‬

‫‪ :‬نبض دانش‬ ‫ناشر‬

‫‪0613 :‬‬ ‫سال چاپ‬

‫‪ :‬دوم‬ ‫نوبت چاپ‬

‫‪011 :‬‬ ‫تیراژ‬

‫‪ 00555 :‬ناموت‬ ‫قیمت‬

‫همسر و پسر عزیزم‬

‫‪ JVM‬چیست ؟ ‪31 ....................................................................................................................................................‬‬

‫‪ NetBeans‬و ‪31 .................................................................................................................................................. JDK‬‬

‫نصب ‪ NetBeans‬و ‪31 ...................................................................................................................................... JDK‬‬

‫پیکربندی‪51 .................................................................................................................................................... JDK‬‬

‫ساخت یک برنامه ساده در‪13 ................................................................................................................................ JAVA‬‬

‫استفاده از ‪ IntelliSense‬در ‪31 ...................................................................................................................... NetBeans‬‬

‫رفع خطاها ‪31 ..........................................................................................................................................................‬‬

‫کاراکترهای کنترلی ‪13.................................................................................................................................................‬‬

‫توضیحات ‪15 ...........................................................................................................................................................‬‬

‫متغیر ‪11 .....................................................................................................................................................................‬‬

‫انواع ساده ‪11 ..........................................................................................................................................................‬‬

‫استفاده از متغیرها ‪11 ...............................................................................................................................................‬‬

‫ثابت ‪13 ..................................................................................................................................................................‬‬

‫تبدیل ضمنی ‪15........................................................................................................................................................‬‬

‫تبدیل صریح ‪11 .......................................................................................................................................................‬‬

‫عبارات و عملگرها ‪11.......................................................................................................................................................‬‬

‫عملگرهای ریاضی ‪11..................................................................................................................................................‬‬

‫عملگرهای تخصیصی ‪16..............................................................................................................................................‬‬

‫عملگرهای مقایسه ای ‪13 .............................................................................................................................................‬‬

‫عملگرهای منطقی ‪15 .................................................................................................................................................‬‬

‫عملگرهای بیتی ‪13 ....................................................................................................................................................‬‬

‫تقدم عملگرها ‪03.......................................................................................................................................................‬‬

‫گرفتن ورودی از کاربر ‪05..................................................................................................................................................‬‬

‫ساختارهای تصمیم ‪03 ...................................................................................................................................................‬‬

‫دستور ‪01 ............................................................................................................................................................ if‬‬

‫دستور‪00 ..................................................................................................................................................... if else‬‬

‫دستور ‪ if‬تو در تو ‪06 ..................................................................................................................................................‬‬

‫دستور ‪ if‬چندگانه ‪63 ...................................................................................................................................................‬‬

‫استفاده از عملگرهای منطقی ‪61 ...................................................................................................................................‬‬

‫دستور ‪61..................................................................................................................................................... switch‬‬

‫تکرار ‪333 ......................................................................................................................................................................‬‬

‫حلقه ‪333 ....................................................................................................................................................... While‬‬

‫حلقه‪335 .................................................................................................................................................. do While‬‬

‫حلقه ‪331 ............................................................................................................................................................ for‬‬

‫آرایهها ‪331 ...............................................................................................................................................................‬‬

‫حلقه ‪336 .................................................................................................................................................... foreach‬‬

‫آرایههای چند بعدی ‪333...............................................................................................................................................‬‬

‫آرایه دندانه دار ‪331 .....................................................................................................................................................‬‬

‫مقدار برگشتی از یک متد ‪353 .......................................................................................................................................‬‬

‫پارامتر و آرگومان ‪351 .................................................................................................................................................‬‬

‫ارسال آرگومان به روش مقدار ‪351..................................................................................................................................‬‬

‫ارسال آرایه به عنوان آرگومان ‪351...................................................................................................................................‬‬

‫محدوده متغیر ‪356.....................................................................................................................................................‬‬

‫آرگومان های متغیر)‪313.............................................................................................................................. (VarArgs‬‬

‫سربارگذاری متدها ‪315 ...............................................................................................................................................‬‬