Course Overview

Course Overview

Hi everyone. My name is Jim Wilson. Welcome to my course, Android Apps with Kotlin: Build Your First App. I'm managing partner of JWHH LLC, and I've had the good fortune to have been a professional software developer now for over 30 years. I've been creating apps for Android since the earliest days of the platform, and I've seen many exciting changes in that time, but none more so than the addition of Kotlin as an Android development language. Kotlin's a game changer. It tremendously simplifies the task of creating Android apps, and it includes a number of features that reduce the likelihood of our apps encountering problems at runtime. Now one of the coolest things about using Kotlin in your Android apps is that you can start using it right away, even in your existing Android apps that have been already been written in Java. Kotlin has fantastic compatibility with Java, and a single Android project can include both code written in Java and Kotlin. And in this course, we're going to teach you everything you need to know to get started developing Android apps with Kotlin. Now some of the major topics we cover include Kotlin language features such as type declarations, null safety, singletons, and data classes; Android activity UI creation and how to connect the UI to your Kotlin code; information passing between activities using intents; activity lifecycle and app data management; and activity instance state management. By the end of this course, you will have successfully created an Android app using Kotlin, and you'll have a solid grounding in the fundamentals of Android app development with Kotlin. This is a beginner course, so you don't need to have any experience with Android or the Kotlin programming language. It is, however, helpful if you have familiarity with any other object-oriented language such as Java or C#. So I hope you'll join me as we learn to develop Android apps with the Pluralsight course, Android Apps with Kotlin: Build Your First App.

Creating and Running a Kotlin App with Android Studio


Welcome to the Pluralsight course Android Apps with Kotlin: Build Your First App. This is our first module, Creating and Running a Kotlin App with Android Studio. My name is Jim Wilson. Throughout this course, we'll take you through everything you need to understand to start building Android apps using the Kotlin programming language. Now no prior experience with either Android or Kotlin is required for this course. We'll cover everything that you need to know. Now in this first module, we'll cover the basics of creating and running an app using Android Studio. In the next module, we'll take you through the fundamentals of working with types in Kotlin. After that, we'll start getting into the details of creating Android activities and how an activity's code and layout interact. We'll then learn how to launch one activity from another, including how to pass information between those activities. From there, we'll get into options menus and what are called action bar actions. Next, we'll see how Android manages transitions between activities using something known as tasks, and we'll see how to leverage activities from other apps within our own app experience. And then finally, we'll dig into the lifecycle of activities. Now whenever I'm working in a new environment, before I get into all the details, I first like to quickly get a sense of the full end-to-end development experience, and that's what we'll do in this first module. We'll go through the end-to-end experience of creating and running an Android app developed with Kotlin. We'll start out with a short overview of downloading and installing Android Studio. We'll then create a new Android application project that includes support for Kotlin. Next, we'll make some simple changes to the layout of the app's user experience. From there, we'll add some Kotlin code to our app. And then finally, we'll run our app using an Android emulator.

Downloading Android Studio

To get started building Android apps using Kotlin, we, of course, will need to have the tools that we'll use. And whether we're working in Kotlin or Java, the primary tool we'll use to create Android apps is Android Studio. Now getting machines set up with Android Studio is super simple. Start out by visiting the URL that I currently have on screen, click on this box here where it says DOWNLOAD ANDROID STUDIO, and when you do, it'll prompt you to accept the terms and conditions. You can then download the Android Studio install file. And once that download completes, simply run the install file and follow the on-screen prompts. Now that installation process will take care of everything you need to get started creating Android apps. It'll provide you with the interactive development environment, including both Java and Kotlin language support. It'll also provide you with the necessary debugging tools, testing tools, and even an Android device emulator. So once the Android Studio install is completed, we'll be ready to start building our Android app using Kotlin. And that's what we'll start doing in our next clip.

Creating a Kotlin Project

Once we have Android Studio installed, we're ready to start creating our Android project. Now the first time we launch Android Studio, you're brought to a screen like this one, and the option that we're interested in is this first one, Start a new Android Studio project. Let's go ahead and select that. So that then takes us to a screen that allows us to identify our project. Now the first thing we'll look at here is the Application name. Now the project we'll be building throughout this course will be a project to create an application that allows us to keep notes about Pluralsight courses. Now we'll talk about the details of the application a little bit later. But for now, let's just go ahead and give it an appropriate name, so we'll name our application NoteKeeper. So that gives us our application name. Now for the Company domain and Project location, we'll go ahead and keep the defaults. But before we leave this screen, there's one key thing we want to do. Notice down here at the bottom there's a checkbox that says Include Kotlin support. Now, by default, Android Studio only includes Java support in the Android projects. Well, we're going to be doing our work in Kotlin, so what we want to do is head down to this checkbox here, and we'll check that box so that our project will include Kotlin support. So now let's go ahead and move to the next screen. So now on this screen, we want to identify what kind of devices we want to target. So we're going to go ahead and keep the default here of Phone and Tablet, so we're building an application so it'll support Android phones and Android tablets, and then we have to specify the API level. So now when it comes to choosing an API level, we're balancing two needs. On one hand, we want to support as many Android devices as possible. On the other hand, we want a version of Android that has as many features as possible. So in order to help us make that decision, Android Studio provides us a link here, Help me choose. And if we select Help me choose, it brings up this screen. Now Android is identified in two ways. The Android operating system is identified by version numbers, and we see those on the left side of our screen here, and those are things like 4. 0, 4. 1, and so forth. But from a developer's standpoint, we look at the API level. And the API level is identified by an integer, and so each Android version supports a particular API level. So, for example, Android 4. 0 supports API level 15, or if we jump further down, Android 7. 0 supports API level 24. So now we look here, we have this column, CUMULATIVE DISTRIBUTION, and that gives us an idea of what percentage of Android devices support a particular version of Android. So, for example, if we targeted Android 4. 1, that means that 99. 2% of devices have Android 4. 1, which is API level 16 or higher. So that means we're going to support lots and lots of devices out there, but we can only use features that are available on API level 16. If we head down here further to where it says 7. 0, API level 24, well that's only 8. 1% of devices. So that would mean our application would work on only 8. 1% of devices out there, but we'd have access to all the features that are available on API level 24. So we're always trying to balance that out, targeting as many devices as possible while getting access to all the features we need. Now this screen helps us know what features were introduced at each API level. So if I go here to Android 4. 4, which is API level 19, and I select that, notice on the right here it gives me a list of the features that were introduced at that API level. If I head down here to Android 7. 0, which is API level 24, and then I select that, it shows me the features that were introduced at API 24. So when we're creating our Android projects, we need to balance these features that are introduced at each API level along with the need to reach as many devices as possible. So let's go ahead and leave this screen. So that takes us back to the screen here where we specify which API level we want to target. Now at the time I'm recording this, Android 8. 0, which is API level 26, supports very few devices. But since we're building this project for our course and we're not really deploying it, we're not really worried about supporting a large number of devices. We really want to see the features that are available, so let's go ahead and stay with that option of using API level 26. So we'll go ahead and go to our next screen. So this screen is where we identify the initial activity we want to include in our application, and we're going to talk a lot about activities throughout this course. Loosely speaking, we can think of an activity as a screen within our application. Actually, it has a lot more going on than that, but for now we'll just think of it as a screen. So let's go ahead and choose the activity option of Basic Activity. So by choosing Basic Activity, we'll have a section at the top of our activity where we can put things like options menus, and our activity will also include something called a floating action button, which is a button that floats above the activity that we can associate tap actions with. So with our Basic Activity selected, let's go ahead and go to our next screen. So on this screen, we'll specify the class name and some other names associated with the initial activity in our application. We'll go ahead and take all the defaults on this one, then we'll head down here to our Finish button, and we'll go ahead and select Finish. And once we do that, Android Studio takes care of generating the project for our application. So now in our next clip, let's take a closer look at our project within Android Studio.

Understanding the Parts of the Android Studio Layout Designer

So here we are now in Android Studio looking at our newly generated project. And before we start making modifications to our app itself, let's take a look at some of the relevant parts of Android Studio. If you're on the left-hand side, we have our Project window. The Project window has a tree-like appearance that shows us some of files and folders that are involved in our project. At the top of the Project window is a drop-down selection. Now this drop-down allows us to select the different views of how the project files and folders are displayed within the Project window. Now the view we currently have selected is the Android view, and it's the Project window's Android view that we use the overwhelming majority of the time. So now let's look at the center area of Android Studio. We see two things that look kind of like a screen. Now these are two different representations of our app's activity layout. Now the one to the left is a representation of how the screen might actually look when displayed on a device, and this is what's known as the layout's design surface appearance. Now the one on the right is a representation of the components that make up the layout. This is what's known as our layout's blueprint surface appearance. Now next we have the Palette. Now the Palette is a list of different what we call widgets or views, or sometimes we even call them controls, and we used these within our user interface. Now we can just drag these from the Palette onto either our design surface or our blueprint surface. Under the Palette, we have the Component Tree. The Component Tree just gives us a tree-like representation of how the views are arranged on our layout. Now let's look here down towards the bottom of Android Studio, and you see there we have some tabs. Now one tab is labeled Design. The other is labeled Text. The Design tab is the one we currently have selected, and that indicates that we're currently looking at our layout's design view. So let's select the other tab, which is our Text tab. And when we make that selection, we see some text appear, and you might recognize that text as XML. So what this is showing us is that the layout of our activity is actually described using XML. And by using XML, we're able to describe our activity's appearance independently from the code that interact with it, and this gives us a clear separation between the activity appearance and the associated application logic. Now if we wanted to, we could edit this XML directly. But in general, we don't do that. Instead, we work in the layout's design view and just let Android Studio do the work of generating the XML. So with that in mind, let's go back over here to our Design tab and select that, and that brings us back to our layout's design view. Alright, so now that we have a better understanding of some of the key parts of Android Studio, in our next clip, we'll start working on our application's appearance and behavior.

Modifying the Activity Layout

We're back here in Android Studio, and we're ready to start making some changes to our app's behavior. Before we get started, let's do something that will allow us to see the design appearance of our layout a bit more clearly. What we'll do is we'll hide the Project window. So now we can do that by clicking on the word Project here on the left. So that hides our Project window, and anytime we want to open the Project window back up, we can just click on that word Project again. With our Project window hidden, we now have more room to interact with our layout's design and blueprint surfaces. Now as I mentioned earlier, the project we'll be building throughout this course will ultimately be an app that creates notes for Pluralsight courses. But before we get into that, let's start with something much simpler. Let's do something simple that'll allow us to experience the whole app development experience from layout, to code, to running our app. So for this simple start to our app, what we'll do is take this view known as a text view, so it's currently displaying Hello World!, and we'll change it to display a number. Then we have this floating action button down here, and let's make it so that each time the user taps on that floating action button that we double the number that's displayed in the text view. And while we're at it, we'll have a message slide up from the bottom that displays the number's value before and after being doubled. So for this simple version of our app, the first thing we'll need to do is make some changes to our user interface layout. Now you'll notice here on the right side of Android Studio there's a window labeled Attributes, and currently there's nothing in it. But now if I go over here to the view displaying Hello World! and then I select that, and now the Attribute window shows some of the attributes for the selected view. Now one thing to note is that the Attribute window is currently displaying only those attributes that people most commonly need to interact with. But you'll notice that the Attribute window has a couple of arrows here. If we were to click on those, the Attribute window would then display all of the attributes that are available for the selected view. But for our simple app, the list of attributes that's currently displayed gives us everything we need, so we're all set here. Now one of the most important attributes is the ID. It's the ID that makes the view accessible from within our code. Now when working in Kotlin, each view is automatically accessible from a variable of the same name as a view's ID attribute. So let's set our view's ID to textDisplayedValue. And by doing that, we can now access this view from within our activity's code by using a variable named textDisplayedValue. So now remember, in this simple version of our app, we want to keep doubling the value that's contained within this view. So rather than having this view's initial text set to Hello World!, let's instead make it the number 1. So what we'll do is go down here to our text attribute, and we'll change Hello World! to the number 1. So now that's set, let's go ahead and make a simple cosmetic change to our view. So now to do that, we'll need to scroll the Attribute window down a bit. And once we scroll down, we can see the textAppearance attribute. Now currently, textAppearance is set to Material Small, but then we'll see as we click the drop-down there are a whole bunch of other values that are available. So to make the value within our view a bit more visible, let's change the Material Small to Material Large. So let's start scrolling down, and then we'll just go ahead and choose Material Large. And when we do that, we can now see that our view's font is a bit larger than it was previously. And with that, our layout's all set. So in our next clip, we'll start adding some code to our application.

Adding Kotlin Code to the Activity

Here we are back in Android Studio. We're ready to start adding some code to our app. To get to the source code for our activity, we use the Project window, so we'll need to open the Project window back up. To do that, we go over here where it says Project, and we just click on it. Now just as a reminder, we have the Android view of the Project window selected, and remember that the Project window shows folders and files associated with our app. Our top-level folder is the app folder. One of the folders under the app folder is the java folder. Now don't let the fact that the folder's named java throw you. All the source code, whether Java or Kotlin, is under the folder named java. Now let's go ahead and expand that java folder. And when we expand that folder, we see three folders underneath of it. The bottom two folders are where our project's test code is placed. The code for our application is in that first folder. Let's go ahead and expand that first folder. And once we expand that folder, we can see the source code file for our app's MainActivity. So we'll go ahead and double-click on the MainActivity to see that source code. So here we are now looking at the source code for our MainActivity. We'll talk about the details of activity classes a little bit later in this course. For now, let's just focus on adding the code we need to add functionality to our floating action button. So the code we're interested in is here where we have the code fab. setOnClickListener. This code was added for us automatically by Android Studio when we created the project. This is the code that it handles when the user taps on the floating action button. Now the main thing we want to do when the user taps on the floating action button is double the value that's contained in our activity's text view. So we'll go and add a blank line, and then we'll declare a variable to hold the current value of the text view. To do that, we use the val keyword, and we'll name our variable originalValue. Now if this is the first time you've seen a variable declared in Kotlin, that declaration may look a bit odd, but don't worry too much about it because in the next module we'll dig into how we work with types in Kotlin, and as part of that discussion we'll see how variables are declared. So now that we have our variable declared, we can assign it the value that's contained in the view. Now remember when we were working with our layout we set our view's ID to be textDisplayedValue, so that means that here in our Kotlin code we can access that view with a variable named textDisplayedValue. So now to access to view's text value, we use the view's text property. The type that's returned by the text property is something that's known as the a char sequence. Now we want to get our value back as an int. So now to do that, we'll first call the toString method to convert our value from a char sequence to a string, and then we'll call the toInt method to convert the string to an int. So now with that, originalValue will hold our view's current value stored as an integer. So now the next thing we want to do is double that value, so let's declare another variable, and we'll name this variable newValue, and we'll assign it the result of multiplying originalValue by 2. So now we're ready to display the new value. So to do that, we'll start out with the variable for our view, we'll access its text property, we then assign the variable newValue to the text property, and then we'll use the toString method to convert the value from an int to a string. And now that easily our app will double the value displayed in our text view each time the user taps on the floating action button. So now let's do one more fun thing. Let's include a message that slides up from the bottom of the screen and displays the old newValues. Now the way we do that is by using an Android Snackbar. And as you can see, the code generated by Android Studio includes the code necessary to display a Snackbar, so let's just go ahead and modify that code. So the first thing we'll do is change the text currently displayed by the Snackbar. Let's start out by just including the word Value. Now after the word Value, we want to show the view's original value. To do that, we can put a dollar sign followed by the name of our originalValue variable. Now that dollar sign followed by a variable name is known as a string template. So when Kotlin creates that string, it'll take care of the details of getting the variable's current value and including that value in the string. So now the next thing we want to put in the string is the literal text changed to, and then we want to include the value inside of our variable newValue, so again we'll use a dollar sign and then put the variable name newValue after the dollar sign. So let's go ahead and put a line break after the comma so we can see all the code. And then just one last little thing. Let's get rid of this call here to the method setAction. Because our application is simply displaying a message, we don't need to associate any action with that message. So now with that, each time the user taps on our floating action button, we'll double the value that's displayed in our text view, and we'll have a message slide up from the bottom of the screen showing the old and new values. So now in our next clip, let's set up an Android device emulator, and we'll run our code.

Running the App Within an Emulator

Here we are back in Android Studio. We're now ready to run our app. Now we'll run our app using an emulator. And emulators are also known as Android Virtual Devices, or AVDs, but whichever term we use, we're talking about the same thing, a software representation of Android device. Now we'll launch our app using the debugger. And to do that, we'll select this button up here, so then Android Studio will take care of doing a build of our app if that's necessary, and it'll prompt us to select our deployment target. If we had a physical Android device connected to the computer, that would show up in this dialog. Additionally, if we had any existing emulator images configured, they'd show up here as well. But in our case, we don't have any existing images, so let's go ahead and create one. So to do that, we'll go here to this button, Create New Virtual Device, and then we'll go ahead and select that. So now this is the way we create a new emulator image. And to do that, we have to identify the characteristics of that emulator. So the first characteristic we need to identify is the hardware profile we'd like it to use. Generally, we want to use a profile that corresponds to a real device, and to do that, we can select one of the profiles from this list. So let's go up here to Pixel 2, and we'll go ahead and select that. So that indicates that our emulator should emulate a Pixel 2 device. So now we can go ahead and move to the next screen. So now the next thing we need to identify is which version of Android we want installed onto the emulator, so let's go ahead and select Android 8. 0. Now Android 8. 0 has an API level of 26, and its release name is Oreo. Now if you see the word Download next to the selected release name, it simply means that you need to download the files necessary to use that version of Android. You can do the download right from here. All you need to do is click on that word Download. And once you have those files downloaded, it'll bring you right back to this screen. So now that we've selected our Android version, let's go ahead and move to our next screen. Now on this screen, we can make any desired changes to our emulator's configuration. Also, from here, we can rename the emulator image. Now you can name the image anything you'd like, but I generally just go ahead with the default name. The default name is composed of the hardware profile followed by our Android API level. So once we're happy with everything, we can go ahead and click Finish. And when we do, we now see the name of our newly created image listed as an available virtual device. So with that image selected as our deployment target, we'll click OK. And then after a few moments we see our emulator start up, and then it launches our app running within it. Now one thing to be aware of, if you are working with an older computer or a computer with limited processing or memory resources, it may take a few minutes for the emulator to start up and begin running your app. But once the app is up and running, we can go ahead and try it out. So now notice that the value displayed in our app is 1. And as you recall, this is the value we set using the view's text attribute when we were working with the layout in Android Studio. So now we have our floating action button down here, so let's go ahead and select that, and you notice that when we do the value changes from 1 to 2. Notice also that we had a message slider from the bottom. That message was displayed for a few seconds and then slid back down. That was our Snackbar. So let me go ahead and tap the floating action button again, and we can see the message displayed by the Snackbar says that the value 2 changed to 4, and 4 is now the value displayed within our app. So with that, it looks like everything is working just how we like it to. We were able to create our app, we modified its activity layout, we added some code, and now within our emulator we're able to see our app run. So I say that all and all we're off to a fantastic start.


Alright, that wraps up our first module, and how cool was that? In just a matter of a few minutes we created a brand-new Android app, we made some simple changes to its layout, we added some Kotlin code to interact with that layout, and then we ran the app within an Android emulator. So now here are some of the key things you'll want to remember from this module. Now the tool we used was Android Studio, and Android Studio provides a complete development environment for creating our Android apps. Now within Android Studio, we had the layout designer. And the layout designer allows us to add views to the layout to describe our user experience, and we configure the characteristics of those views by setting their attributes. Now the way we access our views in code is based on this ID attribute, so we specify the ID attribute for our view. And when we do that, we'll be able to access that view from within our code using a variable that has the same name as the value of that ID. Basically, Kotlin takes care of synthesizing that variable for us. And then we have our emulator. Now remember that emulator lets us run our Android apps directly on our desktop computer. And also remember that whether someone refers to it as an emulator, an Android Virtual Device, or AVD, in all cases, they're talking about the same thing, a software representation of an Android device. Okay, so now we've successfully created and run an Android app. In our next module, we'll start digging into the basics of working with the Kotlin programming language.

Describing Types with Kotlin


Welcome to our next module, Describing Types with Kotlin. This is part of the Pluralsight course Android Apps with Kotlin: Build Your First App. My name is Jim Wilson. In this module, we'll look at some of the basic concepts around using, defining, and interacting with types when working in Kotlin. Now we're not going to dig deep into any of these concepts. Rather, our focus is on acquiring the fundamental skills required to rapidly get up to speed and start building Android apps using Kotlin. So we'll start out with a quick look of what it's like to use Kotlin on the Android platform, a platform which has historically always been Java based. We'll then take a look at some of the basic types in Kotlin and see how we declare variables when working in Kotlin. We'll see how to define our own types using classes. We'll see how to declare and use properties. We'll learn about something known as a primary constructor. We'll then see how to declare functions and take a look at some of the options we have for passing parameters to functions, and then we'll finish up with a look at type initialization.

Using Kotlin with Android

Now Kotlin's rapidly becoming the preferred language for developing Android apps. And although there's a lot of reasons that one chooses a development language, here is three of the common reasons that people site as the reason they like using Kotlin to develop their Android applications. So now the first issue is coding efficiency. And with Kotlin, we just tend to write a lot less code than other environments. Now this is due in part due to Kotlin's concise syntax. Kotlin is specifically designed to take advantage of the powerful capabilities of modern compiler technology, and this allows the language to be very expressive while maintaining a very concise syntax. Now also, Kotlin avoids the need to write so much boilerplate code. In other words, Kotlin minimizes the need to explicitly deal with many common housekeeping tasks, and instead it allows us to focus on writing code that's central to our app's features and functionality. So now another key reason that people give for choosing Kotlin is that it helps to reduce runtime errors because the complier is better able to identify potential erroneous situations. Now one way Kotlin does this is with built-in null safety. Kotlin requires that we be very intentional about the nullability of values, and Kotlin enforces rules for interacting with potentially null values. Another key way that Kotlin helps reduce errors is that the language allows us to be expressive about our intentions with a particular value and how we expect that value to be used. Now this in turn allows the compiler to identify when the value is used in a way that's inconsistent with those intentions. So instead of having to wait until runtime to encounter and debug such an error, the potential for the error to occur can instead be discovered by the compiler. And then finally, another key reason people choose Kotlin is for its excellent compatibility, and it has excellent compatibility with Java, and it has excellent compatibility with Android. It's this excellent compatibility that allows us to use Kotlin as an effective solution for developing apps for the Android platform, a platform that's been primarily Java based right from the very start, and Kotlin is fully compatible with Java. Now this allows Kotlin code to take full advantage of Java libraries and all their contained types, and that includes the entire type system used to create Android applications. Now when the Kotlin code is compiled, it's compiled into the same form as code developed in Java. And that means that when we're working in Android Studio, we'd include both Java code and Kotlin code in a single Android project. So if we have an existing app that we've previously created in Java, we can start writing new code in Kotlin, and the Kotlin code will work together with all that existing Java code just fine. Now the main reason we create Android apps is so we can deploy them to our users. And the Android apps we create with Kotlin produce the same distribution file format as Android apps created with Java. So this means we can deploy our Kotlin-based Android apps, and those apps will work fine on our user's Android devices, and even on devices running older versions of Android. And we're able to do this without requiring any special software on the end user's device. The apps that we build using Kotlin are self-contained, and they're just as easy for our user to install and run as an app created using Java. In fact, the user has no indication of whether the app was created with Java or using Kotlin. So now in our next clip, we'll look at the basic types that are available in Kotlin. We'll see how to declare variables that use those types.

Basic Types and Variable Declarations

Let's look now at some of the basic types in Kotlin. Now, of course, we have signed integers. We can have signed integers that are 8 bits in size, 16, 32, or 64 bits in size, and we declare those using the types byte, short, int, or long. Similarly, we have floating-point types, so we use the float type to declare a floating-point value of 32 bits and the double type to declare a floating-point value of 64 bits. In addition to the numeric basic types, we also have Boolean, which allows us to store a true or false value, char, which allows us to store a single character, and then we have string to store a sequence of characters. Now we'll of course want to declare variables of the various types, and variable declarations are one of the ways that Kotlin allows us to indicate our intentions because there's actually two different ways to declare a variable. One way to declare a variable is using the var keyword, and that declares a mutable variable, and this is what we generally think of as a variable. We can give it an initial value, and we can then later change that value as many times as we would like. Another way we can declare a variable is using the val keyword, and this declares an assign-once variable, in other words, a ready-only variable. So we can give it an initial value, but once a value's been assigned to it, no new values can be assigned to it. So the val keyword allows us to indicate our intentions that we're declaring a variable that once assigned shouldn't change. So let's look at some examples here. So let's declare a variable named student. We'll use the var keyword. Now this is declaring a mutable variable. Now notice that the way we indicate its type is we say var, the variable name, followed by a colon and the type. So student is a string variable. And again, because we used var, it's mutable. So then we can take our student variable, and we can give it an initial value. So in this case, its initial value is the string Jenny Student1. We can go off and do some work with it. And then after that, we can take student, and we can assign it a new value. So now we assign it a new value of Amit Student2, and we can do some work with that. So let's declare another variable. We declare a variable company. We use the val keyword, which means that company is an assign-once variable. Now we've given it the type String, so we can make an assignment to it. So in this case, we're assigning its initial value, so company's initial value is the string Pluralsight. But now remember we indicated we declared company that was an assign-once variable. It's our intention that once this variable is assigned it shouldn't change. So if we have code like company = Another Company, well, since Company's already been assigned and it's an assign-once variable, the compiler will actually indicate that that's an error. So the compiler would catch the fact that we're tying to assign a second value to the variable after we've already assigned its initial value. Now, as we mentioned, one of the values of Kotlin is that it has a concise syntax. So let's look here where we declare our variable. Now we're declaring a variable using the var keyword, so it's a mutable variable, but notice that we haven't given the variable student a type. We simply have assigned it. Now we could have given student an explicit type, but since we're assigning it right here where we declare it, the compiler can infer its type. So since we're assigning a string value to the variable, the compiler will infer that student should be a string. Now, of course, we can go off and do some work with student, and now we can assign a new value to the variable. Alright, so that assigns our new value into it, but now I think it's important to understand that Kotlin is not a dynamically typed language. That variable, student, is a string. So if we were to try to do something like assign an integer to student as the new value, that would actually be a compile time error because Kotlin inferred the variable's type based on the initial value that was assigned to it. Alright, but now as long as we assign a proper value as we're doing here, we could then go off and do some work using the new value in student. And the type of a variable can be inferred whether we're using the var keyword or the val keyword. So we say val company = Pluralsight, again, this is an assign-once variable, and, again, the type is inferred. Since we're assigning a string to company, the compiler will infer that the type of the variable company should be string, but it's still an assign-once variable, right? So if we try to assign a new value to it, again, the compiler will indicate that that's an error. Alright, so now in our next clip, let's see how we can define some of our own types in Kotlin.

Defining Types

As part of building our application, we'll need to define new types. We define types in Kotlin as classes, so we do that using the class keyword, we give our types a name by placing the type's name after the class keyword, and then the body of our class will be contained inside of brackets. There are a number of different things that will make up our classes. Classes can have things like properties, classes can have a primary constructor, and classes can, of course, have functions. And these three things, properties, primary constructor, and functions, those are the things that we most commonly interact with in our classes, but we can also have things like initialization blocks and secondary constructors. We'll look at each of these in more detail as we go throughout this module. So in our next clip, let's start with properties.


Now as we mentioned, classes can have properties, and a property is used to represent a value within a class. Now properties, like variables, must specify the mutability. So if I declare a property using the var keyword, it's a mutable property. If I declare a property using the val keyword, then it's an assign-once property. And when a class has properties, each property could be used to simply store and return a value, or a property can optionally associate code. So we can have explicit code that's run when someone tries to get the value of a property, and we could have a code that's run when someone tries to set the value of a property. So let's go ahead and declare a class. So we have a class. We'll call that class Person. So we start with the class keyword as the name of our class, and then the body of the class goes inside of brackets. So our first property we'll declare with the val keyword. We'll call that property name, its type is String, and we give it an initial value of Jim. Now since this is an assign-once property, it can't be changed because we've already assigned a value to it. Let's go and declare another property. We'll declare this one with the var keyword, and its name is weightLbs. In other words, it's the weight in pounds. Its type is Double, and its initial value is 0. 0. Now because we declare it with the var keyword, it's mutable, which means we can assign new values to it if we want to. So let's go ahead and add another property. This is weightKilos. Again, it's declared with the var keyword. But in this case, rather than having weightKilos directly store values, we're instead going to give it a getter and a setter. So for the getter, we'll associate the code weightLbs divided by 2. 2. So if someone tries to access the value of the property weightKilos, what we'll do is we'll take the value that's stored in weightLbs and convert it to kilos, and we'd do that by dividing the weight in pounds by 2. 2. Then we'll also associate a setter, so our set method takes a parameter named value. So if someone tries to assign a value to this property, weightKilos, that value they're trying to assign is available to us through the parameter named value. So what we'll do in that case is we'll take that value, multiply it by 2. 2, so we'll convert it from kilos to pounds, and then we'll store it in weightLbs. So that gives us our class. Our class has three properties. Now notice that none of these property declarations have semicolons. The same thing for the code with the getter and the code with the setter. And in the previous clip when we were declaring variables we didn't use semicolons at the end of our statements, and that's just something that Kotlin does to help us write more concise code. The compiler is able to figure out when each statement ends, so there's no need for us to end each statement in a semicolon. Let's go ahead and use our class and its properties. So we'll say val p = Person followed by parentheses, so that creates a new instance of the Person class and assigns a reference to it to p. Now notice here that in Kotlin we don't use the new keyword. We create a new instance of a class by simply using the class name followed by parentheses. Again, it's just another thing that Kotlin does to help us write more concise code. So now once we have our reference to that Person instance, we can use it. So here we say val name = p. name, so it takes the value and the name property and assigns it to the local variable called name, so that returns back the string Jim. So now if I say p. weightLbs = 220, well that stores 220 in our weightLbs property. But now if I say val kilos = p. weightKilos, remember that the property weightKilos doesn't actually store a value. Instead, it has a getter. Alright, so that getter took the value that was stored in weightLbs, which is 220, divided it by 2. 2, so it returns back the value 100. So now if I say p. weightKilos = 50, well that'll now run our setter. So that'll take the value 50, multiply it by 2. 2, and store it into weightLbs. So if I then take p. weightLbs and assign it to the variable lbs, it'll then return 110. So it returns back the value that was calculated by the setter associated with our weightKilos property. Alright, so that gives us our initial look at properties. In our next clip, let's take a look at the primary constructor.

Primary Constructor

Kotlin classes can include a primary constructor. A primary constructor accepts a list of construction parameters. Now the primary constructor appears after the class name and can optionally include the constructor keyword. Now the parameters of the primary constructor are used to initialize the class. Now the thing that's a little bit unusual here is that a primary constructor contains no code. If we want to have code run when we create a new instance of a class, we'll see how to do that a little bit later. So now if we look at the Person class that we were working with in the previous clip, if we want to add a primary constructor to it, let's make a little room after the name of the class, we'll put the constructor keyword, and then we'll have the parameter list. So the primary constructor of the Person class has two parameters, name, which is a String, and weightLbs, which is a Double. Now as we said, the constructor keyword is optional, so we can go ahead and remove that. Now there's no difference in the declaration of class. We still have a primary constructor with two parameters, name and weightLbs. Now we can use these parameters to initialize our class. So if we look at our first property, name, currently it's always initialized to the String, Jim. So we'll replace that String, Jim, with the first parameter of our primary constructor. In the same way, we'll take our weightLbs property, and we'll initialize that with the weightLbs parameter of our primary constructor. Alright, so now those two properties are initialized based on the values that are passed into the primary constructor. But now both properties, name and weightLbs, explicitly have a type associated with them. And just like with a variable, we can actually infer the type based on the value that's assigned to it. So we can remove those so the type of our property name is based on the value assigned to it, which is the primary constructor's parameter name, which is a string. So our name property is also a string. In the same way, our weightLbs property is a double because the value assigned to it is a double. So let's look at some code that uses our class now. So I have val p = Person, and we pass in Bob and 176. 0. Alright, so that creates a new instance of Person. Again, remember that we don't use the new keyword. We simply use the class name followed by parentheses. And since this has a primary constructor, we pass in values to the primary constructor. So the variable p has a reference to that Person instance. So if I say val name = p. name, that'll return back Bob because we passed in Bob as the first parameter of the primary constructor and then initialized our name property. If I say val lbs = p. weightLbs, that returns back 176. 0 because, again, the weightLbs property was initialized with a value passed into our primary constructor. Now, of course, we can still use our other properties. So if I say val kilos = p. weightKilos, that'll still run the weightKilos getter. So we'll take the value in weightLbs, divide it by 2. 2, so it returns 80. 0. As you recall, one of the benefits of Kotlin is it helps to reduce the amount of boilerplate code that we need, in other words, code that we just kind of have to write, the things that don't really add value. Well, let's look at our class here. We have our primary constructor that has a parameter name, and the only thing we're using that parameter for is to initialize our property name in the same way our primary constructor's parameter weightLbs is only used to initialize the property weightLbs. So let's see how Kotlin can improve this situation. Now if we look at our property name and our property weightLbs, what makes those properties is that keyword before them. Alright, name is an assign-once property, so it uses the val keyword. WeightLbs is a mutable property, so it uses the var keyword. So if we look over here at primary constructor, let's make a little room next to each one of those parameters. Well, if we take that val and we put it right before name in the primary constructor, we can get rid of that property declaration. So now that name parameter is also declaring a property called name. If we then go to our weightLbs property, we take the var keyword, put that up in the primary constructor, we could then get rid of this property declaration down here. So now our primary constructor can accept the values, and it declares the properties. But we'll use the class just as we did before. So I want to create a new instance. I can say val p = Person, passing in Bob and 176. 0. That creates a new instance of Person and takes care of initializing the properties. So if I now say val name = p. name, it returns Bob. If I say val lbs = p. weightLbs, it returns 176. 0. Alright, both properties were automatically initialized with the values passed into the primary constructor, but those are full-fledge properties. Alright, so if I say val kilos = p. weightKilos, the getter for that property can still use our weightLbs property. So it takes the value in there, 176. 0, divides it by 2. 2, and therefore returns 80. So declaring the property and the primary constructor doesn't limit the capabilities of the property. It simply reduces the amount of code that we have to type. So in our next clip, let's return to Android Studio, and we'll start declaring some types inside of our application.

Demo: CourseInfo & NoteInfo

Here we are in Android Studio, and what we want to do now is add some classes to our project that we'll use to represent our app's data model. Now just as a reminder, the app we're building will be used to manage notes for Pluralsight courses. So we'll need two classes, one to represent a course and one to represent a note. So the first thing we'll do is head over here to our Project window. We'll confirm that we still have the Project window open in Android view. Then here under the app folder, we have the java folder, which then has a folder for our app's package name. Now remember, although it may seem a bit odd, all of our app's source code is placed within the java folder, even our Kotlin code. So now to get started, we'll go ahead and right-click on the package name, we'll choose New, and then we'll choose Kotlin File/Class. Then here in this dialog that opens, notice that we have a drop-down labeled Kind. Let's go ahead and expand that. Now we have a few options here. Now the kind of obvious option for us is the one called Class. Now if we choose Class, we'll create a Kotlin file with the name we provide, and that file will contain the stub of a class with that same name. But it turns out in our case, I think File might be a better choice. Kotlin, unlike Java, allows us to place multiple classes within a single file, and the Kotlin guidelines encourage us to do so in the case where we have simple classes that are closely related. So we'll go ahead and select File, and we'll name this file NoteKeeperData. Then we'll select OK to create the file. So now we have a relatively empty Kotlin file. We'll add the classes related to our data model to this file. The first class we'll add is a class that represents a Pluralsight course, so we use the class keyword, and we'll name the class CourseInfo. When we create an instance of CourseInfo, we'll want to intitialize it with some characteristics, so our course of a class will have a primary constructor. So to represent our primary constructor, we'll place open and close parentheses after the class name. Now the first characteristic will be the course ID, and the course ID is simply a string value used to identify the course. So we'll name our first primary constructor parameter courseId and give it a type of String. The other characteristic of CourseInfo is the course title, so we'll add another parameter named title of type String. Now we'll want to have both of these characteristics, courseId and title, available as properties on our class, so we can declare them as properties right here in our primary constructor. So now from the standpoint of our app, a course's courseId and title cannot be changed, so both of these properties should be assign-once properties. So for the courseId parameter, we'll use the val keyword to make it an assign-once property, and then we'll do the same thing for title. And that now gives us our complete CourseInfo class. Now notice how simple and clean the class declaration is. On a single line we've given our class name, defined the parameters necessary to create an instance of the class, and exposed two assign-once properties. Also, since our class declaration doesn't need a body, we don't have to include open and closing brackets. Our entire class is declared on a single line. So now let's add a class to represent a note. Now we'll do it right here inside of our NoteKeeperData file just below our CourseInfo class. So we'll declare a class name NoteInfo that has a primary constructor. The first characteristic of a note is the course that's associated with that note, so we'll name our first primary constructor parameter course, and we'll give it a type of CourseInfo. We'll want the note's course to be available as a property, and it's possible that we may want to change which course a note is associated with, so we'll use the var keyword to make course a mutable property. A note will have a title, so we'll add a string parameter named title, and we'll go ahead and add the var keyword to make title a mutable property. And a note will have text, so we'll add a parameter named text of type String, and that's also a mutable property. And that gives us our complete NoteInfo class. And again, this class is declared entirely in a single line. Alright, so now we have the two classes that we'll use to represent the data within our app. In our next clip, we'll start looking at how we can add functions to a class.