定义一个包这个和java一样就不多说了，那么哪里和java不同呢？
//java
package com.asdf.myapplication.test;
import android.widget.TextView;
public class Student {
public String getName(TextView textView) {
return textView.getText().toString().trim();
}
}
//kotlin
package com.asdf.myapplication.test
import android.widget.TextView
// 源文件可以从包声明开始
fun getName():String {
return "youxin"
}
fun TextView.name(name: String):Unit {
this.text = name
}
class Person{
fun getName(textView: TextView?):String {
return textView?.text as String;
}
}
区别 kotlin 源文件可以从包声明开始（源文件就是代码，函数变量等等），java是不可以的 再来看看面的代码如何调用（关于 ?. 和 !!. 后面会讲到）
//导包之后就可以调用了，属于同一个包下面就不用导包，这点和java一样的
import com.asdf.myapplication.test.Person
import com.asdf.myapplication.test.getName
class Main2Activity : AppCompatActivity() {
var tv: TextView? = null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main2)
tv = findViewById(R.id.youxin) as TextView
getName()
val person = Person()
person.getName(tv);
}
}
默认情况下，将多个软件包导入到每个Kotlin文件中：所以我们在用kotlin创建一个Acitivity之后会有很多的方法提议调用，不会像java一样使用list集合还要导包，然后利用kotlin的特性，源文件可以从包声明开始，那么这一下，我们的代码写法就变得非常的优雅。因为我们不需要在自己导包了，我们也不需要在方法名字前面加上包名了，就上上面的getName（）方法一样。那么我这里想说的是kotlin默认导入的这些包中，包含的东西很多很多，并且都非常的实用。举几个例子
- kotlin.*
- kotlin.annotation.*
- kotlin.collections.*
- kotlin.comparisons.* (since 1.1)
- kotlin.io.*
- kotlin.ranges.*
- kotlin.sequences.*
- kotlin.text.*
看完下面的代码是不是有如高潮般的激动，listOf 和 mapOf 在kotlin.collections包下面，apply 和 with ，let 在kotlin包下面，还有一些我就不在举例了，我们也可以自己写，自己写也很简单，学完泛型，扩展，和高阶函数后就可以自由的玩耍了。
class Main2Activity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main2)
var aa = listOf<Int>(1,2,3)
var bb = 1 to 2
var cc = mapOf<Int,Int>(bb,bb)
var dd = mutableListOf<String>("1","2","3")
dd.map {
//dosomething
}.forEach {
//dosomething
}
aa.apply {
//dosomething
}.apply {
//dosomething
}
with("youixn"){
//dosomething
}.let {
//dosomething
}
}
}
这是部分的源码里面包含的东西还是蛮多的，包括一些api以后我们都会用的到
格式是：修饰符 关键字var或者val : 类型 ** 这里的类型当后面赋值确定后是可以省略的,下面例子中的abstract 修饰的type 这里和java不同，需要特别注意下，public private···这和java一样，？** 表示的意思是可以为空
public var name:String = "yoxin"
private var name2 = "youxin2"//表示 name2 不能为空他是必须有值的
protected var name3:String? = null//表示的是name3 可以为null也可以不为空
public var id:Int = 1
private var id2 = 2
protected var id3:Int? = null
abstract var type:String
//abstract // 在自身不初始化，需要子类进行初始化，不能省略类型。
关于函数的定义大家可以随便找一篇文章看看，这个简单，网上的文章都说的很好了。
1.具有返回Int类型的两个Int参数的函数：
fun sum(a: Int, b: Int): Int {
return a + b
}
fun sum(a: Int, b: Int) = a + b
//上面两种都是对的，因为kotlin可以自动 推断返回类型
2.Unit为无类型：Unit 和 java的void 一样的意思
fun printSum(a: Int, b: Int): Unit {
println("sum of $a and $b is ${a + b}")
}
fun printSum(a: Int, b: Int): Unit {
println("sum of $a and $b is ${a + b}")
}
//上面两种都是对的，因为kotlin Unit返回类型可以省略：
这个和java一样没什么好说的，Kotlin支持行尾和块注释，这个自己Google我是觉得可以忽略的，关于注释，保持和java一样就不会有什么问题
这个也没什么好说的，和java差不多的理解，但是有一些需要注意的，这里有一些介绍 初识kotlin 每个数字类型都支持以下转换：
- toByte(): Byte
- toShort(): Short
- toInt(): Int
- toLong(): Long
- toFloat(): Float
- toDouble(): Double
- toChar(): Char
- 需要注意的是java是这么玩的： Integer.parseInt("youxin")
- 但是kotlin是这么玩的： "youxin".toInt(),其实kotlin的源码走的还是Integer.parseInt("youxin")，但是代码简单通俗易懂了。
- if表达式 含义这个和java一样
// 传统用法
var max = a
if (a < b) max = b
// With else
var max: Int
if (a > b) {
max = a
} else {
max = b
}
// 函数表达式
val max = if (a > b) a else b
- When表达式 类似与java的Switch
when (x) {
1 -> print("x == 1")
2 -> print("x == 2")
else -> { // Note the block
print("x is neither 1 nor 2")
}
}
when (x) {
in 1..10 -> print("x is in the range")
in validNumbers -> print("x is valid")
!in 10..20 -> print("x is outside the range")
else -> print("none of the above")
}
//in关键字 检查值是否在或不在范围内或集合中
- for循环 接受的参数是 变量 和 一个范围 使用in关键字
for(i in 1..10){
//i
}
// .. 表示从1到10的范围
for (i in array.indices) {
print(array[i])
}
for ((index, value) in array.withIndex()) {
println("the element at $index is $value")
}
- while 循环 和java一样
- 在循环中的 break 和 continue 语句 和java一样