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

喜欢ヅ旅行 2022-06-08 06:06 113阅读 0赞

【

15、控制流

*/\*\**

*\* 用来检查和运算各种条件和逻辑的组合，控制App的运行流向.*

*\* 循环：for, while 及 循环控制*

*\* if：二元判断*

*\* when：细致化判断*

*\*/*

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

//for：依次操作一个序列(如集合类型)中的每一项，执行次数是可预测的

val numbers =  *arrayOf*( 1 , 2 ,  3 , 4)

for (number in numbers) \{

// println(number)

//重复执行：for(a in 1..10)\{//操作\}

for (a in 1.. 100) \{

// println("重要的事情说100遍。。。。")

//while：循环执行一系列操作，直到条件不成立，适合执行次数未知的场合

//Q：1加到多少次，才能加到15050？

var number =  1

var times = 0

var total = 0

while (total <  15050) \{

total += number ;

number += 1

times += 1

if (total ==  5050) \{

break // break 结束整个循环

*println*( "加到多少次才能达到要求: $\{ times \} ")

//循环中的控制：continue 结束本次循环 ， break 结束整个循环

for (number in numbers) \{

if (number ==  3) \{

continue //continue 结束本次循环

// println(number)

//if：条件判断语句，整个语句本身是一个表达式(可用于简单的二元判断计算)

var a = 5

var b = 8

var result =  if (a > b) "大于"  else 3

*println*(result)

//when：可对某个变量的大小/范围/表达式/类类型进行判断:筛选判断，其中的条件都是互斥的

when (result) \{

in 4.. 10 \-> \{ //in:在范围内 !in:不在范围内

*println*( "0到10之间")

/\* (9 - 6) -> \{

println("值是3")

\}\*/

18 , 25 , 32 \->\{

*println*( "值是18,25,32")

is Int ->\{ //is:判断是某类型

*println*( "值是Int类型")

else \-> \{ //以上条件不满足，执行此语句

*println*( "未知")

16、函数

*/\*\**

*\* 函数是有名字的一段代码块.*

*\* 包含参数和返回值(可选)，参数可以有moren4值.*

*\*/*

fun add(x: Int , y: Int = 0): Int \{

return x + y

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

//F1函数名看文档

//调用时可打参数名，可读性更好(但调用Java函数无效)

// val b = add(x = 2,y = 3)

val b = *add*( 2 , 3)

*println*(b)

//可变参数调用

val sum =  *sum*( 1 , 12 , 23 , 45 , 2 , 56)

*println*( "可变参数调用返回结果： $\{ sum \} ")

var a = *intArrayOf*( 1 , 12 , 23 , 45 , 2 , 56 , 12 , 5 , 20)

*println*( "可变参数调用返回结果,参数为数组： $\{  *sum*(\*a) \} ")

//可变参数修饰符vararg, 可以直接接收数组

fun sum( vararg x: Int): Int \{

var total = 0

for (i in x)\{

total += i

return total

17、Lambda和高阶函数

*/\*\**

*\* 高阶函数：参数或返回值的类型是函数型*

*\* 函数型：(参数) -> 返回值*

*\* lambda：一种无名函数的简写 \{ （参数）-> 函数执行语句 \}*

*\* 其他语言称闭包，即有能力访问其自身范围外的变量*

*\*/*

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

//高阶函数：描叙任务的结果，而不是使用循环详细推算

//map：常用于对集合类型的元素类型整体转变

//其lambda中参数的约定名称为it

val a = *arrayOf*( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 , 12)

val b = a. *map* **\{**  "第 $\{  **it** \} " **\}** //参数是一个函数，此处采用的是闭包

for (s in b) \{

*println*(s)

//排序

// a.sortBy \{ \}

//filter：对集合类型进行筛选

var sum = 0

/\* val c = a.filter \{ it % 2 == 0 \} //闭包可以访问自身范围外的变量

for (i in c) \{

println("返回筛选后的元素：$\{i\}")

\}\*/

a. *filter*  **\{ it** % 2 ==  0 **\}**. *forEach* **\{**

sum += **it**

*println*(sum)

**\}**

//分组

// a.groupBy \{ \}

18、面向对象编程简介

*/\*\**

*\* 面向对象编程*

*\* 对某种事物进行抽象化，称为"建模(model)",就是提取生物的基因*

*\* 一个建模称之为一个类(class),从而简化认知，找到规律*

*\* 特征和属性：需氧/厌氧，寿命(多方因素影响) -- 变量(属性)*

*\* 功能和行为：进食，奔跑，睡觉，卖萌 -- 函数(方法)*

*\* 繁殖：继承和多态*

*\**

*\* 要创建一个具体的生物，必须给予配置参数，即"实例化(instance)"*

*\*/*

19、类定义及构造器

*/\*\**

*\* 类定义及构造器*

*\*/*

//快捷定义：class 类名 constructor(属性列表)\{更多的属性和方法描述\}

//构造器：用来设置类的新实例出厂配置

//类的定义，如果设置一个类能否被继承，要加open关键字修饰。

open class Chinese  constructor( var  sex: Boolean , var  region: String) \{

//类的继承,添加了默认属性

class Shanghainin(sex: Boolean , region: String = "sh") : Chinese(sex , region) \{

//类的继承，无默认属性

class Sichuanwa(sex:Boolean ,region: String):Chinese(sex ,region) \{

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

//实例化一个类

val xioayaoming = Shanghainin( true)

*println*( "xioayaoming-sex： $\{ xioayaoming. sex \} \--region： $\{ xioayaoming. region \} ")

val xiaoguojinming = Sichuanwa( true, "四川")

*println*( "xiaoguojinming-sex： $\{ xiaoguojinming. sex \} \--region： $\{ xiaoguojinming. region \} ")

20、普通属性和组合属性

*/\*\**

*\* 普通属性和组合属性*

*\*/*

//快捷定义：class 类名 constructor(属性列表)\{更多的属性和方法描述\}

//构造器：用来设置类的新实例出厂配置

//类的定义，如果设置一个类能否被继承，要加open关键字修饰。

open class ChineseA  constructor( var  sex: Boolean , var  region: String) \{

//普通属性，与变量定义相似

var skin = "yellow"

//组合属性，由其他属性计算而来(get)

val avgLife : Double

get()\{

when( this. region)\{

"sh"\->\{

return 82.4

"安徽"\->\{

return 77.8

else \->\{

return 77.4

//组合属性反过来可以影响其他属性(set,可选)，this代表实例

var avgSalary : Int

get() \{

when ( this. region) \{

"sh" \-> \{

return 4900

"ah"\->\{

return 3200

else \-> \{

return 3000

set(value) \{

when (value) \{

in 4500..Int. MAX\_VALUE \-> \{

this. region = "sh"

in 2800.. 3500\->\{

this. region = "ah"

else \-> \{

this. region = "other region"

21、子类中的属性和属性覆盖

//类的继承,添加了默认属性

class ShanghaininB(sex: Boolean , region: String = "sh") : ChineseB(sex , region) \{

var dialect = "我港吴侬软语" //子类中新增的属性

//属性覆盖,父类属性需加open,子类覆盖的属性前要加override

override var  skinb = "shanghaiYellow"

//类的继承，无默认属性

class SichuanwaB(sex:Boolean ,region: String):ChineseB(sex ,region)\{

var dialect = "四川普通话" //子类中新增的属性

override var  skinb = "sichuanYellow"

22、方法

*/\*\**

*\* 方法*

*\*/*

open class ChineseC  constructor( var  sex: Boolean , var  region: String) \{

//普通属性，与变量定义相似

open var skinb = "yellow"

//组合属性，由其他属性计算而来(get)

val avgLife: Double

get() \{

when ( this. region) \{

"sh" \-> \{

return 82.4

"安徽" \-> \{

return 77.8

else \-> \{

return 77.4

//组合属性反过来可以影响其他属性(set,可选)，this代表实例

var avgSalary: Int

get() \{

when ( this. region) \{

"sh" \-> \{

return 4900

"ah" \-> \{

return 3200

else \-> \{

return 3000

set(value) \{

when (value) \{

in 4500..Int. MAX\_VALUE \-> \{

this. region = "sh"

in 2800.. 3500 \-> \{

this. region = "ah"

else \-> \{

this. region = "other region"

//方法：厨艺

fun cook() \{

val menu =  *arrayOf*( "青椒炒肉丝" , "番茄炒蛋" ,  "紫菜蛋汤")

val desc = menu. *reduce* **\{**  s1 , s2 **->** s1 + ","\+ s2 **\}**

*println*( "我会 $\{ desc \} ")

//类的继承,添加了默认属性

class ShanghaininC(sex: Boolean , region: String = "sh") : ChineseC(sex , region) \{

var dialect = "我港吴侬软语" //子类中新增的属性

//属性覆盖,父类属性需加open,子类覆盖的属性前要加override

override var  skinb = "shanghaiYellow"

//类的继承，无默认属性

class SichuanwaC(sex: Boolean , region: String) : ChineseC(sex , region) \{

var dialect = "四川普通话" //子类中新增的属性

override var  skinb = "sichuanYellow"

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

//实例化一个类

val xioayaoming = ShanghaininC( true)

// println("xioayaoming-sex：$\{xioayaoming.sex\}--region：$\{xioayaoming.region\}")

xioayaoming. avgSalary =  3000

*println*(xioayaoming. region)

*println*(xioayaoming. dialect)

xioayaoming.cook() //调用方法

val xiaoguojinming = SichuanwaC( true, "四川")

// println("xiaoguojinming-sex：$\{xiaoguojinming.sex\}--region：$\{xiaoguojinming.region\}")

23、方法的覆盖和加成

*/\*\**

*\* 方法的覆盖和加成*

*\*/*

open class ChineseD  constructor( var  sex: Boolean , var  region: String) \{

//普通属性，与变量定义相似

open var skinb = "yellow"

//组合属性，由其他属性计算而来(get)

val avgLife: Double

get() \{

when ( this. region) \{

"sh" \-> \{

return 82.4

"安徽" \-> \{

return 77.8

else \-> \{

return 77.4

//组合属性反过来可以影响其他属性(set,可选)，this代表实例

var avgSalary: Int

get() \{

when ( this. region) \{

"sh" \-> \{

return 4900

"ah" \-> \{

return 3200

else \-> \{

return 3000

set(value) \{

when (value) \{

in 4500..Int. MAX\_VALUE \-> \{

this. region = "sh"

in 2800.. 3500 \-> \{

this. region = "ah"

else \-> \{

this. region = "other region"

//方法：厨艺

open fun cook() \{

val menu =  *arrayOf*( "青椒炒肉丝" , "番茄炒蛋" ,  "紫菜蛋汤")

val desc = menu. *reduce* **\{**  s1 , s2 **->** s1 + "," \+ s2 **\}**

*println*( "我会 $\{ desc \} ")

//类的继承,添加了默认属性

class ShanghaininD(sex: Boolean , region: String = "sh") : ChineseD(sex , region) \{

var dialect = "我港吴侬软语" //子类中新增的属性

//属性覆盖,父类属性需加open,子类覆盖的属性前要加override

override var  skinb = "shanghaiYellow"

//类的继承，无默认属性

class SichuanwaD(sex: Boolean , region: String) : ChineseD(sex , region) \{

var dialect = "四川普通话" //子类中新增的属性

override var  skinb = "sichuanYellow"

//方法的覆盖,要加override并且父类方法加open修饰

override fun  cook() \{ //加成，在父类原有的基础上有所发展，叫多态。

super.cook()  //继承父类的方法

val menu =  *arrayOf*( "麻婆豆腐" , "重庆毛血旺" ,  "诸葛烤鱼")

val desc = menu. *reduce* **\{**  s1 , s2 **->** s1 + "," \+ s2 **\}** //将数组合成字符串

*println*( "我还会 $\{ desc \} ")

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

//实例化一个类

val xioayaoming = ShanghaininD( true)

// println("xioayaoming-sex：$\{xioayaoming.sex\}--region：$\{xioayaoming.region\}")

xioayaoming. avgSalary =  3000

*println*(xioayaoming. region)

*println*(xioayaoming. dialect)

xioayaoming.cook() //调用方法

val xiaoguojinming = SichuanwaD( true, "四川")

// println("xiaoguojinming-sex：$\{xiaoguojinming.sex\}--region：$\{xiaoguojinming.region\}")

xiaoguojinming.cook()

24、可见性修饰符

*/\*\**

*\* 可见性修饰符*

*\* 设定类本身及其属性，方法，构造器*

*\* 以及接口和对象的对外的访问权限，即"可见性"*

*\**

*\* 举个例子：生物都有内脏，这个"内"其实就是私有属性*

*\* private 私有：仅当前类可见，最小的可见性*

*\* protected 保护：仅子类可见*

*\* internal 内部：当前模块内可见*

*\* public 公开：\*默认，对外完全可见*

*\*/*

25、嵌套类

*/\*\**

*\* 嵌套类*

*\*/*

//新闻类

class News\{

//默认地区

private var lang = "cn"

//新闻分类：嵌套类 与主类关系并不是十分紧密，只是一个形式上的合作，主从关系。

class Category\{

var list = *arrayOf*( "推荐" , "娱乐" , "体育" , "科技" , "美女")

val listDesc = list. *joinToString*() //将数组转成一个逗号分隔的字符串

//内部类：新闻语种. 通常用于不直接对外的类，为主类服务的。

inner class Lang\{

fun changeRegion(newRegion : String)\{

//内部类可以访问主类的属性

lang = newRegion

*println*( "现在可以查看 $\{ newRegion \} 地区的新闻了!")

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

//显示中国地区的新闻列表. 使用嵌套类

*println*(News.Category(). listDesc)

//更改新闻地区，内部类的调用：内部类必须依赖主类的实例，再加上自身的实例才能使用。

News().Lang().changeRegion( "us")

】

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

发表评论取消回复

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

相关阅读

相关 Kotlin学习之基础数据类型

相关 Kotlin学习笔记 | 函数基础

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

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

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

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

相关 Kotlin学习之 4基础语法

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

相关 Kotlin学习-基础语法

相关 Kotlin 基础语法