diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/collection/CollectionMain.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/collection/CollectionMain.kt new file mode 100644 index 0000000..7c39d74 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/collection/CollectionMain.kt @@ -0,0 +1,267 @@ +package com.krunal.demo.kotlinpractice.collection + +fun main() { + + // Array + println("\nArray\n") + val array = Array(3) { 0 } + array[0] = 1 + array[1] = 2 + array[2] = 3 + println(array.contentToString()) + + + // List + println("\nList\n") + val numList = mutableListOf() + numList.addAll(array) + numList.addAll(listOf(4, 3, 2, 5, 3)) + println(numList) + + // Iterator + println("\nIterator\n") + val iterator = numList.iterator().withIndex() + while (iterator.hasNext()) { + print("${iterator.next().value}: ${iterator.next().value}") + } + println() + + // Progression + println("\nProgression\n") + for (i in 1..10 step 2) { + print("$i ") + } + println() + + for (i in 1 until 10 step 2) { + print("$i ") + } + println() + + for (i in 10 downTo 1 step 2) { + print("$i ") + } + println() + + for (i in (10 downTo 1).reversed() step 2) { + print("$i ") + } + println() + + // Sequence + println("\nSequence\n") + var charSeq = sequenceOf('a', 'b', 'c', 'd') + charSeq = ('a'..'k').asSequence() + charSeq.filter { it in listOf('a', 'e', 'i', 'o', 'u') }.map { print(it); "$it" }.count() + println() + val oddNumSeq = generateSequence(2) { it + 2 } + println(oddNumSeq.take(10).toList()) + val topTen = generateSequence(1) { if (it < 10) it + 1 else null } + println(topTen.toList()) + + val oddSeq = sequence { + yield(1) + yieldAll(listOf(3, 5, 7)) + } + println(oddSeq.toList()) + + // Transformation + println("\nTransformation\n") + val numStrList = listOf("1", "2", "3", "4", "5", "6", "7", "4", "8", "2") + numStrList.map { it.toInt() }.mapIndexedNotNull { index, v -> if (index == 0) null else v } + .forEach(::print) + println() + + val numMap = mutableMapOf( + "one" to 1, "two" to 2, "three" to 3, "four" to 4, "five" to 5 + ) + val newNumMap: MutableMap = mutableMapOf() + numMap.mapValuesTo(newNumMap) { "${it.value} -> " } + println(newNumMap) + + println(newNumMap.values zip newNumMap.keys) + println(newNumMap.values.zip(newNumMap.keys) { value, key -> + "$value $key" + }) + + println(numStrList.associateWith { it.length }) + println(numStrList.withIndex().associateBy { it.index }.mapValues { it.value.value }) + + val numberSets = listOf(setOf(1, 2, 3), setOf(4, 5, 6), setOf(1, 2)) + println(numberSets.flatten()) + println(numberSets.flatMap { it }) + + println(numStrList.joinToString( + separator = " -> ", + prefix = "start: ", + postfix = " :end", + limit = 4, + truncated = "more..." + ) { "${it}x" }) + + // Filtering + println("\nFiltering\n") + + val nums = (1..20).toMutableList() + println("even: ${nums.filter { it % 2 == 0 }}") + println("odd: ${nums.filterNot { it % 2 == 0 }}") + val nullableNums = mutableListOf(null, 1, 2, null) + println(nullableNums.filterNotNull()) + println("large: ${nums.filterIndexed { index, _ -> index > 10 }}") + + val anyType = listOf(null, 1, "two", 3.0, "four") + println("strings: ${anyType.filterIsInstance()}") + + val (odd, even) = nums.partition { it % 2 != 0 } + println("$odd, $even") + + println("any > 20 ${nums.any { it > 20 }}") + println("none > 20 ${nums.none { it > 20 }}") + println("all < 5 ${nums.all { it > 20 }}") + + // Plus and minus operators + println("\nPlus and minus operators\n") + val l1 = listOf(1, 3, 5) + val l2 = listOf(2, 4, 5) + println(l1 + l2 + "str" - 5) + + // Grouping + println("\nGrouping\n") + println(numStrList.groupBy { if (it.toInt() % 2 == 0) "even" else "odd" }) + println(numStrList.groupingBy { if (it.toInt() % 2 == 0) "even" else "odd" }.eachCount()) + + // Retrieve collection parts + println("\nRetrieve collection parts\n") + val numbers = mutableListOf("one", "two", "three", "four", "five", "six") + println(nums.slice(5..10)) + println(nums.slice(5 until 10 step 2)) + println(nums.slice(setOf(2, 3, 5))) + println(nums.subList(5, 10)) + + println(nums.take(5)) + println(nums.takeLast(5)) + println(nums.drop(5)) + println(nums.dropLast(5)) + + println(nums.takeWhile { it < 10 }) + println(nums.takeLastWhile { it < 10 }) + println(nums.dropWhile { it < 10 }) + println(nums.dropLastWhile { it > 10 }) + + println(nums.chunked(5)) + println(nums.windowed(5, step = 3)) + println(nums.windowed(5, step = 3, partialWindows = true)) + println(nums.zipWithNext()) + + // Retrieve single elements + println("\nRetrieve single elements\n") + val numSet = numbers.toSet() + println(numSet.elementAt(4)) +// println(numSet.get(4)) + println(numSet.elementAtOrElse(10) { it * 10 }) + println(numSet.elementAtOrNull(10)) + + println("${numSet.first()} -> ${numSet.last { it.length > 4 }}") + println("${nums.firstOrNull { it > 10 }} -> ${nums.findLast { it > 15 }}") + + println(numSet.random()) + println(emptyList().randomOrNull()) + println(emptyList().isNotEmpty()) + + // Ordering + println("\nOrdering\n") + val randomList = nums.shuffled() + println(randomList) + println(randomList.sortedDescending()) + println(randomList.sortedBy { it % 5 }) + println(randomList.sortedWith { i, j -> (i % 5) - (j % 5) }) + + val revNum1 = numbers.reversed() + val revNum2 = numbers.asReversed() + println("$revNum1 $revNum2") + numbers.removeLast() + revNum2.removeLast() + println("$revNum1 $revNum2") + println(numbers) + + // Aggregate operations + println("\nAggregate operations\n") + println(setOf(2, 5, 3, 1).min()) + println(emptySet().maxOrNull()) + println(nums.average()) + println(nums.count()) + println(nums.sum()) + println(nums.sumOf { it * 2 }) + + println(nums.fold(0) { acc, i -> acc + i }) + println(nums.reduce { acc, i -> acc + i }) + println(nums.foldRight(100) { acc, i -> acc - i }) + println(nums.reduceRight { acc, i -> acc - i }) + println(nums.runningFold(0) { acc, i -> acc + i }) + + // Collection write operations + println("\nCollection write operations\n") + val mNums = nums.toMutableList() + mNums.clear() + println(mNums) + println(mNums.addAll((1..10))) + mNums += 100 + mNums -= 4..7 + mNums.addAll(listOf(5, 5, 10, 9, 9, 4, 3, 2)) + mNums.add(5) + println(mNums) + mNums.remove(10) + mNums.removeAll(listOf(5)) + println(mNums) + mNums.retainAll { it % 2 == 0 } + println(mNums) + mNums[mNums.lastIndex] = 101 + println(mNums) + val mList = mutableListOf(1, 2, 3) + mList.fill(0) + println(mList) + + // Find element positions + println("\nFind element positions\n") + println(mNums.indexOf(9)) + println(mNums.lastIndexOf(2)) + println(mNums.indexOfFirst { it > 8 }) + + println(numbers.binarySearch("two")) + println(numbers.binarySearch("z")) + println(numbers.binarySearch("two", 0, 2)) + + // Set-specific operations + println("\nSet-specific operations\n") + val numSet1 = mutableSetOf(1, 2, 3, 4, 5, 6) + val numSet2 = mutableSetOf(4, 5, 6, 7, 8, 9) + println("union: ${numSet1 union numSet2}") + println("intersect: ${numSet1 intersect numSet2}") + println("subtract: ${numSet1 subtract numSet2}") + + // Map-specific operations + println("\nMap-specific operations\n") + println("${numMap.keys} ${numMap.values}") + println(numMap.entries) + println(numMap["one"]) + println(numMap["nine"]) + println(numMap.getOrDefault("nine", 9)) + println(numMap.getOrElse("nine") { 9 }) + val two by numMap +// val nine by numMap + println(two) + numMap += ("ten" to 10) + println(numMap) + numMap["nine"] = 9 + numMap.remove("ten") + numMap.remove("nine", 10) + numMap -= "five" + println(numMap) + + // Custom quadruple + println("\nCustom quadruple\n") + val quadruple: Quadruple = Quadruple("A", 'b', true, 10) + println(quadruple) + println(quadruple.first) + println(quadruple.toList()) +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/collection/Quadruple.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/collection/Quadruple.kt new file mode 100644 index 0000000..d389ffc --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/collection/Quadruple.kt @@ -0,0 +1,12 @@ +package com.krunal.demo.kotlinpractice.collection + +import java.io.Serializable + +data class Quadruple( + val first: A, val second: B, val third: C, val fourth: D +) : Serializable { + + override fun toString() = "($first, $second, $third, $fourth)" +} + +fun Quadruple.toList() = listOf(first, second, third, fourth) diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/controlflow/ConditionAndLoop.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/controlflow/ConditionAndLoop.kt new file mode 100644 index 0000000..10f06e6 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/controlflow/ConditionAndLoop.kt @@ -0,0 +1,96 @@ +package com.krunal.demo.kotlinpractice.controlflow + +import kotlin.random.Random + +fun main() { + // if-else + val a = 5 + val b = 7 + val max = if (a > b) a else b + println("max $max") + + val name: String? = "KP" + if (name != null) { + println(name) + } + + // when + val char = 'a' + val type = when (char) { + 'a', 'e', 'i', 'o', 'u' -> "small vowel" + 'A', 'E', 'I', 'O', 'U' -> "capital vowel" + in 'a'..'z' -> "small constant" + in 'A'..'Z' -> "capital constant" + else -> "invalid char" + } + println("$char is $type") + + val password = "Krunal@123" + when { + password.isNullOrEmpty() -> println("password can't be empty") + password.length < 5 -> println("password is too short") + password.contains("Krunal") -> println("password should not contain name") + else -> println("valid password") + } + + // Loops + for (i in 1 until 11) { + print(i) + } + println() + + for (i in 10 downTo 0 step 3) { + print(i) + } + println() + + var str = "abcba" + while (str.isNotEmpty()) { + str = str.removeRange(str.length - 1, str.length) + } + println("str $str") + + do { + val num = Random.nextInt(50, 200) + println("num: $num") + } while (num < 100) + + // Break & Continue + small@ for (i in 1..100) { + if (i % 2 == 0) continue + print(i) + if (i > 10) break@small + } + + // Custom double range + for (i in 1.1..2.2) { + println(i) + } +} + +operator fun Double.rangeTo(end: Double): DoubleClosedRange { + + return object : DoubleClosedRange { + override val endInclusive: Double + get() = end + override val start: Double + get() = this@rangeTo + + private var current = this@rangeTo + + override fun iterator(): Iterator { + return object : Iterator { + override fun hasNext(): Boolean { + return current <= end + } + + override fun next(): Double { + current += 0.1 + return current + } + } + } + } +} + +interface DoubleClosedRange : ClosedRange, Iterable diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/DelegationMain.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/DelegationMain.kt new file mode 100644 index 0000000..2229b57 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/DelegationMain.kt @@ -0,0 +1,33 @@ +package com.krunal.demo.kotlinpractice.delegation + +import kotlinx.coroutines.delay +import kotlinx.coroutines.runBlocking + +fun main() { + val player: MediaPlayer = MediaPlayer(ScreenGestureImpl()) + + player.swapLeft() + player.swapLeft(false) + player.swapRight(true) + player.swapRight(false) + + // property delegate + player.changePlaybackSpeed(true) + player.changePlaybackSpeed(false) + + // lazy + println("Current song: ${player.song}") + println("Current song: ${player.song}") + println("Current song: ${player.song}") + + // Observable + runBlocking { + repeat(5) { + player.timeRemain -= 20 + delay(500) + } + } + + // Map + println(player.songDetails) +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/MediaPlayer.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/MediaPlayer.kt new file mode 100644 index 0000000..b3cd54a --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/MediaPlayer.kt @@ -0,0 +1,55 @@ +package com.krunal.demo.kotlinpractice.delegation + +import kotlin.properties.Delegates +import kotlin.random.Random + +class MediaPlayer(gesture: ScreenGesture) : ScreenGesture by gesture { + + private var playbackSpeed: String by PlaybackSpeed() + private val _songDetails = SongDetails( + mapOf( + "Title" to "Tum se hi...", + "Singer" to "Mohit Chauhan", + "Music" to "Pritham", + "Released Year" to 2007, + "Indie Music" to false + ) + ) + val songDetails: String + get() { + return """ + title: ${_songDetails.title} + singer: ${_songDetails.singer} + music: ${_songDetails.music} + releasedYear: ${_songDetails.releasedYear} + indieMusic: ${_songDetails.indieMusic} + """.trimIndent() + } + val a: Lazy = lazy { 5 } + val song: String by lazy { + println("starting song...") + "Tum se hi..." + } + var timeRemain: Int by Delegates.observable(100) { property, oldValue, newValue -> + println("${property.name}: $oldValue -> $newValue") + } + + fun swapLeft(up: Boolean = true) { + a.value + if (up) leftScreenSwipe(Random.nextInt(400)) + else leftScreenSwipe(-Random.nextInt(400)) + } + + fun swapRight(up: Boolean = true) { + if (up) rightScreenSwipe(Random.nextInt(400)) + else rightScreenSwipe(-Random.nextInt(400)) + } + + fun changePlaybackSpeed(inc: Boolean) { + playbackSpeed.removeSuffix("x").toDoubleOrNull()?.let { + if (inc) playbackSpeed = "${it + 0.5}x" + else playbackSpeed = "${it - 0.5}x" + } + println("new playback-speed is $playbackSpeed") + } +} \ No newline at end of file diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/PlaybackSpeed.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/PlaybackSpeed.kt new file mode 100644 index 0000000..d2ac4e5 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/PlaybackSpeed.kt @@ -0,0 +1,18 @@ +package com.krunal.demo.kotlinpractice.delegation + +import kotlin.reflect.KProperty + +class PlaybackSpeed { + + private var speed = "1.0x" + + operator fun getValue(thisRef: Any, property: KProperty<*>): String { + println("$thisRef: ${property.name} getValue()") + return speed + } + + operator fun setValue(thisRef: Any, property: KProperty<*>, value: String) { + println("$thisRef: ${property.name} setValue()") + speed = value + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/PlayerConfig.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/PlayerConfig.kt new file mode 100644 index 0000000..a669f1a --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/PlayerConfig.kt @@ -0,0 +1,7 @@ +package com.krunal.demo.kotlinpractice.delegation + +class PlayerConfig(val map: MutableMap) { + + var brightness: Int by map + var volume: Int by map +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/ScreenGesture.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/ScreenGesture.kt new file mode 100644 index 0000000..f88a02c --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/ScreenGesture.kt @@ -0,0 +1,7 @@ +package com.krunal.demo.kotlinpractice.delegation + +interface ScreenGesture { + + fun leftScreenSwipe(distance: Int) + fun rightScreenSwipe(distance: Int) +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/ScreenGestureImpl.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/ScreenGestureImpl.kt new file mode 100644 index 0000000..ad00135 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/ScreenGestureImpl.kt @@ -0,0 +1,27 @@ +package com.krunal.demo.kotlinpractice.delegation + +class ScreenGestureImpl : ScreenGesture { + + private var brightness = 0 + private var volume = 0 + + override fun leftScreenSwipe(distance: Int) { + if (distance > 0) { + println("Increasing brightness...") + } else { + println("Decreasing brightness...") + } + brightness += distance + println("\uD83D\uDD06: $brightness") + } + + override fun rightScreenSwipe(distance: Int) { + if (distance > 0) { + println("Increasing volume...") + } else { + println("Decreasing volume...") + } + volume += distance + println("\uD83D\uDD0A: $volume") + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/SongDetails.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/SongDetails.kt new file mode 100644 index 0000000..8696984 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/delegation/SongDetails.kt @@ -0,0 +1,10 @@ +package com.krunal.demo.kotlinpractice.delegation + +class SongDetails(map: Map) { + + val title: String by map + val singer: String by map + val music: String by map + val releasedYear: Int by map + val indieMusic: Boolean by map +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/errorhandling/ErrorHandlingMain.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/errorhandling/ErrorHandlingMain.kt new file mode 100644 index 0000000..1b4fb7d --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/errorhandling/ErrorHandlingMain.kt @@ -0,0 +1,37 @@ +package com.krunal.demo.kotlinpractice.errorhandling + +import java.io.BufferedReader +import java.io.InputStreamReader +import java.net.HttpURLConnection +import java.net.URL + +fun main() { + val token = try { + LoginRepo.login("Kruna1Pate1", "Krunal@321").toString() + } catch (e: UserNotFoundException) { + println(e.message) + } catch (e: IllegalArgumentException) { + println(e.message) + } catch (e: InvalidPasswordException) { + println(e.message) + } catch (e: Exception) { + println("Unknown exception ${e.message}") + } + + if (token is String) { + println("unique id: $token") + } + + // try-with resource + try { + val url = URL("https://jsonplaceholder.typicode.com/todos/1") + val con = url.openConnection() as HttpURLConnection + BufferedReader(InputStreamReader(con.inputStream)).use { + it.readLines().forEach(::println) + } + } catch (e: Exception) { + println(e.message) + } finally { + println("Reading completed") + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/errorhandling/InvalidPasswordException.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/errorhandling/InvalidPasswordException.kt new file mode 100644 index 0000000..e88d944 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/errorhandling/InvalidPasswordException.kt @@ -0,0 +1,6 @@ +package com.krunal.demo.kotlinpractice.errorhandling + +class InvalidPasswordException(override val message: String?) : Exception(message) { + + constructor() : this(null) +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/errorhandling/LoginRepo.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/errorhandling/LoginRepo.kt new file mode 100644 index 0000000..f0278f0 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/errorhandling/LoginRepo.kt @@ -0,0 +1,29 @@ +package com.krunal.demo.kotlinpractice.errorhandling + +import java.util.UUID + +object LoginRepo { + + private val userDetails = UserDetails2("Kruna1Pate1", "Krunal@123") + + @Throws + fun login(user: String, password: String): UUID { + if (user != userDetails.userName) { + throw UserNotFoundException("User not found") + } + validate(password) + println("Logged in successfully") + return UUID.randomUUID() + } + + fun validate(password: String): Boolean { + if (password.isEmpty()) { + throw IllegalArgumentException("Password can't be empty") + } else if (password != userDetails.password) { + throw InvalidPasswordException("Invalid password!") + } else { + println("Password is valid") + return true + } + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/errorhandling/UserDetails2.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/errorhandling/UserDetails2.kt new file mode 100644 index 0000000..d79a152 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/errorhandling/UserDetails2.kt @@ -0,0 +1,7 @@ +package com.krunal.demo.kotlinpractice.errorhandling + +data class UserDetails2( + val userName: String, + var password: String, + var email: String? = null +) diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/errorhandling/UserNotFoundException.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/errorhandling/UserNotFoundException.kt new file mode 100644 index 0000000..147d974 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/errorhandling/UserNotFoundException.kt @@ -0,0 +1,5 @@ +package com.krunal.demo.kotlinpractice.errorhandling + +class UserNotFoundException(override val message: String?) : Exception(message) { + constructor() : this(null) +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/function/ExtentionFun.java b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/function/ExtentionFun.java new file mode 100644 index 0000000..b6af348 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/function/ExtentionFun.java @@ -0,0 +1,10 @@ +package com.krunal.demo.kotlinpractice.function; + +public class ExtentionFun { + + public static void main(String[] args) { + Person person = new Person(); + System.out.println("name: " + person.getLname()); + System.out.println("cap name: " + FunctionsKt.capName(person)); + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/function/Functions.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/function/Functions.kt new file mode 100644 index 0000000..950e02f --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/function/Functions.kt @@ -0,0 +1,117 @@ +package com.krunal.demo.kotlinpractice.function + +fun main() { + fun isEven(num: Int): Boolean { + return num % 2 == 0 + } + println("5 isEven ${isEven(5)}") + + // Default parameter + fun greet(num: Int = 90, name: String = "") { + println("Hello $name $num") + } + greet(name = "") + + // Single-expression functions + fun square(n: Int) = n * n + println(square(5)) + + // Variable number of arguments (varargs) + fun printFormatted(delimiter: String = ",", vararg value: T) { + value.forEach { print("$it$delimiter") } + } + printFormatted(", ", "a", "b", "c", "d") + printFormatted("-", *arrayOf(1, 2, 3, 4, 5)) + + // infix notation + println("10 divisible by 5 ${10 isDivisible 5}") + println("10 divisible by 3 ${10 isDivisible 3}") + + // Extensions + val str: String = "Hello World!!" + println(str.removeAll("l")) + + str.let { + println(it) + } + println(str) + + // inline + calculator( + { s: String -> print(s) }, + { n1: Int, n2: Int -> (n1 * n2) } + ) + + // reified + val status1: Int = hpCheck(12) + println(status1) + val status2: String = hpCheck(0) + println(status2) + + printFormattedType(", ", "a", "b", "c", "d") + printFormattedType("-", *arrayOf(1, 2, 3, 4, 5)) + println() + + // cross inline + fun fooCaller() { + foo { + println("In foo") + return@foo + } + println("foo completed") + } + fooCaller() +} + +private fun String.removeAll(str: String): String { + return this.replace(str, "") +} + +infix fun Int.isDivisible(x: Int): Boolean { + return this % x == 0 +} + +inline fun calculator(expression: (String) -> Unit, noinline value: (Int, Int) -> Int) { + expression("5 * 5 = $value(5, 5)") +} + +class Person { + private val fname = "Ron" + val lname = "Weasley" +} + +fun Person.capName(): String { +// return fname.uppercase() + return lname.uppercase() +} + +inline fun hpCheck(hp: Int): T { + return when (T::class) { + Int::class -> { + when (hp) { + in 1..20 -> 20 + in 20..100 -> hp + else -> hp + } as T + } + String::class -> { + when (hp) { + 0 -> "dead" + 100 -> "win" + else -> "invalid" + } as T + } + else -> "Invalid type" as T + } +} + +inline fun printFormattedType(delimiter: String = ",", vararg value: T) { + println("type: ${T::class.java}") + value.forEach { print("$it$delimiter") } +} + +inline fun foo(crossinline f: () -> Unit) { + f() + println("f() completed") +} + diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/function/Group.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/function/Group.kt new file mode 100644 index 0000000..6866f59 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/function/Group.kt @@ -0,0 +1,30 @@ +package com.krunal.demo.kotlinpractice.function + +class Group( + private val persons: MutableList = mutableListOf() +) { + + operator fun plus(other: Group) { + persons.addAll(other.persons) + } + + operator fun minus(other: Group) { + persons.removeAll(other.persons) + } + + operator fun dec(): Group { + return Group(persons.subList(0, persons.lastIndex - 1)) + } + + operator fun unaryPlus() { + persons.add("Dummy") + } + + override fun equals(other: Any?): Boolean { + return persons == (other as? Group)?.persons + } + + override fun hashCode(): Int { + return persons.hashCode() + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/function/Lambdas.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/function/Lambdas.kt new file mode 100644 index 0000000..bf74256 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/function/Lambdas.kt @@ -0,0 +1,38 @@ +package com.krunal.demo.kotlinpractice.function + +fun main() { + fun calculate(n1: Int, n2: Int, cal: (Int, Int) -> Int) { + println("$n1, $n2 = ${cal(n1, n2)}") + } + + val add = { a: Int, b: Int -> a + b } + calculate(5, 10, cal = add) + calculate(5, 10) { a, b -> a * b } + + // Anonymous function + calculate(50, 10, fun(a: Int, b) = a / b) + + // lambda as class extension + val repeat: String.(Int) -> String = { + var str = this + repeat(it - 1) { str += " $this" } + str + } + println("Hello".repeat(5)) + + // Java Functional interface in lambda + fun transformer(value: String, mod: Modifier) { + println(mod(value)) + } + + val abc = Modifier { + return@Modifier "" + } + val modifier = { value: String -> value.uppercase() } + fun modifierFun(value: String) = value.uppercase() + transformer(value = "hello", mod = modifier) + transformer(value = "hello", mod = ::modifierFun) + transformer(value = "world") { + it.uppercase() + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/function/Modifier.java b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/function/Modifier.java new file mode 100644 index 0000000..b1f4ba4 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/function/Modifier.java @@ -0,0 +1,7 @@ +package com.krunal.demo.kotlinpractice.function; + +@FunctionalInterface +public interface Modifier { + + T invoke(T val); +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/function/OperatorOverloading.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/function/OperatorOverloading.kt new file mode 100644 index 0000000..92c00b4 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/function/OperatorOverloading.kt @@ -0,0 +1,20 @@ +package com.krunal.demo.kotlinpractice.function + +fun main() { + var gr1 = Group(mutableListOf("one", "two", "three", "four")) + val gr2 = Group(mutableListOf("three", "four", "five", "six")) + + gr1 - gr2 + println(gr1) + + gr1 + gr2 + println(gr1) + + gr1-- + println(gr1) + + +gr1 + println(gr1) + + println(gr1 == gr2) +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/generics/GenericsMain.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/generics/GenericsMain.kt new file mode 100644 index 0000000..bd2bbca --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/generics/GenericsMain.kt @@ -0,0 +1,18 @@ +package com.krunal.demo.kotlinpractice.generics + +fun main() { + + val stack: MyStack = MyStack() + stack.push("Hello") + stack.push("World") + stack.push("!!") + println(stack.items) + + type("") + type(5) + type(mutableListOf(4, 3, 2)) +} + +inline fun type(e: T) { + println("type: ${e!!::class.java}") +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/generics/MyStack.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/generics/MyStack.kt new file mode 100644 index 0000000..aacf843 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/generics/MyStack.kt @@ -0,0 +1,15 @@ +package com.krunal.demo.kotlinpractice.generics + +class MyStack { + + var items: MutableList = mutableListOf() + + fun push(element: T) { + items.add(element) + } + + fun pop(): T? { + if (items.isEmpty()) return null + return items.removeLast() + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/nullsafety/NullSafety.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/nullsafety/NullSafety.kt new file mode 100644 index 0000000..30fb777 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/nullsafety/NullSafety.kt @@ -0,0 +1,45 @@ +package com.krunal.demo.kotlinpractice.nullsafety + +import kotlin.random.Random + +fun main() { + // Making variable nullable + val num: Int? + num = null // must be initialized + println(num) + + // Checking for null in conditions + val password: String? = "abcde" + if (password != null && password.length >= 5) { + println("valid password") + } + + // Safe calls + var str: String? = "Hello World!!" + println(str?.length) + str?.let { + println("$it is not null") + } + str.checkNull() + + // Elvis operator + str = null + println(str ?: "null string") + + // not-null assertion operator + str = if (Random.nextBoolean()) "" else null + println(str!!.length) + + // Safe casts + val number: Number = 5.5 +// println(number as Int) ClassCastException + println(number as? Int ?: 5) +} + +fun String?.checkNull() { + if (this == null) { + println("null") + } else { + println("not null") + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/Inheritance.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/Inheritance.kt new file mode 100644 index 0000000..a62359f --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/Inheritance.kt @@ -0,0 +1,66 @@ +package com.krunal.demo.kotlinpractice.oop + +import kotlin.math.max + +fun main() { + var animal: Animal = object : Animal(name = "Tom") { + override fun canSecure(): Boolean { + return false + } + } + println(animal.speak()) + animal = Dog("dog") + println(animal.speak()) + animal = Tommy() + println(animal::class.java) + println(animal.sleepTime) + + var derived: Base// = Derived("Hello", "World") + derived = Derived("Hello", "World") + println(derived.name) + println(derived.lastName) +} + +abstract class Animal(val name: String) { + abstract fun canSecure(): Boolean + + open fun speak(): String { + return "hello!!" + } +} + +open class Dog(name: String) : Animal(name) { + override fun canSecure(): Boolean { + return true + } + + override fun speak(): String { + return "bark" + } +} + +class Tommy : Dog("Tommy") { + var sleepTime: Int = 0 + set(value) { + max(value, 0) + } +} + +open class Base(val name: String) { + + init { println("Initializing a base class") } + + open val size: Int = + name.length.also { println("Initializing size in the base class: $it") } +} + +class Derived( + name: String, + val lastName: String, +) : Base(name.replaceFirstChar { it.uppercase() }.also { println("Argument for the base class: $it") }) { + + init { println("Initializing a derived class") } + + override val size: Int = + (super.size + lastName.length).also { println("Initializing size in the derived class: $it") } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/classandobj/Book.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/classandobj/Book.kt new file mode 100644 index 0000000..119bee1 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/classandobj/Book.kt @@ -0,0 +1,30 @@ +package com.krunal.demo.kotlinpractice.oop.classandobj + +class Book( + var name: String, + var author: String?, +) { + + var rating: Int = 0 + + constructor(book: Book) : this(book.name, book.author) { + rating += 10 + println("in constructor") + } + + init { + println("in init1") + } + + init { + println("in init2") + } + + companion object { + init { + println("static init") + } + + var a = 0 + } +} \ No newline at end of file diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/classandobj/ClassAndObjMain.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/classandobj/ClassAndObjMain.kt new file mode 100644 index 0000000..3734990 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/classandobj/ClassAndObjMain.kt @@ -0,0 +1,13 @@ +package com.krunal.demo.kotlinpractice.oop.classandobj + +fun main() { + val book1 = Book( + name = "harry potter and philosopher's stone", + author = "J.K. Rowling" + ) + val book2 = Book(book1) + + Database.getInstance() + val person = Person2(Person2.Name("Will", null, "byers")) +} + diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/classandobj/Database.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/classandobj/Database.kt new file mode 100644 index 0000000..debded9 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/classandobj/Database.kt @@ -0,0 +1,16 @@ +package com.krunal.demo.kotlinpractice.oop.classandobj + +class Database private constructor() { + + companion object { + + private lateinit var instance: Database + fun getInstance(): Database { + if (!Companion::instance.isInitialized) { + println("Creating new db obj") + instance = Database() + } + return instance + } + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/classandobj/Person2.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/classandobj/Person2.kt new file mode 100644 index 0000000..abd1087 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/classandobj/Person2.kt @@ -0,0 +1,22 @@ +package com.krunal.demo.kotlinpractice.oop.classandobj + +class Person2(val name: Name) { + + var age: Int = 20 + + class Name( + var fname: String, var mname: String?, var lname: String + ) { + + init { +// println("age: $age") + } + } + + inner class Address(street: String) { + + init { + println("${name.fname} lives in $street") + } + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/dataclass/DataclassMain.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/dataclass/DataclassMain.kt new file mode 100644 index 0000000..e7719bf --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/dataclass/DataclassMain.kt @@ -0,0 +1,24 @@ +package com.krunal.demo.kotlinpractice.oop.dataclass + +fun main() { + val userDetails = UserDetails("Krunal", 20, "Male") +// println(userDetails.password) lateinit property password has not been initialized + userDetails.password = "Krunal@123" + + val (name, age, _) = userDetails + println("$name info: $userDetails") + + val userDetails2 = userDetails.copy() + userDetails2.password = "Changed" + println("$name info: $userDetails2") + + println(userDetails == userDetails2) + + changer(userDetails) + println(userDetails) +} + +fun changer(userDetails: UserDetails) { + userDetails.age = 44 + println(userDetails) +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/dataclass/UserDetails.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/dataclass/UserDetails.kt new file mode 100644 index 0000000..b1af4ab --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/dataclass/UserDetails.kt @@ -0,0 +1,11 @@ +package com.krunal.demo.kotlinpractice.oop.dataclass + +data class UserDetails( + val name: String, var age: Int, val gender: String +) { + lateinit var password: String + + operator fun component4(): String { + return password + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/enum/EnumMain.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/enum/EnumMain.kt new file mode 100644 index 0000000..e0223c2 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/enum/EnumMain.kt @@ -0,0 +1,18 @@ +package com.krunal.demo.kotlinpractice.oop.enum + +import com.krunal.demo.kotlinpractice.oop.enum.House.* + +fun main() { + var house: House = GRYFFINDOR + house.value = "a" + + when (house) { + GRYFFINDOR -> println(house) + RAVENCLAW -> println(house) + HUFFLEPUFF -> println(house) + SLYTHERIN -> println(house) + } + + house = SLYTHERIN + println(house) +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/enum/House.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/enum/House.kt new file mode 100644 index 0000000..0b0291f --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/enum/House.kt @@ -0,0 +1,18 @@ +package com.krunal.demo.kotlinpractice.oop.enum + +import kotlin.random.Random + +enum class House(var value: String) { + + GRYFFINDOR("Bravery"), + RAVENCLAW("Intelligence"), + HUFFLEPUFF("Empathy"), + SLYTHERIN("Ambition"); + + val canAdd: Boolean + get() = Random.nextBoolean() + + override fun toString(): String { + return "[$ordinal] $name $value" + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/interface/MainInterface.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/interface/MainInterface.kt new file mode 100644 index 0000000..6d4b385 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/interface/MainInterface.kt @@ -0,0 +1,7 @@ +package com.krunal.demo.kotlinpractice.oop.`interface` + +fun main() { + var userRepository = UserRepositoryImpl() + + println(userRepository.getAllUsers()) +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/interface/MyInterface.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/interface/MyInterface.kt new file mode 100644 index 0000000..8e2cc35 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/interface/MyInterface.kt @@ -0,0 +1,9 @@ +package com.krunal.demo.kotlinpractice.oop.`interface` + +interface UserRepository { + + val source: String + + fun getUser(): User + fun getAllUsers(): List +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/interface/User.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/interface/User.kt new file mode 100644 index 0000000..c8b4d06 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/interface/User.kt @@ -0,0 +1,6 @@ +package com.krunal.demo.kotlinpractice.oop.`interface` + +data class User( + val username: String, + var password: String +) diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/interface/UserRepositoryImpl.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/interface/UserRepositoryImpl.kt new file mode 100644 index 0000000..4ffa256 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/interface/UserRepositoryImpl.kt @@ -0,0 +1,18 @@ +package com.krunal.demo.kotlinpractice.oop.`interface` + +class UserRepositoryImpl : UserRepository { + + private val users = mutableListOf( + User("Kruna1Pate1", "Krunal@123"), + User("Harsh", "Harsh@123"), + User("Ankur", "Ankur#123") + ) + + override var source: String = "Local database" + + override fun getUser(): User { + return users.random() + } + + override fun getAllUsers(): List = users +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/interface/functional/FuncMain.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/interface/functional/FuncMain.kt new file mode 100644 index 0000000..9651598 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/interface/functional/FuncMain.kt @@ -0,0 +1,11 @@ +package com.krunal.demo.kotlinpractice.oop.`interface`.functional + +fun main() { + fun cap(str: String, mod: KModifier) { + println(mod(str)) + } + + val mod: KModifier = KModifier { it.uppercase() } + cap("Hello") { it.uppercase() } + cap("Hello", mod = mod) +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/interface/functional/KModifier.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/interface/functional/KModifier.kt new file mode 100644 index 0000000..0368b63 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/interface/functional/KModifier.kt @@ -0,0 +1,5 @@ +package com.krunal.demo.kotlinpractice.oop.`interface`.functional + +fun interface KModifier { + operator fun invoke(value: T): T +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/properties/Polygon.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/properties/Polygon.kt new file mode 100644 index 0000000..536e008 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/properties/Polygon.kt @@ -0,0 +1,9 @@ +package com.krunal.demo.kotlinpractice.oop.properties + +interface Polygon { + + // interface members are 'open' by default + fun draw() { + println("Polygon draw") + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/properties/PropertiesMain.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/properties/PropertiesMain.kt new file mode 100644 index 0000000..606c1e3 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/properties/PropertiesMain.kt @@ -0,0 +1,22 @@ +package com.krunal.demo.kotlinpractice.oop.properties + +fun main() { + val wizard = Wizard(Wizard.Name("Harry", "Potter")) + println(wizard.school) + println(wizard.house) + while (!wizard.changeHouse("slytherin")) { + } + println(wizard.house) + + val sq = Square() + sq.draw() +} + +var Wizard.fullName: String + get() = "${name.fname} ${name.lname}" + set(value) { + value.split(" ").run { + name.fname = first() + name.lname = last() + } + } diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/properties/Rectangle.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/properties/Rectangle.kt new file mode 100644 index 0000000..f447391 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/properties/Rectangle.kt @@ -0,0 +1,8 @@ +package com.krunal.demo.kotlinpractice.oop.properties + +open class Rectangle { + + open fun draw() { + println("Rectangle draw") + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/properties/Square.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/properties/Square.kt new file mode 100644 index 0000000..05e4232 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/properties/Square.kt @@ -0,0 +1,11 @@ +package com.krunal.demo.kotlinpractice.oop.properties + +class Square : Rectangle(), Polygon { + + // The compiler requires draw() to be overridden: + override fun draw() { + println("Square draw") + super.draw() // call to Rectangle.draw() + super.draw() // call to Polygon.draw() + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/properties/Wizard.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/properties/Wizard.kt new file mode 100644 index 0000000..69588d6 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/properties/Wizard.kt @@ -0,0 +1,27 @@ +package com.krunal.demo.kotlinpractice.oop.properties + +import kotlin.random.Random + +class Wizard(var name: Name) { + + var age = 20 + val school = "Hogwarts" + var house: String? = null + get() = "$school.$field" + private set(value) { + field = value?.replaceFirstChar { it.uppercase() } + } + + fun changeHouse(newHouse: String): Boolean { + return if (Random.nextBoolean()) { + house = newHouse + println("house changed to $house") + true + } else { + println("no luck") + false + } + } + + class Name(var fname: String, var lname: String) +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/sealed/Response.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/sealed/Response.kt new file mode 100644 index 0000000..9dcd5b4 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/sealed/Response.kt @@ -0,0 +1,20 @@ +package com.krunal.demo.kotlinpractice.oop.sealed + +sealed interface Response { + + class Success(val data: T) : Response + object Loading : Response + data class Downloading(val read: Double, val total: Double) : Response { + fun pause() { + println("Download paused") + } + + fun restart() { + println("Download restart") + } + } + + sealed class Error(open val message: String?) : Response + data class InternalError(override val message: String?) : Error(message) + data class ServerError(val code: Int, override val message: String?) : Error(message) +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/sealed/SealedMain.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/sealed/SealedMain.kt new file mode 100644 index 0000000..9e2d794 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/oop/sealed/SealedMain.kt @@ -0,0 +1,26 @@ +package com.krunal.demo.kotlinpractice.oop.sealed + +fun main() { + val response: Response = Response.Success("Welcome to the world!!") + response.printResponse() + + Response.Loading.printResponse() + Response.Downloading(45.0, 100.0).let { + it.printResponse() + it.pause() + it.restart() + } + Response.InternalError("no internet connection").printResponse() + Response.ServerError(401, "unauthorized access").printResponse() +// Response.Error() sealed class can't be initialized +} + +fun Response.printResponse() { + when (this) { + is Response.Success<*> -> println("Successful: $data") + Response.Loading -> println("Loading data") + is Response.Downloading -> println("Download: ${(read / total) * 100}%") + is Response.InternalError -> println("Internal error $message") + is Response.ServerError -> println("$code $message") + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/scopped/ScoppedMain.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/scopped/ScoppedMain.kt new file mode 100644 index 0000000..fc98389 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/scopped/ScoppedMain.kt @@ -0,0 +1,40 @@ +package com.krunal.demo.kotlinpractice.scopped + +import com.krunal.demo.kotlinpractice.oop.dataclass.UserDetails + +fun main() { + val user = UserDetails("Harry", 20, "Male") + println(user) + + val let = user.let { + println("let: $it") + "return let" + } + println(let) + + val also = user.also { user -> + println("also: $user") + "return also" + } + println(also) + + val apply = user.apply { + println("apply: $this") + "return apply" + } + println(apply) + + val runEx = user.run { + println("run: $this") + "return run" + } + println(runEx) + + val run = run { "return run" } + println(run) + val with = with(user) { + println("with: $this") + "return with" + } + println(with) +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/types/DataTypes.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/types/DataTypes.kt new file mode 100644 index 0000000..299561f --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/types/DataTypes.kt @@ -0,0 +1,49 @@ +package com.krunal.demo.kotlinpractice + +fun main() { + // Numbers + val intNum = 1 // Int + val longNum = 10_00_000_000 // Long + val longNum2 = 1L // Long + val byteNum: Byte = 1 + val float = 4.4F + val double = 4.4 + + // Unsigned Numbers + val uByte: UByte = 1u + val uShort: UShort = 1u + val uLong: ULong = 1u + val uLong2: ULong = 1UL + + // Boolean + val boolVal = true + println(boolVal.not()) + + // Character + val charA = 'A' + val smile = "😄" + println('\uF604') + println(smile) + + // String + val str = "Hello World!!" + println(str.uppercase()) + val mulStr = """ + Line 1 + Line 2 + Line 3 + """.trimIndent() + println(mulStr) + val name = "Krunal" + println("Hello $name, Welcome") + + // Type checks and casts + val num: Number = 5 +// println(num + num) Unresolved reference `+`. + if (num is Int) { + println(num * num) + } + if ((num as Any) is String) { + println("string") + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/visibilitymod/Outer.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/visibilitymod/Outer.kt new file mode 100644 index 0000000..9f3b99c --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/visibilitymod/Outer.kt @@ -0,0 +1,13 @@ +package com.krunal.demo.kotlinpractice.visibilitymod + +open class Outer { + + private val a = 1 + protected open val b = 2 + internal open val c = 3 + val d = 4 // public by default + + protected class Nested { + val e: Int = 5 + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/visibilitymod/Subclass.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/visibilitymod/Subclass.kt new file mode 100644 index 0000000..b5dfbc7 --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/visibilitymod/Subclass.kt @@ -0,0 +1,12 @@ +package com.krunal.demo.kotlinpractice.visibilitymod + +class Subclass : Outer() { + + // override val a = 4 a is not visible + override val b = 5 // 'b' is protected + override val c = 7 // 'c' is internal + + init { + Nested().e + } +} diff --git a/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/visibilitymod/Unrelated.kt b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/visibilitymod/Unrelated.kt new file mode 100644 index 0000000..6adc30a --- /dev/null +++ b/Demo/app/src/main/java/com/krunal/demo/kotlinpractice/visibilitymod/Unrelated.kt @@ -0,0 +1,12 @@ +package com.krunal.demo.kotlinpractice.visibilitymod + +class Unrelated(outer: Outer) { + + init { +// outer.a Cannot access 'a': it is private in 'Outer' +// outer.b Cannot access 'b': it is protected in 'Outer' + outer.c + outer.d +// outer.Nested Classifier 'Nested' does not have a companion object, and thus must be initialized here + } +}