android随机小球碰撞（一）边界检测

最新推荐文章于 2024-06-14 14:43:53 发布
最新推荐文章于 2024-06-14 14:43:53 发布
阅读量1.2k 收藏 7
点赞数 2
文章标签： 物理小球
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29983773/article/details/95485645
版权

android随机小球碰撞

1. 通过自定义View绘制小球

创建Ball类，封装与小球有关的属性元素
在构造方法中随机生成0-360的方向值

package com.pcf.randomball.bean;

import java.util.HashMap;
import java.util.Random;

public class Ball {

    int radius;//半径大小  单位px
    int color;//色值
    int alpha;//透明度
    int x;//圆心x坐标
    int y;//圆心y坐标
    int degree;//方向
    int speed//速度 1-3
    int axisX;//X轴矢量方向值
    int axisY;//Y轴矢量方向值

    public Ball() {
        //生成一个在0-360范围内的随机数 为小球的方向
        this.degree = new Random().nextInt(360);
        //生成一个在1-3范围内的随机数 为小球的速度
        this.speed = new Random().nextInt(3)+1;
    }

    public Ball(int radius, int color, int alpha, int x, int y) {
        this.radius = radius;
        this.color = color;
        this.alpha = alpha;
        this.x = x;
        this.y = y;
        //生成一个在0-360范围内的随机数 为小球的方向
        this.degree = new Random().nextInt(360);
        //生成一个在1-3范围内的随机数 为小球的速度
        this.speed = new Random().nextInt(3)+1;
        if (degree == 0) {
            axisX = 0;
            axisY = 1;
        } else if (degree == 90) {
            axisX = 1;
            axisY = 0;
        } else if (degree == 180) {
            axisX = 0;
            axisY = -1;
        } else if (degree == 270) {
            axisX = -1;
            axisY = 0;
        } else if (degree > 0 && degree < 90) {
            axisX = 1;
            axisY = 1;
        } else if (degree > 90 && degree < 180) {
            axisX = 1;
            axisY = -1;
        } else if (degree > 180 && degree < 270) {
            axisX = -1;
            axisY = -1;
        } else if (degree > 270 && degree < 360) {
            axisX = -1;
            axisY = 1;
        }
    }

    public int getRadius() {
        return radius;
    }

    public void setRadius(int radius) {
        this.radius = radius;
    }

    public int getColor() {
        return color;
    }

    public void setColor(int color) {
        this.color = color;
    }

    public int getAlpha() {
        return alpha;
    }

    public void setAlpha(int alpha) {
        this.alpha = alpha;
    }
    
    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int getDegree() {
        return degree;
    }

    public void setDegree(int degree) {
        this.degree = degree;
    }
    
    public long getSpeed() {
        return speed;
    }

    public void setSpeed(long speed) {
        this.speed = speed;
    }

    public int getAxisX() {
        return axisX;
    }

    public void setAxisX(int axisX) {
        this.axisX = axisX;
    }

    public int getAxisY() {
        return axisY;
    }

    public void setAxisY(int axisY) {
        this.axisY = axisY;
    }
}

创建自定义RandomView类继承自View类
实现构造方法与OnDraw OnLayout OnMeasure方法
在OnLayout方法中获取控件实际宽高
在OnDraw方法里绘制圆形小球

package com.pcf.randomball.bean;

import android.content.Context;
import android.graphics.Canvas;
import android.util.AttributeSet;
import android.view.View;
/**
 * 随机小球View
 * */
public class RandomView extends View {
	
    public RandomView(Context context) {
        super(context);
    }

    public RandomView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public RandomView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    public RandomView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {

    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        Ball ball = new Ball(50, Color.BLUE, 600, width / 2, height / 2)
        //实例化画笔对象
        Paint paint = new Paint();
        //给画笔设置颜色
        paint.setColor(ball.getColor());
        paint.setAlpha(ball.getAlpha());
        //设置画笔属性
        paint.setStyle(Paint.Style.FILL);//画笔属性是实心
        paint.setStrokeWidth(1);//设置画笔粗细
        /**四个参数：
         * 参数一：圆心的x坐标
         * 参数二：圆心的y坐标
         * 参数三：圆的半径
         * 参数四：定义好的画笔
         **/
        canvas.drawCircle(ball.getX(), ball.getY(), ball.getRadius(), paint);
    }
}

2. 定时更新小球位置，让小球运动

在Ball类的构造方法里面，通过生成随机数0-360赋值运动方向

45度角,第一象限
在直角坐标系中把0-360°分成四等份，均分在四个象限中
通过角度判断小球的运动方向，每个角限都是90°
无法直接对View进行斜线的移动
把斜线的移动分解成竖向与横向的移动
沿X轴的，Y轴的进行分解
把90°分成了10等份，并分解到X轴与Y轴
开启线程定时更新小球位置并重新绘制小球位置

PS：后面会把小球运动的方案改为以速度为基础

package com.pcf.randomball.view;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;

import com.pcf.randomball.bean.Ball;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class RandomView extends View {

    private int height;
    private int width;
    private long maxBallNumber = -1;
    private List<Ball> ballList = new ArrayList();
    private String TAG = "RandomLayout";
    private MyThread thread;

    public RandomView(Context context) {
        super(context);
    }

    public RandomView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public RandomView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    public RandomView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        Log.d(TAG, "onMeasure ");
        width = getMeasuredWidth();
        height = getMeasuredHeight();
        Log.d(TAG, "width " + width);
        Log.d(TAG, "height " + height);
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        Log.d(TAG, "onLayout ");
        ballList.add(new Ball(50, Color.BLUE, 600, width / 2, height / 2));
        //避免重复创建线程
        if (thread == null) {
            thread = new MyThread();
        }
        thread.start();
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        Log.d(TAG, "onDraw ");
        for (int i = 0; i < ballList.size(); i++) {
            Ball ball = ballList.get(i);
            //实例化画笔对象
            Paint paint = new Paint();
            //给画笔设置颜色
            paint.setColor(ball.getColor());
            paint.setAlpha(ball.getAlpha());
            //设置画笔属性
            paint.setStyle(Paint.Style.FILL);//画笔属性是实心
            paint.setStrokeWidth(1);//设置画笔粗细
            /*四个参数：
                参数一：圆心的x坐标
                参数二：圆心的y坐标
                参数三：圆的半径
                参数四：定义好的画笔*/
            canvas.drawCircle(ball.getX(), ball.getY(), ball.getRadius(), paint);
        }
    }

    public long getMaxBallNumber() {
        return maxBallNumber;
    }

    public void setMaxBallNumber(long maxBallNumber) {
        this.maxBallNumber = maxBallNumber;
    }

    /**
     * 往布局添加小球
     */
    public void addBall(Ball ball) {
        if (ball != null && ballList.size()<maxBallNumber) {
            ballList.add(ball);
        }
    }

    /**
     * 从布局移除小球
     */
    public void removeBall(Ball ball) {
        if (ball != null)
            ballList.remove(ball);
    }

    public void actionBall() {
        for (int i = 0; i < ballList.size(); i++) {
            Ball ball1 = ballList.get(i);
            int x1 = ball1.getX();
            int y1 = ball1.getY();
            int degree = ball1.getDegree();

            //按照0-360度划分四个象限
            if (degree >= 0 && degree < 90) {
                //按10等份去分配X轴与Y轴的位移值
                int xL = degree / 9;
                int yL = 10 - degree / 9;
                //第一象限
                ball1.setX(x1 + xL);
                ball1.setY(y1 + yL);
            } else if (degree >= 90 && degree < 180) {
                //第二象限 碰撞到布局边界
                int xL = 10 - (degree / 9 - 10);
                int yL = (degree / 9 - 10);
                ball1.setX(x1 + xL);
                ball1.setY(y1 + yL);
            } else if (degree >= 180 && degree < 270) {
                //第三象限 碰撞到布局边界
                int xL = (degree / 9 - 20);
                int yL = 10 - (degree / 9 - 20);
                ball1.setX(x1 - xL);
                ball1.setY(y1 + yL);
            } else if (degree >= 270 && degree < 360) {
                //第四象限  碰撞到布局边界
                int xL = 10 - (degree / 9 - 30);
                int yL = (degree / 9 - 30);
                ball1.setX(x1 - xL);
                ball1.setY(y1 - yL);
            }
        }
    }

    private class MyThread extends Thread {
        @Override
        public void run() {
            while (true) {
                actionBall();
                //通知更新界面，会重新调用onDraw()函数
                postInvalidate(); 
                try {
                    sleep(10);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        if(thread!=null)
        thread.stop();
    }
}

3. 边界检测，小球碰撞到布局边界时更改小球运动方向

根据入射角与反射角与平面夹角大小相等的原理
可以计算出在不同象限与边界碰撞后的运动方向
入射角与反射角

package com.pcf.randomball.view;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;

import com.pcf.randomball.bean.Ball;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class RandomView extends View {

    private int height;
    private int width;
    private long maxBallNumber = -1;
    private List<Ball> ballList = new ArrayList();
    private String TAG = "RandomLayout";
    private MyThread thread;

    public RandomView(Context context) {
        super(context);
    }

    public RandomView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public RandomView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    public RandomView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        Log.d(TAG, "onMeasure ");
        width = getMeasuredWidth();
        height = getMeasuredHeight();
        Log.d(TAG, "width " + width);
        Log.d(TAG, "height " + height);
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        Log.d(TAG, "onLayout ");
        ballList.add(new Ball(50, Color.BLUE, 600, width / 2, height / 2));
        //避免重复创建线程
        if (thread == null) {
            thread = new MyThread();
        }
        thread.start();
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        Log.d(TAG, "onDraw ");
        for (int i = 0; i < ballList.size(); i++) {
            Ball ball = ballList.get(i);
            //实例化画笔对象
            Paint paint = new Paint();
            //给画笔设置颜色
            paint.setColor(ball.getColor());
            paint.setAlpha(ball.getAlpha());
            //设置画笔属性
            paint.setStyle(Paint.Style.FILL);//画笔属性是实心
            paint.setStrokeWidth(1);//设置画笔粗细
            /*四个参数：
                参数一：圆心的x坐标
                参数二：圆心的y坐标
                参数三：圆的半径
                参数四：定义好的画笔*/
            canvas.drawCircle(ball.getX(), ball.getY(), ball.getRadius(), paint);
        }
    }

    public long getMaxBallNumber() {
        return maxBallNumber;
    }

    public void setMaxBallNumber(long maxBallNumber) {
        this.maxBallNumber = maxBallNumber;
    }

    /**
     * 往布局添加小球
     */
    public void addBall(Ball ball) {
        if (ball != null && ballList.size()<maxBallNumber) {
            ballList.add(ball);
        }
    }

    /**
     * 从布局移除小球
     */
    public void removeBall(Ball ball) {
        if (ball != null)
            ballList.remove(ball);
    }

    public void actionBall() {
        for (int i = 0; i < ballList.size(); i++) {
            Ball ball1 = ballList.get(i);
            int x1 = ball1.getX();
            int y1 = ball1.getY();
            int degree = ball1.getDegree();

            //按照0-360度划分四个象限
            if (degree >= 0 && degree < 90) {
                //按10等份去分配X轴与Y轴的位移值
                int xL = degree / 9;
                int yL = 10 - degree / 9;
                //第一象限 碰撞到布局右边界
                if (ball1.getX() + ball1.getRadius() >= width) {
                    ball1.setDegree(360 - degree);
                    ball1.setX(x1 - ball1.getRadius());
                } else {
                    if (x1 + ball1.getRadius() + 1 + xL >= width) {
                        ball1.setX(width - ball1.getRadius());
                    } else {
                        ball1.setX(x1 + 1 + xL);
                    }
                }
                //碰撞到布局上边界
                if (ball1.getY() - ball1.getRadius() <= 0) {
                    ball1.setDegree(180 - degree);
                    ball1.setY(y1 + 1 + yL);
                } else {
                    if (y1 - ball1.getRadius() - 1 - yL <= 0) {
                        ball1.setY(ball1.getRadius());
                    } else {
                        ball1.setY(y1 - 1 - yL);
                    }
                }
            } else if (degree >= 90 && degree < 180) {
                //第二象限 碰撞到布局边界
                int xL = 10 - (degree / 9 - 10);
                int yL = (degree / 9 - 10);
                if (ball1.getX() + ball1.getRadius() >= width) {
                    ball1.setDegree(180 - degree + 180);
                    ball1.setX(x1 - ball1.getRadius());
                } else {
                    if (x1 + ball1.getRadius() + 1 + xL >= width) {
                        ball1.setX(width - ball1.getRadius());
                    } else {
                        ball1.setX(x1 + 1 + xL);
                    }
                }
                //碰撞到布局边界
                if (ball1.getY() + ball1.getRadius() >= height) {
                    ball1.setDegree(90 - degree + 90);
                    ball1.setY(y1 - 1 - yL);
                } else {
                    if (y1 + ball1.getRadius() + 1 + yL >= height) {
                        ball1.setY(height - ball1.getRadius());
                    } else {
                        ball1.setY(y1 + 1 + yL);
                    }
                }
            } else if (degree >= 180 && degree < 270) {
                //第三象限 碰撞到布局边界
                int xL = (degree / 9 - 20);
                int yL = 10 - (degree / 9 - 20);
                if (ball1.getX() - ball1.getRadius() <= 0) {
                    ball1.setDegree(360 - degree);
                    ball1.setX(x1 + 1 + xL);
                } else {
                    if (x1 - ball1.getRadius() - 1 - xL <= 0) {
                        ball1.setX(ball1.getRadius());
                    } else {
                        ball1.setX(x1 - 1 - xL);
                    }
                }
                //碰撞到布局边界
                if (ball1.getY() + ball1.getRadius() >= height) {
                    ball1.setDegree(270 + 270 - degree);
                    ball1.setY(y1 - 1 - yL);
                } else {
                    if (x1 + ball1.getRadius() + 1 + yL >= height) {
                        ball1.setY(height - ball1.getRadius());
                    } else {
                        ball1.setY(y1 + 1 + yL);
                    }
                }
            } else if (degree >= 270 && degree < 360) {
                //第四象限  碰撞到布局边界
                int xL = 10 - (degree / 9 - 30);
                int yL = (degree / 9 - 30);
                if (ball1.getX() - ball1.getRadius() <= 0) {
                    ball1.setDegree(360 - degree);
                    ball1.setX(x1 + 1 + xL);
                } else {
                    if (x1 - ball1.getRadius() - 1 - xL <= 0) {
                        ball1.setX(ball1.getRadius());
                    } else {
                        ball1.setX(x1 - 1 - xL);
                    }
                }
                //碰撞到布局边界
                if (ball1.getY() - ball1.getRadius() <= 0) {
                    ball1.setDegree(360 - degree + 180);
                    ball1.setY(y1 + 1 + yL);
                } else {
                    if (y1 - ball1.getRadius() - 1 - yL <= 0) {
                        ball1.setY(ball1.getRadius());
                    } else {
                        ball1.setY(y1 - 1 - yL);
                    }
                }
            }
        }
    }

    private class MyThread extends Thread {
        @Override
        public void run() {
            while (true) {
                actionBall();
                //通知更新界面，会重新调用onDraw()函数
                postInvalidate(); 
                try {
                    sleep(10);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        if(thread!=null)
        thread.stop();
    }
}

4. GitHubDemo

GitHubDemo
https://github.com/pengchengfuGit/randomball

5. 相关链接

https://www.cnblogs.com/xieyuan/archive/2012/11/27/3787450.html

小葱猫
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Android，气泡动画
Altsuki的博客
01-25 9652
一、前言 本来想做一个类似window气泡屏保的动画效果。 奈何小球间的非对心碰撞公式没研究出来，对于我来说真的太复杂了，等公式给我研究差不多的时候，发现计算角度的问题也很复杂。博主表示高中的时候物理从未及格，而且这是大学物理的课程……然而我大学并没有学物理。 目前做出来的效果也很简单，只是检测了边界碰撞，原理就是动量守恒，速度交换。 实际效果如丝般顺滑，gif录制掉帧了。 二、...
Android 小球碰撞检测技术
12-18
Android 小球碰撞检测技术
小球大小随机，随机运动碰撞
dongheng123的博客
06-29 255
小球碰撞
Android中球体碰撞代码分享-kotlin，入门版
Chinese_H的博客
06-14 386
* 可以产生形变，回弹的小球 * * 整个view的核心： * Scroller函数 * 1.调用scroller.public void startScroll(int startX, int startY, int dx, int dy, int duration); * 在指定时间范围内，startX,startY,会移动dx,dy距离 * * 2.然后调用:invalidate(); 系统内部会调用onDraw(); * * 3.在onDraw方法内部又会调用 computeScrollOffs
android中碰撞屏幕边界反弹问题
anyoujian8851的博客
11-07 442
其实碰撞问题只是涉及到一点小算法而已，但在实际应用，尤其游戏中有可能会遇到，下面给出一个小示例，代码如下： MainActivity： packagecom.lovo; importandroid.os.Bundle; importandroid.os.Handler; importandroid.os.Message; importan...
Android 气泡碰撞
隔壁小王的博客
11-15 5328
最近有个需求要实现气泡碰撞的效果，本来有两个参考： 1：仿摩拜贴纸动画的效果：博客地址：http://m.blog.csdn.net/qq_28268507/article/details/74892372采用jbox2d物理引擎来实现的，但是没法实现需求的效果2：Android，气泡动画。（碰撞算法的半成品）博客地址：http://blog.csdn.net/u010386612/article
android 触摸屏小球,android平台上20个自由移动的小球
weixin_42297665的博客
05-26 147
package com.junling.surfaceView;import java.io.File;import java.io.IOException;import java.util.Random;import android.content.Context;import android.graphics.Bitmap;import android.graphics.BitmapFacto...
android 吐泡泡动画,android仿摩拜贴纸碰撞|气泡碰撞
weixin_29197835的博客
05-26 399
转载请注明出处准备气泡碰撞最重要的就是边缘检测,气泡的运动涉及到重力,方向,重心,线速度,角速度,,等等一系列因素,想要在android 用view描述现实世界中的气泡实在是难度很大.网上查找资料后,找到了一个正好能满足我们需求的库:SyncAny-JBox2D运用-打造摩拜单车贴纸动画效果,感谢SyncAny提供的思路,不过使用gradle打包时报错,通过mvn install成功生成jar包....
基于Android的handler线程小球运动
cccrush的博客
09-07 834
首先是主界面的绘制。 我并没有在游戏中写登陆界面，因此只有一个activity。在主界面采取的是单击屏幕启动线程，因此需要给imageView添加OnTouchListener监听器。 需要知道的是，安卓中的UI线程是不安全的。更新UI只有在主线程中更新，因此最好在mainactivity中完成画布的布置。 监听类时用到了声明方法的匿名内部类：当某个类不是经常使用，如...
Android 气泡动画（自定义View类）
JiangYH
04-19 976
Android 气泡动画（自定义View类）一、前言二、代码1. 随机移动的气泡2.热水气泡 一、前言 最近有需求制作一个水壶的气泡动画，首先在网上查找了一番，找到了一个文章。 https://blog.csdn.net/u010386612/article/details/50580080 测试了一下发现，如果把它作为子视图的话，会出现小球溢出边界的情况。所以简单的修改了一下。 二、代码 1. 随机移动的气泡 Ball类 /** * @author jiang yuhang * @date 202
android程序设计报告范文,安卓程序设计报告.doc
weixin_39898248的博客
05-26 656
安卓程序设计报告弹球游戏物联一班 谢鑫 20100740123一、实验目的掌握Swing图形用户界面编程以及事件处理等，掌握java绘图技术。掌握多线程编程的基本原理，能使用Runnable、ExecutorService等接口进行线程的创建、启动等工作。二、实验任务设计并编程实现弹球游戏：用户能通过GUI组件指定生成小球的数量，每个小球将从随机的位置出现，并具有随机颜色，随机速度以及随机的运...
javascript canvas检测小球碰撞
10-15
此外，我们还需要一个检测小球与矩形或另一个小球碰撞的函数。 ```javascript function isCollision(ball1, ball2) { const dx = ball1.x - ball2.x; const dy = ball1.y - ball2.y; const distance = Math.sqrt...
基于c++MFC实现的小球碰撞
01-22
标题“基于C++ MFC实现的小球碰撞”指的是一个使用Microsoft Foundation Classes (MFC)库在C++编程环境中开发的程序，该程序模拟了小球之间的碰撞动态。MFC是微软提供的一套C++类库，它使得开发者可以更方便地创建...
java小球点击动画 碰撞效果 随机生成
04-12
这篇内容将详细解析如何利用Java语言来创建这样一个功能：在鼠标点击的位置生成具有随机颜色和大小的小球，并让它们具备碰撞效果，包括小球之间的碰撞和与边界碰撞。 首先，我们需要引入Java Swing库，它提供了丰富...
小球碰撞检测Demo
07-18
在计算机图形学领域，小球碰撞检测是一种常见的技术，它被广泛应用于游戏开发、物理模拟以及各种交互式应用。这个“小球碰撞检测Demo”很可能是一个示例项目，旨在演示如何在程序中实现两个或多个小球之间的碰撞检测...
chromedriver-mac-arm64_126.0.6474.0.zip
07-31
chromedriver-mac-arm64_126.0.6474.0.zip
chromedriver-mac-arm64_128.0.6548.0.zip
最新发布
07-31
chromedriver-mac-arm64_128.0.6548.0.zip
MySQL查询加速器：利用Query Cache提升效率
07-31
MySQL是一个流行的开源关系型数据库管理系统（RDBMS），广泛用于Web应用程序的后端数据存储。它基于结构化查询语言（SQL）来管理数据，并且是LAMP（Linux, Apache, MySQL, PHP/Python/Perl）技术栈的一部分，这个技术栈常用于构建动态网站和Web应用程序。 MySQL的特点包括： - **开放源代码**：MySQL的源代码是公开的，任何人都可以自由使用和修改。 - **跨平台**：MySQL可以在多种操作系统上运行，包括Linux、Windows、macOS等。 - **高性能**：MySQL以其快速的查询处理和良好的性能而闻名。 - **可靠性**：MySQL提供了多种机制来确保数据的完整性和可靠性，包括事务支持、备份和恢复功能。 - **易于使用**：MySQL提供了简单直观的界面和丰富的文档，便于用户学习和使用。 - **可扩展性**：MySQL支持从小型应用到大型企业级应用的扩展。 - **社区支持**：由于其广泛的使用，MySQL拥有一个活跃的开发者社区，提供大量的资源和支持。 MySQL被广泛应用于各种场景，包括在线事务处理（OL
小球碰撞后随机速度vc6
10-31
小球碰撞之后，其随机速度 vc6 可能是指其速度的大小在一个范围内随机变化的情况。球的速度在碰撞之后会发生改变，可能变大也可能变小，而且方向也会发生变化。 当两个小球碰撞时，它们的速度会发生如下变化： 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值