baidu_19552787
baidu_19552787

学习记录

  1. http协议依赖可靠传输，在互联网环境中首选使用是TCP传输协议
  2. http协议是基于request/response范式的，服务端不主动向客户端发数据
  3. http 1.0不支持持久连接，每次request/response都要建立一次TCP连接
  4. http 1.1要求支持持久连接，连接可以复用完成多次request/response,但还不能离开request/response范式，还得依靠轮询。
  5. http 1.1开始支持协议切换

websocket出现了。
原理就是利用http协议进行协议切换，将TCP连接（大家说它socket）从http协议中解放出来，进行更有效的应用数据通讯。

http 与 webSocket 和 socket.io
http ： client > server 靠客户端发起请求，然后服务端收到请求在进行回应。
webSocket ： server <> client 双向。基于TCP的一种新的网络协议。
socket.io ： 封装了WebSocket以及其他的一些协议，并且实现了WebSocket的服务端代码。

https://www.jianshu.com/p/00e4decb7ac2
https://www.cnblogs.com/ostrich-sunshine/p/7474471.html

cocoscreator 使用的标准网络接口
XMLHttpRequest : 用于短连接
WebSocket: 用于长连接

cocoscreator 未提供SocketIO

通过域名查找ip地址就是dns解析
网络7层协议，每一层都有每一层的协议
http协议要基于传输层的tcp/ip协议来实现
物理层： 物理设备
数据链路层： 软件+物理设备（硬件）创建的电路连接（基础的数据传输）
网络层： 数据在节点（网络设备）之间创建逻辑链路

传输层：向高层屏蔽了下层的通讯数据的细节，两个协议 TCP/IP、UDP
会话层：session Layer，负责两个实体 之间的会话 连接确保点到点之间的传输不被中断。
表示层：加密解密编码格式转换
应用层：http协议，构建在TCP协议之上，为应用软件提供了各种服务，屏蔽了网络传输的相关细节-具体网络传输细节也不需要知道。

NodeJS中

  1. __dirname2 ： Node.js 中，__dirname 总是指向被执行 js 文件的绝对路径，所以当你在 /d1/d2/myscript.js 文件中写了 __dirname， 它的值就是 /d1/d2 。
  2. ./ 会返回你执行 node 命令的路径，例如你的工作路径。
  3. 有一个特殊情况是在 require() 中使用 ./ 时，这时的路径就会是含有 require() 的脚本文件的相对路径。

svn使用：
新建一个svn地址：

  1. 在目标工程中 , .svn 目录下，鼠标右键，选择Repo-browser。（和目标工程无关，其实就是为了打开 svn 浏览器）
  2. 在弹出框内 单击选择相应文件夹， 新建 add file ， 会在URl栏出现svn地址
  3. 在本地相对合适的位置 check out 出来，进而在文件内进行添加删除文件。（.svn 同目录下）

在主工程中添加具体游戏软链接：
在主工程引用的位置 添加，Tortoise SVN --> peoperties --> 添加工程的软链接（svn:externals）
在1处（即svn浏览器中），会显示出 对应位置的软链接，标识大概为蓝色↗箭头显示。

添加具体软链接 相当于 引用刚才创建的svn地址的东西

简单介绍工作流：
cocoscreator的底层是cocos2d-x

  1. 外部导入资源。资源管理器创建资源（场景、预置、动画、脚本、粒子）
  2. 搭建场景.fire文件
  3. 场景中的节点挂载，内置组件或自定义组件，控制游戏逻辑
  4. 脚本组件化 和开放式插件
  5. 数据驱动的工作流

项目结构：
assets：所有的都在这，本地资源脚本和第三方库
library：无用（导入自动生成信息）
local: 无用（本地配置）
packages： 放置 此项目的自定义扩展插件
settings： 项目设置
temp：无用
project.json：工程配置文件
build：构建目标 项目->构建发布时产生的

编辑器：
资源管理器
场景编辑器
层级管理器
属性检查器
控件库
工具栏
设置
项目设置

代码编辑环境配置：

第一个游戏：
Canvas： 画布
prefab：

基本工作流程：
配置资源–>
配置场景–>
配置脚本–>
一键接入第三方
发布跨平台

=====================================================================================================
配置资源：
一.在资源管理器中： 创建场景 保存场景 切换场景
切换场景中释放资源:1. cc.loader.release
2. 场景的自动释放功能
如切换场景不释放资源，内存越来越大。
若启用了2的场景自动释放功能，我们想让一部分资源不被释放，可使用cc.loader.setAutoRelease或者cc.loade.setAutoReleaseRecursively保留资源.
延迟加载资源

二.在资源管理器中： 添加贴图资源
Texture和它的子资源SpriteFrame
Atlas和它的多个子资源SpriteFrame
使用SpriteFrame

三.在资源管理器中： 添加预制资源
创建、保存。还原预置
预制体的自动同步和手动同步

四.在资源管理器中： 添加Atlas（图集资源）后，资源管理器中显示Atlas和它的多个子资源SpriteFrame
creator提供了自动图集功能，将碎图打成Atlas

五.在资源管理器中： “创建”自动图集资源Auto Atlas。
六.在资源管理器中：压缩纹理
七.在资源管理器中：创建艺术数字资源(LabelAtlas)
八.在资源管理器中：跨项目导入 导出资源
九.在资源管理器中：图像资源的自动剪裁
十.在资源管理器中：创建和使用脚本组件

十一.在资源管理器中：创建和使用字体资源
系统字体
动态字体
位图字体
直接创建label渲染组件，将字体拖入

十二. 粒子资源

十三.在资源管理器中：创建和使用声音资源
1.属性检查器内会有加载模式的选项
2.使用cc.loader.load

十四.在资源管理器中：创建和使用Spine、DragonBone 骨骼动画资源
十五.在资源管理器中：创建和使用瓦片图资源

十六.在资源管理器中的asset目录下将的所有.json文件，都会导入为cc.JsonAsset
1.直接为组件关联一个json
2.也可以动态加载 cc.loader.loadRes(“路径”, function(err, leixing变量){}); //这里的类型变量为jsonAsset
十七.文本资源： 同上

=====================================================================================================
配置场景：
一.组件式开发（组合而非继承）如Sprite节点 是由Node节点和Sprite组件组合而成的。
节点是承载组件的实体，组件来让节点具有各式各样的表现。
二.坐标系
三.层级管理器，节点层级
四.Canvas 渲染根节点
五.摄像机

=====================================================================================================

配置脚本：
一.创建组件脚本：创建js脚本挂载在节点上。

二.使用cc.Class();声明一个类型，如let 类型 = cc.Class();
声明出来的类型可以实例化对象如 var obj = new 类型();
cc是一个对象，调用cc对象的Class方法，class方法的参数是一个匿名对象，匿名对象在properties中包含了一个匿名对象，匿名对象内 使用key：value的方式设置了key属性，当然value也可以是一个匿名对象

1判断类型
2构造函数
3实例方法
4继承
5父构造函数
6脚本中声明属性
简单声明
完整声明
数组声明
get/set 声明

三.访问节点和组件
1.获得组件所在的节点 this.node
2.获得其它组件 this.node.getComponent(cc.Sprite);
3.利用属性检查器设置组件、利用属性检查器设置节点
4.查找子节点 this.node.children; cc.find(); getChildByName();
5.访问已有变量里的值：
①.通过全局变量访问
②.通过require模块访问

四. 模块化脚本
模块化：引用其它文件，访问其它文件导出的参数，
调用其它文件导出的方法
使用其它文件导出的类型
使用或继承其它组件Component
与NodeJs几乎相同的CommonJS标准来实现模块化
每个单独的脚本文件就构成一个模块
每个模块就是一个单独的作用域
以同步的require 方法来引用其它模块
设置module.exports 为导出的 变量

小例子：

在非cc.class组件内
let AA= require(“脚本名”)
导出对象
module.exports = {};

在cc.class组件内
extends AA;

======================================================
require:
可在脚本任意地方任意时刻调用
游戏开始时会自动require所有脚本，这时每个模块内部定义的代码就会被执行一次，之后无论又被require了几次，返回的始终是同一份实例
require 实际上获取的是 目标脚本中的 moudule.exports变量

定义模块：
①定义组件：当在脚本中 cc.Class({extends: cc.Component,});声明了一个组件，Creator会默认把他们导出，其它模块直接require这个模块 就可以直接使用这个组件。
②定义普通JavaScript模块
不单可以定义组件，还可导出任意js对象

导出变量： module.exports默认是一个空对象{}， 可以直接往里面加字段。 module.exports.key = value;
module.exports的值可以是任意JS类型

封装私有变量：
每个脚本都是一个单独的作用域， 在cc.class();外设置的 var 局部变量是私有变量，只能在脚本中使用，外部模块访问不到。

五. 插件脚本
资源管理器选中任意脚本， 属性检查器看到导入为插件 这一设置界面。
对于组件脚本而言默认为普通脚本。
对于第三方或底层插件 可以设置脚本为插件脚本。

普通脚本：可以require。脚本内声明的局部变量不会暴露到全局。use strict 被强制开启。项目构建阶段所有脚本都会被打包成单个脚本文件。
插件脚本：不可require。脚本内不再任何函数内声明的变量 都默认为全局。use strict需要声明，否则未定义的额变量一旦赋值就会变成全局变量。项目构建阶段不进行打包。

脚本加载顺序：Cocos2d引擎–> 插件脚本–> 普通脚本。

======================================================
六.CCClass进阶
CCClass： 使用cc.Class声明的类
原型对象：调用cc.Class 时传入的字面量参数，原型对象里面的参数可以省略，只需声明用的到的部分。
实例成员：成员变量 、 成员方法
静态成员：static 的静态成员和静态方法
运行时：
序列化：解析内存中的对象，将他的信息编码为一个特殊的字符串 ，以便保存到硬盘上或传输到其他地方。

类名： 使用getClassByName方法可以用来查找类名。
使用cc.js.getClassByName(JsName);来查找对应的类。
判断实例： instanceof();
判断类: cc.isChildClass();
成员： 实例变量、实例方法
静态变量、静态方法 在Class的原型对象参数中设置keyValue如 static:{}; 或者。。。
私有的静态成员（局部变量）
除了私有的静态成员，其它静态成员会被子类继承，继承时会将父类的静态变量 浅拷贝 给子类
继承：无论子类是否有定义构造函数，子类实例化前父构造函数都会被自动调用。
重写： 所有成员方法都是虚方法，子类方法可以直接重写父类方法
属性： 属性是特殊的实例变量，能够显示在属性检查器中，也能被序列化
属性参数： 所有属性都是可选的，但是必须要有default get set中的一个

七. 分包加载
以文件夹为单位进行分包加载。
选中文件夹->属性管理器选中分包加载–>点击应用确认
子包名就是文件名
子包名会在加载子包的时候 作为加载的名字传入

分包的作用只会在构建后才会体现。构建后在sbupackages 文件夹下生成 对应子包名文件夹，文件夹下的代码会合并成一个脚本文件，资源会移动到子目录下。

加载子包， 系统会提供一个统一的api来加载子包文件里面的资源cc.loader.downloader.loadSubpackage(‘包名’, function(){});
如果子包被加载成功，则子包中的脚本会自动运行，之后就像使用主包一样的使用子包了。

八. 对象池cc.NodePoor
运行时 创建销毁节点比较耗时，
我们一般在onLoad的时候进行节点的创建，切换场景的时候进行节点的销毁。
如果在游戏过程中，建议使用对象池，
即在onLoad中创建对象池 this poor = new cc.NodePoor();
创建池对象后,对象池插入对象 poor .put.(cc.instantiate(this.prefab));
在对象池中取出对象 let prefab = poor.get();
将用过的节点放回返回值也是 对象池.put（放回的节点）

this.poor = new cc.NodePoor(“脚本组件参数”);
this.poor.get(); 得到对象池中对象的时候 会调用 脚本组件的reuse方法
当this.poor.put(Item); 会调用脚本组件的unuse方法
就是对象池、脚本组件、和对象池对象的联系。

九. 动作系统：是基于Node的

缓动系统 => 动作系统

// 基础动作 --> 1.时间间隔动作 2.即时动作
// 容器动作
// 动作回调

// 不同类型之间的动作复合
// 动作回调，和动作回调的三个参数 ，动作回调不能停止自身动作
// 缓动动作easing 函数

十.替代动作的 cc.tween 新的API系统

// 链式API
cc.tween(this.node).to(1,{position:cc:v2(100,100), rotation:360}).
to(1,{scale:2}).
start() //将之前生成的action队列重新组合生成一个cc.sequence队列
所以cc.tween的链式结构是依次执行每一个API

// 设置缓动性
to ： 绝对
by ： 相对

// 支持缓动任意对象的任意属性
let obj = {key : 100}
cc.tween(obj).to(1,{key:100}).start();

// 同时执行多个属性
cc.tween(this.node).to(1, {scale:2, position:cc.v2(100,100). rotation:90});

//easing 函数
cc.tween().to(1,{scale:2, position:cc.v2(1,2), rotation:20}, {easing: “”});
easing 函数：可以是系统自带的
可以是自己定义的
easing : t=> tt // 参数 => 函数体 也可以这样写 (t)=>{tt};
对多个属性使用easing 函数，对单个属性使用easing函数

//自定义progress(用法类类似于easing)
cc.tween().to(1, {position: cc.v2(10, 2), rotation:45}, {progress : (t1, t2, t3)=>{ return t1 + t2 + t3;}})

// 一个cc.tween()就是一个队列，如果要同时执行多个队列则使用
.parallel(cc.tween.to(1, position: cc.v2(100,100)), cc.tween.by(2, rotation: 52));

// 回调
.call( ()=>{} )

// 重复执行
repeat / repeatForever函数会将前一个action作为作用对象

// 延迟执行
.delay(),

十一.定时器
// Js 的setTimeout 和setInterval

component.schedule()
四个参数： 回调， 时间间隔，重复几次， 延迟多久

component.unschedule();
取消定时器，参数是哪个回调函数。

当然也可以再回调函数中取消定时器， 参数就是这个回调函数本身

十二.脚本的执行顺序

同节点挂载脚本的执行顺序 ABABAB
设置组件执行优先级
properties: {
}
edit: {
execution: -1, //越小越早
},

android：

小知识1：
this project will support instant apps
这个项目将支持即时应用
无需安装app，直接得到代码环境执行的结果。
把所有代码和资源放到instant app模块，用户即时访问时 关联这个模块。

小知识2：
sync project with gradle files
同步项目与gradle文件

小知识3：
Android Studio “Sync project with Gradle Files”按钮消失问题?
发现工程中少了个.iml文件，看来这一切异常基本和这个iml文件有关系.只要重启android studio打开该项目即可生成iml。

小知识4:
iml文件的用途?
用英语在stackoverflow上试试，第一条便是：What are iml files in Android Studio?
IML是由IntelliJ IDEA创建的模块文件，这是一个用于开发Java应用程序的IDE。它存储有关开发模块的信息，可能是Java、插件、Android或Maven组件;保存模块路径、依赖项和其他设置。
然而，Gradle并不是IntelliJ IDEA的本地项目模型——它是独立的，保存在.iml文件和. IDEA /目录中的元数据中。在Android Studio中，这些东西大多是由Gradle构建脚本生成的，这就是为什么当你修改像build. Gradle这样的文件时，你会被提示“与Gradle文件同步项目”。这也是为什么您不必费心将.iml文件或.idea/放入版本控制中，因为它们的内容将被重新生成。

小知识5：
File 目录 —> invalidate caches/restart —invalidate and restart
即缓存失效重启androidStudio

小知识6：
Android Studio是从build.gradle里面定义的Maven 仓库服务器上下载library的。
Apache Maven是Apache开发的一个工具，提供了用于贡献library的文件服务器。
总的来说，只有两个标准的Android library文件服务器：jcenter 和 Maven Central。

小知识7：
jcenter和Maven Central两个标准的仓库。

小知识8：
为什么webView.loadUrl(“file:///android_asset/example.html”)是这种格式,
找assets文件夹下的example.html文件加载。

小知识9：
讲解findViewById的用法&是做什么的
安卓编程的定位函数，主要是引用.R文件里的引用名。
一般在R.java文件里系统会自动帮你给出你在XML里定义的ID或者Layout里面的名称，
例如：Button button=(Button)findViewById(R.id.button01);
这样就引用了XML（res里的布局文件）文件里面的button，使得在写.java的按钮时能与XML里的一致。

小知识10：
R.java是什么？
R.java文件自动生成，用来定义Android程序中所有各类型的资源的的索引。
有控件的id的索引，string字符串资源的索引，layout的索引，drawable资源索引等等
用户可以通过“R.资源类名.索引”来调用定义的资源

=====================================================================================================
2020/06/23

  1. JS绑定 jsb
  2. android和ios端写原生平台代码，与creator中打包构建项目
  3. 怎么接第三方sdk
  4. 现存项目，如热更新等。马甲包

抽象层
JS绑定的大部分工作其实就是 ，设定JS相关操作的CPP回调，在回调函数中关联cpp对象。
1.注册JS函数，绑定一个CPP回调。
2.注册JS对象的属性读写访问器，分别绑定读与写的cpp回调。
因为script引擎较多，所有我们把它统一了。
使用宏 来抹平不同JS引擎回调函数定义与参数类型的不同。

cocoscreator中 继承自cc.Component的组件所在的脚本一般都会作为组件附加到节点上（被继承的基类可以不用附加到节点上，基类被子类继承，子类就具有了父类的属性）。 在creator中的JavaScript脚本则需要用的时候require此脚本进行使用就可以了。

cc.js.getClassByName(脚本名);//通过名称获取注册类
目前测试的是CocosCreator一旦运行，在assert目录下的继承自extends: cc.Component所有脚本都可以在cc.js的属性里看到
（_registeredClassIds: 和 _registeredClassNames: 属性）。
通过cc.js.getClassByName(脚本名);可以知晓该参数脚本是否被注册。
如果被注册了，说明脚本存在，即脚本可以被挂载在节点上进行使用。
在使用脚本组件时，可以在被挂载节点上getComponent取得该组件进行使用。

在assert目录下的JavaScript脚本，未继承自extends: cc.Component，这个脚本在cc.js的属性里是看不到的。可以使用require(脚本名);获取脚本，如果脚本存在，则可以获取改脚本对象。直接使用require 返回的js脚本对象。

一般浏览器采用CMD规范。CMD规范是非同步加载模块.
CMD规范推崇依赖就近 as lazy as possible
全局函数define(参数);
1.参数是对象或者字符串的时候表示，模块的接口就是该对象或者字符串。
2.当参数是函数的时候，表示是模块的构造方法。
执行该构造方法可以得到模块对外的接口。函数在执行的时候默认会传入三个参数：require，exports，module。
例如：
define(function(require, exports, module){
//-- require函数接收模块标识做参数，用来接收其它模块的接口。require一直就是这么写。
var a = require("./a");
a.doSomething();
});

ADM规范是非同步加载模块，允许指定回调函数。
一般浏览器采用AMD规范。
对于依赖的模块，AMD是提前执行。不过RequireJS从2.0开始，也改成可以延迟执行（根据写法不同，处理方式不同）
AMD推崇依赖前置
define([’./a’,’./b’], function(a, b){
//依赖必须一开始就写好
a.doSomething();
…
b.doSomething();
…
});

一般Nodejs采用CommonJS规范
CommonJS规范加载模块是同步的，只有加载完成，才能执行后面的操作。
每个文件就是一个模块，有自己的作用域。
js文件被加载后，每个模块都有一个moudle对象和一个exports对象。
moudle对象有一个exports属性，属性表示当前模块对外输出的接口，其他文件加载该模块，实际上就是读取moudle.exports变量。
为了方便，Node为每个模块提供一个exports变量指向moulde.exports
require函数用于加载模块文件。
注意：不能直接将exports变量指向一个值，因为这样等于切断了exports与moudle.exports的联系。
所以如果一个模块的对外接口，就是一个单一的值，不能使用exports输出，只能使用module.exports.

例子：
// – a.js
// ---------------------- node -------------------------
module.exports = {
a:function(){},
b:‘xxx’,
};
// ---------------------- ADM or CMD--------------------
define(function(require, exports, module){
module.exports = {
a : function(){},
b : ‘xxx’
};
});

// – b.js
// ---------------------- node -------------------------
var m = require(’./a’);
m.a();
// ---------------------- ADM or CMD -------------------
define(function(require, exports, module){
var m = require(’./a’);
m.a();
});

cocosCreator:
再给属性赋值的时候，属性的notify函数一定会被触发，即使新值与旧值是一样的也会触发。

require/exports
require/exports 出生在野生规范当中，即这些规范是 JavaScript 社区中的开发者自己草拟的规则，得到大家的承认或者广泛的应用。比如 CommonJS、AMD、CMD 等等。

CommonJS 是 Node.js 的规范。require/exports 的用法只有以下三种简单的写法：
const fs = require(‘fs’)
exports.fs = fs
module.exports = fs

module.export

ES6中export和import的使用。
import/export 则是名门正派。TC39 制定的新的 ECMAScript 版本，即 ES6（ES2015）中包含进来。

// profile.js
var firstName = ‘Michael’;
var lastName = ‘Jackson’;
var year = 1958;
export {firstName, lastName, year};

// main.js
import {firstName, lastName, year} from ‘./profile’;

function setName(element) {
element.textContent = firstName + ’ ’ + lastName;
}

CommonJS 和 ES6 之间的差异，Node.js 无法直接兼容 ES6。所以现阶段 require/exports 仍然是必要且是必须的。出自 ES6 的 import/export 相对就晚了许多。
这也就是为什么前面说 require/exports 是必要且必须的。因为事实是，目前你编写的 import/export 最终都是编译为 require/exports 来执行的。

jdk java 虚拟机，编译.class的环境
–> sdk (java) 使用java开发android
–> NDK(c/c) 要使用c/c的第三方库，以前是用java 的jni调用c/c。（Java调用C方法）
NDK的使用（java调用C方法）
https://blog.csdn.net/zhufeng1222/article/details/76047128

数据属性 访问器属性
原型属性 实例属性
Object.cerate() 必须接收一个对象参数，创建的新对象的原型指向接收的参数对象，
new Object() 创建的新对象的原型指向的是 Object.prototype.
（表述有点啰嗦，简洁点说就是前者继承指定对象， 后者继承内置对象Object）

可以通过Object.create(null) 创建一个干净的对象，也就是没有原型，
而 new Object() 创建的对象是 Object的实例，原型永远指向Object.prototype

Object.create(proto)方法创建一个新对象，使用现有的对象来提供新创建的对象的 proto.

proto 新创建对象的原型对象。

每个对象都会在内部初始化一个属性,就是__proto__,当我们访问一个对象时，如果对象内部不存在这个属性，那么他就会去__proto__里去找这个属性，这个__proto__又会有自己的__prto__，于是这样一直找下去，也就是原型链。

每个函数都有一个prototype属性（只有函数才有），这个属性是一个指针，prototype属性指向原型对象。

函数的prototype下的属性，在函数实例化对象时可以由对象调用，不可以用函数名调用。但prototype属性可以被所有对象共享。
如果函数直接添加属性，则可以用 函数名.属性 进行调用添加的属性。因为这是类属性，不是对象属性。

逗号分隔， 不是逗号操作符
var a=0, b=5, c=“ss”;
//-- 下面的函数返回的是i，即返回的是1。
testDouhaoUsed(){

    var args = 1,s2 ="sss";
    cc.log(args);
    cc.log(s2);
    function ttes(){
        var i = 0;
        return (i+=1, i);
    }
    cc.log(ttes());
},

[].slice.call(arguments, 1) //–意思是取得arguments数组的下标为1的元素
//arguments是调用对象，替换了[],1是传递给slice的参数。

//-- 把一些脚本设置为插件， 允许编辑器加载，如编辑器中的其它普通脚本加载过程中会依赖当前脚本，则需要手动开启这个选项。
通常我们在插件中写入：
1.立即执行函数，立即执行函数内部没有加入 window. 的属性，外部是不可访问的，加入即可在外部访问（全局）。如果在函数的外部写入的 属性，则不需要加入 window. 属性。 如果在函数内部，没有定义而立即使用的属性，则也会直接认为是全局变量（在不是strict的情况，在strict的情况直接使用未定义的属性会报错）
2.可以给一些既定存在的类型添加原型属性，例如在cocoscreator中。
cc.Toggle.prototype.setSelectState = function(isSelect) {
cc.log(“isSelect==”, isSelect);
cc.log(“this.toggleGroup==”, this.toggleGroup);
cc.log(“this._toggleContainer==”, this._toggleContainer);
var group = this.toggleGroup || this._toggleContainer;
}

插件脚本需要手动声明 use strict,否则未定义的变量一旦赋值就会变成全局变量

自己的问题：new 出来的ccToggle 和 属性检查器中出来的属性不同。
答：自己new出来的cc.Toggle 是一个组件对象。
属性检查器中的是Node节点上附加了cc.Toggle属性，而且这个Node是由父子节点的。
这两个是不一样的东西，即属性不同。

//-- 关于require的循环引用问题：
//-- item.js
var item = cc.Class({
properties:()=>({
game:{
default:null,
type:require(“other”),
}
})
});
module.exports = item;

//-- other.js
var other = cc.Class({
properties:()=>({
item:{
default:null,
type:require(“item”),
}
})
});
module.exports = other;
即由此可知，在这里require出来的是一个类型。

–> 载入场景 -->自动运行所包含组件的游戏脚本。请深刻理解“包含组件的游戏脚本”

声音加载过程中
插件脚本加载过程中（是否编辑器中的其它普通脚本加载过程中会依赖当前脚本）

get/set 属性
{ item:
{
get:function(){
return this._width;
},
set:function(width){
this._width = width;
}
}
}

属性加载
一般我们这么写
properties:{

}
lambada 属性加载
properties: ()=>({key:{}})
properties: ()=>{ return {};}
properties: function(){
return {};
}

//-- 子类调用基类函数
var rect = cc.Class(){
extends: Shape,
getName : function(){
Shape.prototype.getName.call(this);
return baseName + “(rect)”;
}
//-- 也可以这样调用父类
getName : function(){
this._super();
}

}

C++ 关于宏的一点总结
编译器处理宏是在预处理阶段，是按照文本的顺序进行处理的。遇到宏时就定义一个宏变量。
宏相当一个全局变量，但是在不同cpp中定义是不能相互使用的，除非在.h文件中。

js的方法：
对象方法：
类方法：
原型方法：
function baseClass(){
this.show = function(){console.log(" baseClass : show")};
};

function extendClass(){
this.show = function(){console.log(" extendClass: show")}
};
extendClass.prototype = new baseClass();

let extObj = new extendClass();
//对象方法
extObj.show() //输出 extendClass : show
//类方法不是对象方法
var baseinstance = new baseClass();
baseinstance.show.call(extendClass); //输出 baseClass : show

baseinstance.show.call(extObj); //输出 baseClass : show
extObj.show.call(baseinstance); //输出 extendClass: show

xxx.show.call(yyy); //xxx必须是实例，yyy可以是实例也可以是类型

内置数据类型：string
引用数据类型：Object array date function regExp

array：
array.every 所有为true

some 一些为true

filter//过滤得到符合要求的arra

map //映射得到符合要求的arr

array.forEach(index, index , arrays){

}

push / shift
pop / unshift

原型类型属性：
你不需要显示的声明一个prototype属性，因为在每一个构造函数中都有他的存在。
prototype是一个原型类型对象。
当一个对象呗创建时，这个构造函数 将会把它的属性prototype赋给新对象的内部属性
prototype.
这个__prototype__被这个对象用来查找它的属性。

数据属性
configureable enumeable value writeable
访问器属性
configurwable enumeable set get 通过一个属性的值改变其他属性

实例属性 原型属性
调用构造好函数后生成的每个对象实例都包含 一个原型属性对象。 每个对象实例的原型属性对象都是同一份。
当给与对象实例 覆盖与 原型属性相同的名字的属性，则调用时使用的是 对象实例覆盖的属性。
判断使用的这个属性是否是实例对象自己的，则可以用 实例对象.hasOwnProperty(“属性名”)；
枚举其中的 for in 除了不可枚举的部分都会枚举出来
object.getprototypenames();

例子：证明实例属性和原型属性
function Fish(name, color){
this.name=name;
this.color=color;
}
Fish.prototype.livesIn=“water”;
Fish.prototype.price=20;

var fish1=new Fish(“mackarel”, “gray”);
var fish2=new Fish(“goldfish”, “orange”);
var fish3=new Fish(“salmon”, “white”);
for (int i=1; i<=3; i++){
alert(fish.name+","+fish.color+","+fish.livesIn+","+fish.price);
}
输出应该是：

“mackarel, gray, water, 20”
“goldfish, orange, water, 20”
“salmon, white water, 20”

Node 类型
属性： 组。坐标。旋转角度。相对父节点缩放。xyz轴缩放。xy轴倾斜角度。 透明度
节点颜色。xy轴锚点位置。节点宽度 高度。zIndex层级排序。
节点的不同明度是否影响子节点。children节点的所有子节点。
childrenCount
active
子节点是否在场景中激活
parent
方法：
on ：this.node.on(cc.Node.EventType.TOUCH_START, this.memberFunction, this);
在节点上注册指定的回调函数。可以设置target用于绑定响应函数的this对象

once : 注册节点的特定事件类型回调。回调会在第一时间被触发后删除自身。
off： 删除之前同类型 回调 目标 或useCapture

emit 通过事件名发送自定义事件

我们游戏中使用的fire是 根据数组存储事件对象元素， 在遍历这个数组时候如果存在事件
则使用cb.apply(obj, argument); obj进行即时执行 cb函数。
使用apply

另一种用法： Math.max.apply(null, aray); //null 代表没有对象去执行这个方法，我只需要
用这个方法进行运算，得到返回的结果就行。
（充分利用apply 的特性 自动把第二个数组参数变成一个一个元素 成为函数的参数 ）

array.prototype.push.apply(array, needPushArr);

全局执行上下文 window对象。 他是var 声明的全局变量的载体。
函数执行上下文可以存在无数个，当每一个函数被调用时都会创建一个函数上下文。
执行上下文栈 也叫调用栈，执行栈用于存储代码执行期间创建的所有上下文。

利用JSON转换值达到存储的的方式非常好用
利用json.stringify将存储对象转换成字符串，使用localStorage进行存储，.
当使用localStorge将存储的东西拿出来的后，也是个字符串。
将字符串在使用JSON.parse()从一个字符串中解析出JSON对象 就可以进行使用了

//–JSON.stringify()函数是用来序列化对象的，
无论输入什么，输出的都是字符串类型，可以按自己的需求来定制如何序列化，
输出结果是怎样的格式.
（这个函数可以配置不同的参数：一个参数 object{}/ array []；
二个参数 第二个参数为函数/数组；
三个参数 ）

bool number string 序列化过程中会转为原始值/ undefine null symbol 在序列化过程中会被忽略
（在非数组对象的属性值中时）或者被转换成null（出现在数组中时） 不可枚举的属性会被忽略。

JSON.parse()从一个字符串中解析出JSON对象

浅拷贝与深度拷贝:深拷贝，是拷贝对象各个层级的属性(concat方法与slice也存在这样的情况，他们都不是真正的深拷贝)
（对象的拷贝）
function deepClone(obj){
let objClone = Array.isArray(obj)?[]:{};
if(obj && typeof obj===“object”){
for(key in obj){
if(obj.hasOwnProperty(key)){
//判断ojb子元素是否为对象，如果是，递归复制
if(obj[key]&&typeof obj[key] ===“object”){
objClone[key] = deepClone(obj[key]);
}else{
//如果不是，简单复制
objClone[key] = obj[key];
}
}
}
}
return objClone;
}
let a=[1,2,3,4],
b=deepClone(a);
a[0]=2;
console.log(a,b);

除了递归，我们还可以借用JSON对象的parse和stringify
function deepClone(obj){
let _obj = JSON.stringify(obj),
objClone = JSON.parse(_obj);
return objClone
}
let a=[0,1,[2,3],4],
b=deepClone(a);
a[0]=1;
a[2][0]=1;
console.log(a,b);

js数组和对象的区别：
有序、无序。 对象是关联数组，就是将值与特定的对象关联在一起。
当用点号运算符来存取对象属性时，属性名是用标识符表示的；当用中括号来存取对象属性时，属性名是用字符串表示的，因此可以在运行过程中动态生成字符串。

cocoscreator构建发布， 模板选项生成jsb-default，工程文件在frameworks中。

android studio和eclipse========
因为AS是基于IDEA的，与Eclipse还是有所不同。
Android Studio 项目目录结构
.gradle 文件夹包含的是 gradle 工具的各个版本。

android studio里面的iml是什么文件，android工程的配置文件，这是一个临时文件，编译后出现的。
（IML是由IntelliJ IDEA创建的模块文件，用于开发Java应用程序的IDE。它存储有关开发模块的信息，该模块可能是Java，Plugin，Android或Maven组件; 保存模块路径，依赖关系和其他设置。）

android studio中的build.gradle

英汉互译
//-- Task 任务
//-- plugin插件
//-- Gradle 小秘书

一、什么是Gradle
Gradle是一个构建工具，它是用来帮助我们构建app的，构建包括编译、打包等过程。我们可以为Gradle指定构建规则，然后它就会根据我们的“命令”自动为我们构建app。Android Studio中默认就使用Gradle来完成应用的构建。

有些时候，我们会有一些个性化的构建需求，比如我们引入了第三方库，或者我们想要在通用构建过程中做一些其他的事情，这时我们就要自己在系统默认构建规则上做一些修改。这时候我们就要自己向Gradle”下命令“了，这时候我们就需要用Gradle能听懂的话了，也就是Groovy。Groovy是一种基于JVM的动态语言

我们在开头处提到“Gradle是一种构建工具”。实际上，当我们想要更灵活的构建过程时，Gradle就成为了一个编程框架——我们可以通过编程让构建过程按我们的意愿进行。
当我们把Gradle作为构建工具使用时，我们只需要掌握它的配置脚本的基本写法就OK了；而当我们需要对构建流程进行高度定制时，就务必要掌握Groovy等相关知识了。

二、Gradle的基本组分

  1. Project与Task
    在Gradle中，每一个待构建的工程是一个Project，构建一个Project需要执行一系列Task，比如编译、打包这些构建过程的子过程都对应着一个Task。具体来说，一个apk文件的构建包含以下Task：Java源码编译、资源文件编译、Lint检查、打包以生成最终的apk文件等等。
  2. 插件
    插件的核心工作有两个：一是定义Task；二是执行Task。也就是说，我们想让Gradle能正常工作，完成整个构建流程中的一系列Task的执行，必须导入合适的插件，这些插件中定义了构建Project中的一系列Task，并且负责执行相应的Task。

在新建工程的app模块的build.gradle文件的第一行，往往都是如下这句：
apply plugin: ‘com.android.application’
这句话的意思就是应用“com.android.application“这个插件来构建app模块，app模块就是Gradle中的一个Project。也就是说，这个插件负责定义并执行Java源码编译、资源文件编译、打包等一系列Task。实际上"com.android.application"整个插件中定义了如下4个顶级任务：
assemble: 构建项目的输出（apk）
check: 进行校验工作
build: 执行assemble任务与check任务
clean: 清除项目的输出
当我们执行一个任务时，会自动执行它所依赖的任务。比如，执行assemble任务会执行assembleDebug任务和assembleRelease任务，这是因为一个Android项目至少要有debug和release这两个版本的输出。
3. Gradle配置文件
+png

上面我们说过，Android Studio中的一个Module即为Gradle中的一个Project。上图的app目录下，存在一个build.gradle文件，代表了app Module的构建脚本，它定义了应用于本模块的构建规则。我们可以看到，工程根目录下也存在一个build.gradle文件，它代表了整个工程的构建，其中定义了适用于这个工程中所有模块的构建规则。

接下来我们介绍一下上图中其他几个Gradle配置文件：

gradle.properties: 从它的名字可以看出，这个文件中定义了一系列“属性”。实际上，这个文件中定义了一系列供build.gradle使用的常量，比如keystore的存储路径、keyalias等等。

gradlew与gradlew.bat: gradlew为Linux下的shell脚本，gradlew.bat是Windows下的批处理文件。gradlew是gradle wrapper的缩写，也就是说它对gradle的命令进行了包装，比如我们进入到指定Module目录并执行“gradlew.bat assemble”即可完成对当前Module的构建（Windows系统下）。

local.properties: 从名字就可以看出来，这个文件中定义了一些本地属性，比如SDK的路径。

settings.gradle: 假如我们的项目包含了不只一个Module时，我们想要一次性构建所有Module以完成整个项目的构建，这时我们需要用到这个文件。比如我们的项目包含了ModuleA和ModuleB这两个模块，则这个文件中会包含这样的语句：include ‘:ModuleA’, ‘:ModuleB’。

  1. 构建脚本
    首先我们来看一下工程目录下的build.gradle，它指定了真个整个项目的构建规则，它的内容如下：
    buildscript {
    repositories {
    jcenter() //构建脚本中所依赖的库都在jcenter仓库下载
    }
    dependencies {
    //指定了gradle插件的版本
    classpath ‘com.android.tools.build:gradle:1.5.0’
    }
    }

allprojects {
repositories {
//当前项目所有模块所依赖的库都在jcenter仓库下载
jcenter()
}
}

我们再来简单介绍下app模块的build.gradle的内容：

//加载用于构建Android项目的插件
apply plugin: ‘com.android.application’

android { //构建Android项目使用的配置
compileSdkVersion 23 //指定编译项目时使用的SDK版本
buildToolsVersion “23.0.1” //指定构建工具的版本

defaultConfig {
    applicationId "com.absfree.debugframwork" //包名
    minSdkVersion 15  //指定支持的最小SDK版本
    targetSdkVersion 23 //针对的目标SDK版本
    versionCode 1 
    versionName "1.0"
}
buildTypes { //针对不同的构建版本进行一些设置
    release { //对release版本进行的设置
        minifyEnabled false //是否开启混淆
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'  //指定混淆文件的位置
    }
}

}

dependencies { //指定当前模块的依赖
compile fileTree(dir: ‘libs’, include: [’*.jar’])
testCompile ‘junit:junit:4.12’
compile ‘com.android.support:appcompat-v7:23.1.1’
compile ‘com.android.support:design:23.1.1’
}

三、常见配置
整个工程的build.gradle通常不需我们改动，这里我们介绍下一些对模块目录下build.gradle文件的常见配置。

  1. 依赖第三方库
    当我们的项目中用到了了一些第三方库时，我们就需要进行一些配置，以保证能正确导入相关依赖。设置方法很简单，比如我们在app模块中中用到了Fresco，只需要在build.gradle文件中的dependencies块添加如下语句：
    dependencies {
    …
    compile ‘com.facebook.fresco:fresco:0.11.0’
    }
    这样一来，Gradle会自动从jcenter仓库下载我们所需的第三方库并导入到项目中。
  2. 导入本地jar包
    在使用第三方库时，除了像上面那样从jcenter仓库下载，我们还可以导入本地的jar包。配置方法也很简单，只需要先把jar文件添加到app\libs目录下，然后在相应jar文件上单击右键，选择“Ad As Library”。然后在build.gradle的dependencies块下添加如下语句：
    compile files(‘libs/xxx.jar’)
    实际上我们可以看到，系统为我们创建的build.gradle中就已经包含了如下语句：
    compile fileTree(dir: ‘libs’, include: [’*.jar’])
    这句话的意思是，将libs目录下的所有jar包都导入。所以实际上我们只需要把jar包添加到libs目录下并“Ad As Library"即可。
  3. 依赖其它模块
    假设我们的项目包含了多个模块，并且app模块依赖other模块，那么我们只需app\build.gradle的denpendencies块下添加如下语句：
    compile project(’:other’)
  4. 构建输出为aar文件
    通常我们构建的输出目标都是apk文件，但如果我们的当前项目时Android Library，我们的目标输出就是aar文件。要想达到这个目的也很容易，只需要把build.gradle的第一句改为如下：
    apply plugin:‘com.android.library’
    这话表示我们使用的插件不再是构建Android应用的插件，而是构建Android Library的插件，这个插件定义并执行用于构建Android Library的一系列Task。
  5. 自动移除不再使用的资源
    只需进行如下配置：
    android {
    …
    }
    buildTypes {
    release {
    …
    shrinkResources true
    …
    }
    }
    }
  6. 忽略Lint错误
    在我们构建Android项目的过程中，有时候会由于Lint错误而终止。当这些错误来自第三方库中时，我们往往想要忽略这些错误从而继续构建进程。这时候，我们可以只需进行如下配置：
    android {
    …
    lintOptions {
    abortOnError false
    }
    }
  7. 集成签名配置
    在构建release版本的Android项目时，每次都手动导入签名文件，键入密码、keyalias等信息十分麻烦。通过将签名配置集成到构建脚本中，我们就不必每次构建发行版本时都手动设置了。具体配置如下：
    signingConfigs {
    myConfig { //将"xx"替换为自己的签名文件信息
    storeFile file(“xx.jks”)
    storePassword “xx”
    keyAlias “xx”
    keyPassword “xx”
    }
    }
    android {
    buildTypes {
    release {
    signingConfig signingConfigs.myConfig //在release块中加入这行
    …
    }
    }
    …
    }

真实开发中，我们不应该把密码等信息直接写到build.gradle中，更好的做法是放在gradle.properties中设置：
RELEASE_STOREFILE=xxx.jks
RELEASE_STORE_PASSWORD = xxx
RELEASE_KEY_ALIAS=xxx
RELEASE_KEY_PASSWORD=xxx
然后在build.gradle中直接引用即可：
signingConfigs {
myConfig {
storeFilefile(RELEASE_STOREFILE)
storePassword RELEASE_STORE_PASSWORD
keyAlias RELEASE_KEY_ALIAS
keyPassword RELEASE_KEY_PASSWORD
}
}

四、延伸阅读

  1. 深入理解Android之Gradle:http://blog.csdn.net/Innost/article/details/48228651

    邓凡平老师的一篇博文，从原理到使用非常深入细致地介绍了Gradle。而且重点介绍了怎样把Gradle当做一个编程框架来使用，介绍了Groovy语法基础、Gradle常用API，想要高度定制项目构建过程的小伙伴们一定不要错过这篇文章哦：）

  2. Gradle构建最佳实践: http://www.figotan.org/2016/04/01/gradle-on-android-best-practise/

这篇文章主要从使用者的角度介绍了Gradle在使用过程中的最佳实践，同样非常精彩。

转自http://mp.weixin.qq.com/s?__biz=MzIzMjE1Njg4Mw==&mid=2650117738&idx=1&sn=cfaf39a23d9ebe655f687e4abb90312c#rd

============================================================================
AndroidStudio、gradle、buildToolsVersion概述
每次gradle 或者studio 有推荐更新后,项目重新sync后都会报错，提示更新相应的其他版本，比如AndroidStudio、gradle、buildToolsVersion版本；

概念：
Android SDK Build-Tools： 是编译 Android 应用所需 Android SDK 的一个组件，安装在 /build-tools/ 目录中。（而buildToolsVersion是android构建工具的版本，其中包括了打包工具aapt、dx等等。这个工具的目录位于…your_sdk_path/build-tools/XX.XX.XX，通过SDK Manager 更新；）您应始终让 Build Tools 组件保持最新状态。为此，您可以使用 Android SDK 管理器下载该组件的最新版本。如果您使用的是 Android Plugin for Gradle 3.0.0 或更高版本，那么您的项目会自动使用该插件指定的默认版本的 Build Tools。要使用其他版本的 Build Tools，请在模块的 build.gradle 中使用 buildToolsVersion 进行指定，如下所示：

android {
buildToolsVersion “29.0.0”
…
}

Gradle：是一个工具，同时它也是一个编程框架。使用这个工具可以完成app的编译打包等工作；
compileSdkVersion：编译版本，就是运行我们这个项目的需要的android SDK版本；

comileSdkVersion 和buildToolsVersion区别
新建一个项目，看build.gradle文件的配置，如下：

CompileSdkVersion:是告诉gradle 用哪个SDK版本来编译，和运行时要求的版本号没有关系；使用任何新添加的 API 就需要使用对应 Level 的 Android SDK。
buildToolsVersion: android构建工具的版本,在SDK Manager中安装选择版本，buildToolsVersion的版本需要>=CompileSdkVersion; 高版本的build-tools 可以构建低版本编译的android程序；

gradle版本和com.android.tools.build:gradle配置的版本关系
之前会奇怪，为什么一更新gradle 插件版本，会报错
如下图，红色部分配置的就是android gradle 插件的版本，gradle插件的版本号和gradle版本号是对应的，较新的插件版本需要要求较新版的gradle，所以提示你更新gradle；

和apk有关的是targetSdk， compileSdk只是开发编译时候用的sdk版本，在咱们写代码时候编译报黄或者包红都是跟compilesdk进行的比较，不过为了确保输出版本apk的api和编译时候相同，我们一般都会讲compileSdk和targetSdk设置一样。

=========================
1.Gradle
Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化构建开源工具。它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置，抛弃了基于XML的各种繁琐配置。
2.Gradle插件
其实应该是AndroidStudio Gradle Plugin，也就是AndroidStudio用于开发Android项目的gradle插件。
所以说，Gradle插件和Gradle不是一个东西。
Gradle和Android Gradle Plugin的关系？
①Gradle插件会有版本号，每个版本号又对应有一个或一些 Gradle发行版本（一般是限定一个最低版本），也就是我们常见的类似gradle-4.1-all.zip这种东西；如果这两个版本对应不上了，那你的工程构建的时候就会报错。对应关系参看Gradle插件和Gradle版本对应关系。
②Android Studio 3.0 之后自动将插件版本升级到3.0.0，所以我们也需要对应地把Gradle升级到4.1才行。（后面就是因为这个填坑）
Android Gradle Plugin和 Android SDK BuildTool的关系？
③Android Gradle Plugin又会跟 Android SDK BuildTool有关联（版本有对应的关系），因为它还承接着AndroidStudio里的编译相关的功能，这也是我们要在项目的 local.properties 文件里写明Android SDK路径、在build.gradle 里注明 buildToolsVersion 的原因。Android Gradle Plugin 本质上就是 一个AS的插件，它一边调用 Gradle本身的代码和批处理工具来构建项目，一边调用Android SDK的编译、打包功能，从而让我们能够顺畅地在AS上进行开发。

https://my.oschina.net/huangyong/blog/361751

default package是缺省包的意思!也就是没有名字的包.其它的包如果要调用缺省包中的类,必须插入包名.但是缺省包却无名,所以不能够直接调用!
解决办法:
你右击default package,然后再建立一个新包(例如是:mypackage),把你先前建立的.java文件直接拖到新包(mypackage)中,缺省包会自动消失的!

//-- 一二三步骤可以用来建立一个Jar包，然后其他工程可以引用。
一、创建一个工程，创建一个接口。（编写的服务接口）
二、 将此工程的接口，制作成一个Jar包
既然叫JAR包，一定记着建工程的时候记得建包！不能是default package
1.写好以后右键,然后选择导出
2.选择以JAR文件导出
3.选择导出路径
三、编写服务接口实现类
4.导出成功,然后导入 Build Path->Add External Aarchives
5.右击工程->属性->选择Libraries,选择 Add External JARs
6.选择之前保存的JAR文件
7.并在Order and Export中，在你要导入的包的前面打钩
8.导入成功，利用import关键字导包即可使用
什么是jar包，做什么用的？
@是什么？严格说@符号并未在java 语言中作为操作符使用。而是在其他附属技术中使用

如果导入了jar包，在人为的把jar包路径变更，则会出错。

Java的框架还算比较多的，像spring框架算是很成熟的框架了

Java的配置文件.properties文件和xml文件。
一、properties文件
.properties配置文件是什么？
答：Properties文件是java中很常用的一种配置文件，文件后缀为“.properties”，属文本文件，文件的内容格式是“键=值”的格式，可以用“#”作为注释，java编程中用到的地方很多，运用配置文件，可以便于java深层次的解耦。
例如java应用通过JDBC连接数据库时，可以把数据库的配置写在配置文件 jdbc.properties：
driver=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql://localhost:3306/user
user=root
password=123456

二、Properties类
java中提供了配置文件的操作类Properties类（java.util.Properties）：

读取properties文件的通用方法：根据键得到value
/**
* 读取config.properties文件中的内容，放到Properties类中
* @param filePath 文件路径
* @param key 配置文件中的key
* @return 返回key对应的value
*/
public static String readConfigFiles(String filePath,String key) {
Properties prop = new Properties();
try{
InputStream inputStream = new FileInputStream(filePath);
prop.load(inputStream);
inputStream.close();
return prop.getProperty(key);
}catch (Exception e) {
e.printStackTrace();
System.out.println(“未找到相关配置文件”);
return null;
}
}

把配置文件以键值对的形式存放到Map中：
/**
* 把.properties文件中的键值对存放在Map中
* @param inputStream 配置文件（inputstream形式传入）
* @return 返回Map
*/
public Map convertPropertityFileToMap(InputStream inputStream) {
try {
Properties prop = new Properties();
Map map = new HashMap();
if (inputStream != null) {
prop.load(inputStream);
Enumeration keyNames = prop.propertyNames();
while (keyNames.hasMoreElements()) {
String key = (String) keyNames.nextElement();
String value = prop.getProperty(key);
map.put(key, value);
}
return map;
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
}

在XML配置文件中使用properties文件的键值作为变量化参数

https://www.jb51.net/article/158921.htm
@Java注解又叫java标注（Annotation）

注解，就是元数据，即描述数据的数据。注解就是源代码的元数据。
@Override
public String toString() {
return “This is String Representation of current object.”;
}

上面的代码中，我重写了toString()方法并使用了@Override注解。但是，即使我不使用@Override注解标记代码，程序也能够正常执行。那么，该注解表示什么？这么写有什么好处吗？事实上，@Override告诉编译器这个方法是一个重写方法(描述方法的元数据)，如果父类中不存在该方法，编译器便会报错，提示该方法没有重写父类中的方法

这部分内容很重要，Annotations仅仅是元数据，和业务逻辑无关。
如果Annotations不包含业务逻辑，那么必须有人来实现这些逻辑。
元数据的用户来做这个事情。
Annotations仅仅提供它定义的属性(类/方法/包/域)的信息。
Annotations的用户(同样是一些代码)来读取这些信息并实现必要的逻辑。
当我们使用Java的标注Annotations(例如@Override)时，JVM就是一个用户，它在字节码层面工作。到这里，应用开发人员还不能控制也不能使用自定义的注解。因此，我们讲解一下如何编写自定义的Annotations。

我们来逐个讲述编写自定义Annotations的要点。上面的例子中，你看到一些注解应用在注解上。

开发类库 运行环境 部署环境
JavaEE JavaME
Java的垃圾自动收集（无c c++的垃圾自动收集功能， 运算符重载，多重继承等）
Java语言以面向对象为基础，不能再类外定义单独的数据和函数，所有的对象都要派生于同一个基类，并共享其所有功能。所以说，Java语言最外部的数据类型是对象，所有元素都要通过类和对象来访问。
分布式：
由于Java中内置了TCP/IP, HTTP, FTP等协议，因此在Java应用程序可以通过URL地址访问网络上的对象。

多线程、高效、可移植性。

JDK是Java的开发工具包，也是Java开发者必须安装的软件环境。
JDK包含了JRE与开发Java程序所需的工具，如编译器、调试器、反编译器、文档生成器

JRE是Java程序运行的必要环境，包含类库和JVM,如果只运行Java程序，就没必要安装JDK,只安装JRE即可。

Java是跨平台开发语言，根据平台的不同，要选择不同的JDK

安装Eclipse前需要先安装JDK

Java中最基本的类java.long.Object是Java中所有类的祖先。
java.lang包它包含着Java最基础和核心的类，在编译时会自动导入。Object类没有定义属性，一共有13个方法。
Java 中，用native关键字修饰的函数，表明该方法的具体实现在dll文件中，对于不同平台，其具体实现应该有所不同。

整个类的定义包括其所有成员都是在一对大括号中完成的，这标志着类定义块的开始和结束。
main() 方法，程序从这里开始执行，所有的Java应用程序都必须有一个main()方法。main()方法是所有Java应用程序的起始点。

void static main(String[] args){}
static 表示无需创建类的实例，可以直接调用main方法。

java程序的运行原理：Javac 编译器变异HelloWord.java文件，生成HelloWord.class文件。
Java 解释器解释 .class 文件。

Java程序的基本组成
Java数据类型
Java语言的运算符和表达式
Java语言的流程控制语句
组的定义和使用方法
方法和方法的重载

在Java中声明一个类的方式主要有两种，即class类名称和public class 类名称。
类是Java的基本存储单元，Java中所有的操作都是由类组成的。
一般习惯把main方法放在public class声明的类中，
public static void main(String[] args) 是程序的主方法，
即所有的程序都以此方法为起点并运行下去。
！！！ public class类名称的“类名称”必须与文件名相同。
在一个Java文件中可以有多个class类的定义，但只能有一个public class的定义

Java的标识符和关键字
常量和变量
作用域嵌套

Java数据类型：
（原始类型“简单类型：整数、字符、浮点、布尔”
和引用类型“复合类型”： 类、接口、数组 ）

基本数据类型默认值
类型转换： 自动转化和强制转换
类型提升：提升的规则就是将表达式的运算结果的类型提升为
所有操作数数据类型中范围最大的数据类型。

操作数、运算符、表达式

类声明的基本格式：
访问说明符 class 类名 extends 超类名 implements 接口名
如果访问说明符为public ， 则类名必须和文件名保持一致。

类体：
成员变量： 访问说明符 数据类型 变量名
方法： 访问说明符 数据类型 方法名

类的单继承性： 允许用extends关键字从一个类扩展出一个新类，新类继承超
类的成员变量和方法，并可覆盖该方法。

类中有两个特殊变量super和this
super: 类声明中用关键字extends扩展了其超类之后，super用在扩展类
中引用其超类中的成员变量。
this

构造函数
Package为关键字，包名为标识符。
1.Package语句要作为程序非注释语句的第一行语句
2.包内的类名唯一
3.引用包中的类时，使用import语句。import语句的基本格式为import 包名.类名

接口：
Java禁止多继承属性，但可以通过接口来帮助类扩展方法.接口中可以定义大量的常量和方法,
但其中的方法只是一种声明,没有具体的实现,使用接口的类自己实现这些方法.
接口与类不同在于:
1.没有变量的声明,但可以定义常量.
2.只有方法的声明,没有方法的实现.

接口声明的基本格式:
public interface 接口名 extends 接口列表

Java源程序中可以有多个定义的类，但必须有一个主类，这个主类是Java程序运行的入口点。
主类为包含main方法的类：
在Java源程序中，主类的名字同文件名一致。
标识符，关键字，转义符
运算符和表达式

2的a次方
8 >> a

运算符
流程控制： 顺序 循环 选择
数组声明实际是创建一个引用，通过代表引用的这个名字来引用数组。

由于数组是对象，所以可以使用关键字new来创建一个数组。

new int[10]; //int[10]是一个类型。
数组创建时，每个元素都按它所存放数据类型的缺省值被初始化。

类
类声明：
例如： public class HelloApplet extends Applet
访问说明符 public
类名 HelloApplet
扩展类为 JDK 自带的java.applet.Applet类
由于public的存在，所以文件名必须为HelloApplet.java 同类名保持一致。
类体：
类体包括成员变量和方法
创建类的实例：
类的单继承性：extends关键字从有一个类扩展出一个新类，新类继承超类的成员变量和方法，并可以覆盖方法。
特殊变量： super和this
构造函数：类中的构造函数用来初始化一个类，构造函数为public类型，
用来从类实例中访问类时初始化此类的是一样变量； new object(参数1， 参数2, …);

包：包在物理上 就是一个文件夹，逻辑上代表一个分类的概念。
包就是指一组类。例如一个包名 叫Company的包，可以包含一组类，如Employee/Manager/Department等。
import 包名.类名

根据官方文档
如何在android平台 使用javaScript调用 Java方法？
答：使用反射机制。
使用cocoscreator中的 jsb.reflection 调用Java中的静态方法。
//参数即， 类名 方法名 方法签名
即： jsb.reflection.callStaticMethod(className, methodName, methodSignature, …);

javaScript 下调用Java代码，使得Java执行原生平台的功能：
gg.log(“现在我开始通过JavaScript调用 java的接口了”, jsb);
jsb.reflection.callStaticMethod(“org/cocos2dx/javascript/Test”, “hello”, “(Ljava/lang/String;)V”, “this is msg from js”);;
// 调用第一个sum方法
var result = jsb.reflection.callStaticMethod(“org/cocos2dx/javascript/Test”, “sum”, “(II)I”, 3, 7);
cc.log(result); //10

java下的类和类内的静态函数:
在org/cocos2dx/javascript路径下建立 org/cocos2dx/javascript/Test文件
建立Test类，类内定义三个static 函数。

一.CocosCreator的扩展编辑器
以包（package）的形式进行加载，扩展编辑器的功能。

①创建并安装扩展包：就是在项目路径下创建一个packages文件夹包含两个文件main.js和package.josn
package.json （包描述文件）来告诉编译器这个包来扩展什么。
包描述文件指定的main : main.js 是包的入口程序。入口程序会在CocosCreator的主进程中被加载，加载成功后，会调用入口程序的load函数。
并且会将定义在 messages 字段中的函数注册成 IPC 消息。

②全局扩展包/项目扩展包：它们存放的路径不一样。

③每个新开启的窗口就是 一个独立的渲染进程，每个进程独享自己的javaScript内容，彼此之间无法直接访问，如需访问则要进行IPC通讯。
CocosCreator的扩展包也分为主进程和渲染进程两部分：主进程的脚本程序main.js，用户界面是另一个渲染进程。

④扩展包工作流程模式：
入口程序完成全部工作。（main.js的load生命周期里 / 或者使用菜单项触发）
入口程序和编辑面板配合：就是主进程和渲染进程之间的通讯，Editor.Ipc.sendToPanel，Editor.Ipc.sendToMain

⑤插件只提供组件和资源：指的是扩展包可以作为组件和相关资源（如预制体、贴图、资源）的载体。

⑥扩展主菜单： package.json --> main-menu字段添加 菜单路径 和菜单选项
菜单专用菜单分类：插件专用的菜单分类路径是 i18n:MAIN_MENU.package.title, 在中文语言环境会显示为一级子菜单 “插件”，
接下来的二级菜单路径名应该是插件的包名，最后的三级路径是具体菜单项功能。
如：i18n:MAIN_MENU.package.title/FooBar/Bar

⑦扩展编辑器面板: package.json --> panel字段 添加面板的入口程序
如：
{
“name”: “simple-package”,
“panel”: {
“main”: “panel/index.js”,
…
}
定义入口程序：通过Editor.Panel.extend({…})函数来注册面板。参数是一个对象来描述这个面板。
// panel/index.js
Editor.Panel.extend({
});
通过在主进程中（入口程序）调用Editor.Panel.open(‘simple-package’)

使用udl文件获取数据库的连接字符串
如果我们在没有编译器的情况下，想获得数据库的连接地址，我们可以使用udl格式的文本来获取，非常方面简单；远程服务器的操作也一样，只是将代表本地服务器的.改变成ip地址。

js的函数：
//-- 第二个参数替换第一个参数
replace( ，要被替换文本或生成替换文本的函数) 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。
//-- 全局替换正则表达式中的+
gangFen[j] += parseInt(gangItem[j].replace(/＋/g, “”));

indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。返回-1表示没有找到。

js如何将变量作为对象的key？
答： 将取出的key用【】括起来
for (const key in keyItem) {
qpData[keyItem.strName].push({ [key] : keyItem[key] })
}

合并对象
var o1 = { a: 1 };
var o2 = { b: 2 };
var o3 = { c: 3 };

var obj = Object.assign(o1, o2, o3);
console.log(obj); // { a: 1, b: 2, c: 3 }
console.log(o1); // { a: 1, b: 2, c: 3 }, 注意目标对象自身也会改变。

cocoscreator 注册消息注册一次就可以了， 注册多次则会多次调用回调
this.jmAni.on(dragonBones.EventObject.COMPLETE, this.aniCallBackFunc.bind(this));

html 标记语言是一套标记标签，浏览器使用标签来解释内容。

html 元素：是指从开始标签（开放标签）到结束标签（闭合标签）之间的所有代码。
元素的 标签： 开始标签 结束标签
元素的 内容： 在两个标签之间，某些元素具有空内容。

大多数HTML元素可拥有属性。称为标签属性（总是在开始标签中添加 比如： 属性名 = “属性值”）。注意始终为属性值加引号。’"" ’
属性的例子：
对其方式：


背景颜色：
查找属性可以找 HTML标准属性参考手册

大多数HTML元素可以嵌套。

文档主体：
标题：

搜索引擎使用标题为网页内容和结构编制索引。
段落：


链接：a this is a link
图片：

空的元素（没有内容的元素称为空元素），空的元素是在开始标签中关闭的。
在开始标签中加/，是关闭空元素的正确方法。
换行：
元素是一个空的HTML元素，由于关闭标签没有意义，因此它没有结束标签。
水平线：

HTML标签对大小写不敏感。

注释： ctrl+?
鼠标右键：查看源文件，或查看网页源代码

在html代码中，所有的连续空格都将显示成一个空格。

html样式元素：html中元素的style属性，改变所有html样式的通用方法。
有若干的标签和属性将被废弃
背景颜色：

也可以是h1、body
字体、颜色、字的大小：

A paragraph.


居中对齐：

上面的标题相对于页面居中对齐。

文本格式化元素：
黑体：文本格式化黑体
定义加重语气：

斜体

subscript写在下方的，下标脚注
superscript标在上方的，上标

预格式文本元素：

 
  
 
  
这是
预格式文本。
它保留了      空格
和换行。

 
  
删除字效果和插入字效果：
  
 
  
html 引用元素：
  短的引用， 加引号
 
  
 
   
 长引用
 用于缩略词：WHO
 
  
var元素定义数学变量：
 
  
E = m c2

 code元素定义编程代码示例
  var per = {} 
 
  
html的样式表 CSS
 1.外部样式表：在中外部引入 
 2.内部样式表：中直接加入样式表