1、变量修饰符
class Test{
//可修改变量
var a : String = "a"
//不可修改变量
val b : String = "b"
//自动类型推导
var c = "cccc"
var d = 'c'
}
反编译Test类字节码可看到，b被final修饰，并且只有get方法，其他var修饰的变量均有get和set方法
2、字符串使用
fun main(){
//字符串拼接
var name = "小明"
var age = 5
var sex = 'm'
var info = "小学生"
println("name:$name, age:$age, sex:$sex, info$info")
//带换行""" """
var str = """
row1
row2
row3
""".trimIndent()
println(str)
}
image.png
3、kotlin中的null检查
fun main(){
//加?意为此变量可能会为null,使用时必须做处理，否则编译器报错
var info: String? = null;
//1.像java一样先判断
if (info != null){
println(info.length)
}
//2.如果为null，则不执行后面.length，直接输出null，若不想输出null可以info?.length ?: "为null了"
println(info?.length)
//3.!!自己保证不会为null，如果真的为null，会空指针
println(info!!.length)
}
image.png
4、kotlin中的比较
fun main(){
val a:String = "1111"
val b:String = "1111"
//== 等价于equals,比较值本身
println(a == b)
println(a.equals(b))
val test1:Int? = 10000
val test2:Int? = 10000
//比较对象内存地址
println(test1 === test2)
}
image.png
5、数组
fun main(){
//通过arrayOf生成一个数组
var numbers : Array = arrayOf(1,2,3,4)
println(numbers[1])
for (num in numbers){
print("$num ")
}
println()
//直接通过IntArray类创建大小为 5、值为 [0, 0, 0, 0, 0] 的整型数组
val numbers3: IntArray = IntArray(5)
for (num in numbers3) {
print("$num ")
}
println()
// 例如：使用 lambda 表达式初始化数组中的值
// 大小为 5、值为 [0, 1, 2, 3, 4] 的整型数组（值初始化为其索引值）
val numbers4: Array = Array(5){it*1}
for (num in numbers4) {
print("$num ")
}
}
image.png
6、区间语法
fun main(){
//顺序打印
for (i in 1..10){
print("$i ")
}
println()
//逆序打印
for (i in 10 downTo 1){
print("$i ")
}
println()
//区间做判断
val value = 33
if (value in 1..100){
println("33包含在1~100内")
}
println()
//指定步数，默认为1
for (i in 1..10 step 2){
print("$i ")
}
println()
//去掉区间最后一个
for (i in 1 until 10){
print("$i ")
}
}
image.png
7、标签与循环
fun main(){
tag@for (i in 1..5){
for (j in 1..5){
println("i:$i, j:$j")
if (i == 2){
// break//结束内层循环
break@tag//结束外面循环
}
}
}
val listOf = listOf(1, 2, 3)
for (l in listOf){
print("l:$l ")
}
println()
//indices获取下标，相当于迭代器
for (index in listOf.indices){
print("下标：$index, 对应值：${listOf[index]} ")
}
}
image.png
8、条件
fun main(){
val num1 = 2
val num2 = 100
//if可以用作表达式，直接对变量进行赋值
val min = if (num1 < num2) num1 else num2
println(min)
//用作表达式时，还可以做其他操作
val max = if (num1 > num2) {
println("num1大")
num1
} else {
println("num2大")
num2
}
//when相当于switch，比switch更强大
val num = 1
when(num){
1 -> println("是1")
2 -> println("是2")
3 -> println("是3")
else -> println("其他")
}
//判断可以是一个范围
val num11 = 2
when(num11){
in 1..10 -> println("1..10")
in 11..20 -> println("11..20")
3 -> println("是3")
else -> println("其他")
}
//在其内部可以有不同的返回值，还可以做其他操作
val num111 = 5
val n = when(num111){
1,5 -> {
println("是1")
"返回1"
}
2 -> {
println("是2")
}
3 -> {
println("是3")
1
}
else -> println("其他")
}
println(n)
val x = {v: Int -> (v+10)}
println(x(1))
}
image.png
9、kotlin函数
//void == :Unit，可省略
fun main() : Unit{
println(add(1, 2))
lenMethod(1, 2, 3)
//lambda表达式
val addMethod : (Int,Int) -> Int = {num1,num2 -> num1 + num2}
println(addMethod(2,5))
}
//函数
fun add(num1: Int,num2: Int):Int{
return num1 + num2
}
//返回类型=类型推导
fun add2(num1: Int,num2: Int) = num1 + num2
//可变参数（可变长 参数函数）
fun lenMethod(vararg value: Int){
for (i in value) {
println(i)
}
}
10、类
-
构造函数：
//默认 public final class Person，默认无法被继承，需要加open
open class Person(id: Int)//主构造函数
{ //次构造必须要调用主构造
constructor(id: Int,name: String) : this(id) {
}
//次构造
constructor() : this(11) {
}
}
-
继承：
class Student(id:Int) : //Person()次构造
Person(id)//主构造
{
//kotlin中所有的变量均无默认值,所以无初始值编译器会报错
//java成员变量有默认值，方法内部局部变量没默认值
//若不想赋初始值，可以使用lateinit 懒加载，后续赋值，若后续没有赋值，使用会报错
lateinit var name : String
var age = 0
}
-
接口：
//接口默认都是open的
interface Callback {
fun callbackMethod():String
}
-
抽象类：
//默认是public final class Animal，但加上abstract ，相当于open
abstract class Animal() : Callback{
abstract fun getId():Int
abstract fun init() :Unit
}
-
内部类用inner修饰：
class InnerClass {
val a = "AA"
class Sub{
fun show(){
//无法访问InnerClass类成员，这样只是嵌套类，非内部类，和外部类没有任何关系
// println(a)
}
}
//这样才是内部类，需要加关键字inner
inner class Sub1(){
fun show(){
println(a)
}
}
}
-
数据实体类用data修饰：
//自动生成get set 构造函数，equals，hashCode，toString，copy方法，非常便捷
data class UserBean(var id:Int,val name:String,val sex:Char)
-
object派生类，相当于饿汉式单例，静态变量实例
object Instance{
fun m(){
println("只实例化一次")
}
}
fun main(){
//只会实例一次
Instance.m()
Instance.m()
Instance.m()
}
反编译后的java代码
public final class Instance {
public static final Instance INSTANCE;
public final void m() {
String var1 = "只实例化一次";
boolean var2 = false;
System.out.println(var1);
}
private Instance() {
}
static {
Instance var0 = new Instance();
INSTANCE = var0;
}
}
-
懒加载单例1（相当于java的静态内部类实现单例）
class Singleton1 {
object Holder{
val instance = Singleton1()
}
companion object{
//伴生对象内部全部相当于java的static
fun getInstance() = Holder.instance
}
fun show(msg: String){
println("msg:$msg")
}
}
fun main(){
var singleton: Singleton1 = Singleton1.getInstance()
singleton.show("单例方法调用")
}
-
懒加载单例2
class Singleton2 {
companion object{
private var instance: Singleton2? = null
fun getInstance(): Singleton2?{
if (instance == null){
instance = Singleton2()
}
//是null可以返回,需要方法加 ?
return instance
//强制返回,为null在这里就会报空指针
// return instance!!
}
}
fun show(str:String){
println(str)
}
}
fun main(){
val singleton : Singleton2? = Singleton2.getInstance()
singleton?.show("单例方法调用")
}