https://blog.csdn.net/qq873044564/article/list/3

第一周：

四大组件（Activity、Service、BroadcastReceiver、 ContentProvider）

https://www.jianshu.com/p/a85ca55b8330

https://blog.csdn.net/qq_42418169/article/details/115090626

1、activity

activity栈：

系统采用Activity栈的方式来管理Activity。

activity的四种形态：

• Activity/Running：这个时候，Activity处于Activity栈的最顶层，可见，并与用户进行交互。
• Paused：Activity失去焦点，被一个新的非全屏的Activity或者一个透明的Activity放置在栈顶时，Activity就转换成了qaused形态，他失去了与用户交互的能力，所有状态信息，成员变量都还保留着，只有在系统内存极地的情况下，才会被系统回收。
• Stopped：如果一个Activity被另一个Activity完全覆盖，那么Activity就会进入stop形态，此时他不在可见，但依然保留着所有的状态和成员变量。
• Killed：当Activity被系统回收或者Activity从来没有创建过，Activity就处于killed状态。

链接：https://www.jianshu.com/p/2cce9303b933

activity 的生命周期：

Activity启动和销毁过程

• onCreate中创建基本的UI元素。
• onPause和onStop：清除Acvtivity的资源，避免浪费。

• onDestroy:因为引用会在Activity销毁的时候销毁，而线程不会，所以清除开启的线程。

  Activity的暂停和恢复过程

  当栈顶的Activity部分不可见的时候，就会倒置Activity进入onPause。

• onPause：释放系统资源。

• onResume：需要重新初始化onPause释放的资源。

  Activity的停止过程

  栈顶的Activity部分不可见的时候，实际上后续会有两种可能，从部分不可见到可见，也就是恢复过程，从部分不可见到完全不可见，也就是停止过程，系统在当前Activity不可见的时候调用onPause。

onResume是在启动activity启动之后才能执行的，也就是恢复执行。
程序正常启动：onCreate()->onStart()->onResume();
正常退出：onPause()->onStop()->onDestory()
一个Activity启动另一个Activity: onPause()->onStop(),
再返回：onRestart()->onStart()->onResume()
程序按back 退出： onPause()->onStop()->onDestory(),
再进入：onCreate()->onStart()->onResume();
程序按home 退出： onPause()->onStop(),
再进入：onRestart()->onStart()->onResume();

（1）前台切换到后台，然后再回到前台，Activity生命周期回调方法? (我们假设从Ativity A 跳到 Activity B)

A调用 onCreate() 方法 -> onStart() 方法 -> onResume() 方法，此时 A 前台可见。<br />当 A 跳转到 B 时，A 调用 onPause() 方法，然后调用新的 Activity B 中的 onCreate() 方法 -> onStart() 方法 -> onResume() 方法。最后 A 再调用onStop()方法。<br />当 A 再次回到时前台，B 调用 onPause() 方法，A 调用 onRestart() -> onStart() -> onResume() 方法，然后 B 再调用 onStop() -> onDestroy()方法。

（2）弹出 Dialog，生命周期?

其实是否弹出 Dialog，并不影响 Activity 的生命周期，所以这时和正常启动时 Activity 的生命回调方法一致: onCreate() -> onStart() -> onResume()。

（3）Activity上有Dialog的时候按Home键时的生命周期

弹出的AlertDialog对话框实际上是Activity的一个组件，我们对Activity并不是不可见而是被一个布满屏幕的组件覆盖掉了其他组件，所以我们无法对其他内容进行操作，也就是AlertDialog实际上是一个布满全屏的组件。有 Dialog 和 无 Dialog 按 Home 键效果一样

https://blog.csdn.net/weixin_38576356/article/details/89597896

（4）横竖屏切换时activity生命周期变化的

跟清单文件AndroidManifest.xml中android:configChanges属性有关，而且还跟手机系统的版本有关，因为在Android 4.0及其以上系统上，还跟程序的targetSdkVersion设置有关

清单文件中不配置android:configChanges属性或者配置了android:configChanges=”orientation”，横竖屏切换时的变化跟Android 2.3是一样的，都会先销毁当前activity然后重新创建它。
https://blog.csdn.net/xiaoli100861/article/details/50855152

AlertDialog,popupWindow,Activity区别

（1）AlertDialog builder：用来提示用户一些信息,用起来也比较简单,设置标题类容和按钮即可,如果是加载的自定义的view ,调用 dialog.setView(layout);加载布局即可

创建AlertDialog，用AlertDialog.Builder中的create()方法。

setItems(CharSequence[] items, final OnClickListener listener)方法来实现类似ListView的AlertDialog
第一个参数是要显示的数据的数组，第二个参数是点击某个item的触发事件

  **setSingleChoiceItems**(CharSequence[] items, int checkedItem, final OnClickListener listener)方法来实现类似RadioButton的AlertDialog

setMultiChoiceItems(CharSequence[] items, boolean[] checkedItems, final OnMultiChoiceClickListener listener)方法来实现类似CheckBox的AlertDialog
第一个参数是要显示的数据的数组，第二个参数是选中状态的数组，第三个参数是点击某个item的触发事件

   自定义View的AlertDialog

原文链接：https://blog.csdn.net/android_cmos/article/details/51223776

（2）popupWindow：就是一个悬浮在Activity之上的窗口，可以用展示任意布局文件。

可以使用任意布局的View作为其内容，这个弹出框是悬浮在当前activity之上的。

（3）activity：Activity是Android系统中的四大组件之一，可以用于显示View。Activity是一个与用记交互的系统模块，几乎所有的Activity都是和用户进行交互的。

Activity的启动模式：

• standard

默认的启动模式，每次点击standard模式创建Activity之后，都会创建新的MainActivity覆盖在原有的Activity上。

链接：https://www.jianshu.com/p/2cce9303b933

• singleTop

如果Activity在栈顶的时候，启动相同的Activity，不会创建新的实例，而会调用其onNewIntent方法。

• singleTask

只有一个实例。在同一个应用程序中启动它的时候，若Activity不存在，则会在当前task创建一个新的实例，若存在，则会把task中在其之上的其它Activity destory掉，并调用它的onNewIntent方法。

链接：https://www.jianshu.com/p/3eaa521ff330

• singleInstance

只有一个实例，并且这个实例独立运行在一个task中，这个task只有这个实例，不允许有别的Activity存在。

设置Activity的启动模式，只需要在AndroidManifest.xml里对应的标签设置Android:launchMode属性，例如：
android:name=”.A1”
android:launchMode=”standard”/>

链接：https://www.jianshu.com/p/3eaa521ff330

singleTask 启动模式：

假设在任务栈中存在该Activity的实例，再次启动的时候，也就不会重新去创建它的实例，onCreate方法并没有执行，也就获取不到Bundle传递过来的值。此时，我们需要重写 onNewIntent()方法，系统会回调其onNewIntent方法，并将 onNewIntent 接收的 intent设置给 Activity。之后，我们可以在 onStart()方法中接收Bundle传递过来的值。

如果Activity B的启动模式为singleTask，B在任务栈中已经存在，A启动B，
1. 使用startActivity方法，这时B调用的方法为onNewIntent->onRestart->onStart->onResume
2. 使用startActivityForResult方法，这时B的启动模式就退化为standard模式，这是B调用的方法为onCreate->onStart->onResume

activity之间的通信模式

(1) 在Intent跳转时携带数据

//创建Intent对象
Intent intent = new Intent(MainActivity.this, SecondActivity.class);
//程序自动创建Bundle，然后将对Intent添加的数据装载在Bundle中，对用户透明
intent.putExtra("name", "WangJie");
intent.putExtra("age", 23);
startActivity(intent);

(2)借助类的静态变量来实现

由于类的静态成员可以通过“className.fileName”来访问，故而可以供两个Activity访问从而实现Activity之间的数据通信：

(3)借助全局变量来实现/Application

和类的静态变量类似，但是这个类作为单独第三个类（最好是写一个Application类）：

https://blog.csdn.net/cyanchen666/article/details/81982562

（4）借助外部工具

– 借助SharedPreference
– 使用Android数据库SQLite
– 赤裸裸的使用File
– Android剪切板

（5）借助Service

（6）bundle

可以通过将数据封装在Bundle对象中 ，然后在Intent跳转的时候携带Bundle对象
bundle 本质上是使用 arrayMap实现的
可以传递基本数据类型和String类型的数据，如果传递的是对象就需要进行序列化。

(7) Serializable 和 Parcelable

  如果使用Bundle在Intent之间传递对象需要先进行序列化。<br />    <br />Parcelable是由Android提供的序列化接口,google做了大量的优化<br /> <br />(8)  EventBus

EventBus 使用的是发布 订阅者模型,发布者通过EventBus发布事件，订阅者通过EventBus订阅事件。当发布者发布事件时，订阅该事件的订阅者的事件处理方法将被调用。

https://www.cnblogs.com/chenjy1225/p/9662510.html

Application context和Activity context的区别

https://blog.csdn.net/xiaodongvtion/article/details/8443772

1、不要让生命周期长的对象引用activity context，即保证引用activity的对象要与activity本身生命周期是一样的
2. 对于生命周期长的对象，可以使用application context

android中context可以作很多操作，但是最主要的功能是加载和访问资源。
通常我们在各种类和方法间传递的是activity context。
比如一个activity的onCreate：
protected void onCreate(Bundle state) {
super.onCreate(state);
TextView label = newTextView(this); //传递context给view
control label.setText(“Leaks are bad”);
setContentView(label); }

把activity context传递给view，意味着view拥有一个指向activity的引用，进而引用activity占有的资源： 这样如果context发生内存泄露的话，就会泄露很多内存。

（）setContentView底层原理

Activity调用setContentView的方法是将xml布局文件加载到Activity中。

https://www.jianshu.com/p/9acdf27aae06

（）Android Activity 的详细启动过程

需要的知识前提：

1. Android 中的消息机制
2. Binder 的原理和用法
3. zygote 进程 和 system_server 进程的启动过程
4. Android 消息机制之同步屏障

https://blog.csdn.net/yanzhenjie1003/article/details/99656633

（）ActivityThread的理解

ActivityThread就是我们常说的主线程或UI线程，ActivityThread的main方法是整个APP的入口。

2、fragment

Activity与Fragment之间生命周期比较

片段fragment 必须始终嵌入在 Activity 中，其生命周期直接受宿主 Activity 生命周期的影响。 例如，当 Activity 暂停时，其中的所有片段也会暂停；当 Activity 被销毁时，所有片段也会被销毁。

1. onAttach(Context context)：在Fragment和Activity关联时的时候调用，且仅调用一次。
2. onCreate：在最初创建Fragment的时候会调用，和Activity的onCreate类似。
3. onCreateView在准备绘制Fragment界面时调用，返回值为Fragment要绘制布局的根视图，并不是一定会被调用，当添加的是没有界面的Fragment就不会调用。
4. onActivityCreated ：在Activity的onCreated执行完时会调用。
5. onStart() ：Fragment对用户可见的时候调用，前提是Activity已经started。
6. onResume()：Fragment和用户之前可交互时会调用，前提是Activity已经resumed。
7. onPause()：Fragment和用户之前不可交互时会调用。
8. onStop()：Fragment不可见时会调用。
9. onDestroyView()：在移除Fragment相关视图层级时调用。
10. onDestroy()：最终清楚Fragment状态时会调用。
11. onDetach()：Fragment和Activity解除关联时调用。

链接：https://www.jianshu.com/p/70d7bfae18f3

Fragment 在各种情况下的生命周期

Activity中调用replace()方法时的生命周期：
新替换的Fragment：onAttach > onCreate > onCreateView > onViewCreated > onActivityCreated > onStart > onResume
被替换的Fragment：onPause > onStop > onDestroyView > onDestroy > onDetach

https://blog.csdn.net/ya1139569539/article/details/78192112

如何实现Fragment的滑动

和viewpager绑定一下，就可以滑动了。因为viewpager里面处理了touch事件，会进行move事件的滑动处理。

https://www.yuque.com/ambitious-lu4gu/vtl3p9/nempqp/edit#XajCR

Fragment 之间传递数据

https://blog.csdn.net/xcjean/article/details/78815964

（1）如需将数据从 Fragment B 传回到 Fragment A，请先在接收结果的 Fragment A 上设置结果监听器。在 Fragment A 的 FragmentManager 上调用 setFragmentResultListener() API

（2）如需将结果从子级 Fragment 传递到父级 Fragment，父级 Fragment 在调用 setFragmentResultListener() 时应使用 getChildFragmentManager() 而不是 getParentFragmentManager()。

（3）在MainFragment中设置一个setData()方法，在方法中设置更改按钮名称。在MenuFragment中的ListView条目点击事件中通过标签获取到MainFragment，并调用对应的setData()方法，将数据设置进去，从而达到数据传递的目的。

（4）采取接口回调的方式进行数据传递。

（5）用EventBus来实现以下Fragment之间的数据传递

EventBus是一款针对Android优化的发布/订阅（publish/subscribe）事件总线。主要功能是替代Intent,Handler,BroadCast在Fragment，Activity，Service，线程之间传递消息。
简化了应用程序内各组件间、组件与后台线程间的通信。优点是开销小，代码更优雅，以及将发送者和接收者解耦。比如请求网络，等网络返回时通过Handler或Broadcast通知UI，两个Fragment之间需要通过Listener通信，这些需求都可以通过EventBus实现。

fragment 懒加载

https://www.jianshu.com/p/2201a107d5b5?utm_campaign=hugo

为什么Fragment需要懒加载呢，一般我们都会在onCreate()或者onCreateView()里去启动一些数据加载操作，比如从本地加载或者从服务器加载。大部分情况下，这样并不会出现什么问题，但是当你使用ViewPager + Fragment的时候，问题就来了，这时就应该考虑是否需要实现懒加载了。
ViewPager为了让滑动的时候可以有很好的用户的体验，也就是防止出现卡顿现象，因此它有一个缓存机制。默认情况下，ViewPager会提前创建好当前Fragment旁的两个Fragment，举个例子说也就是如果你当前显示的是编号3的Fragment，那么其实编号2和4的Fragment也已经创建好了，也就是说这3个Fragment都已经执行完 onAttach() -> onResume() 这之间的生命周期函数了。

https://www.cnblogs.com/dasusu/p/5926731.html

https://blog.csdn.net/Ashurol/article/details/50564182

3、Service

https://www.jb51.net/article/98871.htm
【耗时的较长的工作最好放在服务中完成】

Service生命周期

onStartCommand()
当另一个组件（如 Activity）通过调用 startService() 请求启动服务时，系统将调用此方法。
一旦执行此方法，服务即会启动并可在后台无限期运行。 如果您实现此方法，则在服务工作完成后，需要由您通过调用 stopSelf() 或 stopService() 来停止服务。（如果您只想提供绑定，则无需实现此方法。）

https://www.jianshu.com/p/cc25fbb5c0b3

https://www.cnblogs.com/huihuizhang/p/7623760.html

怎么启动server

1、startService 启动的服务：主要用于启动一个服务执行后台任务，不进行通信。停止服务使用stopService；
2、bindService 启动的服务：该方法启动的服务可以进行通信。停止服务使用unbindService；
3、startService 同时也 bindService 启动的服务：停止服务应同时使用stepService与unbindService

https://blog.csdn.net/imxiangzi/article/details/76039978

如果先是bind了，那么start的时候就直接运行Service的onStart方法，
如果先是start，那么bind的时候就直接运行onBind方法。如果你先bind上了，就stop不掉了，
只能先UnbindService, 再StopService,所以是先start还是先bind行为是有区别的。
https://blog.csdn.net/baidu_32731497/article/details/51347298

Activity与Service怎么进行数据交互：

（1）使用bindService
https://www.cnblogs.com/l2rf/p/5953214.html

https://www.jianshu.com/p/0dfc6e9d82b3
（2）Activity和Service的交互方式主要有以下几种

• 通过广播进行交互
• 通过共享文件
• Messenger
• AIDL

https://blog.csdn.net/zh175578809/article/details/72856795

为什么 bindService 能和 Activity 的生命周期联动

bindService 方法执行时，LoadedApk 会记录 ServiceConnection 信息
Activity 执行 finish 方法时，会通过 LoadedApk 检查 Activity 是否存在未注销/解绑的 BroadcastReceiver 和 ServiceConnection，如果有，那么会通知 AMS 注销/解绑对应的 BroadcastReceiver 和 Service，并打印异常信息，告诉用户应该主动执行注销/解绑的操作

https://blog.csdn.net/u011330638/article/details/85010858

4、ContentProvider

作为Android四大组件之一的ContentProvider，其设计的目的是为了为了提供跨应用的数据共享解决方案。

• ContentProvider的底层原理 = Android中的Binder机制

ContentProvider为应用间的数据交互提供了一个安全的环境：允许把自己的应用数据根据需求开放给 其他应用 进行 增、删、改、查，而不用担心因为直接开放数据库权限而带来的安全问题

采用ContentProvider方式，其 解耦了 底层数据的存储方式，使得无论底层数据存储采用何种方式，外界对数据的访问方式都是统一的，这使得访问简单 & 高效

ContentResolver 类提供了与ContentProvider类相同名字 & 作用的4个方法

// 外部进程向 ContentProvider 中添加数据
public Uri insert(Uri uri, ContentValues values)　

// 外部进程 删除 ContentProvider 中的数据
public int delete(Uri uri, String selection, String[] selectionArgs)

// 外部进程更新 ContentProvider 中的数据
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs)　

/ 外部应用 获取 ContentProvider 中的数据
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder)

https://www.jianshu.com/p/ea8bc4aaf057

5、Android广播（Broadcast）

Broadcast是android中的四大组件之一，是在组件之间传播数据（Intent）的一种机制。

实现原理:Android中的广播使用了设计模式中的观察者模式：基于消息的发布 / 订阅事件模型

广播的使用场景

a.同一app内有多个进程的不同组件之间的消息通信。
b.不同app之间的组件之间消息的通信。

Broadcast的分类

标准广播：context.sendBroadcast(Intent)方法发送的广播，不可被拦截
有序广播：context.sendOrderBroadcast(Intent)方法发送的广播，可被拦截
本地广播：localBroadcastManager.sendBroadcast(Intent)，只在app内传播

https://www.cnblogs.com/qikeyishu/p/9215458.html

1. 普通广播（标准广播）
   普通广播是完全异步的，通过Context的sendBroadcast()方法来发送，通过onReceive方法接收。消息传递效率比较高，但所有receivers（接收器）的执行顺序不确定。缺点在于：接收者不能将处理结果传递给下一个接收者，并且无法终止广播Intent的传播，直到没有匹配的接收器广播时才能停止传播。

2. 系统广播
   Android中内置了多个系统广播：只要涉及到手机的基本操作（如开机、网络状态变化、拍照等等），都会发出相应的广波，每个广播都有特定的Intent - Filter（包括具体的action）。

3.有序广播（Ordered Broadcast）

Android中的有序广播，用sendOrderedBroadcast发送。
该广播主要有以下特性：
（1）按照接收者的优先顺序来接收广播，优先级别在intent-filter中的priority中声明，-1000到1000之间，值越大优先级越高，
（2）可以终止广播的继续传播，接受者可以修改intent的内容。
（3）同级别接收顺序是随机的，级别低的后收到
（4）能截断广播的继续传播，高级别的广播接收器接收广播后能决定时候截断。能处理广播
（5）同级别动态注册高于静态注册

1. 粘性广播（Sticky Broadcast）

粘性广播的特点是Intent会一直保留到广播事件结束，而这种广播也没有所谓的10秒限制，10秒限制是指普通的广播如果onReceive方法执行时间太长，超过10秒的时候系统会将这个广播置为可以干掉的candidate，一旦系统资源不够的时候，就会干掉这个广播而让它不执行。该广播用sendStickyBroadcast发送。

1. App应用内广播（Local Broadcast）

   因为android中的广播是可以跨域的（跨App），因此可能存在一下问题：其他App针对性发出与当前App intent-filter相匹配的广播，由此导致当前App不断接收广播并处理；其他App注册与当前App一致的intent-filter用于接收广播，获取广播具体信息； 即会出现安全性和效率性的问题。
   App应用内广播可理解为一种局部广播，广播的发送者和接收者都同属于一个App。相比于全局广播（普通广播），App应用内广播优势体现在：安全性高效率高

原文链接：https://blog.csdn.net/weixin_34819401/article/details/109774523

BroadcastReceiver与LocalBroadcastReceiver有什么区别？

• BroadcastReceiver 是跨应用广播，利用Binder机制实现。
• LocalBroadcastReceiver 是应用内广播，利用Handler实现，利用了IntentFilter的match功能，提供消息的发布与接收功能，实现应用内通信，效率比较高。

https://www.kancloud.cn/aslai/interview-guide/1113686

LocalBroadcastReceiver

[

](https://www.jianshu.com/p/6f1ea19a17ed)

https://www.jianshu.com/p/6f1ea19a17ed

Binder机制原理

https://blog.csdn.net/augfun/article/details/82343249

https://blog.csdn.net/weijinqian0/article/details/52233529

动态注册和静态注册区别

静态注册

• 注册方式：在AndroidManifest.xml里通过标签声明

  动态注册

• 注册方式：在代码中调用Context.registerReceiver（）方法

• 动态广播最好在Activity 的 onResume()注册、onPause()注销。在onResume()注册、onPause()注销是因为onPause()在App死亡前一定会被执行，从而保证广播在App死亡前一定会被注销，从而防止内存泄露。
• 对于动态广播，有注册就必然得有注销，否则会导致内存泄露
• 重复注册、重复注销也不允许

https://www.jianshu.com/p/ca3d87a4cdf3

6、Android Manifest文件详解

https://www.jianshu.com/p/543c5ff531a7

Android Intent用法总结

https://www.jianshu.com/p/67d99a82509b
Android中提供了Intent机制来协助应用间的交互与通讯，Intent负责对应用中一次操作的动作、动作涉及数据、附加数据进行描述，Android则根据此Intent的描述，负责找到对应的组件，将 Intent传递给调用的组件，并完成组件的调用。

• 显式Intent

  显式，即直接指定需要打开的activity对应的类。<br />1）构造方法传入**Component**，最常用的方式：

• 隐式Intent

隐式，不明确指定启动哪个Activity，而是设置Action、Data、Category，让系统来筛选出合适的Activity。筛选是根据所有的来筛选。

Android Bundle 用法总结

https://blog.csdn.net/qq_34480777/article/details/55041032
当一个 Activity 启动另一个 Activity 时，常常会有一些数据需要传过去。因为两个 Activity 之间本来就有一个 Intent，因此我们主要将需要交换的数据放入 Intent 中即可。
Intent 主要通过 Bundle 对象来携带数据，因此 Intent 提供了 putExtras()和 getExtras()两个方法。除此之外，Intent 也提供了多个重载的 putExtra(String key,Xxx value)、getXxxExtra(String key)。其实 Intent 提供的 putExtra(String key,Xxx value)、getXxxExtra(String key)方法，只是两个便捷的方法，这些方法依然是存取 Intent 所携带的 Bundle 中的数据。
Intent 的 putExtra(String key, XXxx value)方法是“智能”的，当程序调用 Intent 的 putExtra(String key,Xxx value)方法向 Intent 中存入数据时，如果该 Intent 中已经携带了 Bundle 对象，则该方法直接向 Intent 所携带的 Bundle 中存入数据；如果 Intent 还没有携带 Bundle 对象，putExtra(String key,Xxx value)方法会优先为 Intent 创建一个 Bundle，再向 Bundle 中存入数据。

7、Handler机制

https://www.jianshu.com/p/592fb6bb69fa
主要作用是消息通信。
https://blog.csdn.net/luoyingxing/article/details/86500542

Message
Message有8个静态方法可以创建Message实例
Message有两个重要的成员变量，分别为target 和callback，一个是Handler，一个是Runnable。
Message有4个公开变量what、arg1、arg2、obj 可以存储消息进行传递
Message还有一个包间成员变量next，它是Message类型，后面会使用到，知道有这个next就行

• 创建方法，obtain()方法

Handler

Handler有且只能绑定一个线程的Looper；

Handler的消息是发送给Looper的消息队列MessageQueue，需要等待处理；

• 无参构造(最常用的)，接收两个参数的构造方法

检验当前线程是否具备开启Handler的条件，如果具备的话，就将Handler和当前线程的Looper以及MessageQueue进行关联绑定。

• enqueueMessage方法

Handler中的这个方法最终内部就是调用了MessageQueue中的enqueueMessage方法来将消息插入队列的

• Handler的sendMessage方法、sendMessageDelayed方法或者是post方法，最终都会调用到这个enqueueMessage方法

• dispatchMessage方法

这个方法是Handler分发消息去处理的方法，在前面讲Looper的loop方法中提到过。
当消息被传入到此方法后，方法内部会根据消息对象的属性以及Handler的属性来决定如何分发这个消息。

• post方法

其本质也是发送一条消息给消息队列，最终再由Looper发送给Handler，只不过这个方法发送的消息的callback属性不为空。而在前面讲dispatchMessage方法时说过，如果当前分发的消息对象的callback不为空，那么会执行到handleCallback方法中。而handleCallback方法内部其实就是调用了消息对象的callback的run方法，所以run方法是运行在Handler所创建的线程中的

作者：孟校长
链接：https://www.jianshu.com/p/7cc1c8b4adb1
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

MessageQueue
MessageQueue的enqueueMessage（）方法
通过单向链表的数据结构来存储消息。既然有了插入消息的方法供Handler插入消息，那么应该有对应的取出消息的方法，供Looper调用取出消息处理，它就是Message.next这个变量（结点）

【几个重要的变量】

• mQuitAllowed变量

含义是当前的MessageQueue是否允许被退出。它在MessageQueue的构造方法中被赋值

• mQuitting变量

含义是当前的MessageQueue是否可以退出了

只有当mQuitAllowed变量为true的前提下，quit方法才得以正常的执行下去，mQuitting变量也才可以有机会被置为true；

• mBlocked变量

含义是作为MessageQueue中next方法是否以一个非零的超时时长被阻塞在pollOnce()方法中的一个标志，简单的可以理解为当前消息队列是否被阻塞的标志。

• mMessages变量，

它是一个Message类型的变量。next的变量，也是一个Message类型的变量。

   ----------<br />**        enqueueMessage方法**<br />第一步，判断消息是否满足入队的条件并且检测队列是否能够插入消息；<br />第二步，根据队列和消息的状态来决定消息插入的方式以及确定是否需要唤醒队列；<br />第三步就是根据值来决定是否需要唤醒队列。
    **next方法**<br />取出消息的过程也可以简单分成三步，<br />第一步，判断队列是否已经退出以及消息是否合法；<br />第二步，根据队列中消息的顺序确定要返回的消息；<br />第三步，将返回的消息从队列中移除。

链接：https://www.jianshu.com/p/7cc1c8b4adb1

Looper

Looper在Handler机制中扮演着关键的一环，它不断的从消息队列中取出的消息，处理，然后分发处理事件。每个线程都可以且只能绑定一个Looper。主线程之所以能处理消息，也是因为在APP启动时，在ActivityThread中的main（）方法中就已经启动了Looper循环。

• prepare方法

用于在一个线程中创建一个Looper

• loop方法

loop方法的流程也可以概括为三步，
第一步，检测Looper对象是否已经创建；
第二步，在循环中通过调用MessageQueue的next方法从消息队列中遍历出消息；
第三步，调用Handler的dispatchMessage方法将消息发送到Handler的手中然后将消息重置。

如果在一个线程中不再使用Looper了，记得调用它的quit或者quitSafely方法，这样loop方法才能结束的。

————————————————
Handler机制可以简述为：
Handler将Message发送到Looper的消息队列中，即MessageQueue，等待Looper的循环读取Message，处理Message，然后调用Message的target，即附属的Handler的dispatchMessage（）方法，将该消息回调到handleMessage（）方法中，然后完成更新UI操作。

Handler 使用场景： 执行比较耗时的I/O操作或者访问网络的操作。

关于handler，在任何地方new handler 都是什么线程下

（1）Handler的构造函数可以传入Looper，默认的使用当前线程的Looper。
如果当前线程没有Looper，则会报错。MainLooper在程序启动，ActivityThread中就创建了。
如果自己开辟线程，可以使用Looper.prepare()创建Looper，然后创建Handler就不会报错了。

（2）Handler handler = new Handler(Looper.getMainLooper());
这个不管在哪个线程中创建，handleMessage回调的都是主线程。

（3）使用默认构造函数创建，当前在哪个线程，handleMessage回调就是在哪个线程。

https://blog.csdn.net/u013072976/article/details/78261349
[

](https://blog.csdn.net/luoyingxing/article/details/86500542)
1.要刷新UI，handler要用到主线程的looper。那么在主线程 Handler handler = new Handler();
如果在其他线程，也要满足这个功能的话，要Handler handler = new Handler(Looper.getMainLooper());

2.不用刷新ui,只是处理消息。
当前线程如果是主线程的话，Handler handler = new Handler();
不是主线程的话，Looper.prepare(); Handler handler = new Handler();Looper.loop();
或者Handler handler = new Handler(Looper.getMainLooper());表示放到主UI线程去处理

https://blog.csdn.net/u013072976/article/details/78261349

handle 发消息给子线程,looper 怎么启动

该handler中引用的looper对象是属于那个线程的， 就会把消息投递给该线程， 并在该线程里执行 handleMessage方法。
https://www.zhihu.com/question/48130951?sort=created

https://zhidao.baidu.com/link?url=WI-igRa5qkwedPgkcn3Z27VU73zHRpi-u5C23FaZcX27XmQT2VlEx5DXZqVAUOhchJOu4M-JOoDY0XELuziBP-X8VnfhcfInZy8Y8yiSckK

https://blog.csdn.net/qq_27070117/article/details/81183118

Android多线程

常用方法主要有：

1. 继承Thread类
2. 实现Runnable接口
3. Handler
4. AsyncTask
5. HandlerThread

AsyncTask异步任务

https://www.runoob.com/w3cnote/android-tutorial-ansynctask.html
官方给提供的封装好的轻量级异步类，相比起Handler，AsyncTask显得更加简单，快捷。
这只适合简单的异步操作，但是到了公司真正做项目以后，我们更多的使用第三发的框架，比如Volley,OkHttp,android-async-http,XUtils等很多。

https://www.jianshu.com/p/ee1342fcf5e7
[

](https://blog.csdn.net/luoyingxing/article/details/86500542)

AsyncTask的缺陷和问题

• 生命周期

如果我们的Activity销毁之前，没有取消 AsyncTask，这有可能让我们的AsyncTask崩溃(crash)

• 内存泄漏

如果AsyncTask被声明为Activity的非静态的内部类，那么AsyncTask会保留一个对创建了AsyncTask的Activity的引用。

• 结果丢失

屏幕旋转或Activity在后台被系统杀掉等情况会导致Activity的重新创建，之前运行的AsyncTask会持有一个之前Activity的引用，这个引用已经无效，这时调用onPostExecute()再去更新界面将不再生效。

如何取消Asynctask

在AsyncTask中，我们没有办法直接停止掉异步任务，只能通过cancel方法来将AsyncTask标记为cancel状态，即cancel方法只是传递了一个信号量，而不是真的cancel了异步任务。
所以如果希望cancel方法能直接取消掉异步任务，就需要在doInBackground中检测当前状态：当状态是cancel状态，则立刻跳出循环。

https://blog.csdn.net/zgljl2012/article/details/47258301/

工作线程更新UI 的方法

1.Activity.runOnUiThread(Runable)

2.View.post(Runable)

3.View.postDelay(Runable)

4.handler更新

https://blog.csdn.net/qidingquan/article/details/50624792
https://www.cnblogs.com/ouyangping/p/7743863.html

为什么不能在子线程更新UI

Android的UI操作不是线程安全的invalidate()在子线程调用会导致线程不安全。

• 子线程可以在ViewRootImpl还没有被创建之前更新UI；
• 访问UI是没有加对象锁的，在子线程环境下更新UI，会造成不可预期的风险；
• 开发者更新UI一定要在主线程进行操作;

ViewRootImpl对象是在onResume方法回调之后才创建，那么就说明了为什么在生命周期的onCreate方法里，甚至是onResume方法里都可以实现子线程更新UI，因为此时还没有创建ViewRootImpl对象，并不会进行是否为主线程的判断；

链接：https://www.jianshu.com/p/58c999d3ada7

https://blog.csdn.net/dfskhgalshgkajghljgh/article/details/106093924
———-

Android Toast使用的简单小结

1.最基本的Toast

2.自定义位置的Toast

3.自定义布局（带图片）的Toast

4.自定义带动画效果的Toast控件

原文链接：https://blog.csdn.net/fitaotao/article/details/82251750
————

一个线程能否创建多个Handler，Handler跟Looper之间的对应关系 ？

一个线程能够创建多个Handler，Handler跟Looper没有对应关系，线程才跟Looper有对应关系，一个线程对应着一个Looper

链接：https://www.jianshu.com/p/c1f8dad0dafb

【HandlerB能够获取HandlerA发送的异步消息吗？】
https://www.cnblogs.com/transmuse/archive/2011/05/16/2048073.html

lopper 是如何区分多个handler

首先说明，一个handler发送的消息只会被自己接收，所以是可以正常处理的
发送消息除了利用Handler之外还有Message，Message一般利用Obtain获取，其实obtain中还可以传递参数，可以接收Message，还可以接收Handler，message有多个属性，常用的有what，arg1,arg2,data等，其实还有一个属性叫做target,
这个target属性就是标识handler的。

原文链接：https://blog.csdn.net/u010126792/article/details/82899976

这样在处理消息的时候通过msg.target就可以区分开不同的Handler了。处理的方法在Looper.loop中.
https://blog.csdn.net/ly502541243/article/details/87475229

8、view相关

什么是View？

View是Android中所有控件的基类，不管是简单的TextView，Button还是复杂的LinearLayout和ListView，它们的共同基类都是View；
View是一种界面层的控件的一种抽象，它代表了一个控件。
在Android中，ViewGroup也继承了View，这就意味着View可以是单个控件，也可以是由多个控件组成的一组控件；

https://www.jianshu.com/p/1ba3d28781e4

https://blog.csdn.net/makyan/article/details/89106967

Android View 绘制流程详解

https://www.jianshu.com/p/9e5ebeb3ed35

traversals 遍历
整个 View 树的绘图流程在ViewRoot.java类的 performTraversals() 函数展开，该函数所做 的工作可简单概况为是否需要重新计算视图大小(measure)、
是否需要重新安置视图的位置(layout)、
以及是否需要重绘(draw)，
流程图如下：

• measure

measure 过程会为一个 View 及所有子节点的 mMeasuredWidth 和 mMeasuredHeight 变量赋值，
该值可以通过
getMeasuredWidth()和
getMeasuredHeight()方法获得。

**measure 过程传递尺寸的两个类**

• ViewGroup.LayoutParams （View 自身的布局参数）

  • MATCH_PARENT 表示子视图希望和父视图一样大(不包含 padding 值)
  • WRAP_CONTENT 表示视图为正好能包裹其内容大小(包含 padding 值)

• MeasureSpecs 类（父视图对子视图的测量要求）

  • UNSPECIFIED （unspecified）
    父视图不对子视图有任何约束，它可以达到所期望的任意尺寸。比如 ListView、ScrollView，一般自定义 View 中用不到，
  • EXACTLY (exactly)
    父视图为子视图指定一个确切的尺寸，而且无论子视图期望多大，它都必须在该指定大小的边界内，对应的属性为 match_parent 或具体值，比如 100dp，父控件可以通过MeasureSpec.getSize(measureSpec)直接得到子控件的尺寸。
  • AT_MOST
    父视图为子视图指定一个最大尺寸。子视图必须确保它自己所有子视图可以适应在该尺寸范围内，对应的属性为 wrap_content，这种模式下，父控件无法确定子 View 的尺寸，只能由子控件自己根据需求去计算自己的尺寸，这种模式就是我们自定义视图需要实现测量逻辑的情况。

    measure 核心方法

• measure(int widthMeasureSpec, int heightMeasureSpec)
  该方法定义在View.java类中，为 final 类型，不可被复写，但 measure 调用链最终会回调 View/ViewGroup 对象的 onMeasure()方法，因此自定义视图时，只需要复写 onMeasure() 方法即可。

• onMeasure(int widthMeasureSpec, int heightMeasureSpec)
  该方法就是我们自定义视图中实现测量逻辑的方法，该方法的参数是父视图对子视图的 width 和 height 的测量要求。在我们自身的自定义视图中，要做的就是根据该 widthMeasureSpec 和 heightMeasureSpec 计算视图的 width 和 height，不同的模式处理方式不同。

• setMeasuredDimension()
  测量阶段终极方法，在 onMeasure(int widthMeasureSpec, int heightMeasureSpec) 方法中调用，将计算得到的尺寸，传递给该方法，测量阶段即结束。该方法也是必须要调用的方法，否则会报异常。在我们在自定义视图的时候，不需要关心系统复杂的 Measure 过程的，

只需调用setMeasuredDimension()设置根据 MeasureSpec 计算得到的尺寸即可，你可以参考 ViewPagerIndicator的 onMeasure 方法。

layout

View 的 onLayout 方法为空实现，而 ViewGroup 的 onLayout 为 abstract 的，因此，如果自定义的 View 要继承 ViewGroup 时，必须实现 onLayout 函数。
在 layout 过程中，子视图会调用
getMeasuredWidth()和
getMeasuredHeight()方法获取到 measure 过程得到的 mMeasuredWidth 和 mMeasuredHeight，作为自己的 width 和 height。
然后调用每一个子视图的layout(l, t, r, b)函数，来确定每个子视图在父视图中的位置。

draw

• View.draw(Canvas canvas)：
  由于 ViewGroup 并没有复写此方法，因此，所有的视图最终都是调用 View 的 draw 方法进行绘制的。在自定义的视图中，也不应该复写该方法，而是复写 onDraw(Canvas) 方法进行绘制，如果自定义的视图确实要复写该方法，那么请先调用 super.draw(canvas)完成系统的绘制，然后再进行自定义的绘制。
• View.onDraw()：
  View 的onDraw（Canvas）默认是空实现，自定义绘制过程需要复写的方法，绘制自身的内容。

• dispatchDraw()
  发起对子视图的绘制。View 中默认是空实现，ViewGroup 复写了dispatchDraw()来对其子视图进行绘制。该方法我们不用去管，

  自定义的 ViewGroup 不应该对dispatchDraw()进行复写。

  • drawChild(canvas, this, drawingTime)
    直接调用了 View 的child.draw(canvas, this,drawingTime)方法，，child.draw(canvas, this, drawingTime) 肯定是处理了和父视图相关的逻辑，

      但 View 的最终绘制，还是View.draw(Canvas)方法。

  • invalidate()
    请求重绘 View 树，即 draw 过程，假如视图发生大小没有变化就不会调用layout()过程，并且只绘制那些调用了invalidate()方法的 View。

  • requestLayout()
    当布局变化的时候，比如方向变化，尺寸的变化，会调用该方法，在自定义的视图中，如果某些情况下希望重新测量尺寸大小，应该手动去调用该方法，它会触发measure()和layout()过程，但不会进行 draw。

Android 计算一个view 的嵌套层级

Android view层级：

 ![image.png](https://cdn.nlark.com/yuque/0/2021/png/23038245/1637897354282-2efea1f3-8ad7-445c-bb91-d97ed9cab4a5.png#clientId=ubd317d18-f44a-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=384&id=uab71b34c&margin=%5Bobject%20Object%5D&name=image.png&originHeight=536&originWidth=660&originalType=binary&ratio=1&rotation=0&showTitle=false&size=18707&status=done&style=none&taskId=u1e5e6de2-8d4b-41bd-9d2b-21c77359878&title=&width=473)<br />[https://www.jianshu.com/p/4dd8eb080534](https://www.jianshu.com/p/4dd8eb080534)

https://blog.csdn.net/zx_android/article/details/79558509

Android获取View的宽度和高度

• onWindowFocusChanged方法中获取：
  onWindowFocusChanged方法执行时代表View已经初始化完毕了，宽度和高度已经测量完毕并且最终确认好了，这时我们可以放心的在这里去获取View 的宽度和高度。

  onWindowFocusChanged会执行多次，在Activity获取焦点和失去焦点时都会被调用一次。
  即在onPause和onResume方法被执行时被反复调用。

• View.post(new Runnable())方法中获取：
  通过View.post方法把Runnable对象放到消息队列的末尾，当执行到这个runable方法的时候，View所有的初始化测量方法说明都已经执行完毕了。因此在这里获取的时候就是测量后的真实值。

• 通过ViewTreeObserver获取：
  当View树的状态发生改变或者View树内部View的可见性发生改变的时候，onGlobalLayout将会被回调。注意：伴随着View树的状态改变，onGlobalLayout会被调用多次

• 手动调用View的measure方法后获取
  手动调用measure后，View会调用onMeasure方法对View发起测量，测量完后，就可以获取测量后的宽度和高度了。但是要对LayoutParams的参数分情况处理才能得到具体的参数值：
  View的LayoutParams参数为match_parent:这种情况下无法获取到具体宽高值，因为当View的测量模式为match_parent时，宽高值是取父容器的剩余空间大小作为它自己的宽高。而这时无法获取到父容器的尺寸大小，因此获取会失败。

  https://blog.csdn.net/chenbaige/article/details/77991594

自定义view需要重写哪些方法

https://www.jianshu.com/p/99878de32418

首先定义一个继承View基类的子类，然后重写View类的一个或者多个方法:

• 1.构造器:重写构造器是定制View的最基本方式，当Java代码创建一个View实例，或根据XML布局文件加载并构建界面时将需要调用该构造器。
  2.onFinishinflate():这是一个回调方法，当应用从XML布局文件加载该组件并利用它来构建界面之后，该方法就会被回调。
  3.onMeasure(int,int):调用该方法来检测View组件及它所包含的所有子组件的大小。
  4.onLayout(boolean,int,int,int,int):当该组件需要分配其子控件的位置、大小时该方法就会被调用。
  5.onSizeChanged(int, int, int, int):当该组件的大小被改变时回调该方法。
  6.onDraw(Canvas):当该组件将要绘制它的内容时回调该方法进行绘制。
  7.onKeyDown(int, KeyEvent):当某个键被按下时触发该方法。
  8.onKeyUp(int, KeyEvent):当松开某个键时触发该方法。
  9.onTrackballEvent(MotionEvent):当发生轨迹球事件时触发该方法。
  10.onTouchEvent(MotionEvent):当发生触摸屏事件时触发该方法。
  11.onWindowFocusChanged(boolean):当该组件得到、失去焦点时触发该方法。
  12.onAttachedToWindow():当把该组件放入某个窗口时触发该方法。
  13.onDetachedFromWindow():当把该组件从某个窗口上分离时触发该方法。
  14.onWindowVisibilityChanged(int):当包含该组件的窗口的可见性发生改变时触发该方法。

当需要开发自定义View时，并不需要重写上面列出的所有方法，而是根据业务需要重写上面的部分方法。

——————-
Window首先加载一个超级复合View，用它包含住所有的其他View，这个超级复合View就叫做DecorView。但是这个DecorView除了包含我们的用户界面上的那些View，还包含了作为一个Window特有的View，叫做TitleBar。

链接：https://www.jianshu.com/p/70853209a182

[自定义view 计步器界面设计]

https://www.bilibili.com/video/BV1S741157Qj?p=3&spm_id_from=pageDriver

// activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity"
    android:id="@+id/refresh">
  <!--使用自定义的view组件  -->
    <com.example.myapplication_view.FIWStepView
        android:id="@+id/step_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:border_width="30dp"
        app:outer_color="@color/yellow"
        app:inner_color="@color/blueviolet"
        app:step_text_color="@color/blueviolet"
        app:step_text_size="30dp"
        />
</androidx.constraintlayout.widget.ConstraintLayout>

// MainActivity.java
import androidx.appcompat.app.AppCompatActivity;
import android.animation.ValueAnimator;
import android.os.Bundle;
import android.view.animation.DecelerateInterpolator;
public class MainActivity extends AppCompatActivity {
    private FIWStepView fiwStepView;  //引用自定义组件view
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        fiwStepView = findViewById(R.id.step_view);
        fiwStepView.setmMaxStep(10000);  // 设置最大步数
        // 加入动画
        ValueAnimator animator = ValueAnimator.ofFloat(0,8000); // 步数范围0-8000 
        animator.setInterpolator(new DecelerateInterpolator());// 设置加速度效果
        animator.setDuration(1000);
        animator.addUpdateListener( (animation)->{
            float currentSteps = (float)animation.getAnimatedValue();
            fiwStepView.setmCurrentStep((int) currentSteps);
        });
        animator.start();
    }
}

// activity_review.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:id="@+id/refresh">
    <com.example.myapplication_view.FIWStepView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:border_width="10dp"
        app:outer_color="@color/yellow"
        app:inner_color="@color/blueviolet"
        app:step_text_color="@color/blueviolet"
        app:step_text_size="30dp"
        />
</LinearLayout>

// FIWStepView.java
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.RectF;
import android.util.AttributeSet;
import android.view.View;
import androidx.annotation.Nullable;
public class FIWStepView extends View {
    private int mOuterColor = Color.YELLOW; //外层颜色
    private int mInnerColor = Color.BLUE;  // 内层颜色
    private int mBorderWidth; //
    private int mStepTextColor = Color.BLUE; // 步数文字颜色
    private int getmStepTextSize; // 步数文本的大小
    private int mCurrentStep;  //  当前步数，// 这连个值在mainActivity.java 中设置
    private int mMaxStep ;    // 最大步数
    private Paint mOuterPaint;// 外圆环 ，设置为全局
    private Paint mInnerPaint; // 内圆环
    private Paint mTextpaint; // 文字
    // 重写get(),为了可以读到私有的值
    public int getmCurrentStep() {
        return mCurrentStep;
    }
    public void setmCurrentStep(int mCurrentStep) {
        this.mCurrentStep = mCurrentStep;
        // 防止调用后就停止，所以要刷新
        invalidate();
    }
    public int getmMaxStep() {
        return mMaxStep;
    }
    public void setmMaxStep(int mMaxStep) {
        this.mMaxStep = mMaxStep;
    }
  // 构造函数
    public FIWStepView(Context context) {
        // 把super 改成 this
        this(context,null);
    }
    public FIWStepView(Context context, @Nullable AttributeSet attrs) {
        this(context, attrs,0);
    }
    public FIWStepView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        // 获取自定义属性
        TypedArray array = context.obtainStyledAttributes(attrs,R.styleable.FIWStepView);
        mOuterColor = array.getColor(R.styleable.FIWStepView_outer_color,mOuterColor);
        mInnerColor = array.getColor(R.styleable.FIWStepView_inner_color,mInnerColor);
        mBorderWidth =(int)array.getDimension(R.styleable.FIWStepView_border_width,mBorderWidth);
        mStepTextColor=array.getColor(R.styleable.FIWStepView_step_text_color,mStepTextColor);
        getmStepTextSize=array.getDimensionPixelSize(R.styleable.FIWStepView_step_text_size,getmStepTextSize);
        array.recycle();
        //外圆环
        mOuterPaint = new Paint();
        mOuterPaint.setAntiAlias(true);
        mOuterPaint.setColor(mOuterColor);
        mOuterPaint.setStrokeWidth(mBorderWidth);
        mOuterPaint.setStyle(Paint.Style.STROKE);//设置圆弧内不填充
        mOuterPaint.setStrokeCap(Paint.Cap.ROUND);//设置断点为圆弧
        //内圆环
        mInnerPaint = new Paint();
        mInnerPaint.setAntiAlias(true);
        mInnerPaint.setColor(mInnerColor);
        mInnerPaint.setStrokeWidth(mBorderWidth);
        mInnerPaint.setStyle(Paint.Style.STROKE);
        mInnerPaint.setStrokeCap(Paint.Cap.ROUND);
        //  文字
        mTextpaint = new Paint();
        mTextpaint.setAntiAlias(true);
        mTextpaint.setColor(mStepTextColor);
        mTextpaint.setTextSize(getmStepTextSize);
    }
    //----------------重写方法-------------
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        // 圆形由正方形截来，所以先以短边来成正方形
        int width =  MeasureSpec.getSize(widthMeasureSpec);
        int height = MeasureSpec.getSize(heightMeasureSpec);
        setMeasuredDimension(width>height? height:width ,width>height?height:width);
    }
    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        // 5 ---------绘制内圆弧
        // RectF rectF = new RectF(0,0,getWidth(),getWidth());
        // 新距离算法，保证圆环完整显示
        int center = getWidth()/2;
        int radius = (getWidth()-mBorderWidth)/2;
        RectF rectF = new RectF(mBorderWidth/2,mBorderWidth/2,center+radius,center+radius);
        //Paint mOuterPaint = new Paint();      这个耗时操作不要放在这里
        // 系统自带画圆弧的功能,需要参数
        canvas.drawArc(rectF,135,270,false,mOuterPaint);
        // ---------绘制外圆环
        if(mMaxStep ==0){return ;}
        float radio = (float) mCurrentStep/mMaxStep;
        canvas.drawArc(rectF,135,270*radio,false,mInnerPaint);
        //-------绘制文字
        String mText = mCurrentStep+"";
        Rect rect = new Rect();
        mTextpaint.getTextBounds(mText,0,mText.length(),rect);
        int dx= getWidth()/2-rect.width()/2;
        Paint.FontMetricsInt fontMetricsInt = mTextpaint.getFontMetricsInt();
        int dy = fontMetricsInt.bottom - fontMetricsInt.top;
        int baseLine = getHeight()/2-dy/2;
        canvas.drawText(mText,dx,baseLine,mTextpaint);
    }
}

//  AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.myapplication_view">
    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.MyApplication_View">
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

// attrs.xml 
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <declare-styleable name="FIWStepView">
        <attr name="outer_color" format="color"/>
        <attr name="inner_color" format="color"/>
        <attr name="border_width" format="dimension"/>
        <attr name="step_text" format="dimension"/>
        <attr name="step_text_color" format="color"/>
        <attr name="step_text_size" format="dimension"/>
    </declare-styleable>
</resources>

ViewPage使用

• ViewPager类直接继承了ViewGroup类，是一个容器，需要在里面添加我们想要显示的内容。
• ViewPager类需要PagerAdapter适配器类提供数据。

作用：左右切换当前的view，实现滑动切换的效果。

用相应的适配器Adapter关联上面的页卡（View/Fragment）和ViewPager：

• PagerAdapter 数据源：List
• FragmentPagerAdapter 数据源：List
• FragmentStatePagerAdapter 数据源：List

利用Viewpage自带的方法setPageTransformer()可用于设置切换动画

FragmentStatePagerAdapter 和 FragmentPagerAdapter 的异同：

• 同
  PageAdapter 是 FragmentPagerAdapter 以及
  FragmentStatePagerAdapter 的基类，可将上面的FragmentPagerAdapter 替换成FragmentStatePagerAdapter
• 异
  FragmentPagerAdapter使用时，每一个生成的 Fragment 都将保存在内存之中，而 FragmentStatePagerAdapter 只保留了当前显示的Fragment，其他划过的Fragment离开视线后，就会被销毁；而在页面需要显示时，再生成新的实例。

https://www.jianshu.com/p/f70073f7e837

ViewPager使用细节,如何设置成每次只初始化当前的Fragment,其他的不初始化

https://www.cnblogs.com/dmrbell/p/12408207.html
（fragment 懒加载）
利用 setUserVisibleHint 和 生命周期方法

https://blog.csdn.net/wellto/article/details/52145899

https://blog.csdn.net/wuqingsen1/article/details/84544665

Android 事件分发机制

事件分发就是从上往下依次遍历，直到找到能够处理消费这次点击事件的View或ViewGroup。

事件分发中的事件指的是点击事件（Touch事件）
一次完整的点击包含四种事件：
（1）ACTION.DOWN：手指触摸到屏幕
（2）ACTION.MOVE：手指在屏幕中滑动
（3）ACTION.UP：手指离开屏幕
（4）ACTION.CANCEL：取消点击事件

事件分发涉及到的方法有3个：

dispatchTouchEvent（）（分发事件）
onInterceptTouchEvent（）（拦截事件）
onTouchEvent（）（处理事件）

onInterceptTouchEvent（）方法是ViewGroup独有的，另外两个方法是三者共有的。

https://blog.csdn.net/yuncaidaishu/article/details/100039363

点击事件被拦截，但是想传到下面的View，如何操作？

重写子类的requestDisallowInterceptTouchEvent()方法返回true，
就不会执行父类的onInterceptTouchEvent()，即可将点击事件传到下面的View

https://www.jianshu.com/p/04d74729d79d

ListView

借助ListView来显示更多的内容。
ListView允许用户通过上下滑动来将屏幕外的数据滚动到屏幕内，同时屏幕内原有的数据滚动出屏幕，从而显示更多的数据内容。

重写getView（）方法，这个方法在每个子项被滚动到屏幕内的时候会被调用。
首先通过getItem()得到当前的项的Fruit实例，
然后使用LayoutInflater来为这个子项加载我们传入的布局。

https://www.jianshu.com/p/f217b0208462

ListView复用和优化详解

• 为什么会存在Item复用问题

ListView内部为了优化而建立的复用机制,在getView（）方法中第二个参数就是ListView传递给你,让你进行复用的View.

• 为什么需要ViewHolder

  了在列表滚动的时候,频繁调用getView方法的时候尽量提高性能.我们可以使用一个普通类,这个类通常就起名字为ViewHolder了,当创建itemView的时候,我们也把里面要用到的控件也找到,然后放在ViewHolder类中,然后再通过itemView.setTag(Object ob)方法实现一个itemView和一个ViewHolder进行绑定.

• 出现复用问题怎么解决

  原理：当我们复用ListView回传的View的时候,这个View是被之前使用过的,也就是说给你的这个View保存了之前用过的状态。

解决方法：对产生问题的控件进行初始化,,把出问题的控件,状态还原一下

https://blog.csdn.net/u011692041/article/details/53099584

Android ListView工作原理完全解析

https://blog.csdn.net/guolin_blog/article/details/44996879

ListView并不会直接和数据源打交道，而是会借助Adapter这个桥梁来去访问真正的数据源。
Adapter的接口都是统一的，因此ListView不用再去担心任何适配方面的问题。
而Adapter又是一个接口(interface)，它可以去实现各种各样的子类，每个子类都能通过自己的逻辑来去完成特定的功能。

Adapter还有一个非常非常重要的方法也需要我们在Adapter当中去重写，就是getView()方法。

在开始分析ListView的源码之前，还有一个东西是我们提前需要了解的，就是RecycleBin机制，这个机制也是ListView能够实现成百上千条数据都不会OOM最重要的一个原因

RecycleBin最主要的几个方法：

• fillActiveViews() 调用这个方法后就会根据传入的参数来将ListView中的指定元素存储到mActiveViews数组当中。

• getActiveView() 这个方法和fillActiveViews()是对应的，用于从mActiveViews数组当中获取数据。

• addScrapView() 用于将一个废弃的View进行缓存

• getScrapView 用于从废弃缓存中取出一个View，这些废弃缓存中的View是没有顺序可言的，

• setViewTypeCount() 我们都知道Adapter当中可以重写一个getViewTypeCount()来表示ListView中有几种类型的数据项，而setViewTypeCount()方法的作用就是为每种类型的数据项都单独启用一个RecycleBin缓存机制。实际上，getViewTypeCount()方法通常情况下使用的并不是很多，所以我们只要知道RecycleBin当中有这样一个功能就行了。

[

](https://blog.csdn.net/guolin_blog/article/details/44996879)
[

](https://blog.csdn.net/guolin_blog/article/details/44996879)
obtainView()方法中的代码并不多，但却包含了非常非常重要的逻辑，不夸张的说，整个ListView中最重要的内容可能就在这个方法里了

调用RecyleBin的getScrapView()方法来尝试从废弃缓存中获取一个View，那么废弃缓存有没有View呢？当然有，因为刚才在trackMotionScroll()方法中我们就已经看到了，一旦有任何子View被移出了屏幕，就会将它加入到废弃缓存中，而从obtainView()方法中的逻辑来看，一旦有新的数据需要显示到屏幕上，就会尝试从废弃缓存中获取View。所以它们之间就形成了一个生产者和消费者的模式，那么ListView神奇的地方也就在这里体现出来了，不管你有任意多条数据需要显示，ListView中的子View其实来来回回就那么几个，移出屏幕的子View会很快被移入屏幕的数据重新利用起来，因而不管我们加载多少数据都不会出现OOM的情况，甚至内存都不会有所增加。
————————————————

Android ListView异步加载图片乱序问题，原因分析及解决方案

https://blog.csdn.net/guolin_blog/article/details/45586553

RecyclerView

是Android一个更强大的控件,其不仅可以实现和ListView同样的效果,还有优化了ListView中的各种不足。其可以实现数据纵向滚动,也可以实现横向滚动(ListView做不到横向滚动)。接下来讲解RecyclerView的用法。

• 定义内部类ViewHolder,并继承RecyclerView.ViewHolder。传入的View参数通常是RecyclerView子项的最外层布局。
• FruitAdapter构造函数,用于把要展示的数据源传入,并赋予值给全局变量mFruitList。
• FruitAdapter继承RecyclerView.Adapter。因为必须重写onCreateViewHolder(),onBindViewHolder()和getItemCount()三个方法
  • onCreateViewHolder()用于创建ViewHolder实例,并把加载的布局传入到构造函数去,再把ViewHolder实例返回。
  • onBindViewHolder()则是用于对子项的数据进行赋值,会在每个子项被滚动到屏幕内时执行。position得到当前项的Fruit实例。
  • getItemCount()返回RecyclerView的子项数目。

链接：https://www.jianshu.com/p/b4bb52cdbeb7

RecyclerViewDemo

//activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
    <!--在MainActivity 中 填写 要展示的recyclerview  组件id也是在这里定义-->
    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/rv_main"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
    />
</LinearLayout>

//MainActivity.java
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import android.os.Bundle;
import java.util.ArrayList;
import java.util.List;
public class MainActivity extends AppCompatActivity {
    List<Student> mStudent = new ArrayList<>(); // 数据
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView(); //初始化View,抽取为方法
        initdata(); // 数据赋值
    }
    // 把数据构建好
    private void initdata() {   // 在这里构建（读取）数据
        for(int i=0;i<100;i++){
            Student student = new Student("name:"+i);
            mStudent.add(student);
        }
    }
    // 实例化都写在这个方法上
    private void initView() {
        RecyclerView recyclerView = findViewById(R.id.rv_main);// 找,传入recyclerView
        // ----控制格式-----
        //传入 LayoutManager 的子类 LinearLayoutManager ,线性
        LinearLayoutManager linearLayoutManager = new LinearLayoutManager(this);
        linearLayoutManager.setOrientation(RecyclerView.VERTICAL); //设置方向
        recyclerView.setLayoutManager(linearLayoutManager); //需要传入一个Manager,构建
        // ----设置适配器----
        // 创建一个 Adapter Java类
        RecyclerViewAdater recyclerViewAdater = new RecyclerViewAdater(this,mStudent);// 把数据传过去
        recyclerView.setAdapter(recyclerViewAdater); // 需要传入一个自定义Adater（通过重写）
    }
}

// RecyclerViewAdater.java
import android.content.Context;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import java.util.ArrayList;
import java.util.List;
public class RecyclerViewAdater extends RecyclerView.Adapter<RecyclerViewAdater.InnerHolder> {
    Context mContent;
    List<Student> mStudent =  new ArrayList<>();//传进来自定义数据
    public RecyclerViewAdater(Context context, List<Student> list){ // 构造方法
        this.mContent = context; // 把content 传进来
        this.mStudent = list;
    }
    @Override
    public RecyclerViewAdater.InnerHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        // 绑定 item 视图
        View view =View.inflate(mContent,R.layout.item_listview,null);// 需要content,还有item_listview的资源文件
        return new InnerHolder(view);// 需要参数view --- 联系InnerHolder（）函数
    }
    @Override
    public void onBindViewHolder(@NonNull RecyclerViewAdater.InnerHolder holder, int position) {
        // 对实例化后的控件进行操作，进行数据的展示，点击事件的监听
        Student student = mStudent.get(position);// 得到某一行的数据
        holder.itemText.setText(student.getStName()); //展示数据
    }
    @Override
    public int getItemCount() {   // 返回数量
        return mStudent.size();
    }
    // 在这个类中对 item 进行实例化
    public class InnerHolder extends RecyclerView.ViewHolder {
        TextView itemText;  //
        public InnerHolder(@NonNull View itemView){
            super(itemView);   // 实例化item
            itemText = itemView.findViewById(R.id.item_text);// 从传进来的itemView中获取
        }
    }
}

// item_listview.xml
<?xml version="1.0" encoding="utf-8"?>
<!-- 在item中 尽量使用相对布局而不是 线性布局-->
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    // 使用卡片布局包裹效果
    <androidx.cardview.widget.CardView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:cardUseCompatPadding="true"
        >
        <TextView
            android:layout_width="match_parent"
            android:layout_height="50dp"
            android:id="@+id/item_text"
            android:text="@string/app_name"
            android:textSize="20dp"
            android:textStyle="bold"
            android:gravity="center_vertical"
            />
    </androidx.cardview.widget.CardView>
</RelativeLayout>

// Student.java
// 自定义数据
public class Student {
    private String stName;
    public Student(String stName) {
        this.stName = stName;
    }
    public String getStName() {
        return stName;
    }
    public void setStName(String stName) {
        this.stName = stName;
    }
}

// AndroidMainfest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.recyclerviewdemo">
    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.RecyclerViewDemo">
        //注册了MainActivity
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

// string.xml
<resources>
    <string name="app_name">RecyclerViewDemo</string>
</resources>

RecycleView四级缓存和RecycleView优化

https://www.jianshu.com/p/11081a051f31

9、okHttp

https://my.oschina.net/u/4856869/blog/4877748
okhttp3是一款优秀的HTTP框架，它支持get请求和post请求，支持基于Http的文件上传和下载，支持加载图片，支持下载文件透明的GZIP压缩，支持响应缓存避免重复的网络请求，支持使用连接池来降低响应延迟问题。
HttpURLConnection这个类相比HttpClient实在是太难用，太弱爆了。
google在Android 6.0中删除了关于Httpclient的APi，采用的则是okhttp

OkHttp是一个相对成熟的解决方案，Android4.4的源码中可以看到HttpURLConnection已经替换成OkHttp实现了。
OkHttp 处理了很多网络疑难杂症：会从很多常用的连接问题中自动恢复。如果您的服务器配置了多个IP地址，当第一个IP连接失败的时候，OkHttp会自动尝试下一个IP。OkHttp还处理了代理服务器问题和SSL握手失败问题。
使用 OkHttp 无需重写您程序中的网络代码。OkHttp实现了几乎和java.net.HttpURLConnection一样的API。如果你用了 Apache HttpClient，则OkHttp也提供了一个对应的okhttp-apache 模块。

OkHttp 源码解析

https://www.jianshu.com/p/bca742ffdbf6

1. 加入网络权限
   在 AndroidManifest.xml 文件中加入如下：

2. 添加 OkHttp 库的依赖
   在当前使用的 module 下的 build.gradle 中加入如下：

需要注意的是，response.body().string() 只能调用一次，否则会抛出如下异常：

同步 GET 请求的步骤：
private void syncGetRequestByOkHttp() throws Exception {
        OkHttpClient client = new OkHttpClient();//1. 创建 OkHttpClient 对象
   //2. 创建 Request 对象，然后通过 Builder() 链式调用可以设置请求 url、header、method 等。
        Request request = new Request.Builder()
                .url("https://www.baidu.com")
                .build();
      //调用 OkHttpClient 对象的 newCall() 方法创建一个 Call 对象
        Call call = client.newCall(request);
      //4. 调用 Call 对象的 execute() 方法发起一个请求，并获取服务器返回的数据。
        Response response = call.execute();
      //Response 就是返回的数据
        if (response.isSuccessful()) {
            Log.i(TAG, "syncGetRequestByOkHttp data-->" + response.body().string());
        } else {
            throw new IOException("Unexpected code " + response);
        }
    }

希望返回 String，则调用 response.body().string()，适用于不超过 1 MB 的数据。
希望返回输入流，则调用 response.body().byteStream()，适用于超过 1 MB 的数据，例如下载文件。
希望返回二进制字节数组，则调用 response.body().bytes()

 //异步 GET 请求
异步 GET 请求与同步 GET 请求的代码差不多，区别是：
异步方法不需要在子线程中执行，因为 enqueue() 方法内部已经有一个线程池去执行。
返回的数据在 onResponse() 方法中，由于内部是通过线程池去执行的，所以该方法也在子线程。如果需要操作 UI，需要使用 handler 等切换到主线程。
    private void asyncGetRequestByOkHttp() {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url("https://www.baidu.com")
                .build();
        Call call = client.newCall(request);
        //将同步方法 execute() 换成异步方法 enqueue()。
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
            }
//
            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (response.isSuccessful()) {
                    Log.i(TAG, "onResponse data-->" + response.body().string());
                } else {
                    throw new IOException("Unexpected code " + response);
                }
            }
        });
    }

// 异步post请求
POST 请求与 GET 请求的区别是 POST 请求需要构建一个 RequestBody 来存放请求参数，然后在 Request.Builder 中调用 post 方法，并传入 RequestBody 对象
private void asyncPostRequestByOkHttp() {
        OkHttpClient client = new OkHttpClient();
        //构建Requestbody 
        RequestBody formBody = new FormBody.Builder()
                .add("username", "wildma")
                .add("password", "123456")
                .build();
         // 在Request.builder 中 调用post 请求，并传入 RequestBody对象 
        Request request = new Request.Builder()
                .url("https://postman-echo.com/post")
                .post(formBody)
                .build();
        Call call = client.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
            }
            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (response.isSuccessful()) {
                    Log.i(TAG, "onResponse data-->" + response.body().string());
                } else {
                    throw new IOException("Unexpected code " + response);
                }
            }
        });
    }

OkHttp 是一个设计得非常优秀的框架。该框架运用了很多设计模式，例如建造者模式、责任链模式等等。
知道了 OkHttp 的核心是拦截器，这里采用的就是责任链模式，每个拦截器负责相应的功能，发起请求的时候由上往下依次执行每个拦截器，响应的数据则层层往上传递。

https://www.jianshu.com/p/bca742ffdbf6

https://www.jianshu.com/p/7624b45fbdc1

https://www.jianshu.com/p/fa0dcbfe05cd

https://www.jianshu.com/p/2663ce3da0db

【

Android Studio 爬虫 之 简单实现使用 jsoup/okhttp3 爬取购物商品信息的案例demo（附有详细步骤）

】

https://blog.csdn.net/u014361280/article/details/108124146?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_title~default-5.no_search_link&spm=1001.2101.3001.4242.4

https://blog.csdn.net/PenTablet/article/details/78273444?locationNum=2&fps=1

【商场系列】
https://www.cnblogs.com/nylcy/p/6599245.html

【OKhttp简单应用】

——-记得测试手机是否正常联网

https://www.bilibili.com/video/BV1Jb4y187C4?p=69
简单测试网址：
https://www.httpbin.org/#/Status_codes

开启网络权限

依赖：

implementation(“com.squareup.okhttp3:okhttp:4.7.2”)

// MainActivity.java
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.ThemedSpinnerAdapter;
import java.io.IOException;
import okhttp3.Call;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
public class MainActivity extends AppCompatActivity {
    private OkHttpClient okHttpClient;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        okHttpClient = new OkHttpClient();
    }
    public void getSync(View view) {
        // 要在子线程中开启网络请求
        new Thread(){
            @Override
            public void run() {
                Request request = new Request.Builder()
                        .url("https://tianqiapi.com/api?unescape=1&version=v1&appid=71834655&appsecret=DIwH2ihM&city="+"北京")
                        .build();
                Call call = okHttpClient.newCall(request);
                try {
                    Response response=call.execute();
                    Log.e("MainActivity","getSync"+response.body().string());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }
}

//activity_main.xml 
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
    <Button
        android:id="@+id/button0"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:onClick="getSync"
        android:text="get同步请求"
        />
</androidx.constraintlayout.widget.ConstraintLayout>

访问天气API——————-

导入依赖
implementation(“com.squareup.okhttp3:okhttp:4.9.0”)
implementation ‘com.google.code.gson:gson:2.8.5’

// main_activity.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:background="#74B6A7"
    android:gravity="center_horizontal"
    tools:context=".MainActivity">
    <!--单独实现靠左-->
    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content">
        <androidx.appcompat.widget.AppCompatSpinner
            android:id="@+id/sp_city"
            android:layout_width="100dp"
            android:layout_height="48dp"
            android:entries="@array/cities"
            android:spinnerMode="dropdown"
            />
    </RelativeLayout>
    <ImageView
        android:layout_width="65dp"
        android:layout_height="65dp"
        android:id="@+id/iv_weather"
        android:src="@drawable/biz_plugin_weather_yin"/>
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/tv_tem"
        android:textSize="20dp"
        android:text="31"
        android:textColor="@color/white"
        />
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/tv_weather"
        android:textSize="20dp"
        android:text="阴转多云（2021-07-25 星期三）"
        android:textColor="@color/white"
        android:layout_marginTop="10dp"
        />
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/tv_tem_low_high"
        android:textSize="20dp"
        android:text="25°C - 33°C"
        android:textColor="@color/white"
        android:layout_marginTop="10dp"
        />
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/tv_win"
        android:textSize="20dp"
        android:text="南风3-4级"
        android:textColor="@color/white"
        android:layout_marginTop="10dp"
        />
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/tv_air"
        android:textSize="10dp"
        android:text="空气：53 良 \n空气好，适应外出"
        android:gravity="center"
        android:textColor="@color/white"
        android:layout_marginTop="10dp"
        />
    <!--未来天气-->
    <androidx.recyclerview.widget.RecyclerView
        android:layout_marginTop="10dp"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:id="@+id/rlv_future_weather"
        />
</LinearLayout>

// Main_activity.java
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.AppCompatSpinner;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.ImageView;
import android.widget.TextView;
import com.example.weather_study.Adapter.FutureWeatherAdapter;
import com.example.weather_study.bean.DayWeatherBean;
import com.example.weather_study.bean.WeatherBean;
import com.example.weather_study.util.NetUtil;
import com.google.gson.Gson;
import java.util.List;
public class MainActivity extends AppCompatActivity {
    // 1、定义
    private AppCompatSpinner mSpinner;
    // 2、适配器
    private ArrayAdapter<String> mSpAdater;
    //3 、数据资源
    private String[] mCities;
    // 添加组件进来
    private TextView tvWeather,tvTem,tvTemLowHigh,tvWin,tvAir;
    private ImageView ivWeather;
    private RecyclerView rlvFutureWeather;
    private FutureWeatherAdapter mWeatherAdapter;
    // 创建Handler
    private Handler mHandler = new Handler(Looper.myLooper()){
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            if(msg.what==0){
                String weather = (String) msg.obj;
                Log.e("fan","---主线程收到天气数据----weather----"+weather);
                // json解析
                Gson gson = new Gson();
                WeatherBean weatherBean = gson.fromJson(weather,WeatherBean.class);
                Log.e("fan","--解析后的数据----weather----"+weatherBean.toString());
                updateUIOfWeather(weatherBean);
            }
        }
    };
    private void updateUIOfWeather(WeatherBean weatherBean) {
        // 获取数据第一步，应该是判断是否为空
        if(weatherBean==null)   return;
        //获取 天 数据
        List<DayWeatherBean> dayWeathers = weatherBean.getDayWeatherBeanList();
        DayWeatherBean todayWeather = dayWeathers.get(0);
        if(todayWeather==null)  return;
        //把数据展示
        tvTem.setText(todayWeather.getTem());
        tvWeather.setText(todayWeather.getWea()+"("+todayWeather.getDate()+todayWeather.getWeek()+")");
        tvTem.setText(todayWeather.getTem());
        tvWeather.setText(todayWeather.getWea()+"("+todayWeather.getDate()+todayWeather.getWeek()+")");
        tvTemLowHigh.setText(todayWeather.getTem2()+"~"+ todayWeather.getTem1());
        tvWin.setText(todayWeather.getWin()[0]+todayWeather.getWinSpeed());
        tvAir.setText("空气："+todayWeather.getAir()+ todayWeather.getAirLevel()+"\n"+todayWeather.getAirTips());
        //
        ivWeather.setImageResource(getImgResOfWeather(todayWeather.getWea_Img()));
        // 未来天气的展示
        // 先要删除当天的天气
        dayWeathers.remove(0);
        //设置数据适配器，布局方向
        mWeatherAdapter = new FutureWeatherAdapter(this,dayWeathers);
        rlvFutureWeather.setAdapter(mWeatherAdapter);
        LinearLayoutManager linearLayoutManager = new LinearLayoutManager(this,LinearLayoutManager.HORIZONTAL,false);
        rlvFutureWeather.setLayoutManager(linearLayoutManager);
    }
    // 这个API 没有返回图片，只返回了一个 标志位，需要自己将本地图片和标志 一一对应
    private int getImgResOfWeather(String weaStr){
        int result = 0;
        switch (weaStr){
            case "qing":
                result = R.drawable.biz_plugin_weather_qing;
                break;
            case "yin":
                result = R.drawable.biz_plugin_weather_yin;
                break;
            case "yu":
                result = R.drawable.biz_plugin_weather_yu ;
                break;
            case"bingbao":
                result = R.drawable.biz_plugin_weather_bingbao;
                break;
            case "wu":
                result = R.drawable.biz_plugin_weather_wu;
                break;
            case "shachen":
                result =R.drawable.biz_plugin_weather_shachen;
                break;
            case "lei":
                result = R.drawable.biz_plugin_weather_lei;
                break;
            default:
                result=R.drawable.biz_plugin_weather_xue ;
                break;
        }
        return result;
    }
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView(); // 刚开始因为没有用这个方法，吃了好多苦
    }
    private void initView(){
        mSpinner = findViewById(R.id.sp_city);
        mCities = getResources().getStringArray(R.array.cities);// 提前写好的城市名
        mSpAdater = new ArrayAdapter<>(this,R.layout.sp_item_layout,mCities);
        mSpinner.setAdapter(mSpAdater);
        // 点击事件
        mSpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener(){
            @Override
            public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
                String selectedCity = mCities[position];
                getWeatherOfCity(selectedCity); // 调用方法
            }
            @Override
            public void onNothingSelected(AdapterView<?> adapterView) {
            }
        });
        tvWeather =findViewById(R.id.tv_weather);
        tvAir = findViewById(R.id.tv_air);
        tvTem = findViewById(R.id.tv_tem);
        tvTemLowHigh = findViewById(R.id.tv_tem_low_high);
        tvWin = findViewById(R.id.tv_win);
        ivWeather=findViewById(R.id.iv_weather);
        rlvFutureWeather = findViewById(R.id.rlv_future_weather);
    }
    private void getWeatherOfCity(String selectedCity) {
        // 开启子线程，请求网络
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 请求网络
                String weatherOfCity = NetUtil.getWeatherofCity(selectedCity);
                //使用handler 将数据传递给主线程
                Message message = Message.obtain();
                message.what=0;
                message.obj = weatherOfCity;
                mHandler.sendMessage(message);
            }
        }).start();
    }
}

Json 数据解析

//json 数据解析
//DayWeatherBean.java
import com.google.gson.annotations.SerializedName;
import java.util.Arrays;
import java.util.List;
public class DayWeatherBean {
    @SerializedName("day")
    private String day;
    @SerializedName("date")
    private String date;
    @SerializedName("week")
    private String week;
    @SerializedName("wea")
    private String wea;
    @SerializedName("wea_img")
    private String wea_Img;
    @SerializedName("wea_day")
    private String weaDay;
    @SerializedName("tem")
    private String tem;
    @SerializedName("tem1")
    private String tem1;
    @SerializedName("tem2")
    private String tem2;
    @SerializedName("win")
    private String[] win;
    @SerializedName("win_speed")
    private String winSpeed;
    @SerializedName("air")
    private String air;
    @SerializedName("air_level")
    private String airLevel;
    @SerializedName("air_tips")
    private String airTips;
    //
    @SerializedName("index")
    private List<OtherTipsBean> mTipsBeans;
    public List<OtherTipsBean> getmTipsBeans() {
        return mTipsBeans;
    }
    public void setmTipsBeans(List<OtherTipsBean> mTipsBeans) {
        this.mTipsBeans = mTipsBeans;
    }
    public String getDay() {
        return day;
    }
    public void setDay(String day) {
        this.day = day;
    }
    public String getDate() {
        return date;
    }
    public void setDate(String date) {
        this.date = date;
    }
    public String getWeek() {
        return week;
    }
    public void setWeek(String week) {
        this.week = week;
    }
    public String getWea() {
        return wea;
    }
    public void setWea(String wea) {
        this.wea = wea;
    }
    public String getWea_Img() {
        return wea_Img;
    }
    public void setWea_Img(String wea_Img) {
        this.wea_Img = wea_Img;
    }
    public String getWeaDay() {
        return weaDay;
    }
    public void setWeaDay(String weaDay) {
        this.weaDay = weaDay;
    }
    public String getTem() {
        return tem;
    }
    public void setTem(String tem) {
        this.tem = tem;
    }
    public String getTem1() {
        return tem1;
    }
    public void setTem1(String tem1) {
        this.tem1 = tem1;
    }
    public String getTem2() {
        return tem2;
    }
    public void setTem2(String tem2) {
        this.tem2 = tem2;
    }
    public String[] getWin() {
        return win;
    }
    public void setWin(String[] win) {
        this.win = win;
    }
    public String getWinSpeed() {
        return winSpeed;
    }
    public void setWinSpeed(String winSpeed) {
        this.winSpeed = winSpeed;
    }
    public String getAir() {
        return air;
    }
    public void setAir(String air) {
        this.air = air;
    }
    public String getAirLevel() {
        return airLevel;
    }
    public void setAirLevel(String airLevel) {
        this.airLevel = airLevel;
    }
    public String getAirTips() {
        return airTips;
    }
    public void setAirTips(String airTips) {
        this.airTips = airTips;
    }
    @Override
    public String toString() {
        return "DayWeatherBean{" +
                "day='" + day + '\'' +
                ", date='" + date + '\'' +
                ", week='" + week + '\'' +
                ", wea='" + wea + '\'' +
                ", wea_Img='" + wea_Img + '\'' +
                ", weaDay='" + weaDay + '\'' +
                ", tem='" + tem + '\'' +
                ", tem1='" + tem1 + '\'' +
                ", tem2='" + tem2 + '\'' +
                ", win=" + Arrays.toString(win) +
                ", winSpeed='" + winSpeed + '\'' +
                ", air='" + air + '\'' +
                ", airLevel='" + airLevel + '\'' +
                ", airTips='" + airTips + '\'' +
                ", mTipsBeans=" + mTipsBeans +
                '}';
    }
}