Kotlin开发之旅《二》—Kotlin的基本语法

如果对Kotlin不太了解的童鞋们，请参考

Kotlin开发之旅《一》— 初学者Kotlin基础必备

Kotlin成为Android开发首选语言——你绝对不能错过的

今天关于来学习Kotlin的基本语法。Java to Kotlin 主要语法，以便于你快速认识 Kotlin 这门语言

1、变量的声明

定义局部变量

次赋值（只读）的局部变量

val a: Int = 1 // ⽴即赋值
val b = 2 // ⾃动推断出 `Int` 类型
val c: Int // 如果没有初始值类型不能省略
c = 3 // 明确赋值

// a = b + c; 写法错误

可变变量

var x = 5 // ⾃动推断出 `Int` 类型
x += 1

2、 使⽤条件表达式

fun maxOf(a: Int, b: Int): Int {
if (a > b) {
return a
} else {
return b
}
}
//使⽤ if 作为表达式:

fun compare(a: Int, b: Int) = if (a > b) a else b

3、使⽤可空值及 null 检测

fun parseInt(str: String): Int? {
var length : Int? = 0;
if(str != null){
length = str.length;
}
return length;
}

fun parseString(content : String) :String ?{

return content;
}

eg:

fun printProduct(arg1: String, arg2: String) {
val x = parseInt(arg1)
val y = parseInt(arg2)
// 直接使⽤ `x * y` 可能会报错，因为他们可能为 null
if (x != null && y != null) {
// 在空检测后，x 和 y 会⾃动转换为⾮空值（non-nullable）
println(x * y)
}
else {
println("either '$arg1' or '$arg2' is not a number")
}
}

fun printProduct2(arg1: String, arg2: String) {
val x = parseInt(arg1)
val y = parseInt(arg2)
if (x == null) {
println("Wrong number format in arg1: '${arg1}'")
return
}
if (y == null) {
println("Wrong number format in arg2: '${arg2}'")
return
}
// 在空检测后，x 和 y 会⾃动转换为⾮空值
println(x * y)
}

4、for循环的使用

基本遍历

fun useForListMap(){
//实例化list计划
var list = listOf("终端","研发部","欢迎","你");
//遍历list
for (content in list){
println(content);
}
//遍历 方法2
for (content in list.indices){
println("------"+list[content]);
println(content);
}
}

Java

if (value >= 0 && value <= 100) {}

for (int i = 1; i <= 100 ; i++) {}

for (int i = 1; i < 100 ; i++) {}

for (int i = 100; i >= 0 ; i–) {}

for (int i = 1; i <= 100 ; i+=2) {}

for (int i = 100; i >= 0 ; i-=2) {}

Kotlin

if (value is 0..100) {

}

for (i in 1..100 ) {}

for (i in 1 until 100) {} // 半开区间：不包含 100

for (i in 100 downTo 0) {}

for (i in 1..100 step 2) {}

for (i in 100 donwTo 1 step 2) {}

Java

List list = Arrays.asList(“java”, “c++”, “Android”, “Kotlin”, “iOS”);

for(int i = 0; i < list.size(); i++ ) {

list.set(i, "Hello " + list.get(i));

if (!list.get(i).contains("c")) {

System.out.println(list.get(i));
}

}

//输出：

// Hello java

// Hello Android

// Hello Kotlin

// Hello iOS

Kotlin

var list = arrayOf(“java”, “c++”, “Android”, “Kotlin”, “iOS”)

list.map {

"Hello $it"

}.filter {

!it.contains("c")

}.forEach {

println(it)

}

//输出：

// Hello java

// Hello Android

// Hello Kotlin

// Hello iOS

只读 list

val list = listOf("a", "b", "c")

访问 map

val map = mapOf("a" to 1, "b" to 2, "c" to 3)
println(map["key"])
map["key"] = value

延迟属性

val p: String by lazy {
// 计算该字符串
}

扩展函数

fun String.spaceToCamelCase() { …… }
"Convert this to camelcase".spaceToCamelCase()

创建单利

object Resource {
val name = "Name"
}

- 返回when 表达式

fun transform(color: String): Int {
return when (color) {
"Red" -> 0
"Green" -> 1
"Blue" -> 2
else -> throw IllegalArgumentException("Invalid color param value")
}
}

“try/catch”

fun test() {
val result = try {
count()
} catch (e: ArithmeticException) {
throw IllegalStateException(e)
}
// 使⽤ result
}

“if” 表达式

fun foo(param: Int) {
val result = if (param == 1) {
"one"
} else if (param == 2) {
"two"
} else {
"three"
}
}

函数

Java

public final void func() {}

public final int func(int value) {

return 1 * value;
}

Kotlin

fun func() {}

fun func(value: Int): Int {

return 1 * value
}

// 或者

fun func(value: Int): Int = 1 * value

类

Java

public final class Person {

private String name = null;

private int age = 25;

private Person() {
}

public Person(String name, int age) {

this.name = name;
this.age = age;
}
}

Kotlin

class Person private constructor() {

private var name: String? = null

private var age: Int = 25

constructor (name: String, age: Int): this() {

this.name = name
this.age = age
}
}

静态方法（ 伴生对象 ）

Java

public final class Manager {

private Manager() {}

public static Manager getInstance () {

return new Manager();
}
}

Kotlin

class Manager private constructor() {

companion object {

fun getInstance(): Manager = Manager()
}

}

实体类

java

public class Person {

public String name;

public age;

public Person(String name, int age) {

this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;

Person person = (Person) o;

if (age != person.age) return false;
return name != null ? name.equals(person.name) : person.name == null;

}

@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}

@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}

Kotlin

data class Person(var name: String, var age: Int)

解构

Java

Person p = new Person("haohao", 25);

String name = p.getName();

String age = p.getAge();

Kotlin

var p = Person("name", 25)

var (name, age) = p

接口

Java

interface Readable {

String getContent();
}
public final class Book implements Readable {

@override
public String getContent() {

return "Hello";
}
}

Kotlin

// Kotlin 接口中可以设置抽象和非抽象方法,可以有属性但必须声明为抽象或提供访问器实现。
interface Readable {

fun getContent(): String

fun getVersion(): Int = 0

}
class Book(): Readable {

override fun getContent(): String = "Hello"

override fun getVersion(): Int {

return super.getVersion()
}
}

继承

Java

public class Person {

private String name = null;

public Person(String name) {
this.name = name;

}

public void sayHello() {
System.out.println("Hello");
}

public final void sayGood() {
System.out.println("Good");
}

}
public final class Student extends Person {

private String school = null;

public Student(String name, String school) {
this.school = school;
super(name);
}

@override
public void sayHello() {
super.sayHello();
System.out.println("Hello Student");
}

}

Kotlin

open class Person(private var name: String? = null) {

open fun sayHello() = println("Hello")

fun sayGood() = println("Good")

}
class Student(private var school: String? = null, name: String): Person(name) {

override fun sayHello() {
super.sayHello()
println("Hello Student")
}

}

静态与非静态内部类

Java

public final class Outer {

private int bar = 100;

public static class Nester {

public final String foo() {
return "Hello Kotlin!";
}
}

public final class Inner {

public final int foo() {
return bar; // 可以访问外部类成员
}

}

}

System.out.println(new Outer.Nester().foo());

// System.out.println(new Outer().Inner().foo()); 不能在其他类中实例化非静态内部类

Kotlin

class Outer {
private var bar: Int = 100

// 嵌套类
class Nester {
// 不能访问外部类成员
fun foo() = "Hello Kotlin!"
}

// 内部类
inner class Inner {
// 可以访问外部类成员
fun foo() = bar
}
}

println(Outer.Nested().foo())

println(Outer().Inner().foo())

匿名内部类

Java

view.setOnClickListener(new OnClickListener() {

@override
onClick(View view){
// to do something.
}

});

Kotlin

interface OnClickListener {
fun onClick()
}

class View(){
var listener: OnClickListener? = null

fun setOnClickListener(listener: OnClickListener) {
this.listener = listener
}
}

view.setOnClickListener(object : OnClickListener{
override fun onClick() {
TODO("not implemented")
}
})

泛型

Java

public final class Wrapper<T> {
private T item;
public Wrapper(T item) {
this.item = item;
}

public T getItem() {
return item;
}
}

Wrapper<String> wrapper = new Wrapper<>("Hello Kotlin");
System.out.println(wrapper.getItem());

Kotlin

class Wrapper<T>(val item: T)

var wrapper = Wrapper("Hello Kotlin")
println(wrapper.item)

匿名函数 ( Lambda 表达式 )

Java (Java 8)

new Thread(() -> {

System.out.println("Hello Kotlin");

}).start();

// 同下

new Thread(new Runnable() {

@Override
public void run() {

System.out.println("Hello Kotlin");

}

}).start();

Kotlin

Thread(Runnable {

println("Hello Kotlin")

}).start()

// Kotlin Lambda 表达式语法

val sum = {x: Int, y: Int -> x + y }

val sum1: (Int, Int) -> Int = {x, y -> x + y }

val sum2 = fun(x: Int, y: Int): Int {
return x + y
}

println(sum(2,8))

println(sum1(2,8))

println(sum2(2,8))

//输出：
//    10
//    10
//    10
//    Hello Kotlin

简单异步

Java (Java 8)

new Thread(() -> {

data = DataSource.obtain(); //耗时操作

runOnUiThread(() -> {

view.load(data); //更新 UI

});

}).start();

Kotlin (Kotlin Anko)

async {

data = DataSource.obtain(); //耗时操作

uiThread {
view.load(data); //更新 UI
}
}

泛型函数

Java

// Java 不能单独实现泛型函数

Kotlin

fun <T> singletonList(item: T): List<T> {
return arrayListOf(item)
}

val list = singletonList<String>("kotlin")

嵌套函数

Java

// Java 不支持嵌套函数

Kotlin

fun main(args: Array<String>) {

fun sayHello() {
println("Hello Kotlin")
}

sayHello();
}
// 输出：
//    Hello Kotlin

Kotlin lazy 懒加载

Kotlin

val lazyValue: String by lazy {
println("init")  //第一次使用时才被初始化
"Hello Kotlin"
}

fun main(args: Array<String>) {
println(lazyValue)
println(lazyValue)
}

//输出：
//    init
//    Hello Kotlin
//    Hello Kotlin

Kotlin 闭包

闭包的理解

简单理解：闭包能够将一个方法作为一个变量去存储，这个方法有能力去访问所在类的自由变量。

Kotlin

val plus = {x: Int, y: Int -> println("$x plus $y is ${x+y}")}

val hello = {println("Hello Kotlin")}

fun main(args: Array<String>) {

{x: Int, y: Int ->
println("$x plus $y is ${x+y}")
}(2, 8)         // 自执行的闭包

plus(2, 8)
hello()
}

//输出：
//    2 plus 8 is 10
//    2 plus 8 is 10
//    Hello Kotlin

Kotlin observable 观察者

Kotlin

class Person{
public var name: String by Delegates.observable("init .. "){
property,oldValue,newValue -> println("property : $property, oldValue : $oldValue, newValue : $newValue")
}
}

fun main(args: Array<String>) {
val person = Person()

println(person.name)

person.name = "haohao"
person.name = "nannan"
}

//输出：
//    init ..
//    property : var Person.name: kotlin.String, oldValue : init .. , newValue : haohao
//    property : var Person.name: kotlin.String, oldValue : haohao, newValue : nannan

学习文档

官网文档：

http://kotlinlang.org/docs/reference/android-overview.html

官网：

http://kotlinlang.org/

国内中文文档：

https://huanglizhuo.gitbooks.io/kotlin-in-chinese/content/

国内中文文档2：

http://www.liying-cn.net/kotlin/docs/reference/

Kotlin-github地址

https://github.com/JetBrains/kotlin

相关博客地址：

https://github.com/androidstarjack/MyKotlin01

相信自己，没有做不到的，只有想不到的

如果你觉得此文对您有所帮助，欢迎入群 QQ交流群 ：232203809

微信公众号：终端研发部



（欢迎关注学习和交流）