Kotlin Language Features - A Java comparison

A Brief Language Overview
Ed Austin
ed@ryer.ru

Hello! Привет!
Developer
ed@ryer.ru
+44 7726 05 0000
+7 925 871 9411
I am Ed Austin Я Эд Остин
Презентация будет на английском

Disclaimer!
Liable to have mistakes!
Don’t hesitate to point them out!

Part 1 Some Background
What is Kotlin and how does it differ to Java?
1

What is in the Name?
Named after an Island off
the coast of St.
Petersburg*
*The second largest city in the Russian Federation and the home of JetBrains
© Ed Austin 2017

History of Kotlin?
2010: JetBrains started the Kotlin Project
2011: Public Announcement
2012: Open Sourced under Apache 2
2016: Release 1.0
2017: Release 1.1 Google announced first class language support
2018: Release 1.2
Release 2.0?? No indication but probably 2019+
._X = bug fixes e.g. 1.02
_.X = incremental, no major changes e.g. 1.1, 1.2
X.0 = major (may introduce major features, deprecate others) e.g. 2.0

What exactly is Kotlin?
Java-like with Clean abstractions,
concise syntax, and type safety.
Full Java interoperability,
significant tool chain from the start.
Fully open-source (Apache 2).
Sugared Java
Java++
Java on Steroids
Scala for idiots
The "PL/1" of our times
💣 Depending on your point of view the Language can be described in various ways!
Negative View Positive View
© Ed Austin 2017

What/Who influenced Kotlin?
😉 Disclaimer: I did ask Andrey Breslav (Language Creator at JB)
Josh Bloch
Grady Booch
Kent Beck
Erich Gamma
Martin Fowler
Groovy, Java, Scala…
Effective Java
OOD
TDD + Smalltalk stuff
GoF
OOD/UML
Smalltalk, Algol 60, Simula 67

Language Viewpoint
Imperative?
Functional?
Object Oriented?
From a purists point of view no, but
then again neither are Java or C++
So from a language classification viewpoint it can be viewed in much the same way as Java.
© Ed Austin 2017

Supported Architectures
Kompiler + Tool support for:
Android (ART) – Google Official Support
Likely to become the dominant mobile applications language for AOSP within a few years
JVM 1.6+ (later JVM may support better optimizations, not yet Valhalla EAB)
Native (x86/ARM/Others)
Transpiles to JS
Basically in the long-term to be running on as many platforms as possible
© Ed Austin 2017

What differs from Java
Non-nullable Type System
All types are non-nullable by
default (but can and may have to
be nullable in some
circumstances)
No Covariant Arrays
Covariant arrays are gone, now
invariant.
No Primitives
Everything in Kotlin is an
Object.
No Checked Exceptions
Don’t exist in the class
hierarchy of Errors.
No Statics
No statics exist in the language,
at least conceptually, but likely
to change
No Raw types
No need for backward JVM
compatibility, we also have
reification!
AND Top level properties and funs, Data Classes, Co-routines, Smartcasting, Operator Overloading,
Properties, Extension Functions, Companion Objects, Mutable/Immutable collections, Singletons, String
templates, Range expressions, Delegation, Generics … NO SEMICOLONS!!!

Some of what it doesn’t have…
Multi-Catch
For Exception handling
True immutability
Same implementation as Java
reference types
Value Types
Beyond simple JVM types
JVM limitation?
PP Visibility/Namespaces
For use in Java interoperability.
Array Slices
data[a:b], data[:b] etc.
SAM Conversion
Only for Java not for Kotlin
interfaces
No Boolean Op Overloading
All other operators are however
overloadable

Classes, Objects & Inheritance
Basics
2

Class Hierarchy - Any and Nothing
Any
Equivalent to java.lang.Object*
Nothing
Is not Void! (Unit type is Void)
Note:Technically Object is actually
a subtype of Any (TBD)
Diagram courtesy of JetBrains

Interface and Implementation Inheritance
private interface IfMyInterface : IfSomeOtherInterface{
val x get() = 100
fun someMethoda(x: Any?) : Unit /* contract unfulfilled */
fun someMethodb(x: Int) : Int = 123 /* Java 8’ish */
}
open class SomeClass /* open for extension – final by default! */
abstract class SomeAbstractClass : Any()
final class MyClass : SomeClass(), IfMyInterface {
override fun someMethoda(x: Any?) {
/* body */
}
}
class SubClass : SomeAbstractClass() {
/* implement the abstract class method bodies */
}
Note:
Syntax is very
close to Java and
readable by any
Java developer.

Class Basics
//constructor keyword optional
//default parameters
public class TopLevelClass private constructor(val name:String="unknown", val age:Int =-1) {
var t = 10
//secondary C
constructor(name:String, age:Int, gender:String ="unknown") : this(name, age) {}
//tripe, just to show local instantiation
inner class InnerClass(){
val innert = t
val tlc = TopLevelClass("jane")
}
class AClass{
val nestedt = t
fun showme() = 123
}
}
/* … */
/* call with a named parameter, and using default parameters */
val tlc = TopLevelClass("john", 22, gender="male") //call 3-arg C

Sealed Class
abstract sealed class Sealy { /* default private C */
class Red : Sealy()
class Green : Sealy()
}
/* … */
val sealy : Sealy = Sealy.Red()
val output = when (sealy) {
is Sealy.Red -> "red"
is Sealy.Green -> "green"
/* no else branch! */
}
println("result is ${output}") //shortened println syntax and String templates
Primary benefit: Exhaustive case when expression. Specified set of specific values (such as a state
machine). Similar to an enum class, effectively abstract so not instantiable.

Data Class
data class Student(val name: String, var age: Int)
This is the entire class (no body)!
getters and if applicable setters autogenerated
hashcode/equals pair for the object (structural equivalence)
Custom toString (in the form of (name=John, age=30) )
Restriction: Can’t be opened for extension, abstract, sealed or inner.
Copy extension function (with optional modification)
val stu = Student("ed", 42)
val stu_amended_copy = stu.copy(age=43) //not referential!

Kotlin Singleton via object
© Ed Austin 2017
// Java
public class SingletonDcl {
private static SingletonDcl instance = null;
private SingletonDcl(){
}
private synchronized static void createInstance() {
if (instance == null) {
instance = new SingletonDcl();
}
}
public static SingletonDcl getInstance() {
if (instance == null) createInstance();
return instance;
}
public void foo() {}
}
SingletonDcl.getInstance().foo();
//Kotlin Thread-safe version
public object Singleton {
public fun foo() {}
}
Singleton.foo()

Anonymous Class
var clickCount = 0
window.addMouseListener(object : MouseAdapter() {
override fun mouseClicked(e: MouseEvent) {
// ...
clickCount++ //true closure!
}
override fun mouseEntered(e: MouseEvent) {
// ...
}
})
Unlike older versions of Java…

Companion Objects
Quite possible at 2.0 will be deprecated in favour of static objects
Possibly better to write top level functions and variables before the class rather than use a
Companion Object- elizarov JetBrains Team Aug ’17 (most of the time.. No @JvmStatic)
public class Penka {
val id: Int? = null
init {
id = nextId?.inc()
}
private companion object : SomeClass
var nextId : Int? = 1
fun masha() {}
}
}
fun main(args: Array<String>) {
Penka()
println(Penka().id!!)
}
//can inherit!
public class Lenka {
Integer id;
{
id = nextId++;
}
private static Integer nextId = 1;
static void masha{}
public static void main(String[] args) {
new Lenka();
System.out.println(new Lenka().id);
}
}
fun masha() {}
//above package namespace
public class Penka {
val id: Int? = null
init {
id = nextId?.inc()
}
private companion object {
fun masha() {}
}
}
Penka()
println(Penka().id!!)
}

Companion Objects
Simply put a companion object is simply a final static method!
File: MyTest.kt
package foo
class Penka {
private companion object {
fun masha() {
/* some code */
}
}
}
public final class MyTestKt {
public static final void masha() {
/* our code */
}
}

Top Level Properties and Functions
We can have properties and methods at Top level
These are compiled down to JVM static methods within YourPackageName.class (delegates implementations to the so-named package-
parts)
Diagram courtesy of JetBrains

Smart Casts
fun demo(x: Any) {
if (x is String) {
print(x.length) // x is automatically cast to String
}
}
if (x !is String) return
print(x.length) // x is automatically cast to String
Safe “as?” /Unsafe “as” Cast
val x: String? = y as? String //safe cast.. return null if cast not possible
val x: String = y as String //unsafe cast, may throw CCE!

Extension Functions (add a method to any class)
Extension fun:
fun Int.appendString(s:String) = this.toString() + s 123.appendString("abc") 123abc
infix fun Int.appendString(s:String) = this.toString() + s 123 appendString "abc" 123abc
EBNF: [Infix] fun MyClassTobeExtended.myNoneOverridenMethod([arg]) [: returnType ] = expression | [{ /* block */ }]
In the result refer to the first argument as the receiver with this, and the arg as the parameter sent with the message
Likely a better way to do this by overloading :
operator fun Int.plus(s:String) = this.toString() + s 123 + "abc" 123abc
Java.lang.Integer
For obvious reasons doesn’t have an appendString method*
*I stand slightly corrected, "+“ is overloaded as to: String s = 123 + "abc“ which makes this example pretty useless
Note: We can’t override existing methods

Standard Functions on Any (let, apply, run)
public inline fun <T, R> T.run(block: T.() -> R): R = block()
myClassInstance.run { //we could also use a property and apply a method such as length
this.myVar = 123
this.funkyFunc(123)
} //returns the result of the block (last arg) and mutates the receiver
public inline fun <T> T.apply(block: T.() -> Unit): T { block(); return this }
val person = myPersonInstance.apply {
this.name = "lenka penka"
this.age = 33
} //Calls the specified function [block] with "this" value as its receiver and returns "this" value.
//mutates receiver
public inline fun <T, R> T.let(block: (T) -> R): R = block(this)
"something here".let {println("The length of this String is ${it.length}")
} //Calls the specified function [block] with "this" value as its argument and returns its result.

Standard Functions on Any (let, apply, run)
if (listz.run {
this.add(11)
this.add(12)
} //mutates receiver and returns the last result (true)
){
listz.apply {
this.remove(1)
} //mutate and return receiver
.let { println(it) } //pass and print the receiver (implicit it)
}
[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
val listz = arrayListOf<Int>(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

Standard Functions on Any (Let, Apply. Run)

Modifiers
Visibility & Access
3

Visibility Modifiers
Classes, objects, interfaces, constructors, functions, properties and their setters can have visibility modifiers
Top Level
Functions, properties and classes, objects and interfaces
public by default
private “file level” visibility
internal same module (i.e. PP)
Class Level
Members declared within a Class
public by default
private for scope inside class (and its members*)
internal same module (i.e. PP)
protected class + subclasses
*Outer cannot see private members of its inner classes,
nor protected, although you can extend an open inner class
within the original class to gain access to the protected
members!

Access Modifiers
Classes are…
final by default
open can be extended
package foo
open class MyClass
class bar : MyClass()
final class MyClass
class foo : MyClass()
By default classes cannot be extended (are final), this includes inner classes

Visibility/Access Modifiers Example
// file name: Example.kt
package foo
/* top level! */
private fun foo() {} // visible inside example.kt
public var bar: Int = 5 // property is visible everywhere
private set // setter is visible only in example.kt
internal val baz = 6 // visible inside foo
open class MyClass(){ //not default
private final inner class Inner(){} //reference to outer class
public final class Nested(){} //no refs to outer class
public final object Objy{} //effectively static/singleton
}

Java -> Kotlin Primitive/Wrapped Mapping

Kotlin Properties
Abstraction over fields
Can be seen as a “front end” for any backing field
Allows custom getters/setters for variables
We can use expressions on evaluation
Transparent to developers (get default implementation)
Many developers may never use them (using the hidden default implementation)
Allows Custom access
We can add specific visibility modifiers such as public for get and private for set
© Ed Austin 2017
These are the equivalent of Java fields

Kotlin Properties
[<modifiers>] var|val <propertyName>[: <PropertyType>] [= <property_initializer>]
[<getter>]
[<setter>]
var someProperty: String = "defaultValue“ val x
get() = field get() = z + 100
private set(value) { field = value }
© Ed Austin 2017
We can modify the getter/setter of the property with an expression evaluated on set/get as well as visibility modifiers.
A val doesn’t obviously have a setter as it can’t mutate! Wait a minute…..
val someProperty2: String = "defaultValue"
public get() = field + random.nextInt()

Kotlin Example Java Mapping
class Student(val name: String, uni:String)
val a = 123
val b = 444f
val c = "ABC"
val d = ("[A..Z]").toRegex()
val e = 1..100
val f = Student("Masha", “MGU")
val g = mutableListOf<Student>()
val h = hashMapOf<Int,Student>()
val i = arrayOf(a,b,c,d,e,f,g,h)
i.forEach { println(it.javaClass.name) }
}
Types are mostly inferred by the Type system, and need not be specified, most underlying types are
from the JDK, the few from Kotlin are additional types

Managing Null Pointers
Design goal was to eliminate NPE as far as possible
Allegedly NPE was/is a huge issue for Java Developers.
Type system rigorously enforces non-nullability
Heavy static typing makes sure you don’t get into trouble
All types have a nullable alternative
We can specify a null type if we really wish
Nullability was not entirely eliminated
Any interoperability with Java brings with it the nullability issue
© Ed Austin 2017

Nullable Type System
Biggest Kotlin difference: A revised Type System that enforces non-nullability by default
var x = 100f /* non-nullable */
var y : Int? = 100 /* this is nullable */
var g : MutableList<Student>? = mutableListOf<Student>()
We simply add “?” After a type definition to indicate the type is
nullable, we must explicitly state (most) nullable types.
IntelliJ picks up static semantic abuse issues and forces use of various
operators to avoid R/T NPE.

Comparing Types
Referential Equality
=== (negated !==)
Points to same object
i.e. shallow
Value/Structural Equality
== (negated !=)
Points to same data
i.e. deep
a?.equals(b) ?: (b === null)
If a not null call equals(b:Any?) and return result
otherwise if a is null (using elvis) return b===null
(referential) i.e. null == null (true). Or null = not null
(false)
The above are used to provide safety working with nullable types in a type system with mixed typing
No "==" or ". equals()" confusion
Java == Java .equals

Some Type System Operators
Safe Call Operator ?.
Allows a check for
receiver nullability before
allowing access to a
method else return null if
the receiver is null
Elvis Operator ?:
Return a non-null
expression on the left
else return a value on
the right
Double Bang Operator !!
Converts any value to a non-null
type and throws an NPE if null
Example:
var foo : String? = "bar"
/* … */
val len = foo?.length()
Example:
var foo: String? = "bar"
/* … */
val len = (foo?.length) ?: -1
Example
var foo: String? = "bar"
/* … */
val len = foo!!.length
The above are used to provide safety working with nullable types in a type system with mixed typing
Safe Cast as?
Cast returns null and
not CCE if the cast fails
Example:
val aInt: Int? = a as? Int

Nullable Types Woes #1
i++
Java
i++
Kotlin Non-nullable
i?.++ (you think?)
i?.inc() (my second guess)
wtf? No side-effects!
Receiver doesn’t mutate!
Kotlin Nullable

Types Woes #2
Thankyou Ilya Ryzhenkov from JetBrains Kotlin Libraries Team for the overridden operator code.
operator fun Int?.inc() : Int? = this?.inc()
fun test() {
var i: Int? = null
i++
}
i++ (for nullables)  i = if (i == null) null else i.inc()
Nullable

Functions/Control Structures
Idiomatic structures and expression usage
5

Some function Signatures
Java Kotlin
String jrasl() { return “abc” } fun justReturnAStringLiteral : String = “abc”
<T> void f(T a, Object b) fun <T> f(a:T, b:Any?) : Unit
<E> void a(Collection<? extends E> items) fun <E> a(items: Collection<out E>) : Unit
void checkConnection() throws IOException No equivalent
No equivalent fun willNeverReturn(): Nothing {
throw IOException()
}

Imperative Structures
Java Kotlin (can be expression)
for(int i=0;i<=10;i++) for(i in 0..10) //i implicit decl/local scope
while (a>0) {/*..*/} while (a>0) {/*..*/}
do { block } while (condition) do { block } while (condition)
String res; val res = if (x > 10) "foo" else "bar"
if (x>10) res="foo";
else res="bar";
if ((x>0) && (x<100)) if (x in 1..100)
for (MyType s : collection) for (item in collection)
switch - case when {...} / when(..) {...} etc

Communicating with Java
A Tour of Kotlin
6

(Nullable) Platform Types
Java composite types have potential nullable references!
That is all reference types in the language (anything other than the basic value types)
When calling to Java we need to prepare for this!
Because we most often are passing back something that could cause us some issues
These types are called “Platform Types” in Kotlin
They are a special type and can cause us NPE when dereferenced because they are nullable
We can use Java-side annotations to pass information
Such as whether to treat the passed reference as @nullable etc.

Platform Types (from Java to Kotlin)
val mjt = MyJavaTest()
//what is the dereference result?
println(mjt.getBaddy())
}
public class MyJavaTest{
private Integer baddy;
/* … */
public Integer getBaddy(){
return baddy;
}
}
What happens if we call the Java getter from Kotlin?
Java Kotlin
© Ed Austin 2017

Platform Types (from Java to Kotlin)
val mjt = MyJavaTest()
//what is the dereference result?
println(mjt.getBaddy()?:"invalid state!")
}
public class MyJavaTest{
private Integer baddy;
/* … */
public Integer getBaddy(){
return baddy;
}
}
What happens if we call the Kotlin code from Java?
Java Kotlin
© Ed Austin 2017

From Kotlin to Java
Kotlin
//@JvmOverloads allows overloaded Constructors/funs from Java
class TopLevelClazz @JvmOverloads constructor( val name:String="unknown",
val age:Int =-1,
val gender:String="unknown") {}
Java
TopLevelClazz tlc1 = new TopLevelClazz("ed");
System.out.println(tlc1.getAge()); //auto-generated getter from Kotlin
TopLevelClazz tlc2 = new TopLevelClazz("ed",43);
TopLevelClazz tlc3 = new TopLevelClazz("ed",43,"male");

Types (from Kotlin to Java)
import penka.Lenka;
class Penka {
/* … */
new Lenka().name;
//@JvmStatic //Instance
Lenka.foo(); Lenka.MyExposed.foo();
Lenka.bar(); Lenka.MyExposed.bar();
w/o name: Lenka.Companion. …
package penka
final class Lenka {
@JvmField
private var name = "hello world“
private set
companion object MyExposed {
@JvmStatic fun foo() {}
fun bar() {}
}
}
Java VisibilityKotlin
© Ed Austin 2017
@JvmStatic will create a proxy static class (so seen as a static class from Java) that
calls the Kotlin object singleton instance.

Kotlin Exceptions
//Kotlin side
@Throws(IOException::class)
fun foo() : Nothing {
throw IOException()
}
No mandatory handing in Kotlin but
We can if we wish same as Java with try-
catch
//Java side does the call, becomes checked and
forces handling
try {
MyKotlinTest().foo();
}
catch (IOException e) {
//…//
} finally {
//…//
}

Collection and Generics
PECS vs CIPO!
7

Collection/Generics in Kotlin
Collection has Mutable and immutable interfaces that branches off into concrete
implementations. Map has a separate interface (like JDK MutableMap extending Map)
Generics are split into covariant/invariant/contravariant signatures using the out and in
keywords at declaration-site. No more extends/super spaghetti! (Use where for
multiple constraints).
Uses the JDK concrete implementations under the hood:
@SinceKotlin("1.1")
@kotlin.internal.InlineOnly
public inline fun <T> mutableListOf(): MutableList<T> = ArrayList()
@SinceKotlin("1.1") public typealias ArrayList<E> = java.util.ArrayList<E>

Generics Conversion
Invariant
Kotlin: <T>
Java: <T>
Example: Collection
concrete classes are
invariant
Covariant (Producer)
Kotlin: <out E>
Java: <? Extends E>
Upper bounded Example:
Collection interfaces are
covariant
Contravariant (Consumer)
Kotlin: <in E>
Java: <? Super E>
Lower bounded Example: Comparable
interface is contravariant (on declaration-
site in Kotlin)
Remember PECS = CIPO
Wildcard
<*> <out Any?>
<?> <? extends Object>
Wildcard example: iterate/read
through a list of any type
Note: No wildcards in Kotlin Generics!

Generics Conversion
Java:
//JSDK: public interface Comparable <T>
//Effective Java it. 28 recommends
//<T extends Comparable<? super T>>
//<T extends Comparable<T>>
<T extends Comparable<? super T>> void sortz(List<T> x){
sort(x);
}
Kotlin:
//KSDK: public interface Comparable<in T>
fun <T:Comparable<in T>> sortz(x :List<T>){
sort(x)
}
Remember PECS = CIPO
Kotlin:
fun processListz(l : MutableList<*>) {
l.add(22)
for(item in l) println(item)
}
val l = mutableListOf<Any>(123, "abc")
processListz(l)
Java:
void processListz(List<?> l) {
l.add(22)
for(Object item : l)
System.out.println(item);
}
/* ... */
List<Object> l = new ArrayList<Object>();
l.add(123);
l.add("abc");
processListz(l);
*Warning:(16, 25) Kotlin: Projection is redundant: the corresponding type parameter of Comparable has the same variance

Collection Generics at Declaration-site
JAVA
Some JDK Collection type Signatures (PECS at work!)
public interface Collection<E> extends Iterable<E> /* Java 8 */
/* ArrayList */
/*use-site covariance */
void addAll(Collection<? extends E> items);
KOTLIN
Some Kotlin Collection type Signatures (CIPO at work!)
/*declaration-site covariance */
public interface Collection<out E> : Iterable<E> /*covariant as to be expected */
/* MutableList */
public fun addAll(elements: Collection<E>): Boolean
Note: Generics are invariant in both Java and Kotlin, RAW types not implemented (no backwards compatibility needed)

Reified Generics
We can!
inline fun <reified T> f(a: Any) {
if (a is T) println("type matches!")
println("Hey! my class is ${T::class.java}!")
}
f<Int>(123)
We can’t!
inline fun <reified T> f() {
val x = T() /* T t = new T() */
}
f<SomeType>()
We can’t!
fun <T> g(a: Any) {
f<T>(a) // error, cant pass T
}
inline fun <reified T> f(a: Any) {}
We can!
inline fun <reified T> g(a: Any) {
f<T>(a) // OK, reified!
}
inline fun <reified T> f(a: Any) {}
These are not callable from Java code!

Collection in Kotlin R/O != immutable
Can’t be modified through the Collection<T>, Set<T> and List<T> interface methods (no mutable
methods exist on those interfaces!)
Some extension functions cast to a mutable type from an immutable implementation (according to JB)
and therefore Collection may be non thread-safe!
Using ‘as’ to cast to a MutableList succeeds but using a mutate operation (such as add) causes a
java.lang.UnsupportedOperationException

Functional Aspects
A Tour of Kotlin
8

Streams-Like Processing (similar to streams in Java 8)
data class Student(
val name: String,
val surname: String,
val passing: Boolean,
val averageGrade: Double
)
studentz
.asSequence()
.filter { it.passing && it.averageGrade > 80.0 }
.sortedBy { it.averageGrade }
.take(2)
//.toList()
//.forEach { println(it.name) }
.forEach(::println)
Trivial example data filtering and extraction
val studentz = arrayListOf<Studentz>(
Studentz("edik","austin",false,70.0),
Studentz("lenka","penka",true,85.0),
Studentz("lasma","plasma",true,100.0),
Studentz("volodya","polodya",true,98.0)
)
Note: Can be viewed as a one-time
iterator on a Collection

Lambda Trivial HoF/Lambda example
//HOF
fun myHigherOrderFun(s:ArrayList<Studentz>,
f: (ArrayList<Studentz>)-> Pair<String,String> ) = f(s)
//ext fun on Sequence
fun <T> Sequence<T>.sequenceToTopNamePair() = this
.toList()
.let { Pair(it[0].toString(), it[1].toString()) }
//Lambda
myHigherOrderFun (studentz) {
it.asSequence() //make it lazy
.filter { it.passing && it.averageGrade > 80.0 }
.sortedByDescending { it.averageGrade }
.take(2)
.sequenceToTopNamePair()}
.let(::println)

Lambda
//SAM
Thread(Runnable {
/* actions */
}).start()
val r = Runnable { /* actions */ }
runz(r)
fun runz(f: (Runnable)) = Thread(f).start()
//Kotlin, no need for use-site variance, declaration-site has this!
fun <T : Comparable<in T>> dooz(a:T, b:T, p: (T,T) -> Boolean ) = p(a,b)
val p = { a: Number, b: Number -> (a > b) }
dooz(3.4f, 2.4f, p).let { println(it) } //true
val p2 = { a:Char, b:Char -> (a > b) }
dooz('a', 'b', p2).let(::println) //false
//another (completely different) way
fun <T:Comparable<in T>> T.dooz(b:T) = this > b
"a".dooz("b")
3.4f.dooz(2.4f)
studentz5.dooz(studentz4)

“ Kotlin deliberately has no
constructs for concurrency built
into the language. We believe
this should be handled by
libraries.
--Andrey Breslav
Kotlin Language Creator

Thanks!
Any questions?
You can find me ed@ryer.ru

Kotlin Language Features - A Java comparison

Recommended

More Related Content

What's hot (20)

Similar to Kotlin Language Features - A Java comparison (20)

Recently uploaded (20)

Kotlin Language Features - A Java comparison

Editor's Notes