前言

• 屬性動畫的使用 是 Android 開發中常用的知識
• 今天，我將講解屬性動畫使用中最核心的一個方法類：ValueAnimator，希望你們會喜歡

Carson帶你學Android動畫系列文章：
Carson帶你學Android：一份全面&詳細的動畫知識學習攻略
Carson帶你學Android：常見的三種動畫類型
Carson帶你學Android：補間動畫學習教程
Carson帶你學Android：屬性動畫學習教程
Carson帶你學Android：逐幀動畫學習教程
Carson帶你學Android：自定義動畫神器-估值器(含實例教學)
Carson帶你學Android：自定義動畫神器-插值器(含實例教學)

目錄

示意圖

1. 簡介

屬性動畫機制中 最核心的一個類

2. 原理

• 通過不斷控制 值 的變化，再不斷 手動 賦給對象的屬性，從而實現動畫效果。
• 具體如圖下：

示意圖

從上面原理可以看出：ValueAnimator類中有3個重要方法：

1. ValueAnimator.ofInt（int values）
2. ValueAnimator.ofFloat（float values）
3. ValueAnimator.ofObject（int values）

下面我將逐一介紹。

3. 整型：ValueAnimator.ofInt（）

3.1 作用

將初始值 以整型數值的形式 過渡到結束值

即估值器是整型估值器 - IntEvaluator

3.2 工作原理

示意圖

3.3 具體使用

• 因為ValueAnimator本質只是一種值的操作機制，所以下面的介紹先是展示如何改變一個值的過程（下面的實例主要講解：如何將一個值從0平滑地過渡到3）
• 至于如何實現動畫，是需要開發者手動將這些 值 賦給 對象的屬性值。關于這部分在下節會進行說明。

操作值的方式 分為 XML 設置 / Java 代碼設置，具體如下：

/*
 * 設置方式1：xml
 */
// 步驟1：在路徑 res/animator的文件夾里創建相應的動畫 .xml文件 - set_animation.xml

// 步驟2：設置動畫參數
// ValueAnimator采用<animator>  標簽
<animator xmlns:android="http://schemas.android.com/apk/res/android"  
    android:valueFrom="0"   // 初始值
    android:valueTo="3"  // 結束值
    android:valueType="intType" // 變化值類型 ：floatType & intType

    android:duration="3000" // 動畫持續時間（ms），必須設置，動畫才有效果
    android:startOffset ="1000" // 動畫延遲開始時間（ms）
    android:fillBefore = “true” // 動畫播放完后，視圖是否會停留在動畫開始的狀態，默認為true
    android:fillAfter = “false” // 動畫播放完后，視圖是否會停留在動畫結束的狀態，優先于fillBefore值，默認為false
    android:fillEnabled= “true” // 是否應用fillBefore值，對fillAfter值無影響，默認為true
    android:repeatMode= “restart” // 選擇重復播放動畫模式，restart代表正序重放，reverse代表倒序回放，默認為restart|
    android:repeatCount = “0” // 重放次數（所以動畫的播放次數=重放次數+1），為infinite時無限重復
    android:interpolator = @[package:]anim/interpolator_resource // 插值器，即影響動畫的播放速度,下面會詳細講
/> 

// 步驟3：啟動動畫
    // 載入XML動畫
    Animator animator = AnimatorInflater.loadAnimator(context, R.animator.set_animation);  
    // 設置動畫對象
    animator.setTarget(view);  
    // 啟動動畫
    animator.start();  

/*
 * 設置方式2：Java
 */
// 步驟1：設置動畫屬性的初始值 & 結束值
    ValueAnimator anim = ValueAnimator.ofInt(0, 3);
    // ofInt()作用：
    // 1. 創建動畫實例
    // 2. 將傳入的多個Int參數進行平滑過渡:此處傳入0和3,表示將值從0平滑過渡到3
    // 如果傳入了3個Int參數 a,b,c ,則是先從a平滑過渡到b,再從b平滑過渡到C，以此類推
    // ValueAnimator.ofInt()內置了整型估值器,直接采用默認的.不需要設置，即默認設置了如何從初始值 過渡到 結束值
    // 關于自定義插值器我將在下節進行講解
    // 下面看看ofInt()的源碼分析 ->>關注1

    // 關注1：ofInt（）源碼分析
    public static ValueAnimator ofInt(int... values) {
    // 允許傳入一個或多個Int參數
    // 1. 輸入一個的情況（如a）：從0過渡到a；
    // 2. 輸入多個的情況（如a，b，c）：先從a平滑過渡到b，再從b平滑過渡到C

    ValueAnimator anim = new ValueAnimator();
    // 創建動畫對象
    anim.setIntValues(values);
    // 將傳入的值賦值給動畫對象
    return anim;
}

// 步驟2：設置動畫的播放各種屬性
    // 設置動畫運行的時長
    anim.setDuration(500); 
    
    // 設置動畫延遲播放時間
    anim.setStartDelay(500); 

    // 設置動畫重復播放次數 = 重放次數+1
    // 動畫播放次數 = infinite時,動畫無限重復
    anim.setRepeatCount(0);
    
    // 設置重復播放動畫模式
    anim.setRepeatMode(ValueAnimator.RESTART);
    // ValueAnimator.RESTART(默認):正序重放
    // ValueAnimator.REVERSE:倒序回放

// 步驟3：將改變的值手動賦值給對象的屬性值：通過動畫的更新監聽器
// 設置值的更新監聽器，即：值每次改變、變化一次,該方法就會被調用一次
    anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
        @Override
        public void onAnimationUpdate(ValueAnimator animation) {

        // 獲得改變后的值
        int currentValue = (Integer) animation.getAnimatedValue();

        // 將改變后的值賦給對象的屬性值，下面會詳細說明
        View.setproperty（currentValue）；

        // 刷新視圖，即重新繪制，從而實現動畫效果
        View.requestLayout();
             }
        });

// 步驟4：啟動動畫
  anim.start();

值 從初始值 過度到 結束值 的過程如下效果圖：

效果圖

3.4 實例說明

• 下面，我將結合 手動賦值給對象屬性 這一步驟，從而實現一個完整的動畫效果
• 實現的動畫效果：按鈕的寬度從 150px 放大到 500px

效果圖

// 創建動畫作用對象：此處以Button為例
    Button mButton = (Button) findViewById(R.id.Button);

// 步驟1：設置屬性數值的初始值 & 結束值
    ValueAnimator valueAnimator = ValueAnimator.ofInt(mButton.getLayoutParams().width, 500);
    // 初始值 = 當前按鈕的寬度，此處在xml文件中設置為150
    // 結束值 = 500
    // ValueAnimator.ofInt()內置了整型估值器,直接采用默認的.不需要設置
    // 即默認設置了如何從初始值150 過渡到 結束值500

// 步驟2：設置動畫的播放各種屬性
    // 設置動畫運行時長:1s
    valueAnimator.setDuration(2000);
        

// 步驟3：將屬性數值手動賦值給對象的屬性:此處是將值賦給按鈕的寬度
// 設置更新監聽器：即數值每次變化更新都會調用該方法
    valueAnimator.addUpdateListener(new AnimatorUpdateListener() {
        @Override
        public void onAnimationUpdate(ValueAnimator animator) {

            // 獲得每次變化后的屬性值
            int currentValue = (Integer) animator.getAnimatedValue();
        
            // 每次值變化時，將值手動賦值給對象的屬性
            // 即將每次變化后的值賦給按鈕的寬度，這樣就實現了按鈕寬度屬性的動態變化
            mButton.getLayoutParams().width = currentValue;
            

            // 步驟4：刷新視圖，即重新繪制，從而實現動畫效果
            mButton.requestLayout();
                
            }
        });

// 步驟4：啟動動畫
valueAnimator.start();

4. 浮點型：ValueAnimator.oFloat（）

4.1 作用

將初始值 以浮點型數值的形式 過渡到結束值

4.2 工作原理

示意圖

4.3 具體使用

其使用方式跟ValueAnimator.ofInt()十分類似，此處僅展示區別之處：

/*
 * 設置方式1：xml
 */
<animator xmlns:android="http://schemas.android.com/apk/res/android"  
    android:valueFrom="0"  
    android:valueTo="3"  
    android:valueType="floatType" // 區別：設置為浮點型類型
    ... // 其余屬性設置跟ValueAnimator.ofInt類似
    />  

/*
 * 設置方式2：Java
 */
ValueAnimator anim = ValueAnimator.ofFloat(0, 3);  
// 采用ValueAnimator.ofFloat()
// 其他使用類似ValueAnimator.ofInt（int values），此處不作過多描述

效果圖

效果圖

從上面可以看出，ValueAnimator.ofInt（）與ValueAnimator.oFloat（）僅僅只是在估值器上的區別：（即如何從初始值 過渡 到結束值）

• ValueAnimator.oFloat（）采用默認的浮點型估值器 (FloatEvaluator)
• ValueAnimator.ofInt（）采用默認的整型估值器（IntEvaluator）

在使用上完全沒有區別，此處對ValueAnimator.oFloat（）的使用就不作過多描述。

5. 對象：ValueAnimator.ofObject（）

5.1 作用

將初始值 以對象的形式 過渡到結束值

即通過操作 對象 實現動畫效果

5.2 工作原理

示意圖

5.3 具體使用

// 1. 創建初始動畫時的對象  & 結束動畫時的對象
myObject object1 = new myObject();  
myObject object2 = new myObject();  

// 2. 創建動畫對象 
ValueAnimator anim = ValueAnimator.ofObject(new myObjectEvaluator(), object1, object2);  
// 參數說明
// 參數1：自定義的估值器對象(TypeEvaluator) - 下面會詳細介紹
// 參數2：初始動畫的對象
// 參數3：結束動畫的對象

// 3. 設置參數
anim.setDuration(5000);  

// 4. 啟動動畫
anim.start(); 

在繼續講解ValueAnimator.ofObject（）的使用前，我先講一下估值器（TypeEvaluator）

5.4 估值器（TypeEvaluator）

• 作用：設置動畫 如何從初始值 過渡到 結束值 的邏輯

1. 插值器（Interpolator）決定 值 的變化模式（勻速、加速blabla）
2. 估值器（TypeEvaluator）決定 值 的具體變化數值

從上面可知：

• ValueAnimator.ofFloat（）實現了 將初始值 以浮點型的形式 過渡到結束值 的邏輯，那么這個過渡邏輯具體是怎么樣的呢？
• 其實是系統內置了一個 FloatEvaluator估值器，內部實現了初始值與結束值 以浮點型的過渡邏輯
• 我們來看一下 FloatEvaluator的代碼實現：

// 步驟1：FloatEvaluator實現了TypeEvaluator接口
public class FloatEvaluator implements TypeEvaluator {  

// 步驟2：重寫evaluate()
    public Object evaluate(float fraction, Object startValue, Object endValue) { 

        // 初始值過渡到結束值 的算法是：
        // 1. 用結束值減去初始值，算出它們之間的差值
        // 2. 用上述差值乘以fraction系數
        // 3. 再加上初始值，就得到當前動畫的值
        float startFloat = ((Number) startValue).floatValue();  
        return startFloat + fraction * (((Number) endValue).floatValue() - startFloat);  
    }  
} 

• ValueAnimator.ofInt（） & ValueAnimator.ofFloat（）都具備系統內置的估值器，即FloatEvaluator & IntEvaluator

即系統已經默認實現了 如何從初始值 過渡到 結束值 的邏輯

• 但對于ValueAnimator.ofObject（），從上面的工作原理可以看出并沒有系統默認實現，因為對對象的動畫操作復雜 & 多樣，系統無法知道如何從初始對象過度到結束對象
• 因此，對于ValueAnimator.ofObject（），我們需自定義估值器（TypeEvaluator）來告知系統如何進行從 初始對象 過渡到 結束對象的邏輯
• 自定義實現的邏輯如下

// 步驟1：實現TypeEvaluator接口
    public class ObjectEvaluator implements TypeEvaluator{  

// 步驟2：復寫evaluate()
// 作用：估值器的計算邏輯，即寫入對象動畫過渡的邏輯
    @Override  
    public Object evaluate(float fraction, Object startValue, Object endValue) {  
        // 參數說明
        // fraction：表示動畫完成度（根據它來計算當前動畫的值），也是插值器getInterpolation()的返回值
        // startValue：動畫的初始值
        // endValue：動畫的結束值

        // 估值器的計算邏輯
        ... 
        
        // 返回對象動畫過渡邏輯計算后的值
        // 即賦給動畫屬性的具體數值
        return value;  
    } 

5.5 實例說明

下面我將用實例說明該如何自定義估值器并通過ValueAnimator.ofObject()實現動畫效果：一個圓從左上角移動到右下角，如下圖所示。

效果圖

• 工程目錄文件如下：

  
  
  工程目錄

步驟1：定義對象類

• 因為ValueAnimator.ofObject（）是面向對象操作的，所以需要自定義對象類。
• 本例需要操作的對象是 圓的點坐標
  Point.java

public class Point {

    // 設置兩個變量用于記錄坐標的位置
    private float x;
    private float y;

    // 構造方法用于設置坐標
    public Point(float x, float y) {
        this.x = x;
        this.y = y;
    }

    // get方法用于獲取坐標
    public float getX() {
        return x;
    }

    public float getY() {
        return y;
    }
}

步驟2：根據需求自定義估值器

• 即實現TypeEvaluator接口和復寫evaluate()，其主要目的是自定義如何從初始點坐標過渡到結束點坐標；

• 本例需要實現的是一個從左上角到右下角的坐標過渡邏輯。

效果圖

// PointEvaluator.java
// 步驟1：實現TypeEvaluator接口
public class PointEvaluator implements TypeEvaluator {

    // 步驟2：復寫evaluate（）
    // 作用：估值器的計算邏輯，即寫入對象動畫過渡的邏輯
    @Override
    public Object evaluate(float fraction, Object startValue, Object endValue) {

        // 將動畫初始值startValue 和 動畫結束值endValue 強制類型轉換成Point對象
        Point startPoint = (Point) startValue;
        Point endPoint = (Point) endValue;

        // 根據fraction來計算當前動畫的x和y的值
        float x = startPoint.getX() + fraction * (endPoint.getX() - startPoint.getX());
        float y = startPoint.getY() + fraction * (endPoint.getY() - startPoint.getY());
        
        // 將計算后的坐標封裝到一個新的Point對象中并返回
        Point point = new Point(x, y);
        return point;
    }
}

步驟3：將屬性動畫作用到自定義View當中

即通過對Point對象進行動畫操作，從而實現整個自定義View的動畫效果。

// MyView.java
public class MyView extends View {

    public static final float RADIUS = 70f;// 圓的半徑 = 70
    private Point currentPoint;// 當前點坐標
    private Paint mPaint;// 繪圖畫筆

    // 初始化畫筆
    public MyView(Context context, AttributeSet attrs) {
        super(context, attrs);
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mPaint.setColor(Color.BLUE);
    }

    // 復寫onDraw()從而實現繪制邏輯
    // 繪制邏輯:先在初始點畫圓,通過監聽當前坐標值(currentPoint)的變化,每次變化都調用onDraw()重新繪制圓,從而實現圓的平移動畫效果
    @Override
    protected void onDraw(Canvas canvas) {
    // 如果當前點坐標為空(即第一次)
    if (currentPoint == null) {
        currentPoint = new Point(RADIUS, RADIUS);
        // 創建一個點對象(坐標是(70,70))

        // 在該點畫一個圓:圓心 = (70,70),半徑 = 70
        float x = currentPoint.getX();
        float y = currentPoint.getY();
        canvas.drawCircle(x, y, RADIUS, mPaint);

    // 重點關注
    // 將屬性動畫作用到View中
        // 步驟1:創建初始動畫時的對象點  & 結束動畫時的對象點
        Point startPoint = new Point(RADIUS, RADIUS);// 初始點為圓心(70,70)
        Point endPoint = new Point(700, 1000);// 結束點為(700,1000)

        // 步驟2:創建動畫對象 & 設置初始值 和 結束值
        ValueAnimator anim = ValueAnimator.ofObject(new PointEvaluator(), startPoint, endPoint);
        // 參數說明
        // 參數1：TypeEvaluator 類型參數 - 使用自定義的PointEvaluator(實現了TypeEvaluator接口)
        // 參數2：初始動畫的對象點
        // 參數3：結束動畫的對象點

        // 步驟3：設置動畫參數
        anim.setDuration(5000);
        // 設置動畫時長

        // 步驟3：通過 值 的更新監聽器，將改變的對象手動賦值給當前對象
        // 此處是將 改變后的坐標值對象 賦給 當前的坐標值對象
        // 設置 值的更新監聽器
        // 即每當坐標值（Point對象）更新一次,該方法就會被調用一次
        anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                currentPoint = (Point) animation.getAnimatedValue();
                // 將每次變化后的坐標值（估值器PointEvaluator中evaluate（）返回的Piont對象值）到當前坐標值對象（currentPoint）
                // 從而更新當前坐標值（currentPoint）

        // 步驟4：每次賦值后就重新繪制，從而實現動畫效果
                invalidate();
                // 調用invalidate()后,就會刷新View,即才能看到重新繪制的界面,即onDraw()會被重新調用一次
                // 所以坐標值每改變一次,就會調用onDraw()一次
            }
        });

        anim.start();
        // 啟動動畫


    } else {
        // 如果坐標值不為0,則畫圓
        // 所以坐標值每改變一次,就會調用onDraw()一次,就會畫一次圓,從而實現動畫效果

        // 在該點畫一個圓:圓心 = (30,30),半徑 = 30
        float x = currentPoint.getX();
        float y = currentPoint.getY();
        canvas.drawCircle(x, y, RADIUS, mPaint);
    }
  }
}

步驟4：在布局文件加入自定義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.MyView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
         />
</RelativeLayout>

步驟5：在主代碼文件設置顯示視圖

MainActivity.java

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

效果圖

效果圖

源碼地址

Carson_Ho的Github地址：https://github.com/Carson-Ho/PropertyAnimator_ofObject

特別注意

從上面可以看出，其實ValueAnimator.ofObject（）的本質還是操作 值，只是是采用將 多個值 封裝到一個對象里的方式 同時對多個值一起操作而已

就像上面的例子，本質還是操作坐標中的x，y兩個值，只是將其封裝到Point對象里，方便同時操作x，y兩個值而已

6. 與ObjectAnimator類對比

對比于屬性動畫中另外一個比較核心的使用類：ObjectAnimator類：

6.1 相同點

其二者的本質都是相同：不斷改變值，然后不斷賦值給對象的屬性從而實現動畫效果

6.2 區別

二者的區別在于：賦值給對象屬性的操作是直接還是間接的。

• ValueAnimator類：不斷改變值，然后手動賦值給對象的屬性從而實現動畫效果，是間接對對象屬性進行操作；
• ObjectAnimator類：不斷改變值，然后自動賦值給對象的屬性從而實現動畫效果，是直接對對象屬性進行操作；

可以理解為：ObjectAnimator類的使用更加智能、自動化程度更高。

至此，關于屬性動畫中最核心的 ValueAnimator類已經講解完畢。

7. 總結

• 本文對Android 屬性動畫中的最核心的 ValueAnimator類進行全面 & 詳細介紹，下面我將繼續講解另外一個重要的類：ObjectAnimator類
• Carson帶你學Android動畫系列文章：
  Carson帶你學Android：一份全面&詳細的動畫知識學習攻略
  Carson帶你學Android：常見的三種動畫類型
  Carson帶你學Android：補間動畫學習教程
  Carson帶你學Android：屬性動畫學習教程
  Carson帶你學Android：逐幀動畫學習教程
  Carson帶你學Android：自定義動畫神器-估值器(含實例教學)
  Carson帶你學Android：自定義動畫神器-插值器(含實例教學)

歡迎關注Carson_Ho的簡書

不定期分享關于安卓開發的干貨，追求短、平、快，但卻不缺深度。

請點贊！因為你的鼓勵是我寫作的最大動力！