其他分享
首页 > 其他分享> > Kotlin语法 入门篇章(1)

Kotlin语法 入门篇章(1)

作者:互联网

Java和Kotlin数据类型对比表
Java基本数据类型 Kotlin对象数据类型 数据类型说明
int Int 整形
long Long 长整型
short Short 短整形
floa Float 单精度浮点型
double Double 双精度浮点型
boolean Boolean 布尔型
char Char 字符型
byte Byte 字节型

 

点击右侧绿色按钮运行

函数:

定义一个方法,接收两个整形参数,返回一个最大值

 

 

 

fun main(){
    print(methodName(2,9))
}

// 函数

// 返回两个数其中一个比较大的值
fun methodName(parame1: Int,parame2:Int):Int{
    return max(parame1,parame2)
}

当函数只有一行代码的时候,我们还能简写,像这样,我们可以将上面的写法简写成这样,输出结果是一样的

fun methodName(parame1:Int,parame2:Int)= max(parame1,parame2)

 

2.判断语句

fun largeNumber(num1:Int,num2:Int):Int{
    var v=0;
    if (num1>num2){
        v=num1
    }else{
        v=num2
    }
    return v
}

这里的写法实现的效果其实和上面的差不多,都是返回一个最大值

kotlin的if语句比相较于Java多了一个功能,那就是可以有返回值,是不是感觉很神奇呢,小编也觉得很神奇,那究竟是怎么一回事呢,快跟着小编来看看吧,事实就是kotlin的if可以携带返回值,而Java的不可以,看到这里你是不是和小编一样感到很神奇呢。小编第一次知道也是感觉感到很神奇,快给小编点个赞吧。

 

 

好了,不沙雕了。

将上面的代码改写为

fun largeNumber(num1: Int, num2: Int): Int {
    val v = if (num1 > num2) {
        num1
    }else{
        num2
    }
    return v
}

注意,这里每个条件最后一行代码作为返回值,最终将变量v返回,直接在main()方法里打印就可以看到结果

 

 

when语句

我们现在做一个查询商品价钱的功能

fun getShopPrice(name:String)=if (name=="香蕉"){
    3
}else if (name=="苹果"){
    5
}else if (name=="菠萝"){
    10
}else{
    0
}

这里定义一个方法,接收一个String类型参数,并返回一个价钱

这里的代码其实还是有些冗余,虽然可以实现很多功能,但是如果判断条件多的时候就应该考虑考虑使用when了

fun getShopPrice(name:String)=when(name){
    "香蕉" ->5
    "苹果"->6
    "菠萝"->9
    else ->0
}

有没有感觉不仅代码更好看了,而且更好看了

 

当代码逻辑只有一行的时候 花括号可省略

 

在when中可以进行类型匹配

fun checkNumber(num:Number){
    when(num){
        is Int -> println("这是一个整形")
        is Double -> println("这是一个双精度浮点型")
        else -> println("不是 num类型")
    }
}

什么是类型匹配??

在kotlin中,Number相当于一个抽象类,Int Long Float Double都是它的子类型,所以这里可以使用类型匹配来判断传入的是什么参数

 

循环语句

熟悉Java的都知道,java有两种循环方式 while和for循环,kotlin也提供这种循环,kotlin对for循环进行了一些修改,for-i在kotlin中被舍弃。

    for (i in 0..10){
        println(i)
    }

.. 是创建两端闭区间的关键字。在 .. 指定区间的左右端点就可以创建一个区间了。

在main方法中写上面那段代码,运行后会打印1-10。

不过,很多时候双端闭区间不如单端闭区间好用。因为数组的下标都是从0开始,一个长度为10的数组,它的下标范围是0-9.因此左闭右开的区间在程序中更常用,kotlin可以使用until来创建一个左闭右开的区间。

    for (i in 0 until 10 step 2){
        println(i)
    }

上述代码表示在[0,10]的时候,每次执行循环都会在区间范围内递增2。打印的结果都是偶数。

此外我们还可以使用 downTo创建一个降序的区间

    for (i in 10 downTo 1){
        println(i)
    }

插入上方代码重新运行就会打印10-1;

 

面向对象

1.类与对象

创建一个类,选择class

 

 

 

class Person {
    var name=""
    var age=0
    
    fun eat(){
        println("这个人叫"+name+"他今年"+age+"岁了")
    }
}

创建name 和age两个字段。不能使用val,使用val之后不能重新赋值,相当于Java中的 final关键字。

实例化这个类

val p=Person()
p.name="小明"
p.age=21
p.eat()

2.继承

 

 

 在Person类的class前面加上open关键字,使其成为可继承

然后新建Student并插入如下代码

 

class Student : Person() {
    var sno=""
    var grade=0
}

这里的继承和java的关键字不同,使用一个冒号即可

kotlin将构造函数分成了两种主构造函数和次构造函数

主构造函数的特点是没有函数体,直接定义在类名后面即可。比如:

class Student(val sno:String,val grade :Int) : Person() {

}

这样写,在实例化Student对象的时候就必须要传入参数

  val s=Student("张益达",25)

init是kotlin提供的一个结构体,可以实现类似主构造函数类似的一些逻辑。

    init {
        println("学号是:"+sno)
    }

 

接口

 

新建一个一个类 New->Kotlin File/Class,输入文件名 Study,创建类型选 Interface

接口类型不需要有函数体

代码:

interface Study {
    fun readBooks()
    fun doHomework()
}

首先把Person类的代码改写为

open class Person(val name:String,val age:Int) {

}

 

接下来到Student中实现这个接口

class Student(name: String,age:Int) : Person(name,age),Study{

}
class Student(name: String,age:Int) : Person(name,age),Study{
    override fun readBooks() {
        println(name+"看书")
    }

    override fun doHomework() {
        println(name+"做家庭作业")
    }

}

 

现在到main中调用这两个函数

 

fun main() {
    val studnt=Student("Jack",19)
    doStudy(studnt)

}
fun doStudy(study: Study){
    study.readBooks()
    study.doHomework()
}

 

 

 

 

 

 

Java和kotlin函数可见性修饰符对照表
修饰符 Java lotlin
public 所有类可见 所有类可见 默认
private 当前类可见 当前类可见
protected 当前类 子类 同一包路径下可见 当前类 子类可见
default 同一包路径下的类可见 默认

          internal                                    无                                                                                                        同一模块中的类可见

 

 

 

数据类与单例类

 

新建一个kotlin类 命名为 Cellphone

代码

data class Cellphone(val brand:String,val price:Double){
}

在main写入如下代码

fun main() {
    
    val cell1=Cellphone("一加",2999.00)
    val  cell2=Cellphone("小米",1999.00)

    println(cell1)
    println(cell1==cell2)
}

运行后输出如下

 

 

 

一定很好奇这些输出的内容是哪里来的吧,这主要归功于data关键字。在kotlin中只要声明了这个关键字,就表示了这是一个数据类,kotlin会根据主构造函数中的参数自动生成 equals(),hashCode() toString(),等固定且无实际逻辑意义的方法,减少很多开发的工作量。

 

单例类

新建一个 kotlin类,输入Singleton,选择创建类型 Object

输入代码如下:

object Singleton {
    fun singletonTest(){
        println("调用单例测试")
    }
}

在main方法中调用 

Singleton.singletonTest()

 

在kotlin中我们班不需要私有化构造函数,也不需要提供getInstance()这样的静态方法。只需要将class关键字换成object,一个单例类创建完成了。

 

Lambda编程

lambda0.1 List集合的创建和遍历
创建一个list集合通常最基础的写法如下。
    val list=ArrayList<String>()
    list.add("1")
    list.add("1")
    list.add("1")
    list.add("1")
    list.add("1")
    list.add("1")
这种写法比较繁琐,为此kotlin提供了一个内置的listof()的函数来初始化集合的写法,如下:
    val list= listOf("1","2","3","4")

遍历

   for (i in list){
        println(i)
    }

不过需要注意,listOf是不可变得集合。该集合只能用于读取,无法进行添加和修改删除操作。如果需要创建一个可变的集合只需要把listOf替换为mutableListOf即可

    val list= mutableListOf("1","2","3","4")

遍历方式和上面的一样

 

lambda0.2 Set集合的创建和遍历

set和list的用法基本一致,只是将创建集合的方式换成了 mutableSetOf和setOf,而set和list最大的区别就是 Set集合底层是使
映射机制来存放数据,因此无法保证元素有序。

    val set= setOf("1","2","3")
    for (s in set){
        println(s)
    }

     最后来看看Map,map是使用 key value的方式存储数据,和list set的用法有较大不同。看代码

 val map=HashMap<String,Int>()
    map.put("a",5)
    map.put("a1",6)
    map.put("a2",7)
    map.put("a3",8)

这种写法与java很相似。但其实kotlin中不建议使用 put 和 get对map数据集进行添加和读取操作。而是推荐使用另一种类似于数组下标的语法结构。比如向map集合加一条数据可以这么写:

 val map=HashMap<String,Int>()
    map["a"]=1

读取可以这么写

val nmeber=map["a"]

当然这不是最简便的写法,我们还可以这么写

 val map= mapOf("a1" to 1,"v" to 2, "b" to 3, "c" to 4)

  这里看似使用 to这个关键字进行关联的,但其实to并非关键字。而是一个 infix的函数。

  最后看下如何遍历map集合

  

    for ((k,v)in map){
        println("键是 "+k+" 值是 "+v)
    }

   

                            集合的函数式API
假定有如下需求 查找一个list中名字最长的水果,常规写法可以这么写。
    val list = listOf("苹果","西红柿","红心龙果")
    var maxLengthFruit=""
    for (f in list){
        if (f.length>maxLengthFruit.length){
            maxLengthFruit=f
        }
    }
    println(maxLengthFruit)

不过如果使用了 集合函数的API这一切都会很简单。

将上面代码改为

    val list = listOf("苹果","西红柿","红心龙果")
    val maxLengthFilter=list.maxBy { it.length }
    println(maxLengthFilter)

上面的代码使用的就是函数式api,只用一行代码就可以实现查询集合中名字最长的水果的名字。

 

来看下Lambda的语法结构

{ 参数名1::参数类型,参数名2:参数类型 -> 函数体}

这是lambda表达式完整的语法结构定义。如果有参数传入到lambda表达式中国,我们需要声明参数列表。参数列表的结尾使用一个 ->符号,表示参数列表

的结束以及函数体的开始,函数体可以编写任意函数代码。

 

将list中的小写全部转大写

 

    val list = listOf("afaagadg","dfdfdafd","fdafdafdffdf")
    val newList=list.map { it.toUpperCase() }
    for (f in newList){
        println(f)
    }

 

其他的函数就自行查看文档吧,不想再写了。

 

标签:入门,val,Int,Kotlin,list,fun,篇章,println,name
来源: https://www.cnblogs.com/inthecloud/p/12903169.html