Elements of Kotlin

• Preface
  • Acknowledgments
• Introducing Kotlin
  • Why?
  • …And Why Not?
  • What You Need to Know
  • Look At All the Kotlins!
  • Getting Kotlin, Normally
  • Introducing the Klassbook
  • How This Book is Structured
• A Few “Hello, World!” Examples
  • Just the Statement
  • Wrapped in a Function
  • Wrapped in a Class
  • So, What Does This Do?
  • Using the Klassbook
  • Running These Snippets in an IDE
• Basic Types and Expressions
  • Basic Types and “Objectness”
  • Numbers
  • Boolean
  • Strings
  • Characters
  • A Quick Note About Equality
• Variables… Whether They Vary or Not
  • Declaring Variables
  • Declaring Read-Only Variables
  • Prefer val Over var
  • String Interpolation
  • More Operators
  • No Automatic Number Conversions
  • Hey, What About ?
• Functions
  • Functions with Parameters
  • Functions with Return Types
  • Local Variables
  • Fancier Functions
• Collections and Lambdas
  • Major Collection Types and Creation Functions
  • Basic Usage
  • Immutability and Collections
  • Introducing Lambda Expressions
  • Common Collection Operations
  • Varargs
  • Other JVM Collections
  • get() and [] Syntax
• If, When, and While
  • If
  • When
  • While
  • If/When As Expressions
  • Bustin’ Out
• Basic Classes
  • Basic Classes
  • Creating Instances of Classes
  • Packages
  • Common Contents
  • this
  • Constructors
  • Inheritance
• Comments and Documentation
  • Basic Comment Syntax
  • Introducing KDoc
• Properties
  • Initialization
  • Constants
  • Getting Down in the Weeds
• Visibility and Scope
  • Visibility
  • Scope
• Abstract Classes and Interfaces
  • The Objective: Contracts
  • Abstract Classes
  • Interfaces
  • Which Do You Use?
• Data Class
  • How You Declare It
  • What You Gain
  • What You Lose
  • Data Classes with Other Properties
• The object Keyword
  • Singletons
  • Companion Objects
  • Nested Objects
  • Object Expressions
• Nested Objects and Classes
  • Nested Objects
  • Nested Classes
  • Nested Interfaces and Abstract Classes
• Enums and Sealed Classes
  • Enums
  • Sealed Classes
• Generics
  • OK, What Are These For Again?
  • Instantiation with Generics
  • Applying Generics to Classes and Interfaces
  • Upper Bounds
  • Generics, WTF?
• Exceptions
  • Catching Exceptions
  • Raising Exceptions
  • Defining Exceptions
  • Checked vs. Unchecked Exceptions
• Annotations
  • Where Annotations Come From
  • Applying Annotations
  • Defining Annotations
• Nullability
  • Introducing Nullable Types
  • Expressions with Nullable Types
  • Nullable Types and Generics
  • Nullable Types and Casts
  • Objective: Minimize Nulls
• Scope Functions
  • let()
  • apply()
  • run()
  • with()
  • also()
  • use()
  • Summary
• Functional Programming
  • Your App Might Not Be Functional
  • Where Immutability Comes Into Play
  • Examples of Functional Kotlin
  • Function Types
  • Arrays, Collections,… And Sequences
• Extension Functions
  • The Case of the Utility Function
  • Monkeying Around
  • Declaring Extension Functions
  • Calling Extension Functions
  • The Limitations
• Java Interoperability
  • Recap of Interoperability
  • Kotlin Calling Java
  • Java Calling Kotlin
  • Decompiling Kotlin to Java
• Changes in Newer Kotlin Versions
  • Version 1.3
  • Version 1.4
• Custom Accessors
  • Defining Custom Accessors
  • Anti-Patterns
  • Alternative: Delegates
• Extension Properties
  • Recapping Extension Functions
  • Recapping Property Custom Accessors
  • Extension Properties = A Mashup
• Escaping Keywords
  • The Scenario: Mockito
  • The Problem: Keywords
  • The Solution: Backticks
• Escaped Method Names
  • The Scenario: JUnit Tests
  • The Problem: You Are Tired of CamelCase
  • The Solution: Backticks
• Property Delegates
  • A Refresher on lazy
  • What’s Really Going On
  • Other Stock Property Delegates
• Class Delegation
  • Playing Favorites
  • Manual Delegation
  • The Class Delegate Alternative
• Constants
  • Declaring a Constant
  • Why Bother, When We Have val?
  • Constant Type Limitations
• Abstract Properties
  • But, But, But… Why?
  • Abstract val
  • Abstract var
• Covariance in Generics
  • You Can’t Put That in That!
  • out Is a Direction
  • Declaration-Site and Use-Site Variance
• Contravariance in Generics
  • Declaration-Site and Use-Site Variance
• Anonymous Functions
  • The Problem: Return Types
  • The Solution: Anonymous Function Syntax
  • Constraints and Effects
• Local Functions
  • I Heard You Like Functions…
  • …So I Put a Function in Your Function
  • Funception
• Local Types
  • Scenario: Perils of Pair Programming
• Inline Functions
  • Macro History
  • Inline Functions: Like Macros
  • Inline Properties
• Inline Classes
  • What?
  • Why?
  • Alpha!
• Reified Type Parameters
  • Type Erasure (Other Than Via the Backspace Key)
  • Reified = Retained Type for Inline Functions
• noinline and crossinline
  • noinline: Keep the Lambda as an Object
  • crossinline: Allowing return
• Receivers in Function Types
  • What with() Looks Like
  • What apply() Looks Like
  • Use Case: DSL
• Renamed Imports
  • The Scenario: Observable
  • The Problem: Import Name Collisions
  • The Solution: import … as …
• Operator Overloading
  • What the #$@&%!?
  • The Concept of Operator Overloading
  • Example: Dividing a String
  • So. Many. Operators.
• Infix Functions
  • Postfix and Infix
  • The infix Keyword
  • Limitations
• Destructuring Declarations
  • The Components of a Class
  • OK, Why Would We Use This?
  • So, Why Does This Exist?
• Labeled Returns
  • Where return Goes By Default
  • Returning Just from a Lambda
  • Applying a Label
  • Is Any of This a Good Idea?
• Nothing
  • Nothing: It’s On the Bottom
  • Uses of Nothing
• Types of Keywords
  • Hard Keywords
  • Soft Keywords
  • Modifier Keywords
  • In General, Avoid Keywords

---

This book is licensed under the Creative Commons Attribution-ShareAlike 4.0 International license.