第一章初识Kotlin，Android开发实战讲解

最新推荐文章于 2024-05-16 01:58:47 发布

嘻嘻哈哈学编程

最新推荐文章于 2024-05-16 01:58:47 发布

阅读量739

点赞数 28

分类专栏： 2024年程序员学习文章标签： android kotlin 开发语言

本文链接：https://blog.csdn.net/m0_61068496/article/details/137207273

版权

2024年程序员学习专栏收录该内容

294 篇文章 1 订阅

订阅专栏

}

var name: String
get() {
return name.toUpperCase()
}
set(value) {
name = value
}
var psd: String = “”
private set
get() {
return psd + “@”
}
}
复制代码

16、interface的方法体是否实现是可选的。属性也是抽象的，需要实现类重新赋值。

interface BaseView {
var mNickName: String//抽象的属性
fun walk() {//方法体是否实现是可选的
println(“BaseView,walk!!!”)
}

fun yeal() {}//
}
复制代码

17、密封类

//密封类
sealed class Expr//相当于枚举的扩展

data class Const(val number: Double) : Expr()//这里只有另外一个double的状态入参
data class Sum(val e1: Expr, val e2: Expr) : Expr()//这个密封类里面就有两个Expr的状态入参
object NotANumber : Expr()

fun eval(expr: Expr): Double = when (expr) {
is Const -> expr.number
is Sum -> eval(expr.e1) + eval(expr.e2)
NotANumber -> Double.NaN
//因为已经覆盖了所以的情况，就不需要else子句了
}
复制代码

18、枚举

Color.BLACK.name
enumValues().size
enumValues().get(0)
enumValues().plus(Color.WHITE)
enumValues().iterator()
enumValueOf(Color.WHITE.toString())
复制代码

19、list和Comparable

fun <T : Comparable> sort(list: List) {
}
sort(listOf(1, 2, 3)) // OK。Int 是 Comparable 的子类型
// 错误：HashMap<Int, String> 不是 Comparable<HashMap<Int, String>> 的子类型
// sort(listOf(HashMap<Int, String>()))
复制代码

20、object对象

val site = object {
var name = “jack”
var url = “www.tansu.com”
}
复制代码

21、委托类，委托对象（通过关键字 by 建立）

interface MyBase {
fun bark()
// fun bak()
}

class BaseImpl(val x: Int) : MyBase {
fun bak() {}
override fun bark() {
println(“x:$x”)
}
}

// 通过关键字 by 建立委托类
class Deried(b: MyBase) : MyBase by b

fun test3() {
var baseImpl = BaseImpl(10)
Deried(baseImpl).bark()
baseImpl.bak()
// Deried(baseImpl).bak()//无法访问到非interface定义的方法
}

// 定义包含属性委托的类
class Example {
var p: String by Delegate()
//说明：如果p是var的话，那么委托类需要有getValue和setValue两个方法(因为此时是可变的变量，需要由set方法）
//说明：如果p是val的话，那么委托类只需要有getValue方法即可，另外一个可以不要求（此时为不可变常量，不需要set值进去）
}

// 委托的类
class Delegate {
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
return “$thisRef, 这里委托了 ${property.name} 属性”//这里name为p
}

operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
println(“$thisRef 的 ${property.name} 属性赋值为 $value”)//value为设置进来的值
}
}

fun test4() {
val e = Example()
println(e.p) // 访问该属性，调用 getValue() 函数

e.p = “Runoob” // 调用 setValue() 函数
println(e.p)
// Example@433c675d, 这里委托了 p 属性
// Example@433c675d 的 p 属性赋值为 Runoob
// Example@433c675d, 这里委托了 p 属性
}
复制代码

21、监听类值的变化

class User {
var name: String by Delegates.observable(“初始值”) { prop, old, new ->
println(“旧值： $o l d - > 新值：$ new. prop:$prop”)
}
}
val user = User()
user.name = “第一次赋值”
user.name = “第二次赋值”
// 旧值：初始值 -> 新值：第一次赋值
// 旧值：第一次赋值 -> 新值：第二次赋值
复制代码

22、map

//把属性储存在映射中
class MyWebSite(val map: Map<String, Any?>) {
val name: String by map
val url: String by map
}
使用
var myWebSite = MyWebSite(mapOf(“name” to “jack”, “url” to “www.baidu.com”))
myWebSite.name
myWebSite.url
//结果读取出来
复制代码

23、其它

class Foo {
var notNullBar: String by Delegates.notNull()
}
使用
var foo = Foo()
foo.notNullBar = “bar”
println(foo.notNullBar)

kotlin最佳实践

类型的声明与使用

val与var

val->不可变引用，var->可变引用。

我们应该尽可能地使用val关键字来声明所有的kotlin变量 为什么呢？

首先一个变量在声明时是不可变的，那就代表你在使用的时候不需要考虑其他地方会对它重新复制和改变(对于对象注意只是引用不可变)，直接使用。
val声明的类型由于必须初始化,它是线程安全的。
kotlin为了保证类型安全，所有变量声明的地方必须要做初始化，即显示赋一个初值。

空与非空

kotlin对于可空类型和非空类型认为是两个完全不同的类型，比如Int与Int?,他们俩就不是相同的类型。利用这个特点和编译时检查，kotlin基本可以避免空指针异常。

上面已经说了kotlin的类型声明时必须要有初值，所以空与非空类型和val与var一组合就会变成4种情况，下面我们对一个Person对象进行声明:

val p:Person = Person()
val p:Person? = null // 这个情况是没有意义的
var p:Person = Person() // 如果这个对象是非空类型，那么初始化的时候必须赋一个非null初值
var p:Person? = null //可以给一个null,也可以给一个对象实例

上面这段代码基本解释了val与var和空与非空的关系。

空与非空的使用

kotlin对空与非空做了严格的限制，那我们在使用时不都要对可空类型类型做判断吗？为了避免这个问题，kotlin提供了许多运算符来使开发人员对于可空与非空编码更加愉快。

安全调用运算符 “?.”

比如我们声明了这样一个类型var p:Person? = null。如果我们直接使用p.name，kotlin编译器是会报错的无法编译通过，所有我们必须这么做:

if(p != null) p.name

这种代码写多了实在是太没有意义了，所有kotlin提供了?.。上面代码我们可以直接这样代替p?.name。它的实际执行过程是这样的:如果p为空则不操作，如果p不为空则调用p.name。

Elvis 运算符 “?:”

在kotlin中我们会写这种代码:

val name = if(p != null) p.name else “” //kotlin中的if是一个表达式

不过使用?:可以更简单实现上面的逻辑 : val name = p?.name ?: "" 。它的实际执行逻辑是如果p为null，p?.name就会为null， ?:会检查前面的结果，如果是null，那么则返回""。

安全转换 “as?”

在kotlin中类型转换关键字为as。不过类型转换会伴随着转换失败的风险。使用as?我们可以更优雅的写出转换无风险的代码:

//Person类中的方法
fun equals(o:Any?):Boolean{
val otherPerson = o as? Person ?: return false
…
}

即as?在转换类型失败时会返回null

非空断言 “!!”

如果使用一个可空类型的方法，并且你不想做非空判断，那么你可以这样做: person!!.getAge()。不过如果person为null，这里就会抛出空指针异常。

其实还是在蛮多case下可以使用它，但是不建议使用, 因为你完全可以使用?、?:来做更优雅的处理, 你也可以使用lateinit来避免编译器的可空提示

val与bylazy、var与lateinit

bylazy

它只能和val一块使用。

private val mResultView：View = bylazy{
initResultView()
}

使用bylazy我们可以对一个变量延迟初始化，即懒加载。它是线程安全的。具体原理是:当我们使用bylazy声明的变量时，如果这个变量为null,那么就会调用bylazy代码块来初始化这个变量。

lateinit

它只能和var一块使用。并且不允许修饰可空类型。那它的使用场景是什么呢？在有些case下，比如一个构造复杂的对象，我们就是想把变量声明为非空类型并且就是不想给他一个初值(代价太大了),这时候我们就可以使用lateinit :

lateinit var p : Person //Person的构造函数太复杂了，不想在这里给一个初值

fun refreshUI(p2:Person){
//p = p2
val name = p.name //注意这个地方是可能会抛p为初始化异常的！！！如果你没有初始化
}

由于使用lateinit的时候我们要人工保证这个变量已经被初始化，并且kotlin在你每个使用这个变量的地方都会添加一个非null判断。所以lateinit尽量少用。

when 与 if

if

if在kotlin中不只是一个控制结构它也是一个表达式,即它是有返回结果的，我们可以利用它来代替java中的三目运算符:

val background = if(isBlcak) R.drawable.black_image else R.drawable.white_image

when

它的使用方法有多种:

代替switch的功能

when(color){
“red”,“green” ->{ }
“blue”->{ }
}

kotlin中的when可以用来判断任何对象，它会逐一检查每一个分支，如果满足这个分支的条件就执行。

多条件判断

可以使用when来避免if..elseif..elseif..else的写法:

val a = 1
val b = 2
when{
a > 0 && b > 0 ->{}
a < 0 && b > 0 ->{}
a < 0 && b < 0 ->{}
else ->{ }
}

when是带有返回值的表达式

和if一样，when也是一个表达式:

val desColor = when(color){
“red”, “gren” -> “red&green”
“blue” -> “blue”
else -> “black” // when作为表达式时必须要有else分支。
}

类

类的构造与主构造函数

简单的声明一个 javabean

在kotlin中我们可以这样简单的定义一个类: class Person(val name:String = "", var age:Int = 0)

这样就定义了一个Person类，这个类有两个属性:name和age。并且他有一个两个参数的构造函数来对这两个属性初始化。可以看出kotlin将一个类的声明变的十分方便。

主构造函数

普通的java构造函数是有代码块的，即可以做一些逻辑操作，那按照kotlin上面的方式，我们怎么做构造函数的逻辑操作呢? kotlin提供了初始化代码块:

class Person(val name:String = “”, var age:Int = 0){
init{
name = “susion”
age = 13
}
}

init代码块会在主构造函数之后运行，注意不是所有的构造函数。

数据类 data class

更方便的定义一个javabean，我们可以使用数据类:

data class Person(val name:String = “”, val age:Int = 0)

使用data定义的Person会默认生成equals、hashCode、toString方法。需要注意的是数据类的属性我们应该尽量定义成val的。这是因为在主构造函数中声明的这些属性都会纳入到equals和hashCode方法中。如果某个属性是可变的，
那么这个对象在被加入到容器后就会是一个无效的状态。

object 和 companion object

在kotlin中没有静态方法，也没有静态类。不过kotlin提供了object与companion object

object 单例类

使用object我们可以很轻松的创建一个单例类 :

object LoginStatus{
var isLogin = false

fun login(){
isLogin = true
}
…
}

我们可以这样直接使用LoginStatus.isLogin()。那这个单例在kotlin中是怎么实现的呢？我们可以反编译看一下它生成的java代码:

public final class LoginStatus {
private static boolean isLogin;
public static final LoginStatus INSTANCE; // for java调用

… //省略不重要的部分

public final void login() {
isLogin = true;
}

private LoginStatus() {
INSTANCE = (LoginStatus)this;
}

static { //类加载的时候构造实例
new LoginStatus();
}
}

即kotlin object实现的单例是线程安全的。它的对象是在类创建的时候就产生了。

object的静态方法的使用

上面我们已经知道object创建单例的原理了。这在某些case下就很棒，但是某些时候我们不是想要单例，我们只是想要一些静态方法呢？比如我们经常创建的一些工具类(UIUtils、StringUtils)等。我们可以直接使用object来完成:

public object UIUtils{
…
…
…
…很多方法
}

按照kotlin单例的设计，我们只要一旦使用这些方法，那么一直有一个单例对象UIUtils存在于内存中。那么这样好吗? 我们是否可以这样写呢 :

public class UIUtils{
…
…
…
…很多方法
}

然后在使用的时候:UIUtils().dp2Px(1)。这样至少不会有一个对象一直在内存中。我想我们在某些case下可以这样使用我们的工具类。或者你可以使用kotlin的扩展函数或顶层函数来定义一些工具方法。所以对于kotlin的object的使用需要注意。

companion object

companion object主要是为了方便我们可以在一个类中创建一些静态方法而存在的，比如:

class Person(val name: String) {
companion object {
fun isMeal(p: Person) = false
}

}

依旧看一下它反编译后的java代码:

public final class Person {
…
public static final Person.Companion Companion = new Person.Companion((DefaultConstructorMarker)null);
…
public static final class Companion {
public final boolean isMeal(@NotNull Person p) {
Intrinsics.checkParameterIsNotNull(p, “p”);
return false;
}

private Companion() {
}
…
}
}

即它也是生成了一个单例类Person.Companion。不过这个单例类是一个静态类。不允许构造。不过它的实现机制几乎和object相同。