Kotlin For Android - Basics (part 1 of 7)

Download as PPTX, PDF

2 likes425 views

This document provides an overview of Kotlin for Android, covering fundamental concepts such as variables, types, functions, and classes. It explains syntax differences between Kotlin and Java, including the use of 'val' and 'var' for variable declarations, the concept of constant values, and string interpolation. The document also introduces the structure for defining classes and interfaces, including visibility modifiers and function implementation.

Software

Kotlin for Android
May 24, 2018
y/kotlin-workbook

Top Level Declarations
Classes, Interfaces, Functions and Properties
y/kotlin-workbook

● Everything is a type - there are no primitives
Types
BASIC SYNTAX
y/kotlin-workbook
Kotlin Java
Boolean boolean, Boolean
Int int, Integer
Same for char, byte, short, long, float and double
Any Object
Unit void
Nothing void
Array<Int> Integer[]
IntArray int[]
Same for BooleanArray, CharArray, ByteArray, ...

package & import
BASIC SYNTAX
package my.demo
import android.view.View
import android.view.View.VISIBLE
import my.demo.Contract.View as CView
y/kotlin-workbook

● val and var
● Strong compiler type inference
Variables
BASIC SYNTAX
y/kotlin-workbook

Variables
BASIC SYNTAX
// Java
final int a = 1;
int b = 2;
// Kotlin
val a: Int = 1
var b: Int = 2
y/kotlin-workbook

Variables
BASIC SYNTAX
// Java
final int a = 1;
int b = 2;
// Kotlin
val a = 1
var b = 2
y/kotlin-workbook

const
BASIC SYNTAX
y/kotlin-workbook
● Only for val
● Stricter than Java’s static
● Available only at top level and inside an object

const
BASIC SYNTAX
const val ONE = 1
const val FOO = "FOO"
const val FOO1 = "FOO" + ONE
y/kotlin-workbook
● Only for val
● Stricter than Java’s static
● Available only at top level and inside an object

● Native suport for multiline strings
● All Strings literals are templates
● Templates are evaluated at compile-time
● Faster than String.format()
Strings
BASIC SYNTAX
y/kotlin-workbook

const val W = "World"
"Hello $W!"
val map = mutableMapOf("foo" to "bar")
"foo is ${map["foo"]}"
Strings
BASIC SYNTAX
y/kotlin-workbook

val w = "World"
println("Hello $w!") // prints "Hello World!"
val map = mutableMapOf("foo" to "bar")
println("foo is ${map["foo"]}") // prints "foo is bar"
map["bar"] = "baz"
println("""
foo is ${map["foo"]}
bar is ${map["bar"]}
""")
Strings
BASIC SYNTAX
y/kotlin-workbook

println("$1 $bills") // "$1 $bills"
println("""$1 ${'$'}bills""") // "$1 $bills"
Strings
BASIC SYNTAX
y/kotlin-workbook

● Can be declared at top level
● Can be declared inside other functions
● Can take other functions as parameters
● Can return functions
functions
BASIC SYNTAX
y/kotlin-workbook

fun world(): String {
return "World"
}
functions
BASIC SYNTAX
y/kotlin-workbook

fun world(): String {
return "World"
}
fun world(): String = "World"
functions
BASIC SYNTAX
y/kotlin-workbook

fun world(): String {
return "World"
}
fun world(): String = "World"
fun world() = "World"
fun hello(who: String) = "Hello $who"
functions
BASIC SYNTAX
y/kotlin-workbook

● A single class, interface or object per file
● final is default modality
○ open and override keyword to declare extensibility
● public is default visibility
○ internal visibility instead of java default
● No new keyword
class & interface
BASIC SYNTAX
y/kotlin-workbook

interfaces
BASIC SYNTAX
interface Runnable {
fun run()
}
y/kotlin-workbook

interfaces
BASIC SYNTAX
interface Runnable {
fun run()
}
interface RepeatingRunnable : Runnable {
fun run(times: Int) {
(1..times).forEach { run() }
}
}
y/kotlin-workbook

classes
BASIC SYNTAX
y/kotlin-workbook
interface Runnable {
fun run()
}
interface RepeatingRunnable : Runnable {
fun run(times: Int) {
(1..times).forEach { run() }
}
}
open class Greeting : Runnable {
override fun run() = println("Hi!")
}

Questions?
Next Up: Constructors and Control Flow

Kotlin For Android - Basics (part 1 of 7)

1. Kotlin for Android May 24, 2018 y/kotlin-workbook

2. Top Level Declarations Classes, Interfaces, Functions and Properties y/kotlin-workbook

3. ● Everything is a type - there are no primitives Types BASIC SYNTAX y/kotlin-workbook Kotlin Java Boolean boolean, Boolean Int int, Integer Same for char, byte, short, long, float and double Any Object Unit void Nothing void Array<Int> Integer[] IntArray int[] Same for BooleanArray, CharArray, ByteArray, ...

4. package & import BASIC SYNTAX package my.demo import android.view.View import android.view.View.VISIBLE import my.demo.Contract.View as CView y/kotlin-workbook

5. ● val and var ● Strong compiler type inference Variables BASIC SYNTAX y/kotlin-workbook

6. Variables BASIC SYNTAX // Java final int a = 1; int b = 2; // Kotlin val a: Int = 1 var b: Int = 2 y/kotlin-workbook

7. Variables BASIC SYNTAX // Java final int a = 1; int b = 2; // Kotlin val a = 1 var b = 2 y/kotlin-workbook

8. const BASIC SYNTAX y/kotlin-workbook ● Only for val ● Stricter than Java’s static ● Available only at top level and inside an object

9. const BASIC SYNTAX const val ONE = 1 const val FOO = "FOO" const val FOO1 = "FOO" + ONE y/kotlin-workbook ● Only for val ● Stricter than Java’s static ● Available only at top level and inside an object

10. ● Native suport for multiline strings ● All Strings literals are templates ● Templates are evaluated at compile-time ● Faster than String.format() Strings BASIC SYNTAX y/kotlin-workbook

11. const val W = "World" "Hello $W!" val map = mutableMapOf("foo" to "bar") "foo is ${map["foo"]}" Strings BASIC SYNTAX y/kotlin-workbook

12. val w = "World" println("Hello $w!") // prints "Hello World!" val map = mutableMapOf("foo" to "bar") println("foo is ${map["foo"]}") // prints "foo is bar" map["bar"] = "baz" println(""" foo is ${map["foo"]} bar is ${map["bar"]} """) Strings BASIC SYNTAX y/kotlin-workbook

13. println("$1 $bills") // "$1 $bills" println("""$1 ${'$'}bills""") // "$1 $bills" Strings BASIC SYNTAX y/kotlin-workbook

14. ● Can be declared at top level ● Can be declared inside other functions ● Can take other functions as parameters ● Can return functions functions BASIC SYNTAX y/kotlin-workbook

15. fun world(): String { return "World" } functions BASIC SYNTAX y/kotlin-workbook

16. fun world(): String { return "World" } fun world(): String = "World" functions BASIC SYNTAX y/kotlin-workbook

17. fun world(): String { return "World" } fun world(): String = "World" fun world() = "World" fun hello(who: String) = "Hello $who" functions BASIC SYNTAX y/kotlin-workbook

18. ● A single class, interface or object per file ● final is default modality ○ open and override keyword to declare extensibility ● public is default visibility ○ internal visibility instead of java default ● No new keyword class & interface BASIC SYNTAX y/kotlin-workbook

19. interfaces BASIC SYNTAX interface Runnable { fun run() } y/kotlin-workbook

20. interfaces BASIC SYNTAX interface Runnable { fun run() } interface RepeatingRunnable : Runnable { fun run(times: Int) { (1..times).forEach { run() } } } y/kotlin-workbook

21. classes BASIC SYNTAX y/kotlin-workbook interface Runnable { fun run() } interface RepeatingRunnable : Runnable { fun run(times: Int) { (1..times).forEach { run() } } } open class Greeting : Runnable { override fun run() = println("Hi!") }

22. classes BASIC SYNTAX y/kotlin-workbook interface Runnable { fun run() } interface RepeatingRunnable : Runnable { fun run(times: Int) { (1..times).forEach { run() } } } open class Greeting : Runnable { override fun run() = println("Hi!") } class RepeatingGreeting : Greeting(), RepeatingRunnable RepeatingGreeting().run(3)

23. Questions? Next Up: Constructors and Control Flow

Editor's Notes

#4: Compiler will optimize your code to use primitives if possible Unit exists and can be passed Unit replaces void in functions’ return types Nothing doesn’t exist and is closer to Java’s void
#5: Word of caution about aliases think very hard if you are really improving readability First one: normal import Second one: static import Third one: alias import
#6: Val instead of final
#7: Compiler always knows the type the right-hand-side of an assignment operator so you can drop it from the left-hand-side Do it only for obvious types
#8: Compiler always knows the type the right-hand-side of an assignment operator so you can drop it from the left-hand-side Do it only for obvious types
#11: Note: This is mostly about templates
#12: First one: Only use const values, so the whole thing can be created at compile time String templates which only use const templates can be evaluated at compile time Second string: Will be evaluated at runtime and use a String concatenation (these use StringBuilder under the hood)
#13: Template Strings: Preserve whitespace
#14: “Normal” strings can be escaped with dollar signs Multiline: need to use ${} blocks. Fortunately you’ll really only need to do that with $ and “, but if you need to do that
#15: Replacement for Java’s methods
#16: Need to include return type or it is considered Unit
#17: Normal and expression bodies Can only do this if something evaluates to a single value (i.e. it is an expression)
#18: Don’t need to include the type because you have an expression function
#19: Can put as many classes as you want in a file. We only keep one Explain open and override in more detail Open goes on the class and overrideable functions Override == the annotation. It gets treated as a compile time error not to have this New keyword: classes start with capital letter by convention
#22: Explain open for classes
#23: Explain override for classes and interfaces Briefly touch on the () after Greeting - more next session ALMOST END OF SLIDES - NEXT SLIDE IS LAST - Q&A STARTS

Kotlin For Android - Basics (part 1 of 7)

More Related Content

What's hot (20)

Similar to Kotlin For Android - Basics (part 1 of 7) (20)

Recently uploaded (20)

Kotlin For Android - Basics (part 1 of 7)

Editor's Notes