Getting Started: Kotlin Project in IntelliJ

1. Creating Your First Kotlin Project

Your first step is to create a new Kotlin project. While the process is similar to creating a Java project in IntelliJ, there are a few Kotlin-specific options to be aware of.

To guide you through this, I recommend watching the following short video from the official IntelliJ IDEA channel. It provides a clear, visual walkthrough of the entire process, from project creation to running the code.

As you set up your own project, here are the key settings to configure in the "New Project" dialog:

1. Name and Location: Give your project a name, for example, KotlinHelloWorld.
2. Language: Select Kotlin.
3. Build System: You'll see options like IntelliJ, Gradle, and Maven.
   • You are already familiar with Maven from your Java work. In the Kotlin ecosystem, Gradle is the more common build tool, and we will use it in later modules when we build Spring Boot applications.
   • For this first simple application, select IntelliJ. It's the simplest option and doesn't require configuring any build scripts.
4. JDK: Select a JDK version 11 or higher. You can use an existing one or have IntelliJ download a new one for you.
5. Sample Code: Check the box for Add sample code. This will automatically generate a simple "Hello, World!" file for you, which is perfect for our goal.

Go ahead and create the project now, following the steps from the video and the guide above.

2. Understanding the Project Structure and main Function

Once IntelliJ has finished setting up, you'll see the project structure in the Project tool window. It should look something like this:

KotlinHelloWorld
├── .idea
└── src
    └── main
        └── kotlin
            └── Main.kt

This structure should feel intuitive. The src/main/kotlin directory is the default location for Kotlin source files, directly analogous to src/main/java in a standard Maven project.

Open the Main.kt file. The .kt extension is used for Kotlin source files. Inside, you'll find the following code, or something very similar:

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

This is the entry point of your application. Let's break down how it compares to the Java main method you're used to:

The most significant difference is that Kotlin's main can exist outside of a class. This reduces boilerplate for simple applications and scripts.

3. Running Your "Hello, World!" Program

Now, let's run the application. This part will be very familiar.

As the video shows, you can run your application by:

1. Clicking the green "Run" icon in the gutter next to the fun main() line.
2. Selecting "Run 'MainKt'".

IntelliJ will compile and run your code, and you'll see the output in the Run tool window at the bottom of the screen:

Hello, World!

Process finished with exit code 0

Congratulations, you've just run your first Kotlin program!

4. Hands-On Practice

To solidify what you've learned, let's do it once more, but this time without the sample code.

1. Create a new Kotlin project in IntelliJ IDEA named KotlinIntro.
2. Choose the IntelliJ build system and your preferred JDK.
3. Do not check the "Add sample code" box this time.
4. After the project is created, right-click the src/main/kotlin directory and select New -> Kotlin Class/File.
5. Choose File and name it App.kt.
6. Inside App.kt, type main and press Enter. IntelliJ's live template will generate the main function for you:

   fun main() {
       
   }
   

7. Inside the main function, add a line to print a custom message:

   println("Welcome to Kotlin!")
   

8. Run the App.kt file and verify that your message appears in the Run window.

This exercise confirms you can create, write, and run a basic Kotlin application from scratch.

Conclusion

In this lesson, we accomplished our goal of setting up and running a "Hello, World!" application in Kotlin. You are now familiar with the initial steps of Kotlin development in IntelliJ.

Key Takeaways:

• Creating a Kotlin project in IntelliJ is straightforward, with choices for build systems like IntelliJ, Gradle, and Maven.
• Kotlin source code resides in src/main/kotlin, similar to Java's structure.
• The entry point is a main function, which can be a top-level function, making it simpler than Java's main method.
• You can run a Kotlin application directly from the editor using the gutter icon.

Next Lesson Preview:

Now that you have a working environment, we'll dive into the core syntax. In the next lesson, you will learn how to declare read-only variables using val and mutable variables using var, and see how Kotlin's powerful type inference helps write more concise code.