Java基础Word格式文档下载.docx
《Java基础Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《Java基础Word格式文档下载.docx（20页珍藏版）》请在冰豆网上搜索。
布尔型数据只有两个值true和false，且它们不对应于任何整数值。
布尔型变量的定义如：
booleanb=true;
2．字符类型--char
字符常量：
字符常量是用单引号括起来的一个字符，如'
，'
A'
字符型变量：
类型为char，它在机器中占16位，其范围为0～65535。
字符型变量的定义如：
charc='
/*指定变量c为char型，且赋初值为'
*/
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
3.4e-038～3.4e+038
double
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赋值'
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
=<
=
==!
9
10
^
11
|
12
13
||
14
?
:
15
=+=-=*=/=%=^=
=|=<
=>
例如，下述条件语句分四步完成：
Result=sum==0?
1:
num/sum;
第1步：
result=sum==0?
（num/sum）
第2步：
result=（sum==0）?
第3步：
result=（（sum==0）?
（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;
…………
casevalueN:
statemendN;
[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语句
do{
}while（termination）;
3．for语句
for（initialization;
termination;
iteration）{
◇for语句执行时，首先执行初始化操作，然后判断终止条件是否满足，如果满足，则执行循环体中的语句，最后执行迭代部分。
完成一次循环后，重新判断终止条件。
◇初始化、终止以及迭代部分都可以为空语句（但分号不能省），三者均为空的时候，相当于一个无限循环。
◇在初始化部分和迭代部分可以使用逗号语句，来进行多个操作。
逗号语句是用逗号分隔的语句序列。
for（i=0,j=10;
i<
j;
i++,j--）{
……
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;
10;
i++）{//外层循环
inner:
for（intj=0;
j<
j++）{//内层循环
if（i<
j）{
……
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（"
//为第一个数组元素开辟空间
stringArray[1]=newString（"
are"
//为第二个数组元素开辟空间
stringArray[2]=newString（"
//为第三个数组元素开辟空间
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;
3;
j++）
a[i][j]=（i+1）*（j+2）;
i++）{
j<
4;
j++）{
c[i][j]=0;
for（k=0;
k<
k++）
c[i][j]+=a[i][k]*b[k][j];
}
}
System.out.println（"
*******MatrixC
升级会员 