Please enable JavaScript.

Coggle requires JavaScript to display documents.

kotlin (Basic synctax (Functions (fun sum(a: Int, b: Int) : Int { return…

- - - - Constructors: class can has only a primary and one or more secondary
        
        Primary don't contain code and maybe has or no has keyword constructor, the code init can be place in init blocks
        
        If it has anotations or visibility modifiers, the constructor is required
        
        Secondary require keyword constructor, it delegate to ther constructor using the this keyword
      - Class members:
        
        Constructors and init blocks
        
        Functions
        
        Properties
        
        Nested and inner classes
        
        Object declarations
      - Inheritances: parent class using keyword open before class
        
        open class parent(age: Int)
        
        class child(age: Int) : parent(age)
        
        If child don't has primary constructor, the secondary constructor will init the age using the super keyword
      - Overriding
        
        Method in parent class and has keyword open before fun
        
        overriding function want to prohibit, set keyword final
        
        overriding properties: open place before val/var
        
        Can override val property with a var property, but no vice versa
      - Properties:
        
        Has default get/set method
        
        Custom get/set method using variable field
        
        Custom private method set/get to can not access it outside
      - Data classes using keyword data
        
        The class can not be abstract , open, sealed, inner
        
        The class extend other class, exclude other data class
        
        Auto generate method setter/getter
        
        Auto generate method hashCode, toString, equals with properties in primary constructor
        
        Allow destructuring declarations
        
        Allow copy object and can change one or some properties in object
      - Sealed class: using keyword sealed
        
        It is abstract class and have abstract member
        
        Can not init directly
        
        Has private constructor, can not has public constructor
        
        It has subclass which placed in same file, and sealed subclass has subclass can place in other file.
        
        The key benefit of it is using in the when expression
      - Nested classs:
        
        Define in the another class:
        Ex: class outer {
        class nested { // TODO }
        }
        
        It can not access members in outer class
        
        Inner class:
        
        Define in the another class same as nested class and using keyword inner
        
        It can access member in outer class
      - Enum classes:
        
        Use method valueOf to get value of item and values() to get all values of enum
        
        Can implement interface
        
        Can contain abstract method in it, and every item will override the abstract method
        
        Ex: enum class COLOR {
        RED, ORANGE, BLUE, YELLOW
        }
      - Object:
        
        Create object of anonymous class, interface
        
        Object declarations is a singleton
        
        Object in class
        
        Create object property or object function
        
        Anonymous object has type private, can call in another object
        
        Anonymous object has other type, properties or method in it, only use in the local of it
        
        Ex: val coordinates = object{
        int x: Int = 0
        int y: Int = 0
        }
        print("x = $coordinates.x and y = $coordinates.y")
        
        Object method
        Ex: private fun printCoordinates() = object { // TODO }
      - Type Aliases:
        
        Provide alternative name for exist type
        
        It define out of class
      - Inline class:
        
        Create inline class has target is safety for parameter, it wrapper around for type of parameter.
        
        The class have only one immutable parameter in constructor and properties, function, extend interface, cannot extends another class
        
        It don't have a init block
        
        In runtime, the inline class will represent to the underlying property
      - Delegate: using in case the class B implement interface C by another implementation C.
        Ex: - interface C
        
        class D: C
        
        class E: C
        
        class B : C by E -> class B use implementation C of class E
        
        Delegate propertise:
        
        lazy: the value gets computed only upon first access
        
        observable: listen and notify change value of property
        
        voteable: same observable, but it have a condition to change value of property
  - - - Infix:
        
        Must be member function or extension function
        
        Must have a single parameter, only one parameter
        
        Priority only higher than boolean operator such as ||, &&, is or in
        
        Using infix method to clear code, readable and near natural language
      - Using varargs parameter:
        
        May has only one varargs parameter in function
        
        Varargs parameter accept pass array , list data of type parameter
      - Inline functions:
        
        Using keyword inline before functions
        
        Can access with another member has public and protected modifier
        
        Help improve performance , eliminate the memory overhead, the complier will copied the function to the call site.
        
        Inline properties: it copied to the call site as same as inline function
      - High-order function:
        
        Allow using another function as a parameter
        Ex: val plus = {(a: Int, b: Int) -> a + b}
        fun plusNumber(calculator: (a: Int, b: Int) 0> Int) {
        plus(4,7)
        }
        
        Allow return a function:
        ex: fun plusNumber() : ((Int, Int) -> Int) {
        return ::plus
        }
  - - - Transformation:
        
        Mapping
        
        Zipping: zip and unzip
        
        Association
        
        Association:
        
        with: create a map which elements of original collection are key of map, and value produces from them
      - Aggregate: Fold and Reduce
        
        Fold need init value and can progress empty collection
        
        Reduce use first and second element to init and start progress, will throw exception if progress empty collection