JAVA教程第二讲Java语言基础知识.docx
《JAVA教程第二讲Java语言基础知识.docx》由会员分享，可在线阅读，更多相关《JAVA教程第二讲Java语言基础知识.docx（15页珍藏版）》请在冰豆网上搜索。
JAVA教程第二讲Java语言基础知识
2．1简单数据类型
2．1．1标识符和保留字
1．标识符
程序员对程序中的各个元素加以命名时使用的命名记号称为标识符（identifier）。
Java语言中，标识符是以字母，下划线（_）,美元符（$）开始的一个字符序列，后面可以跟字母，下划线，美元符，数字。
例如，identifier，userName，User_Name，_sys_val，$change为合法的标识符，而2mailroom#，class为非法的标识符。
2．保留字
具有专门的意义和用途，不能当作一般的标识符使用，这些标识符称为保留字（reservedword）,也称为关键字，下面列出了java语言中的所有保留字：
bstract，break，byte，boolean，catch，case，class，char，continue，default，double，do，else，extends，false，final，float，for，finally，if，import，implements，int，interface，instanceof，long，length，native，new，null，package，private，protected，public，return，switch，synchronized，short，static，super，try，true，this，throw，throws，threadsafe，transient，void，while。
java语言中的保留字均用小写字母表示。
2．1．2数据类型概
1．java中的数据类型划分
java语言的数据类型有简单类型和复合类型：
简单数据类型包括：
整数类型（Integer）：
byte，short，int，long
浮点类型（Floating）：
float，double
字符类型（Textual）：
char
布尔类型（Logical）：
boolean
复合数据类型包括：
class
interface
数组
2．常量和变量
常量：
用保留字final来实现
finaltypeSpecifiervarName=value[,varName[=value]…];
如：
finalintNUM=100;
变量：
是java程序中的基本存储单元，它的定义包括变量名、变量类型和作用域几个部分。
其定义格式如下：
typeSpecifiervarName[=value[,varName[=value]…];
如：
intcount;charc='a';
变量的作用域指明可访问该变量的一段代码，声明一个变量的同时也就指明了变量的作用域。
按作用域来分，变量可以有下面几种：
局部变量、类变量、方法参数和例外处理参数。
在一个确定的域中，变量名应该是唯一的。
局部变量在方法或方法的一个块代码中声明，它的作用域为它所在的代码块（整个方法或方法中的某块代码）。
类变量在类中声明，而不是在类的某个方法中声明，它的作用域是整个类。
方法参数传递给方法，它的作用域就是这个方法。
例外处理参数传递给例外处理代码，它的作用域就是例外处理部分。
2．1．3简单数据类型
1．布尔类型--boolean
布尔型数据只有两个值true和false，且它们不对应于任何整数值。
布尔型变量的定义如：
booleanb=true;
2．字符类型--char
字符常量：
字符常量是用单引号括起来的一个字符，如'a'，'A';
字符型变量：
类型为char，它在机器中占16位，其范围为0～65535。
字符型变量的定义如：
charc='a';/*指定变量c为char型，且赋初值为'a'*/
3．整型数据
整型常量：
◇十进制整数
如123，－456，0
◇八进制整数
以0开头，如0123表示十进制数83，－011表示十进制数－9。
◇十六进制整数
以0x或0X开头，如0x123表示十进制数291，－0X12表示十进制数－18。
整型变量：
数据类型
所占位数
数的范围
byte
8
-27～27-1
bhort
16
-215～215-1
int
32
-231～231-1
long
64
-263～263-1
4．浮点型（实型）数据
实型常量：
◇十进制数形式
由数字和小数点组成，且必须有小数点，如0.123,1.23,123.0
◇科学计数法形式
如：
123e3或123E3，其中e或E之前必须有数字，且e或E后面的指数必须为整数。
◇float型的值,必须在数字后加f或F,如1.23f。
实型变量：
数据类型
所占位数
数的范围
float
32
3.4e-038～3.4e+038
double
64
1.7e-038～1.7e+038
5．简单数据类型的例子：
【例2．1】
publicclassAssign{
publicstaticvoidmain（Stringargs[]）{
intx,y;//定义x，y两个整型变量
floatz=1.234f;//指定变量z为float型，且赋初值为1.234
doublew=1.234;//指定变量w为double型，且赋初值为1.234
booleanflag=true;//指定变量flag为boolean型，且赋初值为true
charc;//定义字符型变量c
Stringstr;//定义字符串变量str
Stringstr1="Hi";//指定变量str1为String型，且赋初值为Hi
c='A';//给字符型变量c赋值'A'
str="bye";//给字符串变量str赋值"bye"
x=12;//给整型变量x赋值为12
y=300;//给整型变量y赋值为300
}
}
2．1．4简单数据类型中各类型数据间的优先关系和相互转换
1．不同类型数据间的优先关系如下：
低------------------------------------------->高
byte,short,char->int->long->float->double
2．自动类型转换规则
整型,实型,字符型数据可以混合运算。
运算中，不同类型的数据先转化为同一类型，然后进行运算，转换从低级到高级；
操作数1类型
操作数2类型
转换后的类型
byte、short、char
int
int
byte、short、char、int
long
long
byte、short、char、int、long
float
float
byte、short、char、int、long、float
double
double
3．强制类型转换
高级数据要转换成低级数据，需用到强制类型转换，如：
inti;
byteb=（byte）i;/*把int型变量i强制转换为byte型*/
2．2运算符和表达式
2．2．1运算符
对各种类型的数据进行加工的过程成为运算，表示各种不同运算的符号称为运算符，参与运算的数据称为操作数，按操作数的数目来分，可有：
◇一元运算符：
＋＋，－－，＋，－
◇二元运算符：
＋，－，>
◇三元运算符：
？
：
基本的运算符按功能划分，有下面几类：
1 算术运算符：
+，―，*，/，%，++，――。
例如：
3+2;
a-b;
i++;
--i;
2 关系运算符：
>，<，>=，<=，==，!
=。
例如：
count>3;
I==0;
n!
=-1;
3 布尔逻辑运算符：
!
，&&，||。
例如：
flag=true;
!
（flag）;
flag&&false;
4 位运算符：
>>，<<，>>>，&，|，^，~。
例如：
a=10011101;b=00111001；则有如下结果：
a<<3=11101000;
a>>3=11110011a>>>3=00010011;
a&b=00011001;a|b=10111101;
~a=01100010;a^b=10100100;
5 赋值运算符=，及其扩展赋值运算符如+=，―=，*=，/=等。
例如：
i=3;
i+=3; //等效于i=i+3;
6 条件运算符?
：
例如：
result=（sum==0?
1:
num/sum）;
7 其它：
包括分量运算符·，下标运算符[]，实例运算符instanceof，内存分配运算符new，强制类型转换运算符（类型），方法调用运算符（）等。
例如：
System.out.println（"helloworld"）;
intarray1[]=newint[4];
2．2．2表达式
表达式是由操作数和运算符按一定的语法形式组成的符号序列。
一个常量或一个变量名字是最简单的表达式，其值即该常量或变量的值；表达式的值还可以用作其他运算的操作数，形成更复杂的表达式。
1．表达式的类型
表达式的类型由运算以及参与运算的操作数的类型决定，可以是简单类型，也可以是复合类型：
布尔型表达式：
x&&y||z;
整型表达式：
num1+num2;
2．运算符的优先次序
表达式的运算按照运算符的优先顺序从高到低进行,同级运算符从左到右进行：
优先次序
运算符
1
.[]（）
2
++--!
~instanceof
3
new（type）
4
*/%
5
+-
6
>>>>><<
7
><>=<=
8
==!
=
9
&
10
^
11
|
12
&&
13
||
14
?
:
15
=+=-=*=/=%=^=
16
&=|=<<=>>=>>>=
例如，下述条件语句分四步完成：
Result=sum==0?
1:
num/sum;
第1步：
result=sum==0?
1:
（num/sum）
第2步：
result=（sum==0）?
1:
（num/sum）
第3步：
result=（（sum==0）?
1:
（num/sum））
第4步：
result=
2．3控制语句
Java程序通过控制语句来执行程序流，完成一定的任务。
程序流是由若干个语句组成的，语句可以是单一的一条语句，如c=a+b,也可以是用大括号{}括起来的一个复合语句。
Java中的控制语句有以下几类：
◇分支语句：
if-else,switch
◇循环语句：
while,do-while,for
◇与程序转移有关的跳转语句：
break,continue,return
◇例外处理语句：
try-catch-finally,throw
◇注释语句：
//，/**/，/***/
2．3．1分支语句
分支语句提供了一种控制机制，使得程序的执行可以跳过某些语句不执行，而转去执行特定的语句。
1．条件语句if-else
if（boolean-expression）
statement1;
[elsestatement2;]
2．多分支语句switch
switch（expression）{
casevalue1:
statement1;
break;
casevalue2:
statement2;
break;
…………
casevalueN:
statemendN;
break;
[default:
defaultStatement;]
}
◇表达式expression的返回值类型必须是这几种类型之一：
int,byte,char,short。
◇case子句中的值valueN必须是常量，而且所有case子句中的值应是不同的。
◇default子句是可选的。
◇break语句用来在执行完一个case分支后，使程序跳出switch语句，即终止switch语句的执行（在一些特殊情况下，多个不同的case值要执行一组相同的操作，这时可以不用break）。
2．3．2循环语句
循环语句的作用是反复执行一段代码，直到满足终止循环的条件为止。
Java语言中提供的循环语句有：
◇while语句
◇do-while语句
◇for语句
1．while语句
[initialization]
while（termination）{
body;
[iteration;]
}
2．do-while语句
[initialization]
do{
body;
[iteration;]
}while（termination）;
3．for语句
for（initialization;termination;iteration）{
body;
}
◇for语句执行时，首先执行初始化操作，然后判断终止条件是否满足，如果满足，则执行循环体中的语句，最后执行迭代部分。
完成一次循环后，重新判断终止条件。
◇初始化、终止以及迭代部分都可以为空语句（但分号不能省），三者均为空的时候，相当于一个无限循环。
◇在初始化部分和迭代部分可以使用逗号语句，来进行多个操作。
逗号语句是用逗号分隔的语句序列。
for（i=0,j=10;i ……
}
2．3．3跳转语句
◇break语句
◇continue语句
◇返回语句return
1．break语句
◇在switch语中，break语句用来终止switch语句的执行。
使程序从switch语句后的第一个语句开始执行。
◇在Java中，可以为每个代码块加一个括号，一个代码块通常是用大括号{}括起来的一段代码。
加标号的格式如下：
BlockLabel:
{codeBlock}
break语句的第二种使用情况就是跳出它所指定的块，并从紧跟该块的第一条语句处执行。
例如：
breakBlockLabel；
break语句
a:
{……//标记代码块a
b:
{……//标记代码块b
c:
{……//标记代码块c
breakb;
……//此处的语句块不被执行
}
……/此处的语句块不被执行
}
……//从此处开始执行
}
2．continue语句
continue语句用来结束本次循环，跳过循环体中下面尚未执行的语句，接着进行终止条件的判断，以决定是否继续循环。
对于for语句，在进行终止条件的判断前，还要先执行迭代语句。
它的格式为：
continue；
也可以用continue跳转到括号指明的外层循环中，这时的格式为
continueouterLable;
例如：
outer:
for（inti=0;i<10;i++）{//外层循环
inner:
for（intj=0;j<10;j++）{//内层循环
if（i ……
continueouter;
}
……
}
……
}
3．返回语句return
return语句从当前方法中退出，返回到调用该方法的语句处，并从紧跟该语句的下一条语句继续程序的执行。
返回语句有两种格式：
returnexpression;
return;
return语句通常用在一个方法体的最后,否则会产生编译错误,除非用在if-else语句中
2．3．4例外处理语句
包括try,catch,finally,throw语
2．4数组
java语言中，数组是一种最简单的复合数据类型。
数组是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和下标来唯一地确定数组中的元素。
数组有一维数组和多维数组。
2．4．1一维数组
1．一维数组的定义
typearrayName[]；
类型（type）可以为Java中任意的数据类型，包括简单类型和复合类型。
例如：
intintArray[]；
DatedateArray[];
2．一维数组的初始化
◇静态初始化
intintArray[]={1,2,3,4};
StringstringArray[]={"abc","How","you"};
◇动态初始化
1）简单类型的数组
intintArray[];
intArray=newint[5];
2）复合类型的数组
StringstringArray[];
StringstringArray=newString[3];/*为数组中每个元素开辟引用
空间（32位）*/
stringArray[0]=newString（"How"）;//为第一个数组元素开辟空间
stringArray[1]=newString（"are"）;//为第二个数组元素开辟空间
stringArray[2]=newString（"you"）;//为第三个数组元素开辟空间
3．一维数组元素的引用
数组元素的引用方式为：
arrayName[index]
index为数组下标，它可以为整型常数或表达式，下标从0开始。
每个数组都有一个属性length指明它的长度，例如：
intArray.length指明数组intArray的长度。
2．4．2多维数组
Java语言中，多维数组被看作数组的数组。
1．二维数组的定义
typearrayName[][]；
type[][]arrayName;
2．二维数组的初始化
◇静态初始化
intintArray[][]={{1,2},{2,3},{3,4,5}};
Java语言中，由于把二维数组看作是数组的数组，数组空间不是连续分配的，所以不要求二维数组每一维的大小相同。
◇动态初始化
1）直接为每一维分配空间，格式如下：
arrayName=newtype[arrayLength1][arrayLength2];
inta[][]=newint[2][3]；
2）从最高维开始，分别为每一维分配空间：
arrayName=newtype[arrayLength1][];
arrayName[0]=newtype[arrayLength20];
arrayName[1]=newtype[arrayLength21];
…
arrayName[arrayLength1-1]=newtype[arrayLength2n];
3）例：
二维简单数据类型数组的动态初始化如下,
inta[][]=newint[2][]；
a[0]=newint[3];
a[1]=newint[5];
对二维复合数据类型的数组，必须首先为最高维分配引用空间，然后再顺次为低维分配空间。
而且，必须为每个数组元素单独分配空间。
例如：
Strings[][]=newString[2][];
s[0]=newString[2];//为最高维分配引用空间
s[1]=newString[2];//为最高维分配引用空间
s[0][0]=newString（"Good"）;//为每个数组元素单独分配空间
s[0][1]=newString（"Luck"）;//为每个数组元素单独分配空间
s[1][0]=newString（"to"）;//为每个数组元素单独分配空间
s[1][1]=newString（"You"）;//为每个数组元素单独分配空间
3．二维数组元素的引用
对二维数组中的每个元素，引用方式为：
arrayName[index1][index2]
例如：
num[1][0];
4．二维数组举例：
【例2．2】两个矩阵相乘
publicclassMatrixMultiply{
publicstaticvoidmain（Stringargs[]）{
inti,j,k;
inta[][]=newint[2][3];//动态初始化一个二维数组
intb[][]={{1,5,2,8},{5,9,10,-3},{2,7,-5,-18}};//静态初始化
一个二维数组
intc[][]=newint[2][4];//动态初始化一个二维数组
for（i=0;i<2;i++）
for（j=0;j<3;j++）
a[i][j]=（i+1）*（j+2）;
for（i=0;i<2;i++）{
for（j=0;j<4;j++）{
c[i][j]=0;
for（k=0;k<3;k++）
c[i][j]+=a[i][k]*b[k][j];
}
}
System.out.println（"**
升级会员 