现所学知识复习

1．标识符
　　程序员对程序中的各个元素加以命名时使用的命名记号称为标识符（identifier）。Java语言中，标识符是以字母，下划线（_）,美元符($)开始的一个字符序列，后面可以跟字母，下划线，美元符，数字。例如，identifier，userName，User_Name，_sys_val， $change为合法的标识符，而2mail room#，class 为非法的标识符。

　2．保留字
　　具有专门的意义和用途，不能当作一般的标识符使用，这些标识符称为保留字(reserved word),也称为关键字，下面列出了java语言中的所有保留字：

abstract,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,leanth,native,new,null,package,private,protected,public,return,switch,synchronized,

short,static,super,try,true,this,throw,throws,threadsafe,transient,void,while.

java语言中的保留字均用小写字母表示。
1． java中的数据类型划分
　　java语言的数据类型有简单类型和复合类型：
　　简单数据类型包括：
                   整数类型（Integer）：byte， short， int， long
　　　　　浮点类型（Floating）：float，double
　　　　　字符类型（Textual）：char
　　　　　布尔类型（Logical）：boolean

复合数据类型包括：
　　　　　class
　　　　　interface
　　　　　数组

　2．常量和变量
　　常量：用保留字final来实现
　　　　　final typeSpecifier varName=value[,varName[=value]…];
　　　　　　　　　　　　　　　　　　　　　如：final int NUM=100;

　　变量：是java 程序中的基本存储单元，它的定义包括变量名、变量类型和作用域几个部分。其定义格式如下：
　　　　　typeSpecifier varName[=value[,varName[=value]…];
　　　 　　　　　　　　　　　　　如：int count; char c='a';
变量的作用域指明可访问该变量的一段代码，声明一个变量的同时也就指明了变量的作用域。按作用域来分，变量可以有下面几种：局部变量、类变量、方法参数和例外处理参数。在一个确定的域中，变量名应该是唯一的。局部变量在方法或方法的一个块代码中声明，它的作用域为它所在的代码块（整个方法或方法中的某块代码）。类变量在类中声明，而不是在类的某个方法中声明，它的作用域是整个类。方法参数传递给方法，它的作用域就是这个方法。例外处理参数传递给例外处理代码，它的作用域就是例外处理部分。

1．布尔类型--boolean

　　布尔型数据只有两个值true和false，且它们不对应于任何整数值。布尔型变量的定义如：
　　　boolean b=true;
2．字符类型--char

　　字符常量：
　　字符常量是用单引号括起来的一个字符，如'a'，'A';

　　字符型变量：
　　类型为char，它在机器中占16位，其范围为0～65535。字符型变量的定义如：
　　　char c='a'; /*指定变量c为char型，且赋初值为'a'*/

　整型常量：
　　◇ 十进制整数
　　　 如123，－456，0
　　◇ 八进制整数
　　　 以0开头，如0123表示十进制数83，－011表示十进制数－9。
　　◇ 十六进制整数
　　　 以0x或0X开头，如0x123表示十进制数291，－0X12表示十进制数－18。

整型变量：
数据类型 所占位数 数的范围
byte 8 -27～27-1
short 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】
　　public class Assign {
　　　public static void main (String args [ ] ) {
　　　int x , y ; //定义x，y两个整型变量
　　　float z = 1.234f ; //指定变量z为float型，且赋初值为1.234
　　　double w = 1.234 ; //指定变量w为double型，且赋初值为1.234
　　　boolean flag = true ; //指定变量flag为boolean型，且赋初值为true
　　　char c ; //定义字符型变量c
　　　String str ; //定义字符串变量str
　　　String str1 = " Hi " ; //指定变量str1为String型，且赋初值为Hi
　　　c = ' A ' ; //给字符型变量c赋值'A'
　　　str = " bye " ; //给字符串变量str赋值"bye"
　　　x = 12 ; //给整型变量x赋值为12
　　　y = 300; //给整型变量y赋值为300
　　　}
　　}

1．不同类型数据间的优先关系如下：

低------------------------------------------->高

byte,short,chart-->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．强制类型转换
　
　　高级数据要转换成低级数据，需用到强制类型转换，如：
　　int i;
　　byte b=(byte)i; /*把int型变量i强制转换为byte型*/
对各种类型的数据进行加工的过程成为运算，表示各种不同运算的符号称为运算符，参与运算的数据称为操作数，按操作数的数目来分，可有：
　　◇ 一元运算符：＋＋，－－，＋，－
　　◇ 二元运算符：＋，－，>
　　◇ 三元运算符：？：

　　基本的运算符按功能划分，有下面几类：
算术运算符： +，―，*，/，%，++，――。
　　 例如：
　　　　3+2;
　　　　a-b;
　　　　i++;
　　　　--i;

                  %得是余数！

2　关系运算符： >，<，>=，<=，==，!=。
　　　例如：
　　　 count>3;
　　　 I==0;
　　　 n!=-1;

布尔逻辑运算符

  逻辑运算是针对布尔型数据进行的运算，运算的结果仍然是布尔型量。常用的运算符如下:

运算符 运算  例子 说  明
！ 逻辑非 !x x真时为假，x假时为真
&& 逻辑与 x&&y x,y都真时结果才为真
& 非简洁与 x&y x,y都真时结果才为真
|| 逻辑或 x||y x,y都假时结果才为假
| 非简洁或 x|y x,y都假时结果才为假
^ 取或 x^y x,y同真假时结果为假

真值表：

op1  op2  op1&&op2  op1&op2  op1||op2  op1|op2  !op1  
false  false  false  false  false  false  true 
false  true  false  false  true  true  true 
true  false  false  false  true  true  false 
true  true  true  true  true  true  false 


·&&、&、‖、|　为二元运算符，实现逻辑与、逻辑或。

·!为一元运算符，实现逻辑非。

1.对于布尔逻辑运算，先求出运算符左边的表达式的值，然后在运算；

2.对逻辑或||的运算，如果左边表达式的值为true，则整个表达式的结果为true，不必对运算符右边的表达式再进行运算,非简洁或|和逻辑或||的真值表是一样的，不同的是运算符右边的表达式无论什么情况都要运算；

3.对逻辑与&&运算，如果左边表达式的值为false，则不必对右边的表达式求值，整个表达式的结果为false。非简洁与&和逻辑与&&的真值表是一样的，不同的是运算符右边的表达式无论什么情况都要运算；

例2.3下面的例子说明了关系运算符和布尔逻辑运算符的使用。

public class RelationAndConditionOp{
  public static void main(String[] args){
    int a=25,b=3;
    boolean d=a<b;//d=false
    System.out.println("a<b="+d);
    int e=3;
    if(e!=0&&a/e>5)
      System.out.println("a/e="+a/e);
    int f=0;
    if(f!=0&&a/f>5)
      System.out.println("a/f="+a/f);
    else
      System.out.println("f="+f);
  }
}


其运行结果为：

C:\＞java RelationAndConditionOp

a<b=false
a/e=8
f=0

注意：上例中，第二个if语句在运行时不会发生除0溢出的错，因为e!=0为false，所以就不需要对a/e进行运算。


赋值运算符(复合赋值运算符)

    赋值语句是程序设计最基本的语句之一，赋值运算的符号是等号，其右部是一个表达式，左部是变量，它把右部的值赋给左部的变量，等号左边的变量称为左值lvalue，右边称为右值rvalue。在Java中，赋值语句像函数一样有返回值，它的返回值即左值，有些语言没有这一特点。

运算符  例子  解释 
+=  x+=a  x=x+a 
-+  x-=a  x=x-a 
*=  x*=a  x=x*a 
/=  x/=a  x=x/a 
%=  x%=a  x=x%a 
&=  x&=a  x=x&a 
|=  x|=a  x=x|a 
^=  x^=a  x=x^a 
<<=  x<<=a  x=x<<a 
>>=  x>>=a  x=x>>a 
<<<=  x<<<=a  x=x<<<a 

下面的例子说明了赋值运算的使用。

　

public class LValue{
  public static void main(String[] args){
    int x=1,y=12;
    x+=2;
    y-=3;
    System.out.println();
    System.out.println("x= "+x+" y= "+y);
    y/=x;
    System.out.println("x= "+x+" y= "+y);
    y++;
    y%=x;
    System.out.println("x= "+x+" y= "+y);
  }
}


其运行结果为：

C:\＞java LValue

x= 3 y= 9
x= 3 y= 3
x= 3 y= 1


三目运算符
Java中的三墓运算符与C语言中的完全相同，使用形式为：
x?y:z;
这就是说，先计算x的值，若x为真，怎整个表达式的结果为y的值，若x为假，则整个表达式的值为表达式z的值。
例如：
int x=5,y=8,z=2;
int k=x<3?y:z; //因为x<3，所以k=z=2；
int j=x>0?x:-x //y的值始终为x的绝对值。


Java短路运算符和非短路运算符












短路运算符就是我们常用的&&、||，一般称为条件操作。















&&、||比较容易混淆；

现在简单将＆＆记成是Ａnd；

而将｜｜记成是ＯＲ


　　
　　class Logic{

public ststic void main(String[] args){

int a=1;int b=1;

if(a<b && b<a/0){

System.out.println("Oh，Thats Impossible!!!");

}else{

System.out.println("Thats in my control.");

}}}
　　
　　&&运算符检查第一个表达式是否返回false，如果是false则结果必为false，不再检查其他内容。
　　
　　a/0是个明显的错误！但短路运算&&先判断a<b，返回false，遂造成短路，也就不进行a/0操作了，程序会打出"Thats in my control."。这个时候，交换一下&&左右两边的表达式，程序立即抛出异常java.lang.ArithmeticException: / by zero。
　　
　　class Logic{

public ststic void main(String[] args){

int a=1;int b=1;

if(a==b || b<a/0){

System.out.println("Thats in my control.");

}else{

System.out.println("Oh，Thats Impossible!!!");}

}}
　　
　　||运算符检查第一个表达式是否返回true，如果是true则结果必为true，不再检查其他内容。
　　
　　a/0是个明显的错误！但短路运算||先执行a==b判断，返回true，遂造成短路，也就不进行a/0操作了，程序会打出"Thats in my control."。这个时候，交换一下||左右两边的表达式，程序立即抛出异常java.lang.ArithmeticException: / by zero。
　　
　　非短路运算符包括 & 与、| 或、^ 异或，一般称为逻辑操作
　　
　　class Logic{

public ststic void main(String[] args){

int a=1;int b=1;

if(a<b & b<a/0){

System.out.println("Oh，Thats Impossible!!!");}

else{System.out.println("Thats in my control.");

}}}
　　
　　&运算符不会造成短路，它会认认真真的检查每一个表达式，虽然a<b已经返回flase了，它还是会继续检查其他内容，以至于最终抛出异常java.lang.ArithmeticException: / by zero。
　　
　　class Logic{

public ststic void main(String[] args){

int a=1;int b=1;

if(a==b | b<a/0){System.out.println("Thats in my control.");

}else{

System.out.println("Oh，Thats Impossible!!!");

}}}
　　
　　同理，|运算符也不会造成短路，虽然a==b已经返回true了，它还是会继续检查其他内容，以至于最终抛出异常java.lang.ArithmeticException: / by zero。
　　
　　^运算符道理是一样的，就不在这里罗索了。
　　
　　最后。短路运算符只能用于逻辑表达式内，非短路运算符可用于位表达式和逻辑表达式内。也可以说：短路运算只能操作布尔型的，而非短路运算不仅可以操作布尔型，而且可以操作数值型。

流程控制语句

  能够决定其它语句的执行顺序的语句称为流程控制语句。Java语言里有如下语句：

     选择判断语句：if-else, switch-case

     循环语句： for, while, do-while  

     其他控制语句：break, continue, label: , return

















选择判断语句

条件语句if-else

if-else语句根据判定条件的真假来执行两种操作中的一种，格式为：

   if(boolean-expression){
        statement1;
  }else{
      statement2;
  }
1.布尔表达式boolean-expression是任意一个返回布尔型数据的达式(这比C、C++的限制要严格)。

2.每个单一的语句后都必须有分号。

3.语句statement1，statement2可以为复合语句，这时要用大括号{}括起。建议对单一的语句也用大括号括起，这样程序的可读性强，而且有利于程序的扩充(可以在其中填加新的语句)。{}外面不加分号。

4.else子句是任选的。

5.若布尔表达式的值为true，则程序执行statement1，否则执行statement2。

6.if-else语句的一种特殊形式为：

    if(expression1){
       statement1;
     }else if(expression2){
        statement2;
     }......
     }else if(expressionM){
         statementM;
    }else{
        statementN;
     }

else子句不能单独作为语句使用，它必须和if配对使用。else总是与离它最近的if配对。可以通过使用大括号{}来改变配对关系。


例:比较两个数的大小，并按从小到大的次序输出。



public class CompareTwo{
   public static void main(String args[]){
      double d1=23.4;
      double d2=35.1;
      if(d2>=d1)
         System.out.println(d2+">="+d1);
      else
         System.out.println(d1+"<="+d2);
   }
}





运行结果为：

C:\＞java CompareTwo
35.1＞=23.4

例:判断某一年是否为闰年。

闰年的条件是符合下面二者之一：①能被4整除，但不能被100整除;②能被4整除，又能被100整除。



public class LeapYear{
public static void main(String args[]){
int year=1989;//method1
if((year%4==0&&year%100!=0)||(year%400==0))
System.out.println(year+"年是闰年。.");
else
System.out.println(year+"年不是闰年。");
year=2000;//method2
boolean leap;
if(year%4!=0)
leap=false;
else if(year%100!=0)
leap=true;
else if(year%400!=0)
leap=false;
else
leap=true;
if(leap==true)
System.out.println(year+"年是闰年。");
else
System.out.println(year+"年不是闰年。");
year=2050;//method3
if(year%4==0){
if(year%100==0){
if(year%400==0)
leap=true;
else
leap=false;
}else
leap=false;
}else
leap=false;
if(leap==true)
System.out.println(year+"年是闰年。");
else
System.out.println(year+"年不是闰年。");
}
}





C:\＞java LeapYear

1989 is not a leap year.
2000 is a leap year.
2050 is not a leap year.

该例中，方法1用一个逻辑表达式包含了所有的闰年条件，方法2使用了if-else语句的特殊形式，方法3则通过使用大括号{}对if-else进行匹配来实现闰年的判断。大家可以根据程序来对比这三种方法，体会其中的联系和区别，在不同的场合选用适当的方法。

多分支语句switch

switch语句根据表达式的值来执行多个操作中的一个，它的般格式如下：

   switch (expression){
          case value1:statement1;
              break;
          case value2:statement2;
              break;
             …………
          case valueN:statemendN;
              break;
           default:defaultStatement;
}

1.表达式expression可以返回任一简单类型的值(如整型、实型、字符型)，多分支语句把表达式返回的值与每个case子句中的值相比。如果匹配成功，则执行该case子句后的语句序列。

2.case子句中的值valueI必须是常量，而且所有case子句中的值是不同的。

3.default子句是任选的。当表达式的值与任一case子句中的?都不匹配时，程序执行default后面的语句。如果表达式的值与任一case子句中的值都不?配且没有default子句，则程序不作任何操作，而是直接跳出switch语句。

4.break语句用来在执行完一个case分支后，使程序跳出switch语句，即终止switch语句的执行。因为case子句只是起到一个标号的作用，用来查找匹配的入口并从此处开始执行，对后面的case子句不再进行匹配，而是直接执行其后的语句序列，因此该在每个case分支后，要用break来终止后面的case分支语句的执行。在一些特殊情况下，多个不同的case值要执行一组相同的操，这时可以不用break。

5.case分支中包括多个执行语句时，可以不用大括号{}括起。

6.switch语句的功能可以用if-else来实现，但在某些情况下，使switch语句更简炼，可读性强，而且程序的执行效率提高。



例:根据考试成绩的等级打印出百分制分数段。



public class GradeLevel{
public static void main(String args[]){
System.out.println("\n**firstsituation**");
char grade='C';//normaluse
switch(grade){
case 'A':System.out.println(grade+" is 85～100");
break; case 'B':System.out.println(grade+" is 70～84");
break; case 'C':System.out.println(grade+" is 60～69");
break; case 'D':System.out.println(grade+" is ＜60");
break; default:System.out.println("input error");
} System.out.println("\n**secondsituation**");
grade='A';//creat error without break statement
switch(grade){
case 'A':System.out.println(grade+"is85～100");
case 'B':System.out.println(grade+"is70～84");
case 'C':System.out.println(grade+"is60～69");
case 'D':System.out.println(grade+"is＜60");
default:System.out.println("inputerror");
} System.out.println("\n**thirdsituation**");
grade='B';//severalcasewithsameoperation
switch(grade){
case 'A':
case 'B':
case 'C':System.out.println(grade+"is＞=60");
break; case 'D':System.out.println(grade+"is＜60");
break; default:System.out.println("inputerror");
}
}
}





运行结果为

C:\＞java GradeLevel

****first situation****
C is 60～69
****second situation****
A is 85～100
A is 70～84
A is 60～69
A is ＜60
input error
****third situation****
B is ＞=60

从该例中我们可以看到break语句的作用。

循环语句

    循环语句的作用是反复执行一段代码，直到满足终止循环条件为止，一个循环一般应包括四部分内容：

1.初始化部分(initialization)：用来设置循环的一些初始条件，计数器清零等。

2.循环体部分(body)：这是反复循环的一段代码，可以是单一一条语句，也可以是复合语句。

3.迭代部分(iteration)：这是在当前循环结束，下一次循环开始执行的语句，常常用来使计数器加1或减1。

4.终止部分(termination)：通常是一个布尔表达式，每一次循环要对该表达式求值，以验证是否满足循环终止条件。

Java中提供的循环语句有：while语句，do-while语句和for语句，下面分别介绍：

  while语句

while语句实现"当型"循环，它的一般格式为：

   [initialization]
    while (termination){
       body;
       [iteration;]
    }

1.当布尔表达式(termination)的值为true时，循环执行大括号中语句。并且初始化部分和迭代部分是任选的。

2.while语句首先计算终止条件，当条件满足时，才去执行循环中的语句。这是"当型"循环的特点。

   do-while语句

   do-while语句实现"直到型"循环，它的一般格式为：

    [initialization]
    do{
       body;
        [iteration;]
    }while (termination);

1.do-while语句首先执行循环体，然后计算终止条件，若结果为true，则循环执行大括号中的语句，直到布尔表达式的结果为false。

2.与while语句不同的是，do-while语句的循环体至少执行一次，是"直到型"循环的特点。

  for语句

for语句也用来实现"当型"循环，它的一般格式为：

  for (initialization;termination;iteration){
    body;
  }

1.for语句执行时，首先执行初始化操作，然后判断终止条件是否满足，如果满足，则执行循环体中的语句，最后执行迭代部分。完成一次循环后，重新判断终止条件。

2.可以在for语句的初始化部分声明一个变量，它的作用域为一个for语句。

3.for语句通常用来执行循环次数确定的情况(如对数组元素进行操作)，也可以根据循环结束条件执行循环次数不确定的情况。

4.在初始化部分和迭代部分可以使用逗号语句，来进行多个动作。逗号语句是用逗号分隔的语句序列。例如：

for(i=0，j=10;i<j;i++，j--){
……
}

5.初始化、终止以及迭代部分都可以为空语句(但分号不能)，三者均为空的时候，相当于一个无限循环。

举例:

public class Sum{
public static void main(String args[]){
System.out.println("\n**while循环语句！**");
int n=10,sum=0;//initialization 初始化
while(n>0){//termination终止条件
sum+=n;//body循环体
n--;//iteration 条件变量改变
}
System.out.println("和是："+sum);
System.out.println("\n**do_while循环语句**");
n=0;
sum=0;
do{
sum+=n;//body
n++;//iteration
}while(n<=10);//termination
System.out.println("和是："+sum);
System.out.println("\n**forstatement**");
sum=0;
for(int i=1;i<=10;i++){
//initialization，termination，iteration
sum+=i;
}
System.out.println("和是："+sum);
}
}




结果：

**while循环语句！**
和是：55

**do_while循环语句**
和是：55

**forstatement**
和是：55


例：求100～200间的所有素数

public class PrimeNumber{
public static void main(String args[]){
System.out.println("** 100 到 200之间的质数**");
int n=0;
outer:for(int i=101;i<200;i+=2){//outer loop
int k=15;//select for convinence
for(int j=2;j<=k;j++){//inner loop
if(i%j==0)
continue outer;
}
System.out.print(" "+i);
n++;//output a newline
if(n<10)//after 10 numbers
continue;
System.out.println();
n=0;
}
System.out.println();
}
}




结果：

** 100 到 200之间的质数**
101 103 107 109 113 127 131 137 139 149
151 157 163 167 173 179 181 191 193 197
199

转移语句

带标号的语句格式

标号: 语句
statementName: someJavaStatement;

break语句

不带标号的break语句: 终止当前语句的执行而使控制转移到当前语句的下一条语句.
带标号的break语句: 终止带标号的语句而使控制转移到带标号语句的下一条语句.
break statementName;

  continue语句

只能用在循环语句中.


1.不带标号的continue语句: 无条件使控制转移到循环语句的条件判定部分.

continue语句用来结束本次循环，跳过循环体中下面尚未执的语句，接着进行终止条件的判断，以决定是否继续循环。对于for语句，在进行终止条件判断前，还要先执行迭代语句。它的格式为：

continue;

2.带标号的continue语句: 无条件使控制转移到带标号的循环语句的条件判定部分.

也可以用continue跳转到括号指明的外层循环中，这时的格式为：

continue outerLable;

例如：

outer:for(int i=0;i＜10;i++){∥外层循环
        for(int j=0;j＜20;j++){∥内层循环
           if(j＞i){
                 …… continue outer;
            }
            ……
        }
        ……
   }

该例中，当满足j＞i的条件时，程序执行完相应的语句后跳转至外层循环，执行外层循环的迭代语句i++；然后开始下一次循环

Return语句

结束当前方法的执行并返回到调用方法语句的下一条语句.
return expression;
return;