Kotlin for Java Developers

Explore Kotlin's purpose and practical application by examining why it exists and watching a Java-to-Kotlin conversion to taste the language and its differences.

Explore Kotlin, a Java interoperable language from JetBrains designed for the JVM; learn its concise, safe, and flexible style, with support for Java integration, functional programming, and multiple idioms.

Analyze the Java text adventure game and its code structure as we prepare a Kotlin conversion, including console gameplay and locations and exits data.

Transforms a Java text adventure into Kotlin by converting location and game logic with data classes, extension functions, and null-safe file parsing; highlights delimiter changes and Kotlin concepts.

IntelliJ converts Java to Kotlin when you paste Java into a Kotlin file, illustrating Java–Kotlin interoperability, with the converter offering a starting point that may be verbose or require refinement.

Explore Kotlin's syntax differences from Java, inspect the Kotlin standard library, and compare variable declarations as you run a Hello World and experiment with the REPL.

Create and run your first Kotlin program 'Hello World' in IntelliJ, learning differences from Java and how kotlinc compiles .kt to .class for the JVM.

Explore the Kotlin standard library and its default imports, including kotlin and kotlin.io, and learn how they enable array and print line usage without explicit imports.

Learn how Kotlin uses type inference with val and var to declare immutable and mutable variables, handle initialization, and understand reassignment rules in a Java context.

Create type aliases in Kotlin to alias existing types and reduce typing, improving readability; alias strings like string builder to java.lang.stringbuilder, and use top-level declarations with imports for reuse.

Explore Kotlin vs. Java differences, including concise syntax with no semicolons and bracket access for collections. Learn about wrappers, soft keywords, the Kotlin string class, unchecked exceptions, and top-level functions.

Explore referential vs. structural equality in Kotlin, showing how the equals operator performs structural checks and triple equals handles referential identity, contrasted with Java's behavior.

Discover how Kotlin handles bitwise operators by spelling them out, and use the is operator for type checks with smart casting that eliminates explicit casts for verified types.

Learn how Kotlin string templates substitute variables and expressions with the dollar sign and braces, how to escape dollars, and how IntelliJ can generate a meaningful toString.

Master Kotlin raw strings, or triple quoted strings, to avoid escaping and preserve line breaks; trimMargin and templates help manage indentation and embed variables.

Explore the Kotlin read-eval-print loop (repl) in IntelliJ to quickly test expressions with ctrl+enter, import project definitions, and iterate code without compiling.

Set up a Kotlin project in IntelliJ and pursue practical exercises on foundational syntax, including val and var, referential and structural equality, any, smart casts, and triple quoted strings.

Explore Kotlin data types and arrays, and learn how Kotlin handles null references to prevent null pointer exceptions, emphasizing safety while acknowledging exceptions require effort.

Explore Kotlin's primitive types and how everything is a class. Learn that Kotlin does not auto widen numbers and how to convert to data types with conversion functions.

Learn how Kotlin treats arrays as a collections class, create and initialize them with arrayOf or Array constructors, and optimize with primitive arrays like IntArray for Java interop and performance.

Explore how Kotlin uses nullable types and the safe call operator to prevent null pointer exceptions, and learn to use the Elvis operator and safe casts for concise null handling.

Explore how to safely handle nullable values in Kotlin by using the safe-call operator, the not-null assertion, and the let function to conditionally invoke code.

Learn how Kotlin creates arrays of nulls with the array of nulls function, and how primitive versus object arrays handle nulls and initialization.

Kotlin practice exercises cover data types, nullability, and arrays, including declaring non-nullable floats, converting to nullable, creating short arrays, and initializing nullable int arrays with a lambda.

Explore object-oriented fundamentals in Kotlin by examining classes, functions, constructors, and extending Kotlin classes, implementing interfaces, overwriting functions, and mastering naming conventions and imports.

Explore Kotlin visibility modifiers—public, private, protected, and internal—for top-level items and class members, contrast with Java, understand module scope, and how Kotlin maps to the JVM.

Explore Kotlin class declarations, primary constructors, and property initialization with val or var, including initializer blocks, secondary constructors, and default parameter values to reduce boilerplate.

Kotlin classes expose properties with default getters and setters for public members, accessible via dot notation; private properties can't be accessed outside. Implement custom accessors with a backing field.

Introduce top-level constants to Kotlin and use data classes for state storage. Explore automatic toString, equals, hashCode, and copy in a car example, with primary constructor properties and immutable vals.

Explore how to declare and use Kotlin functions, including function syntax, return types, expression and block bodies, default values, named arguments, and vararg parameters, with practical examples.

Explore how Kotlin extension functions augment classes without subclassing, using a receiver type and this to add string utilities that IDEs can suggest as if part of the class.

Explore inline functions in Kotlin, showing how the function body is substituted at call sites, why lambdas benefit, how to declare with inline, and JVM inlining behavior.

Explore how inheritance works in Kotlin, including open vs final, abstract classes, overriding, and constructors, illustrated with a printer base class and subclass examples.

Explore Kotlin inheritance: how override implies open, enforce final, and how to use primary and secondary constructors with super calls, plus data class inheritance limitations.

Learn how Kotlin interfaces compare to Java: declare interfaces, extend them, and implement across classes. Explore properties in interfaces, abstract vs concrete, and absence of backing fields or constructors.

Explore how the Kotlin object keyword creates singletons, companion objects, and object expressions, and implement a company communications singleton that provides a tagline and copyright line.

In Kotlin for Java developers, master companion objects to simulate static members, access them without an instance, and implement factory patterns with private constructors.

Explains Kotlin object expressions as anonymous objects that implement interfaces, showing how to pass them to functions, access outer mutable variables, and create non-singleton instances.

Explore Kotlin enums by declaring an enum class for company departments, adding properties and a function, and noting the semicolon rule and use of when.

Master Kotlin imports across packages and modules by importing top-level functions, enums, and object declarations. Learn to manage module dependencies, use as aliases, and apply best practices for package structure.

Learn how Kotlin's internal modifier restricts visibility to the same module, compare it with private at the file level, and use IntelliJ's optimize imports to clean up unused imports.

Convert Java classes to Kotlin by practicing object-oriented concepts, mastering constructors and primary constructors, delegation to super, and using var/val, open classes, and Kotlin string templates for print descriptions.

Explore Kotlin object-oriented programming by building three bike classes, using a main function to print descriptions, and mastering default values, secondary constructors, and a companion object with available colors.

Explore loops, the if expression, and try/catch as expressions, and learn when as the replacement for switch in Kotlin for Java developers.

Master Kotlin for loops with ranges, including start-end, backward down to, steps, and until to exclude the end. Explore iterating arrays and strings, using labeled breaks for advanced control flow.

Explore how Kotlin's if acts as an expression that returns a value, replacing the ternary operator, with examples of using else branches and results in strings.

Kotlin's when expression replaces the Java switch with concise, exhaustive branches, supporting multiple values, ranges, expressions, and smart casting, including enum use.

Learn Kotlin ranges and for loops to print 5 to 5000 by 5, -500 to 0, and the first 15 Fibonacci numbers, using if or when expressions and labeled break/continue.

Explore Kotlin generics, collections, and lambda expressions, including contravariance and covariance, and learn how Kotlin adds convenient collection functions atop Java collections.

Explore Kotlin lambda expressions, their syntax and usage, practice with the run function, apply them to collections with the minBy function, and use member references and top-level functions.

Explore Kotlin lambdas with receivers using with and apply to write concise code, learn receiver objects, and master local and non-local returns with labels and nested apply patterns.

Explore Kotlin collections, including immutable and mutable lists, Java interop with Java collections and array lists, and converting between arrays and lists.

Explore Kotlin list operations, retrieve first and last elements, reverse, safely index with getOrNull, and use zip, union, and distinct to combine or deduplicate lists.

Explore Kotlin sets, including immutable and mutable variants, learn how plus and minus create new results while avoiding duplicates, and explore drop and average.

Explore Kotlin's collection functions beyond basics, including filter, map, all, any, count, find, group by, sorting, and sequences, applied to car data and maps with mutable and immutable examples.

Explore Kotlin sequences to optimize large collections by lazy evaluation and avoiding intermediate collections, using asSequence and terminal operations (including filter and map) for efficient processing.

Delve into Kotlin generics by exploring type parameters, compile-time type safety, and extension functions on lists, showing how generic usage reduces casting and clarifies code.

Explore Kotlin generics with constraints and upper bounds, using where clauses to limit types, handle nullable and non-nullable types, and understand runtime erasure and star projection.

Understand how reified type parameters overcome runtime type erasure in Kotlin by inline functions, enabling type checks and filtering elements by type.

Explore how covariance preserves subtyping in Kotlin generics using the out keyword and out positions. Compare immutable versus mutable collections and invariant vs covariant design to show safe typing.

Learn covariance and contravariance by building garden examples with roses and daffodils, showing how accepting superclasses or subclasses affects flower care implementations.

Explore use-site variance and type projection in Kotlin generics by covarying the copy cars function source, enabling copying Ford or car lists into a car list, contrasted with Java wildcards.

Practice Kotlin fundamentals by building a Person class, exploring data classes versus explicit components, and using maps, filters, and lambdas to manipulate data with variance concepts.

Explore Kotlin file I/O using Java I/O classes, highlighting what Kotlin adds to Java and how to write concise code; briefly examine walking the file tree with Kotlin extension functions.

Learn how Kotlin uses the JDK IO via extension functions to read text files with readLines, readText, and use, while safely closing streams with close or try with resources.

This lecture shows reading binary files in Kotlin with Java I/O, using DataInputStream and FileInputStream, and explains read bytes for managing resources with use.

Learn Kotlin file tree traversal with walk, walkTopDown, and sequences to print and filter Kotlin files by extension from the working directory.

Master Kotlin and Java interop by gradually converting Java to Kotlin, calling Java from Kotlin and Kotlin from Java, and guiding compiler behavior with annotations.

Explore calling Java from Kotlin and managing nullability with @Nullable and @NotNull annotations. See how Kotlin maps Java types to nullable, non-nullable, and platform types, with runtime checks.

Learn how Kotlin accesses Java via properties getters and setters, handles exceptions, uses varargs with spread, works with primitive arrays, and leverages static members, Object, and SAM interfaces with lambdas.

Learn how to call Kotlin from Java by configuring a project, calling top-level functions via the static class, extension functions, and handling property access with getters, setters, and JVM name.

Explore Kotlin to Java interoperability using annotations like @JvmStatic, @JvmField, and @JvmOverloads to call top-level functions, companion objects, and singletons from Java.

Practice solving Java–Kotlin interoperability issues with annotations, enabling property access, static versus instance calls, and overloads, while handling non-nullability and primitive array types.

Review the text adventure code from the course, and relate features back to Java so you can explain the code to others.

Review the converted text adventure app in kotlin for java developers, focusing on the location class, exits map, and central kotlin concepts like data class, init, and Elvis operators.

Recap the key differences between Kotlin and Java data types and outline core Kotlin concepts: classes, interfaces, inheritance, generics, collections, lambda expressions, and file IO, plus Java interoperability.