Java学习笔记(未完成.....)

J2SE 5 与J2SE 1.5

J2SE 5 和J2SE 1.5其实都是指同一个版本的J2SE,前者是它的外部版本号,而后者是内部版本号.

从Java产生时,Sun公司发布了Java 1.0.而后都以1.n的形式来表示版本号.

而由于J2SE 1.5的较前面版本的变化是非常大的,可以是说是一个里程碑.

所以Sun为了强调它,另外取名J2SE 5.

 

J2SE 5相当于别名,而J2SE 1.5是这个版本的真实姓名.

所以当你向编译器询问版本号时,它将回答是1.5.

Sun公司的提供的联机文档使用1.5代表J2SE 5添加的新特性.

J2SE 1.5是用在比正规,严格的情况下使用,而平时生活中,我们可以把它叫做J2SE 5.

如何才算掌握Java(J2SE篇)

每次当我在编写一个Java程序时,如果是要用到Java API包中的类(或方法,常量)时候,我就会感觉写起程序来很吃力.或者说就根本写不出来了.

对于这个问题我思考了很久,后来,

在看完下面的一篇文章后,我明白了一点,是我对Java API中的常用的类,方法以及常量这些东西根本就不熟练。

如何才算掌握Java(J2SE篇)

作者:未知 时间:2005-07-24 21:13 出处:JR 责编:chinaitpower

时常看到一些人说掌握了Java,但是让他们用Java做一个实际的项目可能又困难重重,在这里,笔者根据自己的一点理解斗胆提出自己的一些对掌握Java这个说法的标准,当然对于新手,也可以提供一个需要学习哪些内容的参考.另外这个标准仅限于J2SE部分,J2EE部分的内容有时间再另说.
1、语法：

必须比较熟悉,在写代码的时候IDE的编辑器对某一行报错应该能够根据报错信息知道是什么样的语法错误并且知道任何修正.

2、命令：

必须熟悉JDK带的一些常用命令及其常用选项,命令至少需要熟悉：appletviewer、HtmlConverter、jar、java、javac、javadoc、javap、javaw、native2ascii、serialver，如果这些命令你没有全部使用过,那么你对java实际上还很不了解。

3、工具：

必须至少熟练使用一种IDE的开发工具，例如Eclipse、Netbeans、JBuilder、Jdeveloper、IDEA、JCreator或者Workshop，包括进行工程管理、常用选项的设置、插件的安装配置以及进行调试。

4、API：

Java的核心API是非常庞大的,但是有一些内容笔者认为是必须熟悉的,否则不可能熟练的运用Java,包括：
    1）、java.lang包下的80％以上的类的功能的灵活运用.
    2）、java.util包下的80％以上的类的灵活运用，特别是集合类体系、规则表达式、zip、以及时间、随机数、属性、资源和Timer。
    3）、java.io包下的60％以上的类的使用,理解IO体系的基于管道模型的设计思路以及常用IO类的特性和使用场合.
    4）、java.math包下的100％的内容.
    5）、java.net包下的60％以上的内容,对各个类的功能比较熟悉.
    6）、java.text包下的60％以上的内容,特别是各种格式化类.
    7）、熟练运用JDBC.
    8）、java.security包下40％以上的内容,如果对于安全没有接触的话根本就不可能掌握java.
    9）、AWT的基本内容，包括各种组件事件、监听器、布局管理器、常用组件、打印.
    10）、Swing的基本内容,和AWT的要求类似.
    11）、XML处理,熟悉SAX、DOM以及JDOM的优缺点并且能够使用其中的一种完成XML的解析及内容处理.
5、测试：必须熟悉使用junit编写测试用例完成代码的自动测试。
6、管理：必须熟悉使用ant完成工程管理的常用任务，例如工程编译、生成javadoc、生成jar、版本控制、自动测试。
7、排错：应该可以根据异常信息比较快速的定位问题的原因和大致位置。
8、思想：必须掌握OOP的主要要求，这样使用Java开发的系统才能是真正的Java系统。
9、规范：编写的代码必须符合流行的编码规范，例如类名首字母大写,成员和方法名首字母小写,方法名的第一个单词一般是动词,包名全部小写等,这样程序的可读性才比较好.

文章来源:

http://www.chinaitpower.com/A200507/2005-07-27/172707.html

 public static void main(String[] args)的含义

public static void main(String[] args)这条语句中的String[] args是什么含义呢？

干什么用呢,这个问题曾经一直困惑着我,不过,现在总算知道了.

args是命令行参数,它的数据类型是String(字符串)类.  []表示数组.   String[]即字符串数组.

 

class ArgsDemo

{

public static void main(String[] args)

   {

       String name=args[0];

       String sex= args[1];

       String age= args[2];

       System.out.println("你的姓名是："+name);

       System.out.println("你的性别是："+sex);

       System.out.println("你的年龄是："+age);

}

}

这时候,输入命令应该是java ArgsDemo 杨春 男 21,得出结果如下图所示:

杨春 男 21这三个值你可以随意更改,只要你给出了这三个值即可.

 

如果你只输入java ArgsDemo,得出的结果如下图所示：

java.lang.ArrayIndexOutOfBoundsException是什么意思呢？

ArrayIndexOutOfBoundsException是java.lang包下的一个异常类.它的意思是数组下标越界异常.

下面是在API 中,对这个类进行的描述：

用非法索引访问数组时抛出的异常.如果索引为负或大于等于数组大小,则该索引为非法索引.

参见下面网址：

http://gceclub.sun.com.cn/Java_Docs/html/zh_CN/api/java/lang/ArrayIndexOutOfBoundsException.html

 

 

 

关于内部类的一点思考

 

内部类可以理解成一个"黑盒子"

举个例子:

class Outer

{

   int outer_x=100;

   void test()

      {

          Inner inner=new Inner();

           inner.display();

      } 

      class Inner

        {

            void display();

               {

                      System.out.println("display: outer_x = " + outer_x);

               }

        }

}

class InnerClassDemo

{

      public static void main(String args[])

        {

            Outer outer =new Outer();

            outer.test();

        }

  }

在这个例子中,Outer为外部类,Inner为内部类.

外部类Outer可以(通过创建Inner类对象)使用Inner类的功能.

这可以通过

Inner inner=new Inner();

inner.display();

这两条语句来体现.

但是Inner类中的变量和方法相对于Outer类来说是局部的,不可见的.Outer类看不见这些变量和方法,也就无法改变它们.

也就是说,

外部类可以使用内部类的功能,但却无法知道内部类的工作机制(Inner类的方法和变量)

 

 

 数组与对象

 

在Java中,创建数组和对象都是通过new关键字的.它们是非常相似的

创建数组的语法:

type var-name[]=new type[size];

其中type是数据类型,var-name是数组变量.size指定数组的大小(或者说是数目,个数).

使用new type[size]创建一个新数组.把它赋值给var-name[]数组变量.

数组是作为对象实现的.

 

数组的一个特殊的属性是length实例变量

例如：String str[]={"one", "two", "three"};

int s=str.length;

 

java.lang.String类中有一个length()方法.

例如：String str="my name is yangchun";

int s=str.length();

 

创建对象的语法：

classname var-name=new classname();

classname是类名, var-name是一个普通的类变量

使用new classname()创建一个新对象,把它赋值给var-name类变量.

 

当用class关键字声明一个类时,所声明的类名就是一种自定义的数据类型.例如class Box,类名Box就是一个新的数据类型.

所以,classname实际就是一种新的自定义的数据类型.

事实上,对象是一个特殊的变量,而类(实际上是声明后的类名)是用户自定义的数据类型.

JDK命令

 

JDK常用命令

Appletviewer

HtmlConverter

jar

java

javac

javadoc

javap

javaw

native2ascii

serialver

编译第一个Java程序

编译你的第一个Java程序

下载JDK

打开http://java.sun.com/ 网站,点击Downloads 链接,

打开记事本,复制以下代码:

/*
            This is simple Java program.
            Call tis file "Example.java"
        */
class Example
{
  //Your program begins with a call to main().
  public static void main(String args[])
        {

   System.out.println("This is simple Java program.");

}
}

另存为C盘,文件名为Example.java(文件后缀名一定要是java), 打开命令提示符(开始菜单->程序->附件->命令提示符或开始菜单->运行,输入cmd,点击确定).

首先输入cd/,按回车键,转到C盘

 

 

接下来输入javac Example.java,按回车键,

 

现在打开C盘,会发现C盘多出一个文件Example.class

 

最后输入java Example,按回车键

如果程序没有错误,正常输出

 

 

注意:上面的javac也就是Java编译器,而java是Java解释器,也可以理解成字节码解释器 

 

 

 

关于javac和java的思考

一个包含Java程序的源文件经过javac编译器把它编译为class类文件(包含程序的字节码),再通过java解释器,把class文件转化为可执行代码,运行,最后输出结果.

 

而像C语言的非Java程序,是将源文件直接编译成可执行代码,运行,最后输出结果

 

字节码是一套在Java运行时系统执行的高度优化的指令集.

这个Java运行时系统就是JVM(Java Virtual Machine,Java虚拟机)

javac编译器的作用是把源文件编译成class文件,即字节码文件(准确的说一个class文件包含Java虚拟机指令(即字节码)和一个符号表以及其他的辅助信息),一旦转化为class文件,那么接下来就是JVM开始工作了.

在JVM中有一个字节码编译器----------JIT(Just In Time,即时),它的作用是将字节码动态地编译为本地代码.也就是可执行代码.

 实际上,JVM就是一个字节码解释器,它把class类文件中的字节码解释成可执行代码.

 

前面讲到javac.exe是存放在JDK中的(事实上,你仅可以在JDK中找到它),即生成class文件的工作是由JDK来完成的.

而java.exe是分别存放于JRE和JDK中的,

所以前者的java.exe是把class文件转化为可执行代码,而后者的作用是运行,输出结果

 

将Java程序转化为class文件的过程,

更准确的是把Java程序中的每个单独的类转化为后缀名为.class类文件.

举个例子：

class Box

{

  double width;

  double height;

  double depth;

}

class BoxDemo

{

   public static void main(String args[])

     {

        Box mybox=new Box();

        double vol;

        mybox.width=10;

        mybox.height=20;

        mybox.depth=15;

        vol=mybox.width * mybox.height * mybox.depth;

        System.out.println("Volume is "+vol);

     }

}

在这个程序中,你得把文件名命名为BoxDemo而不是Box,因为BoxDemo是程序的入口类.

当你使用javac BoxDemo.java编译这个程序时,在C盘会形成两个class类文件,分别是Box.class 和BoxDemo.class,

之所以会有两个,是因为程序中有两个类.

 

 

 

 

最终结果如上图所示.

现在新建一个文本文档,取名Box.java,剪切Box类中的代码,即下面的程序：

class Box

{

  double width;

  double height;

  double depth;

}

别忘了保存两个文本文档哦.

删除两个class类文件.

重新打开命令提示符,输入cd/,转到C盘,

接着输入javac BoxDemo.java,同样会在C盘形成两个class类文件.

最后输入java BoxDemo,同样得到上面的结果.

 

 

 

环境变量

当你使用JDK+文本编辑器(如记事本)编译Java程序时,如果没有设置的path环境变量,那么当你在命令提示符中写类似javac Example.java这样的文字时,会出现下面的错误：

'javac'不是内部或外部命令,也不是可运行的程序或批处理文件

 

也就是说系统不认识这个javac,因为你没有告诉系统javac.exe的存放位置

 

javac.exe文件是存放在C:/Program Files/Java/jdk1.6.0_03/bin中的.

java.exe分别存放在C:/Program Files/Java/jre1.6.0_03/bin和C:/Program Files/Java/jdk1.6.0_03/bin中的.

前者的JRE,即Java Runtime Environment,

中文名称为Java运行时环境,也就是JVM(Java Virtual Machine,Java虚拟机).

而后者的JDK,即Java Development Kit,中文名称为Java开发者工具包

1.6.0_03是版本号,表明使用的是最新版本JDK 1.6 Update 3,

C:/Program Files/Java是JDK和JRE的默认安装路径,

在设置path环境变量时,你必须把它改变你自己的JDK的安装路径.

 

而当使用Java编程工具(如Eclipse,JBuilder)时,是不需要设置环境变量的,

因为相应的Java编程工具会在你编译程序时,默默的调用javac.exe(Java编译器),产生class文件.

 

要想得出前面的第一个Java程序的输出结果,请按照如下的方法设置环境变量.

环境变量的设置方法:

右击我的电脑,单击属性,弹出"系统属性"窗口,单击"高级" 选项卡

 

 

单击"环境变量"按钮,弹出"环境变量"窗口

 

在系统变量(S)这一栏找到Path变量,双击它,弹出"编辑系统变量"窗口

 

在变量值这一行,填写;C:/Program Files/Java/jdk1.6.0_03/bin

C:/Program Files/Java是JDK和JRE的默认安装路径,

你必须把它改变为你自己的JDK的安装路径.

 

点击确定,在"环境变量"窗口点击确定,在"系统属性"窗口中点击确定 

 

注意,不要删除原先的变量值.还有就是;一定要加啊!

 

javap 命令 

这个命令的作用可以参见"JDK的命令详解"

它的功能是Java类文件解析器.我自己的理解是这个命令可能获得类的基本信息.

举个例子:

获得Example类的基本信息.

 首先,在C盘新建Example.java 的记事本文档(如果这个记事本文档还存在你的磁盘上,就无需新建).

 

 

提示信息是：

ERROR:Could not find Example

翻译成中文的含义是：

错误:不能找到Example

 

Why?

想想看, javap是用于获得指定类的基本信息,

那么就意味着可能javap Example 这条命令中的Example是指Example.class文件,而不是Example.java

先用javac 命令获得class文件.然后再使用javap命令

 

 

可以看到,使用javap命令后,得到如下信息：

Compiled from "Example.java"

class Example extends java.lang.Object{

    Example();

    public static void main(java.lang.String[]);

}

 

从这些文字中,可以知道Example的继承java.lang.Object类.

它有两个方法：Example() 和main() 方法.

 

首先,所有的类(自定义的类或Java API中定义的类)都继承java.lang.Object类.

java.lang.Object是所有类的父类.

如果用一棵树来表示类的继承关系,那么,根结点肯定是java.lang.Object类.

Example()方法也称为构造函数.

在这个程序中,并没有显式的定义一个构造函数,那么会自动生成一个默认的无参数的构造函数.

至于main()方法,可以在程序中找到它.

 

可以看出, javap返回的是类的成员,包括方法和变量(在示例中,并未有变量).以及类的继承关系(例如, Example继承Object).

 

 

 

javadoc 命令

功能：

Java API文档生成器从Java源文件生成API文档HTML页。

javadoc解析Java源文件中的声明和文档注释,并产生相应的HTML页缺省,描述公有类、保护类、内部类、接口、构造函数、方法和域。

例子

import java.io.*;

/**

 *This class demostrates documentation comments.

 *@author Herbert Schildt

 *version 1.2

*/

public class SquareNum

{

  /**

   *This method returns the square of num.

   *This is a multiline description. You can use

   *@param num The value to be squared.

   *@return num squared. 

  */

  public double square(double num)

  {

    return num * num;

  }

  /**

   *This method inputs a number from the user.

   *@return The value input as a double.

   *@exception IOException On input error.

   *@see IOExcetption

  */

  public double getNumber() throws IOException

   {

     //create a BufferedReader using System.in

     InputStreamReader isr=new InputStreamReader(System.in);

     BufferedReader inDate=new BufferedReader(isr);

     String str;

     str=inDate.readLine();

     return (new Double(str).doubleValue());

   }

   /**

    *This method demostrates square().

    *@param args Unsed.

    *@return Nothing.

    *@exception IOException On input error.

    *@see IOException

   */

   public static void main(String args[]) throws IOException

    {

      SquareNum ob=new SquareNum();

      double val;

      System.out.println("Error value to be squared: ");

      val=ob.getNumber();

      val=ob.square(val);

      System.out.println("Squared value is "+val);

    }

}

 

        

 

      

 

 

在C盘生成了HTML文档.

 

 

 

下图显示了javadoc的用法：

 

 

用法：javadoc [选项] [软件包名称] [源文件] [@file]

-overview <文件>          读取 HTML 文件的概述文档

-public                   仅显示公共类和成员

-protected                显示受保护/公共类和成员（默认）

-package                  显示软件包/受保护/公共类和成员

-private                  显示所有类和成员

-help                     显示命令行选项并退出

-doclet <类>              通过替代 doclet 生成输出

-docletpath <路径>        指定查找 doclet 类文件的位置

-sourcepath <路径列表>    指定查找源文件的位置

-classpath <路径列表>     指定查找用户类文件的位置

-exclude <软件包列表>     指定要排除的软件包的列表

-subpackages <子软件包列表> 指定要递归装入的子软件包

-breakiterator            使用 BreakIterator 计算第 1 句

-bootclasspath <路径列表> 覆盖引导类加载器所装入的

                          类文件的位置

-source <版本>            提供与指定版本的源兼容性

-extdirs <目录列表>       覆盖安装的扩展目录的位置

-verbose                  输出有关 Javadoc 正在执行的操作的消息

-locale <名称>            要使用的语言环境，例如 en_US 或 en_US_WIN

-encoding <名称>          源文件编码名称

-quiet                    不显示状态消息

-J<标志>                  直接将 <标志> 传递给运行时系统

 

通过标准 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>               输出编码名称

appletviewer 命令

使用JDK+文本编辑器的方式处理Java中的Applet(Applet是在Web浏览器中运行的小程序). 

 

 

 

举个例子

import java.awt.*;

import java.applet.*;

/*

   <applet code="Rectangles" width=300 height=200>

   </applet>

*/

public class Rectangles extends Applet

{

  public void paint(Graphics g)

   {

      g.drawRect(10,10,60,50);

      g.fillRect(100,10,60,50);

      g.drawRoundRect(190,10,60,50,15,15);

      g.fillRoundRect(70,90,140,100,30,40); 

   }

}

 

上面这段程序是Applet(小应用程序)的一个例子,正确的输出结果如下图所示：

 

 

 

图A

 

而使用命令提示符,得到的结果如下图所示:

Exception in thread “main” java.lang.NoClassDefFoundError: Rectangles

这一句直接翻译的意思是：

异常在线程”main” java.lang.NoClassDefFoundError: Rectangles

(Rectangles就是上面创建的类.)

java.lang.NoClassDefFoundError是什么意思呢？

首先java.lang是API中的一个包,而NoClassDefFoundError是这个包下的一个错误类,

下面是在API中,对这个类进行的描述：

当 Java 虚拟机或 ClassLoader实例试图在类的定义中加载（作为通常方法调用的一部分或者作为使用 new表达式创建的新实例的一部分）,但无法找到该类的定义时,抛出此异常。

参见下面网址：

http://gceclub.sun.com.cn/Java_Docs/html/zh_CN/api/java/lang/NoClassDefFoundError.html

 

java.exe只能处理由main()函数作为入口的Java程序,

简单理解就是Java程序必须有一条这样的语句：public static void main(String args[])

而在Applet中是根本不需要这条语句的。

事实上,在Java中,main()函数已经很少被使用了,只有在一些非常简单的程序中才能用到.而这些简单的程序一般都是用于演示的目的.

 

使用java是行不通的,但是可以使用appletviewer -debug Rectangles.java

appletviewer.exe是存放在C:/Program Files/Java/jdk1.6.0_03/bin中的,为Java Applet小程序查看器.

下图中详细显示中appletviewer的用法

 

jdb也是存放在C:/Program Files/Java/jdk1.6.0_03/bin中的

 

你会发现等上很长一段时间什么反应都没有,这说明这个方法也是行不通的。

这时候,再来第二个方法:

把Rectangles.java文件的后缀名改成html,也就是Rectangles.html.

首先第一步,向命令提示符键入cd/,转到C盘.

第二,键入javac Rectangles.java  ,转化为Rectangles.class类文件.

注意,在这一步,Rectangles文件的后缀名应该是java,而不是html.

第三步,把后缀名java改成html,打开这个文件

右击允许阻止的内容(请放心,这不会对你的系统产生任何影响)

 

 

 

可以看到与图A的结果是很接近的,所不同的是,前面是在applet查看器中运行的,而后者是html.

所以现在我们关闭Rectangles.html文件.

切换到刚才使用的命令提示符,输入appletviewer Rectangles.html

     按回车键,弹出一个窗口,如下图

    

发现与图A的结果基本是一致的.

 

在Rectangles.java中,有这样一条语句,

/*

   <applet code="Rectangles" width=300 height=200>

   </applet>

*/

首先/* . . .*/ 在Java是注释,也可以把它改成下面的形式：

// <applet code="Rectangles" width=300 height=200> </applet>

而<applet> . . .</applet>其实是<applet>标签.

为什么会出现这个标签呢,这其实与Java Plug-in (插件)有关.

首先, Applet是在Web浏览器中运行的小程序,这就需要浏览器能够支持Applet ,

在早期的时候,基本上只有网景浏览器(Netscape ,可怜啊！现在这个浏览器的市场占有率不到1%),而这个浏览器是可以支持Applet,

所以,Sun公司也就没有开发插件的必要了.

当然了,Sun公司自己也有开发一款浏览器,名字叫做HotJava

而随着微软件的IE浏览器的出现, Netscape的被淘汰,浏览器软件的竞争可以说是非常的激烈,

现在又有Mozilla FireFox(火狐),傲游等等.

这样就出现了一个问题,Sun公司并不能保证所有的游览器都能支持Applet .

于是插件也就出现了.

 

这就有今天的<applet>标签和Java(TM) Plug-in HTML转换程序以及HtmlConverter 命令

在JDK中自带了Java插件,

 

 

 

HtmlConverter 命令

 

 

 

 

 

输入HtmlConverter (大小写可以忽略),弹出Java(TM) Plug-in HTML转换程序.

在里Plug-in是插件的意思.

 

 

 

点击编辑->选项

 

弹出"高级选项"窗口

 

 

 

点击转换按钮,弹出如下窗口：

 

关于HtmlConverter命令还在进一步研究中. . . . .

在Rectangles.java中,是一个applet小程序,现在来看看使用HtmlConverter命令的结果：

在”指定文件或目录路径”这一栏的右侧点击”浏览”, 找到Rectangles.java并且点击”打开” 按钮.

 

 

最后点击”转换”按钮,弹出如下窗口：

点击”完成”.

 

这时候,打开Rectangles.java查看一下：

原来的applet脚本

/*

   <applet code="Rectangles" width=300 height=200>

   </applet>

*/

变成了下面的内容：

/*

   <!--"CONVERTED_APPLET"-->

<!-- HTML CONVERTER -->

<object

    classid = "clsid:8AD9C840-044E-11D1-B3E9-00805F499D93"

    codebase = "http://java.sun.com/update/1.6.0/jinstall-6u30-windows-i586.cab#Version=6,0,0,5"

    WIDTH = 300 HEIGHT = 200 >

    <PARAM NAME = CODE VALUE = "Rectangles" >

    <param name = "type" value = "application/x-java-applet;version=1.6">

    <param name = "scriptable" value = "false">

 

    <comment>

       <embed

            type = "application/x-java-applet;version=1.6" /

            CODE = "Rectangles" /

            WIDTH = 300 /

            HEIGHT = 200

           scriptable = false

           pluginspage = "http://java.sun.com/products/plugin/index.html#download">

           <noembed>

           

            </noembed>

       </embed>

    </comment>

</object>

 

<!--

<APPLET CODE = "Rectangles" WIDTH = 300 HEIGHT = 200>

 

 

</APPLET>

-->

<!--"END_CONVERTED_APPLET"-->

 

*/

 

这部分内容多出的<object>. . .</object>和<embed>. . .</embed>标记.

 

 

 

 

JDK的命令详解

 

这篇文章是转载的,作者不详

rmic

功能说明：
rmic 为远程对象生成 stub 和 skeleton。
语法：
rmic [ options ] package-qualified-class-name(s)
补充说明：
rmic 编译器根据编译后的 Java 类（含有远程对象实现）名，为远程对象生成 stub 和 skeleton（远程对象是指实现 java.rmi.Remote 接口的对象）。在 rmic 命令中所给的类必须是经 javac 命令成功编译且是完全包限定的类。
命令选项
-classpath[路径] 指定 rmic 用于查询类的路径。如果设置了该选项，它将覆盖缺省值或 CLASSPATH 环境变量。目录用冒号分隔。
-d[目录] 指定类层次的根目录。此选项可用来指定 stub 和 skeleton 文件的目标目录。
-depend 使编译器考虑重新编译从其它类引用的类。 一般来说，它只重新编译从源代码引用的遗漏或过期的类。
-g 允许生成调试表格。调试表格含有行号和局部变量的有关信息，即 Java 调试工具所使用的信息。缺省情况下，只生成行号。
-J 与 -D 选项联用，它将紧跟其后的选项（ -J 与 -D 之间无空格）传给 java 解释器。
-keepgenerated 为 stub 和 skeleton 文件保留所生成的 .java 源文件，并将这些源文件写到与 .class 文件相同的目录中，如果要指定目录，则使用 -d 选项。
-nowarn 关闭警告。如果使用该选项，则编译器不输出任何警告信息。
-show 显示 rmic 编译器的 GUI（图形用户界面）。输入一个或多个包限定类名（以空格分隔），并按回车键或“显示”按钮，创建 stub 和 skeleton。
-vcompat （缺省值）创建与 JDK 1.1 和 1.2 stub 协议版本都兼容的 stub 和 skeleton。
-verbose 使编译器和链接器输出关于正在编译哪些类和正在加载哪些类文件的信息。
-v1.1 创建 JDK 1.1 stub 协议版本的 stub 和 skeleton。
-v1.2 只创建 JDK 1.2 stub 协议版本的 stub。

rmid

功能说明：
rmid 启动激活系统守护进程，以便能够在 Java 虚拟机上注册和激活对象。
语法：
rmid [-port port] [-log dir]
补充说明：
rmid 工具启动激活系统守护进程。必须先启动激活系统守护进程，才能向激活系统注册可被激活的对象或在 Java 虚拟机上激活可被激活的对象。
命令选项
-C<某些命令行选项> 指定一个选项，在创建每个 rmid 的子守护进程（激活组）时，该选项以命令行参数的形式传给该子守护进程。
-log[目录] 指定目录的名称，激活系统守护进程在该目录中写入其数据库及相关信息。缺省状态下，将在执行 rmid 命令的目录中创建一个 log 目录。
-port[端口] 指定 rmid 的注册服务程序所使用的端口。激活系统守护进程将 ActivationSystem 与该注册服务程序中的名称java.rmi.activation.ActivationSystem 捆绑在一起。
-stop 停止 -port 选项所指定端口上的当前 rmid 调用。若未指定端口，则将停止在端口 1098 上运行的 rmid。

rmiregistry

功能说明：
rmiregistry 命令可在当前主机的指定端口上启动远程对象注册服务程序。
语法：
rmiregistry [port]
补充说明：
rmiregistry 命令在当前主机的指定 port 上创建并启动远程对象注册服务程序。如果省略 port，则注册服务程序将在 1099 端口上启动。rmiregistry 命令不产生任何输出而且一般在后台运行。远程对象注册服务程序是自举命名服务。主机上的 RMI 服务器将利用它将远程对象绑定到名字上。客户机即可查询远程对象并进行远程方法调用。注册服务程序一般用于定位应用程序需调用其方法的第一个远程对象。该对象反过来对各应用程序提供相应的支持，用于查找其它对象。java.rmi.registry.LocateRegistry 类的方法可用于在某台主机或主机和端口上获取注册服务程序操作。java.rmi.Naming 类的基于 URL 的方法将对注册服务程序进行操作，并可用于查询远程对象、将简单（字符串）名称绑定到远程对象、将新名称重新绑定到远程对象（覆盖旧绑定）、取消远程对象的绑定以及列出绑定在注册服务程序上的 URL。

serialver

功能说明：
serialver 命令返回 serialVersionUID。
语法：
serialver [ 命令选项 ]
补充说明：
serialver 以适于复制到演变类的形式返回一个或多个类的 serialVersionUID。不带参数调用时，它输出用法行。
命令选项
-show 显示一个简单的用户界面。输入完整的类名并按回车键或"显示"按钮可显示 serialVersionUID。

jarsigner

功能说明：
为 Java 归档 (JAR) 文件产生签名，并校验已签名的 JAR 文件的签名。
语法：
jarsigner [ 命令选项 ] jar-file alias
jarsigner -verify [ 命令选项 ] jar-file
补充说明：
jarsigner 工具用于两个目的：
1:为 Java 归档 (JAR) 文件签名
2:校验已签名的 JAR 文件的签名和完整性
命令选项
-keystore[url] 指定密钥仓库的 URL。缺省值是用户的宿主目录中的 .keystore 文件，它由系统属性“user.home”决定。
-storetype[storetype] 指定要被实例化的密钥仓库类型。默认的密钥仓库类型是安全属性文件中 "keystore.type" 属性值所指定的那个类型，由 java.security.KeyStore 中的静态方法 getDefaultType 返回。
-storepass[password] 指定访问密钥仓库所需的口令。这仅在签名（不是校验）JAR 文件时需要。在这种情况下，如果命令行中没有提供 -storepass 选项，用户将被提示输入口令。
-keypass[password] 指定用于保护密钥仓库项（由命令行中指定的别名标出）的私钥的口令。使用 jarsigner 为 JAR 文件签名时需要该口令。如果命令行中没有提供口令，且所需的口令与密钥仓库的口令不同，则将提示用户输入它。
-sigfile[file] 指定用于生成 .SF 和 .DSA 文件的基本文件名。
-signedjar[file] 指定用于已签名的 JAR 文件的名称。
-verify 如果它出现在命令行中，则指定的 JAR 文件将被校验，而不是签名。如果校验成功，将显示“jar verified”。如果试图校验未签名的 JAR 文件，或校验被不支持的算法（例如未安装 RSA 提供者时使用的 RSA）签名的 JAR 文件，则将有如下显示： "jar is unsigned. (signatures missing or not parsable)" 。
-certs 如果它与 -verify 和 -verbose 选项一起出现在命令行中，则输出将包括 JAR 文件的每个签名人的证书信息。
-verbose 如果它出现在命令行中，则代表“verbose”模式，它使 jarsigner 在 JAR 签名或校验过程中输出额外信息。
-internalsf 过去，JAR 文件被签名时产生的 .DSA（签名块）文件包含一个同时产生的 .SF 文件（签名文件）的完整编码副本。这种做法已被更改。为了减小输出 JAR 文件的整个大小，缺省情况下 .DSA 文件不再包含 .SF 文件的副本。但是如果 -internalsf 出现在命令行中，将采用旧的做法。该选项主要在测试时有用；实际上不应使用它，因为这样将消除有用的优化。
-sectionsonly 如果它出现在命令行中，则 JAR 文件被签名时生成的 .SF 文件（签名文件）将不包括含有整个清单文件的散列的头。它仅包含 与 JAR 中每个单独的源文件相关的信息和散列。该选项主要在测试时有用；实际上不应使用它，因为这样将消除有用的优化。
-J[javaoption] 将指定的 javaoption 串直接传递到 Java 解释器。(（jarsigner 实际上是解释器的一个 “wrapper”）。该选项不应含有任何空格。它有助于调整执行环境或内存使用。要获得可用的解释器选项的清单，可在命令行键入 java -h 或 java -X。

keytool

功能说明：
管理由私钥和认证相关公钥的 X.509 证书链组成的密钥仓库（数据库）。还管理来自可信任实体的证书。
语法：
keytool [ 命令 ]
补充说明：
keytool 是个密钥和证书管理工具。它使用户能够管理自己的公钥/私钥对及相关证书，用于（通过数字签名）自我认证（用户向别的用户/服务认证自己）或数据完整性以及认证服务。它还允许用户储存他们的通信对等者的公钥（以证书形式）。

native2ascii

功能说明：
将含有本地编码字符（既非 Latin1 又非 Unicode 字符）的文件转换为 Unicode 编码字符的文件。
语法：
native2ascii [options] [inputfile [outputfile]]
补充说明：
Java 编译器和其它 Java 工具只能处理含有 Latin-1 和/或 Unicode 编码（udddd 记号）字符的文件。native2ascii 将含有其它字符编码的文件转换成含 Latin-1 和/或 Unicode 编码字符的文件。若省略 outputfile，则使用标准输出设备输出。此外，如果也省略 inputfile，则使用标准输入设备输入。
命令选项
-reverse 执行相反的操作：将含 Latin-1 和/或 Unicode 编码字符的文件转换成含本地编码字符的文件。
-encoding[encoding_name] 指定转换过程使用的编码名称。缺省的编码从系统属性 file.encoding 中得到。

appletviewer 

功能说明：
Java applet 浏览器。appletviewer 命令可在脱离万维网浏览器环境的情况下运行 applet。
语法：
appletviewer [ threads flag ] [ 命令选项 ] urls ...
补充说明：
appletviewer 命令连接到 url 所指向的文档或资源上，并在其自身的窗口中显示文档引用的每个 applet。注意：如果 url 所指向的文档不引用任何带有 OBJECT、EMBED 或 APPLET 标记的 applet，那么 appletviewer 就不做任何事情。
命令选项
-debug 在 Java 调试器 jdb 中启动 appletviewer，使您可以调试文档中的 applet。
-encoding[编码名称] 指定输入 HTML 文件的编码名称。
-J[javaoption] 将 javaoption 字符串作为单个参数传给运行 appletviewer 的 Java 解释器。参数不能含有空格。由多重参数组成的字符串，其中的每个参数都必须以前缀 -J 开头，该前缀以后将被除去。这在调整编译器的执行环境或内存使用时将很有用。

extcheck

功能说明：
extcheck 检测目标 jar 文件与当前安装方式扩展 jar 文件间的版本冲突。
语法：
extcheck [ -verbose ] targetfile.jar
补充说明：
extcheck 实用程序检查指定 Jar 文件的标题和版本与 JDK TM 软件中所安装的扩展是否有冲突。在安装某个扩展前，可以用该实用程序查看是否已安装了该扩展的相同版本或更高的版本。
extcheck 实用程序将 targetfile.jar 文件清单的 specification-title 和 specification-version 头与当前安装在扩展目录下所有 Jar 文件的相对应的头进行比较（缺省扩展目录为 jre/lib/ext）。extcheck 实用程序比较版本号的方式与 java.lang.Package.isCompatibleWith 方法相同。若未检测到冲突，则返回代码为 0。如果扩展目录中任何一个 jar 文件的清单有相同的 specification-title 和相同的或更新的 specification-version 号，则返回非零错误代码。如果 targetfile.jar 的清单中没有 specification-title 或 specification-version 属性，则同样返回非零错误代码。
命令选项
-verbose 对扩展目录中的 Jar 文件进行检查时，列出文件。此外，还报告目标 jar 文件的清单属性及所有冲突的 jar 文件。

jar

功能说明：
Java归档工具
语法：
jar [ 命令选项 ] [manifest] destination input-file [input-files]
补充说明：
jar工具是个java应用程序，可将多个文件合并为单个JAR归档文件。jar是个多用途的存档及压缩工具，它基于ZIP和ZLIB压缩格式。然而，设计jar的主要目的是便于将java applet或应用程序打包成单个归档文件。将applet或应用程序的组件(.class 文件、图像和声音)合并成单个归档文件时，可以用java代理(如浏览器)在一次HTTP事务处理过程中对它们进行下载，而不是对每个组件都要求一个新连接。这大大缩短了下载时间。jar还能压缩文件，从而进一步提高了下载速度。此外，它允许applet的作者对文件中的各个项进行签名，因而可认证其来源。jar工具的语法基本上与tar命令的语法相同。
命令选项
-c 在标准输出上创建新归档或空归档。
-t 在标准输出上列出内容表。
-x[file] 从标准输入提取所有文件，或只提取指定的文件。如果省略了file，则提取所有文件；否则只提取指定文件。
-f 第二个参数指定要处理的jar文件。在-c(创建)情形中，第二个参数指的是要创建的jar文件的名称(不是在标准输出上)。在-t(表(或-x(抽取)这两种情形中，第二个参数指定要列出或抽取的jar文件。
　 -v 在标准错误输出设备上生成长格式的输出结果。
-m 包括指定的现有清单文件中的清单信息。用法举例：“jar cmf myManifestFile myJarFile *.class”
-0 只储存，不进行 ZIP 压缩。
-M 不创建项目的清单文件。
-u 通过添加文件或更改清单来更新现有的 JAR 文件。例如：“jar -uf foo.jar foo.class”将文件 foo.class 添加到现有的JAR文件foo.jar中，而“jar umf manifest foo.jar”则用manifest中的信息更新foo.jar的清单。
-C 在执行 jar 命令期间更改目录。例如：“jar -uf foo.jar -C classes * ”将classes目录内的所有文件加到foo.jar中，但不添加类目录本身。
程序示例
1:将当前目录下所有CLASS文件打包成新的JAR文件：
jar cf file.jar *.class
2:显示一个JAR文件中的文件列表
jar tf file.jar
3:将当前目录下的所有文件增加到一个已经存在的JAR文件中
jar cvf file.jar *

javadoc

功能说明
Java API文档生成器从Java源文件生成API文档HTML页。
语法：
javadoc [ 命令选项 ] [ 包名 ] [ 源文件名 ] [ @files ]
其中[ 包名 ]为用空格分隔的一系列包的名字，包名不允许使用通配符，如（*）。[ 源文件名 ]为用空格分隔的一系列的源文件名，源文件名可包括路径和通配符，如（*）。[ @files ]是以任何次序包含包名和源文件的一个或多个文件。
补充说明
Javadoc解析Java源文件中的声明和文档注释，并产生相应的HTML页缺省），描述公有类、保护类、内部类、接口、构造函数、方法和域。
在实现时，Javadoc要求且依赖于java编译器完成其工作。Javadoc调用部分javac编译声明部分，忽略成员实现。它建立类的内容丰富的内部表示，包括类层次和“使用”关系，然后从中生成HTML。Javadoc还从源代码的文档注释中获得用户提供的文档。
当Javadoc建立其内部文档结构时，它将加载所有引用的类。由于这一点，Javadoc必须能查找到所有引用的类，包括引导类、扩展类和用户类。
命令选项
-overview i>path/filename 指定javadoc应该从path/filename所指定的“源”文件中获取概述文档，并将它放到概述页中（overview-summary.html）。其中path/filename 是相对于-sourcepath的相对路径名。
-public 只显示公有类及成员。
-protected 只显示受保护的和公有的类及成员。这是缺省状态。
-package 只显示包、受保护的和公有的类及成员。
-private 显示所有类和成员。
-help 显示联机帮助，它将列出这些javadoc和doclet命令行选项。
-doclet class 指定启动用于生成文档的docle 的类文件。该doclet定义了输出的内容和格式。如果未使用-doclet选项，则javadoc使用标准doclet生成缺省HTML格式。该类必须包含start(Root)法。该启动类的路径由 -docletpath选项定义。
-docletpath classpathlist 指定doclet类文件的路径，该类文件用-doclet选项指定。如果doclet已位于搜索路径中，则没有必要使用该选项。
-1.1 生成具有用Javadoc 1.1生成的文档的外观和功能的文档。也就是说，页的背景为灰色，用图像做页眉，使用bullet列表而不是表格，具有单层目的目录结构，不包含继承 API，不使?*** TML框架，并且不支持内部类。该选项还自动将索引分割成每个字母一个文件。如果想要这种外观，则该选项比javadoc 1.1优越之处等于修正了一些错误。
-sourcepath sourcepathlist
当将包名传递到javadoc命令中时，指定定位源文件（.java）的搜索路径。注意只有当用 javadoc命令指定包名时才能使用sourcepath选项 -- 它将不会查找传递到javadoc命令中的.java文件。如果省略-sourcepath，则javadoc使用类路径查找源文件。
-classpath classpathlist 指定javadoc将在其中查找引用类的路径 -- 引用类是指带文档的类加上它们引用的任何类。Javadoc将搜索指定路径的所有子目录。classpathlist可以包括多个路径，彼此用逗号分隔。
-bootclasspath classpathlist 指定自举类所在路径。它们名义上是Java平台类。这个bootclasspath是Javadoc将用来查找源文件和类文件的搜索路径的一部分。在 classpathlist中用冒号（:）分隔目录。
-extdirs dirlist 指定扩展类所在的目录。它们是任何使用Java扩展机制的类。这个 extdirs是Javadoc将用来查找源文件和在文件的搜索路径的一部分。在dirlist中用冒号（:）分隔目录。
-verbose 在javadoc运行时提供更详细的信息。不使用verbose选项时，将显示加载源文件、生成文档（每个源文件一条信息）和排序的信息。verbose选项导致打印额外的信息，指定解析每个java源文件的毫秒数。
-locale language_country_variant 指定javadoc在生成文档时使用的环境。
-encoding name 指定源文件编码名，例如EUCJIS/SJIS。如果未指定该选项，则使用平台缺省转换器。
-J[flag] 将flag直接传递给运行javadoc的运行时系统java。注意在J和flag之间不能有空格。
标准 Doclet 提供的选项
-d directory 指定javadoc保存生成的HTML件的目的目录。省略该选项将导致把文件保存到当前目录中。其中directory可以是绝对路径或相对当前工作目录的相对路径。
-use 对每个带文档类和包包括一个“用法”页。该页描述使用给定类或包的任何 API 的包、类、方法、构造函数和域。对于给定类 C，使用类 C 的任何东西将包括 C 的子类、声明为 C 的域、返回 C 的方法以及具有 C 类型参数的方法和构造函数。
-version 在生成文档中包括 @version 文本。缺省地将省略该文本。
-author 在生成文档中包括 @author 文本。
-splitindex 将索引文件按字母分割成多个文件，每个字母一个文件，再加上一个包含所有以非字母字符开头的索引项的文件。
-windowtitle[title] 指定放入 HTML <title> 标记中的标题。它将出现在窗口标题栏中和为该页创建的任何浏览器书签（最喜爱的位置）中。该标题不应该包含任何 HTML 标记，因为浏览器将不能正确解释它们。在 title 中的任何内部引号必须转义。如果省略

-windowtitle，则 Javadoc 对该选项使用 -doctitle 的值。
-doctitle[title] 指定放置在靠近概述概览文件顶部的标题。该标题将作为一级标题，居中地直接放在导航栏下面。title 可包含 html 标记和空格，但是如果这样，则必须用引号将它括起。在 title 中的任何内部引号必须转义。
-title[title] 该选项不再存在。它仅存在于 Javadoc 1.2 的 Beta 版中。它已重命名为 -doctitle。重命名该选项是为了更清楚地表示它定义文档标题而不是窗口标题。
-header[header] 指定放置在每个输出文件顶部的页眉文本。该页眉将放在上部导航栏的右边。header 可包含 HTML 标记和空格，但是如果这样则必须用引号将它括起。在 header 中的任何内部引号必须转义。
-footer[footer] 指定放置在每个输出文件底部的脚注文本。脚本将放置在下部导航栏的右边。footer 可包含 html 标记和空格，但是如果这样，则必须用引号将它括起。在 footer 中的任何内部引号必须转义。
-bottom[text] 指定放置在每个输出文件底部的文本。该文本将放置在页底，位于下部导航栏的下面。其中 text 可包含 HTML 标记和空格，但是如果这样，则必须用引号将它括起。在 text 中的任何内部引号必须转义。
-link[docURL] 创建链接指向已用 javadoc-生成的外部引用类的文档。参数 docURL是想要链接到的 javadoc-生成的外部文档的 URL。该位置可以是相对的或绝对的 URL。
-linkoffline[docURL][packagelistURL] 该选项为外部引用类名字创建指向文档的链接。
-group[groupheading]packagepattern:packagepattern:... 将概述页上的包分成指定的组，每组一个表格。用不同的 -group 选项指定每个组。各组按命令行中指定的次序出现在页面上。组内的包按字母排序。对于给定 -group 选项，与 packagepattern 表达式列表匹配的包出现在标题为 groupheading 的表格中。
-nodeprecated 防止在文档中生成任何不鼓励使用的 API。它执行-nodeprecatedlist 所做的事情，并且它不在文档其余部分生成任何不鼓励使用的 API。当编写代码并不想被不鼓励使用的代码分心时，这是非常有用的。
-nodeprecatedlist 防止在生成文件中包含不鼓励使用的 API 列表（deprecated-list.html）并防止在导航栏中包含该页的链接。（但是，javadoc 继续在文档其余部分生成不鼓励使用的 API。） 如果源代码未包含不鼓励使用的 API，并且想要导航栏更干净，则它是非常有用的。
-notree 在生成文档中忽略类/接口层次。缺省地，将产生该层次。
-noindex 在生成文档中忽略索引。缺省地，将产生索引。
-nohelp 在输出的每页顶部和底部的导航栏中忽略“帮助”链接。
-nonavbar 防止产生导航栏、页眉和脚注，否则它们将出现在生成页的顶部和底部。它对“bottom”选项没有影响。当只对内容感兴趣并且没有必要导航时，例如仅将文件转换成 Postscript_ 或 PDF 以进行打印，-nonavbar 选项是非常有用的。
-helpfile[path/filename] 指定顶部和底部导航栏中“帮助”链接所链接到的替代帮助文件 path/filename 的路径。不使用该选项时，Javadoc 自动创建帮助文件 help-doc.html，它在 Javadoc 中硬编码。该选项使得可覆盖这种缺省情况。其中 filename 可以是任何名字，不局限于 help-doc.html -- Javadoc 将相应调整导航栏中的链接。
-stylesheetfile[path/filename] 指定替代 HTML 样式表单文件的路径。不使用该选项时，Javadoc 将自动创建样式表单文件 stylesheet.css，它在 Javadoc 中硬编码。该选项使得可覆盖这种缺省情况。其中 filename 可以是任何名字，不局限于 stylesheet.css。
-docencoding[name] 指定输出 HTML 文件的编码方式。

javah

功能说明：
C 头文件和 Stub 文件生成器。javah 从 Java 类生成 C 头文件和 C 源文件。这些文件提供了连接胶合，使 Java 和 C 代码可进行交互。
语法：
javah [ 命令选项 ] fully-qualified-classname. . .
javah_g [ 命令选项 ] fully-qualified-classname. . .
补充说明：
javah 生成实现本地方法所需的 C 头文件和源文件。C 程序用生成的头文件和源文件在本地源代码中引用某一对象的实例变量。.h 文件含有一个 struct 定义，该定义的布局与相应类的布局平行。该 struct 中的域对应于类中的实例变量。
头文件名以及在头文件中所声明的结构名都来源于类名。如果传给 javah 的类是在某个包中，则头文件名和结构名前都要冠以该包名。下划线 ( _ ) 用作名称分隔符。
缺省情况下，javah 为每个在命令行中列出的类都创建一个头文件，且将该文件放在当前目录中。用 -stubs 选项创建源文件。用 -o 选项将所有列出类的结果串接成一个单一文件。
缺省情况下，javah 为每个在命令行中列出的类都创建一个头文件，且将该文件放在当前目录中。用 -stubs 选项创建源文件。用 -o 选项将所有列出类的结果串接成一个单一文件。
命令选项
-o[输出文件] 将命令行中列出的所有类的头文件或源文件串接到输出文件中。-o 或 -d 两个选项只能选择一个。
-d[目录] 设置 javah 保存头文件或 stub 文件的目录。-d 或 -o 两个选项只能选择一个。
-stubs 使 javah 从 Java 对象文件生成 C 声明。
-verbose 指明长格式输出，并使 javah 将所生成文件的有关状态的信息输出到标准输出设备中。
-help 输出 javah 用法的帮助信息。
-version 输出 javah 的版本信息。
-jni 使 javah 创建一输出文件，该文件包含 JNI 风格的本地方法函数原型。这是缺省输出，所以 -jni 的使用是可选的。
-classpath[路径] 指定 javah 用来查询类的路径。如果设置了该选项，它将覆盖缺省值或 CLASSPATH 环境变量。目录用冒号分隔。
-bootclasspath[路径] 指定加载自举类所用的路径。缺省情况下，自举类是实现核心 Java 平台的类，位于 jrelib
t.jar 和 jrelibi18n.jar 中。
-old 指定应当生成旧 JDK1.0 风格的头文件。
-force 指定始终写输出文件。

javap

功能说明：
Java 类文件解析器。
语法：
javap [ 命令选项 ] class. . .
补充说明：
javap 命令用于解析类文件。其输出取决于所用的选项。若没有使用选项，javap 将输出传递给它的类的 public 域及方法。javap 将其输出到标准输出设备上。
命令选项
-help 输出 javap 的帮助信息。
-l 输出行及局部变量表。
-b 确保与 JDK 1.1 javap 的向后兼容性。
-public 只显示 public 类及成员。
-protected 只显示 protected 和 public 类及成员。
-package 只显示包、protected 和 public 类及成员。这是缺省设置。
-private 显示所有类和成员。
-J[flag] 直接将 flag 传给运行时系统。
-s 输出内部类型签名。
-c 输出类中各方法的未解析的代码，即构成 Java 字节码的指令。
-verbose 输出堆栈大小、各方法的 locals 及 args 数。
-classpath[路径] 指定 javap 用来查找类的路径。如果设置了该选项，则它将覆盖缺省值或 CLASSPATH 环境变量。目录用冒号分隔。
- bootclasspath[路径] 指定加载自举类所用的路径。缺省情况下，自举类是实现核心 Java 平台的类，位于 jrelib
t.jar 和 jrelibi18n.jar 中。
-extdirs[dirs] 覆盖搜索安装方式扩展的位置。扩展的缺省位置是 jrelibext。 （全文完）

 

关于static

如果你留心观察,会发现,在Java API中, 许多类的方法和常量都声明为static,这是为什么呢？

而我们可以使用classname.method()这样的语法形式使用API中类的方法和常量.

其中method是类的方法.

举个例子：

class MathDemo

{

  double CircleArea;     //声明圆面积变量

  double SquareRoot;    //声明平方根变量

  void showArea(double i)

    {

      CircleArea = Math.PI * i * i;

      System.out.println("Circle Area is: " + CircleArea);

    }

 

  void showSqrt(double i)

    {

      SquareRoot=Math.sqrt(i);

      System.out.println("Square Root is: " + SquareRoot);

    }

 

  public static void main(String args[])

  {

     MathDemo math=new MathDemo();

     math.showArea(6);

     math.showSqrt(9);

  }

}

http://gceclub.sun.com.cn/Java_Docs/html/zh_CN/api/java/lang/Math.html#sqrt(double)

 

若没有使用static关键字,那么使用对象去访问方法或成员变量,这比直接用类去访问方法或成员变量要麻烦,繁琐.

注意上面程序中的Math.PI和Math.sqrt(i)部分,

Math为java.lang包下的一个类,

PI(PI常量就是圆周率)为Math类下的一个静态常量.sqrt()为Math类下的一个静态方法.

正因为方法和常量声明为静态的(static)的,所以可以直接用类去访问方法和常量.

如果这个常量并非是静态的.那么你只能通过如下的方法去访问方法和常量：

Math m=new Math();

m.PI;

m.sqrt(i);

相比之下,你更喜欢哪一种的方式呢？

 

关于Math类,可以参考下列网址:

http://gceclub.sun.com.cn/Java_Docs/html/zh_CN/api/java/lang/Math.html

 

 

 

 

对MathDemo.java的修改

class MathDemo

{

  static double CircleArea;     //声明圆面积变量

  static double SquareRoot;    //声明平方根变量

  static void showArea(double i)

    {

      CircleArea = Math.PI * i * i;

      System.out.println("Circle Area is: " + CircleArea);

    }

  static void showSqrt(double i)

    {

      SquareRoot=Math.sqrt(i);

      System.out.println("Square Root is: " + SquareRoot);

    }

 

  public static void main(String args[])

  {

     showArea(6);

     showSqrt(9);

  }

}

注意这段代码与上面的区别.在方法showArea()和showSqrt(),变量CircleArea和SquareRoot前面都加上了static关键字,

结果是不需要创建MathDemo对象,就可以直接访问这两个方法.

 

可以看出,程序的输出结果是和前面的完全一样的.

 

如果变量CircleArea和SquareRoot前面没有加static,会出什么情况呢?看下图

 

MathDemo.java:7: 无法从静态上下文中引用非静态 变量 CircleArea

 

原因如下：

声明为static的方法有几条限制：

•  仅可以调用其他static方法
• 只能访问static数据   说简单一些就是声明为static的变量
• 不能以任何方式引用this或super

 

 

 

 

关于静态方法的一点思考

举个例子：

class Box

 {

   static double width;

   static double height;

   static double depth;

   Box(double w,double h,double d)

     {

       width=w;

       height=h;

       depth=d;

     }

    static double Volume()

      {

         return width * height * depth;

      }

 }

 

class BoxDemo1

{

  public static void main(String args[])

   {

       double vol;

       vol=Box.Volume();

       System.out.println("Volume is: " + vol);

   }

}

当我编出这个程序时,我首先判断这段程序会出现编译错误(也就是说但使用javac BoxDemo.java这条语句后,就会出现错误).

但是结果是,它可以运行而且有输出.下面是输出结果：

结果是0.0.

我明白了.

在vol=Box.Volume();这条语句中,Box实际上指的是new Box(),即创建了一个对象.

Box()是一个没有参数的构造函数.

构造函数初始化一个对象,并且把类中的所有成员变量(即例子中的变量width、height、depth)自动初始化为0.

也就是得到这样的结果：

width = height = depth =0;

所以当调用静态方法Volume()时,返回的三个变量相乘的结果是0.0

自然输出也就是0.0了.

这时候显式声明的构造函数就不起作用.

显式的构造函数就是例子中的

Box(double w,double h,double d)

{

. . .

}

部分.

如果想得到一个非0的结果,可以这样做：

Box mybox = new Box(10,20,15);

mybox.Volume();

 

第一个简短的包示例 

 

 

package MyPack;

 

class Balance

{

  String name;

  double bal;

  Balance(String n,double b)

  {

    name=n;

    bal=b;

  }

  void show()

  {

    if(bal<0)

     System.out.println("-->");

     System.out.println(name + ": $" + bal);

  }

}

 

 

class AccountBalance

{

  public static void main(String args[])

   {

     Balance current[]=new Balance[3];

     current[0]=new Balance("K.J.Fielding",123.23);

     current[1]=new Balance("Will Tell",157.02);

     current[2]=new Balance("Tom Jackson",-12.33);

     for(int i=0;i<3;i++) current[i].show();

   }

}

 

javac -classpath C:/MyPack AccountBalance.java

-classpath设置类文件的存放路径.在这里是C:/MyPack.  

MyPack就是程序中自定义的包名.

在执行下面的java命令前,先使用cd/重新转到C盘.

java MyPack.AccountBalance

在这里,使用包名.类名的形式.

java命令后面跟着的是class类文件名(即后缀名为.class的文件).

MyPack是一个包目录,里面有这两个class文件.

在这里,类AccountBalance和Balance是在MyPack包中的.

当使用java MyPack.AccountBalance这条命令时,意思是说执行MyPack包中的名称为AccountBalance的类文件.

而这里MyPack包具体就是MyPack文件夹.

 

程序的正确输出结果如下图所示：

 

如果在使用java命令前不转到C盘,那么会出现下面的错误：

Exception in thread "main" java.lang.NoClassDefFoundError: MyPack/AccountBalance

 

 

 

 

 

 

 

对第一个包示例的改变

 

 

现在我对上面的程序做一个小小的改变：

在C盘新建一个AccountBalance.java的记事本文档.

复制下面的代码：

import MyPack.Balance;

class AccountBalance

{

  public static void main(String args[])

   {

     Balance current[]=new Balance[3];

     current[0]=new Balance("K.J.Fielding",123.23);

     current[1]=new Balance("Will Tell",157.02);

     current[2]=new Balance("Tom Jackson",-12.33);

     for(int i=0;i<3;i++) current[i].show();

   }

}

 

 

 

在MyPack文件夹中(如果删除了请重新新建一个即可)新建一个Balance.java的记事本文档.

复制下面的代码：

package MyPack;

 

public class Balance

{

  String name;

  double bal;

  public Balance(String n,double b)

  {

    name=n;

    bal=b;

  }

  public void show()

  {

    if(bal<0)

     System.out.println("-->");

     System.out.println(name + ": $" + bal);

  }

}

 

首先Balance类是自定义包MyPack下的一个类,

所以如果想要使用Balance类来创建对象,就必须导入这个类.

语句import MyPack.Balance;的作用就是导入Balance类.

import语句的一般形式：

import pkg1[.pkg2].(classname | *);

pkg1和pkg2是包名,它们可以创建包的层次.

classname | *的含义是显式指定类名或者导入包中的所有类.

import不仅可以导入自定义的包(如程序中的MyPack包),也可以导入Java API中的包.

Java API中的包是已经定义好的,可以直接使用的包.这些定义的工作是由软件来实现的.

 

改变的Balance.java中的类Balance,构造函数Balance(),以及show()方法都使用public方法,为什么呢？ 

先来看看没有加public 产生的结果：

 

 

 

这是在Balance类的声明前面加了public后的结果：

 

 

在Java中有4个访问限定符：public (公有), protected (保护) , private (私有) 和package (包).

其中, package (包)访问限定符是默认的限定符,

当一个成员(类,变量,常量,方法)声明的前面没有加任何限定符(public , protected , private中的任何一个)时,就是默认的访问限定符.

例如,前面程序中,在类AccountBalance的声明前面并没有加任何限定符.

 

类AccountBalance的前面并没有加任何限定符,所以它的访问级别是包.

在AccountBalance.java中,并没有定义任何包,所以类AccountBalance会被放入一个默认的包中,而这个包是没有名字的.

 

同样的,如果Balance类前面没有加public限定符,那么就是包访问级别.

这也就意味着只有同一个包中的类可以访问Balance类.

上图中的"AccountBalance.java:1: MyPack.Balance在MyPack中不是公共的;无法从外部软件包中对其进行访问"这一句说的正是这个意思.

 

同样的,构造函数Balance()和show()方法,如果没有加public限定符,也就是包访问级别.

这也意味着只有同一个包中的类可以访问构造函数和show()方法.

如果构造函数和show()方法被声明为private的, 那么构造函数和show()方法仅仅针对Balance类是可见的.即使是同一包中的类,也不可能访问.

上图中的" AccountBalance.java:7: Balance(java.lang.String,double)在MyPack.Balance中不是公共的;无法从外部软件包中对其进行访问"

和 "AccountBalance.java:10: show()在MyPack.Balance中不是公共的;无法从外部软件包中对其进行访问"

这两句说的正是这个意思.

 

 

 

 

 最后一点,事实上,一个类仅有2种访问级别：默认 和 public

 

 

 

 

运行

 

进入命令提示符,输入cd/转到C盘,接着输入javac AccountBalance.java ,

这时会在C盘和MyPack文件夹中分别形成两个AccountBalance.class和Balance.class的类文件.

 

 

 

 

 

,最后输入java AccountBalance.   程序的输出结果如下图所示：

 

 

 

 

 

关于接口

 

在接口中定义的方法实际上是抽象方法.

在接口中定义的方法return-type method-name(parameter-list);实际上是抽象方法,

它可以表示成如下的形式：

abstract return-type method-name(parameter-list);

而在接口中定义的方法是可以省略abstract关键字的.

在抽象类(在类声明前面加abstract的类)中的抽象方法是不能省略这个关键字的.

 

接口与抽象类(抽象类不能创建对象,也就是说不能通过new来创建对象)是相似的,它们都是抽象的机制,

所不同的是,一个类可以实现任意数目的接口,而只能一个超类(在这里的超类指抽象类)

接口基本上等同于抽象类,但是接口的范围更广泛.

 

在Java中,不支持多重继承,即多个父类,一个子类(n对1)的情况.

只可以有一个父类,一个子类(1对1)或者一个父类,多个子类(1对n)的情况.  (在C++中是支持多重继承的)

 

可以说,接口实际上是多重继承的另外一种方式

把接口看作抽象类,一个类可以有多个接口,也就是可以有多个超类(或称父类)

举个例子：

import static java.lang.Math.PI;

interface Area

{

  double area(double a);

  double area(double a,double b);

  double area(double a,double b,double c);

}

class AreaDemo  implements Area

{

   public double area(double a)

       {

          return  PI *a *a;

       }

   public double area(double a,double b)

     {

        return  a*b;

     }

   public double area(double a,double b,double c)

     {

        return  (a + b) * c / 2.0;

     }

   public static void main(String args[])

    {

      AreaDemo ad=new AreaDemo();

      System.out.println("圆的面积是：");

      System.out.println(ad.area(3));

 

      System.out.println("矩形的面积是：");

      System.out.println(ad.area(3,4));

 

      System.out.println("梯形的面积是：");

      System.out.println(ad.area(3,4,5));

    }

}

 

 

 

值的注意的是,在C盘形成了两个class类文件,其中 一个是Area.class

也就是说,接口在被转化编译后,是以类文件的形式来实现它.

 

 

 

如果将上面程序中的红色部分的public都去除,那么出现的错误如下图所示：

 

AreaDemo.java:18: AreaDemo 中的 area(double,double,double) 无法实现 Area 中的 area(double,double,double)；正在尝试指定更低的访问权限；为 public

 

 

 

抽象类的原则

▲   包含一个或多个抽象方法的类必须被声明为抽象的

     声明一个抽象类的方法：在class前加abstract关键字

 

▲   抽象类不能有对象,即一个抽象类不能通过new直接实例化.这样的对象是无用的.

     可以声明抽象类的变量.

▲   不能声明抽象构造函数或抽象静态方法

▲   所有抽象类的子类都必须实现超类中的所有抽象方法或者本身也声明为abstract

 

 

重载和方法重写的区别

▲   重载要求(方法的)参数的数据类型或个数中有一个不同即可.并且返回类型对重载没有影响.

方法重写要求参数的数据类型和个数均相同.并且返回类型也要相同.

▲   重载针对单个类而言

     方法重写发生在继承中(子类中的方法覆盖超类中的同名方法)

▲   重载只适用于方法

     重写也可以是成员变量的重写

▲   也可以重载构造函数

     方法重写只针对方法,但不包括构造函数.

 

相同点

要求方法的名称相同

 

继承

继承是作用于类的外部。它是类与类之间进行信息交流的手段.

 

 

继承的原则

▲   超类变量可以引用子类对象,此变量仅能访问被子类继承的成员,不能访问由子类自己定义的成员.

    下面的原则证明了这点.

▲   每个子类都有与父类不同的专有(或者说惟一)的属性,而父类是不知道这些专有属性的,即使是引用子类对象.

     超类不知道子类添加了什么

▲   super

super()总是引用调用类之上的直接超类的构造函数.即使在多层次中也是如此.

super()必须永远是子类构造函数内所执行的第一条语句.

super.member

member可以是方法,也可以是实例变量.

这种形式的super多用于超类成员被子类中同名的成员隐藏的情况(用于方法重写中.子类的成员覆盖父类中的同名成员)

这种形式可以用来调用被隐藏的成员(即父类的成员)

▲   超类将成员(private和构造函数除外)复制给子类,使子类拥有这些成员,并且可以通过子类对象直接使用这些成员.

▲   在Java中,不支持多个超类到单个子类的继承.这种形式的继承被称为多重继承.

     一个子类可以是另一个类的超类.

▲   在一个类层次中,构造函数按派生顺序,即从超类到子类的顺序被调用

不管是否使用了super(),这个顺序是不变的