精华内容
下载资源
问答
  • 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有涉及)

    展开全文
  • 编在此整理了大学生暑假三下乡社会实践活动总结范文,供大家参阅,希望大家在阅读过程中有所收获!大学生暑假三下乡社会实践活动总结范文篇1 今年我们三下乡的活动主题是:“盛世华诞传神州科学发展焕新风情拥青春...
  • 看板的实践学习总结

    千次阅读 2014-06-11 13:54:20
    这次活动主要是学习看板的实践,看板的实践介绍如下。   可视化:可视化价值项和价值流(story和它的流动),将问题和 瓶颈也在看板上可视化,可激发团队协作。 限制在制品:通过限制各阶段的在实现的...
    这次活动主要是学习看板的实践,看板的六大实践介绍如下。
    
         
    1. 可视化:可视化价值项和价值流(story和它的流动),将问题和 瓶颈也在看板上可视化,可激发团队协作。
    2. 限制在制品:通过限制各阶段的在实现的story,来加速流动,避免造成“交通”阻塞。考虑到我们小团队运作,暂 时没有启用,若后续发现出现阻塞,要考虑优化。
    3. 管理工作流:工作流中的协作问题,技术问题,集成问题,质量等等问题充分暴露,持续改善和优化我们工作。
    4. 显式化流程规则:从需求—>实现—>测试—>验 收的流转约束条件,我们已经定出来适合团队的,在流程培训中已经和大家介绍了。
    5. 建立反馈循环
    6. 协作、演进、改进


    1. 看 板里面建立了输入输出节奏:“产品需求输 入”和“产 品输出(项目交付)”形成一定规律性的节奏,越频繁的输入和输出,增加了选择工作的灵 活性以及交付产品的能力。
    2. 选择权:在需求阶段,我们对需求库的内容是有选择权的,可选做做哪些,怎么做,丢弃哪些。
    3. 承诺:而真正输入研发后,意味着承诺,产品人员告诉大家这些需求就说他们需要的做的,而开发说我们开始做了,预计在 xxx时间可以交付(依据项目平均leadtime来评估)
    4. 了解了“系统周期时间(Leadtime)”和“用户周期时间”。
    5. 关于丢弃率:减少承诺后的丢弃,而在需求选择阶段的 丢弃率不能一概而论,多或少,取决于团队以及产品形态。
    展开全文
  • 摘要:第十章是讲大学生社会实践活动的,主要内容为社会实践活动的目的,方式,内容,组织原则等方面的内容,感觉东西不多,考点不多。比较合适大学辅导员认真学生的实践,同时,作为科任老师来说,也一定的教学...

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

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

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

    一、社会实践活动的概念

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    千次阅读 2005-06-29 22:51:00
    我们和管道公司领导开了一个座谈会,来了记者和领导,大家说了一些客套的、高度的话,观看了西气东输宣传片,互相赠送了礼物,打着北大的旗子拍了合影。具体内容都不太记得了,只记得在看宣传片时,里面一段时...

    新一代的铁人精神

    在偶然的机会和偶然的条件下,参加了“中石油——西气东输暑期实践团”。第一次活动是去西气东输管道公司北京总部。我们和管道公司领导开了一个座谈会,来了记者和领导,大家说了一些客套的、有高度的话,观看了西气东输宣传片,互相赠送了小礼物,打着北大的旗子拍了合影。具体内容都不太记得了,只记得在看宣传片时,里面有一段时大庆铁人王进喜跳入池子中搅拌泥浆的黑白画面。我当时在想,现在都已经什么年代了,还给我们放这种旧黄历的、疯狂的、被大肆宣扬的、大跃进的革命片断?在二十一世纪中石油还在宣传“铁人精神”理念,未免太不合时宜了吧!

    在我的思想里是将“石油”和money划等号的。美国布什提出的“单边主义”政策很大程度上体现在中东政策上,例如美国与沙特、以色列的外交关系,美国借反恐挑起阿富汗和伊拉克战争,这些所有的目的只为了一个——石油。在我国,中石油、中石化、中海油是大型国有垄断企业,也是世界500强企业。因此,不论从那个层面上说,石油人十分有钱,石油单位十分有钱,石油行业十分有钱。这次实践活动能为我解答不少的疑惑。

    在七天的实践活动中,跟着邱老师从第八标段到第二标段这么一线走来,和一线工人座谈,到工地参观,看到业主、监理和各个承包商的施工管理,施工单位在辛苦和恶劣的环境连续作战,我才知道石油工作是多么让人难以想象,而我的概念和理解是多么的简单和幼稚。我也逐渐体会到石油人艰苦奋斗,将铁人精神为本的原因所在。

    我们参观的第一站是“大港油建”。天津人很热情很诚恳。在座谈会上,我提了关于项目招标方面的问题,合同怎么签的,合同价格多少,工期多长时间,质保多少时间。他们说这个项目从1月初开工,7月底完工,合同是4600万元。我当时就顺口说:“哇!几千万你们半年就轻松赚到了呀!”大家都笑了,笑我口无遮拦,笑我不了解实情,或许笑我大把年纪了却还说这样幼稚的话。下午3点多去工地参观,邱老师怕把我们晒坏了,专门买了帽子给我们。作业带在泰山脚下丘陵地形。在作业带,有很多吊管机、焊机和管子等。他们的施工工序是:管子先下沟再焊接。天气很热,根据工作规范要求,工人们必须浑身上下穿戴严实,他们一手拿面罩,一手拿焊具,脚踩着梯子,在沟中焊接作业,阵阵微风对他们来说丝毫不能带来凉意。在这个巨型流水线上,每个工人焊一道,然后就向下一个接缝移动,火星四溅,机器隆隆,工人都在紧张的工作,工地一派繁忙的景象。我感到有点惭愧了。过去对石油行业的想法看来很多方面都错了。

    在“大庆管道”,杨光峰经理说:“我们的工作在常人眼里是不可理喻的”。根据我们了解,这些石油管道建设者由于赶工期进度长年不能回家。大港油建的书记说,五一劳动节他们是以劳动来庆祝这个自己的节日的。说白了就是没有休息过。新疆油建的年轻小伙因为工作耽误了不能结婚,甚至连对象也没有时间和机会找。“辽河二建”的孙书记说,有家有孩子的职工因为长期在外,回家后孩子不认,把爸爸往门外赶,或者没有时间照顾孩子,孩子的学习成绩不好。“大庆管道”的杨经理,一个朴实无华的石油人,具我们所知,他的父亲患肝癌晚期时,他白天在工地,晚上在医院,在项目要结束的时候,他的父亲永远的离开了他。而他为了工作,在出殡当天又来到了工地,他强忍悲痛、奋力拼搏在工作第一线,在施工现场一守就是三天三夜。任务圆满完成了。但是内心的遗憾缺永远也无法弥补。在座谈会上,他重复着这样的话:“亲情是我这辈子无法弥补的。”虽然他没有多说自己,可是在内心深处,面对亲情他是无论如何也笑不起来的。

    在“新疆油建”,我们见到的是一些我们的同龄人。接待我们的小伙很年轻,瘦瘦高高,戴着眼镜,笑起来蛮腼腆,我简直不能相信他是他们的总工。虽然他们很年轻,干活却很利索的。“这些活要是在家里做,保证两个月就完工,可是在这里,事情变得很复杂。来了大半年了,大家都盼着赶紧干完回家。”谈起了美丽的新疆,他们的家,小伙子的眼中含思念和期待。“我们新疆可是好地方啊,什么北京上海都比不上!欢迎你们去做客!”新疆人的豪爽、热情和自信深深感动了我。我提出了我的疑问,年轻小伙子在处理征地时地方关系时好办吗?他们单位里年龄最大的老罗负责地协工作,故事可多了。老罗实际年龄一点也不大,也就三十出头。可是为了工作,他脸晒黑了,头发掉了很多,憔悴了很多,肚子吹圆了。老罗的故事真多,配着小酒他讲故事十分绘声绘色。在地协过程中,他碰到了蛮不讲理的农村妇女,把他抓打伤了,却反说他打人抓人,他把这个妇女送到医院,人却一声不吭逃跑了。老罗说,这样的事情不是一件两件。为了做好工作,他一趟趟做工作、讲道理,一次次请人吃饭喝酒,和当地政府干部谈征地补偿条件。老罗笑着说,工作做完一次我的头发要掉十根,你们看我的头发都快掉光了。或许吃饭喝酒叫做腐败,可是在地协工作中不吃饭不喝酒工作是不能完成的任务,地要征,机器要开工,地协是后续工作顺利开展的第一步。碰到这样的事情谁不郁闷,谁的压力不大呢?可是既然做了这个工作就要做好。如果把地协工作做好了,我看去搞国际关系也不在话下。老罗真是好样的。面对现状和困难,他没有退缩和逃避,他是能干的新疆油建人。我的心里充满了敬意。

    石油管道建设者是值得我们学习和尊敬的。我身边的人、身边的事还有很多很多,都可以用“不可理喻”来形容。艰苦的工作环境,没有周六周末的休息,远离家人孩子的亲情,身心承受的巨大的压力。但是他们能出色的按工期甚至是提前工期完成业主的任务。是什么样的信念支撑着他们?

    我不会说:啊,多么伟大的建设丰碑,多么具有历史意义的国家工程,他们的无私奉献精神是多么伟大和崇高!我不想把他们的信念与具有高度的党、国家和民族责任联系起来。如果说他们的源动力具有如此的政治高度,未免太虚伪太空洞了。

    他们确实是新时代的铁人,石油管道上的铁人。新时代的铁人精神不是“没条件也要上”式的蛮干,不是不讲回报的一味奉献,不是在党领导下的先进性教育的结果,更不是三个代表理论的伟大实践。我认为支持他们工作的是:在以人为本的管理理念下遵照HSE管理体系,提出的新的工作模式和工作方法,在打造我国第一条数字管道、人文管道、和谐管道的基础上,为将来天然气管道工业的蓬勃发展赢得资本,为能在未来管道建设市场中占有一席之地进行激烈的竞争。对于各个施工单位来说,这才是最具有战略意义的。支撑石油人努力工作的,我认为有以下几点:

    首先,如此辛苦的工作必须要有丰富的经济保障。石油人的钱挣的太辛苦了,根本不是轻松做出来的,这种工作性质必须有比较高的经济收入作为保障。比如他们为了穿越河流,必须连续工作数十个小时,为了协调关系,承受了巨大的精神压力。过年过节不能休息,还要加班加点的干活。这些最直接的回报就是经济上的回报。在调动工作积极性上,经济杠杆是十分有效的。

    其次,要有充分的后勤保障。工人的工作环境和身心健康是十分重要的。例如住宿条件是带空调卫生间的标准间,吃饭上要吃家乡米面,吃自带厨师做的家乡饭。在夏天重点做好防暑降温工作,推广简单的医疗保健知识,定期为职工做身体检查。防止工地的空气污染、噪声污染和废弃物污染,为职工提供良好的工作环境。一定要保障职工的身体健康。

    再次,要主动关心职工的生活和思想,确实解决他们遇到的困难。六一给职工配偶单位邮寄钱,为孩子代买玩具庆祝节日。亲属来探亲的免费食宿招待。年轻人多组织点业余活动,丰富生活。

    另外,更要重视新技术在工作中的应用。科技的发展使得人从过去繁重的劳动中解放出来。例如应用自动焊接,爆破技术,遥感技术等。过去的蛮干越来越不被人多提倡了。采用计算机编制管理信息系统,与当前的业务进行紧密结合,能够大大提高工作效率。相应的工作环境、工作方法都能得到有效的提高。

    我认为,这才是HSE追求的目标。这才是理性的新一代铁人精神。用朴素的话说就是:“巧干活,少受罪,多挣钱,安全回家”。

                                                                                                                                       李梅

    另外,我还想说:从对西气东输还一知半解,到能说出“下管回填”“ 防腐补口”等专业词汇。我们经历了很多。大家互相鼓励,互相学习,开展广泛批评与自我批评,这种团结一致、努力工作的精神是我在过去的几年里少有体验的。
    很开心的是,从这次活动中中我学到了很多。不仅是专业方面的知识,更多的是社会的经验、为人处世的方法、说话的技巧等等。谢谢大家!

    展开全文
  • 社会实践活动报告—06暑假饭店打工

    千次阅读 2006-09-17 22:35:00
    我要看看我能否在恶劣的环境中能力依靠自己的又手和大脑维持自己的生存,同时,也想通过亲身体验社会实践让自己更进一步了解社会,在实践中增长见识,锻炼自己的才干,培养自己的韧性,更为重要的是检验一下自己所...
  • 作者:WeTest编 商业转载请联系腾讯WeTest获得授权,非商业转载请注明出处。 原文链接:https://wetest.qq.com/lab/view/457.html 2019年5月5日,腾讯WeTest作为测试敏捷化标准协会成员之一,主办的测试中台...
  • 摘要:本文结合西格玛管理理论研究和实践探索,从“DMAIC”到“DMADV”阐述了西格玛已经从单纯的西格玛改进(IFSS)发展为西格玛设计(DFSS),实现了质量经济性管理的新实践,论述了西格玛管理的发展途径...
  • 琼教基〔2004〕63号 海南省教育厅关于普通高中综合实践活动课程实施的指导意见 各市、县、自治县教育(教科)局,省农垦总局教育局,海南钢铁公司教育处,洋浦经济开发区社会发展局,厅直属中学: 为了有效实施...
  • 3.在开发者社区搜索“在家实践活动,点击第三个“阿里云高校“在家实践”计划,免费提供2.68亿小时算力!” 4.点击“在家实践活动链接 5.注册阿里云账号——>实名认证——>学生认证——>完成测试...
  • 1D卷积网络HAR(人体活动识别)实践

    千次阅读 2018-10-17 10:56:27
    HAR(人体活动识别)是根据加速度计序列数据,将活动分类为已知的预定义的活动类别,其数据是由专业设备或智能手机记录的。 解决这个问题的传统方法需要手工制作特征,这些特征来自于基于固定大小的窗口和训练机器...
  • 设置时间戳表的最后装载日期 五、结 本篇重点是针对销售订单示例创建并测试数据装载的Kettle作业和转换。在此之前,先简要介绍数据清洗的概念,并说明如何使用Kettle完成常见的数据清洗工作。由于本示例中Kettle...
  • DevOps 实践指南

    千次阅读 2018-11-06 11:54:33
    在此背景下,本书旨在提供从启动 DevOps 转型到实现目标所需的理论、原则和实践,帮助企业提高生产力、盈利能力并且赢得市场。本书不仅适用于从事或影响技术价值流中工作的所有人,通常包括产品管理、开发、QA、IT ...
  • 还记得以前编上大学那会苦于课后习题没有答案...到了考试....就像下面这个图一样~ 现在,那些同样在纠结于书本后的答案太遥远的同学们,要告诉你们一个好消息,个人历时两周作业的时间开发的程序【大学课后...
  • 、神经网络和深度学习 七、问题和答案 八、高级实践 九、无监督学习 十、其它学习形式 十一、总结 流程 一、认领 首先查看 整体进度 以及 ISSUE,确认没有人认领了你想认领的章节。 然后发布 ...
  •  要保护企业的信息系统安全,首先要知道企业中有哪些可识别的资产,哪些是最关键的、需要重点防护的,哪些是次要一些的但是也需要保护的,哪些是不需要专门关注的。从防御的角度来说,对于外来的威胁有时很难准确...
  • 创业基础(第章:创业资源及其管理) 6.1: (单选) 以下资源中,最重要、最核心的资源是(D) A. 物质资源 B. 技术资源 C. 财务资源 D. 人力资源 (单选) 资源就是任何主体在向社会提供产品或...
  • GA 电商数据分析实践

    千次阅读 2018-04-12 10:04:41
    课程介绍 一个电商的流量会某天突然大涨 30%,或者大跌 30%; 季节性(比如11.11)订单量会出现...所以你需要通过学习一套系统性的数据分析课程——GA 电商数据分析实践课。 本课程的理论部分旨在从策略、数据收集...
  • 实践论》全文

    千次阅读 2018-02-27 19:08:00
    首先,马克思主义者认为人类的生产活动是最基本的实践活动,是决定其他一切活动的东西。人的认识,主要地依赖于物质的生产活动,逐渐地了解自然的现象、自然的性质、自然的规律性、人和自然的关系...
  • KVM虚拟化技术实践

    万次阅读 2017-02-01 16:01:01
    、通过JAVA编程控制KVM 在上一个章节中我们知道了一个kvm虚拟机我们可以使用xml文件来控制,那么我们自然也可以用java程序来写xml文件,从而生成虚拟机。如果你使用过阿里云或者腾讯云等云服务器的话你就知道,...
  • 管理实践总结

    万次阅读 2010-06-10 15:43:00
    研讨实践... 62.1 场景概览... 62.2 估计困难——怎么办?... 62.2.1 估计人员经验不足或对系统要完成的内容、要求理解不充分;... 62.2.2 新技术或系统复杂导致估计困难;... 72.2.3 估计人员乐观,导致估计...
  • 腾讯云DevOps流水线的应用与实践

    千次阅读 2017-09-14 11:45:39
    编者按:2017年8月23日,腾讯“云+未来峰会”在北京召开,此次大会特别设立了腾讯云开发者分论坛,在此论坛上,腾讯织云负责人梁定安做了《腾讯DevOps流水线的应用实践》的演讲,本文根据此演讲实录整理而成。...
  • Redis 高可用架构最佳实践

    千次阅读 2017-08-13 21:33:16
    有哪些最佳实践? 二、Sentinel 原理 在讲解 Redis 高可用方案之前,我们先来看看 Redis Sentinel 原理(https://redis.io/topics/sentinel)是怎么样的。 Sentinel 集群通过给定的配置文件...
  • “方法、设计、实现、管理之三十计”读后感 ----《软件工程实践导论》一书的思想方法简析 中国句老话叫“开卷有益”。如今的计算机书籍可谓汗牛充栋,但每个人的时间、精力都有限,要真正做到“开卷有益”,...
  • 活动开始之前,我们采访到了曾老师,一窥他的技术和人生。 编者按:淘宝技术部总监、淘宝技术委员会Java分会会长曾宪杰将携他的新书《大型网站系统与Java中间件实践》做客我们社区问答栏目,担任第四期的问答...
  • 远程软件工程师的10个最佳实践

    千次阅读 2021-05-17 00:11:06
    最佳实践:承担人际沟通的责任 在刚刚开始远程工作的时候,沟通负担的沉重在团队中是很常见的,更不可能既定的协议和最佳实践。很多人都是在偏离正轨的时候才艰难地认识到这一点。如果我们与团队乃至社区脱节...
  • 关于社区人口老龄化的实践报告 嵌入式1511戚春阳 一 社会实践情况 人口老龄化已经成为世界各国广泛关注的社会性问题之一,经查阅资料显示,截止2013年底,我国60周...
  • 一、HAWQ参数配置最佳实践(原文地址:http://hawq.incubator.apache.org/docs/userguide/2.1.0.0-incubating/bestpractices/config_hawq_bestpractices.html) 在$GPHOME/etc/hawq-site.xml文件中维护HAWQ的配置...
  • 本次活动有幸请到了三星和天融信的两位资深总监,从务实角度分享项目与研发管理的理解和最佳实践,共同探讨项目与研发管理的实践。 <br />随着我国加入WTO和知识经济时代的到来,我国的项目与研发管理将...
  • 日请求过亿的Web系统PHP7升级实践

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,202
精华内容 13,280
关键字:

六小实践活动有哪些