第四节  创建数组

创建数组
     使用关键字new 创建一个数组对象
           s = new char 20;
           p = new Point 100;
           p0 = new Point();
           p1 = new Point();
            •
            •

     你可以象创建对象一样，使用关键字new 创建一个数组。
           s = new char 20;
           p = new Point 100;
     第一行创建了一个20个char值的数组，第二行创建了一个100个类型Point的变量。r然而，它并不创建100个Point对象；创建100个对象的工作必须分别完成如下：
           p0 = new Point();
           p1 = new Point();
        •
        •
        •
用来指示单个数组元素的下标必须总是从0开始，并保持在合法范围之内－－大于0或等于0并小于数组长度。任何访问在上述界限之外的数组元素的企图都会引起运行时出错。下面还要谈到一些更好的数组初始化方法。
第五节  初始化数组
初始化数组
-初始化一个数组元素
-用初始化值创建一个数组
         String names  = 
            “Georgianna”,
            “Jen”,
            “Simon”,
           ;
当创建一个数组时，每个元素都被初始化。在上述char数组s的例子中，每个值都被初始化为0 (\u0000-null)字符；在数组p的例子中, 每个值都被初始化为null，表明它还未引用一个Point对象。在经过赋值 p0 = new Point()之后，数组的第一个元素引用为实际Point对象。
   
注意－－所有变量的初始化(包括数组元素)是保证系统安全的基础，变量绝不能在未初始化状态使用。

    Java编程语言允许使用下列形式快速创建数组:
           String names  = 
            “Georgianna”,
            “Jen”,
            “Simon”,
           ;
其结果与下列代码等同：
           String names  ;
           names = new String 3;
           names 0 = “Georgianna”;
           names 1 = “Jen”;
           names 2 = “Simon”;
这种”速记”法可用在任何元素类型。例如：
       Myclass array  = 
         new Myclass (),
         new Myclass (),        
         new Myclass ()
        ;
适当的类类型的常数值也可被使用：
       Color palette   = 
           color.blue,
           color.red,
           color.white
        ;

第四章  数 组
本模块将描述Java编程语言中如何定义、初始化和使用数组。

第一节  相关问题
讨论──下列问题与本模块阐述的论题相关：
- 一个数组的用途是什么？
第二节目 标
完成本模块的学习后，你应该能够：
- 声明并创建原始数组、类数组或数组类型
- 解释为什么数组的元素需初始化
- 给出数组定义并初始化数组元素
- 确定一个数组中元素的数量
- 创建多维数组
- 编写从一个数组类型到另一个数组类型数组值的拷贝代码
第三节  数组的声明
声明数组
-相同类型的成组数据对象
-原始类型或类类型数组声明
-为一个引用创建空间
-数组是一个对象，而不是为原始类型储备的存储器

典型的数组是用来集合相同类型的对象并通过一个名称来引用这个集合。
你可以声明任何类型的数组──原始类型或类类型：
char s［ ］;
Point p  ; // where point is a class
在Java编程语言中，即使数组是由原始类型构成，甚或带有其它类类型，数组也是一个对象。声明不能创建对象本身，而创建的是一个引用，该引用可被用来引用数组。数组元素使用的实际存储器可由new语句或数组初始化软件动态分配。
在以下部分，你将看到如何创建和初始化实际数组。
上述这种将方括号置于变量名之后的声明数组的格式，是用于C、C++和Java编程语言的标准格式。这种格式会使声明的格式复杂难懂，因而，Java编程语言允许一种替代的格式，该格式中的方括号位于变量名的左边：
char［ ］s;
Point［ ］p;
这样的结果是，你可以认为类型部分在左，而变量名在右。上述两种格式并存，你可选择一种你习惯的方式。声明不指出数组的实际大小。
注意----当数组声明的方括号在左边时，该方括号可应用于所有位于其右的变量

第六节  特殊循环流程控制

特殊循环流程控制
break ［标注］；
continue［标注］；
label: 语句；// where statement must be any
               // legal statement.
下列语句可被用在更深层次的控制循环语句中：
break ［标注］；
continue［标注］；
label: 语句；// where statement must be any
       // legal statement.
break语句被用来从switch语句、loop语句和预先给定了label的块中退出。
continue语句被用来略过并跳到循环体的结尾。
label可标识控制需要转换到的任何有效语句，它被用来标识循环构造的复合语句。
例如
loop: while (true) {
for (int i=0; i < 100; i++) {
switch (c = System.in.read()) {
case -1:
case ` \n ` :
// jumps out of while-loop to line #12
break loop;
....
}
} // end for
} // end while
test: for (...) {
....
while (...) {
if (j > 10) {
// jumps to the increment portion of
// for-loop at line #13
continue test;
}
} // end while
} // end for

练习：使用表达式
练习目标──你将编写、编译并运行两个使用标识符、表达式和控制结构的算法程序。
一、准备
为成功地完成本练习，你必须具备编译和运行Java程序的能力，并且熟悉流程控制构造。
二、任务
1级：创建一个阶乘应用程序
一个数X的阶乘（通常记作X!）等于X*(X-1)*(X-2)……*1。例如4!等于4×3×2×1=24。
创建一个称作Factor的应用程序，利用该应用程序可打印2，4，6和10的阶乘。
2级：求解一个几何题程序
已知一个直角三角形，其弦（最长边）的长度由下列公式给出：
编写一个称作hypotenuse的Java软件程序，从已知直角三角形的直角边计算最长边。
提示：从mod3/templates目录中提供的模板解决方案入手，从命令行输入；同时注意java.lang.Math类。
三、练习小结
    讨论──用几分钟的时间讨论一下在以上练习中你所获得的经验、感想和发现。
经验  解释  总结  应用
四、检查你的进度
   在进入下一模块之前，请确认你已经能够：
-区分实例变量和局部变量；
-描述实例变量是如何被初始化的；
-确认并更正“可能的赋值前的引用”的编译器错误；
-辨认、描述并使用Java软件运算符；
-区分合法和非法原始类型赋值；
-确认boolean表达式和它们在控制构造中的要求；
-辨认赋值兼容性和在基本类型中的必要转型；
-使用if, switch,for,while和do句型结构和break和continue的标注形式作为程序的流程控制结构。
五、思考题
-多数编程语言都使用什么数据类型来集合相似的数据元素？
-你怎样对一组元素进行相同的操作（如一个数组）？
-Java编程语言使用什么数据类型？

当变量或表达式的值不能与任何case值相匹配时，可选缺省符（default）指出了应该执行的程序代码。如果没有break语句作为某一个case代码段的结束句，则程序的执行将继续到下一个case，而不检查case表达式的值。 例1： 1.switch (colorNum) { 2.case 0: 3.setBackground(Color.red); 4.break; 5.case 1: 6.setBackground(Color.green); 7.break; 8.default: 9.setBackground(Color.black); 10.break; 11.} 例2： 1.switch (colorNum) { 2.case 0: 3.setBackground(Color.red); 4.case 1: 5.setBackground(Color.green); 6.default: 7.setBackground(Color.black); 8.break; 9.} 例2设定背景颜色为黑色，而不考虑case变量colorNum的值。如果colorNum的值为0，背景颜色将首先被设定为红色，然后为绿色，再为黑色。 第五节 循环语句 循环语句 for语句 for (init_expr; boolean testexpr; alter_expr)｛ statement or block ｝ 循环语句使语句或块的执行得以重复进行。Java编程语言支持三种循环构造类型：for, while和do loops。for和while循环是在执行循环体之前测试循环条件，而do loops是在执行完循环体之后测试循环条件。这就意味着for和while循环可能连一次循环体都未执行， 而do loops将至少执行一次循环体。 3.5.1 for循环 for循环的句法是： for (init_expr; boolean testexpr; alter_expr)｛ statement or block ｝ 例如： for (int i = 0; i < 10; i++) { System.out.println("Are you finished yet?"); } System.out.println("Finally!"); 注意──Java编程语言允许在for () 循环结构中使用逗号作为分隔符。 例如，for (i= 0, j = 0; j<10; i++, j++)是合法的；它将i值初始化为零，并在每执行完一次循环体后，增加一次它们的值。 3.5.2 while循环 循环语句 while循环 while (布尔表达式) ｛ 语句或块 ｝ while循环的句法是： while (布尔表达式) ｛ 语句或块 ｝ 例如： int i = 0; while (i < 10) { System.out.println("Are you finished yet?"); i++; } System.out.println("Finally!"); 请确认循环控制变量在循环体被开始执行之前已被正确初始化，并确认循环控制变量是真时，循环体才开始执行。控制变量必须被正确更新以防止死循环。 3.5.3 do循环 循环语句 do/while语句 do ｛ 语句或块； ｝ while (布尔测试) do循环的句法是： do ｛ 语句或块； ｝ while (布尔测试) 例如： int i = 0; do { System.out.println("Are you finished yet?"); i++; } while (i < 10); System.out.println("Finally!"); 象while循环一样，请确认循环控制变量在循环体中被正确初始化和测试并被适时更新。 作为一种编程惯例，for循环一般用在那种循环次数事先可确定的情况，而while和do用在那种循环次数事先不可确定的情况。

3.3.11  升级和表达式的类型转换
升级和表达式的类型转换
-变量被自动升级为一个较长的形式（如：int至long的升级）
-如果变量类型至少和表达式类型一样大（位数相同），则表达式是赋值兼容的。
当没有信息丢失时，变量可被自动升级为一个较长的形式（如：int至long的升级）
    long bigval = 6; // 6 is an int type, OK
    int smallval = 99L; // 99L is a long, illegal
    double z = 12.414F; // 12.414F is float, OK
    float z1 = 12.414; // 12.414 is double, illegal
一般来讲，如果变量类型至少和表达式类型一样大（位数相同），则你可认为表达式是赋值兼容的。
对 + 运算符来说，当两个操作数是原始数据类型时，其结果至少有一个int，并且有一个通过提升操作数到结果类型、或通过提升结果至一个较宽类型操作数而计算的值，这可能会导致溢出或精度丢失。例如：
short  a，b，c
a=1；
b=2；
c= a+b；
上述程序会因为在操作short之前提升每个short至int而出错。然而，如果c被声明为一个int，或按如下操作进行类型转换：
    c = (short)(a+b);
则上述代码将会成功通过。
第四节  分支语句
分支语句
if, else语句
     if (布尔表达式)｛
        语句或块；
       ｝
     if (条件为真) ｛
        语句或块；
       ｝   else  ｛
        语句或块；
       ｝

条件语句使部分程序可根据某些表达式的值被有选择地执行。Java编程语言支持双路if和多路switch分支语句。
3.4.1  if, else语句
if, else语句的基本句法是：

     if (布尔表达式)｛
        语句或块；
       ｝  else  ｛
        语句或块；
       ｝
例：
int count;
   1.count = getCount(); // a method defined in the program
   2.if (count < 0) {
   3.System.out.println("Error: count value is negative.");
   4.}else {
   5.System.out.println("There will be " + count +
   6." people for lunch today.");
   7.}
在Java编程语言中，if ()用的是一个布尔表达式，而不是数字值，这一点与C/C++不同。前面已经讲过，布尔类型和数字类型不能相互转换。因而，如果出现下列情况：
if  (x)  // x is int
你应该使用下列语句替代：
if  (x ! = 0)
全部else部分是选择性的，并且当测试条件为假时如不需做任何事，else部分可被省略。
3.4.2  switch语句


分支语句
  switch语句
     switch语句的句法是：
     switch (expr1)｛
         case expr2:
         statements;
         break;
         case expr3:
         statements;
         break;
         default:
         statements;
         break;
      ｝

     switch语句的句法是：
     switch (expr1)｛
         case expr2:
         statements;
         break;
         case expr3:
         statements;
         break;
         default:
         statements;
         break;
      ｝
注意──在switch (expr1) 语句中，expr1必须与int类型是赋值兼容的；byte, short或char类型可被升级；不允许使用浮点或long表达式。

3.3.8 右移位运算符>>和>>> 右移位运算符>>和>>> 算术或符号右移位如下所示： 见3-13页 在移位的过程中， 符号位被拷贝 逻辑或非符号右移位运算符(>>>) 作用于位图 在移位的过程中， 符号位不被拷贝 Java编程语言提供了两种右移位运算符 运算符>>进行算术或符号右移位。移位的结果是第一个操作数被2的幂来除，而指数的值是由第二个数给出的。例如： 128 >> 1 gives 128/2 1 = 64 256 >> 4 gives 256/2 4 = 16 -256 >> 4 gives -256/2 4 = -16 逻辑或非符号右移位运算符>>>主要作用于位图，而不是一个值的算术意义；它总是将零置于最重要的位上。例如： 1010 ... >> 2 gives 111010 ... 1010 ... >>> 2 gives 001010 ...在移位的过程中， >>运算符使符号位被拷贝。 注意──移位运算符将它们右侧的操作数模32简化为int类型左侧操作数, 模64简化为long类型右侧操作数。因而, 任何int x, x >>> 32都会导致不变的x值, 而不是你可能预计的零。 注意------值得称赞的重要一点是: >>>运算符仅被允许用在整数类型, 并且仅对int和long值有效。如果用在short或byte值上, 则在应用>>>之前, 该值将通过带符号的向上类型转换被升级为一个int。有鉴于此，无符号移位通常已成为符号移位。 3.3.9 左移位运算符(<<) 左移位运算符(<<) 128 << 1 等于 128*21 = 256 16 <<2 等于 16*22 =64 运算符<<执行一个左移位。移位的结果是：第一个操作数乘以2的幂，指数的值是由第二个数给出的。例如： 128 << 1 gives 128*21 = 256 16<<2 gives 16*22 =64 3.3.10 类型转换 类型转换 如果赋值的信息丢失，程序员必须采用类型转换的方法确认赋值 在short和char之间的赋值需要一个显式转型 见3-16程序 在赋值的信息可能丢失的地方，编译器需要程序员用类型转换（typecast）的方法确认赋值。例如，它可以“挤压”一个long值到一个int变量中。显式转型做法如下： long bigValue =99L; int squashed =（int） （bigValue）; 在上述程序中，期待的目标类型被放置在圆括号中，并被当作表达式的前缀，该表达式必须被更改。一般来讲，建议用圆括号将需要转型的全部表达式封闭。否则，转型操作的优先级可能引起问题。 注意──重温short的范围是：-215至215-1；char的范围是：0至215-1。 因而在short和char之间的赋值总需要一个显式转型

3.3.4  逻辑表达式

逻辑表达式
支持的位运算符如下：
！──NOT          &──AND
｜──XOR          ^──OR
布尔运算符如下：
~ ──Complement(取反)      &──AND
^──XOR                ｜ ｜──OR
多数Java运算符是从其它语言借取得并且和人们一般期待的功能一样。
关系和逻辑运算符返回布尔结果，int到boolean不能自动转换。
     int  i = 1;
     if ( i ) //generates a compile error
     if (i !=0) // Correct
支持的位运算符是！、&、｜、^， 支持的布尔逻辑运算符是NOT、AND、XOR和OR。每个运算都返回布尔结果。运算符&&和｜｜是运算符&和｜的布尔等价物。布尔逻辑运算符将在下一页中讨论。
3.3.5  位运算
Java编程语言支持整数数据类型的位运算，它们的运算符~、&、^和｜分别表示位运算的NOT（为求反）、位AND、位XOR和位OR。移位运算符将稍后在本课程中讨论。
3.3.6  布尔逻辑运算符

布尔逻辑运算符
运算符是&&(AND)和｜｜（OR）
运算符使用举例：
       见3-11页程序
运算符&& (定义为AND)和｜｜（定义为OR）执行布尔逻辑表达式。请看下面的例子：
MyDate d = null;
if ((d! = null) && (d,day() > 31)) ｛
// do something with d
｝
形成if ()语句自变量的布尔表达式是合法且安全的。这是因为当第一个子表达式是假时，第二个子表达式被跳过，而且当第一个子表达式是假时，整个表达式将总是假，所以不必考虑第二个子表达式的值。类似的，如果使用｜｜运算符，而且第一个表达式返回真， 则第二个表达式不必求值，因为整个表达式已经被认为是真。

3.3.7  用加号（+）进行串链接
用加号（+）进行串链接
运算符 +  能够：
进行String链接
生成一个新的String
例如：
        String salutation = "Dr. ";
        String name = "Jack " + "Arthur";
        String title = salutation + name;
    最后一行的结果是：
        Dr. Jack Arthur
一个自变量必须是String对象
非串被自动转换为String对象
运算符 +  能够进行String对象的链接并生成一个新的String：
        String salutation = "Dr. ";
        String name = "Jack " + "Arthur";
        String title = salutation + name;
      最后一行的结果是：
        Dr. Jack Arthur
如果+运算符中有一个自变量为String对象，则其它自变量将被转换成String。所有对象都可被自动转换成String，尽管这样做的结果可能是意义含糊的。不是串的对象是通过使用toString() 成员函数而转换成串的等价物的。

class OurClass { int i; // instance variable of class OurClass int firstMethod() { int j=0; // local variable // both i and j are accessible from // this point ... return 1; } // end of firstMethod() int secondMethod(float f) { //method parameter int j=0; //local variable. Different from the // j defined in firstMethod(). // Scope is limited to the body of // secondMethod(). // Both i(instance variable of the // class OurClass) and j (local // variable of this method) are // accessible from this point. .... return 2; } // end of secondMethod() } // end of class OurClass 3.3.2 变量初始化 在Java程序中，任何变量都必须经初始化后才能被使用。当一个对象被创建时，实例变量在分配存储器的同时被下列值初始化： byte 0 short 0 int 0 long 0L float 0.0f double 0.0d char '\u0000' (NULL) boolean false All reference types Null 注意── 一个具有空值的引用不引用任何对象。试图使用它引用的对象将会引起一个异常。异常是出现在运行时的错误，这将在模块7“异常”中讨论。 在方法外定义的变量被自动初始化。局部变量必须在使用之前做“手工”初始化。如果编译器能够确认一个变量在初始化之前可被使用的情形，编译器将报错。 public void doComputation() { int x = (int)(Math.random() * 100); int y; int z; if (x > 50) { y = 9; } z = y + x; // Possible use before initialization } 3.3.3 运算符 Java软件运算符在风格和功能上都与C和C++极为相似。表3-1按优先顺序列出了各种运算符（“L to R”表示左到右结合，“R to L”表示右到左结合） Separator [] () ; , R to L ++ -- + - ~ ! (data type) L to R * / % L to R + - L to R << >> >>> L to R < > <= >= instanceof L to R == != L to R & L to R ^ L to R | L to R && L to R || R to L ?: R to L = *= /= %= += -= <<= >>= >>>= &= ^= |= 注意──instanceof是Java编程语言特有的运算符，将在模块5“对象和类”中讨论

第三章表达式和流程控制
    本模块讨论变量、运算符和算术表达式并列出不同的管理运行程序路径的控制结构。
   
第一节  相关问题
    讨论──下列问题与本模块阐述的论题相关。
-什么类型的变量对程序员有用(例如，其它语言的程序员想了解Java编程语言是如何定义和处理全局变量和局部变量的) ？
-复合类可以有同名的变量吗？如果可以，它们的作用域有多大？
-列出用于其它语言的控制结构；一般语言都采用什么方法进行流程控制和中断流程(如在循环或开关语句中) ？
第二节  目 标
完成本模块的学习后，你应该能够：
-区分实例变量和局部变量；
-描述实例变量是如何被初始化的；
-确认并更正编译器错误；
-辨认、描述并使用Java软件运算符；
-区分合法和非法原始类型赋值；
-确认boolean表达式和它们在控制构造中的要求；
-辨认赋值兼容性和在基本类型中的必要计算；
-使用if, switch,for,while和do句型结构和break和continue的标号形式作为程序中的流程控制结构。
第三节  表达式
3.3.1  变量和作用域

      变量和作用域
-局部(local)变量是在一个方法内定义的变量, 也被称作自动（automatic）、临时（temporary）或栈（stack）变量
-当一个方法被执行时, 局部变量被创建；当一个方法被终止时, 局部变量被清除
-局部变量必须使用之前初始化, 否则编译时将出错
    你已经看到了两种变量的描述方法：原始类型变量和引用类型变量。你也看到了变量被声明的位置：在方法内(方法是面向对象的术语，它可引用函数或子程序，例如：main())或在方法外但在类定义之内。变量也可被定义为方法参数或构造函数参数。
    在方法内定义的参数被称为局部(local)变量，有时也被用为自动（automatic）、临时（temporary）或栈（stack）变量。
    在方法外定义的变量是在使用new Xxxx ()调用构造一个对象时被创建。在构造一个对象时，可创建两种变量。一是类变量，它是用static关键字来声明的；只要需要对象，类变量就将存在。二是实例变量，它不需用static关键字来声明；只要对象被当作引用，实例变量就将存在。实例变量有时也被用作成员变量，因为它们是类的成员。
    方法参数变量定义在一个方法调用中传送的自变量，每次当方法被调用时，一个新的变量就被创建并且一直存在到程序的运行跳离了该方法。
当执行进入一个方法时，局部变量被创建，当执行离开该方法时，局部变量被取消。因而，局部变量有时也被引用为“临时或自动”变量。在成员函数内定义的变量对该成员变量是“局部的”，因而，你可以在几个成员函数中使用相同的变量名而代表不同的变量。 该方法的应用如下所示：

2.9.6  术语回顾
   术语回顾
-Class
-Object
-Reference type
-member
  
    本模块中介绍了几个术语，简单回顾如下：
-类------在Java编程语言中定义新类型的一种途径。类声明可定义新类型并描述这些类型是如何实现的。有许多关于类的其它特性还未讨论。
-对象------一个类的实例。类可被认为是一个模板------你正在描述一个对象模型。一个对象就是你每次使用new创建一个类的实例的结果。
-引用类型------一个用户定义类型, 它可引用类、界面和数组。
-成员------构成一个对象的元素之一。这个词也被用作定义类的元素(elements)。成员变量(member variabl)、实例变量(instance variable)和域(field)也经常被互换使用。

练习：使用对象
     练习目标──正确使用Java关键字，编写一个创建类的程序并从类创建一个对象。编译并运行程序，然后校验引用是否被赋值并检查引用是不是按照本模块所描述的那样操作的。
一、准备
     为了成功地完成本练习，你必须能够编译并运行Java程序，并且需要熟悉有关类和对象的面向对象的概念和引用的概念。
二、任务
     1级：创建一个类和相应的对象
1.一个点可用x和y坐标描述。定义一个称为MyPoint的类来表达上述想法。你应该称这个文件为什么?
2.在你的类中编写一个类方法，然后为类型MyPoint声明两个变量，将变量称为start和end；用new MyPoint()创建对象并分别将引用值赋予变量start和end；
3.将值10赋予对象start的成员x和y；
4.将值20赋予对象end的x值，将值20赋予对象end的y值。
5.分别打印MyPoint对象(start和end)的成员值(x和y)。

注意----为完成第5步，你需要更多地了解system类。带自变量String的System.out.println()可输出string并开始新的一行，而System.out.print()不开始新的一行。如果你使用System.out.print()，你应该在这个应用程序结束之前，调用System.out.println()或System.out.flush()，否则你会发现，输出的最后一行未被显示出来。
      为显示数字，你可以使用下列形式(稍后将在本课程中讨论)
      System.out.println(“Start MyPoint = x：“+start.x + “ y “ + start.y);
注意--如果一个操作数已经是一个String, 则加号(+)将另一个操作数转换成String。
6.编译并运行程序。
     2级：检验引用赋值
     使用你在前一个练习中MyPoint类，增加代码到main()方法，以完成下列事项：
1.为类型MyPoint声明一个新的变量，称之为stray。将现存变量end的引用值赋予stray；
2.打印end和stray变量的成员x和y的值；
3.赋予变量stray的成员x和y新的值；
4.打印end和stray的成员的值；编译并运行MyPoint类。end的值反映了stray内的变化，表明两个变量都引用了同一个MyPoint对象；
5.将start变量的成员x和y赋予新的值；
6.打印start和end的成员值; 再次编译并运行MyPoint类，start的值仍然独立于stray和end的值，表明start变量仍然在引用一个MyPoint对象，而这个对象与stray和end引用的对象是不同的。
三、练习小结
    讨论──用几分钟的时间讨论一下在以上练习中你所获得的经验、感想和发现。
经验  解释  总结  应用
四、检查你的进度
在进入下一模块之前，请确认你已经能够：
-在源程序中使用注释
-区分有效和无效标识符
-识别Java技术关键字
-列出八个原始类型
-为数字和文本类型定义文字值
-定义术语class, object,member,variable,referrence variable
-为一个简单的包含原始成员变量的类创建一个类定义
-声明类类型的变量
-使用new构造一个对象
-描述缺省初始化
-使用点符号访问一个对象的成员变量
-描述引用变量的意义
-陈述分配类类型变量的结果
五、思考题
    在你现有应用程序中，你可以构思一个使用类和对象的例子吗

使用一个语句同时为引用today和由引用today所指的对象分配空间也是可能的。
      MyDate today = new MyDate ();
2.9.5  引用类型的赋值

引用变量的赋值
请考虑下列代码片段：
     int x = 7;
     int y = x;
     String s = “Hello”;
     String t = s;

    在Java编程语言中，用类的一个类型声明的变量被指定为引用类型，这是因为它正在引用一个非原始类型，这对赋值具有重要的意义。请看下列代码片段：
     int x = 7;
     int y = x;
     String s = “Hello”;
     String t = s;
    四个变量被创建：两个原始类型 int 和两个引用类型String。x的值是7，而这个值被复制到y；x 和 y是两个独立的变量且其中任何一个的进一步的变化都不对另外一个构成影响。
至于变量 s 和 t，只有一个String 对象存在, 它包含了文本”Hello” ，s 和 t均引用这个单一的对象。

2.9.3  创建一个对象
创建一个对象
-原始类型的声明可分配存储器空间
-非原始类型的声明不分配存储器空间
-声明的变量不是数据本身, 而是数据的引用(或指针)
   当任何原始类型(如boolean, byte, short,char,int,long,float或double类型) 的变量被声明时，作为上述操作的一部分，存储器空间也同时被分配。使用非原始类型(如String或class)的变量的声明不为对象分配存储器空间。
    事实上，使用class类型声明的变量不是数据本身，而是数据的引用(reference)。
注意----你也可以认为引用是一个指针(pointer), 这可能会有助于你的理解。实际上, 在大多数实现中, 也确实可以这样认为。值得注意的是, Java编程语言实际上不支持指针数据类型。
    在你可以使用变量之前，实际存储器必须被分配。这个工作是通过使用关键字new来实现的。如下所示：
      MyDate myBirth;
      myBirth = new MyDate ();
    第一个语句(声明)仅为引用分配了足够的空间，而第二个语句则通过调用对象为构成MyDate的三个整数分配了空间。对象的赋值使变量myBirth重新正确地引用新的对象。这两个操作被完成后，MyDate对象的内容则可通过myBirth进行访问。
假使定义任意一个class XXXX, 你可以调用new XXXX () 来创建任意多的对象，对象之间是分隔的。一个对象的引用可被存储在一个变量里，因而一个”变量点成员”(如myBirth.day)可用来访问每个对象的单个成员。请注意在没有对象引用的情况下，仍有可能使用对象，这样的对象称作”匿名”对象。
2.9.4  创建一个对象----存储器分配和布局

创建一个对象----存储器分配和布局
一个声明仅为一个引用分配存储器
     MyDate today
     today = new MyDate();
     today
      在一个方法体中，声明
      MyDate today
      today = new MyDate();
      仅为一个引用分配存储器
      today

      关键字new意味着存储器的分配和初始化
MyDate today;
today = new MyDate();
      赋值则建立了引用变量，从而它可适当地引用新的创建对象
     MyDate today;
      today = new MyDate();

第九节  理解对象

理解对象
回顾对象的历史
创建一个新的类型，如date
     public class date｛
        int day;
        int month;
        int year;
     ｝
声明一个变量
        Date myBirth, yourBirth
访问成员
           myBirth.day  = 26;
           myBirth.month = 11;
           yourBirth.year = 1960;

2.9.1  回顾对象的历史
早些时候的编程语言和初级程序员将每个变量看作相互无关的实体。例如，如果一个程序需处理某个日期，则要声明三个单独的整数：
int day, month, year;
上述语句作了两件事，一是当程序需要日、月或年的有关信息时，它将操作一个整数； 二是为那些整数分配存储器。
尽管这种作法很容易理解，但它存在两个重大缺陷。首先，如果程序需同时记录几个日期，则需要三个不同的声明。例如，要记录两个生日，你可能使用：
int  myBirthDay, myBirthMonth, myBirthYear;
int  yourBirthDay, yourBirthMonth, yourBirthYear;
    这种方法很快就会引起混乱，因为需要的名称很多。
    第二个缺陷是这种方法忽视了日、月和年之间的联系并把每个变量都作为一个独立的值，每个变量都是一个独立单元(在本例中为date)的一部分并被相应地处理。
2.9.2  创建一个新类型
    为克服上述两种缺陷，Java编程语言使用类来创建新类型。请看下列原始类型声明：
         int  day;
    Java编程语言被用来分配一定量的存储器并解释该存储器的内容。于是，要定义一个新的类型，你必须指出需要多大存储器和如何解释存储器内容。这不是根据字节数或位的顺序和含义来做，而是根据已经定义的其它类型来做。
    例如，要定义一个表示日期的类型，你需要足够的存储器存储三个整数变量；进而，日、月和年的意义即由这些整数变量给出。如下所示：
       class MyDate  
      int day;
      int month;
      int year;
      
词class是Java编程语言的一个关键字，必须全部小写。名称MyDate按照大小写的有关约定处理，而不是由语意要求来定。
  注意----- class 不仅仅是一个集合数据类型，这个问题以后还将进一步讨论。

    一个变量可被声明为归属于类型MyDate，从而日、月和年部分将被隐含声明。例如：
    MyDate  myBirth, yourBirth;
    使用这个声明，Java编程语言允许变量的部分(day, month和year)通过调用成员和使用点(•)运算符而被访问。例如：
     myBirth.day  =  26;
     myBirth.month = 11;
     yourBirth.year = 1960;

第八节  Java编码约定
                java编码约定
 类：
                class  AccouJntBook
                class  ComplexVariable
 界面：
                interface  Account
 方法：
                balanceAccount（）
                addComplex （）
    Java编程语言的一些编码约定是：
    classes──类名应该是名词，大小写可混用，但首字母应大写。例如：
                class  AccountBook
                class  ComplexVariable
    interface──界面名大小写规则与类名相同。
                interface  Account
    method──方法名应该是动词，大小写可混用，但首字母应小写。在每个方法名内，大写字母将词分隔并限制使用下划线。例如：
                balanceAccount（）
                addComplex （）
                 Java编码约定
变量
currentCustomer
常量
HEAD-COUNT
MAXIMUM-SIZE
Java编码约定
Variables──所有变量都可大小写混用，但首字符应小写。词由大写字母分隔，限制用下划线，限制使用美元符号（$），因为这个字符对内部类有特殊的含义。
         currentCustomer
变量应该代表一定的含义，通过它可传达给读者使用它的意图。尽量避免使用单个字符， 除非是临时“即用即扔”的变量（例如，用i, j, k作为循环控制变量）
constant──原始常量应该全部大写并用下划线将词分隔；对象常量可大小写混用。
         HEAD-COUNT
         MAXIMUM-SIZE
   control structures──当语句是控制结构的一部分时，即使是单个语句也应使用括号（｛｝）将语句封闭。例如：
if  (condition) ｛
   do something
｝else  ｛
   do something else
｝
spacing── 每行只写一个语句并使用四个缩进的空格使你的代码更易读。
comments──用注释来说明那些不明显的代码段落；对一般注释使用 //  分隔符， 而大段的代码可使用 /*•••*/分隔符。使用 /**•••*/将注释形成文档，并输入给javadoc以生成HTML代码文档。
// A comment that takes up only one line.
/* Comments that continue past one line and take up space on multiple lines...*/
/** A comment for documentation purposes.
@see Another class for more information
*/
注意──@see是一个有关类或方法的特殊的javadoc标记符（”see also”）。有关javadoc的详细资料， 请参见“The Design of Distributed Hyperlinked Programming Documentation”(Lisa著)的有关文档系统的完整定义。该资料可从下列地址获得：http://www.javasoft.com/doc/api_documentation.html.

2.6.4 浮点──float和double
浮点──float和double
-缺省为double
-浮点文字包括小数点或下列各项之一
-E或e  (增加指数值)
-F或f  (float)
-D或d  （double）
3.14            一个简单的浮点值（a double）
4.02E23         一个大浮点值
            2.718F        一个简单的float长度值
            123.4E+306D  一个大的带冗余D的double值
    浮点变量可用关键字float或double来声明，下面是浮点数的示例。如果一个数字文字包括小数点或指数部分，或者在数字后带有字母F或f（float）、D或d（double），则该数字文字为浮点。
3.14            一个简单的浮点值（a double）
4.02E23         一个大浮点值
            2.718F        一个简单的float长度值
            123.4E+306D  一个大的带冗余D的double值
浮点──float和 double
浮点数据类型具有下列范围：
     浮点长度               名称或类型
      32 bits                   float
      64 bits                   double
浮点──float和 double（续）
   
       表2—3  浮点数据类型──范围
     
     浮点长度               名称或类型
      32 bits                   float
      64 bits                   double

注意──浮点文字除非明确声明为float，否则为double

第七节  变量、声明和赋值
Java技术规范的浮点数的格式是由电力电子工程师学会（IEEE）754定义的，它使用表2—3的长度，并且是独立于平台的。
下列程序显示了如何为整数、浮点、boolean、字符和string类型变量声明和赋值。
   1. public class Assign {
   2. public static void main(String args []) {
   3. int x, y; // declare int
     // variables
   4.float z = 3.414f; // declare and assign
     // float
   5.double w = 3.1415; // declare and assign
     // double
   6.boolean truth = true; // declare and assign
     // boolean
   7.char c; // declare character
     // variable
   8.String str; // declare String
   9.String str1 = "bye"; // declare and assign
     // String variable
  10.c = 'A'; // assign value to char
     // variable
  11.str = "Hi out there!"; // assign value to
     // String variable
  12.x = 6;
  13.y = 1000; // assign values to int variables
  14....
  15.}
  16.}
非法赋值举例
y = 3.1415926; // 3.1415926 is not an int.
             // Requires casting and decimal will
             // be truncated.
w = 175,000; // the comma symbol ( , ) cannot appear
truth = 1; // a common mistake made by ex- C / C++
            // programmers.
z = 3.14156 ; //can't fit double into a
           //Float. Requires casting.