一天入门Kotlin学习笔记(一)-数据类型

[TOC]

前言

本系列文章做为学习简单的学习笔记，其目的在于2个：

• 记录本身学过的知识
• 本着分享交流的原则分享

本系列适合彻底没有学过Kotlin而且像快速入门的同窗，本人如今也是在学习中，因此做为笔记不免会有错误，若是我理解的不对或是有疑问，真诚但愿能够在留言区你们进行讨论。

推荐学习资料

• Kotlin入门与进阶
• Kotlin实战
• Kotlin语言中文站

数据类型

1. Boolean类型

val b:Boolean=true
复制代码

定义类型格式 ：访问修饰符 修饰符 对象名：类名=具体赋值

变量的修饰符有2种：

• val 不可变的属性声明
• var 可变属性声明

val修饰相似于java中的final修饰，定义时必须初始化(或在构造方法中或是init{}方法中)，可是不彻底相同Kotlin常量用const修饰。注意是不可变属性不是静态属性

var是可变属性，能够不初始化，能够屡次赋值

在kotlin中不像java，基本数据类型能够用小写的boolean声明。这里必须用他的装箱类来定义。
访问修饰符默认是public(java是defualt)

2. Number类型

val l:Long=1231231L
val l1:Long=1231231
val l2:Long=1231231l//error
val f:Float=3f
val f1:Float=3.0F
val f2:Float=3.0//error
val d1:Double=3.0
val s:Short=12712
val byte:Byte=127
复制代码

在java中有基本数据类型int对应的装箱类型Integer，Kotlin中是没有这个概念的Kotlin中的Int至关于int与Integer合体，编译器会帮我选择。
Kotlin中不存在隐式转换，如：

short s = 0;
        int i = 0;
        long l = 0;
        i = s;
        l = i;
        l = s;
复制代码

java中正确 Kotlin中

val s: Short = 0
    var i: Int = 0
    i = s.toInt()
    i = s//error
复制代码

3. Char类型

与java基本一致，这里列出一些经常使用的转义字符

转义字符	含义
\t	制表符
\b	光标后退一个字符
\n	回车
\r	光标回到行首
'	单引号
"	双引号
\	反斜杠
$	美圆符号，Kotlin 支持美圆符号开头的字符模板

4. String类型

• == 与 ===

val str: String = "str"
val str1: String = String(charArrayOf('s', 't', 'r'))

fun main(args: Array<String>) {
    println(str== str1)
    println(str=== str1)

}

结果： 
true  
false

复制代码

Kotlin中== 至关于.equals()对象比较相等用 ===

• 字符串模板

val int1: Int = 1
    val int2: Int = 2

    println(" " + int1+ " + " + int2 + " = " + (int1 + int2))
    println("$int1 + $int2 = ${int1 + int2}")

    //hello "world"
    //前面提到的转义字符
    println("hello \"world\"")
    val s:String=""" \t \n hello World """
    println(s)
    
    
    
结果：  
1 + 2 = 3
1 + 2 = 3
hello "world"


        \t
        \n
        hello World
    
复制代码

"${}"字符串模板 """ """ 原始字符串  
复制代码

5. 类与对象

直接将理论仍是不够直观，因此直接上代码：

class 美女 private constructor(val 性格: String, val 长相: String, val 声音: String) {//1
    constructor(性格: String, 长相: String, 声音: String, 三围: String) : this(性格, 长相, 声音)//2 
    constructor(性格: String, 长相: String) : this(性格, 长相, "动听")
}

class 帅哥(性格: String, 长相: String, 声音: String) : 人(性格, 长相, 声音) {//3
    init {//4
        println("帅哥: 性格:$性格，长相:$长相，声音:$声音")

    }


}

class Test{//5
    val d: Double
    val i: Int

    constructor(double: Double, int: Int) {
        d = double
        i = int
    }

    constructor(double: Double) {
        d = double
        i = 0
    }

}

open class 人(val 性格: String, val 长相: String, val 声音: String) {
    init {
        println("new 了一个${this.javaClass.simpleName}: 性格:$性格，长相:$长相，声音:$声音")

    }

    fun funA() {
        println(this.声音)//6
    }
}

fun main(args: Array<String>) {
    val 我喜欢的妹子: 美女 = 美女("温柔", "甜美", "动听","三围")
    val 我膜拜的汉子: 帅哥 = 帅哥("彪悍", "帅气", "浑厚")
    val test1 = Test(2.0)
    val test2 = Test(2.0, 3)
}
复制代码

这段代码有点长，可是内容很是简单，我也会分开来讲

1. 类的定义：

class <类名> 构造器(实参1/形参1，实参2/形参2){
    
}
复制代码

Kotlin的构造函数分为主构造器（primary constructor）和次级构造器（secondary constructor）。
简单理解就是写在类名后面的为主构造器
写在类里面的为次构造器
当主构造器被可见性修饰符修饰时，必须加上constructor关键字不然能够省略，如3处帅哥类

2. 只有被open关键字修饰的类才能被继承

• Kotlin中继承是用冒号:来做为继承类或是实现接口
• 2处为次构造器，若是定义了主构造器那么次构造器须要继承主构造器

3. 形参和实参 人这个类中定义的形参，帅哥定义的实参
4. init方法
   当使用主构造器时，因为没有方法体，那么一些初始化的操做能够在init{}方法中实现。这个方法每次建立对象都会被执行
5. 只有次构造器那么构造方法能够重载
6. 形参能够在方法中调用(若是val 声音: String去掉val这行会报错)
7. java中全部类的父类是Object，Kotlin中全部类的父类是Any

更多知识参考Kotlin的构造函数

6. 空类型

在Kotlin对函数有更严格的要求，如在Java中你能够写这样一个方法：

public String getName() {
        return null;
    }
复制代码

这样彻底是没问题的，可是在Kotlin中却不能够

会提示错误，意思说你不能返回一个空字符串
PS: 这里简单说下Kotlin中方法的定义：

<可见性修饰符> <其余修饰符> fun 方法名(形参1，形参2):<返回值类型>{
    
} 
复制代码

这个不难理解，基本和Java同样都是固定格式，没什么好说的.
若是这个方法返回本省就可能为空怎么办呢？能够这样写：

fun getName(): String? {
    return null
}
复制代码

String?表示他是一个可null的字符串，咱们调用时能够这样：

fun getName(): String? {
    return null
}

fun main(args: Array<String>) {

    val nameB:String? = getName()
    println(nameB?.length)//  
}
复制代码

nameB?这样表示name不为空那么就输出长度,不然打印null，这样程序不会崩溃 可是还有一种状况以下：

val value:String ?= "HelloWorld"
    println(value!!.length)
复制代码

定义value是可空类型，可是我明确知道它不是null,那么咱们可使用value!!,表示我已经肯定知道这个值不是null，不要给我报编译错误。

总结

• val notNull: String = null //错误,不能为空
• val nullable: String? = null //正确,能够为空
• notNull.length //正确,不为空的值能够直接使用
• nullable.length //错误,可能为空,不能直接获取长度
• nullable!!.length //正确,强制认定nullable不可空
• nullalbe?.length //正确,若nullable为空,返回空

7. 智能类型转换

下面来看：

if (name != null)
        println(name.length) 
    else 
        return
        
等价于：

  val name: String = getName()?: return
  println(name.length) 
复制代码

经过条件语句肯定name必定不为空那么能够直接调用方法，这就是只能转换String?转String

Java中：

class Parent{
    
}
class Chlid extends Parent{
    public int age=11
}

public void main(){
    Parent parent=new Child()
    ((Chlid)parent).age
}
复制代码

只有强转才能调用子类的方法，可是在Kotlin中却不用 以下：

val parentA: Parent = Chlid()
    if (parentA is Chlid) {
        parentA.age
    }
复制代码

is关键字，经常使用语判断，若是判断成立那么parentA就是Child不用强转 关于强转以下：

val chlidA: Chlid = parentB as Chlid//非安全强转失败crash
    val chlidB: Chlid? = parentB as? Chlid//安全强转失败为null
复制代码

总结：

◆ Java Style类型转换

• val sub: SubClass = parent as SubClass
• 相似于Java的类型转换,失败则抛异常

◆ 安全类型转换

• val sub: SubClass? = parent as? SubClass
• 若是转换失败,返回null ,不抛异常

◆ 智能类型转换

• if(parent is SubClass) parent. <子类的成员>
• 编译器尽量的推导类型,远离无用的类型转换
• if(nullable != null) nullable.length
• 正确!由于咱们确认nullable不为空!.

8. 区间

关于区间比较简单 直接说下概念：

• 个数学上的概念,表示范围
• ClosedRange的子类, IntRange最经常使用
• 基本写法:
  • 0..100表示[0, 100]
  • 0 until 100表示[0, 100)
  • i in 0..100判断i是否在区间[0, 100]中

代码：

val rangeInt: IntRange = 1..1024//[0,1024]
val range_exclusive: IntRange = 0 until 1024//[0,1024)
val b: Boolean = true

fun main(args: Array<String>) {
    println(rangeInt.contains(50))
    println(rangeInt.contains(1024))
    println(1024 in rangeInt)
    println(range_exclusive.contains(1024))
    println(1024 in range_exclusive)

    for (i in range_exclusive) {
        println(i)
    }
}
复制代码

9. 数组

数组的使用方法

• val array: Array = array0f...)

基本操做

• print array[i] 输出第i个成员
• array[i] = ,"Hello" 给第i个成员赋值
• array.length 数组的长度

为了不没必要要的装箱和拆箱, 基本类型的数组是定制的以下：

例子：

val arrayInt: IntArray = intArrayOf(1, 3, 5, 7)
val arrayChar: CharArray = charArrayOf('H', 'e', 'l', 'l', 'o')
val arrayString: Array<String> = arrayOf("陈", "冠", "希")
val array书记: Array<市委书记> = arrayOf(市委书记("张"), 市委书记("李"), 市委书记("王"))

fun main(args: Array<String>) {
    println(arrayInt.size)
    for (i in arrayInt) {
        println(i)
    }

    println(arrayChar.joinToString(""))//链接字符
    println(arrayString.joinToString(""))//链接字符串
    println(array书记[1])
    array书记[1] = 市委书记("赵")
    println(array书记[1])
    println(arrayInt.slice(1..3))//表示的是下标 slice表示"切片"
}
复制代码

结语

本篇就到这里下一篇将说下程序结构相关。

Github源码，包含所有详细笔记