fun main() {

val stateManager = StateManager()

stateManager.state = 10

stateManager.state = 11

}

//输出

property:var org.example.zxf.kotlin5.StateManager.state: kotlin.Int

oldValue:0

newValue:10

property:var org.example.zxf.kotlin5.StateManager.state: kotlin.Int

oldValue:10

newValue:11

属性代理-vetoable：Delegates.vetoable()代理主要用于监控属性值发生变更，类似于一个观察者，当属性值被修改后会往外部抛出一个变更的回调。它需要传入两个参数，一个是initValue初始化的值，另一个就是回调lamba, 回调出property, oldValue, newValue三个参数。与observable不同的是这个回调会返回一个Boolean值，来决定此次属性值是否执行修改。

示例如下：

class StateManager {

var state2: Int by Delegates.vetoable(0) {

property, oldValue, newValue ->

return@vetoable newValue == 1

}

}

//使用

fun main(){

val stateManager2 = StateManager()

stateManager2.state2 = 1

stateManager2.state2 = 2

println(“stateManager2 state2 is 😒{stateManager2.state2}”)

}

//输出

stateManager2 state2 is :1

五、Kotlin单例object

===================================================================================

0.object、companion object以及val和const val的区别

---

object单例

默认有一个INSTATIC的静态成员常量（static final），在静态代码块中，分配自己（new 自己）

成员变量 val 相当于 java类里面的 声明了静态常量（static final），在静态代码块中初始化值。

成员变量var相当于java类里面的 声明了静态变量（static），在静态代码块中初始化值。

方法都是对象方法。

companion object伴生对象理论上来说和object一样。

在当前类里面创建了一个Companion 的类，在当前类中，持有一个静态常量（static final），静态字段初始化的时候new Companion 对象。

里面的成员变量val 和 var 和上面的object相似，不过是在当前类中声明的，在当前类的静态代码块中初始化。

方法在用final修饰的，在Companion 对象内部声明。

这里面的 const val 和 val的区别。

const val 是以静态字段的形式初始化（编译期常量）；

val 在静态代码块中初始化（运行时常量）；

1.单例的多种实现方式

---

饿汉式：线程安全，可用。但类一加载的时候，就实例化，提前占用了系统资源

示例如下（Java）：

public class Singleton {

private Singleton() {

}

private static Singleton sSingleton = new Singleton();

public static Singleton getInstance() {

return sSingleton;

}

}

懒汉式：一般配合双重检查锁 DCL使用，保证线程安全/font>

示例如下（Java）：

public class Singleton {

private Singleton() {

}

private static volatile Singleton sSingleton;

public static Singleton getInstance() {

if (sSingleton == null) {

synchronized (Singleton.class) {

// 未初始化，则初始instance变量

if (sSingleton == null) {

sSingleton = new Singleton();

}

}

}

return sSingleton;

}

}

静态内部类：使用时才会加载，且加载类时初始化，线程安全

示例如下（Java）：

public class Singleton {

private Singleton () {

}

private static class InnerClassSingleton {

private final static Singleton sSingleton = new Singleton();

}

public static Singleton getInstance() {

return InnerClassSingleton.sSingleton;

}

}

2.kotlin的单例模式object

---

单例模式：kotlin使用object修饰的单例模式采用的是饿汉式

示例如下

object Singleton {

}

反编译为java代码如下所示

public final class Singleton {

public static final Singleton INSTANCE;

private Singleton() {

}

static {

Singleton var0 = new Singleton();

INSTANCE = var0;

}

}

可以看的出，反编译之后为饿汉式的方式实现单例的。

3.object单例模式的简单使用

---

简单使用:一般都用做工具类使用(object不能定义构造器)

示例如下

//声明单例类

object Singleton {

var age: Int = 0

var name: String = “”

fun test() {

println(“test”)

}

}

//使用单例类

fun main() {

Singleton.age = 10

Singleton.name = “zxf”

println(Singleton.name)

Singleton.test()

}

//输出

zxf

test

age:1

4.java访问object单例

---

那么java如何访问上述的单例类呢？

示例如下

Singleton.INSTANCE.getAge();

Singleton.INSTANCE.getName();

Singleton.INSTANCE.setName(“zxf”);

Singleton.INSTANCE.test();

上述是不是太麻烦了，有没有简单的方式呢？当然有，使用JvmField或者JvmStatic注解即可

示例如下

object Singleton {

//JvmField 对于java来说不生成getter/setter方法 访问等同于java Field

@JvmField

var age: Int = 0

var name: String = “”

//JvmField object的成员直接按照java静态成员生成字节码，对kotlin内部毫无影响，对于java可直接视为调用静态成员一般

@JvmStatic

fun test() {

println(“test”)

}

}

//java调用

Singleton.age = 10;

Singleton.test();

Singleton.INSTANCE.getName();

4.kotlin中对应java的静态成员

---

companion伴生对象，一般是 companion object 类似于 java静态变量方法的使用

示例如下

//java

public class Foo{

public static int age;

public static void y(){}

}

//kotlin 对应写法

class Foo{

companion object {

@JvmField

var age: Int = 0

@JvmStatic

fun y(){}

}

}

五、Kotlin内部类

==============================================================================

1.Java与Kotlin实现内部类方式比较

---

模式：默认是静态内部类，加上inner 是非静态内部类

示例如下：

//java

public class Outer{

//非静态内部类，实例持有外部类实例引用

class Inner{}

//静态内部类

static class StaticInner{}

}

//kotlin

class Outer{

//非静态内部类，实例持有外部类实例引用

inner class Inner

//静态内部类

class StaticInner

}

2.Kotlin内名内部类

---

示例如下：

val runnable = object : Runnable {

override fun run() {

TODO(“Not yet implemented”)

}

}

kotlin匿名内部类：可以继承类或者实现多个接口

val value = object : Runnable, RemoteJVMLauncher.CallBack {

override fun run() {

TODO(“Not yet implemented”)

}

override fun jvmStarted() {

TODO(“Not yet implemented”)

}

}

六、Kotlin数据类data

==================================================================================

1.Java与Kotlin实现内部类方式比较

---

数据类，不能够被继承，没有无参构造方法。可以进行解构操作、重新了equals、hashcode、toString、提供getter、setter、copy等函数

简单示例如下：

//java

public class Book{

private long id;

private String name;

private String person;

//省略getter/setter方法

}

//kotlin

data class Book(

var id:Long,

var name:String,

var person:String

)

//kotlin 解构的简单使用

val (id, name, person) = Book(1L, “zxf”, “person”)

println(“id:$id,name:$name,person:$person”)

//输出

id:1,name:zxf,person:person

2.data class 注意点

---

我们可以查看data class反编译之后的代码

public final class Book {

private final long id;

@NotNull

private final String name;

@NotNull

private final String person;

public final long getId() {

return this.id;

}

public final void setId(long var1) {

this.id = var1;

}

//其他getset省略

public Book(long id, @NotNull String name, @NotNull String person) {

Intrinsics.checkNotNullParameter(name, “name”);

Intrinsics.checkNotNullParameter(person, “person”);

super();

this.id = id;

this.name = name;

this.person = person;

}

public final long component1() {

return this.id;

}

@NotNull

public final String component2() {

return this.name;

}

@NotNull

public final String component3() {

return this.person;

}

@NotNull

public final Book copy(long id, @NotNull String name, @NotNull String person) {

Intrinsics.checkNotNullParameter(name, “name”);

Intrinsics.checkNotNullParameter(person, “person”);

return new Book(id, name, person);

}

// $FF: synthetic method

public static Book copy$default(Book var0, long var1, String var3, String var4, int var5, Object var6) {

if ((var5 & 1) != 0) {

var1 = var0.id;

}

if ((var5 & 2) != 0) {

var3 = var0.name;

}

if ((var5 & 4) != 0) {

var4 = var0.person;

}

return var0.copy(var1, var3, var4);

}

@NotNull

public String toString() {

return “Book(id=” + this.id + “, name=” + this.name + “, person=” + this.person + “)”;

}

public int hashCode() {

//todo 省略

}

public boolean equals(@Nullable Object var1) {

//todo 省略

}

}

除了常规的方法外，还提供了几个component，上面我们使用的解构的功能，就是通过component实现的。

• 基于component提供相等性，解构等功能

• 数据类属性类型最好为基本类型、string、或者其他dataclass

• Component不可以自定义getter、setter

• 定义成员最好定义为val，防止修改后equals和hashcode的相等性判断错误

七、枚举类EnumClass

=================================================================================

1.Java与Kotlin实现枚举类比较

---

java与kotlin实现枚举对比

简单示例如下：

//java

enum State{

InComplete,Complete

}

//使用

State.InComplete.name()//InComplete

State.InComplete.ordinal()//0

//kotlin

enum State{

InComplete,Complete

}

//使用

State.InComplete.name//InComplete

State.InComplete.ordinal//0

定义构造器示例如下：

//java

enum State{

InComplete(0),Complete(1);

int id;

State(int id){

this.id = id;

}

}

//kotlin

enum class State(val id: Int){

InComplete(0),Complete(1)

}

2.Kotlin枚举的简单使用

---

// 定义枚举类

enum class Color {

WHITE, BLACK, RED;

}

// 为枚举定义扩展方法

fun Color.nextColor(): Color {

// values()以集合的形式返回出所有的枚举

return Color.values().let {

// ordinal 当前的序号

val nextOrdinal = (this.ordinal + 1) % it.size

it[nextOrdinal]

}

}

fun main() {

// 获取枚举的位置和名字

val ordinal = Color.BLACK.ordinal

val name = Color.BLACK.name

println(“enum:name:$name,index:$ordinal”)

// 枚举比较大小 按照序号比较

println(Color.BLACK > Color.RED)

// 使用扩展方法获取下一个

println(“whitenextcolor:${Color.WHITE.nextColor().name}”)

// 枚举的区间

val closedRange = Color.WHITE…Color.RED

}

八、密封类sealed class

====================================================================================

1.密封类概念

---

• 密封类是一种特殊的抽象类

• 密封类的子类定义在与自身相同的文件中

• 密封类的子类个数是有限的

密封类构造器是私有的，子类只能写在同一个文件夹里面

密封类构VS枚举类

| | 密封类 | 枚举类 |

| — | — | — |

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）

学习分享，共勉

Android高级架构师进阶之路

题外话，我在阿里工作多年，深知技术改革和创新的方向，Android开发以其美观、快速、高效、开放等优势迅速俘获人心，但很多Android兴趣爱好者所需的进阶学习资料确实不太系统，完整。今天我把我搜集和整理的这份学习资料分享给有需要的人

• Android进阶知识体系学习脑图

• Android进阶高级工程师学习全套手册

• 对标Android阿里P7，年薪50w+学习视频

• 大厂内部Android高频面试题，以及面试经历

本文已被CODING开源项目：《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》收录

一个人可以走的很快，但一群人才能走的更远。如果你从事以下工作或对以下感兴趣，欢迎戳这里加入程序员的圈子，让我们一起学习成长！

AI人工智能、Android移动开发、AIGC大模型、C C#、Go语言、Java、Linux运维、云计算、MySQL、PMP、网络安全、Python爬虫、UE5、UI设计、Unity3D、Web前端开发、产品经理、车载开发、大数据、鸿蒙、计算机网络、嵌入式物联网、软件测试、数据结构与算法、音视频开发、Flutter、IOS开发、PHP开发、.NET、安卓逆向、云计算

4868a3f0fd6ac81d625c.png)

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）
[外链图片转存中…(img-oOo8w3GJ-1712405629977)]

学习分享，共勉

Android高级架构师进阶之路

题外话，我在阿里工作多年，深知技术改革和创新的方向，Android开发以其美观、快速、高效、开放等优势迅速俘获人心，但很多Android兴趣爱好者所需的进阶学习资料确实不太系统，完整。今天我把我搜集和整理的这份学习资料分享给有需要的人

• Android进阶知识体系学习脑图

[外链图片转存中…(img-dRiV5rEK-1712405629978)]

• Android进阶高级工程师学习全套手册

[外链图片转存中…(img-x6wUwCFU-1712405629978)]

• 对标Android阿里P7，年薪50w+学习视频

[外链图片转存中…(img-yuzD6pUl-1712405629979)]

• 大厂内部Android高频面试题，以及面试经历

[外链图片转存中…(img-BVwnMGwz-1712405629979)]

本文已被CODING开源项目：《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》收录

一个人可以走的很快，但一群人才能走的更远。如果你从事以下工作或对以下感兴趣，欢迎戳这里加入程序员的圈子，让我们一起学习成长！

AI人工智能、Android移动开发、AIGC大模型、C C#、Go语言、Java、Linux运维、云计算、MySQL、PMP、网络安全、Python爬虫、UE5、UI设计、Unity3D、Web前端开发、产品经理、车载开发、大数据、鸿蒙、计算机网络、嵌入式物联网、软件测试、数据结构与算法、音视频开发、Flutter、IOS开发、PHP开发、.NET、安卓逆向、云计算