溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
Android Kotlin開發實例及語法詳解
前言
Kotlin是一種在 Java虛擬機上執行的靜態型別編程語言，它主要是由俄羅斯圣彼得堡的JetBrains開發團隊所發展出來的編程語言。該語言有幾個優勢
1. 簡潔
它大大減少你需要寫的樣板代碼的數量。
2. 安全
避免空指針異常等整個類的錯誤。
3. 通用
構建服務器端程序、Android 應用程序或者在瀏覽器中運行的前端程序。
4. 互操作性
通過 100% Java 互操作性，利用 JVM 既有框架和庫。
配置
在我們的AndroidStudio開發工具中，要想使用Kotlin這個優秀的開發語言，我們需要安裝插件，直接在安裝插件界面搜索Kotlin然后安裝。之后再gradle文件增加如下配置
apply plugin:'kotlin-android'
apply plugin:'kotlin-android-extensions'
dependencies {
compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
}
項目gradle文件
buildscript {
ext.kotlin_version = '1.1.1'
repositories {
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:2.3.1'
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files
}
}
完成上面的配置后，我們就可以愉快的玩耍了。
Kotlin示例
首先我們還和以前一樣，創建一個Android項目，自動創建一個Activity之后我們再創建一個java類
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
fab.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
.setAction("Action", null).show();
}
});
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.menu_main, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
//noinspection SimplifiableIfStatement
if (id == R.id.action_settings) {
return true;
}
return super.onOptionsItemSelected(item);
}
}
public class Test {
private static String str = null;
public static void main(String[] args) {
str = "Code4Android";
System.out.println(str);
}
}
那上面的代碼如果用kotlin實現是什么樣子呢。盡管現在我們還不能寫出Kotlin代碼，但是在安裝插件后AS中提供了自動轉換Kotlin代碼的功能
轉換后的Kotlin代碼
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val toolbar = findViewById(R.id.toolbar) as Toolbar
setSupportActionBar(toolbar)
val fab = findViewById(R.id.fab) as FloatingActionButton
fab.setOnClickListener { view ->
Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
.setAction("Action", null).show()
}
}
override fun onCreateOptionsMenu(menu: Menu): Boolean {
// Inflate the menu; this adds items to the action bar if it is present.
menuInflater.inflate(R.menu.menu_main, menu)
return true
}
override fun onOptionsItemSelected(item: MenuItem): Boolean {
val id = item.itemId
if (id == R.id.action_settings) {
return true
}
return super.onOptionsItemSelected(item)
}
}
object Test {
private var str: String? = null
@JvmStatic fun main(args: Array<String>) {
str = "Code4Android"
println(str)
}
}
注意：AS提供的java代碼自動轉換功能，我們不要輕易使用，更不要轉化我們成熟的項目，如果需要就需要我們自己去重構實現。否則會有意向不到的事情等著你，畢竟轉換不是那么智能。上面的代碼只是讓你先簡單熟悉下Kotlin代碼時什么樣子的，接下來我們先去學習一下Kotlin的基本語法。相信很容易上手。
Hello World!
我們由一個簡單的”Hello World!”輸出程序開始。與新建java文件類似，如下圖，我們選擇Kotlin File/Class.創建一個Kotlin文件。
package com.learnrecord
/**
*Created by Code4Android on 2017/4/21.
*/
var str: String = ""
fun main(args: Array<String>) {
str = "Hello World!"
println(str)
}
上述代碼就是簡單的輸出一個字符串“Hello World”，package 后面跟的是包名，我們看出了和java文件的區別，在包名后面沒有以分號“；”結尾。在Kotlin語法中，語句結尾都不在有分號“；”。
在Kotlin中變量聲明有兩種類型，val修飾變量是只讀變量即只能賦值一次，再次賦值時就會編譯錯誤
，如果我們需要多次修改值就需要使用var。在上面的 var str: String = “”中，str是變量名，：String,表明該變量是String類型變量，后面就是賦值語句。我們也可以這樣寫var str= “”省略了生命變量類型，它可以根據賦的值而自動推斷出類型。如果我們使用下面賦值語句str=null，發現null是不能賦值的，這就是Kotlin的特性，如果我們想賦值null,可以修改為 var str:String?=”“。
fun就是函數生命，而這個main函數就和我們java中的main方法一樣，是程序執行的入口。println就是一個打印輸出。
Kotlin聲明類型
在Kotlin中有如下幾種Number類型，他們都是繼承自Number抽象類。
Float（32位）,Double（64）,Int（32）,Byte（8）,Short（16），Long(64,類型用大寫L，如12L)，Any（任意類型），數組類型Array 根據傳入的泛型數據自動匹配類型，Kotlin還提供了指定類型的Array,如ByteArray，CharArray，ShortArray，IntArray，LongArray，FloatArray，DoubleArray，BooleanArray。在數組類型中都提供了get(index),set(index,value)及iterator（）方法供我們使用。
val iArray: IntArray = intArrayOf(1, 2, 3)
val sArray: Array<String> = Array<String>(3, { i -> i.toString() })
val anyArray: Array<Any> = arrayOf(1, "2", 3.0, 4.1f) // 可將類型進行混排放入同一個數組中
val lArray: LongArray = longArrayOf(1L, 2L, 3L)
函數
我們先來實現一個簡單的數值求和的函數，通用實現方法如下
fun sum(a: Int, b: Int): Int {
return a + b
}
傳入兩個Int型數值，sum是函數名，括號后面的：Int表示該函數返回Int的值，函數體中對兩個數字相加并返回。在Kotlin中表達式也可以作為函數體，編譯器可以推斷出返回類型，可以簡化為
fun sum(a: Int, b: Int) = a + b
為了更好理解表達式可以作為函數體，我們可以創建一個函數獲取兩個數的最大值，如下：
fun max1(a:Int,b:Int)=if (a>b) a else b
需要注意的是若if后有多個表達式,如下
fun max1(a:Int,b:Int)= if (a > b) {
println(a)
a
} else {
println(b)
//如果我們將println(b)放到b的下面,運行會返回kotlin.Unit為無類型，返回值總是最后一個表達式的返回值或值
b
}
println(max1(1,3))
括號中的表達式順序決定了返回的值及其類型。
如果我們的方法體僅僅是打印字符串，并不返回值則
fun printInt(a: Int): Unit {
println(a)
}
Unit就類似我們java中的void，即沒有返回值，此時我們可以省略
fun printInt(a: Int) {
println(a)
}
對于函數體，方法或者類等和java一樣也有一些修飾符，如下
操作符
直接上代碼如下
//操作符 shl 下面對Int和Long
var a: Int = 4
var shl: Int = a shl (1) //Java中的左移運算符 <<
var shr: Int = a shr (1) //Java中的右移運算符 >>
var ushr: Int = a ushr (3) //無符號右移，高位補0 >>>
var and: Int = 2 and (4) //按位與操作 &
var or: Int = 2 or (4) //按位或操作 |
var xor: Int = 2 xor (6) //按位異或操作 ^
print("\nshl:" + shl + "\nshr:" + shr + " \nushr:" + ushr + "\nand：" + and + "\nor:" + or + "\nxor:" + xor)
輸出信息為
shl:8 shr:2 ushr:0 and：0 or:6 xor:4
在上面的部分操作符可達到邏輯操作符， 當我們使用Boolean時，or() 相當于 ||，and() 相當于 &&， xor() 當操作符兩邊相反時為true，否則為false ，not()時取反。
數組遍歷及控制語句
遍歷數組
fun forLoop(array: Array<String>) {
//第一種方式直接輸出字符（類似java foreach）
for (str in array) {
println(str)
}
//Array提供了forEach函數
array.forEach {
println(it)
}
//array.indices是數組索引
for (i in array.indices) {
println(array[i])
}
//(類似javafor(int i=0;i<arry.length;i++))
var i = 0
while (i < array.size) {
println(array[i++])
}
}
使用when判斷類型
fun whenFun(obj: Any) {
when (obj) {
25 -> println("25")
"Kotlin" -> println("Kotlin")
!is String -> println("Not String")
is Long -> println("Number is Long")
else -> println("Nothing")
}
}
is 和java中instanceof是一個作用判斷是否為某個類型。!is即判斷不是某個類型。
//@定義label，一般用在內層循環中跳到外層循環:i in 0..2等價于java中 for（int i=0;i<=2;i++）效果
loop@ for (i in 0..2) {
for (j in 0..3) {
println("i:" + i + " j:" + j)
if (j == 2)
//continue@loop//跳到外層循環，繼續往下執行
break@loop //跳到外層循環label處，跳出改層循環
}
}
倒序輸出是downTo
//倒序輸出5 4 3 2 1 0
for (i in 5 downTo 0) {
println(i)
}
//設置輸出數據步長
for (i in 1..5 step 3) print(i) // 輸出 14
//step和downTo混合使用
for (i in 5 downTo 1 step 3) print(i) //輸出52
類與枚舉
/*** constructor:構造函數
* constructor無修飾符(如：private)時，constructor可以省略：
* 當是無參構造函數時，整個構造函數部分也可以省略，省略的構造函數默認是public的
* 由于primary constructor不能包含任何代碼，因此使用 init 代碼塊對其初始化,
* 同時可以在初始化代碼塊中使用構造函數的參數
*/
open class People private constructor(var id: String, var name: String) {
//可以類中初始化屬性：
var customName = name.toUpperCase() //初始化屬性
//次構造函數，使用constructor前綴聲明，且必須調用primary constructor，使用this關鍵字
constructor( id: String, name: String, age: Int) : this(id, name) {
println("constructor")
}
init {
println("初始化操作，可使用constructor參數")
}
//需要open修飾，子類才可以
open fun study() {
print("study")
}
//People前的冒號":"是繼承的意思，實現類接口的時候也是冒號
class Student(id: String, name: String) : People(id, name) {
var test: Number = 3
private var name1: String?
get() {
return name1
}
set(value) {
name1 = value
}
//override修飾的方法，默認是可以被繼承的。若希望不被繼承，可以使用 final 關鍵詞修飾
override fun study() {
super.study()
}
}
}
數據類用來保存數據，類似于POJO類，使用data關鍵詞進行定義，編譯器默認會為數據類生成以下四個方法
通過數據類你會看到Kotlin的簡潔性，我們創建一個Staff類，有String類型的name，position和泛型T(使用泛型僅僅是為了在Kotlin中接觸以下泛型)
java實現代碼：
public class StaffJ<T> {
private String name;
private String position;
private T age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPosition() {
return position;
}
public void setPosition(String position) {
this.position = position;
}
public T getAge() {
return age;
}
public void setAge(T age) {
this.age = age;
}
}
Kotlin數據類：
data class Staff<T>(var name: String, val position: String,var age:T)
通過對比我們就看出了優點了，一行代碼就實現了,具體使用
var staff = Staff("code4Android","Android工程師","22") //實例化對象
要獲取某個屬性如獲取名字staff.name,賦值就是staff.name=”code4Android2”，既然說了這樣可以賦值，但是動手的小伙伴說為什么我敲的報錯啊，如下
staff.position="前端"
編譯報錯了，在前面我們說過val修飾的屬性只能賦值一次，那在這里val修飾的屬性我們是不能再次賦值的。
fun main(arg:Array<String>){
var staff = Staff("code4Android","Android工程師","22") //實例化對象
staff.name="code4Android2"
var staff1=staff.copy()
//使用copy的時候可以指定默認值，可以指定任意個用逗號","隔開
var staff2=staff.copy(name="ccc",position = "kotlin")
println("name:${staff2.name} position:${staff2.position} age ${staff2.age}")
//staff.position="Kotiln" //val不能再次賦值
var anotherStaff= Staff("code4Android","Android工程師",22) //實例化對象
println("staff toString(): ${staff.toString()} anotherStaff toString(): ${anotherStaff.toString()}")
println("staff hashCode(): ${staff.hashCode()} anotherStaff hashCode(): ${anotherStaff.hashCode()}")
println("staff is equals another staff ? ${staff.equals(anotherStaff)}")
}
上面使用了字符模板，在Kotlin中有兩種字符模板形式，$<變量>、${<變量>}
var name:String="Code4Android"
println("我的名字叫$name")
println("我的名字叫${name}")
/**
* java允許使用匿名內部類;kotlin也有類似的概念，稱為對象表達式-object expressions
*/
open class KeyBord{
open fun onKeyEvent(code:Int):Unit = Unit
}
/**匿名內部類**/
var key=object :KeyBord(){
override open fun onKeyEvent(code:Int):Unit = Unit
}
枚舉
enum class Color{
RED,BLACK,BLUE,GREEN,WHITE
}
fun display(){
var color:Color=Color.BLACK
Color.valueOf("BLACK") // 轉換指定name為枚舉值，若未匹配成功，會拋出IllegalArgumentException
Color.values() //已數組的形式，返回枚舉值
println(color.name)////獲取枚舉名稱
println(color.ordinal)//獲取枚舉值在所有枚舉數組中定義的順序,0開始
}
在Kotlin中枚舉還支持方法。
擴展
/**
* fun receiverType.functionName(params){
*body
*}
* receiverType : 待擴展的類名
* . ：修飾符為擴展符
* functionName ：為自定義的擴展函數名,
* params ：為自定義的擴展函數參數，可為空
* 擴展函數作用域，受函數的visibility modifiers影響
* 擴展函數并沒有對原類做修改，而是為被擴展類的對象添加新的函數。
* 有一條規則，若擴展函數和類原有函數一致，則使用該函數時，會優先使用類本身的函數。
*/
class Employee(var name: String) {
fun print() {
println("Employee")
}
}
//擴展函數
fun Employee.println() {
print("println:Employee name is $name")
}
/**
* 可以擴展一個空對象
*/
fun Any?.toString1(): String {
if (this == null)
return "toString1:null"
else {
return "toString1" + toString()
}
}
/**
* 擴展屬性
* 由于擴展屬性實際上不會向類添加新的成員,
* 因此無法讓一個擴展屬性擁有一個后端域變量. 所以,對于擴展屬性不允許存在初始化器.
* 擴展屬性的行為只能通過明確給定的取值方法與設值方法來定義，也就意味著擴展屬性只
* 能被聲明為val而不能被聲明為var.如果強制聲明為var，即使進行了初始化，
* 在運行也會報異常錯誤，提示該屬性沒有后端域變量。
*/
val Employee.lastName: String
get() {
return "get:"+name
}
使用
fun main(arg: Array<String>) {
var employee = Employee("Code4Android")
employee.print()
employee.println()
println(employee.toString1())
println(employee.lastName)
}
代理
**
* 被代理接口
*/
interface Base {
fun display()
}
/**
* 被代理類
*/
open class BaseImpl : Base {
override fun display() = print("just display me.")
}
/**
* 代理類，使用:以及關鍵詞by進行聲明
* 許代理屬性和其他繼承屬性共用
* class Drived(base: Base) : Base by base,BaseImpl()
*/
class Drived(base: Base) : Base by base
//使用
fun show() {
var b = BaseImpl()
var drived = Drived(b)
drived.display()
}
**
* 代理類型：
* 懶加載：Lazy
* 觀察者：Delegates.observable()
* 非空屬性：Delegates.notNull<>()
*/
class Water {
public var weight:Int by Delegates.notNull()
/**
* 代理屬性
*/
public val name: String by lazy {
println("Lazy.......")
"Code4Android"
}
public var value: String by Delegates.observable("init value") {
d, old, new ->
println("$d-->$old->$new")
}
}
fun main(arg: Array<String>) {
show()
var water = Water()
println(water.name)
println(water.name)
water.value = "11111"
water.value = "22222"
water.value = "33333"
println(water.value)
println(water.value)
//必須先賦值否則IllegalStateException: Property weight should be initialized before get.
water.weight=2
print(water.weight)
}
操作符::
val String.lastChar: Char get() = this[this.length - 1] class A(val p: Int)
//1,反射得到運行時的類引用:
val c = Student::class
//2,函數引用
fun isOdd(x: Int) = x % 2 != 0
val numbers = listOf(1, 2, 3)
println(numbers.filter(::isOdd))
//3，屬性引用(在此引用main函數主體外聲明的變量)
println(::x.get())
::x.set(2)
println(x)
//4，::x 表達式評估為 KProperty<Int> 類型的屬性，它允許我們使用 get() 讀它的值或者使用名字取回它的屬性
val prop = A::p
println(prop.get(A(1)))
//5，對于擴展屬性
println(String::lastChar.get("abc"))
//6，與 java 反射調用
println(A::p.javaClass),
var f: Array<Field> = A::p.javaClass.declaredFields
伴生對象
伴生對象(companion object )類似于java中的靜態關鍵字static。在Kotlin沒有這個關鍵字，而是伴生對象，具體用法
open class People constructor(var id: String, var name: String){
//可以類中初始化屬性：
var customName = name.toUpperCase() //初始化屬性
//使用constructor前綴聲明，且必須調用primary constructor，使用this關鍵字
constructor( id: String, name: String, age: Int) : this(id, name) {
println("constructor")
}
init {
println("初始化操作，可使用constructor參數")
}
//,Kotlin的class并不支持static變量,所以需要使用companion object來聲明static變量,
// 其實這個platformStatic變量也不是真正的static變量,而是一個伴生對象,
companion object {
val ID = 1
}
}
使用的話直接People.ID。
單例模式
在Kotlin中使用object修飾類的時候，。該類是單例對象。
/**
* 使用object定義類，該類的實例即為單例，訪問單例直接使用類名，不能通過構造函數進行訪問，不允許有構造函數
* Place.doSomething() // 訪問單例對象
*/
object Singleton {
fun doSomething() {
println("doSomething")
}
}
/**
* 實例化的時候，單例是懶加載，當使用的時候才去加載；而對象表達式是在初始化的地方去加載。
*
* 當在類內部使用 object 關鍵詞定義對象時，允許直接通過外部類的類名訪問內部對象進而訪問其相關屬性和方法，相當于靜態變量
* 可以使用companion修飾單例，則訪問其屬性或方法時，允許省略單例名
* MyClass.doSomething() // 訪問內部單例對象方法
*/
class MyClass {
companion object Singleton {
fun doSomething() {
println("doSomething")
}
}
}
感謝閱讀，希望能幫助到大家，謝謝大家對本站的支持！
源碼下載：http://xiazai.jb51.net/201705/yuanma/KotlinForAndroid(jb51.net).rar
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
