本文详细介绍了Kotlin编程语言的基础知识，包括变量声明、函数定义、字符串与数字转换、数组、列表、Map操作、When表达式、异常捕获、递归、尾递归优化、类定义、继承与多态、抽象类和接口、委托与代理以及单例模式。Kotlin作为Android的官方开发语言，其简洁的语法和强大的功能使得它在开发中广泛应用。
第一章 kotlin基础知识
文章目录
前言
kotlin与java有一些相似之处。但也有很多不同，比如可以不写末尾的分号，类型和变量反着写（x:Int），与java正着写类型变量（int x）形成鲜明对比，写法不重要，习惯了就好。另外，kotlin有一些新的特性，可以大大简化代码。
一、kotlin是什么？
Kotlin 是一种在 Java 虚拟机上运行的静态类型编程语言，由 JetBrains 设计开发并开源。
Kotlin 可以编译成Java字节码，也可以编译成 JavaScript，方便在没有 JVM 的设备上运行。
在Google I/O 2017中，Google 宣布 Kotlin 成为 Android 官方开发语言。
二、kotlin基础知识
1.变量的声明
Byte，Int ，Long ，String 基础类型的变量声明 ：
fun main(args: Array<String>) {
var str = "test"
println(str)
var b: Byte = 10
var i: Int = 12
var j: Long = 10000000000000
var s: String = "test"
var a: Int
val number="no"
val aByte:Byte = Byte.MAX_VALUE;
println("Byte的最大值"+aByte)
val aInt:Int = 0b0011
println("aInt的值是："+aInt)
printContent()
}
fun printContent(){
println("内容")
}
2.函数定义的几种方式
代码如下：
fun main(agrs:Array<String>){
var result = add(2,3)
println(result)
var result2 = add2(2,3)
println(result2)
println("变量作为函数名：")
var i = {x:Int,y:Int -> x+y}
var result3 = i(2,3)
println(result3)
var j:(Int,Int)->Int = {x,y -> x+y}
var result4 = j(2,3)
println(result4)
}
fun add(x: Int, y: Int): Int {
return x+y
}
fun add2(x: Int, y: Int): Int = x+y
3.字符串与数字的转换
代码如下：
var a = "12"
var b = 12
a = b.toString() //把b数字转换成字符串放入a里面
b = a.toInt() //把a字符串转换成数字放入b里面
println("${b} + 测试") //注：${b}属于字符串模板
4.数组
代码如下：
fun main(agrs:Array<String>) {
var nums = 1 .. 100 //范围为[1 100]的闭区间
var result = 0
for (num in nums){
result = result+num
}
println("结果：${result}")
}
5.列表
代码如下：
fun main(args:Array<String>){
var lists = listOf("测试1","测试2","Test")
for (list in lists) {
println(list)
}
println("测试列表索引：")
for((i,e) in lists.withIndex()){
println("$i $e")
}
}
6.Map
代码如下：
fun main(agrs:Array<String>){
var map = TreeMap<String,String>()
map["好"] = "good"
map["学习"] = "study"
map["天"] = "day"
map["向上"] = "up"
println(map["好"])
}
7.When的使用
代码如下：
fun numToChinese(num:Int):String{
var result = when(num){
1 -> "一"
2 -> "二"
3 -> "三"
4 -> "四"
5 -> "五"
else -> "其他"
}
return result
}
8.默认参数
代码如下：
val Pi = 3.14159f
fun 获取圆的周长(PI:Float = Pi, 半径:Float):Float{
return 2*PI*半径
}
fun main(agrs:Array<String>) {
var area = 获取圆的周长(半径 = 2.0f)
println(area)
}
9.Exception异常捕获
代码如下：
fun main(agrs: Array<String>) {
while (true) {
println("请输入第一个数字：")
var num1str = readLine()
println("请输入第二个数字：")
var num2str = readLine()
try {
var num1: Int = num1str!!.toInt()
var num2: Int = num2str!!.toInt()
println("${num1} + ${num2} = ${num1 + num2}")
} catch (e: Exception){
println("您输入的不是数字。请输入数字")
}
}
}
10.递归
计算n的阶乘：
//5的阶乘 5*4*3*2*1 //n的阶乘？
fun main(args: Array<String>) {
var num = 5
//计算5的阶乘
println(fact(num))
}
fun fact(num: Int): Int {
if(num == 1){
return 1
} else {
return num*fact(num-1)
}
}
计算超大数的阶乘：
fun main(args: Array<String>) {
var num = BigInteger("80")
//计算num的阶乘
println(fact3(num))
}
fun fact3(num: BigInteger): BigInteger {
if(num == BigInteger.ONE){//或者可以写成BigInteger("1")
return BigInteger.ONE
} else {
return num*fact3(num-BigInteger.ONE)
}
}
11.尾递归优化
不使用尾递归优化时：
//5的累加 5+4+3+2+1 //n的累加？
fun main(args: Array<String>) {
println(ollAdd(20000))//不能计算大整数的累加，例如计算20000的累加，会报错：java.lang.StackOverflowError
}
fun ollAdd(num: Int): Int {
if(num == 1){
return 1
} else {
return num+ollAdd(num-1)
}
}
使用尾递归优化时：
fun main(args: Array<String>) {
var result = 0
println(ollAdd2(20000,result)) //通过tailrec尾递归优化，可以计算大整数的累加，例如计算20000的累加
}
tailrec fun ollAdd2(num: Int, result: Int): Int { //tailrec 尾递归优化
println("计算机第${num}次运算，result=${result}")
if(num == 0){
return result
} else {
return ollAdd2(num-1, result+num)
}
}
12.class类定义
kotlin的类的参数，同时也是类的成员属性，有点像java的带参数的构造方法，但java的构造方法的参数仅是形式参数，与类的成员属性无直接关系。
示例1：
//矩形 高 宽
class Rect(var height:Int, var width:Int)
fun main(agrs:Array<String>) {
var rect01 = Rect(20,10)
println("矩形的高度：${rect01.height}")
println("矩形的宽度：${rect01.width}")
}
示例2：
class People(var chactor:String, var voice:String){
fun smile(){
println("他笑了！！！")
}
fun cry(){
println("他哭了！！！")
}
}
fun main(agrs:Array<String>) {
var people1 = People("认真","普通")
println("people1这个人的声音：${people2.voice}")
people2.cry()
people2.smile()
}
示例3：
class WashMachine(var module: String, var size: Int) {
var isDoorOpen = true
var currentMode = 0
fun openDoor() {
println("洗衣机的门已经打开了...")
isDoorOpen = true
}
fun closeDoor() {
println("洗衣机的门已经关闭了...")
isDoorOpen = false
}
fun selectMode(mode: Int) {
currentMode = mode
when (mode) {
0 -> println("初始模式，请您选择模式")
1 -> println("轻柔")
2 -> println("狂揉")
}
}
fun start() {
if (isDoorOpen) {
println("滴滴...门没有关，不能运行")
} else {
when (currentMode) {
0 -> {
println("选择模式错误，不能开始洗衣服")
}
1 -> {
println("放水...")
setMotorSpeed(1)
println("轻柔开始，发动机转速 慢")
}
2 -> {
println("放水...")
setMotorSpeed(10)
println("狂揉开始，发动机转速 快")
}
}
}
}
private fun setMotorSpeed(speed:Int) {
println("当前发动机转速为 ${speed}圈/秒")
}
}
fun main(agrs: Array<String>) {
var washMachine = WashMachine("某洗衣机品牌", 12)
washMachine.openDoor()
println("张三把衣服放进去了")
washMachine.closeDoor()
washMachine.selectMode(2)
washMachine.start()
}
13.继承和多态
代码如下：
abstract class Human(var name: String) {
abstract fun eat()
abstract fun drink()
}
/**
* 父亲
*/
open class Father {
var chactor:String = "性格内向"
open fun action(){
println("喜欢讲故事")
}
}
/**
* 孩子
*/
class Son : Father() {//继承
override fun action() {
println("公众场合很有礼貌")
}
}
class Man(name: String) : Human(name) {
override fun eat() {
println("${name}大口吃")
}
override fun drink() {
println("${name}喝凉开水")
}
}
class WoMan(name: String) : Human(name) {
override fun eat() {
println("${name}小口吃")
}
override fun drink() {
println("${name}喝温开水")
}
}
fun main(agrs:Array<String>) {
var son1 = Son()
println("儿子的性格${son1.chactor}")
son1.action()
var person1 = Man("张三")
person1.eat()
var person2 = WoMan("李四")
person2.eat()
var person3 = Man("王五")
var person4 = WoMan("赵六")
var person5 = Man("李七")
var houseList = listOf<Human>(person1,person2,person3,person4,person5)
for (h in houseList) {
h.drink()
}
}
14.抽象类和接口
代码如下：
interface IMan {
fun height() //身高
}
interface IWoMan {
fun test()
}
abstract class Human() {
abstract fun eat()
abstract fun drink()
}
class Man : Human(),IMan {
override fun height() {
println("身高较高")
}
override fun eat() {
println("Man 吃")
}
override fun drink() {
println("Man 喝")
}
}
class WoMan : Human(),IWoMan {
override fun test() {
println("测试")
}
override fun eat() {
println("WoMan 吃")
}
override fun drink() {
println("WoMan 喝")
}
}
fun main(agrs: Array<String>) {
var man1 = Man()
man1.height()
var mWoMan = WoMan()
mWoMan.drink()
var house = listOf<Human>(man1, mWoMan)
for (p in house) {
if (p is Man){
p.eat()
}
}
}
15.委托和代理
代码如下：
interface IWashBowl {
fun washing()
}
/**
* 大头儿子
*/
class BigHeadSon : IWashBowl {
override fun washing() {
println("我是大头儿子，我在开心的洗碗，一次赚1块钱")
}
}
//我是小头爸爸，我在开心的洗碗，一次赚10块钱
class SmallHeadFather : IWashBowl by BigHeadSon() {//使用委托 //爸爸委托儿子洗碗
}
fun main(agrs: Array<String>) {
var son = BigHeadSon()
son.washing()
var father = SmallHeadFather()
father.washing()
}
16.单例模式
单例模式，即内存中只存在一个此类的对象实例。使用object关键字。
/**
* 大头儿子
*/
object BigHeadSon : IWashBowl {
override fun washing() {
println("我是大头儿子，我在开心的洗碗，一次赚1块钱")
}
}
interface IWashBowl {
fun washing()
}
/**
* 使用委托
*/
class SmallHeadFather : IWashBowl by BigHeadSon {
override fun washing() {
println("我是小头爸爸，我赚了10块钱")
BigHeadSon.washing()
println("我是看着儿子把碗洗好了")
}
}
fun main(agrs: Array<String>) {
// var son = BigHeadSon
BigHeadSon.washing()
var father = SmallHeadFather()
father.washing()
var a = BigHeadSon
var b = BigHeadSon
println(a==b)
}
总结
以上就是今天要讲的内容，本文仅仅简单介绍了kotlin的基础知识。下一章将继续介绍kotlin其他基础知识。
扫一扫
355
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
