Kotlin puzzler

Kotlin Puzzler
Rainist 
Park, MIREUK

Not a test
To understand Kotlin language
For fun(remember easily)

Engineer with Lover
data class Engineer(
val name: String,
val lover: Lover?
)
data class Lover(
val name: String,
val phoneNumber: String?
)
fun main(args: Array<String>) {
val james =
Engineer(
name = "James",
lover = Lover(
name = "Soo",
phoneNumber = null
)
)
james.lover?.let { girlFriend ->
girlFriend.phoneNumber?.let {
print("${girlFriend.name} phone number is $it")
}
} ?: run {
print("There is no lover.")
}
}

Engineer with Lover
val name: String,
val lover: Lover?
)
data class Lover(
val name: String,
)
val james =
Engineer(
name = "James",
lover = Lover(
name = "Soo",
phoneNumber = null
)
)
}
} ?: run {
}
}
/**
* 1. "There is no lover."
* 2. "Soo phone number is null"
* 3. nothing
* */

let s check return, expression
val name: String,
val lover: Lover?
)
data class Lover(
val name: String,
)
val james =
Engineer(
name = "James",
lover = Lover(
name = "Soo",
phoneNumber = null
)
)
}
} ?: run {
}
}
/**
* 1. "There is no lover."
* 2. "Soo phone number is null"
* 3. nothing
* */

Book, full of text
class Book {
var preface: Preface? = null
}
class Preface {
val text: String? = null
}
val book = Book()
val hasText: Boolean = book.preface?.text != null ?: false
print("hasText:$hasText")
}

Book, full of text
class Book {
var preface: Preface? = null
}
class Preface {
val text: String? = null
}
val book = Book()
val hasText: Boolean = book.preface?.text != null ?: false
print("hasText:$hasText")
}
/**
* 1. true
* 2. false
* */

Memo
import org.junit.Test
import org.junit.Assert.*
class MemoTest {
data class Memo(
val content: String? = null,
val photo: Photo? = null
)
data class Photo(
val imageUrl: String? = null
)
@Test
fun checkDefaultConstructor() {
val memo = Memo()
val content = memo.content ?: "empty"
val photoUrl = memo.photo?.run { imageUrl }
assert(content == "empty")
assert(photoUrl != null)
}
}

Memo
class MemoTest {
data class Memo(
)
data class Photo(
)
@Test
val memo = Memo()
}
}
/**
* 1. Success
* 2. Fail
* */

Memo
class MemoTest {
data class Memo(
)
data class Photo(
)
@Test
val memo = Memo()
}
}
/**
* 1. Success
* 2. Fail
* */
/**
* Throws an [AssertionError] calculated by [lazyMessage] if the [value] is false
* and runtime assertions have been enabled on the JVM using the *-ea* JVM option.
*/
@kotlin.internal.InlineOnly
public inline fun assert(value: Boolean, lazyMessage: () -> Any) {
if (_Assertions.ENABLED) {
if (!value) {
val message = lazyMessage()
throw AssertionError(message)
}
}
}

Writing failing test rst.
class MemoTest {
data class Memo(
)
data class Photo(
)
@Test
val memo = Memo()
}
}
/**
* 1. Success
* 2. Fail
* */

Null everywhere
private var account: String? = null
private var password: String? = null
val textBuilder = StringBuilder()
if (account?.toString() != null) {
textBuilder.append("account is $account.")
appendPassword(textBuilder)
} else {
textBuilder.append("account is empty.")
}
print(textBuilder.toString())
}
private fun appendPassword(textBuilder: StringBuilder) {
if (password.toString() != null) {
textBuilder.append("password is $password.")
} else {
textBuilder.append("password is empty.")
}
}

Null everywhere
} else {
}
}
} else {
}
}
/**
* The root of the Kotlin class hierarchy. Every Kotlin class has [Any] as a superclass.
*/
public open class Any {
/**
* Returns a string representation of the object.
*/
public open fun toString(): String
}
/**
* Returns a string representation of the object. Can be called with a null receiver, in which case
* it returns the string "null".
*/
public fun Any?.toString(): String

Check before use.
} else {
}
}
} else {
}
}

My Data class
sealed class BankAccount {
abstract val id: String
abstract val name: String
override fun equals(other: Any?): Boolean {
return (other as? BankAccount)?.id == id
}
override fun hashCode(): Int {
return id.hashCode()
}
}
data class CheckingAccount(
override val id: String,
override val name: String,
val number: String
) : BankAccount()
val a = CheckingAccount(id = "001", name = "hello", number = "number")
val b = a.copy(number = "abc")
print("a and b is equal:${a == b}")
}

My Data class
}
}
}
val number: String
) : BankAccount()
}
/**
* 1. “a and b is equal:true”
* 2. “a and b is equal:false”
* */

My Data class
}
}
}
val number: String
) : BankAccount() {
return super.equals(other)
}
return super.hashCode()
}
}
}

My Data class
final override fun equals(other: Any?): Boolean {
}
final override fun hashCode(): Int {
}
}
val number: String
) : BankAccount()
}

Double check doc.
final override fun equals(other: Any?): Boolean {
}
final override fun hashCode(): Int {
}
}
val number: String
) : BankAccount()
}

My name is
class User {
lateinit var name: String
}
fun User.newInstance(name: String) = User().apply { this.name = name }
val james = User.newInstance("james")
print("Hello, my name is ${james.name}")
}

My name is
class User {
}
fun User.Companion.newInstance(name: String) = User().apply { … }
}

My name is
class User {
companion object
}
fun User.Companion.newInstance(name: String) = User().apply { ... }
}

Gotta get that!
class Company {
val members =
mutableListOf(
"Mireuk",
"Sunghyun",
"ChaeYoon",
"BeomJoon"
)
val sizeValue: Int = getMemberCount()
val sizeGet: Int
get() = getMemberCount()
val sizeLazy by lazy { getMemberCount() }
private fun getMemberCount(): Int = members.size
}
Company().run {
println("1:$sizeValue, 2:$sizeGet, 3:$sizeLazy")
members.add("YOU")
}
}

Gotta get that!
class Company {
val members =
mutableListOf(
"Mireuk",
"Sunghyun",
"ChaeYoon",
"BeomJoon"
)
val sizeGet: Int
}
Company().run {
members.add("YOU")
}
}
/**
* 1: 4, 2: 4, 3: 4
* 4: 4, 5: 5, 6: 4
* */

value is nal.
class Company {
val members =
mutableListOf(
"Mireuk",
"Sunghyun",
"ChaeYoon",
"BeomJoon"
)
val sizeGet: Int
}
Company().run {
members.add("YOU")
}
}
/**
* 1: 4, 2: 4, 3: 4
* 4: 4, 5: 5, 6: 4
* */

Kotlin puzzler

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Kotlin puzzler

Similar to Kotlin puzzler (20)

Recently uploaded

Recently uploaded (20)

Kotlin puzzler