Java第一章：基本数据类型与数组
Java的基本数据类型和C语言中的基本数据类型很相似，但也有很多不同之处，特别是float常量的格式与C语言的区别。Java语言的数组和C语言的数组有类似的地方，但也有不同的地方。
1.1标识符与关键字
1.1.1标识符
用来标识类名、变量名、方法名、类型名、数组名及文件名的有效字符序列称为标识符，简单来说，标识符就是一个名字。以下是Java关于标识符的语法规则：
- 标识符是由字母、下划线、美元符号和数字组成的，长度不受限制。
- 标识符的第一个字符不能是数字字符。
- 标识符不能是数字字符。
- 标识符不能是true、false和null（尽管true、false、null不是java的关键字）。
例如，以下都是标识符：
HappyNewYear_ava、TigerYear_2010、$98apple、hello、Hello需要特别注意的是，标识符中的字母是区分大小写的，hello和Hello是不同的标识符。
1.1.2 Unicode字符集
Java语言使用Unicode标准字符集，该字符集由UNICODE协会管理并接受其技术上的修改，最多可以识别65536个字符。Unicode字符集的前128个字符刚好是ASCII码，还不能覆盖历史上的全部文字，但大部分国家的“字母表”的字母都是Unicode字符集的一个字符。Java所谓的子母包括了世界上大部分语言中的“字母表”，因此Java所使用的字母不仅包括通常的拉丁字母a、b、c等，也包括汉语等。
1.2.3关键字
关键字就是具有特定用途或被赋予特定意义的一些单词，不可以把关键字作为标识符来用，下面是Java的50个关键字：
abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while
1.2基本数据类型
基本数据类型也称为简单数据类型。Java语言中包括8中基本数据类型，分别为boolean、byte、short、char、int、long、float、double，这八个基本数据类型习惯上可分为以下四大类型：
- 逻辑类型：boolean；
- 整数类型：byte、short、int、long；
- 字符类型：char；
- 浮点类型：float、double；
1.2.1逻辑类型
（1）常量：true、false
（2）变量：使用关键字boolean来声明逻辑变量，声明时也可以赋给初值，例如：
boolean male=true,on=true,off=false,isTriangle;1.2.2 整数类型
整型数据分为四种：
1.int型
常量：123、6000（十进制），077（八进制），0x3AABC（十六进制）
变量：使用int关键字int声明int型变量，声明时也可以赋给初值，例如：
int x=12,y=10,z;对于int型变量，分配4个字节内存，因此，int型变量的取值范围是：-231～231-1.
2.byte型
变量：使用关键字byte来声明byte型变量，例如：
byte x=-12,tom=28,漂亮=98;常量：Java不存在byte型常量的表示法，但可以把一定范围内的int型常量赋值给byte型变量。
对于byte型变量，分配1字节内存，占8位，因此byte型变量的取值范围是-27～27-1，如果需要强调一个整数是byte型数据时，可以使用类型转换运算的结果来表示，例如：(byte)-12,(byte)28;。
3.short型
变量：使用关键字short来声明short变量，例如：
short x=12,y=1234;常量：和byte类型类似，Java中也不存在short型常量的表示法，但可以把一定范围内的int型常量赋值给short型变量。
对于short型变量，分配2个字节内存，占16位，因此short型变量的取值范围是-215～215-1。如果需要强调一个整数是short型数据时，可以使用强制转换运算的结果来表示，例如：(short)-12,(short)28。
4.long型
常量：long型常量常用后缀L来表示，例如108L（十进制）、07123L（八进制）、0x3ABCL（十六进制）。
变量：使用关键字long来声明long型变量，例如：
long width=12L,height=2005L,length;对于long型变量，分配8个字节内存，占64位，因此long型变量的取值范围是-263～263-1。
注：Java没有无符号的byte、short、int、long，这一点和C语言有很大不同。因此unsigned int m;是错误的变量声明。
1.2.3字符类型
常量：‘A’……，即用单引号（需要英文输入法输入）括起来的Unicode表中的一个字符。
变量：使用关键字char来声明char型变量，例如：
char ch='A',home='家';对于char型变量，分配2个字节内存，占16位，最高位不是符号位，没有负数的char。char型变量的取值范围是0～65535。对于
char x='a'内存x中存储的是97，97是字符a在Unicode表中的排序位置。因此，允许将上面的变量声明写为：
char x=97;有些字符（如回车符）不能提供键盘输入到字符串或程序中，这是就需要转义字符常量，例如：\n（换行）、\t（水平制表符）、\’（单引号）等。
例如：
char ch1='\n',ch2='\"',ch3='\\'在Java中，可以用字符在Unicode表中排序位置的十六进制转义（需要用u做前缀）来表示该字符，其一般格式为’\u****’，例如，’\u0041’表示字符A，’\u0061’表示字符a。
要观察一个字符在Unicode表中的顺序位置，可以使用int型类型转换，如(int)’A’。如果要得到一个0～65535之间的数所代表的Unicode表中相应位置上的字符，必须使用char型类型转换，如(char)65。
注：Java中的char型数据一定是无符号的，而且不允许使用unsigned来修饰所声明的char型变量（这一点是和C语言不同的）。
public class Main {
public static void main(String[] args) {
char chinaWord='好',eWord='f';
char you='\u4F60';
int position=20320;
System.out.println("汉字："+chinaWord+"的位置:"+(int)chinaWord);
System.out.println("英语："+eWord+"的位置:"+(int)eWord);
System.out.println(position+"位置上的字符是:"+(char)position);
position=21319;
System.out.println(position+"位置上的字符是:"+(char)position);
System.out.println("you:"+you);
}
}
//汉字：好的位置:22909
//英语：f的位置:102
//20320位置上的字符是:你
//21319位置上的字符是:升
//you:你1.2.4 浮点类型
浮点型分为float（单精度）型和double（双精度）型。
1.float型
常量：4.53221f，2.356545F。需要特别注意的是常量后面必须加上后缀f或F。
变量：使用关键字float来声明float型变量，例如：
float x=22.76f,tom=1234.987f,weight=1e-12F;float变量存储在float型数据时保存8位有效数字（相对double型保留的有效数字，称之为单精度）。
对于float型变量，分配4个字节内存，占32位，float型变量的取值范围是1.4E-45～3.4.282235E38和-3.4.282235E38～-1.4E-45。
2.double型
常量：2389.539d等。对于double常量，后面可以有后缀d或D，但允许省略后缀。
变量：使用关键字double来声明double型变量，例如：
double height=23.456,width=34.56D,length=1e12;对于double变量，分配8个字节内存，占64位，double型变量的取值范围是4.9E-324～1.7976931348623157E308和-1.7976931348623157E308～-4.9E-324。double变量在存储double型数据是保留16位有效数字（相对float型保留的有效数字，称之为双精度）。
需要特别注意的是，比较float和double型数据时必须注意数据的实际精度，例如：
float x=0.4f;
double y=0.4;那么在实际存储在变量x中的数据是0.4000000059604645，存储在变量y中的数据是0.4000000000000000，因此y小于x中的值。
1.3 类型转换运算
当把一种基本数据类型变量的值赋值给另一种基本类型变量，就涉及数据转换。下列基本类型会涉及数据转换（不包括逻辑类型）。将这些类型按精度从底到高排列：
byte short char int long float double
当把级别低的变量的值赋给级别高的变量，系统自动完成数据类型的转换。
例如：
float x=100;如果输出x的值，结果将是100.0。
例如：
int x=50;
float y;
y=x;如果输出y的值，结果将是50.0。
当把级别高的变量的值赋给级别低的变量时，必须使用类型转换运算，格式如下：
（类型名）要转换的值;
例如：
int x=(int)34.89;
long y=(long)56.98F;
int z=(int)1999L;如果输出x、y和z的值，结果将34、56和1999，类型转换运算的结果的精度可能低于原数据的精度。
当把一个int型常量赋值给一个byte、short和char型变量时，不可超过这些变量的取值范围，否则必须进行类型转换运算。例如，常量128属于int型常量，超过byte变量的取值范围，如赋值给byte型变量，必须进行byte类型转换运算（将导致精度的损失）。
byte a=(byte)128;
byte b=(byte)(-129);那么a和b得到的值分别是-128和127.
另外，一个常见的错误是把一个double型变量赋值给float型变量时没有进行类型转换运算，例如：
float x=12.4;//不兼容的类型: 从double转换到float可能会有损失将导致语法错误，编译器提示“possible loss of precision”。正确的做法是：
float x=12.4F;或
float x=(float)12.4;下面的例子使用了类型转换运算。
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);
/*
b=22
n=129
f=123456.68
d=1.2345678912345679E8
b=-127
f=1.2345679E8
*/1.4 输入、输出数据
1.4.1输入基本型数据
Scanner是JDK1.5新增的一个类，可以使用该类创建一个对象；
Scanner reader=new Scanner(System.in);然后reader对象调用下列方法，读取用户在命令行输入的各种基本数据类型：
nextBoolean(),nextByte(),nextShort(),nextInt(),nextLong(),nextFloat(),nextDouble()上述方法执行时都会阻塞，程序等待用户在命令行输入数据回车确认。
在下面的例子中，用户在键盘依次输入若干个数字，每输入一个数字都需要按回车键确认，在键盘输入数0结束整个的输入操作过程，程序将计算出这些数的和。
import java.util.Scanner;
public class Main {
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);
/*
请输入若干个数，每输入一个数回车确认
最后输入0结束输入操作
675.9
2356.9879
4567.88
0
sum=7600.767900000001
*/
}
}1.4.2 输出基本型数据
System.out.println()或System.out.print()可输出串值、表达式的值，二者的区别时前者输出数据后换行，后者不换行。允许使用并置符号+将变量、表达式或一个常数值与一个字符串并置一起输出，例：
System.out.println(m+"个数的和为sum"+sum);
System.out.println(":"+123+"大于"+123);需要特别注意的时，在使用System.out.println()或System.out.print()输出字符串常量时，不可以出现“回车”，例如，下面的写法无法提高编译
System.out.println("你好，
很高兴认识你");如果需要输出的字符串的长度较长，可以将字符串分解成几部分，然后使用并置符号+将它们首尾相接，例如：
System.out.println("你好，"+
"很高兴认识你");另外，JDK1.5新增了和C语言中printf函数类似的输出数据的方法，格式如下：
System.out.printf("格式控制部分",表达式1，表达式2，表达式3,...,表达式n);格式控制部分由格式控制符号%d、%c、%f、%s和普通的字符组成，普通字符原样输出，格式符号用来输出表达式的值。
%d：输出int类型数据。
%c：输出char型数据。
%f：输出浮点型数据，小数部分最多保留6位。
%s：输出字符串数据。
输出数据时也可以控制数据在命令行的位置，例如：
%md：输出的int型数据占m列。
%m.nf：输出的浮点型数据占m列，小数点保留n位。
例如：
System.out.printf("%d,%f",12,23.78);1.5 数组
如果程序需要更多的int型变量，以这种方式来声明变量是不可取的，这就促使我们学习使用数组。数组是相同类型的变量按顺序组成的一种复合数据类型（数组是一些类型相同的变量组成的集合），称这些相同类型的变量为数组的元素或单元。数组通过数组名加索引来使用数组的元素。
数组属于引用型变量，创建数组需要经过声明和为数组分配变量两个步骤。
1.5.1 声明数组
声明数组包括数组变量的名字（简称数组名）、数组的类型。
声明一维数组有下列两种格式：
数组的元素类型 数组名[];
数组的元素类型 []数组名;
声明二维数组有下列两种格式：
数组的元素类型 数组名[];
数组的元素类型 [][] 数组名;
例如：
float boy[];
char cat[][];那么数组boy的元素都是float类型变量，可以存放float型数据，数组cat的元素的都是char型变量，可以存放char型数据。
可以一次声明多个数组，例如：
int [] a,b;声明了两个int型一维数组a和b，等价声明是：
int a[],b[];注：与C/C++不同，Java不允许声明数组中的方括号内指定数组元素的个数，若声明
int a[12];或
int [12] a;
将导致语法错误。
1.5.2 为数组分配元素
声明数组仅仅是给出了数组变量的名字和元素的数据类型，要想真正地使用数组还必须创建数组，即给数组分配元素。
为数组分配元素地格式如下：
数组名=new 数组元素地类型[数组元素的个数]
例如：
boy=new float[4];为数组分配元素后，数组boy获得4个用来存放float类型数据的变量，即4个float元素。数组变量boy中存放这些元素的首地址，该地址称为数组的引用，这样数组就可以通过索引使用分配给它的变量，即操作它的元素。
数组属于引用型变量，数组变量中存放着数组的首元素的地址，通过数组变量的名字加索引使用数组的元素（内存图如下），例如：
声明数组和创建数组可以一起完成：
float boy[]=new float[4];二维数组和一维数组一样，在声明之后必须使用new运算符为数组分配元素，例如：
int mytwo[][];
mytwo = new int [3][4];或
int mytwo[][]=new int[3][4];构建二维数组的一维数组不必有相同的长度，在创建二维数组是可以分别制定构成二维数组的一维数组的长度，例如：
int a[][]=new int[3][];创建一个二维数组a，a由一个一维数组a[0]、a[1]、a[2]构成，当它们的长度还没有确定，即还没有为这些一维数组分配元素，因此必须要创建a的3个一维数组。
a[0]=new int[6];
a[1]=new int[12];
a[2]=new int[8];注：和C语言不同的是，Java允许使用int型变量的值指定数组的元素的个数，例如：
int size=30; double number[]=new double[size];
1.5.3 数组元素的使用
一维数组通过索引符访问自己的元素，如boy[0]，boy[1]等。需要注意的是索引从0开始，因此，数组若有7个元素，那么所有到6为止，如果程序使用了如下语句：
boy[7]=384.98f;程序可以编译通过，但运行时将发生ArrayIndexOutOfBoundsException异常，因此在使用数组时必须谨慎，防止索引越界。
二维数组也通过索引符访问自己的元素，如a[0][1]，a[1][2]等；需要注意的时索引从0开始，例如声明创建了一个二维数组a：
int a[][]=new int [6][8];那么第一个索引的变化范围从0到5，第二个索引变化范围从0到7。
1.5.4 length的使用
数组的元素的个数称为数组的长度。对于一维数组，“数组名.length“的值就是数组中元素的个数；对于二维数组“数组名.length”的值它包含有的一维数组的个数。例如，对于
float a[] =new float[12];
int b[][]=new int[3][6];a.length的值为12，而b.length的值是3。
1.5.5 数组的初始化
创建数组后，系统会给数组的每个元素一个默认的值，如float型是0.0。
在声明数组的同时也可以给数组的元素一个初始值，如：
float boy[]={21.3f,23.89f,2.0f,23f,778.98f};上述语句相当于：
float boy[]=new float[5];然后
boy[0]=21.3f;boy[1]=23.89f;boy[2]=2.0f;boy[3]=23f;boy[4]=778.98f;也可以直接用若干个一维数组初始化一个二维数组，这些一维数组的长度不尽相同，例如：
int a[][]={{1},{1,1},{1,2,1},{1,3,3,1},{1,4,6,4,1}};1.5.6 数组的引用
数组属于引用型变量，因此两个相同类型的数组如果具有相同的引用，它们就有完全相同的元素。例如，对于：
int a[]={1,2,3},b[]={4,5};数组变量a和b分别存放着引用de6ced和c17164，内存模型如下图：
如果使用了下列赋值语句（a和b的类型必须相同）：
a=b;那么，a中存放的引用和b相同，这时系统将释放最初分配给数组a的元素，使得a的元素和b的元素相同，a、b的内存模型改变为如下图：
例：
public class Main {
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.println("b[0]="+b[0]+",b[1]="+b[1]+",b[2]="+b[2]);
/*数组a的元素个数=4
数组b的元素个数=3
数组a的引用=[I@5b6f7412
数组b的引用=[I@27973e9b
数组a的元素个数=3
数组b的元素个数=3
a[0]=100,a[1]=200,a[2]=300
b[0]=100,b[1]=200,b[2]=300
*/
}
}需要注意的是，对于char型数组a，System.out.println(a)不会输出数组a的引用而是输出数组a的全部元素的值，对于：
char a[]={'中','国','科','大'};下列
System.out.println(a);的输出结果是：
//中国科大如果像输出char型数组的引用，必须让数组a和字符串做并置运算，例如：
输出数组a的引用：
//b4c966a