从java快速入门Kotlin,开发安卓必备前置知识

1.基本数据类型

2.数据容器

2.1数组

//直接创建数组,通过arrayOf
    var arrayNum:Array<Int> = arrayOf(1,2,3,4)
    var arrayObjects:Array<Any> = arrayOf(1,true,"1")
    //通过arrayOfNulls创建数组,所有的元素都是空的
    val arrayOfNulls = arrayOfNulls<String>(5)
    //利用Array的构造函数动态创建数组
    val array = Array(5) { i ->  (i * i).toString()  }

    //创建一个初始长度为5,内容全是100的数组
    val arr1= IntArray(5){100}
    //创建一个数组,对应索引的内容是索引的2倍,it是专有的一个变量,表示的是初始的下标
    val arr2=IntArray(5){it*2}

    //数组的遍历操作
    for(item in arr2){
        //print(item)
    }
    //根据下标获取对应的元素
    for (item in arr2.indices){
        //print(arr2[item])
    }
    //同时遍历下标和元素
    for((index,item) in arr2.withIndex()){
        println("$index->$item")
    }
    //通过foreach循环遍历
    arr2.forEach {
        //println(it)
    }
    //foreach的加强版,可以同时获取对应的下标和元素
    arr2.forEachIndexed{index, item ->
        println("$index->$item")
    }

2.2集合

/**
* list集合
*/
//可变列表,用arrayListOf也是一样的
val mutableListOf = mutableListOf<String>()
mutableListOf.add("1")
//不可变列表,listOf
val listOf = listOf<Int>(1,2,3)

/**
* map集合
*/
val mutableMapOf = mutableMapOf<String, Int>()
mutableMapOf.put("aihua",1)
mutableMapOf["aihua"]=2

//通过pair指定集合中初始化的元素
val mutableMapOf1 = mutableMapOf<String, String>(Pair("hello", "world"))
//不可变的map元素
val mapOf = mapOf<String, String>(Pair("key","value"))

/**
* set集合
*/
val mutableSetOf = mutableSetOf<Int>()

val of = setOf<Int>()

3.方法

3.1普通类的方法

3.2静态类的方法

3.3伴生类的方法

package com.sjvave.aihua.basictype

import java.awt.PrintGraphics

fun main(){
    //调用普通类中的普通方法
    Person().test()
    //直接通过类名调用伴生类中的方法
    Person.test02()
    //通过类名调用静态方法
    println(Util.add(1,1))
}

/**
 * 普通类中声明方法
 */
class Person{
    fun test(){
        println("我是person中的test方法")
    }
    companion object{
        fun test02(){
            println("我是可以直接被调用的")
        }
    }
}

/**
 * 静态类中调用方法
 */
object Util{
    fun add(a:Int,b:Int):Int{
        return a+b
    }
}

3.4方法参数

默认参数

其实就是在参数后面加一个等号之后给一个默认的值

具名参数

针对的情况就是:一个默认参数后面有一个没有默认值的参数,那么在进行方法调用的时候就必须要使用(变量名 = 值)的方式进行赋值

还有下面的一种特殊的情况

package com.sjvave.aihua.basictype

import java.awt.PrintGraphics

fun main(){
    //调用方式一
    test(1,2,action = {
        //方法体里面的最后一行就是方法的返回值
         3
    })
    //调用方式二
    test(start = 2){
        3
    }
}

fun test(offset:Int = 0,start:Int,action:() -> Int){
    val res=action()
    print(res)
}

可变数量的参数

package com.sjvave.aihua.basictype

import java.awt.PrintGraphics

/**
 * 要注意的点:
 * 一个方法中只可以有一个参数标明vararg
 * vararg不是最后一个参数,可以使用具名参数语法对后面的参数进行赋值
 */
fun main(){
    val append = append('1', '2', '3')
    val charArrayOf = charArrayOf('a', 'b', 'c')
    val append1 = append('a', 'b', *charArrayOf)
    print(append1)
}
fun append(vararg str:Char):String{
    val stringBuffer = StringBuffer()
    for (char in str){
        stringBuffer.append(char)
    }
    return stringBuffer.toString()
}

4.Lambda表达式

package com.sjvave.aihua.basictype

import java.awt.PrintGraphics

/**
 * 要注意的点:
 * 当参数只有一个的时候可以直接使用隐式的参数it
 */
fun main(){
    val number = arrayOf(1, 3, 4, 5)
    /*transform(number,action = { index:Int,element:Int ->
        index*element
    })*/
    transform(number){index,element ->
        index*element
    }
    for (i in number) {
        println(i)
    }
}
fun transform(array:Array<Int>,action:(Int,Int)->Int){
    for (index in array.indices){
        val newVal = action(index, array[index])
        array[index]=newVal
    }
}

5.条件控制

package com.sjvave.aihua.basictype

import java.awt.PrintGraphics

/**
 * 要注意的点:
 * 当参数只有一个的时候可以直接使用隐式的参数it
 */
fun main(){
    println("maxof:${maxOf(2,4)}")
}
fun maxOf(a:Int,b:Int):Int{
    if(a>b){
        return a
    }else{
        return b
    }
}
fun max0f02(a:Int,b:Int):Int{
    return if (a>b) a else b
}

/**
 * when括号里面的值不一定是一个确定的值,可以动态获取
 */
fun eval2(number:Number):String=when (number){
    is Int -> "this is Int"
    else -> "invalid number"
}

6.泛型

泛型接口/类

泛型字段

泛型方法

泛型约束

泛型中的out与in

package com.sjvave.aihua.basictype

import java.awt.PrintGraphics

/**
 * 要注意的点:
 * 当参数只有一个的时候可以直接使用隐式的参数it
 */
fun main(){
    AppleDrink().drink("苹果汁")
    BlueColor("blue").printColor()
    formJson("{}", String::class.java)
}

/**
 * 泛型接口
 */
interface Drink<T>{
    fun drink(t:T)

}
class AppleDrink :Drink<String>{
    override fun drink(t: String) {
        print("我在喝${t}")
    }
}

/**
 * 泛型类
 */
abstract class Color<T>(val t:T/*泛型字段*/){
    abstract fun printColor()
}
class BlueColor(val color:String):Color<String>(color){
    override fun printColor() {
        println("color:${color}")
    }

}

/**
 * 泛型方法
 */
fun <T>formJson(json:String,tClass:Class<T>):T?{
    val t:T?=tClass.newInstance()
    return t
}
/**
 * 泛型约束
 * 对泛型进行约束,只可以是对应的类型或者其子类(单个约束)
 */
fun <T:BlueColor>formJson02(json:String,tClass:Class<T>):T?{
    val t:T?=tClass.newInstance()
    return t
}
/**
 * 泛型约束
 * 多个约束
 */
fun <T>formJson03(json:String,tClass:Class<T>):T? where T:Comparable<T>,T:Number{
    val t:T?=tClass.newInstance()
    return t
}

/**
 * out和in关键字的使用
 */
open class Animal
open class Dog:Animal()
fun animalFuns(){
    val animal:Animal=Dog()
    //使用了out关键字之后下面就不会报错了,因为kotlin的集合类型是不会主动进行强转的
    //这是在使用处用out关键字
    val animalList:ArrayList<out Animal> = ArrayList<Dog>()

    //与之相反,这个表示了类型下限,允许传入本身或者其父类
    val animalList02:ArrayList<in Dog> = ArrayList<Animal>()

}
//在定义处用out关键字
class ArrayList<out T>{

}

7.扩展函数

扩展方法(给一个类扩展没有的方法)

package com.sjvave.aihua.basictype

import java.awt.PrintGraphics

/**
 * 要注意的点:
 * 当参数只有一个的时候可以直接使用隐式的参数it
 */
fun main(){
    //Ikun().rup()
    val mutableListOf = mutableListOf<Int>(1,2,3,4)
    mutableListOf.swap(0,2)
    mutableListOf.forEach{
        print(it)
    }
    var myString="android"
    val lastChar = myString.lastChar
    println(lastChar)
    tesApply()
}

class Ikun{
    fun test(){

    }
}
fun Ikun.rup():String{
    return "ge ge rap"
}
//扩展方法
fun <T> MutableList<T>.swap(index:Int,index2:Int){
    val temp=this[index]
    this[index]=this[index2]
    this[index2]=temp
}
//扩展字段
val String.lastChar:Char get() = this.get(length-1)

//内置的一些扩展let,run,apply
//类的后面加上问号,代表参数可以为空,就是有一个判空的操作
fun testLet(str: String?){
    //如果对应的为空,则不会执行里面的逻辑,最后一行是返回值
    str?.let {
        //这个属性在作用域外面访问不到
        val str2="android"
        print(str2)
    }
}
//run扩展函数
fun testIkun(ikun: Ikun){
    ikun.run {
        //可以直接访问实例的公有属性和方法,最后一行是返回值
        test()
    }
}
//apply扩展,返回值就是自己本身,和run有点不同,run返回最后一行
fun tesApply(){
    ArrayList<String>().apply {
        add("11")
        add("33")
    }.run {
        for (s in this){
            println("apply:${s}")
        }
    }
}

8.做个简单的二则运算器

package com.sjvave.aihua.basictype

import java.lang.Exception

fun main(){
    while (true){
        println("请输入你的表达式:")
        val input= readLine()
        try {
            //不为空的时候才去进行计算
            input?.let {
                val res=cacalate(it)
                println("${input}=${res}")
                println("是否继续使用(y/n)")
                val cmd= readLine()
                cmd?.let {
                    if(it.equals("n")){
                        System.exit(-1)
                    }else{

                    }
                }
            }
        }catch (ex:Exception){
            ex.printStackTrace()
        }
    }
}

fun cacalate(input: String): String {

    if(input.contains("+")){
        val numbers = input.trim().split("+")
        return operate(numbers[0].toDouble(),numbers[1].toDouble(),"+").toString()
    }else if(input.contains("-")){
        val numbers = input.trim().split("-")
        return operate(numbers[0].toDouble(),numbers[1].toDouble(),"-").toString()
    }else if(input.contains("*")){
        val numbers = input.trim().split("*")
        return operate(numbers[0].toDouble(),numbers[1].toDouble(),"*").toString()
    }else if(input.contains("/")){
        val numbers = input.trim().split("/")
        return operate(numbers[0].toDouble(),numbers[1].toDouble(),"/").toString()
    }
    return "error please input you numbers"
}

fun operate(num1: Double, num2: Double,operate:String): Double {
    return when(operate){
        "+" -> num1+num2
        "-" -> num1-num2
        "*" -> num1*num2
        "/" -> num1/num2
        else -> 0.0
    }
}