JAVA语言基础

本章的目的在于让读者对数据类型、表达式、控制流程等Java语言的基本内容有一个深入的了解，这些内容是任何一门程序设计语言都必须包含的部分，也是我们编程的基础。
　　对于那些熟悉编程特别是用C和C++语言编程的人来说，本章的内容将会是非常熟悉的，除了Java在一些地方更偏重于面向对象的思想外，几乎所有的基本内容都与C++语言相同或是类似的。对那些把Java语言作为自己的第一门编程语言的人来说，应该仔细阅读本章。本章内容虽然比较简单，介大家务必仔细弄清楚每一个环节。在这方面花点时间，会使以后的程序设计更为简单。
3.1　Java语言的基本组成

　　Java语言主要由以下五种元素组成：标识符、关键字、文字、运算符和分隔符。这五种元素有着不同的语法含义和组成规则，它们互相配合，共同完成Java语言的语意表达。下面我们分别予以讲解。

3.1.1　标识符

　　变量，以及我们后面将要讲到的类和方法都需要一定的名称，我们将这种名称叫做标识符。佬是一个有效的标识符呢？在Java中，所有的标识符都必须以一个字母、下划线＿或美元符￥作开头。后面的字符包括数字（0--9），所有从A--Z的大写字母和a--z的小写字母，以及所有在十六进制0xc0前的ASCII码。
　　以上只是标识符命名的基本规则，以下是一个正误对照表，通过它会对标识符的命名规则有一个具体的了解：


              合法标识符                非法标识符
       
              try                       try#
              group_7                   7group
              opendoor                  open-door
              boolean_1                 boolean

                           表4-11
                      注：boolean 为关键字

3.1.2　关键字

　　关键字是Java语言本身使用的标识符，它有其特定的语法含义。所有的Java关键字将不能被用作标识符，如：for、while、boolean等都是Java语言的关键字。本书后附有Java语言关键字列表。

3.1.3　文字

　　文字，其实就是我们通常所说的数据。文字的不同表现形式，也就是不同的数据类型，Java的数据类型有：整型、浮点型、布尔型、字符型、字符串型。
　　整型数据是最普通的数据类型，它的表现方式有：十进制、十六进制和八进制。基数为10的十进制是我们最熟悉的。基娄为16的十六进制表示法，也是程序设计中常常用到的，在十六进制中，每一位数字相当于4个二进制0和1的组合。十六进制整数用0--9的10个数字和字母A--F代表10--15这些整数，十六进制整数必须以0X作为开头。
　　每一个整型数据占有32位的存储空间，即四个字节。这意味着整型数据所表示,的范围在-2,147,483,648和2,147,483,648之间，假如由于某些原因，你必须表示一个更大的数，64位的长整型应该是足够的。如果你想把一个整数强制存为一个长型（long），你可以在数字后面加字母l。
　　浮点数据用来代表一个带小数的十进制数。例如1.5或43.7。它父或者是标准形式，或者是用科学计数法的形式，下面是一些例子：
　　3.1415 0.1 .6 .02243 2.997E8
　　标准的浮点数叫做单精度浮点数，它的存储空间为32位，也就是四个字节。也有64位的双精度浮点数。你可以用D后缀确定你想使用这种双精度浮点数。
　　布尔类型是最简单的一种数据类型，布尔数据只有两种状态：真和假，通常用关键字true和false来表示这两种状态。
　　字符型数据是由一对单引号括起来的单个字符。它可以是字符集中的任意一个字符，如：'a'，'b'。
　　字符串数据类型是用一对双引号括起来的字符序列，字符串数据实际上是由String类所实现（类这个概念我们将在后续章节中详细讲解），而不是Ｃ语言中所用的字符数组。每一个字符串数据将产生一个String类的新的实例，读者不必对字符串与类这个概念发生关系而感到担心，由于类的特性，你不必担心如何去实现它们，它们会自己照顾好自己，需要说明的是字符串在Java里作为类只是出于安全的考虑。
　　表4-2给出了几个字符串的例子。


          字符串描述                对应值
   
          ""
          "Let's go"                Let's go
          "Two"              Two
                                    Lines
              表 4-2 几个例子
              注：''在这里表示回车换行。

3.1.4　运算符

　　任何语言都有自己的运算符，Java语言也不例外，如＋、－、＊、／等都是运算符，运算符的作用是与一定的运算数据组成表达式来完成相应的运算。对不同的数据类型，有着不同的运算符，我们将在下一节中对不同类型的运算符分别讨论。

3.1.5　分隔符

　　分隔符用来使编译器确认代码在何处分隔。‘’‘’‘;’‘:’都是Java语言的分隔符。

3.2　变量

　　为了在Java中存储一个数据，必须将它容纳在一个变量之中。定义一个变量的两个基本要素是：类型和标识符，通常你可以用如下语法去说明变量：
　　type identifer[,identifer]; 　　该语句告诉编译器用“type”的类型和以“identifer”为名字建立一个变量，这里的分号将告诉编译器这是一个说明语句的结束；方格中的逗号和标识符表示你可以把几个类型相同的变量放在同一语句进行说明，变量名中间用逗号分隔。
　　在你创建了一个变量以后，你可以给它赋值，或者用运算符对它进行一些运算。如同上一节内容中所提到的一样，类型将决定变量所代表的不同种类的数据，在Java语言中有两种变量。最基本的是简单类型变量，他们不建立在任何其他类型上，整数、浮点、布尔和字符类型都是这类型；另外Java可以定义构造另一种变量类型：类，这些类型建立在简单类型之上，它包括数值、变量和方法，是一种数据与代码相结合的复合结构。

3.2.1 整型变量的说明

　　整型变量按所占内存大小的不同可分为四种不同的类型，最短的整型是byte，它只有八位长，然后是短整型short，它有16位，int类型有32位，长整型long是64位，下面是这些整型变量的说明示例。
　　　　byte a;
　　　　short row;
　　　　int numberOfSportor;
　　　　long treeCount;
　　　　int x,y,z;

3.2.2　浮点变量的说明

　　浮点类型可用关键字float或double来说明，float型的浮点变量用来表示一个32位的单精度浮点数，而double型的浮点变量用来表示一个64位的双精度浮点数。double型所表示的浮点数比float型更精确。
　　　　float alpha;
　　　　double speed;

3.2.3　字符变量说明

　　Java使用16位的Unicode字符集。因此Java字符是一个16位的无符号整数，字符变量用来存放单个字符，它不是完整的字符串。示例如下：
　　　　char a;
　　　　a='c';

3.2.4 布尔变量说明

　　布尔型有真和假两个逻辑值，另外，逻辑运算符也将返回布尔类型的值，示例如下：
boolean mouseOn;
mouseOn=true;
　　布尔型是一个独立的类型，它不像C语言中的布尔型代表0和1两个整数，由于这个原因，Java中的布尔类型不能转换成数字。

3.2.5 变量的使用范围

　　当你说明了一个变量后，它将被引入到一个范围当中，也就是说，该名字只能在程序的特定范围内使用。变量的使用范围是从它被说明的地方到它所在那个块的结束处，块是由两个大括号所定义的，例如：


      class Example
     
         public static void main(String args[])
        
            int i;
            ......
        
         public void function()
        
            char c;
            ......

　　整型变量i在方法main中说明，因为main的块不包括function块，所以任何在function块中对i的引用都是错误的。对字符型变量c也同样如此。
　　在某一个特定情形中，变量能被别的变量所隐藏，如：在一个块中说明一个变量，而在这个块中建立一个新块并且在其中定义相同名字的变量，这样在第二个块中，程序对该变量的使用均是指第二次定义的那个变量。这样我们说，第一个变量被隐藏了。变量隐藏的示例如下：

      class Example
     
         public static void main(String args[])
        
             int i;     //    * * *
             boolean try=true;
             while(try)
            
                int i;  //以下对变量i的引用均指这里定义的i
                ......
                 //以下对变量i的引用均指* * *处定义的i
                ......

　　当你定义一个变量时，首先必须明确它的活动范围，并根据它的实际功能来命名，此外还应尽量使用详细的注释，这些办法可以使你能够清晰地区分变量，变量被隐藏的问题也会大大减少。
3.2.6 类型转换

　　系统方法System.in.read返回一个整型数值，但你却常常想要把它当作一个字符来使用。现在的问题是，当有一个整数而你需要把变成一个字符时应当去做些什么呢？你需要去做一个类型转换为一个字符。从一种类型转换到另一种类型可以使用下面的语句：
　　　　int a;
　　　　char b;
　　　　a=(int)b;
　　加括号的int告诉编译器你想把字符变成整型并把它放在a里，另一方面，如果你想做相反的转换，你可以使用：
　　　　b=(char)a;
　　记住整型和字符型变量位长不同是非常重要的，整型是32位长，字符型是16长，所以当你从整型转换到字符型可能会丢失信息。同样，当你把64位的长整型数转换为整型时，由于长整型可能有比32位更多的信息，你也很可能会丢失信息。即使两个量具有相同的位数，比如整和浮点型（都是32位），你在转换小数时也会丢失信息，Java不象c/c++那样允许自动类型转换，当你进行类型转换要注意使目标类型能够容纳原类型的所有信息，不会丢失信息的类型转换有：


          原始类型              目标类型
   
          byte          short,char,int,long,float,double
          short         int,long,float,double
          char          int,long,float,double
          int           long,float,double
          long          float,double
          float         double

           表3-3  不会丢失信息的类型转换列表

　　需要说明的是，当你执行一个这里并未列出的类型转换时可能并不总会丢失信息，不过进行这样一个理论上并不安全的转换总是很危险的。
3.3　运算符

　　在你定义了的变量之后，通常都要对变量赋值、改变变量的值和使用变量进行计算，这都是运算符的作用。

3.3.1　优先级

　　表3-4按从高到低的优先级列出了运算符。同一行中的运算符优先级相同。


            .    []        ()
           ++    --         !       ~
            *     /         %
            +     -
           <<    >>        >>>
           <     >         <=       >=
           ==    !=
           &
           ^
           &&
           ||
           ?:
           =
       
              表3-4 运算符的优先级

　　优先级是指同一式子中多个运算符被执行和次序，同一级里的操作符具有相同的优先级，例如对于表达式：
　　　　a=b+c*d/(c^d)
　　Java处理时将会按照表3-4从最高优先级到最低的次序进行，在本例中，因为括号优先级最高，所以先计算c^d，接着是c*d，然后除以c^d，最后，把上述结果与b的和存储到变量a中，不论任何时候，当你一时无法确定某种计算的执行次序时，可以使用加括号的方法明确为编译器指定运算顺序，这也是提高程序可读性的一个重要方法。
3.3.2 整型运算符

　　整型运算符按操作数的多少可分为一元和二元两类，一元运算符一次对一个变量进行操作，二元运算符一次对两个变量进行操作。对于运算来说，如果有一个变量或操作数是长整型的，那么结果就肯定是长整型的，否则即使操作数还没有确定是字节型、短整型或字符型，运算结果都是整型，表3-5是一元运算符的列表。


        运算符        实际操作          例子
   
         -       改变整型数符号         -i
         ~        位运算：非            ~i
         ++       加1                   i++
         --       减1                   i--

              表3-5  一元运算符列表

注：一元取反运算符（－）用来改变整数的正负号，逐位求反把所变量所有是1的位变成0，是0的位变成1，加加和减减（＋＋，－－）把变量的值加1或减1。
　　以下是一个具体例子：

      int i=0;
      int j=1=;
      for (i=1;i<10;i++)
     
         j--;
         System.out.println(i+""+j+"");

　　这个程序的一行执行加运算，另一行执行减运算，注意“＋＋”和“－－”的使用，每次遇到“＋＋”或“－－”的时候，系统就把操作数的值相应地加1或减1，一元运算符执行的方式是改变它们所作用的变量的值，对一元取反和逐位求反来说，变量的值并不改变，而对加和减运算（＋＋，－－）来说，就量的值被改变了，下面的代码给出了这种工作方式的一个例子：　　　　int i=10,j=10,k=10,l=10;
　　　　System.out.println(i+""+j+""+k+""+l+"");
　　　　j++;
　　　　i--;
　　　　~k;
　　　　-l;
　　　　System.out.println(i+""+j+""+k+""+l+"");
　　注意j和i被改变并打印出它们的新值，可是k和l仍然为原来的数值，当在复合表达式中使用一元取反和逐位求余运算时，你实际上是在用一个临时存贮操作数的新值。
　　＋＋和－－既是前置运算符也是后置运算符，这就是说，它们既可以放在操作数前面（＋＋x），也可以放在后面（x＋＋），如果它们被用在复合语句中如：
　　　　i=x++; 或 i=++x;
　　那么第一个语句中x把值赋给i以后再加1，而第二个语句先把x加1，再把新的x值赋给i。
　　整型运算符的第二种类型是二元运算符，这种运算并不改变操作数的值，而是返回一个必须赋给变量的值，表3-6列出了二元运算符。

        运算符          实际操作          例子
     
          +             加运算            a+b
          -             减运算            a-b
          *             乘运算            a*b
          /             除运算            a/b
          %           取模运算            a%b
          &             与运算            a&b
          |             或运算            a|b
          ^           异或运算            a^b
          <<            左移              a<          >>            右移              a>>b
          >>>           右移              a>>>b

               表3-6 二元运算符列表

注意：>>与>>>的基本功能都是右移，但>>是用符号位来填充右移后所留下的空位，而>>>则是用零来填充右移后所留下的空位。
　　还有一类运算，它们形如：j-=i，这里-=是二元运算-和赋值运算=的复合运算，它等价于j=j-i，这种复合方式适用于所有的二元运算符。
　　这里有几点关于整型运算进一步说明，首先，整数除法向靠近0的方向取整；其次，如果你除以0或者对0取模，程序就会在运行时被强行中止，如果你的运算结果超出最小极限，或者说是下溢，结果将为0，如果超出了最大极限，就将会导致结果的回绕。
3.3.3 布尔运算符

　　另外还有一些运算符能产生布尔类型的结果，我们把它们称为布尔运算符，表4-7列出了这些运算符。


          运算符      实际操作          例子
   
          <           小于              a          >           大于              a>b
          <=          小于等于          a<=b
          >           大于等于          a>=b
          ==          等于              a==b
          !=          不等于            a!=b

               表3-7  产生布尔类型结果的运算符

　　在这里要指出的是相等运算符==可能会给你带来许多麻烦，很多人在比较两个值时往往错用了等号=，以致于变成了赋值操作，所以在编程中一定要注意你在比较数值时用的是==。布尔类型本身还有几个逻辑运算符，它们可以对布尔类型的数据进行运算：
　　　　!,&&,//
　　其实如果你把布尔类型的值true等效地看成1，false看成0，那么对于相同的运算符，整型运算的法则对布尔类型也是适用的。
　　布尔运算符中还有一种三元运算符，它的格式如下：
　　　　Operand ? Statement1:Statement2
　　在这个式子中，先计算Operand的真假，若为真，则执行Statement1，若为假，则执行Statement2。下面的代码给出了这种运算的一个例子：
　　　　(a>b)?a:b;
　　这个表达式将返回a和b中较大的那个数值。
3.3.4 浮点型运算符

　　传统的浮点型二元运算除了赋值运算符(+=,-=.*=./)取模(%)和取模赋值(%=0)使浮点数值等价于整数除法，同样，++和--使变量的值增加或减小1。
　　同整型变量相似，结果被放在最大长度的类型里，如果运算包括两个浮点类型，结果也是个浮点类型，如果有一个或几个是双精度浮点型，结果就是双精度浮点型，当你使用关系运算符：>、<、>=、<=、==和!=时，注意浮点变量与整型的不同，只有a==b成立并不能说明ab不成立，这是因为浮点类型数值次序同整型不同，当你写程序，对浮点型数值进行假设时要小心，浮点型数值也包括inf，代表无穷大，溢出产生无穷大inf，下溢产生0。

3.3.5 字符串运算符

　　+运算符可以把字符串并置起来，如果哪一个操作数不是字符串，在并置之前它会被转换成字符串，另外，+=运算符把两个字符串并置的结果放进第一个字符串里，在前面的例子里，当你想把几项打印在同一行里时使用的是+运算符，试着在解释器里用System.out.println和+运算符来造成不同的组合输出。

3.4 数组

3.4.1 说明数组

　　数组是Java语言中的特殊类型。它们存放能通过索引来引用的一系列对象，另外，你可以定义数组的数组，下面是一些示例：


    int i[];
    char c[];
    float f[][];

4.4.2 数组运算符

　　同C/C++不同，数组的分配是通过使用new运算符建立数组然后把它赋给变量，如：
　　　　int a[]=new int[10];
　　前面这个例子建立了一个包括10个整型变量的数组并把它赋给a，你将得到按数字顺序的变量a[0]，a[1]，......，a[8]，a[9]，注意下标是从第一个元素的0开始，到数组个数减1。
　　数组的使用与变量相同，每一个数组成员都可以被用在同类变量被使用的地方，Java也支持多维数组。
　　　　char c[][]=new char[10][10];
　　　　float f[][]=new float[5][];
　　清注意在第二个说明中只有一维的尺度被确定，Java要求在编译时（即在源代码中）至少有一维的尺度被确定了，其余维的尺度可以在以后分配。
　　数组主要用于你有大量相关数据想要存贮在一起而且能够简单地通过数字访问它们，数组是非常强有力的，在后面有章节中我们还会进一步讨论它。

4.5 循环: for,while和do

　　前面四节我们已经学习了Java语言的基本组成，下面三节，我们将学习如何运用这些基本元素去构成Java程序。
　　首先我们学习最简单和最常用的循环语句。
　　Java的循环语句分为三种： for、while和do，它们的语法定义如下：


    for:          for(expression1;expression2;expression3)
                  statement;
    while:        while(boolean)statement;
    do-while:     do statement while(boolean);

4.5.1 for循环

　　Java语言的for语句与C语言的用法完全一致，这一点通过下面的讲解可以看出。
　　for循环结构在实现顺序递增直到达到某一极限的循环时是一个强有力的工具，for语句的格式要求你把一个变量和一个确定的极限作比较，当达到极限时，中止循环，如：
　　　　for(i=0;i<10;i++)......;
　　下面解释变元的格式，在(ex1;ex2;ex3)中，第一个表达式指出for循环的变量初值，在这个例子中变量i被设为0；第二个表达式，i<10，指出循环何时结束，在这个例子中，对0-9的数值表达式都为真(这就是说循环应该继续)；最后的表达式指出循环每次对变量做什么，在例子中，循环使i从0到9，你可以使用这样的语句来顺序访问数组的各个成员；
　　　　int i,a[]=new int[10];
　　　　for (i=0,i<10;i++)a[i]=0;
　　这段代码把整型数组a中的所有元素都赋成0。
　　你可以在for循环的头部说明你的变量，而且最后一个表达式可以省略，不过要确定在语句中对变量的值有所改变，如：
　　for(int i=10;i>=0;)i--;
　　下面for循环的例子将按５度的增量打印出一个从摄氏度到华氏度的转换表：


  class TempConversion
 
      public static void main (String args[])
     
           int fahr,cels;
           System.out.println("Celsius Fahrenheit");
           for(cels=0;cels<=100;cels+=5)
          
               fahr=cels*9/5+32;
               System.out.println(cels+""+fahr);

4.5.2 while和while--do循环结构

　　while循环检查表达式的值是否为真，若为真，则执行给定语句，直到表达式的值为假，另一个while--do循环则执行给定的语句，再检查表达式，若表达式值为真则跳出循环，前面你已经使用过while循环来表示加法运算，你应该记得你一定改变了循环判断中的表达式的值，否则的话，如果它的值为真，你将进入一个死循环，因为它总是真，正如下面的例子：


    boolean test=true;
    while(test)
   
         System.out.println("Hey!.get me out of here!:);
    


　　你可以试着运行一下这些代码，这过千万不要等它结束(Ctrl-C可以中断程序运行)，否则它会一直循环下去的。有些情况下，不管条件表达式的值是为真还是假，你都希望把指定的语句至少执行一次，那么就应使用do--while循环，下面是个例子：

     boolean test=false;
     do
    
       ......
    
     while(test);


　　这种控制并不是很常用，但有时却非常重要，使用时注意结尾处while语句后的分号。
4.6 条件控制:if和switch

4.6.1 if语句

　　if语句通常都与else语句配套使用，所以我们一般都把它叫做if--else语句，它的语法结构如下：


    if--else:      if(boolean)statement1
                      else statement2


　　当表达式boolean为真时，执行statement1，否则执行statement2。
　　下面是一个用if--else语句构造多分支程序的例子：

    if(a>5) b=1
      else if(a>4) b=2
        else if(a>3) b=3
           ...
           else b=-1;

4.6.2 switch分支结构

　　switch分支结构实际上也是一种if--else结构，不过它使你在编码时很容易写出判断条件，特别是有很多选项的时候，它把括号里变量的值同每种情况列出的值做比较，如果相等，就执行后面的语句，如果不等，就执行default语句。在switch语句中，你通常在每一种case情况后都应使用break语句，否则，第一个相等情况后面所有的语句都会被执行，这种情况叫做落空。你可以试着分别加上去和去掉break语句来执行下面的例子：


    class Switch Test
   
        public static void main(String args[])
        throws java.io.IOException
       
          char a;
          System.out.println("Enter a number from 1--3:");
          a=(char)System.in.read();
          switch(a)
         
            case'1':System.out.println("win a Car!");break;
            case'2':System.out.println("picked the goat");break
            case'3':System.out.println("get to keep your 100");
            break;
            default:System.out.println("entry");


　　在代码中加break语句后，你应明确知道程序将会发生的变化，并要确认程序没有转移到你不想执行的代码上。
　　掌握了以上这些基本语句之后，你可以写更加实际点的程序了，下面这个程序计算从终端输入的数字和字符的数量。

    class SwitchTest
   
       public static void main (String args[])
       throws java.io.IOException
      
         int numberOfDigits=0,numberOfSpaces=0,numberOfOthers=0;
         char c;
         while((c=(char)System.in.read())!='')
        
           switch©
          
              case'0':
              case'1':
              ...
              ...
              case'8':
              case'9':numberOfDigits++;break;
              case' ':numberOfSpaces++;break;
              default:numberOfOthers++;break;
           
         
         System.out.println(":");
         System.out.println("Number of digits="+numberOfDigits+"");
         System.out.println("Number of spaces="+numberOfSpaces+"");
         System.out.println("Number of others="+numberOfOthers+"");


　　代码的while循环从键盘读入字符直至输入一个回车符，循环内部的switch语句先把它和数字比较，当发现相等时，它就使对应的统计变量的值加1，然后break语句结束switch语句，程序回到等待键盘输入的状态。程序中，在default语句中的break是不必要的，不过加上它可以使程序风格保持一致。
4.7 break和label

4.7.1 break

　　break语句提供了一种方便的跳出循环的方法。


    boolean test=true;
    int i=0;
    while(test)
   
       i++;
       if(i>=10) break;


　　执行这段程序时，尽管while条件表达式始终为真，全循环只运行10次。
4.7.2 标号label

　　标号提供了一种简单的break语句所不能实现的控制循环的方法，当在循环语句中遇到break时，不管其它控制变量，都会终止。但是，当你嵌套在几层循环中想退出循环时又会怎样呢？正常的break只退出一重循环，你可以用标号标出你想退出哪一个语句。


    char a;
    outer://this is the label for the outer loop
    for(int i=0;i<10;i++)
   
        for(int j=0;j<10;j++)
       
            a=(char)System.in.read();
            if(a=='b')
           
               breakouter;
           
            if(a=='c')
           
               continue outer;


　　在这个例子中，循环从键盘接受100个输入字符，输入“b”字符时，breakouter语句会结束两重循环，注意continue outer语句，它告诉计算机退出现在的循环并继续执行outer循环。
　　读者可能会注意到Java语言没有goto语句，这对于那些习惯使用它的程序员来讲可能会有些不适应，但有经验的程序员一定会明白，goto语句实际上是程序结构混乱的重要根源之一，它最终所引起的问题比它可能带来的好处要大得多。它一般用于比较特殊的问题，但却使你在日后花大量时间去找出一个程序是干什么的。正由于这些原因，Java的设计者果断地删去了它。