Kotlin基础学习笔记 (二）

1、定义

Kotlin是一门可以运行在java虚拟机、Android、浏览器上的静态语言与Java 100%兼容。

 

2、数据类型

 

 2.1、Numbers 基本数据类型

     Boolean数据类型

val aBoolean: Boolean = true; // val 变量名:变量类型= 赋值

 

Number数据类型

Type	Bitwidth
Long	64
Int	32
Short	16
Byte	8
Double	64
Float	32

 

 val aFloat :Float =2.0F（不加F是双精度浮点型）

 val minFloat :Float = -Float.Max_VALUE

 0.0F/0.0F != Float.NaN 不是数

 

Integer ：装箱类型

int ： 基本类型

Kotlin：Int = 基本类型+装箱类型 ：合体

 

2.2、字面量

    十进制：1

    Longs 类型大写L ：1L

    十六进制：0x01

    二进制：0b0000 0001

    八进制：无| 不支持八进制

 

2.3、字符串：

字符串String 不可变类型

字符char类型，一个char类型占2个字节，表示一个16位字符

 

转意符：由转义字符、原声字符串、换行和任意文本

\t : 制表符

\b: 光标后退一个字符

\n: 回车换行符

\r: 光标回到行首

\' : 单引号

\": 双引号

\\ : 反斜杠

\$ : 美元符号

 

Characters

    Characters 用 Char表示；用单引号表示Chararacter；可以调用显示转换把Character转换为Int

Char 类似 于Java的基本类型 char ，Char？类似于Java引用类型Character。

 

字符串模版表达式——以$符号开始 ，内部是一个任意表达式

 两个整型相加母版：

println("$anInt+$anotherInt= ${anInt + anotherInt}")

 

美元符号

val salary : Int = 1000

print(“$$salary”) ===》$1000

 

原生字符串：

使用 引号三个（””"） 引起来的String，内部没有转义，通过 “空格”分开进行转意

 

字符串比较：

a=b ：赋值；在逻辑运算时有效

a ==b ：等于运算；标示比较内容或是值，而不是引用；即类似于java的equals

a ===b ，完全等于运算；表示比较对象是否相同，是否为同一个，比较对象的引用值（同时也比较值）

 

基本类型的转换——kotlin不支持隐式转换

-val anInt : Int =5 

-val aLong : Long =anInt.toLong();  //显示转换

 

Numbers类型支持如下的转换：

toByte() :Byte

toShot() :Short

toInt() :Int

toLong() :Long

toFloat() :Float

toDouble() :Double

toChar() :Char

 

 

    2.4、类和对象

类：一个抽象的概念，具有某些特征的事物的概括，不特定指代任何一个具体的食物

class <类名> ( 构造方法) {<成员>... }

         类和对象的关系

•     一个类通常可以有很多具体的对象
•     一个对象本质上只能从属于一个类

    Class (1)—————对应关系——————object(1…n)

 

     2.5  类的继承

•     提取多个类的共性得到一个更抽象的类，即是父类
•     子类拥有父类的一切特征
•     子类也可以自定义自己的特征
•     所有的类都最终继承自Any，所有类的始祖

 

    ex，一个简单的对象及其构造方法：

            

class 妹子(var 性感: String,

        var 长发: String,

        var 甜美: String){

    //若无具体实现可以删掉{ }

    init {

        println("new 了一个妹子, 性格：$性感,长发:$长发,甜美:$甜美")

    }

}

val 我喜欢的妹子: 妹子 = 妹子("咪咪","黑色","声音")

 

 

 2.4.空类型和智能类型转换

 

空类型安全

java：在java中null会报空指针异常

kotlin：在kotlin中任意类型都有可空和不可空两种

 

不可空类型 就类似与java中的基本数字类型，是原始的数字类型，比如，int,long,float,double等

可空类型 就相当于引用的数字类型，如integer，Long，Float，Double

 

ex 1：

判断name 是否为null的状态

old 示例写法: 

val name = xxx();

    if( name == null ){

        println(“xxxx”);

    }else{ 

        printlin(name.length)

    }

 

new 示例写法:

val name = xxx():

//如果name不为空就返回长度，否则返回null

println(name? .length)  

 

ex 2：

判断name 是否为null的状态，若为null则直接返回

 

old 示例写法:

    val name = xxx();

    if(name == null ) return 

 

new 示例写法:

//定义一个名为name的变量，它的值是xxx()；如果xxx()返回的是null，就进行return——>”?:"

    val name:String = xxx()?:return 

 

“？： always 表达式”：判断问号之前的表达式;如果为空，则执行？后面的语句

    

注意：将getName()的值返回并赋值给name，这个name的类型是一个不可为null的String类型

val name : String = getName() ?: return 

println(name.length) //否则返回一个string类型的变量

 

ex 3：

对于一个可null的String类型，但值却不是null

 

    val value :String? = “FuckWorld”

       if( value is String )

       //在已经肯定String 字符串不为null的情况下，可以使用 “!!.” 进行表达式肯定的阐述

        println(value!!.length)// !!.强制认可空类型 nullable

 

类型转换异常

   val parent: Parent = parent()

    val child:Child ?= parent as? Child//如果转换失败则抛出异常（安全的类型转换）

       println( child ) //返回为null 

 

// 这里不能通过编译. User对象不能是null

 var notNullUser: User= null

 

 // User可以是 null 

var user: User? = null 

 

// 无法编译, user可能是null，我们需要进行处理

 user.print() 

 

// 只要在user != null时才会打印

 user?.print() 

 

// 使用Elvis操作符来给定一个在是null的情况下的替代值 

val name = user?.name ?: "empty” 

 

/** 如果user为可空类型，又一定要调用它的成员函数和变量，

*可以用 !! 操作符 两种可能，

*要么正确返回name，要么抛出空指针异常 当user为null，

*你不想返回null，而是抛出一个空指针异常，你就可以使用它。 

**/

var name = user!!.name

 

 

任意类型都有可空和不可空两种：

-val notNull:String = null    //错误，不能为空

-val nullable: String?= null  //正确 ，可以为空 String可null类型

-notNull.length    //正确 ，不为空的值可以直接使用

-nullable.length    //错误， 可能为空，不能直接获取长度

-nullable !!.length  //正确，强制认定nullable不可空

-nullable ?.length  //正确 ，若nullable为空，返回空

 

智能类型转换

java style 类型转换

-val  sub : SubClass = parent asSubClass 

——类似于java的类型转换，失败则抛出异常

 

安全类型转换

-val  sub:SubClass ?= parent as?SubClass

——如果转换失败，返回null 不抛异常

 

智能类型转换

-if(parent is SubClass)parent.<子类的成员>

    ——编译器尽可能的推导类型，远离无用的类型转换

-if(nullable != null) nullable.length

    ——正确！因为确认nullable不可空

 

2.5  包Package

 命名空间，限定一个类的使用范围，路径

 

2.6  区间Range

 

var ranger:IntRange=0..1024//闭区间 [0,1024] ，整形区间

    .. :rangeTo

var ranger_exclusive:IntRange=0 until  1024//半开区间 [0,1023] or [0,1024)

        until : CloseRange {

            CharRange / 

            ComparableRange /

             IntRange 

            / LongRange  }

 

var   emptyRange: IntRange = 0..-1 //表示为空区间 

    i in 0..100 判断 i 是否再区间 [0，100]中 

        range.contains(50)  === 50 in range 

迭代： 

    for ( i in ranger_exclusive ) { 

                print (“ $i , “) 

    }

 

2.7 数组 

数组数组 ，数是数，组是组，合在一起就是组，就没有数了。

数组就是一系列的对象

 

基本写法：通过arrayOf 创建数组

    （1）包含数值的数组：val a:Array<String> = arrayOf(“yy”,”xx")

    （2）指定大小,元素位空的数组：val b: arrayOfNulls<String>(10)

    （3）函数数组： val c = Array(10, {i->(i+1).toString() } )

       (4)  kotlin 自带原始类型 数组： xxArrayOf (... )

val arrayOfInt:IntArray = intArrayOf(1 ,3 ,5 ,7)

val arrayOfChar:CharArray = charArrayOf(“i”,”a”,”m")

val arrayOfString:Array<String>=arrayOf( “me”,”is” ,”god"); //字符串数组

 

 

基本操作

    1、数组的大小

    arrayOfInt.size 

    2、 输出第i个元素：

        println( arrayOf对象名 [i])输出

   3、 给第i个元素赋值：

       array[i] =Hello（“给第i个成员赋值”）

   4、 拼接整个元素并去除其中的默认“，”

        arrayOfChar .joinToString( “” ) //去除中间的，

    5、字符串切割：取值array中的第2个和第3个元素

       arrayOfInt .slice( 1..2 ) //传入的是一个闭区间的元素

 

数组类型映射

Java type:  int[]  / String []

Kotlin type : kotlin.IntArray /  kotlin.Array<9out) String > !