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

【

     ##为什么选择它？---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})")

}

}

}

】