【
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")
}
}
】
312
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
