Kotlin

Kotlin Programming Language
Tanikin Yeldos
1

Content
1. Why Kotlin?
2. Features of Kotlin
3. Benefits of using Kotlin
4. Efforts to use Kotlin
5. Kotlin integration scenarios to a project
6. Q&A
2

● Statically typed
● 100% Interoperable with Java
● Fast learning curve (way simpler than Scala)
● Good tooling in IDEs
● Concise
● Familiar syntax and environments
● Over hundreds of important language constructions
Why Kotlin ?
5

Properties (1)
7
fun typesExample() {
bigDecimal.add(projectName) /* Compile time Error */
}
Type inference
var projectName = "RoadLog"
val bigDecimal = BigDecimal.TEN

public class Person {
private String name;
private int age;
public Bar(String Name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String Name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
class Person(var name: String, var age: Int)
Properties (2)
8
Class in single line

Custom setter/getter
Properties (3)
class Money {
var amount = BigDecimal.ZERO
get() {
return if (field >= BigDecimal.ZERO) field else BigDecimal.ONE
}
set(value) {
field = value + BigDecimal.TEN
}
//Accessor will invoke automatically when you assign value
Money.amount = BigDecimal.valueOf(-200)
var amount = money.amount
9

Interoperable in properties
Properties (4)
10
val exampleJavaClass = ExampleJavaClass()
exampleJavaClass.value = BigDecimal.ONE
exampleJavaClass.currency = "EUR"
val currency = exampleJavaClass.currency
Project project= new Project("RoadLog", 4);
String name = project.getName();
project.setAge(5);
class Project(var name: String, var age: Int)

Functions (1)
Default parameters come in handy (optional arguments)
public void setManyParameters() {
setManyParameters("name");
}
fun setManyParameters(name: String= "name", age: Int = 18, weight: Int = 50) {
}
11
public void setManyParameters(String name, int age, int weight) {
// Do something
}
public void setManyParameters(String name, int age) {
setManyParameters(name, age, 50);
}
public void setManyParameters(String name) {
setManyParameters(name, 18);
}

Functions(2)
Order of parameters, not important
setManyParameters(age = 19)
fun setManyParameters(name: String= "name", age: Int = 18, weight: Int = 50) {
// Do something
}
12
setManyParameters(19)
Integer.parseInt(radix = 7, number = "100")

Lambda
Lambda as first class invoke just with round bracket, not apply, run, call etc.
13
fun getFilteredNumber(numbers: List<String>, prefix: String, predicate: (String, String) -> Boolean): List<String> {
return users.filter { predicate(it, prefix) }
}
public List<String> getFilteredNumber(List<String> numbers, String prefix, BiFunction<String, String, Boolean> predicate) {
return numbers.stream()
.filter(s -> predicate.apply(s, prefix))
.collect(Collectors.toList());
}

Functions (4)
Best way for naming test method
15
@Test
fun `shoudn't be empty when amount is valid`() {
// Check something
}
@Test
fun `should create billing info for groupage shipment`() {
// Check something
}

String in Kotlin
String templates are String literals that contain embedded expressions
16
public void printSum(int firstNumber, int secondNumber) {
println("sum of " + firstNumber+ " and " + secondNumber+ " is " + (firstNumber + secondNumber));
}
fun printSum(firstNumber: Int, secondNumber: Int): Unit {
println("sum of $firstNumber and $secondNumber is ${firstNumber + secondNumber}")
}

Singleton
Singleton in single line
17
public class SingletonJava {
private static SingletonJava instance = null;
private SingletonJava (){}
private synchronized static void createInstance() {
if (instance == null) {
instance = new SingletonJava ();
}
}
public static SingletonJava getInstance() {
if (instance == null) {
createInstance();
}
return instance;
}
}
object SingletonKotlin {}

Collections
Really read-only collections by default
18
val numbers = listOf("one", "two", "three", "four", "five")
print(numbers[2])
numbers.add(3) // compile time error
numbers[2] = "six" // compile time error
List<Object> numberList = new ArrayList<>();
// adding few values to the list in a few lines((
List<Object> unmodifiableList = Collections.unmodifiableList(numberList);
unmodifiableList.add("one"); // not errors((
val mutableCollection = mutableListOf("one", "two");
mutableCollection.add("three") // OK
mutableCollection[6] = "four" // OK
val numbersMap = mapOf(1 to "one", 2 to "two", 3 to "three")
numbersMap.put(4, "four") // compile time error
numbersMap[4] = "four" // compile time error

Operator overriding
Any operator can be overridden
19
if (amount < 0.b) {
throw IllegalArgumentException()
}
val amount = 1.b
if (amount in 1.b..100.b) { // in 1.b..100.b equivalent of 1 <= amount && amount <= 100
return amount + 1000.b
}
class Money(var amount: BigDecimal, var currency: String) {
operator fun plus(value: BigDecimal): Money {
return Money(amount + value, currency)
}
}

Type-safe builder
Great replacement for the builder
20
class Person(var name: String = "Jack", var age: Int = 21, val students: MutableList<Person> = ArrayList()) {
fun student(init: Person.() -> Unit) = Person().also {
it.init()
students.add(it)
}
}
fun person(init: Person.() -> Unit) = Person().apply { init() }
val teacher= person {
name = "Jack"
age = 75
student {
name = "John"
age = 10
}
student {
name = "Gaga"
age = 11
}
}

Type-safe builder
Great replacement for the builder
21
val teacher= person {
name = "Jack"
age = 75
student {
name = "John"
age = 10
}
student {
name = "Gaga"
age = 11
}
}
Person teacher= PersonBuilder.buider()
.withName("Jack")
.withAge(75)
.withStudents(Lists.of(PersonBuilder.buider()
.withName("John")
.withAge(10)
.build(),
PersonBuilder.buider()
.withName("Gaga")
.withAge(11)
.build()))
.build()

1. Legacy code can remain untouched
2. Development productivity increase
a. Less writing
b. Less code reading (we read more than write)
c. Less code for reviewing
3. Code-base grows, Kotlin is easy for monorepo(git pull, status etc)
4. More understandable and cleaner code
5. The language is less error-prone
6. Less code - cheaper support
7. Interesting for developers
8. Attractive for new candidates
Benefits for RoadLOG
What are the benefits we can get
22

Risks
Language support in the future
23

Efforts
The efforts that is required of us
26
● Add one dependency and one plugin to pom.xml
● Set up SonarQube
● Install the IDE plugin

Kotlin integration plan
27
● For tariff component only, at first time
● Parallel coexistence

What skipped
Don’t have enough time to tell
28
● Coroutines
● Improved @Deprecated in Kotlin
● with, apply, let, run methods
● Data classes
● Sealed classes
● Destructing declarations val (name, age) = getUserByName();
● Inline functions
● Elvis (name ?: "name is empty")
● Kotlin DSL(already can be used in Gradle, because it’s type safety unlike groovy)
● Range in for
● Improved “when” (switch in java )
● Smart casting you don’t need cast after checking by “is” (instanceof)
● Access modifier internal
● …and lot more

“if” like expression
try, when, if can be used as expression and return result
30
val max = if (firstValue > secondValue) {
println("choose firstValue")
firstValue
} else {
println("choose secondValue")
secondValue
}
return if (firstValue > secondValue) {
firstValue
} else {
secondValue
}

“when”
“switch” with range expression
31
val primeNumbers= listOf(1, 37, 73)
val x = 100
when (x) {
6, 700 -> print("== 6 or == 700")
in 1..10 -> print("x is in the range 1 to 10")
in primeNumbers-> print("best prime number")
!in 10..20 -> print("x is outside the range")
else -> print("none of the above")
}

Kotlin

More Related Content

What's hot (20)

Similar to Kotlin (20)

Recently uploaded (20)

Kotlin

Editor's Notes