一切都是对象
尽管Java语言是基于C++的，但是相比之下，Java是一种更“纯粹”的面向对象程序设计语言。也就是说，在使用Java进行程序设计之前，必须将思想换到面对对象的世界中来，这是入门基本功.
即把整个世界的物体分成很多类，比如人类、鱼类，草类，而具体的每个具体的事物，比如你这个人，就是一个人类的对象，比如我们刚钓的鱼，也是鱼的对象。比如“我拿鱼竿钓鱼”，对象就是我和鱼和鱼竿，每个对象都有一些属于自己的能力，比如人有拿鱼竿拿这个能力，而且鱼竿具有钓这个能力，这些能力就是相当于之后要讲的类内部的方法，而这个世界正是由这样所组成，而正如Java语言的特点，所以说Java中（几乎）一切都是对象。（PS：别问特例是什么，问就是下面这些基本类型，boolean,char、byte，short、int、long、float、double）
1.1 用引用操纵对象
每种编程语言都有自己的操作内存中元素的方式。有时候，程序员必须注意要处理的数据是什么类型。你是直接操作元素，还是用某种特殊的语法来间表示(在C/C++)来操纵对象。
所有的这一切在Java中得到了简化。因为一切都被看作成对象，所以可以采用一些单一固定的语法。尽管一切都视作对象，但操纵的标识符实际上是对象的一个"引用",可以将这情形想象成用遥控器(引用)来操控电视机(对象)。只要握住这个遥控器，就能保持与电视机的连接，当有人想改变频道或者减少音量时，实际上操控的是遥控器(引用)，再由遥控器来控制电视机(对象)，如果你想干点别的事情，比如在房间四处走走，同时仍可以控制电视机，只需要你带着遥控器(引用)而不是电视机(对象)。
除此之外，即使没有电视机，遥控器亦可独立存在，也就是说，当你有一个引用，并不一定需要要有对象与他关联。
class TV{};
TV tvReference;
第一行我是对类进行声明，即对类进行定义，就是有这么一种类叫TV。
第二行是创建一个TV的引用，而不是创建了一个对象，如果此时向tvReference发消息，就会出现错误，因为此时tvReference还没有与什么东西关联起来(即电视机)。因此，一般比较安全的做法是创建一个引用的时候，就对引用进行初始化，像下面这样:
String strReference="fantuanxiaoshen";
这里用到了Java语言的一种特性，字符串可以直接用带双引号(英文版)的文本初始化。通常，一般都是用对象采用另外一种方法定义，就是下面要讲的使用new创建对象。
1.2 必须由你来创建所有对象
Java中不会自己生成对象，必须要你自己去创建对象，一旦创建了一个引用，一般希望第一时间让它与新的对象相关联，一般都是使用new关键字来实现，new关键字的意思是，“给我一个对象”，所以刚才的例子可以写成:
String strReference=new String("fantuanxiaoshen");
这不仅表示“给我一个新的字符串",而且通过提供一个初始字符串，给出怎样产生这个String的信息
除了String类型外，Java还提供了许多类型，即自带类库，之后的博客中会慢慢用到。
1.2.1 特例:基本类型
在程序设计中经常用到一系列类型，它们需要特殊对待。可以把它们想像成"基本类型"，之所以特殊对待，是因为New的对象存储在"Java堆中" ，所以如果用new创建一个特别小的对象，往往不是很有效的。对于这些类型，Java采用和C和C++相同的方法，也就是说，不适用new，而是创建一个并非是引用的自动变量，这个变量是直接存储”值“,并存在java虚拟栈中，因此更加高效。
Java中要确定每种基本类型所占用存储空间的大小。他们的大小并不像其他大多数语言那样随硬件架构变化而变化，这种所占存储空间大小不变性是Java可移植性强的主要原因之一。
| 基本类型 | 大小 | 最小值 | 最大值 | 包装器类型 |
|---|---|---|---|---|
| boolean | - | - | - | Boolean |
| char | 16-bit | Unicode 0 | Unicode 2^16-1 | Character |
| byte | 8 bits | -128 | +127 | Byte |
| Short | 16 bits | -2^15 | +2^15-1 | Short |
| int | 32 bits | -2^31 | +2^31-1 | Integer |
| long | 64 bits | -2^63 | +2^63-1 | Long |
| float | 32 bits | -2^31 | +2^31-1 | Float |
| double | 64 bits | -2^63 | +2^63-1 | Double |
| void | - | - | - | Void |
所有的类型都有正负号，所以不要去寻找无符号的数值类型。
boolean类型所占存储空间的大小没有明确规定，仅定义为能够取字面值true或false但我查阅资料得知boolean的大小分两种情况：
1.当单个boolean类型变量在编译时使用的是int类型即占4个字节:
boolean a=true;
2.当boolean类型数组进行编译的时候相当于byte 数组即每个boolean占1个字节:
boolean [] a=new boolean[10];
另外一个要提到的Java特性就是Java中自动拆装箱，即Java会自动把基本类型包装成包装器类型，也会自动包装器类型拆成基本类型，随情况而定，很“智能”:
int b=a+6;
Float c=0.3F;
float d=(float) (c+2.6);
Double e=3.0;
double f=e+2;
Long g=326L;
long h=g+67;
Byte i=1;
byte j=(byte) (i+5);
Short k=5;
short l=(short) (k+6);
char m=11;
Character n=(char) (m+6);
上述代码都是可以编译成功的。
1.2.2 Java中的数组
几乎在所有的程序设计语言都支持数组。在C和C++中使用数组是很危险的，因为C和C++的数组都是内存块。如果一个程序访问其自身内存块之外的数组，或者在数组出事前使内存，都会出现难以预料的后果。
Java中主要目标之一是安全性，所以许多在C和C++里困扰程序员的问题在Java中都不会存在。Java会确保数组会被初始化：
而且不能在它的范围之外访问，编译会抛出异常，异常在之后的博客会讲解:
这种范围检查，是以每个数组上少量的内存的开销和运行时检查下标为代价，但由此换来得是安全性和效率的提高，因此付出的代价是值得的（并且Java有时可以优化这些操作 PS:优化方法我目前还不知道，不过不久之后一定会知道的！！！）。
当创建一个数组对象时，实际上就是创建一个引用数组，每个引用都会自动的初始化为一个特定值，该值拥有自己的关键字null。一旦Java看到null，就会知道这个引用还没有指向某个对象，在使用任何引用前，必须为其指定一个对象，如果试图使用一个还是null的引用，运行时会报错。因此常犯的数组的数组错误在Java中就可以避免。
还可以创建用来存放基本数据类型的数组，同样，编译器也能确保这种数组的初始化，因为它将这种数组所占的内存分配全部置零。
1.3 永远不需要销毁对象
在大多数程序设计语言中，变量的生命周期的概念，占据了程序设计工作中重要部分，变量需要存活多出时间？如果想要销毁对象，那么生命时候进行？变量生命周期的混乱往往会导致大量的程序bug，本节将介绍Java中如何替我们完成所有的工作（主要还是因为Java自带的垃圾回收机制，垃圾回收之后会单独讲）
1.3.1 作用域
大多数过程性语言都有作用域(scope)的概念，作用域觉得了在其内定义的可见性和生命周期，在C、C++和Java中，作用域由花括号的位置决定。比如:
{
int y=5;
//只有y有效
{
int x=6;
//x和y都有效
}
//只有y有效 x因为除了作用域无效了
}
在作用域里定义的变量只可用于作用域结束之前。
缩排格式是使Java代码更易于阅读。
另外Java中，空格，制表符，换行都不会影响程序的执行结果。
尽管C/C++中，变量是可以重复定义的，但是Java中不能重复书写：
所以在C和C++中将一个较大作用域的变量的“隐藏”起来的做法，在Java中是不行的，Java设计者认为这样会导致程序混乱。
1.3.2 对象的作用域
Java中对象不具备和基本类型一样的生命周期。当用new创建一个Java对象是，它可以存活于作用域之外，所以假如你采用如下代码：
{
String s=new String("something");
}//引用s的作用域结束了，但是其实"something"这个String对象还存活者，存活到下一次垃圾回收之前
引用s在作用域之外就无法访问了。而对象确还存在，Java中如何防止对象填满内存空间呢，进而阻塞你的程序呢？这正是C++可能遇到的问题，C++需要delete进行销毁。这便是Java的神奇之处，Java中有自带的垃圾回收器，会采用引用链方法，辨别对象是否存活，从而进行进一步的垃圾回收工作，你根本不需要担心内存回收的问题，你尽管创建对象，不能回收算我输(但是也存在一些现象回收不了的，之后再讲)。这样就消除了这类问题，由于程序员忘了释放内存而产生的问题。
1.4 创建新的数据类型: 类
如果说Java中一切都是对象，那是什么确定了对象的类型呢？是不是类呢？Java中采用 class紧跟新类型名称的方式创建类。例如:
class ATypeName{//具体的类内部内容}
这样你就定义了一个类名为ATypeName的类了，接着，你就可以用new创建这个类型的对象了:
ATypeName a=new ATypeName();
但是因为你还没有在这个类内部定义具体的方法，所以你的a引用还没办法做任何具体的事情，也就是说，不能向它发送任何有意义的消息。
1.4.1 字段和方法
一旦定义了一个类(在Java中你所做的所有工作就是定义类，产生那些类的对象，以及发消息给这些对象)，就可以在类中两种类型的元素:字段(数据成员)和方法(有时候叫成员函数).字段可以是任何类型的对象，即可以是对象引用也可以是基本的数据类型。如果是对象引用，必须先初始化该引用（让他与一个实际的对象相关联）。
每个对象都有用来存储其字段的空间，普通字段(即访问权限为包私有，访问权限之后会讲解)不能在对象间共享，下面是一个具体字段的类:
class SomeData{
int i;
double d;
boolean b;
}
目前这个对象可以用来存储数据。也可以像之前说的，创建一个这个类的对象data。如下:
SomeData data=new SomeData()
可以给字段赋值，但必须知道如何引用一个对象的成员。具体的实现为:在对象的名称后面紧接一个句点，然后接着对象内部的成员名称。例如:
data.i=23;
data.d=1232;
data.b=true;
想修改数据也有可能位于对象所包含的对象中，只要在句点再句点就好了。像这样：
class AClass{
SomeData a=new SomeData();
}
AClass b=new AClass();
b.a.i=6;//放在方法执行，一般具体操作都放在方法中执行，我试过在方法外进行着操作，不行，可是具体原因不知道为什么
1.4.2 基本成员默认值
若类的某个成员是基本数据类型，即使没有初始化Java也会确保它获得一个默认值，如下标所示
| 基本类型 | 默认值 |
|---|---|
| boolean | false |
| char | ‘\u0000’(null) |
| byte | (byte)0 |
| short | (short)0 |
| int | 0 |
| long | 0L |
| float | 0F |
| double | 0.0d |
当变量作为类成员使用时，Java才会初始化，但是这些默认值可能对于你的程序来说，可能不符合你的程序要求，所以最好还是明确的对变量进行初始化。另外局部变量不初始化会报错：
1.5 方法、参数和返回值
许多程序设计语言，用函数这个术语来描述命名子程序，Java则是用方法这个术语来表示“做某些事情的方式”，实际上，继续把它看成函数也无妨，但是我们还是称之为方法。
Java中的方法决定了一个对象能够接受什么类型的信息，方法的基本组成包括：方法名称，方法参数，方法体，和方法返回值。下面试这个最基本的例子：
ReturnType methodName(/*Argument List*/){
/*method body*/
}
返回类型描述的是在调用方法之后从方法中返回的值，参数列表是给出要传给方法的信息的类型和名称。方法名和参数列表（合起来称为"方法签名"）用来唯一标识出某个方法。
Java中方法只能作为类的一部分来创建，不能单独创建，方法只有通过对象才能被调用，且这个对象必须能执行这个方法，如果执行对象上不存在的方法，那么编译的时候就会发出错误信息。一般调用方法的方式是对象名,然后是句点，接着是方法名和参数列表，如下:
objectNAME.methodName(arg1,arg2,arg3);
如果方法有返回值，比如f()，不带任何参数，返回double类型，是一个a对象中的方法，那么可以这样：
double d=a.f();
返回的类型不一定要与d的类型完全相同，可以是d的类型的子类，即类型兼容。
1.5.1 参数列表
方法的参数列表指明了要向方法传递怎么样的信息，就像之前认识的那样，Java中一切都是对象，参数列表一般都是对象形式的，因此，在参数列表中必须指定所传递对象的类型和名字，就算Java中传递对象的场合一样，方法的参数列表中传递的是对对象的引用，并且引用的类型要正确，如果参数被设置为String类型，那么传递的类型也要是String。否则编译会出错。
另外要注意的是，如果一个方法的参数列表包含多个不同类型的数据时，使用方法时要注意参数类型的顺序，否则，编译会出错。另外就算相同类型，也要注意具体的引用或者基本类型的名称，不要搞混淆。否则可能造成程序错误。
int strLength(String s){
rerurn 2*s.length();
}
此方法告诉你，需要多少字节才能容纳一个特定的String对象中的信息(字符串中的每个字符的尺寸都是16即两个字节，以此来提供对Unicode字符集的支持)。此方法的参数类型是String，参数名是s,一旦将s传递给此方法。就可以把他当作其他对象一样处理，可以用其传递小心，在这里，s的length()方法被调用，它是String类提供的方法之一，会返回字符串包含的字符串。
通过上面的例子，还可以了解到return的用法，首先表示方法做完了，离开此方法，另外就是返回一个值，return后可以不是一个具体值，可以是一个表达式，想这里的2*s.length()就是一个表达式。
当然也可以设置方法的返回值为不返回，即void
void setName(String s){
/*somethings*/
}
若返回的类型是void,return的作用只是用来退出方法，因为没必要非要到方法结束才出来，可以在任何地方返回，如果返回类型不是void，那么无论何处返回，编译器都会强制返回一个正确类型的返回值。
1.6 构建一个Java程序
1.6.1 名字可见性
在Java1.0和Java1.1中，扩展名com, edu, org, net等约定为大写形式。然而，在Java 2 开发到一般时，设计者们发现这样做会引起一些问题，因此，现在整个包名都是小写。如果大写会引入矛盾，比如，一个包名为net.MindView,而net包下正好有一个MindView.java的类或接口。这样就好引发矛盾，同时也提高可读性，程序看一眼名字是包名还是类名。
1.6.2 运行其他构件
如果想在自己的程序中使用预先定义好的类，那么编译器就必须知道怎么定位它们。当然这个类可能就在发出调用的那个源文件中；在这种情况下，就可以使用这个类——即使这个类在文件的后面才会被定义(Java消除了“向前引用”的问题)
如果那个类位于其他文件中，又会怎么样呢？ 你可能会认为编译器应该由足够的智慧，能够直接找到它的位置，但事实并非如此。想象下面的情况，如果你想使用某个特定名字的类，但其定义却不止一份（假设这些定义各不相同）。更糟糕的是，假设你正在写一个程序，在构建过程中，你想将某个心累添加到类库找活干，但却与已有的某个类名冲突。
为了解决这个问题，必须消除所有可能的混淆情况。为实现这个目的，可以使用关键import来准确地告诉编译器你想要的类是什么。import指示编译器导入一个包，也就是一个类库(在其他语言中，一个库不仅包含类，还可能包含方法和数据，但是Java中所有的代码必须写在类里)。
大多时候，我们使用与编译器附在一起的Java标准类库的构建，有了这些构件，你就不必谢一大串的反转域名。举例来说，只须向下面这么书写就行了：
import java.util.ArrayList;
如果你想一次使用util中的多个类，你可以使用通配符"*****"来达到这个目的：
import java.util.*;
1.6.3 关键字static
通常来说，当创建类是，就是在描述那额类的对象的外观与行为。除非使用new创建那个那个类的对象，否则实际上并未获取任何对象。执行new来创建对象时，数据存储空间才被分配，其方法才供外界调用。
有两种情形用上述方法是无法解决的。一种情形是，只想为某个特定域分配单一存储空间，而不去靠究竟要创建多少对象，甚至根本就不创建任何对象。另一种情形是，希望这个方法不与包含它的类的任何对象关联在一起。也就是说，即使没有创建对象，也能够调用这个方法。
通过static关键字可以满足这两方面的需要。当声明一个事物是static时，这就意味着这个域或方法不会与包含它的那个类的任何对象实例关联在一起。所以，即使从未创建某个类的任何对象，也可以调用其static方法或访问其static域。通常，你必须创建一个对象，并用它来访问数据或者，因为非static域和方法必须知道他们一起运作的特定对象。
有些面向对象语言采用类数据和类方法两个术语，代表那些非static数据和方法只是作为整个类，而不是类的某个特定对象而存在的。
只须将static关键字放在定义之前，就可以将字段或方法设定为public。例如，下面的代码就生成了一个static字段，并对其进行了初始化。
class StaticTest {
static int i = 47;
}
现在，即使你创建了两个StaticTest对象，StaticTest.i也只有一份存储空间，这个两个对象共享一个i。
引用static变量有两种方法。如前例所示，可以通过一个对象去定位它，如s2.i;也可以通过其类名直接引用，而这对于非静态成员则不行。
StaticTest.i++
类似逻辑也应用于静态方法。既可以像其他方法一样，通过一个对象来引用某个静态方法，也可以通过特殊的语法形式**ClassName.method()**加以引用。定义静态方法的方式也与定义静态变量的方式相似：
class Incrementable {
static void increment() {staticTest.i++;}
}
可以看到，Incrementable的increment()方法通过++运算符将静态数据i递增。可以采用典型的方式，通过对象来调用increment();
Incrementable sf = new Incrementable();
sf.increment();
或者，因为increment()是一个静态方法，所以也可以通过它的类直接调用。
Incrementable.increment();
尽管当static作用于某个字段时，肯定会改变数据创建的方式(因为一个static字段对每个类来说都只有一份存储空间，而非static字段则是对每个对象有一个存储空间)，但是如果static作用于某个方法，差别却没有那么大。static方法的一个重要用法就是在不创建任何对象的前提下就可以调用它。正如我们将会看到的那样，这一点对于定义main()方法很重要，这个方法是运行一个应用时的入口点。
和其他任何一样，static方法可以创建或者使用与其类型相同的被命名对象，因此，static方法常常拿来做“牧羊人”的角色，负责看护与其隶属同一类型的实力群。
1.7 你的第一个Java程序
// HelloDate.java
import java.util.*;
public class HelloDate {
public static void main(String[] args) {
System.out.println("Hello, it's:");
System.out.println("")
}
}
1.8 注释和嵌入式文档
Java中有两种注释风格。一种是传统的C语言风格的注释——C++ 也继承了这种风格。此种注释以“/*”开始，随后是注释内容，并可跨越多行，最后以“*/”。注意，许多程序员在连续的注意内容的每一行都以一个“*”开头，所以经常看到像下面的写法：
/* This is a comment
* that continues
* across lines
*/
但请记住，进行编译时，/*和*/之间的而所有东西都会忽略，所以上述注释与下面这段注释并没有什么两样：
/* This is a comment that
continue across lines */
第二种注释的风格也源于C++。这种注释是“单行注释”，以一个“//”起头，直到句末。这句风格的注意因为书写容易，所以更方便，更常用。例如：
// This is a one-line comment
1.8.1 注释文档
java中可以使用javadoc来提取注释，它是JDK安装的一部分。它采用了Java编译期的某些技术，查找程序内的特殊注释标签。它不仅解析由这些标签标记的信息，也将毗邻注释的类名或者方法名抽取出来。如此，我们就可以用最少的工作量，生成相当好的程序文档。
javadoc输出的是一个HTML文件，可以在Web浏览器查看。这样，该工具就使得我们只需创建和维护单一的源文件，并能自动生成有用的文档。有了javadoc，就有了创建文档的简明直观的标准；我们可以期望、甚至要求所有的Java类库都提供相关的文档。
此外，如果想对javadoc处理过的信息执行特殊的操作，那么可以通过编写你自己的被称为"doclets"的javadoc处理来实现。具体可参照doclets官网.
1.8.2 语法
所有javadoc命令都能在“/**”注释中出现，和通常一样，注意结束语"*/"。使用javadoc的方式主要有两种：嵌入HTML，或使用”文档标签“。独立文档标签是一些以”@“字符开头的命令，且要置于注释行的最前面(但是不算前导”@“字符开头，但要括在花括号内。
共有三种类型的注意文档，分别对应于注意位置后面的三种元素：类、域和方法。也就是说，类注释正好位于类定义之前，域注释正好位于域定义之前；而方法注释也正好位于方法定义的前面。如下面的这个简单的例子所示：
//: object/Documentation1.java
/** A class comment */
public class Documentation1 {
/** A field comment */
public int i;
/** A method comment */
public void f() {}
}///:~
注意，javadoc只能为public和protected成员进行文档注释。private和包内可访问成员的注释会被忽略掉，所以输出结果中看不到它们(不过可以用-private进行标记，以便把private成员的注释也包括在内)。这么做是有道理的，因为只有public和protected成员才能有文件之外被使用，这是客户端程序员所期望。
上述的代码的输出结果是一个HTML文件，它与其他Java文档具有相同的标准格式。因此，用户会非常熟悉这种格式，从而方便地导航到用户自己设计的类。输入上述代码，然后通过javadoc处理产生的HTML文件，最后通过浏览器观看生成的结果，，这样做是非常值得的。
1.8.3 嵌入式HTML
javadoc通过生成的HTML文档传送HTML命令，这使你可以充分利用HTML，当然，其主要目的还是为了对代码进行格式化，例如：
//: object/Documentation2.java
package object;
/**
* <pre>
* System.out.println(new Date());
* </pre>
*/
public class Documentation2 {
}
///:~
也可以像其他Web文档中那样运用HTML，对普通文本按照你自己所描述的进行格式化：
//: object/Documentation3.java
package object;
/**
* you can <em>even</em> insert a list;
* <ol>
* <li>Item one
* <li>Item two
* <li>Item three
* </ol>
*/
public class Documentation3 {
}
///:~
注意，在文档注释中，位于每一行开头的星好和前导空格都会被javadoc丢弃。javadoc会对所有内容重新格式化，使其与标准的文档外观一致。不要在嵌入式HTML中使用标题标签，例如<h1>或者<hr>，因为javadoc会插入自己的标签，而你的标签可能同它们发生冲突。
所有类型的注释文档——类、域和方法——都支持嵌入式HTML。
1.8.4 一些标签示例
这里将介绍一些可用于代码文档的javadoc标签。在使用javadoc处理重要的事情之前，应该先到JDK文档哪里查阅javadoc参考，以学习javadoc的各种不同的使用方法。
-
1.@see 引用其他类
@see标签允许用户引用其他类的文档。javadoc会在其生成的HTML文件中，通过@See标签链接到其他文档，其格式如下：
@see classname
@see fully-quanlified-classname
@see fullly-quanlified-classname#method-name
上述每种格式都会在生成的文档中加入一个具有超链接的“See Also”(参见)条目。但是javadoc不会检查你提供的超链接是否有效。
-
2.{@link package.class#member label}
该标签产生到文档根目录的相对路径，用于文档树界面的显式超链接。
-
3.{@docRoot}
该标签产生到文档根目录的相对路劲，用于文档树页面的显式超链接。
-
4.{@inheritDoc}
该标签从当前这个类的最直接的基类中继承相关文档到当前的文档注释中。
-
5.@version
该标签的格式如下：
@version version-information要提取出@version和@author标签需要额外的命令行参数。具体如下：
-overview <file> 从 HTML 文件读取概览文档 -public 仅显示 public 类和成员 -protected 显示 protected/public 类和成员 (默认值) -package 显示 package/protected/public 类和成员 -private 显示所有类和成员 -help 显示命令行选项并退出 -doclet <class> 通过替代 doclet 生成输出 -docletpath <path> 指定查找 doclet 类文件的位置 -sourcepath <pathlist> 指定查找源文件的位置 -classpath <pathlist> 指定查找用户类文件的位置 -cp <pathlist> 指定查找用户类文件的位置 -exclude <pkglist> 指定要排除的程序包列表 -subpackages <subpkglist> 指定要递归加载的子程序包 -breakiterator 计算带有 BreakIterator 的第一个语句 -bootclasspath <pathlist> 覆盖由引导类加载器所加载的 类文件的位置 -source <release> 提供与指定发行版的源兼容性 -extdirs <dirlist> 覆盖所安装扩展的位置 -verbose 输出有关 Javadoc 正在执行的操作的信息 -locale <name> 要使用的区域设置, 例如 en_US 或 en_US_WIN -encoding <name> 源文件编码名称 -quiet 不显示状态消息 -J<flag> 直接将 <flag> 传递到运行时系统 -X 输出非标准选项的提要 通过标准 doclet 提供: -d <directory> 输出文件的目标目录 -use 创建类和程序包用法页面 -version 包含 @version 段 -author 包含 @author 段 -docfilessubdirs 递归复制文档文件子目录 -splitindex 将索引分为每个字母对应一个文件 -windowtitle <text> 文档的浏览器窗口标题 -doctitle <html-code> 包含概览页面的标题 -header <html-code> 包含每个页面的页眉文本 -footer <html-code> 包含每个页面的页脚文本 -top <html-code> 包含每个页面的顶部文本 -bottom <html-code> 包含每个页面的底部文本 -link <url> 创建指向位于 <url> 的 javadoc 输出的链接 -linkoffline <url> <url2> 利用位于 <url2> 的程序包列表链接至位于 <url> 的文档 -excludedocfilessubdir <name1>:.. 排除具有给定名称的所有文档文件子目录。 -group <name> <p1>:<p2>.. 在概览页面中, 将指定的程序包分组 -nocomment 不生成说明和标记, 只生成声明。 -nodeprecated 不包含 @deprecated 信息 -noqualifier <name1>:<name2>:... 输出中不包括指定限定符的列表。 -nosince 不包含 @since 信息 -notimestamp 不包含隐藏时间戳 -nodeprecatedlist 不生成已过时的列表 -notree 不生成类分层结构 -noindex 不生成索引 -nohelp 不生成帮助链接 -nonavbar 不生成导航栏 -serialwarn 生成有关 @serial 标记的警告 -tag <name>:<locations>:<header> 指定单个参数定制标记 -taglet 要注册的 Taglet 的全限定名称 -tagletpath Taglet 的路径 -charset <charset> 用于跨平台查看生成的文档的字符集。 -helpfile <file> 包含帮助链接所链接到的文件 -linksource 以 HTML 格式生成源文件 -sourcetab <tab length> 指定源中每个制表符占据的空格数 -keywords 使程序包, 类和成员信息附带 HTML 元标记 -stylesheetfile <path> 用于更改生成文档的样式的文件 -docencoding <name> 指定输出的字符编码 -
6.@author
该标签的格式如下：
@author author-information
其中author-information表示作者信息。
-
7.@Since
该标签允许你指定程序代码最早使用的版本，可以在HTML Java文档中看到它被用里指定同一段落，置于生成的HTML中。
-
8.@param
该标签用于方法文档中，形式如下：
@param paramter-name description
其中，parameter-name是方法的参数列表中的标识符，description是可延续数行的文本，终止与新的文档标签之前。可以使用任意多个这种标签,大约每个参数都有一个这样的标签。
-
9.@return
该标签用于方法文档，格式如下：
@return description
其中，“description”用来描述返回值的含义，可以延续数行。
-
10.@throws
异常标签的格式如下：
@throws fully-quanlified-class-name description
其中fully-quanlified-class-name给出一个异常类的无歧义的名字。而该异常类在别处定义。description(同样可以延续数行)告诉你为什么此特殊类型的异常会在方法调用中出现。
-
11.@deprecated
该标签用于支出一些旧特性已有改进的新特性所取代，建议用户不要再使用这些就特性了，因为在不久的将来它们可能会被删除。如果使用一个标记为@deprecated的方法，则会引起编译器发布警告。
在Java SE5中，Javadoc标签@deprecated已经被@Deprecated注解所替代。
1.8.5 文档示例
下面再回到第一个Java程序，但是这次加上了文档注释：
//: object/HelloDate.java
package object;
import java.util.Date;
/** The first Thinking in Java example program
* Display a string and today's date
* @author xun
* @version 4.0
*/
public class HelloDate {
/** Entry point to class and application
@param args array of string arguments
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("Hello,it's :");
System.out.println(new Date());
}
}/*Output:
Hello,it's :
Mon July 29 09:47:26 CST 2019
*///:~
1.9 编码风格
在“Java编程语言编码约定”中，代码风格是这样规定的：类名的首字母要大写，如果类名由几个单词构成，那么把它们并在一起(也就是说，不要用下划线来分隔名字)，其中每个内部单词的首字母都采用大写形式。例如：
class AllTheColorsOfTheRainbow { //...}
这种风格有时称作“驼峰风格”。几乎其他所有内容——方法，字段(成员变量)以及对象引用名称等，公认的风格与类的风格一样，只是标识符的第一个字符采用小写。例如：
class AllTheColorsOfTheRainbow {
int anIntegerRepresentingColors;
void changeTheHueOfTheColor(int newHue) {
// ...
}
// ...
}
当然，用户还必须键入所有这些长名字，并且不能输错，因为，一定要格外仔细。
Sun程序库中的Java代码也采用本书排放开，闭花括号的方式。
1.10 总结
通过本章的学习，大家已接触相当多的关于如何编写一个简单程序的Java编程知识。
参考文献
《Thinking in Java》
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
