源文件布局
源文件布局
包含三个“顶级”要素
-一个可选择的包声明
-任意数量的输入语句
-类和界面声明
一个Java源文件可包含三个“顶级”要素：
-   一个包声明（可选）
-   任意数量的输入语句
-   类和界面声明
该三要素必须以上述顺序出现。即，任何输入语句出现在所有类定义之前；如果使用包声明，则包声明必须出现在类和输入语句之前。
第五节类和包介绍
类和包介绍
1.什么是类和包？
2.Java类库中的几个重要包
       java.lang
       java.awt
       java.applet
       java.net
       java.io
       java.util
类是描述提供某种功能的模块的一般术语。Java开发集（JDK）给出了一套标准的类（称作类库），这些类可执行大部分所需的基本行为     不仅为编程任务（例如，类可提供基本的数学函数、数组和字符串），而且为图形和网络。
类库被组织成许多包，每个包都包含几个类。如下所列为一些重要的包：
java.lang包含一些形成语言核心的类，如String、Math、Integer和Thread。
java.awt包含了构成抽象窗口工具包（AWT）的类，这个包被用来构建和管理应用程序的图形用户界面。
java.applet包含了可执行applet特殊行为的类。
    java.net包含执行与网络相关的操作的类和处理接口及统一资源定位器(URLs)的类。
    java.io包含处理I/O文件的类。
java.util包含为任务设置的实用程序类，如随机数发生、定义系统特性和使用与日期日历相关的函数。
第六节使用Java API文档
使用Java API文档
1.一组超文本标识语言(HTML)文件提供了有关API的信息
2.一个包包含了对所有类信息的超链接
3.一个类文档包括类层次、一个类描述、一组成员变量和构造函数等
一组HTML文件以文档的形式提供了有关API的信息，这个文档的布局是等级制的，因而主页列出所有的包为超链接。如果选中了一个特殊包的热链接，作为那个包成员的类将被列出。从一个包页选中一个类的热链接将提交一页有关那个类的信息。

图1-1显示了这样一个类文档


图1-1
一个类文档的主要部分包括:
-类层次
-类和类的一般目的描述
-成员变量列表
-构造函数列表
-方法列表
-变量详细列表及目的和用途的描述
-构造函数详细列表及描述
-方法详细列表及描述
练习：基本任务
练习目标－－在本练习里，你将利用Java API文档练习如何识别包、类和方法并练习标准输入输出方法。你还将编写、编译和运行两个简单的使用这些方法的应用程序。
一、准备
理解本模块中提出的概念和术语对理解文件和运用文件信息编写程序至关重要。
二、任务
1级：阅读文件
1.你的老师将指导你如何启动API浏览器并打开Java API在线文档的索引页。
2.找到java.lang包
3.在此包中定义了那些类？在System类中有那些方法？System.out.println方法是在什么包中定义的？什么是标准输入方法调用？
2级：创建一个Java应用程序
1.使用任意文本编辑器，创建一个可打印你选定的字串的与HelloWorldApp类似的应用程序。
2.编译程序并纠正错误。
3.用解释器运行程序。
3级：使用标准输入和标准输出
编写一个称为MyCat的应用程序，它将从stdin中读出一行并将这一行写回到stdout. 无论stdin还是stdout都在java.lang.System类中。
三、检查你的进度
在进入下一模块之前，请确认你已经能够：
-描述Java编程语言的主要特性
-描述JVM
-描述垃圾收集是如何进行的
-列出由处理代码安全性的Java平台所执行的三个任务
-定义术语类、包、applets和application
-编写、编译并运行一个简单的Java应用程序
-使用Java技术应用程序编程界面(API)的在线文档识别java.lang包中的方法。
四、思考题
使用Java编程语言将为你的工作带来什么益处？

第二章  标识符、关键字和类型
本模块阐述了在Java技术程序中使用的基本元素，包括变量、关键字、原始类型和类类型。

第一节  相关问题
讨论──下列问题与本模块阐述的论题相关。
- 你是如何理解类的？
- 你是如何理解一个对象的？
第二节  目标
完成本模块的学习后，你应该能够：
- 在一个源程序中使用声明
- 区分有效和无效标识符
- 确认Java技术关键字
- 列出八个原始类型
- 为数字类型和文本类型定义文字值
- 定义术语class、object、member variable和reference variable
- 为一个简单的包含原始成员变量的类创建一个类定义
- 声明类类型变量
- 使用new构造一个对象
- 描述缺省初始化
- 使用点符号访问一个对象的成员变量
- 描述一个参考变量的意义
- 规定分配类类型变量的结果
第三节注 释
注释
三种允许的Java技术程序注释风格
          //comment on one line
          /* comment on one
          or more line */
          /** documenting comment */
2.3.1  概述
有三种插入注释的允许风格：
          //comment on one line
          /* comment on one or more line */
          /** documenting comment */
紧放在声明(变量、方法或类的声明)之前的文档注释表明, 注释应该被放在自动生成的文档中(由javadoc命令生成的HTML文件)以当作对声明项的描述。

注意------有关这些注释的格式和 javadoc工具的使用，请见JDK1.2 API文件的  docs/tooldocs/win32目录

2.3.2分号、块和空白
分号、块和空白
-一个语句是一行用分号(；) 终止的代码   
     totals=a+b+c+d+e+f；
-一个块是以上括号和下括号为边界的语句集合
      
          x=y+1
          y=x+1
      
    在Java编程语言中，语句是一行由分号(;)终止的代码。
    例如
               totals=a+b+c+d+e+f；
       与下式相同
           total=a+b+c+
            d+e+f；
一个块(block)或一个复合语句是以上括号和下括号（）为边界的语句集合；块语句也被用来组合属于某个类的语句。

分号、块和空白（续）
分号、块和空白
-一个块可被用在一个类的定义中
      public class Date 
         int day;
         int month;
         int year;
      
-块语句可被嵌套
-Java程序中允许任意多的空白
语句块可被嵌套。HelloWorldApp类由main方法构成，这个方法就是一个语句块，它是一个独立单元，单元本身可作为在类HelloWorldApp块中的一组事务之一。
    其它一些块语句或组的例子如下：
   
   // a block statement
{
x = y + 1;
y = x + 1;
}
Semicolons, Blocks, and Whitespace
// a block used in a class definition
public class MyDate {
int day;
int month;
int year;
}
// an example of a block statement nested within
// another block statement
while ( i < large ) {
a = a + i;
if ( a == max ) {
b = b + a; // nested block is here
a = 0;
}
}
在源代码元素之间允许空白，空白的数量不限。空白(包括空格、tabs和新行)可以改善你的对源代码的视觉感受。
{
int x;
x = 23 * 54;
}
   
   
    int  x
    x  =  23  +  54;
}

第四节  标识符
                    标识符
-是赋予变量、类和方法的名称
-可从一个字母、下划线(_)或美元符号($)开始
-是大小写区别对待的, 且无最大长度
    在Java编程语言中，标识符是赋予变量、类或方法的名称。标识符可从一个字母、下划线(_)或美元符号($)开始，随后也可跟数字。标识符是大小写区别对待的并且未规定最大长度。
    有效标识符如下：
-identifier
-userName
-User_name
-_sys_varl
-$change
Java技术源程序采用有效的16-bit 双字节字符编码标准(Unicode) ，而不是8-bit ASCII文本。因而，一个字母有着更广泛的定义，而不仅仅是a到z和A到Z。
谨慎对待非ASCII字符，因为Unicode可支持看似相同而实际不同 的字符。
标识符不能是关键字，但是它可包含一个关键字作为它的名字的一部分。例如，thisone是一个有效标识符，但this却不是，因为this是一个Java关键字。Java关键字将在后面讨论。
注意──包含美元符号（$）的关键字通常用的较少， 尽管它在BASIC和VAX/VMS系统语言中有着广泛的应用。由于它们不被熟知， 因而最好避免在标识符中使用它们， 除非有本地使用上的习惯或其他不得已的原因。

第五节  Java关键字
表2-1列出了使用在Java编程语言中的关键字。
abstract    do     implements  private    throw
boolean    double  import      protected  throws
break      else    instanceof   public    transient
byte       extends int         return     true
case       false   interface    short      try
catch      final   long        static      void
char       finally  native      super      volatile
class      float    new       switch     while
continue   for     null        synchronized
default     if      package    this
关键字对Java技术编译器有特殊的含义，它们可标识数据类型名或程序构造（construct）名。
以下是有关关键字的重要注意事项：
- true、false和null为小写，而不是象在C++语言中那样为大写。严格地讲，它们不是关键字，而是文字。然而，这种区别是理论上的。
- 无sizeof运算符；所有类型的长度和表示是固定的，不依赖执行。
- goto和const不是Java编程语言中使用的关键字。

第六节  基本Java类型
Java编程语言定义了八个原始类型
-逻辑类   boolean
-文本类   char
-整数类   byte, short, int, long
-浮点类   double, float
2.6.1  原始类型
Java编程语言为八个原始数据类型和一个特殊类型定义了文字值。原始类型可分为四种：
-逻辑类   boolean
-文本类   char
-整数类   byte, short, int, long
-浮点类   double, float
2.6.2  基本Java类型
1.逻辑类──boolean
逻辑类──boolean
boolean  数据类型有两种文字值：true和false。
例如：boolean  truth  =  true；
上述语句声明变量truth为boolean 类型，它被赋予的值为true。
逻辑值有两种状态，即人们经常使用的“on”和“off” 或“true”和“false”或“yes”和“no”，这样的值是用boolean类型来表示的。boolean有两个文字值，即true和false。以下是一个有关boolean类型变量的声明和初始化：
boolean truth = true; //declares the variable truth
                 //as boolean type and assigns it
                 //the value true
注意──在整数类型和boolean类型之间无转换计算。有些语言（特别值得强调的是C和C++）允许将数字值转换成逻辑值， 这在Java编程语言中是不允许的；boolean类型只允许使用boolean值。

2.文本类──char和String
文本类──char和String
char
-代表一个16-bit Unicode字符
-必须包含用单引号（’’）引用的文字
-使用下列符号：
    ‘a’
    ‘\t’        一个制表符
   ‘\u????’    一个特殊的Unicode字符，????应严格使用四个16进制数进行替换
使用char类型可表示单个字符。一个char代表一个16-bit无符号的（不分正负的）Unicode字符。一个char文字必须包含在单引号内(‘’)。
‘a’
‘\t’       一个制表符
‘\u????’   一个特殊的Unicode字符。????应严格按照四个16进制数字进行替换
String不是原始类型，而是一个类（class），它被用来表示字符序列。字符本身符合Unicode标准，且上述char类型的反斜线符号适用于String。与C和C++不同，String不能用 \0作为结束。
文本类──char和String
String
-不是一个原始数据类型，它是一个类
-具有用双引号引用的文字
“The  quick brown fox jumped over the lazy dog.”
-   可按如下情形使用：
String greeting =  “Good Morning!! \n”；
String err_meg = “ record not found !”;

文本类──char和String (续)
String的文字应用双引号封闭，如下所示：
“The  quick brown fox jumped over the lazy dog.”
Char和String类型变量的声明和初始化如下所示：
   char ch = `A'; // declares and initializes a char variable
   char ch1,ch2 ; // declares two char variables
  // declare two String variables and initialize them
  String greeting = "Good Morning !! \n" ;
  String err_msg = "Record Not Found !" ;
  String str1,str2 ; // declare two String variables
2.6.3  整数类──byte, short, int, long
整数类──byte, short, int, long
   
采用三种进制──十进制、八进制和16进制
2        十进制值是2
077      首位的0表示这是一个八进制的数值
0xBAAC  首位的0x表示这是一个16进制的数值
具有缺省int
用字母“L”和“l”定义long
在Java编程语言中有四种整数类型，每种类型可使用关键字byte, short, int和long中的任意一个进行声明。整数类型的文字可使用十进制、八进制和16进制表示，如下所示：
2        十进制值是2
077      首位的0表示这是一个八进制的数值
    0xBAAC  首位的0x表示这是一个16进制的数值

注意──所有Java编程语言中的整数类型都是带符号的数字。

整数类──byte, short, int, long（续）
整数类文字属int类型，除非在其后直接跟着一个字母“L”。L表示一个long值。请注意，在Java编程语言中使用大写或小写L同样都是有效的，但由于小写l与数字1容易混淆，因而，使用小写不是一个明智的选择。上述文字的long的形式如下：
2L        十进制值是2，是一个long
077L      首位的0表示这是一个八进制的数值
0xBAACL  前缀0x表示这是一个16进制的数值
整数类──byte, short, int, long
每个整数数据类型具有下列范围：
Integer Length  Name or Type  Range
8 bits         byte         -2 7 ... 2 7 -1
16 bits        short        -2 15 ... 2 15 -1
32 bit         int          -2 31 ... 2 31 -1
64 bits        long         -2 63 ... 2 63 -1
整数类──byte, short, int, long（续）
四个整数类型的长度和范围如表2-2所示。范围的表示是按Java编程语言规范定义的且不依赖于平台。
表2-2  整数数据类型—范围
Integer Length  Name or Type  Range
8 bits         byte         -2 7 ... 2 7 -1
16 bits        short        -2 15 ... 2 15 -1
32 bit         int          -2 31 ... 2 31 -1
64 bits        long         -2 63 ... 2 63 -1
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

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.

第八节  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.

第九节  理解对象

理解对象
回顾对象的历史
创建一个新的类型，如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;

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();

使用一个语句同时为引用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.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构造一个对象
-描述缺省初始化
-使用点符号访问一个对象的成员变量
-描述引用变量的意义
-陈述分配类类型变量的结果
五、思考题
    在你现有应用程序中，你可以构思一个使用类和对象的例子吗

第三章表达式和流程控制
    本模块讨论变量、运算符和算术表达式并列出不同的管理运行程序路径的控制结构。
   
第一节  相关问题
    讨论──下列问题与本模块阐述的论题相关。
-什么类型的变量对程序员有用(例如，其它语言的程序员想了解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关键字来声明；只要对象被当作引用，实例变量就将存在。实例变量有时也被用作成员变量，因为它们是类的成员。
    方法参数变量定义在一个方法调用中传送的自变量，每次当方法被调用时，一个新的变量就被创建并且一直存在到程序的运行跳离了该方法。
当执行进入一个方法时，局部变量被创建，当执行离开该方法时，局部变量被取消。因而，局部变量有时也被引用为“临时或自动”变量。在成员函数内定义的变量对该成员变量是“局部的”，因而，你可以在几个成员函数中使用相同的变量名而代表不同的变量。 该方法的应用如下所示：

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“对象和类”中讨论