精华内容
下载资源
问答
  • 绘制五个球,没什么难度,让球绕圆进行运动,这个好像我们没有见到是怎么去实现了,那下就说这个。  从本质上看,球绕圆运动,其实我们可以看作是一个物体绕指定的路劲运动,那我们就有下面几个东西需要说一下: ...
  • 想要知道关于更多自定义View的实例,请参考:android自定义View索引先上个效果图,以免大家跑错地了。... 绘制五个球,没什么难度,让球绕圆进行运动,这个好像我们没有见到是怎么去实现了,那下就说这个。 从本...

        想要知道关于更多自定义View的实例,请参考:android自定义View索引

    先上个效果图,以免大家跑错地了。


        嗯,除了只能录三秒,其他没啥问题。

       下面分析一下怎么实现上面这个效果。

        理性分析后我们可以看到是几个小球绕着一个圆进行运动,那这里面的重点我们看看什么。

        绘制五个球,没什么难度,让球绕圆进行运动,这个好像我们没有见到是怎么去实现了,那下就说这个。

        从本质上看,球绕圆运动,其实我们可以看作是一个物体绕指定的路劲运动,那我们就有下面几个东西需要说一下:

    1:Path
    2:ValueAnimator
    3:PathMeasure
    复制代码

        前两个大家应该都见过,一个是路径,就是可以自己绘制路线的一个工具,一个是动画,用来指定物体运动的工具,那第三个是一个关于测量路径的类。

        下面说说PathMeasure的用法。

        首先是初始化:

    pathMeasure = new PathMeasure(path, false);复制代码

        两个参数第一个,第一个就是我们需要用到的路径,第二个参数意思就是这个以路径头尾是否相连来计算结果,通常我们就写false就行,不会有问题。

        然后是用法:

    private float[] mCurrentPositionOne = new float[2];复制代码
    float value = (Float) animation.getAnimatedValue();
    pathMeasure.getPosTan(value, mCurrentPositionOne, null);复制代码

        我们可以看见把一个二维数组放到了getPosTan这个方法里面,然后还有一个animation,这里的animation来自哪里呢?来自这里:

    valueAnimatorOne.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            // 获取当前点坐标封装到mCurrentPosition
            float value = (Float) animation.getAnimatedValue();
            pathMeasure.getPosTan(value, mCurrentPositionOne, null);
            postInvalidate();
        }
    });复制代码

        看见没,是动画的监听里面来的,getPosTan的最后一个参数通常也就写null就行了,那么这整个一行的代码意思就是当动画发生了变化,就执行这行代码,然后这行代码会把这个时间点的路径上的坐标赋值给mCurrentPositionOne。

        那我们获取到看这个路径上的坐标点怎么办呢?

        立马用来ondraw里面啊,我的小球此时就可以根据这个坐标点去绘制自己的位置,这个的话,当动画开始时,小球就会不断接受新的坐标,然后不断重绘,最终产生旋转小球的效果。

         我先把属性动画的代码贴出来:

    if (valueAnimatorOne == null) {
        valueAnimatorOne = ValueAnimator.ofFloat(0, pathMeasure.getLength());
        valueAnimatorOne.setDuration(800);
        // 减速插值器
        valueAnimatorOne.setInterpolator(new DecelerateInterpolator());
        valueAnimatorOne.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                // 获取当前点坐标封装到mCurrentPosition
                float value = (Float) animation.getAnimatedValue();
                pathMeasure.getPosTan(value, mCurrentPositionOne, null);
                postInvalidate();
            }
        });
        valueAnimatorOne.addListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animator) {
                finishAnimateOne = 1;
            }
    
            @Override
            public void onAnimationEnd(Animator animator) {
                finishAnimateOne = 0;
            }
    
            @Override
            public void onAnimationCancel(Animator animator) {
    
            }
    
            @Override
            public void onAnimationRepeat(Animator animator) {
    
            }
        });
    }
    valueAnimatorOne.start();复制代码

        我写了个800,也就是动画的维持时间,但是我们发现有啊后几个小球,所以我们需要绘制好几个小球,然后给他们不同的动画,为什么呢?因为动画都一样,小球就叠加在一起了,我们就只能看见一个球了。

        说到这里的话,我们的目标算时完成了,具体的操作,大家参考以下代码,或者去:

    android自定义View索引

         里面动画的demo进行下载,大家随意,下面给出代码:

    /**
     * 仿视频加载动画,旋转的蓝色小球
     */
    
    public class RotaryBall extends View {
    
        private Path rotationPath;
        private float radius;
        private Paint circlePaintOne;
        private PathMeasure pathMeasure;
        private int finishAnimateOne = 0;   // 用来判断当前动画有没有开始
        private int finishAnimateTwo = 0;   // 用来判断当前动画有没有开始
        private int finishAnimateThree = 0;   // 用来判断当前动画有没有开始
        private int finishAnimateFour = 0;   // 用来判断当前动画有没有开始
        private int finishAnimateFive = 0;   // 用来判断当前动画有没有开始
        private Handler handler;
        private float[] mCurrentPositionOne = new float[2];
        private float[] mCurrentPositionTwo = new float[2];
        private float[] mCurrentPositionThree = new float[2];
        private float[] mCurrentPositionFour = new float[2];
        private float[] mCurrentPositionFive = new float[2];
        private ValueAnimator valueAnimatorOne = null;
        private ValueAnimator valueAnimatorTwo = null;
        private ValueAnimator valueAnimatorThree = null;
        private ValueAnimator valueAnimatorFour = null;
        private ValueAnimator valueAnimatorFive = null;
        private int currentStatus = -1;    //-1表示第一次运行,0表示动画结束或者没开始,1表示正在运动中
        private boolean animateOrNot = true;    //用来决定是否开启动画
    
        public RotaryBall(Context context) {
            super(context);
            initData();
        }
    
    
        public RotaryBall(Context context, AttributeSet attrs) {
            super(context, attrs);
            initData();
        }
    
        private void initData() {
            rotationPath = new Path();
            circlePaintOne = new Paint();
            circlePaintOne.setColor(Color.BLUE);
            circlePaintOne.setAntiAlias(true);
            handler = new Handler() {
                @Override
                public void handleMessage(Message msg) {
                    super.handleMessage(msg);
                    switch (msg.what) {
                        case 4:
                            if (finishAnimateOne == 0) {
                                startAnimatorOne();
                            }
                            if (finishAnimateTwo == 0) {
                                startAnimatorTwo();
                            }
                            if (finishAnimateThree == 0) {
                                startAnimatorThree();
                            }
                            if (finishAnimateFour == 0) {
                                startAnimatorFour();
                            }
                            if (finishAnimateFive == 0) {
                                startAnimatorFive();
                            }
                            currentStatus = 0;
                    }
                }
            };
        }
    
        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            radius = getMeasuredWidth() / 2;
        }
    
        @Override
        protected void onDraw(Canvas canvas) {
            super.onDraw(canvas);
    //        rotationPath.addCircle(radius, radius, radius - 10, CW);
            rotationPath.moveTo(radius, 0 + 10);
            rotationPath.cubicTo(radius, 0 + 10, radius * 2 - 10, 0 + 10, radius * 2 - 10, radius);
            rotationPath.cubicTo(radius * 2 - 10, radius, radius * 2 - 10, radius * 2 - 10, radius, radius * 2 - 10);
            rotationPath.cubicTo(radius, radius * 2 - 10, 0 + 10, radius * 2 - 10, 0 + 10, radius);
            rotationPath.cubicTo(0 + 10, radius, 0 + 10, 0 + 10, radius, 0 + 10);
            rotationPath.close();
            pathMeasure = new PathMeasure(rotationPath, false);
            //下面绘制不同半径的小圆
            canvas.drawCircle(mCurrentPositionOne[0], mCurrentPositionOne[1], 10, circlePaintOne);
            canvas.drawCircle(mCurrentPositionTwo[0], mCurrentPositionTwo[1], 9, circlePaintOne);
            canvas.drawCircle(mCurrentPositionThree[0], mCurrentPositionThree[1], 7, circlePaintOne);
            canvas.drawCircle(mCurrentPositionFour[0], mCurrentPositionFour[1], 5, circlePaintOne);
            canvas.drawCircle(mCurrentPositionFive[0], mCurrentPositionFive[1], 3, circlePaintOne);
            if (currentStatus == -1) {
                Message message = new Message();
                message.what = 4;
                handler.sendMessage(message);
            }
            if (animateOrNot) {
                if (currentStatus == 0) {
                    currentStatus = 1;
                    new Thread() {            //用线程来统一五个圆的周期
                        @Override
                        public void run() {
                            super.run();
                            try {
                                Log.d("thread", "thread");
                                Thread.sleep(1600);
                                Message message = new Message();
                                message.what = 4;
                                handler.sendMessage(message);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }.start();
                }
            }
        }
    
        //供外部调用,开始动画
        public void startAnimate() {
            if (!animateOrNot) {
                animateOrNot = true;
                currentStatus = -1;
                invalidate();
            }
        }
    
        //供外部调用,停止动画
        public void stopAnimate() {
            if (animateOrNot) {
                animateOrNot = false;
            }
        }
    
        //界面被销毁
        @Override
        protected void onDetachedFromWindow() {
            super.onDetachedFromWindow();
            stopAnimate();
            clearAllAnimation();
        }
    
        //清除所有动画效果
        private void clearAllAnimation() {
            if (valueAnimatorOne != null){
                if (valueAnimatorOne.isRunning()){
                    valueAnimatorOne.cancel();
                }
                valueAnimatorOne.removeAllUpdateListeners();
                valueAnimatorOne = null;
            }
            if (valueAnimatorTwo != null){
                if (valueAnimatorTwo.isRunning()){
                    valueAnimatorTwo.cancel();
                }
                valueAnimatorTwo.removeAllUpdateListeners();
                valueAnimatorTwo = null;
            }
            if (valueAnimatorThree != null){
                if (valueAnimatorThree.isRunning()){
                    valueAnimatorThree.cancel();
                }
                valueAnimatorThree.removeAllUpdateListeners();
                valueAnimatorThree = null;
            }
            if (valueAnimatorFour != null){
                if (valueAnimatorFour.isRunning()){
                    valueAnimatorFour.cancel();
                }
                valueAnimatorFour.removeAllUpdateListeners();
                valueAnimatorFour = null;
            }
            if (valueAnimatorFive != null){
                if (valueAnimatorFive.isRunning()){
                    valueAnimatorFive.cancel();
                }
                valueAnimatorFive.removeAllUpdateListeners();
                valueAnimatorFive = null;
            }
        }
    
    
        //开始第一个小球的动画
        private void startAnimatorOne() {
            if (valueAnimatorOne == null) {
                Log.d("valueAnimatorOne", "valueAnimatorOne");
                valueAnimatorOne = ValueAnimator.ofFloat(0, pathMeasure.getLength());
                valueAnimatorOne.setDuration(800);
                // 减速插值器
                valueAnimatorOne.setInterpolator(new DecelerateInterpolator());
                valueAnimatorOne.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
                    @Override
                    public void onAnimationUpdate(ValueAnimator animation) {
                        // 获取当前点坐标封装到mCurrentPosition
                        float value = (Float) animation.getAnimatedValue();
                        pathMeasure.getPosTan(value, mCurrentPositionOne, null);
                        postInvalidate();
                    }
                });
                valueAnimatorOne.addListener(new Animator.AnimatorListener() {
                    @Override
                    public void onAnimationStart(Animator animator) {
                        finishAnimateOne = 1;
                    }
    
                    @Override
                    public void onAnimationEnd(Animator animator) {
                        finishAnimateOne = 0;
                    }
    
                    @Override
                    public void onAnimationCancel(Animator animator) {
    
                    }
    
                    @Override
                    public void onAnimationRepeat(Animator animator) {
    
                    }
                });
            }
            valueAnimatorOne.start();
        }
    
        //开始第二个小球的动画
        private void startAnimatorTwo() {
            if (valueAnimatorTwo == null) {
                valueAnimatorTwo = ValueAnimator.ofFloat(0, pathMeasure.getLength());
                valueAnimatorTwo.setDuration(1000);
                // 减速插值器
                valueAnimatorTwo.setInterpolator(new DecelerateInterpolator());
                valueAnimatorTwo.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
                    @Override
                    public void onAnimationUpdate(ValueAnimator animation) {
                        float value = (Float) animation.getAnimatedValue();
                        // 获取当前点坐标封装到mCurrentPosition
                        pathMeasure.getPosTan(value, mCurrentPositionTwo, null);
                        postInvalidate();
                    }
                });
                valueAnimatorTwo.addListener(new Animator.AnimatorListener() {
                    @Override
                    public void onAnimationStart(Animator animator) {
                        finishAnimateTwo = 1;
                    }
    
                    @Override
                    public void onAnimationEnd(Animator animator) {
                        finishAnimateTwo = 0;
                    }
    
                    @Override
                    public void onAnimationCancel(Animator animator) {
    
                    }
    
                    @Override
                    public void onAnimationRepeat(Animator animator) {
    
                    }
                });
            }
            valueAnimatorTwo.start();
        }
    
        //开始第三个小球的动画
        private void startAnimatorThree() {
            if (valueAnimatorThree == null) {
                valueAnimatorThree = ValueAnimator.ofFloat(0, pathMeasure.getLength());
                valueAnimatorThree.setDuration(1200);
                // 减速插值器
                valueAnimatorThree.setInterpolator(new DecelerateInterpolator());
                valueAnimatorThree.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
                    @Override
                    public void onAnimationUpdate(ValueAnimator animation) {
                        float value = (Float) animation.getAnimatedValue();
                        // 获取当前点坐标封装到mCurrentPosition
                        pathMeasure.getPosTan(value, mCurrentPositionThree, null);
                        postInvalidate();
                    }
                });
                valueAnimatorThree.addListener(new Animator.AnimatorListener() {
                    @Override
                    public void onAnimationStart(Animator animator) {
                        finishAnimateThree = 1;
                    }
    
                    @Override
                    public void onAnimationEnd(Animator animator) {
                        finishAnimateThree = 0;
                    }
    
                    @Override
                    public void onAnimationCancel(Animator animator) {
    
                    }
    
                    @Override
                    public void onAnimationRepeat(Animator animator) {
    
                    }
                });
            }
            valueAnimatorThree.start();
        }
    
        //开始第四个小球的动画
        private void startAnimatorFour() {
            if (valueAnimatorFour == null) {
                valueAnimatorFour = ValueAnimator.ofFloat(0, pathMeasure.getLength());
                valueAnimatorFour.setDuration(1400);
                // 减速插值器
                valueAnimatorFour.setInterpolator(new DecelerateInterpolator());
                valueAnimatorFour.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
                    @Override
                    public void onAnimationUpdate(ValueAnimator animation) {
                        float value = (Float) animation.getAnimatedValue();
                        // 获取当前点坐标封装到mCurrentPosition
                        pathMeasure.getPosTan(value, mCurrentPositionFour, null);
                        postInvalidate();
                    }
                });
                valueAnimatorFour.addListener(new Animator.AnimatorListener() {
                    @Override
                    public void onAnimationStart(Animator animator) {
                        finishAnimateFour = 1;
                    }
    
                    @Override
                    public void onAnimationEnd(Animator animator) {
                        finishAnimateFour = 0;
                    }
    
                    @Override
                    public void onAnimationCancel(Animator animator) {
    
                    }
    
                    @Override
                    public void onAnimationRepeat(Animator animator) {
    
                    }
                });
            }
            valueAnimatorFour.start();
        }
    
        //开始第五个小球的动画
        private void startAnimatorFive() {
            if (valueAnimatorFive == null) {
                valueAnimatorFive = ValueAnimator.ofFloat(0, pathMeasure.getLength());
                valueAnimatorFive.setDuration(1600);
                // 减速插值器
                valueAnimatorFive.setInterpolator(new DecelerateInterpolator());
                valueAnimatorFive.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
                    @Override
                    public void onAnimationUpdate(ValueAnimator animation) {
                        float value = (Float) animation.getAnimatedValue();
                        // 获取当前点坐标封装到mCurrentPosition
                        pathMeasure.getPosTan(value, mCurrentPositionFive, null);
                        postInvalidate();
                    }
                });
                valueAnimatorFive.addListener(new Animator.AnimatorListener() {
                    @Override
                    public void onAnimationStart(Animator animator) {
                        finishAnimateFive = 1;
                    }
    
                    @Override
                    public void onAnimationEnd(Animator animator) {
                        finishAnimateFive = 0;
                    }
    
                    @Override
                    public void onAnimationCancel(Animator animator) {
    
                    }
    
                    @Override
                    public void onAnimationRepeat(Animator animator) {
    
                    }
                });
            }
            valueAnimatorFive.start();
        }
    
    }复制代码

               喜欢我的文章的,请点击关注我哦。万学冬的掘金


    转载于:https://juejin.im/post/5a5461ce5188257327397867

    展开全文
  • 我最近看到了一个纯CSS实现的球体动画效果:经过研究上面的效果实现起来大致可以分为五个步骤,下面就来一一介绍。1.使用Jade和SCSS生成一个圆圈创建一个圆圈的第一步是生成所有组成圆圈的粒子。有了Jade,我们不用...

    我最近看到了一个纯CSS实现的球体动画效果:

    bVbtIJD?w=396&h=373

    经过研究上面的效果实现起来大致可以分为五个步骤,下面就来一一介绍。

    1.使用Jade和SCSS生成一个圆圈

    创建一个圆圈的第一步是生成所有组成圆圈的粒子。有了Jade,我们不用一个一个的写出200个div。

    以下的代码创建了一个容器.mommy和200个div:

    .mommy

    - for (var x = 0; x < 200; x++)

    div

    添加一点CSS确认一下200个div已经生成:

    .mommy{

    border:1px solid black;

    }

    div{

    width: 4px;

    height: 4px;

    background:red;

    }

    正如下面你所看到的,我们生成了一个800px高的红色方块,它是由200个div组成的。

    bVbtzUo?w=639&h=422

    接下来,我们要将这200个div分别定位在不同的位置组成一个圆圈,并通过SCSS来实现。

    在上面的CSS中还需要再添加一些设置,给所有的div设置绝对定位,并将它们向左和向上移动2px的距离,这样div的中心点与容器的0,0坐标点就重合了。然后,我们设置容器为固定的宽高大小。

    .mommy{

    border:1px solid black;

    width: 400px;

    height: 400px;

    position: relative;

    }

    div{

    width: 4px;

    height: 4px;

    background:red;

    position: absolute;

    top: -2px;

    left: -2px;

    }

    通过SCSS,我们可以在for循环中为每一个div设置不同的位置,这样就不必手动的一个一个去设置。首先创建一个变量,它的值等于div的个数,这样在后面如果要用到div的数量值时,直接引用这个变量就可以了。如果有一天需要改变成400个div,只需要在CSS中改变变量的值就可以了。

    $amount : 200;

    @for $i from 1 through $amount {

    //循环中的代码

    }

    现在我们就可以在循环中改变每个div的坐标了,这需要一点点的数学计算。

    以下的函数就是生成圆圈的坐标点的计算公式:

    x = cos((index/amount)*(PI*2))*radius + radius;

    y = sin((index/amount)*(PI*2))*radius + radius;

    用SCSS来表示上面的公式就是:

    $x : cos(($i/$amount)*360deg)*200px + 200;

    $y : sin(($i/$amount)*360deg)*200px + 200;

    然后我们将通过公式计算得出的点坐标应用在每个div上:

    div:nth-child(#{$i}){

    transform: translate3d($x, $y,0px);

    }

    这是第一步生成的结果,虽然不是很漂亮,但是,嗯,你从零开始创造了一个圆圈!

    bVbtz1o?w=418&h=418

    2.将圆圈变成一个球体

    现在我们有了一个用SCSS生成的圆圈,但是我们需要的是一个球体。圆圈是一个二维图形,而球体是一个三维立体图形。二维几何图形只有两个轴:X轴和Y轴,而对于三维,又多了一个坐标轴:Z轴。这意味着我们还要计算每个div在Z轴上的位置坐标。幸运的是,已经有成熟的公式帮助我们来定位球体上每个元素的位置,我不会详细的介绍公式的原理(属于数学范畴),我们只需要使用就可以了:

    θ : (index / amount) * 120;

    δ : (index / amount) * PI;

    x : radius * cos(δ) * cos(θ);

    y : radius * cos(δ) * sin(θ);

    z : radius * sin(δ);

    现在我们有了以上的函数,它可以完全满足我们的需求,我们把它插入到循环中。

    @for $i from 1 through $amount {

    $theta : ($i / $amount) * 120;

    $delta : ($i / $amount) * pi();

    $x : 200px * cos($delta) * cos($theta) + 200; //+200 to center our sphere in our 3D world

    $y : 200px * cos($delta) * sin($theta) + 200; //+200 to center our sphere in our 3D world

    $z : 200px * sin($delta);

    div:nth-child(#{$i}){

    transform: translate3d($x, $y,$z);

    }

    }

    下面就是生成的球体效果,正如你所看到的,所有的div都有重新有了新的位置,但是我们看到的好像仍然是平面效果,不是3D立体的。

    bVbtAaK?w=413&h=412

    在CSS中有一个叫perspective的属性,它允许我们为任何元素设置一个特定的透视值。在我们的例子中,我们希望在容器.mommy设置3D效果。并且还需要设置一个transform-style: preserve-3d;这样所有的div就处于立体坐标系中了。

    bVbtAdK?w=429&h=426

    现在我们可以看到所有div的大小都变得不一样了。div距离“屏幕”的距离越远,它就会越小,这意味着它们已经处于立体坐标系中了!

    3.旋转球体

    所有的div已经就绪了,接下来我们就要看到最后的结果了。我们设置一个仅有一个关键帧的动画效果:

    .mommy{

    [...]

    animation: rotation 10s linear infinite;

    }

    @keyframes rotation{

    to{

    transform:rotateY(360deg);

    }

    }

    bVbtAhb?w=430&h=419

    你可能已经注意到,有些div不是正面屏幕而是与屏幕成90°时,它们就会消失看不到。为了防止这种情况的发生,我们需要给每个div一个反方向的旋转,让它们的正面始终面对屏幕显示。

    我们要在div上应用一个反方向的旋转,但是由于已经应用了一个转换,我们将利用伪元素,它将成为红色的小方块。这样,div本身只需要提供定位作用就可以了,并且设置一个transform-style属性,让div处于3D环境中。

    div{

    [...]

    transform-style: preserve-3d;

    &:before{

    content:"";

    display: block;

    width: 4px;

    height:4px;

    background:red;

    animation: rotation 10s infinite linear reverse;

    }

    }

    bVbtAkR?w=430&h=419

    塔达!CSS球体的效果就这样做好了!

    4.更炫的球体

    在以上代码的基础上,我们发散思维,可以做出更加炫酷的球体效果:

    bVbtAoJ?w=669&h=669

    bVbtAoQ?w=467&h=467

    获取以上所有球体动画的代码可以:

    bVbtAvp?w=380&h=380

    展开全文
  • 问题十七:怎么用ray tracing个球? 中途又补充了点C++的东西: 问题十:C++中抽象类,虚函数是什么鬼?怎么测试 问题十六:使用初始化列表的构造函数和使用函数体的构造函数有什么区别? 第二部分:原文...
    展开全文
  • IQ面试题(经典智力题)

    2009-08-20 10:50:01
    5.12个球一个天平,现知道只有一个和其它的重量不同,问怎样称才能用三次就找到那个球。13个呢?(注意此题并未说明那个球的重量是轻是重,所以需要仔细考虑) 6.在9个点上10条直线,要求每条直线上至少有三个点?...
  • 5.12个球一个天平,现知道只有一个和其它的重量不同,问怎样称才能用三次就找到那个球。13个呢?(注意此题并未说明那个球的重量是轻是重,所以需要仔细考虑)(5分钟-1小时) 6.在9个点上10条直线,要求每条直线...
  • 面试题2:在9点上10条线 面试题3:100盏灯 面试题4:找出不同的 面试题5:时针、分针和秒针重合问题 面试题6:可以喝多少瓶汽水 面试题7:怎样拿到第100号 面试题8:烧绳计时 面试题9:分金条 面试题10:...
  • 疯狂的程序员

    热门讨论 2012-07-18 18:05:32
    路过妹妹楼下,绝影往四周看了遍,一人也没有。来不急多想,就到了校医院。 因为是外伤,情况并不是很严重,也就是清洗伤口,缝针。绝影心里惦记着那妹妹,可那时候手机手机还没现在这样普及,普及的是传呼机。...
  • vc++ 应用源码包_1

    热门讨论 2012-09-15 14:22:12
    使用了六个类五个模块类演示了atl的调用方法 autoplaysnd mp3 播放器源码 重载了自带的控件进行播放 aviplayer avi播放器源码 引用了atl控件播放 beautifulskin 源码 演示了各种控件方法 Browser.Net源码 C#的一...
  • vc++ 应用源码包_6

    热门讨论 2012-09-15 14:59:46
    使用了六个类五个模块类演示了atl的调用方法 autoplaysnd mp3 播放器源码 重载了自带的控件进行播放 aviplayer avi播放器源码 引用了atl控件播放 beautifulskin 源码 演示了各种控件方法 Browser.Net源码 C#的一...
  • vc++ 应用源码包_2

    热门讨论 2012-09-15 14:27:40
    使用了六个类五个模块类演示了atl的调用方法 autoplaysnd mp3 播放器源码 重载了自带的控件进行播放 aviplayer avi播放器源码 引用了atl控件播放 beautifulskin 源码 演示了各种控件方法 Browser.Net源码 C#的一...
  • vc++ 应用源码包_5

    热门讨论 2012-09-15 14:45:16
    使用了六个类五个模块类演示了atl的调用方法 autoplaysnd mp3 播放器源码 重载了自带的控件进行播放 aviplayer avi播放器源码 引用了atl控件播放 beautifulskin 源码 演示了各种控件方法 Browser.Net源码 C#的一...
  • vc++ 应用源码包_4

    热门讨论 2012-09-15 14:38:35
    使用了六个类五个模块类演示了atl的调用方法 autoplaysnd mp3 播放器源码 重载了自带的控件进行播放 aviplayer avi播放器源码 引用了atl控件播放 beautifulskin 源码 演示了各种控件方法 Browser.Net源码 C#的一...
  • vc++ 应用源码包_3

    热门讨论 2012-09-15 14:33:15
    使用了六个类五个模块类演示了atl的调用方法 autoplaysnd mp3 播放器源码 重载了自带的控件进行播放 aviplayer avi播放器源码 引用了atl控件播放 beautifulskin 源码 演示了各种控件方法 Browser.Net源码 C#的一...
  • vc++ 开发实例源码包

    2014-12-16 11:25:17
    使用了六个类五个模块类演示了atl的调用方法 class CDHtmlSinkHandler; // Events Sink Base class CDHtmlEventSink; // IHTMLDocument2 Events Sink // IDispatch class CDHtmlControlSink; // ActiveX Control ...
  • 软件工程教程

    热门讨论 2012-07-06 23:10:29
    不要为每事物都模型,应该把精力放在关键的领域 对象图 对象图 表示在某一时刻类的具体实例和这些实例之间的具体连接关系 类 与 对象 关系 类 与 对象 关系 类图和对象图的区别 包 包 一种分组...
  • 算法导论(part1)

    热门讨论 2010-09-09 22:51:05
    编写上采用了“五个一”,即一章介绍一个算法、一种设计技术、一个应用领域和一个相关话题。.. 3.图文并茂,可读性强。 书中的算法均以通俗易懂的语言进行说明,并采用了大量插图来说明算法是如何工作的,易于...
  • 算法导论(part2)

    2010-09-09 22:54:12
    编写上采用了“五个一”,即一章介绍一个算法、一种设计技术、一个应用领域和一个相关话题。.. 3.图文并茂,可读性强。 书中的算法均以通俗易懂的语言进行说明,并采用了大量插图来说明算法是如何工作的,易于...
  • 乒乓似的 43 00:01:47,480 --> 00:01:47,960 煮一会儿 44 00:01:47,960 --> 00:01:50,600 下一步咱们把芒果切了 45 00:01:51,160 --> 00:01:53,000 切成了小方块就行了 46 00:01:53,000 --> 00:01...

空空如也

空空如也

1 2
收藏数 21
精华内容 8
关键字:

五个球怎么画