Towards the end of last year, I got an interest in learning a new programming language or library/framework for building mobile applications apart from React-Native which I had used during my first role for a couple of months. The essence pf this article is to just document my Kotlin learning journey. I’m a bit inconsistent currently since I still have to improve my frontend skills that I use in my day-to-day activities.
I find learning and building projects continuously is what makes software development more refreshing. I’m more of a web developer and still have a lot of skills, especially around Javascript(core & frameworks), CSS, and technologies like Typescript that still need me up-skilling on but starting to learn Kotlin over free time might make the journey more interesting.
I started looking at Flutter and learned that one has to learn Dart programming language first before moving to build mobile app projects using Flutter and the Dart syntax is almost like that of C++ which I’m not yet familiar with. I found a few Flutter tutorials in FreeCodeCamp but a random thought came to mind when I was just getting started with Flutter to consider checking Kotlin. I saw its syntax is favorable for someone with a JavaScript background I looked into resources from Kotlin's official documentation, some courses on Udacity, and some on youtube by FreeCodeCamp. I also spoke to a developer who frequently codes with Kotlin and he shared some resources that have worked for him so far. He recommended some courses on Udacity and this youtube channel that has a **Kotlin Tutorial for Beginners: The Kotlin Programming Language** which he said a mentor recommended to him.
According to Kotlin’s official documentation, Kotlin is a modern but already mature programming language aimed at making developers happier. It's concise, safe, interoperable with Java and other languages, and provides many ways to reuse code between multiple platforms for effective programming.
I have started learning Kotlin basics and just learned by coding along the last youtube tutorial I tagged the instructor recommends using the Integrated Development Environment (Intellij IDEA by Jet Brains) which I had to install and learn how to use GIT/Github on top of it as well as compiling the code after writing it and expecting an output
Steps on how to set up JDK & SDK version 17 on IntelliJ IDEA for Kotlin development
Open IntelliJ IDEA and go to File
> Project Structure
.
In the Project Structure window, select SDKs
from the left menu.
Click the +
button to add a new SDK
and select JDK
.
Navigate to the location of your JDK 17 installation
and select it.
Once the JDK is added, go to File
> Project Structure
again.
Select Project from the left menu, and ensure that the Project SDK
is set to the JDK 17
you just added.
In the same window, go to the Project language level and select 17-Preview and Experimental
.
Click Apply
and OK
to save the changes.
Now you should be able to create a new Kotlin project and write code using JDK & SDK version 17 on IntelliJ IDEA.
Steps on how to start a Kotlin project with a main.kt file in IntelliJ IDEA
Create New Project
".Kotlin
" as the project type and "JVM
| Kotlin/JVM
" as the project template.Finish
" button to create the project.main.kt
" under the "src
" folder. This file is the entry point of your application, and it contains the main function.main.kt
" file in the editor and you can start writing your code.Run
" button on the top menu, or you can press the Shift+F10
key.main
" and click on "OK
".Run
" tab at the bottom of the screen.Here is a sample code for the main.kt file which is the entry point of the application
fun main() {
printLn("hello world!")
}
/* definition of keyword
- fun: keyword for function
- main: name of the function which is special
*/
Kotlin: human-readable & compatible with JVM
Writing Kotlin Code & Understanding Basic Variables, Syntax,, and inBuilt Method
Kotlin uses the camelCase naming convention i.e first word in a multi-word identifier is in lowercase and each subsequent word has its first letter capitalized. For example, "helloWorld
”
variables can be declared using:
var
keyword: used to declare variables and assign a value that can be reassigned// a value assigned to it.
var x = 5
// without assigning a value, and assign a value later
var y: Int
y = 6
// reassign a value to a variable that has already been declared and assigned a value
x = 7
val
keyword: used to declare variables and assign a value that cannot be reassigned i.e value cannot be changed. It’s the same as const
in Javascriptval name: String = "Sharon Jebitok"
Kotlin has many inbuilt methods which are available for different contexts. e.g
length() // returns the number of characters in a string
substring(startIndex: Int, endIndex: Int) // returns a new string i.e substring of the original string, starting at the specified startIndex & ending at the specified endIndex-1.
toLowerCase() // returns a new string with all characters in lowercase
toUpperCase() // returns a new string with all characters in uppercase
trim() // returns a new string with leading and trailing whitespace removed
split(delimiter: String) // returns a list of substrings, split by the specified delimiter
replace(oldValue: String, newValue: String) // returns a new string with all occurrences of the specified oldValue replaced with the specified newValue
filter(predicate: (T) -> Boolean) // returns a new collection containing only elements that satisfy the specified predicate
map(transform: (T) -> R) // returns a new collection containing the results of applying the specified transform function to each element in the original collection
reduce(operation: (acc: R, T) -> R) // applies the specified binary operation to the elements in the collection, going left to right, and returning an accumulation of the operation
forEach(action: (T) -> Unit) // performs the specified action on each element of the collection
any() // returns true if at least one element in the collection satisfies the specified predicate, otherwise false
all(predicate: (T) -> Boolean) // returns true if all elements in the collection satisfy the specified predicate, otherwise false
toInt(): // Converts a number to an integer
toLong(): // Converts a number to a long
toFloat(): // Converts a number to a float
toDouble(): // Converts a number to a double
abs(): // Returns the absolute value of a number
round(): // Rounds a number to the nearest whole number
ceil(): // Rounds a number up to the nearest whole number
floor(): // Rounds a number down to the nearest whole number
sqrt(): // Returns the square root of a number
pow(): // Raises a number to a specified power
sort(): // sorts the elements of the array in ascending order
slice(): // returns a subarray that starts at a specified index and has a specified length
fill(): // fills all elements of the array with a specified value
copyOf(): // returns a new array that is a copy of the original array
copyOfRange(): // returns a new array that is a copy of a range of elements from the original array
forEach() : // Iterates over array elements and perform the given action on each element
types of numbers that can be used to represent different range of value in Kotlin
Byte
A 8-bit signed integer. It can hold values from -128 to 127Short
A 16-bit signed integer. It can hold values from -32768 to 32767Int
A 32-bit signed integer. It can hold values from -2147483648 to 2147483647Long
**A 64-bit signed integer. It can hold values from -9223372036854775808 to 9223372036854775807Float
**A 32-bit floating-point number. It can hold decimal valuesDouble
**A 64-bit floating-point number. It can hold decimal values and is the default type for decimal numbers in Kotlin.val d: Double = 3.14 //Double
var b: Byte = 100 // Byte
val f: Float = 3.14f // Float
val l: Long = 10000000000 // Long
val i: Int = 100000 // Int
val s: Short = 10000 // Short
// main.kt file with sample code of inbuilt methods & variables
fun main() {
var fullName: String = "Sharon Jebitok"
var age:Int = 26
// numbers
val myByte: Byte = 8 // 8-bit signed integer
val myShort: Short = 16 // 16-bit signed integer
val myInt: Int = 32 // 32-bit signed integer
val myLong: Long = 64 // 64-bit signed integer
// decimals
val myFloat: Float = 32.00F // 32-bit floating point number
val myDouble: Double = 64.00 // 64-bit floating point number
val bigLong: Long = 1_000_000
println(bigLong)
val newInt = myInt.plus( other = 12)
println(newInt)
// println(bigLong)
// println(myByte.toDouble()::class)
// println(myByte.toShort()::class)
// println(myByte.toLong()::class)
// println(myByte.toFloat()::class)
// println(myByte.toInt()::class)
// println(myByte.toByte()::class)
}
Thank you for reading through my article. You can leave a comment if you’re aware of a better way to learn Kotlin or maybe you’re also getting started and need a buddy. We can also connect on Twitter or LinkedIn.