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

0 comments :

Post a Comment

Your comments are valuable for us !!!