计时器，计时到几秒，中间打断从新计时 倒计时

最新推荐文章于 2022-07-30 15:17:13 发布
最新推荐文章于 2022-07-30 15:17:13 发布
阅读量533 收藏
点赞数
分类专栏： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aicpzl/article/details/110799171
版权 
package com.transengines.;

import android.app.AlarmManager;
import android.content.Context;
import android.os.CountDownTimer;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import android.view.View;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;

public class ActionHandling {
    public static final boolean DEBUG = false;
    public static final boolean DEBUG_mHandlerTask = false;
    public static final boolean DEBUG_TAG = false;
    public static final boolean DEBUG_TIME = true;


    /**
     * 构造初始化
     */
    public ActionHandling() {
        //mLastActionTime = System.currentTimeMillis();
        //开始计时
       // startTimer();
       // startTimerIpReset();

        startTimer1();
        startTimerIpReset1();
        //noOperationTimeOut.start();
    }

    
    

        uiManage.uiRegR.setOnClickCallBack(new UIRegR.OnClickCallBack() {
            @Override
            public void onClick(View v) {
                if (playerSpeaker.isPlaying()) {
                    playerSpeaker.clearList(true);
//                    playerSpeaker.stop(true);
                }
                mHandlerTask.sendEmptyMessage(handlerClickButton);
                Message msg = new Message();
                msg.what = handlerTaskEvent;
                Event event = new Event();
                event.setValue(Event.cancelOrReturn, 1);
                msg.obj = event;
                if (DEBUG_mHandlerTask)
                    LogPrint.d("mHandlerTask send event returnCancel button");
                mHandlerTask.sendMessage(msg);
            }

            @Override
            public void onTouch(View v, int type) {
                if (type == 1) {
                    playBuzzer.playError();//每次触碰都响蜂鸣器
                    if (!playerSpeaker.contains(1066)) {
                        playerSpeaker.play(State.OutOfServer, 1066, true);
                    }
                } else if (type == 2) {
                    playBuzzer.playError();//每次触碰都响蜂鸣器
                    if (!playerSpeaker.contains(1065)) {
                        playerSpeaker.play(State.OutOfServer, 1065, true);
                    }
                }
            }
        });
    }

    public static void addEvent(Event event) {
        Message msg = new Message();
        msg.what = handlerTaskEvent;
        msg.obj = event;
        mHandlerTask.sendMessage(msg);
        if (DEBUG_mHandlerTask) {
            LogPrint.d("mHandlerTask send event ");
            event.printEventList(blockEvevt);
        }
    }

    /**
     * 打印未定义事件
     *
     * @param event
     */
    private void printUndefinedEvent(Event event) {
        if (DEBUG_mHandlerTask) {
            LogPrint.d("未定义的事件");
            event.printEventList(blockEvevt);
        }
    }


    private void initHandler() {
        if (mHandlerThreadStateMachine == null) {
            mHandlerThreadStateMachine = new HandlerThread("StateMachineTask");
            mHandlerThreadStateMachine.start();
        }

        if (mHandlerTask == null) {
            mHandlerTask = new Handler(mHandlerThreadStateMachine.getLooper()) {

                @Override
                public void handleMessage(Message msg) {
                    switch (msg.what) {
                        case handlerFactorySettings:
                            globalValue.updateUI.post(new Runnable() {
                                @Override
                                public void run() {
                                    uiManage.uiRegN.getFloorDataAndRefresh();
                                    if (ActionHandling.signalProcess != null) {
                                        ActionHandling.signalProcess.setSendEnable(true);
                                        ActionHandling.signalProcess.setReceEnable(true);
                                        ActionHandling.signalProcess.setHeartBeatEnable(true);
                                        ActionHandling.signalProcess.sendResetMPU();
                                    }
                                }
                            });

                            break;
                        case handlerTaskEvent:
                            //事件处理
                            Event event = (Event) msg.obj;
                            if (event == null) {
                                LogPrint.d("event is null! skip.");
                                return;
                            }

                            if (DEBUG_mHandlerTask) {
                                LogPrint.d("mHandlerTask rece event");
//                                event.printEventList(blockEvevt);
                                event.printEventList(null);
                            }
                            changeStateByEvent(event);
                            break;
                        case handlerTaskUI:
                            //界面更改
                            if (DEBUG_mHandlerTask)
                                LogPrint.d("mHandlerTask rece event change ui " + msg.arg1);
                            changeUIByState(msg.arg1);
                            break;
                        case handlerTimeTask:
                            LogPrint.e("====handlerTimeTask====1");
                            Calendar calendar = (Calendar) msg.obj;
//                            calendar.setTimeInMillis(1603158733918L);
//                            calendar.set(Calendar.YEAR, 2020);
//                            calendar.set(Calendar.MONTH, 9);
//                            calendar.set(Calendar.DAY_OF_MONTH, 10);
//                            calendar.set(Calendar.HOUR_OF_DAY, 22);
//                            calendar.set(Calendar.MINUTE, 18);
                            long when = calendar.getTimeInMillis();

//                            android.provider.Settings.Global.putInt(globalValue.mContext.getContentResolver(),
//                                    android.provider.Settings.Global.AUTO_TIME_ZONE, 0);
                            android.provider.Settings.System.putString(globalValue.mContext.getContentResolver(),
                                    android.provider.Settings.System.TIME_12_24, "24");
                            if (when / 1000 < Integer.MAX_VALUE) {
                                LogPrint.e( "====handlerTimeTask=222=" + when+"==="+System.currentTimeMillis());
                                LogPrint.e( "====handlerTimeTask=333=" + (when -System.currentTimeMillis()));
//                                SystemClock.setCurrentTimeMillis(when);
                                ((AlarmManager) globalValue.mContext.getSystemService(Context.ALARM_SERVICE)).setTime(when);
                            }

//                            long now = Calendar.getInstance().getTimeInMillis();
//                            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//                            String dateString = formatter.format(now);
//                            LogPrint.d("=====time set tm=" + when + ", now tm=" + now + ",  " + dateString);
                            break;
                        case handlerClickScreen:
                            uiManage.uiRegN.setUIDormancyHide();
                            uiManage.uiRegR.setUIDormancyHide();
                            uiManage.uiRegD.setUIDormancyHide();
                            resetScreenTimeOut();
                            break;
                        case handlerClickButton:
                            resetScreenTimeOut();
                            playBuzzer.playNormal();
                            break;
                        case handlerSaveEnergy:
                            if (DEBUG_TIME)
                                LogPrint.e("======进行屏幕亮度的调节");
                            //接到屏幕无操作超时时，进行屏幕亮度的调节
                            globalValue.updateUI.post(new Runnable() {
                                @Override
                                public void run() {
                                    uiManage.uiRegN.setUIDormancyShow();
                                    uiManage.uiRegR.setUIDormancyShow();
                                    uiManage.uiRegD.setUIDormancyShow();
                                    SystemUtil.setBackLight((float) (ConfigManage.jsonBean.getDisplay().getBrightnessEnergy() / 100.0));
                                    File file = new File("/sdcard/usb-ts-error");
                                    try {
                                        file.createNewFile();
                                    } catch (IOException e) {
                                    }
                                }
                            });
                            break;
                        case handlerSaveEnergyIpReset:
                            if (DEBUG_TIME)
                                LogPrint.d("======进行屏幕亮度的调节handlerSaveEnergyIpReset");
                            //接到屏幕无操作超时时，进行屏幕亮度的调节
                            globalValue.updateUI.post(new Runnable() {
                                @Override
                                public void run() {
                                    File file = new File("/sdcard/usb-ts-error");
                                    try {
                                        file.createNewFile();
                                    } catch (IOException e) {
                                    }
                                }
                            });
                            break;
                        case handlerRefreshFloorButton:
                            if (DEBUG)
                                LogPrint.d("flush floor button");
                            uiManage.uiRegN.showExtFloor();
                            break;
                        default:
                            break;
                    }
                }
            };
        }
    }

  
   


   


 

    private void resetScreenTimeOut() {
        if (DEBUG_TIME)
            LogPrint.e("=====中断");
        globalValue.isTimeForEnergy = false;
       /* endDate = new Date(System.currentTimeMillis());
        synchronized (noOperationTimeOut) {
            noOperationTimeOut.interrupt();
            noOperationTimeOut.notify();
        }*/
        // 停止计时任务
       /* stopTimer();
        stopTimerIpReset();

        startTimer();
        startTimerIpReset();*/


        stopTimer1();
        stopTimerIpReset1();

        startTimer1();
        startTimerIpReset1();

        globalValue.updateUI.post(new Runnable() {
            @Override
            public void run() {
                SystemUtil.setBackLight((float) (ConfigManage.jsonBean.getDisplay().getBrightness() / 100.0));
            }
        });
    }


    private Timer mTimer; //计时器，每1秒执行一次任务
    private MyTimerTask mTimerTask; //计时任务，判断是否未操作时间到达3s
    private long mLastActionTime; //上一次操作时间
    long timeForEnergy = ConfigManage.jsonBean.getDisplay().getTimeForEnergy() * 60 * 1000;

    private class MyTimerTask extends TimerTask {
        @Override
        public void run() {
            //3s未操作,则结束计时
            if (DEBUG_TIME)
                LogPrint.e("======3s未操作,则结束计时" + (System.currentTimeMillis() - mLastActionTime) + "====" + timeForEnergy);
            if (System.currentTimeMillis() - mLastActionTime > timeForEnergy) {
                if (DEBUG_TIME)
                    LogPrint.e("======3屏幕变暗");
                //结束计时
                removeTimer();
                // 停止计时任务
                stopTimer();
            }
        }
    }

    //开始计时
    private void startTimer() {
        if (ConfigManage.jsonBean.getDisplay().getTimeForEnergy() != 0) {
            mTimer = new Timer(true);
            mTimerTask = new MyTimerTask();
            mTimer.schedule(mTimerTask, 0, 1000); //延时1000ms后执行，1000ms检查一次
            // 初始化上次操作时间为登录成功的时间
            mLastActionTime = System.currentTimeMillis();
        }
    }



    //倒计时完毕的操作
    private void removeTimer() {
        if (DEBUG_TIME)
            LogPrint.e("=====removeTimer");
        if (globalValue.isUIBrightness) {
            if (DEBUG_TIME)
                LogPrint.e("=====removeTimer====1111");
            globalValue.isTimeForEnergy = true;
            ActionHandling.mHandlerTask.sendEmptyMessage(handlerSaveEnergy);
        }
    }

    // 停止计时任务
    private void stopTimer() {
        if (DEBUG_TIME)
            LogPrint.e("=====stopTimer");
        if (mTimer != null) {
            mTimer.cancel();
            mTimer = null;
        }

        if(mTimerTask!=null){
            mTimerTask.cancel();
            mTimerTask=null;
        }
    }


    static Date curDate, endDate;
    private Thread noOperationTimeOut = new Thread() {
        @Override
        public void run() {
            while (true) {
                try {
                    if (ConfigManage.jsonBean.getDisplay().getTimeForEnergy() == 0) {
                        synchronized (this) {
                            this.wait();
                        }
                        continue;
                    }
                    curDate = new Date(System.currentTimeMillis());
                    endDate = new Date(System.currentTimeMillis());
                    long timeForEnergy = ConfigManage.jsonBean.getDisplay().getTimeForEnergy() * 60 * 1000;
                    sleep(timeForEnergy);
                    //判断是否要延迟时间
                    while (true) {
                        long time = endDate.getTime() - curDate.getTime();
                        if (time < 1000) {
                            break;
                        }
                        if (0 < time && time < timeForEnergy) {
                            sleep(timeForEnergy - time);
                        } else {
                            break;
                        }
                    }
                    if (globalValue.isUIBrightness) {
                        globalValue.isTimeForEnergy = true;
                        ActionHandling.mHandlerTask.sendEmptyMessage(handlerSaveEnergy);
                    }
                } catch (InterruptedException e) {

                }
            }
        }
    };


    Timer mTimerIpReset; //计时器，每1秒执行一次任务
    private MyTimerTaskIpReset mTimerTaskIpReset; //计时任务，判断是否未操作时间到达3s
    private long mLastActionTimeIpReset; //上一次操作时间
    long timeForEnergyIpReset = ConfigManage.jsonBean.getDisplay().getIpResetSetting() * 1000;

    private class MyTimerTaskIpReset extends TimerTask {
        @Override
        public void run() {
            //3s未操作,则结束计时
            if (DEBUG_TIME)
                LogPrint.d("======3s未操作,MyTimerTaskIpReset" + (System.currentTimeMillis() - mLastActionTimeIpReset) + "====" + timeForEnergyIpReset);
            if (System.currentTimeMillis() - mLastActionTimeIpReset > timeForEnergyIpReset) {
                if (DEBUG_TIME)
                    LogPrint.d("======3屏幕变暗MyTimerTaskIpReset");
                //结束计时
                removeTimerIpReset();
                // 停止计时任务
                stopTimerIpReset();
            }
        }
    }


    //开始计时
    private void startTimerIpReset() {
        if (ConfigManage.jsonBean.getDisplay().getTimeForEnergy() != 0
                && ConfigManage.jsonBean.getDisplay().getIpResetSetting() != 0) {
            mTimerIpReset = new Timer(true);
            mTimerTaskIpReset = new MyTimerTaskIpReset();
            mTimerIpReset.schedule(mTimerTaskIpReset, 0, 1000); //延时1000ms后执行，1000ms检查一次
            // 初始化上次操作时间为登录成功的时间
            mLastActionTimeIpReset = System.currentTimeMillis();
        }
    }


    //倒计时完毕的操作
    private void removeTimerIpReset() {
        if (DEBUG_TIME)
            LogPrint.d("=====removeTimerIpReset");
        if (globalValue.isUIBrightness) {
            if (DEBUG_TIME)
                LogPrint.d("=====removeTimerIpReset====1111");
            //globalValue.isTimeForEnergy = true;
            ActionHandling.mHandlerTask.sendEmptyMessage(handlerSaveEnergyIpReset);
        }
    }

    // 停止计时任务
    private void stopTimerIpReset() {
        if (DEBUG_TIME)
            LogPrint.d("=====removeTimerIpReset");
        if (mTimerIpReset != null) {
            mTimerIpReset.cancel();
            mTimerIpReset = null;
        }

        if(mTimerTaskIpReset!=null){
            mTimerTaskIpReset.cancel();
            mTimerTaskIpReset = null;
        }
    }






//========================================================
    //开始计时
    boolean isRunning;
    private void startTimer1() {
        if (ConfigManage.jsonBean.getDisplay().getTimeForEnergy() != 0) {
            if(timer1 == null){
                getCountDownTimer();
            }
            timer1.start();
        }
    }

    private CountDownTimer timer1;
    public void getCountDownTimer(){
        timer1 = new CountDownTimer(timeForEnergy, 1000) {
            @Override
            public void onTick(long millisUntilFinished) {
                isRunning=true;
                LogPrint.e("======88888===="+millisUntilFinished / 1000);
            }
            @Override
            public void onFinish() {
                isRunning=false;
                LogPrint.e("======88888====onFinish");
                removeTimer1();
                stopTimer1();
            }
        };
    }

    // 停止计时任务
    private void stopTimer1() {
        if (DEBUG_TIME)
            LogPrint.e("=====88888stopTimer停止");
        if (timer1 != null) {
            timer1.cancel();
            timer1 = null;
            isRunning=false;
        }
    }


    //倒计时完毕的操作
    private void removeTimer1() {
        if (DEBUG_TIME)
            LogPrint.e("=====removeTimer");
        if (globalValue.isUIBrightness) {
            if (DEBUG_TIME)
                LogPrint.e("=====removeTimer====1111");
            globalValue.isTimeForEnergy = true;
            ActionHandling.mHandlerTask.sendEmptyMessage(handlerSaveEnergy);
        }
    }

//========================================================

    //开始计时
    boolean isRunningIpReset1;
    private void startTimerIpReset1() {
        if (ConfigManage.jsonBean.getDisplay().getTimeForEnergy() != 0
                && ConfigManage.jsonBean.getDisplay().getIpResetSetting() != 0) {
            if(timerIpReset1 == null){
                getCountDownTimerIpReset1();
            }
            timerIpReset1.start();
        }
    }

    private CountDownTimer timerIpReset1;
    public void getCountDownTimerIpReset1(){
        timerIpReset1 = new CountDownTimer(timeForEnergyIpReset, 1000) {
            @Override
            public void onTick(long millisUntilFinished) {
                isRunningIpReset1=true;
                LogPrint.e("======88888===="+millisUntilFinished / 1000);
            }
            @Override
            public void onFinish() {
                isRunningIpReset1=false;
                LogPrint.e("======88888====onFinish");
                removeTimerIpReset1();
                stopTimerIpReset1();
            }
        };
    }

    // 停止计时任务
    private void stopTimerIpReset1() {
        if (DEBUG_TIME)
            LogPrint.e("=====88888stopTimer停止");
        if (timerIpReset1 != null) {
            timerIpReset1.cancel();
            timerIpReset1 = null;
            isRunningIpReset1=false;
        }
    }


    //倒计时完毕的操作
    private void removeTimerIpReset1() {
        if (DEBUG_TIME)
            LogPrint.e("=====removeTimer");
        if (globalValue.isUIBrightness) {
            if (DEBUG_TIME)
                LogPrint.e("=====removeTimer====1111");
            globalValue.isTimeForEnergy = true;
            ActionHandling.mHandlerTask.sendEmptyMessage(handlerSaveEnergyIpReset);
        }
    }


}

 

aicpzl
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA获取当前系统时间 System.currentTimeMillis()
weixin_30820151的博客
07-19 245
System.currentTimeMillis()产生一个当前的毫秒，这个毫秒其实就是自1970年1月1日0时起的毫秒数，Date()其实就是相当于Date(System.currentTimeMillis());因为Date类还有构造Date(long date)，用来计算long秒与1970年1月1日之间的毫秒差。 得到了这个毫秒数，我们自己也可以算起现在的年月日周时，但是这不是我们...
System.currentTimeMillis()计算方式与时间的单位转换
weixin_34088583的博客
04-27 253
一、时间的单位转换 1秒=1000毫秒(ms) 1毫秒=1／1,000秒(s)1秒=1,000,000 微秒(μs) 1微秒=1／1,000,000秒(s)1秒=1,000,000,000 纳秒(ns) 1纳秒=1／1,000,000,000秒(s)1秒=1,000,000,000,000 皮秒(ps) 1皮秒=1／1,000,000,000,000秒(s) 1分钟=60秒 1小时=60分钟...
android 重置倒计时,Android计时器跟倒计时的实现（含开始，暂停，和复位）
weixin_34382844的博客
05-26 902
倒计时和计时在比赛中经常用到，由于涉及到子线程和主线程的通信问题，同学们在制作的时候总有点畏手畏脚的，今天会有两个神器出现，帮助大家攻克这两道难关！神器一：chronometer --andrdoid 控件的一种，自带监听方法，使用前需要将该控件设置在xml配置文件里神奇二：CountDownTimer---代码控制的倒计时，只需要调用textview显示即可===================...
JAVA Timer()实现可重置计时器
weixin_42152152的博客
07-30 1796
要去实现一个计时器功能：倒记时10秒，倒计时结束后，触发事件A，倒计时过程中，若触发事件B，则重置计时器，重新倒计时十秒。
Js获取当前系统时间
醉殇姒若梦遗年 ツ的博客
09-24 2377
Js获取当前系统时间 var myDate = new Date(); myDate.getYear(); //获取当前年份(2位) myDate.getFullYear(); //获取完整的年份(4位,1970-????) myDate.getMonth(); //获取当前月份(0-11,0代表1月) myDate....
用软件延时实现00－59秒单片机计时器
08-11
在本设计中，我们使用一个存储单元作为秒计数单元，当一秒钟到来时，就让秒计数单元加1，当秒计数达到60时，就自动返回到0，从新秒计数。我们可以使用CJNE A,#60,NEXTLJMP START来实现秒计数单元的自动返回。 知识...
vue倒计时刷新页面不会从头开始的解决方法
10-15
在本篇文章里小编给大家整理的是关于vue倒计时刷新页面不会从头开始的解决方法，需要的朋友们参考下。
00－59秒计时器（用软件延时）
08-02
00－59秒计时器（用软件延时） 本文主要介绍了00－59秒计时器（用软件延时），该计时器使用软件延时的方法来实现秒计时。下面是该计时器的详细知识点： 一、实验任务： * 在AT89S51单片机的P0和P2端口分别接有两...
倒计时 QT安卓版程序示例
最新发布
01-05
6. **重新倒计时**：这个功能意味着用户可以设置新的倒计时时间，需要清空现有的计时器状态，并从新时间开始计数。 7. **异常处理**：考虑到可能出现的错误条件，比如用户在倒计时过程中突然退出应用，开发者需要...
魔方专用计时器 (exe 版)
05-14
******* 计时器 (魔方专用) ******* /** * Timer & ListTimer * version 1.0.0 * * URI: http://blog.dofy.net/?p=918 * * Author: Seven Yu * Update: 20090629 */ 声明: ~~~~~ 该软件为自由软件, 你...
Mars3D开发基础学习：时钟Clock及时序控制
木遥的专栏
12-30 1357
平台的强大之处也在于其可以将时间运用到三维地球上，平台不仅仅是3D的地理空间的展示，同时也具备“时间维度”的时序的相关控制，具备空间+时间的管理，可以根据“时间”进行动画、轨迹记录、地球的光照等等所有与时间相关的可视化效果。
Java程序计时（currentTimeMillis()和nanoTime()）
qq_43644002的博客
08-05 1654
一. currentTimeMillis() java.lang.System中的方法。 public static long currentTimeMillis() 以毫秒为单位返回当前时间。 程序运行速度太快时无法捕捉运行时间，可测量程序多次运行的时间。 二. nanoTime() java.lang.System中的方法。 public static long nanoTime() 返...
嵌入式调试时间戳
qq_33901011的博客
11-14 1237
该思路是不用RTC时钟，根据Unix时间戳换算成北京时间，再用一定的格式打印出来。适用于长时间的跑代码，查找问题。代码简单，方便移植。 简要说明。 1、g_debug_time为32位变量，Unix时间戳，在中断里每一秒加一 2、初始化时调用debug_time_init，更改时间时也调用debug_time_init。该函数会将g_debug_time更新。 3、将需要打印时间的地方调用debu...
重新计时的Timer
final1992的博客
12-08 2151
今天项目需要进行一个计时，当第一次调用方法call()时，等待60s调用方法A()，但是在等待的这60S中，如果再次调用方法call()，就要重新计时。 在网上查了一些资料，总是达不到这种效果或者线程没有正常结束。 自己写了一个工具类，做个笔记。 http://blog.csdn.net/gggland/article/details/45887855 借鉴了这个博客定义最后调用call()方
java timer 销毁_java重新计时 timer
weixin_33305182的博客
02-16 691
想实现一个逻辑：有一个方法A()，第一次调用等待500ms,如果在这个时间间隔内再次调用方法A(),则重新对方法A()进行计时，如果连续有多次调用方法A()且时间间隔均小于500ms，则只执行最后一个时间间隔大于500ms，也就是说只有与下一次调用超过500ms的调用才被执行。本人才疏学浅，不知道是否java提供这样的方法，所以找起百度大神搜到的解答，有的说：sleep计算间隔，第一次睡500ms...
小笔记：Timer定时间隔时间操作
amkgae9654的博客
10-02 921
小笔记：Timer定时间隔时间操作，后面有时间再补充和完善： public class TimingSvc { /// <summary> /// 定时器，执行定时任务 /// </summary> private static Timer m_Timer; ...
android 定时器重置,android – 计时器重置
weixin_31635881的博客
05-26 849
我正在尝试完全重新启动计时器,它不工作.而是暂停.基本上我要做的就是在计时器计数到10时做一些事情.完成后,我们提示用户再试一次.在这种情况下,我们要重做计数从1到10秒.但是计时器从暂停时间开始,而不是从0开始.这里是代码：_cutOfTime = 10; // constant每次按下按钮都执行startRecording()它应该始终启动计时器,而不是停止/暂停它,但它做的相反protect...
篮球竞赛30秒计时器课程设计详解与实现
篮球竞赛30秒计时器设计课程是一门针对计算机科学与技术专业的实践性课程，旨在让学生将理论知识应用于实际项目，设计并实现一个专门用于篮球比赛的计时工具。课程设计任务发生在2010年7月15日至7月24日期间，主题...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值