From 2a504cd786a83fd3faec41c4bfc0bb8b9f36c388 Mon Sep 17 00:00:00 2001 From: fechin Date: Sun, 26 Feb 2023 16:55:33 +0800 Subject: [PATCH] A rough draft of a Kotlin cheat sheet --- source/_posts/kotlin.md | 811 ++++++++++++++++++++++++++++++++++ source/assets/icon/kotlin.svg | 3 + 2 files changed, 814 insertions(+) create mode 100644 source/_posts/kotlin.md create mode 100644 source/assets/icon/kotlin.svg diff --git a/source/_posts/kotlin.md b/source/_posts/kotlin.md new file mode 100644 index 0000000..2fccf0d --- /dev/null +++ b/source/_posts/kotlin.md @@ -0,0 +1,811 @@ +--- +title: Kotlin +date: 2023-02-26 16:24:31 +background: bg-[#7954f6] +tags: + - cross-platform + - modern +categories: + - Programming +intro: | + A quick reference cheatsheet for Kotlin that includes usage, examples, and more. +--- + + +Introduction to Kotlin +---- + + + +### main() + +```kotlin +fun main() { + println("Greetings, QuickRef.ME!") + // Code goes here +} +``` + +The main() function is the starting point of every Kotlin program and must be included in the code before execution + + + +### Print statement + +```kotlin +println("Greetings, earthling!") +print("Take me to ") +print("your leader.") + +/* +Print: +Greetings, earthling! +Take me to your leader. +*/ +``` + + + +### Notes + +```kotlin +// this is a single line comment + +/* +this +note +for +many +*/ +``` + + + +### Execution order + +```kotlin +fun main() { + println("I will be printed first.") + println("I will be printed second.") + println("I will be printed third.") +} +``` + +Data Types and Variables +--- + + + +### Mutable variables + +```kotlin +var age = 25 +age = 26 +``` + + + +### Immutable variables + +```kotlin +val goldenRatio = 1.618 +``` + + + +### Type inference + +```kotlin +// The following variables are assigned a literal value inside double quotes +// so the inferred type is String + +var color = "Purple" +``` + + + +### String concatenation + +```kotlin +var streetAddress = "123 Main St." +var cityState = "Brooklyn, NY" + +println(streetAddress + " " + cityState) +// Print: 123 Main St. Brooklyn, NY +``` + + + +### String Templates + +```kotlin +var address = "123 Main St." +println("The address is $address") +// prints: The address is 123 Main St. +``` + + + +### Built-in Properties and Functions +```kotlin +var monument = "the Statue of Liberty" + +println(monument. capitalize()) +// print: The Statue of Liberty +println(monument. length) +// print: 21 +``` + + + +### Character escape {.row-span-2} + +```kotlin {.wrap} +print("\"Excellent!\" I cried. \"Elementary,\" said he.") + +// Print: "Excellent!" I cried. "Elementary," said he. +``` + +- `\n` insert new line +- `\t` inserts a tab +- `\r` inserts carriage return +- `\'` inserts a single quote +- `\"` inserts a double quote +- `\\` inserts a backslash +- `\$` inserts a dollar sign + + + +### Arithmetic Operators + +```kotlin +5 + 7 // 12 +9 -2 // 7 +8 *4 // 32 +25 /5 // 5 +31 % 2 // 1 +``` + +`+` addition, `-` subtraction, `*` multiplication, `/` division, and `%` modulus + + + +### Order of operations + +```kotlin +5 + 8 *2 /4 -3 // 6 +3 + (4 + 4) /2 // 7 +4 *2 + 1 *7 // 15 +3 + 18 /2 *1 // 12 +6 -3 % 2 + 2 // 7 +``` + + + +### Enhanced assignment operator + +```kotlin +var batteryPercentage = 80 + +// long syntax +batteryPercentage = batteryPercantage + 10 + +// short syntax with augmented assignment operator +batteryPercentage += 10 +``` + + + +### Increment and decrement operators + +```kotlin +var year = 2019 +year++ // 2020 +year-- // 2019 +``` + + + +### Math library + +```kotlin +Math.pow(2.0, 3.0) // 8.0 +Math.min(6, 9) // 6 +Math.max(10, 12) // 12 +Math. round(13.7) // 14 +``` + + + + + +Conditional Expression +---- + + +### If expression + +```kotlin +var morning = true + +if (morning) { + println("Rise and shine!") +} +// Print: Rise and shine! +``` + + + +### Else-expression + +```kotlin +var rained = false + +if (rained) { + println("No need to water the plants today.") +} else { + println("The plant needs to be watered!") +} +// print: The plant needs watering! +``` + + + +### Else-If expressions + +```kotlin +var age = 65 + +if (age < 18 ) { + println("You are considered a minor") +} else if (age < 60) { + println("You are considered an adult") +} else { + println("You are considered senior") +} + +// print: you are considered senior +``` + + + +### Comparison Operators + +```kotlin +var myAge = 19 +var sisterAge = 11 +var cousinAge = 11 + +myAge > sisterAge // true +myAge < cousinAge // false +myAge >= cousinAge // true +myAge <= sisterAge // false +``` + + + +### Logical Operators + +```kotlin +var humid = true +var raining = true +var jacket = false + +println(!humid) +// print: false +println(jacket && raining) +// print: true +println(humid || raining) +// print: true +``` + + + +### AND operator: && + +```kotlin +var humid = true +var raining = true +var shorts = false +var sunny = false + +// true AND true +println(humid && raining) // true +// true AND false +println(humid && shorts) // false +// false AND true +println(sunny && raining) // false +// false AND false +println(shorts && sunny) // false +``` + + + +### Or operator:|| + +```kotlin +var late = true +var skipBreakfast = true +var underslept = false +var checkEmails = false + +// true OR true +println(skipBreakfast || late) // true +// true OR false +println(late || checkEmails) // true +// false OR true +println(underslept || late) // true +// false OR false +println(checkEmails || underslept) // false +``` + + + +### NOT operator + +```kotlin +var hungry = true +var full = false + +println(!hungry) // false +println(!full) // true +``` + + + +### Evaluation order + +```kotlin +!true && (false || true) // false +/* +(false || true) is evaluated first to return true. +Then, evaluate !true && true and return the final result false +*/ + +!false && true || false // true +/* +!false is evaluated first to return true. +Then true && true is evaluated, returning true. +then, true || evaluates to false and eventually returns true +*/ +``` + + + +### Nested conditions + +```kotlin +var studied = true +var well Rested = true + +if (wellRested) { + println("Good luck today!") + if (studied) { + println("You should prepare for the exam!") + } else { + println("Spend a few hours studying before the exam!") + } +} + +// Print: Good luck today! +// print: You should be ready for the exam! +``` + + + +### When expression + +```kotlin +var grade = "A" + +when (grade) { + "A" -> println("Great job!") + "B" -> println("Great job!") + "C" -> println("You passed!") + else -> println("Close! Be sure to prepare more next time!") +} +// print: Great job! +``` + + + +### Range operator + +```kotlin {.wrap} +var height = 46 // inches + +if (height in 1..53) { + println("Sorry, you must be at least 54 inches to ride the coaster") +} +// Prints: Sorry, you must be at least 54 inches to ride the roller coaster +``` + + + +### Equality Operators + +```kotlin +var myAge = 22 +var sisterAge = 21 + +myAge == sisterAge // false +myAge !== sisterAge // true +``` + + + + +Collections +--- + + + +### Immutable list + +```kotlin {.wrap} +var programmingLanguages = listOf("C#", "Java", "Kotlin", "Ruby") +``` + + + +### Mutable List + +```kotlin {.wrap} +var fruits = mutableListOf("Orange", "Apple", "Banana", "Mango") +``` + + + +### Access List + +```kotlin {.wrap} +var cars = listOf("BMW", "Ferrari", "Volvo", "Tesla") + +println(cars[2]) // Prints: Volvo +``` + + + +### Size Attribute + +```kotlin {.wrap} +var worldContinents = listOf("Asia", "Africa", "North America", "South America", "Antarctica", "Europe", "Australia") + +println(worldContinents.size) // Prints: 7 +``` + + + +### List Manipulation {.row-span-2} + +```kotlin {.wrap} +var seas = listOf("Black Sea", "Caribbean Sea", "North Sea") +println(seas. contains("North Sea")) // Prints: true + +// The contains() function performs a read operation on any list and determines if the element exists +seas.add("Baltic Sea") // Error: cannot write to immutable list +// The add() function can only be called on mutable lists, so the code above throws an error +``` + + + +### Immutable Sets + +```kotlin {.wrap} +var primaryColors = setOf("Red", "Blue", "Yellow") +``` + + + +### Mutable Sets + +```kotlin {.wrap} +var womenInTech = mutableSetOf("Ada Lovelace", "Grace Hopper", "Radia Perlman", "Sister Mary Kenneth Keller") +``` + + + +### Access Collection Elements {.row-span-2} + +```kotlin {.wrap} +var companies = setOf("Facebook", "Apple", "Netflix", "Google") + +println(companies.elementAt(3)) +// Prints: Google +println(companies.elementAt(4)) +// Returns and Error +println(companies.elementAtOrNull(4)) +// Prints: null +``` + + + +### Immutable Map + +```kotlin {.wrap} +var averageTemp = mapOf("winter" to 35, "spring" to 60, "summer" to 85, "fall" to 55) +``` + + + +### Mutable Mapping + +```kotlin {.wrap} +var europeanDomains = mutableMapOf("Germany" to "de", "Slovakia" to "sk", "Hungary" to "hu", "Norway" to "no") +``` + + + +### Retrieve map keys and values + +```kotlin {.wrap} +var oscarWinners = mutableMapOf("Parasite" to "Bong Joon-ho", "Green Book" to "Jim Burke", "The Shape Of Water" to "Guillermo del Toro") + +println(oscarWinners.keys) +// Prints: [Parasite, Green Book, The Shape Of Water] + +println(oscarWinners.values) +// Prints: [Bong Joon-ho, Jim Burke, Guillermo del Toro] +println(oscarWinners["Parasite"]) +// Prints: Bong Joon-ho +``` + + + +### Add and remove map entries + +```kotlin {.wrap} +var worldCapitals = mutableMapOf("United States" to "Washington D.C.", "Germany" to "Berlin", "Mexico" to "Mexico City", "France" to "Paris") + +worldCapitals.put("Brazil", "Brasilia") +println(worldCapitals) +// Prints: {United States=Washington D.C., Germany=Berlin, Mexico=Mexico City, France=Paris, Brazil=Brasilia} + +worldCapitals.remove("Germany") +println(worldCapitals) +// Prints: {United States=Washington D.C., Mexico=Mexico City, France=Paris, Brazil=Brasilia} +``` + + + + +Function +--- + + + +### Function + +```kotlin +fun greet() { + println("Hey there!") +} + +fun main() { + //Function call + greet() //Prints: Hey there! +} +``` + + + +### Function Parameters + +```kotlin {.wrap} +fun birthday(name: String, age: Int) { + println("Happy birthday $name! You turn $age today!") +} + +fun main() { + birthday("Oscar", 26) + //Prints: Happy birthday Oscar! You turn 25 today! + birthday("Amarah", 30) + //Prints: Happy birthday Amarah! You turn 30 today! +} +``` + + + +### Default Parameters + +```kotlin {.wrap} +fun favoriteLanguage(name, language = "Kotlin") { + println("Hello, $name. Your favorite programming language is $language") +} + +fun main() { + favoriteLanguage("Manon") + //Prints: Hello, Manon. Your favorite programming language is Kotlin + + favoriteLanguage("Lee", "Java") + //Prints: Hello, Lee. Your favorite programming language is Java +} +``` + + + +### Named Parameters + +```kotlin {.wrap} +fun findMyAge(currentYear: Int, birthYear: Int) { + var myAge = currentYear -birthYear +println("I am $myAge years old.") +} + +fun main() { + findMyAge(currentYear = 2020, birthYear = 1995) + //Prints: I am 25 years old. + findMyAge(birthYear = 1920, currentYear = 2020) + //Prints: I am 100 years old. +} +``` + + + +### Return Statement + +```kotlin {.wrap} +//Return type is declared outside the parentheses +fun getArea(length: Int, width: Int): Int { + var area = length *width + + //return statement + return area +} + +fun main() { + var myArea = getArea(10, 8) +println("The area is $myArea.") +//Prints: The area is 80. +} +``` + + + +### Single expression function + +```kotlin{.wrap} +fun fullName(firstName: String, lastName: String) = "$firstName $lastName" + +fun main() { + println(fullName("Ariana", "Ortega")) + //Prints: Ariana Ortega + println(fullName("Kai", "Gittens")) + //Prints: Kai Gittens +} +``` + + + +### Function Literals + +```kotlin{.wrap} +fun main() { + //Anonymous Function: + var getProduct = fun(num1: Int, num2: Int): Int { +return num1 *num2 + } + println(getProduct(8, 3)) + //Prints: 24 +//Lambda Expression + var getDifference = { num1: Int, num2: Int -> num1 -num2 } + println(getDifference(10, 3)) + //Prints: 7 +} +``` + + + + +Class +--- + + +### Class Example + +```kotlin +//class with properties containing default values +class Student { + var name = "Lucia" + var semester = "Fall" + var gpa = 3.95 +} + +//shorthand syntax without class body +class Student +``` + + +### Class Instance + +```kotlin +// Class +class Student { + var name = "Lucia" + var semester = "Fall" +var gpa = 3.95 +} + +fun main() { + var student = Student() + // Instance + println(student.name) + // Prints: Lucia + println(student.semester) + // Prints: Fall + println(student.gpa) + // Prints: 3.95 +} +``` + +### Primary Constructor + +```kotlin {.wrap} +class Student(val name: String, val gpa: Double, val semester: String, val estimatedGraduationYear: Int) + +fun main() { + var student = Student("Lucia", 3.95, "Fall", 2022) + println(student.name) + //Prints: Lucia + println(student.gpa) + //Prints: 3.95 + println(student.semester) + //Prints: Fall + println(student.estimatedGraduationYear) + //Prints: 2022 +} +``` + + + +### Initialization Block + +```kotlin {.wrap} +class Student(val name: String, val gpa: Double, val semester: String, val estimatedGraduationYear: Int) { + init { + println("$name has ${estimatedGraduationYear -2020} years left in college.") + } +} + +fun main() { + var student = Student("Lucia", 3.95, "Fall", 2022) +//Prints: Lucia has 2 years left in college. +} +``` + + + +### Member Function {.col-span-2} + +```kotlin {.wrap} +class Student(val name: String, val gpa: Double, val semester: String, val estimatedGraduationYear: Int) { + + init { +println("$name has ${estimatedGraduationYear -2020} years left in college.") + } + + //member function + fun calculateLetterGrade(): String { + return when { + gpa >= 3.0 -> "A" + gpa >= 2.7 -> "B" + gpa >= 1.7 -> "C" +gpa >= 1.0 -> "D" + else -> "E" + } + } +} + +//When the instance is created and the function is called, the when expression will be executed and return the letter grade +fun main() { + var student = Student("Lucia", 3.95, "Fall", 2022) +//Prints: Lucia has 2 years left in college. + println("${student.name}'s letter grade is ${student.calculateLetterGrade()}.") + //Prints: Lucia's letter grade is A. +} +``` + +See Also +--- + +- [Kotlin Language Official Documentation](https://kotlinlang.org/) _(kotlinlang.org)_ diff --git a/source/assets/icon/kotlin.svg b/source/assets/icon/kotlin.svg new file mode 100644 index 0000000..5330f43 --- /dev/null +++ b/source/assets/icon/kotlin.svg @@ -0,0 +1,3 @@ + + + \ No newline at end of file