生命周期的基本概念：
一、什么是生命周期：
1、生命周期是人家封装好的一套接口，然后提供的回调方法，当发生变化时，我们只需要取实现它。（按通俗的讲，就是回调方法（函数））。
2、让你知道我封装好的这个widget它处于什么样的状态了！
二、那生命周期有什么作用
1、监听Widget的事件
2、初始化数据
（1）、创建数据
（2）、发送网络请求
3、内存管理
（1）、销毁数据、销毁监听者
（2）、销毁Timer等等
接下来我们来看一下Widget的生命周期
首先我们来实现一下无状态的StatelessWidget的生命周期
代码
class MyHomePages extends StatelessWidget{
final String title;
MyHomePages({this.title}){
print("构造函数被调用");
}
@override
Widget build(BuildContext context) {
// TODO: implement build
print("build方法被调用了");
return Center(
child: Text(title),
);
}
}
然后执行程序，打印结果为
flutter: 构造函数被调用
flutter: build方法被调用了
flutter: 构造函数被调用
flutter: build方法被调用了
Application finished.
从上面的结果，可以看到打印了两次，那为什么会打印两次呢？
原因是as的bug，接下来我们用ios模拟器运行一下程序
你会发现它只打印了一次
2020-06-15 23:55:03.352660+0800 Runner[89125:1491460] flutter: 构造函数被调用
2020-06-15 23:55:03.831544+0800 Runner[89125:1491460] flutter: build方法被调用了
所以说这是android stido的bug，这个我们就不去管它了（也可以用终端运行程序，也只是运行一次，这边不再尝试了）。
从执行结果可以看出，在StatelessWidget的生命周期中，会调用一个构造方法和一个build方法。（StatelessWidget没有dispose方法）。
接下来来到有状态的StatefulWidget的生命周期
代码
class MyHomePages extends StatefulWidget{
final String title;
MyHomePages({this.title}){
print('构造函数被调用了!');
}
@override
_MyHomePageState createState() => _MyHomePageState();
}
class _MyHomePageState extends State<MyHomePages>{
int _count = 0;
_MyHomePageState(){
print('State的构造方法');
}
@override
void initState() {
// TODO: implement initState
super.initState();
print('State的init方法');
}
@override
Widget build(BuildContext context) {
// TODO: implement build
print('State的build方法');
return Column(
children: [
RaisedButton(
child: Icon(Icons.add),
onPressed: (){
_count ++;
setState(() {
});
}),
Text('$_count'),
],
);
}
@override
void didChangeDependencies() {
// TODO: implement didChangeDependencies
print('didChangeDependencies');
super.didChangeDependencies();
}
//当State对象从渲染树中移出的时候,就会调用!即将销毁!
@override
void deactivate() {
// TODO: implement deactivate
print('deactivate');
super.deactivate();
}
@override
void dispose() {
// TODO: implement dispose
super.dispose();
print('State的dispose');
}
}
打印结果:
flutter: 构造函数被调用了!
flutter: State的构造方法
flutter: State的init方法
flutter: didChangeDependencies
flutter: State的build方法
省略了as重复的调用
从上面的执行结果，我们可以看出，首先调用的是StatefulWidget的构造方法，然后通过createState调用State的构造方法；
顺序依次为:Widget的构造方法->Widget的createState方法->State的构造方法->State的initState方法->didChangeDependencies方法（改变依赖关系）->State的build方法->Widget销毁方法dispose。
而当我们点击按钮时，你会发现，程序只调用了State的build方法，因为在StatefulWidget中，状态管理都用通过setState重新渲染的，那么我们可以查看setState的源代码
上图中有很多断言，是用来筛选判断用的
我们看到_element.markNeedsBuild();这一行代码主要工作原理是通过标记需要重新构建的代码。那么element用来做什么的，在后面会详细介绍。
由此可以得出，这是一个增量渲染，widget的Render Tree会将旧数据与新数据进行比较，当数据发生变化时，会对更新的一部分进行重新渲染，未更新的就会不对它进行变化。那么element是做什么用的呢？我们点进去element的源码（BuildContext get context => _element;），可以看出，这个element就是一个context。
那么，我们如何去证明这个呢？
我们在build的方法里创建一个element变量
StatefulElement element = context;
将setState方法换成
element.markNeedsBuild();
得到的结果与用setState方法调用顺序一样。
flutter: 构造函数被调用了!
flutter: State的构造方法
flutter: State的init方法
flutter: didChangeDependencies
flutter: State的build方法
flutter: 构造函数被调用了!
flutter: State的build方法
flutter: State的build方法
flutter: State的build方法
flutter: State的build方法
但是呢，我们并不会这样用，因为这样不安全，只是告诉你们可以这样用。用setState会更安全。
当我们点击了按钮，count值发生了变化，可以看到State的build被调用了，因此可以得到结论，当setState方法被调用，build方法会重新渲染。
从上面的程序可以得到deactivate方法并没有调用，那是因为这个方法是当State对象从渲染树中移出的时候,就会调用!即将销毁!
这个方法你们可以用push去尝试一下，这边不再尝试。
这边来详细讲述一下didChangeDependencies这个方法。
在介绍之前，我们先总结一下StatelessWidget的生命周期：
Stateless:
1、构造方法
2、build方法
Stateful：
1、widget构造方法
2、widget的createState
3、state的构造方法
4、State的initState方法
5、didChangeDependencies方法（改变依赖关系，依赖的InheritedWidget发生变化之后，方法也会调用）
6、State的build（当调用setState方法，会重新调用build进行渲染）
7、当widget销毁的时候，调用State的dispose
在我们开发当中，如果需要层层传递参数时，我们通常会怎么去写，是每个类里面都创建一个参数，然后层层传递吗？这个方法是很麻烦的，那么我们就要用到一个InheritedWidget类来实现共享数据。
代码
class MyData extends InheritedWidget{
MyData({this.data,Widget child}) : super(child:child);
final int data;//需要在子Widget中共享数据！
//提供一个方法让子Widget访问共享数据
static MyData of(BuildContext context){
return context.dependOnInheritedWidgetOfExactType<MyData>();
}
更新通知，可以判断数据是否发生变化，如果发生变化，就更新数据
@override
bool updateShouldNotify(MyData oldWidget) {
// TODO: implement updateShouldNotify
return oldWidget.data != data;
}
}
class InheritedDemo extends StatefulWidget{
@override
_InheritedDemoState createState() => _InheritedDemoState();
}
class _InheritedDemoState extends State<InheritedDemo>{
int count = 1;
@override
Widget build(BuildContext context) {
// TODO: implement build
return MyData(
data: count,
child: Column(
children: [
Test1(),
RaisedButton(
child: Text('我是按钮'),
onPressed: () => setState((){
count++;
}),
),
],
),
);
}
}
中间省略部分嵌套代码
class Test3 extends StatefulWidget{
// final count;
// Test3(this.count);
@override
_Test3State createState() => _Test3State();
}
class _Test3State extends State<Test3>{
@override
Widget build(BuildContext context) {
// TODO: implement build
return Text(MyData.of(context).data.toString());
}
@override
void didChangeDependencies() {
// TODO: implement didChangeDependencies
print('didChangeDependencies');
super.didChangeDependencies();
}
}
当我们创建了一个MyData类继承InheritedWidget时，我们就可以在需要用到这个数据的类中使用这个数据，以此来实现数据的共享。这样就不需要通过层层嵌套去实现数据的传输。当我们点击按钮时，didChangeDependencies这个方法会调用。
那么会有疑问，MyData每次都是递增的，这个数值是怎么保持的？
注意：Widget是没有递增的，而渲染是递增渲染的，递增改变是值数据发生变化，渲染只渲染发生变化的一部分，但是widget是全部重新创建的一个对象，这个widget可以看成渲染界面的描述。
Widget渲染原理
下图是一个Widget树。
Widget是一个很不稳定的，一但重新build，就会重新渲染，这个是非常影响性能的。那么，Widget如何知道哪些数据是要重新渲染，而那些是不需要重新渲染的呢？
下面我们就介绍一下Render Tree。这歌Render是一个RenderObject，并不是所有widget都会变成RenderObject。
我们结合源码来看：
StatelessWidget和StatefulWidget都是继承自Widget，所以说像StatelessWidget，StatefulWidget是不会创建RenderObject。
因此可以得出结论，只有继承RenderObject的类才能创建RenderObject并加入到RenderObject树，例如Row，Column都是继承RenderObjectWidget，而我们点进去看RenderObjectWidget也是继承至widget。
部分Flex源代码下有一个createRenderObject对象
@override
RenderFlex createRenderObject(BuildContext context) {
return RenderFlex(
direction: direction,
mainAxisAlignment: mainAxisAlignment,
mainAxisSize: mainAxisSize,
crossAxisAlignment: crossAxisAlignment,
textDirection: getEffectiveTextDirection(context),
verticalDirection: verticalDirection,
textBaseline: textBaseline,
);
}
点击RenderFlex对象，RenderFlex又继承至RenderBox，点击RenderBox，又继承于RenderObject，所以说这是一个子类对象。
class RenderFlex extends RenderBox with ContainerRenderObjectMixin<RenderBox, FlexParentData>,
RenderBoxContainerDefaultsMixin<RenderBox, FlexParentData>,
DebugOverflowIndicatorMixin {
/// Creates a flex render object.
///
/// By default, the flex layout is horizontal and children are aligned to the
/// start of the main axis and the center of the cross axis.
RenderFlex({
List<RenderBox> children,
Axis direction = Axis.horizontal,
MainAxisSize mainAxisSize = MainAxisSize.max,
MainAxisAlignment mainAxisAlignment = MainAxisAlignment.start,
CrossAxisAlignment crossAxisAlignment = CrossAxisAlignment.center,
TextDirection textDirection,
VerticalDirection verticalDirection = VerticalDirection.down,
TextBaseline textBaseline,
}) : assert(direction != null),
assert(mainAxisAlignment != null),
assert(mainAxisSize != null),
assert(crossAxisAlignment != null),
_direction = direction,
_mainAxisAlignment = mainAxisAlignment,
_mainAxisSize = mainAxisSize,
_crossAxisAlignment = crossAxisAlignment,
_textDirection = textDirection,
_verticalDirection = verticalDirection,
_textBaseline = textBaseline {
addAll(children);
}
通过上面的源码，可以得到并不是所有的widget都会被独立渲染，只有继承RenderObjectWidget才会创建RenderObject对象。
而我们去查看RenderObjectWidget源码，会调用两个方法，一个是createElement(),一个是createRenderObject(BuildContext context),而createElement是一个十分重要的方法。
源码部分我就不展示了，直接上结论！
在flutter渲染流程中，有三颗重要的树，flutter是针对Render树进行渲染！
Widget树，Element树，Render树
一、每一个Widget都会创建一个Element对象
1、隐式的调用createElement方法，Element加入Element树种（它会创建三种Element）
二、RenderElement主要创建RenderOnject对象（继承RenderObjectWidget的Widget会创建RenderElement）
1、创建RenderElement
2、flutter会调用mount方法，调用createRenderObject方法
三、StatefulElement继承ComponentElement（StatefulWidget会创建StatefulElement）
1、调用createState，创建state
2、将widget赋值给state
3、调用State的build方法并且将自己的（element）传出去（build里面的context就是Widget的element！）
四、StatelessElement继承ComponentElement（StatelessWidget会创建StatelessElement）
1、主要就是调用build方法，并且将自己（element）传出去。
感谢大家观看，小白一个，欢迎大神纠错！
