Kotlin语法 入门篇章（1）
作者：互联网
| 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 | 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