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

【

15、控制流

{

/\**

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

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

\ if：二元判断*

\ when：细致化判断*

\/*

fun main(args: Array) {

//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) {

//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) {

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

//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) {

//实例化一个类

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) {

//实例化一个类

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) {

//实例化一个类

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) {

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

println(News.Category(). listDesc)

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

News().Lang().changeRegion( “us”)

}

}

】