《Java编程思想》读书笔记：第二章一切都是对象

在Java中尽管一切都看作是对象，但是操作的标识符实际上是对象的一个“”引用。可以将这一情形想象成用遥控器（引用）来操纵电视机（对象）。只要握住这个遥控器，就能保持与电视机的连接。当用人想改变频道或者减小音量时，实际控制的是遥控器（引用），在由遥控器来调控电视机（对象）。如果想在房间走动，同时仍能调控电视机，那么直须携带（引用）而不是电视机（对象）。

此外，即使没有电视机，遥控器亦可以独立存在。也就是说，你拥有一个引用，并不一定需要有一个对象于它关联。因此，如果想操控一个词或句子，则可以创建一个String引用：

String s；

这里所创建的只是引用，并不是对象。如果此时向s发送一个消息，就会返回一个运行时错误。这是因为此时s实际上没有与任何事物相关联（即：没有电视机）。因此，一种安全的做法是：创建一个引用的同时便进行初始化。

String s="asdf";

这里用到了Java语言的一个特性：字符串可以用带双引号的文本初始化。

2.2必须由你创建所有对象

一旦创建了一个引用，就希望它能与一个新的对象相关联。通常用new操作符来实现这一目的。nei关键字的意思是“给我一个新对象”。所以前面的例子可以写成：

String s=new String("asdf");

它不仅表示“给我一个新的字符串”，而且通过提供一个初始字符串，给出了怎样产生这个String的消息。

2.2.1存储到什么地方

程序运行时，对象是怎么进行放置安排的呢？有五个不同的地方可以存储数据。

寄存器。这是最快的存储区，因为它位于不同于其他存储区的地方——处理器内部。但是寄存器的数量及其有限，所以寄存器根据需要进行分配。你不能直接控制，也不能在程序中感受到寄存器存在的任何迹象（另一方面，C和C++允许您向编译器建议寄存器的分配方式）。
堆栈。位于通用RAM（随机访问存储器）中，但通过堆栈指针可以从处理器那里获得直接支持。堆栈指针若向下移动，则分配新的内存；向上移动则释放那些内存。这是一种快速有效的分配存储方法，仅次于寄存器。创建程序时，Java系统必须知道存储在堆栈内所有项的确切生命周期，以便上下移动堆栈指针。这一约束限制了程序的灵活性，所以虽然某些Java数据存储于堆栈中——特别是对象的引用，但是Java对象并不存储于其中。
堆。一种通用的内存池（也位于RAM区）中，用于存放所有的Java对象。堆不同于堆栈的好处是：编译器不需要知道存储的数据在堆里存活多长时间。当需要一个对象时，只需要new写一个简单代码，当执行这行代码时，会自动在堆里进行存储分配。当然，为这种灵活性必须要付出相应的代价：用堆进行存储分配和清理可能比用堆栈进行存储分配需要更多的时间（如果确实可以在Java中像在C++中一样在栈中创建对象）。
常量存储。常量值通常直接存放在程序代码内部，这样做是安全的，因为它们永远不会被改变。——有时，在嵌入式系统中，常量本身会和其他部分隔离开，所以在这种情况下，可以选择将其存放在ROM（只读存储器）中。这种存储区的一个例子是字符串池。所有字面常量字符串和具有字符串值的常量表达式都自动是内存限定的，并且会置于特殊的静态存储区中。
非RAM存储。如果数据完全存活于程序之外，那么它可以不受程序的任何控制，在程序没有运行时也可以存在。其中两个基本例子是流对象和持久化对象。在流对象中，对象转化成字节流，通常被发送给另一台机器。在“持久化对象”中，对象被存放于磁盘上，因此，即使程种植，它们仍可以保持自己的状态。这种存储方式的技巧在于；把对象转换成可以存放在其他媒介上的事物，在需要时，可恢复成常规的、基于RAM的对象。

2.2.2特例：基本类型

对于基本类型，Java采取与C和C++相同的方法。也就是说，不用new来创建变量，而是创建一个并非是引用的“自动”变量。这个变量直接存储“值”，并置于堆栈中，因此更加高效。

Java要确定每种基本类型所占存储空间的大小。它们的大小并不像其他大多数语言那样随机器硬件架构的变化而变化。这种所占存储空间大小的不变性是Java程序比用其他大多数语言编写的程序更具可移植性的原因之一

基本类型	大小	最小值	最大值	包装类
boolean	——	——	——	Boolean
char	16bit/2B	Unicode 0	Unicode 2^16-1	Character
byte	8bit/1B	-128	+127	Byte
short	16bit/2B	-2^15	+2^15-1	Short
int	32bit/4B	-2^31	+2^31-1	Integer
long	64bit/8B	-2^63	+2^63-1	Long
float	32bit/4B	IEEE754	IEEE754	Float
double	64bit/8B	IEEE754	IEEE754	Double
void	——	——	——	——

所有数值类型都有正负号，所以不要去寻找无符号的数值类型。

boolean类型所占存储空间的大小没有明确指定，仅定义为能够取字面值true或false

基本类型具有的包装器类，使得可以在堆中创建一个非基本对象，用来表示对应的基本类型。Eg：

char c='x';
Character ch=new Character(c);
//也可以这样用
Character ch=new Character('x');
//Java SE5的自动包装功能将自动地将基本类型转换为包装器类型
Character ch='x';
//并可以反向转换
char c=ch;

高精度数字

Java中提供了俩个用于高精度计算的类：BigInteger和BigDecimal。虽然它们大体上属于“”包装器类“的范畴，但二者都没有对应的基本类型。不过这两类包含的方法，提供的操作与对基本类型所能执行的操作相似。也就是说，能作用与int和float的操作，也同样能作用与这两类。只不过必须以方法调用方式取代运算符方式来实现。由于这么做复杂许多，所以运算速度会比较慢。在这里，外面以速度换取了精度。

BigInteger支持任何精度的整数。也就是说，在运算中，可以准确地表示任何大小的整数值，而不会丢失任何信息。

BigDecimal支持任何角度的定点数，例如，可以用它进行精确的货币计算。

2.2.3Java中的数组

几乎所有的程序设计语言都支持数组。在C和C++中使用数组是很危险的，因为C和C++中的数组就是内存块。如果一个程序要访问其自身内存块之外的数组、或在数组初始化之前使用内存，都会产生难以预料的后果。

Java确保数组会被初始化，而且不能在它的范围之外被访问。这种范围检查，是以每个数组上少量的内存开销及运行时的下标检查为代价的。但由此换来的是安全性和效率的提高，因此付出的代价是值得的。

当创建一个数组对象时，实际上就是创建了一个引用数组，并且每个引用都会自动被初始化一个特定的值，该值拥有自己的关键字null。一旦Java看到null，就知道这个引用还没有指向某个对象。在使用任何引用前，必须为其指定一个对象；如果试图使用一个还是null的引用，在运行时将会报错。因此，常犯的数组错误在Java中就可以避免。还可以创建用来存放基本数据类型的数组。同样，编译器也能确保这种数组的初始化，因为它会将这种数组所占的内存全部置零

2.3永远不需要销毁对象

2.3.1作用域

作用域决定了在其内定义的变量名的可见性和生命周期。作用域由花括号的位置决定。Eg：

{
  int x=12;
  //x的作用域
   {
     int q=96;
     //q的作用域
   }
  //x的作用域
  //q的作用域结束
}

在作用域里定义的变量只可用于作用域结束之前。

任何位于“//”之后到行末的文字都是注释。

尽管以下代码在C和C++中是合法的，但是在Java中却不能这样书写。

{
  int x=12;
   {
     int x=96
   }
}

编译器将会报告变量x已经定义过。所以，在C和C++里将一个较大作用域的变量”隐藏“起来的做法，在Java里是不允许的。

2.3.2对象的作用域

Java对象不具备和基本类型一样的生命周期。当new一个对象时，它可以存活于作用域之外。Eg：

{
  String s=new String("a string")
}

引用s在作用域终点消失了。然后，s指向的String对象仍然继续占据内存空间。在这一小段代码中，我们无法在这个作用域之后访问这个对象，因为对它的唯一的引用已超出了作用域的范围。

事实证明，由new创建的对象，只要你需要，就会一直保留下去。在C++中，你不仅必须要确保对象的保留时间与你需要这些对象的时间一样长，而且还必须在你使用完它们之后，将其销毁。

Java中有一个垃圾回收器，用来监视用new创建的所有对象，并辨别那些不会再被引用的对象。随后，释放这些对象的内存空间，以便供其他对象使用。这样就消除了“内存泄漏”这种编程问题，这是由于程序员忘记释放内存而产生的问题。

2.4创建新的数据类新：类

大多数面向对象的程序设计语言习惯用关键字class来表示“我准备告诉你一种新类型的对象看起来是什么样子”。class这个关键字之后紧跟着的是新类型的名称，Eg：

class ATypeName{/* Class body goes here*/}

这就引入了一种新的类型，尽管类的主体仅包含一条注释语句（星号和斜杆以及其中的内容就是注释）。因此，你还不能用它做太多的事情，然而，你已经可以用new来创建这种类型的对象：

ATypeName a=new ATypeName();

但是，在定义它的所有方法之前，还没有办法能让它去做更多的事情（也就是说，不能向它发送任何有意义的消息）

2.4.1字段和方法

一旦定义了一个类，就可以在类中设置两种类型的元素：字段（有时被称作数据成员）和方法（有时被称为成员函数）。字段可以是任何类型的对象，可以通过其引用与其进行通信；也可以是基本类型中的一种。如果字段是对某个对象的引用，那么必须初始化该引用，以便使其与一个实际的对象相关联。

每个对象都有用来存储其字段的空间，普通字段不能在对象间共享。Eg：

class DataOnly{
   int y;
   double d;
   boolean b;
}

尽管这个类除了存储数据之外什么也不能做，但是仍旧可以像下面这样创建它的一个对象：

DataOnly data=new DataOnly();

可以给字段赋值，但首先必须知道如何引用一个对象的成员。具体的实现为：在对象引用的名称之后紧跟着一个句点，然后再接着是对象内部的成员名称：Eg：

data.i=47;
data.d=1.1;
data.b=false;

想修改的数据也有可能位于对象所包含的其他对象中。在这种情况下，只需要再使用连接句点即可Eg:

myPlane.leftTank.capacity=100;

基本成员默认值

若类的某个成员是基本数据类型，即使没有进行初始化，Java也会确保它获得一个默认值：

基本类型
boolean	false
char	'\uoooo'(null)
byte	(byte)0
short	(short)0
int	0
long	0L
float	0.0f
double	0.0d

这些初始值对你的程序来说，可能是不正确的，甚至是不合法的。所以最好明确地对变量进行初始化。

然而上述确保初始化的方法并不适用于“局部”变量（即并非某个类的字段）。因此，如果在某个方法定义中有

int x

那么变量x得到的可能是任意值（与C和C++中一样），而不会被自动初始化为零。所以在使用x前，应先对其赋值一个适当的值。如果忘记了这么做，Java会在编译时返回一个错误，告诉你此变量没有初始化，这正是Java优于C++的地方。

2.5方法、参数和返回值

许多程序设计语言（像C和C++）用函数这个术语来描述命名子程序，而在Java里却常用方法这个术语来表示“做某些事情的方式”。

Java的方法决定了一个对象能够接收什么样的消息。方法的基本组成部分包括：名称、参数、返回值和方法体。Eg：

返回值类型 名称(参数列表)
{方法体}

返回类型描述的是在调用方法之后从方法返回的值。参数列表给出了要传给方法的信息的类型和名称。方法名和参数列表（它们合起来被称为“方法签名”）唯一地标识出某个方法。

Java中的方法只能作为类的一部分来创建。方法只有通过对象才能被调用（后面会学到static方法，它是针对类的调用的，并不依赖于对象的存在），且这个对象必须能执行这个方法调用。如果试图在某个对象上调用它并不具备的方法，那么在编译时就会得到一条错误消息。通过对象调用方法时，需要先列出对象名，紧接着是句点，然后是方法名和参数列表。Eg：

对象名.方法名(参数1，参数2，参数3);

例如，假设有一个方法f()，不带任何参数，返回类型是int。如果有个名为a的对象，可以通过它调用f()，那么就可以这样写：

int x=a.f();

返回值的类型必须要与x的类型兼容。

这种调用方法的行为通常被称为发送消息给对象。在上面的例子中，消息是f()，对象是a。面向对象的程序设计通常简单地归纳为“向对象发送消息”。

2.5.1参数列表

方法的参数列表指定要传递给方法什么样的信息。在参数列表中必须指定每个所传递对象的类型及名字。像Java中任何传递对象的场合一样，这里传递的实际上也是引用，并且引用类型必须正确。否则，编译器将抛出错误。

假设某个方法接受String为其参数，下面是其具体定义，它必须置于某个类的定义内才能被正确编译。Eg:

int storage(String s) {
   return s.length() *2;
}

此方法告诉你，需要多少字节才能容纳一个特定的String对象中的信息（字符串中每个字符的尺寸都是16位或2个字节，以此来提供对Unicode字符集的支持）。此方法的参数类型是String，参数名是s.一旦将s传递给此方法，就可以把它当作其他对象一样进行处理（可以给它传递消息）。在这里，s的length()方法被调用，它是String类提供的方法之一，会返回字符串包含的字符数。

通过上面的例子，还可以了解到return关键字的用法，它包括两个方面：首先，它代表“已经做完，离开此方法”。其次，如果此方法产生一个值，这个值要放在return语句后面。在这个例子中，返回值是通过计算s.length()*2这个表达式得到的。

你可以定义方法返回任意的类型，如果不想返回任何值，可以指示此方法返回void（空）。若返回类型是void，return关键字的作用只是用来退出方法。因此，没有必要到方法结束时才离开，可在任何地方返回。但如果返回类型不是void，那么无论在何处返回，编译器都会强制返回一个正确类型的返回值。

2.6构建一个Java程序

2.6.1名字可见性

为了给一个类库生成不会与其他名字混淆的名字，Java设计者希望程序员反过来使用自己的Internet域名。因为这样可以保证它们肯定是独一无二的。由于我的域名是MindView.net，所以我的各种奇奇怪怪的应用工具类库就被命名为net.mindview.utility.foible。反转域名后，句点就用来代表子目录的划分。

这种机制意味着所有的文件都能够自动存活于它们自己的名字空间内，而且同一个文件内的每个类都有唯一的标识符

2.6.2运用其他构件

在Java中可以使用关键字import来准确地告诉编译器你想要的类是上面。import指示编译器导入一个包，也就是一个类库（在其他语言中，一个库不仅包含类，还可能包括方法和数据，但是Java中所有的代码都必须写在类里）。

大多数时候，我们使用于编译器附在一起的Java标准类库里的构件。有了这些构件，你就不必写一长串的反转域名。Eg：

import java.util.ArrayList;

这行代码告诉编译器，你想使用Java的ArrayList类。但是，util包含了数量众多的类，有时你想使用其中的几个，同时又不想明确地逐一声明，那么你很容易使用通配符“*”来达到这个目的

import java.util.*;

这种一次导入一群类的方法比一个一个地导入类的方法更常用。

2.6.3static关键字

通常来说，当创建类时，就是在描述那个类的对象的外观与行为。除非用new创建那个类的对象，否则，实际上并未获得任何对象。执行new来创建对象时，数据存储空间才被分配，其方法才供外界调用。

当声明一个事物是static时，就意味着这个域或方法不会与包含它的那个类的任何对象实际关联在一起。所以，即使从未创建某个类的任何对象，也可以调用其static方法或访问其static域。非static域和方法必须知道它们一起运作的特定对象。

有些面向对象语言采用类数据和类方法两个术语，代表那些数据和方法只是作为整个类，而不是类的某个特定对象而存在的。

只需将static关键字放在定义之前，就可以将字段或方法设定为static。Eg

class StaticTest {
   static int i = 47;
}

现在，即使你创建了两个StaticTest对象，StaticTest也只有一份存储空间，着两个对象共享同一个i，在来看看下面代码

StaticTest st1 =new StaticTest();
StaticTest st2 =new StaticTest();

在这里st1.i和st2.i指向同一个存储空间，因此它们具有相同的值47。

引用static变量又两种方法。例如前面所示，可以通过一个对象去定位它，如st2.i。也可以通过其类名直接引用，而这对于非静态成员则不行。

StaticTest.i++;

其中，++运算符对变量进行递加操作。此时st1.i和st2.i仍具有相同的值48。

使用类名是引用static变量的首先方式，这不仅是因为它强调了变量的static结构，而且在某些情况下它还为编译器进行优化提供了更好的机会。

类似逻辑也应用于静态方法。既可以像其他方法一样，通过一个对象来引用某个静态方法，也可以通过特殊的语法形式“类名.方法名”加以引用。定义静态方法的方式与定义变量的方法类似：

class Incrementable {
  static void increment() { 
    staticTest.i++;
  }
}

可以看到Incrementable的increment()方法通过++运算符将静态数据i递加。可以采用典型的方式，通过对象来调用increment()；

Incrementable sf = new Incrementable();
sf.increment();

或者，因为increment()是一个静态方法，所以也可以通过它的类直接调用；

Incrementable.increment();

尽管当static作用域某个字段时，肯定会改变数据创建的方式（因为一个stati字段对每个类来说都只有一份存储空间，而非static字段则是对每个对象有一个存储空间），但是如果static作用于某个方法，差别却没那么大。static方法的一个重要用法就是在不创建任何对象的前提下就可以调用它。正如我们将会看到的那样，这一点对于定义main（）方法很重要，这个方法是运行一个应用时的入口点、

和其他任何方法一样，static方法可以创建或使用与其类型相同的被命名对象，因此，static方法常常拿来做“牧羊人”的角色，负责看护与其隶属同一类型的实例群。

2.7你的第一个Java程序

编写第一个完整的程序。此程序开始是打印一个字符串，然后是打印当前日期，这里用到了Java标准库里的Date类。

/HelloDate. java
  import java.uti1.*:
  public class HelloDate{
     public static void main (string[0] args){
        system.out.println( "Hello. it's : ");
        system.out.println(new Date());
     }
  )

每个程序文件的开头，必须声明impor语句。以便引入在文件代码中需要用到的额外类。注意，在这里说它们“额外”，是因为有一个特定类会自动被导入到每个Java文件中，java.lang。java.lang是默认导入到每个Java文件中，所以它的所有类哦都可以被直接使用，java.lang里没有Date类，所以必须导入另外一个类库才能使用它。由于Date位于util类库周末，并且必须书写import java.util.*才能使用Date类。

在java.lang中system类有许多属性；若选择out，就会发现它是一个静态PrintStream对象。因为是静态的，所以不需要创建任何东西，out对象便已经存在，只需直接使用即可。但我们能够用out对象做些什么事情，是由它的类型PrintStream决定的。PrintStream在描述文档中是以超链接形式显示，所以很方便进行查看，只需点击它，就可以看到能够为PrintStream调用的所有方法。现在我们只对println()方法感兴趣，它的实际作用是“将我给你的数据打印到控制台，完成后换行”。

类的名字必须和文件名相同。如果你像现在这样创建一个独立运行的程序，那么文件中必须存在某个类于该文件同名（否则，编译器会报错），且那个类必须包含一个名为main()的方法，形式如下所示：

public static void main (string[0] args){

其中，public关键字意指这是一个可由外部调用的方法，main()方法的参数是一个String对象的数组。在这个程序中并未用到args，但是Java编译器要求必须这样做，因为args要用来存储命令行参数。

 system.out.println(new Date());

在这里，传递的参数是一个Date对象，一旦创建它之后，就可以直接将它的值（它被自动转换未String类型）发送给println()。当这条语句执行完毕之后，Date对象就不再被使用，而垃圾回收器会发现这一情况，并在任意时候将其回收。

2.7.1编译和运行

javac HelloDate.java

正常情况下，这行命令不会产生任何响应。如果由任何错误消息返回给你，就说明还没能正确安装号JDK，需进一步检查并找出问题所在

java HelloDate

接着，便可看到程序中的消息和当天日期被输出。

2.8注释和嵌入式文档

Java里有两种注释风格。一种是传统的C语言风格的注释——C++也继承了这种风格。此种注释以“/*"开始，随后是注释内容，并可跨越多行，最后以“*/”结束。但请记住，进行编译时，/*和*/之间的所有东西都会被忽略。

/*This is a comment that
 continues across lines */

第二种的注释也源于C++，这种注释是“单行注释”，以一个"//"起头，直到句末。

//This is a one-line comment

2.8.1注释文档

代码文档撰写的最大问题，大概就是对文档的维护了。如果文档与代码是分离的，那么在
每次修改代码时，都需要修改相应的文档，这会成为一件相当乏味的事情。解决的方法似乎很简单:将代码同文档“链接”起来。为达到这个目的，最简单的方法是将所有东西都放在同一个文件内。然而，为实现这一目的，还必须使用一种特殊的注释语法来标记文档;此外还需一个工具，用于提取那些注释，并将其转换成有用的形式。这正是Java所做的。

javadoc便是用于提取注释的工具，它是JDK安装的一部分。它采用了Java编译器的某些技术，查找程序内的特殊注释标签。它不仅解析由这些标签标记的信息，也将毗邻注释的类名或方法名抽取出来。如此，我们就可以用最少的工作量，生成相当好的程序文档。

javadoc输出的是一个HTML文件，可以用Web浏览器查看。这样，该工具就使得我们只需创建和维护单一的源文件，并能自动生成有用的文档。有了javadoc，就有了创建文档的简明直观的标准:我们可以期望、甚至要求所有的Java类库都提供相关的文档。

2.8.2语法

所有javadoc命令都只能在“/**”注释中出现，和通常一样，注释结束于“*/”。使用javadoc的方式主要有两种:嵌入HTML，或使用“文档标签”。

独立文档标签是一些以“@”字符开头的命令，且要置于注释行的最前面（但是不算前导“*”之后的最前面)。而“行内文档标签”则可以出现在javadoc注释中的任何地方，它们也是以“@”字符开头，但要括在花括号内。
共有三种类型的注释文档，分别对应于注释位置后面的三种元素:类、域和方法。也就是说，类注释正好位于类定义之前﹔域注释正好位于域定义之前，而方法注释也正好位于方法定义的前面。如下面这个简单的例子所示:

//object/Documentation1.java
  /**类注释*/
  public class Documentation1 {
  /**域注释*/
   public int i ;
  /**方法注释*/
   public void f(){}
}

注意，javadoc只能为public .(公共）和protected(受保护）成员进行文档注释。private(私有）和包内可访问成员的注释会被忽略掉，所以输出结果中看不到它们(不过可以用-private进行标记，以便把private成员的注释也包括在内)。这样做是有道理的，因为只有public和protected成员才能在文件之外被使用，这是客户端程序员所期望的。
上述代码的输出结果是一个HTML文件，它与其他Java文档具有相同的标准格式。因此，用户会非常熟悉这种格式，从而方便地导航到用户自己设计的类。输入上述代码，然后通过javadoc处理产生HTML文件，最后通过浏览器观看生成的结果，这样做是非常值得的。

2.8.3嵌入式HTML

javadoc通过生成的HTML文档传送HTML命令，这使你能够充分利用HTML。当然，其主要目的还是为了对代码进行格式化，Eg:

//:object/Documentation2.java
/**
*<pre>
*system.out.println(new Date());
*</pre>
*/

也可以像在其他Web文档中那样运用HTML，对普通文本按照你自己所描述的进行格式化:

//object/Documentation3.java
/**
*You can <em>even</em> insert a list ;
*<ol>
*<li> Item one
*<ii> Item two
*<ii> Item three. 
*</ol>
*/

注意，在文档注释中，位于每一行开头的星号和前导空格都会被javadoc丢弃。javadoc会对所有内容重新格式化，使其与标准的文档外观一致。不要在嵌入式HTML中使用标题标签，例如<h1>或<hr>，因为javadoc会插入自己的标题，而你的标题可能同它们发生冲突。
所有类型的注释文档-—类、域和方法—--都支持嵌入式HTML。

2.8.4一些标签示例

这里将介绍一些可用于代码文档的Java标签。

1、@see：引用其他类

@see标签允许用户引用其他类的文档。javadoc会在其生成的HTML文件中，通过@see标签链接到其他文档。Eg:

@see classname
@see fully-qualified-classname
@see fully-qualified-classname#method-name

上述每种格式都会在生成的文档中加入一个具有超链接的“See Also”(参见）条目。但是javadoc不会检查你所提供的超链接是否有效。

2、(@link package.class#member label）

该标签与@see极其相似，只是它用于行内，并且是用“label”作为超链接文本而不用“SeeAlso”。

3、(@docRoot)

该标签产生到文档根目录的相对路径，用于文档树页面的显式超链接。

4、(@inheritDoc)

该标签从当前这个类的最直接的基类中继承相关文档到当前的文档注释中。

5、@version

@version version-information

其中，“version-information”可以是任何你认为适合包含在版本说明中的重要信息。如果javadoc命令行使用了“-version”标记，那么就从生成的HTML文档中特别提取出版本信息。

6、@author

@author author-information

其中，author-information一-看便知是你的姓名，但是也可以包括电子邮件地址或者其他任何适宜的信息。如果javadoc命令行使用了-author标记，那么就从生成的HTML文档中特别提取作者信息。

可以使用多个标签，以便列出所有作者，但是它们必须连续放置。全部作者信息会合并到同一段落，置于生成的HTML中。

7、@since

该标签允许你指定程序代码最早使用的版本，可以在HTML Java文档中看到它被用来指定所用的JDK版本的情况。

8、@param

@param parameter-name description

其中，parameter-name是方法的参数列表中的标识符，description是可延续数行的文本，终止于新的文档标签出现之前。可以使用任意多个这种标签，大约每个参数都有一个这样的标签。

9、@return

@return description

其中，“description”用来描述返回值的含义，可以延续数行。

10、@throws

是由于某个方法调用失败而“抛出”的对象。尽管在调用一个方法时，只出现一个异常对象，但是某个特殊方法可能会产生任意多个不同类型的异常，所有这些异常都需要进行说明。所以，异常标签的格式如下:

@throws fully-qualified-class-name description

其中fully-qualified-class-name给出一个异常类的无歧义的名字，而该异常类在别处定义。description(同样可以延续数行）告诉你为什么此特殊类型的异常会在方法调用中出现。

11、@deprecated

该标签用于指出一些旧特性已由改进的新特性所取代，建议用户不要再使用这些旧特性，因为在不久的将来它们很可能会被删除。如果使用一个标记为@deprecated的方法，则会引起编译器发布警告。
在Java SE5中，Javadoc标签@deprecated已经被@Deprecated注解所替代。

2.8.5文档示例

//:object/He1loDate.java
import java.util.* ;
/**The first Thinking in Java example program.
 *Displays a string and today 's date.
 *@author Bruce Eckel
 *@author www . Hindview.net
 *@version 4.0
*/
public class HelloDate {
  /**Entrv point to class & applicat.ion 
   *@param args array of string arguments
   *@throws exceptions No exceptions thrown
   */
   public static void main(string[n] args) {
     system. out.println ( "Hello， it's : “);
     system.out.printlninew Date());
   }
}
/*output: (55% match)
Hello. it's:
wed oct 05 14:39:36 MDT 2005
*///:~

第一行采用我自己独特的方法，用一个“:”作为特殊记号说明这是包含源文件名的注释行。该行包含文件的路径信息（此时，object代表本章)，随后是文件名。最后一行也是一行注释，这个“///:~”标志源代码清单的结束。自此，在通过编译器和执行检查后，文档就可以自动更新成本书的文本。
/*Output标签表示输出的开始部分将由这个文件生成，通过这种形式，它会被自动地测试以验证其准确性。在本例中，(55% match)在向测试系统说明程序的每一次运行和下一次运行的输出存在着很大的差异，因此它们与这里列出的输出预期只有55%的相关性。本书中能够产生输出的大部分示例都包含这种注释方式的输出，因此你可以查看它们的运行输出，并知晓其正确性。

2.9编码风格

在“Java编程语言编码约定”中，代码风格是这样规定的:类名的首字母要大写。如果类名由几个单词构成，那么把它们并在一起（也就是说，不要用下划线来分隔名字)，其中每个内部单词的首字母都采用大写形式。例如:

class AllThecolorsOfTheRainbow { //...

这种风格有时称作“驼峰风格”。几乎其他所有内容——方法、字段（成员变量〉以及对象引用名称等，公认的风格与类的风格一样，只是标识符的第一个字母采用小写。例如:

class AllTheColors0fTheRainbow {
    int anIntegerRepresentingcolors;
    void changeTheHueofThecolor (int newHue) {
      // ...
    }
  //...
}

标签

#java