java Microsoft Word 文档.docx
《java Microsoft Word 文档.docx》由会员分享，可在线阅读，更多相关《java Microsoft Word 文档.docx（86页珍藏版）》请在冰豆网上搜索。
javaMicrosoftWord文档
文本注释Comments：
注释必须写上，以便其他人阅读、引用和维护。
单行注释//...
多行注释/*....*/
文档注释/**...*/
文档注释，可以使用JDK的javadoc工具从原文件中抽取这种注释形成程序的帮助文档。
使用javadoc命令建立HTML格式的程序文档:
javadoc[options][packagenames][sourcefiles][@files]
标示符：
用来给一个类、变量或方法命名的符号
标示符命名规则：
1.以字母，“_”和“$”开头。
可以包含字母、数字、“_”和“$”。
2.大小写敏感
3.不能与保留关键字冲突
4.没有长度限制（暗示使用长的标示符，以便阅读。
长名字可使用工具输入）
5.建议使用JavaBeans规则命名，并根据方法的目的，以set、get、is、add或remove开头。
标示符命名约定：
1.类名、接口名：
每个单词的首字母应该大写，尤其第一个单词的首字母应该大写。
（驼峰规则）
classMyFirstClass
interfaceWeapon
2.字段、方法以及对象：
第一个单词首字母应小写，其他单词首字母大写。
（以便跟上面的有所区别）
booleanisWoman
voidsetName（Stringname）
3.常量：
全部用大写字母表示。
如果由几个单词组成，则由下画线连接。
publicfinalintGREEN
publicfinalintHEAD_COUNT
4.Java包（Package）：
全部用小写字母。
packagejava.awt.event
java.lang.System.gc（）;/java.lang.Runtime.gc（）;
垃圾回收的建议语句,只能建议而不能强制回收
注意：
System.gc（）;是静态方法，可直接调用。
java.lang.Runtime.gc（）;不是静态方法，不能直接在main方法里调用
package包
目的：
命名冲突，便于管理类
运行时，先找到包所在目录，再执行“包名.类名”
import导入。
导入包内的类
定义包之后，执行时：
javac-d包的路径类名.java
java包名.类名
importjava.util.*;//表示导入java.util里面的所有类；但importjava.*;则什么类都导不进
用“*”表示导入当前包的类，不包括子包的类（可把包看作目录）。
声明规则
＊一个源代码文件最多只能有一个公共（public）类。
＊如果源文件包含公共类，则该文件名称应该与公共类名称相同。
＊一个文件只能有一个包语句，但是，可以有多个导入语句。
＊包语句（如果有的话）必须位于源文件的第一行。
＊导入语句（如果有的话）必须位于包之后，并且在类声明之前。
＊如果没有包语句，则导入语句必须是源文件最前面的语句。
＊包和导入语句应用于该文件中的所有类。
＊一个文件能够拥有多个非公共类。
＊没有公共类的文件没有任何命名限制。
输入：
使用Scanner获取输入
在J2SE5.0中，可以使用java.util.Scanner类别取得使用者的输入
可以使用这个工具的next（）功能，来获取用户的输入
Scanners=newScanner（System.in）;
System.out.printf（"您输入了字符：
%s\n",s.next（））;
System.out.printf（"您输入了数字：
%d\n",s.nextInt（））;
输入：
使用BufferedReader取得输入//5.0之前的读取键盘的方法
BufferedReader建构时接受java.io.Reader物件
可使用java.io.InputStreamReader
例:
importjava.io.InputStreamReader;
importjava.io.BufferedReader;
classn{
publicstaticvoidmain（String[]args）{
System.out.println（"请输入一列文字，包括空格：
"）;
BufferedReaders=newBufferedReader（newInputStreamReader（System.in））;
Stringnext;
try{next=s.readLine（）;//此语句会抛异常，需处理
System.out.println（"您输入了文字：
"+next）;
}catch（Exceptione）{}
}}
数值保存方式：
正数＝二进制
负数＝补码
补码＝反码+1正数＝负数的补码（反码+1）
反码＝非（二进制数）
八进制数，零开头011（八进制）＝9（十进制）
十六进制数，零x开头0x55（十六进制）＝5*16+5（十进制）
类型：
数据都必须有类型
boolean（8bit,不定的）只有true和false两个值
char16bit,0~2^16-1（2^16=6万6）
byte8bit,-2^7~2^7-1（2^7=128；注意：
两个byte数相加，变int型）
short16bit,-2^15~2^15-1（2^15=32768）
int32bit,-2^31~2^31-1（2147483648,20亿,10位有效数字）
long64bit,-2^63~2^63-1（900亿亿,20位有效数字）
float32bit,9位有效数字，含小数（四舍五入）（小数点算一位，正负号不算）
double64bit,18位有效数字
注：
float和double的小数部分不可能精确，只能近似。
比较小数时，用doublei=0.01;if（i-0.01<1E-6）...
不能直接if（i==0.01）...
默认，整数是int类型，小数是double类型
long类型值，需跟L或l在数据后；float类型要跟f或F；或强制类型转换
科学计数法：
12.5E3
类型转换默认序列：
byte>short>int>long>float>double
char」
注意：
默认类型转换（自动类型提升）会丢失精度，但只有三种情况：
int>float;long>float;long>double.看一下他们的有效位就明白。
二进制是无法精确的表示0.1的。
进行高精度运算可以用java.math包中BigDecimal类中的方法。
自动类型提升又称作隐式类型转换。
强制类型转换：
intti;（byte）ti;
强制转换，丢弃高位
宣告变量名称的同时，加上“final”关键词来限定，这个变量一但指定了值，就不可以再改变它的值
如：
finalintn1=10;n1=20;这就会报错
输出命令：
System.out.println（）会自动换行的打印
System.out.print（）直接打印，不会自动换行
System.out.printf（）可插入带%的输入类型,前两种只可以插入转义符,不能插入%的数据或字符串
在printf里面,输出有5个部分%[argument_index$][flags][width][.precision]conversion
以“％”开头，[第几个数值$][flags][宽度][.精确度][格式]
printf（）的引入是为了照顾c语言程序员的感情需要
格式化输出Formatter；格式化输入Scanner；正则表达式
输出格式控制：
转义符：
\ddd1到3位8进制数指定Unicode字符输出（ddd）
\uxxxx1到4位16进制数指定Unicode字符输出（xxxx）
\\\
\''
\""
\b退格（光标向左走一格）
\f走纸转页,换页
\n换行
\r光标回到行首，不换行
\t跳格
%%%
%d输出10进位整数，只能输出Byte、Short、Integer、Long、或BigInteger类型。
（输出其他类型会抛异常）
%f以10进位输出浮点数，提供的数必须是Float、Double或BigDecimal（输出Integer类型也抛异常）
%e,%E以10进位输出浮点数，并使用科学记号，提供的数必须是Float、Double或BigDecimal
%a,%A用科学记号输出浮点数,以16进位输出整数部份,以10进位输出指数部份,数据类型要求同上。
%o（字母o）以8进位整数方式输出，限数据类型:
Byte,Short,Integer,Long或BigInteger
%x,%X将浮点数以16进位方式输出，数据类型要求同上
%s,%S将字符串格式化输出（可输出任何类型）
%c,%C以字符方式输出，提供的数必须是Byte、Short、Character或Integer
%b,%B输出"true"或"false"（%B输出"TRUE"或"FALSE"）;另外,非空值输出true,空值输出false
%t,%T输出日期/时间的前置，详请看在线API文件
/********找出各字符的Unicode值*******************/
classTest{
publicstaticvoidmain（String[]args）{
Strings=""+0+'a';//0=48,9=57
//A=65,Z=90;a=97,z=122;空格=32
inti=s.codePointAt（0）;
intj=s.codePointAt
（1）;
//利用这codePointAt（intindex）方法
System.out.printf（"%d%d",i,j）;
}}
/**********************************************/
字符串的拼接：
字符串+数值＝字符串
数值+字符串＝字符串
如：
str+10+20＝＝str1020而10+20+str＝＝30str
"+"和"+="都被重载了，具有合并字符串的能力，相当于String类里的concat（）；
运算：
算术运算：
加（+）减（－）乘（*）除（/）取余（％）
％取余运算：
2%3=2100%3=1
赋值运算符：
=+=－=*=/=%=
（先运行完右边的，再跟左边的进行赋值运算；如inti=10;i-=3*5;结果-5）
<<=>>=
比较、条件运算：
大于>不小于>=小于<不大于<=等于==不等于!
=
逻辑运算：
短路运算（且&&或||）非短路运算（&|）反相!
短路运算：
当前面一个表达式可以决定结果时，后面的语句不用再判断。
非短路运算时，还照样判断后面的
位运算：
&（AND）|（OR）^（XOR异或）~（补码）按位取反＝加1再取反（全1的补码是-1）
移位运算：
>><<>>>
>>右移:
全部向右移动,移到右段的低位被舍弃,最高位则移入原来最高位的值。
右移一位相当于除2取商。
>>>同上，只是最高位移入0（不带符号）。
因为最高位是符号位，所以负数跟>>有区别，正数没区别。
12>>>33为12>>（33%32）＝12>>1=6；因为int型只有32位，认为全移走后就没意义
1<<32为1
instanceof（）：
用户判断某一个对象是否属于某一个类的实例。
“＝＝”双等于号，比较数值是否相等。
还可以用于比较两个引用，看他们引用的地址是否相等。
在Object类里equals（）跟“＝＝”功能一样；但可以重载定义一个比较两者意义是否相等的方法。
在java里可以把赋值语句连在一起写，如：
x=y=z=5;这样就x,y,z都得到同样的数值5
两个数相运算时，默认是int类型
如果有更高级的，就按高级的那个类型
if（其中一个是double型）double型；
elseif（其中一个是float型）float型；
elseif（其中一个是long型）long型；
elseint型。
选择：
if（...）{...}else{...}
if（...）{...}elseif（...）{...}
if（...）{...if（...）{...}}
三重以上的选择，建议使用switch
switch（charc）{
casec1:
...;break;
casec2:
...;break;
...
default:
...;
}/*switch的括号里只能用int和枚举类型
能隐式转换为int的也可以：
byte,short,char,Integer,Short,Character,Byte等。
不能用long、小数类型（float,double）和String。
case后的值必须是常量。
而包装类变量（Integer,Character）不会被视作常量。
*/
循环：
for（初始表达式;布尔表达式;步进）循环语句;
跟C的for一样，for的初始化条件、结束条件、增量都可以不写。
但条件判断部分只能是boolean值，所以只能是一条条件判断语句。
for循环一般用在循环次数已知的情况。
while（）...;
do...;while（）;注意：
do后最好用“{}”，while后的分号不可忘。
break和continue
break退出当前的循环体，在嵌套循环中，只退出当前的一层循环。
continue结束当前本次循环，继续进行下一轮的循环。
可以说，只是本次忽略循环内后面的语句。
continue只能在循环体内用。
break可以用在任意代码块中，表示退出当前程序块（配合标签使用，很好用）
这两个相当于JAVA里的goto语句。
注意：
（个人归结的）
循环体内申明的变量，在循环体结束后立即释放，循环体外无法使用。
但在另外一个循环体内可以再次申明一个跟前面同名的变量，互相不影响。
如for内定义的i：
for（inti=0;i<10;i++）{...}
则在上式for循环结束后无法再调用i值，还会报错。
for（inti=0;i<10;i++）{...}和后面的for（inti=0;i<3;i++）{...}互不影响
若想循环体外还可以调用for循环体内的值，应先在体外定义。
如：
inti;for（i=0;i<10;i++）{...}则for循环后再调用i值，其值为10
关键字列表：
abstractbooleanbreakbytecasecatchcharclass
continuedefaultdodoubleelseextendsenumfalse
finalfinallyfloatforifimplementsimportinstanceof
intinterfacelongnativenewnullpackageprivate
protectedpublicreturnshortstaticsuperswitchsynchronized
thisthrowthrowstransienttruetryvoidvolatilewhile
Java中true、false不是关键字,而是boolean类型的字面量。
但也不能当作变量用。
所有的关键字都是小写，friendly，sizeof不是java的关键字
保留字：
const，goto：
这两个已经削去意义，但同样不能用作变量名。
第三章对象
名词
对象：
类：
一类属性相同的对象
属性：
是什么样
方法：
能做什么（C中叫作函数）
对象:
声明：
Students;
这时我们只是说明s是一个能够指向Student类型的引用（相当于C++中的指针）,并没有创建一个对象。
所以我们此时不能对s做任何操作。
初始化：
s=newStudent（）;
向系统申请一块存储空间（地址空间），该地址空间保存的是一个Student类型的数据。
而s中保存的就是该地址空间的首地址。
变量：
内存空间中一块具有固定长度的，用来保存数据的地址空间。
（s也是一个变量）
一个对象可以有多个引用指向。
Student[]s=newStudent[3]只是相当于声明一个长度为3的Student类型的数组。
实例变量和局部变量
实例变量：
1、在一个类中，任何方法之外定义的变量；
2、从面向对象的思想来说我们又把实例变量看成一个类的属性。
3、实例变量在没有符初值时系统会自动帮我们做初始化：
整型数据初始化为0，布尔型数据初始化为false，对象类型初始化为null。
实例变量的作用域在本类中完全有效，当被其他的类调用的时候也可能有效。
局部变量：
1、在方法内定义的变量叫局部变量。
2、局部变量使用前必须初始化，系统不会自动给局部变量做初始化。
3、局部变量的生命范围在他所在的代码块，在重合的作用域范围内不允许两个局部变量命名冲突。
注：
局部变量与实例变量允许同名，在局部变量的作用域内，其优先级高于实例变量。
我们可以用this.实例变量名以区分局部变量。
第四章数组
数组：
数组也是对象
数组中保存着多个相同类型的元素
数组中的每一个元素都是变量
可以创建数组对象，但数组里只能放对象的引用，不能直接放对象进去
数组的创建：
1.声明一个int数组变量，数组变量是数组对象的遥控器
int[]nums;
2.创建大小为7的数组，并将它赋值给变量nums
nums=newint[7];
3.赋于int数组每一个元素一个int值
nums[0]=6;nums[1]=34;nums[2]=23;nums[3]=4;
多维数组：
1.定义方式：
type维数 arrayName；
如：
int[][]b=newint[2][1];
2.分配内存空间,有两种方法：
直接为每一维分配空间:
int[][]a=newint[2][3]；
分别为每一维分配空间int[][]a=newint[2][]；//列数可以没有，行数则一定要有
a[0]=newint[3];a[1]=newint[5];//a[][]看成一维数组
可以为每行设置为空间大小不同的数组。
3.初始化,有两种方式：
先定义数组，分配空间，然后直接对每个元素进行赋值（一个个写，或用for函数）
在定义数组的同时进行初始化。
如：
inta[][]={{2,3},{1,5},{3,4}};
java实质上把多维数组看作一维数组，但数组里的元素也是一个数组，即数组的数组
多维数组的长度＝行数；（a.length=行数；a[0].length=列数）
创建数组对象的另外几种方式：
Int[]nums={6,34,23,4,15,0,57};（java形式）
这方法只能在初始化定义的时候可以，以后再想定义nums={...}就不行了
Int[]nums=newint[]{6,34,23,4,15,0,57};
这句的后一个int[]内不能填数字，怕人弄错数目；
这句可以先int[]nums;以后再另外定义nums=newint[]{...}
[]可以换换位置，如：
Intnums[];（C和C++形式）
注意：
short[]z[][];//这是合法的，定义一个三维数组
声明数组时，不能定义其大小；只有new数组时可以定大小。
数组元素的默认值:
byteshortintlong为0
floatdouble为0.0
char为‘\0’
boolean为false
引用类型为null
数组的length属性:
表示数组的长度，是指这个数组最多能保存的元素个数
length属性只能被读取，不能被修改
java.lang.ArrayIndexOutOfBoundsException:
（这是数组下标越界的报错）
随机数：
Math.random（）;//可以产生随机的0~1的小数,不需导包
java.util.Random;//可以产生更加多种的随机数
0~100的一个随机整数（包括0，但不包括100）：
Doubled=100*Math.random（）;intr=d.intValue（）;//方法一
Randomr=newRandom（）;intnum=r.nextInt（100）;//方法二；需要importjava.util.Random;
可以直接在程序中写这句，而临时导入inti=newjava.util.Random（）.nextInt（100）;
Arrays.sort（数组名）
排序算法。
需导入imporjava.util.Arrays;
数组的拷贝:
1.用for语句，将数组的元素逐个赋值。
直接如果直接将数组a=数组b;则是将b的指针赋给a
2.用System.arraycopy（）;
arraycopy（Objectsrc,int srcPos,Object dest,int destPos,int length）
src-源数组。
srcPos-源数组中的起始位置。
dest-目标数组。
destPos-目标数据中的起始位置。
length-要复制的数组元素的数量。
如：
System.arraycopy（a,0,b,0,a.length）;//把数组a全部复制到数组b中
在java中对面向对象（OO）的要求
1．对象是客观存在的，万物皆对象。
（注：
看不见的对象并不表示该对象不存在，比如说事件）；
2．简单性：
采用面向对象方法可以使系统各部分各司其职各尽所能。
3．复用性：
对象
升级会员 