At this year's Google I/O 2017 Developer Conference, Google announced that it had officially included Kotlin in the official first-class language of Android programs. As an Android developer, of course, you must gradually become familiar with this language. The first step is to start learning grammar.
Before this, we need to understand how to write an Android application using Kotlin. For Android Studio 3.0 version, we just check the Include Kotlin support option when creating the project; for versions before 3.0, we need to install the Kotlin plug-in, and manually configure gradle. The method is as follows
Add the following code under the gradle of the app
apply plugin: 'kotlin-android' apply plugin: 'kotlin-android-extensions'
Add the following code under the gradle of the project
ext.kotlin_version = '1.1.2-3' classpath ":kotlin-gradle-plugin:$kotlin_version"
Kotlin defines variables
- There are two types of variable definitions in kotlin, val and var. val is equivalent to a variable modified by final in Java (read-only), generally a constant, and var is generally a variable.
- The variable definition of kotlin supports type inference when assigning, and all variables are modified to "not null" by default. You must explicitly add a ? modifier after the type to be assigned to null.
- When writing code, we should try to habitually design the variable as non-empty as possible, so that many problems will be reduced in the subsequent operation of the variable.
Kotlin function extension
The specific syntax is fun + type.function (parameters)
fun (message: String, length: Int = Toast.LENGTH_SHORT) {
(this, message, length).show()
}
Kotlin Parcelable serialization
package
import
import
/**
* Java Bean Data Entity Class
* Created by john on 17-5-24.
*/
data class UserBean(var name: String, var id: String) : Parcelable {
constructor(source: Parcel) : this((), ())
override fun describeContents(): Int {
return 0
}
override fun writeToParcel(dest: Parcel, flags: Int) {
()
()
}
companion object {
@JvmField val CREATOR: <UserBean> = object : <UserBean> {
override fun createFromParcel(source: Parcel): UserBean {
return UserBean(source)
}
override fun newArray(size: Int): Array<UserBean?> {
return arrayOfNulls(size)
}
}
}
}
Companion keyword interpretation
- Unlike Java or C#, in Kotlin, Class does not have static methods. In most cases, it is recommended to use package-level functions instead of static methods.
- If you need to write a function inside Class without instantiating Class (such as a factory function), you can declare it as a real-name Object inside Class.
- In addition, if you declare a component object in Class, all members in the object will be equivalent to using the static modifier in Java/C# syntax, and these properties or functions can only be accessed through the class name externally.
@JvmField annotation function
- Instructs the Kotlin compiler not to generate getters/setters for this property and exposes them as a field.
- If you need to expose the Kotlin attribute as a field in Java, you need to annotate it with the @JvmField annotation, which will have the same visibility as the underlying attribute.
Kotlin writing tool classes
In Java, we will encapsulate some commonly used functions into tool classes. Tool classes are actually extensions of functions of commonly used classes such as String, Collection, IO, etc. The tool-like methods and variables we write will be written as static. Because we just want to call these methods and do not need to involve any attributes or variables in the tool class, so there is no need to instantiate them (new). Since instantiation is not required, then just use static.
package
import
import
/**
* Toast tool class
* Created by john on 17-5-24.
*/
object ToastUtils {
fun toast(context: Context, message: String) {
(context, message, Toast.LENGTH_SHORT).show()
}
}
Kotlin Activity Jump
We set the click event in MainActivity, jump to another Activity, and pass the data past
package
import
import .
import
import
import .activity_main.*
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
(savedInstanceState)
setContentView(.activity_main)
test_tv.text = "hello kotlin"
test_tv.setOnClickListener {
(this, "hello kotlin")
val user = UserBean("zhang", "001")
= "100"
(this, user)
}
}
fun (message: String, length: Int = Toast.LENGTH_SHORT) {
(this, message, length).show()
}
}
Then create a new SecondActivity and provide a static method for the activity jump. I believe everyone knows the advantage of doing this is to let the caller know what parameters are needed without looking at the source code. If you write according to Java, you will find that the keyword static is not available! Don't panic, you can use companion objects to implement them here. Companion objects are objects that accompany this class declaration cycle.
package
import
import
import
import .
import .activity_second.*
/**
* Jump Activity test class
* Created by john on 17-5-24.
*/
class SecondActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
(savedInstanceState)
setContentView(.activity_second)
val user = <UserBean>(EXTRA_KEY_USER)
user_name_tv.text =
(this, )
}
//Create an accompanying object companion object {
//extra key val EXTRA_KEY_USER = ""
fun navigateTo(context: Context, user: UserBean) {
val intent = Intent(context, SecondActivity::)
(EXTRA_KEY_USER, user)
(intent)
}
}
}
summary
The above just briefly introduces some grammatical features of kotlin, which is a beginning to eliminate some unfamiliar fears about this new language. In fact, kotlin has many new features, which we still need to slowly digest and understand in development.
The above is all the content of this article. I hope it will be helpful to everyone's study and I hope everyone will support me more.