1。数据类型：
1.Boolean
2.Number:包括整形和浮点型
分类 类型 位数
浮点型：Double 64
Float 32
整型： Long 64
Int 32
Short 16
字节 Byte 8
3.Char类型（Character）
4.字符串：
比较：
a == b 表示比较内容，即类似Java的equals
a === b 表示对象是否相同
字符串模板：
"hello,$name" ==> "hello 小明"
示例代码：
val anotherBoolean: Boolean = false
val maxInt:Int = Int.MAX_VALUE
val aLong:Long = 12332323231232
val anotherInt:Int = 0xFF
val aInt = 0b00000011
val aFloat:Float = 123F
val aDouble:Double = 3.0
val another:Double = 3.141592653
val ashort:Short = 123
val abyte:Byte = 127
val aChar:Char = '\u000f'
val cChar:Char = '\n'
val anInt:Int = 5
val asLong:Long = anInt.toLong()
val string:String = "hello world"
val formChar:String = String(charArrayOf('d','e','e'))
val TAG:String = "MainActivity"
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
show("hello world")
Log.d(TAG,"\r\n"+cChar + "我的第一个Kotlin项目"+cChar)
var arg1:Int = 1
var arg2:Int = 2
Log.d(TAG,"" + arg1 + " + " + arg2 + " = " + (arg1 + arg2))
Log.d(TAG,"$arg1 + $arg2 = ${arg1 + arg2}")//$字符串模板
val rawString:String = """//原始字符串
2
hello
"""
Log.d(TAG,rawString)
Log.d(TAG,"长度：" + rawString.length)1.类和对象
class 妹子 : 人 {
override var 性格: String
override var 长相: String
override var 声音: String
constructor(性格: String, 长相: String, 声音: String) : super(性格, 长相, 声音) {
this.性格 = 性格
this.长相 = 长相
this.声音 = 声音
// Log.d("妹子", "她性格：$性格，长相：$长相, 声音：$声音")
}
}
class 帅哥 constructor (var 性格:String,var 长相:String,var 声音:String){
init {
Log.d("帅哥","他性格：$性格，长相：$长相, 声音：$声音")
}
}
open class 人(open var 性格:String,open var 长相:String,open var 声音:String){
init {
Log.d("妹子", "new 了一个 ${this.javaClass.simpleName}：$性格，长相：$长相, 声音：$声音")
}
}
val 我喜欢的妹子:人 = 妹子("温柔","甜美","动人")
val 我膜拜的帅哥: 帅哥 = 帅哥("彪悍","帅气","浑厚")3.空类型安全
？可以为空
!! 不可能为空
代码示例：
val name = getName() ?: return;
val value:String? = "hello world"
Log.d(TAG,"name = " + getName()?.length)
Log.d(TAG, value!!.length.toString())4.类型转换和智能类型转换
val mParent:Parent = Child()
if (mParent is Child){
Log.d(TAG,parent.packageName)
}
安全类型转换：
val sub: SubClass? = parent as? SubClass
如果转换失败返回null,不抛异常
5.数组Array
val TAG:String = "Arrayexample";
val arrayOfInt:IntArray = intArrayOf(1,3,5,7)
val arrayOfChar:CharArray = charArrayOf('f','d','e','a','b')
val arrayOfString:Array<String> = arrayOf("我是码农")
val arrayOf书记:Array<市委书记> = arrayOf(市委书记("张"),市委书记("李"))
fun main(args: Array<String>) {
Log.d(TAG, "" +arrayOfInt.size + "")
for (i in arrayOfChar){
Log.d(TAG, "" +i + "")
}
Log.d(TAG, arrayOfChar.joinToString(""))
arrayOfInt.slice(1..2)//切片，取范围内的值
6.常量和变量
val = value ,值类型 类似Java的final,不可以重复赋值
运行时常量： val x = getX() 编译器编译的时候并不能确切的知道它的值
编译期常量：const val x = 2;
var = variable
var x = "Hello Wolrd"//定义变量
x = "Hi Macal"//再次复制
类型推导：
val string = "hello world" /推导出String类型
val value = 5 //Int常量
val x = getString() + 5 //String类型
val FINAL_HELLO_WORLD:String = "hello world"
val FINAL_HELLO_CHANL = "HELLOCHINAL"//类型推导 7函数
注意事项：
功能单一
函数名要做到顾名思义
参数不能太多
fun show(): Unit {//Unit相当于void，可以省略不写
val arg1 = 1
val arg2 = 2
Log.d("Hello","$arg1 + $arg2 = ${sum(arg1,arg2)}")
int2Long(3)
}
fun sum(arg1: Int, arg2: Int): Int {
return arg1 + arg2;
}
fun sum1(arg1: Int,arg2: Int) = arg1 + arg2 //等价于sun
val int2Long = fun(x:Int):Long{//匿名函数：函数也可以没有名字
return x.toLong()
}8.Lambda表达式（匿名函数）
传入整型参数，返回整型值
写法：{[参数列表] -> [函数体，最后一行是返回值]}
var sum = {arg1:Int,arg2:Int ->
println("$arg1 + $arg2 = ${arg1 + arg2}")
arg1 + arg2
}
val printlnHello={
println("hello")
}
应用：
sum(2,3) 等价于 sum.invoke(2,3)
数组遍历：
args:数组
args.forEach({println(it)})
终极版：
args.forEach(::println)
终止循环(添加标签@，终止的是迭代，而不是这个函数)：
args.forEach ForEach@{
if(it == "q" return@ForEach
println(it)
}
Lambda表达是的简化：
。函数参数调用是最后一个Lambda可以移出去
。函数参数只有一个Lambda，调用是小括号可以省略
。Lambda只有一个参数可默认为it
。入参，返回值与形参一致的函数可以用函数应用的方式作为实参实参传入
9.类成员和和变量
class X
class A{
var b = 0//可以加访问修饰符，默认public
lateinit var c:String //延时初始化
lateinit var d:X
val e:X by lazy{//val只能通过lazy初始化
X()
}
get(){
return field
}
set(value){
field = value
}
}
10.运算符(待学)
11.表达式（中缀表达式，分支表达式，when表达式 ）
中缀表达式：只有一个参数，并且用infix修饰的函数
class Book {
infix fun on(place:String){
}
fun main(){
Book() on "My Desk"
}
}分支表达式：
if语句
private const val DEBUG = 1
private const val USER = 0;
val mode = if(args[0] == "1"){//if语句有返回值，就是最后一句
DEBUG
}else{
USER
}
when表达式：（kotlin没有switch）
val x = 5
when(x){
is Int -> Log.i(TAG,"hello $x")
in 1..100 -> Log.i(TAG,"$x is in 1-100")
!in 1..100 -> Log.i(TAG,"$x is not in 1-100")
args[0].toInt() -> Log.i(TAG,"x == arg[0]")
}
val mode = when {//when也有返回结果，类似加强版的switch，支持任意类型
args.isNotEmpty && args[0] == "1" -> 1
else ->0
}12循环语句（for循环，while循环，continue，break）
for循环：
fun xunhuan(args: Array<String>){
for (arg in args){
System.out.print(arg)
}
for (index,values) in args.widthIndex(){
System.out.print("$index -> $values")
}
for (indexedValue in args.widthIndex()){
System.out.print("${indexedValue.index} -> ${indexedValue.value}")
}
val list = MyIntList()
list.add(1)
list.add(2)
list.add(3)
for (i in list){
System.out.print(i)
}
}
class MyIterator(val interator: Iterator<Int>){//自定义迭代器
operator fun next():Int{
return interator.next()
}
operator fun hasNext():Boolean{
return interator.hasNext();
}
}
class MyIntList{
private val list = ArrayList<Int>();
fun add(int: Int){
list.add(int)
}
fun remove(int: Int){
list.remove(int)
}
operator fun iterator():MyIterator{
return MyIterator(list.iterator())
}
}while循环：
var x = 5
while (x > 0){
System.out.println(x)
x--
}
do {
System.out.println(x)
}while (x > 0)
continue和break和Java类似（跳过和跳出循环）
多层循环嵌套的终止结合标签使用
Outer@for(...){
Inner@while(i<0){
if(..)break@Outer
}
}
13：具名参数，变长参数，默认参数
//具名参数
fun sum(arg1:Int,arg2:Int):Int = arg1 + arg2
fun test(){
sum(arg2 = 2,arg1 = 1)
}
变长参数：
val array = intArrayOf(1,2,3,4)
hello(*array,string = "hello")//*只支持数组，其他类型不支持
fun hello(vararg ints:Int,string: String){
ints.forEach(::println)
System.out.println(string)
}小案例：
package com.example.myapplication
fun main(args: Array<String>) {
try {
var string = "1 = 2"
val split = string.trim().split(" ")
var arg1 = split[0]
val op = split[1]
val arg3 = split[2]
System.out.println("$arg1 $op $arg3 = ${Operator(op).apply(arg1,arg3)}")
}catch (e:NumberFormatException){
System.out.print("您确定输入的数字吗？")
}catch (e:Exception) {
System.out.print("亲爱的用户，程序遇到了异常,${e.message}")
}
}
class Operator(op:String){
val opFun:(left:Double,right:Double) ->Double
init {
opFun = when(op){
"+"-> {l,r -> l + r}
"-"->{l,r -> l -r}
else ->{
throw UnsupportedOperationException(op)
}
}
}fun apply(left:Double,right: Double):Double{
return opFun(left,right)
}
}