Android 动画（anim）详解

最新推荐文章于 2025-10-06 15:30:00 发布
转载 最新推荐文章于 2025-10-06 15:30:00 发布 · 6.2k 阅读 · 12
文章标签：

#android #动画

转载于：http://www.2cto.com/kf/201412/358203.html


1.Android的animation由四种类型组成：

   alpha(透明度)、scale(缩放)、translate(位移)、rotate(旋转)


2.XML配置文件中

android:alpha渐变透明度动画效果
android:scale渐变缩放动画效果
android:translate画面转换位置移动动画效果
android:rotate画面转移旋转动画效果

3.Java Code代码中 

AlphaAnimation渐变透明度动画效果
ScaleAnimation渐变缩放动画效果
TranslateAnimation画面转换位置移动动画效果
RotateAnimation画面转移旋转动画效果

Alpha

  • xml配置：

<!--?xml version="1.0"encoding="utf-8"?-->
<set xmlns:android="http://schemas.android.com/apk/res/android">
  
<!-- 透明度控制动画效果 alpha
        浮点型值：
            fromAlpha 属性为动画起始时透明度
            toAlpha   属性为动画结束时透明度
            说明:
                0.0表示完全透明
                1.0表示完全不透明
            以上值取0.0-1.0之间的float数据类型的数字
 
        长整型值：
            duration  属性为动画持续时间
            说明:    
                时间以毫秒为单位
-->
</alpha></set>


  • Java代码：

AlphaAnimation(float fromAlpha, float toAlpha)

//第一个参数fromAlpha为 动画开始时候透明度

//第二个参数toAlpha为 动画结束时候透明度




?

Scale

  • xml配置：

<!--?xml version="1.0"encoding="utf-8"?-->

<set xmlns:android="http://schemas.android.com/apk/res/android">

   <scale 

android:interpolator="@android:anim/accelerate_decelerate_interpolator"

android:fromxscale="0.0"

android:toxscale="1.4"

android:fromyscale="0.0"

android:toyscale="1.4"

android:pivotx="50%"

android:pivoty="50%"

android:fillafter="false"

android:duration="700">

</scale></set>

<!-- 尺寸伸缩动画效果 scale

       属性：interpolator 指定一个动画的插入器

        基本的有三种动画插入器:

            accelerate_decelerate_interpolator：加速-减速 动画插入器

            accelerate_interpolator ：加速-动画插入器

            decelerate_interpolator ：减速- 动画插入器

        其他的属性单独解释

      浮点型值：    

            fromXScale：属性为动画起始时 X坐标上的伸缩尺寸   

            toXScale：属性为动画结束时 X坐标上的伸缩尺寸    

            fromYScale：属性为动画起始时Y坐标上的伸缩尺寸   

            toYScale：属性为动画结束时Y坐标上的伸缩尺寸   

      说明:

           以上四种属性值   

                    0.0表示收缩到没有

                    1.0表示正常无伸缩    

                    值小于1.0表示收缩 

                    值大于1.0表示放大

         

            pivotX：属性为动画相对于物件的X坐标的开始位置

            pivotY：属性为动画相对于物件的Y坐标的开始位置

         

       说明:

            以上两个属性值 从0%-100%中取值

            50%为物件的X或Y方向坐标上的中点位置

         

        长整型值：

            duration  属性为动画持续时间

            说明:   时间以毫秒为单位

 

        布尔型值:

            fillAfter 属性 当设置为true，该动画转化在动画结束后被应用

-->

  • Java代码：

ScaleAnimation(floatfromX, floattoX, floatfromY, floattoY,
           intpivotXType, floatpivotXValue, intpivotYType, floatpivotYValue)

//第一个参数fromX为动画起始时 X坐标上的伸缩尺寸   

//第二个参数toX为动画结束时 X坐标上的伸缩尺寸    

//第三个参数fromY为动画起始时Y坐标上的伸缩尺寸   

//第四个参数toY为动画结束时Y坐标上的伸缩尺寸 

/*说明:

                    以上四种属性值   

                    0.0表示收缩到没有

                    1.0表示正常无伸缩    

                    值小于1.0表示收缩 

                    值大于1.0表示放大

*/

//第五个参数pivotXType为动画在X轴相对于物件位置类型 

//第六个参数pivotXValue为动画相对于物件的X坐标的开始位置

//第七个参数pivotXType为动画在Y轴相对于物件位置类型  

//第八个参数pivotYValue为动画相对于物件的Y坐标的开始位置

myAnimation_Scale = newScaleAnimation(0.0f,1.4f,0.0f,1.4f,
             Animation.RELATIVE_TO_SELF,0.5f, Animation.RELATIVE_TO_SELF, 0.5f);


Translate

  • xml配置：
<!--?xml version= "1.0" encoding= "utf-8" ?-->
<set xmlns:android= "http://schemas.android.com/apk/res/android" >
<translate 
android:fromxdelta= "30"
android:toxdelta= "-80"
android:fromydelta= "30"
android:toydelta= "300"
android:duration= "2000" >

<!-- translate 位置转移动画效果
         整型值:
             fromXDelta:属性为动画起始时 X坐标上的位置   
             toXDelta:属性为动画结束时 X坐标上的位置
             fromYDelta:属性为动画起始时 Y坐标上的位置
             toYDelta:属性为动画结束时 Y坐标上的位置
         注意:
             没有指定fromXType toXType fromYType toYType 时候， 默认是以自己为相对参照物            
         长整型值：
             duration  属性为动画持续时间
             说明:   时间以毫秒为单位
-->
</translate></set>

  • Java代码：
TranslateAnimation(floatfromXDelta, floattoXDelta,
                       floatfromYDelta, floattoYDelta)
//第一个参数fromXDelta为动画起始时 X坐标上的位置   
//第二个参数toXDelta为动画结束时 X坐标上的位置     
//第三个参数fromYDelta为动画起始时Y坐标上的位置    
//第四个参数toYDelta为动画结束时Y坐标上的位置
myAnimation_Translate = newTranslateAnimation(10f, 100f, 10f, 100f);




?

Rorate

  • xml配置：
<!--?xml version="1.0"encoding="utf-8"?-->
<set xmlns:android="http://schemas.android.com/apk/res/android">
<rotate 
android:interpolator="@android:anim/accelerate_decelerate_interpolator"
android:fromdegrees="0"
android:todegrees="+350"
android:pivotx="50%"
android:pivoty="50%"
android:duration="3000"> 

<!-- rotate 旋转动画效果
       属性：interpolator 指定一个动画的插入器
             基本有三种动画插入器:
                accelerate_decelerate_interpolator:加速-减速 动画插入器
                accelerate_interpolator:加速-动画插入器
                decelerate_interpolator :减速- 动画插入器
            <span style="font-family: Arial, Helvetica, sans-serif;">其他的属性单独解释</span>
 
       浮点数型值:
            fromDegrees：属性为动画起始时物件的角度   
            toDegrees：属性为动画结束时物件旋转的角度 可以大于360度  
 
 
            说明:
                     当角度为负数——表示逆时针旋转
                     当角度为正数——表示顺时针旋转             
                     (负数from——to正数:顺时针旋转)  
                     (负数from——to负数:逆时针旋转)
                     (正数from——to正数:顺时针旋转)
                     (正数from——to负数:逆时针旋转)      
 
            pivotX：属性为动画相对于物件的X坐标的开始位置
            pivotY：属性为动画相对于物件的Y坐标的开始位置
 
            说明:        以上两个属性值 从0%-100%中取值
                         50%为物件的X或Y方向坐标上的中点位置
 
        长整型值：
            duration  属性为动画持续时间
            说明:       时间以毫秒为单位
-->
</rotate></set>


  • Java代码：
RotateAnimation(floatfromDegrees, floattoDegrees,
            intpivotXType, floatpivotXValue, intpivotYType, floatpivotYValue)
//第一个参数fromDegrees为动画起始时的旋转角度   
//第二个参数toDegrees为动画旋转到的角度  
//第三个参数pivotXType为动画在X轴相对于物件位置类型 
//第四个参数pivotXValue为动画相对于物件的X坐标的开始位置
//第五个参数pivotXType为动画在Y轴相对于物件位置类型  
//第六个参数pivotYValue为动画相对于物件的Y坐标的开始位置
myAnimation_Rotate = newRotateAnimation(0.0f, +350.0f,
               Animation.RELATIVE_TO_SELF,0.5f,Animation.RELATIVE_TO_SELF,0.5f);

?
Android有三种动画模式 ：Tween Animation（补间动画）、Frame Animation(逐帧动画)、Property Animation（属性动画）

1. View Animation（Tween Animation）

View Animation（Tween Animation）：补间动画，给出两个关键帧，通过一些算法将给定属性值在给定的时间内在两个关键帧间渐变。

View animation只能应用于View对象，而且只支持一部分属性，如支持缩放旋转而不支持背景颜色的改变。

而且对于View animation，它只是改变了View对象绘制的位置，而没有改变View对象本身，比如，你有一个Button，坐标（100,100），Width:200,Height:50，而你有一个动画使其变为Width：100，Height：100，你会发现动画过程中触发按钮点击的区域仍是(100,100)-(300,150)。

View Animation就是一系列View形状的变换，如大小的缩放，透明度的改变，位置的改变，动画的定义既可以用代码定义也可以用XML定义，当然，建议用XML定义。

可以给一个View同时设置多个动画，比如从透明至不透明的淡入效果，与从小到大的放大效果，这些动画可以同时进行，也可以在一个完成之后开始另一个。

用XML定义的动画放在/res/anim/文件夹内，XML文件的根元素可以为,,,,interpolator元素或(表示以上几个动画的集合，set可以嵌套)。默认情况下，所有动画是同时进行的，可以通过startOffset属性设置各个动画的开始偏移（开始时间）来达到动画顺序播放的效果。

可以通过设置interpolator属性改变动画渐变的方式，如AccelerateInterpolator，开始时慢，然后逐渐加快。默认为AccelerateDecelerateInterpolator。

定义好动画的XML文件后，可以通过类似下面的代码对指定View应用动画。

ImageView spaceshipImage = (ImageView)findViewById(R.id.spaceshipImage);
Animation hyperspaceJumpAnimation=AnimationUtils.loadAnimation( this , R.anim.hyperspace_jump;
spaceshipImage.startAnimation(hyperspaceJumpAnimation);


2. Drawable Animation（Frame Animation）

Drawable Animation（Frame Animation）：帧动画，就像GIF图片，通过一系列Drawable依次显示来模拟动画的效果。在XML中的定义方式如下：

  <item android:drawable= "@drawable/rocket_thrust1" android:duration= "200" >
     <item android:drawable= "@drawable/rocket_thrust2" android:duration= "200" >
     <item android:drawable= "@drawable/rocket_thrust3" android:duration= "200" >
</item></item></item></animation-list>

java代码：
protected void onCreate(Bundle savedInstanceState) {
         // TODO Auto-generated method stub
         super .onCreate(savedInstanceState);
         setContentView(R.layout.main);
         imageView = (ImageView) findViewById(R.id.imageView1);
         imageView.setBackgroundResource(R.drawable.drawable_anim);
         anim = (AnimationDrawable) imageView.getBackground();
     }
 
     public boolean onTouchEvent(MotionEvent event) {
         if (event.getAction() == MotionEvent.ACTION_DOWN) {
             anim.stop();
             anim.start();
             return true ;
         }
         return super .onTouchEvent(event);
     }

?
?
注意：
  • 要在代码中调用Imageview的setBackgroundResource方法，如果直接在XML布局文件中设置其src属性当触发动画时会FC。
  • 在动画start()之前要先stop()，不然在第一次动画之后会停在最后一帧，这样动画就只会触发一次。
  • 最后一点是SDK中提到的，不要在onCreate中调用start，因为AnimationDrawable还没有完全跟Window相关联，如果想要界面显示时就开始动画的话，可以在onWindowFoucsChanged()中调用start()。

    3. Property Animation

    属性动画，这个是在Android 3.0中才引进的，它更改的是对象的实际属性，在View Animation（Tween Animation）中，其改变的是View的绘制效果，真正的View的属性保持不变，比如无论你在对话中如何缩放Button的大小，Button的有效点击区域还是没有应用动画时的区域，其位置与大小都不变。而在Property Animation中，改变的是对象的实际属性，如Button的缩放，Button的位置与大小属性值都改变了。而且Property Animation不止可以应用于View，还可以应用于任何对象。Property Animation只是表示一个值在一段时间内的改变，当值改变时要做什么事情完全是你自己决定的。

    在Property Animation中，可以对动画应用以下属性：

      • Duration：动画的持续时间
      • TimeInterpolation：属性值的计算方式，如先快后慢
      • TypeEvaluator：根据属性的开始、结束值与TimeInterpolation计算出的因子计算出当前时间的属性值
      • Repeat Count and behavoir：重复次数与方式，如播放3次、5次、无限循环，可以此动画一直重复，或播放完时再反向播放
      • Animation sets：动画集合，即可以同时对一个对象应用几个动画，这些动画可以同时播放也可以对不同动画设置不同开始偏移
      • Frame refreash delay：多少时间刷新一次，即每隔多少时间计算一次属性值，默认为10ms，最终刷新时间还受系统进程调度与硬件的影响


        Interpolator


        首先要了解为什么需要插值器，因为在补间动画中，我们一般只定义关键帧（首帧或尾帧），然后由系统自动生成中间帧，生成中间帧的这个过程可以成为“插值”。插值器定义了动画变化的速率，提供不同的函数定义变化值相对于时间的变化规则，可以定义各种各样的非线性变化函数，比如加速、减速等。下面是几种常见的插值器：

        Interpolator对象资源ID功能作用
        AccelerateDecelerateInterpolator@android:anim/accelerate_decelerate_interpolator先加速再减速
        AccelerateInterpolator@android:anim/accelerate_interpolator加速
        AnticipateInterpolator@android:anim/anticipate_interpolator先回退一小步然后加速前进
        AnticipateOvershootInterpolator@android:anim/anticipate_overshoot_interpolator在上一个基础上超出终点一小步再回到终点
        BounceInterpolator@android:anim/bounce_interpolator最后阶段弹球效果
        CycleInterpolator@android:anim/cycle_interpolator周期运动
        DecelerateInterpolator@android:anim/decelerate_interpolator减速
        LinearInterpolator@android:anim/linear_interpolator匀速
        OvershootInterpolator@android:anim/overshoot_interpolator快速到达终点并超出一小步最后回到终点

        如果只简单地引用这些插值器还不能满足需要的话，我们要考虑一下个性化插值器。我们可以创建一个插值器资源修改插值器的属性，比如修改AnticipateInterpolator的加速速率，调整CycleInterpolator的循环次数等。为了完成这种需求，我们需要创建XML资源文件，然后将其放于/res/anim下，然后再动画元素中引用即可。我们先来看一下几种常见的插值器可调整的属性：

        ?
      •   android:tension 浮点值，起始点后退的张力、拉力数，默认为2
         android:tension 同上 android:extraTension 浮点值，拉力的倍数，默认为1.5（2 * 1.5）
        <bounceinterpolator> 无
        <cycleinterplolator> android:cycles 整数值，循环的个数，默认为1
        <decelerateinterpolator> android:factor 浮点值，减速的速率，默认为1
        <linearinterpolator> 无
        <overshootinterpolator> 浮点值，超出终点后的张力、拉力，默认为2

      • </overshootinterpolator>
      • </linearinterpolator>
      • </decelerateinterpolator>
      • </cycleinterplolator>
      • </bounceinterpolator>
      • </anticipateovershootinterpolator>
      • </anticipateinterploator>
      • </accelerateinterpolator>
      • </acceleratedecelerateinterpolator>


        下面我们就拿最后一个插值器来举例：

        ?
        1
        2
        <!--?xml version= "1.0" encoding= "utf-8" ?-->
        <overshootinterpolator xmlns:android= "http://schemas.android.com/apk/res/android" android:tension= "7.0" ></overshootinterpolator>

        上面的代码中，我们把张力改为7.0，然后将此文件命名为my_overshoot_interpolator.xml，放置于/res/anim下，我们就可以引用到自定义的插值器了： 
        ?
        1
        <scale xmlns:android= "http://schemas.android.com/apk/res/android" android:interpolator= "@anim/my_overshoot_interpolator" ...= "" ></scale>


        AccelerateDecelerateInterpolator

        ?
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        /**
          * An interpolator where the rate of change starts and ends slowly but
          * accelerates through the middle.
          *
          */
        public class AccelerateDecelerateInterpolator implements Interpolator {
             public AccelerateDecelerateInterpolator() {
             }
             
             @SuppressWarnings ({ "UnusedDeclaration" })
             public AccelerateDecelerateInterpolator(Context context, AttributeSet attrs) {
             }
             
             public float getInterpolation( float input) {
                 return ( float )(Math.cos((input + 1 ) * Math.PI) / 2 .0f) + 0 .5f;
             }
        }


        \

        <喎�"/kf/ware/vc/" target="_blank" class="keylink">vcD4KPGgyPgpBY2NlbGVyYXRlSW50ZXJwb2xhdG9yPC9oMj4KPHByZSBjbGFzcz0="brush:java;">/** * 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); } } }

        \

        AnticipateInterpolator

        ?
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        /**
          * An interpolator where the change starts backward then flings forward.
          */
        public class AnticipateInterpolator implements Interpolator {
             private final float mTension;
         
             public AnticipateInterpolator() {
                 mTension = 2 .0f;
             }
         
             /**
              * @param tension Amount of anticipation. When tension equals 0.0f, there is
              *                no anticipation and the interpolator becomes a simple
              *                acceleration interpolator.
              */
             public AnticipateInterpolator( float tension) {
                 mTension = tension;
             }
         
             public AnticipateInterpolator(Context context, AttributeSet attrs) {
                 TypedArray a = context.obtainStyledAttributes(attrs,
                         com.android.internal.R.styleable.AnticipateInterpolator);
         
                 mTension =
                         a.getFloat(com.android.internal.R.styleable.AnticipateInterpolator_tension, 2 .0f);
         
                 a.recycle();
             }
         
             public float getInterpolation( float t) {
                 // a(t) = t * t * ((tension + 1) * t - tension)
                 return t * t * ((mTension + 1 ) * t - mTension);
             }
        }


        \

        AnticipateOvershootInterpolator

        ?
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        35
        36
        37
        38
        39
        40
        41
        42
        43
        44
        45
        46
        47
        48
        49
        50
        51
        52
        53
        54
        55
        56
        57
        58
        /**
          * An interpolator where the change starts backward then flings forward and overshoots
          * the target value and finally goes back to the final value.
          */
        public class AnticipateOvershootInterpolator implements Interpolator {
             private final float mTension;
         
             public AnticipateOvershootInterpolator() {
                 mTension = 2 .0f * 1 .5f;
             }
         
             /**
              * @param tension Amount of anticipation/overshoot. When tension equals 0.0f,
              *                there is no anticipation/overshoot and the interpolator becomes
              *                a simple acceleration/deceleration interpolator.
              */
             public AnticipateOvershootInterpolator( float tension) {
                 mTension = tension * 1 .5f;
             }
         
             /**
              * @param tension Amount of anticipation/overshoot. When tension equals 0.0f,
              *                there is no anticipation/overshoot and the interpolator becomes
              *                a simple acceleration/deceleration interpolator.
              * @param extraTension Amount by which to multiply the tension. For instance,
              *                     to get the same overshoot as an OvershootInterpolator with
              *                     a tension of 2.0f, you would use an extraTension of 1.5f.
              */
             public AnticipateOvershootInterpolator( float tension, float extraTension) {
                 mTension = tension * extraTension;
             }
         
             public AnticipateOvershootInterpolator(Context context, AttributeSet attrs) {
                 TypedArray a = context.obtainStyledAttributes(attrs, AnticipateOvershootInterpolator);
         
                 mTension = a.getFloat(AnticipateOvershootInterpolator_tension, 2 .0f) *
                         a.getFloat(AnticipateOvershootInterpolator_extraTension, 1 .5f);
         
                 a.recycle();
             }
         
             private static float a( float t, float s) {
                 return t * t * ((s + 1 ) * t - s);
             }
         
             private static float o( float t, float s) {
                 return t * t * ((s + 1 ) * t + s);
             }
         
             public float getInterpolation( float t) {
                 // a(t, s) = t * t * ((s + 1) * t - s)
                 // o(t, s) = t * t * ((s + 1) * t + s)
                 // f(t) = 0.5 * a(t * 2, tension * extraTension), when t < 0.5
                 // f(t) = 0.5 * (o(t * 2 - 2, tension * extraTension) + 2), when t <= 1.0
                 if (t < 0 .5f) return 0 .5f * a(t * 2 .0f, mTension);
                 else return 0 .5f * (o(t * 2 .0f - 2 .0f, mTension) + 2 .0f);
             }
        }


        \

        BounceInterpolator

        ?
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        /**
          * An interpolator where the change bounces at the end.
          */
        public class BounceInterpolator implements Interpolator {
             public BounceInterpolator() {
             }
         
             @SuppressWarnings ({ "UnusedDeclaration" })
             public BounceInterpolator(Context context, AttributeSet attrs) {
             }
         
             private static float bounce( float t) {
                 return t * t * 8 .0f;
             }
         
             public float getInterpolation( float t) {
                 // _b(t) = t * t * 8
                 // bs(t) = _b(t) for t < 0.3535
                 // bs(t) = _b(t - 0.54719) + 0.7 for t < 0.7408
                 // bs(t) = _b(t - 0.8526) + 0.9 for t < 0.9644
                 // bs(t) = _b(t - 1.0435) + 0.95 for t <= 1.0
                 // b(t) = bs(t * 1.1226)
                 t *= 1 .1226f;
                 if (t < 0 .3535f) return bounce(t);
                 else if (t < 0 .7408f) return bounce(t - 0 .54719f) + 0 .7f;
                 else if (t < 0 .9644f) return bounce(t - 0 .8526f) + 0 .9f;
                 else return bounce(t - 1 .0435f) + 0 .95f;
             }
        }


        \

        CycleInterpolator

        ?
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        /**
          * Repeats the animation for a specified number of cycles. The
          * rate of change follows a sinusoidal pattern.
          *
          */
        public class CycleInterpolator implements Interpolator {
             public CycleInterpolator( float cycles) {
                 mCycles = cycles;
             }
             
             public CycleInterpolator(Context context, AttributeSet attrs) {
                 TypedArray a =
                     context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.CycleInterpolator);
                 
                 mCycles = a.getFloat(com.android.internal.R.styleable.CycleInterpolator_cycles, 1 .0f);
                 
                 a.recycle();
             }
             
             public float getInterpolation( float input) {
                 return ( float )(Math.sin( 2 * mCycles * Math.PI * input));
             }
             
             private float mCycles;
        }


        　　参数为2时的曲线：

        \

        DecelerateInterpolator


        ?
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        35
        36
        37
        38
        39
        40
        41
        /**
          * An interpolator where the rate of change starts out quickly and
          * and then decelerates.
          *
          */
        public class DecelerateInterpolator implements Interpolator {
             public DecelerateInterpolator() {
             }
         
             /**
              * Constructor
              *
              * @param factor Degree to which the animation should be eased. Setting factor to 1.0f produces
              *        an upside-down y=x^2 parabola. Increasing factor above 1.0f makes exaggerates the
              *        ease-out effect (i.e., it starts even faster and ends evens slower)
              */
             public DecelerateInterpolator( float factor) {
                 mFactor = factor;
             }
             
             public DecelerateInterpolator(Context context, AttributeSet attrs) {
                 TypedArray a =
                     context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.DecelerateInterpolator);
                 
                 mFactor = a.getFloat(com.android.internal.R.styleable.DecelerateInterpolator_factor, 1 .0f);
                 
                 a.recycle();
             }
             
             public float getInterpolation( float input) {
                 float result;
                 if (mFactor == 1 .0f) {
                     result = ( float )( 1 .0f - ( 1 .0f - input) * ( 1 .0f - input));
                 } else {
                     result = ( float )( 1 .0f - Math.pow(( 1 .0f - input), 2 * mFactor));
                 }
                 return result;
             }
             
             private float mFactor = 1 .0f;
        }

        \

        LinearInterpolator

        ?
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        /**
          * An interpolator where the rate of change is constant
          *
          */
        public class LinearInterpolator implements Interpolator {
         
             public LinearInterpolator() {
             }
             
             public LinearInterpolator(Context context, AttributeSet attrs) {
             }
             
             public float getInterpolation( float input) {
                 return input;
             }
        }


        \

        OvershootInterpolator

        ?
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        35
        36
        37
        /**
          * An interpolator where the change flings forward and overshoots the last value
          * then comes back.
          */
        public class OvershootInterpolator implements Interpolator {
             private final float mTension;
         
             public OvershootInterpolator() {
                 mTension = 2 .0f;
             }
         
             /**
              * @param tension Amount of overshoot. When tension equals 0.0f, there is
              *                no overshoot and the interpolator becomes a simple
              *                deceleration interpolator.
              */
             public OvershootInterpolator( float tension) {
                 mTension = tension;
             }
         
             public OvershootInterpolator(Context context, AttributeSet attrs) {
                 TypedArray a = context.obtainStyledAttributes(attrs,
                         com.android.internal.R.styleable.OvershootInterpolator);
         
                 mTension =
                         a.getFloat(com.android.internal.R.styleable.OvershootInterpolator_tension, 2 .0f);
         
                 a.recycle();
             }
         
             public float getInterpolation( float t) {
                 // _o(t) = t * t * ((tension + 1) * t + tension)
                 // o(t) = _o(t - 1) + 1
                 t -= 1 .0f;
                 return t * t * ((mTension + 1 ) * t + mTension) + 1 .0f;
             }
        }





  • 要在代码中调用Imageview的setBackgroundResource方法，如果直接在XML布局文件中设置其src属性当触发动画时会FC。
  • 在动画start()之前要先stop()，不然在第一次动画之后会停在最后一帧，这样动画就只会触发一次。
  • 最后一点是SDK中提到的，不要在onCreate中调用start，因为AnimationDrawable还没有完全跟Window相关联，如果想要界面显示时就开始动画的话，可以在onWindowFoucsChanged()中调用start()。
Android 动画↑
zenmela2011的专栏
04-12 1711
1.Android动画 Android系统的动画主要分为三大类： ①View Animation 视图动画：在古老的Android版本系统中就已经提供了，只能被用来设置View的动画。 ②Drawable Animation (也叫Frame动画、帧动画）：专门用来一个一个的显示Drawable的resources，就像放幻灯片一样。 ③Property Animation属性动画：只对Android 3.0（API 11）以上版本的Android系统才有效，这种动画可以设置给任何Object，包.
CSS——一个圆点绕着另一个圆点转动(animation动画中rotate使用)
我是我
06-21 5428
1.要实现的效果 2. 实现思路 一个容器画出运动轨迹，设置宽高和border-radius，并relative定位 一个中心点，绝对定位至圆心处 一个移动点，固定在某处，跟着外部容器一起转动 animation + transform:rotate的使用 3.实现代码 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="
android_anim
12-25
android 项目中res下anim Activity切换动画使用的xml文件
【Android】Android 的三种动画（帧动画、View 动画、属性动画）
最新发布
LiuYaoheng的博客
10-06 930
Android提供三种动画类型：帧动画、View动画（补间动画）和属性动画。帧动画通过连续播放图片序列实现，简单但易导致内存溢出。View动画包含四种基本变换（透明度、缩放、旋转、平移），通过XML定义视图的起始和结束状态，系统自动补间中间帧。属性动画则通过动态修改对象属性实现更灵活的动画效果。每种动画类型适用于不同场景，开发者可根据需求选择合适的实现方式。
android animation的学习之路
因为了解所以无知
01-15 1014
 android animation关键字: android动画效果编程基础--AnimationAndroid 动画类型 Android的animation由四种类型组成 XML中 alpha 渐变透明度动画效果 scale 渐变尺寸伸缩动画效果 translate 画面转换位置移动动画效果 rotate 画面转移旋转动画效果 JavaCode中 AlphaAnimation 渐
Android Animation动画(超详细)
Liu_LongPo的专栏
11-16 5861
Animations 一、Animations介绍 Animations是一个实现android UI界面动画效果的API，Animations提供了一系列的动画效果，可以进行旋转、缩放、淡入淡出等，这些效果可以应用在绝大多数的控件中。  二、Animations的分类 Animations从总体上可以分为两大类： 1.Tweened Animations：该类Ani
精选资源
Android 混合动画详解及实现代码
01-04
在Android开发，我们会经常使用到动画，但是简单的一种动画（如旋转、缩放、渐变、位移等）有时候并不能满足我们项目的要求，这时候就需要运用到混合动画，那么在安卓中是如何实现一个炫酷的混合动画，下面是一个...
Android Dialog 动画实例详解
08-30
当然，Android中的Dialog动画不仅仅局限于这种滑动效果，还可以通过自定义动画或者使用Transition API来实现更多复杂的动画效果，例如缩放、旋转等。开发者可以根据实际需求和设计风格选择合适的动画方式，以创造更...
Android实现动画效果详解
09-03
在Android平台上，实现动画效果是提升用户体验的重要手段。Android提供了两种基本类型的动画：Tween动画和Frame动画。Tween动画主要用于对象的连续图像变换，包括旋转、平移、缩放和渐变，而Frame动画则类似于GIF...
android anim 动画效果
热门推荐
chenlinben的专栏
09-02 3万+
动画效果编程基础--AnimationAndroid        动画类型        Android的animation由四种类型组成        XML中     alpha     渐变透明度动画效果     scale     渐变尺寸伸缩动画效果     translate     画面转换位置移动动画效果     rotate     画面转移旋转动画
Android anim文件
09-26
页面切换效果文件，slide_in_left.xml、slide_in_right.xml、slide_out_left.xml、slide_out_right.xml
android anim动画
05-09
android中有各种效果,比如activity跳转时的滑动效果等,这里收集了一些anim.
Android中的动画效果
linghu_java的专栏
01-31 8353
本文主要研究Android中的三种动画，第一种是单个View的各种动画效果，第二种是两个Activity切换时的动画效果，第三种是类似于Gif的Frame By Frame动画效果，其中View的各种动画包括在xml文件中定义和代码中定义两种方式。 一、动画基本类型： 如下表所示，Android的动画由四种类型组成，即可在xml中定义，也可在代码中定义，如下所示：
Android—Animation
LightSun----让成功成为可能!
08-21 1762
一.Animation简介 1.简介  Animation为Android提供了一系列的动画效果：旋转、缩放、移动、淡入淡出，这些动画效果可以应用于绝大多数控件。 2.分类 Animation可分为两类：     TweenedAnimations：渐变动画，具体就是旋转、缩放、移动、淡入淡出效果。     Frame-by-FrameAnimations：将一系列Drawable序列一
Android Animation动画
AllenCall的博客
06-01 723
一、Animations介绍 Animations是一个实现android UI界面动画效果的API，Animations提供了一系列的动画效果，可以进行旋转、缩放、淡入淡出等，这些效果可以应用在绝大多数的控件中。 二、Animations的分类 Animations从总体上可以分为两大类： 1.Tweened Animations：该类Animations提供了旋转、移动、伸展和淡出等效
Android Anim动画
zhong8888888800的博客
10-23 406
Android补间动画：http://www.jianshu.com/p/733532041f46 translate: http://www.cnblogs.com/bavariama/archive/2013/01/29/2881225.html
android中anim动画,王立平--android中的anim(动画)
weixin_42436482的博客
05-26 547
简单实用步骤： 1.新建anim文件夹，2.在anim下新建xml文件，3.在xml下编写自己需要动画。简单例子：给Imageview添加动画public class MainActivity extends Activity {private ImageView imv;@Overrideprotected void onCreate(Bundle savedInstanceState) {su...
android animation动画(很详细),Android Animation动画(很详细)
weixin_39854326的博客
05-27 765
Contents：Animati**Tween Animati**Animati**etInterpolatorFrame-By-Frame Animati**LayoutAnimati**ControllerAnimationListenerAnimati**一、Animati**介绍Animati**是一个实现android UI界面动画效果的API，Animati**提供了一系列的动画效果，...
Android动画实现方法详解
- XML定义：Android支持通过XML文件来定义动画，开发者可以将动画定义放在res/anim目录下，并在代码中引用。这种方式使得动画的创建和管理更为方便。 - Java代码：开发者也可以在Java代码中直接创建和启动动画。通过...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值