package android.animation; /**  * A time interpolator defines the rate of change of an animation. This allows animations  * to have non-linear motion, such as acceleration and deceleration.  */ public interface Interpolator {     /**      * Maps a value representing the elapsed fraction of an animation to a value that represents      * the interpolated fraction. This interpolated value is then multiplied by the change in      * value of an animation to derive the animated value at the current elapsed animation time.      *      * @param input A value between 0 and 1.0 indicating our current point      *        in the animation where 0 represents the start and 1.0 represents      *        the end      * @return The interpolation value. This value can be more than 1.0 for      *         interpolators which overshoot their targets, or less than 0 for      *         interpolators that undershoot their targets.      */     float getInterpolation(float input);

package android.view.animation; import android.content.Context; import android.content.res.TypedArray; import android.util.AttributeSet; /**  * An interpolator where the rate of change starts out slowly and  * and then accelerates.  *  */ public class AccelerateInterpolator implements Interpolator {     private final float mFactor;     private final double mDoubleFactor;     public AccelerateInterpolator() {         mFactor = 1.0f;         mDoubleFactor = 2.0;     }     /**      * Constructor      *      * @param factor Degree to which the animation should be eased. Seting      *        factor to 1.0f produces a y=x^2 parabola. Increasing factor above      *        1.0f  exaggerates the ease-in effect (i.e., it starts even      *        slower and ends evens faster)      */     public AccelerateInterpolator(float factor) {         mFactor = factor;         mDoubleFactor = 2 * mFactor;     }     public AccelerateInterpolator(Context context, AttributeSet attrs) {         TypedArray a =             context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.AccelerateInterpolator);         mFactor = a.getFloat(com.android.internal.R.styleable.AccelerateInterpolator_factor, 1.0f);         mDoubleFactor = 2 * mFactor;         a.recycle();     }     public float getInterpolation(float input) {         if (mFactor == 1.0f) {             return input * input;         } else {             return (float)Math.pow(input, mDoubleFactor);         }     } }

public abstract class Animation implements Cloneable {     Interpolator mInterpolator;     // 通过set方法注入       public void setInterpolator(Interpolator i) {          mInterpolator = i;      }     public boolean getTransformation(long currentTime, Transformation outTransformation) {         // ... ...         // 具体调用         final float interpolatedTime = mInterpolator.getInterpolation(normalizedTime);         applyTransformation(interpolatedTime, outTransformation);        // ... ...     }      // 缺省实现，是个小技巧，顺便提下，这个不是重点      protected void ensureInterpolator() {          if (mInterpolator == null) {              mInterpolator = new AccelerateDecelerateInterpolator();          }      } }