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
}
}