特別提醒：本文參考摘自【工匠若水 http://blog.csdn.net/yanbober/article/details/46481171 】 及Carson_Ho：【http://www.lxweimin.com/p/2412d00a0ce4 】 強(qiáng)烈建議讀者進(jìn)入原博客查看學(xué)習(xí)。】

1、Android動畫簡介

1.1 分類

Android系統(tǒng)提供了很多豐富的API去實(shí)現(xiàn)UI的2D與3D動畫，最主要的劃分可以分為如下幾類：

Drawable Animation： 這種動畫（也叫Frame動畫、幀動畫）其實(shí)可以劃分到視圖動畫的類別，專門用來一個一個的顯示Drawable的resources，就像放幻燈片一樣。

View Animation： 視圖動畫在古老的Android版本系統(tǒng)中就已經(jīng)提供了，只能被用來設(shè)置View的動畫。

**Property Animation： **屬性動畫只對Android 3.0（API 11）以上版本的Android系統(tǒng)才有效，這種動畫可以設(shè)置給任何Object，包括那些還沒有渲染到屏幕上的對象。這種動畫是可擴(kuò)展的，可以讓你自定義任何類型和屬性的動畫。

1.2 每種動畫的特點(diǎn)及區(qū)別

Drawable Animation：幀動畫沒有什么好說的，就是把幾張圖片按一定間隔順序顯示出來，就像播放幻燈片一樣，實(shí)際開發(fā)中用處不大。

View Animation：View動畫只能夠為View添加動畫，如果想為非View對象添加動畫須自己實(shí)現(xiàn)；且View動畫支持的種類很少；尤其是他改變的是View的繪制效果，View的屬性沒有改變，其位置與大小都不變； View動畫代碼量少，使用簡單方便。

**Property Animation： **屬性動畫彌補(bǔ)了View動畫的缺陷，可以為一個對象的任意屬性添加動畫，對象自己的屬性會被真的改變；當(dāng)對象的屬性變化的時候，屬性動畫會自動刷新屏幕；屬性動畫改變的是對象的真實(shí)屬性，而且屬性動畫不止用于View，還可以用于任何對象。

2、屬性動畫簡介（Property Animation）

2.1 屬性動畫出現(xiàn)的原因

• 原因：Android中另外兩種動畫幀動畫和View動畫有太多的局限性：

1、幀動畫:完全就是通過時間差來顯示不同的圖片，適用場景和實(shí)用性非常小，即使有很多地方可以用幀動畫來做，但是要存放那么多圖片資源，這樣會增加apk大小，這無疑是不明智的做法。
2、View動畫：View動畫還是比較實(shí)用的，能夠解決一般APP開發(fā)中大部分需要的動畫，但View動畫也有很多缺點(diǎn)。首先：動畫效果無疑是平面平移、平面旋轉(zhuǎn)、透明度變化以及大小縮放幾種動畫，如果說現(xiàn)在要想實(shí)現(xiàn)卡片翻轉(zhuǎn)的3D效果，則View動畫就實(shí)現(xiàn)不了；再有：View動畫顧名思義，只能為View添加這些動畫；第三：沒有改變View的屬性，只是改變視覺效果，比如將屏幕左上角的按鈕 通過補(bǔ)間動畫 移動到屏幕的右下角，點(diǎn)擊當(dāng)前按鈕位置（屏幕右下角）是沒有效果的，因為實(shí)際上按鈕還是停留在屏幕左上角，補(bǔ)間動畫只是將這個按鈕繪制到屏幕右下角，改變了視覺效果而已。

• 所以：為了解決補(bǔ)間動畫的缺陷，在 Android 3.0（API 11）開始，系統(tǒng)提供了一種全新的動畫模式：屬性動畫（Property Animation）

2.2 屬性動畫簡介

• 作用對象：任意 Java 對象

不再局限于 視圖View對象

• 實(shí)現(xiàn)的動畫效果：可自定義各種動畫效果

不再局限于4種基本變換：平移、旋轉(zhuǎn)、縮放 & 透明度

2.3 屬性動畫特點(diǎn)

• 作用對象進(jìn)行了擴(kuò)展：不只是View對象，甚至沒對象也可以
• 動畫效果：不只是4種基本變換，還有其他動畫效果
• 作用領(lǐng)域：Android 3.0（API 11）后引入的

3、屬性動畫使用相關(guān)

3.1 屬性動畫使用相關(guān)類

• 所有的屬性動畫的抽象基類就是它：

/**
 * This is the superclass for classes which provide basic support for animations which can be
 * started, ended, and have <code>AnimatorListeners</code> added to them.
 */
public abstract class Animator implements Cloneable {
    ......
}

• 他的實(shí)現(xiàn)子類(紅色標(biāo)注的)， 可以看見，屬性動畫的實(shí)現(xiàn)有7個類：

3050655-46ea1b4994a9ec77.png

• 我們平時使用屬性動畫的重點(diǎn)就在于AnimatorSet、ObjectAnimator、TimeAnimator、ValueAnimator。：

3050655-624cc1dde19ca8e1.png

3.2 屬性解釋：

3.2.1<set>屬性解釋：

3.2.2 <objectAnimator>屬性解釋：

3.3 Evaluators（估值器）相關(guān)類解釋：

• Evaluators就是屬性動畫系統(tǒng)如何去計算一個屬性值。它們通過Animator提供的動畫的起始和結(jié)束值去計算一個動畫的屬性值。

3.4 Interpolators（插值器）相關(guān)類解釋：

4、具體使用--ValueAnimator類

4.1 定義、原理

• 定義：屬性動畫機(jī)制中 最核心的一個類

• 實(shí)現(xiàn)動畫的原理：通過不斷控制 值 的變化，再不斷 手動 賦給對象的屬性，從而實(shí)現(xiàn)動畫效果。

4.2 ValueAnimator類中常用方法：

• ValueAnimator.ofInt（int values）

• ValueAnimator.ofFloat（float values）
• ValueAnimator.ofObject（int values）

4.2.1 ValueAnimator.ofInt（int values）

• 作用：將初始值 以整型數(shù)值的形式 過渡到結(jié)束值

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

設(shè)置方式一：Java代碼中設(shè)置

實(shí)際開發(fā)中，建議使用Java代碼實(shí)現(xiàn)屬性動畫：因為很多時候?qū)傩缘钠鹗贾凳菬o法提前確定的（無法使用XML設(shè)置），這就需要在Java代碼里動態(tài)獲取。

        //步驟1：設(shè)置動畫屬性的初始值 & 結(jié)束值
        ValueAnimator animator = ValueAnimator.ofInt(0, 3);
        // ofInt（）作用有兩個
        // 1. 創(chuàng)建動畫實(shí)例
        // 2. 將傳入的多個Int參數(shù)進(jìn)行平滑過渡:此處傳入0和1,表示將值從0平滑過渡到1
        // 如果傳入了3個Int參數(shù) a,b,c ,則是先從a平滑過渡到b,再從b平滑過渡到C，以此類推
        // ValueAnimator.ofInt()內(nèi)置了整型估值器,直接采用默認(rèn)的.不需要設(shè)置，即默認(rèn)設(shè)置了如何從初始值 過渡到 結(jié)束值
        // 關(guān)于自定義插值器我將在下節(jié)進(jìn)行講解

        //步驟2：設(shè)置動畫的播放各種屬性
        animator.setDuration(500);//設(shè)置動畫時長
        animator.setStartDelay(100);//設(shè)置動畫延遲播放時間
        animator.setRepeatCount(0);// 設(shè)置動畫重復(fù)播放次數(shù) = 重放次數(shù)+1
        // 當(dāng)動畫播放次數(shù) = infinite時,動畫無限重復(fù)
        animator.setRepeatMode(ValueAnimator.RESTART);// 設(shè)置重復(fù)播放動畫模式
        // ValueAnimator.RESTART(默認(rèn)):正序重放
        // ValueAnimator.REVERSE:倒序回放

        //步驟3：將改變的值手動賦值給對象的屬性值：通過動畫的更新監(jiān)聽器
        // 設(shè)置 值的更新監(jiān)聽器   即：值每次改變、變化一次,該方法就會被調(diào)用一次
        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                //獲取改變后的值
                int currentValue = (int) animation.getAnimatedValue();

                //步驟4：將改變后的值賦給對象的屬性值，后文會詳細(xì)說明


                //步驟5：刷新視圖，即重新繪制，從而實(shí)現(xiàn)動畫效果
                xxx.requestLayout();
            }
        });

       //步驟6：設(shè)置對象 &&　啟動動畫
        animator.setTarget(button);
        animator.start();

設(shè)置方式二：在XML 文件中設(shè)置

步驟一：創(chuàng)建xml動畫文件，設(shè)置參數(shù)（必須放到 res/animator 文件夾下）

set_animator.xml文件如下：

<animator xmlns:android="http://schemas.android.com/apk/res/android"  
    android:valueFrom="0"   // 初始值
    android:valueTo="100"  // 結(jié)束值
    android:valueType="intType" // 變化值類型 ：floatType & intType

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

/>

步驟二：在Java代碼中創(chuàng)建動畫并啟動

//創(chuàng)建動畫對象
        Animator animator= AnimatorInflater.loadAnimator(this,R.animator.set_animator);

        //設(shè)置動畫對象
        animator.setTarget(view);

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

實(shí)例演示

• 演示效果說明：將Button的寬度從100px變成500px

• 效果圖大致如下：

  
  
  944365-cf61973c2bcbc9ee.gif

• 這里僅演示Java代碼中設(shè)置：

public class MainActivity extends AppCompatActivity {

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

        //此處以button作為動畫對象
        final Button button = (Button) findViewById(R.id.button);

        //實(shí)現(xiàn)的效果：讓button的寬度從 100px到500px

        //步驟1：創(chuàng)建對象
        ValueAnimator valueAnimator = ValueAnimator.ofInt(100, 500);
        // ValueAnimator.ofInt()內(nèi)置了整型估值器,直接采用默認(rèn)的.不需要設(shè)置

        //步驟2：設(shè)置屬性
        valueAnimator.setDuration(3000);

        //步驟3：將屬性數(shù)值手動賦值給對象的屬性:此處是將 值 賦給 按鈕的寬度
        //置更新監(jiān)聽器：即數(shù)值每次變化更新都會調(diào)用該方法
        valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                //獲取當(dāng)前值
                int currentValue = (int) animation.getAnimatedValue();

                //步驟4：將改變后的值賦予對象的屬性值
                button.getLayoutParams().width = currentValue;

                //步驟5：刷新視圖，即重新繪制，從而實(shí)現(xiàn)動畫效果
                button.requestLayout();
            }
        });

        //步驟6：設(shè)置對象 &&　啟動動畫
        valueAnimator.setTarget(button);
        valueAnimator.start();

    }

}

4.2.2 ValueAnimator.ofFloat（float values）

• 作用：將初始值 以浮點(diǎn)型數(shù)值的形式 過渡到結(jié)束值

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

• 設(shè)置方式及使用方法同ofInt(int values)一模一樣（此處就不作說明了）

• ValueAnimator.ofInt（）與ValueAnimator.oFloat（）僅僅只是在估值器上的區(qū)別：（即如何從初始值 過渡 到結(jié)束值）

ValueAnimator.oFloat（）采用默認(rèn)的浮點(diǎn)型估值器 (FloatEvaluator)
ValueAnimator.ofInt（）采用默認(rèn)的整型估值器（IntEvaluator）

4.2.3 ValueAnimator.ofObject（）

• 作用：將初始值 以對象的形式 過渡到結(jié)束值

即通過操作 對象 實(shí)現(xiàn)動畫效果

• 具體使用：

// 創(chuàng)建初始動畫時的對象  & 結(jié)束動畫時的對象
myObject object1 = new myObject();  
myObject object2 = new myObject();  

ValueAnimator anim = ValueAnimator.ofObject(new myObjectEvaluator(), object1, object2);  
// 創(chuàng)建動畫對象 & 設(shè)置參數(shù)
// 參數(shù)說明
// 參數(shù)1：自定義的估值器對象（TypeEvaluator 類型參數(shù)） - 下面會詳細(xì)介紹
// 參數(shù)2：初始動畫的對象
// 參數(shù)3：結(jié)束動畫的對象
anim.setDuration(5000);  
anim.start();

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

估值器（TypeEvaluator） 介紹

• 作用：設(shè)置動畫 如何從初始值 過渡到 結(jié)束值 的邏輯

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

從前文中可看到：

• ValueAnimator.ofFloat（）實(shí)現(xiàn)了 將初始值 以浮點(diǎn)型的形式 過渡到結(jié)束值 的邏輯，那么這個過渡邏輯具體是怎么樣的呢？
• 其實(shí)是系統(tǒng)內(nèi)置了一個 FloatEvaluator估值器，內(nèi)部實(shí)現(xiàn)了初始值與結(jié)束值 以浮點(diǎn)型的過渡邏輯
• 我們來看一下 FloatEvaluator的代碼實(shí)現(xiàn)：

public class FloatEvaluator implements TypeEvaluator {  
// FloatEvaluator實(shí)現(xiàn)了TypeEvaluator接口

// 重寫evaluate()
    public Object evaluate(float fraction, Object startValue, Object endValue) {  
// 參數(shù)說明
// fraction：表示動畫完成度（根據(jù)它來計算當(dāng)前動畫的值）
// startValue、endValue：動畫的初始值和結(jié)束值
        float startFloat = ((Number) startValue).floatValue();  

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

• ValueAnimator.ofInt（） & ValueAnimator.ofFloat（）都具備系統(tǒng)內(nèi)置的估值器，即**FloatEvaluator **& IntEvaluator

即系統(tǒng)已經(jīng)默認(rèn)實(shí)現(xiàn)了 如何從初始值 過渡到 結(jié)束值 的邏輯

• 但對于ValueAnimator.ofObject（），從上面的工作原理可以看出并沒有系統(tǒng)默認(rèn)實(shí)現(xiàn)，因為對對象的動畫操作復(fù)雜 & 多樣，系統(tǒng)無法知道如何從初始對象過度到結(jié)束對象
• 因此，對于ValueAnimator.ofObject（），我們需自定義估值器（TypeEvaluator）來告知系統(tǒng)如何進(jìn)行從 初始對象 過渡到 結(jié)束對象的邏輯
• 自定義實(shí)現(xiàn)的邏輯如下:

// 實(shí)現(xiàn)TypeEvaluator接口
public class ObjectEvaluator implements TypeEvaluator{  

// 復(fù)寫evaluate（）
// 在evaluate（）里寫入對象動畫過渡的邏輯
    @Override  
    public Object evaluate(float fraction, Object startValue, Object endValue) {  
        // 參數(shù)說明
        // fraction：表示動畫完成度（根據(jù)它來計算當(dāng)前動畫的值）
        // startValue、endValue：動畫的初始值和結(jié)束值

        ... // 寫入對象動畫過渡的邏輯

        return value;  
        // 返回對象動畫過渡的邏輯計算后的值
    }

實(shí)例說明

• 下面我將用實(shí)例說明 該如何自定義TypeEvaluator接口并通過ValueAnimator.ofObject（）實(shí)現(xiàn)動畫效果

• 實(shí)現(xiàn)的動畫效果大致如下：一個圓從一個點(diǎn) 移動到 另外一個點(diǎn)

  
  
  944365-45b817bd4ca8c119.gif

步驟1：定義對象類

• 因為ValueAnimator.ofObject（）是面向?qū)ο蟛僮鞯模孕枰远x對象類。

• 本例需要操作的對象是 圓的點(diǎn)坐標(biāo)
  Point.java

public class Point {

    //設(shè)置兩個變量用于記錄點(diǎn)坐標(biāo)的位置
    private float x;
    private float y;

    // 構(gòu)造方法用于設(shè)置坐標(biāo)
    public Point(float x, float y) {
        this.x = x;
        this.y = y;
    }

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

    public float getY() {
        return y;
    }
}

步驟2：根據(jù)需求實(shí)現(xiàn)TypeEvaluator接口

• 實(shí)現(xiàn)TypeEvaluator接口的目的是自定義如何 從初始點(diǎn)坐標(biāo) 過渡 到結(jié)束點(diǎn)坐標(biāo)；

• 本例實(shí)現(xiàn)的是一個從左上角到右下角的坐標(biāo)過渡邏輯。
  PointEvaluator.java

public class PointEvaluator implements TypeEvaluator {
    //復(fù)寫evaluate（）
    //在evaluate（）里寫入對象動畫過渡的邏輯
    @Override
    public Object evaluate(float fraction, Object startValue, Object endValue) {
        //將動畫初始值startValue 和 動畫結(jié)束值endValue強(qiáng)制類型轉(zhuǎn)換成Point對象
        Point startPoint = (Point) startValue;
        Point endPoint = (Point) endValue;

        //根據(jù)fraction來計算當(dāng)前動畫的x和y的值
        float x = startPoint.getX() + fraction * (endPoint.getX() - startPoint.getX());
        float y = startPoint.getY() + fraction * (endPoint.getY() - startPoint.getY());

        //將計算后的坐標(biāo)封裝到一個新的point對象中并返回
        Point point = new Point(x, y);
        return point;
    }
}

• 上面步驟是根據(jù)需求自定義TypeEvaluator的實(shí)現(xiàn)

• 下面將講解如何通過對 Point 對象進(jìn)行動畫操作，從而實(shí)現(xiàn)整個自定義View的動畫效果。

步驟3 : 將屬性動畫作用到自定義View當(dāng)中

MyView.java

public class MyView extends View {
    //設(shè)置需要用到的變量
    public static final float RADIUS = 50f;//園的半徑
    private Point currentPoint;//當(dāng)前點(diǎn)坐標(biāo)
    private Paint mPaint;//畫筆

    //在構(gòu)造方法里初始化畫筆（因為這里我們要用在xml文件中，所以用兩個參數(shù)的）
    public MyView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        //初始化畫筆
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        //定義畫筆顏色
        mPaint.setColor(Color.BLUE);
    }

    //復(fù)寫onDraw（）實(shí)現(xiàn)繪制邏輯
    //繪制邏輯：先在初始點(diǎn)畫圓，通過監(jiān)聽當(dāng)前坐標(biāo)值得變化，
    //每次變化都調(diào)用onDraw重新繪制圓，從而實(shí)現(xiàn)圓的平移動畫效果
    @Override
    protected void onDraw(Canvas canvas) {
        //如果當(dāng)前點(diǎn)坐標(biāo)為空（即第一次）
        if (currentPoint == null) {
            //創(chuàng)建一個點(diǎn)對象（坐標(biāo)是半徑，這樣的話就能在屏幕顯示全）
            currentPoint = new Point(RADIUS, RADIUS);

            //在該點(diǎn)畫一個圓：圓心=（50,50），半徑=50
            float x = currentPoint.getX();
            float y = currentPoint.getX();
            canvas.drawCircle(x, y, RADIUS, mPaint);

            //以下是重點(diǎn)代碼

            //步驟1：創(chuàng)建初始動畫時的對象點(diǎn) & 結(jié)束動畫時的對象點(diǎn)
            Point startPoint = new Point(RADIUS, RADIUS);//初始點(diǎn)為圓心（50，50）
            Point endPoint = new Point(700, 1000);//結(jié)束點(diǎn)為（700,1000）

            //步驟2：創(chuàng)建動畫對象 & 設(shè)置初始值 和 結(jié)束值
            ValueAnimator animator = ValueAnimator.ofObject(new PointEvaluator(), startPoint, endPoint);
            // 參數(shù)說明
            // 參數(shù)1：TypeEvaluator 類型參數(shù) - 使用自定義的PointEvaluator(實(shí)現(xiàn)了TypeEvaluator接口)
            // 參數(shù)2：初始動畫的對象點(diǎn)
            // 參數(shù)3：結(jié)束動畫的對象點(diǎn)

            //步驟3：設(shè)置動畫參數(shù)
            animator.setDuration(5000);//動畫時長

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

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

            //步驟6：啟動動畫
            animator.start();

        } else {
            //如果坐標(biāo)值不為0，則畫圓
            //坐標(biāo)值每改變一次,就會調(diào)用onDraw()一次,就會畫一次圓,從而實(shí)現(xiàn)動畫效果

            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"
    tools:context="com.example.animation02.MainActivity">

    <com.example.animation02.MyView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />


</RelativeLayout>

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

public class MainActivity extends AppCompatActivity {

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

    }

}

• 效果圖大致是這樣的：

  
  
  944365-45b817bd4ca8c119.gif

特別注意

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

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

• 至此，關(guān)于屬性動畫中最核心的 ValueAnimator類已經(jīng)講解完畢

5、具體使用--ObjectAnimator類

5.1 實(shí)現(xiàn)動畫的原理

• 直接對對象的屬性值進(jìn)行改變操作，從而實(shí)現(xiàn)動畫效果

1.如直接改變 View的 alpha 屬性 從而實(shí)現(xiàn)透明度的動畫效果
2.繼承自ValueAnimator類，即底層的動畫實(shí)現(xiàn)機(jī)制是基于ValueAnimator類

• 本質(zhì)原理： 通過不斷控制 值 的變化，再不斷 自動 賦給對象的屬性，從而實(shí)現(xiàn)動畫效果。

• ObjectAnimator與 ValueAnimator類的區(qū)別：

**ValueAnimator **類是先改變值，然后 手動賦值 給對象的屬性從而實(shí)現(xiàn)動畫；是 間接 對對象屬性進(jìn)行操作；
**ObjectAnimator **類是先改變值，然后 自動賦值 給對象的屬性從而實(shí)現(xiàn)動畫；是 直接 對對象屬性進(jìn)行操作；

5.2 實(shí)現(xiàn)的方式

• 由于是繼承了ValueAnimator類，所以使用的方法十分類似：XML 設(shè)置 / Java設(shè)置

5.2.1 設(shè)置方式一：Java 代碼設(shè)置

        ObjectAnimator animator = ObjectAnimator.ofFloat(Object object, String property, float ....values);  
      // ofFloat()作用有兩個
      // 1. 創(chuàng)建動畫實(shí)例
      // 2. 參數(shù)設(shè)置：參數(shù)說明如下
      // Object object：需要操作的對象
      // String property：需要操作的對象的屬性
      // float ....values：動畫初始值 & 結(jié)束值（不固定長度）
      // 若是兩個參數(shù)a,b，則動畫效果則是從屬性的a值到b值
      // 若是三個參數(shù)a,b,c，則則動畫效果則是從屬性的a值到b值再到c值
      // 以此類推
      // 至于如何從初始值 過渡到 結(jié)束值，同樣是由估值器決定，此處ObjectAnimator.ofFloat（）是有系統(tǒng)內(nèi)置的浮點(diǎn)型估值器FloatEvaluator，同ValueAnimator講解

        // 設(shè)置動畫運(yùn)行的時長
        anim.setDuration(500);

        // 設(shè)置動畫延遲播放時間
        anim.setStartDelay(500);

        // 設(shè)置動畫重復(fù)播放次數(shù) = 重放次數(shù)+1
        anim.setRepeatCount(0);
        // 動畫播放次數(shù) = infinite時,動畫無限重復(fù)

        // 設(shè)置重復(fù)播放動畫模式
        anim.setRepeatMode(ValueAnimator.RESTART);
        // ValueAnimator.RESTART(默認(rèn)):正序重放
        // ValueAnimator.REVERSE:倒序回放

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

5.2.2 設(shè)置方法2：在XML 代碼中設(shè)置

步驟一：創(chuàng)建xml動畫文件（必須放到res/animator文件夾下）

set_animation.xml

// ObjectAnimator 采用<animator>  標(biāo)簽
<objectAnimator xmlns:android="http://schemas.android.com/apk/res/android"  
    android:valueFrom="1"   // 初始值
    android:valueTo="0"  // 結(jié)束值
    android:valueType="floatType"  // 變化值類型 ：floatType & intType
    android:propertyName="alpha" // 對象變化的屬性名稱

/>

步驟二：在Java代碼中創(chuàng)建動畫并啟動

Animator animator = AnimatorInflater.loadAnimator(context, R.animator.view_animation);  
// 載入XML動畫

animator.setTarget(view);  
// 設(shè)置動畫對象

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

5.3 使用實(shí)例——四種基本變換

• 此處先展示四種基本變換：平移、旋轉(zhuǎn)、縮放 & 透明度

5.3.1 透明度（“alpha”）

        //此處用button做動畫效果對象
        Button button = (Button) findViewById(R.id.button);

        //創(chuàng)建動畫對象
        ObjectAnimator animator=ObjectAnimator.ofFloat(button,"alpha",1f,0f,1f);
        // 參數(shù)表示的是:
        // 動畫作用對象是button
        // 動畫作用的對象的屬性是透明度alpha
        // 動畫效果是:常規(guī) - 全透明 - 常規(guī)

        //設(shè)置屬性
        animator.setDuration(3000);//設(shè)置動畫時長

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

• 效果圖大致如下：

  
  
  944365-f022260060ab6cd8.gif

5.3.2 旋轉(zhuǎn)（“rotation”）

        //此處用button做動畫效果對象
        Button button = (Button) findViewById(R.id.button);

        //創(chuàng)建動畫對象
        ObjectAnimator animator=ObjectAnimator.ofFloat(button,"rotation",0f,360f);
        // 參數(shù)表示的是:
        // 動畫作用對象是button
        // 動畫作用的對象的屬性是旋轉(zhuǎn)rotation
        // 動畫效果是:0 - 360

        //設(shè)置屬性
        animator.setDuration(3000);//設(shè)置動畫時長

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

• 效果圖大致如下：

944365-3afd2ec909521458.gif

5.3.3 平移（“translationX”或“translationY”）

        //獲取button當(dāng)前位置
        float currentX = button.getX();

        //創(chuàng)建動畫對象
        ObjectAnimator animator = ObjectAnimator.ofFloat(button, "translationX", currentX, currentX*2, currentX);
        // 參數(shù)表示的是:
        // 動畫作用對象是button
        // 動畫作用的對象的屬性是X軸平移（在Y軸上平移同理，采用屬性"translationY"
        // 動畫效果是:從當(dāng)前位置平移到 2倍位置 再平移到初始位置

        //設(shè)置屬性
        animator.setDuration(3000);//設(shè)置動畫時長

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

• 效果圖大致如下：

944365-9ccbc93c0591bebc.gif

5.3.4 縮放（“scaleX”或“scaleY”）

        //此處用button做動畫效果對象
        button = (Button) findViewById(R.id.button);
        
        //創(chuàng)建動畫對象
        ObjectAnimator animator = ObjectAnimator.ofFloat(button, "scaleX", 1f, 3f, 1f);
        // 參數(shù)表示的是:
        // 動畫作用對象是button
        // 動畫作用的對象的屬性是X軸縮放(Y軸是 scaleY)
        // 動畫效果是:放大到3倍,再縮小到初始大小

        //設(shè)置屬性
        animator.setDuration(3000);//設(shè)置動畫時長

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

• 效果圖大致如下：

944365-f77663d1b955f010.gif

5.3.5 四種基本動畫總結(jié)

• 在上面的講解，我們使用了屬性動畫最基本的四種動畫效果：透明度、平移、旋轉(zhuǎn) & 縮放

即在ObjectAnimator.ofFloat（）的第二個參數(shù)String property傳入**alpha、rotation、translationX 和 scaleY **等

5.4 關(guān)于ofFloat()的第二個參數(shù)還能傳入什么屬性值呢？

• 答案：任意屬性值。

• **因為：ObjectAnimator **類 對 對象屬性值 進(jìn)行改變從而實(shí)現(xiàn)動畫效果的本質(zhì)是：通過不斷控制 值 的變化，再不斷 自動 賦給對象的屬性，從而實(shí)現(xiàn)動畫效果

  
  
  944365-7adf6ee408a81f5c.png

• 而 自動賦給對象的屬性的本質(zhì)是調(diào)用該對象屬性的set（） & get（）方法進(jìn)行賦值

• 所以，ObjectAnimator.ofFloat(Object object, String property, float ....values)的第二個參數(shù)傳入值的作用是：讓ObjectAnimator類根據(jù)傳入的屬性名 去尋找 該對象對應(yīng)屬性名的 set（） & get（）方法，從而進(jìn)行對象屬性值的賦值，如上面的例子：

ObjectAnimator animator = ObjectAnimator.ofFloat(mButton, "rotation", 0f, 360f);
// 其實(shí)Button對象中并沒有rotation這個屬性值
// ObjectAnimator并不是直接對我們傳入的屬性名進(jìn)行操作
// 而是根據(jù)傳入的屬性值"rotation" 去尋找對象對應(yīng)屬性名對應(yīng)的get和set方法，從而通過set（） &  get（）對屬性進(jìn)行賦值

// 因為Button對象中有rotation屬性所對應(yīng)的get & set方法
// 所以傳入的rotation屬性是有效的
// 所以才能對rotation這個屬性進(jìn)行操作賦值
public void setRotation(float value);  
public float getRotation();  

// 實(shí)際上，這兩個方法是由View對象提供的，所以任何繼承自View的對象都具備這個屬性

• 至于是如何進(jìn)行自動賦值的，我們直接來看源碼分析：

// 使用方法
ObjectAnimator animator = ObjectAnimator.ofFloat(Object object, String property, float ....values);  
anim.setDuration(500);
animator.start();  
// 啟動動畫，源碼分析就直接從start()開始

<--  start()  -->
@Override  
public void start() {  
    AnimationHandler handler = sAnimationHandler.get();  

    if (handler != null) {  
        // 判斷等待動畫（Pending）中是否有和當(dāng)前動畫相同的動畫，如果有就把相同的動畫給取消掉 
        numAnims = handler.mPendingAnimations.size();  
        for (int i = numAnims - 1; i >= 0; i--) {  
            if (handler.mPendingAnimations.get(i) instanceof ObjectAnimator) {  
                ObjectAnimator anim = (ObjectAnimator) handler.mPendingAnimations.get(i);  
                if (anim.mAutoCancel && hasSameTargetAndProperties(anim)) {  
                    anim.cancel();  
                }  
            }  
        }  
      // 判斷延遲動畫（Delay）中是否有和當(dāng)前動畫相同的動畫，如果有就把相同的動畫給取消掉 
        numAnims = handler.mDelayedAnims.size();  
        for (int i = numAnims - 1; i >= 0; i--) {  
            if (handler.mDelayedAnims.get(i) instanceof ObjectAnimator) {  
                ObjectAnimator anim = (ObjectAnimator) handler.mDelayedAnims.get(i);  
                if (anim.mAutoCancel && hasSameTargetAndProperties(anim)) {  
                    anim.cancel();  
                }  
            }  
        }  
    }  

    super.start();  
   // 調(diào)用父類的start()
   // 因為ObjectAnimator類繼承ValueAnimator類，所以調(diào)用的是ValueAnimator的star（）
   // 經(jīng)過層層調(diào)用，最終會調(diào)用到 自動賦值給對象屬性值的方法
   // 下面就直接看該部分的方法
}  



<-- 自動賦值給對象屬性值的邏輯方法 ->>

// 步驟1：初始化動畫值
private void setupValue(Object target, Keyframe kf) {  
    if (mProperty != null) {  
        kf.setValue(mProperty.get(target));  
        // 初始化時，如果屬性的初始值沒有提供，則調(diào)用屬性的get（）進(jìn)行取值
    }  
        kf.setValue(mGetter.invoke(target));   
    }  
}  

// 步驟2：更新動畫值
// 當(dāng)動畫下一幀來時（即動畫更新的時候），setAnimatedValue（）都會被調(diào)用
void setAnimatedValue(Object target) {  
    if (mProperty != null) {  
        mProperty.set(target, getAnimatedValue());  
        // 內(nèi)部調(diào)用對象該屬性的set（）方法，從而從而將新的屬性值設(shè)置給對象屬性
    }  

}

• 自動賦值的邏輯：

1、初始化時，如果屬性的初始值沒有提供，則調(diào)用屬性的 get（）進(jìn)行取值；
2、當(dāng) 值 變化時，用對象該屬性的 set（）方法，從而從而將新的屬性值設(shè)置給對象屬性。

• 所以：

• ObjectAnimator 類針對的是任意對象 & 任意屬性值，并不是單單針對于View對象

• 如果需要采用ObjectAnimator 類實(shí)現(xiàn)動畫效果，那么需要操作的對象就必須有該屬性的set（） & get（）
• 同理，針對上述另外的三種基本動畫效果，View 也存在著setRotation()、getRotation()、setTranslationX()、getTranslationX()、setScaleY()、getScaleY()等set（） & get（） 。

5.5 使用實(shí)例——通過自定義對象屬性實(shí)現(xiàn)動畫效果

• 對于屬性動畫，其拓展性在于：不局限于系統(tǒng)限定的動畫，可以自定義動畫，即自定義對象的屬性，并通過操作自定義的屬性從而實(shí)現(xiàn)動畫。

• 那么，該如何自定義屬性呢？本質(zhì)上，就是：（類似于ValueAnimator的過程）

• 為對象設(shè)置需要操作屬性的set（） & get（）方法

• 通過實(shí)現(xiàn)TypeEvaluator類從而定義屬性變化的邏輯

• 下面，用一個實(shí)例來說明如何通過自定義屬性實(shí)現(xiàn)動畫效果

• 實(shí)現(xiàn)的動畫效果大致如下：一個圓的顏色漸變

  
  
  944365-3bdaacdd53e7bc30.gif

• 自定義屬性的邏輯如下：（需要自定義屬性為圓的背景顏色）

  
  
  944365-08d6618df6368369.png

步驟1：設(shè)置對象類屬性的set（） & get（）方法

• 設(shè)置對象類屬性的set（） & get（）有兩種方法：

方式一：通過繼承原始類，直接給類加上該屬性的 get（）& set（），從而實(shí)現(xiàn)給對象加上該屬性的 get（）& set（）
方式二：通過包裝原始動畫對象，間接給對象加上該屬性的 get（）&set（）。即 用一個類來包裝原始對象

• 在這個demo中，用第一種方式實(shí)現(xiàn)展示，關(guān)于第二種方式的使用，會在下一節(jié)進(jìn)行詳細(xì)介紹。

MyView02.java自定義View如下：

public class MyView02 extends View {
    //設(shè)置需要用到的變量
    public static final float RADIUS = 100f;  //圓的半徑
    private Paint mPaint;//繪制的畫筆
    private String color;//設(shè)置背景顏色

    //設(shè)置get（）& set()方法
    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;

        //設(shè)置畫筆顏色
        mPaint.setColor(Color.parseColor(color));

        //調(diào)用重繪方法
        invalidate();
        //每次都會調(diào)用onDraw方法重新畫圓，因為每次畫筆顏色都不一樣，所以圓的顏色也會變
    }

    //構(gòu)造方法（因為這里是要在xml中使用這個控件，所以用兩個參數(shù)的構(gòu)造）
    public MyView02(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        //初始化畫筆
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        //設(shè)置初始化筆顏色為藍(lán)色
        mPaint.setColor(Color.BLUE);
    }

    //重寫onDraw方法實(shí)現(xiàn)繪制邏輯
    @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"
    tools:context="com.example.animation02.MainActivity">

    <com.example.animation02.MyView02
        android:id="@+id/myView02"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
    
</RelativeLayout>

步驟3：根據(jù)需求實(shí)現(xiàn)TypeEvaluator接口

• 此處實(shí)現(xiàn)估值器的本質(zhì)是：實(shí)現(xiàn) 顏色過渡的邏輯。

ColorEvaluator.java

public class ColorEvaluator implements TypeEvaluator {
    //定義當(dāng)前RGB的顏色變量
    private int mCurrentRed;
    private int mCurrentGreen;
    private int mCurrentBlue;

    //復(fù)寫evaluate（）方法，實(shí)現(xiàn)動畫過渡的邏輯（這里應(yīng)該寫顏色過渡的邏輯）
    @Override
    public Object evaluate(float fraction, Object startValue, Object endValue) {
        //獲取到顏色的初始值和結(jié)束值
        String startColor = (String) startValue;
        String endColor = (String) endValue;

        //通過字符串截取的方式將初始化顏色分為RGB三個部分，并轉(zhuǎn)換成十進(jìn)制
        //則每個顏色取值范圍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);

        //將初始化顏色值定位為當(dāng)前需要操作的顏色值
        mCurrentRed = startRed;
        mCurrentGreen = startGreen;
        mCurrentBlue = startBlue;

        // 計算初始顏色和結(jié)束顏色之間的差值
        // 該差值決定著顏色變化的快慢:初始顏色值和結(jié)束顏色值很相近，那么顏色變化就會比較緩慢;否則,變化則很快
        // 具體如何根據(jù)差值來決定顏色變化快慢的邏輯寫在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) {
            // getCurrentColor()決定如何根據(jù)差值來決定顏色變化的快慢
            mCurrentRed = getCurrentColor(startRed, endRed, colorDiff,
                    0, fraction);
        } 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);

        return currentColor;
    }

    //具體是根據(jù)fraction值來計算當(dāng)前的顏色。
    //由于我們計算出的顏色是十進(jìn)制數(shù)字，所以需要轉(zhuǎn)換成十六進(jìn)制字符串:調(diào)用getHexString()
    // 最終將RGB顏色拼裝起來,并作為最終的結(jié)果返回
    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;
    }

    //將10進(jìn)制顏色值轉(zhuǎn)換成16進(jìn)制
    private String getHexString(int value) {
        String hexString = Integer.toHexString(value);
        if (hexString.length() == 1) {
            hexString = "0" + hexString;
        }
        return hexString;
    }

}

步驟4：調(diào)用ObjectAnimator.ofObject（）方法

MainActivity.java

public class MainActivity extends AppCompatActivity {

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

        MyView02 myView = (MyView02) findViewById(R.id.myView02);

        //創(chuàng)建動畫對象
       ObjectAnimator animator=ObjectAnimator.ofObject(myView,"color",new ColorEvaluator(),"#0000ff","#ff0000");
        // 參數(shù)表示的是:
        // 設(shè)置自定義View對象、背景顏色屬性值 & 顏色估值器 & 顏色過渡值
        // 屬性值即  setXXX（）的 XXX
        // 本質(zhì)邏輯：
        // 步驟1：根據(jù)顏色估值器不斷 改變 值
        // 步驟2：調(diào)用set（）設(shè)置背景顏色的屬性值（實(shí)際上是通過畫筆進(jìn)行顏色設(shè)置）
        // 步驟3：調(diào)用invalidate()刷新視圖，即調(diào)用onDraw（）重新繪制，從而實(shí)現(xiàn)動畫效果

        //設(shè)置屬性
        animator.setDuration(10000);//設(shè)置動畫時長

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

    }
    
}

5.6 特別注意：如何手動設(shè)置對象類屬性的 set（） & get（）

a. 背景

• ObjectAnimator 類 自動賦給對象的屬性 的本質(zhì)是調(diào)用該對象屬性的set（） & get（）方法進(jìn)行賦值

• 所以，ObjectAnimator.ofFloat(Object object, String property, float ....values)的第二個參數(shù)傳入值的作用是：讓ObjectAnimator類根據(jù)傳入的屬性名 去尋找 該對象對應(yīng)屬性名的 set（） & get（）方法，從而進(jìn)行對象屬性值的賦值

從上面的原理可知，如果想讓對象的屬性a的動畫生效，屬性a需要同時滿足下面兩個條件：
1、對象必須要提供屬性a的set（）方法

a. 如果沒傳遞初始值，那么需要提供get（）方法，因為系統(tǒng)要去拿屬性a的初始值
b. 若該條件不滿足，程序直接Crash

2、對象提供的 屬性a的set（）方法 對 屬性a的改變 必須通過某種方法反映出來

a. 如帶來ui上的變化
b. 若這條不滿足，動畫無效，但不會Crash）

上述條件，一般第二條都會滿足，主要是在第一條

1、比如說：由于View的setWidth（）并不是設(shè)置View的寬度，而是設(shè)置View的最大寬度和最小寬度的；所以通過setWidth（）無法改變控件的寬度；所以對View視圖的width做屬性動畫沒有效果

2、具體請看下面Button按鈕的例子

 Button  mButton = (Button) findViewById(R.id.Button);
        // 創(chuàng)建動畫作用對象：此處以Button為例
        // 此Button的寬高設(shè)置具體為具體寬度200px

               ObjectAnimator.ofInt(mButton, "width", 500).setDuration(5000).start();
                 // 設(shè)置動畫的對象

• 效果圖
  

  944365-1a6e1c2ebb554772.gif

• 為什么沒有動畫效果呢？我們來看View 的 setWidth方法

public void setWidth(int pixels) {  
    mMaxWidth = mMinWidth = pixels;  
    mMaxWidthMode = mMinWidthMode = PIXELS;  
    // 因為setWidth（）并不是設(shè)置View的寬度，而是設(shè)置Button的最大寬度和最小寬度的
    // 所以通過setWidth（）無法改變控件的寬度
   // 所以對width屬性做屬性動畫沒有效果

    requestLayout();  
    invalidate();  
}  


@ViewDebug.ExportedProperty(category = "layout")  
public final int getWidth() {  
    return mRight - mLeft;  
    // getWidth的確是獲取View的寬度
}

b. 問題

• 那么，針對上述對象屬性的set（）不是設(shè)置屬性 或 根本沒有set（） / get （）的情況應(yīng)該如何處理？

c. 解決方案

• 手動設(shè)置對象類屬性的set（） & get（）。共有兩種方法：

1、通過繼承原始類，直接給類加上該屬性的 get（）& set（），從而實(shí)現(xiàn)給對象加上該屬性的 get（）& set（）
2、通過包裝原始動畫對象，間接給對象加上該屬性的 get（）&set（）。即 用一個類來包裝原始對象

• 對于第一種方法，在上面的例子已經(jīng)說明；下面主要講解第二種方法：通過包裝原始動畫對象，間接給對象加上該屬性的get（）& set（）

本質(zhì)上是采用了設(shè)計模式中的裝飾模式，即通過包裝類從而擴(kuò)展對象的功能

• 還是采用上述 Button 按鈕的例子

public class MainActivity extends AppCompatActivity {

    private Button button;
    private ViewWrapper wrapper;

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

        //動畫作用對象
        button = (Button) findViewById(R.id.button);

        //創(chuàng)建包裝類，并傳入動畫作用的對象
        wrapper = new ViewWrapper(button);

        //點(diǎn)擊時開始動畫
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //創(chuàng)建動畫的對象是包裝類的對象
                ObjectAnimator.ofInt(wrapper, "width", 100,500).setDuration(3000).start();
            }
        });


    }

    private class ViewWrapper {
        private View mTarget;

        //構(gòu)造方法：傳入需要包裝的對象
        public ViewWrapper(View target) {
            mTarget = target;
        }

        //為寬度設(shè)置get() & set（）
        public int getWidth() {
            return mTarget.getLayoutParams().width;
        }

        public void setWidth(int width) {
            //動態(tài)改變控件寬度
            mTarget.getLayoutParams().width = width;
            mTarget.requestLayout();
        }
    }

}

• 效果圖大致如下：

  
  
  944365-7889934974344381.gif

6、上文兩種動畫類總結(jié)

• 對比ValueAnimator類 & **ObjectAnimator **類，其實(shí)二者都屬于屬性動畫，本質(zhì)上都是一致的：先改變值，然后 賦值 給對象的屬性從而實(shí)現(xiàn)動畫效果。

• 但二者的區(qū)別在于：

• **ValueAnimator **類是先改變值，然后 手動賦值 給對象的屬性從而實(shí)現(xiàn)動畫；是 間接 對對象屬性進(jìn)行操作；ValueAnimator 類本質(zhì)上是一種 改變 值 的操作機(jī)制

• ObjectAnimator類是先改變值，然后 自動賦值 給對象的屬性從而實(shí)現(xiàn)動畫；是 直接 對對象屬性進(jìn)行操作；可以理解為：ObjectAnimator更加智能、自動化程度更高

7、具體使用——AnimatorSet 類（組合動畫）

• 單一動畫實(shí)現(xiàn)的效果相當(dāng)有限，更多的使用場景是同時使用多種動畫效果，即組合動畫

• 實(shí)現(xiàn) 組合動畫 的功能：AnimatorSet類

• 具體使用：

AnimatorSet.play(Animator anim)   ：播放當(dāng)前動畫
AnimatorSet.after(long delay)   ：將現(xiàn)有動畫延遲x毫秒后執(zhí)行
AnimatorSet.with(Animator anim)   ：將現(xiàn)有動畫和傳入的動畫同時執(zhí)行
AnimatorSet.after(Animator anim)   ：將現(xiàn)有動畫插入到傳入的動畫之后執(zhí)行
AnimatorSet.before(Animator anim) ：  將現(xiàn)有動畫插入到傳入的動畫之前執(zhí)行

實(shí)例演示

• 實(shí)現(xiàn)方式有 XML設(shè)置 / Java代碼設(shè)置

• 演示效果說明：主要動畫是平移，平移過程中伴隨旋轉(zhuǎn)動畫，平移完后進(jìn)行透明度變化

  
  
  944365-a27607d0dd6eb8d9.gif

實(shí)現(xiàn)方式一：Java代碼設(shè)置

        //動畫作用對象
        Button button = (Button) findViewById(R.id.button);

        //步驟1：設(shè)置需要組合的動畫效果
        //平移動畫
        ObjectAnimator translation = ObjectAnimator.ofFloat(button, "translationX", 100, 300, 100);
        //旋轉(zhuǎn)動畫
        ObjectAnimator rotate = ObjectAnimator.ofFloat(button, "rotation", 0f, 360f);
        //透明度動畫
        ObjectAnimator alpha = ObjectAnimator.ofFloat(button, "alpha", 1f, 0f, 1f);

        //步驟2：創(chuàng)建組合動畫的對象
        AnimatorSet animatorSet = new AnimatorSet();

        //步驟3：根據(jù)組合動畫的對象
        animatorSet.play(translation).with(rotate).before(alpha);
        animatorSet.setDuration(5000);

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

實(shí)現(xiàn)方式二：xml代碼設(shè)置

步驟1：創(chuàng)建xml動畫文件（必須放在res/animator文件夾下）

set_animation.xml

<?xml version="1.0" encoding="utf-8"?><!-- ValueAnimator采用<animator>  標(biāo)簽-->
<set xmlns:android="http://schemas.android.com/apk/res/android"
    android:ordering="sequentially">
    // 上面這個屬性表示Set集合內(nèi)的動畫按順序進(jìn)行
    // sequentially:表示set中的動畫，按照先后順序逐步進(jìn)行（a 完成之后進(jìn)行 b ）
    // together:表示set中的動畫，在同一時間同時進(jìn)行,為默認(rèn)值

    <set android:ordering="together">
        //下面的動畫同時執(zhí)行
        <objectAnimator
            android:duration="2000"
            android:propertyName="translationX"
            android:valueFrom="0"
            android:valueTo="300"
            android:valueType="floatType">
        </objectAnimator>

        <objectAnimator
            android:duration="3000"
            android:propertyName="rotation"
            android:valueFrom="0"
            android:valueTo="360"
            android:valueType="floatType">
        </objectAnimator>
    </set>
    
    <set android:ordering="sequentially">
        //下面的動畫按序進(jìn)行
        <objectAnimator
            android:duration="1500"
            android:propertyName="alpha"
            android:valueFrom="1"
            android:valueTo="0"
            android:valueType="floatType">
        </objectAnimator>
        <objectAnimator
            android:duration="1500"
            android:propertyName="alpha"
            android:valueFrom="0"
            android:valueTo="1"
            android:valueType="floatType">
        </objectAnimator>
    </set>
</set>

步驟2：在Java代碼中創(chuàng)建動畫對象并啟動

        //動畫作用對象
        Button button = (Button) findViewById(R.id.button);

        //創(chuàng)建組合動畫對象 & 加載xml動畫
        AnimatorSet animator = (AnimatorSet) AnimatorInflater.loadAnimator(this, R.animator.set_animator);

        //設(shè)置動畫作用對象
        animator.setTarget(button);

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

8、關(guān)于動畫監(jiān)聽

• 因Animator類、AnimatorSet類、ValueAnimator、ObjectAnimator類存在以下繼承關(guān)系
  

  944365-56dfb73edfed1293.png

• Animation類通過監(jiān)聽動畫開始 / 結(jié)束 / 重復(fù) / 取消時刻來進(jìn)行一系列操作，如跳轉(zhuǎn)頁面等等
  通過在Java代碼里addListener（）設(shè)置

        //屬性動畫的監(jiān)聽
        animator.addListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animation) {
                //動畫開始時執(zhí)行
            }

            @Override
            public void onAnimationEnd(Animator animation) {
                //動畫結(jié)束時執(zhí)行
            }

            @Override
            public void onAnimationCancel(Animator animation) {
                //動畫取消時執(zhí)行
            }

            @Override
            public void onAnimationRepeat(Animator animation) {
                //動畫重復(fù)時執(zhí)行
            }
        });

9、屬性動畫拓展之ViewPropertyAnimator動畫

• 請查看原文：http://blog.csdn.net/yanbober/article/details/46481171 或 http://www.lxweimin.com/p/2412d00a0ce4