flutter练习 - flutter基本控件

发表于 2018-12-26 更新于 2019-06-01 分类于 flutter

Flutter 基本控件

Widget

StatelessWidget — 只能用来展示信息，不能有用户交互
StatefulWidget — 可以通过改变状态使得 UI 发生变化

文本 Text

class TestWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Text("text");
  }
}

图片 Image

资源：Image.asset(name);
文件：Image.file(file);
内存：Image.memory(bytes);
网络：Image.network(src);

class TestWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Image.network(
      "http://www.zhangjiaxue.cn/images/avatar.jpg",
      width: 150.0,
      height: 150.0,
    );
  }
}

按钮（ FlatButton ，RaisedButton ）

FlatButton
RaisedButton

class TestWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    var flatBtn = FlatButton(
      //按钮被点击的时候得到回调
      onPressed: () => print('FlatButton pressed'),
      //设置按钮的内容
      child: Text('FlatButton BUTTON'),
    );
    var raisedButton = RaisedButton(
      onPressed: () => print('RaisedButton pressed'),
      child: Text('RaisedButton BUTTON'),
    );
    return raisedButton;
  }
}

文本输入框 TextField

class TestWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
   return Scaffold(
      appBar: AppBar(title: Text("输入")),
      body: TextField(),
    );
  }
}

显示弹框 dialog

class TestWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
   return RaisedButton(
        child: Text("点击按钮弹出Dialog"),
        onPressed: () {
          showDialog(
              // 第一个 context 是参数名，第二个 context 是 State 的成员变量
              context: context,
              builder: (_) {
                return AlertDialog(
                  // dialog 的内容
                  content: Text("提示框"),
                  // actions 设置 dialog 的按钮
                  actions: <Widget>[
                    FlatButton(
                      child: Text('OK'),
                      // 用户点击按钮后，关闭弹框
                      onPressed: () => Navigator.pop(context),
                    )
                  ],
                );
              });
        });
  }
}

布局

Container（容器）

class TestWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Container(
      padding: EdgeInsets.all(8.0),
      margin: EdgeInsets.all(4.0),
      width: 200.0,
      height: 200.0,
      decoration: BoxDecoration(
        // 背景色
        color: Colors.grey,
        // 圆角
        borderRadius: BorderRadius.circular(5.0),
      ),

      // 把文本放在 Container 的中间
      child: Center(
        child: Text('text'),
      ),
    );
  }
}

Row(水平布局)

class TestWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    //水平布局
    return Row(
      // 只有一个子元素的 widget，一般使用 child 参数来设置；Row 可以包含多个子控件，
      // 对应的则是 children。
      children: <Widget>[
        Text('text1'),
        Text('text2'),
        Text('text3'),
        Text('text4'),
      ],
    );
  }
}

Column(竖直布局)

class TestWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    //垂直布局
    return Column(
      children: <Widget>[
        Text('text1'),
        Text('text2'),
        Text('text3'),
        Text('text4'),
      ],
    );
  }
}

Stack(层叠布局)

class TestWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Stack(
      // Aligment 的取值范围为 [-1, 1]，Stack 中心为 (0, 0)，
      // 这里设置为 (-0.5, -0.5) 后，可以让文本对齐到 Container 的 1/4 处
      alignment: const Alignment(-0.5, -0.5),
      children: <Widget>[   
      Container(
          width: 200,
          height: 200,
          color: Colors.blue,
        ),
        Text("text2"),
      ],
    );
  }
}

布局控件

Flexible

Flexible组件可以使Row、Column、Flex等子组件在主轴方向有填充可用空间的能力(例如，Row在水平方向，Column在垂直方向)，但是它与Expanded组件不同，它不强制子组件填充可用空间。

class TestWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
  return new Scaffold(
      appBar: new AppBar(
        title: new Text('水平方向布局'),
      ),
      body: new Row(children: <Widget>[
        new RaisedButton(
          onPressed: () {
            print('点击红色按钮事件');
          },
          color: Colors.red,
          child: new Text('红色按钮'),
        ),
        new Flexible(
          flex: 1,
          child: new RaisedButton(
            onPressed: () {
              print('点击黄色按钮事件');
            },
            color: Colors.yellow,
            child: new Text('黄色按钮'),
          ),
        ),
        new RaisedButton(
          onPressed: () {
            print('点击蓝色按钮事件');
          },
          color: Colors.blue,
          child: new Text('蓝色按钮'),
        ),
      ]),
    );
  }
}

Expanded

Expanded组件可以使Row、Column、Flex等子组件在其主轴方向上展开并填充可用空间(例如，Row在水平方向，Column在垂直方向)。如果多个子组件展开，可用空间会被其flex factor(表示扩展的速度、比例)分割。

class TestWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
  return new Scaffold(
      appBar: new AppBar(
        title: new Text('水平方向布局'),
      ),
      body: new Row(children: <Widget>[
        new RaisedButton(
          onPressed: () {
            print('点击红色按钮事件');
          },
          color: Colors.red,
          child: new Text('红色按钮'),
        ),
        new Expanded(
          flex: 1,
          child: new RaisedButton(
            onPressed: () {
              print('点击黄色按钮事件');
            },
            color: Colors.yellow,
            child: new Text('黄色按钮'),
          ),
        ),
        new RaisedButton(
          onPressed: () {
            print('点击蓝色按钮事件');
          },
          color: Colors.blue,
          child: new Text('蓝色按钮'),
        ),
      ]),
    );
  }
}

非常感谢

Flutter学习指南：UI布局和控件（微信号：玉刚说 YugangTalk），作者：水晶虾饺

flutter控件Flexible和 Expanded的区别，作者：chunchun1230

kotlin练习 - 数组练习

发表于 2018-12-17 更新于 2019-06-01 分类于 kotlin

kotlin练习 - 数组练习

数组创建

使用arrayOf()函数：这种方式无需显示指定数组的长度，但需要依次列出每个数组元素。

fun main(args: Array<String>) {
    //创建包含指定元素的数组
    var arg1 = arrayOf("Java","Kotlin","PHP","Swift")
    var arg2 = arrayOf(0,1,2,3,4,5)
    println("arg1 = ${Arrays.toString(arg1)}")
    println("arg2 = ${Arrays.toString(arg2)}")
}

使用arrayOfNulls()函数：这种方法需要显示指定数组的长度，数组元素全部被初始化为null。

fun main(args: Array<String>) {
    //创建指定长度，元素为null的数组
    var arg3 = arrayOfNulls<Int>(5)
}

使用emptyArray()函数：这种方法会创建一个长度为0的空数组。

fun main(args: Array<String>) {
    //创建长度为0的空数组
    var arg4 = emptyArray<String>()
    var arg5 = emptyArray<Int>()
}

使用Array(size : Int,init ：(Int) -> T )构造器：这种方法需要显示指定数组的长度，并可通过Lambda表达式来动态计算各数组元素的值，

fun main(args: Array<String>) {
    //创建指定长度，使用Lambda表达式初始化数组元素的数组
    var arg6 = Array(5,{(it * 2+97).toChar()})
    var arg7 = Array(6,{"fkit"})
    println("arg6 = ${Arrays.toString(arg6)}")
    println("arg7 = ${Arrays.toString(arg7)}")
}

其他 Array：Kotlin专门提供了 ByteArray、ShortArray、IntArra、LongArray、CharArray、FloatArray、DoubleArray、BooleanArray 分别对应java中的 byte[]、short[]、int[]、long[]、char[]、floar[]、double[]、boolean[] 这8种基本数据类型的数组。

fun main(args: Array<String>) {
    var intArr = intArrayOf(2,3,4,5,6)
    var doubleArr = doubleArrayOf(2.1,2.2,2.3,2.4)
    var intArr2 = IntArray(5,{it*it})
    var charArr = CharArray(5,{(it*2+97).toChar()})

    println("intArr = ${Arrays.toString(intArr)}")
    println("doubleArr = ${Arrays.toString(doubleArr)}")
    println("intArr2 = ${Arrays.toString(intArr2)}")
    println("charArr = ${Arrays.toString(charArr)}")
}

数组使用

get(index) 方法，set(index，value)方法

fun main(args: Array<String>) {
    var strArray = arrayListOf<String>("Java","Kotlin","Go","Swift")
    println(strArray[1])//Kotlin
    println(strArray.get(1))//Kotlin
    strArray.set(0,"Python")
    strArray[2] = "Groovy"
    println(strArray.toString())//[Python, Kotlin, Groovy, Swift]
}

数组遍历

fun main(args: Array<String>) {
    var books = arrayListOf<String>("疯狂java讲义", "疯狂android讲义", "疯狂kotlin讲义")
    for (book in books) {
        println(book)
    }
    for (i in 0 until books.size) {
        println(books[i])
    }
    //根据数组的索引来遍历数组
    for (i in books.indices){//索引 = size -1
        println(books[i])
    }
    for ((index,value) in books.withIndex()){//索引 = size -1
        println("索引为${index}的元素为：${value}")
    }
}

数组常用方法

var indexs = arrayOf<Int>(1, 2, 3, 4, 5, 6, 7, 8, 9)
 //所有元素都要满足条件则返回 true
 var isAll = indexs.all { x -> x > 0 && x < 10 }
 print(isAll)//true
 //任一数组元素满足条件则返回 true
 var isAny = indexs.any { x -> x == 9 }
 println(isAny)//true
 //将数组转为List集合
 var indexList = indexs.asList()
 println(indexList.toString())
 //返回Map集合
 var indexMap1 = indexs.associate { x -> x to x * x }
 println(indexMap1.toString())//{1=1, 2=4, 3=9, 4=16, 5=25, 6=36, 7=49, 8=64, 9=81}
 var indexMap2 = indexs.associate { it to it * it }
 println(indexMap2.toString())//{1=1, 2=4, 3=9, 4=16, 5=25, 6=36, 7=49, 8=64, 9=81}
 //返回Map集合
 var indexMap3 = indexs.associateBy { it * it }//Map<K,T>中的K
 println(indexMap3.toString())//{1=1, 4=2, 9=3, 16=4, 25=5, 36=6, 49=7, 64=8, 81=9}
 var indexMap4 = indexs.associateBy({ it }, { it * it })
 println(indexMap4.toString())//{1=1, 2=4, 3=9, 4=16, 5=25, 6=36, 7=49, 8=64, 9=81}
 var indexMap5 = indexs.associateBy({ it * it })//Map<K,T>中的K
 println(indexMap5.toString())//{1=1, 4=2, 9=3, 16=4, 25=5, 36=6, 49=7, 64=8, 81=9}
 //在将数组转成的Map集合插入map，最后返回修改后的map
 var map6 = mutableMapOf(10 to 100, 11 to 121, 12 to 144)
 var indexMap6 = indexs.associateByTo(map6, { it }, { it * it })
 println(map6.toString())//{10=100, 11=121, 12=144, 1=1, 2=4, 3=9, 4=16, 5=25, 6=36, 7=49, 8=64, 9=81}
 //在将数组转成的Map集合插入map，最后返回修改后的map
 var map7 = mutableMapOf(10 to 100, 11 to 121, 12 to 144)
 var indexMap7 = indexs.associateTo(map7, { it to it * it })
 println(map7.toString())//{10=100, 11=121, 12=144, 1=1, 2=4, 3=9, 4=16, 5=25, 6=36, 7=49, 8=64, 9=81}
 //数组平均值
 var average = indexs.average();
 println("平均值为$average")//5.0
 //通过二分法查询element出现的索引，如果找不到则返回负数-------要求数组中的元素已经按升序排序
 var binarySearch1 = indexs.binarySearch(4, 0, 3)
 println("4在数组(数组从第一个元素,到第三个元素)中的位置：$binarySearch1")//-4
 var binarySearch2 = indexs.binarySearch(4)
 println("4在数组中的位置：$binarySearch2")//3
 //判断数组中是否包含元素
 var contains = indexs.contains(10);
 println("数组中是否有元素10：${contains}")//false

 var indexs1 = arrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
 //判断两个数组是否相等
 var contentDeepEquals = indexs.contentDeepEquals(indexs1)
 println("两个数组是否相等：${contentDeepEquals}")//true
 //将数组转成String
 var str_index = indexs.contentToString();
 println(str_index)//[1, 2, 3, 4, 5, 6, 7, 8, 9]
 //复制数组成为一个新数组
 var copyof1 = indexs.copyOf()
 println("copyof1 = ${copyof1.contentToString()}")//[1, 2, 3, 4, 5, 6, 7, 8, 9]
 indexs[0] = 0;
 println("copyof1 = ${copyof1.contentToString()}")//[1, 2, 3, 4, 5, 6, 7, 8, 9]
 indexs[0] = 1;
 var copyof2 = indexs.copyOf(5)
 println("copyof2 = ${copyof2.contentToString()}")//[1, 2, 3, 4, 5]
 var copyof3 = indexs.copyOf(10)
 println("copyof3 = ${copyof3.contentToString()}")//[1, 2, 3, 4, 5, 6, 7, 8, 9, null]
 //复制数组（通过索引指定）
 var copyOfRange1 = indexs.copyOfRange(0, 10)
 println("copyOfRange1 = ${copyOfRange1.contentToString()}")//[1, 2, 3, 4, 5, 6, 7, 8, 9, null]
 indexs[0] = 10
 println("copyOfRange1 = ${copyOfRange1.contentToString()}")//[1, 2, 3, 4, 5, 6, 7, 8, 9, null]
 indexs[0] = 1
 var copyOfRange2 = indexs.copyOfRange(0, 5)
 println("copyOfRange2 = ${copyOfRange2.contentToString()}")//[1, 2, 3, 4, 5]
 //数组满足条件的数量
 var count1 = indexs.count({ it > 5 })
 println("数组中大于5的元素有：${count1}个")//4

 var indexs2 = arrayOf(1, 2, 3, 1, 4, 2, 3, 4, 1)
 //去掉数组中重复的元素
 var indexs2_distinct1 = indexs2.distinct()
 println(indexs2_distinct1.toString())//[1, 2, 3, 4]
 var indexs2_distinct2 = indexs2.distinctBy { it % 2 == 0 }
 println(indexs2_distinct2.toString())//[1, 2]

 //去掉数组中前3个元素
 var drop = indexs.drop(3);
 println(drop.toString())

 //去掉前面满足条件的元素，当出现第一个条件不满足时，返回后面的所有元素
 var dropWhile = indexs.dropWhile { it <= 3 }
 println(dropWhile.toString())//[4, 5, 6, 7, 8, 9]

 //去掉数组中后3个元素
 var dropLast = indexs.dropLast(3);
 println(dropLast.toString())//[1, 2, 3, 4, 5, 6]

 //去掉前面满足条件的元素，当出现第一个条件不满足时，返回前面的所有元素
 var dropLastWhile = indexs.dropLastWhile { it > 6 }
 println(dropLastWhile.toString())//[1, 2, 3, 4, 5, 6]

 //将数组中的元素赋值为element
 var indexs4 = arrayOf<Int>(1, 2, 3, 4, 5, 6, 7, 8, 9)
 indexs4.fill(3)
 println(indexs4.contentToString())//[3, 3, 3, 3, 3, 3, 3, 3, 3]

 var indexs5 = arrayOf<Int>(1, 2, 3, 4, 5, 6, 7, 8, 9)
 indexs5.fill(3, 0, 5);
 println(indexs5.contentToString())//[3, 3, 3, 3, 3, 6, 7, 8, 9]

 var first1 = indexs.first()
 println("数组的第一个元素：${first1}")//1
 var first2 = indexs.first { it > 5 }
 println("数组的第一个满足条件的元素：${first2}")//6

 var last1 = indexs.last()
 println("数组的最后一个元素：${last1}")//9
 var last2 = indexs.last { it > 5 }
 println("数组的最后一个满足条件的元素：${last2}")//9

 //求和
 var fold = indexs.fold(0, { acc, i -> acc + i })
 println("数组元素和为：${fold}")
 //搜索元素查询的位置
 var index1 = indexs.indexOf(5)//从前往后
 var index2 = indexs.lastIndexOf(5)//从后往前
 println("元素5在数组中的位置是：${index1}和${index2}")

 var indexs6 = arrayOf(1, 2, 3, 1, 4, 2, 3, 4, 1)
 var index3 = indexs6.indexOfFirst { it == 3 }//第一次出现的位置
 var index4 = indexs6.indexOfLast { it == 3 }//最后一次查询的位置
 println("元素3在数组中第一次出现在${index3},最后一次出现在${index4}")//2,6

 var indexs7 = arrayListOf<Int>(3, 4, 5, 6, 7, 8, 9)
 var indexs8 = arrayListOf<Int>(1, 2, 5, 6)
 //intersect(交集)，subtract(差集)，union(并集)，minus(补集)
 var intersect = indexs7.intersect(indexs8)
 var subtract = indexs7.subtract(indexs8)
 var union = indexs7.union(indexs8)
 var minus = indexs7.minus(indexs8)
 println("交集：${intersect}")//[5, 6]
 println("差集：${subtract}")//[3, 4, 7, 8, 9]
 println("并集：${union}")//[3, 4, 5, 6, 7, 8, 9, 1, 2]
 println("补集：${minus}")//[3, 4, 7, 8, 9]
 //数组最大值
 var max = indexs.max();//9
 //数组最小值
 var min = indexs.min();//1
 println("数组中的最大值：${max} 最小值：${min}")

 var indexs9 = arrayListOf<Int>(1, 9, 3, 7, 2, 5, 4, 6, 8)
 //排序
 indexs9.sort();
 println(indexs9)//[1, 2, 3, 4, 5, 6, 7, 8, 9]
 //排序
 val mapList = mutableListOf(1 to "A" , 2 to "B", 5 to "C", 3 to "D")
 mapList.sortBy { it.first }
 println(mapList) // [(1, A), (2, B), (3, D), (5, C)]
 mapList.sortBy { it.second }
 println(mapList) // [(1, A), (2, B), (5, C), (3, D)]

kotlin练习 - 循环练习

发表于 2018-12-16 更新于 2019-06-01 分类于 kotlin

kotlin练习 - 循环练习

for-in 循环

for-in 循环语法格式
for（常量名 in 字符串|范围|集合）{}

//循环打印1-10
fun main (args : Array<String>){
for(num in 1..10){
    println("num = $num")
}
}

while 循环

while循环语法格式
[init_statements]
while (test_expression){
body_statements
[iteration_statements]
}
while每次在执行循环体之前，都要先对test_expression 循环条件求值，如果循环条件为真，则运行循环体。从上面的语法格式来看，迭代语句 iteration_statements 总是位于循环体的最后，因此只有当循环体能成功执行完成时，while循环才会执行迭代语句iteration_statements；如果test_expression 循环条件为假，则循环体部分将不会执行。

//循环 0-10
fun main (args : Array<String>){
    var num =0
    println("循环开始")
    while (num<10){
        println("num = $num")
        //迭代语句
        num++
    }
    println("循环结束")
}

do while 循环

do while循环语法格式
[init_statements]
do{
body_statements
[iteration_statements]
} while (test_expression){
}
do while 循环先执行循环体，再判断循环条件，如果条件为真，则执行下一次循环，否则中止循环

fun main (args : Array<String>){
    var num =0
    println("循环开始")
    do{
        println("num = $num")
        num++
    }while (num<10)
    println("循环结束")
}

嵌套循环

使用 for-in 和 while 嵌套循环

fun main (args : Array<String>){
    println("循环开始")
    for(i in 0 until 10){//0-9
        var j = 0
        while (j<3){
            println("i = $i +，j = ${j++}")
        }
    }
    println("循环结束")
}

控制循环

使用break结束循环

fun main(args: Array<String>) {
    println("循环开始")
    for (i in 0..10) {//0-10
        println("i = $i")
        if (i==3){
            break//结束循环
        }
    }
    println("循环结束")
}

使用标识符@

fun main(args: Array<String>) {
    println("循环开始")
    outer@ for (i in 0..10) {//0-10
        for (j in 0 until 3){//0-2
            println("i = $i ,j = $j")
            if(j==1){
                //跳出outer标签所标识的循环
                break@outer
            }
        }
    }
    println("循环结束")
}

运行结果：
    循环开始
    i = 0 ,j = 0
    i = 0 ,j = 1
    循环结束

** 代码解释：
程序从外层循环进入内层循环后，当j等于1时，程序执行break@outer语句，这条语句将会结束outer@标签指定的循环。（并不是结束break所在的内层循环，而是结束 outer@标签所标识的外层循环）
** 注意：
通常警跟break之后的标签，必须在break所在的循环的外层循环之前定义才有意义

使用continue忽略本次循环剩下的语句

使用continue结束本次循环

fun main(args: Array<String>) {
    println("循环开始")
    for (i in 0..10) {//0-10
        if (i == 2) {
            continue//结束本次循环
        }
        println("i = $i")
    }
    println("循环结束")
}

使用标识符@

fun main(args: Array<String>) {
    //外层循环
    outer@ for (i in 0..3) {//0-3
        // 内层循环
        for (j in 0 until 3){//0-2
            println("i = $i ,j = $j")
            if(j==1){
                //忽略outer标签所标识的循环中当次循环剩下的语句
               continue@outer
            }
        }
    } 
}
循环结果：
    i = 0 ,j = 0
    i = 0 ,j = 1
    i = 1 ,j = 0
    i = 1 ,j = 1
    i = 2 ,j = 0
    i = 2 ,j = 1
    i = 3 ,j = 0
    i = 3 ,j = 1

代码解释
程序从外层循环进入内层循环后，当j等于1时，程序执行continue@outer语句，这条语句将会结束outer@标签指定的循环的当次循环，直接开始下一次循环，内层循环没有机会执行完成。

使用return结束方法

使用return语句结束函数或方法

fun main(args: Array<String>) {
    println("循环开始")
    text()
    println("循环结束")
}
fun text(){//循环到3后，结束循环
for(i in 0 until 10){//0-9
println("i = $i")
    if(i==3){
        return
    }
    //当i等于3时，无法执行
    println("循环中...")
}
}

kotlin练习 - when分支结构练习

发表于 2018-12-16 更新于 2019-06-01 分类于 kotlin

kotlin练习 - when分支练习

when表达式

when(expression){
expression1 ->	statements...
expression2 -> statements...
else -> statements...
}

例子1

fun main(args: Array<String>) {
    var score = 'B'
    when (score) {
        'A' -> println("优秀")
        'B' -> println("良好")
        'C' -> println("中")
        'D' -> println("及格")
        else -> println("不及格")
    }
}

例子2

fun main(args: Array<String>) {
    var score = 'c'
    when (score) {
        'A', 'a' -> println("优秀")
        'B', 'b' -> println("良好")
        'C', 'c' -> println("中")
        'D', 'd' -> println("及格")
        else -> {
            println("不及格")
        }
    }
}

例子3

fun main(args: Array<String>) {
    var score = 'A'
    var str = "EFGH"
    when (score) {
        str[0]-4,str[1]-4 -> println("优秀")
        str[2]-4,str[3]-4  -> println("中")
        else -> {
            println("不及格")
        }
    }
}

例子4

fun main(args: Array<String>) {
    var date = Date()
    when (date) {
        Date() -> println("优秀") 
        else -> {
            println("不及格")
        }
    }
}

例子5

fun main(args: Array<String>) {
    var score = 'B'
    var  str = when (score) {
        'A' -> "优秀"
        'B' -> "良好"
        'C' -> "中"
        'D' -> "及格"
        else -> "不格"
    }
    println(str)
}

例子6

fun main(args: Array<String>) {
    var score = Random().nextInt(100)
    var str = when (score) {
        in 90..100 -> "优秀"
        in 80..90 -> "良好"
        in 70..80 -> "中"
        in 60..70 -> "及格"
        else -> "不及格"
    }
    println("${score} = ${str}")
}

例子7

fun main(args: Array<String>) {
    var inputPrice = "09"
    println(realPrice(inputPrice))
}
fun realPrice(inputPrice:Any)=when(inputPrice){
    is String -> inputPrice.toDouble()//如果inputPrice类型为String,返回该字符的Double值
    is Int -> inputPrice.toDouble()//如果inputPrice类型为Int,返回该字符的Double值
    is  Double -> inputPrice
    else -> 0.0
}

例子8

fun main(args: Array<String>) {
    println("请输入内容")
    val string = readLine()//读取控制台的一行输入 类型: String?
    if(string!=null){
        when{
            //每个分支条件都需要是布尔表达式
            string.matches(Regex("\\d+")) -> println("您输入的全是数字")
            string.matches(Regex("[a-zA-Z]+")) -> println("您输入的全是字母")
            string.matches(Regex("[a-zA-Z0-9]+")) -> println("您输入的既有数字也有字母")
            else -> println("您输入的内容中包含了特殊字符")
        }
    }
}

kotlin练习 - if分支结构练习

发表于 2018-12-16 更新于 2019-06-01 分类于 kotlin

kotlin练习 - if分支结构练习

if 分支

常见形式：

第一种形式

1
2
3

if(expression){
	statements...
}

第二种形式

if(expression){
	statements...
}else{
    statements...
}

第三种形式

if(expression){
	statements...
}else if(expression){
    statements...
}
...  //可以有零个或多个else判断

注意事项
通常建议不要省略if、else、else if后执行体的花括号{}，即使条件执行体只有一行代码，也要保留花括号，这样有更好的可读性，也可以避免发生错误的可能。
表达式

1	var str = if (age>20) "age大于20" else if (age<20) "age小于20" else "age等于20"

var age = 20
var str = if (age > 20) {
    println("age大于20的分支")
    "age大于20"
} else if (age < 20) {
    println("age小于20的分支")
    "age小于20"
} else {
    println("age等于20的分支")
    "age等于20"
}
println(str)