kotlin基础语法学习

本篇文章我们简单说下kotlin的基本语法，相信熟悉java语言的同学，看完之后，会更容易学习kotlin。下一篇，我会根据安卓开发中的语法，进行kotlin讲解。这片我会通过kotlin语法和Java对比的方式，达到更容易理解的效果。
声明：本篇大部分代码示例是从kotlin官方文档上摘录下来。这篇只讲了一些基本的语法。要深入了解，还需个人努力。

如果大家想看实例，可以到这，我写了一个跑马灯效果实例。已经上架应用宝。

android studio想要支持kotlin特别简单：
首先添加插件File->Setting->Plugins->搜索Kotlin->install
最后Restart AS。
当你新建第一个kotlin文件或activity的时候会提示你配置kotlin。如图：

点击配置就好了。
这里就不多说了。下面让我们开始学习kotlin的语法。到最后我会运用到安卓中，从安卓开发的角度使用起来。

---

定义常量 - - -val

val str = “final” //会自动检测为String类型
val str :String =”final”;
val b = 2
val c:Int = 2
val d:Int //常量没有初始值必须声明类型
d=1

这里我们和java代码对比一下，更清晰：

//相当于java的
final String STR =”final”;
final int COUNT = 1;

---

定义变量 - - -var

var x = 2
var str = “var”
x +=2
str =” change var”

和java代码对比一下：

String str =”str”;
str = “str1”;
int a=1;
a =2;

---

静态变量 - - - companion

这里我说一下，在我开发过程中发现kotlin不能在内部类里添加静态变量

//静态常量
companion object {
val s = “string”
val a =1
}
//静态变量
companion object{
var s=”string”
var a =2
}

java:

//静态常量
final static String S =”fianl static”;
final static String A = 1;
//静态变量
static String S=”static”;
static String A =”static”;

---

函数

kotlin的程序入口：

//main方法执行
fun main(args:Array){
print(“sum of 3 and 5 is “)
println(sum(3,5))
}

java程序入口：

public static void main(Array args){
…
}

带有两个Int 参数，返回Int 的函数：

fun sum(a:Int,b:Int) :Int{
return a +b
}
//也可以写成表达式方式
fun sum(a:Int,b:Int) =a + b
//无返回值：
fun printSum(a:Int,b:Int):Unit{
…
}
//Unit可以省略：
fun printSum(a:Int,b:Int){
…
}

Java对比：

//int返回值
public int sum(int a,int b){
….
}
//无返回值
public void execute(int a,int b){
}

---

修饰符

在Kotlin中有以下四个可见性修饰符
- private：同一类或文件（针对包级别定义）中可见
- protected：同private 加子类可见
- internal：在同一个模块中可见（如果声明范围的所有者是可见的）
- public：公共，所有都可见 （默认）

---

构造 - - -constructor

kotlin和Java一样，属于单继承，多实现。也就是最多继承一个类，可以实现多个接口。

//如果有一个构造函数,后面 会详细讲解重载，继承class Child(private val str:String)//class Child {    constructor(a:Int,b:Int){    }    constructor(a:Int,b:Int,c:Int){    }}

让我们看看熟悉的Java构造：

public class Child {    private String mStr;    public Child( String str){        this.mStr=str;    }      public Child(String str,int a){    }}

---

条件表达式 - - - if

fun maxOf(a:Int ,b:Int):Int{    if(a>b) return a    else return b}//或fun maxOf(a:Int,b:Int) = if(a>b) a else b

条件语句和java基本大致相同：

public int maxOf(int a,int b){    if(a>b) return a;    else return b;}

---

使用可空值检测及null检测

当某个变量的值为null的时候，必须在声明处的类型后添加？来标识该引用可为null。

//如果str不是数字内容，返回nullfun parseInt(str:String):Int?{    return str.toIntOrNull}

使用类型检测及类型转换 - - - is

is 是判断是否为某类型的一个实例。如果已经呗判断出来，可以直接当作该类型使用，无需显式转换，具体我们看看下面代码讲解：

fun getStringLength(obj:Any):Int?{    if(obj is String){        //现在已经判断出来obj为String类型        //我们可以直接调用String类型的属性和方法        return obj.length    ｝}

Java中还是需要转换的：

public int getStringLength(Object obj){     if (obj instanceof String){            ((String) obj).length();      }}

---

使用 for 循环

var items =listOf("apple","banana","kiwi")for(item in items){    println(item)}//或者for(index in items.indices){    //可以通过$符号显示    println("item at $index is ${items[index]}")}

相当于Java中使用for和foreach：

ArrayList<String> listStr=new ArrayList<String>();listStr.add("apple");listStr.add("banana");listStr.add("kiwi");for (int i = 0; i < listStr.size(); i++) {    Log.e("TAG",listStr.get(i));}for (String str:listStr) {    Log.e("TAG",str);}

---

使用while循环

while(index<items.size){    println("item at $index is ${items[index]}")}

和Java的使用方法基本类似

---

使用when表达式

when的使用，相比Java就要强大的多了，它可以支持多种类型，而Java只支持整型。让我们看看when

fun describe(obj:Any):String =    when(obj){        1 -> "One"        "Hello"    -> "Greenting"        is Long    -> "Long"        !is String -> "Not a string"        else       ->"Unknown"    }

kotlin的when语法，和Java的switch比较相似：

swith(v.getId()){    case R.id.tv:    break;    case 2:    break;    defalut:    break;}

---

使用区间 - - - range

if(x in 1..10){}if(-1 !in 1..100){}for(x in 1..5){ print(x) }for(x in 1..10 step 2){ print(x) }

java写法就比较笨重了：

if(x>1 && x<10){}for(int i =1;i<10;i+=2){}

---

使用集合

//对集合进行迭代var items = listOf("apple","banana","kiwi","avocado")for(item int items){    println(item)}//使用in运算符判断集合内是否包含某实例when{    "apple" in items -> println("apple")    "banana" int items -> println("banana")}//使用lambda表达式来过滤（filter）和映射（map）集合：fruits    .filter{it.startsWith("a")}    .sortedBy{it}    .map{it.toUpperCase()}    .forEach{ println(it)}

---

类和继承

类声明由类名、类头（指定其类型参数、主构造函数等）和大括号包围的类体构成。类头和类体都是可选的；如果一个类没有类体，可以省略括号。

class KotlinTest{}//或class KotlinTest

构造函数

//在kotlin中一个类可以有一个主构造函数和一个或多个构造函数。主构造函数是类头的一部分：它跟在类名（和可选的类型参数）后。class Person constructor(firstName:String){}

//如果主构造函数没有任何注解或者可见性修饰符，可以省略这个constructor关键字。class Person(firstName:String){}

//主构造函数不能包含任何的代码。初始化的代码可以放到以init关键字作为前缀的初始化块（initializer blocks）中：class Customer(name:String){    init{        logger.info("Customer initialized with value ${name}")    }}

//主构造的参数可以在初始化块中使用。也可以在类体内声明的属性初始化器中使用：class Customer(name:String){    val customerKey = name.toUpperCase()}//如果构造函数有注解或可见性修饰符，constructor是必需的class Customer public @Inject constructor(name :String){}

类也可以声明前缀有constructor的次构造函数：

class Person{    constructor(parent:Person){        parent.children.add(this)    }}

如果有一个构造函数，每个次构造函数需要委托给主构造函数，可以直接委托或者通过别的次构造函数间接委托。委托到同一个类的另一个构造函数用this 关键字即可：

class Person(val name:String){    constructor(name:String,parent:Person):this(name){        parent.children.add(this)    }}

如果一个非抽象没有声明任何（主或次）构造函数，它会有一个生成的不带参数的主构造函数。构造函数可见性是public。如果你不希望你的类有一个公有构造函数，需要声明一个带有非默认可见性的空主构造函数。
这一点和Java一样

class DontCreateMe private constructor(){}

继承

在kotlin中所有类都有一个共同的超类Any，这对于没有超类型声明的类是默认超类：

class Example // 从Any隐式继承

Any不是java.lang.Object；尤其是，它除了equels()、hashCode()和toString()外没有任何成员。

声明显式的超类型：

open class Base(p:Int)class Derived(p:Int) : Base(p)

如果该类有一个主构造函数，其基类必须用主构造函数参数就地初始化。
如果类没有主构造函数，那么每个次构造函数必须使用 super关键字初始化其基类类型，或委托给另一个构造函数做到这一点。注意，在这种情况下，不同的次构造函数可以调用基类型的不同构造函数：

class MyView :View{    constructor(ctx:Context): super(ctx)    constructor(ctx:Context,attrs:AttributeSet) :super(ctx,attrs)}

用open标注的类，表示允许其他类继承。默认final。