Android动画使用（三）——属性（Property）动画

特别提醒：本文参考摘自【工匠若水 http://blog.csdn.net/yanbober/article/details/46481171 】及Carson_Ho：【http://www.jianshu.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

java类名	xml关键字	描述信息
ValueAnimator	<animator>	放置在res/animator/目录下在一个特定的时间里执行一个动画
TimeAnimator	不支持/点我查看原因	时序监听回调工具
ObjectAnimator	<objectAnimator>	放置在res/animator/目录下一个对象的一个属性动画
AnimatorSet	<set>	放置在res/animator/目录下	动画集合

3.2 属性解释：

3.2.1<set>属性解释：

xml属性	解释
android:ordering	控制子动画启动方式是先后有序的还是同时进行。sequentially:动画按照先后顺序；together(默认):动画同时启动；

3.2.2 <objectAnimator>属性解释：

xml属性	解释
android:propertyName	String类型，必须要设置的节点属性，代表要执行动画的属性（通过名字引用），辟如你可以指定了一个View的”alpha” 或者 “backgroundColor” ，这个objectAnimator元素没有对外说明target属性，所以你不能在XML中设置执行这个动画，必须通过调用loadAnimator()方法加载你的XML动画资源，然后调用setTarget()应用到具备这个属性的目标对象上（譬如TextView）。
android:valueTo	float、int或者color类型，必须要设置的节点属性，表明动画结束的点；如果是颜色的话，由6位十六进制的数字表示。
android:valueFrom	相对应valueTo，动画的起始点，如果没有指定，系统会通过属性的get方法获取，颜色也是6位十六进制的数字表示。
android:duration	动画的时长，int类型，以毫秒为单位，默认为300毫秒。
android:startOffset	动画延迟的时间，从调用start方法后开始计算，int型，毫秒为单位。
android:repeatCount	一个动画的重复次数，int型，”-1“表示无限循环，”1“表示动画在第一次执行完成后重复执行一次，也就是两次，默认为0，不重复执行。
android:repeatMode	重复模式：int型，当一个动画执行完的时候应该如何处理。该值必须是正数或者是-1，“reverse”会使得按照动画向相反的方向执行，可实现类似钟摆效果。“repeat”会使得动画每次都从头开始循环。
android:valueType	关键参数，如果该value是一个颜色，那么就不需要指定，因为动画框架会自动的处理颜色值。有intType和floatType（默认）两种：分别说明动画值为int和float型。

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

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

类型	说明
IntEvaluator	整数属性值。
FloatEvaluator	浮点数属性值。
ArgbEvaluato	十六进制color属性值。
TypeEvaluator	用户自定义属性值接口，譬如对象属性值类型不是int、float、color类型，你必须实现这个接口去定义自己的数据类型。

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

类型	说明
AccelerateDecelerateInterolator	先加速后减速。
AccelerateInterpolator	加速。
DecelerateInterpolator	减速。
AnticipateInterpolator	先向相反方向改变一段再加速播放。
AnticipateOvershootInterpolator	先向相反方向改变，再加速播放，会超出目标值然后缓慢移动至目标值，类似于弹簧回弹。
BounceInterpolator	快到目标值时值会跳跃。
CycleIinterpolator	动画循环一定次数，值的改变为一正弦函数：Math.sin(2 * mCycles * Math.PI * input)。
LinearInterpolator	线性均匀改变。
OvershottInterpolator	最后超出目标值然后缓慢改变到目标值。
TimeInterpolator	一个允许自定义Interpolator的接口，以上都实现了该接口。

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 **等

属性	作用	数值类型
Alpha	控制View的透明度	float
TranslationX	控制X方向的位移	float
TranslationY	控制Y方向的位移	float
ScaleX	控制X方向的缩放倍数	float
ScaleY	控制Y方向的缩放倍数	float
Rotation	控制以屏幕方向为轴的旋转度数	float
RotationX	控制以X轴为轴的旋转度数	float
RotationY	控制以Y轴为轴的旋转度数	float

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 或 http://www.jianshu.com/p/2412d00a0ce4

最后编辑于：2017.12.08 03:24:15

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 203,324评论 5赞 476
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 85,303评论 2赞 381
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 150,192评论 0赞 337
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,555评论 1赞 273
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,569评论 5赞 365
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,566评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,927评论 3赞 395
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,583评论 0赞 257
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,827评论 1赞 297
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,590评论 2赞 320
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,669评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,365评论 4赞 318
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,941评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,928评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,159评论 1赞 259
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 42,880评论 2赞 349
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,399评论 2赞 342

Android动画使用（三）——属性（Property）动画

1、Android动画简介

1.1 分类

1.2 每种动画的特点及区别

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

2.1 属性动画出现的原因

2.2 属性动画简介

2.3 属性动画特点

3、属性动画使用相关

3.1 属性动画使用相关类

3.2 属性解释：

3.2.1<set>属性解释：

3.2.2 <objectAnimator>属性解释：

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

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

4、具体使用--ValueAnimator类

4.1 定义、原理

4.2 ValueAnimator类中常用方法：

4.2.1 ValueAnimator.ofInt（int values）

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

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

实例演示

4.2.2 ValueAnimator.ofFloat（float values）

4.2.3 ValueAnimator.ofObject（）

估值器（TypeEvaluator） 介绍

实例说明

步骤1：定义对象类

步骤2：根据需求实现TypeEvaluator接口

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

步骤4：在布局文件加入自定义View控件

步骤5：在主代码文件设置显示视图

特别注意

5、具体使用--ObjectAnimator类

5.1 实现动画的原理

5.2 实现的方式

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

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

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

5.3.1 透明度（“alpha”）

5.3.2 旋转（“rotation”）

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

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

5.3.5 四种基本动画总结

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

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

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

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

步骤3：根据需求实现TypeEvaluator接口

步骤4：调用ObjectAnimator.ofObject（）方法

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

a. 背景

b. 问题

c. 解决方案

6、上文两种动画类总结

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

实例演示

实现方式一：Java代码设置

实现方式二：xml代码设置

8、关于动画监听

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

推荐阅读更多精彩内容

估值器（TypeEvaluator）介绍