Android知识总结

java语言翻译成c++语言

1. 创建Native c++项目<br>

配置Cmake文件<br>

1、编写声明了native方法的Java类<br>2、javac编译文件<br>3、javah获得包含该方法的C声明头文件（将class中用native声明的函数生成jni规则的函数）<br>4、用本地代码实现.h头文件中的函数<br>5、将本地代码编译成动态库（共享库）<br>6、在Java程序中加载该类库<br>

定义：将抽象部分与实现部分分离，使它们可以独立地进行变化<br>

使用场景<br>

定义：<br>

使用场景

定义：组合模式允许客户端统一处理单个对象和组合对象，从而使得客户端无需区分对象的类型，简化了客户端的代码<br>

优点：<br>

应用：自定义View，l里面包含多个其它按钮(TextView、Button、ImageView等)<br>

定义：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作<br>

适配器模式是为了解决接口不兼容问题

使用场景：<br>

图片编辑器，画笔，中间增加了一个类去衔接两边

有重复就复用，没有就直接创建，避免了重复对象的大量创建

应用：消息队列<br>

定义：装饰模式指的是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象<br>

获得被装饰对象。添加新的功能

定义：要求一个子系统的外部与其内部的通信必须通过一个统一的对象进行。外观模式提供一个高层次的接口，使得系统更易于使用<br>

使用场景：<br>

优点：<br>

缺点

定义：保证一个类只有一个实例，并且这个单例类提供一个函数接口让其他类获取到这个唯一的实例<br>

①构造私有。构造函数不对外开放，一般为private。<br>②以静态方法或枚举返回实例。<br>③确保实例只有一个，尤其是在多线程环境。<br>④确保实例在反序列化时不会重新构建对象。

创建方式

使用场景

使用

抽象类定义两个抽象方法

系统的产品有多于一个的产品族，而系统只消费其中某一族的产品时

缺点：产品族扩展非常困难，改动或增加一个产品需同时改动多个类<br>

使用场景：一个对象族（或一组没有任何关系的对象）都有相同的约束<br>

定义：通过定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象<br>

图片编辑器，画笔实现

定义：创建重复的对象，同时又能保证性能<br>

应用：OkHttp、realm数据库<br>

适用场景

定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。<br>

适用场景

使用

定义：核心思想是将数据操作与数据结构分离，允许在不改变数据结构的前提下，定义新的操作<br>

适用场景

定义：定义一系列的算法，把每一个算法封装起来，并且使它们可相互替换。策略模式模式使得算法可独立于使用它的客户而独立变化。（如：当有许多的if else 的时候，就可以考虑使用策略模式来处理）<br>

策略模式定义了一系列的算法，并将每一个算法封装起来，使它们可以相互替换

优点

缺点

定义：在不破坏对象封闭的前提下，捕获到对象的当前状态，并且在该对象之外保存这个状态，以便于以后该对象恢复到该状态<br>

使用场景

定义：用于定义对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会收到通知并自动更新<br>

使用场景

定义

使用场景

定义：迭代器模式由两个主要角色组成：迭代器（Iterator）和集合（Collection）<br>

使用场景

定义：类的行为是基于它的状态改变，不同状态下有不同的行为。<br>

适用场景

优点

缺点

定义：将一系列的方法调用封装，用户只需要调用一个方法执行，那么所有这些被封装的方法就会被挨个执行调用<br>

使用场景

定义：降低系统中各个对象之间的耦合度，通过引入一个中介者对象来协调多个对象之间的交互<br>

使用场景

比如登录注册界面，我们使用EditText的addTextChangedListener监听输入密码的位数、用户名是否为空，密码与确认密码是否一致等等判断时，此时多个控件交互，就是由Activity充当中介者来协调

定义：给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子<br>

使用场景

定义：责任链模式定义了多个对象都有机会处理同一个请求，但具体由哪个对象处理则在运行时动态决定。这些对象形成一个链条，请求从链的开始传递，直到被处理为止。每个处理者都有机会处理请求，如果当前处理者无法处理，则将请求传递给下一个处理者，直到找到能够处理的处理<br>

使用

一个类应该只有一个引起它变化的原因，只承担一项职责

扩展是开放的，对于修改是封闭的

子类对象应该能够替换父类对象，并且程序逻辑不受影响

高层模块不应该依赖于低层模块

不应该强迫用户依赖他们不需要的接口方法，接口应该尽量小而精

一个对象应当尽可能少地了解其他对象的细节

1.每个节点要么是红色，要么是黑色

2.根节点必须黑色

3.所有叶子节点（NIL节点）都是黑色

4.如果一个节点是红色的，则它的两个子节点必须是黑色的。这意味着不会有连续的两个红色节点

5.从任意节点到其叶子节点的所有路径上，黑色节点的数量是相同的

1.旋转

2.变色

动态内存分配

可扩展性

非连续存储

1.要么是空树

2.左右子树均为AVL树

3.左右树的高度差（平衡因子）的绝对值不超过1

空间 O(n)

查找

插入

删除

hashMap.put(key,value)

计算hashCode，存到数组，出现哈希冲突，用链表处理，如果链表长度大于8并且数组大于64，转用红黑树<br>

1.根据key计算hash值

2.确定下标 i

3.检查是否冲突

4.处理哈希冲突

5.插入后检查是否需要扩容

数组达到64跟长度达到8，变成红黑树

尽可能避免rehash，尽可能提高容量，避免哈希冲突

new HashMap（100/0.75+1）

HashMap 本身实现了 Serializable 接口，这意味着 HashMap 对象可以被序列化。

序列化是将对象状态转换为可以存储或传输的格式的过程。

大于17，最大32

是通过按位运算所以需要2的指数幂

HashMap的扩容机制是以2倍的形式进行扩容的

17不是2的次幂，无法找到均匀下标，变成单链表，查找复杂度会很高

当链表长度过长进行扩容，即增加数组长度，然后将数据重新放入数组中，达到扩容

1.Collections.synchronizedMap 可以将 HashMap 包装成线程安全的 Map

2.ConcurrentHashMap 是专门为并发设计的线程安全 Map，性能优于 Collections.synchronizedMap

3.通过 synchronized 关键字手动控制 HashMap 的访问

4.使用 ReadWriteLock，通过 ReadWriteLock 实现读写分离，提升并发性能

导致哈希冲突

key跟hash相同才会替换

通过链表法解决冲突

链表效率太低，引入红黑树

hashMap线程不安全，效率高

HashTable所有函数加了锁（Synchronized），线程安全，但是效率会变低

与 HashMap 和 ConcurrentHashMap 不同，它不存储键值对，只存储单个元素。和 LinkedList 相比，ArrayList 的随机访问速度更快，但是在插入和删除元素（特别是在中间位置插入和删除）时，由于需要移动后面的元素，效率相对较低

eden

so

s1

不容易被回收，经过多次Gc存活下来的对象，每次Gc+1，一般到达15次就到老年代<br>

新生代跟老年代内存比一般1：2<br>

老年代满了会触发Major GC 即 Full GC清空内存

主要存放静态文件，如java类，方法等<br>

1.需要单独的字段作为存储计数器，这样的做法会增加内存的开销<br> 2.每一次的赋值都需要更新计数器，会增加我们的时间开销<br> 3.无法处理循环引用的问题

以对象集合为起点（GC Root）为起始点，按从上到下的方式搜索跟踪目标对象，看看能否到达，<br> 在内存当中根对象和内存中对象，直接或者间接的连接，被称为引用链，如果没有的话，说明这个<br> 垃圾对象（死亡对象）,将其清除

1.标记所有需要回收的对象

2.统一回收所有被标记的对象

3. 优点：实现简单<br>

4.缺点：标记清除效率不高，产生大量内存碎片<br>

1.将内存划分为大小相等的两块

2.&nbsp;一块内存用完之后复制存活对象到另一块

3.清理另一块内存

优点：实现简单，运行高效，每次仅需遍历标记一半的内存区域<br>

缺点：会浪费一半的空间，代价大<br>

1.标记过程与 标记-清除算法 一样

2.存活对象往一端进行移动

3.&nbsp;清理其余内存<br>

优点：避免 标记-清除 导致的内存碎片，避免复制算法的空间浪费<br>

1.结合多种算法优势

2.新生代对象存活率低，使用 复制算法

3.老年代对象存活率高，使用 标记-整理算法

新对象生成，并且在Eden申请空间失败时，就会触发Scavenge GC

· 年老代（Tenured）被写满<br><br>· 持久代（Perm）被写满<br><br>· System.gc()被显示调用<br><br>·上一次GC之后Heap的各域分配策略动态变化

idle(pid=0)

zygote进程有jvm、各种资源、reg(注册jni)，直接复制即可

binder是可以异步处理的，异步处理的时候Zygote fork出子线程处于死锁状态，binder处于等待锁状态

不同进程，但是都是继承SystemService，都是SystemSeviceManager去管理，通过Binder去通信

ServiceManager.getService("activity")

使用Binder机制来实现不同进程间的通信，所有服务放SystemServiceManager管理

解耦、安全、高效

所有服务继承SystemService

SystemServiceManager：创建启动各种服务

ServiceManager负责管理和调度系统中所有的Binder服务，负责IPC通信

Looper

1. 轻量级任务：如加载数据、更新UI等轻量级操作，这些操作可以在不影响用户体验的前提下，利用主线程的空闲时间完成。<br>2. 延迟初始化：对于一些不需要立即初始化的组件或资源，可以注册为IdleHandler，在空闲时进行初始化，以减少应用启动时的加载时间。<br>3. 性能监控与优化：利用IdleHandler实现性能监控和优化，如统计每次空闲时的内存占用情况，或者执行一些内存释放操作。&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&nbsp;<br>

IdleHandler是Android中MessageQueue类定义的一个接口，它允许开发者在Looper事件循环的过程中，当消息队列（MessageQueue）出现空闲时执行特定的任务。IdleHandler提供了一种机制，使得开发者能够充分利用主线程的空闲时间，执行一些轻量级的操作，从而提升应用的性能和用户体验<br>

1.性能优化<br>

2.资源管理

3.任务调度

应用

1.myHandler.removeCallbacksAndMessages(null);

2.使用WeakReference，如果必须在Handler内部持有对Activity或Fragment的引用

匿名内部类，默认持有外部类引用<br>

调用 Looper#quit() 或 quitSafely()，它将清空所有的 Message 或未来的 Message，并促使 loop() 轮询的结束

MessageQueue持有了Message持有了Handler，handler又持有了activity，如果消息没有处理完，就可能会出现内存泄漏<br>

1.一个线程只会有一个Looper对象，所以线程和Looper是一一对应的

2. MessageQueue对象是在new Looper的时候创建的，所以Looper和MessageQueue是一一对应的

3.Handler的作用只是将消息加到MessageQueue中，并后续取出消息后，根据消息的target字段分发给当初的那个handler，所以Handler对于Looper是可以多对一的，也就是多个Hanlder对象都可以用同一个线程、同一个Looper、同一个MessageQueue

综合：Looper、MessageQueue、线程是一一对应关系，而他们与Handler是可以一对多的<br>

应用在启动的过程中就已经初始化了一个主线程Looper。每个java应用程序都是有一个main方法入口，Android是基于Java的程序也不例外

Looper的死循环，是循环执行各种事务，包括UI绘制事务。Looper死循环说明线程没有死亡，如果Looper停止循环，线程则结束退出了，Looper的死循环本身就是保证UI绘制任务可以被执行的原因之一

当没有消息的时候，会阻塞在loop的queue.next()中的nativePollOnce()方法里，此时主线程会释放CPU资源进入休眠状态，直到下个消息到达或者有事务发生，所以死循环也不会特别消耗CPU资源

在使用Hanlder发送消息的时候，会设置msg.target = this，所以target就是当初把消息加到消息队列的那个Handler

使用不同线程的Looper处理消息。我们知道，代码的执行线程，并不是代码本身决定，而是执行这段代码的逻辑是在哪个线程，或者说是哪个线程的逻辑调用的。每个Looper都运行在对应的线程，所以不同的Looper调用的dispatchMessage方法就运行在其所在的线程了

循环加锁，配合阻塞唤醒机制。我们发现，MessageQueue其实是【生产者-消费者】模型，Handler不断地放入消息，Looper不断地取出，这就涉及到死锁问题。如果Looper拿到锁，但是队列中没有消息，就会一直等待，而Handler需要把消息放进去，锁却被Looper拿着无法入队，这就造成了死锁，Handler机制的解决方法是循环加锁<br>

copy_from_user/copy_to_user

Binder跨进程通信原理

Binder通信模型

Binder Dirver

启动ServerManager

获取ServerManager

Binder通信的代理模式

IBinder/IInterface/Binder/Stub

AIDL使用原理

oneway

内存只拷贝一次，创建一个共享内存

同步数据传输大小是1M-8k，异步是同步的一半

lintToDeath回调移除监听

添加isBinderAlive跟pingBinder()<br>

tcp/ip

管道：handler epoll使用管道机制

共享内存：mmkv

信号量：matrix/xcrash/友盟apm

Launcher点击图标

IPackageManager.Stub

PKMS管理所有应用权限

为什么要PKMS?

安卓开机慢，什么原因？

MainActivity跳转到DerryActivity（launchMode）请问launcMode什么时候解析的？

安装apk原理是什么？

Launcher3如何展示应用的？

手机开机后为什么能收到开机广播？

1. 窗口管理：管理所有应用程序的窗口，包括窗口的显示、布局、大小和位置。<br>

2.焦点管理：当用户点击某个窗口时，WMS会将焦点设置到该窗口上，并通知AMS更新Activity的状态<br>

activity创建window

onMeasure()

requestLayout()

ActivityThread.handleResumeActivity

WindowManagerGlobal是ViewRootImpl的二次封装

onResume中度量宽高是否有效？

子线程中更新View是否一定会报错？

1.活动管理：管理应用程序中的各种活动（Activity）的生命周期，包括启动、调度、关闭等。<br>

2.组件管理：管理应用程序的组件（如Activity、Service等）的启动、停止和通信，以及进行任务管理和权限管理等

fragment

生命周期

ActivityThread

Activity栈管理

Activity管理

hook插件化

启动耗时优化？

事件分发机制

Activity如何与window与view进行分工合作？

onResume函数中度量宽高有效吗？

子线程中view.setText一定会报错吗？

View的绘制过程都是用的同一个canvas吗？

view创建过程？

startService，将所有服务添加到SystemServiceManager里面进行管理

1. 提高线程的利用率

2.提高程序的响应速度

3. 便于统一管理线程对象

4. 可以控制最大并发数

ThreadPoolExecutor()<br>

Executors.newSingleThreadExecutor()<br>

Executors.newCachedThreadPool()<br>

1. 执行任务出现异常，并抛出异常，会销毁掉该线程，再重新创建一个线程

2// 创建线程池<br>&nbsp; &nbsp; &nbsp; &nbsp; val executor = ThreadPoolExecutor(<br>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; 2,&nbsp; // 核心线程数，始终存活的线程数<br>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; 4,&nbsp; // 最大线程数，线程池中允许的最大线程数量<br>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; 60,&nbsp; // 非核心线程空闲存活时间<br>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; TimeUnit.SECONDS,&nbsp; // 时间单位<br>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; LinkedBlockingQueue&lt;Runnable&gt;(10),&nbsp; // 任务队列，用于存放待执行的任务<br>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; Executors.defaultThreadFactory(),&nbsp; // 线程工厂，线程工厂，用于创建新线程，名称等<br>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; ThreadPoolExecutor.AbortPolicy() // 拒绝策略，拒绝策略，当任务队列已满且线程数达到最大线程数时，如何处理新任务<br>&nbsp; &nbsp; &nbsp; &nbsp; )

当提交一个新任务时：<br>如果当前线程数小于核心线程数，则创建新线程执行任务。<br>如果当前线程数等于核心线程数，则将任务放入任务队列。<br>如果任务队列已满且当前线程数小于最大线程数，则创建新线程执行任务。<br>如果任务队列已满且当前线程数等于最大线程数，则触发拒绝策略。<br>当线程池中的线程数量超过核心线程数时：<br>空闲时间超过 keepAliveTime 的非核心线程会被销毁。

LinkedBlockingQueue：无界队列，任务数量无限制。<br>ArrayBlockingQueue：有界队列，任务数量有限制。<br>SynchronousQueue：不存储任务，直接将任务交给线程执行。

threadFactory：线程工厂，用于创建新线程。<br>可以自定义线程的名称、优先级等。

常用的拒绝策略：<br>ThreadPoolExecutor.AbortPolicy：默认策略，直接抛出 RejectedExecutionException。<br>ThreadPoolExecutor.CallerRunsPolicy：由提交任务的线程直接执行任务。<br>ThreadPoolExecutor.DiscardPolicy：直接丢弃任务，不抛出异常。<br>ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列中最旧的任务，然后重新尝试提交任务。

volatile能保证变量的可见性，禁止指令重排序<br>

1.新建状态(New)<br>

2. 就绪状态（Runnable）<br>

3.运行状态（Running）<br>

4.阻塞状态（Blocked）<br>

5. 等待状态（Waiting）<br>

6.计时等待状态（Timed Waiting）<br>

7.终止状态（Terminated）<br>

原理：<br>

Synchronized<br>

volatile<br>

原子性

1. 实时图表展示应用内存使用量

2.用于识别内存泄漏、抖动等

3.提供捕获堆转储、强制GC以及根据内存分配的能力

强大的 Java Heap 分析工具，查找 内存泄漏及内存占用，<br>生成 整体报告、分析内存问题

自动化 内存泄漏检测神器

发生内存泄漏的引用链

StrictMode

Trace.beginSection("my_section");

BlockCanary

Debug<br>

原因：频繁创建释放变量导致频繁Gc，出现内存抖动

导致问题：内存抖动会导致卡顿，甚至崩溃

解决：减少变量频繁创建

Android系统虚拟机的垃圾回收是通过虚拟机GC机制来实现的

处理

OOM时会导致程序异常

大部分都是图片处理不当导致

原因：内存不足，可分配内存不足<br>

为什么内存抖动会导致OOM？<br>

如何优化内存抖动？？<br>

内存优化？<br>

重构了项目，旧项目代码太乱，维护不方便，可阅读性差

删除大量代码，sdk大大减少，代码可阅读性大大提高，维护起来更简单方便

1. 我们以前是做工具类应用，上架谷歌商店，操作图片以前是所有手机都是加载一样大小的图片去操作，性能差的手机就会非常卡顿，性能好的手机显示操作的时候清晰度不够，根据手机性能去加载不同图片显示

2. 以前为了做历史记录，就是上下一步处理，每操作一次就会缓存一个bitmap，操作过多会导致内存消耗很大，很多操作保存操作步骤即可，必要的才缓存bitmap，可以减少内存消耗。

3.算法以前是用c++实现的，后面改造成使用openGl实现图片处理，处理速度会快很多倍

4. 启动优化，将很多耗时的操作放子线程去初始化或者获取，数据保存之前是用sp，后面改用mmkv，mmkv是使用内存共享的，效率高很多

5.布局也做了优化，使用ConstraintLayout布局，减少了层级

6.下载优化，有很多资源是放服务器的，使用了workManager去下载，资源分小图跟大图，默认预览是显示小图，真正使用再用大图显示，而且很多图片都替换成了svg图片，减少应用大小

7.使用完的bitmap要及时手动释放，因为bitmap一般比较大，容易引起oom或者触发GC<br>

LUT

2.

'iːkwəlaɪzə&nbsp; &nbsp;equalizer

音乐裁剪

TCP跟UDP区别？

加密方式

触摸超过五秒

前台服务20秒后台服务200秒

ContentProvider调度超时10秒<br>

前台广播10秒，后台广播60秒

adb shell top --查看当前系统中排名前20的进程信息

2. 发生ANR的进一步原因：<br><br>(1) 主线程存在耗时操作：主线程阻塞（Blocked）、挂起（suspend）、死锁、死循环、耗时操作等；<br><br>(2) cpu资源被抢占：其他进程某一时间点cpu占比高、某一刻系统的cpu占比过高，都会导致这一时间段无法抢到cpu时间片；<br><br>(3) 主线程卡在 binder 通信的对端：需要通过 binder info 查看对端信息；<br><br>(4) 系统或者应用自身可用内存紧张：系统一直在执行 lowmemory killer 操作查杀进程；<br><br>(5) 应用频繁crash：包括应用自身也容易导致前台应用出现anr的现象；<br><br>(6) 应用内存泄露；<br><br>(7) 系统原因导致：如冻结、温度过高、多媒体（音视频、编解码）、包管理、Block I/O、底层服务NE（native crash）、watchdog、内存黑洞、芯片能力等。

Android 应用的主线程（UI 线程）负责处理用户输入事件（如点击、滑动等）和界面更新。<br><br>如果 CPU 被大量占用（例如主线程或后台线程执行了复杂的计算、死循环、频繁的 GC 等），主线程可能无法及时响应用户输入

1. 首先在 android（logcat）日志中搜索“ANR in”关键字，通过此关键字主要查看，原因<br>

2.其次查看 event (logcat -b events)日志

3.然后查看 /data/anr下的 trace日志

4. CPU使用率信息分析从android（高通平台在android.txt,MTK平台在system*.txt）日志中，查看系统中各个进程的cpu使用率，首先关注的进程就是发生anr的进程、system_server、kswapd0、kworker和其他占比较高的进程、以及最终统计的整体cpu使用率信息

5. Memory角度分析查看发生anr时间点前后的可用内存情况，以及系统查杀应用的频繁程度

7. kernel日志分析思路

8. 综合系统功能进行整体分析

不用连接用于本机进程之间通信

什么是socket?<br>

网络通信都是用socket<br>

1.使用https协议可认证用户和服务器，确保数据发送到正确的客户机和服务器；<br>

2.https协议是由SSL+http协议构建的可进行加密传输、身份认证的网络协议，要比http协议安全，可防止数据在传输过程中不被窃取、改变，确保数据的完整性。<br>

3.https是现行架构下最安全的解决方案，虽然不是绝对安全，但它大幅增加了中间人攻击的成本。<br>

5.谷歌曾在2014年8月份调整搜索引擎算法，并称“比起同等http网站，采用https加密的网站在搜索结果中的排名将会更高”。

1.https协议握手阶段比较费时，会使页面的加载时间延长近50%，增加10%到20%的耗电；<br>

2.https连接缓存不如http高效，会增加数据开销和功耗，甚至已有的安全措施也会因此而受到影响；

3.SSL证书需要钱，功能越强大的证书费用越高，个人网站、小网站没有必要一般不会用。

4.SSL证书通常需要绑定IP，不能在同一IP上绑定多个域名，IPv4资源不可能支撑这个消耗。

5.https协议的加密范围也比较有限，在黑客攻击、拒绝服务攻击、服务器劫持等方面几乎起不到什么作用。最关键的，SSL证书的信用链体系并不安全，特别是在某些国家可以控制CA根证书的情况下，中间人攻击一样可行。

1.数据加密

2.数据完整性

3.身份验证

HTTPS 的加密是通过 SSL/TLS 协议（Secure Sockets Layer / Transport Layer Security）实现的。SSL/TLS 协议在 HTTP 协议的基础上增加了加密层

1.SSL/TLS 握手

2.证书验证

3.对称加密通信

1.非对称加密（Asymmetric Encryption

2.对称加密（Symmetric Encryption

3.数字证书（Digital Certificate）

4.哈希算法（Hash Algorithm）：

使用 非对称加密 确保密钥的安全交换。<br>使用 对称加密 加密实际传输的数据。<br>使用 数字证书 验证服务器的身份。<br>使用 哈希算法 确保数据的完整性。

通过 HTTPS，可以有效防止数据被窃听、篡改或伪造，保护用户的隐私和安全

1. https协议需要到ca申请证书，一般免费证书较少，因而需要一定费用。

2.http是超文本传输协议，信息是明文传输，https则是具有安全性的ssl加密传输协议。

3.http和https使用的是完全不同的连接方式，用的端口也不一样，前者是80，后者是443。

4.http的连接很简单，是无状态的；https协议是由SSL+http协议构建的可进行加密传输、身份认证的网络协议，比http协议安全。

是 Android 中实现应用程序之间数据共享的标准机制。它允许一个应用程序将其数据暴露给其他应用程序，而无需直接访问底层数据库或文件系统

封装了底层数据的存储细节（如 SQLite 数据库、文件系统等），对外提供统一的访问接口。这样，即使底层数据存储方式发生变化，也不会影响外部应用程序的访问

提供了细粒度的权限控制，允许开发者定义哪些数据可以被其他应用程序访问，以及访问的权限级别

提供了标准的 CRUD 操作接口，其他应用程序可以通过 ContentResolver 调用这些接口来查询和操作数据

支持数据变更通知机制。当数据发生变化时，可以通过 ContentResolver.notifyChange() 方法通知注册的观察者（如 CursorLoader），以便及时更新 UI

共享系统数据：例如，访问通讯录、媒体库、日历等系统数据。<br>跨应用数据共享：例如，一个应用程序提供数据给另一个应用程序使用。<br>数据封装：将底层数据存储细节隐藏，提供统一的访问接口。<br>数据安全：通过权限控制确保数据的安全性。

用于将普通函数转换为挂起函数，当你调用一个挂起函数时，执行会被挂起，直到协程恢复执行

非阻塞挂起，挂起是不占用CPU<br>

挂起或者暂停，用于暂停当前执行的协程，并保存所有局部变量

当遇到suspend函数时，协程会挂起，等待suspend函数执行完毕后再继续执行<br>

已经暂停的协程恢复

阻塞调用，如果通过它来处理协程，那么只有当runBlocking的方法体中执行完，才会往下执行，会一直霸占cpu，直到运行完才会释放

控制协程的执行与取消

launch启动后台调度线程，并且不堵塞当前线程

协程中使用的挂起函数

用于延迟当前协程<br>不会阻塞当前运行的线程<br>允许其他协程在同线程运行<br>当延迟的时间到了，协程会被恢复并继续执行

Dispatchers.Main：Android主线程<br>Dispatchers.IO：IO密集型任务<br>Dispatchers.Default：CPU密集型任务

1. Kotlin中的协程是一种轻量级的线程，它们允许以更简洁和结构化的方式编写异步代码。

2. 协程挂起函数执行时不会阻塞线程，而是将控制权交还给协程调度器，直到可以恢复执行。

3.在Android开发中，协程用于简化异步任务，如网络请求、数据库操作等，而不阻塞主线程。

Kotlin中的扩展函数和扩展属性允许给已存在的类添加新的行为和属性，而不需要修改原始类。这在Android开发中非常有用，可以增加现有类的功能性，同时保持代码的整洁和可读性

val 声明不可变变量（只读），而 var 声明可变变量

Kotlin 通过类型系统的可空性标记（如 String?）来防止空指针异常 (NullPointerException)，使开发者明确处理空值

扩展函数允许你为已有类添加新函数，而无需继承或使用设计模式

委托属性允许你将属性的实现委托给另一个对象。例如，lazy 委托用于延迟初始化

使用 ViewModel 和 LiveData 来实现 MVVM 架构，并通过 Data Binding 实现视图和数据的绑定

协程提供了更简洁的异步编程模型，而 RxJava 是基于响应式编程的框架，两者都可以处理异步任务，但语法和实现方式不同

协程创建成本低，几十个字节，线程要1Mb左右<br>

切换开销：无需内核参与，线程需要系统调度<br>

并发数量：单线程可运行数千个，线程通常数百个<br>

非空判断，返回it<br>

可以执行函数引用，多个函数引用可以链式调用，返回it<br>

需要传入参数

返回this

SHA-256 使用逻辑运算、位移和压缩函数生成 256 位哈希值

CRC32 的计算速度最快，适合大规模数据校验

定义被观察者（Subject）。<br>定义观察者（Observer）。<br>在被观察者中注册和通知观察者。

简单易用：API 设计简洁，易于上手。<br><br>高效性能：支持连接池和缓存，减少网络请求的开销。<br><br>支持同步和异步请求：满足不同场景的需求。<br><br>拦截器机制：支持自定义拦截器，方便扩展功能（如日志、重试、缓存等）。<br><br>支持 HTTP/2 和 WebSocket：提供更高效的网络通信

1.日志拦截器<br>

2.网络拦截器

重试机制：在请求失败时，自动重试请求<br>

日志记录：记录请求和响应的详细信息，例如 URL、请求头、响应体等，方便调试和分析。<br>修改请求：在请求发出之前，动态修改请求的 URL、请求头或请求体。<br>修改响应：在响应返回之后，动态修改响应的状态码、响应头或响应体。<br>重试机制：在请求失败时，自动重试请求。<br>缓存处理：实现自定义的缓存策略，例如根据特定条件缓存响应。<br>认证和授权：自动添加认证信息（例如 Token）到请求头中。<br>性能监控：统计请求的耗时、成功率等性能指标<br>

1.创建请求：OkHttpClient client = new OkHttpClient();<br>

2.创建请求

3.发送同步请求

4.发送异步请求

高级：<br>