Android kotlin Jetpack mvvm 项目，互联网大厂高频重点面试题

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

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

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

如果你需要这些资料，可以添加V获取：vip204888 （备注Android）

正文

• 还可以切换到Design模式编辑

NavController

• 在fragment1中直接调用以下代码即可从fragment1切换到fragment2，并且传入参数

findNavController().navigate(NavigationFragment1Directions.actionNavigationFragment1ToNavigationFragment22(“测试”))

其他功能

• 全局操作 使用全局操作来创建可由多个目的地共用的通用操作
• 创建深层链接 将用户直接转到应用内特定目的地的链接
• 使用 NavigationUI 更新界面组件 使用顶部应用栏、抽屉式导航栏和底部导航栏来管理导航
• 自定义返回导航

Lifecycle

传统在生命周期方法写逻辑代码的缺点

• 太多管理界面和其他组件的调用，以响应生命周期的当前状态。管理多个组件会在生命周期方法（如 onStart() 和 onStop()）中放置大量的代码，这使得它们难以维护
• 无法保证组件会在 Activity 或 Fragment 停止之前启动。在我们需要执行长时间运行的操作（如 onStart() 中的某种配置检查）时尤其如此

Lifecycle的优势

• 生命周期感知型组件可执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。这些组件有助于您编写出更有条理且往往更精简的代码，您可以将依赖组件的代码从生命周期方法移入组件本身中，此类代码更易于维护。

lifecycle使用

• 定义LifecycleObserver

inner class MyLifecycleObserver(val lifecycle: Lifecycle) : LifecycleObserver {

@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun onStart() {
CoroutineScope(scope).launch {
delay(3000)
if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
LogUtil.e(“开启定位”)
}
}
}

@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun onStop() {
LogUtil.e(“关闭定位”)
}
}

• 添加LifecycleObserver

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
lifecycle.addObserver(MyLifecycleObserver(lifecycle))
}

ViewModel

• 旨在以注重生命周期的方式存储和管理界面相关的数据。ViewModel 类让数据可在发生屏幕旋转等配置更改后继续留存，负责为界面准备数据。在配置更改期间会自动保留 ViewModel 对象，以便它们存储的数据立即可供下一个 Activity 或 Fragment 实例使用。

ViewModel可以解决什么问题

• 如果系统销毁或重新创建界面控制器，则存储在其中的任何瞬态界面相关数据都会丢失，为了避免我们的程序出现上述这种情况，我们除了使用Activity的savedInstanceState(仅适合可以序列化再反序列化的少量数据)保存数据之外，还可以使用ViewModel来进行处理数据(可保存较大数据)
• 简化资源管理工作，避免内存泄漏风险，Activity 和 Fragment经常需要进行可能需要一些时间才能返回的异步调用（如网络请求），我们需要确保系统在其销毁后清理这些调用以避免潜在的内存泄漏，同时如果配置发生更改重新创建对象的时候可能会发生重复此前已完成的工作，造成资源浪费
• 让 Activity 和 Fragment 专注于界面显示，如果要求界面控制器也负责从数据库或网络加载数据，那么会使类越发膨胀，ViewModel可以更容易、高效的分离出视图数据操作
• 实现Fragment和Activity/Fragment共享数据

ViewModel使用

• 实现ViewModel，继承ViewModel抽象类即可

class ViewModelViewModel: ViewModel() {
val userList = mutableListOf()
}

• 引用ViewModel

在fragment/activity中使用

val viewModel:ViewModelViewModel by viewModels()
viewModel.userList

在多个fragment中共享的ViewModel，使用by activityViewModels()创建的ViewModel依赖于Activity，在多个Fragment为同一个对象

val shareViewModel:ViewModelViewModel by activityViewModels()

或者使用koin依赖注入,koin使用说明在下文

val viewModel: ViewModelViewModel by viewModel()

val viewModel: ViewModelViewModel by sharedViewModel()

ViewModel生命周期

生命周期感知数据 LiveData

是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力，意指它遵循其他应用组件（如 Activity、Fragment 或 Service）的生命周期。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。

LiveData的优势

• 确保界面符合数据状态:LiveData 遵循观察者模式。当底层数据发生变化时，LiveData 会通知 Observer 对象。您可以整合代码以在这些 Observer 对象中更新界面。
• 不会发生内存泄漏:观察者会绑定到 Lifecycle 对象，并在其关联的生命周期遭到销毁后进行自我清理。
• 不会因 Activity 停止而导致崩溃:如果观察者的生命周期处于非活跃状态（如返回栈中的 Activity），则它不会接收任何 LiveData 事件。
• 不再需要手动处理生命周期:界面组件只是观察相关数据，不会停止或恢复观察。LiveData 将自动管理所有这些操作，因为它在观察时可以感知相关的生命周期状态变化。
• 数据始终保持最新状态:如果生命周期变为非活跃状态，它会在再次变为活跃状态时接收最新的数据。
• 适当的配置更改:如果由于配置更改（如设备旋转）而重新创建了 Activity 或 Fragment，它会立即接收最新的可用数据。
• 共享资源:可以使用单例模式扩展 LiveData 对象以封装系统服务，以便在应用中共享它们。

LiveData使用

• 定义

private val normaLiveData1 = MutableLiveData()

• 赋值

normaLiveData1.value=“LiveDataValue”//UI线程
normaLiveData1.postValue(“LiveDataValue”)//非UI主线程

• 观察数据

normaLiveData1.observe(viewLifecycleOwner, Observer {
LogUtil.e(“观察到第一个值发生了变化”)
tv.text = it
})

• 无生命周期感知地观察数据，这种方式需要手动取消观察，否则会发生内存泄漏

val observer=Observer{
LogUtil.e(“观察到第一个值发生了变化”)
}
normaLiveData1.observeForever(observer)
//在合适的生命周期移除观察
normaLiveData1.removeObserver(observer)

• 转换 LiveData

private val transLiveData= Transformations.map(normaLiveData1){
“$it -----转换”
}

• 合并多个 LiveData

private val mediatorLiveData = MediatorLiveData()

mediatorLiveData.addSource(normaLiveData1){
mediatorLiveData.value=“合并后的值：$it---${normaLiveData2.value}”
}

mediatorLiveData.addSource(normaLiveData2){
mediatorLiveData.value=“合并后的值：$normaLiveData1.value---$it”
}

• LiveData结合room、协程使用(下文)

kotlin数据流 Flow

Flow数据流以协程为基础构建，可提供多个值。从概念上来讲，数据流是可通过异步方式进行计算处理的一组数据序列,有点像RxJava。

Flow的使用

• 创建Flow

val flow = flow {
emit(“value1”)
emit(“value2”)
delay(1000)
emit(“value3”)
}

val flow = flowOf(“value”)

val flow = listOf(1, 2, 3).asFlow()

• 收集Flow----collect()

由于 collect 是挂起函数，因此需要在协程中执行

scope.launch {
flow.collect {
LogUtil.e(it)
}
}

• 转换Flow----map()

flowOf(1, 2, 3).map {
“第$it 个”
}.collect {
LogUtil.e(it)
}

• 过滤Flow----filter()

flowOf(1, 2, 3).filter {
it > 1
}.collect {
LogUtil.e(it)
}

• 合并Flow

zip操作符会把 flow1 中的一个 item 和 flow2 中对应的一个 item 进行合并,如果 flow1 中 item 个数大于 flow2 中 item 个数,合并后新的 flow 的 item 个数 = 较小的 flow 的 item 个数

val flow1 = flowOf(1, 2, 3, 4, 5)
val flow2 = flowOf(“一”, “二”, “三”, “四”, “五”, “六”)
flow1.zip(flow2) { a, b ->
“$a---$b”
}.collect {
LogUtil.e(it)
}

combine合并时，每次从 flow1 发出新的 item ，会将其与 flow2 的最新的 item 合并

val flow1 = flowOf(1, 2, 3, 4, 5).onEach { delay(1000) }
val flow2 = flowOf(“一”, “二”, “三”, “四”, “五”, “六”).onEach { delay(500) }
flow1.combine(flow2) { a, b ->
“$a---$b”
}.collect {
LogUtil.e(it)
}

• 捕获异常----catch()

flow {
emit(1)
emit(1 / 0)
emit(2)
}.catch {
it.printStackTrace()
}.collect {
LogUtil.e(it)
}

• 线程切换----flowOn()

withContext(Dispatchers.IO){
flowOf(1, 2, 3, 4).onEach {
//受到下面最近的flowOn控制-Main
LogUtil.e(“init—KaTeX parse error: Expected 'EOF', got '}' at position 33: …read().name}") }̲.filter { //受到下…{Thread.currentThread().name}”)
it > 1
}.flowOn(Dispatchers.Main).map {
//受到下面最近的flowOn控制-IO
LogUtil.e(“map—$Thread.currentThread().name")"第$it”
}.flowOn(Dispatchers.IO).map {
//受到下面最近的flowOn控制-Main
LogUtil.e(“第二次map—$Thread.currentThread().name")"$it 个结果”
}.flowOn(Dispatchers.Main).collect {
//collect要看整个flow处于哪个线程，此处为IO
LogUtil.e(“collect—${Thread.currentThread().name}”)
LogUtil.e(it)
}
}

• 转为liveData----asLiveData()

添加依赖

“androidx.lifecycle:lifecycle-livedata-ktx:${LibraryVersion.LIVEDATA_KTX}”

flowOf(1, 2, 3, 4).asLiveData().observe(viewLifecycleOwner, Observer {
LogUtil.e(it)
})

更多操作符

本地保存 DataStore

DataStore 是一种数据存储解决方案,允许您使用协议缓冲区存储键值对或类型化对象。DataStore 使用 Kotlin 协程和 Flow 以异步、一致的事务方式存储数据。 参考鸿洋的公众号内容

SharedPreferences存在的问题

• 通过 getXXX() 方法获取数据，可能会导致主线程阻塞
• SharedPreference 不能保证类型安全
• SharedPreference 加载的数据会一直留在内存中，浪费内存
• apply() 方法虽然是异步的，可能会发生 ANR，在 8.0 之前和 8.0 之后实现各不相同
• apply() 方法无法获取到操作成功或者失败的结果

DataStore 解决了什么问题

• DataStore 是基于 Flow 实现的，所以保证了在主线程的安全性
• 以事务方式处理更新数据，事务有四大特性（原子性、一致性、 隔离性、持久性）
• 没有 apply() 和 commit() 等等数据持久的方法
• 自动完成 SharedPreferences 迁移到 DataStore，保证数据一致性，不会造成数据损坏
• 可以监听到操作成功或者失败结果
• 另外 Jetpack DataStore 提供了 Proto DataStore 方式，用于存储类的对象（typed objects ），通过 protocol buffers 将对象序列化存储在本地，protocol buffers 现在已经应用的非常广泛，无论是微信还是阿里等等大厂都在使用

DataStore使用

添加依赖

const val DATA_STORE = “1.0.0-alpha05”
const val PROTOBUF = “3.11.0”
“androidx.datastore:datastore-preferences:$LibraryVersion.DAT{A}_{S}TORE"//protobuf需下面的依赖"androidx.datastore::datastore-core:${LibraryVersion.DATA_STORE}”
“com.google.protobuf:protobuf-java:${LibraryVersion.PROTOBUF}”

保存键值对

object DataStore {

private const val APP_DATA_STORE_NAME = “APP_DATA_STORE_NAME”
private lateinit var dataStore: DataStore

fun init(context: Context) {
dataStore = context.createDataStore(APP_DATA_STORE_NAME)
}

suspend fun save(key: Preferences.Key, value: T) {
dataStore.edit {
it[key] = value
}
}

suspend fun get(key: Preferences.Key): T? {
val value = dataStore.data.map {
it[key]
}
return value.first()
}

}

保存

CoroutineScope(scope).launch {
DataStore.save(preferencesKey(“key1”), “aa”)
}

读取

CoroutineScope(scope).launch {
val get = DataStore.get(preferencesKey(“key1”))
}

保存protobuf

protobuf相关知识不在这里展开叙述

• 定义.proto文件

syntax = “proto3”;

option java_package = “com.haikun.jetpackapp.home.ui.demo.datastore.bean”;
option java_multiple_files = true;

message MessageEvent {
int32 type = 1;
string message = 2;
}

• 编译文件

编译后得到下图三个文件

• 定义Serializer

object MessageSerializer : Serializer {
override val defaultValue: MessageEvent
get() = MessageEvent.getDefaultInstance()

override fun readFrom(input: InputStream): MessageEvent {
return MessageEvent.parseFrom(input)
}

override fun writeTo(t: MessageEvent, output: OutputStream) {
t.writeTo(output)
}
}

• 保存

val createDataStore = context?.createDataStore(“data”, MessageSerializer)
createDataStore?.updateData {
it.toBuilder().setType(12).setMessage(“消息”).build()
}

• 读取

CoroutineScope(scope).launch {
context?.createDataStore(“data”, MessageSerializer)?.data?.first()?.let {
LogUtil.e(“$it.type---${it.message}”)
}
}

声明式UI DataBinding

数据绑定库是一种支持库，借助该库，您可以使用声明性格式（而非程序化地）将布局中的界面组件绑定到应用中的数据源,可以使用 LiveData 对象作为数据绑定来源，自动将数据变化通知给界面 。

声明式UI VS 命令式UI

• 声明式UI 只需要把界面给「声明」出来，而不需要手动更新，只要声明的数据发生了变化，UI就跟着变化

• 命令式UI 需要主动让UI更新，比如setText()

DataBinding使用

开启DataBinding

android {
…
dataBinding {
enabled = true
}
}

基本用法

• 在ViewModel中定义数据和方法

class DataBindingViewModel : ViewModel() {

val userName = MutableLiveData()
val clickTimes = MutableLiveData()
val sexCheckId = MutableLiveData()
val love = MutableLiveData()

fun save(){
LogUtil.e(“$userName.value---${sex.value}—${love.value}”)
}
}

• xml中引用和调用

• Fragment

class DataBindingFragment : Fragment() {

private val mViewModel: DataBindingViewModel by viewModels()

override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
val dataBinding = DataBindingUtil.inflate(
inflater,
R.layout.fragment_data_binding,
container,
false
)
//使用liveData必须要设置lifecycleOwner，否则无法更新数据
dataBinding.lifecycleOwner = viewLifecycleOwner
dataBinding.viewModel = mViewModel
return dataBinding.root

}
}

进阶用法

• BindingMethods 绑定方法名

@BindingMethods(value = [BindingMethod(type = MyButton::class, attribute = “maxTimes”, method = “setMaxTimes”)])

xml中使用

app:maxTimes=“@{15}”

• BindingAdapter 提供自定义逻辑

一些属性需要自定义绑定逻辑。例如，android:paddingLeft 特性没有关联的 setter，而是提供了 setPadding(left, top, right, bottom) 方法。使用 BindingAdapter 注释的静态绑定适配器方法支持自定义特性 setter 的调用方式。

object ViewAdapter {
@BindingAdapter(“minTimes”)
@JvmStatic
fun setMinTimes(view: MyButton, minTimes: Int) {
view.setMin(minTimes)
}
}

xml中使用

app:minTimes=“@{8}”

• 自定义双向绑定

@InverseBindingAdapter(attribute = “clickTimes”)
@JvmStatic
fun getClickTimes(view: MyButton): Int {
return view.clickTimes
}

@BindingAdapter(“clickTimesAttrChanged”)
@JvmStatic
fun setListener(view: MyButton, listener: InverseBindingListener?) {

view.onTimesChangeListener = {
listener?.onChange()
}

}

xml使用

app:clickTimes=“@={viewModel.clickTimes}”

Compose----android声明式UI未来的趋势

• 2019 年中，Google 在 I/O 大会上公布了 Android 最新的 UI 框架：Jetpack Compose。Compose 可以说是 Android 官方有史以来动作最大的一个库了。它在 2019 年中就公布了，但要到今年也就是 2021 年才会正式发布。这两年的时间 Android 团队在干嘛？在开发这个库，在开发 Compose。一个 UI 框架而已，为什么要花两年来打造呢？因为 Compose 并不是像 RecyclerView、ConstraintLayout 这种做了一个或者几个高级的 UI 控件，而是直接抛弃了我们写了 N 年的 View 和 ViewGroup 那一套东西，从上到下撸了一整套全新的 UI 框架。直白点说就是，它的渲染机制、布局机制、触摸算法以及 UI 的具体写法，全都是新的。
• 第一眼看到Compose，第一感觉就是觉得和Flutter的写法惊人的相似,Compose需要系统的学习，而且需要较高的学习成本，不在这里展开叙述
• Compose只支持kotlin，并且目前需要用Canary版本的android studio进行开发

数据库 Room

Room 在 SQLite 上提供了一个抽象层，以便在充分利用 SQLite 的强大功能的同时，能够流畅地访问数据库 Room可以和kotlin协程/flow结合使用 Room可以和LiveData结合使用

Room 包含 3 个主要组件：

• 数据库：包含数据库持有者，并作为应用已保留的持久关系型数据的底层连接的主要接入点。
• Entity：表示数据库中的表。
• DAO：包含用于访问数据库的方法。

添加依赖

implementation “androidx.room:room-runtime:$roo{m}_{v}ersion"kapt"androidx.room:room-compiler:$room_version”

implementation “androidx.room:room-ktx:$room_version”

基本用法

• 定义Entity

@Entity
data class Car(
@PrimaryKey(autoGenerate = true) val id: Long,
var name: String,
val color: String,
)

@PrimaryKey 主键 类名就是表名，也可以在@Entity(table=)设置表名 可以使用@Ignore忽略某个字段

• 定义Dao

@Dao
interface CarDao {

@Insert(onConflict = OnConflictStrategy.REPLACE)
fun insertCar(car: Car):Long

@Delete
fun deleteCar(car: Car)

@Update
fun updateCar(car: Car)

@Query(“SELECT * From Car”)
fun queryCarList(): MutableList

@Query(“Select * from Car where id=:id”)
fun queryCarById(id: Long): Car?
}

• 定义Database

@Database(entities = [Car::class], version = 1,exportSchema = false)
abstract class DemoDatabase : RoomDatabase() {

abstract fun carDao(): CarDao

}

• 创建Database和获取Dao

private val db: DemoDatabase by lazy {
Room.databaseBuilder(
JetpackApp.getContext(),
DemoDatabase::class.java, “demo-database”
).build()
}

private val carDao: CarDao by lazy {
db.carDao()
}

• 增删改查

carDao.insertCar(car)
carDao.delete(car)
carDao.updateCar(car)
val car = carDao.queryCarById(mUpdateId)

Room并不支持在主线程访问数据库, 除非在Builder调用allowMainThreadQueries()方法, 因为它很可能将UI锁上较长一段时间. 但是, 异步查询–返回LiveData/Flowable实例的查询–则从此规则中免除, 因为它们在需要的时候会在后台线程异步地运行查询.

• 使用Flow流进行响应式查询

只要表中的任何数据发生变化，返回的 Flow 对象就会再次触发查询并重新发出整个结果集。

使用 Flow 的响应式查询有一个重要限制：只要对表中的任何行进行更新（无论该行是否在结果集中），Flow 对象就会重新运行查询。通过将 distinctUntilChanged() 运算符应用于返回的 Flow 对象，可以确保仅在实际查询结果发生更改时通知界面：

@Query(“Select * From Car where id = :id”)
fun queryCarAsFlowById(id: Long): Flow

fun queryCarAsFlowByIdDistinctUntilChanged(id: Long): Flow<Car?> =
queryCarAsFlowById(id).distinctUntilChanged()

• 使用 Kotlin 协程进行异步查询

将 suspend Kotlin 关键字添加到 DAO 方法中，以使用 Kotlin 协程功能使这些方法成为异步方法。这样可确保不会在主线程上执行这些方法。

• 使用 LiveData 进行可观察查询

@Query(“Select * From Car where id = :id”)
fun queryCarAsLiveDataById(id: Long): LiveData<Car?>

对象之间的关系

嵌套关系

一对一

一对多

多对多

以一对多为例

• 定义Entity和关系

@Entity
data class One(@PrimaryKey(autoGenerate = true) val id: Long, val name: String)

@Entity
data class More(@PrimaryKey(autoGenerate = true) val id: Long, val oneId: Long, val name: String)

data class OneAndMore(
@Embedded val one: One,
@Relation(
parentColumn = “id”,
entityColumn = “oneId”
) val moreList: MutableList
)

• 定义Dao

添加 @Transaction 注释，以确保整个操作以原子方式执行。

@Transaction
open fun insertOneAndMore(){
val one = One(0, “OneName”)
val insertOneId = insertOne(one)
val more = More(0, insertOneId, “moreName1”)
val more1 = More(0, insertOneId, “moreName2”)
insertMore(more)
insertMore(more1)
}

@Transaction
@Query(“Select * from One”)

最后

其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。

上面分享的腾讯、头条、阿里、美团、字节跳动等公司2019-2021年的高频面试题，博主还把这些技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，上面只是以图片的形式给大家展示一部分。

【Android思维脑图（技能树）】

知识不体系？这里还有整理出来的Android进阶学习的思维脑图，给大家参考一个方向。

【Android高级架构视频学习资源】

**Android部分精讲视频领取学习后更加是如虎添翼！**进军BATJ大厂等（备战）！现在都说互联网寒冬，其实无非就是你上错了车，且穿的少（技能），要是你上对车，自身技术能力够强，公司换掉的代价大，怎么可能会被裁掉，都是淘汰末端的业务Curd而已！现如今市场上初级程序员泛滥，这套教程针对Android开发工程师1-6年的人员、正处于瓶颈期，想要年后突破自己涨薪的，进阶Android中高级、架构师对你更是如鱼得水，赶快领取吧！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注Android）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

rom One")

最后

其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。

上面分享的腾讯、头条、阿里、美团、字节跳动等公司2019-2021年的高频面试题，博主还把这些技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，上面只是以图片的形式给大家展示一部分。

【Android思维脑图（技能树）】

知识不体系？这里还有整理出来的Android进阶学习的思维脑图，给大家参考一个方向。

[外链图片转存中…(img-ozCdoMjU-1713648828931)]

【Android高级架构视频学习资源】

**Android部分精讲视频领取学习后更加是如虎添翼！**进军BATJ大厂等（备战）！现在都说互联网寒冬，其实无非就是你上错了车，且穿的少（技能），要是你上对车，自身技术能力够强，公司换掉的代价大，怎么可能会被裁掉，都是淘汰末端的业务Curd而已！现如今市场上初级程序员泛滥，这套教程针对Android开发工程师1-6年的人员、正处于瓶颈期，想要年后突破自己涨薪的，进阶Android中高级、架构师对你更是如鱼得水，赶快领取吧！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注Android）
[外链图片转存中…(img-nnYvrBDB-1713648828931)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！