Learn Kotlin Programming: A comprehensive guide to OOP, functions, concurrency, and coroutines in Kotlin 1.3, 2nd Edition

Cover
Title Page
Copyright and Credits
About Packt
Contributors
Table of Contents
Preface
Section 1: Fundamental Concepts in Kotlin
Chapter 1: Getting Started with Kotlin
	Technical requirements
	Using the command line to compile and run Kotlin code
	Kotlin runtime
	The REPL
	Kotlin for scripting
	Kotlin with Gradle
	Kotlin with Maven
	IntelliJ and Kotlin
	Eclipse and Kotlin
	Mixing Kotlin and Java in a project
	Summary
Chapter 2: Kotlin Basics
	val and var
	Type inference
	Basic types in Kotlin
		Numbers
		Unsigned integers
		Booleans
		Chars
		Strings
		Arrays
	Comments
	Packages
	Imports
		Wildcard imports
		Import renaming
	String templates
	Ranges
	Loops
	Exception handling
	Instantiating classes
	Referential equality and structural equality
	This expression
		Scope
	Visibility modifiers
		Private
		Protected
		Internal
	Control flow as expressions
	The null syntax
		Smart casts
		Explicit casting
	The when expression
		When (value)
			The when without argument
		Function return
	Type hierarchy
	Code contracts
		Contracts API
		Contracts on a function return value
		Contracts on method invocation
		Limitations
	Summary
Chapter 3: Object-Oriented Programming in Kotlin
	Classes
		Access levels
		Nested classes
		Data classes
		Inline classes
		Enum classes
		Static methods and companion objects
	Interfaces
	Inheritance
	Visibility modifiers
	Abstract classes
	Interface or abstract classes
	Polymorphism
	Overriding rules
	Inheritance versus composition
	Class delegation
	Sealed classes
	Summary
Section 2: Practical Concepts in Kotlin
Chapter 4: Functions in Kotlin
	Defining functions
	Single expression functions
	Member functions
	Local functions
	Top-level functions
	Named parameters
	Default parameters
	Extension functions
		Extension function precedence
		Extension functions on null values
		Member extension functions
		Overriding member extension functions
		Companion object extensions
		Multiple return values
		Infix functions
	Operators
		Operator overloading
		Basic operators
		in/contains
		Get/set
		Invoke
		Comparison
		Assignment
		Java interop
	Function literals
	Tail recursive functions
	Varargs
		Spread operator
	Standard library functions
		Apply
		Let
		With
		Run
		Lazy
		Use
		Repeat
		Require/assert/check
	Generic functions
	Pure functions
	Java from Kotlin
		Getters and setters
		Single abstract methods
		Escaping Kotlin identifiers
		Java void methods
	Kotlin from Java
		Top-level functions
		Default parameters
		Object and static methods
		Erasure naming
		Checked exceptions
	Summary
Chapter 5: Higher-Order Functions and Functional Programming
	Higher-order functions
		Returning a function
		Assigning a function 
	Closures
	Anonymous functions
	Function references
		Top-level function references
		Member and extension function references
		Bound references
	Function-literal receivers
	Functions in the JVM
		Bytecode
	Function composition
	Inline functions
		Noinline
	Currying and partial application
		Currying in action
		Adding currying support
	Memoization
		Implementing memoization
	Type alias
	Either
		Fold
		Projection
		Further projection functions
	Custom DSLs
		Infix functions as keywords
		Using function receivers in a DSL
	Validation and error accumulation
	Summary
Chapter 6: Properties
	Why use properties?
	Overriding getters and setters
	Visibility
	Late initialization
	Delegated properties
	Lazy initializations
	Lateinit versus lazy
	Observables
	A non-null property delegate
	Properties or methods?
	Summary
Chapter 7: Null Safety, Reflection, and Annotations
	Nullable types
	Smart cast
	Safe null access
		Force operator
	Elvis operator
	Safe casting
	Optional
		Creating and returning an Optional
		Using an Optional
	Reflection
		KClass
		Instantiation using reflection
	Constructors
		Instantiation with callBy
	Objects and companions
	Useful KClass properties
	Reflective functions and properties
		Invoking a function reflectively
		Declared and undeclared
	Annotations
		Annotation parameters
	Standard annotations
		@JvmName
		@JvmStatic
		@Throws
		@JvmOverloads
	Runtime annotation discovery
	Summary
Chapter 8: Generics
	Parameterized functions
	Parameterized types
	Bounded polymorphism
		Upper bounds
			Multiple bounds
	Type variance
		Invariance
		Covariance
		Covariant return
		Contravariance
		Variance overview
	Nothing type
	Type projection
	Type erasure
	Type reification
	Recursive type bounds
	Algebraic data types
	Summary
Chapter 9: Data Classes
	Introduction to data classes
	Automatic creation of getters and setters
	The copy method
	toString out of the box
	The hashCode and equals methods generated for you
	Destructed declarations
	Destructing types
	Data class definition rules
	Limitations
	Summary
Chapter 10: Collections
	Class hierarchy
	Arrays
	Lists
	Maps
	Sets
	Read-only views
	Indexed access
	Sequences
	Summary
Chapter 11: Testing in Kotlin
	Getting started
	Choosing a spec
	Matchers
		String matchers
		Collection matchers
		Floating point matchers
			Expecting exceptions
		Combining matchers
		Custom matchers
	Inspectors
	Interceptors
		The test case interceptor
		The spec interceptor
	Project config
	Property testing
		Specifying a generator
			A custom generator
	Table-driven testing
		Testing non-deterministic code
	Tags, conditions, and config
		Config
		Conditions
		Tags
			One instance
		Resources
	Summary
Chapter 12: Microservices with Kotlin
	Definition
	Drawbacks
	Why microservices?
	Lagom
	Defining services
	Implementing a Lagom service
	Summary
Section 3: Advanced Concepts in Kotlin
Chapter 13: Concurrency
	Threads
		Blocking
			Creating a thread
			Stopping a thread
			Thread interrupts
			CPU-bound versus I/O-bound
	Deadlocks and livelocks
		The Dining Philosophers Problem
	Executors
	Race conditions
		Monitors
		Locks
			Read-write locks
		Semaphores
			he bounded buffer problem
		Concurrent collections
			ConcurrentHashMap
			A blocking queue
		Atomic variables
		CountDownLatch
		CyclicBarrier
		Non-blocking I/O and asynchronous programming
		Futures
	Summary
Chapter 14: Coroutines
	Suspending functions
	Coroutine builders
		Launch builder
		runBlocking Builder
	Structured concurrency
		Nested coroutines
		Parent-child relationship
	Jobs
		Cancellation
		Join
		Job state
	Context and scope
		Global scope
	Cancellation and failure
		Cancellation or failure in a parent
		Failure in a child coroutine
		Supervisor scope
	Async
	Coroutine dispatchers
		Dispatcher inheritance
		Wrapping Java executors
		With context
	Error handling
	Summary 
Chapter 15: Application of Coroutines
	Channels
		Rendezvous channels
		Closing a channel
		Producers
		Conflated channels
		 Ticker channels
	select expression
		Using select for channels
		Using select for deferred
	Debugging coroutines
	Coroutines in action
		 Concurrent HTTP requests
		Blocking IO with coroutines
		Using callbacks with coroutines
	Summary
Chapter 16: Kotlin Serialization
	Setup 
	Json serialization and deserialization
	How it works
	Protobuf serialization and deserialization
	Annotations
	Rules
	Summary
Other Books You May Enjoy
Index