"Classes Without Ceremony" — Constructors, Properties and Objects

// Fragment of story/JavaShapedProduct.kt
// What Kabir typed first: a Java class, transliterated.
class JavaShapedProduct {
    private val name: String
    private var pricePaise: Long

    constructor(name: String, pricePaise: Long) {
        this.name = name
        this.pricePaise = pricePaise
    }

    fun getName(): String = name
    fun getPricePaise(): Long = pricePaise
    fun setPricePaise(pricePaise: Long) {
        this.pricePaise = pricePaise
    }
}

// Fragment of story/JavaShapedProduct.kt
// What Lena typed: the same JVM class, as far as Java callers can tell.
class Product(val name: String, var pricePaise: Long)

public final class com.shelfwise.part03.story.Product {
  private final java.lang.String name;
  private long pricePaise;
  public com.shelfwise.part03.story.Product(java.lang.String, long);
  public final java.lang.String getName();
  public final long getPricePaise();
  public final void setPricePaise(long);
}

// CallsProduct.java, in the same module
Product product = new Product("Toor Dal 1kg", 16_500);
product.setPricePaise(15_900);
System.out.println(product.getName() + " " + product.getPricePaise()); // -> Toor Dal 1kg 15900

class ShelfSlot(val aisle: Int, val position: Int, capacity: Int) {
    // A property with an initialiser has a backing field. 'capacity' (no val) is only a constructor parameter.
    var unitsOnShelf: Int = 0
        // A custom setter: 'field' is the backing field. Writing 'unitsOnShelf = value' here would recurse.
        set(value) {
            require(value in 0..maxUnits) { "slot holds 0..$maxUnits units, got $value" }
            field = value
        }

    val maxUnits: Int = capacity

    // A custom getter with no initialiser and no 'field': computed on every read, no backing field at all.
    val code: String
        get() = "A$aisle-P$position"

    val isEmpty: Boolean
        get() = unitsOnShelf == 0

    // Readable everywhere, writable only inside the class.
    var lastRestockedBy: String = "nobody"
        private set

    fun restock(units: Int, by: String) {
        unitsOnShelf += units // goes through the setter, so the range check applies
        lastRestockedBy = by
    }
}

fun main() {
    val slot = ShelfSlot(aisle = 7, position = 3, capacity = 24)
    println(slot.code) // -> A7-P3
    println(slot.isEmpty) // -> true

    slot.restock(20, by = "kabir")
    println("${slot.unitsOnShelf} by ${slot.lastRestockedBy}") // -> 20 by kabir
    // slot.lastRestockedBy = "lena"  // error: cannot access 'lastRestockedBy': it is private in 'com.shelfwise.part03.properties.ShelfSlot'.

    try {
        slot.restock(10, by = "kabir")
    } catch (e: IllegalArgumentException) {
        println(e.message) // -> slot holds 0..24 units, got 30
    }
}

public final class com.shelfwise.part03.properties.ShelfSlot {
  private final int aisle;
  private final int position;
  private int unitsOnShelf;
  private final int maxUnits;
  private java.lang.String lastRestockedBy;
  public final int getUnitsOnShelf();
  public final void setUnitsOnShelf(int);
  public final java.lang.String getCode();      // no field: computed
  public final boolean isEmpty();               // no field, and no "get" prefix for is-names
  public final java.lang.String getLastRestockedBy();   // no setter emitted: it is private
  ...
}

// Fragment of properties/BackingFields.kt
// Explicit backing field (Stable in Kotlin 2.4.0): one property, two types.
// Outside the class it is a List<Long>; inside, the compiler knows the field is a MutableList.
class PriceHistory {
    val changes: List<Long>
        field = mutableListOf()

    fun record(pricePaise: Long) {
        changes += pricePaise // smart-cast to MutableList<Long> inside the class
    }
}

fun main() {
    val history = PriceHistory()
    history.record(16_500)
    history.record(15_900)
    println(history.changes) // -> [16500, 15900]
    // Outside the class, += on a read-only List means 'changes = changes + 1', which needs a var:
    // history.changes += 1  // error: 'val' cannot be reassigned.
    // The read-only view is a compile-time guarantee only: the object really is a MutableList.
    println(history.changes is MutableList<*>) // -> true
}

// The primary constructor is part of the class header. 'val'/'var' parameters become properties;
// plain parameters ('openedYear') are visible only to initialisers and init blocks.
class Store(val code: String, val city: String, openedYear: Int, val aisles: Int = 12) {

    // Initialisers and init blocks run top to bottom, interleaved, as one constructor body.
    val ageInYears: Int = 2026 - openedYear.also { println("1. property initialiser") }

    init {
        println("2. first init block")
        // println(label)  // error: variable 'label' must be initialized.
        require(code.matches(Regex("[A-Z]{3}-\\d{3}"))) { "bad store code: $code" }
    }

    val label: String = "$code ($city)".also { println("3. second property initialiser") }

    init {
        println("4. second init block")
    }

    // A secondary constructor must delegate to the primary one, which runs first.
    constructor(csvLine: String) : this(
        code = csvLine.substringBefore(','),
        city = csvLine.substringAfter(',').substringBefore(','),
        openedYear = csvLine.substringAfterLast(',').toInt(),
    ) {
        println("5. secondary constructor body")
    }
}

fun main() {
    val pune = Store("PUN-014", "Pune", openedYear = 2019)
    // -> 1. property initialiser
    // -> 2. first init block
    // -> 3. second property initialiser
    // -> 4. second init block
    println("${pune.label}, ${pune.ageInYears} years, ${pune.aisles} aisles") // -> PUN-014 (Pune), 7 years, 12 aisles

    val blr = Store("BLR-003,Bengaluru,2021")
    // -> 1. property initialiser
    // -> 2. first init block
    // -> 3. second property initialiser
    // -> 4. second init block
    // -> 5. secondary constructor body
    println(blr.label) // -> BLR-003 (Bengaluru)
}

// Classes are final unless marked open. So are their members.
open class Promotion(val code: String) {
    open fun discountPaise(pricePaise: Long): Long = 0
    fun describe(): String = "$code: ${discountPaise(10_000)} off ₹100" // final: subclasses can't override
}

class PercentOff(code: String, private val percent: Int) : Promotion(code) {
    // 'override' is mandatory, and an override is itself open unless marked final.
    override fun discountPaise(pricePaise: Long): Long = pricePaise * percent / 100
}

// class Flash : PercentOff("FLASH", 50)  // error: this type is final, so it cannot be extended.

fun main() {
    val promo: Promotion = PercentOff("DIWALI10", percent = 10)
    println(promo.describe()) // -> DIWALI10: 1000 off ₹100
}

// Interfaces can declare properties (abstract, or with a getter) and default methods.
interface Priced {
    val pricePaise: Long
    fun priceLabel(): String = "₹${pricePaise / 100}"
}

interface Labelled {
    val name: String
    val shelfName: String get() = name.uppercase() // a property with a default getter, no field
    fun priceLabel(): String = "see shelf"
}

// Both interfaces supply priceLabel(), so the class must override it,
// and super<T> picks which default to call. Same rule as Java's Priced.super.priceLabel().
class Item(override val name: String, override val pricePaise: Long) : Priced, Labelled {
    override fun priceLabel(): String = "${super<Labelled>.priceLabel()} — ${super<Priced>.priceLabel()}"
}

// class Broken(override val name: String, override val pricePaise: Long) : Priced, Labelled
//   error: class 'Broken' must override 'priceLabel' because it inherits multiple interface methods for it.

fun main() {
    val ghee = Item("Desi Ghee 1L", 64_900)
    println(ghee.shelfName) // -> DESI GHEE 1L
    println(ghee.priceLabel()) // -> see shelf — ₹649
}

open class PricingRule {
    // protected = subclasses only. No package access, unlike Java.
    protected fun marginPercent(): Int = 18

    // internal = visible anywhere in the same module (Gradle source set), nowhere else.
    internal fun auditCode(): String = "RULE-${marginPercent()}"
}

class FestivalRule : PricingRule() {
    fun summary(): String = "festival margin ${marginPercent()}%" // fine: a subclass
}

// Same package, not a subclass. In Java, a protected member would be accessible here.
class PriceReport {
    fun audit(rule: PricingRule): String = rule.auditCode() // internal: same module, fine
    // fun peek(rule: PricingRule) = rule.marginPercent()  // error: cannot access 'fun marginPercent(): Int': it is protected in 'com.shelfwise.part03.visibility.PricingRule'.
}

// private at the top level = visible in this file only.
private fun secretFormula(): Int = 42

fun main() {
    println(FestivalRule().summary()) // -> festival margin 18%
    println(PriceReport().audit(PricingRule())) // -> RULE-18
    println(secretFormula()) // -> 42
}

public class com.shelfwise.part03.visibility.PricingRule {
  protected final int marginPercent();
  public final java.lang.String auditCode$kotlin_for_java_survivors_language_part03_classes_without_ceremony();
}

// object: a class and its single instance in one declaration. Initialised lazily and
// thread-safely on first access, by the JVM's class initialisation, like a holder-idiom singleton.
object TaxTable {
    private val gstByCategory = mapOf("staples" to 5, "snacks" to 12, "household" to 18)

    fun gstPercent(category: String): Int = gstByCategory[category] ?: 18
}

interface IdSource {
    fun next(): Sku
}

class Sku private constructor(val value: String) {
    override fun toString() = value

    // A companion object holds what Java would make static: factories and constants.
    // Unlike statics, it is a real object, so it can implement an interface.
    companion object : IdSource {
        const val PREFIX = "SHW" // const in a companion becomes a static field on Sku
        private var issued = 0

        override fun next(): Sku = Sku("$PREFIX-${++issued}")

        @JvmStatic // also generate a static Sku.parse(...) for Java callers
        fun parse(raw: String): Sku {
            require(raw.startsWith("$PREFIX-")) { "not a Shelfwise SKU: $raw" }
            return Sku(raw)
        }
    }
}

fun issueTwo(source: IdSource): String = "${source.next()}, ${source.next()}"

interface PriceListener {
    fun onChange(sku: String, newPaise: Long)
}

fun main() {
    println(TaxTable.gstPercent("snacks")) // -> 12

    println(Sku.next()) // -> SHW-1
    println(issueTwo(Sku)) // -> SHW-2, SHW-3
    println(Sku.parse("SHW-77")) // -> SHW-77
    // Sku("SHW-9")  // error: cannot access 'constructor(value: String): Sku': it is private in 'com.shelfwise.part03.objects.Sku'.

    // Object expression: Java's anonymous class. Captured locals can be modified.
    var changes = 0
    val listener = object : PriceListener {
        override fun onChange(sku: String, newPaise: Long) {
            changes++ // a Java anonymous class could only read an effectively final local
            println("$sku -> $newPaise")
        }
    }
    listener.onChange("SHW-1", 15_900) // -> SHW-1 -> 15900
    listener.onChange("SHW-2", 8_900) // -> SHW-2 -> 8900
    println(changes) // -> 2
}

public final class com.shelfwise.part03.objects.TaxTable {
  public static final com.shelfwise.part03.objects.TaxTable INSTANCE;
  private static final java.util.Map<java.lang.String, java.lang.Integer> gstByCategory;
  public final int gstPercent(java.lang.String);
  static {};
}

public final class com.shelfwise.part03.objects.Sku {
  public static final com.shelfwise.part03.objects.Sku$Companion Companion;
  public static final java.lang.String PREFIX;          // const val: a real static field
  private static int issued;                             // companion state lives on Sku
  public static final com.shelfwise.part03.objects.Sku parse(java.lang.String);  // @JvmStatic bridge
  ...
}

public final class com.shelfwise.part03.objects.Sku$Companion implements com.shelfwise.part03.objects.IdSource {
  public com.shelfwise.part03.objects.Sku next();                          // an override, so not final
  public final com.shelfwise.part03.objects.Sku parse(java.lang.String);
}

class Aisle(val number: Int) {
    private val slots = mutableListOf<String>()

    // Nested by default: no reference to an Aisle. This is Java's *static* nested class.
    class Builder {
        private var number = 0
        fun number(value: Int) = apply { number = value }
        fun build() = Aisle(number)
        // fun slotCount() = slots.size  // error: outer class 'class Aisle : Any' of non-inner class cannot be used as receiver.
    }

    // 'inner' captures the enclosing Aisle, like a Java inner class without 'static'.
    inner class Slot(val position: Int) {
        fun label(): String = "A$number-P$position" // reads the outer instance's 'number'
        fun fill(product: String) {
            slots += product // and can touch its private state
        }
    }

    fun filled(): List<String> = slots
}

fun main() {
    val aisle = Aisle.Builder().number(7).build() // no Aisle instance needed to create a Builder
    val slot = aisle.Slot(3) // an inner class needs one
    slot.fill("Basmati Rice 5kg")
    println(slot.label()) // -> A7-P3
    println(aisle.filled()) // -> [Basmati Rice 5kg]
}

enum class StorageZone(val minCelsius: Int, val maxCelsius: Int) {
    AMBIENT(15, 30),
    CHILLED(0, 5) {
        override fun handlingNote() = "keep the cold chain unbroken"
    },
    FROZEN(-25, -18) {
        override fun handlingNote() = "restock within 20 minutes"
    };

    // An open member with a default; constants with a body override it.
    open fun handlingNote(): String = "no special handling"

    fun accepts(celsius: Int): Boolean = celsius in minCelsius..maxCelsius
}

fun main() {
    // entries: a fixed, cached List. values() still exists, but allocates a new array on every call.
    println(StorageZone.entries.map { it.name }) // -> [AMBIENT, CHILLED, FROZEN]
    println(StorageZone.entries.first { it.accepts(-20) }) // -> FROZEN
    println(StorageZone.CHILLED.handlingNote()) // -> keep the cold chain unbroken
    println(StorageZone.AMBIENT.handlingNote()) // -> no special handling
    println(StorageZone.valueOf("CHILLED").ordinal) // -> 1
    println(StorageZone.values() === StorageZone.values()) // -> false
    println(StorageZone.entries === StorageZone.entries) // -> true
}

// Fragment of catalog/Catalog.kt
// Step 1: categories carry their GST rate; parsing lives on the enum's companion.
enum class Category(val gstPercent: Int) {
    STAPLES(5),
    DAIRY(5),
    SNACKS(12),
    HOUSEHOLD(18);

    companion object {
        fun parse(raw: String): Category =
            entries.firstOrNull { it.name.equals(raw.trim(), ignoreCase = true) }
                ?: error("unknown category: '$raw'")
    }
}

// Fragment of catalog/Catalog.kt
// Step 2: the constructor is private, so every Product goes through a validating factory.
class Product private constructor(val sku: String, name: String, val category: Category, pricePaise: Long) {

    // Step 3: a validating setter. 'field' is the backing field.
    var name: String = name.trim()
        set(value) {
            require(value.isNotBlank()) { "name must not be blank" }
            field = value.trim()
        }

    // Readable everywhere, changed only through reprice().
    var pricePaise: Long = pricePaise
        private set

    // Explicit backing field: List to the world, MutableList inside the class.
    val priceHistory: List<Long>
        field = mutableListOf(pricePaise)

    // Computed on every read: no field at all.
    val shelfPricePaise: Long
        get() = pricePaise + pricePaise * category.gstPercent / 100

    init {
        require(sku.matches(SKU_FORMAT)) { "bad SKU: $sku" }
        require(pricePaise > 0) { "price must be positive, was $pricePaise" }
    }

    fun reprice(newPaise: Long) {
        require(newPaise > 0) { "price must be positive, was $newPaise" }
        pricePaise = newPaise
        priceHistory += newPaise
    }

    override fun toString() = "$sku $name [${category.name.lowercase()}] ₹${shelfPricePaise / 100}"

// Fragment of catalog/Catalog.kt
    // Step 4: the factory and the format rule live in the companion, like Java statics.
    companion object {
        private val SKU_FORMAT = Regex("SHW-\\d{4}")

        fun fromCsv(line: String): Product {
            val parts = line.split(',').map { it.trim() }
            require(parts.size == 4) { "expected sku,name,category,price but got: $line" }
            return Product(parts[0], parts[1], Category.parse(parts[2]), parts[3].toLong())
        }
    }
}

// Fragment of catalog/Catalog.kt
fun main() {
    val feed = listOf(
        "SHW-1001, Toor Dal 1kg, staples, 16500",
        "SHW-1002, Masala Chips 150g, SNACKS, 3000",
        "SHW-1003, Floor Cleaner 1L, household, 22000",
    )
    val products = feed.map { Product.fromCsv(it) }
    for (product in products) println(product)
    // -> SHW-1001 Toor Dal 1kg [staples] ₹173
    // -> SHW-1002 Masala Chips 150g [snacks] ₹33
    // -> SHW-1003 Floor Cleaner 1L [household] ₹259

    val dal = products.first()
    dal.reprice(15_900)
    dal.name = "  Toor Dal (Arhar) 1kg "
    println(dal) // -> SHW-1001 Toor Dal (Arhar) 1kg [staples] ₹166
    println(dal.priceHistory) // -> [16500, 15900]
    // dal.pricePaise = 1  // error: cannot access 'pricePaise': it is private in 'com.shelfwise.part03.catalog.Product'.

    try {
        Product.fromCsv("SHW-12, Paneer 200g, dairy, 9500")
    } catch (e: IllegalArgumentException) {
        println(e.message) // -> bad SKU: SHW-12
    }
    try {
        Product.fromCsv("SHW-1004, Cricket Bat, toys, 99900")
    } catch (e: IllegalStateException) {
        println(e.message) // -> unknown category: 'toys'
    }
}

open class Shelf(val code: String) {
    init {
        // Calling an open member from a constructor: the subclass isn't initialised yet.
        println("registering ${describe()}")
    }

    open fun describe(): String = "shelf $code"
}

class ChilledShelf(code: String, val celsius: Int) : Shelf(code) {
    // A non-null String, which is still null while Shelf's init block runs.
    val label: String = "chilled at $celsius°C"

    override fun describe(): String = "$code: $label"
}

fun main() {
    val shelf = ChilledShelf("D-04", celsius = 4)
    // -> registering D-04: null
    println(shelf.describe()) // -> D-04: chilled at 4°C
}