目录
1、条件语句&循环语句
package com.example.Chapter2
//if条件语句
//if(条件){满足条件执行的语句}
fun IfLearn(param1:Int,param2:Int):Int{
if(param1 < param2){
return param1
}
else{
return param2
}
}
//when条件语句
//when(变量){匹配值1->{执行逻辑1} 匹配值2->{执行逻辑2}}
fun whenLeran(num:Int){
var n:String = ""
when(num){
8 -> {n="big"}
7 -> {n="big"}
1 -> {n="small"}
2 -> {n="small"}
else -> {n="NA"}
}
println(n)
}
//for循环语句
fun forLearn(num1:Int,num2:Int){
//升序闭区间序列
println("for i in num1..num2 构造左闭右闭区间")
for (i in num1..num2)
{
println(i)
}
//升序左闭右开区间序列
println("for i in num1 until num2 构造左闭右开区间")
for (i in num1 until num2)
{
println(i)
}
//升序左闭右开区间序列
println("for i in num1 until num2 step num3 构造左闭右开区间")
for (i in num1 until num2 step 2)
{
println(i)
}
//降序左闭右开区间序列
println("for i in num1 downT0 num2降序序列")
for (i in num2 downTo num1)
{
println(i)
}
}
fun main(){
println(IfLearn(1,2))
println(IfLearn(2,0))
whenLeran(1)
whenLeran(9)
forLearn(0,10)
}
2、类的继承、构造、接口
package com.example.Chapter2
//-----------1、类的构造
// 在kotlin钟类默认是不可继承的
//构造一个学生类
open class Stuedent {
//定义学生的属性
var name:String = ""
var age:Int = 0
var weight:Int = 0
var classNum:Int = 0
//定义学生的方法
fun basicMess(){
println(name+" is "+age+" years old,his weight is" + weight + " kg and his classroom is " + classNum)
}
}
//实例化类，即构造一个学生
fun student(name:String,age:Int,weight:Int,classNum:Int){
//实例化类，即构造一个学生
val s1 = Stuedent()
//给类属性赋值，并调用类方法
s1.name = name
s1.age = age
s1.classNum = weight
s1.weight = classNum
s1.basicMess()
}
//---------2、继承，减少代码重复编写，在共同属性的基础上，添加不同子类的差异性，如人都有年龄身高体重，但是不同职业的人有不同的岗位
// 在kotlin钟类默认是不可继承的，需要添加关键字open来定义来是可继承的
//构造大学生类，继承学生类
class collegeStudent(var subject:String,var school:String): Stuedent(){
//通过constructor关键字来实现不同大学生类的参数组合
constructor(name: String,age: Int):this("语文","上海理工大学"){} //组合1：通过this关键字来调用当前类的参数
constructor(name: String):this("英语","上海大学"){}
constructor():this("",""){}
fun printI(){
println(subject + school)
}
}
//实例化大学生类
fun colleageStu(){
val c1 = collegeStudent() //不带参实例化
val c2 = collegeStudent("tim",18)
val c3 = collegeStudent("tom")
c1.printI()
c1.subject = "数学"
c1.school = "交通大学"
c1.printI()
c2.printI()
c3.printI()
}
//----------3、接口，接口可以只定义函数名而不需要定义函数体
//1）定义接口
interface Study{
fun readbook()
fun doHomeWork()
fun goschool(){
println("带函数体的接口方法，不需要强制定义函数，未定义时默认运行此语句")
}
}
//2）让类继承实现多个接口
class coll(subj:String): Stuedent(), Study {
//利用override重写接口方法
override fun readbook() {
println("readbook")
}
override fun doHomeWork() {
println("dohomework")
}
}
//3)实例化coll类
fun collStu(){
val cc1 = coll("接口学习")
cc1.readbook()
cc1.goschool()
}
fun main(){
//实例化类并调用方法
student("Tom",18,70,2)
//继承
colleageStu()
//接口
collStu()
}
//可修饰性学习，在fun关键字前面加上对应可修饰性关键字即可
//private：只对当前类可见
//protected：仅对当前类和子类可见
//public：公开
//internal：只对同一模块可见3、数据类&单例类
package com.example.Chapter2
//数据类和单例类学习
//数据类，关键字：data
data class cell(val sub:String)
val c1 = cell("c1")
val c2 = cell("c2")
//单例类，关键字：object
//主要用于希望一个类只有一个实例的情况
object Singleton{
fun printl() {
println("单例类")
}
}
//引用
fun main(){
println(c1 == c2)
//单例类
Singleton.printl()
val s1 = Singleton
Singleton.printl()
val s2 = Singleton
Singleton.printl()
}
4、lamada编程
package com.example.Chapter2
//1、常见数据结构
//1）列表：有序集合，listof()---不可变有序列表，mutablelistof()---可变有序列表
fun listLearn(){
println("list数据结构学习")
val list1 = listOf<String>("a","b","c")
for (l in list1){
println(l)
}
val list2 = mutableListOf<String>("a","b","c")
list2.add("d")
for (l2 in list2){
println(l2)
}
}
//2）集合：无序集合，setof()---不可变集合，mutablesetof()---可变集合
fun setLearn(){
println("set数据结构学习")
val set1 = setOf<String>("a","b","c")
for (s in set1){
println(s)
}
val set2 = mutableSetOf<String>("a","b","c")
set2.add("d")
for (s2 in set2){
println(s2)
}
}
//3）字典：无序字典，mapof()---不可变集合，mutablemapof()---可变集合
fun mapLearn(){
println("map数据结构学习")
val map1 = mapOf<String,Int>("a" to 1,"b" to 2,"c" to 3)
for (m in map1){
println(m)
}
val map2 = mutableMapOf<String,Int>("a" to 1,"b" to 2,"c" to 3)
map2.put("d", 4)
for (m2 in map2){
println(m2)
}
}
//2、集合式的API
//1）maxby()---取一个集合的最大值
//2）map()---将集合每一个元素按照规则映射成另一个元素
//3）filter（）---将集合中符合条件的元素筛选出来
//4）any()---判断集合中是否至少存在一个符合条件的元素，是返回true，否返回false
//5）all()---判断集合中是否所有元素都符合条件，是返回true，否返回false
fun apiLearn(){
val list3 = listOf<String>("ab","bcs","cdff")
val maxLength = list3.maxBy { l3->l3.length }
val maxLength2 = list3.maxBy { it.length } //只有一个参数，所以可以用It关键字来代替
println("maxLength:"+maxLength)
println("maxLength2:"+maxLength2)
val mapEle = list3.map { l3->l3.uppercase() }
val mapEle2 = list3.map { it.uppercase() }
println("mapEle:"+mapEle)
println("mapEle2:"+mapEle2)
val filterEle = list3.filter { l3 -> l3.length <= 3 }
val filterEle2 = list3.filter { it.length <= 3 }
println("filterEle:"+filterEle)
println("filterEle2:"+filterEle2)
val anyEle = list3.any { l3 -> l3.length > 5 }
val anyEle2 = list3.any { l3 -> l3.length < 5 }
val anyEle3 = list3.any { it.length < 5 }
println("anyEle:"+anyEle)
println("anyEle2:"+anyEle2)
println("anyEle3:"+anyEle3)
val allEle = list3.all { l3 -> l3.length > 5 }
val allEle2 = list3.all { l3 -> l3.length < 5 }
val allEle3 = list3.all { it.length < 5 }
println("allEle:"+allEle)
println("allEle2:"+allEle2)
println("allEle3:"+allEle3)
}
fun main(){
//1、数据结构学习
listLearn()
setLearn()
mapLearn()
//2、集合式API
apiLearn()
}5、空指针检查
package com.example.Chapter2
//kotlin默认是传入函数的参数和变量不可以为空，在编译前期实现了空指针的检查
//1、可空类型系统：在数据类名后加问号，表示参数可空，如Int为不可空整型，Int？为可空整型
fun nullLearn(l1:Int,l2:Int?){
//l1：不可空参数，l2：可空参数
if (l2 != null){ //进行空指针检查，避免出现空指针异常
println("l1+l2="+(l1+l2))
}
else {
println("l2为空")
}
}
//2、判空辅助工具
//1）？.工具：如果变量不为空则运行，否则跳过
fun wenhaoDot(l1:String?){
val l2 = l1?.length
println(l2)
}
//2）？:工具。如果变量不为空，执行左边表达式，否则执行右边表达式
fun wenhaoMao(l1:String?){
val l3 = l1?:0
println(l3)
val l4 = l1?.length?:-1
println(l4)
}
//3）！！强制通过判空，具有一定风险
fun tanhao(l1:String?){
println(l1!!.length) //这个其实是错误的，因为未解决为空的风险
}
//4）let函数API，可以对全局变量进行判断
var ll:String? = "content"
fun letLearn(){
// if (ll != null) {
// println(ll.length) //这里会提示为空的风险，因为if 无法对全局变量进行判空操作
// }
println(ll?.length)
println(ll?.let{ lll->
lll.length
})
println(ll?.let{ lll->lll.length?:lll
})
}
fun main(){
nullLearn(1,2)
nullLearn(1,null)
wenhaoDot(null)
wenhaoDot("非空")
wenhaoMao(null)
wenhaoMao("非空")
tanhao("非空")
// tanhao(null) //这个运行是会报错的，因为null无length属性
letLearn()
}
6、字符串内嵌表达式、函数参数默认值
package com.example.Chapter2
//通过${}来内嵌变量到一个完整的字符串句子中,只有一个变量时，大括号可以删除
fun stringPad(){
val num = 2
val string = "null"
println("test ${num} $string")
}
fun main(){
stringPad()
}package com.example.Chapter2
fun functionParams(num:Int = 2,string:String){
println("$num $string")
}
fun main(){
functionParams(1,"iii")
functionParams(string = "hello")
}