第二章 基本数据类型与数组

2.1、标识符与关键字

2.1.1、标识符

（1）标识符概念：标识符就是一个名字(一段字符序列)。
（2）标识符作用：用来标识类名、变量名、方法名、类型名、数组名以及文件名。
（3）标识符由什么构成：标识符由字母、数字、下划线、美元符号组成，长度不限。
（4）标识符的特点：标识符的第一个字符不能是数字、标识符不能是关键字、标识符不能是true、false和null、标识符严格区分大小写。

2.1.2、Unicode字符集

（1）Java使用Unicode标准字符集(C语言使用ASCII字符集)
（2）Unicode字符集最多可以识别65536个字符(2的16次方)
（3）Unicode字符集的前128个字符刚好是ASCII码

2.1.3、关键字

（1）关键字概念：关键字就是具有特定用途或被赋予特定意义的一些单词。
（2）Java的关键字都是小写的。
（3）以下是Java的50个关键字：
	abstract、assert、boolean、break、byte、case、catch、char、class、const、
	continue、default、do、double、else、enum、extends、final、finally、float、
	for、goto、if、implements、import、instanceof、int、interface、long、
	native、new、package、private、protected、public、return、short、static、
	strictfp、super、switch、synchronized、this、throw、throws、transient、
	try、void、volatile、while。

2.2、基本数据类型

（1）基本数据类型也称简单数据类型。
（2）Java语言有4类8种基本数据类型。
	逻辑类型：boolean(2B)
	整数类型：byte(1B)、short(2B)、int(4B)、long(8B)
	字符类型：char(2B)
	浮点类型：float(4B)、double(8B)

2.2.1、逻辑类型

（1）逻辑常量：true、false。
（2）逻辑变量：使用关键字boolean声明逻辑变量，同时可以赋初值。
（3）声明逻辑变量实例：
	boolean on=true;
	boolean off=false;
（4）boolean型变量占用2个字节。

2.2.2、整数类型

（1）整数类型分为四种：int型、byte型、short型、long型。
（2）Java没有无符号的int型、byte型、short型、long型。

int型：

（1）int型常量：123(十进制)、077(八进制)、0x3ABC(十六进制)。
（2）int型变量：使用关键字int声明整型变量，同时可以赋初值。
（3）声明int型变量示例：
	int x=123,y=077,z=0x3ABC;
（4）int型变量占用4个字节。

byte型:

（1）byte型变量：使用关键字byte声明byte型变量，同时可以赋int型常量初值。
（2）声明byte型变量示例：
	byte x=-12,tom=28,漂亮=98;
（3）byte型常量：不存在这种表示方法，但是可以把一定范围内的int型常量赋值给byte型变量。
（4）如果需要强调一个整型是byte型数据时候，可以使用强制类型转换来表示，例如：
	(byte)-12、(byte)28
（5）byte型变量占用1个字节。

short型：

（1）short型变量：使用关键字short来声明short型变量。
（2）声明short型变量示例：
	short x=12,y=1234;
（3）short型常量：不存在这种表示方法，但是可以把一定范围内的int型变量赋值给short变量。
（4）如果需要强调一个整型是short型数据时候，可以使用强制类型转换来表示，例如：
	(short)-12、(short)28
（5）short型变量占用2个字节。

long型：

（1）long型常量：需要用后缀L来表示，如：108L(十进制)、07123L(八进制)、0x3ABCL(十六进制)
（2）long型变量：使用关键字long来声明long型变量。
（3）声明long型变量示例：
	long width=12L,height=2005L,length;
（4）long型变量占用8个字节。

2.2.3、字符类型

（1）char型常量：用单引号括起来的一个Unicode字符，如：'A','b','?','!','9','好','\t'
（2）char型变量：使用关键字char来声明char型变量
（3）声明char型变量示例：
	char x='a';
（4）注意：在Unicode表中，97表示a，因此，也允许把上面的变量声明写为：char x=97;
（5）转义字符的出现：有些字符不能用键盘输入到字符串或程序中
（6）转义字符格式：'\n','\b','\t','\'','\"','\\'
（7）转义字符示例：
	错误格式："我喜欢使用双引号""
	正确格式："我喜欢使用双引号\""
（8）转义字符也可以用Unicode表中的十六进制来表示某个字符，格式：'\u****'，如：'u0041'表示字符A。
（9）Java中的char型数据一定是无符号的。
（10）char型变量占用2个字节。
（11）要观察一个字符在Unicode表中的顺序，可以使用int型类型转换，如(int)'A'。
（12）要得到0-65535之间的数所代表的Unicode表中的相应位置，可以使用char型强制类型转换，如(char)65。

2.2.4、Example2_1.java
分别用类型转换，来显示一些字符在Unicode表中的位置，以及Unicode表中某些位置上的字符。

public class Example2_1{
	public static void main (String args[]){
		char chinaWord='好',japanWord='ぁ';
		char you='\u4F60';
		int position=20320;
		System.out.println("汉字:"+chinaWord+"的位置:"+(int)chinaWord);
		System.out.println("日文:"+japanWord+"的位置:"+(int)japanWord);
		System.out.println(position+"位置上的字符是:"+(char) position);
		position=21319;
		System.out.println(position+"位置上的字符是:"+(char) position);
		System.out.println("you:"+you);		
	}
}

2.2.4、浮点类型

（1）浮点型分为float(单精度)和double(双精度)型

float型：

（1）float型常量：1.0f、2.2F(小数表示法)、2e40f(指数法表示)，需要注意的是常量后面必须要f或F，否则系统默认认为是double型数据。
（2）float型变量：用关键字float来声明
（3）声明float型变量示例：
	float x=22.76f,tom=1234.987f,weight=1e-12F;
（4）float型变量占用4个字节。
（5）float型变量存储时候，保留8位有效数字(也就是从第一个数字开始算起)
（6）有效数字的概念：在数学中，有效数字是指在一个数中，从该数的第一个非零数字起，直到末尾数字止的数字称为有效数字，如0.618的有效数字有三个，分别是6,1,8。

double型:

（1）double型常量：0.05D、123.0d(小数表示法)，1e-90(指数表示法)，D/d可省略。
（2）double型变量：使用关键字double来声明double型变量
（3）声明double型变量示例：
	double height=23.345,width=34.56D,legth=1e12;
（4）double型变量占用8个字节。
（5）double型变量存储时候，保留16位有效数字(也就是从第一个数字开始算起)
（6）比较float型数据和double型数据时候必须要注意数据的实际长度。
	float x=0.4f;
	double y=0.4;
	单精度保留8为有效数字，双精度保留16为有效数字。但是计算机在实际存储的时候，x=0.4000000059604645(从第9为有效数字就有其他的值了)，y=0.4000000000000000(16位有效数字都是0)

2.3、类型转换运算

2.3.1、自动类型转换

（1）数据类型按照低精度向高精度排列(除了boolean类型)：
	byte short char int long float double
（2）当把低精度的变量的值赋值给高精度的变量时，系统自动完成数据类型的转换(也就是低精度向高精度转换，小容量向大容量转换)。例如：
	float x=100;	//x的值是100.0

2.3.2、强制类型转换

（1）当把高精度的变量的值赋值给低精度的变量的时，必须进行强制类型转换，格式如下：
	(类型名)要转换的值;
（2）示例：
	int x = int(34.89);
	long y = (long)56.98F;
	int x = (int)1999L;
（3）例外：把int常量赋值给一个byte、short、char型变量的时候，在一定范围内，可以不转换类型。
（4）注意1：当把int型常量赋值给一个byte、short、char型变量的时候，不可超出这些变量的取值范围，否则必须进行强制类型转换。
示例：
	byte a = byte(128);		//byte范围是-128到127，所以a的值是-128
	byte b = byte(-129);	//b的值是127
（6）注意2：当直接把一个double型常量赋值给一个float变量的时候，将导致语法错误，编译器提示“possible loss of percision”

Example2_2.java

public class Example2_2{
	public static void main(String args[]){
		byte b = 22;
		int n = 129;
		float f = 123456.6789f;
		double d = 123456789.123456789;
		System.out.println("b="+b);
		System.out.println("n="+n);
		System.out.println("f="+f);
		System.out.println("d="+d);
		b = (byte)n;
		f = (float)d;
		System.out.println("b="+b);
		System.out.println("f="+f);
	}	
}

2.4、输入、输出数据

2.4.1、输入基本数据类型

（1）Scanner是JDK1.5新增的一个类，可以使用该类创造(实例化)一个对象；
	Scanner reader = new Scanner(System.in);
（2）然后reader对象可以调用以下方法，读取用户在命令行输入的各种基本数据类型。
	nextBoolean()方法->接收boolean型数据
	nextByte()方法->接收byte型数据
	nextShort()方法->接收short型数据
	nextInt()方法->接收int型数据
	nextLong()方法->接收long型诗句
	nextFloat()方法->接收float型数据
	nextDouble()方法->接收double型数据
	next()方法->只接收一个字符

2.4.2、Example2_3.java
下面的例子三中，用户在键盘上依次输入若干个数字，每输入一个数字都需要按回车键确认，在键盘上输入数0结束整个的输入操作过程，程序将计算出这些数的和。

import java.util.Scanner;

public class Example2_3{
	public static void main(String args[]){
		System.out.println("请输入若干个数，每输入一个数回车确认");
		System.out.println("最后输入数字0，结束输入操作");
		Scanner reader = new Scanner(System.in);
		double sum = 0;
		double x = reader.nextDouble();
		while(x!=0)
		{
			sum+=x;
			x = reader.nextDouble();
		}
		System.out.println("sum="+sum);
	}
}

2.4.3、输出基本数据类型

（1）System.out.println()或System.out.print()可输出串值、表达式的值，二者的区别是前者有换行，后者无换行。允许使用并置符号(也就是符号+)将变量、表达式或一个常数值与一个字符串并置一起输出。(类似于PHP的字符串拼接符号.)
（2）例子：
	System.out.println(m+"个数的和为"+sum);
	System.out.print(":"+123+"大于"+122);
	System.out.println("你好，"+
					"很高兴认识你");
（3）JDK1.5新增了和语言类似的输出数据的方法，普通字符原样输出：
	System.out.printf("格式控制部分",表达式1,表达式2,表达式3,...,表达式n);
	System.out.printf("%d,%f",12,23.78);	//注意：双精度用%lf

2.5、数组

（1）数组是相同类型的变量按顺序组成的一种复合数据类型(数组是一些类型相同的变量组成的集合)。
（2）称这些相同类型的变量为数组的元素或单元。
（3）数组通过数组名加索引来使用数组的元素。

2.5.1、声明数组

（1）声明数组，需要声明：数组名和数组类型
（2）声明一维数组的两种格式：
	数组的元素类型 数组名[];
	数组的元素类型 [] 数组名;
（3）声明二维数组的两种格式：
	数组的元素类型 数组名[][];
	数组的元素类型 [][] 数组名;	
	//演变格式：数组的元素类型 [] 数组名[];
（4）声明两个int型一维数组a和b的两种方法：
	int a[],b[];
	int [] a,b;
（5）声明一个int型一维数组a，一个int型二维数组b的两种格式：
	int a[],b[][];
	int [] a,b[];
（6）注意：Java不允许在声明数组的时候，指定数组元素的个数。不然语法出错。

2.5.2、为数组分配元素

（1）给数组分配元素，也就是创建数组。
（2）为数组分配元素的格式如下：
	数组名 = new 数组元素的类型[数组元素的个数];
（3）维数组分配元素示例：
	boy = new float[4];
	//数组变量boy存放着数组元素首地址，该地址称为数组的引用。
（4）声明数组可以和创建数组一起进行：
	float boy[] = new float[4];
（5）二维数组就是由若干个一维数组构成的。
（6）在创建二维数组时可以分别指定构成二维数组的一维数组的长度，如
	int a[][] = new int[3][];
	a[0] = new int[6];
	a[1] = new int[12];
	a[2] = new int[8];
（7）注意：与不同的是，Java允许使用int型变量的值指定数组元素的个数，例如：
	int size = 30;
	double number[] = new double[size];

2.4.3、数组元素的使用

（1）一维数组通过索引访问自己的元素，需要注意的索引从0开始计算。
（2）当索引越界的时候，也就是引用超过了数组长度时，会报出“ArrayIndexOutBoundsException”异常。

2.4.4、length的使用

（1）数组的元素个数称为数组的长度。
（2）对于一维数组，“数组名.length”的值就是数组中元素的个数。
（3）对于二维数组，“数组名.length”的值就是二维数组中一维数组的个数。
（4）例如：
	flaot a[] = new float[12];	//a.length的值是12
	int b[][] = new int[3][6];	//b.length的值是3

2.4.5、数组的初始化

（1）创建数组后，也就是给数组分配元素后，系统会给数组的每个元素一个默认的值，如flag是0.0。
（2）在声明数组的同时也可以给数组的元素一个初始值，例如：
	float boy[] = {21.3f,23.89f,2.0f,23f,778.98f};
	int a[][ ]={{1},{1,1},{1,2,1},{1,3,3,1},{1,4,6,4,1}};	

2.4.6、数组的引用

（1）数组属于引用型变量，因此两个相同类型的数组如果具有相同的引用，它们就有完全相同的元素
	//条件：类型相同
（2）例如：
	int a[] = {1,2,3};
	int b[] = {4,5};
	a=b;	//此时b的引用赋值给a，那么a中的元素就和b中的元素完全相同了。

2.4.7、Example2_4.java

public class Example2_4{
	public static void main(String args[]){
		int a[] = {1,2,3,4};
		int b[] = {100,200,300};
		System.out.println("数组a的元素个数="+a.length);
		System.out.println("数组b的元素个数="+b.length);
		System.out.println("数组a的引用="+a);
		System.out.println("数组b的引用="+b);
		a=b;
		System.out.println("数组a的元素个数="+a.length);
		System.out.println("数组b的元素个数="+b.length);
		System.out.println("a[0]="+a[0]+",a[1]="+a[1]+"a[2]="+a[2]);
		System.out.print("b[0]="+b[0]+",b[1]="+b[1]+"b[2]="+b[2]);
	}
}

//需要注意的是：对于char型数组a，System.out.println(a)并不会输出数组a的引用，而是直接数组数组的全部元素。如果想要输出数组a的引用，必须让数组a和字符串做并置计算，如：System.out.println(""+a);

2.6、应用举例

2.6.1、Example2_6
利用折半法在一个有序(升序)的数组元素中，快速地判断某数据是否在数组中。

略

2.7、小结

（1）有效数字的概念：在数学中，有效数字是指在一个数中，从该数的第一个非零数字起，直到末尾数字止的数字称为有效数字，如0.618的有效数字有三个，分别是6,1,8。
（2）比较float型数据和double型数据时候必须要注意数据的实际长度。
	float x=0.4f;
	double y=0.4;
	单精度保留8为有效数字，双精度保留16为有效数字。但是计算机在实际存储的时候，x=0.4000000059604645(从第9为有效数字就有其他的值了)，y=0.4000000000000000(16位有效数字都是0)

2.8、安全小结

本章节对于WEB安全来说，有哪些需要必须掌握的细节性内容？
本人保证，以下内容，是我在以前学习WEB安全/打CTF的时候遇到的一些小细节。
比如：Unicode会扩展到Unicode的编码解码转字符串；转义字符会在给phpstudy设置环境GPC、转义的绕过中遇到；Java的并置符号以及PHP的字符串拼接符号也会常常遇到。

（1）Unicode字符集最多可以识别65536个字符(2的16次方)
（2）Unicode字符集的前128个字符刚好是ASCII码
（3）要观察一个字符在Unicode表中的顺序，可以使用int型类型转换，如(int)'A'。
（4）要得到0-65535之间的数所代表的Unicode表中的相应位置，可以使用char型强制类型转换，如(char)65。
（5）转义字符示例：
	错误格式："我喜欢使用双引号""
	正确格式："我喜欢使用双引号\""
（6）System.out.println()或System.out.print()可输出串值、表达式的值，二者的区别是前者有换行，后者无换行。允许使用并置符号(也就是符号+)将变量、表达式或一个常数值与一个字符串并置一起输出。(类似于PHP的字符串拼接符号.)

2021.09.16 (4h)