当程序需要将值保存起来以备将来使用时，便将其赋值给一个变量，值的类型称作数据类型。
 
变量
 
JavaScript 的变量是松散类型的，所谓松散类型就是可以用来保存任何类型的数据。换句话说，每个变量仅仅是一个用于保存值的占位符而已。定义变量时要使用关键字 var 来声明的，如下所示：
 
var message;
 
这行代码定义了一个名为 message 的变量，该变量可以用来保存任何值（像这样未经过初始化的变量，会保存一个特殊的值 undefined）。JavaScript 也支持直接初始化变量，因此在定义变量的同时就可以设置变量的值，如下所示：
 
var message = "hello";
 
此时，变量 message 中保存了一个字符串值 "hello"。像这样初始化变量并不会把它标记为字符串类型，因此，可以在修改变量值的同时修改值的类型。如下所示：
 
var message = "hello";
message = 100;           // 有效的语句，不好的写法
 
在这个例子中，变量 message 一开始保存了一个字符串值 "hello"，然后该值又被一个数字值100取代。虽然我们不建议修改变量所保存值的类型，但这种操作在 JavaScript 中完全有效。
 
有一点必须注意，即使用 var 运算符定义的变量是的该作用域中的局部变量。也就是说，如果在函数中使用 var 定义一个变量，那么这个变量在函数退出后就会被销毁，例如：
 
function test(){
    var message = "hello";  // 局部变量
}
test();
console.log(message);   // 产生错误
 
这里，变量 message 是在函数中使用 var 定义的，是局部变量。当函数被调用时，就会创建该变量并为其赋值。而在此之后，这个变量又会立即被销毁，因此例子中的下一行代码就会导致错误。不过，可以像下面这样省略 var 运算符，从而创建一个全局变量：
 
function test(){
    message = "hello";  // 全局变量，不好的写法
}
test();
console.log(message);   // "hello"
 
这个例子省略了 var 运算符，因而 message 就成了全局变量。这样，只要调用一次 test() 函数，这个变量就有了定义，就可以在函数外部的任何地方被访问到。
 
虽然省略 var 运算符可以定义全局变量，但这也不是推荐的做法，因为在局部作用域中定义全局变量很难维护，给未经声明的变量赋值在严格模式下会抛出 ReferenceError 错误。
 
数据类型
 
JavaScript 中有5种简单数据类型（也称为「基本数据类型」或「原始数据类型」）：Undefined、Null、Boolean、Number、String 。还有1种复杂数据类型 Object，Object 本质上是由一组无序的名值对组成的。JavaScript 不支持任何创建自定义类型的机制，所有值最终都将是上述6种数据类型之一。
 
typeof 运算符
 
鉴于 JavaScript 是松散类型的，因此需要有一种手段来检测给定变量的数据类型，typeof 就是负责提供这方面信息的运算符。对一个值使用 typeof 运算符可能返回下列某个字符串：
 
"undefined"，如果这个值未声明或已声明但未初始化。
"boolean"，如果这个值是布尔值。
"string"，如果这个值是字符串。
"number"，如果这个值是数值。
"object"，如果这个值是对象或 null。
"function"，如果这个值是函数。
 
下面是几个使用 typeof 运算符的例子：
 
var message = "some string";
console.log(typeof message);     // "string"
console.log(typeof(message));    // "string"
console.log(typeof 95);          // "number"
 
从以上例子可以看出，typeof 运算符既可以对变量使用，又可以对字面量使用。由于 typeof 是一个运算符而不是函数，因此例子中的圆括号尽管可以使用，但并不提倡。
 
typeof null 结果是 "object" 是历史遗留 Bug，在 ECMAScript 6中，曾经有提案为历史平反, 将 type null 的值纠正为 "null"，但最后该提案被拒。理由是历史遗留代码太多，不如继续将错就错。
 
从技术角度讲，函数在 JavaScript 中是对象，不是一种数据类型。然而，函数也确实有一些特殊的属性，因此通过 typeof 运算符来区分函数和其他对象是有必要的。
 
 
 
扩展阅读「为什么 JavaScript 里面 typeof null 的值是 "object"？」 
 https://www.zhihu.com/question/21691758
 
 
扩展阅读「MDN 之 typeof」 
 https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/typeof
 
 
扩展阅读「JavaScript 检测原始值、引用值、属性」 
 http://shijiajie.com/2016/06/20/javascript-maintainable-javascript-validate1/
 
 
扩展阅读「JavaScript 检测之 basevalidate.js」 
 http://shijiajie.com/2016/06/25/javascript-maintainable-javascript-basevalidatejs/
 
 
Undefined 类型
 
Undefined 类型只有1个值，即 undefined。使用 var 声明变量但未对其加以初始化时，这个变量的值就是 undefined，直接使用未声明的变量会产生错误。对未声明或已声明但未初始化的变量执行 typeof 运算符会返回 "undefined" 值，例如：
 
var message;    // 这个变量声明之后默认取得了 undefined 值
// var age      // 这个变量并没有声明

console.log(message);           // "undefined"
console.log(age);               // 产生错误
console.log(typeof message);    // "undefined"
console.log(typeof age);        // "undefined"
 
Null 类型
 
Null 类型也只有1个值，即 null。它用来表示值的空缺。你可以认为 undefined 是表示系统级的、出乎意料的或类似错误的值的空缺，而 null 是表示程序级的、正常的或在意料之中的值的空缺。在下列场景中应当使用 null。
 
用来初始化一个变量，这个变量可能赋值为一个对象。
用来和一个已经初始化的变量比较，这个变量可以是也可以不是一个对象。
当函数的参数期望是对象时，作用参数传入。
当函数的返回值期望是对象时，作用返回值传出。
 
在下列场景中不应当使用 null。
 
不要使用 null 来检测是否传入了某个参数。
不要使用 null 来检测一个未初始化的变量。
 
Boolean 类型
 
Boolean 类型是 JavaScript 中使用得最多的一种类型，该类型只有两个字面值：true 和 false。需要注意的是，他们是区分大小写的，也就是说 True 和 False（以及其他的混合大小写形式）都不是 Boolean 值，只是标识符。
 
虽然 Boolean 类型的字面值只有两个，但 JavaScript 中所有类型的值都能使用 if 语句或 Boolean() 函数转换为对应的 Boolean 值，例如：
 
var message = "Hello world!";
if (message){
    console.log("Value is true.");  // 被执行
}
var messageAsBoolean = Boolean(message);
console.log(messageAsBoolean);  // true
 
下表给出了各种数据类型及其对应的转换规则。
 
数据类型
转换为true的值
转换为false的值
Undefined
-
undefined
Null
-
null
Boolean
true
false
String
任何非空字符串
“”（空字符串）
Number
任何非零数字值（包括无穷大）
0和NaN
Object
任何对象
-
 
Number 类型
 
Number 类型是 JavaScript 中最令人关注的数据类型，这种类型使用 IEEE 754 格式来表示整数和浮点数值（浮点数值在某些语言中也被称为双精度数值）。和其他编程语言不同，JavaScript 中的所有数字均用浮点数值表示。
 
 
 
扩展阅读「IEEE 754-1985」 
 https://en.wikipedia.org/wiki/IEEE_754-1985
 
 
整数
 
在 JavaScript 中进行算术计算时，所有以八进制和十六进制表示的数值最终都将被转换成十进制数值。例如：
 
var a = 10;         // 十进制
var b = 023;        // 八进制
var c = 0x12ac;     // 十六进制
console.log(b);     // 19
console.log(c);     // 4780
 
八进制第一位必须是0，后面跟八进制序列0到7，如果超出了范围，则忽略前导0，后面的数值当做十进制解析，例如：089会被解析为89。（八进制字面量在严格模式下是无效的，会抛出错误。）
 
十六进制前两位必须是 0x 或 0X，后跟十六进制序列0~9、a~f（不区分大小写），如果超出了范围，则会报语法错误。
 
浮点数
 
所谓浮点数值，就是该数值中必须包含一个小数点，并且小数点后面必须至少有一位数字。虽然小数点前面可以没有整数，但我们不推荐这种写法。例如：
 
var a = 1.1;
var b = 0.1;
var c = .1;     // 有效，但不推荐
 
JavaScript 会不失时机的将浮点数转换成整数。例如：
 
var a = 5.;      // 解析成整数5
var b = 5.0;     // 解析成整数5
 
对于极大或者极小的数值，可采用科学技术法（也称e表示法）。JavaScript 会将那些小数点后面带有6个零以上的小于1的浮点数值转换为以e表示法表示的数值。例如：
 
var a = 3.14e7;             // 等于31400000
var b = 3.14E-7;            // 等于0.000000314
console.log(0.0000003);     // 3e-7
 
浮点数值的最高精度是17位小数，但在进行算术计算时其精确度远远不如整数，例如：
 
console.log(0.1 + 0.2);     // 0.30000000000000004
 
这个舍入误差会导致无法测试特定的浮点数值，因此，永远不要测试某个特定的浮点数值。
 
正无穷、负无穷
 
由于内存限制，JavaScript 能表示的数值范围从 Number.MIN_VALUE 到 Number.MAX_VALUE，并将超出范围的数转换成 Number.POSITIVE_INFINITY 或 Number.NEGATIVE_INFINITY。0作为除数是不会报错的，正数除以0返回正无穷，负数除以0返回负无穷，0除以0返回NaN。例如：
 
console.log(Number.MAX_VALUE);       // 最大数 1.7976931348623157e+308
console.log(Number.MIN_VALUE);       // 最小数 5e-324

console.log(Number.POSITIVE_INFINITY);    // 正无穷  Infinity
console.log(Number.NEGATIVE_INFINITY);    // 负无穷 -Infinity

console.log( 1 / 0);     //  Infinity
console.log(-1 / 0);     // -Infinity
 
JavaScript 提供了 isFinite() 函数，来确定一个数是不是有穷的。例如：
 
console.log(isFinite(100));         // true
console.log(isFinite(Infinity));    // false 
 
NaN
 
NaN（not a number），是一个特殊的数值。之所以称它为「非数值」，是因为它不能参与算数运算，任何涉及 NaN 的操作都返回 NaN。并且 NaN 与任何值都不相等（包括自身）。例如：
 
console.log(typeof NaN);      // "number"

console.log(0 / 0);                 // NaN
console.log(NaN - NaN);             // NaN
console.log(Infinity - Infinity);   // NaN

var a = NaN;
console.log(a === a);   // false
 
JavaScript 提供了 isNaN() 函数，来确定一个数是不是 NaN。例如：
 
console.log(isNaN(100));        //  false
console.log(isNaN("100"));      //  false
console.log(isNaN(true));       //  false
console.log(isNaN("sss"));      //  true
console.log(isNaN(NaN));        //  true
 
Number()、parseInt()、parseFloat() 转型函数
 
isNaN() 函数在接收到一个值之后，会尝试使用转型函数 Number() 将这个值转换为数值，转换规则如下：
 
undefined 转换为 NaN；
null 转换为 0；
true 转换为 1、false 转换为 0；
number 整数转换为十进制，小数不变；
string 如果只包含十进制数和小数，则返回对应的数值，如果只包含八进制数，则忽略前导0返回剩余部分，如果只包含十六进制，则返回十进制数，空字符串转换为0，其它字符串转换为 NaN；
object 先则调用对象的 valueOf() 方法，然后依照前面的规则转换返回的值。如果转换的结果是 NaN，则调用对象的 toString() 方法，然后再次依照前面的规则转换返回的字符串值。
 
由于 Number() 转型函数在转换字符串时不够理想，因此还有两个专门用来转换字符串的函数 parseInt() 和 parseFloat() 函数。
 
parseInt() 函数会忽略字符串前面的空格，直至找到第一个非空格字符，只要第一个非空格字符不是数字或者正负号，一律返回 NaN， 如果第一个非空格字符是数字字符，parseInt() 会继续解析第二个字符，直到解析完所有后续字符或者遇到了一个非数字字符。例如：
 
console.log(parseInt(""));          // NaN（Number("")返回 0）
console.log(parseInt("123S"));      // 123
console.log(parseInt("12.4"));      // 12
 
parseFloat() 函数也会忽略字符串前面的空格，直至找到第一个非空格字符，只要第一个非空格字符不是数字或者正负号或者小数点，一律返回 NaN， 如果第一个非空格字符是上述字符之一，parseFloat() 会继续解析第二个字符，直到解析完所有后续字符或者遇到了一个非浮点数值。例如：
 
console.log(parseFloat("098.2"));       // 98.2
console.log(parseFloat("123.23.23"));   // 123.23
 
String 类型
 
String 类型用于表示由零或多个16位 Unicode 字符组成的字符序列，即字符串。字符串可以由双引号（”）或单引号（’）表示，因此下面两种字符串的写法都是有效的：
 
var firstName = "Nicholas";
var lastName = 'Zakas';
 
JavaScript 中的这两种语法形式没有什么区别。用双引号表示的字符串和用单引号表示的字符串完全相同。不过，以双引号开头的字符串也必须以双引号结尾，而以单引号开头的字符串必须以单引号结尾。
 
String 数据类型包含一些特殊的字符字面量，也叫转义序列，用于表示非打印字符，或者具有其他用途的字符。例如：\n 换行、\t 制表、\b 空格、\r 回车、\f 进纸、\\ 斜杠、\' 单引号，在用单引号表示的字符串中使用、\" 双引号，在用双引号表示的字符串中使用。
 
转义字符可出现在字符串中的任意位置，且长度为1。如要在字符串中显示 \ ，则必须使用 \ 进行转义。例如：
 
console.log("\n\\".length);    // 2
console.log("\\hello");        // "\hello"（长度为6）
 
大部分值都可以使用继承而来的 toString()方法转换为字符串，但 undefined 和 null 值没有这个方法。对数值使用 toString() 方法时，可以传入一个数字基数，以此输出对应进制的字符串值。例如：
 
console.log(true.toString());   // "true"

var num = 10;
console.log(num.toString());    // "10"
console.log(num.toString(2));   // "1010"
console.log(num.toString(8));   // "12"
console.log(num.toString(16));  // "a"
 
在不知道要转换的值是不是 undefined 或 null 的情况下，还可以使用转型函数 String()，这个函数能够将任何类型的值转换为字符串。String() 函数遵循下列转换规则：
 
如果值有 toString() 方法，则调用该方法（没有参数）并返回相应的结果；
如果值是 undefined，则返回 "undefined"；
如果值是 null，则返回 "null"。
 
var value;
console.log(String(10));        // "10"
console.log(String(true));      // "true"
console.log(String(null));      // "null"
console.log(String(value));     // "undefined"
 
Object 类型
 
JavaScript 中所有对象都继承自 Object 类型，每个对象都具有下列基本的属性和方法：
 
constructor：保存着用于创建当前对象的函数（构造函数）。
hasOwnProperty()：用于检查给定的属性在当前对象实例中是否存在。
propertyIsEnumerable()：用于检查给定的属性是否能够使用for-in语句来枚举。
isPrototypeOf()：用于检查对象是否是传入对象的原型。
toString() 方法：返回对象的字符串表示。
toLocaleString()：返回对象的本地字符串表示。
valueOf()：返回对象的字符串、数值或布尔值表示（通常与toString()方法的返回值相同）。
 
Object 本质上是由一组无序的名值对组成，「名称」部分是一个 JavaScript 字符串，「值」部分可以是任何 JavaScript 的数据类型（包括对象和方法）。这使用户可以根据具体需求，创建出相当复杂的数据结构。
 
以下两种方法都可以创建一个空对象，这两种方法在语义上是相同的。第二种更方便的方法叫作「对象字面量」法。这也是 JSON 格式的核心语法，一般我们优先选择第二种方法。例如：
 
var obj = new Object();
var obj = {};   // 好的写法
 
「对象字面量」也可以用来在对象实例中定义一个对象：
 
var obj = {
    name: "Carrot",
    "for": "Max",
    details: {
        color: "orange",
        size: 12
    }
}
 
对象的属性可以通过链式（chain）表示方法进行访问：
 
obj.details.color;       // orange
obj["details"]["size"];  // 12
 
完成创建后，对象属性可以通过如下两种方式进行赋值和访问：
 
obj.name = "Simon"      // 赋值
var name = obj.name;    // 访问

obj["name"] = "Simon";  // 赋值
var name = obj["name"]; // 访问
 
关卡
 
// 挑战一
console.log(typeof "undefined");  // ???
console.log(typeof null);         // ???
 
// 挑战二
var message = "some string";
console.log(typeof massage);    // ???
message = 10000;
console.log(typeof message);    // ???
 
// 挑战三
var a;
var b = null;
var c = {};
if(a && b && c){
    console.log("true.");       // ???
}else{
    console.log("false.");      // ???
}
 
// 挑战四
console.log(typeof (0 / 0));    // ???
console.log(023 + 123);         // ???
 
// 挑战五
console.log(Number("1234S"));   // ???
console.log(parseInt("1234S")); // ???
 
// 挑战六
console.log(3.14E-7 === 0.000000314);   // ???
console.log(0.1 + 0.6 === 0.7); // ???
console.log(0.1 + 0.7 === 0.8); // ???
console.log(NaN === NaN);       // ???
 
// 挑战七
console.log("\right\now");          // ???
console.log("\right\now".length);   // ???
console.log(010.toString(2));       // ???
 
// 挑战八
// 1、为 person、wife、child 对象新增 weight 属性，数值分别为 62、36、15。
// 2、为 person 对象新增二胎 child2 子对象，name 为 emma，其他属性自行发挥。
var person = {
    name: "stone",
    age: 30,
    wife: {
        name: "sohpie",
        age: 30
    },
    child:{
        name: "tommy",
        age: 3
    }
}
 
 
 
挑战九，深度阅读下面两篇文章，提出你的疑问。
 
 
「JavaScript 检测原始值、引用值、属性」 
 http://shijiajie.com/2016/06/20/javascript-maintainable-javascript-validate1/
 
 
「JavaScript 检测之 basevalidate.js」 
 http://shijiajie.com/2016/06/25/javascript-maintainable-javascript-basevalidatejs/
 
 
更多
 
 
 
关注微信公众号「劼哥舍」回复「答案」，获取关卡详解。 
 关注 https://github.com/stone0090/javascript-lessons，获取最新动态。
 

1. 成员变量
 
成员变量的修饰
 
 （1） public 公共变量，可被任何包中的任何类访问，只有在确认任何外部访问都不会带来不良后果的情况下才将成员声明为公共的，公共变量对任何类可见，不具有数据保护功能。
 （2）private私有变量，由 private 修饰的变量称为私有变量，私有变量是不公开的，它们得到了最好的保护，这是对类进行封装时使用的主要方法。
 （3）protected 受保护变量，可以被声明它的类和派生子类以及同一个包中的类访问，而外界无法访问。
 （4）package(default)，有 package 修饰的变量常常省略 package 关键字，即没有修饰符的成员被视为包成员。
 
static 静态变量， **静态变量是类固有的，可以直接引用，其他成员变量仅仅在被声明、生成实例对象后才存在，**才可以被引用，因此，把静态变量称作类变量、把非静态变量称为实例变量。
 
2. 成员方法和参数传递机制
 
在Java中，方法只能作为类的成员，故称为成员方法。方法操作类定义的数据，以及提供对数据的访问的代码。
 
大多数情况下，程序的其他部分都是通过类的方法和其他类的实例进行交互的，对象的行为由类的方法实现，其他对象可以调用另外一个对象的方法，通过消息（方法参数）的传递实现对该对象行为的控制。
 
2.1 成员方法的声明与修饰
 
[public] [private] [protected] [package] //访问控制修饰符 ，与成员变量的修饰符有相同作用。
 
final 最终方法
 当方法被声明为最终方法后，将不能被子类覆盖，即最终方法能被子类继承和使用，但不能在子类中修改或重新定义。
 
适用于： 保护一些重要的方法不被修改，尤其是那些对类的状态和行为有关键作用的方法被保护后，可以避免未知情况的发生。
注意 ： 有时不便于把整个类声明为最终类，这种保护太严格，不利于编程，此时可以有选择的把一些方法声明为最终方法，同样可以起到保护作用。
 
abstract 方法
 一个抽象类可以含有抽象方法，抽象方法是指没有具体方法体的方法，该方法不能实现，所以抽象方法不能出现在非抽象类中。
 
使用抽象类和抽象方法的原因： 一个抽象类可以定义一个统一的编程接口，使其子类表现出共同的状态和行为，但各自的细节可以不同。子类共有的行为由抽象类中的抽象方法来约束，而子类行为的具体细节则通过抽象方法的覆盖来实现。这种机制可增加编程的灵活性，也是 OOP 继承树的衍生基础。
 
 
 
例如，直线、圆和矩形等图形对象都有一些共同的位置（位置、边界）和行为（移动、改变大小、画出）。可以利用这些共性，把它们声明为同一个父类的子类，但是一个圆和一个矩形在很多细节方面又是不同的，这时，一个抽象父类是最佳选择。 子类继承父类后，可以通过覆盖方法实现自己的方法。
 
 
方法参数的传值方式
 一个对象和外部交换信息主要靠方法的参数来传递。在 Java中，可传递的参数包括任何数据类型，例如基本数据类型、数组和对象（没错，对象也可以）。
 
class MyBox {
	private int x, y, weight, height;
	…
	public void draw(Graphics g){
	g.drawRect(x,y,width,height);
	}
}
 
Java虽然不能传递方法，但可以传递对象，然后调用该对象的方法。
 
可变参数
 返回值类型 方法名称（类型 参数名 1 ， 类型 参数名 2， 类型…可变参数名）{}
 
向方法传递可变参数之后，其中可变参数以数组形式保存下来，如果方法中有多个参数，可变参数必须位于最后一项。

 
 
1. 关键字
 
 
关键字是编程语言里事先定义好并赋予了特殊含义的单词，也称作保留字。和其它语言一样，Java中保留了许多关键字，例如，class、public等，下面列举的是Java中所有的关键字。
 
 
1.1 关键字概述
 
 
被Java语言赋予特定含义的单词
 
 
1.2 关键字特点
 
 
组成关键字的字母全部小写
 
 
1.3 关键字注意事项
 
 
 
goto和const作为保留字存在,目前并不使用
 
 
类似Notepad++这样的高级记事本,针对关键字有特殊的颜色标记，非常直观
 
 
 

 

2. 标识符
 
2.1 标识符概述
 
就是给类，接口，方法，变量等起名字时使用的字符序列
 
2.2 组成规则
 
由英文大小写字母、数字字符、$（美元符号）、_（下划线）组成
 
2.3 注意事项
 
 
不能以数字开头
 
 
不能是Java中的关键字
 
 
区分大小写
 
2.4 标识符常见命名规则：见名知意
 
2.4.1 包
 
其实就是文件夹，用于把相同的类名进行区分，全部小写，单级：liuyi，多级：cn.itcast
 
为了便于对硬盘上的文件进行管理，通常都会将文件分目录进行存放。同理，在程序开发中，也需要将编写的类在项目中分目录存放，以便于文件管理。为此，Java引入了包(package)机制，程序可以通过声明包的方式对Java类定义目录。
 
Java中的包是专门用来存放类的，通常功能相同的类存放在相同的包中。在声明包时，使用package语句，具体示例如下：
 
package cn.itcast.chapter01; // 使用package关键字声明包
public class Example01{…}
 
需要注意的是，包的声明只能位于Java源文件的第一行。
 
在实际程序开发过程中，定义的类都是含有包名的，如果没有显式地声明package语句，创建的类则处于默认包下，在实际开发中，这种情况是不应该出现的，本教材的示例代码主要展现的是功能部分的代码，所以在大多数示例代码中没有为示例指定包名，但是在提供的源码中，都已使用包名。
 
在开发时，一个项目中可能会使用很多包，当一个包中的类需要调用另一个包中的类时，就需要使用import关键字引入需要的类。使用import可以在程序中一次导入某个指定包下的类，这样就不必在每次用到该类时都书写完整类名，简化了代码量。使用import关键字的具体格式如下所示：
 
import 包名.类名;
 
需要注意的是，import通常出现在package语句之后，类定义之前。如果有时候需要用到一个包中的许多类，则可以使用 import 包名.*; 来导入该包下所有类。
 
在JDK中，不同功能的类都放在不同的包中，其中Java的核心类主要放在java包及其子包下，Java扩展的大部分类都放在javax包及其子包下。为了便于后面的学习，接下来简单介绍Java语言中的常用包。
 
 
java.util:包含Java中大量工具类、集合类等，例如Arrays、List、Set等。
 
 
java.net:包含Java网络编程相关的类和接口。
 
 
java.io:包含了Java输入、输出有关的类和接口。
 
 
java.awt:包含用于构建图形界面(GUI)的相关类和接口。
 
除了上面提到的常用包，JDK中还有很多其它的包，比如数据库编程的java.sql包，编写GUI的javax.swing包等等，JDK中所有包中的类构成了Java类库。在以后的章节中，这些包中的类和接口将逐渐介绍，这里只需要有个大致印象即可。
 
2.4.2 类或者接口
 
一个单词：单词的首字母必须大写，举例：Student,Dog
 多个单词：每个单词的首字母必须大写举例：HelloWorld，StudentName
 
2.4.3 方法和变量
 
一个单词：单词的首字母小写，举例：main,age
 多个单词：从第二个单词开始，每个单词的首字母大写，举例：studentAge,showAllNames()
 
2.4.4 常量
 
一个单词：全部大写，举例：PI
 多个单词：每个字母都大写，用_隔开，举例：STUDENT_MAX_AGE
 
3. 注释
 
3.1 注释概述
 
用于解释说明程序的文字
 
3.2 Java中注释分类格式
 
 
单行注释，格式：//注释文字
 
 
多行注释，格式：/* 注释文字 */
 
 
文档注释，格式：/** 注释文字 */
 
/*
    注释：用于解释说明程序的文字

    Java中注释的分类及格式
        单行注释：//
        多行注释：/星 星/
            注意：多行不可以嵌套使用，而单行是可以的
        文档注释：被javadoc工具解析生成一个说明书，面向对象部分讲解。
*/

//这是我的注释案例
class ZhuShiDemo {
    //main方法是主方法
    //是程序的入口
    //被jvm调用
    public static void main(String[] args) {
        System.out.println("好好学习,天天向上");
    }
}
 
 
对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行
 
 
对于文档注释，是java特有的注释，其中注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档
 
 
注释是一个程序员必须要具有的良好编程习惯
 
 
初学者编写程序可以养成习惯：先写注释再写代码
 
 
将自己的思想通过注释先整理出来，在用代码去体现
 
 
因为代码仅仅是思想的一种体现形式而已
 
/*
    需求：我准备写一个java程序，把"HelloWorld"这句话输出在控制台

    分析：
        A:要写一个Java程序，必须定义类
        B:把数据能够输出，说明我们的程序是可以独立运行的，而程序要独立运行，必须定义main方法
        C:把数据输出在控制台，必须使用输出语句

    实现：
        A:java语言提供了一个关键字：class用来定义类，后面跟的是类名
        B:main方法的格式是固定的：
            public static void main(String[] args) {

            }
        C:输出语句的格式是固定的：
            System.out.println("HelloWorld");
            "HelloWorld"这个内容是可以改变的
*/

//这是我的HelloWorld案例
class HelloWorld {
    /*
        为了程序能够独立运行，定义main方法
        main方法是程序的入口
        被jvm自动调用
    */
    public static void main(String[] args) {
        //为了把数据显示在控制台，我们就使用了输出语句
        System.out.println("HelloWorld");
    }
}
 
4. 常量
 
4.1 常量概述
 
在程序执行的过程中其值不可以发生改变
 
4.2 Java中常量分类
 
4.2.1 字面值常量
 
 
字符串常量：用双引号括起来的内容，举例：“hello”，“world”
 
 
整数常量：所有整数，举例：12，23
 
 
小数常量：所有小数，举例：12.34，56.78
 
 
字符常量：用单引号括起来的内容，举例：‘a’,’A’,’0’
 
 
布尔常量，较为特有，举例：true，false
 
 
空常量，举例：null
 
4.2.2 自定义常量
 
/*
    常量：
        在程序执行过程中，其值不发生改变的量。

    分类：
        A:字面值常量
        B:自定义常量(后面讲)

    字面值常量
        A:字符串常量 用双引号括起来的内容。
            举例："hello","world","HelloWorld"
        B:整数常量  所有的整数
            举例：100,200
        C:小数常量  所有的小数
            举例：10.23,110.11
        D:字符常量  用单引号括起来的内容
            举例：'a','A','0'
            错误的：'ab'
        E:布尔常量  比较特殊
            举例：true,false
        F:空常量   后面讲
            举例：null
*/
class ConstantDemo {
    public static void main(String[] args) {
        //字符串常量的输出
        System.out.println("hello");

        //整数常量的输出
        System.out.println(100);

        //小数常量的输出
        System.out.println(100.10);

        //字符常量的输出
        System.out.println('a');
        System.out.println('A');
        System.out.println('0');
        //这个是有问题的
        //System.out.println('ab');

        //布尔常量的输出
        System.out.println(true);
        System.out.println(false);
    }
}
 
5. 变量
 
在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在一些内存单元中，每个内存单元都用一个标识符来标识。这些内存单元我们称之为变量，定义的标识符就是变量名，内存单元中存储的数据就是变量的值。
 
5.1 变量概述
 
在程序执行的过程中，在某个范围内其值可以发生改变的量，理解：如同数学中的未知数
 
5.2 变量定义格式
 
数据类型 变量名 = 初始化值;
 注意：格式是固定的，记住格式，以不变应万变
 
5.3 变量的组成规则
 
 
1、从本质上讲，变量其实是内存中的一小块区域，使用变量名来访问这块区域，因此，每一个变量使用前必须要先申请（声明），然后必须进行赋值（填充内容），才能使用。通过画图说明一个变量的组成部分
 
数据类型，变量名，变量值
 
2、为什么要定义变量呢?用来不断的存放同一类型的常量，并可以重复使用
 
6. 数据类型和类型转换
 
Java是一门强类型的编程语言，它对变量的数据类型有严格的限定。在定义变量时必须声明变量的类型，在为变量赋值时必须赋予和变量同一种类型的值，否则程序会报错。
 
 

6.1 数据类型
 
6.1.1 Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间
 
6.1.2 所谓有效数字：具体地说，是指在分析工作中实际能够测量到的数字。所谓能够测量到的是包括最后一位估计的，不确定的数字。对于一个近似数，从左边第一个不是0的数字起，到精确到的位数止，所有的数字都叫做这个数的有效数字。
 
6.1.3 Java 各整数类型有固定的表数范围和字段长度，其不受具体操作系统的影响，以保证Java程序的可移植性。
 
 
Java语言的整型常量默认为int型，声明long型常量可以后加‘ l ’或‘ L ’ ，如：
 
int i1 = 600; //正确     long l1 = 88888888888L; //必须加l否则会出错
 
 
- 与整数类型类似，Java浮点类型有固定的表数范围和字段长度，不受平台影响。
 
Java浮点类型常量有两种表示形式，十进制数形式，如: 3.14       314.0
 
 
Java 浮点型常量默认为 double型，如要声明一个常量为 float 型，则需在数字后面加 f 或 F ，如：
java<br />double d = 12345.6; //正确 <br />float f = 12.3f; //必须加f否则会出错<br />
 
 
char* 型数据用来表示通常意义上的“字符”
 
  
 
字符常量为用单引号括起来的单个字符，例如：char ch1= 'a'; char ch2='中';
 
 
Java字符采用 Unicode 编码，每个字符占两个字节，因而可用十六进制编码形式表示。
 
 
注：Unicode是全球语言统一编码
 
 
boolean类型
 
  
 
boolean 类型适于逻辑运算，一般用于程序流程控制 。
 
 
boolean 类型数据只允许取值 true 或 false ，不可以 0 或非 0 的整数替代 true 和 false ，这点和C语言不同。
 
 
数据类型
 
  
 
基本数据类型：整型byte、short、int、long，浮点型float、double，字符型char，布尔型boolean
 
 
引用数据类型：类class、接口interface、数组[]
 
 
/*
    数据类型：Java是一种强类型的语言，针对每一种数据都定义了明确的数据类型。

    数据类型分类：
        A:基本数据类型
        B:引用数据类型(类,接口,数值)

    基本数据类型:4类8种
        A:整数            占用字节数
            byte            1
            short           2
            int             4
            long            8

        B:浮点数
            float           4
            double          8

        C:字符
            char            2
        D:布尔
            boolean         1

        注意：
            整数默认是int类型
            浮点数默认是double类型。

            长整型后缀用L或者l标记。建议使用L。
            单精度浮点数用F或者f标记。建议使用F。
*/
class DataTypeDemo {
    public static void main(String[] args) {
        //定义变量的格式：
        //数据类型 变量名 = 初始化值;

        //定义一个字节变量
        byte b = 10;
        System.out.println(10);
        System.out.println(b);

        //定义一个短整型变量
        short s = 100;
        System.out.println(s);

        //定义一个整型变量
        int i = 1000;
        System.out.println(i);

        //超过了int的范围
        //int j = 1000000000000;
        long j = 1000000000000L;
        //long j = 100L;
        System.out.println(j);

        //定义浮点数据变量
        float f = 12.345F;
        System.out.println(f);

        double d = 12.345;
        System.out.println(d);

        //定义字符变量
        char ch = 'a';
        System.out.println(ch);

        //定义布尔变量
        boolean flag = true;
        System.out.println(flag);
    }
}
 
运行结果:
 
 
 
 
6.1.4 使用变量的时候要注意的问题：
 
 
 
A：作用域
 变量定义在哪个大括号内，它就在这个大括号内有效。
 并且，在同一个大括号内不能同时定义同名的变量。
 
B：初始化值
  没有初始化值的变量不能直接使用。
  你只要在使用前给值就行，不一定非要在定义的时候立即给值。
  推荐在定义的时候给值。
 
定义变量的格式：       
    a：数据类型 变量名 = 初始化值;      
    b：数据类型 变量名;    
    变量名 = 初始化值;
 

C：在一行上建议只定义一个变量        
    可以定义多个，但是不建议
 
6.2 类型转换
 
当把一种数据类型的值赋给另一种数据类型的变量时，需要进行数据类型转换。
 
根据转换方式的不同，数据类型转换可分为两种：自动类型转换和强制类型转换。
 
6.2.2 默认转换(从小到大的转换)
 
自动类型转换也叫隐式类型转换，指的是两种数据类型在转换的过程中不需要显式地进行声明。
 
要实现自动类型转换，必须同时满足两个条件，
 
 
第一是两种数据类型彼此兼容，
 
 
第二是目标类型的取值范围大于源类型的取值范围。
 
（1）整数类型之间可以实现转换，如byte类型的数据可以赋值给short、int、long类型的变量，short、char类型的数据可以赋值给int、long类型的变量，int类型的数据可以赋值给long类型的变量
 （2）整数类型转换为float类型，如byte、char、short、int类型的数据可以赋值给float类型的变量。
 （3）其它类型转换为double类型，如byte、char、short、int、long、float类型的数据可以赋值给double类型的变量。
 
A：byte，short，char—int—long—float—double
 
B：byte，short，char相互之间不转换，他们参与运算首先转换为int类型
 
6.2.2 强制转换：
 
强制类型转换也叫显式类型转换，指的是两种数据类型之间的转换需要进行显式地声明。
 
当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时就需要进行强制类型转换。
 
从大的数据类型到小的数据类型
 格式：目标数据类型 变量 = (目标数据类型) (被转换的数据);
 注意：不要随意的去使用强制转换，因为它隐含了精度损失问题
 
/*
    面试题：
        byte b1=3,b2=4,b;
        b=b1+b2;
        b=3+4;
        哪句是编译失败的呢？为什么呢？
        b = b1 + b2;是有问题的。
        因为变量相加，会首先看类型问题，最终把结果赋值的也会考虑类型问题。
        常量相加，首先做加法，然后看结果是否在赋值的数据类型范围内，如果不是，才报错。
*/
class DataTypeDemo6 {
    public static void main(String[] args) {
        //定义了三个byte类型的变量，b1，b2，b3
        //b1的值是3，b2的值是4，b没有值
        byte b1 = 3,b2 = 4,b;

        //b = b1 + b2; //这个是类型提升，所有有问题

        b = 3 + 4; //常量，先把结果计算出来，然后看是否在byte的范围内，如果在就不报错。
    }
}
 
1、在定义Long或者Float类型变量的时候，要加L或者f。
 
 
整数默认是int类型，浮点数默认是double。
 
 
byte，short在定义的时候，他们接收的其实是一个int类型的值。
 
 
这个是自己做了一个数据检测的，如果不再它们的范围内，就报错。
 
2、byte值的问题
 
byte b1 = 127;
byte b2 = (byte)128; //-128
byte b3 = (byte)129; //-127
byte b4 = (byte)130; //-126
byte的范围：-128 ~ 127
128：10000000
-128：10000000 (这里的1即是符号位，也是数值位)
 
3、数据类型转换之默认转换
  byte，short，char -- int -- long -- float -- double
  long：8个字节
  float：4个字节
  A：它们底层的存储结构不同
  B：float表示的数据范围比long的范围要大
    long：2^63-1
    float：3.4*10^38 > 2*10^38 > 2*8^38 = 2*2^3^38 = 2*2^114 > 2^63-1
 
4、Java语言中的字符char可以存储一个中文汉字吗?为什么呢?        
 可以。因为java语言中的字符占用两个字节。Java语言采用的是Unicode编码。
 
 
 
参考地址：https://github.com/JackChan1999/Java_Basic_Introduction
 
 
更多好文
 
java精品入门-0基础第一篇
 
JDK、JRE、JVM的区别与联系
 
亲，需要你的“分享”和“在看”
 
 
 
IT入门 感谢关注
 
 
程序员题库→
 
程序员用的单词表→
 
练习地址：http://520mg.com/it/#/main/397
 

引言
 
众所周知，数据挖掘中大约有80%的时间被用来做数据预处理。其中高维类别数据是数据挖掘算法（比如神经网络、线性or逻辑回归、SVM）最具挑战性的数据类型。事实上，在一些像决策树或者一些规则归纳的学习算法中，对类别数据并不需要额外的处理。但是一些回归算法却需要将每一个输入特征都转变成数值类型的特征。而且在现实生活中，我们需要解决的分类或者预测问题的数据集中，充满了类别属性，比如：ZIP码，SIC，IP，区号，域名等等。这就需要有种系统的方法能够将高维类别数据映射到可供回归任务学习的准连续标量属性上。我读了篇SIGKDD上的解决上述问题的文章：A Preprocessing Scheme for High-Cardinality Categorical 
 Attributes in Classification and Prediction Problems，并总结了文章的方法，特分享如下。
 
文章方法综述
 
该论文提出了一种将高维类别属性的数据映射到可供回归任务学习的准连续标量属性上。转换的关键之处在于将高维类别属性的每个值映射成基于目标属性的概率估计。
 
 
 
在分类场景下，被映射成，给定类别属性值的条件下，目标属性的后验概率。
在预测场景下，被映射成，给定类别属性值的条件下，目标的期望值。
 
 
该方法听起来是统计相关的，而且可以应用于分类与回归的任务场景中，它还优雅地处理了类别属性是缺失值的情况。这种方法听起来是不是牛掰爆了，大家会担心，这种方法是不是很难呀。在这里我要说的是：很简单~。论文的组织结构如下：第二节讲述了处理类别属性的最通用的方法；第三节讲述了本文要重点分析的方法；第四节描述了该方法在层次化数据上的应用拓展；第五节就总结了文章。接下来，本文也会按照论文的组织结构，给大家分析下这篇论文的。
 
处理类别属性的通用方法
 
这里处理类别属性的通用方法有两大类，这两大类按照数据的维度划分。因此可以分为低维类别数据及高维类别数据。
 
低维类别数据预处理方法
 
对于低维度的类别数据最普遍的做法就是二值化。我们简单举个例子：
 
ID
Gender
Color of cloth
1
male
blue
2
female
white
3
male
red
 
上面的表格中存放了我们构造的三个样本数据，其中属性栏，有三个属性，ID，Gender，Color of cloth，其中很明显，Gender与Color of cloth是类别属性。我们将其二值化，从而将二值化后的新表格如下图所示：
 
ID
male
female
blue
white
red
1
1
0
1
0
0
2
0
1
0
1
0
3
1
0
0
0
1
 
二值化编码的核心思想就是将第i个组成标记为1，其余标记为0。这是一种1到N的映射关系，当面对高维类别数据即N很大的时候，这种方法就不太适用（矩阵很稀疏）。那么为了解决高维类别属性，又该采用何种方法呢？
 
高维类别数据
 
现如今，处理高维类别数据的最常用方法就是聚类。核心思想就是将1到N的映射问题降维到1到K的映射问题上来（$k\ll N$）。 
 因此该方法的工作流程就是：
 
 
 
*先采用诸如层次聚类的聚类算法，有效地将N个原始数据聚类成K个簇 
 *再将K个簇二值化 
 然后论文就说了下这些通用方法的缺点啊，不足啊，又吹捧了下自己提出的方法。
 
 
使用目标统计方法来对类别属性进行编码
 
终于来到正文了，首先说下，接下来提到的方法，就如我们章节标题所写，是个典型的统计学方法，而且历史悠久，应用领域颇多，但是，在类似这些分类预测任务中作为预处理方法的应用，其他文献没有提到过，所以文章还是有一定创新性的。 
 这一章节将按照目标变量的类型分成三个小节：二值型变量、连续型变量、多类别变量
 
二值型变量
 
当目标属性$Y$是二值的，$Y\in\{0，1\}$，将高维类别属性$X$的一个值$X_i$映射成一个标量$S_i$，其中$S_i$就代表给定$X=X_i$的条件下$Y=1$的概率估计： 
 
 $$X_i \to S_i \cong P(Y|X=X_i) \tag{$1$}$$  

 有了这个映射关系，接下来就需要来算出这个“概率估计”了。这里我们假设训练集有

$n_{TR}$个样本，测试集有

$n_{TS}$个样本。既然
概率估计是在训练模型过程中的一部分（即概率估计是发生在模型训练的过程中，而不是测试模型时），那么概率估计只与训练数据的

$n_{TR}$个样本有关。 

 假如训练样本足够大，那么概率估计直接可以用下面的公式计算： 

 

 $$S_i=\frac{n_{iY}}{n_i} \tag{$2$}$$  

 其中

$n_i$是

$X_i$的数量，

$n_{iY}$是

$Y=1$的数量。 

 但是在实际场景中，

$n_i$的数量很小，因此公式（2）来计算后验概率并不是很可信。为了削弱某些样本个数较小带来的影响，文章提出了一种计算混合概率的方法：将公式（2）的后验概率与Y的先验概率同时利用起来。方法如下： 

 

 $$S_i = \lambda(n_i)\frac{n_{iY}}{n_i}+(1-\lambda(n_i))\frac{n_Y}{n_{TR}}\tag{$3$}$$  

 其中

$n_Y$是

$Y=1$的训练样本数，权重因子

$\lambda(n_i)$是边界为0，1的单调递增函数。 

 当

$n_i$的数量很大的时候，

$\lambda \cong 1$，我们给后验概率分配更多的权重，此时等价于公式（2）；但是如果

$n_i$的数量很小，

$\lambda \cong 0$，我们直接采用先验概率。 

 其中可以给权重因子指定一个函数，例如： 

 

 $$\lambda(n) = \frac{1}{1+e^{-\frac{n-k}{f}}} \tag{$4$}$$  

 很显然，该函数是个sigmoid函数变种。当n=k时，函数大小为0.5，此处为S型曲线的拐点。参数

$f$控制该函数在拐点处的斜率。 

公式（3）在统计与精算学中有着很长的一段历史。事实上公式（3）是贝叶斯概率的分支之一被称作经验贝叶斯（Empirical Bayesian）。 

公式如下： $$P_i = B_iy_i+(1-B_i)\bar{y}\tag{$5$}$$  

 其中

$\bar{y}$指先验概率，

$y_i$指后验概率。

$B_i$称作shrinkage因子（

$0< B<1$）。假设数据及后验估计的概率分布均满足高斯分布，那么

$B_i$采用如下形式： 

 

 $$B_i=\frac{n_i\tau^2}{\sigma^2+n_i\tau^2}\tag{$6$}$$  

 其中

$\sigma^2$为

$X=X_i$数据集方差，

$\tau^2$是整个样本的方差。

$n_i$是

$X=X_i$数据集的大小。很显然

$B_i$是

$\lambda(n)$的一种特殊形式，

$B_i$不仅考虑了样本大小，还考虑了数据集的方差。
 
处理缺失数据
 
在大多数情况下，数据集里会存在缺失数据。根据属性的特性及所采用的具体算法有不同的处理方法：
 
 
 
如果$X$是数值型数据，一般通过均值或者基于其他属性的估计来填充空缺值
  
如果$X$是低维类别数据，那么如果采用二值化编码（有m个元素的向量），那么空缺值可以初始化为m个0的向量。
有些决策树算法会直接丢弃空缺值，或者用另外一个值来填充。
 
 
这篇论文提出了一种方法来补全空缺值：引入一个空缺值$X_0$，然后再给定条件$X=X_0$的情况下求： 
 
 $$S_0=\lambda(n_0)\frac{n_{0Y}}{n_0}+(11-\lambda(n_0))\frac{n_Y}{n_{TR}}\tag{$7$}$$  

 这个方法的好处是，如果缺失值与目标值有很大相关性，那么这个公式就能很好的表达出相关信息。如果缺失值与目标值没有太大关系，那么

$S_0$也会很快收敛于先验概率，这也是对缺失值的中立表示。
 
连续型变量
 
上面提出的方法，也能应用到目标变量是连续值得情况下。无非就是将概率估计转变成期望估计。现在我们就是要考虑期望了，公式如下： 
 
 $$S_i =\lambda(n_i)\frac{\sum_{k\in L_i}Y_k}{n_i}+(1-\lambda(n_i))\frac{\sum^{N_{TR}}_{k=1}Y_k}{n_{TR}} \tag{$8$}$$ 
 
多类别变量
 
当目标变量是多类别的，扩展的方法也很直接，就是直接求
 $$P(Y=Y_j|X=X_i)\tag{$9$}$$ 
 
在具有层次结构类别数据上的应用
 
一些高维类别数据通常是定义好的层次结构，这样便于做聚合运算。一个典型的案例就是美国的邮政编码系统：一个5位的ZIP码，如果在一个大都市区域，那么该ZIP码的前三位是一样的。所以可以在基于ZIP3或ZIP4的基础上聚合ZIP5。其他的一些例子像手机号码，IP地址都有这样的层次编码结构。 
 论文提出的方法可以很好的利用层次结构这一特性来讲结构数据进行转换。直接举例说明，以ZIP5编码作为说明。ZIP5级别的公式如下： 
 
 $$S_i^5=\lambda(n_i)\frac{n_{il}}{n_i}+(1-\lambda(n_i))\frac{n_Y}{n_{TR}}\tag{$10$}$$  

 如果ZIP5类别很稀疏，那么可以“降维”成ZIP4，对ZIP4级别的类别数据进行估计。
因为大多数估计都与先验概率近似，因此可以讲ZIP5级别的先验概率有ZIP4的估计代替： 

 

 $$S_i^5=\lambda(n_i)\frac{n_{il}}{n_i}+(1-\lambda(n_i))S_i^4\tag{$11$}$$  

 以此类推ZIP3，ZIP2。从上述公式可以看到这个公式可以自动根据数据的密度进行调节。
 
总结
 
这篇论文，基本介绍完了，就是提出了EB（经验贝叶斯）的通用方法，然后应用到了机器学习分类回归任务的预处理中，关于这个方法到底好用不好用，现在我还不清楚，因为在做Kaggle一个赛题，有人分享了这篇文章，我分析了下，准备试试具体效果，如果效果好，我会再来给本文写个附加的评论的~