First Yard: Learning the Basics of Kotlin
-------------------------------------------

_01 Getting Started with Kotlin
__01-1 Background of Kotlin's birth
__01-2 Building a Practice Environment
__01-3 Starting a Kotlin Project
__Chapter 01 Final Problem

_02 Variables, data types, and operators
__02-1 Kotlin package
__02-2 Variables and data types
__02-3 Checking and converting data types
__02-4 Kotlin Operators
Chapter __02 Final Problem

_03 Functions and Functional Programming
__03-1 Declare and call a function
__03-2 Functional Programming
__03-3 Higher-order functions and lambda expressions
__03-4 Learn about higher-order functions and lambda expressions
__03-5 Learning about various functions in Kotlin
__03-6 Scope of functions and variables
Chapter 3 Final Problems

_04 Program flow control
__04-1 Conditional statement
__04-2 loop
__04-3 Stopping and returning the flow
Chapter __04 Final Problem

----------------------------------------------
Second Yard Object-Oriented Programming
----------------------------------------------

_05 Classes and Objects
__05-1 Definition of classes and objects
__05-2 constructor
__05-3 Inheritance and Polymorphism
__05-4 References to super and this
__05-5 Information Hiding Encapsulation
__05-6 Class-to-class relationship
Chapter __05 Final Problem

_06 Properties and Initialization
__06-1 Property Access
__06-2 Lazy Initialization and Delegation
__06-3 Static variables and companion objects
Chapter 6 Final Problems

_07 Various classes and interfaces
__07-1 Abstract classes and interfaces
__07-2 Data classes and other classes
__07-3 Operator Overloading
Chapter 7 Final Problems

------------------------------------------------------------
Third Yard: Utilizing the Kotlin Standard Library
------------------------------------------------------------

_08 Generics and Arrays
__08-1 Handling Generics
__08-2 Handling Arrays
__08-3 Handling strings
Chapter 8 Final Problems

_09 Collection
__09-1 Structure and Basics of the Collection
__09-2 Using List
__09-3 Using Sets and Maps
Extension functions for the __09-4 collection
__09-5 Using the sequence
Chapter 9 Final Problems

_10 Standard functions and file input/output
__10-1 Kotlin standard functions
__10-2 Lambda Expressions and DSL
__10-3 File Input/Output
__Chapter 10 Final Problems

_11 Coroutines and Concurrent Programming
__11-1 Concurrent Programming
__11-2 Coroutine Concept and Usage
__11-3 Controlling coroutine behavior
__11-4 Understanding the Shared Data Problem
Chapter 11 Final Problems

------------------------------------------------------
Fourth Yard Android App Development and Application
------------------------------------------------------

_12 Android App Development and Kotlin
__12-1 Preparing the development environment
__12-2 Understanding Android Components
__12-3 Learn Android Coding Rules
__Chapter 12 Final Problems

_13 Kotlin Android Extension
__13-1 View binding
__13-2 Creating a RecyclerView Mini Project
__13-3 Other extensions and communication objects
__13-4 Android UI Programming
Chapter 13 Final Problems

_14 Anko Extension Utilization
__14-1 Anko Library
__14-2 Creating a layout using DSL
__14-3 Creating a login processing mini-project
Chapter 14 Final Problems

__Find

“Will you be swept away? Will you climb aboard?”
An introductory guide to Kotlin from Hwang Young-deok, an Android developer with 10 years of experience in both practical and educational settings!
Get swept away or get on board.
This is a concern for developers facing Kotlin these days.
The author, who has worked as an Android developer for 10 years, also started from the same concerns.
But after building a commercial app with Kotlin myself, I was convinced.
"Kotlin is the answer now!" Since then, I have become a Kotlin evangelist and, with the single-minded belief that "I hope others don't have to go through the same difficulties I did," I personally educate both junior and senior developers both online and offline.
Another strength of the author is that he understands the minds of Kotlin beginners better than anyone else.
Concept explanations that could easily become boring are made more interesting with analogies and simulation examples, and the 285 carefully selected examples are designed to help you learn grammar and functions by practicing them step by step.
They say even beads need to be strung to be considered precious.
Since it covers how to use Android, it's Kotlin.
This one book is enough.

“Seeing once is better than hearing a hundred times!”
Thorough and detailed training with 285 carefully selected practice examples!
Even if you just blink and look at someone else's code a hundred times, it's not as good as trying to code it yourself.
The author, who has experienced all sorts of things in practice, has systematically organized 285 practical examples to help readers master Kotlin as quickly as possible, like a staircase leading to the top.
Readers can learn the entire process through hands-on experience, not just with their eyes, including the basic grammar of Kotlin and its application to Android, as well as grammar traps that are easy to make mistakes even for those familiar with programming, grammar elements that require consideration of memory, and even how to convert Kotlin to Java.

“I’m still not good at Java…”
96 illustrations and diagrams to solidify your understanding of the basic concepts!
The class is a new family, the interface is a coffee maker, and the access control is a car and a thief! The author, who emphasizes visual education, personally drew all the diagrams and illustrations in the book.
Even if you are weak in Java or have no development experience, it is no problem.
If you grasp the concepts thoroughly, your foundation in Kotlin will become stronger.
The basis is direction.
If you lay a good foundation, you can go on the right path without getting lost.
Even if it's a little slow, just believe and follow.
Code explanations actively use diagrams rather than text.
No matter how complex the code is, if you follow the arrows, brackets, squares, and other shapes drawn by the author, you will be able to understand it clearly without getting confused.
You will feel relieved every time you feel the author's kindness and clarity in the text and code.
“I made a good choice choosing this book.”

“Kotlin has been adopted by Google as the official language for Android!”
Meet the latest version 1.3!
Slack, Evernote, Reddit, Trello, Expedia, Netflix, WordPress, Twitter, Airbnb, and WeChat all have one thing in common.
The point is that it is a global service developed entirely in Kotlin.
Kotlin, adopted by Google as the official language for Android, has become an irreversible trend and is evolving rapidly.
For readers who want to keep up with the pace of the world, this book contains the latest Kotlin syntax.
You can experience a more complete Kotlin, including null checks that solve Java's chronic null pointer error, coroutines that enable concurrent programming, and extension functions that make it easy to extend class functionality.

“All the exercises in the book are free!”
Available on the Aegis Publishing website and GitHub
The correct answer code for all exercises in the book is provided in the author's GitHub and the data room of the Aegis Publishing website.
You can increase your learning effectiveness by practicing the book's examples and comparing them with the code written by the author himself.

- Author's GitHub: https://github.com/acaroom/kotlin
- Easy Publishing Data Room: https://easyspub.co.kr → [Data Room] (Membership required)