Post on 21-Jan-2018
KOTLIN2010 - Work Started 2011 - Announced 2016 - 1.0 release 2017 - 1.1 release
Official Android First Class Language
Agenda
What is Kotlin ?
Kotlin for Android devs
Why Kotlin ? Syntax crash course
Features of Kotlin QnA
Hands-on Session
• Null references are controlled by the type system.
• No raw types
• Arrays in Kotlin are invariant
• Kotlin has proper function types, as opposed to Java’s SAM-conversions
• Use-site variance without wildcards
• Kotlin does not have checked exceptions
Kotlin fixes a series of issues that Java suffers
from
Checked exceptions Primitive types that are not classes
Static members Non-private fields
Wildcard-types
What Java has that Kotlin does not
OOP language with functional
aspects
Modern and powerful language
Focuses on safe concise and readable
code
Its a statically-typed programming language
What is Kotlin ?
First class tool support
Statically typed programming language for the JVM,
Android and the browser
What is Kotlin ?Its a statically-typed programming language
What we get by using Java 6/7 + Android -
• Inability to add methods in platform APIs , have to use Utils
• NO Lambdas , NO Streams • NPE - so many of them
What we needWe need modern and smart coding language
Why Kotlin ?
• Not Functional language • Combines OOP and Functional Programming features
• Open source • Targets JVM , Android and even JS
Why Kotlin ?
Kotlin has lots of advantages for #AndroiDev. By using #Kotlin, my code is simply better for it. - Annyce Davis
I love #Kotlin. It's a breath of fresh air in the #AndroidDev world - Donn Felker
At work we're just 100% on the #Kotlin train and yes, that includes #AndroidDev production code! - Huyen Tue Dao
I enjoy writing in #Kotlin because I don't have to use a lot of #AndroidDev 3rd party libraries - Dmytro Danylyk
#Kotlin enables more concise and understandable code without sacrificing performance or safety - Dan Lew
Variables and propertiesSyntax
val name: String ="John" //Immutable , its final
var name: String ="John" //Mutable
ex: name= "Johnny"
val name ="John" // Types are auto-inferred
val num: int =10 //Immediate assignment
var personList:List<String> = ArrayList() //Explicit type declaration
Syntax
Immutable“Anything which will not change is val”
Mutable“If value will be changed with time use var”
Rule of thumb
Modifiers - Class level
For members declared inside a class :
• Private - member is visible inside the class only. • Protected - member has the same rules as private but is also available in
subclasses. • Internal - any member inside the same module can see internal members • Public - any member who can see the class can see it’s public members.
Default visibility is public
Modifiers - Top level
For declarations declared inside at the top level:
• Private - declaration only visible in the same file. • Protected - not available as the top level is independent of any class
hierarchy. • Internal - declaration visible only in the same module • Public - declaration is visible everywhere
Default visibility is public
// Simple usage
val myValue = a
if (a < b) myValue = b
// As expression
val myValue = if ( a < b) a else b
// when replaces switch operator
when (x) {
1 -> print("First output")
2 -> print("Second output")
else -> {
print(" Nor 1 or 2 ") // This block :)
}
// for loop iterates with iterator
val list = listOf("Game of thrones","Breaking Bad","Gotham")
//while and do ..usual
while (x > 0) {
x--
}
do {
val y= someData()
} while( y!=100)
// Functions in Kotlin are declared using the fun keyword
fun sum (a: Int , b: Int) : Int {
return a + b
}
//or ..single line return
fun sum(a: Int , b: Int , c: Int) = a + b + c
//default values with functions
fun sum(a: Int , b: Int , c: Int , d: Int = 1) = a + b + c + d
Class - big picture
class Person(pName: String) { var name: String = "" var age: Int = -1
init { this.name = pName }
constructor(pName: String , pAge: Int) : this(pName) { this.age = pAge }
fun greet(): String { return "Hello $name" }
Class - big picture
class Person(pName: String) { var name: String = "" var age: Int = -1
init { this.name = pName }
constructor(pName: String , pAge: Int) : this(pName) { this.age = pAge }
fun greet(): String { return "Hello $name" }
// Instance , we call the constructor as if it were a //regular functionval person = Person()val me = Person("Adit")
// Kotlin - has no new keyword
Code// The full syntax for declaring a property is
private var age:Int =0get() = fieldset(value) { if(value>0) field = value}
internal fun sum(first: Int , second: Int): Int { return first + second}
Access modifier Keyword Name
Param name Param type
Return type
Code// Full syntaxinternal fun sum(first: Int , second: Int): Int { return first + second}
// Omit access modifierfun sum(first: Int , second: Int): Int { return first + second}
// Inline returnfun sum(first: Int , second: Int): Int = first + second
// Omit return typefun sum(first: Int , second: Int) = first + second
// As a typeval sum - { first : Int, second: Int -> first + second }
Higher order functions
• Functions which return a function or take a function as a parameter
• Used via Lambdas • Java 6 support
Null Safety
var a: String = "abc"a = null // compilation error
var b: String? = "abc"b = null // ok
// what about this ?val l = a.length // Promise no NPE crash
val l = b.length // error: b can be null
Null Safety
// You could explicitly check if b is null , and handle the options separatelyval l = if (b!= null) b.length else -1
// Or ...val length = b?.length
// Even better
val listWithNulls: List<String?> = listOf("A",null)for (item in listWithNulls) { item?.let { println(it)} // prints A ignores null
Nullability
• In Java, the NullPointerException is one of the biggest headache’s
• Kotlin , ‘null’ is part of the type system
• We can explicitly declare a property , with nullable value
• For each function, we can declare whether it returns a nullable value
• Goodbye, NullPointerException
Data classes
public class Movie { private String name; private String posterImgUrl; private float rating;
public Movie(String name, String imageUrl, float rating)
{ this.name = name; this.posterImgUrl = imageUrl; this.rating = rating; }
// Getters and setters// equals and hashCode// toString()
}
Data classes// Just use the keyword 'data' and see the magic
data class Movie(val name: String , val imgUrl:
String , val rating: Float)
val inception = Movie("Inception","http://inception.com/poster.jpg",4.2)
print(inception.name)print(inception.imgUrl)print(inception.rating)
// Pretty printprint(inception.toString())
// Copy objectval inceptionTwo = inception.copy(imgUrl= "http://imageUrl.com/inception2.png")
Fun tricks
fun evaluateObject(obj: Any): String { return when(obj){ is String -> "String it is , ahoy !!" is Int -> "Give me the 8 ball" else -> "Object is in space" } }
fun ImageView.loadUrl(url: String) { Glide.with(context).load(url).into(this)}
Extensions
public static boolean isTuesday(Date date) { return date.getDay() == 2;}
boolean tuesdayBool = DateUtils.isTuesday(date);
fun Date.isTuesday(): Boolean { return getDay() ==2}
val dateToCheck = Date()println(date.isTuesday())
Lambdas
myButton.setOnClickListener { navigateToDetail() }
fun apply(one: Int , two: Int , func: (Int, Int) -> Int): Int{ return func(one,two)}
println(apply(1, 2, { a, b -> a * b }))println(apply(1, 2, { a, b -> a * 2 - 3 * b }))
Higher order Functions
if (obj instanceOf MyType) { ((MyType)obj).getXValue();} else { // Oh no do more}
Smart Casting
if (obj is MyType) { obj.getXValue()} else {// Oh no do more}
… and More
• Visibility Modifiers • Companion Objects • Nested, Sealed Classes • Generics • Coroutines • Operator overloading • Exceptions • Annotations • Reflection • and more
… and Even More
• Infix extension methods • Interfaces • Interface Delegation • Property Delegation • Destructuring • Safe Singletons • Init blocks • Enums • Multiline Strings • Tail recursion
CODE
❤ Kotlin
Try Kotlin online https://goo.gl/z9Hhq6
https://fabiomsr.github.io/from-java-to-kotlin/