java.docx

java.docx

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

java

Java基础

设置windows下的JDK环境变量配置：

（3分）

Jdk 安装在 c:

\jdk1.5

（1） 配置JAVA_HOME= c:

\jdk1.5

（2） 配置path  %JAVA_HOME%\bin;    

（3） 配置CLASSPATH  .; %JAVA_HOME%\lib\tools.jar ; %JAVA_HOME%\lib\dt.jar ; %JAVA_HOME%\jre\lib\rt.jar 

一、java 中有3种注释

　　//表示单选注释

　　/*表示多行注释*/

　　/**文档注释*/

　　1.多行注释内不能嵌套多行注释

　　2.多行注释内可以嵌套单行注释

　　3.注释不会被编译为字节码

    4.文档注释的作用:

　　/**

　　@author Administrator

　　@since jdk1.5

　　*/

　　编译:

javadoc 类文件名.java 会生成许多网页

二、Scanner工具

　　作用:

获得用户输入的信息

　　使用前需要导入包：

　　import java.util.Scanner;

　　Scanner scan=new Scanner（System.in）;//创建Scanner工具

　　Scanner工具常用的方法：

　　next（）方法 获得用户输入的字符串信息

　　如：

String name=scan.next（）;

三、标准的输入与输出串流

　　System.in:

标准的输入对象

　　System.out:

标准的输出对象

　　System.err:

标准的错误输出对象

　　标准的输出对象的作用:

支持定向输出

　　如：

在当前文件夹下创建一个out.txt文档。

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

　　java 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 Double BigDecimal

　　%s %S:

将字符串格式化输出

　　%c %C:

以字符方式输出，提供的数必须是Byte Short 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:

int age=100;//正确

　　   int age;//错误

　　   System.out.println（age）;

　　给变量赋值有两种方法：

　　第一种：

int age=100;

　　第二种：

ing age;

　　        age=100;

　　注：

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

eg:

int a=1.456;//这是不允许的。

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

　　2.1、不能用数字作为开头

　　2.2、不能使用一些特殊符号如* & % ^ 之类。

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

如int float static 等

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

八、常量 

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

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

　　如：

final int age=100; System.out.println（age）;  打印结果为：

100---->常量

　　    int age=20; age=50; age=30; System.out.println（age）;打印结果为：

30----->变量

　　    final int age=100; age=50; System.out.println（age）;  //这是错误的

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

　　1. + - * / %求余（取模）

　　2.“+”运算符具有两种意义 ，对于数据，表示求和，对于字符串，表示字符串的连接。

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

否则为浮点数。

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

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

分母可为0。

其结果为Infinity或NaN  如：

　　   double a=15;

　　   int b=0;

　　   a/b=Infinity

　　4.byte short char 的运算会先转换为int 运算。

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

　　  如：

byte a=1000;//损失精度，因为byte的范围是：

-128~+127

　　     可以进行强制类型转换：

byte a=（byte）1000;

　　  注一:

 int a=（int）5.2;----->转换后为：

5

　　      int a=（int）5.8;----->转换后为：

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

　　  注二：

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

double型的要长于float型的。

　　        可以写成：

float a=5.6F

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

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

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

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

但有些处理器使用的

　　   却是80位的寄存器。

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

比如：

考虑下面的计算：

double 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 && ++y>0）不会增长

&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位，例如，0x31 & 0x0f的结果为0x01。

利用异或进行简单加密：

public class Test{

public static void main（String[] args）{ char a = 'A';

      System.out.println（"加密前"+a）;

      char b = （char）（a^10）;

 System.out.println（"加密后"+b）;

  char c = （char）（b^10）;

     System.out.println（"解密后"+c）;

   }

}

十二、位运算符

　　左移（<<） 右移（>>）

　　作用：

可进行2的N次方运算。

　　eg:

public class TestOne{

public static void main（String[] args）{

int num = 1;

System.out.println（"2的0次方等于"+num）;

num = num<<1;

System.out.println（"2的1次方等于"+num）;

num = num<<1;

System.out.println（"2的2次方等于"+num）;

  }

}

十三、递增、递减运算符

　　--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<<=b  a>>=b 

　　差别：

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

　　a=+b：

不用进行类型转换 

　　a=a+b;得进行类型转换

十四、java中常用的语句

　　1.if （）{ }else{ }语句 

　　import java.util.Scanner;

public class IfDome{

public static void main（String[] args）{

System.out.println（"请输入成绩"）;

Scanner scan = new Scanner（System.in）;

int score = scan.nextInt（）;

if （score>=90&&score<=100）{

System.out.println（"A"）;

}else if （score>=80&&score<=90）{

System.out.println（"B"）;

}else if （score>=70&&score<=80）{

System.out.println（"C"）;

}else if （score>=60&&score<=70）{

System.out.println（"及格"）;

}else if （score<60）{

System.out.printf（"不及格！

"）;

   }

 }

}

2. for （; ; ）{ }语句：

　eg1.　public class ForDome{

public static void main（String[] args）{

for （int i=9;i>0 ;i-- ）{

System.out.println（i）;

   }

 }

}

eg2.public  class ForDomeTwo{

public static void main（String[] args）{

for （int i=1;i<=9 ;i++ ）{

for （int j=1;j

System.out.printf（"%d*%d=%d\t" ,i,j,i*j）;

}

System.out.println（）;

      }

   }

}

3. switch （）{

case 1:

case 2:

}语句：

import java.util.Scanner;

public class SwicthDome{

public static void main（String[] args）{ 

for （int i=0; i<5;i++ ）{

      System.out.printf（"请输入成绩"）;

  Scanner scan = new Scanner（System.in）;

      int score = scan.nextInt（）;

  int num=score/10;

  switch （num）{

  case 10:

  case 9:

     System.out.printf（"A"）;

         break;

  case 8:

     System.out.printf（"B"）;

         break;

  case 7:

     System.out.printf（"C"）;

 break;

  case 6:

    System.out.printf（"及格"）;

        break;

  default:

    System.out.printf（"不及格！

"）;   

       }

    }

  }

}

swicth case中能能比较的是：

byte short int char 枚举类型 

4. while （）{}语句：

5. do{

}

while （）;

装箱与拆箱

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

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

byte         java.lang.Byte

short        java.lang.Short

int          java.lang.Integer

long         java.lang.Long

float        java.lang.Float

double       java.lang.Double

char         java.lang.character

boolean      java.lang.Boolean

（2）装箱与拆箱过程:

【1】Integer a=new Integer（56）;--------->手动装箱

（1）

        Integer a =56;-------->自动装箱

（2）

（1）相当于

（2）

【2】Integer a=new Integer（100）;

         int b=a.intValue（）;------------------------------>手动拆箱

         int c=a;//相当于int c=a.intValue（）;-------------->自动拆箱

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

例：

int a=10;

int b=10;

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

Integer wrapper1 = new Integer（a）;

Integer wrapper2= new 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之后可直接把一个基本类型赋值给包装类型，这就是一个自动装箱的过程。

例：

int a=10;

    Integer integer=a;---------->自动装箱

手动的装箱

Integer wrapper=new Integer（100）;

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

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

第一种：

直接声明对象 如:

Integer wrapper=new Integer（100）;

第二种：

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

Integer wrapper=Integer.valueOf（100）;

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

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

Integer wrapper=new Integer（100）;

int a=wrapper.intValue（）;（JDK1.5之前）------->手动的拆箱

int a=wrapper;（JDK1.5之后）------------>自动拆箱

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

Integer a=new Integer（500）;

Integer b=new Integer（500）;  【一】

int c=500;

int d=500;                   【二】

System.out.println（a==b）;------------->false（"=="表示是否引用了同一个内存地址的对象）

System.out.println（c==d）;-------------->true

原因:

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

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

如果:

Integer a=500;

Integer b=500;

System.out.println（a==b）;------------------>false

Integer a=100;

Integerb=100;

System.out.println（a==b）;------------------>true

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

如：

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

（6）如