객체와 클래스

fun drawCircle() {
	val circle = object {
		val x = 10
		val y = 20
		val radius = 30
	}
	println("Circle x: ${circle.x} y: ${circle.y} radius : ${circle.radius}")
}

fun createRunnable() : Runnable {
	val runnable = object : Runnable {
		override fun run() { println("You called...") }
	}
	return runnable
}

fun specialTransaction(account: BankAccount) {
    // Creates an anonymous object that inherits from the BankAccount class and 
    // implements the Transaction interface
    
    // The balance of the provided account is passed to the BankAccount superclass constructor
    val temporaryAccount = object : BankAccount(account.balance), Transaction {

        override val balance = account.balance + 500  // Temporary bonus

        // Implements the execute() function from the Transaction interface
        override fun execute() {
            println("Executing special transaction. New balance is $balance.")
        }
    }
    // Executes the transaction
    temporaryAccount.execute()
}

object Util {
	fun numberOfProcessors() = Runtime.getRuntime().availableProcessors()
}

object Sun : Runnable {
	val radiusInKM = 696000
	var coreTemperatureInC = 15000000
	override fun run() { println("spin...") }
}

fun moveIt(runnable: Runnable) {
	runnable.run()
}

println(Sun.radiusInKM) 
moveIt(Sun)

object DefaultListener : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) { ... }

    override fun mouseEntered(e: MouseEvent) { ... }
}

class Car(val yearOfMake: Int)

val car = Car(2019)
println(car.yearOfMake) // 2019
car.yearOfMake = 2019 // ERROR: val cannot be reassigned

// 읽기-쓰기 전용 속성
class Car(val yearOfMake: Int, var color: String)

fun useCarObject(): Pair<Int, String> {
  val car = Car(2019, "Red")
  val year = car.yearOfMake
  car.color = "Green"
  val color = car.color
  return year to color
}

Compiled from "UseCar.kt"
public final class UseCarKt {
  public static final kotlin.Pair<java.lang.Integer, java.lang.String> useCarObject();
    Code:
       0: new           #10                 // class Car
       3: dup
       4: sipush        2019
       7: ldc           #12                 // String Red
       9: invokespecial #16                 // Method Car."<init>":(ILjava/lang/String;)V
      12: astore_0
      13: aload_0
      14: invokevirtual #20                 // Method Car.getYearOfMake:()I
      17: istore_1
      18: aload_0
      19: ldc           #22                 // String Green
      21: invokevirtual #26                 // Method Car.setColor:(Ljava/lang/String;)V
      24: aload_0
      25: invokevirtual #30                 // Method Car.getColor:()Ljava/lang/String;
      28: astore_2
      29: iload_1
      30: invokestatic  #36                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      33: aload_2
      34: invokestatic  #42                 // Method kotlin/TuplesKt.to:(Ljava/lang/Object;Ljava/lang/Object;)Lkotlin/Pair;
      37: areturn
}

fun main() {
    lateinit var text: String
    val textLength: Int by lazy {
        text.length
    }

    // 대충 중간에 뭔가 했음
    text = "H43RO_Velog"
    println(textLength)
}

if (foo:bar.isInitialized) {
	println(foo.bar)
}

class Car(val yearOfMake: Int, theColor: String) {
	var fuelLevel = 100
	var color = theColor
	set(value) {
		if (value.isBlank()) {
			throw RuntimeException("no empty, please")
		}
		field = value
	}
}

var fuelLevel = 100
private set

class InitOrderDemo(name: String) {
    val firstProperty = "First property: $name".also(::println)
    
    init {
        println("First initializer block that prints $name")
    }
    
    val secondProperty = "Second property: ${name.length}".also(::println)
    
    init {
        println("Second initializer block that prints ${name.length}")
    }
}

class Person public constructor(firstName: String) { /*...*/ }
// 아래와 같음
class Person(firstName: String) { /*...*/ }


// 생성자에 annotatino이나 visibility modifier를 적용하려면 consturctor keyword를 사용해야함
class Customer public @Inject constructor(name: String) { /* ... */ }

// private constructor
class C private constructor(a:Int) { ... }

class Person(val pets: MutableList<Pet> = mutableListOf())

class Pet {
    constructor(owner: Person) {
        owner.pets.add(this) // adds this pet to the list of its owner's pets
    }
}

// 주생성자가 있다면, 각각의 보조 생성자는 주 생성자에게 위임을 꼭 해야함
class Person(val name: String) {
    val children: MutableList<Person> = mutableListOf()
    constructor(name: String, parent: Person) : this(name) {
        parent.children.add(this)
    }
}

class Constructors {
    init {
        println("Init block")
    }

    constructor(i: Int) {
        println("Constructor $i")
    }
}
// Init block
// Constructor 1

class MachineOperator(val name: String) {
	fun checkin() = checkedIn++
	fun checkout() = checkedIn--
	companion object {
		var checkedIn = 0
		fun minimumBreak() = "15 minutes every 2 hours"
	}
}

MachineOperator("Mater").checkin()
println(MachineOperator.minimumBreak()) // 15 minutes every 2 hours
println(MachineOperator.checkedIn)      // 1

companion object MachineOperatorFactory {
	var checkedIn = 0
}

class MachineOperator private constructor(val name: String) {
	//...
	companion object {
		fun create(name: String): MachineOperator {
			val instance = MachineOperator(name)
			instance.checkin()
			return instance
		}
	}
}

companion object {
	@JvmStatic
	fun create() = Counter(0)
}

class PriorityPair<T: Comparable<T>>(member1: T, member2: T) {
	val first: T
	val second: T
	init {
		if (member1 >= member2) {
			first  = member1
			second = member2
		} else {
			first  = member2
			second = member1
		}
	}
	override fun toString() = "${first}, ${second}"
}

data class Task(val id: Int, val name: String, val completed: Boolean,
	val assigned: Boolean)

data class Result(val result: Int, val status: Status)
fun function(...): Result {
    // computations

    return Result(result, status)
}

// Now, to use this function:
val (result, status) = function(...)