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

【 

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 in1..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")

}

}

】