http://www.jetbrains.com/products.html

jetbrains 开发了多种语言的一系列的IDE：

http://www.jetbrains.com/products.html

WebStorm7 注册码：

User Name:

ninja911.com

1	ninja911.com

Licsense Key:

===== LICENSE BEGIN =====
53931-12042010
00001VQROnNeYqp6yrImItwg0Opa7U
68hDtCnR1uaFA7"k6Ufzkppi9dSwAv
8UahXQ7XHY3AHOZN6XSI"PUZch6Ji3
===== LICENSE END =====

===== LICENSE BEGIN =====

53931-12042010

00001VQROnNeYqp6yrImItwg0Opa7U

68hDtCnR1uaFA7"k6Ufzkppi9dSwAv

8UahXQ7XHY3AHOZN6XSI"PUZch6Ji3

===== LICENSE END =====

使用 idea 开发cpp

http://www.xinvalue.com/intellij-idea-develop-cpp.html

安装插件后要重启IDE哦

一、什么是嵌套类及内部类

可以在一个类的内部定义另一个类，这种类称为嵌套类（nested classes），它有两种类型：静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类（inner）。嵌套类从JDK1.1开始引入。其中inner类又可分为三种：
其一、在一个类（外部类）中直接定义的内部类；
其二、在一个方法（外部类的方法）中定义的内部类；
其三、匿名内部类。

下面，我将说明这几种嵌套类的使用及注意事项。

二、静态嵌套类

如下所示代码为定义一个静态嵌套类，

public class StaticTest {   
        private static String name = "javaJohn";　          
　　private String id = "X001";  
　　static class Person{  
　　　　private String address = "swjtu,chenDu,China";  
　　　　public String mail = "josserchai@yahoo.com";//内部类公有成员  
　　　　public void display(){  
　　　　　　//System.out.println(id);//不能直接访问外部类的非静态成员  
　　　　　　System.out.println(name);//只能直接访问外部类的静态成员  
　　　　　　System.out.println("Inner "+address);//访问本内部类成员。  
　　　　}  
　　}  

　　public void printInfo(){  
　　　　Person person = new Person();  
　　　　person.display();  
　　　　//System.out.println(mail);//不可访问  
　　　　//System.out.println(address);//不可访问  
　　　　System.out.println(person.address);//可以访问内部类的私有成员  
　　　　System.out.println(person.mail);//可以访问内部类的公有成员  

　　}  
　　public static void main(String[] args) {  
　　StaticTest staticTest = new StaticTest();  
　　staticTest.printInfo();  
}  
}

public class StaticTest {

private static String name = "javaJohn";　

　　private String id = "X001";

　　static class Person{

　　　　private String address = "swjtu,chenDu,China";

　　　　public String mail = "josserchai@yahoo.com";//内部类公有成员

　　　　public void display(){

　　　　　　//System.out.println(id);//不能直接访问外部类的非静态成员

　　　　　　System.out.println(name);//只能直接访问外部类的静态成员

　　　　　　System.out.println("Inner "+address);//访问本内部类成员。

　　　　}

　　public void printInfo(){

　　　　Person person = new Person();

　　　　person.display();

　　　　//System.out.println(mail);//不可访问

　　　　//System.out.println(address);//不可访问

　　　　System.out.println(person.address);//可以访问内部类的私有成员

　　　　System.out.println(person.mail);//可以访问内部类的公有成员

　　}

　　public static void main(String[] args) {

　　StaticTest staticTest = new StaticTest();

　　staticTest.printInfo();

}

在静态嵌套类内部，不能访问外部类的非静态成员，这是由Java语法中”静态方法不能直接访问非静态成员”所限定。若想访问外部类的变量，必须通过其它方法解决，由于这个原因，静态嵌套类使用很少。注意，外部类访问内部类的的成员有些特别，不能直接访问，但可以通过内部类来访问，这是因为静态嵌套内的所有成员和方法默认为静态的了。同时注意，内部静态类Person只在类StaticTest 范围内可见，若在其它类中引用或初始化，均是错误的。

三、在外部类中定义内部类

如下所示代码为在外部类中定义两个内部类及它们的调用关系：

public class Outer {   
         　　int outer_x = 100;  
　　　　class Inner{  
　　　　　　public int y = 10;  
　　　　　　private int z = 9;  
　　　　　　int m = 5;  
　　　　　　public void display(){  
　　　　　　　　System.out.println("display outer_x:"+ outer_x);  
　　　　　　}  
　　　　　　private void display2(){  
　　　　　　　　System.out.println("display outer_x:"+ outer_x);  
　　　　　　}  
　　　　}  
　　　　void test(){  
　　　　　　Inner inner = new Inner();  
　　　　　　inner.display();  
　　　　　　inner.display2();  
　　　　　　//System.out.println("Inner y:" + y);//不能访问内部内变量  
　　　　　　System.out.println("Inner y:" + inner.y);//可以访问  
　　　　　　System.out.println("Inner z:" + inner.z);//可以访问  
　　　　　　System.out.println("Inner m:" + inner.m);//可以访问  
　　　　　　InnerTwo innerTwo = new InnerTwo();  
　　　　　　innerTwo.show();  
　　　　}  
　　　　class InnerTwo{  
　　　　　　Inner innerx = new Inner();  
　　　　　　public void show(){  
　　　　　　　　//System.out.println(y);//不可访问Innter的y成员  
　　　　　　　　//System.out.println(Inner.y);//不可直接访问Inner的任何成员和方法  
　　　　　　　　innerx.display();//可以访问  
　　　　　　　　innerx.display2();//可以访问  
　　　　　　　　System.out.println(innerx.y);//可以访问  
　　　　　　　　System.out.println(innerx.z);//可以访问  
　　　　　　　　System.out.println(innerx.m);//可以访问  
　　　　　　}  
　　　　}  
　　　　public static void main(String args[]){  
　　　　　　Outer outer = new Outer();  
　　　　　　outer.test();  
　　　　}  
　　} 
}

public class Outer {

　　int outer_x = 100;

　　　　class Inner{

　　　　　　public int y = 10;

　　　　　　private int z = 9;

　　　　　　int m = 5;

　　　　　　public void display(){

　　　　　　　　System.out.println("display outer_x:"+ outer_x);

　　　　　　}

　　　　　　private void display2(){

　　　　　　　　System.out.println("display outer_x:"+ outer_x);

　　　　　　}

　　　　void test(){

　　　　　　Inner inner = new Inner();

　　　　　　inner.display();

　　　　　　inner.display2();

　　　　　　//System.out.println("Inner y:" + y);//不能访问内部内变量

　　　　　　System.out.println("Inner y:" + inner.y);//可以访问

　　　　　　System.out.println("Inner z:" + inner.z);//可以访问

　　　　　　System.out.println("Inner m:" + inner.m);//可以访问

　　　　　　InnerTwo innerTwo = new InnerTwo();

　　　　　　innerTwo.show();

　　　　}

　　　　class InnerTwo{

　　　　　　Inner innerx = new Inner();

　　　　　　public void show(){

　　　　　　　　//System.out.println(y);//不可访问Innter的y成员

　　　　　　　　//System.out.println(Inner.y);//不可直接访问Inner的任何成员和方法

　　　　　　　　innerx.display();//可以访问

　　　　　　　　innerx.display2();//可以访问

　　　　　　　　System.out.println(innerx.y);//可以访问

　　　　　　　　System.out.println(innerx.z);//可以访问

　　　　　　　　System.out.println(innerx.m);//可以访问

　　　　　　}

　　　　public static void main(String args[]){

　　　　　　Outer outer = new Outer();

　　　　　　outer.test();

　　　　}

以上代码需要说明有，对于内部类，通常在定义类的class关键字前不加public 或 private等限制符，若加了没有任何影响，同时好像这些限定符对内部类的变量和方法也没有影响（？）。另外，就是要注意，内部类Inner及InnterTwo只在类Outer的作用域内是可知的，如果类Outer外的任何代码尝试初始化类Inner或使用它，编译就不会通过。同时，内部类的变量成员只在内部内内部可见，若外部类或同层次的内部类需要访问，需采用示例程序中的方法，不可直接访问内部类的变量

PHP中类的初始化

在JAVA中有如下代码：

public class Test {
    static {
        _i = 10;
    }
    public static int _i;

    public static void main(String[] args) {
        System.out.println(_i);
    }
}

public class Test {

static {

_i = 10;

}

public static int _i;

public static void main(String[] args) {

System.out.println(_i);

}

PHP中没有static块儿的概念，可以如下实现：

<?php

class Test{
	private static $init_ok = 0;
	private static $data;
	public static function class_init() {
		if (!self::$init_ok) {
			self::$data = array(/*.... */);
		}
	}
}
Test::class_init();

<?php

class Test{

private static $init_ok = 0;

private static $data;

public static function class_init() {

if (!self::$init_ok) {

self::$data = array(/*.... */);

}

Test::class_init();

参考资料： http://blog.csdn.net/darxin/article/details/5293427

理解JAVASCRIPT 中hasOwnProperty()的作用

【转载】http://hj149.javaeye.com/blog/505237

hasOwnProperty：是用来判断一个对象是否有你给出名称的属性或对象。不过需要注意的是，此方法无法检查该对象的原型链中是否具有该属性，该属性必须是对象本身的一个成员。格式如下：

Js代码

1. object.hasOwnProperty(proName);

判断proName的名称是不是object对象的一个属性或对象。

1. 示例一：

var bStr = “Test String”.hasOwnProperty(“split”); // 得到false，因为不能检测原型链中的属性

但是：

“Test String”.split(” “);是能成功调用的
2.示例二：

var bStr1 = String.prototype.hasOwnProperty(“split”); //String对象的原型上本来就有这个属性,自然返回true
3. 示例三

var bObj = ({fnTest:function(){}}).hasOwnProperty(“fnTest”); // 返回true，因为对象中属性存在

Object 对象

Object 对象自身用处不大，不过在了解其他类之前，还是应该了解它。因为 ECMAScript 中的 Object 对象与 Java 中的 java.lang.object 相似，ECMAScript 中的所有对象都由这个对象继承而来，Object 对象中的所有属性和方法都会出现在其他对象中，所以理解了 Object 对象，就可以更好地理解其他对象。

Object 对象具有下列属性：

constructor
对创建对象的函数的引用（指针）。对于 Object 对象，该指针指向原始的 Object() 函数。
Prototype
对该对象的对象原型的引用。对于所有的对象，它默认返回 Object 对象的一个实例。

Object 对象还具有几个方法：

hasOwnProperty(property)
判断对象是否有某个特定的属性。必须用字符串指定该属性。（例如，o.hasOwnProperty(“name”)）
IsPrototypeOf(object)
判断该对象是否为另一个对象的原型。
PropertyIsEnumerable
判断给定的属性是否可以用 for…in 语句进行枚举。
ToString()
返回对象的原始字符串表示。对于 Object 对象，ECMA-262 没有定义这个值，所以不同的 ECMAScript 实现具有不同的值。
ValueOf()
返回最适合该对象的原始值。对于许多对象，该方法返回的值都与 ToString() 的返回值相同

关于cookie的数量测试

测试目的：

浏览器最多允许的cookie的个数是多少？子域与父域之间的关系？

实验器材

1. chrome浏览器

测试方法

关于html5本地存储

缘起

localstorage

以chrome为例，localstorage的存储如下：

存储位置： %appdata%\Local\Google\Chrome\User Data\Default\Local Storage\*

使用sqlite命令查看如下：

sqlite3 http_open.weibo.com_0.localstorage 
SQLite version 3.3.6
Enter ".help" for instructions
sqlite> .schema
CREATE TABLE ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB NOT NULL ON CONFLICT FAIL);
sqlite> select * from ItemTable;
name|phpor
sqlite>

sqlite3 http_open.weibo.com_0.localstorage

SQLite version 3.3.6

Enter ".help" for instructions

sqlite> .schema

CREATE TABLE ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB NOT NULL ON CONFLICT FAIL);

sqlite> select * from ItemTable;

name|phpor

sqlite>

大小限制： 5M

参考资料:

http://www.html5china.com/HTML5features/LocalStorage/20110926_2022.html

http://blog.csdn.net/gointoit/article/details/9151629

http://blog.csdn.net/yhawaii/article/details/7246106

http://www.iteye.com/magazines/62-html5-local-storage

关于代理

一、 http代理服务器代理https请求（这个就是http隧道吧）

1）打开连接

CONNECT passport.sina.cn:443 HTTP/1.1
Host: passport.sina.cn
Proxy-Connection: keep-alive
User-Agent: Mozilla/5.0 (Linux; Android 4.1.1; MI 2 Build/JRO03L) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/30.0.1599.92 Mobile Safari/537.36

HTTP/1.1 200 Connection Established
FiddlerGateway: Direct
StartTime: 20:01:27.916
Connection: close

2）开始ssl握手(其实下面可以是任何的其他协议）

…

当使用CONNECT 时，代理服务器就只负责建立一个tcp连接通道，不再关心上层是什么协议了

二、普通的http代理

> GET http://phpor.net/test.php HTTP/1.1
> User-Agent: curl/7.15.5 (x86_64-redhat-linux-gnu) libcurl/7.15.5 OpenSSL/0.9.8b zlib/1.2.3 libidn/0.6.5
> Host: login.sina.com.cn
> Pragma: no-cache
> Accept: */*
> Proxy-Connection: Keep-Alive
>
< HTTP/1.1 200 OK
< Date: Fri, 15 Nov 2013 12:15:40 GMT
< Server: Apache

Memcache 的两个参数

1. -k 参数禁止memcached使用swap；参考资料： http://blog.csdn.net/zzmfish/article/details/6666373 相关系统函数mlock

2. -I参数，允许指定大于或小于1m的page大小，最小1k，最大128M

-I Override the size of each slab page. Adjusts max item size
(default: 1mb, min: 1k, max: 128m)

小米2下的chrome调试

缘起

pc上的网页元素调试的软件很多，用起来也很方便，比如: firebug/IE的开发者工具/chrome的开发者工具等；但是手机上就没这么方便了，好在chrome提供了一个pc上调试手机chrome浏览器页面的功能，虽然只是调试chrome浏览器，但是比没有强多了，赶快试试吧…

实验材料

1. 安装了chrome浏览器的手机一部

2. 安装了chrome浏览器的电脑一台，电脑chrome浏览器上安装adb plugin插件

理论上来讲：

1. 手机上开启调试

2. chrome插件点击“start adb”

3. chrome插件中就能看到自己的手机了

但是，事情如果这么顺利就不会写这篇blog了，且看下面问题

问题

1. chrome插件中看不到我的手机

开始折腾：

1. 我曾经安装过adroid的一套开发工具，用adb devices看看能不能看到我的手机；结果显示adb服务没有响应，而且也杀不死。查了一下：adb服务的端口 5037 是被腾讯的tadb.exe给侦听了，于是，杀死tadb.exe，似乎比较正常了，但是还是看不到我的小米2；上网搜了一通，都说是安装驱动程序，安装之后还是不行，最后，是这篇博文说到了点子上了： http://bbs.xiaomi.cn/forum.php?mod=viewthread&tid=8435974 ；现在adb可以看到我的小米2 了；但是chrome插件还是看不到小米2

2. 当我把adb服务停掉之后，从chrome插件启动adb，得知插件自带了一个adb.exe，但是插件目录中却没有出现adb_usb.ini 文件，尝试把正确的adb_usb.ini 放到了adb.exe 旁边，再次从插件启动adb，我的小米2有反应了，然后插件中也能看到我的小米2了

3. 开始调试网页，一切OK了

文本与二进制方式打开文件的区别

Windows平台下
如果以“文本”方式打开文件，当读取文件的时候，系统会将所有的”/r/n”转换成”/n”；当写入文件的时候，系统会将”/n”转换成”/r/n”写入。
如果以”二进制”方式打开文件，则读/写都不会进行这样的转换。

在Unix/Linux平台下

“文本”与“二进制”模式没有区别。

数据有字符型和非字符型（数）两种。按文本方式写文件指的是将数据转换为对应的字符型数据之后再写入文件。对于字符型数据，由于其本身就是ASCII码字符，一般不必转换，直接写入文件。但是，由于不同的系统对于换行符（’/n’）有不同的处理（转换）方式，在有的系统（如Windows）下也会对 ‘/n’ 作适当的转换。

对于非字符型数据，都要进行转换处理。例如：int m = 12; 以及 double f = 2.3;，分别按照 “%d”、”%lf” 方式将 m 和 f 写入文件的时候，写入的分别是 ‘1’、’2′ 两个字符以及 ‘2’、’.’、’3′ 等三个字符的ASCII码值。显然，如果按照二进制方式写的话，在文件中一般 m 要占 4 个字节、f 要占 8 个字节。

一、文本文件与二进制文件的定义
大家都知道计算机的存储在物理上是二进制的，所以文本文件与二进制文件的区别并不是物理上的，而是逻辑上的。这两者只是在编码层次上有差异。
简单来说，文本文件是基于字符编码的文件，常见的编码有ASCII编码，UNICODE编码等等。二进制文件是基于值编码的文件，你可以根据具体应用，指定某个值是什么意思（这样一个过程，可以看作是自定义编码）。
从上面可以看出文本文件基本上是定长编码的(也有非定长的编码如UTF-8)，基于字符嘛，每个字符在具体编码中是固定的，ASCII码是8个比特的编码，UNICODE一般占16个比特。而二进制文件可看成是变长编码的，因为是值编码嘛，多少个比特代表一个值，完全由你决定。大家可能对BMP文件比较熟悉，就拿它举例子吧，其头部是较为固定长度的文件头信息，前2字节用来记录文件为BMP格式，接下来的8个字节用来记录文件长度，再接下来的4字节用来记录bmp文件头的长度。。。大家可以看出来了吧，其编码是基于值的（不定长的，2、4、8字节长的值都有），所以BMP是二进制文件。

二、文本文件与二进制文件的存取
文本工具打开一个文件的过程是怎样的呢？拿记事本来说，它首先读取文件物理上所对应的二进制比特流（前面已经说了，存储都是二进制的），然后按照你所选择的解码方式来解释这个流，然后将解释结果显示出来。一般来说，你选取的解码方式会是ASCII码形式（ASCII码的一个字符是８个比特），接下来，它8个比特8个比特地来解释这个文件流。例如对于这么一个文件流”01000000_01000001_01000010_01000011″(下划线”_”，是我为了增强可读性，而手动添加的)，第一个8比特”01000000”按ASCII码来解码的话，所对应的字符是字符”A”，同理其它3个8比特可分别解码为”BCD”，即这个文件流可解释成“ABCD”，然后记事本就将这个“ABCD”显示在屏幕上。
事实上，世界上任何东西要与其他东西通信会话，都存在一个既定的协议，既定的编码。人与人之间通过文字联络，汉字“妈”代表生你的那个人，这就是一种既定的编码。但注意到这样一种情况，汉字“妈”在日本文字里有可能是你生下的那个人，所以当一个中国人Ａ与日本Ｂ之间用“妈”这个字进行交流，出现误解就很正常的。用记事本打开二进制文件与上面的情况类似。记事本无论打开什么文件都按既定的字符编码工作（如ASCII码），所以当他打开二进制文件时，出现乱码也是很必然的一件事情了，解码和译码不对应嘛。例如文件流”00000000_00000000_00000000_00000001”可能在二
进制文件中对应的是一个四字节的整数int 1，在记事本里解释就变成了”NULL_NULL_NULL_SOH”这四个控制符。
文本文件的存储与其读取基本上是个逆过程，不再累述。而二进制文件的存取显然与文本文件的存取差不多，只是编／解码方式不同而已，也不再叙述。

三、文本文件与二进制文件的优缺点
因为文本文件与二进制文件的区别仅仅是编码上不同，所以他们的优缺点就是编码的优缺点，这个找本编码的书来看看就比较清楚了。一般认为，文本文件编码基于字符定长，译码容易些；二进制文件编码是变长的，所以它灵活，存储利用率要高些，译码难一些（不同的二进制文件格式，有不同的译码方式）。关于空间利用率，想想看，二进制文件甚至可以用一个比特来代表一个意思(位操作)，而文本文件任何一个意思至少是一个字符．
很多书上还认为，文本文件的可读性要好些，存储要花费转换时间(读写要编译码)，而二进制文件可读性差，存储不存在转换时间（读写不要编解码，直接写值）．这里的可读性是从软件使用者角度来说的，因为我们用通用的记事本工具就几乎可以浏览所有文本文件，所以说文本文件可读性好；而读写一个具体的二进制文件需要一个具体的文件解码器，所以说二进制文件可读性差，比如读BMP文件，必须用读图软件．而这里的存储转换时间应该是从编程的角度来说的，因为有些操作系统如windows需要对回车换行符进行转换(将”/n”，换成”/r/n”，所以文件读写时，操作系统需要一个一个字符的检查
当前字符是不是”/n”或”/r/n”).这个在存储转换在Linux操作系统中并不需要，当然，当在两个不同的操作系统上共享文件时，这种存储转换又可能出来(如Linux系统和Windows系统共享文本文件)。

四、Ｃ的文本读写和二进制读写
应该说Ｃ的文本读写与二进制的读写是一个编程层次上的问题，与具体的操作系统有关，所以＂用文本方式读写的文件一定是文本文件，用二进制读写的文件一定是二进制文件”这类观点是错误的．下面的讲述非明确指出操作系统类型，都暗指windows．
Ｃ的文本方读写与二进制读写的差别仅仅体现在回车换行符的处理上．文本方式写时，每遇到一个”/n”(0AH换行符)，它将其换成”/r/n”(0D0AH，回车换行)，然后再写入文件；当文本读取时，它每遇到一个”/r/n”将其反变化为”/n”，然后送到读缓冲区．正因为文本方式有”/n”－－”/r/n”之间的转换，其存在转换耗时．二进制读写时，其不存在任何转换，直接将写缓冲区中数据写入文件．
总地来说，从编程的角度来说，Ｃ中文本或二进制读写都是缓冲区与文件中二进制流的交互，只是文本读写时有回车换行的转换．所以当写缓冲区中无换行符”/n”(0AH)，文本写与二进制写的结果是一样的，同理，当文件中不存在”/r/n”(0DH0AH)时，文本读与二进制读的结果一样．
五、实例
5678的存储形式为：ASCII码：　00110101 00110110 00110111 00111000 （四个字节）
5678的存储形式为：二进制： 00010110 00101110 （两个字节）
二进制文件和文本文件的唯一差异就是前者含有一些非标准输出的ASCII码。0x01就是非标准输出的ASCII码，0x61就是标准输出的ASCII码。）