特别提醒：本文参考摘自【工匠若水 http://blog.csdn.net/yanbober/article/details/46481171 】 及Carson_Ho：【//www.greatytc.com/p/2412d00a0ce4 】 强烈建议读者进入原博客查看学习。】

1、Android动画简介

1.1 分类

Android系统提供了很多丰富的API去实现UI的2D与3D动画，最主要的划分可以分为如下几类：

Drawable Animation： 这种动画（也叫Frame动画、帧动画）其实可以划分到视图动画的类别，专门用来一个一个的显示Drawable的resources，就像放幻灯片一样。

View Animation： 视图动画在古老的Android版本系统中就已经提供了，只能被用来设置View的动画。

**Property Animation： **属性动画只对Android 3.0（API 11）以上版本的Android系统才有效，这种动画可以设置给任何Object，包括那些还没有渲染到屏幕上的对象。这种动画是可扩展的，可以让你自定义任何类型和属性的动画。

1.2 每种动画的特点及区别

Drawable Animation：帧动画没有什么好说的，就是把几张图片按一定间隔顺序显示出来，就像播放幻灯片一样，实际开发中用处不大。

View Animation：View动画只能够为View添加动画，如果想为非View对象添加动画须自己实现；且View动画支持的种类很少；尤其是他改变的是View的绘制效果，View的属性没有改变，其位置与大小都不变； View动画代码量少，使用简单方便。

**Property Animation： **属性动画弥补了View动画的缺陷，可以为一个对象的任意属性添加动画，对象自己的属性会被真的改变；当对象的属性变化的时候，属性动画会自动刷新屏幕；属性动画改变的是对象的真实属性，而且属性动画不止用于View，还可以用于任何对象。

2、属性动画简介（Property Animation）

2.1 属性动画出现的原因

• 原因：Android中另外两种动画帧动画和View动画有太多的局限性：

1、帧动画:完全就是通过时间差来显示不同的图片，适用场景和实用性非常小，即使有很多地方可以用帧动画来做，但是要存放那么多图片资源，这样会增加apk大小，这无疑是不明智的做法。
2、View动画：View动画还是比较实用的，能够解决一般APP开发中大部分需要的动画，但View动画也有很多缺点。首先：动画效果无疑是平面平移、平面旋转、透明度变化以及大小缩放几种动画，如果说现在要想实现卡片翻转的3D效果，则View动画就实现不了；再有：View动画顾名思义，只能为View添加这些动画；第三：没有改变View的属性，只是改变视觉效果，比如将屏幕左上角的按钮 通过补间动画 移动到屏幕的右下角，点击当前按钮位置（屏幕右下角）是没有效果的，因为实际上按钮还是停留在屏幕左上角，补间动画只是将这个按钮绘制到屏幕右下角，改变了视觉效果而已。

• 所以：为了解决补间动画的缺陷，在 Android 3.0（API 11）开始，系统提供了一种全新的动画模式：属性动画（Property Animation）

2.2 属性动画简介

• 作用对象：任意 Java 对象

不再局限于 视图View对象

• 实现的动画效果：可自定义各种动画效果

不再局限于4种基本变换：平移、旋转、缩放 & 透明度

2.3 属性动画特点

• 作用对象进行了扩展：不只是View对象，甚至没对象也可以
• 动画效果：不只是4种基本变换，还有其他动画效果
• 作用领域：Android 3.0（API 11）后引入的

3、属性动画使用相关

3.1 属性动画使用相关类

• 所有的属性动画的抽象基类就是它：

/**
 * 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 {
    ......
}

• 他的实现子类(红色标注的)， 可以看见，属性动画的实现有7个类：

3050655-46ea1b4994a9ec77.png

• 我们平时使用属性动画的重点就在于AnimatorSet、ObjectAnimator、TimeAnimator、ValueAnimator。：

3050655-624cc1dde19ca8e1.png

3.2 属性解释：

3.2.1<set>属性解释：

3.2.2 <objectAnimator>属性解释：

3.3 Evaluators（估值器）相关类解释：

• Evaluators就是属性动画系统如何去计算一个属性值。它们通过Animator提供的动画的起始和结束值去计算一个动画的属性值。

3.4 Interpolators（插值器）相关类解释：

4、具体使用--ValueAnimator类

4.1 定义、原理

• 定义：属性动画机制中 最核心的一个类

• 实现动画的原理：通过不断控制 值 的变化，再不断 手动 赋给对象的属性，从而实现动画效果。

4.2 ValueAnimator类中常用方法：

• ValueAnimator.ofInt（int values）

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

4.2.1 ValueAnimator.ofInt（int values）

• 作用：将初始值 以整型数值的形式 过渡到结束值

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

设置方式一：Java代码中设置

实际开发中，建议使用Java代码实现属性动画：因为很多时候属性的起始值是无法提前确定的（无法使用XML设置），这就需要在Java代码里动态获取。

        //步骤1：设置动画属性的初始值 & 结束值
        ValueAnimator animator = ValueAnimator.ofInt(0, 3);
        // ofInt（）作用有两个
        // 1. 创建动画实例
        // 2. 将传入的多个Int参数进行平滑过渡:此处传入0和1,表示将值从0平滑过渡到1
        // 如果传入了3个Int参数 a,b,c ,则是先从a平滑过渡到b,再从b平滑过渡到C，以此类推
        // ValueAnimator.ofInt()内置了整型估值器,直接采用默认的.不需要设置，即默认设置了如何从初始值 过渡到 结束值
        // 关于自定义插值器我将在下节进行讲解

        //步骤2：设置动画的播放各种属性
        animator.setDuration(500);//设置动画时长
        animator.setStartDelay(100);//设置动画延迟播放时间
        animator.setRepeatCount(0);// 设置动画重复播放次数 = 重放次数+1
        // 当动画播放次数 = infinite时,动画无限重复
        animator.setRepeatMode(ValueAnimator.RESTART);// 设置重复播放动画模式
        // ValueAnimator.RESTART(默认):正序重放
        // ValueAnimator.REVERSE:倒序回放

        //步骤3：将改变的值手动赋值给对象的属性值：通过动画的更新监听器
        // 设置 值的更新监听器   即：值每次改变、变化一次,该方法就会被调用一次
        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                //获取改变后的值
                int currentValue = (int) animation.getAnimatedValue();

                //步骤4：将改变后的值赋给对象的属性值，后文会详细说明


                //步骤5：刷新视图，即重新绘制，从而实现动画效果
                xxx.requestLayout();
            }
        });

       //步骤6：设置对象 &&　启动动画
        animator.setTarget(button);
        animator.start();

设置方式二：在XML 文件中设置

步骤一：创建xml动画文件，设置参数（必须放到 res/animator 文件夹下）

set_animator.xml文件如下：

<animator xmlns:android="http://schemas.android.com/apk/res/android"  
    android:valueFrom="0"   // 初始值
    android:valueTo="100"  // 结束值
    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 // 插值器，即影响动画的播放速度,后文会详细讲

/>

步骤二：在Java代码中创建动画并启动

//创建动画对象
        Animator animator= AnimatorInflater.loadAnimator(this,R.animator.set_animator);

        //设置动画对象
        animator.setTarget(view);

        //启动动画
        animator.start();

实例演示

• 演示效果说明：将Button的宽度从100px变成500px

• 效果图大致如下：

  
  
  944365-cf61973c2bcbc9ee.gif

• 这里仅演示Java代码中设置：

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

        //实现的效果：让button的宽度从 100px到500px

        //步骤1：创建对象
        ValueAnimator valueAnimator = ValueAnimator.ofInt(100, 500);
        // ValueAnimator.ofInt()内置了整型估值器,直接采用默认的.不需要设置

        //步骤2：设置属性
        valueAnimator.setDuration(3000);

        //步骤3：将属性数值手动赋值给对象的属性:此处是将 值 赋给 按钮的宽度
        //置更新监听器：即数值每次变化更新都会调用该方法
        valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                //获取当前值
                int currentValue = (int) animation.getAnimatedValue();

                //步骤4：将改变后的值赋予对象的属性值
                button.getLayoutParams().width = currentValue;

                //步骤5：刷新视图，即重新绘制，从而实现动画效果
                button.requestLayout();
            }
        });

        //步骤6：设置对象 &&　启动动画
        valueAnimator.setTarget(button);
        valueAnimator.start();

    }

}

4.2.2 ValueAnimator.ofFloat（float values）

• 作用：将初始值 以浮点型数值的形式 过渡到结束值

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

• 设置方式及使用方法同ofInt(int values)一模一样（此处就不作说明了）

• ValueAnimator.ofInt（）与ValueAnimator.oFloat（）仅仅只是在估值器上的区别：（即如何从初始值 过渡 到结束值）

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

4.2.3 ValueAnimator.ofObject（）

• 作用：将初始值 以对象的形式 过渡到结束值

即通过操作 对象 实现动画效果

• 具体使用：

// 创建初始动画时的对象  & 结束动画时的对象
myObject object1 = new myObject();  
myObject object2 = new myObject();  

ValueAnimator anim = ValueAnimator.ofObject(new myObjectEvaluator(), object1, object2);  
// 创建动画对象 & 设置参数
// 参数说明
// 参数1：自定义的估值器对象（TypeEvaluator 类型参数） - 下面会详细介绍
// 参数2：初始动画的对象
// 参数3：结束动画的对象
anim.setDuration(5000);  
anim.start();

• 在继续讲解ValueAnimator.ofObject（）的使用前，我先讲一下估值器（TypeEvaluator）

估值器（TypeEvaluator） 介绍

• 作用：设置动画 如何从初始值 过渡到 结束值 的逻辑

1、插值器（Interpolator）决定 值 的变化模式（匀速、加速blabla）
2、估值器（TypeEvaluator）决定 值 的具体变化数值

从前文中可看到：

• ValueAnimator.ofFloat（）实现了 将初始值 以浮点型的形式 过渡到结束值 的逻辑，那么这个过渡逻辑具体是怎么样的呢？
• 其实是系统内置了一个 FloatEvaluator估值器，内部实现了初始值与结束值 以浮点型的过渡逻辑
• 我们来看一下 FloatEvaluator的代码实现：

public class FloatEvaluator implements TypeEvaluator {  
// FloatEvaluator实现了TypeEvaluator接口

// 重写evaluate()
    public Object evaluate(float fraction, Object startValue, Object endValue) {  
// 参数说明
// fraction：表示动画完成度（根据它来计算当前动画的值）
// startValue、endValue：动画的初始值和结束值
        float startFloat = ((Number) startValue).floatValue();  

        return startFloat + fraction * (((Number) endValue).floatValue() - startFloat);  
        // 初始值 过渡 到结束值 的算法是：
        // 1. 用结束值减去初始值，算出它们之间的差值
        // 2. 用上述差值乘以fraction系数
        // 3. 再加上初始值，就得到当前动画的值
    }  
}

• ValueAnimator.ofInt（） & ValueAnimator.ofFloat（）都具备系统内置的估值器，即**FloatEvaluator **& IntEvaluator

即系统已经默认实现了 如何从初始值 过渡到 结束值 的逻辑

• 但对于ValueAnimator.ofObject（），从上面的工作原理可以看出并没有系统默认实现，因为对对象的动画操作复杂 & 多样，系统无法知道如何从初始对象过度到结束对象
• 因此，对于ValueAnimator.ofObject（），我们需自定义估值器（TypeEvaluator）来告知系统如何进行从 初始对象 过渡到 结束对象的逻辑
• 自定义实现的逻辑如下:

// 实现TypeEvaluator接口
public class ObjectEvaluator implements TypeEvaluator{  

// 复写evaluate（）
// 在evaluate（）里写入对象动画过渡的逻辑
    @Override  
    public Object evaluate(float fraction, Object startValue, Object endValue) {  
        // 参数说明
        // fraction：表示动画完成度（根据它来计算当前动画的值）
        // startValue、endValue：动画的初始值和结束值

        ... // 写入对象动画过渡的逻辑

        return value;  
        // 返回对象动画过渡的逻辑计算后的值
    }

实例说明

• 下面我将用实例说明 该如何自定义TypeEvaluator接口并通过ValueAnimator.ofObject（）实现动画效果

• 实现的动画效果大致如下：一个圆从一个点 移动到 另外一个点

  
  
  944365-45b817bd4ca8c119.gif

步骤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接口

• 实现TypeEvaluator接口的目的是自定义如何 从初始点坐标 过渡 到结束点坐标；

• 本例实现的是一个从左上角到右下角的坐标过渡逻辑。
  PointEvaluator.java

public class PointEvaluator implements TypeEvaluator {
    //复写evaluate（）
    //在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;
    }
}

• 上面步骤是根据需求自定义TypeEvaluator的实现

• 下面将讲解如何通过对 Point 对象进行动画操作，从而实现整个自定义View的动画效果。

步骤3 : 将属性动画作用到自定义View当中

MyView.java

public class MyView extends View {
    //设置需要用到的变量
    public static final float RADIUS = 50f;//园的半径
    private Point currentPoint;//当前点坐标
    private Paint mPaint;//画笔

    //在构造方法里初始化画笔（因为这里我们要用在xml文件中，所以用两个参数的）
    public MyView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        //初始化画笔
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        //定义画笔颜色
        mPaint.setColor(Color.BLUE);
    }

    //复写onDraw（）实现绘制逻辑
    //绘制逻辑：先在初始点画圆，通过监听当前坐标值得变化，
    //每次变化都调用onDraw重新绘制圆，从而实现圆的平移动画效果
    @Override
    protected void onDraw(Canvas canvas) {
        //如果当前点坐标为空（即第一次）
        if (currentPoint == null) {
            //创建一个点对象（坐标是半径，这样的话就能在屏幕显示全）
            currentPoint = new Point(RADIUS, RADIUS);

            //在该点画一个圆：圆心=（50,50），半径=50
            float x = currentPoint.getX();
            float y = currentPoint.getX();
            canvas.drawCircle(x, y, RADIUS, mPaint);

            //以下是重点代码

            //步骤1：创建初始动画时的对象点 & 结束动画时的对象点
            Point startPoint = new Point(RADIUS, RADIUS);//初始点为圆心（50，50）
            Point endPoint = new Point(700, 1000);//结束点为（700,1000）

            //步骤2：创建动画对象 & 设置初始值 和 结束值
            ValueAnimator animator = ValueAnimator.ofObject(new PointEvaluator(), startPoint, endPoint);
            // 参数说明
            // 参数1：TypeEvaluator 类型参数 - 使用自定义的PointEvaluator(实现了TypeEvaluator接口)
            // 参数2：初始动画的对象点
            // 参数3：结束动画的对象点

            //步骤3：设置动画参数
            animator.setDuration(5000);//动画时长

            //步骤4：通过 值 的更新监听器，将改变的对象手动赋值给当前对象
            // 此处是将 改变后的坐标值对象 赋给 当前的坐标值对象
            // 设置 值的更新监听器,即每当坐标值（Point对象）更新一次,该方法就会被调用一次
            animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
                @Override
                public void onAnimationUpdate(ValueAnimator animation) {
                    // 将每次变化后的坐标值（估值器PointEvaluator中evaluate（）返回的Piont对象值）到当前坐标值对象（currentPoint）
                    // 从而更新当前坐标值（currentPoint）
                    currentPoint = (Point) animation.getAnimatedValue();

                    //步骤5：每次赋值后就重新绘制，从而实现动画效果
                    invalidate();
                    // 调用invalidate()后,就会刷新View,即才能看到重新绘制的界面,即onDraw()会被重新调用一次
                    // 所以坐标值每改变一次,就会调用onDraw()一次
                }
            });

            //步骤6：启动动画
            animator.start();

        } else {
            //如果坐标值不为0，则画圆
            //坐标值每改变一次,就会调用onDraw()一次,就会画一次圆,从而实现动画效果

            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：在主代码文件设置显示视图

public class MainActivity extends AppCompatActivity {

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

    }

}

• 效果图大致是这样的：

  
  
  944365-45b817bd4ca8c119.gif

特别注意

• 从上文可以看出，其实ValueAnimator.ofObject（）的本质还是操作 值 ，只是是采用将 多个值 封装到一个对象里的方式 同时对多个值一起操作而已

就像上文的例子，本质还是操作坐标中的x，y两个值，只是将其封装到Point对象里，方便同时操作x，y两个值而已

• 至此，关于属性动画中最核心的 ValueAnimator类已经讲解完毕

5、具体使用--ObjectAnimator类

5.1 实现动画的原理

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

1.如直接改变 View的 alpha 属性 从而实现透明度的动画效果
2.继承自ValueAnimator类，即底层的动画实现机制是基于ValueAnimator类

• 本质原理： 通过不断控制 值 的变化，再不断 自动 赋给对象的属性，从而实现动画效果。

• ObjectAnimator与 ValueAnimator类的区别：

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

5.2 实现的方式

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

5.2.1 设置方式一：Java 代码设置

        ObjectAnimator animator = ObjectAnimator.ofFloat(Object object, String property, float ....values);  
      // ofFloat()作用有两个
      // 1. 创建动画实例
      // 2. 参数设置：参数说明如下
      // Object object：需要操作的对象
      // String property：需要操作的对象的属性
      // float ....values：动画初始值 & 结束值（不固定长度）
      // 若是两个参数a,b，则动画效果则是从属性的a值到b值
      // 若是三个参数a,b,c，则则动画效果则是从属性的a值到b值再到c值
      // 以此类推
      // 至于如何从初始值 过渡到 结束值，同样是由估值器决定，此处ObjectAnimator.ofFloat（）是有系统内置的浮点型估值器FloatEvaluator，同ValueAnimator讲解

        // 设置动画运行的时长
        anim.setDuration(500);

        // 设置动画延迟播放时间
        anim.setStartDelay(500);

        // 设置动画重复播放次数 = 重放次数+1
        anim.setRepeatCount(0);
        // 动画播放次数 = infinite时,动画无限重复

        // 设置重复播放动画模式
        anim.setRepeatMode(ValueAnimator.RESTART);
        // ValueAnimator.RESTART(默认):正序重放
        // ValueAnimator.REVERSE:倒序回放

      // 启动动画
      animator.start();  

5.2.2 设置方法2：在XML 代码中设置

步骤一：创建xml动画文件（必须放到res/animator文件夹下）

set_animation.xml

// 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" // 对象变化的属性名称

/>

步骤二：在Java代码中创建动画并启动

Animator animator = AnimatorInflater.loadAnimator(context, R.animator.view_animation);  
// 载入XML动画

animator.setTarget(view);  
// 设置动画对象

animator.start();  
// 启动动画

5.3 使用实例——四种基本变换

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

5.3.1 透明度（“alpha”）

        //此处用button做动画效果对象
        Button button = (Button) findViewById(R.id.button);

        //创建动画对象
        ObjectAnimator animator=ObjectAnimator.ofFloat(button,"alpha",1f,0f,1f);
        // 参数表示的是:
        // 动画作用对象是button
        // 动画作用的对象的属性是透明度alpha
        // 动画效果是:常规 - 全透明 - 常规

        //设置属性
        animator.setDuration(3000);//设置动画时长

        //启动动画
        animator.start();

• 效果图大致如下：

  
  
  944365-f022260060ab6cd8.gif

5.3.2 旋转（“rotation”）

        //此处用button做动画效果对象
        Button button = (Button) findViewById(R.id.button);

        //创建动画对象
        ObjectAnimator animator=ObjectAnimator.ofFloat(button,"rotation",0f,360f);
        // 参数表示的是:
        // 动画作用对象是button
        // 动画作用的对象的属性是旋转rotation
        // 动画效果是:0 - 360

        //设置属性
        animator.setDuration(3000);//设置动画时长

        //启动动画
        animator.start();

• 效果图大致如下：

944365-3afd2ec909521458.gif

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

        //获取button当前位置
        float currentX = button.getX();

        //创建动画对象
        ObjectAnimator animator = ObjectAnimator.ofFloat(button, "translationX", currentX, currentX*2, currentX);
        // 参数表示的是:
        // 动画作用对象是button
        // 动画作用的对象的属性是X轴平移（在Y轴上平移同理，采用属性"translationY"
        // 动画效果是:从当前位置平移到 2倍位置 再平移到初始位置

        //设置属性
        animator.setDuration(3000);//设置动画时长

        //启动动画
        animator.start();

• 效果图大致如下：

944365-9ccbc93c0591bebc.gif

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

        //此处用button做动画效果对象
        button = (Button) findViewById(R.id.button);
        
        //创建动画对象
        ObjectAnimator animator = ObjectAnimator.ofFloat(button, "scaleX", 1f, 3f, 1f);
        // 参数表示的是:
        // 动画作用对象是button
        // 动画作用的对象的属性是X轴缩放(Y轴是 scaleY)
        // 动画效果是:放大到3倍,再缩小到初始大小

        //设置属性
        animator.setDuration(3000);//设置动画时长

        //启动动画
        animator.start();

• 效果图大致如下：

944365-f77663d1b955f010.gif

5.3.5 四种基本动画总结

• 在上面的讲解，我们使用了属性动画最基本的四种动画效果：透明度、平移、旋转 & 缩放

即在ObjectAnimator.ofFloat（）的第二个参数String property传入**alpha、rotation、translationX 和 scaleY **等

5.4 关于ofFloat()的第二个参数还能传入什么属性值呢？

• 答案：任意属性值。

• **因为：ObjectAnimator **类 对 对象属性值 进行改变从而实现动画效果的本质是：通过不断控制 值 的变化，再不断 自动 赋给对象的属性，从而实现动画效果

  
  
  944365-7adf6ee408a81f5c.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的对象都具备这个属性

• 至于是如何进行自动赋值的，我们直接来看源码分析：

// 使用方法
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）中是否有和当前动画相同的动画，如果有就把相同的动画给取消掉 
        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）中是否有和当前动画相同的动画，如果有就把相同的动画给取消掉 
        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();  
   // 调用父类的start()
   // 因为ObjectAnimator类继承ValueAnimator类，所以调用的是ValueAnimator的star（）
   // 经过层层调用，最终会调用到 自动赋值给对象属性值的方法
   // 下面就直接看该部分的方法
}  



<-- 自动赋值给对象属性值的逻辑方法 ->>

// 步骤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（）方法，从而从而将新的属性值设置给对象属性
    }  

}

• 自动赋值的逻辑：

1、初始化时，如果属性的初始值没有提供，则调用属性的 get（）进行取值；
2、当 值 变化时，用对象该属性的 set（）方法，从而从而将新的属性值设置给对象属性。

• 所以：

• ObjectAnimator 类针对的是任意对象 & 任意属性值，并不是单单针对于View对象

• 如果需要采用ObjectAnimator 类实现动画效果，那么需要操作的对象就必须有该属性的set（） & get（）
• 同理，针对上述另外的三种基本动画效果，View 也存在着setRotation()、getRotation()、setTranslationX()、getTranslationX()、setScaleY()、getScaleY()等set（） & get（） 。

5.5 使用实例——通过自定义对象属性实现动画效果

• 对于属性动画，其拓展性在于：不局限于系统限定的动画，可以自定义动画，即自定义对象的属性，并通过操作自定义的属性从而实现动画。

• 那么，该如何自定义属性呢？本质上，就是：（类似于ValueAnimator的过程）

• 为对象设置需要操作属性的set（） & get（）方法

• 通过实现TypeEvaluator类从而定义属性变化的逻辑

• 下面，用一个实例来说明如何通过自定义属性实现动画效果

• 实现的动画效果大致如下：一个圆的颜色渐变

  
  
  944365-3bdaacdd53e7bc30.gif

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

  
  
  944365-08d6618df6368369.png

步骤1：设置对象类属性的set（） & get（）方法

• 设置对象类属性的set（） & get（）有两种方法：

方式一：通过继承原始类，直接给类加上该属性的 get（）& set（），从而实现给对象加上该属性的 get（）& set（）
方式二：通过包装原始动画对象，间接给对象加上该属性的 get（）&set（）。即 用一个类来包装原始对象

• 在这个demo中，用第一种方式实现展示，关于第二种方式的使用，会在下一节进行详细介绍。

MyView02.java自定义View如下：

public class MyView02 extends View {
    //设置需要用到的变量
    public static final float RADIUS = 100f;  //圆的半径
    private Paint mPaint;//绘制的画笔
    private String color;//设置背景颜色

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

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

        //设置画笔颜色
        mPaint.setColor(Color.parseColor(color));

        //调用重绘方法
        invalidate();
        //每次都会调用onDraw方法重新画圆，因为每次画笔颜色都不一样，所以圆的颜色也会变
    }

    //构造方法（因为这里是要在xml中使用这个控件，所以用两个参数的构造）
    public MyView02(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        //初始化画笔
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        //设置初始化笔颜色为蓝色
        mPaint.setColor(Color.BLUE);
    }

    //重写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"
    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：根据需求实现TypeEvaluator接口

• 此处实现估值器的本质是：实现 颜色过渡的逻辑。

ColorEvaluator.java

public class ColorEvaluator implements TypeEvaluator {
    //定义当前RGB的颜色变量
    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三个部分，并转换成十进制
        //则每个颜色取值范围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) {
            // getCurrentColor()决定如何根据差值来决定颜色变化的快慢
            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;
    }

    //具体是根据fraction值来计算当前的颜色。
    //由于我们计算出的颜色是十进制数字，所以需要转换成十六进制字符串:调用getHexString()
    // 最终将RGB颜色拼装起来,并作为最终的结果返回
    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进制颜色值转换成16进制
    private String getHexString(int value) {
        String hexString = Integer.toHexString(value);
        if (hexString.length() == 1) {
            hexString = "0" + hexString;
        }
        return hexString;
    }

}

步骤4：调用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);

        //创建动画对象
       ObjectAnimator animator=ObjectAnimator.ofObject(myView,"color",new ColorEvaluator(),"#0000ff","#ff0000");
        // 参数表示的是:
        // 设置自定义View对象、背景颜色属性值 & 颜色估值器 & 颜色过渡值
        // 属性值即  setXXX（）的 XXX
        // 本质逻辑：
        // 步骤1：根据颜色估值器不断 改变 值
        // 步骤2：调用set（）设置背景颜色的属性值（实际上是通过画笔进行颜色设置）
        // 步骤3：调用invalidate()刷新视图，即调用onDraw（）重新绘制，从而实现动画效果

        //设置属性
        animator.setDuration(10000);//设置动画时长

        //启动动画
        animator.start();

    }
    
}

5.6 特别注意：如何手动设置对象类属性的 set（） & get（）

a. 背景

• ObjectAnimator 类 自动赋给对象的属性 的本质是调用该对象属性的set（） & get（）方法进行赋值

• 所以，ObjectAnimator.ofFloat(Object object, String property, float ....values)的第二个参数传入值的作用是：让ObjectAnimator类根据传入的属性名 去寻找 该对象对应属性名的 set（） & get（）方法，从而进行对象属性值的赋值

从上面的原理可知，如果想让对象的属性a的动画生效，属性a需要同时满足下面两个条件：
1、对象必须要提供属性a的set（）方法

a. 如果没传递初始值，那么需要提供get（）方法，因为系统要去拿属性a的初始值
b. 若该条件不满足，程序直接Crash

2、对象提供的 属性a的set（）方法 对 属性a的改变 必须通过某种方法反映出来

a. 如带来ui上的变化
b. 若这条不满足，动画无效，但不会Crash）

上述条件，一般第二条都会满足，主要是在第一条

1、比如说：由于View的setWidth（）并不是设置View的宽度，而是设置View的最大宽度和最小宽度的；所以通过setWidth（）无法改变控件的宽度；所以对View视图的width做属性动画没有效果

2、具体请看下面Button按钮的例子

 Button  mButton = (Button) findViewById(R.id.Button);
        // 创建动画作用对象：此处以Button为例
        // 此Button的宽高设置具体为具体宽度200px

               ObjectAnimator.ofInt(mButton, "width", 500).setDuration(5000).start();
                 // 设置动画的对象

• 效果图
  

  944365-1a6e1c2ebb554772.gif

• 为什么没有动画效果呢？我们来看View 的 setWidth方法

public void setWidth(int pixels) {  
    mMaxWidth = mMinWidth = pixels;  
    mMaxWidthMode = mMinWidthMode = PIXELS;  
    // 因为setWidth（）并不是设置View的宽度，而是设置Button的最大宽度和最小宽度的
    // 所以通过setWidth（）无法改变控件的宽度
   // 所以对width属性做属性动画没有效果

    requestLayout();  
    invalidate();  
}  


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

b. 问题

• 那么，针对上述对象属性的set（）不是设置属性 或 根本没有set（） / get （）的情况应该如何处理？

c. 解决方案

• 手动设置对象类属性的set（） & get（）。共有两种方法：

1、通过继承原始类，直接给类加上该属性的 get（）& set（），从而实现给对象加上该属性的 get（）& set（）
2、通过包装原始动画对象，间接给对象加上该属性的 get（）&set（）。即 用一个类来包装原始对象

• 对于第一种方法，在上面的例子已经说明；下面主要讲解第二种方法：通过包装原始动画对象，间接给对象加上该属性的get（）& set（）

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

• 还是采用上述 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);

        //创建包装类，并传入动画作用的对象
        wrapper = new ViewWrapper(button);

        //点击时开始动画
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //创建动画的对象是包装类的对象
                ObjectAnimator.ofInt(wrapper, "width", 100,500).setDuration(3000).start();
            }
        });


    }

    private class ViewWrapper {
        private View mTarget;

        //构造方法：传入需要包装的对象
        public ViewWrapper(View target) {
            mTarget = target;
        }

        //为宽度设置get() & set（）
        public int getWidth() {
            return mTarget.getLayoutParams().width;
        }

        public void setWidth(int width) {
            //动态改变控件宽度
            mTarget.getLayoutParams().width = width;
            mTarget.requestLayout();
        }
    }

}

• 效果图大致如下：

  
  
  944365-7889934974344381.gif

6、上文两种动画类总结

• 对比ValueAnimator类 & **ObjectAnimator **类，其实二者都属于属性动画，本质上都是一致的：先改变值，然后 赋值 给对象的属性从而实现动画效果。

• 但二者的区别在于：

• **ValueAnimator **类是先改变值，然后 手动赋值 给对象的属性从而实现动画；是 间接 对对象属性进行操作；ValueAnimator 类本质上是一种 改变 值 的操作机制

• ObjectAnimator类是先改变值，然后 自动赋值 给对象的属性从而实现动画；是 直接 对对象属性进行操作；可以理解为：ObjectAnimator更加智能、自动化程度更高

7、具体使用——AnimatorSet 类（组合动画）

• 单一动画实现的效果相当有限，更多的使用场景是同时使用多种动画效果，即组合动画

• 实现 组合动画 的功能：AnimatorSet类

• 具体使用：

AnimatorSet.play(Animator anim)   ：播放当前动画
AnimatorSet.after(long delay)   ：将现有动画延迟x毫秒后执行
AnimatorSet.with(Animator anim)   ：将现有动画和传入的动画同时执行
AnimatorSet.after(Animator anim)   ：将现有动画插入到传入的动画之后执行
AnimatorSet.before(Animator anim) ：  将现有动画插入到传入的动画之前执行

实例演示

• 实现方式有 XML设置 / Java代码设置

• 演示效果说明：主要动画是平移，平移过程中伴随旋转动画，平移完后进行透明度变化

  
  
  944365-a27607d0dd6eb8d9.gif

实现方式一：Java代码设置

        //动画作用对象
        Button button = (Button) findViewById(R.id.button);

        //步骤1：设置需要组合的动画效果
        //平移动画
        ObjectAnimator translation = ObjectAnimator.ofFloat(button, "translationX", 100, 300, 100);
        //旋转动画
        ObjectAnimator rotate = ObjectAnimator.ofFloat(button, "rotation", 0f, 360f);
        //透明度动画
        ObjectAnimator alpha = ObjectAnimator.ofFloat(button, "alpha", 1f, 0f, 1f);

        //步骤2：创建组合动画的对象
        AnimatorSet animatorSet = new AnimatorSet();

        //步骤3：根据组合动画的对象
        animatorSet.play(translation).with(rotate).before(alpha);
        animatorSet.setDuration(5000);

        //步骤4：启动动画
        animatorSet.start();

实现方式二：xml代码设置

步骤1：创建xml动画文件（必须放在res/animator文件夹下）

set_animation.xml

<?xml version="1.0" encoding="utf-8"?><!-- ValueAnimator采用<animator>  标签-->
<set xmlns:android="http://schemas.android.com/apk/res/android"
    android:ordering="sequentially">
    // 上面这个属性表示Set集合内的动画按顺序进行
    // sequentially:表示set中的动画，按照先后顺序逐步进行（a 完成之后进行 b ）
    // together:表示set中的动画，在同一时间同时进行,为默认值

    <set android:ordering="together">
        //下面的动画同时执行
        <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">
        //下面的动画按序进行
        <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代码中创建动画对象并启动

        //动画作用对象
        Button button = (Button) findViewById(R.id.button);

        //创建组合动画对象 & 加载xml动画
        AnimatorSet animator = (AnimatorSet) AnimatorInflater.loadAnimator(this, R.animator.set_animator);

        //设置动画作用对象
        animator.setTarget(button);

        //启动动画
        animator.start();

8、关于动画监听

• 因Animator类、AnimatorSet类、ValueAnimator、ObjectAnimator类存在以下继承关系
  

  944365-56dfb73edfed1293.png

• Animation类通过监听动画开始 / 结束 / 重复 / 取消时刻来进行一系列操作，如跳转页面等等
  通过在Java代码里addListener（）设置

        //属性动画的监听
        animator.addListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animation) {
                //动画开始时执行
            }

            @Override
            public void onAnimationEnd(Animator animation) {
                //动画结束时执行
            }

            @Override
            public void onAnimationCancel(Animator animation) {
                //动画取消时执行
            }

            @Override
            public void onAnimationRepeat(Animator animation) {
                //动画重复时执行
            }
        });

9、属性动画拓展之ViewPropertyAnimator动画

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