[PDF] [PDF] Kotlin - RIP Tutorial Kotlin is a statically-typed

View - Download [PDF] Kotlin - RIP Tutorial

Previous PDF

Next PDF

Kotlin

#kotlin

Table of Contents

About1

Chapter 1: Getting started with Kotlin2

Remarks2

Compiling Kotlin2

Versions2

Examples3

Hello World3

Hello World using an Object Declaration3

Hello World using a Companion Object4

Main methods using varargs5

Compile and Run Kotlin Code in Command Line5

Reading input from Command Line5

Chapter 2: Annotations7

Examples7

Declaring an annotation7

Meta-annotations7

Chapter 3: Arrays9

Examples9

Generic Arrays9

Arrays of Primitives9

Extensions10

Iterate Array10

Create an array10

Create an array using a closure10

Create an uninitialized array11

Chapter 4: Basic Lambdas12

Syntax12

Remarks12

Examples13

Lambda as parameter to filter function13

Lambda passed as a variable13

Lambda for benchmarking a function call13

Chapter 5: Basics of Kotlin14

Introduction14

Remarks14

Examples14

Basic examples14

Chapter 6: Class Delegation16

Introduction16

Examples16

Delegate a method to another class16

Chapter 7: Class Inheritance17

Introduction17

Syntax17

Parameters17

Examples17

Basics: the 'open' keyword17

Inheriting fields from a class18

Defining the base class:18

Defining the derived class:18

Using the subclass:18

Inheriting methods from a class18

Defining the base class:18

Defining the derived class:18

The Ninja has access to all of the methods in Person18

Overriding properties and methods19

Overriding properties (both read-only and mutable):19

Overriding methods:19

Chapter 8: Collections20

Introduction20

Syntax20

Examples20

Using list20

Using map20

Using set20

Chapter 9: Conditional Statements21

Remarks21

Examples21

Standard if-statement21

If-statement as an expression21

When-statement instead of if-else-if chains22

When-statement argument matching22

When-statement as expression23

When-statement with enums23

Chapter 10: Configuring Kotlin build25

Examples25

Gradle configuration25

Targeting JVM25

Targeting Android25

Targeting JS25

Using Android Studio26

Install the plugin26

Configure a project26

Converting Java26

Migrating from Gradle using Groovy script to Kotlin script27

Chapter 11: coroutines29

Introduction29

Examples29

Simple coroutine which delay's 1 second but not blocks29

Chapter 12: Delegated properties30

Introduction30

Examples30

Lazy initialization30

Observable properties30

Map-backed properties30

Custom delegation30

Delegate Can be used as a layer to reduce boilerplate31

Chapter 13: DSL Building33

Introduction33

Examples33

Infix approach to build DSL33

Overriding invoke method to build DSL33

Using operators with lambdas33

Using extensions with lambdas34

Chapter 14: Enum35

Remarks35

Examples35

Initialization35

Functions and Properties in enums35

Simple enum36

Mutability36

Chapter 15: Exceptions37

Examples37

Catching exception with try-catch-finally37

Chapter 16: Extension Methods38

Syntax38

Remarks38

Examples38

Top-Level Extensions38

Potential Pitfall: Extensions are Resolved Statically38 Sample extending long to render a human readable string39

Sample extending Java 7+ Path class39

Using extension functions to improve readability39 Sample extending Java 8 Temporal classes to render an ISO formatted string40 Extension functions to Companion Objects (appearance of Static functions)40

Lazy extension property workaround41

Extensions for easier reference View from code41

Extensions41

Usage42

Chapter 17: Functions43

Syntax43

Parameters43

Examples43

Functions Taking Other Functions43

Lambda Functions44

Function References44

Basic Functions46

Shorthand Functions46

Inline Functions46

Operator functions47

Chapter 18: Generics48

Introduction48

Syntax48

Parameters48

Remarks48

Implied Upper Bound is Nullable48

Examples49

Declaration-site variance49

Use-site variance49

Chapter 19: Idioms51

Examples51

Creating DTOs (POJOs/POCOs)51

Filtering a list51

Delegate to a class without providing it in the public constructor51

Serializable and serialVersionUid in Kotlin52

Fluent methods in Kotlin52

Use let or also to simplify working with nullable objects53 Use apply to initialize objects or to achieve method chaining53

Chapter 20: Interfaces55

Remarks55

Examples55

Basic Interface55

Interface with default implementations55

Properties55

Multiple implementations56

Properties in Interfaces56

Conflicts when Implementing Multiple Interfaces with Default Implementations57 super keyword57

Chapter 21: Java 8 Stream Equivalents59

Introduction59

Remarks59

About laziness59

Why are there no Types?!?59

Reusing Streams60

See also:60

Examples61

Accumulate names in a List61

Convert elements to strings and concatenate them, separated by commas61

Compute sum of salaries of employee61

Group employees by department61

Compute sum of salaries by department61

Partition students into passing and failing62

Names of male members62

Group names of members in roster by gender62

Filter a list to another list62

Finding shortest string a list62

Different Kinds of Streams #2 - lazily using first item if exists63 Different Kinds of Streams #3 - iterate a range of Integers63 Different Kinds of Streams #4 - iterate an array, map the values, calculate the average63 Different Kinds of Streams #5 - lazily iterate a list of strings, map the values, convert 63 Different Kinds of Streams #6 - lazily iterate a stream of Ints, map the values, print res64 Different Kinds of Streams #7 - lazily iterate Doubles, map to Int, map to String, print e64 Counting items in a list after filter is applied64 How streams work - filter, upper case, then sort a list64 Different Kinds of Streams #1 - eager using first item if it exists65 Collect example #5 - find people of legal age, output formatted string65 Collect example #6 - group people by age, print age and names together66 Collect example #7a - Map names, join together with delimiter67 Collect example #7b - Collect with SummarizingInt67

Chapter 22: JUnit69

Examples69

Rules69

Chapter 23: Kotlin Android Extensions70

Introduction70

Examples70

Configuration70

Using Views70

Product flavors71

Painfull listener for getting notice, when the view is completely drawn now is so simple a72

Chapter 24: Kotlin Caveats73

Examples73

Calling a toString() on a nullable type73

Chapter 25: Kotlin for Java Developers74

Introduction74

Examples74

Declaring Variables74

Quick Facts74

Equality & Identity75

IF, TRY and others are expressions, not statements75

Chapter 26: logging in kotlin76

Remarks76

Examples76

kotlin.logging76

Chapter 27: Loops in Kotlin77

Remarks77

Examples77

Repeat an action x times77

Looping over iterables77

While Loops78

Break and continue78

Iterating over a Map in kotlin78

Recursion79

Functional constructs for iteration79

Chapter 28: Null Safety80

Examples80

Nullable and Non-Nullable types80

Safe call operator80

Idiom: calling multiple methods on the same, null-checked object80

Smart casts81

Eliminate nulls from an Iterable and array81

Null Coalescing / Elvis Operator81

Assertion82

Elvis Operator (?:)82

Chapter 29: Ranges83

Introduction83

Examples83

Integral Type Ranges83

downTo() function83 step() function83 until function83

Chapter 30: RecyclerView in Kotlin84

Introduction84

Examples84

Main class and Adapter84

Chapter 31: Reflection86

Introduction86

Remarks86

Examples86

Referencing a class86

Referencing a function86

Inter-operating with Java reflection86

Getting values of all properties of a class87

Setting values of all properties of a class87

Chapter 32: Regex90

Examples90

Idioms for Regex Matching in When Expression90

Using immutable locals:90

Using anonymous temporaries:90

Using the visitor pattern:90

Introduction to regular expressions in Kotlin91

The RegEx class91

Null safety with regular expressions91

Raw strings in regex patterns92

find(input: CharSequence, startIndex: Int): MatchResult?92 findAll(input: CharSequence, startIndex: Int): Sequence92 matchEntire(input: CharSequence): MatchResult?93 matches(input: CharSequence): Boolean93 containsMatchIn(input: CharSequence): Boolean93 split(input: CharSequence, limit: Int): List93 replace(input: CharSequence, replacement: String): String94

Chapter 33: Singleton objects95

Introduction95

Examples95

Use as repalcement of static methods/fields of java95

Use as a singleton95

Chapter 34: Strings97

Examples97

Elements of String97

String Literals97

String Templates98

String Equality98

Chapter 35: Type aliases100

Introduction100

Syntax100

Remarks100

Examples100

Function type100

Generic type100

Chapter 36: Type-Safe Builders101

Remarks101

A typical structure of a type-safe builder101

Type-safe builders in Kotlin libraries101

Examples101

Type-safe tree structure builder101

Chapter 37: Vararg Parameters in Functions103

Syntax103

Examples103

Basics: Using the vararg keyword103

Spread Operator: Passing arrays into vararg functions103

Chapter 38: Visibility Modifiers105

Introduction105

Syntax105

Examples105

Code Sample105

Credits106

About You can share this PDF with anyone you feel could benefit from it, downloaded the latest version from: kotlin It is an unofficial and free Kotlin ebook created for educational purposes. All the content is extracted from Stack Overflow Documentation, which is written by many hardworking individuals at Stack Overflow. It is neither affiliated with Stack Overflow nor official Kotlin. The content is released under Creative Commons BY-SA, and the list of contributors to each chapter are provided in the credits section at the end of this book. Images may be copyright of their respective owners unless otherwise specified. All trademarks and registered trademarks are the property of their respective company owners. Use the content presented in this book at your own risk; it is not guaranteed to be correct nor accurate, please send your feedback and corrections to info@zzzprojects.com https://riptutorial.com/1

Chapter 1: Getting started with Kotlin

Remarks

Kotlin is a statically-typed object-oriented programming language developed by JetBrains primarily targeting the JVM. Kotlin is developed with the goals of being quick to compile, backwards- compatible, very type safe, and 100% interoperable with Java. Kotlin is also developed with the goal of providing many of the features wanted by Java developers. Kotlin's standard compiler allows it to be compiled both into Java bytecode for the JVM and into JavaScript.

Compiling Kotlin

Kotlin has a standard IDE plugin for Eclipse and IntelliJ. Kotlin can also be compiled using Maven, using Ant, and using Gradle, or through the command line. It is worth noting in will output a java class file, in this case (Note the Kt appended to the class name). However if one was to run the class file using java will throw the following exception:

In order to run the resulting class file using Java, one must include the Kotlin runt-time jar file to

the current class path.

Versions

VersionRelease Date

1.0.02016-02-15

1.0.12016-03-16

1.0.22016-05-13

1.0.32016-06-30

1.0.42016-09-22

https://riptutorial.com/2

VersionRelease Date

1.0.52016-11-08

1.0.62016-12-27

1.1.02017-03-01

1.1.12017-03-14

1.1.22017-04-25

1.1.32017-06-23

Examples

Hello World

All Kotlin programs start at the function. Here is an example of a simple Kotlin "Hello World" program: Place the above code into a file named (this filename is entirely arbitrary) When targeting the JVM, the function will be compiled as a static method in a class with a name derived from the filename. In the above example, the main class to run would be To change the name of the class that contains top-level functions for a particular file, place the following annotation at the top of the file above the package statement: In this example, the main class to run would now be .

See also:

Package level functions including annotation.•

Annotation use-site targets•

Hello World using an Object Declaration

You can alternatively use an Object Declaration that contains the main function for a Kotlin program. https://riptutorial.com/3 The class name that you will run is the name of your object, in this case is . The advantage to this method over a top-level function is that the class name to run is more self- evident, and any other functions you add are scoped into the class . You then also have a singleton instance of to store state and do other work.

See also:

Static Methods including the annotation•

Hello World using a Companion Object

Similar to using an Object Declaration, you can define the function of a Kotlin program using a

Companion Object of a class.

The class name that you will run is the name of your class, in this case is . The advantage to this method over a top-level function is that the class name to run is more self- evident, and any other functions you add are scoped into the class . This is similar to the example, other than you are in control of instantiating any classes to do further work. A slight variation that instantiates the class to do the actual "hello": https://riptutorial.com/4

See also:

Static Methods including the @JvmStatic annotation•

Main methods using varargs

All of these main method styles can also be used with varargs:

Compile and Run Kotlin Code in Command Line

As java provide two different commands to compile and run Java code. Same as Kotlin also provide you different commands. to compile java files. to run java files. Same as to compile kotlin files to run kotlin files.

Reading input from Command Line

The arguments passed from the console can be received in the Kotlin program and it can be used as an input. You can pass N (1 2 3 and so on) numbers of arguments from the command prompt. A simple example of a command-line argument in Kotlin. https://riptutorial.com/5 Here, Enter two number from the command line to find the maximum number. Output :

For !! Operator Please check Null Safety.

Note: Above example compile and run on Intellij.

Read Getting started with Kotlin online: https://riptutorial.com/kotlin/topic/490/getting-started-with-

kotlin https://riptutorial.com/6

Chapter 2: Annotations

Examples

Declaring an annotation

Annotations are means of attaching metadata to code. To declare an annotation, put the annotation modifier in front of a class:

Annotations can have meta-anotations:

Annotations, like other classes, can have constructors: But unlike other classes, is limited to the following types: types that correspond to Java primitive types (Int, Long etc.);• strings• classes ( Foo:: class)• enums• other annotations• arrays of the types listed above•

Meta-annotations

When declaring an annotation, meta-info can be included using the following meta-annotations: : specifies the possible kinds of elements which can be annotated with the annotation (classes, functions, properties, expressions etc.)• specifies whether the annotation is stored in the compiled class files and whether it's visible through reflection at runtime (by default, both are true.)• allows using the same annotation on a single element multiple times.• specifies that the annotation is part of the public API and should be included in the class or method signature shown in the generated API documentation.•

Example:

https://riptutorial.com/7 Read Annotations online: https://riptutorial.com/kotlin/topic/4074/annotations https://riptutorial.com/8

Chapter 3: Arrays

Examples

Generic Arrays

Generic arrays in Kotlin are represented by .

To create an empty array, use factory function:

To create an array with given size and initial values, use the constructor:

Arrays have and functions:

Arrays of Primitives

These types do not inherit from to avoid boxing, however, they have the same attributes and methods.

Kotlin typeFactory functionJVM type

https://riptutorial.com/9

Extensions

is defined for , , , , , and always returns : , , ... return an item of the array returns null if index is out of bounds, otherwise an item of the array returns a of all elements , creates and returns a new array with sorted elements of current , sort the array in-place

Iterate Array

You can print the array elements using the loop same as the Java enhanced loop, but you need to change keyword from to .

You can also change data type in for loop.

Create an array

Create an array using a closure

https://riptutorial.com/10

Create an uninitialized array

The returned array will always have a nullable type. Arrays of non-nullable items can't be created uninitialized. Read Arrays online: https://riptutorial.com/kotlin/topic/5722/arrays https://riptutorial.com/11

Chapter 4: Basic Lambdas

Syntax

Explicit parameters:•

{ parameterName: ParameterType, otherParameterName: OtherParameterType -> anExpression() }•

Inferred parameters:•

val addition: (Int, Int) -> Int = { a, b -> a + b }•

Single parameter shorthand•

val square: (Int) -> Int = { it*it }•

Signature:•

() -> ResultType• (InputType) -> ResultType• (InputType1, InputType2) -> ResultType•

Remarks

Input type parameters can be left out when they can be left out when they can be inferred from the context. For example say you have a function on a class that takes a function: You can use this function by passing a lambda, and since the parameters are already specified in the function signature there's no need to re-declare them in the lambda expression: This also applies when you are assigning a lambda to a variable: https://riptutorial.com/12 When the lambda takes one parameter, and the type can be inferred from the context, you can refer to the parameter by .

Examples

Lambda as parameter to filter function

Lambda passed as a variable

Lambda for benchmarking a function call

quotesdbs_dbs17.pdfusesText_23

[PDF] learn kotlin free pdf

[PDF] learn kotlin or java first

[PDF] learn kotlin vs java

[PDF] learn kotlin without java

[PDF] learn latex on overleaf

[PDF] learn lua in 15

[PDF] learn lua pdf

[PDF] learn lua roblox 2020

[PDF] learn oop php

[PDF] learn oops concepts in php

[PDF] learn photoshop pdf free download ebook

[PDF] learn preposition in bengali

[PDF] learn programming languages

[PDF] learn python in 1 day pdf

[PDF] learn roblox lua online