While using kotlin, it summarizes differences from java and sample codes.
0. The main function does not have to be inside a class.
If the main function is defined without a class, a class is created with the file name and the main function is put into it.
1. All primitive types are classes.
Basic types are not very different from Java, but they are all in the form of classes.
2. At compile time, a check is made for the scope of the base type.
An error occurs when initializing a value beyond the maximum value, such as val a: Byte = 500.
You can prevent overflow for an initial wrong type.
3. Add fun to function definitions, val and var to variable definitions.
fun foo(a: Int): Int // fun function_name(parameter): return_type
Add val or var in front of a variable, where val means that does not change to value, and var means that changes to variable.
4. Using a for loop
Can be used in multiple styles.
5. if, when
You can use an if statement as a value, like val c = if (a == 5) "a is 5" else "a is not 5". In this case, there should always be an else.
You can think of using when instead of switch. Use else instead of default.
The values used in when are used from basic types to class objects,
Multiple values can be grouped into one item using ','.
6. Defining member variables
If the class name parameter is defined as val or var, it becomes a member variable. It is mainly used in "data class" types.
Member variables can be initialized with the passed parameters, and can also be initialized using the init block.
In the case of var variables, you can use lateinit to delay initialization (initialize them before use).
lateinit cannot be used on val variables. val is immutable and must be initialized at creation time.
7. Defining getters and setters
In Java, you need to define get~, set~ methods, but in kotlin, you can attach get(), set(value) under member variables.
Getters and setters are simply defined, and set and get are automatically called when values are assigned or used as if using variables.
8. Using Inheritance
A class in Kotlin is a final class in Java. not inherited
Kotlin's open class is Java's class. inheritance is possible
Functions that can be overridden are prefixed with "open". When override it, add "override" in front.
Abstract classes are defined using the "abstract" keyword.
9. Null Stability - 1
When defining a variable, add "?" to determine whether to use null.
var testName: String? = null
If you attach "!!" when using it, a null pointer exception occurs when it is a null value, as when using it in java.
If you use it with "?", it doesn't do anything if it is a null value.
dog.printName() // compile error
cat2.printName()
Both of them did a null check in the if statement, but one generated a compilation error and the other did not.
The difference is whether the value of the variable can be changed after the if statement.
If dog is a member variable and operates in multi-thread, it may change in another thread immediately after passing the if statement.
cat2 is a local variable that cannot be changed within the function. After checking for null, "." It is possible to use only
10. Null Stability - 2
dog?.let defines a block that operates only when dog is not null and accesses dog using "it".
The elvis operator "?:" simplifies the if statement.
11. data class
It is defined by attaching data in front of the class name. If the defined value is the same in the constructor parameter, true is returned during == operation.
Use "===" to check whether objects are the same.
The data class internally defines several methods such as copy and equals. (Recommended to convert and compare with java code)
12. Using Arrays
Returns an array whose values are set through arrayOf.
The value of the array can be changed (you can see what it means by comparing it to List).
There is also a way to define the number other than value setting, and it is possible to set an initial value like "IntArray(10) { index -> index }".
In the case of arrays related to numbers like Int type, frequently used operation functions such as sum and average are added.
13. List, MutableList
The main data storage types include a List with order, a Set without duplicate values, and a Map connected with a key.
These types cannot be changed in value, and if you want to change it, define it as a type with Mutable attached. (MutableList...)
14. Lambda expression
These days, when you look at development languages, you often see support for lambda expressions (c++, java, etc.).
It is a useful development method if you know and use it.
This expression is used when you want to access the created object's variable from another object and create the desired result.????
As I said, it is not easy to explain, but I recommend that you understand it by looking at several sample codes.
In the example code, { num -> list.contains(num) } is created as an internal object and its reference is passed to LambdaTest.
It's important to understand where lambda expressions act as inner objects.
15. Coroutines are not multi-threaded.
When I first saw it, I understood it as a multi-threaded concept because it said light concurrent work.
The operation is completely different because it is a concurrent operation that is performed without context switching.
When calling delay, which is used for coroutines, the control passes to scope management.
I think each coroutine will be called according to the delay time, but unlike multi-threading, the guarantee that it will be called is weak.
If the coroutine execution is short and a delay is called to move to scope management, you may get the desired result.
If coroutine execution is long, coroutines within the same scope are not guaranteed to be executed in time.
If you put sleep, other coroutines do not work until sleep ends.
It is used when asynchronous execution with short execution time is required.
