Android ObjectAnimator类：手把手带你自定义属性动画

太过爱你忘了你带给我的痛 2021-10-30 00:54 585阅读 0赞

![a26aedafc2ac45510787091b1d02f019.png][]

--------------------

# 前言 #

*  属性动画的使用 是 `Android` 开发中常用的知识
 *  今天，我将讲解属性动画使用中最核心的一个方法类：`ObjectAnimator`，希望你们会喜欢。

> Carson带你学`Android`动画系列文章：  
> [Carson带你学Android：一份全面&详细的动画知识学习攻略][Carson_Android]  
> [Carson带你学Android：常见的三种动画类型][Carson_Android 1]  
> [Carson带你学Android：补间动画学习教程][Carson_Android 2]  
> [Carson带你学Android：属性动画学习教程][Carson_Android 3]  
> [Carson带你学Android：逐帧动画学习教程][Carson_Android 4]  
> [Carson带你学Android：自定义动画神器-插值器与估值器(含实例教学)][Carson_Android_-]

--------------------

# 目录 #

![示意图][c3e3ac051ce2eb4103dbf7d8e003364e.png]

--------------------

# 储备知识 #

阅读本文前，请先阅读文章：[Carson带你学Android：属性动画学习教程][Carson_Android 3]

--------------------

# 1. 简介 #

*  实现属性动画中的一个核心方法类
 *  继承自ValueAnimator类，即底层的动画实现机制是基于ValueAnimator类

--------------------

# 2. 实现动画的原理 #

直接对对象的属性值进行改变操作，从而实现动画效果

> 如直接改变 `View`的 `alpha` 属性 从而实现透明度的动画效果

--------------------

# 3. 本质原理 #

通过不断控制 值 的变化，再不断 **自动** 赋给对象的属性，从而实现动画效果。如下图：

![示意图][43c4e6327161698f850bf4907bd318e3.png]

从上面的工作原理可以看出：`ObjectAnimator`与 `ValueAnimator`类的区别：

*  `ValueAnimator` 类是先改变值，然后 **手动赋值** 给对象的属性从而实现动画；是 **间接** 对对象属性进行操作；具体请看文章：[Android：这份Android核心使用类ValueAnimator学习指南请收好！][Android_Android_ValueAnimator]
 *  `ObjectAnimator` 类是先改变值，然后 **自动赋值** 给对象的属性从而实现动画；是 **直接** 对对象属性进行操作；

> 至于是如何自动赋值给对象的属性，下面会详细说明

--------------------

# 4. 基础使用 #

### 4.1 使用步骤 ###

由于是继承了ValueAnimator类，所以使用的方法十分类似：`XML` 设置 / `Java`设置

/*
     * 设置方式1：Java
     */
     // 步骤1：创建ObjectAnimator对象
         ObjectAnimator animator = ObjectAnimator.ofFloat(Object object, String property, float ....values);  
        // 作用：
        // 1. 创建动画实例
        // 2. 参数设置：
        // Object object：需要操作的对象
        // String property：需要操作的对象的属性
        // float ....values：动画初始值 & 结束值（不固定长度）
        // 若是两个参数a,b，则动画效果则是从属性的a值到b值
        // 若是三个参数a,b,c，则则动画效果则是从属性的a值到b值再到c值
        // 以此类推
        // 至于如何从初始值过渡到结束值，同样是由估值器决定，此处ObjectAnimator.ofFloat()是有系统内置的浮点型估值器FloatEvaluator，同ValueAnimator讲解
    
    // 步骤2：设置动画属性
        // 设置动画运行的时长
        anim.setDuration(500);
        
        // 设置动画延迟播放时间
        anim.setStartDelay(500);
        
        // 设置动画重复播放次数 = 重放次数+1
        // 动画播放次数 = infinite时,动画无限重复
        anim.setRepeatCount(0);
        
        // 设置重复播放动画模式
        anim.setRepeatMode(ValueAnimator.RESTART);
        // ValueAnimator.RESTART(默认):正序重放
        // ValueAnimator.REVERSE:倒序回放
    
    // 步骤3：启动动画
    animator.start();  
    
    /*
     * 设置方式2：xml
     */
     // 步骤1：在路径 res/animator 的文件夹里创建动画效果.xml文件
     // set_animation.xml
    
     // 步骤2：设置动画参数
     // ObjectAnimator 采用<animator>  标签
        <objectAnimator xmlns:android="http://schemas.android.com/apk/res/android"  
            android:valueFrom="1"   // 初始值
            android:valueTo="0"  // 结束值
            android:valueType="floatType"  // 变化值类型 ：floatType & intType
            android:propertyName="alpha" // 对象变化的属性名称
        /> 
    
    // 步骤3：启动动画
        // 1. 载入XML动画
        Animator animator = AnimatorInflater.loadAnimator(context, R.animator.view_animation);  
        // 2. 设置动画对象
        animator.setTarget(view);  
        // 3. 启动动画
        animator.start();

### 4.2 使用实例 ###

此处先展示四种基本变换：平移、旋转、缩放 & 透明度

#### 平移 ####

// 1. 创建动画作用对象：此处以Button为例
    Button mButton = (Button) findViewById(R.id.Button);
    
    // 2. 获得当前按钮的位置
    float curTranslationX = mButton.getTranslationX();
    
    // 3. 创建动画对象
    ObjectAnimator animator = ObjectAnimator.ofFloat(mButton, "translationX", curTranslationX, 300,curTranslationX);
    
    // 表示的是:
    // 动画作用对象是mButton
    // 动画作用的对象的属性是X轴平移（在Y轴上平移同理，采用属性"translationY"
    // 动画效果是:从当前位置平移到 x=1500 再平移到初始位置
    
    // 4. 设置动画时长
    animator.setDuration(5000);
    
    // 5. 启动动画
    animator.start();

![属性动画 - X轴平移.gif][- X_.gif]

#### 旋转 ####

// 1. 创建动画作用对象：此处以Button为例
    Button mButton = (Button) findViewById(R.id.Button);
    
    // 2. 创建动画对象
    ObjectAnimator animator = ObjectAnimator.ofFloat(mButton, "rotation", 0f, 360f);
    // 表示的是:
    // 动画作用对象是mButton
    // 动画作用的对象的属性是旋转alpha
    // 动画效果是:0度-360度
    
    // 3. 设置动画时长
    animator.setDuration(5000);
    
    // 4. 启动动画
    animator.start();

![属性动画- 旋转.gif][- _.gif]

#### 缩放 ####

// 1. 创建动画作用对象：此处以Button为例
    Button mButton = (Button) findViewById(R.id.Button);
    
    // 2. 创建动画对象
    ObjectAnimator animator = ObjectAnimator.ofFloat(mButton, "scaleX", 1f, 3f, 1f);
    // 表示的是:
    // 动画作用对象是mButton
    // 动画作用的对象的属性是X轴缩放
    // 动画效果是:放大到3倍,再缩小到初始大小
    
    // 3. 设置动画时长
    animator.setDuration(5000);
    
    // 4. 启动动画
    animator.start();

![属性动画 - 缩放.gif][- _.gif 1]

#### 透明度 ####

// 1. 创建动画作用对象：此处以Button为例
    Button mButton = (Button) findViewById(R.id.Button);
    
    // 2. 创建动画对象
    ObjectAnimator animator = ObjectAnimator.ofFloat(mButton, "alpha", 1f, 0f, 1f);
    // 表示的是:
    // 动画作用对象是mButton
    // 动画作用的对象的属性是透明度alpha
    // 动画效果是:常规 - 全透明 - 常规
    
    // 3. 设置动画时长
    animator.setDuration(5000);
    
    // 4. 启动动画
    animator.start();

![属性动画 - 透明度.gif][- _.gif 2]

--------------------

# 4. 通过自定义对象属性实现动画效果 #

在上面的基础使用中，我们对于ObjectAnimator.ofFloat()的第二个参数传入了：alpha、rotation、translationX 和 scaleY等对象的属性值，从而实现了平移、旋转、缩放、透明度的动画。

实际上，这个参数是可以传入对象的**任意属性值**的，因为ObjectAnimator类实现动画效果的本质是：**通过不断控制值的变化，再不断自动赋值给对象的属性。**

![工作原理][bc07644f60c44548c1d61aa2b2cd9a7f.png]

而 **自动赋给对象的属性的本质是调用该对象属性的set() 、get()方法进行赋值**。所以，`ObjectAnimator.ofFloat(Object object, String property, float ....values)`的第二个参数传入值的作用是：**让`ObjectAnimator`类根据传入的属性名去寻找该对象对应属性名的 set() 、get()方法，从而进行对象属性值的赋值**。如上面的例子：

ObjectAnimator animator = ObjectAnimator.ofFloat(mButton, "rotation", 0f, 360f);
    // 其实Button对象中并没有rotation这个属性值
    // ObjectAnimator并不是直接对我们传入的属性名进行操作
    // 而是根据传入的属性值"rotation" 去寻找对象对应属性名对应的get和set方法，从而通过set()、get()对属性进行赋值
    
    // 因为Button对象中有rotation属性所对应的get & set方法
    // 所以传入的rotation属性是有效的
    // 所以才能对rotation这个属性进行操作赋值
    public void setRotation(float value);  
    public float getRotation();  
    
    // 实际上，这两个方法是由View对象提供的，所以任何继承自View的对象都具备这个属性

### 4.1 原理解析 ###

至于是如何进行自动赋值，直接看源码分析：从启动动画的animator.start()方法开始。

@Override  
    public void start() {  
        AnimationHandler handler = sAnimationHandler.get();  
    
        ...
        
        super.start();  
       // 调用父类的start()
       // 因为ObjectAnimator类继承ValueAnimator类，所以调用的是ValueAnimator的star()
       // 经过层层调用，最终会调用到 自动赋值给对象属性值的方法 ->关注1
    }  
    
    /*
     * 关注1：自动赋值给对象属性值的逻辑方法
     */
    // 步骤1：初始化动画值
    private void setupValue(Object target, Keyframe kf) {  
        if (mProperty != null) {  
            kf.setValue(mProperty.get(target));  
            // 初始化时，如果属性的初始值没有提供，则调用属性的get()进行取值
        }  
            kf.setValue(mGetter.invoke(target));   
        }  
    }  
    
    // 步骤2：更新动画值
    // 当动画下一帧来时（即动画更新的时候），setAnimatedValue()都会被调用
    void setAnimatedValue(Object target) {  
        if (mProperty != null) {  
            mProperty.set(target, getAnimatedValue());  
            // 内部调用对象该属性的set()，从而将新的属性值设置给对象属性
        }   
    }

从上面的源码分析可以看出自动赋值的逻辑是：

*  初始化时，若属性的初始值没有提供，则调用属性的 `get()`进行取值；
 *  当值变化时，会调用对象该属性的 `set()`方法，从而将新的属性值设置给对象属性。

所以：

*  `ObjectAnimator` 类针对的是**任意对象 & 任意属性值**，并不是单单针对于View对象
 *  如果需要采用`ObjectAnimator` 类实现动画效果，那么需要操作的对象就必须有该属性的set()、get()
 *  同理，针对上述另外的四种基本动画效果，`View` 也存在着对应的set()、get()方法，如旋转属性的`setRotation()`、`getRotation()`、平移属性的`setTranslationX()`、`getTranslationX()`、缩放属性的`setScaleY()`、`getScaleY()`

--------------------

### 4.2 具体使用 ###

对于属性动画，其拓展性在于：不局限于系统限定的动画且可以自定义动画(即自定义对象的属性)，并通过操作自定义的属性从而实现各种复杂多样的动画效果。

那么，该如何自定义属性呢？本质上分为两个步骤：

1.  为对象设置需要操作属性的set()、get()方法；
2.  通过自定义估值器(实现TypeEvaluator类接口）从而定义属性变化的逻辑。

在属性值变化的时候，会自动调用属性的set()、get()方法进行赋值，从而实现动画效果。

### 4.3 实例讲解 ###

下面，我将用一个实例来说明如何通过自定义属性实现动画效果：一个圆的颜色渐变，即此处要变化、操作的对象属性值是圆的背景颜色

![属性动画 - 颜色变化][-]

*  自定义属性的逻辑如下：（需要自定义属性为圆的背景颜色）

![自定义属性的逻辑][717ef7077c0ec0c5b8a03f154925edb9.png]

\#步骤1：设置对象类属性的set() 、get()  
即此处要变化、操作的对象属性值是圆的背景颜色。共有两种方法：

*  直接法：通过继承原始类，直接给类加上该属性的get()、set()方法；
 *  间接法：通过包装原始动画对象，间接给对象加上该属性的get()、set()方法。即用一个类来包装原始对象。

此处主要使用第一种方式进行展示。

// MyView2.java
    public class MyView2 extends View {
        public static final float RADIUS = 100f;// 圆的半径 = 100
        
         // 画笔相关
        private Paint mPaint;
    
        // 初始化画笔
        public MyView2(Context context, AttributeSet attrs) {
            super(context, attrs);
            mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
            mPaint.setColor(Color.BLUE);
        }
    
        // 背景颜色属性
        private String color;
    
        // 设置背景颜色的get()方法
        public String getColor() {
            return color;
        }
    
        // 设置背景颜色的set()方法
        public void setColor(String color) {
            this.color = color;
    
            // 将画笔的颜色设置成可传入颜色的参数
            mPaint.setColor(Color.parseColor(color));
            
            // 调用了invalidate(),即画笔颜色每次改变都会刷新视图，然后调用onDraw()方法重新绘制圆
            // 而因为每次调用onDraw()方法时画笔的颜色都会改变,所以圆的颜色也会改变，从而实现动画效果
            invalidate();
        }
    
        // 复写onDraw()从而实现绘制逻辑
        // 绘制逻辑:先在初始点画圆,通过监听当前坐标值(currentPoint)的变化,每次变化都调用onDraw()重新绘制圆,从而实现圆的平移动画效果
        @Override
        protected void onDraw(Canvas canvas) {
            canvas.drawCircle(500, 500, RADIUS, mPaint);
        }
     
    }

\#步骤2：在布局文件加入自定义View控件

*activity\_main.xml*

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        tools:context="scut.carson_ho.valueanimator_ofobject.MainActivity">
    
        <scut.carson_ho.valueanimator_ofobject.MyView2
            android:id="@+id/MyView2"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
             />
    </RelativeLayout>

# 步骤3：自定义估值器 #

即通过实现TypeEvaluator类接口从而定义属性变化的逻辑。此处要定义的是：实现颜色过渡的逻辑。

// ColorEvaluator.java
    
    public class ColorEvaluator implements TypeEvaluator {
        // 实现TypeEvaluator接口
    
        private int mCurrentRed;
        private int mCurrentGreen ;
        private int mCurrentBlue ;
    
        // 复写evaluate（）
        // 作用：写入对象动画过渡的逻辑，此处是写颜色过渡的逻辑
        @Override
        public Object evaluate(float fraction, Object startValue, Object endValue) {
    
            // 获取到颜色的初始值和结束值
            String startColor = (String) startValue;
            String endColor = (String) endValue;
    
            // 通过字符串截取的方式将初始化颜色分为RGB三个部分，并将RGB的值转换成十进制数字
            // 那么每个颜色的取值范围就是0-255
            int startRed = Integer.parseInt(startColor.substring(1, 3), 16);
            int startGreen = Integer.parseInt(startColor.substring(3, 5), 16);
            int startBlue = Integer.parseInt(startColor.substring(5, 7), 16);
    
            int endRed = Integer.parseInt(endColor.substring(1, 3), 16);
            int endGreen = Integer.parseInt(endColor.substring(3, 5), 16);
            int endBlue = Integer.parseInt(endColor.substring(5, 7), 16);
    
            // 将初始化颜色的值定义为当前需要操作的颜色值
            mCurrentRed = startRed;
            mCurrentGreen = startGreen;
            mCurrentBlue = startBlue;
    
            // 计算初始颜色和结束颜色之间的差值
            // 该差值决定着颜色变化的快慢:初始颜色值和结束颜色值很相近，那么颜色变化就会比较缓慢;否则,变化则很快
            // 具体如何根据差值来决定颜色变化快慢的逻辑写在getCurrentColor()里.
            int redDiff = Math.abs(startRed - endRed);
            int greenDiff = Math.abs(startGreen - endGreen);
            int blueDiff = Math.abs(startBlue - endBlue);
            int colorDiff = redDiff + greenDiff + blueDiff;
    
            if (mCurrentRed != endRed) {
                mCurrentRed = getCurrentColor(startRed, endRed, colorDiff, 0,
                        fraction);
                        // getCurrentColor()决定如何根据差值来决定颜色变化的快慢 ->>关注1
            } else if (mCurrentGreen != endGreen) {
                mCurrentGreen = getCurrentColor(startGreen, endGreen, colorDiff,
                        redDiff, fraction);
            } else if (mCurrentBlue != endBlue) {
                mCurrentBlue = getCurrentColor(startBlue, endBlue, colorDiff,
                        redDiff + greenDiff, fraction);
            }
    
            // 将计算出的当前颜色的值组装返回
            String currentColor = "#" + getHexString(mCurrentRed)
                    + getHexString(mCurrentGreen) + getHexString(mCurrentBlue);
    
            // 由于我们计算出的颜色是十进制数字，所以需要转换成十六进制字符串:调用getHexString()->>关注2
            // 最终将RGB颜色拼装起来,并作为最终的结果返回
            return currentColor;
        }
    
    
        // 关注1:getCurrentColor()
        // 具体是根据fraction值来计算当前的颜色。
        private int getCurrentColor(int startColor, int endColor, int colorDiff,
                                    int offset, float fraction) {
            int currentColor;
            if (startColor > endColor) {
                currentColor = (int) (startColor - (fraction * colorDiff - offset));
                if (currentColor < endColor) {
                    currentColor = endColor;
                }
            } else {
                currentColor = (int) (startColor + (fraction * colorDiff - offset));
                if (currentColor > endColor) {
                    currentColor = endColor;
                }
            }
            return currentColor;
        }
    
        // 关注2:将10进制颜色值转换成16进制。
        private String getHexString(int value) {
            String hexString = Integer.toHexString(value);
            if (hexString.length() == 1) {
                hexString = "0" + hexString;
            }
            return hexString;
        }
    }

\#步骤4：启动动画

// MainActivity.java
    public class MainActivity extends AppCompatActivity {
    
        MyView2 myView2; // 自定义的view
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            // 1. 设置自定义View对象
            // 传入背景颜色属性值 & 颜色估值器
            myView2 = (MyView2) findViewById(R.id.MyView2);
            ObjectAnimator anim = ObjectAnimator.ofObject(myView2, "color", new ColorEvaluator(),
                    "#0000FF", "#FF0000");
            
            // 本质逻辑：
            // 步骤1：根据颜色估值器不断 改变 值 
            // 步骤2：调用set()设置背景颜色的属性值（实际上是通过画笔进行颜色设置）
            // 步骤3：调用invalidate()刷新视图，即调用onDraw()重新绘制，从而实现动画效果
    
            // 2. 设置动画时长
            anim.setDuration(8000);
    
            // 3. 启动动画
            anim.start();
        }
    }

### 效果图 ###

![属性动画 - 颜色变化][-]

# 源码地址 #

[Carson\_Ho的Github地址][Carson_Ho_Github]

--------------------

# 5. 特别说明 #

对于手动设置对象类属性的 set()、get()

对于该对象本身无这个属性时，一般是采用使用第一种方式，即上述实例说明。那么什么情况下会使用第二种方式，即间接法呢？

答案：**当该属性存在set()方法但该set()方法无法带来预期的UI变化时。**

### 5.1 示例说明 ###

*  由于`View`的`setWidth()`并不是设置`View`的宽度，而是设置`View`的最大宽度和最小宽度的；
 *  所以通过`setWidth()`无法改变控件的宽度；
 *  即对`View`视图的`width`做属性动画没有效果

具体请看下面按钮的例子，设置后该按钮不会有任何动画效果变化。

// 创建动画作用对象：此处以Button为例
    // 此Button的宽高设置具体为具体宽度200px
    Button mButton = (Button) findViewById(R.id.Button);
    
    // 对该button设置宽度变化
    ObjectAnimator.ofInt(mButton, "width", 500).setDuration(5000).start();

因为button的setWidth()是用于设置最大、最小宽度的，而不是设置即时宽度的。

![效果图：不会有动画效果][9dfa945876f52983e11f935a7ffb9590.gif]

public void setWidth(int pixels) {  
        mMaxWidth = mMinWidth = pixels;  
        mMaxWidthMode = mMinWidthMode = PIXELS;  
        // 因为setWidth（）并不是设置View的宽度，而是设置Button的最大宽度和最小宽度的
        // 所以通过setWidth（）无法改变控件的宽度
       // 所以对width属性做属性动画没有效果
      
        requestLayout();  
        invalidate();  
    }  
    
    // 但getWidth的确是获取View的宽度
    @ViewDebug.ExportedProperty(category = "layout")  
    public final int getWidth() {  
        return mRight - mLeft;  
    }

### 5.2 解决方案 ###

通过包装原始动画对象，间接给对象加上该属性的get()、set()方法。即用一个类来包装原始对象。

> 本质上是采用了设计模式中的装饰模式，即通过包装类从而扩展对象的功能

// MainActivity.java
    public class MainActivity extends AppCompatActivity {
    
        Button mButton;
        ViewWrapper wrapper;
    
        // 1. 提供ViewWrapper类,用于包装View对象
        // 本例:包装Button对象
        private static class ViewWrapper {
            private View mTarget;
    
            // 构造方法:传入需要包装的对象
            public ViewWrapper(View target) {
                mTarget = target;
            }
    
            // 为view的宽度设置get()、set()
            public int getWidth() {
                return mTarget.getLayoutParams().width;
            }
    
            public void setWidth(int width) {
                mTarget.getLayoutParams().width = width;
                mTarget.requestLayout();
            }
        }
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            // 2. 创建动画作用对象
            // 以以Button为例
            mButton = (Button) findViewById(R.id.Button);
        
            // 3. 创建包装类,并传入动画作用的对象
            wrapper = new ViewWrapper(mButton);
            
            // 4. 点击时设置动画的对象是包装类的对象
            mButton.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    ObjectAnimator.ofInt(wrapper, "width", 500).setDuration(3000).start();
                }
            });
        }  
    }

## 效果图 ##

![效果图 - 动画有效][- 1]

--------------------

# 6. 与`ValueAnimator`类对比 #

对比于属性动画中另外一个比较核心的使用类：`ValueAnimator`类：

### 6.1 相同点 ###

其二者的本质都是相同：不断改变值，然后不断赋值给对象的属性从而实现动画效果

### 6.2 区别 ###

二者的区别在于：赋值给对象属性的操作是直接还是间接的。

*  ValueAnimator类：不断改变值，然后手动赋值给对象的属性从而实现动画效果，是间接对对象属性进行操作；
 *  ObjectAnimator类：不断改变值，然后自动赋值给对象的属性从而实现动画效果，是直接对对象属性进行操作；

可以理解为：ObjectAnimator类的使用更加智能、自动化程度更高。

至此，关于属性动画中的核心使用类`ObjectAnimator`讲解完毕

--------------------

# 7. 总结 #

*  本文对`Android` 属性动画中的最核心的 `ObjectAnimator`类进行全面 & 详细介绍。
 *  Carson带你学`Android`动画系列文章：  
    [Carson带你学Android：一份全面&详细的动画知识学习攻略][Carson_Android]  
    [Carson带你学Android：常见的三种动画类型][Carson_Android 1]  
    [Carson带你学Android：补间动画学习教程][Carson_Android 2]  
    [Carson带你学Android：属性动画学习教程][Carson_Android 3]  
    [Carson带你学Android：逐帧动画学习教程][Carson_Android 4]  
    [Carson带你学Android：自定义动画神器-插值器与估值器(含实例教学)][Carson_Android_-]

--------------------

# 欢迎关注Carson\_Ho的[CSDN博客][CSDN] 与 公众号！ #

博客链接：https://carsonho.blog.csdn.net/  
![06b2ed0fbb8979f0aba34c14ede04b59.png][]

--------------------

# 请点赞！因为你的鼓励是我写作的最大动力！ #

[a26aedafc2ac45510787091b1d02f019.png]: /images/20211029/b8cf83464a4148ff9ef8b20685d87635.png
[Carson_Android]: https://carsonho.blog.csdn.net/article/details/79860980
[Carson_Android 1]: https://carsonho.blog.csdn.net/article/details/120486151
[Carson_Android 2]: https://carsonho.blog.csdn.net/article/details/72827747
[Carson_Android 3]: https://carsonho.blog.csdn.net/article/details/72909894
[Carson_Android 4]: https://carsonho.blog.csdn.net/article/details/73087488
[Carson_Android_-]: https://carsonho.blog.csdn.net/article/details/72863901
[c3e3ac051ce2eb4103dbf7d8e003364e.png]: /images/20211029/ccdfe458f8ec463190419a88fb392cec.png
[43c4e6327161698f850bf4907bd318e3.png]: /images/20211029/c9f32e2aadbf4820bf4784d76cf43b14.png
[Android_Android_ValueAnimator]: https://carsonho.blog.csdn.net/article/details/99619871
[- X_.gif]: /images/20211029/11968880b23e40f7b3c2a2981623631f.png
[- _.gif]: /images/20211029/8ffdbf7062f347b4b7eb8df50f60dd70.png
[- _.gif 1]: /images/20211029/ac8a97bfdee14b7a9c76c2f26a1440c1.png
[- _.gif 2]: /images/20211029/3b0909ce95544e568675b703f9a1d270.png
[bc07644f60c44548c1d61aa2b2cd9a7f.png]: /images/20211029/6b98d9f7209a4e1dbbae523b55942607.png
[-]: /images/20211029/b4b2b9ec73b9408e91ac126ababdb71c.png
[717ef7077c0ec0c5b8a03f154925edb9.png]: /images/20211029/0edc6c03ab264e418e73c7ef4ec6fc76.png
[Carson_Ho_Github]: https://github.com/Carson-Ho/PropertyAnimator_ofObject
[9dfa945876f52983e11f935a7ffb9590.gif]: /images/20211029/13d28ee0b857412ca0d2a56e7a3603b3.png
[- 1]: /images/20211029/85586514505849d392ab69ce59dc368b.png
[CSDN]: https://carsonho.blog.csdn.net/
[06b2ed0fbb8979f0aba34c14ede04b59.png]: /images/20211029/6f97f632efb547e58b6fc27bb9c38d6d.png