Share Description
In this course, you will learn :
- How Java and Kotlin differ.
- How to work with functions
- How to use collections, which you'll use extensively in Kotlin.
- Introduced to more advanced concepts such as lambdas, Kotlin fluency, and asynchronous programming.
- Apply what you've learned to create an Android application that communicates with a backend service.
Syllabus :
1. Hello Kotlin
- Reasons to Love Kotlin
- Why Should You Choose Kotlin?
- Taking Kotlin for a Ride
- Compile to Bytecode and Run
- Compiling to Other Targets
- Which Option to Choose?
2. Kotlin Essentials for the Java Eyes
- Less Typing
- Sensible Warnings
- Prefer val over var
- Improved Equality Check
- String Templates
- Raw Strings
- More Expressions, Fewer Statements
3. Working with Functions
- Creating Functions
- Default and Named Arguments
- vararg and Spread
- Destructuring
4. External Iteration and Argument Matching
- Range and Iteration
- Iterating over Arrays and Lists
- When It’s Time to Use when
5. Using Collections
- Flavors of Collections
- Using Pair and Triple
- Arrays of Objects and Primitives
- Using List
- Using Set
- Using Map
6. Type Safety to Save the Day
- Any and Nothing Classes
- Nullable References
- Type Checking and Casting
- Explicit Type Casting
- Generics: Variance and Constraints of Parametric Types
- Reified Type Parameters
7. Objects and Classes
- Objects and Singletons
- Creating Classes
- Companion Objects and Class Members
- Creating Generics Classes
- Data Classes
8. Class Hierarchies and Inheritance
- Creating Interfaces and Abstract Classes
- Nested and Inner Classes
- Inheritance
- Sealed Classes
- Creating and Using Enums
9. Extension Through Delegation
- When to Choose Delegation over Inheritance?
- Designing with Delegates
- Delegating to a Parameter
- Dealing with Method Collisions
- Caveats of Kotlin Delegation
- Delegating Variables and Properties
- Built-in Standard Delegates
10. Functional Programming with Lambdas
- The Functional Style
- Lambda Expressions
- Lambdas and Anonymous Functions
- Closures and Lexical Scoping
- Non-Local and Labeled return
- Inlining Functions with Lambdas
11. Internal Iteration and Lazy Evaluation
- External vs. Internal Iterators
- Internal Iterators
- Sequences for Lazy Evaluation
12. Fluency in Kotlin
- Overloading Operators
- Injecting Using Extension Functions and Properties
- Extending Functions
- Function Fluency with infix
- Fluency with Any Object
- Implicit Receivers
13. Creating Internal DSLs
- Types and Characteristics of DSLs
- Kotlin for Internal DSLs
- Challenges in Building for Fluency
- Type-Safe Builders
- Narrowing Access with Scope Control
14. Programming Recursion and Memoization
- The Power and Perils of Recursion
- Tail Call Optimization
- Memoization
- Applying Memoization to Dynamic Programming
15. Exploring Coroutines
- Coroutines and Concurrency
- Running Concurrently Using Coroutines
- Coroutine Context and Threads
- Debugging Coroutines
- async and await
- A Peek at Continuations
- Creating Infinite Sequences
16. Asynchronous Programming
- Programming Asynchronously
- Exception Handling
- Cancellations and Timeouts
17. Intermixing Java and Kotlin
- Joint Compilation
- Calling Java from Kotlin
- Calling Kotlin from Java
18. Unit Testing with Kotlin
- The Code Under Test
- Getting the Project Files
- Starting with a Canary Test
- Writing Empirical Tests
- Writing Data-Driven Tests
- Mocking Out Dependencies
- Testing Top-Level Functions
- Testing Coroutines and Asynchronous Calls
- Integrating with the Service
- Viewing the Code Coverage
- Taking the App for a Drive
19. Programming Spring Applications with Kotlin
- Creating a Starter Project
- Creating a Controller
- Creating an Entity Class
- Creating a Repository Interface
- Creating a Service
- Integrating the Service with Controller
- Taking It for a Ride
