پروژه کاتلین

برای شروع یک پروژه کاتلین از ابتدا، ابتدا باید یک پروژه جدید بسازیم، سپس اولین کلاس و فایل اصلی (main) خود را ایجاد کرده و چند مثال ساده از ویژگی‌های زبان کاتلین را پیاده‌سازی کنیم. در این مثال، نحوه ایجاد یک پروژه در IntelliJ IDEA، ایجاد فایل‌ها، نوشتن یک تابع اصلی و اجرای برنامه را قدم به قدم بررسی می‌کنیم.

ایجاد یک پروژه جدید در IntelliJ IDEA

برای شروع یک پروژه جدید کاتلین درIntelliJ IDEA  ابتدا باید اطمینان حاصل کنید که این IDE را نصب کرده‌اید. **IntelliJ IDEA** یکی از قدرتمندترین محیط‌های توسعه یکپارچه (IDE) است که توسط شرکت JetBrains توسعه یافته و ابزارهای مناسبی برای کدنویسی با کاتلین ارائه می‌دهد. در ادامه مراحل نصب IntelliJ IDEA و سپس ایجاد یک پروژه کاتلین را به تفصیل بررسی می‌کنیم.

 مرحله ۱: نصب IntelliJ IDEA

1. دانلود IntelliJ IDEA:
– به سایت رسمی [JetBrains](https://www.jetbrains.com/idea/download/) بروید.
– دو نسخه از IntelliJ IDEA در دسترس است:
– نسخه Community: رایگان و متن‌باز است و بیشتر ویژگی‌های مورد نیاز برای کدنویسی با کاتلین را دارد.
– نسخه Ultimate:نسخه پولی با امکانات بیشتر برای پروژه‌های حرفه‌ای و پیشرفته.
– برای شروع کار با کاتلین، می‌توانید از نسخه Community استفاده کنید.
– پس از انتخاب نسخه، سیستم‌عامل خود (Windows، macOS یا Linux) را انتخاب کرده و فایل نصب را دانلود کنید.

2. نصب IntelliJ IDEA:
– پس از دانلود فایل نصب، آن را باز کنید و مراحل نصب را مطابق راهنمای نصب دنبال کنید.
– روی Nextکلیک کنید تا مراحل نصب پیش رود و در صورت نیاز به ایجاد آیکون یا افزودن IntelliJ IDEA به مسیر سیستم (PATH)، گزینه‌های مربوطه را انتخاب کنید.
– پس از پایان نصب، IntelliJ IDEA را باز کنید.

3. پیکربندی اولیه IntelliJ IDEA
– اولین باری که IntelliJ IDEA باز می‌شود، از شما خواسته می‌شود که برخی تنظیمات اولیه را انجام دهید.
– می‌توانید از تنظیمات پیش‌فرض استفاده کنید یا آن‌ها را مطابق نیاز خود تغییر دهید.

مرحله ۲: ایجاد یک پروژه جدید کاتلین

بعد از نصب و باز کردن IntelliJ IDEA، می‌توانید یک پروژه جدید کاتلین ایجاد کنید.

1.شروع به ایجاد پروژه جدید:
– پس از باز شدن IntelliJ IDEA، صفحه خوش‌آمدگویی را مشاهده خواهید کرد.
– در این صفحه، روی گزینه **New Project** کلیک کنید تا پنجره ایجاد پروژه جدید باز شود.

2.انتخاب زبان و تنظیمات پروژه:
– در پنجره باز شده، از قسمت سمت چپ گزینه **Kotlin** را انتخاب کنید و سپس **Kotlin/JVM** را برای ایجاد پروژه کاتلین انتخاب کنید.
– Project SDK (Software Development Kit):
– در بخش **Project SDK**، باید نسخه‌ای از **JDK** (Java Development Kit) را انتخاب کنید.
– اگر قبلاً JDK را نصب نکرده‌اید، می‌توانید آن را از طریق IntelliJ IDEA دانلود کنید یا به صورت دستی نصب کنید و سپس مسیر آن را در اینجا مشخص کنید.
– حداقل نسخه پیشنهادی برای JDK، نسخه 8 یا 11 است.
– سپس روی **Next** کلیک کنید.

3.پیکربندی پروژه:
– در این بخش، می‌توانید نام پروژه خود (مثلاً `FirstKotlinProject`) و مسیر ذخیره‌سازی پروژه را مشخص کنید.
– مسیر ذخیره‌سازی محلی است که IntelliJ IDEA فایل‌های پروژه را در آن قرار می‌دهد. می‌توانید یک پوشه جدید برای پروژه‌های کاتلین خود ایجاد کنید.
– پس از وارد کردن اطلاعات، روی **Finish** کلیک کنید.

4. ساختار پروژه:
– اکنون پروژه شما ایجاد شده و در پنجره **Project** سمت چپ، ساختار پروژه را مشاهده خواهید کرد.
– IntelliJ IDEA به طور خودکار یک پوشه به نام `src` (مخفف Source) برای قرار دادن فایل‌های کد منبع پروژه ایجاد کرده است.

مرحله ۳: ایجاد فایل اصلی کاتلین (Main.kt)

برای شروع کدنویسی، نیاز به یک فایل کاتلین دارید که معمولاً با نام `Main.kt` ایجاد می‌شود و شامل تابع اصلی `main` است.

1. ایجاد فایل جدید:
– روی پوشه `src` راست‌کلیک کرده و گزینه New > Kotlin File/Classرا انتخاب کنید.
– در کادر باز شده، نام فایل را `Main` وارد کنید و نوع آن را File انتخاب کنید.
– روی OK کلیک کنید تا فایل `Main.kt` ایجاد شود.

2. نوشتن تابع اصلی (main):
– فایل `Main.kt` باز خواهد شد. حالا می‌توانید تابع اصلی خود را بنویسید:

fun main() {
    println("Hello, Kotlin!")
}

– این تابع `main`، نقطه شروع برنامه است و دستور `println` یک پیام را در کنسول چاپ می‌کند.

مرحله ۴: اجرای پروژه

پس از نوشتن کد، می‌توانید برنامه را اجرا کنید.

1. اجرای برنامه:
– روی فایل `Main.kt` راست‌کلیک کرده و گزینه Run ‘MainKt را انتخاب کنید.
– برنامه اجرا می‌شود و خروجی آن که همان پیام `”Hello, Kotlin!”` است، در پنجره کنسول پایین IntelliJ IDEA نمایش داده می‌شود.

2. اجرای مجدد برنامه:
– برای اجرای مجدد، می‌توانید از دکمه سبزرنگ **Run** در نوار ابزار بالا استفاده کنید.

 جمع‌بندی

حالا یک پروژه کاتلین کامل دارید و می‌توانید کدنویسی را آغاز کنید. در این مراحل:
– IntelliJ IDEA را نصب و پیکربندی کردید.
– یک پروژه جدید کاتلین ایجاد کردید.
– فایل `Main.kt` را ایجاد و تابع `main` را نوشتید.
– برنامه را اجرا و نتیجه را مشاهده کردید.

این مراحل برای ایجاد و اجرای هر پروژه جدید کاتلین در IntelliJ IDEA پایه‌ای است.

ایجاد فایل اصلی (Main) در کاتلین

در هر پروژه کاتلین، نیاز به یک فایل اصلی داریم که بتوانیم در آن تابع اصلی (`main`) را بنویسیم. این تابع نقطه شروع برنامه است و اجرای کد از اینجا آغاز می‌شود. در ادامه، مراحل کامل ایجاد فایل اصلی (`Main.kt`) و نوشتن کد در آن را بررسی می‌کنیم.

مرحله ۱: ایجاد فایل اصلی (Main.kt)

برای اینکه بتوانیم برنامه خود را در کاتلین اجرا کنیم، نیاز داریم یک فایل کاتلین جدید با نام دلخواه ایجاد کنیم. در این مثال، نام فایل را `Main.kt` می‌گذاریم، که البته نام‌گذاری `Main` صرفاً یک انتخاب رایج و قراردادی است و می‌توانید نام دیگری نیز انتخاب کنید.

1. ایجاد فایل کاتلین جدید:
– در پنجره **Project** در سمت چپ محیط IntelliJ IDEA، پوشه `src` را پیدا کنید. این پوشه به طور پیش‌فرض برای قرار دادن فایل‌های کد منبع در نظر گرفته شده است.
– روی پوشه `src` راست‌کلیک کرده و از منوی باز شده گزینه **New > Kotlin File/Class** را انتخاب کنید.

2. نام‌گذاری و انتخاب نوع فایل:
– پس از کلیک روی **Kotlin File/Class**، کادری باز می‌شود که از شما می‌خواهد نام فایل و نوع آن را مشخص کنید.
– در قسمت **Name** نام فایل را `Main` وارد کنید.
– نوع فایل را **File** انتخاب کنید و سپس روی **OK** کلیک کنید.
– با انجام این مراحل، IntelliJ IDEA فایلی به نام `Main.kt` در پوشه `src` ایجاد می‌کند.

مرحله ۲: نوشتن تابع اصلی (main) در فایل Main.kt

تابع اصلی `main` در کاتلین مانند زبان‌های دیگر نقطه شروع برنامه است. این تابع با کلمه کلیدی `fun` تعریف می‌شود و هر بار که برنامه اجرا می‌شود، دستورات موجود در این تابع اجرا خواهند شد.

1. نوشتن تابع main:
– فایل `Main.kt` را باز کنید. حالا آماده هستیم که تابع اصلی خود را در این فایل بنویسیم.
– کد زیر را در فایل `Main.kt` وارد کنید:

fun main() {
    println("Hello, Kotlin!")
}

2. توضیح کد:
– **`fun main()`**: در کاتلین، برای تعریف تابع از کلمه کلیدی `fun` استفاده می‌شود. `main` نام تابع اصلی است که توسط سیستم به عنوان نقطه شروع برنامه شناخته می‌شود.
– **`println(“Hello, Kotlin!”)`**: `println` یک تابع داخلی در کاتلین است که یک پیام متنی را در کنسول نمایش می‌دهد. در اینجا، ما پیامی با متن `”Hello, Kotlin!”` را در کنسول چاپ می‌کنیم.

مرحله ۳: اجرای فایل اصلی (Main.kt)

بعد از نوشتن تابع اصلی، حالا می‌توانید برنامه را اجرا کرده و نتیجه را در کنسول مشاهده کنید.

1.اجرای فایل Main.kt:
– روی فایل `Main.kt` راست‌کلیک کنید و از منوی باز شده گزینه **Run ‘MainKt’** را انتخاب کنید.
– یا می‌توانید از دکمه سبزرنگ **Run** در بالای پنجره IntelliJ IDEA استفاده کنید. این دکمه به طور خودکار تابع `main` را شناسایی کرده و برنامه را اجرا می‌کند.

2. مشاهده نتیجه:
– پس از اجرای برنامه، در پنجره **Console** در پایین محیط IntelliJ IDEA، خروجی زیر نمایش داده می‌شود:

Hello, Kotlin!

– این خروجی نشان‌دهنده آن است که برنامه شما به درستی اجرا شده و پیام `”Hello, Kotlin!”` در کنسول نمایش داده شده است.

 مرحله ۴: افزودن کد بیشتر به فایل Main.kt (اختیاری)

می‌توانید به راحتی دستورات دیگری به تابع `main` اضافه کنید تا ویژگی‌های بیشتری از کاتلین را بررسی کنید. به عنوان مثال، کد زیر یک مقدار را به متغیر `name` اختصاص می‌دهد و آن را در کنسول چاپ می‌کند.

fun main() {
    val name = "Kotlin Developer"
    println("Hello, $name!")
}

در این کد:
– `val name = “Kotlin Developer”`: با استفاده از `val` یک متغیر ثابت به نام `name` تعریف کرده و مقدار `”Kotlin Developer”` را به آن اختصاص می‌دهیم.
-`println(“Hello, $name!”)`**: با استفاده از `$` و نام متغیر `name`، مقدار آن در متن چاپ می‌شود.

جمع‌بندی

در این مراحل، یاد گرفتیم که چگونه فایل اصلی `Main.kt` را در پروژه کاتلین ایجاد کرده و تابع `main` را در آن تعریف کنیم. همچنین، با استفاده از تابع `println` اولین پیام خود را در کنسول چاپ کردیم. اکنون فایل اصلی شما آماده است و می‌توانید با افزودن کدهای بیشتر، برنامه‌های پیچیده‌تری بنویسید و اجرا کنید.

نوشتن اولین برنامه در کاتلین

برای نوشتن اولین برنامه در زبان کاتلین، باید یک فایل اصلی ایجاد کنیم و در آن، تابع `main` را بنویسیم. تابع `main` نقطه شروع برنامه‌های کاتلین است و تمام کدهای برنامه از این تابع شروع به اجرا می‌کنند. در اینجا به طور کامل توضیح می‌دهیم که چگونه می‌توانید این برنامه ساده را ایجاد و اجرا کنید.

مراحل نوشتن اولین برنامه کاتلین

۱. ایجاد پروژه جدید کاتلین در IntelliJ IDEA

1. **باز کردن IntelliJ IDEA**: ابتدا IntelliJ IDEA را باز کنید. اگر هنوز این IDE را نصب نکرده‌اید، می‌توانید از [سایت JetBrains](https://www.jetbrains.com/idea/download/) نسخه رایگان آن را دانلود و نصب کنید.
2. **ایجاد پروژه جدید**:
– در صفحه خوش‌آمدگویی IntelliJ IDEA روی **New Project** کلیک کنید.
– در پنجره‌ای که باز می‌شود، از قسمت **Kotlin** گزینه **Kotlin/JVM** را انتخاب کنید. این گزینه به شما کمک می‌کند که پروژه‌ای مناسب برای اجرای کاتلین روی ماشین مجازی جاوا (JVM) ایجاد کنید.
– یک نسخه از **JDK (Java Development Kit)** نیز باید انتخاب شود. اگر JDK نصب نیست، می‌توانید از طریق IntelliJ IDEA آن را دانلود کنید.
– روی **Next** کلیک کنید، سپس یک نام برای پروژه انتخاب کرده (مثلاً `HelloKotlinProject`) و مسیر ذخیره آن را مشخص کنید.
– روی **Finish** کلیک کنید تا پروژه ایجاد شود.

۲. ایجاد فایل اصلی (Main.kt)

بعد از ایجاد پروژه، باید یک فایل جدید کاتلین برای نوشتن کد برنامه ایجاد کنید.

1. ایجاد فایل جدید
– در پنجره Projectدر سمت چپ، به پوشه `src` بروید.
– روی `src` راست‌کلیک کنید و گزینه **New > Kotlin File/Class** را انتخاب کنید.
2. نام‌گذاری فایل:
– در کادر **Name**، نام فایل را `Main` بنویسید.
– نوع فایل را **File** انتخاب کنید و روی **OK** کلیک کنید.
– با این کار فایل `Main.kt` ایجاد می‌شود و آماده نوشتن کد است.

۳. نوشتن تابع اصلی (main) در فایل Main.kt

حالا فایل `Main.kt` را باز کنید. برای نوشتن اولین برنامه، از تابع `main` استفاده می‌کنیم که به عنوان نقطه شروع برنامه‌ها در کاتلین تعریف شده است.

1. **نوشتن کد برنامه**:
– تابع `main` را به صورت زیر تعریف کنید:

fun main() {
    println("Hello, Kotlin!")
}

2. توضیح کد:
– `fun`: در کاتلین برای تعریف تابع از کلمه کلیدی `fun` استفاده می‌کنیم.
– `main`: `main` نام تابع اصلی است که به طور پیش‌فرض توسط سیستم به عنوان نقطه شروع برنامه شناخته می‌شود. این تابع بدون پارامتر تعریف شده است.
– `println(“Hello, Kotlin!”)`: `println` یک تابع داخلی کاتلین است که متن داخل پرانتزها را در کنسول چاپ می‌کند. در اینجا، `”Hello, Kotlin!”` پیامی است که در کنسول نمایش داده می‌شود.

3. چگونگی عملکرد کد:
– وقتی این کد اجرا شود، برنامه به تابع `main` می‌رود، دستور `println` را اجرا می‌کند و پیامی با متن `”Hello, Kotlin!”` در کنسول نمایش داده می‌شود.

۴. اجرای برنامه

بعد از نوشتن تابع `main`، حالا می‌توانید برنامه خود را اجرا کرده و نتیجه را مشاهده کنید.

1. اجرای برنامه:
– روی فایل `Main.kt` راست‌کلیک کنید و گزینه Run ‘MainKt’ را انتخاب کنید.
– یا می‌توانید از دکمه سبز رنگRun در نوار ابزار بالای IntelliJ IDEA استفاده کنید.

2. مشاهده خروجی:
– در پنجره Run یا Console در پایین IntelliJ IDEA، خروجی برنامه نمایش داده می‌شود و باید عبارت زیر را ببینید:

Hello, Kotlin!

این خروجی نشان می‌دهد که برنامه به درستی اجرا شده و تابع `println` پیام `”Hello, Kotlin!”` را در کنسول نمایش داده است.

۵. توضیحات بیشتر و افزودن تغییرات به برنامه (اختیاری)

حالا که برنامه ساده `Hello, Kotlin!` را اجرا کردید، می‌توانید کدهای بیشتری به تابع `main` اضافه کنید تا بیشتر با امکانات کاتلین آشنا شوید. به عنوان مثال، می‌توانید یک متغیر جدید تعریف کنید و پیام را با استفاده از آن متغیر چاپ کنید:

fun main() {
    val greeting = "Hello, Kotlin!"
    println(greeting)
}

در این کد:
– `val greeting = “Hello, Kotlin!”: با استفاده از `val` یک متغیر به نام `greeting` تعریف کردیم که مقدار `”Hello, Kotlin!”` را در خود نگه می‌دارد. `val` به معنای متغیر ثابت است که پس از مقداردهی اولیه، نمی‌توان مقدار آن را تغییر داد.
– `println(greeting)`: این خط از مقدار متغیر `greeting` استفاده کرده و آن را در کنسول نمایش می‌دهد.

 جمع‌بندی

در این مراحل، اولین برنامه کاتلین خود را نوشتید و اجرا کردید. با این برنامه، مفاهیم اولیه کاتلین شامل:
– تعریف تابع (`fun`)
– تابع `main` به عنوان نقطه شروع برنامه
– استفاده از `println` برای نمایش پیام در کنسول

آشنا شدید. حالا آماده‌اید که برنامه‌های پیچیده‌تری بنویسید و ویژگی‌های بیشتری از کاتلین را یاد بگیرید.

اجرای برنامه

برای اجرای برنامه در IntelliJ IDEA و مشاهده خروجی آن، نیاز است که کد خود را در پروژه‌تان کامپایل و اجرا کنید. در اینجا به‌صورت کامل و گام‌به‌گام توضیح داده شده که چگونه می‌توانید برنامه‌ای که در کاتلین نوشته‌اید را اجرا کنید و خروجی آن را در کنسول ببینید.

مراحل کامل اجرای برنامه کاتلین در IntelliJ IDEA

مرحله ۱: اطمینان از ذخیره کد

پس از نوشتن کد برنامه در فایل `Main.kt`، ابتدا مطمئن شوید که کد شما ذخیره شده است. در IntelliJ IDEA، معمولاً کدها به طور خودکار ذخیره می‌شوند، اما برای اطمینان می‌توانید کلیدهای **Ctrl + S** (در ویندوز) یا **Cmd + S** (در مک) را فشار دهی

مرحله ۲: انتخاب فایل برای اجرا

برای اجرای برنامه، ابتدا باید روی فایل حاوی کد برنامه خود، که در اینجا `Main.kt` است، کلیک کنید. فایل `Main.kt` باید شامل تابع `main` باشد، زیرا این تابع نقطه شروع اجرای برنامه در کاتلین است.

مرحله ۳: اجرای برنامه از طریق منوی کلیک راست

1. کلیک راست روی فایل `Main.kt`:
– در پنجره Project در سمت چپ، به پوشه `src` بروید و فایل `Main.kt` را پیدا کنید.
– روی فایل `Main.kt` راست‌کلیک کنید.

2. انتخاب گزینه Run ‘MainKt’:
– بعد از کلیک راست، منویی باز می‌شود که گزینه‌های مختلفی را نمایش می‌دهد.
– در این منو، گزینهRun ‘MainKt را انتخاب کنید.
– `MainKt` به نام فایل کاتلین شما اشاره دارد که حاوی تابع `main` است. این گزینه به IntelliJ IDEA می‌گوید که پروژه را از تابع `main` موجود در فایل `Main.kt` اجرا کند.

مرحله ۴: مشاهده فرآیند اجرای برنامه

1. کامپایل و اجرا:
– با انتخاب گزینه **Run ‘MainKt’**، IntelliJ IDEA به طور خودکار کد شما را کامپایل می‌کند. این مرحله شامل تبدیل کد کاتلین به بایت‌کد قابل اجرای ماشین مجازی جاوا (JVM) است.
– سپس، برنامه از تابع `main` شروع به اجرا می‌کند.

2. مشاهده پیام‌های سیستم و خروجی:
– هنگام کامپایل و اجرای برنامه، IntelliJ IDEA ممکن است پیام‌هایی در پنجره Run نمایش دهد که به شما اطلاعاتی در مورد وضعیت اجرای برنامه می‌دهد، مثلاً پیام‌هایی درباره شروع اجرای برنامه یا موفقیت‌آمیز بودن آن.

مرحله ۵: مشاهده خروجی در کنسول

پس از اجرای موفقیت‌آمیز برنامه، خروجی برنامه در پنجره **Console** یا **Run** در پایین محیط IntelliJ IDEA نمایش داده می‌شود. به طور خاص:

– اگر کد شما به شکل زیر باشد:

fun main() {
    println("Hello, Kotlin!")
}

در این صورت، خروجی برنامه که در کنسول نمایش داده می‌شود، به این شکل خواهد بود:

Hello, Kotlin!

این پیام نشان می‌دهد که برنامه با موفقیت اجرا شده و دستور `println` پیام `”Hello, Kotlin!”` را در کنسول چاپ کرده است.

مرحله ۶: اجرای مجدد برنامه (در صورت نیاز)

اگر بخواهید برنامه را دوباره اجرا کنید، می‌توانید از دو روش استفاده کنید:

1. استفاده از دکمه Run در نوار ابزار:
– در بالای محیط IntelliJ IDEA، دکمه‌ای سبزرنگ با نام **Run** وجود دارد. با کلیک بر روی این دکمه، برنامه آخرین فایل اجرا شده (در اینجا `Main.kt`) را مجدداً اجرا می‌کند.

2.کلید میانبر برای اجرای مجدد:
– از کلید میانبر Shift + F10(در ویندوز) یا Ctrl + R (در مک) نیز می‌توانید برای اجرای مجدد آخرین برنامه اجرا شده استفاده کنید.

 نکات اضافی

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

 جمع‌بندی

برای اجرای یک برنامه کاتلین در IntelliJ IDEA:

1. روی فایل `Main.kt` راست‌کلیک کنید و **Run ‘MainKt’** را انتخاب کنید.
2. برنامه شما کامپایل شده و از تابع `main` اجرا می‌شود.
3. خروجی در پنجره **Console** نمایش داده می‌شود، که در این مثال پیام `”Hello, Kotlin!”` خواهد بود.

این مراحل به شما کمک می‌کند تا اولین برنامه کاتلین خود را در IntelliJ IDEA با موفقیت اجرا کنید و خروجی آن را در کنسول مشاهده نمایید.

افزودن کدهای بیشتر

پس از افزودن کد جدید به برنامه، باید آن را دوباره اجرا کنیم تا تغییرات اعمال شده را مشاهده کنیم. IntelliJ IDEA به شما اجازه می‌دهد که به‌راحتی برنامه را با اجرای مجدد، خروجی جدید را ببینید. در اینجا گام‌های کاملی برای اجرای مجدد برنامه آورده شده است.

مراحل اجرای مجدد برنامه در IntelliJ IDEA

 مرحله ۱: اطمینان از ذخیره تغییرات

هنگامی که کد جدیدی به برنامه اضافه کردید، مطمئن شوید که فایل خود را ذخیره کرده‌اید. در IntelliJ IDEA، معمولاً تغییرات به‌طور خودکار ذخیره می‌شوند، اما برای اطمینان می‌توانید از کلیدهای میانبر زیر استفاده کنید:
– **Ctrl + S** (در ویندوز) یا **Cmd + S** (در مک) برای ذخیره دستی فایل.

 مرحله ۲: اجرای مجدد برنامه

برای اجرای مجدد برنامه پس از اعمال تغییرات، می‌توانید از دو روش زیر استفاده کنید:

روش ۱: استفاده از دکمه **Run** در نوار ابزار

1. در نوار ابزار بالای IntelliJ IDEA، روی دکمه سبز رنگ **Run** کلیک کنید. این دکمه شبیه مثلثی رو به سمت راست است و به شما امکان می‌دهد تا آخرین برنامه اجرا شده را مجدداً اجرا کنید.
2. با کلیک روی این دکمه، IntelliJ IDEA به طور خودکار برنامه شما را کامپایل و اجرا می‌کند و نتیجه را در پنجره **Run** یا **Console** نمایش می‌دهد.

روش ۲: استفاده از گزینه **Run ‘MainKt’** از طریق کلیک راست

1. به فایل `Main.kt` در پنجره **Project** بروید.
2. روی فایل `Main.kt` راست‌کلیک کرده و گزینه **Run ‘MainKt’** را انتخاب کنید.
– این گزینه برنامه شما را از تابع `main` اجرا می‌کند و نتیجه به روز شده را نمایش می‌دهد.

روش ۳: استفاده از کلید میانبر برای اجرای مجدد برنامه

IntelliJ IDEA دارای کلیدهای میانبری است که می‌توانید از آن‌ها برای اجرای مجدد برنامه استفاده کنید:
– **Shift + F10** (در ویندوز) یا **Control + R** (در مک): این کلید میانبر باعث اجرای مجدد آخرین برنامه اجرا شده می‌شود و به شما اجازه می‌دهد به‌سرعت برنامه را دوباره اجرا کنید.

 مرحله ۳: مشاهده خروجی جدید در کنسول

پس از اجرای مجدد برنامه، خروجی جدید در پنجره **Run** یا **Console** در پایین محیط IntelliJ IDEA نمایش داده می‌شود. به عنوان مثال، اگر کدی مشابه زیر داشته باشید:

fun main() {
    val person1 = Person("Alice", 25)
    person1.greet()
    person1.haveBirthday()
}

و کلاس `Person` به شکل زیر تعریف شده باشد:

class Person(val name: String, var age: Int) {
    fun greet() {
        println("Hello, my name is $name and I am $age years old.")
    }

    fun haveBirthday() {
        age += 1
        println("Happy Birthday, $name! You are now $age years old.")
    }
}

پس از اجرای مجدد، خروجی به شکل زیر خواهد بود:

Hello, my name is Alice and I am 25 years old.
Happy Birthday, Alice! You are now 26 years old.

این خروجی نشان می‌دهد که تغییرات شما به درستی اعمال شده و کد جدید اجرا شده است

مرحله ۴: بررسی و اشکال‌زدایی (در صورت بروز خطا)

اگر برنامه پس از اجرای مجدد خطایی نشان داد، IntelliJ IDEA پیام‌های خطا را در پنجره کنسول نمایش می‌دهد. این پیام‌ها به شما کمک می‌کنند تا مشکلات موجود در کد را شناسایی و برطرف کنید. برای مثال، ممکن است پیام‌هایی درباره مشکلات دسترسی به متغیرها، خطاهای تایپی یا ناسازگاری انواع داده‌ها ببینید.

نکته‌های اضافی

– اگر تغییرات شما در کلاس‌ها یا توابع دیگری اعمال شده است، و IntelliJ IDEA آن‌ها را تشخیص نداده است، می‌توانید از گزینه **Build > Rebuild Project** در منوی بالا استفاده کنید تا پروژه به طور کامل بازسازی شود.
– پس از بازسازی پروژه، دوباره برنامه را اجرا کنید تا تغییرات جدید به درستی اعمال شوند.

جمع‌بندی

برای اجرای مجدد برنامه بعد از افزودن کدهای جدید:

1. ذخیره تغییرات: مطمئن شوید که فایل‌ها ذخیره شده‌اند.
2. اجرای مجدد: از یکی از روش‌های اجرای مجدد، مانند دکمه **Run**، راست‌کلیک روی فایل و انتخاب **Run ‘MainKt’**، یا استفاده از کلید میانبر **Shift + F10 استفاده کنید.
3. مشاهده خروجی جدید: خروجی به‌روز شده در پنجره کنسول نمایش داده می‌شود.
4. اشکال‌زدایی در صورت نیاز: در صورت بروز خطا، پیام‌های کنسول را بررسی کنید و مشکلات احتمالی را رفع کنید.

با این مراحل، به‌سادگی می‌توانید تغییرات جدید در کد را آزمایش کرده و از اجرای درست آن‌ها اطمینان حاصل کنید.

 جمع‌بندی

این مراحل، یک پروژه ساده کاتلین با تعریف کلاس و استفاده از توابع را به شما نشان دادند. در این پروژه:
– یک فایل کاتلین ایجاد کردیم و تابع اصلی `main` را نوشتیم.
– یک کلاس به نام `Person` با دو ویژگی و یک تابع تعریف کردیم.
– از کلاس `Person` در تابع `main` استفاده کردیم و ویژگی‌های آن را نمایش دادیم.

می‌توانید از این ساختار برای ایجاد پروژه‌های پیچیده‌تر استفاده کرده و به کدهای خود ویژگی‌های بیشتری اضافه کنید.