• Kotlin is officially recognized by Google as a level 1 programming language for Android development
• Today, I will present a comprehensive and detailed introduction to Kotlin, including defining features, configuring usage, and getting started syntax. I hope you will enjoy it.

• Level 1 Programming language developed for Android (Google official certification)
• Launched in 2010 by JetBrains & open source, interworking with the Java language & with a number of new features not yet supported by Java
• Versions of Android Studio3.0 and later support Kotlin

Here’s how to configure Kotlin for use in Android Studio.

It consists of three steps to complete the Kotlin configuration.

Buildscript {ext.kotlin_version = '1.2.10' repositories {mavenCentral()} dependencies {classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" } }Copy the code

Kotlin has six basic numeric types: Byte, Short, Int, Long, Float, and Double

Note: Unlike Java, a character (char) in Kotlin is not a numeric type; it is a separate data type.

• Note: Each data type can be converted to another data type using the corresponding method

ToByte () : Byte toShort() : Short toInt() : Int toLong() : Long toFloat() : Float toDouble() : Double toChar() : CharCopy the code

• Description: String
• Features: immutable
• Use: characters in strings accessed by index: s [I]

// Use 1: a string can be iterated with a for loop for (c in STR) {println(c)} // Use 2: a string can be concatenated with three quotes """ "fun main(args: Array<String>) {val text = """ String 1 String 2 """ println(text) // There are some prespaces} // note: Through trimMargin () to delete redundant blank fun strSample () {val text = "" |" "str1 | str2 | | multi-line string BBBBBB" "" trimMargin println () / / (text) Removed leading space}Copy the code

String Templates

• That’s a little bit of code inside the string that evaluates and merges the results into the string.
• Template expressions begin with a dollar character ($)

${varname.fun ()} : ${varname.fun ()} : ${varname.fun ()} : Val s = "ABC" val STR = "$s.length is ${s.length}" // identify "abc.length is 3"Copy the code

• Implementation: Use the Array class
• Use the size attribute, get, and set methods. Note: Using [] overrides the get and set methods to get/set array values by subscript.
• ArrayOf (); arrayOf(); Mode 2 = factory function

[1,2,3] val a = arrayOf(1, 2,3) Create an Array [0,2,4] val b = Array(3, {I -> (I * 2)}) Public inline constructor(size: Int, init: (Int) -> T) println(a[0]) println(b[1]) In addition to the Array class, ByteArray, ShortArray, and IntArray are used to represent various types of arrays. IntArray = intArrayOf(1, 2, 3)Copy the code

Note: Unlike Java, arrays in Kotlin are invariant, i.e. Kotlin does not allow arrays to be assigned to arrays to prevent possible runtime failures

• Part of the class header = follows the class name with the constructor keyword
• Cannot contain any code. The initialized code is placed in a code block prefixed with the init keyword

Constructor () {init {//... Constructor (userName: String) {//... }}Copy the code

Note: Omit the constructor keyword if the main constructor does not have any annotation/visibility modifiers

// Form class class name (parameter name: parameter type) {init {//... } // Example class User (userName: String) {init {//... }}Copy the code

Kotlin classes can have attributes: keyword var (read and write)/keyword val (read only)

class User { var userName: String val sex: String = "male"} // Use the property = name + reference User().sex // Use the property = Java getter User().username = "HJC" // Set the property = Java setter methodCopy the code

• Like Java, Kotlin is single inheritance = there is only one parent class
• Difference: Kotlin uses the colon “:” for inheritance & inheritance is not allowed by default (to make a class inheritable, use the open keyword)

Open class Fruits class Fruits: Food()Copy the code

• In Kotlin, methods are also not overridden by default when subclasses override their parent
• If a subclass wants to override a method in its parent class, it must add the open keyword in front of the method and the Override keyword in front of the method overridden by the subclass

Open class Food {open fun banana() {}} // Subclass class Fruits: Food(){override fun banana() {super.banana()}}Copy the code

Function name (parameter name: parameter type) : return value type {function body return return value} // Description: // 1. Use "fun" to identify // 2. Parentheses are the parameter values and types of the passed function // Example: A function named "ABC", the type of the passed parameter is Int, and the type of the returned value is String fun ABC (Int: Int): String {return "carson_ho"} String {return "carson_ho"} String {return "carson_ho"} Fun add(a: Int, b: Int) = a + b; fun add(a: Int, b: Int) = a + b; fun add(a: Int, b: Int) = a + b; // Call a function: suppose a class has a function called foo: User().foo()Copy the code

A function, in addition to passing in arguments & returns values, will exist:

• Passed arguments & no return value
• No passed arguments & no return value

Void void void void void void void void void void void void void void void Unit{function body} // No argument &no return value // template: fun () {function body} // or return Unit (void, similar to Java) fun () : Unit{function body}Copy the code

Some useful grammar candy about Kotlin, mainly including:

• Control flow (if, when, for, while)
• Range use (in, downTo, step, until)
• Type checking & Conversions (IS, Intelligent Conversions, AS)
• Equals (), =, ==
• Air safety

Control flow statements include: if, when, for, and while.

Similar to the Switch statement in Java

// Switch statement int a = 0; switch (a) { case 0: break; case 1: break; default: break; Var a = 0 when (a) {0 -> {block 1} 1 -> {block 2} 2,3 -> {block 3} else -> {block 4}} // Execute code block 1 when a=0 // execute code block 2 when a=1 // execute code block 3 when a=2, 3 when a= other values // Note: the when statement terminates execution of the WHEN statement after the conditional branch executionCopy the code

Similar to the Java while statement, divided into while and do… While statement:

var i = 5 while(i in 1.. 4){code block 1} do{code block 2}while(I in 1.. 4) {}Copy the code

/** * 1. Is used to check whether an object is of the specified type **/ If (a is String) {println("a is String ")} if (a! Is Int) {println("a is not an Int ")} /** * 2. Note: Kotlin does not have to use explicit type conversion operations because the compiler tracks is checks for immutable values as well as explicit conversions and automatically inserts (safe) conversions when needed **/ var a: Any = "a" if (a is String) {println("a is String ") println(a.length) A is automatically converted to String if (a! Is String) {print (a. ength)} / / in && and | | right can also be intelligent transformation: / / ` && ` a automatically converted to the String on the right side of the if (a is a String && a. ength > 0) / / ` | | ` a automatically converted to the String on the right side of the if (a is a String | | a. ength > 0) When (a){is String -> a.length is Int -> a + 1} // Note: Smart conversions cannot be used when the compiler cannot guarantee that the variable will not change between checking and using. // 1. Val local variables -- always, except for local delegate attributes; // 2. val attribute -- If the attribute is private or internal, or the check is performed in the same module where the attribute is declared. Smart conversions do not apply to open properties or properties with custom getters; // 3. var local variable -- if the variable is not modified between check and use, is not captured in the lambda that will modify it, and is not a local delegate attribute; // 4. Var attribute -- never possible (because this variable can be changed by other code at any time) /** * 3. Cast: as **/ var any: any = "ABC" var STR: String = any as String Int = 123 var STR: String = String ClassCastException /** * 4. Nullable conversion operator: as? * Nulls cannot be converted to String because the type is not nullable. **/ var STR = null var str2 = STR as String // Throw TypeCastException // Use safe conversion operator as? You can return NULL if the conversion fails, avoiding throwing an exception. var str = null var str2 = str as? String println(str2) // The output is nullCopy the code

• NullPointerException is quite common in Java
• Kotlin has the advantage of avoiding null-pointer exceptions when executing code as much as possible

In Kotlin, there are two situations that are most likely to cause a NullPointerException **/ / case 1: explicitly calling throw NullPointerException() // case 2: using!! Operator // description:!! The operator converts any value to a non-null type and throws an exception if it is null var a = null a!! / / throw KotlinNullPointerException / / case 3: data types cannot be null / / in Kotlin, distinguish between a reference type system can accommodate null (null reference) and does not fit (not null reference) / / such as: // To allow nullability, declare a variable as a nullable String: place a question mark after the String type. For String, it is written: String? var b: String? = "b" b = null /** * 2. .length // means: if b is not null, then b.length is called. .b? .c? .d // If a is not null, the whole expression will return NULL. // If you only perform an operation on non-null values, you can use a? .b? .let { println(it) }Copy the code

That concludes the introductory syntax for Kotlin.

• This article provides a comprehensive introduction to Kotlin learning, including defining features, configuring usage, and getting started with syntax
• In the upcoming articles, I will continue to explain Kotlin, including its usage and syntax. If you are interested, please follow me on my blog: Carson_ho’s Android blog