2 标识符
标识符的首字符必须是一个字母，下划线("_")或美元符号("$")。 后
面的字符也可是数字0-9。 Java使用泛代码字符集，为了便于识别好一
合法标识符，下面列出它的“字母”：
* 大写字母“A”～“Z”
* 小写字母“a”～“z”
* 泛代码（Unicode）中所有字符编码在十六进制数00C0之前的字
符。标识符中，首字母后的字符可以是任意的。当然，Unicode区段中
那些被保留作特殊字符的除外。由此，“garton”及“MjΦlner”都是合法标识符

3 关键字
下面的标识符被保留用作关键字，他们不能作任何其它的用途。
abstract default goto* null synchronized
boolean do if package this
break double implements private threadsafe
byte else import protected throw
byvalve * extends instanceof public transient
case false int return true
catch final interface short try
char finally long static void
class float native super while
const * for new switch
continue
其中，加*标记后是被保留但当前却未使用的。

4 字变量
字变量(literal)是某些类型值的基本表述，这些类型包括整型，浮点型，布尔量，字符及字符串。

4.1 整型字变量
整数可有三种表示形式： 十进制，八进制和十六进制。一个十进制
整型字变量由一系列的数字组成，但它的第一个数字不能是0(有时十进
制数字也可象下面讲的那样加后缀)。整数也可表达成八进制或十六进制
形式。
以0开头的整型字变量，意味着它是一个十六进制的。十六进制
整数可以包括数字0-9以及字母a-f及A-F。
八进制整数中则只能是出现数字0-7。在超过32位所能表示的范围之前，
整型字变量的类型即为int，否则为long型。
一个整型字变量可通过加后缀L或l而强迫成long型。
下面的均为合法的整型字变量。
2 2L 0777

4.2 浮点字变量
一个浮点字变量可包括以下部分: 一个十进制整数，一个小数点“.”，
小数部分(另外一个十进制整数)，指数部分，一个类型后缀。指数部分
是一个e或E后跟一个整数。浮点字变量至少包含有一个数字，外加或
者一个小数点或者一个e(或E)，下面举一些浮点字变量的例子：
3.1415 3.1E12 .1e12 2E12
就象在后面描述的那样，Java语言有两种浮点类型： float 及
double，用户可按以下写法区分：
2.0d或2.0D double 型
2.0f或2.0F或2.0 float型

4.3 布尔字变量
布尔(boolean)字变量有两个值： true及false。

4.4 字符字变量
字符字变量是一个由单引号括起的字符(或者是由一组字符来表述
一个字符)。字符属于char类型，并且均从泛代码字符集中得来。而下面
列出的转义序列则用来描述一些非图形字符，它们以反斜杠“\”开始以
作转义用。

续行符头 \
换行 NL(LF) \n
垂直制表符 HT \t
退格 BS \b
回车 CR \r
走纸换页 FF \f
反斜杠 \ \\
单引号 ' \'
双引号 " \"
八进制数 0ddd \ddd
十六进制数 0xdd \xdd
泛代码字符 0xdddd \udddd

4.5 串字变量
串字变量是双引号引起的零个或多个字符的序列。每个串字变量被
看作是一个串对象，而并非是一个字符的数组，例如“abc”创建了一
个新的串类的实例。下面的都是合法的串字变量：
" " \\空串
"\" " \\只包含一个双引号的串
"This is a string"
"This is a \
two-line string"

5 运算符及特殊分隔符
下面这些字符在Java源程序中作运算符或分隔符用：
+ — ! % ^ & * ｜ ～ / > <
( ) { } [ ] ; ? : ，· =
另外，下面这些复合字符被用作运算符：
++ -- == <= >= != << >>
>>> += -= *= /= &= /=
^= %= <<= >>= >>>= ‖ &&
后面还要在运算符一节中作详细介绍。

6 类型
任何一个变量或表达式都有一个类型，类型决定变量可能的取值范
围，决定对这些值允许的操作，以及这些操作的意义是什么。Java语言
中提供了内置定义类型，程序员也可以利用类及界面(interface)机制构造
新类型。
Java语言有两种类型： 简单类型和复合类型。简单类型指那些不能
再分割的原子类型。如：整型、浮点型、布尔型、字符型均为简单类型。
复合类型建立在简单类型的基础上。Java语言有三种复合类型：数组、
类及界面。在本节中，我们主要讨论简单类型及数组。

6.1 数值类型

6.2 字符类型
Java全部使用泛代码字符集，因此char类型数据被定义成一个16位的无符号整数。

6.3 数组
数组在Java语言中属第一类对象。由它们代替了指针运算，所有的
对象(包括数组)都可通过标识来引用。即使被当作数运算，标识的值也
不应被破坏。  通过new运算符可创建一个数组。
char s[]=new char[30];
数组第一元素的下标为0，在声明中指定维数是不允许的。每次都
必须显式地用new分配数组：
int i [] =new int [3];
Java语言不支持多维数组，但是，程序员却可以创建数组的数组。
int i [ ] [ ]=new int [3][4];
至少有一维要明确给定，而其它维则可在以后再确定。例如：
int i[] []=new int [3] [ ]
是一个合法的声明。
 除了在变量名及方法名后跟方括号这种C风格的声明之外，Java语
言允许方括号跟在数组类型之后，下面两行是等价的：
int iarray[ ];
int [ ] iarray;
同样地，方法声明也一样：
byte f(int n)[ ];
byte [ ] f(int n);
运行时检查下标保证它们是合法的：
int a[ ]=new int [10];
a[5]=1;
a[1]=a[0]+a[2];
a[-1]=4; // 运行时引发一个ArrayIndexOutOfBoundsException(数组下标越界)异常
a[10]=2; //运行时引发一个ArrayIndexOutOfBoundsException(数组下标越界)异常

数组的大小必须使用整数表达式：
int n;
float arr[ ]=new float[n+1]
数组的长度可通过.length 查找：
int a[] []=new int [10][3];
println (a.length) //打印出10
println (a[0].length) //打印出3。

6.3.1 数组细节(???)

我们所定义的数组都是Object类的一个子类的实例，在类的层次结
构中有一个被称为Array的子类，它有一个实例变量“length”。对每
一个基本类型，都有一个相应的Array的子类。同理，每一个类也都有
一个相应的Array子类存在。例如： new Thread[n] 创建一个Thread[ ]
的实例。如果类A是类B的超类，那么，A[]是B[]的超类，见下图：
Object
Array A

int[] float[] A[] B B[]

因此，可以把数组赋给一个Object变量。
Object o;
int a[]=new int [10];
o=a;
并且可通过强制类型转换把object变量赋给一数组变量。
a=(int [])o;
Array类本身不能显式地产生子类。


7. 类
要想得到一个新的类，程序员必须首先找到一个已有的类，新类即
在这个已有类的基础上构造，我们称之为派生(derived)。派生出的类亦称
为原来类的子类，而这个类我们称为超类(super class)。
类的派生具有传递性： 如果B是A的子类，C是B的子类，则C
是A的子类。

一个类的直接超类以及指示这个类如何实现的界面(interface)，在类
的声明中，由关键字extends及implements标出。如下示(黑体表示关键字)：

举例：
/** 2 dimension point */
public class Points {
float x，y;
......
}
/** printable point */
class PinttablePoint extends Points implements Printable {
......
public void Print ( ) {
}
}

所有的类均从一个根类 Object中派生出来。除Object之外的任何类
都有一个直接超类。如果一个类在声明时未指明其直接超类，那么缺省
即为Object。如下述：
class Point {
float x，y
}
与下面写法等价
class Point extends Object {
float x， y；
}

Java语言仅支持单继承，通过一个被称作“界面”的机制，来支持
某些在其它语言中用多继承实现的机制(详见“界面”一节)。Java之所
以没有采用C++的多继承机制，是为了避免多继承带来的诸多不便，例
如：可能产生的二义性，编译器更加复杂，程序难以优化等问题。

7.1 类类型之间的强制转换
Java语言支持在两个类型之间的强制转换，因为每个类即是一个新
的类型。Java支持类类型之间的强制转换，如果B是A的子类，那么B
的一个实例亦可作为A的实例来使用，虽然不需要显式的转换，但显式
转换亦是合法的，这被称作拓宽(widening)。如果A的一个实例，想当作
B的实例使用，程序员就应写一个类型转换叫作削窄（narrowing）的强
制。从一个类到其子类的强制转换在运行时要作例行的检查以确保这个对象就是其子类的一个实例
(或其子类之一)。兄弟类之间的强制类型转换是一个编译错误，类的强制转换的语法如下
(classname) ref
其中，(classname)是要转换的目的类，而ref是被转换的对象。
强制转换仅仅影响到对象的引用，而不会影响对象本身。然而，对实例
变量的访问却受到对象引用的类型的影响。一个对象从一个类型到另一类型的强制转换后，
可以使同一变量名对不同的实例变量访问。

class ClassA{
String name = "ClassA"
}

class ClassB extends ClassA { //ClassB是ClassA的子类
String name="ClassB";
}

class AccessTest {
void test( ) {
ClassB b=new ClassB( );
println (b.name); //打印： ClassB
ClassA a
a=(ClassA)b;
println (a.name); //打印： ClassA
}
}

7.2 方法
方法(method)是可施于对象或类上的操作，它们既可在类中，也可在
界面中声明。但是他们却只能在类中实现(Java中所有用户定义的操作均用方法来实现)。

类中的方法声明按以下方式：
[Doc_ comment] [Access Specifiers] ReturnType methodName(parameterList){
method body(本地的native及抽象的方法没有体部分)
}

除构造函数可以无返回类型外，其余的方法都有一个返回类型。如
果一个不是构造函数的方法不返回任何值，那么它必须有一个void的返
回类型。
参数表由逗号分隔的成对的类型及参数名组成，如果方法无参数，
则参数表为空。方法内部定义的变量(局部变量)不能隐藏同一方法的其 
它变量或参数。例如： 如果一个方法带以名为i的参数实现，且方法内
又定义一个名为i的局部变量，则会产生编译错误，例如：
class Rectangle {
void vertex (int i，int j) {
for (int i=0; i<=100; i++) { //出错
…
}
}
}
方法体内循环语句中声明的i是一个编译错误。
 Java语言允许多态方法命名，即用一个名字声明方法，这个名字已
在这个类或其超类中使用过，从而实现方法的覆盖(overriding)及重载
(overloadding)。所谓覆盖是对继承来的方法提供另一种不同的实现。而
重载是指声明一个方法，它与另外一个方法有相同的名字，但参数表不同。
注： 返回类型不能用来区别方法，即在一个类的范围内，具有相同
的名字，相同的参数表(包括个数、位置及类型)的方法，必须返回相同
的类型。若这样的两个方法有不同的返回类型，将会产生一个编译错误。

7.2.1 实例变量
实例变量(instance variables)是指那些在类内声明，但在方法的作用
域之外尚未被static标记的变( 参照 “静态方法，变量及初始化”段)。
而在一个方法的作用域之内声明的变量是局部变量。实例变量可以有修
饰符(见修饰符)。 实例变量可以是任何的类型，并且可以有初始值。  如果一个实例变 量无初始值，它将被初始化成0。布尔型变量被初始化成flase，对象被
初始化成null。下面是一个实例变量j具有初始化值的例子：
class A{
int j =23;
……
} 
7.2.2 this 和super变量
在一个非静态方法的作用域内，this这个名字代表了当前对象。
例如： 一个对象可能需要把自己作为参数传给另一个对象的方法：
class MyClass {
void Method (OtherClass obj) {
…
obj.Method (this)
…
}
}

不论何时，一个方法引用它自己的实例变量及方法时，在每个引用 的前面都隐含着“this”。
如：
class Foo {
int a，b，c;
......
void myPrint ( ) {
print (a+ "\n"); // a=="this.a"
}
......
}

super变量类似于this变量。this变量实际上是对当前对象的引用，
它的类型就是包含当前正在处理的方法的类。而super变量则是对其超类
类型对象的引用。