Last Updated: August 18, 2017

Switch from Java to Kotlin


Description: In this post I'm gonna show some of the basic syntax and semantics difference while we use "KOTLIN" in your android application w.r.t JAVA(Java v/s KOTLIN).


So let's get started.



1. Variable Declaration
Java:
String name="coderconsole";

Kotlin:
val  name:String="coderconsole"

2. Casting

Java:
WifiManager wifiManager = (WifiManager)context.getSystemService(Context.WIFI_SERVICE);

Kotlin:
val wifiManager = context.getSystemService(Context.WIFI_SERVICE) as WifiManager

3. Function Declaration

Java:

void methodDeclaration(){
    methodDeclaration("First Method ");
}

void methodDeclaration(String firstParam) {
    methodDeclaration(firstParam, "Second Method ");
}

void methodDeclaration(String firstParam, String secondParams) {
    System.out.println(firstParam + secondParams);
}


Kotlin:


fun methodDeclaration(){
    methodDeclaration("First Method ")
}

fun methodDeclaration(name : String){
    methodDeclaration(name, "Second Method ")
}

fun methodDeclaration(first : String, second: String){
    println(first + second)
}


4. Static Functions and Variable

Java:

class DeviceUtils{
    static final String name = "coderconsole";

    public static String getAndroidId(Context context){
        return Settings.Secure.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID);
    }
}



Kotlin:


class DeviceUtils {

    companion object {
        val name: String = "coderconsole"
        @JvmStatic fun getAndroidId(context: Context): String = Settings.Secure.getString(context.contentResolver, Settings.Secure.ANDROID_ID)
   }

}



5. Ternary


Java:
String ternary(String name) {
    return name.equalsIgnoreCase("coderconsole") ? " Ternary success" : " Ternary failed";
}

Kotlin:
fun ternary(name: String): String {
    return if (name.equals("coderconsole"))"Ternary success" else "Ternary failed"
}

6. Operators(this operators are only useful in kotlin)

a) Null Type(?)- variable can be made null only using null type operator

   val array: String = null /** Null cannot be the value of not null type**/ 
   val array: String? = null  /** Bingo! Will work now **/

b) Safe Type:(?.) - Helpful when we donot know when the variable be null.So instead of throwing NPE it return the value as null.

//The below code will return "customerId" if present else return null even if the "customerObject" is null.
fun safeTypeDemo(customerObject: JSONObject?): String?{
         return customerObject?.optString("customerId")     
}

c) Elvis Operator(?:) - Helpful when we want to return some not-null values, if the first result is null.
Java:
int elvisDemo(JSONObject result){
      if (result != null)
        return result.optInt("marks");
     else  return -1;
   }

Kotlin: 
fun elvisDemo(marksObject: JSONObject?): Int {
         return marksObject?.optInt("marks")?:-1      
}
                                 (or)
fun elvisDemo(marksObject: JSONObject?): Int = marksObject?.optInt("marks")?:-1


d) !! operator - throws Null Pointer when asked explicitly
//The below code will throw NullPointerException if customerObject is null.
fun npeTypeDemoDemo(customerObject: JSONObject?): String{
         return customerObject!!.optString("customerId")     
}


7. Loops
a) for loop:
Java
void forLoopDemo(List mList) {
        for (String item : mList)Log.d("Loop", item);
    }

Kotlin
fun forLoopDemo(mList: List) {
       for (item in mList) Log.d("Loop", item)
    }

b) while/do-while: - there is no syntactical difference from Java.

8. Switch Case
Java
void switchCaseDemo(int type) {
    switch (type){
        case 0:
            Log.d("switch", "value - " + type);
            break;
        case 1:
            Log.d("switch", "value - " + type);
            break;
        default:
            Log.d("switch", "value default");
            break;

    }
}

Kotlin
fun switchCaseDemo(type: Int) {
    when (type) {
        0 -> Log.d("switch", "value - " + type)
        1 -> Log.d("switch", "value - " + type)
        else -> Log.d("switch", "value default")
    }
}


9. Extends/Implements

//This sample contains abstract class and an interface to printData.
public abstract class AbstractA {
    public void printAbstractData(String data){
        System.out.println(data);
    }
}
public interface InterfaceA {
    public void printData(String data);
}


public class ExtendsImpDemo extends AbstractA implements InterfaceA {
    @Override    public void printData(String data) {
        printAbstractData(data);
    }
}


Kotlin

abstract class AbstractA{
    public fun printAbstractData(data: String){
        println(data)
    }
}

interface InterfaceA{
    fun printData(data: String)
}

class ExtendsImpDemo : AbstractA(), InterfaceA {
    override fun printData(data: String) {
        printAbstractData(data)
    }
}


10. Iterating JSONArray

Java:
void arrayTest(JSONArray jsonArray) {
    for (int i = 0; i < jsonArray.length(); i++) {
        JSONObject jsonObject = jsonArray.optJSONObject(i);
        Log.d("ArrayTest", jsonObject.optString("name"));
    }
}

Kotlin:
fun arrayTest(jsonArray: JSONArray){
    jsonArray.items<JSONObject>().forEachIndexed { i, jsonObject ->
        Log.d("ArrayTest", jsonObject.optString("name"))
    }
}

Kotlin is an awesome language and very fun to write code in it.
For further reference you can try https://try.kotlinlang.org

For more updates follow us on -  Twitter

3 comments :

  1. Kotlin over-states the fact it is easy thanks to its clean syntax. Contrary to its claim, the example provided above: ( quoted below )

    fun arrayTest(jsonArray: JSONArray){
    jsonArray.items().forEachIndexed { i, jsonObject ->
    Log.d("ArrayTest", jsonObject.optString("name"))
    }
    }

    It is hard to read, very cluttered, difficulty for average human eyes with this extremely simplified code snippet. What is the practical purpose of "i" on the Lambda expression?


    ReplyDelete

Your comments are valuable for us !!!