Kotlin Access Modifiers Classes

snippet.kt

// final public class (default)
class A

// final private class (only visible in the file)
private class B

// final internal class (only visible in the module)
internal class C

// abstract public class
abstract class D

// final public class, private constructor
class E private constructor(val a: Int)

// sub-classable public class
open class F {
  
  private val a = 1           // private
  protected open val b = 2    // overridable protected
  internal val c = 3          // non-overridable, only visible in the module    
  val d = 4                   // non-overridable public (default)

  // final public method (default)
  fun xyz() { ... }
  
  // overridable public method
  open fun foo() { ... }
  
  // final protected method
  protected fun baz() { ... }
  
  // overridable protected method
  open protected fun bar() { ... }
  
  // private method
  private fun qux() { ... }
}

// final public subclass
class F1: F() {
  // a is not visible
  final override val b = 42     // locked override (protected)
  // c and d are visible
  
  final override foo() { ... }  // final override
  override bar() { ... }        // override (protected)
}

// sub-classable public subclass 
open class F2: F() {
  override public b = 43        // override, public promoted 
  override public bar() { ... } // override, public promoted 
}

// access-modifiers are accepted into the primary constructor
open class G(private val a: Int, protected open val b: Int, 
             internal val c: Int, val d: Int)