javaWord文档格式.docx

javaWord文档格式.docx

《javaWord文档格式.docx》由会员分享，可在线阅读，更多相关《javaWord文档格式.docx（140页珍藏版）》请在冰豆网上搜索。

　　java 

demo>

out.txt 

意思是将demo中的结果输出到out.txt中。

>

意思是将demo中的结果追加定向输出到out.txt中。

　　注:

System.err不支持定向输出

四、1.输出字符串的方法在JDK1.5之前主要是println（）、print（）

在JDK1.5之后增加了printf（）:

进行格式化字符串输出

　　2.有时在需要输出双引号、单引号等，这时候需要转化。

要输出"

中国"

，　println（“\"

中国\"

”）　

　　“\”在这个过程中起一个转化作用

　　常见的输出格式控制：

　　\\：

反斜杠

　　\"

：

双引号

　　\'

单引号

　　\n：

换行

　　\t：

跳格（一个Tab键）

　　\b：

倒退一个字符

　　\f：

换页

　　\r：

游标移致行首

　　\xxx：

以8进制数Unicode字符输出

　　\uxxxx：

以16进制数Unicode字符输出

　　3.格式字符

　　%%：

在字符串中显示%

　　%d:

以10进制整数方式输出，提供的数必须是Byte 

Short 

Long 

Integer 

BigInteger

　　%f:

将浮点数以10进位方式输出，提供的数必须是Float 

Double 

BigDecimal

　　%e 

%E:

使用科学计数法将浮点数以10进位方式输出，提供的数必须是Float 

　　%s 

%S:

将字符串格式化输出

　　%c 

%C:

以字符方式输出，提供的数必须是Byte 

Character 

Integer

　　%b 

%B:

将“true”和“false”输出，注：

非null值输出的是true,null输出的是false

五、基本数据类型

　　JAVA中的基本数据类型不是以对象形式存在的，所以JAVA不是100%的面向对象的语言。

　　四大类数据类型：

整型 

浮点型 

字符型 

布尔型 

　　整型：

没有小数点的数

　　整型又分为四种：

字节型（byte） 

短整型（short） 

整型（int） 

长整型（long） 

整型占4个字节

　　byte:

范围：

-128~127 

在JAVA中占一个字节（一个字节是8位）

　　short:

+-3万左右 

占2个字节

　　int:

范围 

+-21亿左右 

占4个字节

　　long:

范围:

21亿 

占8个字节

　　浮点型：

float（单精度） 

double（双精度）

　　浮点数：

小数

　　float:

占4字节 

小数点后6-7位

　　double:

占8个字节 

小数点后15位（一般常用double型）

a=0.12345--->

double型,默认是double型

b=0.123456F--->

float型

　　字符型（char）:

　　java中每一个字符中占2个字节

　　放在单引号中的叫字符，单引号内只能放一个字符，如“ab”--->

错误

　　放在又引号中的叫字符串

在java当中 

，无论是一个汉字（你）、一个数字（5）、一个字母（x）都表示一个字符，占两个字节。

　　如“你好abc”一共有5个字符

　　布尔型（boolean）：

　　用来表示逻辑的真假，一个布尔型占内存的2个字节，只有两个值：

true 

false 

　　注：

没有0 

1 

no 

yes 

六、基本数据类型知识点：

　　1.整型中最常用的是int型，浮点型常用的是double型

　　2.JAVA是面向对象的语言，基本数据类型不是以对象形式存在的

　　3.JAVA的基本数据类型在不同的平台上长度是统一的。

　　4.如果直接声明3.2这样的浮点数，默认是double型的。

可以通过在数的后面加上D 

F,来明确数据类型。

　　5.JAVA中有一个任意精度的算术包，称为“大数字”，不过虽然名字叫做大数字。

“Big 

number”并不是新的

java类型，而是java对象。

七、变量

　　1.java是一种强类型的语言，在java中使用变量，必须先声明变量名称和数据类型。

int 

age;

//声明一个整型变量

double 

score;

//声明一个双精度浮点数变量

　　（javacript是一种弱类型的语言，不需要变量类型，给定什么类型的数据，他就是什么类型）

　　1.1 

在同一个代码块内不能命名两个相同名字的变量。

　　1.2 

变量在使用前必须赋值。

　　eg:

age=100;

//正确

//错误

System.out.println（age）;

　　给变量赋值有两种方法：

　　第一种：

　　第二种：

ing 

赋值时一定要用符合类型的值。

eg:

a=1.456;

//这是不允许的。

　　2.声明变量时就注意的问题：

　　2.1、不能用数字作为开头

　　2.2、不能使用一些特殊符号如* 

&

% 

^ 

之类。

　　2.3、不能使用java中的关键字。

如int 

float 

static 

等

　　2.4、命名时最好使用首字母小写，驼峰式命名。

八、常量 

　　声明一个变量时，加上关键字“final”,那么这个变量就成为了常量。

值一但指定，就不能更改。

final 

打印结果为：

100---->

常量

age=20;

age=50;

age=30;

30----->

变量

//这是错误的

九、java中常用的算术运算符

　　1. 

+ 

- 

* 

/ 

%求余（取模）

　　2.“+”运算符具有两种意义 

，对于数据，表示求和，对于字符串，表示字符串的连接。

　　3.“/”用于两个整数时，表示整数除法，结果为整数。

否则为浮点数。

整/整=整、整/浮=浮、浮/整=浮

整数除法，分母不能为0.浮点数除法。

分母可为0。

其结果为Infinity或NaN 

如：

a=15;

b=0;

a/b=Infinity

　　4.byte 

short 

char 

的运算会先转换为int 

运算。

　　5.将精度大的值指定给精度小的变量时，由于在精确度上会有遗失，编译程序会认定这是一个错误。

byte 

a=1000;

//损失精度，因为byte的范围是：

-128~+127

可以进行强制类型转换：

a=（byte）1000;

注一:

a=（int）5.2;

----->

转换后为：

5

a=（int）5.8;

5 

这就是一个截断的过程，没有四舍五入。

注二：

a=5.6;

//这是不行的，因为a=5.6默认是double型的。

double型的要长于float型的。

可以写成：

a=5.6F

　　6.;

java程序语言的一个既定目标是可移植性。

不管是在那个虚拟机上运行，同一个计算都会产生相同的结果。

然而，要对浮点数的算术运算实现移植确极为困难。

double类型使用64位储存数值。

但有些处理器使用的

却是80位的寄存器。

这此寄存器为计算的中间结果增加了精度。

比如：

考虑下面的计算：

w=x*y/z;

许多Inter处理器首先计算x*y,然后把结果放到80位的寄存器中。

然后除z，最后把结果截断为64位。

这样

做会产生准确的结果。

还能避免指数溢出。

但是这个结果就可能与自始自终都在64位的寄存器上计算所得到

的结果不同。

所以java虚拟机初始规定所有中间计算都必须进行截断。

但是这么做去遭到了数字团体的反对。

截断不仅会产生溢出。

而且在计算速度上比更精确的计算速度要慢（因为截断也需要时间）。

为此,java语言

进行了升级。

承认是在最优性能和最佳可再生性方面相互冲突的矛盾要求。

但是对于 

strictfp 

关键字标记的 

方法必须使用严格的浮点运算。

以产生可再生结果。

如果strictfp用在方法上，那么该方法的所有指令都使用

严格的浮点运算。

如果给一个类加上strictfp,则他内部的所有方法都是用严格的浮点计算。

十、比较、条件运算符

　　大于号（>

） 

小于号（<

等于号（==） 

大于等于号（>

=） 

小于等于号（<

不等号（！

=）

　　三元条件运算符：

条件式？

条件成立返回的值：

条件失败返回的值。

　　例:

System.out.println（"

该生是否及格？

"

+（scoreOfStudent>

=60?

是 

否））;

十一、逻辑运算符

逻辑运算符：

与（&

）：

有一个假就为假

或（||）：

有一个真就为真

非（！

真为假 

假为真

AND（&

OR（|） 

XOR异或（^） 

补码（~）

　　知识点：

求奇偶时，让这个数和1进行与运算。

num&

0==0?

偶数：

奇数

和&

的区别：

都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。

还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式，例如，对于if（str 

!

= 

null 

str.equals（"

））表达式，当str为null时，后面的表达式不会执行，所以不会出现NullPointerException如果将&

改为&

，则会抛出NullPointerException异常。

If（x==33 

++y>

0） 

y会增长，If（x==33 

0）不会增长

还可以用作位运算符，当&

操作符两边的表达式不是boolean类型时，&

表示按位与操作，我们通常使用0x0f来与一个整数进行&

运算，来获取该整数的最低4个bit位，例如，0x31 

0x0f的结果为0x01。

利用异或进行简单加密：

public 

class 

Test{

void 

main（String[] 

args）{ 

a 

'

A'

加密前"

+a）;

b 

（char）（a^10）;

加密后"

+b）;

c 

（char）（b^10）;

解密后"

+c）;

}

十二、位运算符

　　左移（<

<

右移（>

）

　　作用：

可进行2的N次方运算。

TestOne{

args）{

num 

1;

2的0次方等于"

+num）;

num<

2的1次方等于"

2的2次方等于"

十三、递增、递减运算符

　　--i:

先-1后引用

　　++i:

先+1后引用

　　i++:

先引用后+1

　　i--:

先引用后-1

递增、递减运算符必须对变量进行 

5++;

（错误）

　　通常写法：

a=+b 

相当于 

a=a+b;

a-=b 

a*=b 

a/=b 

a%=b 

a&

=b 

a|=b 

a^=b 

a<

a>

　　差别：

在没有类型转换的情况下，他们是一样的。

　　a=+b：

不用进行类型转换 

　　a=a+b;

得进行类型转换

十四、java中常用的语句

　　1.if 

（）{ 

}else{ 

}语句 

IfDome{

请输入成绩"

）;

Scanner 

scan 

new 

score 

scan.nextInt（）;

if 

（score>

=90&

score<

=100）{

A"

}else 

=80&

=90）{

B"

=70&

=80）{

C"

=60&

=70）{

及格"

（score<

60）{

System.out.printf（"

不及格！

2. 

for 

（;

）{ 

}语句：

　eg1.　public 

ForDome{

（int 

i=9;

i>

0 

i-- 

）{

System.out.println（i）;

eg2.public 

ForDomeTwo{

i=1;

i<

=9 

i++ 

j=1;

j<

i 

j++）{

%d*%d=%d\t"

i,j,i*j）;

System.out.println（）;

3. 

switch 

（）{

case 

1:

2:

import 

SwicthDome{

i=0;

5;

num=score/10;

（num）{

10:

9:

break;

8:

7:

6:

default:

swicth 

case中能能比较的是：

枚举类型 

4. 

while 

（）{}语句：

5. 

do{

（）;

装箱与拆箱

对象的好处是有方法，可以提供一些功能，JAVA中的基本数据类型，不是以对象形式存在的，所以就没有方法，JAVA给这们提供了与基本数据类型相对应的包装（Warp）包装类型，类型的好处就是可以使用方法，包装的这个过程称之为装箱

（1）8种基本数据类型与其相对应的包装类型:

java.lang.Byte

java.lang.Short

java.lang.Integer

long 

java.lang.Long

java.lang.Float

java.lang.Double

java.lang.character

boolean 

java.lang.Boolean

（2）装箱与拆箱过程:

【1】Integer 

a=new 

Integer（56）;

--------->

手动装箱

（1）

=56;

-------->

自动装箱

（2）

（1）相当于

（2）

【2】Integer 

Integer（100）;

b=a.intValue（）;

------------------------------>

手动拆箱

c=a;

//相当于int 

c=a.intValue（）;

-------------->

自动拆箱

也就是自己做就是手动的，自己不做交给JAVA去做就是自动的。

例：

a=10;

b=10;

//使用Integer类型来包装int类型数据

wrapper1 

Integer（a）;

wrapper2= 

Integer（b）;

System.out.println（a/3）;

System.out.println（wrapper1.doubleValue（）/3）;

结果为：

3.3333333333333335

//相当于double（c/3）结果为3.0

partTo（wrapper2）

这是wrapper1与wrapper2都是对象，所以可以使用compartTo（）方法，来进行字典顺序比较，如果是两个数字不能直接进行字典比较，必须转化为包装类型，要是两个数字类型的字符串，可以直接进行字典顺序比较。

JAVA 

1.5之前必须手动装箱（Integer 

wrapper=new 

Integer（100）），JAVA1.5之后提供了自动装箱功能（Integer 

integer=100）;

（3）在JDK1.5之后可直接把一个基本类型赋值给包装类型，这就是一个自动装箱的过程。

integer=a;

---------->

自动装箱

手动的装箱

手动的拆箱是用一个Integer类型的变量，调用它的intValue（）方法，或者是相应类型的其它方法，将其拆箱成相对应的基本数据类型。

（4）将一个基本数据类型转变为包装类型有两种方法，也就是可以有两种方法来进行装箱。

第一种：

直接声明对象 

如:

第二种：

将基本数据类型包装成包装类型：

wrapper=Integer.valueOf（100）;

将一个包装类型拆箱成基本数据类型:

也就是拆箱也有两种方法：

a=wrapper.intValue（）;

（JDK1.5之前）------->

手动的拆箱

a=wrapper;

（JDK1.5之后）------------>

（5）小心的使用装箱和拆箱的功能（boxing）

Integer（500）;

b=new 

【一】

c=500;

d=500;

【二】

System.out.println（a==b）;

------------->

false（"

=="

表示是否引用了同一个内存地址的对象）

System.out.println（c==d）;

true

原因:

a和b在内存中引用的不是同一个对象，判断它们是否引用同一个对象

因为基本数据类型不是对象，c和d引用都是基本数据类型，判断它们的值是否相等

如果:

a=500;

b=500;

------------------>

false

a=100;

Integerb=100;

因为这是一个自动装箱的过程，而在自动装箱时，对于-128-127之间的值，它们被装箱为Integer对象之后，会在内存当中被重用.这时a和b都用了同一个对象100（在-128-127之间）.（所以要比较是否是同一个对象，要手动的装箱，不论是几百，就看是否引用了同一个地址），如果真要比大小，可用手动拆箱.

System.out.println（a.intValue（）==b.intValue（））;

（6）如