آموزش جاوا (فصل ۲)

آشنایی با روش‌های نام‌گذاری متغیرها در زبان برنامه‌نویسی جاوا


در زبان‌های برنامه‌نویسی مختلف متغیرها عناصری می‌باشند که با به‌کارگیری آن‌ها می‌توان یکسری دیتای مورد استفاده در برنامه را ذخیره‌سازی و نگهداری کرد به طوری که داده‌های منتسب به آن‌ها در برخی مواقع قابلیت تغییر داشته و توسط برنامه‌نویس یا کاربر تغییر داده می‌شوند که از همین روی نام «متغیر» برای این عناصر انتخاب شده است. به طور کلی، دیتای تخصیص‌یافته به هر یک از متغیرها در فضایی از حافظۀ سیستم به عنوان یک Value یا «مقدار» ذخیره شده و در صورت جایگزینی این مقدار با دیتایی جدید، دیتای پیشین به طور کامل از بین می‌رود.

به منظور استفاده از متغیرها در زبان برنامه‌نویسی جاوا همواره می‌باید نکاتی را مد نظر قرار دهیم بدین صورت که هر یک از متغیرها شامل نوع، نام و مقدار می‌باشند و تعریف متغیری که یکی از این سه مورد را نداشته باشد به منزلۀ ایجاد متغیری ناقص است (همان‌طور که پیش‌تر اشاره کردیم، نام هر متغیر واژه‌ای از جنس Identifier می‌باشد.)

در این مرحله، جهت درک بهتر مفهوم متغیرها، با توجه به آنچه تاکنون آموخته‌ایم، یک برنامۀ جدید جاوا در محیط آی‌دی‌ای خود با نامی دلخواه مانند Variables ایجاد کرده سپس کلاسی داخل آن می‌سازیم و نام کلاس را به دلخواه Variable انتخاب می‌نماییم (توجه داشته باشیم که نام کلاس می‌باید با حرف اول بزرگ نوشته شود.) در ادامه، جهت وارد کردن اطلاعات مورد نیاز خود در برنامه می‌توانیم از دیتا تایپ‌های مختلف استفاده کرده و یکسری متغیر مد نظر خود را تعریف کنیم که در ادامه به طور خلاصه برخی از آن‌ها را مورد بررسی قرار می‌دهیم که عبارتند از:

 نوع دادۀ عدد صحیح: دیتا تایپ int به منظور تعریف متغیر جهت ذخیرۀ دیتایی از نوع اعداد صحیح مورد استفاده قرار می‌گیرد (برای نگهداری نوع دادۀ عدد صحیح دیتا تایپ‌های دیگری همچون byte و short یا long در زبان برنامه‌نویسی جاوا تعریف شده‌اند.)
– نوع دادۀ عدد اعشاری: دیتا تایپ double جهت ذخیره‌سازی اطلاعاتی از جنس اعداد اعشاری به کار گرفته می‌شود (زبان جاوا علاوه بر دیتا تایپ double قابلیت تعریف متغیر جهت نگهداری اعداد اعشاری با به‌کارگیری دیتا تایپ دیگری تحت عنوان float را دارا است که تفاوت این دو دیتا تایپ در دقت بالای نوع دادۀ double می‌باشد.) 

همچنین برای تعریف متغیرها و به منظور جلوگیری از حجیم شدن سورس‌کد می‌توانیم آن‌ها را با یکدیگر ادغام نماییم اما توجه داشته باشیم که در این صورت داده‌های اختصاص‌یافته به تمامی متغیرها می‌باید دیتا تایپی یکسان داشته باشند. به طور مثال، نمی‌توان متغیری با دیتایی از جنس int را با یک متغیر دیگر ادغام کرد که داده‌ای از جنس double را نگهداری می‌کند. برای روشن‌تر شدن این مسئله، در مثال زیر با استفاده از نوع دادۀ int سه متغیر تعریف کرده و یکسری عدد صحیح را به هر یک اختصاص داده‌ایم که به صورت زیر می‌توانیم آن‌ها را ادغام نماییم:

int apple = 8, banana = 10, orange = 12;

در کد فوق، سه متغیر تحت عناوین banana ،apple و orange تعریف کرده و سه مقدار از نوع دادۀ عدد صحیح به ترتیب معادل اعداد 8، 10 و 12 را به آن‌ها اختصاص داده‌ایم و در ادامه هر یک را با علامت , از یکدیگر جدا کرده‌ و پس از آخرین متغیر نیز یک علامت ; قرار داده‌ایم.

– نوع دادۀ کاراکتر: در برنامه‌نویسی گاهی نیاز داریم تا مقادیری از جنس حرف یا کاراکتر را در یک متغیر ذخیره‌سازیم که برای این منظور می‌توانیم از نوع دادۀ char استفاده کنیم؛ به عبارت دیگر، به منظور ذخیره کردن صرفاً یک کاراکتر یا برخی علائم خاص در حافظهٔ سیستم می‌توانیم دیتای مد نظر خود را در قالب مقداری از نوع char به متغیری منتسب کنیم بدین صورت که حتماً می‌باید دیتای مذکور را داخل علائم ' ' قرار دهیم. نکتهبرای نوشتن کلمه‌ای حاوی بیش از یک کاراکتر به هیچ وجه نمی‌توان دیتا تایپ char را مورد استفاده قرار داد.

– نوع دادۀ بولین: در فرآیند توسعۀ نرم‌افزار گاهی با شرایطی مواجه می‌شویم که نیاز است تا به منظور پیشبرد اهداف نرم‌افزار چک کنیم که «آیا کاربر پسورد خود را به طور صحیح وارد کرده است یا خیر؟» که پاسخ به پرسش‌هایی از این دست در قالب دو مقدار «آری» یا «خیر» می‌باشند و بدین ترتیب سایر دستورات برنامه نیز بر اساس دیتای مربوطه اجرا می‌شوند. در چنین شرایطی، به منظور نگهداری دیتایی در قالب مقادیر آری (درست) یا خیر (نادرست) نیاز به استفاده از دیتا تایپی تحت عنوان boolean داریم چرا که این نوع داده قابلیت ذخیرۀ اطلاعات مرتبط با درست یا اشتباه بودن یک رویداد را دارا است. هشدارگرچه مقادیر نوع دادۀ بولین true یا false هستند، اما نمی‌توان آن‌ها را همچون دیتا تایپ‌های char و String داخل علامت‌های ‘ ‘ و ” ” قرار داد چرا که استفاده از مقادیری به صورت ‘true’ منجر به بروز مشکل در حین کامپایل برنامه می‌شود.

به طور کلی، در زبان برنامه‌نویسی جاوا، اصطلاحاً هشت Primitive Type به معنای «تایپ اولیه» داریم که عبارتند از:

– short
– int
– long 
– float 
– double 
– char 
– boolean 
– byte 

از میان این هشت دیتا تایپ انواع دادۀ double و char و همچنین سایر دیتا تایپ‌هایی همچون booleanو int از اهمیت بیشتری برخوردارند.

روش نام‌گذاری صحیح متغیرها در زبان جاوا

نام‌گذاری صحیح کلاس‌ها، متدها و متغیرها در این زبان یکی از مواردی است که رعایت آن اثربخشی فرآیند توسعۀ نرم‌افزار را افزایش داده و منجر به تولید سورس‌کدی تمیز، قابل‌فهم و با قابلیت نگهداری بالا می‌شود که در همین راستا در ادامه قصد داریم تا راه‌کارهایی جهت نام‌گذاری صحیح متغیرها و دیگر بخش‌های برنامه ارائه دهیم.

به طور کلی، برای هر متغیر می‌باید نامی در نظر گرفته شود که با حرف کوچک شروع شده و همچنین متناسب با دیتایی باشد که قرار است تا در متغیر مذکور نگهداری شود. برای مثال، فرض کنیم که قصد داریم تا دیتایی همچون تعداد مسافرین یک هتل را در برنامۀ خود مورد استفاده قرار دهیم که در چنین شرایطی می‌توانیم از دیتا تایپ int استفاده کرده و مثلاً عدد 300 را به متغیری تحت عنوان people منتسب کنیم که برای این منظور نیاز است تا دستوری به صورت زیر بنویسیم:

int people = 300;

در دستور فوق، با به‌کارگیری دیتا تایپ int متغیری تحت عنوان people تعریف کرده و عدد 300 را با استفاده از عملگر= بدان اختصاص داده و در انتهای دستور نیز یک علامت ; قرار داده‌ايم که با اجرای چنین دستوری کامپایلر جاوا ایرادی برای نام متغیر نمی‌گیرد اما بر اساس آنچه که در بالا بدان اشاره کردیم، انتخاب این نام به منظور ذخیرۀ دیتا صحیح نمی‌باشد چرا که عنوان people توصیف‌کنندۀ ماهیت متغیر نبوده و از همین روی انتخاب نامی همچونguestNumber برای نگهداری دیتای مربوط به تعداد مسافرین هتل به مراتب بهتر است چرا که ماهیت آن با دیتای ذخیره‌شده در برنامه همخوانی دارد.

همچنین استفاده از اسپیس یا سایر علائمی نظیر  و . و همچنین , در نام‌گذاری متغیرهایی با بیش از یک کلمه مجاز نمی‌باشد بلکه واژگان مورد استفاده در نام متغیر باید به یکدیگر بچسبند اما از سوی دیگر خواندن یکسری واژۀ به هم چسبیده کمی دشوارتر از حالت معمولی می‌باشد که برای رفع چنین مشکلاتی حروف اول واژگان دوم به بعد از اسامی متغیرها به صورت حروف بزرگ نوشته می‌شوند؛ به عبارت بهتر، واژۀ اول با حروف کوچک و سایر واژگان با حروف اول بزرگ نوشته می‌شوند که این سبک نام‌گذاری اصطلاحا camelCase نامیده شده و خواندن نام متغیرها را به مراتب آسان‌تر می‌سازد. برای روشن شدن این مسئله، در ادامه یکسری متغیر بر اساس قوانین فوق تعریف کرده‌ایم:

public class Variable {
    int appleNumber = 100;
    double moneyAmount = 22.3;
    char letterName = 'A';
    boolean isMale = true;
}

همان‌طور که مشاهده می‌کنید، در ابتدا با استفاده از نوع دادۀ int متغیری تحت عنوان appleNumber تعریف کرده و عدد 100 را بدان اختصاص داده‌ایم و در سطر بعد با دیتا تایپ double متغیری به نام moneyAmount ایجاد کرده و در ادامه عدد اعشاری 22.3 را به متغیر مذکور منتسب کرده‌ایم. به همین ترتیب،‌ نوع دادۀ char را به منظور تعریف متغیر دیگری به نام letterName مورد استفاده قرار داده و کاراکتر «A» را داخل علائم ' ' به این متغیر منتسب نموده‌ایم و در نهایت هم به منظور نگهداری مقدار بولین true دیتا تایپ boolean را به کار گرفته و آن را به متغیری تحت عنوانisMale اختصاص داده‌ایم.

معرفی کلاس String در زبان برنامه‌نویسی جاوا


در آموزش قبل با برخی از دیتا تایپ‌های به اصطلاح Primitive Type آشنا شدیم و در این آموزش قصد داریم تا با مجموعۀ دیتا تایپ‌های دیگری از نوع Reference Type آشنا شده و یکی از پرکاربردترین آن‌ها به نام String را معرفی کرده و در ادامه به تشریح کاربردهای این نوع داده در قالب چند مثال کاربردی بپردازیم.

به طور کلی، دیتا تایپ String به منظور نگهداری و ذخیره‌سازی مقادیر داده‌ای متشکل از کاراکترها، کلمات، عبارات، جملات، اعداد، علائم و غیره مورد استفاده قرار می‌گیرد که با کنار هم قرار دادن آن‌ها می‌توان جمله‌ای را تشکیل داد و از همین روی چنانچه نیاز به استفاده از جمله‌ای در برنامه داشته باشیم، با به‌کارگیری نوع دادۀ String می‌توانیم متغیری تعریف کرده و دیتای مورد نظر را در آن ذخیره کنیم (توجه داشته باشیم که این نوع داده بر خلاف سایر دیتا تایپ‌ها با حرف بزرگ شروع می‌شود.)

در حقیقت، انواع دادۀ به اصطلاح Reference Type متفاوت از هشت دیتا تایپ Primitive Type بوده و از جنس کلاسی از پیش تعریف‌شده در زبان برنامه‌نویسی جاوا می‌باشند که به منظور تعریف متغیر با استفاده از آن‌ها می‌باید نمونه‌ای از روی کلاس مد نظر ساخته و مقادیر داده‌ای را بدان اختصاص داد. حال جهت تعریف متغیر با به‌کارگیری این دیتا تایپ نیاز است تا نمونه‌ای از روی کلاس String ایجاد کرده و استرینگ مربوطه را به آن منتسب کرد به طوری که به طور مثال داریم:

String myString = "My Name Is Behzad";

در دستور فوق، آبجکتی تحت عنوان myString از روی کلاس از پیش تعریف‌شدۀ String ایجاد کرده و استرینگ «My Name Is Behzad» را داخل علائم " " بدان اختصاص داده‌ایم (در آموزش‌های آتی به تفصیل مفاهیم کلاس، آبجکت و ساخت نمونه از روی یک کلاس را تشریح خواهیم کرد.) 

یکی از ابتدایی‌ترین راه‌کارها به منظور نمایش دادن جمله‌ای در زبان برنامه‌نویسی جاوا، استفاده از دستور زیر می‌باشد که در آموزش‌های گذشته به بررسی ساختار و نحوۀ عملکرد آن پرداختیم:

System.out.println();

اکنون جهت نمایش استرینگ «My Name Is Behzad» در کنسول، کدی مانند زیر خواهیم داشت:

public class Test {
    public static void main(String[] args) {
        String myString = "My Name Is Behzad";
        System.out.println(myString);
    }
}

در نتیجۀ اجرای کد فوق، استرینگ منتسب به متغیر myString به صورت زیر در کنسول نمایش داده می‌شود:

My Name Is Behzad

نکتۀ قابل‌توجه در رابطه با استرینگ فوق این است که علائم " " به همراه استرینگ مذکور در کنسول نمایش داده نمی‌شوند. به علاوه، چنانچه بخواهیم از طولانی شدن سورس‌کد جلوگیری کنیم، به جای تعریف آبجکتی از جنس Stringو در ادامه اختصاص مقدار استرینگ مد نظر به آن سپس پاس دادن آبجکت مذکور به متد ()println به راحتی می‌توانیم استرینگ مورد نظر خود را به عنوان آرگومان ورودی به متد ()println پاس دهیم. به عبارت دیگر، کد فوق را می‌توانیم به شکل زیر تغییر دهیم: 

public class Test {
    public static void main(String[] args) {
        System.out.println("My Name Is Behzad");
    }
}

خروجی حاصل از اجرای هر دو کد یکسان می‌باشد. همچنین نکتۀ حائز اهمیت در رابطه با متد ()println این است که با به‌کارگیری متد مذکور می‌توان دو یا چند استرینگ دلخواه را در کنسول به نمایش در آورد که برای درک بهتر این موضوع کد زیر را مد نظر قرار می‌دهیم:

public class Test {
    public static void main(String[] args) {
        System.out.println("My Name Is Behzad");
        System.out.println("My Last Name is Moradi");
    }
}

در این مثال، هر دو استرینگ مربوطه داخل علائم " " قرار گرفته و به عنوان آرگومان ورودی به متد ()println داده شده‌اند که در نتیجۀ اجرای این کد خواهیم داشت:

My Name Is Behzad
My Last Name is Moradi

در واقع، اجرای دستورات فوق منجر به چاپ استرینگ‌های مربوطه در دو سطر جداگانه شده‌اند که این موضوع بیانگر تفاوت متدهای ()println و ()print می‌باشد به طوری که متد ()println به منظور نمایش استرینگ‌ها در دو سطر جدا به کار گرفته می‌شود در حالی که متد ()print استرینگ مد نظر را به صورت پشت سر هم و  در یک خط چاپ می‌کند که  برای روشن شدن وجه تمایز دو متد، مثال قبل را به صورت زیر با به‌کارگیری متد ()print بازنویسی می‌کنیم:

public class Test {
    public static void main(String[] args) {
        System.out.print("My Name Is Behzad ");
        System.out.print("My Last Name is Moradi");
    }
}

در نتیجۀ اجرای کد فوق، استرینگ‌های مربوطه به صورت زیر در کنسول نمایش داده می‌شوند:

My Name Is Behzad My Last Name is Moradi

همان‌طور که می‌بینیم، استفاده از متد ()print منجر به چاپ دو استرینگ به صورت پشت سر هم شده است و علائم" " نیز به همراه استرینگ‌های مربوطه در کنسول نمایش داده نمی‌شوند اما در برخی شرایط نیاز به استفاده از علائم دابل‌کوتیشن جهت تأکید روی واژه‌ای خاص در استرینگ مد نظر داریم که برای این منظور می‌توانیم کلمۀ مورد نظر را داخل علائمی به صورت "\ "\ قرار دهیم. برای مثال، در کد زیر قصد داریم تا واژه‌ٔ «Java» را داخل علائم مذکور در کنسول نمایش دهیم:

public class Test {
    public static void main(String[] args) {
        System.out.print("I like the \"Java\" Programming Language");
    }
}

در واقع، در کد فوق استرینگی به صورت «I like the “Java” Programming Language» با تأکید روی واژۀ «Java» تعریف کرده‌ایم که برای این منظور نیز واژۀ مورد نظر را داخل علائم "\ "\ از استرینگ مربوطه قرار داده‌ایم که خروجی حاصل از اجرای کد فوق به صورت زیر خواهد بود:

I like the "Java" Programming Language

همان‌طور که انتظار داشتیم، واژۀ «Java» داخل دابل‌کوتیشن قرار گرفته و به همراه استرینگ مربوطه در کنسول نمایش داده می‌شود. همچنین می‌توان از علائم دیگری نظیر t\ و n\ پس از واژۀ مورد نظر استفاده کرد و نحوۀ کار آن‌ها نیز بدین صورت است که با قرار دادن هر یک از علائم مذکور پس از واژۀ مد نظر، به ترتیب یک تَب و یک سطر فاصله پس از آن در استرینگ متناظر ایجاد شده و در کنسول نمایش داده می‌شوند. به عنوان مثال، اگر بخواهیم دو کلمۀ «Programming Language» را در سطر بعد چاپ نماییم، از دستور زیر استفاده خواهیم کرد:

public class Test {
    public static void main(String[] args) {
        System.out.print("I like the \"Java\" \nProgramming Language");
    }
}

در نتیجۀ اجرای کد فوق، استرینگی به صورت زیر و در دو سطر جداگانه در کنسول چاپ می‌شود:

I like the "Java"
Programming Language

همان‌طور که انتظار داشتیم، قرار دادن علائم n\ پس از کلمۀ «Programming» منجر به چاپ ادامهٔ استرینگ‌ها پس از آن در سطر بعدی شده است.

آشنایی با نحوهٔ کانکت کردن استرینگ‌ها در زبان جاوا

واژۀ Concatenation در زبان برنامه‌نویسی جاوا به مفهومی اطلاق می‌گردد که در آن دو یا چند مقدار به یکدیگر الحاق شده و یک مقدار واحد را تشکیل می‌دهند. به طور مثال، در برخی موارد نیاز داریم تا یک عبارت بسیار طولانی را در کنسول به نمایش در آوریم که در این صورت می‌توانیم از اپراتور + استفاده کرده و استرینگ مد نظر را با کانکت کردن دو یا چند استرینگ کوتاه‌تر در کنسول چاپ کنیم (در آموزش‌های آتی به طور مفصل پیرامون اپراتورها صحبت خواهیم کرد.) برای روشن شدن این مطلب، مثال زیر را مد نظر قرار می‌دهیم:

public class Test {
    public static void main(String[] args) {
        System.out.print("I like the \"Java\" Programming Language." +
        "This language is used to create android apps.");
    }
}

همان‌طور که مشاهده می‌شود، هر یک از دو استرینگ کوتاه‌تر را داخل علائم " " قرار داده و با استفاده از عملگر + با یکدیگر کانکت کرده‌ایم که در نهایت استرینگی متشکل از دو استرینگ فوق‌الذکر در کنسول چاپ می‌شود (لازم به ذکر است که اِعمال عملگر + روی داده‌هایی از جنس int منجر به جمع شدن مقادیر عددی می‌شود اما در مورد مقادیر استرینگ، اپراتور + هر یک از‌ آن‌ها را با سایر استرینگ‌ها کانکت می‌کند.)

به علاوه، در برخی موارد نیاز است تا مقادیری از نوع دادۀ استریگ را در کنار سایر مقادیر با دیتا تایپ‌های مختلفی نظیرint یا double در محیط کنسول نمایش دهیم که برای آشنایی با نحوۀ انجام چنین کاری مثال زیر را در نظر می‌گیریم:

public class Test {
    public static void main(String[] args) {
        int studentNumber = 12;
        int teacherNumber = 3;
        System.out.println("The number of students is " + studentNumber);
        System.out.println("The number of teachers is " + teacherNumber);
    }
}

در مثال فوق، با به‌کارگیری نوع دادۀ int دو متغیر تحت عناوین studentNumber و teacherNumber تعریف کرده و به ترتیب مقادیر عددیِ 12 و 3 را به آن‌ها اختصاص داده‌ایم. در ادامه، قصد داریم تا هر یک از اعداد مذکور را با استرینگی کانکت کرده و در کنسول نمایش دهیم که برای این منظور لازم است تا پس از علامت " در انتهای استرینگ مد نظر عملگر + را قرار داده سپس نام متغیر مربوطه را بنویسیم.

در چنین شرایطی، با اجرای کد فوق هر یک از اعداد تعریف‌شده به همراه استرینگ‌های متناظرشان در محیط کنسول نمایش داده می‌شوند بدین معنی که عملگر + قابلیت الحاق مقداری از نوع دادۀ int به مقداری از جنس String را دارا است و بدین ترتیب خروجی حاصل از اجرای کد فوق به صورت زیر خواهد بود:

The number of students is 12
The number of teachers is 3

همان‌طور که می‌بینیم، هر یک از اعداد منتسب به متغیرهای studentNumber و teacherNumber با استرینگ‌های متناظرشان کانکت شده و در کنسول نمایش داده می‌شوند.

آشنایی با متدهای مرتبط با کلاس String در زبان برنامه‌نویسی جاوا


پیش از پرداختن به مباحث تکمیلی کلاس String و معرفی برخی متدهای پرکاربرد آن در زبان برنامه‌نویسی جاوا، ابتدا قصد داریم تا یکی از خصوصیات کلیدی اکثر محیط‌های برنامه‌نویسی همچون اکلیپس را مورد بررسی قرار دهیم. این خصیصه تحت عناوین مختلفی مانند Content Assist ،Code Completion ،Code Assist و Auto Completion شناخته می‌شود.

در واقع، این ویژگی در بسیاری  از محیط‌های برنامه‌نویسی به منظور کمک به برنامه‌نویسان و جهت افزایش دقت و سرعت ایشان در کدنویسی گنجانده شده است. حال چنانچه بخواهیم در حین کدنویسی از قابلیت‌های محیط برنامه‌نویسی اکلیپس راهنمایی بگیریم، با فشردن هم‌زمان کلیدهای Ctrl + Space می‌توانیم کلمۀ مد نظر خود را به صورت خودکار تکمیل نموده و بدین وسیله از نوشتن کامل آن خودداری کنیم. برای مثال، با تایپ بخشی از نام متغیری که قبلاً آن را در برنامۀ خود ایجاد کرده‌ایم، می‌توانیم کلیدهای Ctrl + Space را فشار دهیم تا آی‌دی‌ای اکلیپس نام متغیر مذکور را به صورت خودکار برای‌مان تکمیل کند. برای مثال، در کد زیر قصد داریم تا به بررسی ویژگی Auto Completion بپردازیم:

public class Test {
    public static void main(String[] args) {
        String myFistName;
    }
}

همان‌طور که می‌بینید، در کد فوق آبجکتی تحت عنوان myFirstName از روی کلاس String ایجاد کرده‌ایم که حاوی هیچ مقداری نیست. در سطر بعد قصد داریم تا مقداری را به متغیر مذکور اختصاص دهیم که برای این منظور می‌توانیم واژۀ «my» از نام متغیر را تایپ کرده و کلیدهای Ctrl + Space را به صورت هم‌زمان فشار دهیم که بدین ترتیب آی‌دی‌ای اکلیپس نام متغیر را به صورت myFirstName تکمیل می‌نماید.

به علاوه، ویژگی Auto Completion صرفاً به منظور تکمیل کردن نام متغیرها نبوده و به منظور کامل کردن سورس‌کد نیز مورد استفاده قرار می‌گیرد. در حقیقت، زبان برنامه‌نویسی جاوا متدها و کلاس‌های از پیش تعریف‌شدۀ بسیاری دارا است که برنامه‌نویسان با استفاده از قابلیت تکمیل خودکار در محیط‌های برنامه‌نویسی دیگر نیاز به حفظ نام آن‌ها ندارند به طوری که با تایپ بخشی از نام متد یا کلاس مد نظر و فشردن هم‌زمان کلیدهای Ctrl + Space می‌توانند از میان پیشنهادات آی‌دی‌ای مربوطه متد یا کلاس مورد نظر را انتخاب کرده و بدین ترتیب سورس‌کد خود را تکمیل نمایند.

حال با در نظر گرفتن این توضیحات، در ادامهٔ این آموزش قصد داریم تا برخی از متدهای از پیش تعریف‌شدهٔ کلاسString را معرفی کنیم که بسته به نوع اپلیکیشنی که قصد داریم توسعه دهیم، می‌توانند بسیار کاربردی باشند.

متد ()equals

در زبان برنامه‌نویسی جاوا می‌توان از این متد به منظور مقایسۀ دو مقدار از جنس استرینگ استفاده کرد بدین صورت که یک مقدار استرینگ به عنوان آرگومان ورودی دریافت کرده و آن را با استرینگ مد نظر مقایسه می‌کند که در صورت یکسان بودن هر دو استرینگ مقدار true و در غیر این صورت مقدار false را در خروجی ریترن می‌کند که برای روشن‌تر شدن مطلب، مثال زیر را مد نظر قرار می‌دهیم:

public class Test {
    public static void main(String[] args) {
        String name = "Behzad";
        String lastName = "Moradi";
        System.out.println("My first name is " + name);
        System.out.println("Is my last name Behzad? " + lastName.equals(name));
    }
}

در مثال فوق، ابتدا دو آبجکت از روی کلاس String تحت عناوین name و lastName تعریف کرده و به ترتیب استرینگ‌های «Behzad» و «Moradi» را به هر یک اختصاص داده‌ایم سپس در ادامه گفته‌ایم استرینگ «My first name is» با استرینگ منتسب به متغیر name کانکت شده و در کنسول چاپ شود. در سطر بعد، قصد داریم تا مقادیر دو استرینگ منتسب به هر یک از متغیرهای name و lastName را با یکدیگر مقایسه کنیم که برای این منظور متد()equals را روی آبجکت lastName فراخوانی کرده و آبجکت name را به عنوان آرگومان ورودی به این متد پاس داده‌ایم.

حال چنانچه مقادیر استرینگ‌های منتسب به هر دو متغیر مذکور یکسان باشند، مقدار بولین true و در صورت عدم تساوی آن‌ها مقدار false در خروجی ریترن می‌شود که گفته‌ایم نتیجۀ ریترن‌شده از متد مذکور با استرینگ «?Is my last name Behzad» کانکت شده و در خروجی چاپ شود که در نهایت خروجی حاصل از اجرای کد فوق به صورت زیر خواهد بود:

My first name is Behzad
Is my last name Behzad? false

در واقع، از آنجایی که مقادیر استرینگ منتسب به هر دو متغیر یکسان نمی‌باشند، متد ()equals مقدار false را در خروجی ریترن کرده است. برای ریترن شدن عبارت true نیز می‌توانیم مقادیر استرینگ دو متغیر را یکسان در نظر گرفته و مجدداً سورس‌کد را کامپایل کنیم. برای مثال، مقدار استرینگ منتسب به متغیر lastName را به صورت زیر تغییر می‌دهیم:

public class Test {
    public static void main(String[] args) {
        String name = "Behzad";
        String lastName = "Behzad";
        System.out.println("My first name is " + name);
        System.out.println("Is my last name Behzad? " + lastName.equals(name));
    }
}

در نهایت، با اجرای کد فوق متد ()equals مقدار دو استرینگ منتسب به متغیرهای  name و lastName را با هم مقایسه می‌کند و از آنجایی که دو استرینگ مذکور مشابه می‌باشند، مقدار true در خروجی ریترن شده و به همراه سایر استرینگ‌های مربوطه در کنسول چاپ می‌شود به طوری که داریم:

My first name is Behzad
Is my last name Behzad? true

همان‌طور که انتظار داشتیم، متد ()equals مقادیر دو استرینگ مذکور را با یکدیگر مقایسه کرده و مقدار بولین true را در خروجی ریترن کرده است.

متد ()length 

این متد به منظور شمارش تعداد کاراکترهای استرینگ مربوطه مورد استفاده قرار می‌گیرد بدین صورت که استرینگ مورد نظر خود را به عنوان آرگومان ورودی به متد ()length می‌دهیم و این متد تعداد کاراکترهای استرینگ مذکور در خروجی ریترن می‌کند. برای روشن شدن مطلب، مثال زیر را مد نظر قرار می‌دهیم:

public class Test {
    public static void main(String[] args) {
        String sentence = "This is a short sentence.";
        System.out.println(sentence);
        System.out.println("The number of its characters equals to " + sentence.length());
    }
}

در مثال فوق، ابتدا آبجکتی به نام sentence از روی کلاس String ساخته و استرینگ «.This is a short sentence» را بدان منتسب کرده‌ایم و در ادامه آن را به عنوان آرگومان ورودی به متد ()println داده سپس متد از پیش تعریف‌شدۀ ()length را روی آبجکت sentence فراخوانی کرده‌ایم که بدین ترتیب خروجی حاصل از آن به همراه استرینگ «The number of its characters equals to» در کنسول چاپ می‌شود (توجه داشته باشیم که متد ()lengthحتی اسپیس، نقطه، کاما و غیره را نیز در استرینگ مربوطه  شمارش کرده و تعداد کاراکترها را در خروجی ریترن می‌کند.) با اجرای کد فوق در خروجی خواهیم داشت:

This is a short sentence.
The number of its characters equals to 25

همان‌طور که می‌بینید، متد ()length تعداد کاراکترهای استرینگ ورودی را برابر با عدد 25 ریترن کرده است در حالی که تعداد کاراکترها در جملۀ «.This is a short sentence» معادل عدد 20 می‌باشد چرا که متد ()length نقطه و اسپیس‌های استرینگ را نیز به عنوان کاراکتر می‌شمارد.

متدهای ()toUpperCase و ()toLowerCase 

هر یک از این متدها به ترتیب جهت تبدیل کاراکترهای استرینگ مد نظر به حروف بزرگ و کوچک به کار گرفته می‌شوند. به طور مثال، فرض کنیم استرینگی به صورت «EhSan AzimI» را به عنوان ورودی از کاربر دریافت کرده و نیاز داریم تا تمامی کاراکترهای آن را به صورت یکسان به حروف کوچک یا بزرگ تبدیل کرده سپس در حافظه ذخیره‌سازیم که برای این منظور استفاده از متدهای فوق‌الذکر راه‌کار مناسبی می‌باشد. برای مثال، در کد زیر داریم:

public class Test {
    public static void main(String[] args) {
        String name = "EhSan AzimI";
        System.out.println(name.toLowerCase());
    }
}

در ابتدا آبجکتی تحت عنوان name از روی کلاس String تعریف کرده و استرینگ «EhSan AzimI» را به آن اختصاص داده‌ایم سپس متد ()toLowerCase را روی آبجکت مذکور فراخوانی کرده و نتیجه را به عنوان آرگومان ورودی به متد()println داده‌ایم تا خروجی حاصل را در کنسول چاپ کند به طوری که در خروجی خواهیم داشت:

ehsan azimi

همان‌طور که می‌بینید، تمامی کاراکترهای استرینگ مد نظر به حروف کوچک تبدیل شده‌اند. حال به منظور تبدیل کلیۀ کاراکترهای استرینگ مربوطه به حروف بزرگ از متد ()toUpperCase استفاده می‌کنیم که برای این منظور کد مربوط به مثال قبل را به صورت زیر تغییر می‌دهیم:

public class Test {
    public static void main(String[] args) {
        String name = "EhSan AzimI";
        System.out.println(name.toUpperCase());
    }
}

با اجرای کد فوق، متد از پیش تعریف‌شدۀ ()toUpperCase روی آبجکت name فراخوانی شده و منجر بدین می‌شود تا کاراکترهای استرینگ مد نظر به حروف بزرگ تبدیل شوند که نتیجۀ حاصل از اجرای آن به صورت زیر خواهد بود:

EHSAN AZIMI

همان‌طور که ملاحظه می‌شود، تمامی کاراکترهای استرینگ ورودی به حروف بزرگ تبدیل شده و در خروجی چاپ شده‌اند. 

آشنایی با نحوۀ به‌کارگیری اپراتورها در زبان برنامه‌نویسی جاوا


در این آموزش قصد داریم تا با نحوۀ استفاده از عملگرها در زبان برنامه‌نویسی جاوا آشنا شده و ببینیم که چگونه می‌توان برخی عملیات ریاضیاتی نظیر جمع، تفریق و غیره را روی داده‌های مورد نظر اِعمال کرده و پردازش‌های مورد نیاز را روی آن‌ها انجام داد به علاوه اینکه به بررسی نحوۀ اولویت‌بندی اپراتورها خواهیم پرداخت.

برای شروع، در ابتدا با به‌کارگیری دیتا تایپ int متغیری تحت عنوان studentNumber تعریف کرده و مقداری معادل عدد 121 را به آن اختصاص می‌دهیم که برای این منظور داریم:

int studentNumber = 121;

در ادامۀ آموزش برخی از رایج‌ترین عملگرهای ریاضیاتی را معرفی کرده و نحوۀ پیاده‌سازی هر یک به منظور اِعمال روی مقدار منتسب به متغیر studentNumber در دستور فوق را بررسی می‌نماییم.

اپراتور Plus
با توجه به مقدار اختصاص‌یافته به متغیر studentNumber معادل عدد 121، اگر بخواهیم عددی مثل 10 را با مقدار منتسب به متغیر مذکور جمع کنیم، از اپراتور + استفاده می‌کنیم:

int studentNumber = 121;
studentNumber = studentNumber + 10;

در کد فوق، با به‌کارگیری نوع دادۀ int متغیری تحت عنوان studentNumber تعریف کرده و مقدار 121 را بدان منتسب کرده‌ایم و در ادامه با استفاده از اپراتور + عدد 10 را با 121 جمع کرده و نتیجۀ حاصل را مجدداً به متغیر studentNumberاختصاص داده‌ایم که بدین ترتیب مقدار جدید جایگزین مقدار پیشین می‌گردد. به علاوه، روش دیگری جهت افزودن یک مقدار به عدد اختصاص‌یافته به متغیر مذکور وجود دارد که منجر به کوتاهی و سادگی کد فوق می‌شود که برای این منظور دستور سطر دوم از مثال پیشین را به صورت زیر تغییر می‌دهیم:

int studentNumber = 121;
studentNumber += 10;

همان‌طور که ملاحظه می‌شود، در این روش، عدد 10 با مقدار منتسب به متغیر studentNumber معادل عدد 121 جمع شده و در نهایت نتیجۀ حاصل برابر با عدد 131 به متغیر studentNumber اختصاص داده می‌شود.

اپراتور Minus
چنانچه بخواهیم عدد 10 را از مقدار منتسب به متغیر در مثال قبل کم کنیم، اپراتور - را مورد استفاده قرار می‌دهیم که در مثال زیر نحوۀ اِعمال آن روی متغیر مذکور را آورده‌ایم:

int studentNumber = 121;
studentNumber = studentNumber - 10;

در دستور فوق عدد 10 از مقدار اختصاص‌یافته به متغیر studentNumber معادل عدد 121 کم شده و نتیجۀ حاصل جایگزین مقدار پیشینِ منتسب به این متغیر می‌گردد. همچنین به منظور ساده‌سازی سورس‌کد روش دیگری می‌توان مورد استفاده قرار داد که در مثال زیر نحوۀ پیاده‌سازی آن را بررسی می‌نماییم:

int studentNumber = 121;
studentNumber -= 10;

در این روش نیز شاهد خروجی مشابهی همچون روش اول هستیم و عدد 111 حاصل خواهد شد.

اپراتور Multiply
در ادامه، قصد داریم تا یک مقدار عددی را در مقدار اختصاص‌یافته به متغیر studentNumber ضرب کنیم که برای این منظور اپراتور * را به کار می‌گیریم که نحوۀ پیاده‌سازی آن به صورت زیر می‌باشد:

int studentNumber = 121;
studentNumber = studentNumber * 10;

در کد فوق، مقدار منتسب به متغیر studentNumber در عدد 10 ضرب شده و عدد به دست آمده مجدداً در متغیر مذکور ذخیره می‌شود. همچنین مشابه روش‌های پیشین و به منظور ساده‌سازی سورس‌کد، می‌توانیم به روش زیر نیز عمل نماییم:

int studentNumber = 121;
studentNumber *= 10;

نتیجۀ حاصل از ضرب مقدار اختصاص‌یافته به متغیر studentNumber برابر با عدد 1210 می‌باشد که جایگزین مقدار قبلیِ منتسب به متغیر مذکور شده و در آن ذخیره می‌گردد.

اپراتور Division
به منظور تقسیم مقدار اختصاص‌یافته به متغیر studentNumber بر عددی دلخواه می‌توانیم از اپراتور / استفاده نماییم که برای این منظور دستوری مانند زیر خواهیم داشت:

int studentNumber = 121;
studentNumber = studentNumber / 10;

در واقع، مقدار منتسب به متغیر studentNumber معادل عدد 121 بر عدد 10 تقسیم شده و عدد حاصل به متغیر مذکور اختصاص داده می‌شود (توجه داشته باشیم که مقدار حاصل از عملیات تقسیم در مثال فوق عدد 12.1 می‌باشد اما از آنجایی که جنس متغیر studentNumber از نوع دادۀ int تعریف شده است، مقادیر اعشاری را نمی‌تواند در خود ذخیره کند که از همین روی بخش اعشاری عدد حذف شده و فقط مقدار صحیح در آن ذخیره می‌شود.) به منظور ساده‌سازی سورس‌کد در رابطه با پیاده‌سازی اپراتور تقسیم نیز می‌توانیم مشابه روش‌های قبل عمل کرده و آن را به صورت زیر بر روی مقادیر عددی مورد نظر اِعمال کنیم:

int studentNumber = 121;
studentNumber /= 10;

نتیجۀ حاصل از دستورات فوق نیز مشابه روش قبل بوده و بخش صحیح حاصل از عملیات تقسیم در متغیر studentNumber ذخیره می‌شود.این بخش از محتوا مخصوص کاربرانی است که ثبت‌نام کرده‌اند.
جهت مشاهدهٔ این بخش از محتوا لاگین نمایید.

اولویت اپراتورها در زبان برنامه‌نویسی جاوا

در پروسهٔ توسعهٔ نرم‌افزار برخی مواقع نیاز داریم تا بیش از یک عمل ریاضیاتی را روی دیتای مورد استفاده در برنامۀ خود اِعمال کنیم که برای این منظور می‌باید از اولویت عملگرها در این زبان مطلع باشیم. برای مثال، فرض کنیم که با استفاده از دیتا تایپ int دو متغیر به نام‌های x و y به صورت زیر تعریف کرده‌ایم به طوری که متغیر x دارای هیچ داده‌ای نمی‌باشد اما متغیر y دارای مقدار اولیهٔ 10 است:

int x;
int y = 10;

حال اگر فرض کینم که مقدار حاصل از ضرب عدد ذخیره‌شده در متغیر y در عدد 2 سپس جمع آن با عدد 6 را در متغیر xنگهداری کنیم، لازم است تا کد فوق را به صورت زیر تغییر دهیم:

int x;
int y = 10;
x = y * 2 + 6;

نتیجۀ حاصل از اجرای چنین دستوری هم می‌تواند عدد 26 و هم 80 باشد و بسته به اینکه اول عمل ضرب انجام شود یا عمل جمع، مقادییر متفاوتی به متغیر x منتسب می‌شوند. نکتهبه طور کلی، در زبان برنامه‌نویسی جاوا عملیات Incrementing و Decrementing از اولویت بالاتری برخوردار بوده و در ابتدا رخ می دهند سپس محاسبات مربوط به ضرب و تقسیم صورت گرفته و در نهایت دستورات مرتبط با جمع و تفریق بر روی دیتای مد نظر اِعمال می‌شوند.

حال با توجه به آنچه در نکتۀ بالا بدان اشاره کردیم، می‌توان گفت که نتیجۀ حاصل از اِعمال اپراتورهای ریاضیاتی روی داده‌های مد نظر برابر با عدد 26 بوده و در متغیر x ذخیره می‌شود. به علاوه، چنانچه بخواهیم تا اولویت بالاتری به اپراتور مورد نظر خود بدهیم به طوری که مفسر جاوا در ابتدا آن را روی عملوندهای متناظرش (مقادیر مربوط به سمت چپ و راست عملگر مربوطه) اِعمال کند، کافی است تا اعداد مد نظر را به همراه عملگر متناظرشان داخل علائم () قرار دهیم. برای مثال، در کد فوق قصد داریم تا در ابتدا اعداد 2 و 6 با یکدیگر جمع شده سپس حاصل‌جمع آن‌ها در مقدار ذخیره‌شده در متغیر y معادل با عدد 10 ضرب شود که برای منظور دو عدد 2 و 6 را به صورت زیر داخل علامت پرانتز قرار می‌دهیم:

int x;
int y = 10;
x = y * (2 + 6);

در دستور فوق، ابتدا عملیات ریاضیاتی داخل پرانتز اجرا شده و نتیجه حاصل در مقدار منتسب به متغیر y ضرب می‌شود که در نهایت مقدار به دست آمده معادل عدد 80 به متغیر x اختصاص می‌یابد.

استفادۀ عملی از اپراتورها در قالب پروژۀ محاسبۀ وزن خود روی سایر سیارات


در این آموزش قصد داریم تا به بررسی نحوۀ به‌کارگیری اپراتورها در قالب یک پروژۀ عملی بپردازیم و در همین راستا سناریویی مد نظر قرار می‌دهیم که در آن قرار است تا عدد مربوط به وزن کنونی خود روی کرۀ زمین را وارد برنامه کرده سپس ببینیم که وزن معادل‌مان روی سیارات دیگری مانند مشتری و زحل چه‌قدر است.

برای این منظور، ابتدا بر اساس آنچه در آموزش‌های پیشین آموختیم، یک پروژۀ جدید ایجاد کرده و کلاسی به نامOperator در آن می‌سازیم که پس از باز کردن فایل، کدی مانند زیر خواهیم داشت:

public class Operator {
    /**
    * @param args
    */
    public static void main(String[] args) {
    // TODO Auto-generated method stub
    }
}

همان‌طور که در آموزش نگاهی به کامنت‌گذاری در زبان برنامه‌نویسی جاوا توضیح داده شد، سه نوع کامنت در این زبان داریم که در کد بالا دو نوع از آن‌ها را مشاهده می‌کنیم؛ به علاوه اینکه گفتیم کامنت‌ها در روند اجرای برنامه بی‌تأثیر هستند و از همین روی کلیۀ کامنت‌ها را حذف کرده و در نتیجه کدی به شکل زیر خواهیم داشت:

public class Operator {
    public static void main(String[] args) {

    }
}

همچنین لازم به یادآوری است که برای حذف یک سطر از کد می‌توانیم نشانگر ماوس را روی سطر مورد نظر قرار داده سپس کلیدهای Ctrl + D را به صورت هم‌زمان فشار دهیم (البته نیاز به توضیح است که بسته به تنظیمات نرم‌افزار، این کلیدها می‌توانند از سیستمی به سیستم دیگر متفاوت باشند.)به خاطر داشته باشیدنکته‌ای که می‌باید جزو عادات خود به عنوان یک برنامه‌نویس حرفه‌ای قرار دهیم، کامنت‌گذاری اصولی سورس‌کد است چرا که بدین ترتیب از سردرگمی خود و همچنین سایر دولوپرها در آینده جلوگیری می‌نماییم.

همچنین توجه داشته باشیم که در صورت تمایل می‌توانیم برخی کامنت‌ها را در قالب جملات فارسی در سورس‌کدِ خود درج کنیم با این توضیح که در حین ذخیره کردن فایل جاوای مربوطه نیاز است تا گزینۀ Save as UTF-8 را انتخاب نماییم.

حال شروع به نوشتن برنامۀ مورد نظر خود می‌کنیم به طوری که در ابتدا قصد داریم تا با اجرای برنامه، استرینگ «My weight on the Earth» در کنسول چاپ شود:

public class Operator {
    public static void main(String[] args) {
        // این بخش از کد مربوط وزن من روی کره زمین است
        System.out.print("My weight on the Earth");
    }
}

همان‌طور که می‌بینید، کامنتی در سطر مربوط به محاسبۀ وزن خود بر روی زمین درج می‌کنیم تا آن را از قسمت‌های مربوط به محاسبۀ وزن روی سایر سیارات جدا سازیم.

چرا وزن اجسام بر روی سیارات مختلف متفاوت می‌باشد؟

پیش از ادامۀ بحث، می‌باید به سؤال فوق پاسخ دهیم. در واقع، نیروی گرانشی یا نیروی جاذبه‌ای که از طرف سیارات مختلف بر اجسام وارد می‌شود متفاوت بوده و منجر بدین می‌شود تا اجسام از وزن متفاوتی برخوردار گردند. 

در حقیقت، هر یک از اجسام دارای جرمی ثابت می‌باشد که روی سیارات مختلف تغییری نمی‌کند چرا که جرم جسم را مؤلفه‌های ثابتی همچون تعداد کل اتم‌ها، تراکم اتم‌های درون آن و همچنین نوع این اتم‌ها تشکیل می‌دهند اما این در حالی است که اجسام مختلف بر اساس نیروی جاذبۀ متفاوتی که در هر یک از سیارات بر آن‌ها وارد می‌شود، وزن متفاوتی به خود می‌گیرند؛ به عبارت بهتر، می‌توان گفت که وزن هر شیئ بر روی سیارات مختلف از حاصل‌ضرب جرم جسم در نیروی جاذبۀ سیارۀ مربوطه به دست می‌آید.

با توجه به آنچه در بالا بدان اشاره کردیم، بهتر است تا معادل «نیروی وزن» را به جای واژۀ «وزن» برای هر یک از اجسام به کار برد چرا که نیرویی متشکل از نیروی جاذبۀ سیارۀ مورد نظر در جرم جسم می‌باشد که واحد آن نیز نیوتون است اما این در حالی است که واحد کیلوگرم به اشتباه هم برای جرم و هم برای وزن (نیروی وزن) شیئ به کار برده می‌شود. با توجه به آنچه که اشاره کردیم، نیروی وزن یک شیئ بر روی زمین از حاصل‌ضرب جرم جسم در نیروی گرانش زمین معادل عدد 9/8 به دست می‌آید.

در واقع، با در نظر داشتن نیروی وزن یک جسم روی زمین معادل عددی دلخواه همچون 85/5 می‌توان نیروی وزن آن روی سایر سیارات را به دست آورد به طوری که کافی است تا عدد مربوطه را در نسبت نیروی گرانشی زمین به نیروی گرانشی سیارۀ مورد نظر ضرب کرد که در این آموزش ما قصد داریم تا نیروی وزن خود روی دو سیارۀ مشتری و زحل را محاسبه کنیم. در حقیقت، نیروی گرانش روی دو سیارۀ مشتری و زحل به ترتیب برابر با 24/79 و 10/44 می‌باشد بدین معنی که نیروی گرانش روی دو سیارۀ مشتری و زحل به ترتیب 2/52 و 1/06 برابرِ نیروی گرانش زمین است و از همین روی می‌توان نیروی وزن خود روی سیارات مشتری و زحل را از حاصل‌ضرب نیروی وزن خود روی زمین در اعداد مذکور به دست آورد.

اکنون با دانستن هر یک از مفاهیم جرم، نیروی وزن و نسبت نیروی جاذبۀ هر یک از سیارات مشتری و زحل نسبت به زمین، پروژۀ خود را در ادامه تکمیل می‌نماییم. ابتدا به ساکن نیاز است تا با استفاده از دیتا تایپ double متغیری به منظور نگهداری مقدار نیروی وزن خود تعریف کنیم (نوع دادۀ عدد اعشاری را بدین دلیل انتخاب نموده‌ایم که در بیشتر مواقع نیروی وزن افراد رُند نبوده بلکه در قالب یک عدد اعشاری است و از همین روی نوع دادۀ عدد صحیح جهت نگهداری مقدار نیروی وزن مناسب نمی‌باشد.) برای این منظور، کدی مانند زیر خواهیم داشت:

public class Operator {
    public static void main(String[] args) {
        // این بخش از کد مربوط به نیروی وزن من روی کره زمین است
        System.out.print("My weight on the Earth ");
        double myWeightOnEarth = 85.5;
        System.out.println(myWeightOnEarth);
    }
}

در کد فوق، پس از دستور مربوط به چاپ استرینگ «My weight on the Earth» متغیری تحت عنوانmyWeightOnEarth با به‌کارگیری نوع دادۀ double تعریف کرده و عددی دلخواه مانند 85/5 را بدان منتسب کرده‌ایم سپس مقدار منتسب به متغیر مذکور را به عنوان آرگومان ورودی به متد ()println داده‌ایم تا مقدار منتسب‌شده به آن معادل نیروی وزن کاربر روی زمین را به همراه استرینگ «My weight on the Earth» در کنسول نمایش داده و به سطر بعد برود.

در واقع، نکتۀ قابل‌توجه در رابطه با کد فوق این است که از متد ()print برای چاپ استرینگ مذکور استفاده نموده‌ایم چرا که قصد داریم تا عدد مربوط به نیروی وزن کاربر به دنبال استرینگ مد نظر در کنسول چاپ شود و در ادامه نیز از متد ()println را برای چاپ نیروی وزن کاربر به کار گرفته‌ایم چرا که می‌خواهیم نیروی وزن معادل کاربر روی سیارات مختلف به همراه استرینگ متناظرشان در سطرهای جداگانه‌ای در معرض دیدمان قرار گیرند.

در این مرحله برنامۀ خود را به منظور محاسبۀ نیروی وزن معادل روی سایر سیارات تکمیل می‌نماییم و همان‌طور که پیش‌تر اشاره کردیم، برای محاسبۀ نیروی وزن روی هر یک از سیارات مشتری و زحل کافی است تا نیروی وزن خود روی زمین را به ترتیب در اعداد 2/52 و 1/06 ضرب نماییم که برای این منظور کد خود را به صورت زیر تکمیل می‌کنیم:

public class Operator {
    public static void main(String[] args) {
        // این بخش از کد مربوط به نیروی وزن من روی کره زمین است
        System.out.print("My weight on the Earth ");
        double myWeightOnEarth = 85.5;
        System.out.println(myWeightOnEarth);
        // این بخش از کد مربوط به نیروی وزن من روی سیاره مشتری است
        System.out.print("My weight on the Jupiter ");
        double myWeightOnJupiter = myWeightOnEarth * 2.52;
        System.out.println(myWeightOnJupiter);
        // این بخش از کد مربوط به نیروی وزن من روی سیاره زحل است
        System.out.print("My weight on the Saturn ");
        double myWeightOnSaturn = myWeightOnEarth * 1.06;
        System.out.println(myWeightOnSaturn);
    }
}

همان‌طور که ملاحظه می‌شود، در ادامه دستور مربوط به چاپ استرینگ «My weight on the Jupiter» را نوشته سپس با استفاده از دیتا تایپ double متغیری به نام myWeightOnJupiter تعریف کرده که در ادامه مقدار منتسب به متغیر myWeightOnEarth برابر با نیروی وزن خود روی زمین را در نسبت نیروی جاذبۀ سیارۀ مشتری به زمین معادل عدد 2/52 ضرب کرده و مقدار حاصل را به متغیر myWeightOnJupiter منتسب می‌نماییم سپس مقدار متغیر مذکور را به عنوان آرگومان وروی به متد ()println می‌دهیم تا عدد مربوط به نیروی وزن کاربر روی سیارۀ مشتری را به همراه استرینگ «My weight on the Jupiter» در کنسول نمایش داده و به سطر بعد برود.

به همین ترتیب، با استفاده از دیتا تایپ double متغیر دیگری تحت عنوان myWeightOnSaturn تعریف کرده و مقدار منتسب به متغیر myWeightOnEarth را در نسبت نیروی جاذبۀ سیارۀ زحل به زمین معادل با عدد 1/06 ضرب نموده و مقدار حاصل را در متغیر مذکور ذخیره می‌کنیم و در ادامه مشابه روش پیشین آن را در کنسول نمایش می‌دهیم که در نهایت خروجی حاصل از اجرای کد فوق به صورت زیر می‌باشد:

My weight on the Earth 85.5
My weight on the Jupiter 215.46
My weight on the Saturn 90.63000000000001

همچنین بدیهی است که بر اساس نیروی وزن متفاوتی که ممکن است به ازای افراد مختلف در برنامۀ فوق وارد کنیم، نتیجۀ متفاوتی نیز در خروجی دریافت خواهیم کرد.

آشنایی با نحوۀ نام‌گذاری صحیح متغیرها در زبان جاوا در قالب پروژۀ ظرفیت مجاز آسانسور


در این آموزش به تشریح نحوۀ صحیح نام‌گذاری متغیرها در قالب پروژه‌ای کاربردی خواهیم پرداخت که در آن قصد داریم تا بر اساس میانگین وزن چند نفر و همچنین ظرفیت یک آسانسور، بررسی کنیم ببینیم که آیا آسانسور مد نظر قابلیت حمل ایشان را دارد یا خیر.

حال برای پیاده‌سازی پروژۀ خود فرض می‌کنیم که در یک برج مسکونی زندگی می‌کنیم و در ادامه بر اساس میانگین وزن سکنه و همچنین تعداد افرادی که در هر بار سوار آسانسور می‌شوند، وزن کل افراد را محاسبه کرده و با ظرفیت مُجاز مقایسه می‌کنیم که برای آسانسور مورد نظر تعریف نموده‌ایم. 

برای پیاده‌سازی چنین برنامه‌ای، در ابتدا یک پروژۀ جدید در آی‌دی‌ای خود ایجاد کرده و نامی دلخواه همچون Elevator برای آن انتخاب می‌کنیم. در ادامه، یک کلاس تحت عنوان ElevatorCapacity ساخته و گزینۀ public static void main را تیک می‌زنیم به طوری که خواهیم داشت:

public class ElevatorCapacity {
    /**
    * @param args
    */
    public static void main(String[] args) {
    // TODO Auto-generated method stub
    }
}

همان‌طور که در آموزش‌های پیشین اشاره کردیم، متد ()main در کد فوق به منزلۀ نقطۀ شروع برنامه است. در ادامه، تعداد افراد حاضر در آسانسور و میانگین وزن ایشان را تعریف می‌کنیم که برای این منظور کد فوق را به صورت زیر تکمیل می‌نماییم:

public class ElevatorCapacity {
    public static void main(String[] args) {
        double weightOfEachPerson = 75.5;
        int numberOfPeople = 16;
    }
}

در کد فوق، با استفاده از دیتا تایپ double متغیری تحت عنوان weightOfEachPerson تعریف کرده و عدد اعشاری 75/5 را بدان اختصاص داده‌ایم که نوع دادۀ double را جهت فراهم کردن امکان ذخیره و نگهداری اعداد مربوط به وزن هر فرد در قالب یک عدد اعشاری تعریف کرده‌ایم. سپس با به‌کارگیری نوع دادۀ int متغیری دیگر به نام numberOfPeople تعریف کرده و عدد صحیح مربوط به تعداد افراد حاضر در آسانسور را در آن ذخیره نموده‌ایم (بدیهی است که تعداد افراد نمی‌تواند از نوع عدد اعشاری باشد.)

همان‌طور که می‌بینیم، نامی که برای هر یک از متغیرها انتخاب کرده‌ایم متشکل از چند واژه می‌باشد که در آن‌ها کلمۀ اول را با حروف کوچک نوشته و حروف اول از سایر کلمات را به صورت بزرگ نوشته‌ایم (توجه داشته باشیم که این شیوهٔ نام‌گذاری یک روش رایج در میان برنامه‌نویسان می‌باشد که منجر به سادگی در خواندن اسامی متغیرها و همچنین تسهیل درک سورس‌کد می‌گردد.)  نکتهروش نام‌گذاری فوق‌الذکر اصطلاحاً camelCase نامیده می‌شود به طوری که در زبان انگلیسی واژۀ Camel به معنای «شتر» بوده و نام‌گذاری متغیرها با این سبک نیز بر اساس شمایی از «کوهان شتر» بدین نام شناخته شده است.

در این مرحله، نیاز است تا مجموع کل وزن افراد حاضر در آسانسور را محاسبه نماییم که برای این منظور میانگین وزن سکنه را در تعداد افراد حاضر در آسانسور ضرب می‌نماییم. بنابراین نیاز است تا متغیری به صورت زیر تعریف کرده و برنامۀ خود را تکمیل کنیم:

public class ElevatorCapacity {
    public static void main(String[] args) {
        double weightOfEachPerson = 75.5;
        int numberOfPeople = 16;
        double totalWeight = weightOfEachPerson * numbersOfPeople;
    }
}

همان‌طور که در کد فوق ملاحظه می‌شود، با استفاده از دیتا تایپ double متغیری تحت عنوان totalWeight تعریف کرده و حاصل‌ضرب هر یک از مقادیر منتسب به متغیرهای weightOfEachPerson در numberOfPeople را به متغیر مذکور اختصاص داده‌ایم (توجه داشته باشیم که تمامی اسامی متغیرها متناسب با ماهیت دیتای متناظرشان می‌باشند.) در ادامه، متغیر دیگری جهت نگهداری ظرفیت مجاز آسانسور مذکور به صورت زیر تعریف می‌کنیم:

double elevatorCapacity = 750;

در دستور فوق، جهت تعریف متغیر مربوط به ذخیرۀ ظرفیت مجاز آسانسور نیز نوع دادۀ double را به کار برده‌ایم تا به راحتی امکان تعریف عدد اعشاری را برای ظرفیت آسانسور مورد نظر داشته باشیم و همان‌طور که می‌بینیم، از سبک نام‌گذاری camelCase استفاده کرده و همچنین نامی متناسب با دیتای منتسب به آن را انتخاب نموده‌ایم. بنابراین دستور فوق را به برنامۀ خود اضافه کرده و در ادامه استرینگ مبنی بر تعداد افراد سوارشده به آسانسور در کنسول نمایش می‌دهیم که برای این منظور کدی مانند زیر خواهیم داشت:

public class ElevatorCapacity {
    public static void main(String[] args) {
        double weightOfEachPerson = 75.5;
        int numberOfPeople = 16;
        double totalWeight = weightOfEachPerson * numberOfPeople;
        double elevatorCapacity = 750;
        System.out.println(numberOfPeople + " people get on!");
    }
}

بنابراین متغیر numberOfPeople را به عنوان آرگومان ورودی به متد ()println داده‌ایم تا مقدار منتسب به آن را به همراه استرینگ «!people get on» در ابتدای اجرای برنامه و در کنسول چاپ کند.

همچنین توجه داشته باشیم که در دستور سطر هفتم از کد فوق، کیورد System به یکی از کلاس‌های از پیش تعریف‌شدۀ زبان جاوا اشاره دارد که امکان دسترسی به بخش‌هایی از سیستم را به برنامه می‌دهد که خارج از کنترل مستقیم JVM یا ماشین مجازی جاوا هستند و در ادامه کیورد out نشان‌دهندۀ خروجی مرتبط با آی‌دی‌ای مورد استفاده است بدین معنی که با استفاده از دستور System.out به محیط کنسول در نرم‌افزار مورد استفادۀ خود (در این آموزش اکلیپس) دسترسی داشته و با فراخوانی متد ()println دیتای مورد نظر را در کنسول چاپ می‌نماییم (جهت کسب اطلاعات بیشتر در رابطه با ماشین مجازی جاوا توصیه می‌کنیم به آموزش ماشین مجازی جاوا چیست؟ مراجعه نمایید.)

در این مرحله از آموزش می‌باید چک کنیم که آیا کل وزن افراد حاضر در آسانسور متناسب با ظرفیت مجاز آن می‌باشد یا خیر که در صورت تطابق با ظرفیت آسانسور مورد نظر، استرینگی مبنی بر قابلیت بسته شدن درب آن و در غیر این صورت عدم امکان بسته شدن درب را در کنسول چاپ کند که برای این منظور برنامۀ فوق را به صورت زیر تکمیل می‌نماییم:

public class ElevatorCapacity {
    public static void main(String[] args) {
        double weightOfEachPerson = 75.5;
        int numberOfPeople = 16;
        double totalWeight = weightOfEachPerson * numberOfPeople;
        double elevatorCapacity = 750;
        System.out.println(numberOfPeople + " people get on!");
        if (totalWeight <= elevatorCapacity) {
            System.out.println("The door can be closed!");
        } else {
            System.out.println("The number of people is more than the elevator capacity and the door can't be closed.");
        }
    }
}

همان‌طور که ملاحظه می‌شود، در برنامۀ فوق ابتدا استرینگ مربوط به نمایش تعداد افراد سوارشده بر آسانسور را در کنسول چاپ کرده و در ادامه دستور if اجرا می‌شود که در آموزش‌ آشنایی با دستور شرطی if در زبان برنامه‌نویسی جاوابه بررسی نحوۀ پیاده‌سازی دستورات شرطی پرداخته‌ایم اما در این مثال به طور خلاصه می‌توان گفت که با اجرای دستور سطر هشتم چک می‌کنیم ببینیم که اگر مقدار منتسب به متغیر totalWeight یا مجموع وزن افراد حاضر در آسانسور کوچک‌تر یا مساوی با مقدار منتسب به متغیر elevatorCapacity یا ظرفیت مجاز آسانسور باشد، شرط برقرار بوده و دستور داخل آن اجرا می‌شود بدین معنی که استرینگ «!The door can be closed» در کنسول چاپ می‌شود و در غیر این صورت نیز دستور داخل else اجرا شده و استرینگ مربوطه در کنسول نمایش داده می‌شود. در نهایت، با اجرای برنامۀ فوق در خروجی خواهیم داشت:

16 people get on!
The number of people is more than the elevator capacity and the door can't be closed.

در این پروژه، تعداد افراد حاضر در آسانسور معادل 16 نفر، میانگین وزن افراد 75/5 و ظرفیت مجاز آسانسور را برابر با 750 در نظر گرفته بودیم که با توجه به دیتای مد نظر می‌بینیم که مجموع وزن افراد خارج از ظرفیت آسانسور بوده و استرینگی مبنی بر عدم توانایی بسته شدن درب آن چاپ شده است.

زبان برنامه‌نویسی جاوا امکانی را برای دولوپرها فراهم می‌کند تا بتوانند به صورت دینامیک (پویا) بخشی از دیتای مورد نیاز را از کاربر دریافت کنند که در چنین شرایطی مثلاً می‌توان تعداد افراد را توسط کیبورد وارد کرده و بدین ترتیب پروژۀ فوق را به صورت کاربردی‌تر پیاده‌سازی نمود که در همین راستا، در آموزش آینده کلاسی تحت عنوان Scanner را به منظور دریافت ورودی از کاربر معرفی خواهیم کرد.




مطالب مرتبط

پاسخی بگذارید

نشانی ایمیل شما منتشر نخواهد شد. بخش‌های موردنیاز علامت‌گذاری شده‌اند *