In fact as I read Why you should totally switch to Kotlin \u2013 Magnus Vinther \u2013 Medium<\/a><\/em> I wonderded why they haven’t switched to Eiffel, as it has had for decades most of the features they praised in Kotlin!<\/p>\n <\/p>\n I want to tell you about a new programming language<\/strong> called Kotlin<\/strong> and why you should consider it for your next project. I used to prefer Java but the last year I\u2019ve found myself coding Kotlin whenever I could, and at this point I really can\u2019t think of a situation where Java would be a better choice.<\/p>\n It\u2019s developed by JetBrains<\/strong><\/a>, and the fact that these are the people behind a suite of IDEs<\/a>, such as IntelliJ <\/strong>and ReSharper<\/strong>, really shines through in Kotlin. It\u2019s pragmatic<\/strong> and concise<\/strong>, and makes coding a satisfying and efficient experience.<\/p>\n Although Kotlin compiles to both JavaScript<\/strong><\/a> and soon machine code<\/strong><\/a>, I\u2019ll focus on its prime environment, the JVM<\/strong>.<\/p>\n So here\u2019s a couple of reasons why you should totally switch to Kotlin (in no particular order):<\/p>\n Kotlin is 100% interoperable with Java<\/strong>. You can literally continue work on your old Java projects using Kotlin. All your favorite Java frameworks are still available<\/strong>, and whatever framework you\u2019ll write in Kotlin is easily adopted by your stubborn Java loving friend.<\/p>\n Kotlin isn\u2019t some weird language born in academia. Its syntax is familiar to any programmer coming from the OOP<\/a> domain, and can be more or less understood from the get go. There are of course some<\/em> differences from Java such as the reworked constructors or the It\u2019s as if a smarter and more readable version of Java\u2019s Kotlin will infer your types wherever you feel it will improve readability:<\/p>\n The Kotlin compiler tracks your logic and auto-casts types if possible<\/strong>, which means no more You can stop calling No need to define several similar methods with varying arguments:<\/p>\n Combined with default arguments, named arguments eliminates the need for builders<\/a>:<\/p>\n The switch case is replaced with the much more readable and flexible when<\/em> expression:<\/p>\n It works both as an expression or a statement, and with or without an argument:<\/p>\n Custom set & get behavior can be added to public fields, which means we can stop bloating our code with mindless getters & setters<\/a>.<\/p>\n It\u2019s a POJO complete with A predefined set of operators can be overloaded to improve readability:<\/p>\n Some objects can be destructured, which is for example useful for iterating maps:<\/p>\n For readability\u2019s sake:<\/p>\n Remember the first time you had to sort a If only there was a way to add new functions to old classes; that way your IDE could help you find the right function in code-completion. In Kotlin you can do exactly that:<\/p>\n The standard library extends the functionality of Java\u2019s original types, which was especially needed for Java is what we should call an almost<\/em> statically typed language. In it, a variable of type Kotlin resolves this by distinguishing between non-null types<\/strong> and nullable types<\/strong>. Types are non-null by default, and can be made nullable by adding a\u00a0 Kotlin forces you to guard against NPEs whenever you access a nullable type:<\/p>\n And while this might seem cumbersome, it\u2019s really a breeze thanks to a few of its features. We still have smart casts, which casts nullable types to non-null wherever possible:<\/p>\n We could also use a safe call\u00a0 Safe calls can be chained together to avoid those nested if-not-null checks we sometimes write in other languages, and if we want a default value other than If none of that works for you, and you absolutely need a NPE, you will have to ask for it explicitly:<\/p>\n Oh boy, is this a good lambda system\u200a\u2014\u200aperfectly balanced between readability and terseness, thanks to some clever design choices. The syntax is first of all straight forward:<\/p>\n And here come the clever bits:<\/p>\n These facts combined makes the following three lines equivalent:<\/p>\n And this allows us to write concise functional code\u200a\u2014\u200ajust look at this beauty:<\/p>\n Kotlin\u2019s lambda system combined with extension functions makes it ideal for DSL<\/a> creation. Check out Anko<\/a> for an example of a DSL that aims to enhance Android development:<\/p>\n You have a number of options if you intend to get started with Kotlin, but I highly recommend using IntelliJ <\/strong>which comes bundled with Kotlin<\/strong>\u2014its features demonstrate the advantage of having the same people design both language and IDE.<\/p>\n Just to give you a minor but clever example, this thing popped up when I first tried to copy-paste some Java code from Stack Overflow:<\/p>\n\n
Why you should totally switch to\u00a0Kotlin<\/h1>\n
It\u2019s time to start using a modern programming language<\/h2>\n
0# Java Interoperability<\/a><\/h4>\n
1# <\/strong>Familiar\u00a0Syntax<\/strong><\/a><\/h4>\n
val<\/code> var<\/code> variable declarations. The snippet below presents most of the basics:<\/p>\nclass<\/strong> Foo {\n\n val<\/strong> b: String = \"b\" \/\/ <\/em>val means unmodifiable\n var<\/strong> i: Int = 0 \/\/ <\/em>var means modifiable\n\n fun<\/strong> hello() {\n val<\/strong> str = \"Hello\"\n print<\/em>(\"$str World\")\n }\n\n fun<\/strong> sum(x: Int, y: Int): Int {\n return<\/strong> x + y\n }\n\n fun<\/strong> maxOf(a: Float, b: Float) = if<\/strong> (a > b) a else<\/strong> b\n\n}<\/pre>\n2# <\/strong>String Interpolation<\/strong><\/a><\/h4>\n
String.format()<\/code> was built into the language:<\/p>\nval<\/strong> x = 4\nval<\/strong> y = 7\nprint<\/em>(\"sum of $x and $y is ${x + y}\") \/\/ sum of 4 and 7 is 11<\/pre>\n3# Type Inference<\/a><\/h4>\n
val<\/strong> a = \"abc\" \/\/ type inferred to String\nval<\/strong> b = 4 \/\/ type inferred to Int\n\nval<\/strong> c: Double = 0.7 \/\/ type declared explicitly\nval<\/strong> d: List<String> = ArrayList() \/\/ type declared explicitly<\/pre>\n
4# Smart\u00a0Casts<\/a><\/h4>\n
instanceof<\/code> checks followed by explicit casts:<\/p>\nif<\/strong> (obj is<\/strong> String) {\n print<\/em>(obj.toUpperCase<\/em>()) \/\/ obj is now known to be a String\n}<\/pre>\n5# Intuitive Equals<\/a><\/h4>\n
equals()<\/code> explicitly, because the ==<\/code> operator now checks for structural equality:<\/p>\nval john1 = Person(\"John\")\nval john2 = Person(\"John\")<\/pre>\n
john1 == john2 \/\/ true (structural equality)\njohn1 === john2 \/\/ false (referential equality)<\/pre>\n
6# Default Arguments<\/a><\/h4>\n
fun<\/strong> build(title: String, width: Int = 800, height: Int = 600) {\n Frame(title, width, height)\n}<\/pre>\n7# Named Arguments<\/a><\/h4>\n
build(\"PacMan\", 400, 300) \/\/ equivalent\nbuild(title = \"PacMan\", width = 400, height = 300) \/\/ equivalent\nbuild(width = 400, height = 300, title = \"PacMan\") \/\/ equivalent<\/pre>\n
8# The When Expression<\/a><\/h4>\n
when<\/strong> (x) {\n 1 -> print<\/em>(\"x is 1\")\n 2 -> print<\/em>(\"x is 2\")\n 3, 4 -> print<\/em>(\"x is 3 or 4\")\n in<\/strong> 5..10 -> print<\/em>(\"x is 5, 6, 7, 8, 9, or 10\")\n else<\/strong> -> print<\/em>(\"x is out of range\")\n}<\/pre>\nval<\/strong> res: Boolean = when<\/strong> {\n obj == null<\/strong> -> false\n obj is<\/strong> String -> true\n else<\/strong> -> throw<\/strong> IllegalStateException()\n}<\/pre>\n9# <\/strong>Properties<\/strong><\/a><\/h4>\n
class <\/strong>Frame {\n var<\/strong> width: Int = 800\n var <\/strong>height: Int = 600\n\n val <\/strong>pixels: Int\n get<\/strong>() = width * height\n}<\/pre>\n10# <\/strong>The Data\u00a0Class<\/strong><\/a><\/h4>\n
toString()<\/code>, equals()<\/code>, hashCode()<\/code>, and copy()<\/code>, and unlike in Java it won\u2019t take up 100 lines of code:<\/p>\ndata class<\/strong> Person(val<\/strong> name: String,\n var<\/strong> email: String,\n var<\/strong> age: Int)\n\nval<\/strong> john = Person(\"John\", \"john@gmail.com\", 112)<\/pre>\n
11# Operator Overloading<\/a><\/h4>\n
data class<\/strong> Vec(val <\/strong>x: Float, val <\/strong>y: Float) {\n operator fun<\/strong> plus(v: Vec) = Vec(x + v.x, y + v.y)\n}\n\nval <\/strong>v = Vec(2f, 3f) + Vec(4f, 1f)<\/pre>\n12# Destructuring Declarations<\/a><\/h4>\n
for <\/strong>((key, value) in <\/strong>map) {\n print<\/em>(\"Key: $key\")\n print<\/em>(\"Value: $value\")\n}<\/pre>\n13# Ranges<\/a><\/h4>\n
for<\/strong> (i in<\/strong> 1..100) { ... } \nfor<\/strong> (i in<\/strong> 0 until 100) { ... }\nfor<\/strong> (i in<\/strong> 2..10 step 2) { ... } \nfor<\/strong> (i in<\/strong> 10 downTo 1) { ... } \nif<\/strong> (x in<\/strong> 1..10) { ... }<\/pre>\n14# <\/strong>Extension Functions<\/strong><\/a><\/h4>\n
List<\/code> in Java? You couldn\u2019t find a sort()<\/code>function so you had to ask either your tutor or google to learn of Collections.sort()<\/code>. And later when you had to capitalize a String<\/code>, you ended up writing your own helper function because you didn\u2019t know of StringUtils.capitalize()<\/code>.<\/p>\nfun<\/strong> String.replaceSpaces(): String {\n return<\/strong> this.replace<\/em>(' ', '_')\n}\n\nval <\/strong>formatted = str.replaceSpaces()<\/pre>\nString<\/code>:<\/p>\nstr.removeSuffix<\/em>(\".txt\")\nstr.capitalize<\/em>()\nstr.substringAfterLast<\/em>(\"\/\")\nstr.replaceAfter<\/em>(\":\", \"classified\")<\/pre>\n
15# <\/strong>Null\u00a0Safety<\/strong><\/a><\/h4>\n
String<\/code> is not guaranteed<\/em> to refer to a String<\/code>\u2014 it might refer to null<\/code>.<\/span> Even though we are used to this, it negates the safety of static type checking, and as a result Java developers have to live in constant fear of NPEs<\/a>.<\/p>\n?<\/code>like so:<\/p>\nvar<\/strong> a: String = \"abc\"\na = null<\/strong> \/\/ compile error\n\nvar<\/strong> b: String? = \"xyz\"\nb = null<\/strong> \/\/ no problem<\/pre>\n
val<\/strong> x = b.length \/\/ compile error: b might be null<\/pre>\n
if<\/strong> (b == null<\/strong>) return<\/strong>\nval <\/strong>x = b.length \/\/ no problem<\/pre>\n
?.<\/code>, which evaluates to null instead of throwing a NPE:<\/p>\nval <\/strong>x = b?.length \/\/ type of x is nullable Int<\/pre>\n
null<\/code> we can use the elvis operator\u00a0?:<\/code>:<\/p>\nval <\/strong>name = ship?.captain?.name ?: \"unknown\"<\/pre>\n
val <\/strong>x = b?.length ?: throw<\/strong> NullPointerException() \/\/ same as below\nval <\/strong>x = b!!.length \/\/ same as above<\/pre>\n
16# <\/strong>Better\u00a0Lambdas<\/strong><\/a><\/h4>\n
val<\/strong> sum = { x: Int, y: Int -> x + y } \/\/ type: (Int, Int) -> Int\nval <\/strong>res = sum(4,7) \/\/ res == 11<\/pre>\n\n
it<\/code>.<\/li>\n<\/ol>\nnumbers.filter({ x -> x.isPrime() })\nnumbers.filter { x -> x.isPrime() }\nnumbers.filter { it.isPrime() }<\/pre>\npersons\n .filter { it.age >= 18 }\n .sortedBy { it.name }\n .map { it.email }\n .forEach { print(it) }<\/pre>\nverticalLayout {\n padding = dip(30)\n editText {\n hint = \u201cName\u201d\n textSize = 24f\n }\n editText {\n hint = \u201cPassword\u201d\n textSize = 24f\n }\n button(\u201cLogin\u201d) {\n textSize = 26f\n }\n}<\/pre>\n17# IDE\u00a0Support<\/a><\/h4>\n