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

屬性動畫（Property Animation）是在 Android 3.0（API 11）后才提供的一種全新動畫模式
那么為什么要提供屬性動畫（Property Animation）煤蚌？
1.1 背景

實現(xiàn)動畫效果在Android開發(fā)中非常常見，因此Android系統(tǒng)一開始就提供了兩種實現(xiàn)動畫的方式：

逐幀動畫（Frame Animation）
補間動畫（ Tweened animation ）
1.2 問題

逐幀動畫 & 補間動畫存在一定的缺點：

a. 作用對象局限：View

即補間動畫 只能夠作用在視圖View上，即只可以對一個Button、TextView橘洞、甚至是LinearLayout映企、或者其它繼承自View的組件進(jìn)行動畫操作，但無法對非View的對象進(jìn)行動畫操作

有些情況下的動畫效果只是視圖的某個屬性 & 對象而不是整個視圖；
如要拂，現(xiàn)需要實現(xiàn)視圖的顏色動態(tài)變化，那么就需要操作視圖的顏色屬性從而實現(xiàn)動畫效果站楚，而不是針對整個視圖進(jìn)行動畫操作
b. 沒有改變View的屬性脱惰，只是改變視覺效果

補間動畫只是改變了View的視覺效果，而不會真正去改變View的屬性窿春。
如拉一，將屏幕左上角的按鈕 通過補間動畫 移動到屏幕的右下角
點擊當(dāng)前按鈕位置（屏幕右下角）是沒有效果的，因為實際上按鈕還是停留在屏幕左上角旧乞，補間動畫只是將這個按鈕繪制到屏幕右下角蔚润，改變了視覺效果而已。
c. 動畫效果單一

補間動畫只能實現(xiàn)平移尺栖、旋轉(zhuǎn)嫡纠、縮放 & 透明度這些簡單的動畫需求
一旦遇到相對復(fù)雜的動畫效果，即超出了上述4種動畫效果决瞳，那么補間動畫則無法實現(xiàn)。
即在功能 & 可擴展性有較大局限性
1.3 問題

為了解決補間動畫的缺陷左权，在 Android 3.0（API 11）開始皮胡，系統(tǒng)提供了一種全新的動畫模式：屬性動畫（Property Animation）
下面，我將全面介紹屬性動畫（Property Animation）

2. 簡介

作用對象：任意 Java 對象
不再局限于 視圖View對象
實現(xiàn)的動畫效果：可自定義各種動畫效果
不再局限于4種基本變換：平移赏迟、旋轉(zhuǎn)屡贺、縮放 & 透明度

3. 特點

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

4. 工作原理

在一定時間間隔內(nèi)甩栈，通過不斷對值進(jìn)行改變，并不斷將該值賦給對象的屬性糕再，從而實現(xiàn)該對象在該屬性上的動畫效果
可以是任意對象的任意屬性
具體的工作原理邏輯如下：

這里寫圖片描述

從上述工作原理可以看出屬性動畫有兩個非常重要的類：ValueAnimator 類 & ObjectAnimator 類
其實屬性動畫的使用基本都是依靠這兩個類
所以量没，在下面介紹屬性動畫的具體使用時，我會著重介紹這兩個類突想。
2.ObjectAnimator類
2.1實現(xiàn)動畫的原理
如直接改變 View的 alpha 屬性 從而實現(xiàn)透明度的動畫效果
繼承自ValueAnimator類殴蹄，即底層的動畫實現(xiàn)機制是基于ValueAnimator類

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

這里寫圖片描述

從上面的工作原理可以看出：ObjectAnimator與 ValueAnimator類的區(qū)別：

ValueAnimator 類是先改變值，然后 手動賦值 給對象的屬性從而實現(xiàn)動畫绑嘹；是 間接 對對象屬性進(jìn)行操作稽荧；
ObjectAnimator 類是先改變值，然后 自動賦值 給對象的屬性從而實現(xiàn)動畫工腋；是 直接 對對象屬性進(jìn)行操作姨丈；
至于是如何自動賦值給對象的屬性畅卓，下面會詳細(xì)說明

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

設(shè)置方式1：Java 設(shè)置

ObjectAnimator animator = ObjectAnimator.ofFloat(Object object, String property, float ....values);

// ofFloat()作用有兩個
// 1. 創(chuàng)建動畫實例
// 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)置的浮點型估值器FloatEvaluator唐础，同ValueAnimator講解

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

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

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

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

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

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

// 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代碼中啟動動畫

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

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

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

問題：那么ofFloat()的第二個參數(shù)還能傳入什么屬性值呢？
答案：任意屬性值矾飞。因為：

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

這里寫圖片描述

而 自動賦給對象的屬性的本質(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);
// 其實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();

// 實際上瞒津，這兩個方法是由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è)置給對象屬性
}

}
自動賦值的邏輯：

初始化時，如果屬性的初始值沒有提供阵赠，則調(diào)用屬性的 get（）進(jìn)行取值烁落；
當(dāng) 值 變化時，用對象該屬性的 set（）方法豌注，從而從而將新的屬性值設(shè)置給對象屬性伤塌。
所以：

ObjectAnimator 類針對的是任意對象 & 任意屬性值，并不是單單針對于View對象
如果需要采用ObjectAnimator 類實現(xiàn)動畫效果轧铁，那么需要操作的對象就必須有該屬性的set（） & get（）
同理每聪，針對上述另外的三種基本動畫效果，View 也存在著setRotation()、getRotation()药薯、setTranslationX()绑洛、getTranslationX()、setScaleY()童本、getScaleY()等set（） & get（） 真屯。

2.3 通過自定義對象屬性實現(xiàn)動畫效果

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

那么配深，該如何自定義屬性呢？本質(zhì)上嫁盲，就是：

為對象設(shè)置需要操作屬性的set（） & get（）方法
通過實現(xiàn)TypeEvaluator類從而定義屬性變化的邏輯
類似于ValueAnimator的過程
下面篓叶，我將用一個實例來說明如何通過自定義屬性實現(xiàn)動畫效果

實現(xiàn)的動畫效果：一個圓的顏色漸變

這里寫圖片描述

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

這里寫圖片描述

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

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

通過繼承原始類，直接給類加上該屬性的 get（）& set（）羞秤，從而實現(xiàn)給對象加上該屬性的 get（）& set（）

通過包裝原始動畫對象缸托，間接給對象加上該屬性的 get（）&
set（）。即 用一個類來包裝原始對象

此處主要使用第一種方式進(jìn)行展示瘾蛋。

關(guān)于第二種方式的使用俐镐，會在下一節(jié)進(jìn)行詳細(xì)介紹。

MyView2.java

public class MyView2 extends View {
// 設(shè)置需要用到的變量
public static final float RADIUS = 100f;// 圓的半徑 = 100
private Paint mPaint;// 繪圖畫筆

private String color;
// 設(shè)置背景顏色屬性

// 設(shè)置背景顏色的get() & set()方法
public String getColor() {
    return color;
}

public void setColor(String color) {
    this.color = color;
    mPaint.setColor(Color.parseColor(color));
    // 將畫筆的顏色設(shè)置成方法參數(shù)傳入的顏色
    invalidate();
    // 調(diào)用了invalidate()方法,即畫筆顏色每次改變都會刷新視圖瘦黑，然后調(diào)用onDraw()方法重新繪制圓
    // 而因為每次調(diào)用onDraw()方法時畫筆的顏色都會改變,所以圓的顏色也會改變
}


// 構(gòu)造方法(初始化畫筆)
public MyView2(Context context, AttributeSet attrs) {
    super(context, attrs);
    // 初始化畫筆
    mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
    mPaint.setColor(Color.BLUE);
}

// 復(fù)寫onDraw()從而實現(xiàn)繪制邏輯
// 繪制邏輯:先在初始點畫圓,通過監(jiān)聽當(dāng)前坐標(biāo)值(currentPoint)的變化,每次變化都調(diào)用onDraw()重新繪制圓,從而實現(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"
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：根據(jù)需求實現(xiàn)TypeEvaluator接口

ColorEvaluator.java

public class ColorEvaluator implements TypeEvaluator {
// 實現(xiàn)TypeEvaluator接口

private int mCurrentRed;

private int mCurrentGreen ;

private int mCurrentBlue ;

// 復(fù)寫evaluate（）
// 在evaluate（）里寫入對象動畫過渡的邏輯:此處是寫顏色過渡的邏輯
@Override
public Object evaluate(float fraction, Object startValue, Object endValue) {

    // 獲取到顏色的初始值和結(jié)束值
    String startColor = (String) startValue;
    String endColor = (String) endValue;

    // 通過字符串截取的方式將初始化顏色分為RGB三個部分京革，并將RGB的值轉(zhuǎn)換成十進(jìn)制數(shù)字
    // 那么每個顏色的取值范圍就是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) {
        mCurrentRed = getCurrentColor(startRed, endRed, colorDiff, 0,
                fraction);
                // getCurrentColor()決定如何根據(jù)差值來決定顏色變化的快慢 ->>關(guān)注1
    } else if (mCurrentGreen != endGreen) {
        mCurrentGreen = getCurrentColor(startGreen, endGreen, colorDiff,
                redDiff, fraction);
    } else if (mCurrentBlue != endBlue) {
        mCurrentBlue = getCurrentColor(startBlue, endBlue, colorDiff,
                redDiff + greenDiff, fraction);
    }
    // 將計算出的當(dāng)前顏色的值組裝返回
    String currentColor = "#" + getHexString(mCurrentRed)
            + getHexString(mCurrentGreen) + getHexString(mCurrentBlue);

    // 由于我們計算出的顏色是十進(jìn)制數(shù)字幸斥，所以需要轉(zhuǎn)換成十六進(jìn)制字符串:調(diào)用getHexString()->>關(guān)注2
    // 最終將RGB顏色拼裝起來,并作為最終的結(jié)果返回
    return currentColor;
}


// 關(guān)注1:getCurrentColor()
// 具體是根據(jù)fraction值來計算當(dāng)前的顏色。

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;
}

// 關(guān)注2:將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 {

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

    myView2 = (MyView2) findViewById(R.id.MyView2);
    ObjectAnimator anim = ObjectAnimator.ofObject(myView2, "color", new ColorEvaluator(),
            "#0000FF", "#FF0000");
    // 設(shè)置自定義View對象甲葬、背景顏色屬性值 & 顏色估值器
    // 本質(zhì)邏輯：
    // 步驟1：根據(jù)顏色估值器不斷 改變 值 
    // 步驟2：調(diào)用set（）設(shè)置背景顏色的屬性值（實際上是通過畫筆進(jìn)行顏色設(shè)置）
    // 步驟3：調(diào)用invalidate()刷新視圖，即調(diào)用onDraw（）重新繪制懈贺，從而實現(xiàn)動畫效果

    anim.setDuration(8000);
    anim.start();
}

}
效果圖

這里寫圖片描述

2.4 特別注意：如何手動設(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需要同時滿足下面兩個條件：

對象必須要提供屬性a的set（）方法
a. 如果沒傳遞初始值，那么需要提供get（）方法堡妒，因為系統(tǒng)要去拿屬性a的初始值
b. 若該條件不滿足配乱，程序直接Crash
對象提供的 屬性a的set（）方法 對 屬性a的改變 必須通過某種方法反映出來
a. 如帶來ui上的變化
b. 若這條不滿足，動畫無效，但不會Crash）
上述條件搬泥，一般第二條都會滿足桑寨，主要是在第一條

比如說：由于View的setWidth（）并不是設(shè)置View的寬度，而是設(shè)置View的最大寬度和最小寬度的；所以通過setWidth（）無法改變控件的寬度；所以對View視圖的width做屬性動畫沒有效果
具體請看下面Button按鈕的例子
Button mButton = (Button) findViewById(R.id.Button);
// 創(chuàng)建動畫作用對象：此處以Button為例
// 此Button的寬高設(shè)置具體為具體寬度200px

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

效果圖

這里寫圖片描述

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（）。共有兩種方法：

通過繼承原始類，直接給類加上該屬性的 get（）& set（）芭碍，從而實現(xiàn)給對象加上該屬性的 get（）& set（）

通過包裝原始動畫對象，間接給對象加上該屬性的 get（）&
set（）孽尽。即 用一個類來包裝原始對象

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

本質(zhì)上是采用了設(shè)計模式中的裝飾模式瞻讽，即通過包裝類從而擴展對象的功能
還是采用上述 Button 按鈕的例子

public class MainActivity extends AppCompatActivity {
Button mButton;
ViewWrapper wrapper;

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

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

    wrapper = new ViewWrapper(mButton);
    // 創(chuàng)建包裝類,并傳入動畫作用的對象
    
    mButton.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {

            ObjectAnimator.ofInt(wrapper, "width", 500).setDuration(3000).start();
            // 設(shè)置動畫的對象是包裝類的對象
        }
    });

}
// 提供ViewWrapper類,用于包裝View對象
// 本例:包裝Button對象
private static 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) {
        mTarget.getLayoutParams().width = width;
        mTarget.requestLayout();
    }

}

}
效果圖

這里寫圖片描述

4 總結(jié)

對比ValueAnimator類 & ObjectAnimator 類，其實二者都屬于屬性動畫熏挎，本質(zhì)上都是一致的：先改變值速勇，然后 賦值 給對象的屬性從而實現(xiàn)動畫效果。
但二者的區(qū)別在于：
ValueAnimator 類是先改變值坎拐，然后 手動賦值 給對象的屬性從而實現(xiàn)動畫烦磁；是 間接 對對象屬性進(jìn)行操作；
ValueAnimator 類本質(zhì)上是一種 改變 值 的操作機制
ObjectAnimator類是先改變值哼勇，然后 自動賦值 給對象的屬性從而實現(xiàn)動畫都伪；是 直接 對對象屬性進(jìn)行操作；

可以理解為：ObjectAnimator更加智能积担、自動化程度更高