拆轮子系列---RxJava理解（零）前奏篇

最新推荐文章于 2024-10-09 16:00:54 发布
最新推荐文章于 2024-10-09 16:00:54 发布
阅读量100 收藏
点赞数
文章标签： java 数据结构与算法
原文链接：https://juejin.im/post/5b4fe921f265da0f9b4de16d
版权

本系列文章：

本篇文章主要介绍为什么要使用RxJava，属于RxJava理解的前奏篇。本文大纲如下：

    1. RxJava的常规写法
    1. 一个具体的例子---从普通写法逐渐演变成RxJava写法
    1. 总结

1. RxJava 的常规写法

有人说RxJava非常好用，那么，它究竟好用在哪里？今天来具体分析下。首先，先来阐述RxJava到底是什么，RxJava官方的解释是：“a library for composing asynchronous and event-based programs using observable sequences for the Java VM”，其核心就是“asynchronous”这个词，直白的说，RxJava就是一个实现异步操作的库。那为什么大家会觉得RxJava好用，而不是使用AsyncTask/Handler...？这里可以归结一个词，简洁。举个例子，我们要从网络上获取图片然后显示。利用AsyncTask的做法是这样的：

public class ImageTask extends AsyncTask<String, Void, Bitmap> {
        @Override
        protected Bitmap doInBackground(String... params) {
            String imageUrl = params[0];
            try {
                URL url = new URL(imageUrl);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                InputStream is = conn.getInputStream();
                Bitmap bitmap = BitmapFactory.decodeStream(is);
                if (bitmap != null) {
                    return bitmap;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }

        @Override
        protected void onPostExecute(Bitmap bitmap) {
            super.onPostExecute(bitmap);
            if(bitmap!=null){
                showBitMap();
            }
        }
    }
复制代码

如果将这个需求用RxJava实现会是怎么样？我们先实现看看：

Observable.just(imageUrl)
                .map(new Func1<String, Bitmap>() {
                    @Override
                    public Bitmap call(String url) {
                        return getBitmapFromUrl(url);
                    }
                })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<Bitmap>() {
                    @Override
                    public void call(Bitmap bitmap) {
                        showBitMap();
                    }
                }); 
复制代码

可能有的朋友要说话了没看出什么区别啊，好用个毛线啊。其实，我们观察下就能发现，RxJava的这个实现，是一条链式调用，在逻辑上没有任何的嵌套，简单明了。更进一步说，当我们需求变得复杂时，比如在大量的图片资源中选择一张，亦或者是选择前几张图片的时候，你还能在你那片代码中能迅速理清逻辑，并快速调整？RxJava在处理复杂逻辑时，一条链式调用，虽然很长，但胜在逻辑清晰。

2. 一个具体的例子---从普通写法逐渐演变成RxJava写法

接下来，以一个例子具体阐述下RxJava到底逻辑清晰在哪里。假设有一个需求：谁是最可爱的人（SB需求，哈哈哈）。该需求大体就是网络请求查询一组图片，每张图片有一个可爱系数（一个整型值），而我们的任务，就是下载一组可爱人的照片集合，然后选择最可爱的那个。 好了，需求弄明白了接下来就进行实现吧，先定义一个简单的数据结构：

public class CutestPeople implements Comparable<CutestPeople> {

    private Bitmap image;
    private int cuteness;

    @Override
    public int compareTo(CutestPeople cutestPeople) {
        return Integer.compare(cuteness, cutestPeople.cuteness);
    }
 }  
复制代码

然后，提供两个接口，查询与保存：

public interface QueryApi {
    /**
     * 查询可爱的人
     */
    List<CutestPeople>  queryCuestPeople(String query);
    /**
     * 获取需要保存的Uri
     */
    Uri store(CutestPeople people);
}
复制代码

好了，大体结构基本完成，接下来定义一个帮助类，该类就是调用前面定义的方法获取结果：

public class DataHelper {
    private QueryApi mApi;

    public Uri saveTheCutestPeople(String query) {
        List<CutestPeople> cutestPeoples = mApi.queryCuestPeople(query);
        CutestPeople cutestPeople = findCutestPeople(cutestPeoples);
        Uri savedUrl = mApi.store(cutestPeople);
        return savedUrl;
    }

    /**
     * 获取最可爱的人
     */
    public CutestPeople findCutestPeople(List<CutestPeople> people) {
        return Collections.max(people);
    }
}
复制代码

上面似乎完成了？不对，还有一个问题，加上异常处理机制：

try {
       List<CutestPeople> cutestPeoples = mApi.queryCuestPeople(query);
       CutestPeople cutestPeople = findCutestPeople(cutestPeoples);
       Uri savedUrl = mApi.store(cutestPeople);
       return savedUrl;
   } catch (Exception e) {
       e.printStackTrace();
       return error;
   }
复制代码

到这里，需求算是大体完成了，程序可以跑起来了。但是，有没有发现，以上的代码还有很大的优化空间，比如，我们在接口里面定义异步回调机制，这样程序运行的结果或者异常都可以从回调中拿到：

public interface QueryApi {

    interface CuestPeopleQueryCallback {
        void onCuestPeopleReceived(List<CutestPeople> people);
        void onQueryError(Exception e);
    }

    interface StoreCallback {
        void onCuestPeopleStore(Uri uri);
        void onStoreError(Exception e);
    }

    /**
     * 获取可爱人儿集合
     *
     */
    List<CutestPeople> queryCutestPeople(String query, CutestPeopleQueryCallback callback);

    /**
     * 保存最可爱的人到本地
     *
     */
    Uri store(CutestPeople people, StoreCallback callback);
}
复制代码

既然接口发生了改变，那么相应的DataHelper类的逻辑也要发生改变，继续修改：

public class DataHelper {

    private QueryApi mApi;

    public void saveTheCuestPeople(String query, final CutestPeopleCallback cutestCallback) {
     mApi.queryCutestPeople(query, new QueryApi.CutestPeopleQueryCallback() {
     @Override
     public void onCutestPeopleReceived(List<CutestPeople> people) {
        CutestPeople cutestPeople = findCutestPeople(people);
        mApi.store(cutestPeople, new QueryApi.StoreCallback() {
        @Override
        public void onCutestPeopleStore(Uri uri) {
           cutestPeopleCallback.onCutestPeopleSaved(uri);
        }

        @Override
        public void onStoreError(Exception e) {
            cutestPeopleCallback.onError(e);
            }
          });
        }

            @Override
            public void onQueryError(Exception e) {
                cutestPeopleCallback.onError(e);
            }
        });
    }

    /**
     * 获取最可爱的人
     */
    public CutestPeople findCutestPeople(List<CutestPeople> people) {
        return Collections.max(people);
    }

    /**
     * 最可爱的人保存结果回调
     */
    public interface CutestPeopleCallback {
        void onCutestPeopleSaved(Uri uri);
        void onError(Exception e);
    }
}
复制代码

经过上面的修改，代码看起来是不是好了很多。可是，有没有发现接口调用的太多了，而且在每一个关键点都需要手动的插入相应的接口回调，而且，错误传递机制也木有。这样子还不行，需要继续优化。目前的情况看，我们QuaryApi中的接口是这个样子的：

void onCutestPeopleReceived(List<CutestPeople> people);
void onCutestPeopleStore(Uri uri);
...
void onQueryError(Exception e);
void onStoreError(Exception e);
复制代码

这个时候已经定义的接口方法是不能改变了，但是，我们可以在不改变方法的前提下对接口进行包装：

public interface Callback<T> {
    void onGetResult(T result);
    void onError(Exception e);
}
复制代码

继续搞事情，将之前定义的QueryApi进行包装下：

public class ApiWarpper {

    private QueryApi mApi;

    public void queryQuestPeople(String query, final MyCallback<List<CutestPeople>> myCallback) {

        mApi.queryCutestPeople(query, new QueryApi.CutestPeopleQueryCallback() {
            @Override
            public void onCutestPeopleReceived(List<CutestPeople> people) {
                myCallback.onGetResult(people);
            }

            @Override
            public void onQueryError(Exception e) {

                myCallback.onError(e);
            }
        });

    }

    public void storeUri(CutestPeople people, final MyCallback<Uri> myCallback) {
        mApi.store(people, new QueryApi.StoreCallback() {
            @Override
            public void onCutestPeopleStore(Uri uri) {
                myCallback.onGetResult(uri);
            }

            @Override
            public void onStoreError(Exception e) {
                myCallback.onError(e);
            }
        });
    }
}
复制代码

在对QueryApi进行包装之后，我们再来修改下DataHelper中的逻辑，调整如下：

public class DataHelper {

    ApiWrapper mApiWrapper;

    public void saveTheCutestPeople(String query, final MyCallback<Uri> myCallBack) {

        mApiWrapper.queryQuestPeople(query, new MyCallback<List<CutestPeople>>() {
            @Override
            public void onGetResult(List<CutestPeople> result) {
                CutestPeople cutestPeople = findCutestPeople(result);
                mApiWrapper.storeUri(cutestPeople, myCallBack);
            }

            @Override
            public void onError(Exception e) {
                myCallBack.onError(e);
            }
        });
    }

    /**
     * 获取最可爱的人
     */
    public CutestPeople findCutestPeople(List<CutestPeople> people) {
    return Collections.max(people);
    }
}
复制代码

好了，到了这一步基本上没什么问题，需求已经完成。但是，没错还有但是，我们可以想想，能不能将每个异步操作分解成更小的粒子，也就是说，每个异步操作只携带一个参数对象，然后返回携带者回调信息的临时变量。 接下来定义一个通用的临时变量，该对象只是携带一个参数：

public abstract class MyAsyncTask<T> {
    public abstract void start(MyCallback<T> callback);
}
复制代码

修改ApiWrapper中的方法，将异步请求分解成更小的粒子：

public class ApiWrapper {

    private QueryApi mApi;

    public MyAsyncTask<List<CutestPeople>> queryQuestPeople(final String query) {
    //这里做了修改，传入一个参数，返回一个临时变量
    return new MyAsyncTask<List<CutestPeople>>() {
    @Override
    public void start(final MyCallback<List<CutestPeople>> callback) {
       mApi.queryCutestPeople(query, new QueryApi.CutestPeopleQueryCallback() {
            @Override
             public void onCutestPeopleReceived(List<CutestPeople> people) {
             callback.onGetResult(people);
             }

             @Override
              public void onQueryError(Exception e) {
              callback.onError(e);
             }
         });
       }
     };
   }

    public MyAsyncTask<Uri> storeUri(final CutestPeople people){
        //这里做了修改，传入一个参数，返回一个临时变量  
        return new MyAsyncTask<Uri>() {
            @Override
            public void start(final MyCallback<Uri> callback) {

                mApi.store(people, new QueryApi.StoreCallback() {
                    @Override
                    public void onCutestPeopleStore(Uri uri) {
                        callback.onGetResult(uri);
                    }

                    @Override
                    public void onStoreError(Exception e) {

                        callback.onError(e);
                    }
                });
            }
        };
    }
}
复制代码

改了ApiWrapper当然同步的需要修改DataHelper这个类：

public class DataHelper {

    ApiWrapper mApiWrapper;

    public MyAsyncTask<Uri> saveTheCuestPeople(final String query) {

        final MyAsyncTask<List<CutestPeople>> listMyAsyncTask = mApiWrapper.queryQuestPeople(query);

        final MyAsyncTask<CutestPeople> myCutestAsyncTask = new MyAsyncTask<CutestPeople>() {

            @Override
            public void start(final MyCallback<CutestPeople> callback) {
            listMyAsyncTask.start(new MyCallback<List<CutestPeople>>){
                     @Override
                     public void onGetResult(List<CutestPeople> result) {                       
                      callback.onGetResult(findCutestPeople(result));
                     }

                     @Override
                     public void onError(Exception e) {
                     callback.onError(e);
                    }
               });
            }
        };

     MyAsyncTask<Uri> uriMyAsyncTask = new MyAsyncTask<Uri>() {
          @Override
          public void start(final MyCallback<Uri> callback) {
           myCutestAsyncTask.start(new MyCallback<CutestPeople>() {
                    @Override
                    public void onGetResult(CutestPeople result) {
                        mApiWrapper.storeUri(result)
                                .start(new MyCallback<Uri>() {
                                 @Override
                                  public void onGetResult(Uri result) {
                                  callback.onGetResult(result);
                                  }

                                  @Override
                                  public void onError(Exception e) {
                                  callback.onError(e);
                                  }
                              });
                    }

                    @Override
                    public void onError(Exception e) {
                        callback.onError(e);
                    }
                });
            }
        };
        return uriMyAsyncTask;
    }


    /**
     * 获取可爱的人
     */

    public CutestPeople findCutestPeople(List<CutestPeople> people) {
        return Collections.max(people);
    }
}
复制代码

修改之后似乎变得比之前要复杂，我们回顾最初我们写的代码：

public class DataHelper {
    private QueryApi mApi;

    public Uri saveTheCutestPeople(String query) {
        List<CutestPeople> cutestPeoples = mApi.queryCuestPeople(query);
        CutestPeople cutestPeople = findCutestPeople(cutestPeoples);
        Uri savedUrl = mApi.store(cutestPeople);
       return savedUrl;
    }

    /**
     * 获取最可爱的人
     */
    public CutestPeople findCutestPeople(List<CutestPeople> people) {
        return Collections.max(people);
    }
}
复制代码

将我们最后修改的代码简化下：

public class DataHelper {

    ApiWrapper mApiWrapper;

    public MyAsyncTask<Uri> saveTheCuestPeople(final String query) {

      final MyAsyncTask<List<CutestPeople>> listMyAsyncTask = mApiWrapper.queryQuestPeople(query);

      final MyAsyncTask<CutestPeople> myCutestAsyncTask = new MyAsyncTask<CutestPeople>() { ...};
      MyAsyncTask<Uri> uriMyAsyncTask = new MyAsyncTask<Uri>() {...};
      return uriMyAsyncTask;
    }

    /**
     * 获取最可爱的人
     */

    public CutestPeople findCutestPeople(List<CutestPeople> people) {
        return Collections.max(people);
    }
}
复制代码

对比上面两份代码我们发现，其实大体的逻辑是保持一致的，区别就是我们将异步操作细分成了更小的模块，然后组合在一起，最后返回一个组合后的结果对象而已。 写了这么多，好像跟RxJava没有什么关系啊，别急，下面我们用RxJava来实现这个需求:

public class ApiWrapper {

    private QueryApi mApi;

    public Observable<List<CutestPeople>> queryQuestPeople(final String query) {
        return Observable.create(new Observable.OnSubscribe<List<CutestPeople>>() {
            @Override
            public void call(final Subscriber<? super List<CutestPeople>> subscriber) {

                mApi.queryCutestPeople(query, new QueryApi.CutestPeopleQueryCallback() {
                    @Override
                    public void onCutestPeopleReceived(List<CutestPeople> people) {
                        subscriber.onNext(people);
                    }

                    @Override
                    public void onQueryError(Exception e) {
                        subscriber.onError(e);
                    }
                });
            }
        });
    }

    public Observable<Uri> storeUri(final CutestPeople people) {
        return Observable.create(new Observable.OnSubscribe<Uri>() {
         @Override
         public void call(final Subscriber<? super Uri> subscriber) {
                mApi.store(people, new QueryApi.StoreCallback() {
                    @Override
                    public void onCutestPeopleStore(Uri uri) {
                        subscriber.onNext(uri);
                    }

                    @Override
                    public void onStoreError(Exception e) {
                        subscriber.onError(e);
                    }
                });
            }
        });
    }
}
复制代码

DataHelper类：

public class DataHelper {

    ApiWrapper mApiWrapper;

    public Observable<Uri> saveTheCuestPeople(String query) {
        Observable<List<CutestPeople>> listObservable = mApiWrapper.queryQuestPeople(query);
        Observable<CutestPeople> cutestPeople = listObservable.map(new Func1<List<CutestPeople>, CutestPeople>() {
            @Override
            public CutestPeople call(List<CutestPeople> cutestPeoples) {
                return findCutestPeople(cutestPeoples);
            }
        });
        Observable<Uri> storeObservable = cutestPeople.flatMap(new Func1<CutestPeople, Observable<Uri>>() {
            @Override
            public Observable<Uri> call(CutestPeople people) {
                return mApiWrapper.storeUri(people);
            }
        });
        return storeObservable;
    }

    /**
     * 获取最可爱的人
     */
    public CutestPeople findCutestPeople(List<CutestPeople> people) {
        return Collections.max(people);
    }
}
复制代码

看到上面的逻辑，是否发现跟我们最后写的逻辑基本一致？而区别就是利用RxJava将一个个的异步操作单独的抽象出来，这样我们就能避免各种嵌套的回调，然后将这些抽象出来的异步操作进行组合作为一个结果返回即可。

3. 总结

RxJava的核心思想就是处理异步操作，将异步操作独立的抽象出来，在异步条件非常复杂的情况下，RxJave以一条链式调用将所有复杂的异步操作串成一条线，从而实现代码的易读性与简洁性。

weixin_33979363
关注
Android-拆轮子-学习Depth唯美的动画效果
08-13
"Android-拆轮子-学习Depth唯美的动画效果"这个主题，旨在深入探索如何在Android应用中实现深度（Depth）感知的精美动画。这类动画通常会给用户带来更真实、更有层次的视觉体验，使交互更加生动有趣。 深度动画在...
需几个轮子---教学设计.doc
11-28
需几个轮子---教学设计.doc
java imapi_拆轮子系列---RxJava理解（零）前奏篇
weixin_36446407的博客
02-24 84
本系列文章：本篇文章主要介绍为什么要使用RxJava，属于RxJava理解的前奏篇。本文大纲如下：RxJava的常规写法一个具体的例子---从普通写法逐渐演变成RxJava写法总结1. RxJava 的常规写法有人说RxJava非常好用，那么，它究竟好用在哪里？今天来具体分析下。首先，先来阐述RxJava到底是什么，RxJava官方的解释是：“a library for composing asy...
拆轮子系列--RxJava理解(一)--Map解析
weixin_34334744的博客
07-19 69
本系列文章如下： 拆轮子系列--RxJava前奏篇 拆轮子系列--RxJava理解(一)--Map解析 拆轮子系列--RxJava理解(二)--subscribeOn 拆轮子系列--RxJava理解(三)--observeOn 上一篇文章属于RxJava的前奏篇，大体介绍了下为什么要使用RxJava，本篇文章主要从RxJava的基本使用流程入手来对RxJava的源码进行分析，本文的分析源码基于...
拆轮子系列--RxJava理解（三）--observeOn
weixin_33737134的博客
07-19 70
本系列文章如下： 拆轮子系列--RxJava前奏篇 拆轮子系列--RxJava理解(一)--Map解析 拆轮子系列--RxJava理解(二)--subscribeOn 拆轮子系列--RxJava理解(三)--observeOn 上一篇文章主要介绍了RxJava中线程调度的核心方法之一subscribeOn，本篇文章继续分析RxJava中线程调度的另一个核心方法--observeOn。本篇文章基...
拆轮子系列--RxJava理解（二）--subscribeOn
weixin_34253539的博客
07-19 46
本系列文章如下： 拆轮子系列--RxJava前奏篇 拆轮子系列--RxJava理解(一)--Map解析 拆轮子系列--RxJava理解(二)--subscribeOn 拆轮子系列--RxJava理解(三)--observeOn 上一篇文章主要介绍了RxJava中基本的调用流程以及常用的操作符--map。本文主要介绍RxJava中线程调度的核心操作符之一subscribeOn，本文源码分析基于R...
第三方开源库 RxJava - 基本使用和源码分析
z240336124的专栏
12-08 504
RxJava 历史有点悠久，目前最新版是 2.x 的版本，网络上有很多关于 RxJava 的文章， 随便搜搜一大堆。为什么还要来写一些文章，毕竟那是别人的东西，并没有变成我的知识，其次课程具体的内容有安排，所以我们还是自己动手写写吧。还是老套路从源码的角度出发，当然 RxJava 用了这么久，我们应该也有自己的一些理解，其实就是三个字：事件流很多人一开始就从观察者设计模式入手去分析，这个也不说行不通
android 必读的文章- 收藏集 - 掘金
hzy670800844的博客
05-06 3836
写给 Android 开发者的混淆使用手册 - Android - 掘金 本文转自：点击打开链接 毫无疑问，混淆是打包过程中最重要的流程之一，在没有特殊原因的情况下，所有 app 都应该开启混淆。 首先，这里说的的混淆其实是包括了代码压缩、代码混淆以及资源压缩等的优化过程。依靠 ProGuard，混淆流程将...
python3.7轮子文件dlib-19.22.99-cp37-cp37-win-amd64.whl
11-12
python模块:dlib 版本号：19.22.99 适用平台：windows x64 适用python版本:3.7系列 安装方式:pip install dlib-19.22.99-cp37-cp37-win_amd64.whl
20--[旋转的轮子1].zip源码scratch2.0 3.0编程项目源文件源码案例素材源代码
04-17
20--[旋转的轮子1].zip源码scratch2.0 3.0编程项目源文件源码案例素材源代码20--[旋转的轮子1].zip源码scratch2.0 3.0编程项目源文件源码案例素材源代码20--[旋转的轮子1].zip源码scratch2.0 3.0编程项目源文件源码...
python3.8轮子文件dlib-19.22.99-cp38-cp38-win-amd64.whl
11-12
python模块:dlib 版本号：19.22.99 适用平台：windows x64 适用python版本:3.8系列 安装方式:pip install dlib-19.22.99-cp38-cp38-win_amd64.whl
JDK1.0主要特性
FoolRabbit的专栏
10-06 605
JDK1.0主要特性。
2024Java最新面试题总结（针对于一些小厂、中厂）
weixin_62375676的博客
10-07 1381
2024最新Java面试题，针对一些小厂，中厂
已解决-Sentinel控制台明明正常启动，扫描不到客户端应用
qq_46248151的博客
10-08 537
经排查才发现，我在启动了Sentinel控制台之后，对SpringBoot应用做了配置的更新，于是重启了SpringBoot服务，这时SpringBoot是没有任何访问的。今天启动Sentinel控制台的时候，明明启动成功，无报错，浏览器能正常访问，但就是无论如何都刷新不出来应用。
Spring Boot新闻推荐系统设计与实现
2402_85758936的博客
10-04 1523
目前，界面设计已经成为对软件质量进行评价的一条关键指标，一个好的用户界面可以使用户使用系统的信心和兴趣增加，从而使工作效率提高，JSP技术是将JAVA语言作为脚本语言的，JSP网页给整个服务器端的JAVA库单元提供了一个接口用来服务HTTP的应用程序。一旦输入系统的数据不正确，那么处理后的输出就会扩大这些错误，因此输入的数据的准确性对整个系统的性能起着决定性意义。输出是由电脑对输入的基本信息进行解决，生成高质量的有效信息，并使之具有一定的格式，提供给管理者使用，这是输出设计的主要责任和目标。
【含开题报告+文档+PPT+源码】基于SSM框架的线上交易商城的设计与实现
码蜂窝编程-全网唯一毕设在线答疑，项目包运行成功，全套教学视频一站式辅导机构。
10-07 588
本课程演示的是一款校园二手交易系统，主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的 Java 学习者。包含：项目源码、项目文档、数据库脚本、软件工具等所有资料带你从零开始部署运行本套系统该项目附带的源码资料可作为毕设使用系统主要功能有：登录注册、公告管理、用户管理、商品管理、商品搜索、购物车、订单管理、用户私聊等模块。
springboot 用request.setAttribute 传值到控制层
最新发布
qq56477643的博客
10-09 416
【代码】springboot 用request.setAttribute 传值到控制层。
古典舞在线交流：SpringBoot平台实现与优化
2401_85341950的博客
10-04 728
在这段时期里，我查找了很多相关的资料，查阅了很多Java的相关文献，结合自己的经验，设计了这个古典舞在线交流平台，虽然每个学期学校都会针对动手练习进行相应的课程设计，但是在古典舞在线交流平台的具体设计中还是遇到了一些小问题，但在不断的学习、研究中都将问题一一解决，在一一克服的过程中，我也得到了成长，知识和经验也得到了丰富，这对我来说是一笔巨大的财富。这次设计也大大提高了我的动手的能力，让我在学习中充分体会到了探索的乐趣，享受成功的创作过程，在本次设计过程中汲取的东西，是一笔宝贵的财富，让我受益匪浅。
V-REP机器人模拟教程：构建BubbleRob
为了更好地理解V-REP的各项功能，除了本教程外，建议同时参考其他的V-REP教程，特别是关于建立仿真模型的教程。这些教程将帮助你掌握建模、脚本编写和仿真调试等关键技能。 V-REP英文教程中的BubbleRob部分是学习V-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值