精华内容
下载资源
问答
  • 六小实践活动有哪些
    万次阅读
    2020-12-30 10:41:31

    教案通常又叫课时计划,包括时间、方法、步骤、检查以及教材的组织等。那么教师是怎么设计教案的呢?下面是小编分享给大家的初中数学实践活动教案的资料,希望大家喜欢!初中数学实践活动教案一教学目标1.会通过列方程解决“配套问题”;2.掌握列方程解决实际问题的一般步骤;3.通过列方程解决实际问题的过程,体会建模思想.教学重点建立...

    综合实践活动是一种研究性活动,也是一种通过实践让学生产生情感体验、能力方法和知识经验的活动,下面是小编收集整理的,欢迎阅读。篇一综合实践活动目的在于通过一系列实践活动增强学生的探究和创新意识,使学生获得亲身参与实践的积极体验和丰富经验,培养和发展学生解决问题的能力和综合实践的能力,发展学生对知识的综合运用和创新能力。结合本校实际情况,以学生为本,重在实践、重在体验、重在提高、...

    社会实践活动激发学生的活力和创造性,是课堂教学的有益补充和不可分割的一部分。下面是小编为大家整理的,供你参考!篇1随着人们经济能力的提高,如今的青少年一代在小学就开始有独立消费的行为,到了中学时代,他们一般都有一笔固定的消费资金(零花钱),有了经常性的独立购买活动。例如购买衣物:饰品、音像制品等自己喜欢的东西和上网交友娱乐等方面,虽然高消费的学生并不多,但是有关专家认为,十几...

    实践,就是把所学的理论知识,运用到客观实际中去,下面就是小编给大家带来的,希望能帮助到大家!初中社会实践活动心得一快乐的时光总是弥足珍贵,短暂的经历总是耐人寻味的,我们反复回忆、思索这一路上的点点滴滴,这十几天的社会实践有汗水,有欢笑,更有沉甸甸的收获。2019年x月11日至x月26日,我作为校级社会实践小分队的一员参加了院里组织的暑期社会实践活动,虽然半个月的时间...

    综合实践活动的内容具有开放性、科学性、实践性,它强调学科间的整合、知识的综合运用以及综合能力的培养。在此,小编为大家准备好了初中综合实践活动论文,一起来学习吧!在新一轮基础教育课程改革中,综合实践是课程改革的一个亮点,也是人们关注的焦点。新课程给领导和教师带来了全新的课程理念。在新课程的指导下,教学的过程不只是机械地实施教学计划,而是一次探究实践创新的过程,是培养学生的综合实践能力的过...

    综合实践活动的内容具有开放性、科学性、实践性,它强调学科间的整合、知识的综合运用以及综合能力的培养。在此,小编为大家准备好了初中综合实践活动论文,一起来学习吧!在新一轮基础教育课程改革中,综合实践是课程改革的一个亮点,也是人们关注的焦点。新课程给领导和教师带来了全新的课程理念。在新课程的指导下,教学的过程不只是机械地实施教学计划,而是一次探究实践创新的过程,是培养学生的综合实践能力的过...

    随着课程改革和规范办学的不断深入,素质教育步入内涵发展的新阶段。为了推进学校特色建设,提升学校文化品位,开发优质教育资源,全面增强教育教学实力,我校英语组全体教师发扬“善于学习、精于教学、强于研究、勇于创新、乐于奉献”的精神,大力开展多姿多彩的学科特色实践活动。指导思想:以科学的教育思想和先进的办学理念为先导,按照“高标准、高起点,重过程、重创新,实验性、示范性”的总体要求,立足县...

    今天是星期六,约定时间在下午1:00来到学校参加小队实践活动。正在这时,我遇到了罗小恺、蔡荣轩、邹德治、吴资敏、安誉恩。听邹德治说:“我上午和二班同学在华光城打扫过了。”我暗暗赞叹:难怪老师让他做卫生委员!真是选对人了。我们来到了新基础教育实验幼儿园,“开工啦!”我一边大叫道,一边拿出了我的“独家秘方”(指劳动工具)——扫把、抹布。我们忙得不可开交。我大叫,仿佛见到鬼似的说:“哇!...

    阳春三月,细雨蒙蒙,碧草如丝,淄博六中北校区初一年级的全体师生,来到了位于周村教师进修学校的中小学生社会活动基地,进行了为期五天的社会实践活动。实践基地的老师们根据初中生的特点举办了一系列活动:有让学生在紧急情况下镇定冷静,积极采取相应措施以自救救人的生命科学;有教给学生做事要专心致志、一丝不苟,坚持到底的木刻、刻瓷;有发扬团结精神,让学生在团结中合作,在合作中竞争的南水北调、铺路搭桥...

    阳春三月,细雨蒙蒙,碧草如丝,淄博六中北校区初一年级的全体师生,来到了位于周村教师进修学校的中小学生社会活动基地,进行了为期五天的社会实践活动。实践基地的老师们根据初中生的特点举办了一系列活动:有让学生在紧急情况下镇定冷静,积极采取相应措施以自救救人的生命科学;有教给学生做事要专心致志、一丝不苟,坚持到底的木刻、刻瓷;有发扬团结精神,让学生在团结中合作,在合作中竞争的南水北调、铺路搭桥...

    更多相关内容
  • 年级下册综合实践活动教案-让我们的创意点亮生活全国通用.pdf
  • 教育精品资料
  • 2018-2019学年西师大版语文年级上册第七单元 综合实践活动练习卷.pdf
  • 摘要:第十章是讲大学生社会实践活动的,主要内容为社会实践活动的目的,方式,内容,组织原则等方面的内容,感觉东西不多,考点不多。比较合适大学辅导员认真学生的实践,同时,作为科任老师来说,也一定的教学...

    摘要:第十章是讲大学生社会实践活动的,主要内容为社会实践活动的目的,方式,内容,组织原则等方面的内容,感觉东西不多,考点不多。比较合适大学辅导员认真学生的实践,同时,作为科任老师来说,也有一定的教学指导意义吧。反正这章内容倒是不多,背起来也比较容易些,上次参加考试似乎这部分内容并没考到呢。

    第十章 大学生社会实践活动及指导

    第一节 大学生社会实践活动的意义

    一、社会实践活动的概念

    • 大学生社会实践是一种以实践的方式实现高等学校教育目标的教育形式,是高校学生有目的、有计划地深入现实社会,参与具体的生产劳动和社会生活,以了解社会、增长知识技能、养成正确的社会意识和人生观的活动过程。

    二、社会实践活动的目的主要在于培养学生

    (一)社会实践活动的目的主要在于培养学生
    • 高等学校组织学生参加社会实践,最主要的目的在于培养学生,最终的目的是增长了见识和才干,完善了品格修养,是改造了学生自身。
    (二)现实参与的方式
    • 社会实践活动主要通过参与社会活动的方式而实施,这使其区别于高校的课堂教学。大学生在社会生产、生活过程中通过亲历亲感获得直接的、现实的知识和技能。
    (三)定向选择的内容
    • 大学生社会实践有定向选择的内容,带有特定的教育目的。定向选择的内容保障了社会实践活动的持续、稳定、有效的开展。
    (四)互补并进的效果
    • 大学生社会实践与高等学校其他的教育环节互相补充、促进,是高等学校完成育人目标不可分割的一部分。
    • 双重性特点。在社会实践中大学生既是高校的学生又是实践的主体,既是学习者又是生产者。

    三、社会实践活动在培养人的过程中的作用

    (一)可促进知识的转化和知识的拓展
    (二)有利于增强大学生的社会意识和社会技能
    (三)有利于发展大学生的创造才能和组织才能
    (四)有利于大学生提高修养、完善个性

    四、社会实践活动与教学和科研的关系

    (一)社会实践活动与教学活动的关系
    1. 目的的统一性
    2. 活动的主体有差别
    3. 所获知识的层次不同
    4. 知识获得的环境有差别
    (二)社会实践活动与科研活动的关系
    1. 目的结果的总体一致性:社会实践与科研同样服务于培养人才的大目的。严格来说,科研活动也是社会实践活动的一种特殊方式,二者有从属关系。
    2. 活动对象有差别:科研以自然物为对象,社会实践以社会生活为对象
    3. 活动方式有差别:科研以严格控制的实验,严密的论证来探索自然与社会的规律,社会实践则主要通过对生产生活的现实参与来体验和了解其含义与规则。
    4. 活动环境有差别:科研为了保证结论的真实与可靠,常常对环境进行严格控制,是相对封闭的,而社会实践则是开放的不加干涉的。

      • 社会实践与教学、科研共同构成高等学校的主体教育环境。

    第二节 社会实践活动的内容与形式

    一、大学生社会实践活动的内容

    (一)政治思想教育
    (二)国情、民情教育
    (三)社会规范与社会角色教育
    (四)心志磨练与个性养成教育
    (五)劳动和专业技能教育

    二、大学生社会实践活动的类别

    (一)教学计划内社会实践活动与教学计划外社会实践活动
    (二)基地化社会实践活动与非基地化社会实践活动
    (三)专业实践活动与非专业实践活动

    三、几种主要的社会实践介绍

    (一)军事训练
    (二)专业实习
    (三)生产劳动(学工学农)
    (四)社会调查
    (五)智力扶贫
    (六)参观考察

    第三节 大学生社会实践活动的组织

    一、大学生社会实践活动的组织程序

    (一)确定活动内容和场所
    (二)编制活动计划
    1. 活动目标
    2. 参加人员
    3. 过程安排
    4. 预算活动经费
    (三)组织活动过程
    (四)评估与总结

    二、大学生社会实践活动的组织原则

    (一)坚持教育效益为主,社会效益、经济效益兼顾的原则
    (二)点面结合、以点带面的原则
    (三)系统规则、分层进行的原则
    (四)因地制宜、勤俭节约的原则

    三、正确处理开展社会实践活动中的一些关系

    (一)出人才与出成果的关系
    • 培养人才是开展社会实践活动的根本目的,而出成果是相对次要的目的。
    (二)社会实践活动与教学科研的关系
    • 课堂教学、科学研究与社会实践是高等学校实现教育目标、培养合格人才的三个基本途径。在以教学为中心的前提下,要做到三者并重,同时各有侧重。
    (三)学生自主性与教师指导的关系
    • 社会实践活动中学生的自主性是指大学生要调动自身一切积极因素,按自己的方式去认识和探索世界,而不是处处依赖教师及其他人员的指点。
    • 只有大学生在参与社会实践的过程中充分发挥了自主和主动的精神,社会实践活动的锻炼意义才能真正体现出来。
      • (1)学生的主动性、自主性的发挥程度影响着社会实践活动的参与深度。
      • (2)社会实践活动的重要目的之一,即促进学生正确的政治思想品德的形成,学生在主动参与的过程中可以充分调动其各方面的能动性,使其对活动对象的理解更深刻、更准确。
    (四)深入性与广泛性的关系
    • 深入性是指要在活动过程中完成既定的目标和任务,确有所获;而广泛性则是指活动的内容要有广泛的涉及面和保证参与主体的广泛性。
    • 注意做好二者的协调,争取在现有条件下,尽可能地兼顾。
    (五)集体活动与个体活动的关系
    • 社会实践活动的组织形式有集体形式、小组形式和个体形式等三种。
    • 在保证大型的集体社会活动的前提下,鼓励个体自发组织各种小型的实践活动。这是社会实践活动本身开放性特点的要求。
    展开全文
  • DDD 领域驱动设计落地实践步拆解 DDD

    千次阅读 多人点赞 2022-01-11 07:56:12
    相信通过前面几篇文章的介绍,大家对于 DDD 的相关理论以及实践的套路了一定的理解,但是理解 DDD 理论和实践手段是一回事,能不能把这些理论知识实际应用到我们实际工作中又是另外一回事,因此本文通过实际的业务...

    引言

    相信通过前面几篇文章的介绍,大家对于 DDD 的相关理论以及实践的套路有了一定的理解,但是理解 DDD 理论和实践手段是一回事,能不能把这些理论知识实际应用到我们实际工作中又是另外一回事,因此本文通过实际的业务分析把之前文章中涉及的理论和手段全部带着大家走一遍,我想通过这种方式,让大家实际的感受下 DDD 落地过程中会遇到哪些问题以及我们应该怎样去解决这些问题。

    项目需求信息

    这里还是大家比较熟悉的电商场景来进行说明,我想这样大家比较好理解一点。在前段时间双十一,大家被各种购物优惠券的套路整的眼花缭乱,仿佛数学不好,都不配拿到最优惠的价格了。大家都在吐槽,就不能少点套路,买东西直接给我 5 折不就天下太平了吗?我想造成这种现象的原因大概就是中国电商行业的内卷吧,只有通过各种营销活动的堆积,才能让大家话更多的时间去浏览更过的商品,才能获得更好的留客以及交易。好了,跑题了,这些我们先不去关心。那我们今天就用这个折磨人的优惠券的流程作为设计实例来说明整个 DDD 的落地过程吧。优惠券的关键业务流程如下:

    (1)当需要进行大促活动的时候,运营同学需要选定对应的商品,创建创建优惠券。

    (2)运营同学需要创建营销活动,制定对应的营销活动规则,比如什么满减啊,跨店减啊类似这种折磨人脑细胞的规则,然后关联相应的优惠券,最后提交活动审批。审批通过后,进行营销活动发布。

    (3)提交活动审批后,审批进行营销活动审批。

    (4)用户在营销页面领取优惠券之后,下单购买商品之后,在付款的时候根据对应的优惠券进行付费金额计算并完成支付。

    在这里插入图片描述

    DDD 落地实践

    项目背景信息我们大致了解之后,那么我们就要着手开始通过DDD来进行领域驱动设计的过程了。其实我们学习 DDD 理论以及方法不是最终的目的,而通过它实现实际的业务复杂度治理以及优化微服务设计才是真正的目的。

    战略设计

    在战略设计阶段,我们最主要的过程大致包括了业务场景分析、领域建模、划分边界上下文三个阶段。实际上战略设计是 DDD 过程中的核心步骤。

    1、业务分析

    在这个阶段我们所有做的就是进行全面的业务梳理,吧业务中涉及到的所有细节都梳理出来,为后续进行领域建模分析提供足够的、全面的业务输入。经常使用到的业务场景分析方法主要包括用例分析法、事件风暴法以及四色建模法。这里我们使用事件风暴进行业务场景的分析以及梳理。

    (1)事前准备

    在进行事件风暴之前我们需要进行一些准备,主要包括贴纸、笔以及讨论的会议室,会议室中最好不要有椅子,目的是想让大家都能够站立在一起、全神贯注的去进行业务讨论。

    (2)邀请参会的人

    会议的参与方主要包括业务、用户、PD、研发、测试、架构师等。

    (3)业务讨论

    首先确定我们今天需要讨论的业务是什么,目标是什么。像前文所说的那样,本次讨论的业务就是营销活动的优惠券业务,目标就是完成优惠券的业务梳理,确保没有业务方面的理解 gap,在团队中达成业务理解的的一致性。在这个过程中我们需要通过提问的方式来驱动交流。

    a、分析业务中的事件,搞清楚事件发生的前因后果,什么意思呢?就是什么动作会导致当前时间的发生,当前这个事件发生后又会导致怎样的后果。这些我们都需要梳理清楚。还有一点需要注意, 我不但要关注正常的业务流程还要关注异常的业务流程。

    b、寻找业务逻辑和业务规则,比如我们在提交活动前,需要确定这些优惠券适用哪些人、领取方式是怎样的以及生效事件是怎样的等等,这些都是我们在执行操作之前需要确定的业务规则。

    如下图所示,我们将优惠券的业务流程进行了梳理,分别从操作人、事件、命令的方式来描述整个优惠券业务流转的过程。

    在这里插入图片描述
    :在进行事件风暴过程中,所有的参与人都要全身投入整个过程,放下手机以及电脑,一起参与整个业务梳理过程,只有这样,事件风暴才可能有比较好的效果。

    2、领域建模

    在前面的事件风暴业务梳理中,我们已经把优惠券业务涉及到的参与者、动作以及事件等都进行了全面的梳理。那么接下来我们就要在此基础之上进行领域建模,这是整个 DDD 的核心。

    (1)领域对象分析

    如上面所示的事件风暴小黑板中的内容,我们需要在这些梳理出来的内容中找到对应的实体、值对象以及围绕这些的领域事件以及命令操作。根据分析,我们总整个业务过程中提取了优惠券、营销活动、活动审批单、活动规则、审批意见等实体以及值对象以及和这些领域对象相关的命令操作。

    在这里插入图片描述
    (2)构建业务聚合

    完成领域对象分析之后,我们需要构建业务聚合。想要构建聚合,那么首先就要在实体中找到聚合根。我们先来回顾下聚合根的特点,聚合根一定是实体,那么它具有全局唯一的标识,另外它是具备生命周期的同时需要专门的模块来进行管理。根据这样的标准,在领域对象中我们发现优惠券、营销活动以及活动审批单是具备聚合根特征的,而营销规则、营销内容等是和营销活动紧密相关的,因此他们构成营销活动聚合关系。优惠券规则、优惠券类型等是和优惠券聚合根紧密相连的,所以他们构成优惠券聚合关系。同理活动审批单也会构成聚合关系。最终我们形成如下的聚合关系。

    在这里插入图片描述

    3、划分边界上下文

    在上述步骤中,我们获得了整个业务流程中的所有聚合后,我们需要更具业务语义上下文将具体的聚合划分到对应的上下文中,因此我们可以把优惠券的业务分为优惠券、营销活动以及审批三个限界上下文。

    战术设计

    在战略设计阶段,我们通过事件风暴法对整体的业务进行了全部的梳理,同时构建了领域模型以及划分了边界下文。那么接下来我们就要将领域模型映射到工程结构以及代码中实现最终的实现落地。另外在这个阶段实际还有很多细节需要明确,那优惠券来说,它包含哪些属性,需要哪些领域服务,哪些需要设计为实体,哪些需要设计为值对象,这些都是需要在战术设计阶段明确下来。

    1、微服务拆分

    我们根据已经划分的边界上下文,我们可以拆分为优惠券服务、营销活动服务以及审批中心三个微服务,至于用户支付使用这块,还是由原先已存在支付服务来完成,只是在付款核算的时候需要使用到优惠券进行最后的金额计算。

    2、领域分层

    在领域分层方面,我们还是按照之前文章中所说的分层结构来进行,即 interfaces 层、biz 层、domain 层以及 instructure 层。每层代表的含义之前的文章中已经进行了详细的说明,大家可以翻看前面文章中的介绍,这里不再进行赘述了。

    我们以优惠券为例,实际聚合中对象还需要进行进一步的细化。对于优惠券来说它实际上还有如下所示的值对象以及实体来组成实际的优惠券。同时在优惠券我们的梳理的领域服务还包括创建优惠券、查询优惠券以及修改优惠券状态,这些动作实际都应该在领域层通过领域服务的形式完成落地。而对应的 biz 层就相当于业务的编排组合,也就是实际的业务流程的串联。
    在这里插入图片描述

    3、代码结构

    当我们把领域对象进行进一步的细化之后,同时把对应的领域服务敲定之后,我们可以把这些分析后的内容映射成工程分层后的代码了。如下图所示,即为优惠券的 domain 层的代码映射。

    在这里插入图片描述
    当然到这里并不意味着结束,其实在后续还有很多工作要做,比如详细设计、编写代码以及功能测试,特别实在详细设计阶段,我们还要涉及很多的细节问题的敲定,比如数据库表的设计、比如使用什么 MQ,用不用缓存,怎么保证缓存和数据库的数据一致性问题,分布式服务有没有分布式事务的问题,应该怎么解决?有没有服务幂等问题,应该怎么解决?这些都是需要在详细设计阶段进行确定的。因此 DDD 就像是框架,通过它把业务映射成为领域对象以及领域服务和领域事件,再把这些领域相关内容再读映射为实际的代码。使得我们的服务更加的逻辑清晰以及扩展性更强,但是分布式的技术实现细节,我们还是需要有对应的解决方案来进行解决。

    总结

    本文以电商行业的营销活动中的优惠券的发放和使用作为实际案例来阐述 DDD 领域驱动设计落地实践的过程,通过整个过程的梳理,为大家提炼了整个设计过程的精要,相信大家可以按照这样的思路在实际的工作中再结合各自的业务特征应该可以真正完成整个 DDD 的实践。万事开头难,相信只要大家能够亲自去参与或者主导一个 DDD 的落地实践过程,那么对于理解 DDD 这套架构设计方法论又会进入一个新的台阶。在后面的文章中再和大家聊聊落地 DDD 过程中可能会遇到的一些问题以及软件复杂度治理的问题。

    真正的大师永远怀着一颗学徒的心
    ————————————————

    展开全文
  • AS+kotlin+SurfaceView最佳实践之打造子棋游戏1.源码:https://gitee.com/zouchengxin/liu_zi_qi2.效果:...

    1.源码:

    https://gitee.com/zouchengxin/liu_zi_qi

    2.效果:

    http://39.106.207.193:8080/liu_zi_qi.mp4

    3.App下载:

    https://gitee.com/zouchengxin/liu_zi_qi/blob/master/app/release/app-release.apk (放心下载)

    4.实现功能:

    • 双人对战
    • 悔棋
    • 游戏退出
    • 游戏重新开始

    5.未实现功能:

    由于时间有限,技术限制等原因未能实现的功能

    • 人机对战:额,这个实现有点复杂,不想做了
    • 蓝牙对战:这个蓝牙模块也没接触过

    6.游戏说明:

    双方各6个棋子,只能上下左右移动一格,2个相连棋子可以干掉对方一个棋子,3个棋子不行,2个棋子不相连也不行,2个棋子与对方棋子有间隔也不行.不如:白白黑空空可以干掉黑子,白白空黑空,白空白黑空,白白黑空白这些都不行

    7.代码:

    MainActivity

    package com.zcx.liu_zi_qi
    
    import android.content.Intent
    import android.os.Bundle
    import android.os.PersistableBundle
    import android.support.v7.app.AppCompatActivity
    import android.view.View
    import android.widget.Toast
    
    class MainActivity:AppCompatActivity() {
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
        }
    
        /**
         * 人机对战
         */
        fun onRenJi(view:View){
            Toast.makeText(this,"正在进入人机对战", Toast.LENGTH_SHORT).show()
            val intent=Intent()
            intent.setClass(this,GameActivity::class.java)
            intent.putExtra("model",GameModel.RENJI)
            startActivity(intent)
        }
    
        /**
         * 双人PK
         */
        fun onTwo(view:View){
            Toast.makeText(this,"正在进入双人对战", Toast.LENGTH_SHORT).show()
            val intent=Intent()
            intent.setClass(this,GameActivity::class.java)
            intent.putExtra("model",GameModel.TWO)
            startActivity(intent)
        }
    
        /**
         * 蓝牙对战
         */
        fun onLanYa(view:View){
            Toast.makeText(this,"正在进入蓝牙对战", Toast.LENGTH_SHORT).show()
            val intent=Intent()
            intent.setClass(this,GameActivity::class.java)
            intent.putExtra("model",GameModel.LANYA)
            startActivity(intent)
        }
    }
    

    主活动类:3个按钮的显示和点击事件的编写

    GameActivity

    package com.zcx.liu_zi_qi
    import android.annotation.TargetApi
    import android.app.AlertDialog
    import android.content.Context
    import android.content.DialogInterface
    import android.content.Intent
    import android.graphics.Point
    import android.os.Build
    import android.support.v7.app.AppCompatActivity
    import android.os.Bundle
    import android.os.Handler
    import android.os.Message
    import android.util.AttributeSet
    import android.view.LayoutInflater
    import android.view.ViewGroup
    import android.view.WindowManager
    import android.widget.Button
    import android.widget.LinearLayout
    import android.widget.TextView
    import android.widget.Toast
    import java.util.*
    import java.util.concurrent.CopyOnWriteArrayList
    import kotlin.collections.HashMap
    
    class GameActivity : AppCompatActivity(),Handler.Callback {
        val handle=Handler(this)
        var windowWidth=0
        var windowHeight=0
        lateinit var bt_regret:Button
        lateinit var bt_restart:Button
        lateinit var bt_exit:Button
        lateinit var tv_black:TextView
        lateinit var tv_white:TextView
        lateinit var gameView:GameUI
    
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            val display=(getSystemService(Context.WINDOW_SERVICE) as WindowManager).defaultDisplay
            val size=Point()
            display.getSize(size)
            windowWidth=size.x
            windowHeight=size.y
            println("($windowWidth,$windowHeight)")
            init()
        }
    
        /**
         * 初始化
         */
        fun init(){
            gameView= GameUI(this)
            gameView.layoutParams=ViewGroup.LayoutParams(windowWidth*3/5,ViewGroup.LayoutParams.MATCH_PARENT)
    
            val userView=LayoutInflater.from(this).inflate(R.layout.user_ui,null)
            userView.layoutParams=ViewGroup.LayoutParams(windowWidth*2/5,ViewGroup.LayoutParams.MATCH_PARENT)
    
            bt_regret=userView.findViewById<Button>(R.id.bt_regret)
            bt_regret.setOnClickListener {
                synchronized(Map){
                    if(!Map.history.isEmpty()){
                        Map.list.removeAll(Map.list)
                        Map.list=Map.copyList(Map.history.last().first)
                        Map.map=Map.copyMap(Map.history.last().second)
    
                        Map.printList(Map.history.last().first)
                        Map.printMap(Map.history.last().second)
                        Map.history.remove(Map.history.last())
                        Map.printList()
                        Map.printMap()
                    }else{
                        Toast.makeText(this,"官人,不能再悔了", Toast.LENGTH_LONG).show()
                    }
    
                }
            }
            bt_restart=userView.findViewById<Button>(R.id.bt_restart)
            bt_restart.setOnClickListener {
                val builder=AlertDialog.Builder(this)
                builder.setTitle("提示")
                builder.setMessage("是否重新开始")
                builder.setPositiveButton("确定",
                    object :DialogInterface.OnClickListener{
                        override fun onClick(dialog: DialogInterface?, which: Int) {
                            gameView.exit()
                            this@GameActivity.init()
                        }
    
                    })
                builder.setNegativeButton("取消",
                    object :DialogInterface.OnClickListener{
                        override fun onClick(dialog: DialogInterface?, which: Int) {
    
                        }
    
                    })
                builder.create().show()
            }
            bt_exit=userView.findViewById<Button>(R.id.bt_exit)
            bt_exit.setOnClickListener {
                val builder=AlertDialog.Builder(this)
                builder.setTitle("提示")
                builder.setMessage("是否退出游戏")
                builder.setPositiveButton("确定",
                    object :DialogInterface.OnClickListener{
                        override fun onClick(dialog: DialogInterface?, which: Int) {
                            gameView.exit()
                            val intent= Intent()
                            intent.setClass(this@GameActivity,MainActivity::class.java)
                            this@GameActivity.finish()
                        }
    
                    })
                builder.setNegativeButton("取消",
                    object :DialogInterface.OnClickListener{
                        override fun onClick(dialog: DialogInterface?, which: Int) {
    
                        }
    
                    })
                builder.create().show()
            }
            tv_black=userView.findViewById<TextView>(R.id.tv_black)
            tv_white=userView.findViewById<TextView>(R.id.tv_white)
    
    
            val layout=LinearLayout(this)
            layout.layoutParams=ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,ViewGroup.LayoutParams.MATCH_PARENT)
            layout.addView(gameView)
            layout.addView(userView)
            setContentView(layout)
        }
    
        @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
        override fun handleMessage(msg: Message?): Boolean {
            when(msg?.what){
                1 ->{
                    val builder=AlertDialog.Builder(this)
                    builder.setTitle("提示")
                    val str=when(msg.obj){ChessManType.WHITE ->"白子" else -> "黑子"}
                    builder.setMessage("${str}获胜,是否开始下一局")
                    builder.setPositiveButton("开始下一局",
                        object :DialogInterface.OnClickListener{
                            override fun onClick(dialog: DialogInterface?, which: Int) {
                                gameView.exit()
                                this@GameActivity.init()
                            }
    
                        })
                    builder.setNegativeButton("退出",
                        object :DialogInterface.OnClickListener{
                            override fun onClick(dialog: DialogInterface?, which: Int) {
    
                            }
    
                        })
                    builder.create().show()
                }
                2 ->{
                    val map=msg.obj as HashMap<String, String>
                    if(Map.gameModel==GameModel.RENJI){
                        tv_black.setText("黑子(电脑):"+map.get("blackCount"))
                    }else{
                        tv_black.setText("黑子:"+map.get("blackCount"))
                    }
                    tv_white.setText("白子:"+map.get("whiteCount"))
    
                    when(Map.whoChess){
                        ChessManType.WHITE ->{
                            tv_white.setBackgroundResource(R.color.btnSelect)
                            tv_black.setBackgroundResource(R.color.btnNotSelect)
                        }
                        else ->{
                            tv_black.setBackgroundResource(R.color.btnSelect)
                            tv_white.setBackgroundResource(R.color.btnNotSelect)
                        }
                    }
    
                }
            }
            return true
        }
    
        override fun onBackPressed() {
            if(gameView.isExit) {
                super.onBackPressed()
            }else{
                Toast.makeText(this,"再按一次退出",Toast.LENGTH_LONG).show()
                gameView.isExit=true
            }
        }
    }
    

    游戏活动:手机横屏,3/5宽度的SurfaceView(显示棋盘),2/5显示用户界面(黑棋,白棋个数,悔棋,重新开始,退出游戏按钮)

    GameUI

    package com.zcx.liu_zi_qi
    
    import android.annotation.TargetApi
    import android.content.Context
    import android.content.Intent
    import android.graphics.*
    import android.os.Build
    import android.os.Message
    import android.util.Range
    import android.view.MotionEvent
    import android.view.SurfaceHolder
    import android.view.SurfaceView
    import android.widget.Toast
    
    class GameUI constructor(context:Context):SurfaceView(context),SurfaceHolder.Callback{
        private lateinit var thread:Thread//绘图线程
        private lateinit var chessBoard:ChessBoard//棋盘实例
        private var isChessable=true//标记是否可下子
        private var whoWin:ChessManType?=null//哪方获胜,null代表没有胜利者
        var isExit=false//标记是否退出游戏
        private lateinit var background:Bitmap//背景图片
    
        init {
            this.setZOrderOnTop(true)
            //this.setBackgroundResource(R.drawable.background)
            background=BitmapFactory.decodeResource(context.resources,R.drawable.background)
            this.holder.setFormat(PixelFormat.TRANSLUCENT)
            this.holder.addCallback(this)
            Map.list.removeAll(Map.list)
            Map.history.removeAll(Map.history)
            for (i in 0..3){
                val arr= Array<Int>(4,{it -> 0})
                for (j in 0..3){
                    if(i==0||(i==1&&(j==0||j==3))){
                        arr[j]=2
                    }
                    if(i==3||(i==2&&(j==0||j==3))){
                        arr[j]=1
                    }
                }
                Map.map[i]=arr
                Toast.makeText(context,"游戏初始化完成", Toast.LENGTH_SHORT).show()
            }
        }
        override fun surfaceChanged(holder: SurfaceHolder?, format: Int, width: Int, height: Int) {
    
        }
    
        override fun surfaceDestroyed(holder: SurfaceHolder?) {
            thread.join()
        }
    
        override fun surfaceCreated(holder: SurfaceHolder?) {
            thread= Thread(GameThread(holder))
            thread.start()
        }
    
        inner class GameThread(val holder: SurfaceHolder?):Runnable{
            override fun run() {
                while(true){
                    if(isExit){
                        return
                    }
                    var canvas= holder?.lockCanvas()
                    //canvas?.drawColor(Color.WHITE)
                    canvas?.drawBitmap(background, Rect(0,0,background.width,background.height),
                        Rect(0,0,canvas.width,canvas.height),Paint())
                    canvas?.let {
                        chessBoard=ChessBoard(it)
                        chessBoard.update()
                    }
                    holder?.unlockCanvasAndPost(canvas)
                    if(whoWin!=null){
                        val msg=Message.obtain()
                        msg.what=1
                        msg.obj=whoWin
                        (context as GameActivity).handle.sendMessage(msg)
                        return
                    }
                }
    
            }
    
        }
    
        /**
         * 监听触摸事件
         */
        override fun onTouchEvent(event: MotionEvent?): Boolean {
            val x= event?.getX()
            val y=event?.getY()
            //println("(x,y)=($x,$y)")
            if (x != null&&y!=null) {
                selectChessMan(x,y)
            }
            return true
        }
    
        /**
         * 下子
         */
        @TargetApi(Build.VERSION_CODES.LOLLIPOP)
        private fun selectChessMan(x:Float,y:Float){
            val ij=chessBoard.xy2ij(Pair(x,y))
            val i=ij?.first
            val j=ij?.second
            println("(i,j)=($i,$j)")
            synchronized(Map){//同步代码块
                isChessable=when(Map.whoChess){
                    ChessManType.WHITE -> if (Map.map[i!!][j!!]!=2) true else false
                    else -> if (Map.map[i!!][j!!]!=1) true else false
                }
                if(isChessable){
                    Map.list.forEach {
                        if(x in Range(it.cx-100,it.cx+100)
                            && y in Range(it.cy-100,it.cy+100)){
                            Map.list.filter { it.isSelect }.forEach {
                                it.isSelect=false
                            }
                            it.isSelect=true
                        }
                    }
                    moveChessMan(i!!,j!!)
                }
    
            }
    
        }
    
        /**
         * 移动棋子
         */
        private fun moveChessMan(i:Int,j:Int){
            if(Map.map[i][j]!=0){//目标位置有子
                return
            }
            Map.list.filter { it.isSelect }.forEach {
                if(it.move(i,j)){
                    //println(Map.printMap())
                    it.isSelect=false
                    Map.whoChess=when(Map.whoChess){
                        ChessManType.WHITE -> ChessManType.BLACK
                        else -> ChessManType.WHITE
                    }
                    it.check()
                    val msg=Message.obtain()
                    msg.what=2
                    val map=kotlin.collections.HashMap<String,String>()
                    map.put("blackCount",Map.list.filter { it.type==ChessManType.BLACK }.size.toString())
                    map.put("whiteCount",Map.list.filter { it.type==ChessManType.WHITE }.size.toString())
                    msg.obj=map
                    (context as GameActivity).handle.sendMessage(msg)
                    checkWin()
                }
    
    
            }
    
        }
    
        /**
         * 判断输赢
         */
        fun checkWin(){
            if(Map.list.filter { it.type==ChessManType.WHITE }.size==0){
                whoWin=ChessManType.BLACK
            }
            if(Map.list.filter { it.type==ChessManType.BLACK }.size==0){
                whoWin=ChessManType.WHITE
            }
        }
    
        /**
         * 退出游戏
         */
        fun exit(){
            isExit=true
            thread.join()
    
        }
    
    
    
    }
    

    继承SurfaceView,循环绘制棋盘,棋子.监听触摸事件并做出响应

    ChessBoard:

    package com.zcx.liu_zi_qi
    
    import android.graphics.Canvas
    import android.graphics.Color
    import android.graphics.Paint
    import android.graphics.RectF
    
    /**
     *棋盘类
     */
    class ChessBoard(val canvas: Canvas) {
        val width = canvas.height - 200//棋盘宽度
        val height = canvas.height - 200//棋盘高度
        val block = width / 3
        val rect: RectF = RectF(100f, 100f, (width + 100).toFloat(), (height + 100).toFloat())
    
        /**
         *内部棋子类
         * i:横坐标(0,1,2,3)
         * j:纵坐标(0,1,2,3)
         */
        inner class ChessMan(var i:Int=0,var j:Int=0,var type:ChessManType=ChessManType.WHITE):Cloneable{
            var cx=this@ChessBoard.rect.left+j*block//棋子中心x坐标
            var cy=this@ChessBoard.rect.top+i*block//棋子中心y坐标
            var isSelect=false//标记棋子是否被选中
            var callMoveDirection= arrayListOf<ChessManDirection>()//棋子可移动方向
    
            override fun toString():String{
                return "{i:${this.i},j:${this.j},cx:${this.cx},cy:${this.cy},type:${this.type},isSelect:${this.isSelect}}"
            }
    
            fun copy(): ChessMan {
                val temp=ChessMan(i,j)
                temp.cx=cx
                temp.cy=cy
                temp.type=type
                temp.isSelect=isSelect
                return temp
            }
            /**
             * 绘制棋子
             */
            fun draw(r:Float=50f){
                val paint=Paint()
                paint.style=Paint.Style.FILL_AND_STROKE
                paint.strokeWidth=4f
                paint.color=when(type){
                    ChessManType.WHITE -> Color.WHITE
                    else -> Color.BLACK
                }
                canvas.drawCircle(cx,cy,r,paint)
    
                paint.color=Color.BLACK
                paint.style=Paint.Style.STROKE
                canvas.drawCircle(cx,cy,r,paint)
                if(isSelect){
                    paint.color=Color.YELLOW
                    paint.strokeWidth=6f
                    paint.strokeCap=Paint.Cap.SQUARE//设置笔刷图形样式
                    paint.strokeMiter=10f//设置笔画倾斜度
                    canvas.drawRect(
                        RectF((cx-60).toFloat(),(cy-60).toFloat(),(cx+60).toFloat(),(cy+60).toFloat()),
                        paint
                    )
                }
            }
    
            /**
             * 移动棋子
             */
            fun move(i:Int,j:Int):Boolean{
                if((Math.abs(this.i-i)<1&&this.i==i)
                    ||(Math.abs(this.j-j)<1&&this.j==j)){
                    if(Map.history.size>5){//历史记录大于5,清空
                        Map.history.removeAll(Map.history)
                    }
                    Map.history.add(Pair(Map.copyList(),Map.copyMap()))
                    this.cx=this@ChessBoard.rect.left+j*block
                    this.cy=this@ChessBoard.rect.top+i*block
                    Map.map[this.i][this.j]=0
                    this.i=i
                    this.j=j
                    Map.map[i][j]=when(type){
                        ChessManType.BLACK ->2
                        else -> 1
                    }
                    return true
                    //Map.printMap()
                    //Map.printList()
                }
                return false
            }
    
            /**
             * 检查
             */
            fun check() {
                val tp=when(type){ChessManType.WHITE ->1 else ->2}
                val _tp=when(type){ChessManType.WHITE ->2 else ->1}
                when(i){
                    0 ->{
                        if(Map.map[1][j]==tp&&Map.map[2][j]==_tp&&Map.map[3][j]==0){
                            Map.map[2][j]=0
                            Map.list.filter { it.i==2&&it.j==this.j }[0].destroy()
                        }
                    }
                    1 ->{
                        if(Map.map[0][j]==tp&&Map.map[2][j]==_tp&&Map.map[3][j]==0){
                            Map.map[2][j]=0
                            Map.list.filter { it.i==2&&it.j==this.j }[0].destroy()
                        }
                        if(Map.map[0][j]==0&&Map.map[2][j]==tp&&Map.map[3][j]==_tp){
                            Map.map[3][j]=0
                            Map.list.filter { it.i==3&&it.j==this.j }[0].destroy()
                        }
                    }
                    2 ->{
                        if(Map.map[0][j]==0&&Map.map[1][j]==_tp&&Map.map[3][j]==tp){
                            Map.map[1][j]=0
                            Map.list.filter { it.i==1&&it.j==this.j }[0].destroy()
                        }
                        if(Map.map[0][j]==_tp&&Map.map[1][j]==tp&&Map.map[3][j]==0){
                            Map.map[0][j]=0
                            Map.list.filter { it.i==0&&it.j==this.j }[0].destroy()
                        }
                    }
                    3 ->{
                        if(Map.map[0][j]==0&&Map.map[1][j]==_tp&&Map.map[2][j]==tp){
                            Map.map[1][j]=0
                            Map.list.filter { it.i==1&&it.j==this.j }[0].destroy()
                        }
                    }
                }
                when(j){
                    0 ->{
                        if(Map.map[i][1]==tp&&Map.map[i][2]==_tp&&Map.map[i][3]==0){
                            Map.map[i][2]=0
                            Map.list.filter { it.j==2&&it.i==this.i }[0].destroy()
                        }
                    }
                    1 ->{
                        if(Map.map[i][0]==tp&&Map.map[i][2]==_tp&&Map.map[i][3]==0){
                            Map.map[i][2]=0
                            Map.list.filter { it.j==2&&it.i==this.i }[0].destroy()
                        }
                        if(Map.map[i][0]==0&&Map.map[i][2]==tp&&Map.map[i][3]==_tp){
                            Map.map[i][3]=0
                            Map.list.filter { it.j==3&&it.i==this.i }[0].destroy()
                        }
                    }
                    2 ->{
                        if(Map.map[i][0]==0&&Map.map[i][1]==_tp&&Map.map[i][3]==tp){
                            Map.map[i][1]=0
                            Map.list.filter { it.j==1&&it.i==this.i }[0].destroy()
                        }
                        if(Map.map[i][0]==_tp&&Map.map[i][1]==tp&&Map.map[i][3]==0){
                            Map.map[i][0]=0
                            Map.list.filter { it.j==0&&it.i==this.i }[0].destroy()
                        }
                    }
                    3 ->{
                        if(Map.map[i][0]==0&&Map.map[i][1]==_tp&&Map.map[i][2]==tp){
                            Map.map[i][1]=0
                            Map.list.filter { it.j==1&&it.i==this.i }[0].destroy()
                        }
                    }
                }
    
            }
    
            /**
             * 销毁
             */
            fun destroy(){
                Map.list.remove(this)
    
            }
        }
    
        /**
         *绘制棋盘
         */
        fun drawChessBoard(){
            val paint=Paint()
            paint.color=Color.BLUE
            paint.style=Paint.Style.STROKE
            paint.strokeWidth=8f
            for (i in 0..2){
                canvas.drawRect(
                    RectF(rect.left,rect.top+i*block.toFloat(),rect.right,rect.top+(i+1)*block.toFloat()),
                    paint
                )
                canvas.drawRect(
                    RectF(rect.left+i*block.toFloat(),rect.top,rect.left+(i+1)*block.toFloat(),rect.bottom),
                    paint
                )
            }
        }
    
        /**
         * 更新棋盘
         */
         fun update(){
            this.drawChessBoard()
            synchronized(Map){
                if(Map.list.isEmpty()){
                    Map.list.removeAll(Map.list)
                    for (i in 0..3){
                        for (j in 0..3){
                            if(Map.map[i][j]==1){
                                Map.list.add(ChessMan(i,j,ChessManType.WHITE))
                            }
                            if(Map.map[i][j]==2){
                                Map.list.add(ChessMan(i,j,ChessManType.BLACK))
                            }
                        }
                    }
                }
    
    
                Map.list.forEach {
                    //println(it.toString())
                    it.draw()
                }
            }
    
        }
    
        /**
         * 将x,y转换成i,j
         */
        fun xy2ij(pair: Pair<Float,Float>): Pair<Int, Int>? {
            val x=pair.first
            val y=pair.second
            if(x>rect.right+block/2){
                return null
            }
            val j=((x-rect.left+block/2)/block).toInt()
            val i=((y-rect.top+block/2)/block).toInt()
            return Pair(i,j)
        }
    }
    

    棋盘类:包含一个棋子内部类,棋盘类实现了绘制棋盘,更新棋盘等功能,棋子类实现了绘制棋子,移动棋子等功能

    Map:

    package com.zcx.liu_zi_qi
    
    object Map {
        var map= Array<Array<Int>>(4,{it -> Array<Int>(4,{it -> 0})})//4X4数组.0:空,1:白子,2:黑子
        var list = arrayListOf<ChessBoard.ChessMan>()//list集合存储棋子数据
        val gameModel=GameModel.RENJI//游戏模式
        var whoChess=ChessManType.WHITE//轮到哪方下子
        var history= arrayListOf<Pair<ArrayList<ChessBoard.ChessMan>,Array<Array<Int>>>>()//记录历史信息
    
        fun copyMap(m: Array<Array<Int>> = map):Array<Array<Int>>{
            val temp=Array<Array<Int>>(4,{it -> Array<Int>(4,{it -> 0})})
            for (i in 0..3){
                for (j in 0..3) {
                    temp[i][j]=m[i][j]
                }
            }
            return temp
        }
    
        fun copyList(l: ArrayList<ChessBoard.ChessMan> = list):ArrayList<ChessBoard.ChessMan>{
            val temp=ArrayList<ChessBoard.ChessMan>()
            l.forEach {
                temp.add(it.copy())
            }
            return temp
        }
        /**
         * 打印Map信息
         */
        fun printMap(m: Array<Array<Int>> = map){
            print("[")
            for (i in 0..3){
                print("[")
                for (j in 0..3) {
                    if (j == 3) {
                        print("${m[i][j]}")
                    } else {
                        print("${m[i][j]},")
                    }
                }
                print("]")
    
            }
            println("]")
        }
    
        /**
         * 打印List信息
         */
        fun printList(l: ArrayList<ChessBoard.ChessMan> = list){
            print("[")
            l.forEach {
                print(it.toString())
            }
            println("]")
        }
    }
    

    一个object类(相当于单例,只有一个实例):1.map属性:4X4数组,记录棋盘信息(0:空,1:白子,2:黑子),2.属性list:一个list集合,存储所有棋子信息(坐标信息,棋子类型,是否被选中)

    ChessManType:

    package com.zcx.liu_zi_qi
    
    /**
     * 棋子类型
     */
    enum class ChessManType {
        WHITE,BLACK
    }
    

    棋子类型:一个枚举类,WHITE:表示白子,BLACK:表示黑子

    GameModel:

    package com.zcx.liu_zi_qi
    
    /**
     * 对战模式
     */
    enum class GameModel {
        RENJI,TWO,LANYA
    }
    

    游戏模式:一个枚举类,RENJI:人机模式,TWO:双人对战,LANYA:蓝牙对战

    8.注意:

    所有的ui更改(比如Toast)必须在主线程中进行,可以通过发送Message给主线程处理.
    特别注意类的深拷贝和浅拷贝问题(Map类里的map和list有涉及)

    展开全文
  • 看板的实践学习总结

    千次阅读 2014-06-11 13:54:20
    这次活动主要是学习看板的实践,看板的实践介绍如下。   可视化:可视化价值项和价值流(story和它的流动),将问题和 瓶颈也在看板上可视化,可激发团队协作。 限制在制品:通过限制各阶段的在实现的...
  • 小学生“树叶探秘”主题活动方案

    千次阅读 2020-12-24 19:13:28
    以紧密围绕“树叶探秘”为主题的综合实践活动应运而生,通过观察、调查、表演、手工制作、成果展示等活动形式,让同学们认识树叶、创作树叶、赞美树叶……从而增强同学们的环保意识,有效地发展同学们的多元智能。...
  • 还记得以前编上大学那会苦于课后习题没有答案...到了考试....就像下面这个图一样~ 现在,那些同样在纠结于书本后的答案太遥远的同学们,要告诉你们一个好消息,个人历时两周作业的时间开发的程序【大学课后...
  • 全国性竞赛活动名单 序号 竞赛名称 主办单位 竞赛面向学段 自然科学素养类 1 第五届全国青少年人工智能创新挑战赛 中国少年...
  • 作者:WeTest编 商业转载请联系腾讯WeTest获得授权,非商业转载请注明出处。 原文链接:https://wetest.qq.com/lab/view/457.html 2019年5月5日,腾讯WeTest作为测试敏捷化标准协会成员之一,主办的测试中台...
  • 设置时间戳表的最后装载日期 五、结 本篇重点是针对销售订单示例创建并测试数据装载的Kettle作业和转换。在此之前,先简要介绍数据清洗的概念,并说明如何使用Kettle完成常见的数据清洗工作。由于本示例中Kettle...
  • 幼儿园语言教学中的提问,是教学过程中教师和幼儿之间相互交流常用的一种教学手段。...经验的教师在教学过程中,总是精心设计提问,竭力点燃幼儿思维的火花,激发他们的求知欲望,并意识地为幼儿发现...
  • 3.在开发者社区搜索“在家实践活动,点击第三个“阿里云高校“在家实践”计划,免费提供2.68亿小时算力!” 4.点击“在家实践活动链接 5.注册阿里云账号——>实名认证——>学生认证——>完成测试...
  • 云原生落地实践的25个步骤

    千次阅读 2020-06-01 08:13:30
    其实我们在很多的技术大会上,看到的都是分层架构图,就像上一节我们分的个层次一样,这容易给希望落地云原生的企业造成误解,因为大部分公司的云原生体系的建设都不是按层次来建设的,不会IaaS完全建设完毕,再...
  • DevOps 实践指南

    千次阅读 2018-11-06 11:54:33
    在此背景下,本书旨在提供从启动 DevOps 转型到实现目标所需的理论、原则和实践,帮助企业提高生产力、盈利能力并且赢得市场。本书不仅适用于从事或影响技术价值流中工作的所有人,通常包括产品管理、开发、QA、IT ...
  • GitChat:您在学习和实践领域驱动设计的过程中是否有哪些(有趣的)故事可以和读者们分享? 张逸:我在 ThoughtWorks 的时候,公司邀请《实现领域驱动设计》作者 Vaughn Vernon 到北京 Office 给我们做了一次 DDD ...
  • 1D卷积网络HAR(人体活动识别)实践

    千次阅读 多人点赞 2018-10-17 10:56:27
    HAR(人体活动识别)是根据加速度计序列数据,将活动分类为已知的预定义的活动类别,其数据是由专业设备或智能手机记录的。 解决这个问题的传统方法需要手工制作特征,这些特征来自于基于固定大小的窗口和训练机器...
  • 远程软件工程师的10个最佳实践

    千次阅读 2021-05-17 00:11:06
    最佳实践:承担人际沟通的责任 在刚刚开始远程工作的时候,沟通负担的沉重在团队中是很常见的,更不可能既定的协议和最佳实践。很多人都是在偏离正轨的时候才艰难地认识到这一点。如果我们与团队乃至社区脱节...
  • 社会实践成果报告 成果名称:单独二孩政策对中城镇居民生育意愿影响研究调查——以江西省萍乡市为例 成果类别:社科法学类 主 持 人:谢祎玉 团队成员:刘俊 黄钰 刘露萍 谭志威 指导老师:刘朝阳 1 单独二...
  • 代码审查的必要性和最佳实践

    千次阅读 2021-05-20 15:17:56
    代码审查不利于团建,因为经常程序员因为观点不同在代码审查的时候吵起来。 代码审查的好处 代码审查是个人和团队提升的最佳途径之一。 识别出设计的缺陷,找到安全、性能、依赖和兼容性等测试不易发现的问题。...
  • 阿里云运维架构实践秘籍

    万次阅读 2021-12-07 10:31:47
    中国互联网发展编年史、 运维、 ...、缓存、 Session管理种策略、分库分表、云迁移步骤、监控方案、运维的发展阶段、传统运维痛点、云服务供应商排行、黑客常见入侵步骤、架构阶段、云端运维安全、黑客常见系统层攻击
  • 面渣逆袭:Java并发十问,快来看看你会多少道

    万次阅读 多人点赞 2022-01-13 11:08:07
    四万字、五十图,图文详解十道Java并发面试题!——Java并发面试,看这一篇就够了!
  • 、神经网络和深度学习 七、问题和答案 八、高级实践 九、无监督学习 十、其它学习形式 十一、总结 流程 一、认领 首先查看 整体进度 以及 ISSUE,确认没有人认领了你想认领的章节。 然后发布 ...
  • 学生德育实践(自选项目)结题表

    千次阅读 2020-01-11 11:50:06
    学生德育实践(自选项目)结题表 项目名称: 辛勤劳动,体验生活 立题时间: 2018年9月1日—2019年1月1日 项目负责人: 分 院: 专业班级: 指导老师: 联系方式: 项目名称 辛勤劳动,体验生活 负责人 ...
  • 关于社区人口老龄化的实践报告 嵌入式1511戚春阳 一 社会实践情况 人口老龄化已经成为世界各国广泛关注的社会性问题之一,经查阅资料显示,截止2013年底,我国60周...
  • GA 电商数据分析实践

    千次阅读 2018-04-12 10:04:41
    课程介绍 一个电商的流量会某天突然大涨 30%,或者大跌 30%; 季节性(比如11.11)订单量会出现...所以你需要通过学习一套系统性的数据分析课程——GA 电商数据分析实践课。 本课程的理论部分旨在从策略、数据收集...
  • 本书的作者傅哥,投入50天时间,从互联网实际业务开发中抽离出,交易、营销、秒杀、中间件、源码等22个真实场景,来学习设计模式实践使用的应用可上手技能。 1. 谁发明了设计模式? 设计模式的概念最早是由 克里斯...
  • 有关树叶活动方案5篇

    千次阅读 2020-12-24 19:13:43
    有关树叶活动方案5篇有关树叶活动方案1一、设计思路:时值深秋,各种树叶都纷纷落下,为了扩展幼儿的视野,增进师生、同伴间的交流,丰富孩子们的社会经验,让幼儿与大自然亲密接触,感受秋天大自然的美好风光,我们...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,387
精华内容 14,954
热门标签
关键字:

六小实践活动有哪些