Kotlin一步一个脚印学习基础一

淩亂°似流年 2022-06-08 03:05 179阅读 0赞

【

\#\#为什么选择它？---1、Google官方指定 2、简洁、现代、安全 3、无缝兼容Java

\#\#Basic：@1：IDE安装 @2：常量和变量、赋值、常量和变量的关系、代码注释 @3：整数型、浮点型、类型安全、布尔型、元组、可空类型。

\#\#Operalor&Type：@1、String-字符串和字符 @2、Collection-数组、Map、集合：一次处理多个类型的元素 @3、控制流-根据逻辑条件控制程序运行流向。

\#\#Function & Lambda：@1、函数 @2、Lambda @3、行内函数 @4、高级函数。

\#\#OOP：@1、类和继承、属性、权限修饰符 @2、嵌套、数据类、封印类 @3、枚举类、对象声明和表达式。

@4、错误处理 @5、类型检查。

\#\#Interface：@1、接口实现 @2、接口中的属性 @3、接口冲突规则。

\#\#Extensions：@1、函数拓展 @2、属性拓展 @3、伴生对象拓展 @4、拓展成员。

\#\#Generics<泛型>：@1、型变 @2、类型投影 @3、泛型函数和泛型约束

1、开发工具：IntelliJ IDEA \{JetBrains

fun main(args: Array<String>) \{

*print*( "Hello World 世界你好！")

2、常量：

*/\*\**

*\* 预期范围内恒定不变的量*

*\**

*\* 定义：val 常量名(任意文字、长度不限)*

*\* 给常量一个值，叫"赋值"，形式 val 常量名 = 值*

*\*/*

val  *pai* = 3.14159

val  *girl* = 1

val  *wages* = 7000

3、变量：

*/\*\**

*\* 可主动变更或者预期内自动有规律或者无规律的量*

*\**

*\* 比如：每天的清醒时间、个人前途。。。。*

*\*/*

//空调开机时间

var  *airConditionerOpenTime* = 5

4、整数型：

*/\*\**

*\* 值的类型*

*\* 3这样的整数，在Kotlin中称为Int类型的值*

*\* 形式：var 变量名 : Int = 3*

*\* 由于Kotlin有类型推断，类型可以省略不写*

*\*/*

//var run : Int = 5

fun  main(args: Array<String>) \{

var run = 5

run = 6

*print*( "每天跑 $\{ run \} 公里")

5、浮点型

*/\*\**

*\* 浮点型(小数)*

*\* Kotlin 中默认的浮点型是Double(双精度)*

*\*/*

fun  main(args: Array<String>) \{

val pi = 3.14159267532

*print*( "圆周率 $\{ pi \} ")

6、类型安全

*/\*\**

*\* 类型安全：变量一旦定义，其类型不可更改。*

*\* 即：不能给变量一个类型不同的值*

*\* 类型安全的JavaScript:TypeScript*

*\*/*

fun  main(args: Array<String>) \{

var 电费 = 3.6

// 电费 = "5毛" //类型安全,其类型不可更改。

*print*( "电费 $\{ 电费 \} ")

7、布尔型

*/\*\**

*\* 布尔型:Boolean*

*\*/*

fun main(args: Array<String>) \{

var vip = false

*print*( "布尔值 $\{ vip \} ")

8、元组(Tuple)

*/\*\**

*\* 元组(Tuple)，给多个变量同时赋值，分二元(Pair)和三元(Triple)*

*\*/*

fun main(args: Array<String>) \{

val (day ,method ,course) = Triple( 3 , "学会" , "Kotlin") //三元

*println*( " $\{ day \} 天 $\{ method \}$\{ course \} ")

val (desc ,toll) = Pair( "学费" , 0) //二元

*println*( " $\{ day \} 天 $\{ method \}$\{ course \}$\{ desc \}$\{ toll \} 元")

val peopleName = Pair( "王" , "五")

*println*( "此人的姓名为: $\{ peopleName. first \}$\{ peopleName. second \} ")

9、可空类型

*/\*\**

*\* 可空类型（据说这个发明价值$1000000000）*

*\**

*\* 代表变量可能没有值的情况*

*\* 如：用户资料的选填部分，如住址/性别等辅助信息*

*\* 形式：var 变量 : 类型?,无值则是null*

*\*/*

fun main(args: Array<String>) \{

var addr: String? =  "上海师范大学东校区" //类型后加?代表可空类型

var sex:Boolean? =  null

if(addr != null)\{

println( "您的地址是 $\{ addr \} ")

sex = false

if(sex != null && sex)\{

println( "您的男生")

\} else\{

println( "您的女生")

10、可空类型

*/\*\**

*\* 可空类型（据说这个发明价值$1000000000）*

*\**

*\* 代表变量可能没有值的情况*

*\* 如：用户资料的选填部分，如住址/性别等辅助信息*

*\* 形式：var 变量 : 类型?,无值则是null*

*\*/*

fun main(args: Array<String>) \{

var addr: String? =  "上海师范大学东校区" //类型后加?代表可空类型

var sex:Boolean? =  null

if(addr != null)\{

println( "您的地址是 $\{ addr \} ")

sex = false

if(sex != null && sex)\{

println( "您的男生")

\} else\{

println( "您的女生")

11、基础操作符

*/\*\**

*\* 一个符号或单词，类似数学+、-、\*、/，用于运算或者操作*

*\* 同时操作对象的数目，被称之为几元操作符*

*\*/*

fun main(args: Array<String>) \{

//操作一个目标，是一元操作符

var a = 3

var b = a

var c = -a

*println*( "b: $\{ b \} \--c: $\{ c \} ")

//二元操作符操作2个目标，在2个目标之间，前后用空格分隔

var d = b + c

*println*( "d: $\{ d \} ")

//赋值操作符，用等号右边的值来更新左边变量的值

var e = d

*println*( "e: $\{ e \} ")

//数学操作符：+、-、\*、/

*println*( 3\+ 4)

*println*( 3\- 4)

*println*( 3\* 4)

*println*( 3/ 4)

//赋值与数学操作符的组合，比如+=、-=、\*=、/=

var gdp = 10\_000.0

var gdpGrowth =  6.7/ 100

gdp += gdp\*gdpGrowth

*println*(gdp)

//比较操作符：>、>= 、<、<= 结果是true或false

//逻辑操作符:布尔值的组合，与<&&>/或<||>/非<!>

var havaComputer =  true

var netAvaible =  true

var watchVideo =  false

if(havaComputer && netAvaible || watchVideo)\{

*println*( "你学会Kotlin不成问题!")

\} else\{

*println*( "无法学会Kotlin!")

var tt = true

var xx = !tt

*println*(xx)

12、集合类型-数组

*/\*\**

*\* 集合类型 Collection*

*\* 同类型的值的组合，根据整体特性分：*

*\* 1、有序可重复 - Array，索引从0开始(index,i)*

*\* 2、无序不重复 - Set*

*\* 3、无序可重复 - Map，但值有唯一的键(Key) 字典*

*\* 区别：Array数组和List集合的区别，大小是否可变。*

*\*/*

fun main(args: Array<String>) \{

//Array：Array<类型> 或 arrayof（元素1，元素2，...，元素n）

//\#大小固定，元素类型不可变

var nollstations =  *arrayOf*( "嘉定北" , "徐家汇" , "南翔" , "桃浦新村" , "上海西站" , "罗山路" , "迪士尼" , "桃浦新村" , "徐家汇")

for (nollstation  in nollstations) \{

// println(nollstation)

//创建一个有默认值的数组，Array（计数，\{默认值\}）

var nollstionNamePlaces = Array( 20 , **\{**  "临时站名" **\}**)

for (nollstionNamePlace  in nollstionNamePlaces) \{

// println(nollstionNamePlace)

//创建1到10数组：Array（10，\{i ->i+1\}）

//i代表元素的索引值，从0开始。

var oneToTen = Array( 10 , **\{** i **->**i+ 1 **\}**) //通过索引和Lamda表达式给数组赋值,索引默认从0开始

for (i in oneToTen) \{

// println("输出数组元素为:$\{i\}")

//元素计数：count(),空否：isEmpty

/\* println("数组的长度为：$\{oneToTen.count()\}")

println("数组为空：$\{oneToTen.isEmpty()\}")

println("数组不为空：$\{oneToTen.isNotEmpty()\}")\*/

//获取其中元素：数组名\[索引\]，首元素：数组名.first，尾元素：数组名.last

/\* println("获取数组的首元素：$\{oneToTen.first()\}")

println("获取数组元素的尾元素：$\{oneToTen.last()\}")

println("获取数组指定索引(3)位置的值：$\{oneToTen\[3\]\}")\*/

//获取前5个元素的快捷方法.component 1到5

// println("$\{oneToTen.component1()\},$\{oneToTen.component2()\}")

//获取筛选重复元素后的数组：distinct()或用.toSet()转为Set.

var nollStationsNoRepeat = nollstations. *distinct*() //唯一，去重

for (s in nollStationsNoRepeat) \{

// println("通过distinct()去重后的数组元素为：$\{s\}")

var nollStationsNoRepeatToSet = nollstations. *toSet*() //转换成Set集合，去重

for (s in nollStationsNoRepeatToSet) \{

// println("通过toSet()转成集合去重后元素为：$\{s\}")

//切割数组：sliceArray

val nollstationsInNanXiang = nollstations. *sliceArray*( 2.. 3) //规定一个区间

for (s in nollstationsInNanXiang) \{

// println("切割后的数组元素为：$\{s\}")

//mutableList：MutableList<类型>或mutableListOf(元素1,元素2,....,元素n)

//注意：大小可变，类型不可变.

var nollNewsStations =  *mutableListOf*( "嘉定北" , "徐家汇" , "南翔" , "桃浦新村" , "上海西站" , "罗山路" , "迪士尼" ,

"桃浦新村" , "徐家汇" , "嘉定北" , "嘉定新城")

var newStations =  *arrayOf*( "徐家汇" , "嘉定北" , "嘉定新城")

//在末尾增加元素：add方法，添加另一个数组addAll方法

nollNewsStations.add( "花桥")

nollNewsStations. *addAll*(newStations)

for (nollNewsStation  in nollNewsStations. *distinct*()) \{ //去重

// println("添加数组元素后的结果为：$\{nollNewsStation\}")

//移除元素remove,移除指定位置removeAt,移除一个数组

nollNewsStations. *removeAll*(newStations) //移除一个数组

nollNewsStations.removeAt( 0)  //根据下标移除元素

nollNewsStations.remove( "花桥")  //根据元素名移除元素

for (nollNewsStation  in nollNewsStations) \{

// println("移除元素后的数组集合为：$\{nollNewsStation\}")

13、集合类型-Set

*/\*\**

*\* 集合类型 Set：无序不重复*

*\* 主要方法：交差并补*

*\*/*

fun main(args: Array<String>) \{

//Set<类型> 或 setOf(元素1,元素2,...,元素n)

//注意：大小固定,元素类型不可变

//地铁11号线主线："迪士尼","徐家汇","桃浦新村","南翔","马陆","嘉定新城"

//嘉定区支线："嘉定新城","嘉定西","嘉定北"

//江苏昆山支线："嘉定新城","上海赛车场","安亭","花桥"

val mainLine =  *setOf*( "迪士尼" , "徐家汇" , "桃浦新村" , "南翔" , "马陆" , "嘉定新城")

val subkineJd =  *setOf*( "嘉定新城" , "嘉定西" , "嘉定北")

val sublineKs =  *setOf*( "嘉定新城" , "上海赛车场" , "安亭" , "花桥")

//元素计数：count(),空否：isEmpty()

// println("Set集合计数：$\{mainLine.count()\}")

//检查是否包含某元素：contains，包含另一个Set：containsAll

/\* println("Set集合是否包含某个元素：$\{mainLine.contains("徐家汇")\}")

println("Set集合是否包含某个集合：$\{mainLine.containsAll(subkineJd)\}")\*/

//转化为数组：toTypedArray()

mainLine. *toTypedArray*()

//集合之间的运算：intersect<交>/subtract<差>/union<并>/minus<补>(补集的被操作对象无须是Set类型)

val interchage = mainLine. *intersect*(subkineJd) //取交：换乘站

*println*( "换成站为： $\{ interchage \} ")

*println*( "取差集： $\{ mainLine. *subtract*(subkineJd) \} ") //取差集：就是取交集剩下的部分

*println*( "集合元素合并，行程所有站点： $\{ mainLine. *union*(subkineJd). *union*(sublineKs) \} ")

*println*( "获取集合元素的补集： $\{ mainLine. *minus*(subkineJd) \} ")

//转换为可变：toMutableSet

//MutableSet<类型>或mutableSetOf(元素1,元素2,...,元素n)

//注意：大小可变，类型不可变.

val mutableMainline = mainLine. *union*(subkineJd). *union*(sublineKs). *toMutableSet*() //长度可变

//在末尾增加元素：add方法. 添加另一个集合：addAll方法

mutableMainline.add( "光明路")

val newsLine =  *setOf*( "昌吉东路" , "上海汽车城")

mutableMainline.addAll(newsLine)

//移除元素：remove, 移除另一个集合：removeAll

mutableMainline.remove( "昌吉东路")

mutableMainline.removeAll(newsLine)

for (s in mutableMainline) \{

*println*( "最后的集合元素为： $\{ s \} ")

14、集合类型-Map

*/\*\**

*\* 集合类型Map：无序可重复.类型于"字典"字典的概念*

*\* 主要属性：keys (Set),values*

*\* 主要方法：*

*\*/*

fun main(args: Array<String>) \{

//mapOf<key,value>(pair(key,value),...)

//显示指定类型,可防止初始化值类型的错误

//机场："PVG","浦东" "SHA","虹桥" "HGH","萧山"

val airports =  *mapOf* <String,String>(Pair( "PVG" , "浦东国际机场") ,Pair( "SHA" , "虹桥") , Pair( "HGH" , "萧山")) //元组

//元素计数：size,空否：isEmpty()

*println*( "Map集合的大小： $\{ airports. size \} 是否为空 $\{ airports.isEmpty() \} ")

//获取某个key对应的value：get,getOrDefault

*println*( "根据键key-PVG获取值： $\{ airports.get( "PVG") \} ")

*println*( "根据键key获取值不存在返回默认值： $\{ airports.getOrDefault( "PVGs" , "送你去外太空") \} ")

//返回所有的key：keys,所有的value：values

for (key in airports. keys) \{

*println*( "打印Map集合所有ksy的值： $\{ key \} ")

for (value in airports. values) \{

*println*( "打印Map集合所有values的值： $\{ value \} ")

//转换为可变：toMutableMap

val airports2 = airports. *toMutableMap*()

//mutableMapOf<key,value>(Pair(key,value),...)

//添加或更新：下标方法 map变量名\[key\] = value

airports2\[ "PVG"\] =  "上海市浦东新区浦东国际机场" //存在键值，则更新对应的value值

airports2\[ "DLC"\] =  "大连市周水子机场" //不存在键，则新增一条数据

for (mutableEntry  in airports2) \{

// println("打印键值对:($\{mutableEntry.key\},$\{mutableEntry.value\})")

//移除元素：remove

airports2.remove( "PVG")

for (mutableEntry  in airports2) \{

*println*( "移除元素后的集合为：( $\{ mutableEntry. key \} , $\{ mutableEntry. value \} )")

】

Kotlin一步一个脚印学习基础一

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Kotlin学习系列——集合详解(一)

相关 Kotlin基础学习(持续更新)

相关 kotlin 官方学习教程之基础语法

相关 Kotlin一步一个脚印学习基础三

相关 Kotlin一步一个脚印学习基础二

相关 Kotlin一步一个脚印学习基础一

相关 Kotlin教学(一)基础篇

相关 Kotlin学习之 4基础语法

相关 kotlin函数学习，应用笔记（基础篇）

相关 Kotlin学习-基础语法