ja

配置Java环境安装eclipse方法步骤如下：1首先需要安装JDK。一步一步来就行。注意选择安装路径，或者是默认路径即可。2接下来进行Java环境变量配置。右击"计算机"，选择"属性"，在弹出的窗口中选择"高级系统设置"3.在弹出的"系统属性"窗口中的"高级"选项卡下，选择"环境变量"4.在弹出的"环境变量"窗口中，在"系统变量(S)"中设置3项属性，分别为：JAVA_HOME,PATH,CLASSPATH(大小写无所谓)，若已存在则点击"编辑"，不存在则点击"新建"。新建(JAVA_HOME)变量名：JAVA_HOME变量值：E:Program Files (x86)Javajdk1.7.0(该目录为JDK安装的路径，此路径下包括lib,bin,jre等文件夹)编辑(CLASSPATH)，若没有该变量则需新建；CLASSPATH为java加载类(class or lib)路径，只有类在classpath中，java命令才能识别变量名：CLASSPATH变量值：%JAVA_HOME%libdt.jar;%JAVA_HOME%lib ools.jar;(注：该变量值置于CLASSPATH即可；其中，变量值最后要加";")编辑(PATH),若没有该变量则需新建；PATH使得系统可在任何路径下识别JAVA命令。变量名：PATH变量值：.;%JAVA_HOME%in; (注：该变量值置于现有PATH值的前面)4检测是否安装成功：打开cmd，输入java——enter。出现Java的一些说明。安装成功。5安装Eclipse。将下载的文件解压，打开Eclipse.exe,直接可以运行。注意：JDK版本要和Eclipse一样。要不然不能打开：出现“Failed to load the JNI shared library”。那就要重新下载相对应的版本。

进行eclipse可视化java界面设计步骤如下：一、先新建一个普通的java工程。二、为这个java工程添加有可视化界面的java类，选择新建中的other选项。三、找到windows build里的jFrame，即主界面，进行新建有界面的java。四、点击Design进入可视化编辑界面、

点file new一个java project 。再点出现的项目。new 一个 package ，（这一步可以不要），③new一个class文件。可以了

用Eclipse快捷键编写第一个Java程序HelloWorldhttp://jingyan.baidu.com/article/c33e3f4884a832ea14cbb55b.html

1.在官网中下载Java，安装JDK。2.设置环境变量：（1）选中“我的电脑”，右键选中“属性”，弹出对话框如图所示：（2）选中对话框左边的“高级系统设置”，弹出对话框如图所示：（3）选中“环境变量”，弹出对话框如图所示：（4）我们先打开电脑找到自己保存Java文件的文件夹进入到JDK文件夹（系统默认为c:ProgramFilejavajdk.80）复制链接，然后从上图中我们可以看到“系统变量”，在“系统变量”里点击“新建”，我们新建一个变量名为“JAVA_HOME”的新变量（建立这个变量是为了方便运行环境的设置），然后在变量值中粘贴我们复制的链接，点击“确定”，“JAVA_HOME”的变量就设置好了，如图所示。（5）接着我们来设置Java的运行环境，在系统变量框里面找到一个名为“Path”的变量，接着进入JDK文件夹找到bin文件夹进入复制链接然后粘贴在“path”变量值的前面，正常的步骤就是这样的，但是刚刚我们新建的“JAVA_HOME”的变量不是白建立的，我们只需要在“path”的变量值最前面输入%JAVA_HOME%in;就可以了（注意：不论是正常方法还是快捷方法都要在bin后面加分号），点击确定-->确定-->确定，Java的运行环境就设置好了，如图所示。3.验证Java运行环境设置成功的方法是用命令语句来运行Java和Javac（Java的编译器）。（1）打开菜单，在搜索中输入cmd,弹出命令框，如图所示。（2）输入命令Javac和Java，出现如图所示的一大串字符即为设置成功。eclipse的安装和设置1.eclipse是编程的基本软件，eclipse工作也需要设置工作环境，先下载eclipse软件，安装好。（未设置工作环境或者没有安装Java软件是打不开eclipse的）2.右键单击“我的电脑”，找到“属性”，打开属性框，找到“高级系统设置”点击进去，找到“环境变量”点击，步骤如上。3.在“系统变量”里面新建一个变量名为“CLASSPATH”(告诉系统字节码（Java运行原理：源代码-->字节码）在哪里)的变量名，变量值为：.；%JAVA_HOME%jrelib；%JAVA_HOME%lib（.表示先在当前目录下寻找）。4.打开eclipse软件，如果打得开则设置成功。Eclipse 是一个开放源代码的、基于Java的可扩展开发平台。就其本身而言，它只是一个框架和一组服务，用于通过插件组件构建开发环境。幸运的是，Eclipse 附带了一个标准的插件集，包括Java开发工具（Java Development Kit，JDK）。

新建java项目即可

1、先打开自己电脑上的Eclipse程序2、打开Eclipse的“Package Explorer”界面：选择菜单栏中的【File->new->Java Project】，进入创建java Project界面，在此界面需要填写项目的名称后，点击下边的“Finish”按钮，即可完成创建。3、我们可以看到项目中有一个"src"包，可以在src下面，根据自己项目的结构创建包【选中src，右键选择new -->package】4、创建完包后，我们可以创建一个class文件来写代码了~【选中一个package，右键选择new-->class】，填写类名后，点击finish按钮。5、已经创建好一个java项目、包、类了，可以开始编写相应的实现代码了~

smooth criminal？这是犯罪高手，不明白你什么意思，应该是吧..

1、首先打开eclipse软件。2、点击“File"，再选择“New”，然后点击“Java Project”。3、在此输入项目名称。4、点击“Finish”。5、然后在左侧，找到并双击刚刚创建的项目。6、选中“src”。7、点击如图的按钮，新建一个包。8、输入包的名字，并点击“Finish”。9、再点击“C+”图标，新建class。10、输入class文件名，并点击“Finish”。11、这样Java应用程序就新建好了。拓展资料：Eclipse是著名的跨平台的自由集成开发环境(IDE)。最初主要用来Java语言开发，通过安装不同的插件Eclipse可以支持不同的计算机语言，比如C++和Python等开发工具。Eclipse的本身只是一个框架平台，但是众多插件的支持使得Eclipse拥有其他功能相对固定的IDE软件很难具有的灵活性。许多软件开发商以Eclipse为框架开发自己的IDE。Eclipse 最初由OTI和IBM两家公司的IDE产品开发组创建，起始于1999年4月。IBM提供了最初的Eclipse代码基础，包括Platform、JDT 和PDE。Eclipse项目IBM发起，围绕着Eclipse项目已经发展成为了一个庞大的Eclipse联盟，有150多家软件公司参与到Eclipse项目中，其中包括Borland、Rational Software、Red Hat及Sybase等。Eclipse是一个开放源码项目，它其实是Visual Age for Java的替代品，其界面跟先前的Visual Age for Java差不多，但由于其开放源码，任何人都可以免费得到，并可以在此基础上开发各自的插件，因此越来越受人们关注。

首先是搭建Java开发环境，先要安装JDK，然后配置环境变量，之后安装eclipse。完成之后就可以编写Java程序了。搭建完成后打开eclipse，界面如图。下面就开始新建Java工程。点击File——New——Java Project。输入工程名以“HelloWorld”为例，点击下一步在出现的对话框中选择完成，结束右击工程名称下面的src文件夹。点击New——Class。在对话框输入类名，注意名称要与工程名称一致！之后点击完成。编写代码。编译运行程序，点击工具栏里的绿点。运行程序，运行结果在下面的小框里显示。也可以直接按F11，编译并运行程序。

1、百度一下“eclipse”，去官网下载eclipse，这里下载的是Eclipse IDE for Java Developers，一般是zip文件。2、百度一下“jdk”，去官网（一般是第一个）下载jdk，一般就下载最新版的3、准备工作完成后，接下来就是安装软件。先安装jdk，如下图所示，安装过程就不详述了。记下这个路径，后面要用。4、解压下载的eclipse文件，不需要安装，解压到自定义的目录就行。5、首次打开eclipse.exe，设置工作空间，建议最好不要放在c盘6、打开eclipse后，在Window-->Preferences-->Java-->Installed JREs。看路径是不是和安装的jdk路径一致(第3步骤中记住的那个路径)。7、把eclipse中Java编译器版本改成最大，在Window-->Preferences-->Java-->Compiler。8、为了防止在以后的开发中，出现打个空格却变成了小黑点什么的怪象，把eclipse中，展开Window-->Preferences-->General-->Editors-->Text Editors去掉Show whitespace characters前面的钩。9、到这里windows下eclipse+java开发环境就配置好了

141116和洪万吃饭的时候，两个忙内因为包肉吵起来是李东旭说的

　　工具/原料　　Eclipse　　方法/步骤依次选择file--New--Project选项选择java——>java project在Project name后输入工程名new——>packageNew——>Class以上步骤全部完成后，就可以开始编写程序了。

单击File-----new----project,打开如下对话框，选择Java-----project,如下图：单击next，会看到下图，在project名称中输入 一个名字 如ddChap1单击Finish，即完成一个java工程的创建。

1.在官网中下载Java，安装JDK。2.设置环境变量：（1）选中“我的电脑”，右键选中“属性”，弹出对话框如图所示：（2）选中对话框左边的“高级系统设置”，弹出对话框如图所示：（3）选中“环境变量”，弹出对话框如图所示：（4）我们先打开电脑找到自己保存Java文件的文件夹进入到JDK文件夹（系统默认为c:ProgramFilejavajdk.80）复制链接，然后从上图中我们可以看到“系统变量”，在“系统变量”里点击“新建”，我们新建一个变量名为“JAVA_HOME”的新变量（建立这个变量是为了方便运行环境的设置），然后在变量值中粘贴我们复制的链接，点击“确定”，“JAVA_HOME”的变量就设置好了，如图所示。（5）接着我们来设置Java的运行环境，在系统变量框里面找到一个名为“Path”的变量，接着进入JDK文件夹找到bin文件夹进入复制链接然后粘贴在“path”变量值的前面，正常的步骤就是这样的，但是刚刚我们新建的“JAVA_HOME”的变量不是白建立的，我们只需要在“path”的变量值最前面输入%JAVA_HOME%in;就可以了（注意：不论是正常方法还是快捷方法都要在bin后面加分号），点击确定-->确定-->确定，Java的运行环境就设置好了，如图所示。3.验证Java运行环境设置成功的方法是用命令语句来运行Java和Javac（Java的编译器）。（1）打开菜单，在搜索中输入cmd,弹出命令框，如图所示。（2）输入命令Javac和Java，出现如图所示的一大串字符即为设置成功。eclipse的安装和设置1.eclipse是编程的基本软件，eclipse工作也需要设置工作环境，先下载eclipse软件，安装好。（未设置工作环境或者没有安装Java软件是打不开eclipse的）2.右键单击“我的电脑”，找到“属性”，打开属性框，找到“高级系统设置”点击进去，找到“环境变量”点击，步骤如上。3.在“系统变量”里面新建一个变量名为“CLASSPATH”(告诉系统字节码（Java运行原理：源代码-->字节码）在哪里)的变量名，变量值为：.；%JAVA_HOME%jrelib；%JAVA_HOME%lib（.表示先在当前目录下寻找）。4.打开eclipse软件，如果打得开则设置成功。Eclipse 是一个开放源代码的、基于Java的可扩展开发平台。就其本身而言，它只是一个框架和一组服务，用于通过插件组件构建开发环境。幸运的是，Eclipse 附带了一个标准的插件集，包括Java开发工具（Java Development Kit，JDK）。

把歌词打在百度搜索条上，应该就会有了。

dancer

desedekeyspec是一个类。即：public class DESedeKeySpecextends Objectimplements KeySpec此类指定一个 DES-EDE ("triple-DES") 密钥。构造方法：DESedeKeySpec(byte[] key) 创建一个 DESedeKeySpec 对象，使用 key 中的前 24 个字节作为 DES-EDE 密钥的密钥内容。 DESedeKeySpec(byte[] key, int offset) 创建一个 DESedeKeySpec 对象，使用 key 中始于且包含 offset 的前 24 个字节作为 DES-EDE 密钥的密钥内容。

我是他的歌迷，找到的翻译 Trouble is her only friend,麻烦是她唯一的朋友and he"s back again她又回来了Makes her body older than it really is她看起来比她实际年龄还要老And she says it"s high time she went away,她说这是她走的时候了no one"s got much to say in this town这小镇的人没话可说Trouble is the only way is down, down down麻烦是唯一的出路As strong as you were, tender you go因为过去你坚强,现在你变得软弱了I"m watching you breathing, for the last time我最后一次看你呼吸了A song for your heart, but when it is quiet,为你的心而作的歌曲,但安静的时候I know what it means and I"ll carry you home,我明白它的意思,我会带你回家I"ll carry you home.我会带你回家If she had wings she would fly away如果她有翅膀,她会飞走了and another day God will give her some某天上帝又会给她一些Trouble is the only way is down, down down.麻烦是唯一出路As strong as you were, tender you go因为过去你坚强,现在你变得软弱了I"m watching you breathing, for the last time我最后一次看你呼吸了A song for your heart, but when it is quiet,为你的心而作的歌曲,但安静的时候I know what it means and I"ll carry you home,我明白它的意思,我会带你回家I"ll carry you home.我会带你回家And their all going crazy in New York City at night他们在纽约的夜晚变得放纵And someone"s little girl有人的小女孩was taken from the world to light从这世界走向光明Under the stars and stripes在星空下As strong as you were, tender you go因为过去你坚强,现在你变得软弱了I"m watching you breathing, for the last time我最后一次看你呼吸了A song for your heart, but when it is quiet,为你的心而作的歌曲,但安静的时候I know what it means and I"ll carry you home,我明白它的意思,我会带你回家I"ll carry you home.我会带你回家

日本横滨市神奈川县

Shot like an arrow going through my heartThat"s the pain I feelI feel whenever we"re apartNot to say that I"m in love with youBut who"s to say that I"m notI just know that it feels wrong，When I"m away too longIt makes my body hotSo let me tell ya babyI"ll tell your mamaI"ll tell your friendsI"ll tell anyone whose heart can comprehendSend it in a letter babyTell you on the phoneI"m not the kinda girlWho likes to be aloneI miss ya much （boy-oh-I miss you much）I really miss you much （M-I-S-S you much）I miss ya much （boy-oh-I miss you much）Baby I really miss you much （M-I-S-S you much）I"m rushing homeJust as soon as I canI"m rushing home to seeYour smiling faceAnd feel your warm embraceIt makes f-feel so g-g-g goodSo I"ll tell you babyI"ll tell your mamaI"ll tell your friendsI"ll tell anyone whose heart can comprehendSend it in a letter babyTell you on the phoneI"m not the kinda girlWho likes to be aloneI miss ya much （boy-oh-I miss you much）I really miss you much （M-I-S-S you much）I miss ya much （boy-oh-I miss you much）Baby I really miss you much （M-I-S-S you much）I miss you muchI really really miss you muchI miss you muchI"m not ashamed to tell the worldI miss youI"ll tell your mamaI"ll tell your friendsI"ll tell anyone whose heart can comprehendSend it in a letter babyTell you on the phoneI"m not the kinda girlWho likes to be aloneI miss ya much （boy-oh-I miss you much）I really miss you much （M-I-S-S you much）I miss ya much （boy-oh-I miss you much）Baby I really miss you much （M-I-S-S you much）

歌曲名:The Kiss歌手:Queen专辑:Flash Gordon-Hollywood"The Kiss (Skit)"I"m gonna kill this bitch. I"m gonna kill her. I"m going to fuckin" jail, cause i"m gonna kill this bitch.Yo" man, I don"t know.What?I got a really, really bad feelin" about this.Man, will you shut the fuck up Gary. You"ve always got a bad feeling man. That"s her car right there. Just park.Allright, just let me park. I"m parking!Fuckin", turn the car off dog.Alright.Alright, we wait.We wait for what?We wait until she comes out. Man, i"m gonna fuckin" kill her.Man, you ain"t gonna kill nobody.Man, just shut the fuck up dog.What the fuck did you bring that for?Just shut up, fuckin" clip is empty.Don"t point that shit at me!It"s not even loaded bitch, look!Dude! God I fuckin" hate when you do that shit.Ha ha, ya but it"s funny as fuck.You"re gonna fuck around and kill me one of these days, I swear.It get"s you every time. Is that her?Where?Right there motherfucker.Yeah, fuck.Alright, get up, get up.Here we go again.Get down!What the fuck do you want me to do get under the car?Yo", who"s she walkin" with?How the fuck am I supposed to know? You told me to duck down.It"s the fucking bouncer. Did she just kiss him?I don"t think so.Dog, she just fuckin" kissed him.No, she didn"t!She"s kissing him dog!No she"s not...oh shit.C"mon, motherfucker!MAARRSSHH!!!

首先确认你的电脑已经安装了java。打开我的电脑，在右上角的搜索栏里面输入javaw.exe，然后等待搜索完毕。在搜索出来的列表里找到javaw.exe，在名称下面就是他的所在路径。也就是说一般java路径是C:Program FilesJavajre7injavaw.exe

在内容上，游戏算法机制有所不同导致了有些物品的属性有差。根本区别是基岩版是由C语言编写的，Jave版是Java编写的。

BufferedReader 的缓存开大一点；或者如果确定文件大小，一次性读进一个byte[] 用ByteArrayInputStream 包起来

generate方法中还缺点东西，没有把随机生成出来的letters数组下标所对应的元素，放入chs数组中

jdk的问题啊，重装一个试试

client必须保持长连接，简单说，你的client和server之间的连接是不能断开的，你每次启动client都是直接尝试读取然后断掉链接的话，c1在传输文件的时候，c2的连接已经断掉了，server还如何和c2之间通讯呢？

给你个例子自己看看吧，太多了，不会再问吧123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion><groupId>cn.wasu</groupId><artifactId>wasu_bp_manager</artifactId><version>0.0.1-SNAPSHOT</version><packaging>war</packaging><name>wasu_bp_manager</name><url>http://maven.apache.org</url><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><dubbo_version>3.0.1</dubbo_version><zookeeper_version>3.4.8</zookeeper_version><zkclient_version>0.8</zkclient_version><org.springframework-version>4.2.5.RELEASE</org.springframework-version><slf4j_version>1.7.7</slf4j_version></properties><dependencies><!-- test --><dependency> <groupId>javax</groupId><artifactId>javaee-api</artifactId><version>7.0</version><scope>provided</scope></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.10</version><scope>test</scope></dependency><!-- http --><dependency><groupId>org.apache.httpcomponents</groupId><artifactId>httpclient</artifactId><version>4.3.6</version></dependency><dependency><groupId>org.apache.httpcomponents</groupId><artifactId>httpcore</artifactId><version>4.3.3</version></dependency><dependency><groupId>org.apache.httpcomponents</groupId><artifactId>httpmime</artifactId><version>4.3.6</version></dependency><!-- Spring Framework --><dependency><groupId>org.springframework</groupId><artifactId>spring-expression</artifactId><version>${org.springframework-version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-tx</artifactId><version>${org.springframework-version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context-support</artifactId><version>${org.springframework-version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>${org.springframework-version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>${org.springframework-version}</version><scope>test</scope></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>${org.springframework-version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>${org.springframework-version}</version></dependency><!-- DB --><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.0.2</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.17</version></dependency><!--dependency><groupId>com.oracle</groupId><artifactId>ojdbc14</artifactId><version>10.2.0.5.0</version></dependency--><dependency><groupId>com.oracle</groupId><artifactId>classes12</artifactId><version>10.2.0.5.0</version><scope>system</scope><systemPath>${basedir}/src/main/webapp/WEB-INF/lib/classes12(64).jar</systemPath></dependency><dependency><groupId>net.sourceforge.jexcelapi</groupId><artifactId>jxl</artifactId><version>2.6.12</version></dependency><!-- https://mvnrepository.com/artifact/joda-time/joda-time --><dependency><groupId>joda-time</groupId><artifactId>joda-time</artifactId><version>2.9.4</version><!-- https://mvnrepository.com/artifact/commons-lang/commons-lang --></dependency><dependency><groupId>commons-lang</groupId><artifactId>commons-lang</artifactId><version>2.6</version></dependency><!-- Logging --><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId><version>${slf4j_version}</version></dependency><!-- json --><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.1.39</version></dependency><!-- gson --><dependency><groupId>com.google.code.gson</groupId><artifactId>gson</artifactId><version>2.2.4</version></dependency><!-- beetl模板引擎 --><dependency><groupId>org.beetl</groupId><artifactId>beetl-core</artifactId><version>2.0.11</version></dependency><!-- others --><!-- <dependency><groupId>org.aspectj</groupId><artifactId>aspectjrt</artifactId><version>1.8.6</version></dependency> --><dependency><groupId>org.aspectj</groupId><artifactId>aspectjrt</artifactId><version>1.6.11</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.6.11</version></dependency><dependency><groupId>org.javassist</groupId><artifactId>javassist</artifactId><version>3.18.2-GA</version></dependency><dependency><groupId>commons-fileupload</groupId><artifactId>commons-fileupload</artifactId><version>1.3.1</version></dependency><dependency><groupId>org.apache.poi</groupId><artifactId>poi</artifactId><version>3.10-FINAL</version></dependency><dependency><groupId>org.apache.poi</groupId><artifactId>poi-ooxml</artifactId><version>3.10-beta2</version></dependency><dependency><groupId>org.apache.poi</groupId><artifactId>poi-ooxml-schemas</artifactId><version>3.10-beta2</version></dependency><!-- mybatis --><dependency><groupId>com.github.pagehelper</groupId><artifactId>pagehelper</artifactId><version>3.6.3</version></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.2.6</version></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId><version>1.2.2</version></dependency><!-- redis --><dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>2.8.0</version></dependency><!-- commom jar --><!--dependency><groupId>hzdracom.com</groupId><artifactId>hzdracom_manager_jar</artifactId><version>0.0.1-SNAPSHOT</version></dependency--><dependency><groupId>joda-time</groupId><artifactId>joda-time</artifactId><version>2.1</version></dependency></dependencies><build><finalName>wasu_bp_manager</finalName><plugins><plugin><artifactId>maven-compiler-plugin</artifactId><version>2.3.2</version><configuration><source>1.6</source><target>1.6</target><encoding>UTF-8</encoding><compilerArguments><extdirs>src/main/webapp/WEB-INF/lib</extdirs></compilerArguments></configuration></plugin></plugins><resources><resource><directory>${project.basedir}/src/main/resources</directory><filtering>true</filtering></resource></resources></build></project>

怎样查找MP3音乐链接地址 用于QQ空间背景 请参考我百度空间上的这篇文章，因为百度不能发连接，里面详细地教你怎么找链接，一看就学会了，呵呵，学会了不要忘了采纳哟点我的名字进去以后，再点上面的第二个连接“他的空间”

前面那个吧，因为后面那个名字让人一下子就想到那个明星，第一印象可能以为你是个假小子

有个开源代码托管平台叫github来了解下。GitHub是一个面向开源及私有软件项目的托管平台，因为只支持git作为唯一的版本库格式进行托管，故名GitHub。github也可以是一个远程代码仓库，你可以将你的代码或者项目上传到github仓库，这个完全没有问题，网上有github客户端管理软件，操作非常简单，就类似于：SVN、CVS。github也是一个开源代码协作社区，通过github你可以参与别人的开源项目，也可以让别人参与你的开源项目。有些公司的产品，自己不想投入人力，但又不想放弃，就采用github代码托管的方式，将代码开源出去，让开发爱好者参与进来，其中docker就是一个很好的例子，也是开源最成功的一个项目。下面介绍如何从github上拿到开源项目：zxin。1、打开github官网“，全是英文，要能读懂源代码，需要有很好的英文阅读能力，祝你好运。学JAVA经常听老师说有空去看看源码，也不告诉人家怎么看，该看什么东西。不可能是无脑的把一个开源的项目反编译就这样看吧例如二维码的ZXing开源项目，我想阅读下这个的源码，该怎么看，请大神赐教了，谢谢。

您好！添加计分板scoreboardobjectivesadd英文名字计分板类型["显示名称"]将以上指令的中文更改为想要的文字及类型，如：scoreboardobjectivesaddChinesedummy["中文"]即可添加只能用命令控制的，计分板名称为Chinese，显示名称为中文的计分板了

有个开源代码托管平台叫github来了解下。GitHub是一个面向开源及私有软件项目的托管平台，因为只支持git作为唯一的版本库格式进行托管，故名GitHub。github也可以是一个远程代码仓库，你可以将你的代码或者项目上传到github仓库，这个完全没有问题，网上有github客户端管理软件，操作非常简单，就类似于：SVN、CVS。github也是一个开源代码协作社区，通过github你可以参与别人的开源项目，也可以让别人参与你的开源项目。有些公司的产品，自己不想投入人力，但又不想放弃，就采用github代码托管的方式，将代码开源出去，让开发爱好者参与进来，其中docker就是一个很好的例子，也是开源最成功的一个项目。下面介绍如何从github上拿到开源项目：zxin。1、打开github官网“”。2、根据“zxing”查找。3、下载开源项目：zxing操作：Cloneordowanload->DownloadZIP.这样zxin源代码就拿到了，doc目录是项目文档，打开index.html，全是英文，要能读懂源代码，需要有很好的英文阅读能力，祝你好运。

1、 尽量指定类的final修饰符 带有final修饰符的类是不可派生的。在Java核心API中，有许多应用final的例子，例如java.lang.String。为String类指定final防止了人们覆盖length()方法。另外，如果指定一个类为final，则该类所有的方法都是final。Java编译器会寻找机会内联（inline）所有的final方法（这和具体的编译器实现有关）。此举能够使性能平均提高50% 。2、 尽量重用对象。特别是String 对象的使用中，出现字符串连接情况时应用StringBuffer 代替。由于系统不仅要花时间生成对象，以后可能还需花时间对这些对象进行垃圾回收和处理。因此，生成过多的对象将会给程序的性能带来很大的影响。3、 尽量使用局部变量，调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速度较快。其他变量，如静态变量、实例变量等，都在堆（Heap）中创建，速度较慢。另外，依赖于具体的编译器/JVM，局部变量还可能得到进一步优化。请参见《尽可能使用堆栈变量》。4、 不要重复初始化变量默认情况下，调用类的构造函数时， Java会把变量初始化成确定的值：所有的对象被设置成null，整数变量（byte、short、int、long）设置成0，float和double变量设置成0.0，逻辑值设置成false。当一个类从另一个类派生时，这一点尤其应该注意，因为用new关键词创建一个对象时，构造函数链中的所有构造函数都会被自动调用。5、 在JAVA + ORACLE 的应用系统开发中，java中内嵌的SQL语句尽量使用大写的形式，以减轻ORACLE解析器的解析负担。6、 Java 编程过程中，进行数据库连接、I/O流操作时务必小心，在使用完毕后，即使关闭以释放资源。因为对这些大对象的操作会造成系统大的开销，稍有不慎，会导致严重的后果。7、 由于JVM的有其自身的GC机制，不需要程序开发者的过多考虑，从一定程度上减轻了开发者负担，但同时也遗漏了隐患，过分的创建对象会消耗系统的大量内存，严重时会导致内存泄露，因此，保证过期对象的及时回收具有重要意义。JVM回收垃圾的条件是：对象不在被引用；然而，JVM的GC并非十分的机智，即使对象满足了垃圾回收的条件也不一定会被立即回收。所以，建议我们在对象使用完毕，应手动置成null。8、 在使用同步机制时，应尽量使用方法同步代替代码块同步。9、 尽量减少对变量的重复计算例如：for(int i = 0;i < list.size; i ++) {…}应替换为：for(int i = 0,int len = list.size();i < len; i ++){…}10、尽量采用lazy loading 的策略，即在需要的时候才开始创建。例如： String str = “aaa”;if(i == 1) {list.add(str);}应替换为：if(i == 1) {String str = “aaa”;list.add(str);}11、慎用异常异常对性能不利。抛出异常首先要创建一个新的对象。Throwable接口的构造函数调用名为fillInStackTrace()的本地（Native）方法，fillInStackTrace()方法检查堆栈，收集调用跟踪信息。只要有异常被抛出，VM就必须调整调用堆栈，因为在处理过程中创建了一个新的对象。 异常只能用于错误处理，不应该用来控制程序流程。12、不要在循环中使用：Try {} catch() {}应把其放置在最外层。13、StringBuffer 的使用：StringBuffer表示了可变的、可写的字符串。有三个构造方法 :StringBuffer (); //默认分配16个字符的空间StringBuffer (int size); //分配size个字符的空间StringBuffer (String str); //分配16个字符+str.length()个字符空间你可以通过StringBuffer的构造函数来设定它的初始化容量，这样可以明显地提升性能。这里提到的构造函数是StringBuffer(int length)，length参数表示当前的StringBuffer能保持的字符数量。你也可以使用ensureCapacity(int minimumcapacity)方法在StringBuffer对象创建之后设置它的容量。首先我们看看StringBuffer的缺省行为，然后再找出一条更好的提升性能的途径。StringBuffer在内部维护一个字符数组，当你使用缺省的构造函数来创建StringBuffer对象的时候，因为没有设置初始化字符长度，StringBuffer的容量被初始化为16个字符，也就是说缺省容量就是16个字符。当StringBuffer达到最大容量的时候，它会将自身容量增加到当前的2倍再加2，也就是（2*旧值+2）。如果你使用缺省值，初始化之后接着往里面追加字符，在你追加到第16个字符的时候它会将容量增加到34（2*16+2），当追加到34个字符的时候就会将容量增加到70（2*34+2）。无论何事只要StringBuffer到达它的最大容量它就不得不创建一个新的字符数组然后重新将旧字符和新字符都拷贝一遍――这也太昂贵了点。所以总是给StringBuffer设置一个合理的初始化容量值是错不了的，这样会带来立竿见影的性能增益。StringBuffer初始化过程的调整的作用由此可见一斑。所以，使用一个合适的容量值来初始化StringBuffer永远都是一个最佳的建议。14、合理的使用Java类 java.util.Vector。简单地说，一个Vector就是一个java.lang.Object实例的数组。Vector与数组相似，它的元素可以通过整数形式的索引访问。但是，Vector类型的对象在创建之后，对象的大小能够根据元素的增加或者删除而扩展、缩小。请考虑下面这个向Vector加入元素的例子：Object bj = new Object();Vector v = new Vector(100000);for(int I=0;I<100000; I++) { v.add(0,obj); }除非有绝对充足的理由要求每次都把新元素插入到Vector的前面，否则上面的代码对性能不利。在默认构造函数中，Vector的初始存储能力是10个元素，如果新元素加入时存储能力不足，则以后存储能力每次加倍。Vector类就对象StringBuffer类一样，每次扩展存储能力时，所有现有的元素都要复制到新的存储空间之中。下面的代码片段要比前面的例子快几个数量级：Object bj = new Object();Vector v = new Vector(100000);for(int I=0; I<100000; I++) { v.add(obj); }同样的规则也适用于Vector类的remove()方法。由于Vector中各个元素之间不能含有“空隙”，删除除最后一个元素之外的任意其他元素都导致被删除元素之后的元素向前移动。也就是说，从Vector删除最后一个元素要比删除第一个元素“开销”低好几倍。假设要从前面的Vector删除所有元素，我们可以使用这种代码：for(int I=0; I<100000; I++){v.remove(0);}但是，与下面的代码相比，前面的代码要慢几个数量级：for(int I=0; I<100000; I++){v.remove(v.size()-1);}从Vector类型的对象v删除所有元素的最好方法是：v.removeAllElements();假设Vector类型的对象v包含字符串“Hello”。考虑下面的代码，它要从这个Vector中删除“Hello”字符串：String s = "Hello";int i = v.indexOf(s);if(I != -1) v.remove(s);这些代码看起来没什么错误，但它同样对性能不利。在这段代码中，indexOf()方法对v进行顺序搜索寻找字符串“Hello”，remove(s)方法也要进行同样的顺序搜索。改进之后的版本是：String s = "Hello";int i = v.indexOf(s);if(I != -1) v.remove(i);这个版本中我们直接在remove()方法中给出待删除元素的精确索引位置，从而避免了第二次搜索。一个更好的版本是：String s = "Hello"; v.remove(s);最后，我们再来看一个有关Vector类的代码片段：for(int I=0; I++;I < v.length)如果v包含100,000个元素，这个代码片段将调用v.size()方法100,000次。虽然size方法是一个简单的方法，但它仍旧需要一次方法调用的开销，至少JVM需要为它配置以及清除堆栈环境。在这里，for循环内部的代码不会以任何方式修改Vector类型对象v的大小，因此上面的代码最好改写成下面这种形式：int size = v.size(); for(int I=0; I++;I<size)虽然这是一个简单的改动，但它仍旧赢得了性能。毕竟，每一个CPU周期都是宝贵的。15、当复制大量数据时，使用System.arraycopy()命令。int[] src={1,3,5,6,7,8};int[] dest = new int[6];System.arraycopy(src, 0, dest, 0, 6);src:源数组; srcPos:源数组要复制的起始位置;dest:目的数组; destPos:目的数组放置的起始位置; length:复制的长度.注意：src and dest都必须是同类型或者可以进行转换类型的数组．16、代码重构：增强代码的可读性。public class ShopCart {private List carts ;…public void add (Object item) {if(carts == null) {carts = new ArrayList();}crts.add(item);}public void remove(Object item) {if(carts. contains(item)) {carts.remove(item);}}public List getCarts() {//返回只读列表return Collections.unmodifiableList(carts);}//不推荐这种方式//this.getCarts().add(item);}17、不用new关键词创建类的实例用new关键词创建类的实例时，构造函数链中的所有构造函数都会被自动调用。但如果一个对象实现了Cloneable接口，我们可以调用它的clone()方法。clone()方法不会调用任何类构造函数。在使用设计模式（Design Pattern）的场合，如果用Factory模式创建对象，则改用clone()方法创建新的对象实例非常简单。例如，下面是Factory模式的一个典型实现：public static Credit getNewCredit() {return new Credit();}改进后的代码使用clone()方法，如下所示：private static Credit BaseCredit = new Credit();public static Credit getNewCredit() {return (Credit) BaseCredit.clone();}上面的思路对于数组处理同样很有用。18、乘法和除法考虑下面的代码：for (val = 0; val < 100000; val +=5) {alterX = val * 8; myResult = val * 2;}用移位操作替代乘法操作可以极大地提高性能。下面是修改后的代码：for (val = 0; val < 100000; val += 5) {alterX = val << 3; myResult = val << 1;}修改后的代码不再做乘以8的操作，而是改用等价的左移3位操作，每左移1位相当于乘以2。相应地，右移1位操作相当于除以2。值得一提的是，虽然移位操作速度快，但可能使代码比较难于理解，所以最好加上一些注释。19、在JSP页面中关闭无用的会话。一个常见的误解是以为session在有客户端访问时就被创建，然而事实是直到某server端程序调用HttpServletRequest.getSession(true)这样的语句时才被创建，注意如果JSP没有显示的使用 <> 关闭session，则JSP文件在编译成Servlet时将会自动加上这样一条语句HttpSession session = HttpServletRequest.getSession(true);这也是JSP中隐含的session对象的来历。由于session会消耗内存资源，因此，如果不打算使用session，应该在所有的JSP中关闭它。对于那些无需跟踪会话状态的页面，关闭自动创建的会话可以节省一些资源。使用如下page指令：<%@ page session="false"%>20、JDBC与I/O如果应用程序需要访问一个规模很大的数据集，则应当考虑使用块提取方式。默认情况下，JDBC每次提取32行数据。举例来说，假设我们要遍历一个5000行的记录集，JDBC必须调用数据库157次才能提取到全部数据。如果把块大小改成512，则调用数据库的次数将减少到10次。21、Servlet与内存使用许多开发者随意地把大量信息保存到用户会话之中。一些时候，保存在会话中的对象没有及时地被垃圾回收机制回收。从性能上看，典型的症状是用户感到系统周期性地变慢，却又不能把原因归于任何一个具体的组件。如果监视JVM的堆空间，它的表现是内存占用不正常地大起大落。解决这类内存问题主要有二种办法。第一种办法是，在所有作用范围为会话的Bean中实现HttpSessionBindingListener接口。这样，只要实现valueUnbound()方法，就可以显式地释放Bean使用的资源。另外一种办法就是尽快地把会话作废。大多数应用服务器都有设置会话作废间隔时间的选项。另外，也可以用编程的方式调用会话的setMaxInactiveInterval()方法，该方法用来设定在作废会话之前，Servlet容器允许的客户请求的最大间隔时间，以秒计。22、使用缓冲标记一些应用服务器加入了面向JSP的缓冲标记功能。例如，BEA的WebLogic Server从6.0版本开始支持这个功能，Open Symphony工程也同样支持这个功能。JSP缓冲标记既能够缓冲页面片断，也能够缓冲整个页面。当JSP页面执行时，如果目标片断已经在缓冲之中，则生成该片断的代码就不用再执行。页面级缓冲捕获对指定URL的请求，并缓冲整个结果页面。对于购物篮、目录以及门户网站的主页来说，这个功能极其有用。对于这类应用，页面级缓冲能够保存页面执行的结果，供后继请求使用。23、选择合适的引用机制在典型的JSP应用系统中，页头、页脚部分往往被抽取出来，然后根据需要引入页头、页脚。当前，在JSP页面中引入外部资源的方法主要有两种：include指令，以及include动作。include指令：例如<%@ include file="copyright.html" %>。该指令在编译时引入指定的资源。在编译之前，带有include指令的页面和指定的资源被合并成一个文件。被引用的外部资源在编译时就确定，比运行时才确定资源更高效。24、及时清除不再需要的会话为了清除不再活动的会话，许多应用服务器都有默认的会话超时时间，一般为30分钟。当应用服务器需要保存更多会话时，如果内存容量不足，操作系统会把部分内存数据转移到磁盘，应用服务器也可能根据“最近最频繁使用”（Most Recently Used）算法把部分不活跃的会话转储到磁盘，甚至可能抛出“内存不足”异常。在大规模系统中，串行化会话的代价是很昂贵的。当会话不再需要时，应当及时调用HttpSession.invalidate()方法清除会话。HttpSession.invalidate()方法通常可以在应用的退出页面调用。25、不要将数组声明为：public static final 。26、HashMap的遍历效率for(Entry<String, String[]> entry : paraMap.entrySet()){String appFieldDefId = entry.getKey();String[] values = entry.getValue();.......}取得Entry的值之后直接取key和value，效率高。27、array(数组) 和 ArryList，基于效率和类型检验，应尽可能使用array，无法确定数组大小时才使用ArrayList！28、尽量使用HashMap 和ArrayList ,除非必要，否则不推荐使用HashTable和Vector ，后者由于使用同步机制，而导致了性能的开销。29、StringBuffer 和StringBuilder，应优先StringBuilder类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。为了获得更好的性能，在构造 StirngBuffer 或 StirngBuilder 时应尽可能指定它的容量。30、尽量避免使用split

这么简单都想不明白么。如果你把哥哥的对象赋值给弟弟，那不就是就存在一个人了？都是同个对象，还有两人？只是名字不一样，而指的是同一个人既然是两个人，为什么是一个对象？简单克隆就可以复制对象你在哥哥中构造弟弟，弟弟就是一个person对象，弟弟这个对象，变成了哥哥的成员对象了但是不是同一个人另外，你说的有克颗痣的差异，设计时不是这么设计的再说，你说的这个关系，要设计，也不是这么设计的

数据库吗？数据库+SE？

算术异常类：ArithmeticExecption空指针异常类：NullPointerException类型强制转换异常：ClassCastException数组负下标异常：NegativeArrayException数组下标越界异常：ArrayIndexOutOfBoundsException违背安全原则异常：SecturityException文件已结束异常：EOFException文件未找到异常：FileNotFoundException字符串转换为数字异常：NumberFormatException操作数据库异常：SQLException输入输出异常：IOException方法未找到异常：NoSuchMethodExceptionjava.lang.AbstractMethodError抽象方法错误。当应用试图调用抽象方法时抛出。java.lang.AssertionError断言错。用来指示一个断言失败的情况。java.lang.ClassCircularityError类循环依赖错误。在初始化一个类时，若检测到类之间循环依赖则抛出该异常。java.lang.ClassFormatError类格式错误。当Java虚拟机试图从一个文件中读取Java类，而检测到该文件的内容不符合类的有效格式时抛出。java.lang.Error错误。是所有错误的基类，用于标识严重的程序运行问题。这些问题通常描述一些不应被应用程序捕获的反常情况。java.lang.ExceptionInInitializerError初始化程序错误。当执行一个类的静态初始化程序的过程中，发生了异常时抛出。静态初始化程序是指直接包含于类中的static语句段。java.lang.IllegalAccessError违法访问错误。当一个应用试图访问、修改某个类的域（Field）或者调用其方法，但是又违反域或方法的可见性声明，则抛出该异常。java.lang.IncompatibleClassChangeError不兼容的类变化错误。当正在执行的方法所依赖的类定义发生了不兼容的改变时，抛出该异常。一般在修改了应用中的某些类的声明定义而没有对整个应用重新编译而直接运行的情况下，容易引发该错误。java.lang.InstantiationError实例化错误。当一个应用试图通过Java的new操作符构造一个抽象类或者接口时抛出该异常.java.lang.InternalError内部错误。用于指示Java虚拟机发生了内部错误。java.lang.LinkageError链接错误。该错误及其所有子类指示某个类依赖于另外一些类，在该类编译之后，被依赖的类改变了其类定义而没有重新编译所有的类，进而引发错误的情况。java.lang.NoClassDefFoundError未找到类定义错误。当Java虚拟机或者类装载器试图实例化某个类，而找不到该类的定义时抛出该错误。java.lang.NoSuchFieldError域不存在错误。当应用试图访问或者修改某类的某个域，而该类的定义中没有该域的定义时抛出该错误。java.lang.NoSuchMethodError方法不存在错误。当应用试图调用某类的某个方法，而该类的定义中没有该方法的定义时抛出该错误。java.lang.OutOfMemoryError内存不足错误。当可用内存不足以让Java虚拟机分配给一个对象时抛出该错误。java.lang.StackOverflowError堆栈溢出错误。当一个应用递归调用的层次太深而导致堆栈溢出时抛出该错误。java.lang.ThreadDeath线程结束。当调用Thread类的stop方法时抛出该错误，用于指示线程结束。java.lang.UnknownError未知错误。用于指示Java虚拟机发生了未知严重错误的情况。java.lang.UnsatisfiedLinkError未满足的链接错误。当Java虚拟机未找到某个类的声明为native方法的本机语言定义时抛出。java.lang.UnsupportedClassVersionError不支持的类版本错误。当Java虚拟机试图从读取某个类文件，但是发现该文件的主、次版本号不被当前Java虚拟机支持的时候，抛出该错误。java.lang.VerifyError验证错误。当验证器检测到某个类文件中存在内部不兼容或者安全问题时抛出该错误。java.lang.VirtualMachineError虚拟机错误。用于指示虚拟机被破坏或者继续执行操作所需的资源不足的情况。java.lang.ArithmeticException算术条件异常。譬如：整数除零等。java.lang.ArrayIndexOutOfBoundsException数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。java.lang.ArrayStoreException数组存储异常。当向数组中存放非数组声明类型对象时抛出。java.lang.ClassCastException类造型异常。假设有类A和B（A不是B的父类或子类），O是A的实例，那么当强制将O构造为类B的实例时抛出该异常。该异常经常被称为强制类型转换异常。java.lang.ClassNotFoundException找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。java.lang.CloneNotSupportedException不支持克隆异常。当没有实现Cloneable接口或者不支持克隆方法时,调用其clone()方法则抛出该异常。java.lang.EnumConstantNotPresentException枚举常量不存在异常。当应用试图通过名称和枚举类型访问一个枚举对象，但该枚举对象并不包含常量时，抛出该异常。java.lang.Exception根异常。用以描述应用程序希望捕获的情况。java.lang.IllegalAccessException违法的访问异常。当应用试图通过反射方式创建某个类的实例、访问该类属性、调用该类方法，而当时又无法访问类的、属性的、方法的或构造方法的定义时抛出该异常。java.lang.IllegalMonitorStateException违法的监控状态异常。当某个线程试图等待一个自己并不拥有的对象（O）的监控器或者通知其他线程等待该对象（O）的监控器时，抛出该异常。java.lang.IllegalStateException违法的状态异常。当在Java环境和应用尚未处于某个方法的合法调用状态，而调用了该方法时，抛出该异常。java.lang.IllegalThreadStateException违法的线程状态异常。当县城尚未处于某个方法的合法调用状态，而调用了该方法时，抛出异常。java.lang.IndexOutOfBoundsException索引越界异常。当访问某个序列的索引值小于0或大于等于序列大小时，抛出该异常。java.lang.InstantiationException实例化异常。当试图通过newInstance()方法创建某个类的实例，而该类是一个抽象类或接口时，抛出该异常。java.lang.InterruptedException被中止异常。当某个线程处于长时间的等待、休眠或其他暂停状态，而此时其他的线程通过Thread的interrupt方法终止该线程时抛出该异常。java.lang.NegativeArraySizeException数组大小为负值异常。当使用负数大小值创建数组时抛出该异常。java.lang.NoSuchFieldException属性不存在异常。当访问某个类的不存在的属性时抛出该异常。java.lang.NoSuchMethodException方法不存在异常。当访问某个类的不存在的方法时抛出该异常。java.lang.NullPointerException空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。java.lang.NumberFormatException数字格式异常。当试图将一个String转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常。java.lang.RuntimeException运行时异常。是所有Java虚拟机正常操作期间可以被抛出的异常的父类。java.lang.SecurityException安全异常。由安全管理器抛出，用于指示违反安全情况的异常。java.lang.StringIndexOutOfBoundsException字符串索引越界异常。当使用索引值访问某个字符串中的字符，而该索引值小于0或大于等于序列大小时，抛出该异常。java.lang.TypeNotPresentException类型不存在异常。当应用试图以某个类型名称的字符串表达方式访问该类型，但是根据给定的名称又找不到该类型是抛出该异常。该异常与ClassNotFoundException的区别在于该异常是unchecked（不被检查）异常，而ClassNotFoundException是checked（被检查）异常。java.lang.UnsupportedOperationException不支持的方法异常。指明请求的方法不被支持情况的异常。异常javax.servlet.jsp.JspException: Cannot retrieve mapping for action /Login （/Login是你的action名字） 可能原因action没有再struts-config.xml 中定义，或没有找到匹配的action，例如在JSP文件中使用 <html:form action="Login.do".将表单提交给Login.do处理，如果出现上述异常，请查看struts-config.xml中的定义部分，有时可能是打错了字符或者是某些不符合规则，可以使用strutsconsole工具来检查。-----------------------------------------------------------------------------------------------------------------异常org.apache.jasper.JasperException: Cannot retrieve definition for form bean null可能原因 这个异常是因为Struts根据struts-config.xml中的mapping没有找到action期望的form bean。大部分的情况可能是因为在form-bean中设置的name属性和action中设置的name属性不匹配所致。换句话说，action和form都应该各自有一个name属性，并且要精确匹配，包括大小写。这个错误当没有name属性和action关联时也会发生，如果没有在action中指定name属性，那么就没有name属性和action相关联。当然当action制作某些控制时，譬如根据参数值跳转到相应的jsp页面，而不是处理表单数据，这是就不用name属性，这也是action的使用方法之一。

hashtable和hashmap，从存储结构和实现来讲基本上都是相同的，最大的不同就是hashtable是线程安全的，put等方法都加了synchronized关键字。另外就继承关系上面有点区别，这里就从如下几个方面来分析一下hashtable，从中穿插着和hashmap的对比说明。1、继承关系[java] view plain copy public class Hashtable<K,V>extends Dictionary<K,V>implements Map<K,V>, Cloneable, java.io.Serializable 这里和hashmap的唯一区别就是hashtable继承Dictionary，这个抽象类没有实现任何方法，按照官方的说法是这个类已经过时了，hashMap则是继承abstractMap。2、关键类，这个类实现Iterator的功能，它实现了Enumeration和Iterator接口，其实Enumeration和Iterator的功能差不多，至于为什么需要同时实现两个接口，有一种说法是历史原因，具体的话我们就不去分析说明了，这里的Enumerator就是一个迭代器的功能，有hashNext和next方法。[java] view plain copy private class Enumerator<T> implements Enumeration<T>, Iterator<T> {Entry[] table = Hashtable.this.table;int index = table.length;Entry<K,V> entry = null;Entry<K,V> lastReturned = null;int type;/*** Indicates whether this Enumerator is serving as an Iterator* or an Enumeration. (true -> Iterator).*/boolean iterator;/*** The modCount value that the iterator believes that the backing* Hashtable should have. If this expectation is violated, the iterator* has detected concurrent modification.*/protected int expectedModCount = modCount;Enumerator(int type, boolean iterator) {this.type = type;this.iterator = iterator;}public boolean hasMoreElements() {Entry<K,V> e = entry;int i = index;Entry[] t = table;/* Use locals for faster loop iteration */while (e == null && i > 0) {e = t[--i];}entry = e;index = i;return e != null;}public T nextElement() {Entry<K,V> et = entry;int i = index;Entry[] t = table;/* Use locals for faster loop iteration */while (et == null && i > 0) {et = t[--i];}entry = et;index = i;if (et != null) {Entry<K,V> e = lastReturned = entry;entry = e.next;return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e);}throw new NoSuchElementException("Hashtable Enumerator");}// Iterator methodspublic boolean hasNext() {return hasMoreElements();}public T next() {if (modCount != expectedModCount)throw new ConcurrentModificationException();return nextElement();}public void remove() {if (!iterator)throw new UnsupportedOperationException();if (lastReturned == null)throw new IllegalStateException("Hashtable Enumerator");if (modCount != expectedModCount)throw new ConcurrentModificationException();synchronized(Hashtable.this) {Entry[] tab = Hashtable.this.table;int index = (lastReturned.hash & 0x7FFFFFFF) % tab.length;for (Entry<K,V> e = tab[index], prev = null; e != null;prev = e, e = e.next) {if (e == lastReturned) {modCount++;expectedModCount++;if (prev == null)tab[index] = e.next;elseprev.next = e.next;count--;lastReturned = null;return;}}throw new ConcurrentModificationException();}}} 3、关键属性和方法hashtable和hashmap的关键属性和方法的实现基本没有区别，或者说没有区别，最大的区别就是前者的方法有synchronized关键字，是线程安全的方法，后者不是线程安全的方法，另外hashtable不支持null的key和value，hashmap支持null的key和value。具体的方法实现和hashmap是一样的，这里就不在重复的分析了。最后总结，hashtable是线程安全的hashmap。

(1)Easy:Java的语法比C++的相对简单，另一个方面就是Java能使软件在很小的机器上运行，基础解释其和类库的支持的大小约为40kb，增加基本的标准库和线程支持的内存需要增加125kb。 (2)分布式:Java带有很强大的TCP/IP协议族的例程库，Java应用程序能够通过URL来穿过网络来访问远程对象，由于servlet机制的出现，使Java编程非常的高效，现在许多的大的web server都支持servlet。 (3)OO:面向对象设计是把重点放在对象及对象的接口上的一个编程技术.其面向对象和C++有很多不同，在与多重继承的处理及Java的原类模型。 (4)健壮特性:Java采取了一个安全指针模型，能减小重写内存和数据崩溃的可能型。 (5)安全:Java用来设计网路和分布系统，这带来了新的安全问题，Java可以用来构建防病毒和防攻击的System.事实证明Java在防毒这一方面做的比较好。 (6)中立体系结构:Java编译其生成体系结构中立的目标文件格式可以在很多处理器上执行，编译器产生的指令字节码(Javabytecode)实现此特性，此字节码可以在任何机器上解释执行。 (7)可移植性:Java中对基本数据结构类型的大小和算法都有严格的规定所以可移植性很好。 (8)多线程:Java处理多线程的过程很简单，Java把多线程实现交给底下操作系统或线程程序完成.所以多线程是Java作为服务器端开发语言的流行原因之一。 (9)Applet和servlet:能够在网页上执行的程序叫Applet，需要支持Java的浏览器很多，而applet支持动态的网页，这是很多其他语言所不能做到的。 基本概念 1.OOP中唯一关系的是对象的接口是什么，就像计算机的销售商她不管电源内部结构是怎样的，他只关系能否给你提供电就行了，也就是只要知道can or not而不是how and why.所有的程序是由一定的属性和行为对象组成的，不同的对象的访问通过函数调用来完成，对象间所有的交流都是通过方法调用，通过对封装对象数据，很大限度上提高复用率。 2.OOP中最重要的思想是类，类是模板是蓝图，从类中构造一个对象，即创建了这个类的一个实例(instance)。 3.封装:就是把数据和行为结合起在一个包中)并对对象使用者隐藏数据的实现过程，一个对象中的数据叫他的实例字段(instance field)。 4.通过扩展一个类来获得一个新类叫继承(inheritance)，而所有的类都是由Object根超类扩展而得，根超类下文会做介绍。 5.对象的3个主要特性 behavior---说明这个对象能做什么. state---当对象施加方法时对象的反映. identity---与其他相似行为对象的区分标志. 每个对象有唯一的indentity 而这3者之间相互影响. 6.类之间的关系: use-a :依赖关系 has-a :聚合关系 is-a :继承关系--例:A类继承了B类，此时A类不仅有了B类的方法，还有其自己的方法.(个性存在于共性中) 7.构造对象使用构造器:构造器的提出，构造器是一种特殊的方法，构造对象并对其初始化。 例:Data类的构造器叫Data new Data()---构造一个新对象，且初始化当前时间. Data happyday=new Data()---把一个对象赋值给一个变量happyday，从而使该对象能够多次使用，此处要声明的使变量与对象变量二者是不同的.new返回的值是一个引用。 构造器特点:构造器可以有0个，一个或多个参数 构造器和类有相同的名字 一个类可以有多个构造器 构造器没有返回值 构造器总是和new运算符一起使用. 8.重载:当多个方法具有相同的名字而含有不同的参数时，便发生重载.编译器必须挑选出调用哪个方法。 9.包(package)Java允许把一个或多个类收集在一起成为一组，称作包，以便于组织任务，标准Java库分为许多包.java.lang java.util java，net等，包是分层次的所有的java包都在java和javax包层次内。 10.继承思想:允许在已经存在的类的基础上构建新的类，当你继承一个已经存在的类时，那么你就复用了这个类的方法和字段，同时你可以在新类中添加新的方法和字段。 11.扩展类:扩展类充分体现了is-a的继承关系. 形式为:class (子类) extends (基类)。 12.多态:在java中，对象变量是多态的.而java中不支持多重继承。 13.动态绑定:调用对象方法的机制。 (1)编译器检查对象声明的类型和方法名。 (2)编译器检查方法调用的参数类型。 (3)静态绑定:若方法类型为priavte static final 编译器会准确知道该调用哪个方法。 (4)当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用x所指向的对象的实际类型相匹配的方法版本。 (5)动态绑定:是很重要的特性，它能使程序变得可扩展而不需要重编译已存代码。 14.final类:为防止他人从你的类上派生新类，此类是不可扩展的。 15.动态调用比静态调用花费的时间要长。 16.抽象类:规定一个或多个抽象方法的类本身必须定义为abstract。 例: public abstract string getDescripition 17.Java中的每一个类都是从Object类扩展而来的。 18.object类中的equal和toString方法。 equal用于测试一个对象是否同另一个对象相等。 toString返回一个代表该对象的字符串，几乎每一个类都会重载该方法，以便返回当前状态的正确表示. (toString 方法是一个很重要的方法) 19.通用编程:任何类类型的所有值都可以同object类性的变量来代替。 20.数组列表:ArrayList动态数组列表，是一个类库，定义在java.uitl包中，可自动调节数组的大小。 21.class类 object类中的getclass方法返回ckass类型的一个实例，程序启动时包含在main方法的类会被加载，虚拟机要加载他需要的所有类，每一个加载的类都要加载它需要的类。 22.class类为编写可动态操纵java代码的程序提供了强大的功能反射，这项功能为JavaBeans特别有用，使用反射Java能支持VB程序员习惯使用的工具。 能够分析类能力的程序叫反射器，Java中提供此功能的包叫Java.lang.reflect反射机制十分强大. 1.在运行时分析类的能力。 2.在运行时探察类的对象。 3.实现通用数组操纵代码。 4.提供方法对象。 而此机制主要针对是工具者而不是应用及程序。 反射机制中的最重要的部分是允许你检查类的结构.用到的API有: java.lang.reflect.Field 返回字段. java.reflect.Method 返回方法. java.lang.reflect.Constructor 返回参数. 方法指针:java没有方法指针，把一个方法的地址传给另一个方法，可以在后面调用它，而接口是更好的解决方案。 23.接口(Interface)说明类该做什么而不指定如何去做，一个类可以实现一个或多个interface。 24.接口不是一个类，而是对符合接口要求的类的一套规范。 若实现一个接口需要2个步骤: 1.声明类需要实现的指定接口。 2.提供接口中的所有方法的定义。 声明一个类实现一个接口需要使用implements 关键字 class actionB implements Comparable 其actionb需要提供CompareTo方法，接口不是类，不能用new实例化一个接口. 25.一个类只有一个超类，但一个类能实现多个接口。Java中的一个重要接口：Cloneable 26.接口和回调.编程一个常用的模式是回调模式，在这种模式中你可以指定当一个特定时间发生时回调对象上的方法。 例:ActionListener 接口监听. 类似的API有:java.swing.JOptionPane java.swing.Timer java.awt.Tookit 27.对象clone:clone方法是object一个保护方法，这意味着你的代码不能简单的调用它。 28.内部类:一个内部类的定义是定义在另一个内部的类。 原因是: 1.一个内部类的对象能够访问创建它的对象的实现，包括私有数据。 2.对于同一个包中的其他类来说，内部类能够隐藏起来。 3.匿名内部类可以很方便的定义回调。 4.使用内部类可以非常方便的编写事件驱动程序。 29.代理类(proxy): 1.指定接口要求所有代码 2.object类定义的所有的方法(toString equals) 30.数据类型:Java是强调类型的语言，每个变量都必须先申明它都类型，java中总共有8个基本类型.4种是整型，2种是浮点型，一种是字符型，被用于Unicode编码中的字符，布尔型。

不能吧?还是别与C对比了,如果你真想学的话,找一本<<Thinking in java>>学习面向对象的机制吧.

如何写出好的Java代码1． 优雅需要付出代价。从短期利益来看，对某个问题提出优雅的解决方法，似乎可能花你更多的时间。但当它终于能够正确执行并可轻易套用于新案例中，不需要花上数以时计，甚至以天计或以月计的辛苦代价时，你会看得到先前所花功夫的回报（即使没有人可以衡量这一点）。这不仅给你一个可更容易开发和调试的程序，也更易于理解和维护。这正是它在金钱上的价值所在。这一点有赖某种人生经验才能够了解，因为当你努力让某一段程序代码变得比较优雅时，你并不是处于一种具生产力的状态下。但是，请抗拒那些催促你赶工的人们，因为那么做只会减缓你的速度罢了。2． 先求能动，再求快。即使你已确定某段程序代码极为重要，而且是系统的重要瓶颈，这个准则依然成立。尽可能简化设计，让系统能够先正确动作。如果程序的执行不够快，再量测其效能。几乎你总是会发现，你所认为的”瓶颈”其实都不是问题所在。把你的时间花在刀口上吧。3． 记住”各个击破”的原理。如果你所探讨的问题过于混杂，试着想像该问题的基本动作会是什么，并假设这一小块东西能够神奇地处理掉最难的部分。这”一小块”东西其实就是对象–请撰写运用该对象的程序代码，然后检视对象，并将其中困难的部分再包装成其他对象，依此类推。4． 区分class开发者和class使用者（使用端程序员）。Class 使用者扮演着”客户”角色，不需要（也不知道）class的底层运作方式。Class开发者必须是class设计专家，并撰写class，使它能够尽可能被大多数新手程序员所用，而且在程序中能够稳当执行。一套程序库只有在具备通透性的情况下，使用起来才会容易。5．当你撰写class时，试着给予明了易懂的名称，减少不必要的注解。你给客户端程序员的接口，应该保持概念上的单纯性。不了这个目的，当函数的重载（overloading）适合制作出直觉、易用的接口时，请善加使用。6． 也必你的分析和设计必须让系统中的classes保持最少，须让其Public interfaces保持最少，以及让这些classes和其他classes之间的关联性（ 尤其是base classes）保持最少。如果你的设计所得结果更甚于此，请问问自己，是否其中每一样东西在整个程序生命期中都饶富价值？如果并非如此，那么，维护它们会使你付出代价。开发团队的成员都有不维护”无益于生产力提升”的任何东西的倾向；这是许多设计方法无法解释的现象。7． 让所有东西尽量自动化。先撰写测试用的程序代码（在你撰写class之前），并让它和class结合在一起。请使用makefile或类似工具，自动进行测试动作。通过这种方式，只要执行测试程序，所有的程序变动就可以自动获得验证，而且可以立即发现错误。由于你知道的测试架构所具备的安全性，所以当你发现新的需求时，你会更勇于进行全面修改。请记住，程序语言最大的改进，是来自型别检查、异常处理等机制所赋予的内置测试动作。但这些功能只能协助你到达某种程度。开发一个稳固系统时，你得自己验证自己的classes或程序的性质。8． 在你撰写class之前先写测试码，以便验证你的class 是否设计完备。如果你无法撰写测试码，你便无法知道你的class 的可能长相。撰写测试码通常能够显现出额外的特性（features）或限制 ( constraints)__它们并不一定总是能够在分析和设计过程中出现。测试码也可做为展示class 用法的示例程序。9． 所有软件设计上的问题，都可以通过”引入额外的概念性间接层（conceptual indirection）”加以简化。这个软件工程上的基础法则是抽象化概念的根据，而抽象化概念正是面向对象程序设计的主要性质。10． 间接层(indirection)应该要有意义（和准则-9致）。这里所指的意义可以像”将共用程序代码置于惟一函数”这么简单。如果你加入的间接层（或抽象化、或封装等等）不具意义，它可能就和没有适当的间接层一样糟糕。11． 让class尽可能微小而无法切割（atomic）。赋予每个class单一而清楚的用途。如果你的classes或你的系统成长得过于复杂，请将复杂的classes切割成比较简单的几个classes。最明显的一个判断指针就是class的大小：如果它很大，那么它工作量过多的机会就可能很高，那就应该被切割。重新设计class的建议线索是： 1） 复杂的switch语句：请考虑运用多态（Polymorphism）。 2） 许多函数各自处理类型极为不同的动作：请考虑切割为多个不同的（classes）。12． 小心冗长的引数列（argument lists）。冗长的引数列会使函数的调用动作不易撰写、阅读、维护。你应该试着将函数搬移到更适当的class中，并尽量以对象为引数。13． 不要一再重复。如果某段程序代码不断出现于许多derived class函数中，请将该段程序代码置于某个base class 函数内，然后在derived class函数中调用。这么做不仅可以省下程序代码空间，也可以让修改该段程序代码动作更易于进行。有时候找出此种共通程序代码还可以为接口增加实用功能。14． 小心switch语句或成串的if-else 子句。通常这种情况代表所谓的”type-check coding”。也就是说究竟会执行哪一段程序代码，乃是依据某种型别信息来做抉择（最初，确切型别可能不十分明显）。你通常可以使用继承和多态来取代此类程序代码；Polymorphical method （多态函数）的调用会自动执行此类型别检验，并提供更可靠更容易的扩充性。15． 从设计观点来看，请找出变动的事物，并使它和不变的事物分离。也就是说，找出系统中可能被你改变的元素，将它们封装于classes中。你可以在《Thinking in Patterns with Java》（可免费下载于 www. BruceEckel. Com）大量学习到这种观念。16． 不要利用subclassing来扩充基础功能。如果某个接口元素对class而言极重要，它应该被放在base class 里头，而不是直到衍生（derivation）时才被加入。如果你在继承过程中加入了函数，或许你应该重新思考整个设计。17． 少就是多。从class 的最小接口开始妨展，尽可能在解决问题的前提下让它保持既小又单纯。不要预先考量你的class被使用的所有可能方式。一旦class被实际运用，你自然会知道你得如何扩充接口。不过，一旦class被使用后，你就无法在不影响客户程序代码的情况下缩减其接口。如果你要加入更多函数倒是没有问题–不会影响既有的客户程序代码，它们只需重新编译即可。但即使新函数取代了旧函数的功能，也请你保留既有接口。如果你得通过”加入更多引数”的方式来扩充既有函数的接口，请你以新引数写出一个重载化的函数；通过 这种方式就不会影响既有函数的任何客户了。18． 大声念出你的classes,确认它们符合逻辑。请base class和derived class 之间的关系是”is-a”(是一种)，让class和成员对象之间的关系是”has-a”(有一个)。19． 当你犹豫不决于继承（inheritance）或合成（组合，composition）时，请你问问自己，是否需要向上转型（upcast）为基础型别。如果不需要，请优先选择合成（也就是是使用成员对象）。这种作法可以消除”过多基础型别”。如果你采用继承，使用者会认为他们应该可以向上转型。20． 运用数据成员来表示数值的变化，运用经过覆写的函数（overrided method）来代表行为的变化 。也就是说，如果你找到了某个 class, 带有一些状态变量，而其函数会依据这些变量值切换不同的行为，那么你或许就应该重新设计，在subclasses 和覆写后的函数（overrided methods）中展现行为止的差异。21． 小心重载（overloading）。函数不应该依据引数值条件式地选择执行某一段程序代码。这种情况下你应该撰写两个或更多个重载函数（overloaded methods）22． 使用异常体系（exception hierarchies）最好是从Java标准异常体系中衍生特定的classes, 那么，捕捉异常的人便可以捕捉特定异常，之后才捕捉基本异常。如果你加入新的衍生异常，原有的客户端程序仍能通过其基础型别来捕捉它。23． 有时候简单的聚合（aggregation）就够了。飞机上的”旅客舒适系统”包括数个分离的元素：座椅、空调、视讯设备等等，你会需要在飞机上产生许多这样的东西。你会将它们声明为Private成员并开发出一个全新的接口吗？不会的，在这个例子中，元素也是Public接口的一部分，所以仍然是安全的。当然啦，简单聚合并不是一个常被运用的解法，但有时候的确是。24． 试着从客户程序员和程序维护的角度思考。你的class应该设计得尽可能容易使用。你应该预先考量可能性有的变动，并针对这些 可能的变动进行设计，使这些变动日后可轻易完成。25． 小心”巨大对象并发症”。这往往是刚踏OOP领域的过程式（procedural）程序员的一个苦恼，因为他们往往最终还是写出一个过程式程序，并将它们摆放到一个或两个巨大对象中。注意，除了application framework (应用程序框架，译注：一种很特殊的、大型OO程序库，帮你架构程序本体)之外，对象代表的是程序中的观念，而不是程序本身。26． 如果你得用某种丑陋的方式来达成某个动作，请将丑陋的部分局限在某个class里头。27． 如果你得用某种不可移植方式来达成某个动作，请将它抽象化并局限于某个class里头。这样一个”额外间接层”能够防止不可移植的部分扩散到整个程序。这种作法的具体呈现便是Bridge设计模式（design pattern）。28． 对象不应仅仅只用来持有数据。对象也应该具有定义明确界限清楚的行为。有时候使用”数据对象”是适当的，但只有在通用形容器不适用时，才适合刻意以数据对象来包装、传输一群数据项。29． 欲从既有的classes身上产生新的classes时，请以组合(composition)为优先考量。你应该只在必要时才使用继承。如果在组合适用之处你却选择了继承，你的设计就渗杂了非必要的复杂性。30． 运用继承和函数覆写机制来展现行为上的差异，运用fields(数据成员)来展现状态上的差异。这句话的极端例子，就是继承出不同的classes表现各种不同的颜色，而不使用”color”field.31． 当心变异性（variance）。语意相异的两个对象拥有相同的动作（或说责任）是可能的。OO世界中存在着一种天生的引诱，让人想要从某个class继承出另一个subclass,为的是获得继承带来的福利。这便是所谓”变异性”。但是，没有任何正当理由足以让我们强迫制造出某个其实并不存在的superclass/subclass关系。比较好的解决方式是写出一个共用的base class,它为两个derived classes制作出共用接口–这种方式会耗用更多空间，但你可以如你所盼望地从继承机制获得好处，而且或许能够在设计上获得重大发现。32． 注意继承上的限制。最清晰易懂的设计是将功能加到继承得来的class里头；继承过程中拿掉旧功能（而非增加新功能）则是一种可疑的设计。不过，规则可以打破。如果你所处理的是旧有的class程序库，那么在某个class的subclass限制功能，可能会比重新制定整个结构（俾使新class得以良好地相称于旧 class）有效率得多。33． 使用设计模式（design patterns）来减少”赤裸裸无加掩饰的机能（naked functionality）”。举个例子，如果你的class只应该产出惟一一个对象，那么请不要以加思索毫无设计的手法来完成它，然后撰写”只该产生一份对象”这样的注解就拍拍屁股走人。请将它包装成singleton（译注：一个有名的设计模式，可译为”单件”）。如果主程序中有多而混乱的”用以产生对象”的程序代码，请找出类似 factory method这样的生成模式（creational patterns），使价钱可用以封装生成动作减少”赤裸裸无加掩饰的机能”（naked functionality）不仅可以让你的程序更易理解和维护，也可以阻止出于好意却带来意外的维护者。34． 当心”因分析而导致的瘫痪（analysis paralysis）”。请记住，你往往必须在获得所有信息之前让项目继续前进。而且理解未知部分的最好也最快的方式，通常就是实际前进一步而不只是纸上谈兵。除非找到解决办法，否则无法知道解决办法。Java拥有内置的防火墙，请让它们发挥作用。你在单一class或一组classes中所犯的错误，并不会伤害整个系统的完整性。35． 当你认为你已经获得一份优秀的分析、设计或实现时，请试着加以演练。将团队以外的某些人带进来-他不必非得是个顾问不可，他可以是公司其他团队的成员。请那个人以新鲜的姿态审视你们的成果，这样可以在尚可轻易修改的阶段找出问题，其收获会比因演练而付出的时间和金钱代价来得高。实现 （Implementation）36. 一般来说，请遵守Sun的程序编写习惯。价钱可以在以下网址找到相关文档：java.sun.com/docs/codeconv/idex.html。本书尽可能遵守这些习惯。众多Java程序员看到的程序代码，都有是由这些习惯构成的。如果你固执地停留在过去的编写风格中，你的（程序代码）读者会比较辛苦。不论你决定采用什么编写习惯，请在整个程序中保持一致。你可以在home.wtal.de/software-solutions/jindent上找到一个用来重排Java程序的免费工具。37. 无论使用何种编写风格，如果你的团队（或整个公司，那就更好了）能够加以标准化，那么的确会带来显著效果。这代表每个人都可以在其他人不遵守编写风格修改其作品，这是个公平的游戏。标准化的价值在于，分析程序代码时所花的脑力较小，因而可以专心于程序代码的实质意义。38. 遵守标准的大小写规范。将 class名称的第一个字母应为大写。数据成员、函数、对象（references）的第一个字母应为小写。所有识别名称的每个字都应该连在一块儿，所有非首字的第一个字母都应该大写。例如： ThisIsAClassName thisIsAMethodOrFieldName 如果你在static final 基本型别的定义处指定了常量初始式（constant initializers）,那么该识别名称应该全为大写，代表一个编译期常量。 Packages是个特例，其名称皆为小写，即使非首字的字母亦是如此。域名（org, net, edu 等等）皆应为小写。（这是Java 1.1迁移至Java 2时的一项改变） 。39、不要自己发明”装饰用的”Private数据成员名称。通常这种的形式是在最前端加上底线和其他字符，匈牙利命名法（Hungarian notation）是其中最差的示范。在这种命名法中，你得加入额外字符来表示数据的型别、用途、位置等等。仿佛你用的是汇编语言（assembly language）而编译器没有提供任何协肋似的。这样的命名方式容易让人混淆又难以阅读，也不易推行和维护。就让classes和packages来进行”名称上的范围制定（name scoping）”吧。40、当你拟定通用性的class时，请遵守正规形式（canonical form）。包括equals( )、hashCode( )、clone( ) ( 实现出Cloneable),并实现出Comparable和Serialiable等等。41、对于那些”取得或改变Private数据值”的函数，请使用Java Beans 的”get”、”set”、”is”等命名习惯，即使你当时不认为自己正在撰写Java Bean。这么做不仅可以轻易以Bean的运用方式来运用你的class,也是对此类函数的一种标准命名方式，使读者更易于理解。42、对于你所拟定的每一个class，请考虑为它加入static public test( )，其中含有class功能测试码。你不需要移除该测试就可将程序纳入项目。而且如果有所变动，你可以轻易重新执行测试。这段程序代码也可以做为class的使用示例。43、有时候你需要通过继承，才得以访问base class的protected成员。这可能会引发对多重基类（multiple base types）的认识需求。如果你不需要向上转型，你可以先衍生新的class发便执行protected访问动作，然后在”需要用到上述 protected成员”的所有classes中，将新class声明为成员对象，而非直接继承。44、避免纯粹为了效率考量而使用final函数。只有在程序能动但执行不够快时，而且效能量测工具（profiler）显示某个函数的调用动作成为瓶颈时，才使用final函数。45、如果两个classes因某种功能性原因而产生了关联（例如容器containers和迭代器iterators）,那么请试着让其中某个class成为另一个class 的内隐类（inner class）。这不仅强调二者间的关联，也是通过”将class名称嵌套置于另一个class 内”而使同一个class 名称在单一Package中可被重复使用。Java 容器库在每个容器类中都定义了一个内隐的（inner）Iterator class,因而能够提供容器一份共通接口。运用内隐类的另一个原因是让它成为private实现物的一部分。在这里，内隐类会为信息隐藏带来好处，而不是对上述的class关联性提供肋益，也不是为了防止命名空间污染问题(namespace pollution)。46、任何时候你都要注意那些高度耦合（coupling）的 classes.请考虑内隐类（inner classes）为程序拟定和维护带来的好处。内隐类的使用并不是要去除classes间的耦合，而是要让耦合关系更明显也更便利。47、不要成为”过早最佳化”的牺牲品。那会让人神经错乱。尤其在系统建构初期，先别烦恼究竟要不要撰写（或避免）原生函数（native methods）、要不要将某些数声明为final、要不要调校程序代码效率等等。你的主要问题应该是先证明设计的正确性，除非设计本身需要某种程度的效率。48、让范围（作用域，scope）尽可能愈小愈好，这么一来对象的可视范围和寿命都将尽可能地小。这种作法可降低”对象被用于错误场所，因而隐藏难以察觉的臭虫”的机会。假设你有个容器，以及一段走访该容器的程序片段。如果你复制该段程序代码，将它用于新的容器身上，你可能会不小心以旧容器的大小做为新容器的走访上限值。如果旧容器已不在访问范围内，那么编译期便可找出这样的错误。49、使用Java 标准程序库提供的容器。请熟悉他们的用法。你将因此大幅提升你的生产力。请优先选择ArrayList来处理序列（sequences），选择HashSet来处理集合（sets）、选择HashMap来处理关联式数组（associative arrays），选择Linkedlist (而不是Stack) 来处理 shacks和queues。50、对一个强固的（robust）程序而言，每一个组成都必须强固。请在你所撰写的每个class中运用Java 提供的所有强固提升工具：访问权限、异常、型别检验等等。通过这种方式，你可以在建构系统时安全地移往抽象化的下一个层次。51、宁可在编译期发生错误，也不要在执行期发生错误。试着在最靠近问题发生点的地方处理问题。请优先在”掷出异常之处”处理问题，并在拥有足够信息以处理异常的最接近处理函数（handler）中捕捉异常。请进行现阶段你能够对该异常所做的处理；如果你无法解决问题，应该再次掷出异常。52、当心冗长的函数定义。函数应该是一种简短的、”描述并实现class接口中某个可分离部分”的功能单元。过长且复杂的函数不仅难以维护，维护代价也高。或许它尝试做太多事情了。如果你发现这一类函数，代表它应该被切割成多相函数。这种函数也提醒你或许得撰写新的class。小型函数同样能够在你的class中被重复运用。（有时候函数必须很大才行，但它们应该只做一件事情。）53、尽可能保持”Private”。一旦你对外公开了程序库的概况（method、Class 或field）。你便再也无法移除它们。因为如果移除它们，便会破坏某个现有的程序代码，使得它们必须重新被编写或重新设计。如果你只公开必要部分，那么你便可以改变其他东西而不造成伤害。设计总是会演化，所以这是个十分重要的自由度。通过这种方式，实现码的更动对derived class 造成的冲击会降最低。在多线程环境下，私密性格外重要-只有private数据可受保护而不被un-synchronized（未受同步控制）的运用所破坏。54、大量运用注解，并使用javadoc的”注解文档语法”来产生程序的说明文档。不过注解应该赋予程序代码真正的意义；如果只是重申程序代码已经明确表示的内容，那是很烦人的。请注意，通常Java class和其函数的名称都很长，为的便是降低注解量。55、避免使用”魔术数字”，也就是那种写死在程序代码里头的数字–如果你想改变它们，它们就会成为你的恶梦，因为你永远都没有办法知道”100″究竟代表” 数组大小”或其他东西。你应该产生具描述性的常量度名称，并在程序中使用该常量名称。这使程序更易于理解也更易于维护。56、撰写构造函数时，请考虑异常状态。最好情境下，构造函数不执行任何会掷出异常的动作。次佳情境下，class 只继承自（或合成自）强固的（robust）classes，所以如有任何异常被掷出，并不需要清理。其他情况下，你就得在finally子句清理合成后的classes。如果某个构造函数一定会失败，适当的动作就是掷出异常，使调用者不至于盲目认为对象已被正确产生而继续执行。57、如果你的class需要在”客户程序员用完对象”后进行清理动作，请将清理动作，放到单一而定义明确的函数中。最好令其名称为cleanup() 以便能够将用途告诉他人。此外请将boolean旗标放到class中，用以代表对象是否已被清理，使finalize()得以检验其死亡条件（请参考第 4章）。58、finalize() 只可用于对象死亡条件的检验（请参考4章），俾有益于调试。特殊情况下可能需要释放一些不会被垃圾回收的内存。因为垃圾回收器可能不会被唤起处理你的对象，所以你无法使用finalize()执行必要的清理动作。基于这个原因，你得拟定自己的”清理用”函数。在class finalize()中，请检查确认对象的确已被清理，并在对象尚未被清理时，掷出衍生自Runtime Exception 的异常。使用这种架构前，请先确认finalize()在你的系统上可正常动作（这可能需要调用System.gc()来确认）。59、如果某个对象在某个特定范围（scope）内必须被清理（cleaned up）,而不是被垃圾回收机制收回，请使用以下方法；将对象初始化，成功后立刻进入拥有finally子句的一个try区段内。Finally子句会引发清理动作。60、当你在继承过程中覆写了finalize(),请记得调用super. Finalize()。但如果你的”直接上一层superclass”是Object，，就不需要这个动作。你应该让super.finalize() 成为被覆写（overridden）之finalize()的最后一个动作而不是第一个动作，用以确保base class的组件在你需要它们的时候仍然可用。61、当你撰写固定大小的对象容器，请将它们转换为数组–尤其是从某个函数返回此一容器时。通过这种方式，你可以获得数组的”编译期型别检验”的好处，而且数组接收者可能不需要”先将数组中的对象加以转型”便能加以使用。请注意，容器库的base class (Java. Util. Collection) 具有两个toArray()，能够达到这个目的。62、在interface(接口)和abstract class(抽象类)之间，优先选择前者。如果你知道某些东西即将被设计为一个base class,你的第一选择应该是让它成为interface;只有在一定得放进函数或数据成员时，才应该将它改为abstract class. Interface只和”客户端想进行什么动作”有关，class则比较把重心放在实现细节上。63、在构造函数中只做惟一必要动作：将对象设定至适当状态。避免调用其他函数（除了final函数），因为这些函数可能会被其他人覆写因而使你在建构过程中得不可预期的结果（请参考第7章以取得更详细的信息）。小型而简单的构造函数比较不可能掷出异常或引发问题。64、为了避免一个十分令人泄气的经验，请确认你的classpath中的每个名称，都只有一个未被放到packages里头class。否则编译器会先找到另一个名称相同的class，并回报错误消息。如果你怀疑你的classpath出了问题，试着从classpath中的每个起点查找同名的.class文件。最好还是将所有classes都放到packages里头。65、留意一不小心犯下的重载（overloading）错误。如果你覆写base class 函数时没有正确拼写其名称，那么便会增加一个新的函数，而不是覆写原有的函数。但是情况完全合法，所以你不会从编译器或执行期系统得到任何错误消息–你的程序代码只是无法正确作用，如此而已。66、当心过早最佳化。先让程序动起来，再让它快–但只有在你必须（也就是说只有在程序被证明在某段程序代码上遭遇效能瓶颈）时才这么做。除非你已经使用效能量测工具（profiler）找出瓶颈所在，否则你可能性只是在浪费你的时间。效能调校的”隐藏成本”便是让你的程序代码变得更不可读、更难维持。67、记住，程序代码被阅读的时间多于它被撰写的时间。清晰的设计能够制作出去易懂的程序。注解、细节说明、示例都是无价的。这些东西能够帮助你和你的后继者。如果没有其他信息，那么Java 线上文档找出一些有用的信息时，你所遭遇的挫败应该足以让你相信这一点。

名首字母应该大写。字段、方法以及对象（句柄）的首字母应小写。对于所有标识符，其中包含的所有单词都应紧靠在一起，而且大写中间单词的首字母

作为一只敬业的程序员，就是不能接受我的编程出现bug！可见我们对bug是如此的深恶痛觉！它已成为我们职业生涯中的拦路虎，所以今天精心为大家总结一下Java中常见的几种异常，望大家多多注意。1、java.lang.NullPointerException(空指针异常)调用了未经初始化的对象或者是不存在的对象。经常出现在创建图片，调用数组这些操作中，比如图片未经初始化，或者图片创建时的路径错误等等。对数组操作中出现空指针， 即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化， 依然是空的，所以还需要对每个元素都进行初始化（如果要调用的话）。2、 java.lang.ClassNotFoundException指定的类不存在这里主要考虑一下类的名称和路径是否正确即可，通常都是程序试图通过字符串来加载某个类时可能引发异常。比如：调用Class.forName();或者调用ClassLoad的finaSystemClass();或者LoadClass();3、 java.lang.NumberFormatException字符串转换为数字异常当试图将一个String转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常.如现在讲字符型的数据“123456”转换为数值型数据时，是允许的。但是如果字符型数据中包含了非数字型的字符，如123#56，此时转换为数值型时就会出现异常。系统就会捕捉到这个异常，并进行处理。4、java.lang.IndexOutOfBoundsException数组下标越界异常查看调用的数组或者字符串的下标值是不是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候先查看一下数组的length，以免出现这个异常。5、java.lang.IllegalArgumentException方法的参数错误比如g.setColor(int red,int green,int blue)这个方法中的三个值，如果有超过255的也会出现这个异常，因此一旦发现这个异常，我们要做的，就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。6、java.lang.IllegalAccessException没有访问权限当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了Package的情况下要注意这个异常。7、java.lang.ArithmeticException数学运算异常当算术运算中出现了除以零这样的运算就会出这样的异常。8、java.lang.ClassCastException数据类型转换异常当试图将对某个对象强制执行向下转型，但该对象又不可转换又不可转换为其子类的实例时将引发该异常，如下列代码。Object obj = new Integer(0);String str = obj;9、 java.lang.FileNotFoundException文件未找到异常当程序试图打开一个不存在的文件进行读写时将会引发该异常。该异常由FileInputStream,FileOutputStream,RandomAccessFile的构造器声明抛出，即使被操作的文件存在，但是由于某些原因不可访问，比如打开一个只读文件进行写入，这些构造方法仍然会引发异常。10、java.lang.ArrayStoreException数组存储异常当试图将类型不兼容类型的对象存入一个Object[]数组时将引发异常，如Object[] obj = new String[3]obj[0] = new Integer(0);11、java.lang.NoSuchMethodException方法不存在异常当程序试图通过反射来创建对象，访问(修改或读取)某个方法，但是该方法不存在就会引发异常。12、 java.lang.NoSuchFiledException方法不存在异常当程序试图通过反射来创建对象，访问(修改或读取)某个filed，但是该filed不存在就会引发异常。13、 java.lang.EOFException文件已结束异常当程序在输入的过程中遇到文件或流的结尾时，引发异常。因此该异常用于检查是否达到文件或流的结尾14、java.lang.InstantiationException实例化异常当试图通过Class的newInstance()方法创建某个类的实例,但程序无法通过该构造器来创建该对象时引发。Class对象表示一个抽象类，接口，数组类，基本类型 。该Class表示的类没有对应的构造器。15、java.lang.InterruptedException被中止异常当某个线程处于长时间的等待、休眠或其他暂停状态，而此时其他的线程通过Thread的interrupt方法终止该线程时抛出该异常。16、java.lang.CloneNotSupportedException 不支持克隆异常当没有实现Cloneable接口或者不支持克隆方法时,调用其clone()方法则抛出该异常。17、java.lang.OutOfMemoryException 内存不足错误当可用内存不足以让Java虚拟机分配给一个对象时抛出该错误。18、java.lang.NoClassDefFoundException 未找到类定义错误当Java虚拟机或者类装载器试图实例化某个类，而找不到该类的定义时抛出该错误。违背安全原则异常：SecturityException操作数据库异常：SQLException输入输出异常：IOException通信异常：SocketException以上便是Java常见的几种异常，希望各位同学都能编译出完美的代码，笑隐竹林中！编码bug，江湖永无相见！

Exception

有常量池的存在,可以让两个对象指向同一个String,此时他们代表的都是同一个字符串.不需要clone方法去克隆一个对象了.

LinkedList newList = new LinkedList(oldList);或者，LinkedList实现了Cloneable接口，直接调用clone()也可以。

http://blog.csdn.net/y_h_t/article/details/6322823你是一名java程序员，这些应该知道些吧

零基础开始学习

现在网上的Java教程一堆一堆的，看的我们很多Java宝宝们是眼花缭乱，不知该如何是好，我当年也是从这个过程走过来的，每天看很多itjob老师的Java教程，听的自己晕头转向的，当然我不是说他们讲错了，他们讲的知识层面的东西是对的，但是很多做Java教程的老师不善于深入浅出，通俗易懂的来为我们讲解知识，什么是好教程？好教程就是让我们学了之后，有一种豁然开朗的感觉，而不是云深不知处，我想说的是这种教程，不看也罢，浪费了时间，迷茫了自己。　　二 有一种教程叫无论你身处何地，都能现场直播教你　　现在很多网上流传的教程都是很多年前的，远远的不适应现在Java新应用的需要，基本上都是一些淘汰货，很多小伙伴们，从网上找这种破烂，学的还不亦乐乎，也是醉了。综上所述，我们很多人学不好Java，是因为 一开始就选择错了，选择不对，努力白费。为了能够让广大Java学子们在网上学到Java的系统精华知识，通俗易懂的理解这些知识，我们决定现在每天晚上现场直播在网上教大家学习Java，我们的老师，一般的老师不用，我们只让牛掰的老师讲，而你什么都不需要付出，你只需要来我们这个群里听就行，开头的的第一部分是：426.，位于中间的第二部分是：396，处于最后一部分的是：284，学习没有任何借口，想强大就要努力，同时这也不是一个单打独斗的时代了，大家在这里一块学习，打拼出属于我们的Java新天地。 　　三Java新手入门的30个基本概念　　在我们学习Java的过程中,掌握其中的基本概念对我们的学习无论是J2SE,J2EE,J2ME都是很重要的,J2SE是Java的基础,所以有必要对其中的基本概念做以归纳,以便大家在以后的学习过程中更好的理解java的精髓,在此我总结了30条基本的概念。　　Java概述:　　目前Java主要应用于中间件的开发(middleware)---处理客户机于服务器之间的通信技术,早期的实践证明,Java不适合pc应用程序的开发,其发展逐渐变成在开发手持设备,互联网信息站,及车载计算机的开发.Java于其他语言所不同的是程序运行时提供了平台的独立性,称许可以在windows,solaris,linux其他操作系统上使用完全相同的代码.Java的语法与C++语法类似,C++/C程序员很容易掌握,而且Java是完全的彻底的面向对象的,其中提出了很好的GC(Garbage Collector)垃圾处理机制,防止内存溢出。　　Java的白皮书为我们提出了Java语言的11个关键特质。　　(1)Easy:Java的语法比C++的相对简单,另一个方面就是Java能使软件在很小的机器上运行,基础解释其和类库的支持的大小约为40kb,增加基本的标准库和线程支持的内存需要增加125kb。　　(2)分布式:Java带有很强大的TCP/IP协议族的例程库,Java应用程序能够通过URL来穿过网络来访问远程对象,由于servlet机制的出现,使Java编程非常的高效,现在许多的大的web server都支持servlet。　　(3)OO:面向对象设计是把重点放在对象及对象的接口上的一个编程技术.其面向对象和C++有很多不同,在与多重继承的处理及Java的原类模型。　　(4)健壮特质:Java采取了一个安全指针模型,能减小重写内存和数据崩溃的可能型。　　(5)安全:Java用来设计网路和分布系统,这带来了新的安全问题,Java可以用来构建防病毒和防攻击的System.事实证明Java在防毒这一方面做的很优秀。　　(6)中立体系结构:Java编译其生成体系结构中立的目标文件格式可以在很多处理器上执行,编译器产生的指令字节码(Javabytecode)实现此特性,此字节码可以在任何机器上解释执行。　　(7)可移植:Java中对基本数据结构类型的大小和算法都有严格的规定所以可移植很好。　　(8)多线程:Java处理多线程的过程很简单,Java把多线程实现交给底下操作系统或线程程序完成.所以多线程是Java作为服务器端开发语言的流行原因之一。　　(9)Applet和servlet:能够在网页上执行的程序叫Applet,需要支持Java的浏览器很多,而applet支持动态的网页,这是很多其他语言所不能做到的。　　基本概念:　　1.OOP中唯一关系的是对象的接口是什么,就像计算机的销售商她不管电源内部结构是怎样的,他只关系能否给你提供电就行了,也就是只要知道can or not而不是how and why.所有的程序是由一定的属性和行为对象组成的,不同的对象的访问通过函数调用来完成,对象间所有的交流都是通过方法调用,通过对封装对象数据,很大限度上提高复用率。　　2.OOP中最重要的思想是类,类是模板是蓝图,从类中构造一个对象,即创建了这个类的一个实例(instance)。　　3.封装:就是把数据和行为结合起在一个包中)并对对象使用者隐藏数据的实现过程,一个对象中的数据叫他的实例字段(instance field)。　　4.通过扩展一个类来获得一个新类叫继承(inheritance),而所有的类都是由Object根超类扩展而得,根超类下文会做介绍。　　5.对象的3个主要特点　　behavior---说明这个对象能做什么.　　state---当对象施加方法时对象的反映.　　identity---与其他相似行为对象的区分标志.　　每个对象有唯一的indentity 而这3者之间相互影响.　　6.类之间的关系:　　use-a :依赖关系　　has-a :聚合关系　　is-a :继承关系--例:A类继承了B类,此时A类不仅有了B类的方法,还有其自己的方法.(个性存在于共性中)　　7.构造对象使用构造器:构造器的提出,构造器是一种特殊的方法,构造对象并对其初始化。　　例:Data类的构造器叫Data　　new Data()---构造一个新对象,且初始化当前时间.　　Data happyday=new Data()---把一个对象赋值给一个变量happyday,从而使该对象能够多次使用,此处要声明的使变量与对象变量二者是不同的.new返回的值是一个引用。　　构造器特点:构造器可以有0个,一个或多个参数　　构造器和类有相同的名字　　一个类可以有多个构造器　　构造器没有返回值　　构造器总是和new运算符一起使用.　　8.重载:当多个方法具有相同的名字而含有不同的参数时,便发生重载.编译器必须挑选出调用哪个方法。　　9.包(package)Java允许把一个或多个类收集在一起成为一组,称作包,以便于组织任务,标准Java库分为许多包.java.lang java.util java,net等,包是分层次的所有的java包都在java和javax包层次内。　　10.继承思想:允许在已经存在的类的基础上构建新的类,当你继承一个已经存在的类时,那么你就复用了这个类的方法和字段,同时你可以在新类中添加新的方法和字段。　　11.扩展类:扩展类充分体现了is-a的继承关系. 形式为:class (子类) extends (基类)。　　12.多态:在java中,对象变量是多态的.而java中不支持多重继承。　　13.动态绑定:调用对象方法的机制。　　(1)编译器检查对象声明的类型和方法名。　　(2)编译器检查方法调用的参数类型。　　(3)静态绑定:若方法类型为priavte static final 编译器会准确知道该调用哪个方法。　　(4)当程序运行并且使用动态绑定来调用一个方法时,那么虚拟机必须调用x所指向的对象的实际类型相匹配的方法版本。　　(5)动态绑定:是很重要的特性,它能使程序变得可扩展而不需要重编译已存代码。　　14.final类:为防止他人从你的类上派生新类,此类是不可扩展的。　　15.动态调用比静态调用花费的时间要长。　　16.抽象类:规定一个或多个抽象方法的类本身必须定义为abstract。　　例: public abstract string getDescripition　　17.Java中的每一个类都是从Object类扩展而来的。　　18.object类中的equal和toString方法。　　equal用于测试一个对象是否同另一个对象相等。　　toString返回一个代表该对象的字符串,几乎每一个类都会重载该方法,以便返回当前状态的正确表示.　　(toString 方法是一个很重要的方法)　　19.通用编程:任何类类型的所有值都可以同object类性的变量来代替。　　20.数组列表:ArrayList动态数组列表,是一个类库,定义在java.uitl包中,可自动调节数组的大小。　　21.class类 object类中的getclass方法返回ckass类型的一个实例,程序启动时包含在main方法的类会被加载,虚拟机要加载他需要的所有类,每一个加载的类都要加载它需要的类。　　22.class类为编写可动态操纵java代码的程序提供了强大的功能反射,这项功能为JavaBeans特别有用,使用反射Java能支持VB程序员习惯使用的工具。　　能够分析类能力的程序叫反射器,Java中提供此功能的包叫Java.lang.reflect反射机制十分强大.　　1.在运行时分析类的能力。　　2.在运行时探察类的对象。　　3.实现通用数组操纵代码。　　4.提供方法对象。　　而此机制主要针对是工具者而不是应用及程序。　　反射机制中的最重要的部分是允许你检查类的结构.用到的API有:　　java.lang.reflect.Field 返回字段.　　java.reflect.Method 返回方法.　　java.lang.reflect.Constructor 返回参数.　　方法指针:java没有方法指针,把一个方法的地址传给另一个方法,可以在后面调用它,而接口是更好的解决方案。　　23.接口(Interface)说明类该做什么而不指定如何去做,一个类可以实现一个或多个interface。　　24.接口不是一个类,而是对符合接口要求的类的一套规范。　　若实现一个接口需要2个步骤:　　1.声明类需要实现的指定接口。　　2.提供接口中的所有方法的定义。　　声明一个类实现一个接口需要使用implements 关键字　　class actionB implements Comparable 其actionb需要提供CompareTo方法,接口不是类,不能用new实例化一个接口.　　25.一个类只有一个超类,但一个类能实现多个接口。Java中的一个重要接口：Cloneable　　26.接口和回调.编程一个常用的模式是回调模式,在这种模式中你可以指定当一个特定时间发生时回调对象上的方法。　　例:ActionListener 接口监听.　　类似的API有:java.swing.JOptionPane　　java.swing.Timer　　java.awt.Tookit　　27.对象clone:clone方法是object一个保护方法,这意味着你的代码不能简单的调用它。　　28.内部类:一个内部类的定义是定义在另一个内部的类。

⑴浅复制(浅克隆)被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。⑵深复制(深克隆)被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。Java的clone()方法⑴clone方法将对象复制了一份并返回给调用者。一般而言，clone()方法满足：①对任何的对象x，都有x.clone() !=x//克隆对象与原对象不是同一个对象②对任何的对象x，都有x.clone().getClass()= =x.getClass()//克隆对象与原对象的类型一样③如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立。⑵Java中对象的克隆①为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。②在派生类中覆盖基类的clone()方法，并声明为public。③在派生类的clone()方法中，调用super.clone()。④在派生类中实现Cloneable接口。请看如下代码：class Student implements Cloneable{String name;int age;Student(String name,int age){this.name=name;this.age=age;}public Object clone(){Object o=null;try{o=(Student)super.clone();//Object中的clone()识别出你要复制的是哪一// 个对象。}catch(CloneNotSupportedException e){System.out.println(e.toString());} return o;}}public static void main(String[] args){Student s1=new Student("zhangsan",18);Student s2=(Student)s1.clone();s2.name="lisi";s2.age=20;System.out.println("name="+s1.name+","+"age="+s1.age);//修改学生2后，不影响 //学生1的值。}说明：①为什么我们在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢?在运行时刻，Object中的 clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。②继承自java.lang.Object类的clone()方法是浅复制。以下代码可以证明之。class Professor{String name;int age;Professor(String name,int age){this.name=name;this.age=age;}}class Student implements Cloneable{String name;//常量对象。int age;Professor p;//学生1和学生2的引用值都是一样的。Student(String name,int age,Professor p){ this.name=name;this.age=age;this.p=p;}public Object clone(){Student o=null;try{o=(Student)super.clone();}catch(CloneNotSupportedException e){System.out.println(e.toString());}o.p=(Professor)p.clone();return o;}}public static void main(String[] args){Professor p=new Professor("wangwu",50);Student s1=new Student("zhangsan",18,p);Student s2=(Student)s1.clone();s2.p.name="lisi";s2.p.age=30;System.out.println("name="+s1.p.name+","+"age="+s1.p.age);//学生1的教授 //成为lisi,age为30。}那应该如何实现深层次的克隆，即修改s2的教授不会影响s1的教授?代码改进如下。改进使学生1的Professor不改变(深层次的克隆)class Professor implements Cloneable{String name;int age;Professor(String name,int age){this.name=name;this.age=age;}public Object clone(){Object o=null;try{o=super.clone();}catch(CloneNotSupportedException e){System.out.println(e.toString());}#p#副标题#e#return o;}}class Student implements Cloneable{String name;int age;Professor p;Student(String name,int age,Professor p){this.name=name;this.age=age;this.p=p;}public Object clone(){Student o=null;try{o=(Student)super.clone();}catch(CloneNotSupportedException e){System.out.println(e.toString());}o.p=(Professor)p.clone();return o;}}public static void main(String[] args){Professor p=new Professor("wangwu",50);Student s1=new Student("zhangsan",18,p);Student s2=(Student)s1.clone();s2.p.name="lisi";s2.p.age=30;System.out.println("name="+s1.p.name+","+"age="+s1.p.age);//学生1的教授不改变。}3.利用串行化来做深复制把对象写到流里的过程是串行化(Serilization)过程，但是在Java程序师圈子里又非常形象地称为“冷冻”或者“腌咸菜(picking)”过程;而把对象从流中读出来的并行化(Deserialization)过程则叫做“解冻”或者“回鲜(depicking)”过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面，因此“腌成咸菜”的只是对象的一个拷贝，Java咸菜还可以回鲜。在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象(实际上只是对象的一个拷贝)写到一个流里(腌成咸菜)，再从流里读出来(把咸菜回鲜)，便可以重建对象。如下为深复制源代码。public Object deepClone(){//将对象写到流里ByteArrayOutoutStream bo=new ByteArrayOutputStream();ObjectOutputStream oo=new ObjectOutputStream(bo);oo.writeObject(this);//从流里读出来ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());ObjectInputStream oi=new ObjectInputStream(bi);return(oi.readObject());}这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将之排除在复制过程之外。上例代码改进如下。class Professor implements Serializable{String name;int age;Professor(String name,int age){this.name=name;this.age=age;}}class Student implements Serializable{String name;//常量对象。int age;Professor p;//学生1和学生2的引用值都是一样的。Student(String name,int age,Professor p){this.name=name;this.age=age;this.p=p;}public Object deepClone() throws IOException,OptionalDataException,ClassNotFoundException{//将对象写到流里ByteArrayOutoutStream bo=new ByteArrayOutputStream();ObjectOutputStream oo=new ObjectOutputStream(bo);oo.writeObject(this);//从流里读出来ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());ObjectInputStream oi=new ObjectInputStream(bi);return(oi.readObject());}}public static void main(String[] args){Professor p=new Professor("wangwu",50);Student s1=new Student("zhangsan",18,p);Student s2=(Student)s1.deepClone();s2.p.name="lisi";s2.p.age=30;System.out.println("name="+s1.p.name+","+"age="+s1.p.age); //学生1的教授不改变。}#p#副标题#e#

S1.clone()String中没有这个方法，你是不是写错了你要是想赋值的话这么写就可以了String S1="It"s a string for test."; String S2=S1; System.out.println(S2);

很简单啊。克隆就是克隆内容和自己一样的 一个对象被。比如有个A类 A a=new A();首先按你说的A aa=a;这样不叫克隆 只是多添加了个引用 既 a 改变东西后。 aa 也跟着改变了如果要用 A aa=(A)a.clone() 那么aa内容被改变 a 的内容是不会跟着改变的 super.clone() 是就是先把自己的父类 克隆先。 就要还是理解下。就是克隆出一个完全和自己 一样的 类。。自然要从最上层开始。克隆了。克隆要实现Cloneable接口

我记得信息工程学的科目是这样的，c语言，然后c++，然后java基础编程，然后安卓系统编程，这些个都是要考证的，c语言不难，c++听说挺难的

这方法在Object中并未实现/** * Creates and returns a copy of this object. The precise meaning * of "copy" may depend on the class of the object. The general * intent is that, for any object <tt>x</tt>, the expression: * <blockquote> * <pre> * x.clone() != x</pre></blockquote> * will be true, and that the expression: * <blockquote> * <pre> * x.clone().getClass() == x.getClass()</pre></blockquote> * will be <tt>true</tt>, but these are not absolute requirements. * While it is typically the case that: * <blockquote> * <pre> * x.clone().equals(x)</pre></blockquote> * will be <tt>true</tt>, this is not an absolute requirement. * <p> * By convention, the returned object should be obtained by calling * <tt>super.clone</tt>. If a class and all of its superclasses (except * <tt>Object</tt>) obey this convention, it will be the case that * <tt>x.clone().getClass() == x.getClass()</tt>. * <p> * By convention, the object returned by this method should be independent * of this object (which is being cloned). To achieve this independence, * it may be necessary to modify one or more fields of the object returned * by <tt>super.clone</tt> before returning it. Typically, this means * copying any mutable objects that comprise the internal "deep structure" * of the object being cloned and replacing the references to these * objects with references to the copies. If a class contains only * primitive fields or references to immutable objects, then it is usually * the case that no fields in the object returned by <tt>super.clone</tt> * need to be modified. * <p> * The method <tt>clone</tt> for class <tt>Object</tt> performs a * specific cloning operation. First, if the class of this object does * not implement the interface <tt>Cloneable</tt>, then a * <tt>CloneNotSupportedException</tt> is thrown. Note that all arrays * are considered to implement the interface <tt>Cloneable</tt>. * Otherwise, this method creates a new instance of the class of this * object and initializes all its fields with exactly the contents of * the corresponding fields of this object, as if by assignment; the * contents of the fields are not themselves cloned. Thus, this method * performs a "shallow copy" of this object, not a "deep copy" operation. * <p> * The class <tt>Object</tt> does not itself implement the interface * <tt>Cloneable</tt>, so calling the <tt>clone</tt> method on an object * whose class is <tt>Object</tt> will result in throwing an * exception at run time. * * @return a clone of this instance. * @exception CloneNotSupportedException if the object"s class does not * support the <code>Cloneable</code> interface. Subclasses * that override the <code>clone</code> method can also * throw this exception to indicate that an instance cannot * be cloned. * @see java.lang.Cloneable */ protected native Object clone() throws CloneNotSupportedException;

利用Java开发数据库应用系统时，经常需要在用户界面上显示查询结果。由于SUN公司提供的JDK1.x开发工具包不是可视化的集成开发环境（IDE），不能象Delphi、VB那样方便地把查询结果在DBGrid等表格中显示出来。因此，只能靠自己编写代码来实现。 在实际应用中，我们可以利用Vector、JTable、AbstractTableModel等三个类较好地解决这一问题。以下，详细介绍一下实现方法。· 一、 类Vector、类JTable及类AbstractTableModel简介：1、 类Vector： 类Vector是Java的历史集合类，隶属于java.util包。它包装了异构链表和数组杂合体，具有以下两个特点： * 向量是异构的，不要求每个元素的类型相同，向量中可以混合多种对象类型； * 向量是数组杂合体，因为它们可以在增加元素时动态增大。 其异构性正好符合数据库记录中属性类型不一的特点，而其动态性也正好符合数据库查询时，结果集记录个数不定的特点。 类Vector定义如下： public class Vector extends AbstractList implements List , Cloneable , Serializable{…} 实现了向量成员的查找、新增、删除等方法。如：add(Object obj)可方便地加入一个对象；get(int index)可方便地得到向量中的一个对象；remove(Object obj)。则可方便地删除向量中一个对象。· 2、 类JTable： JTable组件是Swing组件中比较复杂的小件，隶属于javax.swing包，它能以二维表的形式显示数据。类JTable定义如下： public class JTable extends JComponent implements TableModelListener, Scrollable, TableColumnModelListener, ListSelectionListener, CellEditorListener, Accessible{…} 类JTable在显示数据时具有以下特点： * 可定制性：可以定制数据的显示方式和编辑状态； * 异构性：可以显示不同类型的数据对象，甚至包括颜色、图标等复杂对象； * 简便性：可以以缺省方式轻松地建立起一个二维表。 其可定制性可满足不同用户和场合的要求，异构性也正好符合数据库访问结果集中属性类型不一的特点。类JTable提供了极为丰富的二维表格操作方法，如设置编辑状态、显示方式、选择行列等，在此不一一赘述。 使用类JTable显示数据之前，必须根据情况生成定制模型、单元绘制器或单元编辑器。类AbstractListModel用来定制用户自己的数据模型，这个类在后面要介绍。TableCellRenderer接口用来定制单元绘制器，TableCellEditor接口用来定制单元编辑器，这两个接口主要用于颜色对象的处理上，在示例中没有用到，不做过多说明。· 3、 类AbstractTableModel： 类AbstractTableModel是一个抽象类，没有完全实现，不能实例化，使用时必须在程序中实现方法。它隶属于javax.swing.table 。类定义如下： public abstract class AbstractTableModel extends Object implements TableModel, Serializable{…} 类AbstractTableModel提供了TableModel接口中绝大多数方法的缺省实现。TableModel接口定义了JTable 的基础数据结构。用户要生成自己的数据模型，本来可以通过实现TableModel接口中所有方法来满足要求，但管理听众表的功能对于所有数据模型是共同的，所以在javax.swing.table中又定义了类AbstractTableModel来处理这个工作。它既管理听众表，又为生成TableModelEvents事件并委托给听众提供了便利。 要想生成一个具体的TableModel作为AbstractTableMode的子类，至少必须实现下面三个方法： public int getRowCount(); public int getColumnCount(); public Object getValueAt(int row, int column); 至此，我们可以建立一个简单二维表（5×5），实现方法如下： TableModel dataModel = new AbstractTableModel() { public int getColumnCount() { return 5; } public int getRowCount() { return 5;} public Object getValueAt(int row, int col) { return new Integer(row*col); } }; JTable table = new JTable(dataModel); JScrollPane scrollpane = new JScrollPane(table);· 二、 数据库及其连接方法简介： 示例采用Sybase数据库系统，数据库存放在数据库服务器中。路径为：D:/WORKER，数据库名为：worker.dbf。具有以下字段： 字段名 类型 Wno（职工号） VARCHAR Wname（职工名） VARCHAR Sex（性别） VARCHAR Birthday（出生日期） DATE Wage（工资） FLOAT 要连接此数据库，需使用java.sql包中的类DriverManager。此类是用于管理JDBC驱动程序的实用程序类。它提供了通过驱动程序取得连接、注册，撤消驱动程序， 设置登记和数据库访问登录超时等方法。具体连接方法如下： 第一步：定位、装入和链接SybDriver类； driver="com.sybase.jdbc.SybDriver"; SybDriver sybdriver=(SybDriver)Class.forName(driver).newInstance(); 第二步：注册SybDriver类； DriverManager.registerDriver(sybdriver); 第三步：取得连接（SybConnection）对象引用。 user="sa"; password=""; url="jdbc:sybase:Tds:202.117.203.114:5000/WORKER"; SybConnection connection=(SybConnection)DriverManager.getConnection (url,user,password); 建立完连接后，即可通过Statement接口进行数据库的查询与更改。· 三、 实现方法： 限于篇幅，在此只给出核心代码，包引入、界面处理、变量定义等部分不再介绍。 第一步：对象声明。 AbstractTableModel tm;//声明一个类AbstractTableModel对象 JTable jg_table;//声明一个类JTable对象 Vector vect;//声明一个向量对象 JScrollPane jsp;//声明一个滚动杠对象 String title[]={"职工号","职工名","性别","出生日期","工资"}; //二维表列名 第二步：定制表格。 1、实现抽象类AbstractTableModel对象tm中的方法： vect=new Vector();//实例化向量 tm=new AbstractTableModel(){ public int getColumnCount(){ return title.length;}//取得表格列数 public int getRowCount(){ return vect.size();}//取得表格行数 public Object getValueAt(int row,int column){ if(!vect.isEmpty()) return ((Vector)vect.elementAt(row)).elementAt(column); else return null;}//取得单元格中的属性值 public String getColumnName(int column){ return title[column];}//设置表格列名 public void setValueAt(Object value,int row,int column){} //数据模型不可编辑，该方法设置为空 public Class getColumnClass(int c){ return getValueAt(0,c).getClass(); }//取得列所属对象类 public boolean isCellEditable(int row,int column){ return false;}//设置单元格不可编辑，为缺省实现 }; 2、定制表格： jg_table=new JTable(tm);//生成自己的数据模型 jg_table.setToolTipText("显示全部查询结果");//设置帮助提示 jg_table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF); //设置表格调整尺寸模式 jg_table.setCellSelectionEnabled(false);//设置单元格选择方式 jg_table.setShowVerticalLines(true);//设置是否显示单元格间的分割线 jg_table.setShowHorizontalLines(true); jsp=new JScrollPane(jg_table);//给表格加上滚动杠 第三步：显示查询结果。 1、 连接数据库：第二部分已给出。 2、 数据库查询： Statement stmt=connection.createStatement(); ResultSet rs=stmt.executeQuery("select * from worker"); 3、 显示查询结果： vect.removeAllElements();//初始化向量对象 tm.fireTableStructureChanged();//更新表格内容 while(rs.next()){ Vector rec_vector=new Vector(); //从结果集中取数据放入向量rec_vector中 rec_vector.addElement(rs.getString(1)); rec_vector.addElement(rs.getString(2)); rec_vector.addElement(rs.getString(3)); rec_vector.addElement(rs.getDate(4)); rec_vector.addElement(new Float(rs.getFloat(5))); vect.addElement(rec_vector);//向量rec_vector加入向量vect中 } tm.fireTableStructureChanged();//更新表格，显示向量vect的内容。

顺序的，带Linked的是链接的。LinkedList是链表。set是无序的

不清楚，我也准备转

1.Object中的clone执行的时候使用了RTTI（run-time type identification）的机制,动态得找到目前正在调用clone方法的那个reference，根据它的大小申请内存空间，然后进行bitwise的复制，将该对象的内存空间完全复制到新的空间中去，从而达到shallowcopy的目的。 x0dx0a 所以你调用super.clone() 得到的是当前调用类的副本，而不是父类的副本。根本没有必用调用this.clone();x0dx0a2.要让实例调用clone方法就需要让此类实现Cloneable接口，API里面还有句话是：如果在没有实现 Cloneable 接口的实例上调用 Object 的 clone 方法，则会导致抛出 CloneNotSupportedException 异常，这便是“合法”的含义。 但请注意，Cloneable接口只是个标签接口，不含任何需要实现的方法，就像Serializable接口一样。x0dx0ax0dx0a总之，一般如果你的子类没有特殊需要而重写clone()方法就直接用super.clone() 就行了。

有呀，其实你可以敲一下代码就知道。

1. java.lang.nullpointerexception 这个异常大家肯定都经常遇到，异常的解释是"程序遇上了空指针"，简单地说就是调用了未经初始化的对象或者是不存在的对象，这个错误经常出现在创建图片，调用数组这些操作中，比如图片未经初始化，或者图片创建时的路径错误等等。对数组操作中出现空指针，很多情况下是一些刚开始学习编程的朋友常犯的错误，即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化，依然是空的，所以还需要对每个元素都进行初始化（如果要调用的话） 2. java.lang.classnotfoundexception 这个异常是很多原本在jb等开发环境中开发的程序员，把jb下的程序包放在wtk下编译经常出现的问题，异常的解释是"指定的类不存在"，这里主要考虑一下类的名称和路径是否正确即可，如果是在jb下做的程序包，一般都是默认加上package的，所以转到wtk下后要注意把package的路径加上。 3. java.lang.arithmeticexception 这个异常的解释是"数学运算异常"，比如程序中出现了除以零这样的运算就会出这样的异常，对这种异常，大家就要好好检查一下自己程序中涉及到数学运算的地方，公式是不是有不妥了。 4. java.lang.arrayindexoutofboundsexception 这个异常相信很多朋友也经常遇到过，异常的解释是"数组下标越界"，现在程序中大多都有对数组的操作，因此在调用数组的时候一定要认真检查，看自己调用的下标是不是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以免出现这个异常。 5. java.lang.illegalargumentexception 这个异常的解释是"方法的参数错误"，很多j2me的类库中的方法在一些情况下都会引发这样的错误，比如音量调节方法中的音量参数如果写成负数就会出现这个异常，再比如g.setcolor(int red,int green,int blue)这个方法中的三个值，如果有超过255的也会出现这个异常，因此一旦发现这个异常，我们要做的，就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。 6. java.lang.illegalaccessexception 这个异常的解释是"没有访问权限"，当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了package的情况下要注意这个异常。 其他还有很多异常，我就不一一列举了，我要说明的是，一个合格的程序员，需要对程序中常见的问题有相当的了解和相应的解决办法，否则仅仅停留在写程序而不会改程序的话，会极大影响到自己的开发的。关于异常的全部说明，在api里都可以查阅。算术异常类：ArithmeticExecption空指针异常类：NullPointerException类型强制转换异常：ClassCastException数组负下标异常：NegativeArrayException数组下标越界异常：ArrayIndexOutOfBoundsException违背安全原则异常：SecturityException文件已结束异常：EOFException文件未找到异常：FileNotFoundException字符串转换为数字异常：NumberFormatException操作数据库异常：SQLException输入输出异常：IOException方法未找到异常：NoSuchMethodExceptionjava.lang.AbstractMethodError抽象方法错误。当应用试图调用抽象方法时抛出。java.lang.AssertionError断言错。用来指示一个断言失败的情况。java.lang.ClassCircularityError类循环依赖错误。在初始化一个类时，若检测到类之间循环依赖则抛出该异常。java.lang.ClassFormatError类格式错误。当Java虚拟机试图从一个文件中读取Java类，而检测到该文件的内容不符合类的有效格式时抛出。java.lang.Error错误。是所有错误的基类，用于标识严重的程序运行问题。这些问题通常描述一些不应被应用程序捕获的反常情况。java.lang.ExceptionInInitializerError初始化程序错误。当执行一个类的静态初始化程序的过程中，发生了异常时抛出。静态初始化程序是指直接包含于类中的static语句段。java.lang.IllegalAccessError违法访问错误。当一个应用试图访问、修改某个类的域（Field）或者调用其方法，但是又违反域或方法的可见性声明，则抛出该异常。java.lang.IncompatibleClassChangeError不兼容的类变化错误。当正在执行的方法所依赖的类定义发生了不兼容的改变时，抛出该异常。一般在修改了应用中的某些类的声明定义而没有对整个应用重新编译而直接运行的情况下，容易引发该错误。java.lang.InstantiationError实例化错误。当一个应用试图通过Java的new操作符构造一个抽象类或者接口时抛出该异常.java.lang.InternalError内部错误。用于指示Java虚拟机发生了内部错误。java.lang.LinkageError链接错误。该错误及其所有子类指示某个类依赖于另外一些类，在该类编译之后，被依赖的类改变了其类定义而没有重新编译所有的类，进而引发错误的情况。java.lang.NoClassDefFoundError未找到类定义错误。当Java虚拟机或者类装载器试图实例化某个类，而找不到该类的定义时抛出该错误。java.lang.NoSuchFieldError域不存在错误。当应用试图访问或者修改某类的某个域，而该类的定义中没有该域的定义时抛出该错误。java.lang.NoSuchMethodError方法不存在错误。当应用试图调用某类的某个方法，而该类的定义中没有该方法的定义时抛出该错误。java.lang.OutOfMemoryError内存不足错误。当可用内存不足以让Java虚拟机分配给一个对象时抛出该错误。java.lang.StackOverflowError堆栈溢出错误。当一个应用递归调用的层次太深而导致堆栈溢出时抛出该错误。java.lang.ThreadDeath线程结束。当调用Thread类的stop方法时抛出该错误，用于指示线程结束。java.lang.UnknownError未知错误。用于指示Java虚拟机发生了未知严重错误的情况。java.lang.UnsatisfiedLinkError未满足的链接错误。当Java虚拟机未找到某个类的声明为native方法的本机语言定义时抛出。java.lang.UnsupportedClassVersionError不支持的类版本错误。当Java虚拟机试图从读取某个类文件，但是发现该文件的主、次版本号不被当前Java虚拟机支持的时候，抛出该错误。java.lang.VerifyError验证错误。当验证器检测到某个类文件中存在内部不兼容或者安全问题时抛出该错误。java.lang.VirtualMachineError虚拟机错误。用于指示虚拟机被破坏或者继续执行操作所需的资源不足的情况。java.lang.ArithmeticException算术条件异常。譬如：整数除零等。java.lang.ArrayIndexOutOfBoundsException数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。java.lang.ArrayStoreException数组存储异常。当向数组中存放非数组声明类型对象时抛出。java.lang.ClassCastException类造型异常。假设有类A和B（A不是B的父类或子类），O是A的实例，那么当强制将O构造为类B的实例时抛出该异常。该异常经常被称为强制类型转换异常。java.lang.ClassNotFoundException找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。java.lang.CloneNotSupportedException不支持克隆异常。当没有实现Cloneable接口或者不支持克隆方法时,调用其clone()方法则抛出该异常。java.lang.EnumConstantNotPresentException枚举常量不存在异常。当应用试图通过名称和枚举类型访问一个枚举对象，但该枚举对象并不包含常量时，抛出该异常。java.lang.Exception根异常。用以描述应用程序希望捕获的情况。java.lang.IllegalAccessException违法的访问异常。当应用试图通过反射方式创建某个类的实例、访问该类属性、调用该类方法，而当时又无法访问类的、属性的、方法的或构造方法的定义时抛出该异常。java.lang.IllegalMonitorStateException违法的监控状态异常。当某个线程试图等待一个自己并不拥有的对象（O）的监控器或者通知其他线程等待该对象（O）的监控器时，抛出该异常。java.lang.IllegalStateException违法的状态异常。当在Java环境和应用尚未处于某个方法的合法调用状态，而调用了该方法时，抛出该异常。java.lang.IllegalThreadStateException违法的线程状态异常。当县城尚未处于某个方法的合法调用状态，而调用了该方法时，抛出异常。java.lang.IndexOutOfBoundsException索引越界异常。当访问某个序列的索引值小于0或大于等于序列大小时，抛出该异常。java.lang.InstantiationException实例化异常。当试图通过newInstance()方法创建某个类的实例，而该类是一个抽象类或接口时，抛出该异常。java.lang.InterruptedException被中止异常。当某个线程处于长时间的等待、休眠或其他暂停状态，而此时其他的线程通过Thread的interrupt方法终止该线程时抛出该异常。java.lang.NegativeArraySizeException数组大小为负值异常。当使用负数大小值创建数组时抛出该异常。java.lang.NoSuchFieldException属性不存在异常。当访问某个类的不存在的属性时抛出该异常。java.lang.NoSuchMethodException方法不存在异常。当访问某个类的不存在的方法时抛出该异常。java.lang.NullPointerException空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。java.lang.NumberFormatException数字格式异常。当试图将一个String转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常。java.lang.RuntimeException运行时异常。是所有Java虚拟机正常操作期间可以被抛出的异常的父类。java.lang.SecurityException安全异常。由安全管理器抛出，用于指示违反安全情况的异常。java.lang.StringIndexOutOfBoundsException字符串索引越界异常。当使用索引值访问某个字符串中的字符，而该索引值小于0或大于等于序列大小时，抛出该异常。java.lang.TypeNotPresentException类型不存在异常。当应用试图

非常简单的道理，clone方法是重写的基类Object中的方法，所以通过super.clone()就可以指向它的内存引用复制出一个新的对象。至于为什么不用this.clone().在实现了cloneable接口重写了Clone方法后，在这个clone方法体中如果调用this.clone()就是调用自身的这个方法，陷入递归调用中从而形成死循环抛异常，所以不能使用this.clone()

推荐的那个答案其实不精确的。首先，“RuntimeException发生后，说明代码存在BUG”这句话是没问题的，但用来说明RuntimeException却不合适，也没有意义。因为发生任何未处理的异常，都说明代码存在BUG。这句话如何理解呢，就拿ArrayIndexOutOfBoundsException来说，数组下标越界，你定义一个int is = new int[5];然后for(int index = 0;index<6;index++){int i = is[index];...}如果不看"..."中的内容，数组一定会越界，程序一定会在这里抛出异常。但如果...换成了 if(i == 4) break;那么这段代码就完全没有问题了。一般的ide，简单的代码逻辑是能分析出可能出现的情况并提示你的（但不会强制要求你改，因为语法没问题）。但编译器和ide不可能在编译时深入的去研究你的代码逻辑是否正常。而且你这段代码在语法上完全没有问题，它在编译时根本不知道这个异常是否会抛出，但是！如果下标越界那确实有问题，异常就必须要抛。所以就有人这样理解运行时异常：“RunTime：运行时，很简单，就是“运行时”异常。它表明，这个异常只有在运行的时候才能知道是否有异常，这就是运行时异常，又叫不可查异常，而编译时异常又叫可查异常！”这种说法不能算错，但也不严谨，因为很多编译时异常也是不可查的。比如你要读某一个文件123.txt，在编译时，编译器是不会去检查这个文件是否存在的（有人说，那编译时为什么不检查？你这样想：如果编译时文件存在，而且当程序还没执行到这里时，我把文件删了怎么办），这种情况下，程序也只有在运行时，才能知道文件是否存在，按上面的说法，这个异常(FileNotFoundException)也应该是运行时异常才对。但，稍微玩过java的人都知道，这个异常被强制要求处理，它是编译时异常。既然编译时异常和运行时异常都可能无法预期，那为什么还要有运行时异常和编译时异常之分呢，这个答案我找遍网络也找不到，java官方也没有详细说明，只是说运行时异常不强制要求处理，jvm会自动接管并一直向上抛出，直到栈顶或被处理。所以我自己总结了一点，我也不知道是否正确：RuntimeException，只是为了“减少代码中对异常做的处理而必须写代码”而引入的。拿一个很常见的运行时异常：nullPointException。空指针异常。这个异常发生在一个对象是null时，你对它进行了方法调用等操作。在java中，所有的Object都可以赋值为null的，如果NullPointException强制需要处理的话，那么几乎你的每一句代码都应该被try{}catch（NullpointException){}所包括，这样的java代码想想都可怕。我在一些网站上找到了这么一句话：“RuntimeException 类及其子类表示‘JVM 常用操作"引发的错误”，没错，这句话可能正说明了重点，正是因为这些异常发生在“JVM常用操作”中，也就是说这些异常随处都可能发生，而你不可能在代码的所有地方都try{}catch(RuntimeException){}，所以为了简化代码，JVM对这些异常进行了默认处理：“抛出”。归根结底，运行时异常就是为了减少try{}catch(){}或throws 这类代码而引入的。纯手打，完全个人见解，欢迎讨论。

我们知道在Java中存在这个接口Cloneable，实现该接口的类都会具备被拷贝的能力，同时拷贝是在内存中进行，在性能方面比我们直接通过new生成对象来的快，特别是在大对象的生成上，使得性能的提升非常明显。然而我们知道拷贝分为深拷贝和浅拷贝之分，但是浅拷贝存在对象属性拷贝不彻底问题。关于深拷贝、浅拷贝的请参考这里：渐析java的浅拷贝和深拷贝一、浅拷贝问题我们先看如下代码：[java] view plain copypublic class Person implements Cloneable{ /** 姓名 **/ private String name; /** 电子邮件 **/ private Email email; public String getName() { return name; } public void setName(String name) { this.name = name; } public Email getEmail() { return email; } public void setEmail(Email email) { this.email = email; } public Person(String name,Email email){ this.name = name; this.email = email; } public Person(String name){ this.name = name; } protected Person clone() { Person person = null; try { person = (Person) super.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return person; } } public class Client { public static void main(String[] args) { //写封邮件 Email email = new Email("请参加会议","请与今天12:30到二会议室参加会议..."); Person person1 = new Person("张三",email); Person person2 = person1.clone(); person2.setName("李四"); Person person3 = person1.clone(); person3.setName("王五"); System.out.println(person1.getName() + "的邮件内容是：" + person1.getEmail().getContent()); System.out.println(person2.getName() + "的邮件内容是：" + person2.getEmail().getContent()); System.out.println(person3.getName() + "的邮件内容是：" + person3.getEmail().getContent()); } } -------------------- Output: 张三的邮件内容是：请与今天12:30到二会议室参加会议... 李四的邮件内容是：请与今天12:30到二会议室参加会议... 王五的邮件内容是：请与今天12:30到二会议室参加会议... 在该应用程序中，首先定义一封邮件，然后将该邮件发给张三、李四、王五三个人，由于他们是使用相同的邮件，并且仅有名字不同，所以使用张三该对象类拷贝李四、王五对象然后更改下名字即可。程序一直到这里都没有错，但是如果我们需要张三提前30分钟到，即把邮件的内容修改下：[java] view plain copypublic class Client { public static void main(String[] args) { //写封邮件 Email email = new Email("请参加会议","请与今天12:30到二会议室参加会议..."); Person person1 = new Person("张三",email); Person person2 = person1.clone(); person2.setName("李四"); Person person3 = person1.clone(); person3.setName("王五"); person1.getEmail().setContent("请与今天12:00到二会议室参加会议..."); System.out.println(person1.getName() + "的邮件内容是：" + person1.getEmail().getContent()); System.out.println(person2.getName() + "的邮件内容是：" + person2.getEmail().getContent()); System.out.println(person3.getName() + "的邮件内容是：" + person3.getEmail().getContent()); } } 在这里同样是使用张三该对象实现对李四、王五拷贝，最后将张三的邮件内容改变为：请与今天12:00到二会议室参加会议...。但是结果是：[java] view plain copy张三的邮件内容是：请与今天12:00到二会议室参加会议... 李四的邮件内容是：请与今天12:00到二会议室参加会议... 王五的邮件内容是：请与今天12:00到二会议室参加会议... 这里我们就疑惑了为什么李四和王五的邮件内容也发送了改变呢？让他们提前30分钟到人家会有意见的！其实出现问题的关键就在于clone()方法上，我们知道该clone()方法是使用Object类的clone()方法，但是该方法存在一个缺陷，它并不会将对象的所有属性全部拷贝过来，而是有选择性的拷贝，基本规则如下：1、 基本类型如果变量是基本很类型，则拷贝其值，比如int、float等。2、 对象如果变量是一个实例对象，则拷贝其地址引用，也就是说此时新对象与原来对象是公用该实例变量。3、 String字符串若变量为String字符串，则拷贝其地址引用。但是在修改时，它会从字符串池中重新生成一个新的字符串，原有紫都城对象保持不变。基于上面上面的规则，我们很容易发现问题的所在，他们三者公用一个对象，张三修改了该邮件内容，则李四和王五也会修改，所以才会出现上面的情况。对于这种情况我们还是可以解决的，只需要在clone()方法里面新建一个对象，然后张三引用该对象即可：[java] view plain copyprotected Person clone() { Person person = null; try { person = (Person) super.clone(); person.setEmail(new Email(person.getEmail().getObject(),person.getEmail().getContent())); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return person; } 所以：浅拷贝只是Java提供的一种简单的拷贝机制，不便于直接使用。对于上面的解决方案还是存在一个问题，若我们系统中存在大量的对象是通过拷贝生成的，如果我们每一个类都写一个clone()方法，并将还需要进行深拷贝，新建大量的对象，这个工程是非常大的，这里我们可以利用序列化来实现对象的拷贝。二、利用序列化实现对象的拷贝如何利用序列化来完成对象的拷贝呢？在内存中通过字节流的拷贝是比较容易实现的。把母对象写入到一个字节流中，再从字节流中将其读出来，这样就可以创建一个新的对象了，并且该新对象与母对象之间并不存在引用共享的问题，真正实现对象的深拷贝。[java] view plain copypublic class CloneUtils { @SuppressWarnings("unchecked") public static <T extends Serializable> T clone(T obj){ T cloneObj = null; try { //写入字节流 ByteArrayOutputStream out = new ByteArrayOutputStream(); ObjectOutputStream obs = new ObjectOutputStream(out); obs.writeObject(obj); obs.close(); //分配内存，写入原始对象，生成新对象 ByteArrayInputStream ios = new ByteArrayInputStream(out.toByteArray()); ObjectInputStream ois = new ObjectInputStream(ios); //返回生成的新对象 cloneObj = (T) ois.readObject(); ois.close(); } catch (Exception e) { e.printStackTrace(); } return cloneObj; } } 使用该工具类的对象必须要实现Serializable接口，否则是没有办法实现克隆的。[html] view plain copypublic class Person implements Serializable{ private static final long serialVersionUID = 2631590509760908280L; .................. //去除clone()方法 } public class Email implements Serializable{ private static final long serialVersionUID = 1267293988171991494L; .................... } 所以使用该工具类的对象只要实现Serializable接口就可实现对象的克隆，无须继承Cloneable接口实现clone()方法。

set集合中的数据没有顺序，且如果add两个一样的对象或基本类型的数据，set集合里也是只有一个，即set集合中的数据都是独一无二的；不能使用加强的for循环；list中的数据是有顺序的，可以加入多个一样的对象和基本类型的数据，可使用加强的for循环；map集合是键值对的形式进行存储，一个key，一个value。

clone()方法

浅克隆就是只能在本机识别的，深克隆就是其他平台也能识别的，这个需要用到序列化

java复制对象：一、使用clone。对象可克隆的类必须实现Cloneable接口，并且clone方法是浅克隆。二、类实现Serializable，用ObjectOutputStream、ObjectInputStream 来复制对象。三、可以直接new一个对象，赋值！

1. java.lang.nullpointerexception这个异常大家肯定都经常遇到，异常的解释是"程序遇上了空指针"，简单地说就是调用了未经初始化的对象或者是不存在的对象，这个错误经常出现在创建图片，调用数组这些操作中，比如图片未经初始化，或者图片创建时的路径错误等等。对数组操作中出现空指针，很多情况下是一些刚开始学习编程的朋友常犯的错误，即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化，依然是空的，所以还需要对每个元素都进行初始化（如果要调用的话）2. java.lang.classnotfoundexception这个异常是很多原本在jb等开发环境中开发的程序员，把jb下的程序包放在wtk下编译经常出现的问题，异常的解释是"指定的类不存在"，这里主要考虑一下类的名称和路径是否正确即可，如果是在jb下做的程序包，一般都是默认加上package的，所以转到wtk下后要注意把package的路径加上。3. java.lang.arithmeticexception这个异常的解释是"数学运算异常"，比如程序中出现了除以零这样的运算就会出这样的异常，对这种异常，大家就要好好检查一下自己程序中涉及到数学运算的地方，公式是不是有不妥了。4. java.lang.arrayindexoutofboundsexception这个异常相信很多朋友也经常遇到过，异常的解释是"数组下标越界"，现在程序中大多都有对数组的操作，因此在调用数组的时候一定要认真检查，看自己调用的下标是不是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以免出现这个异常。5. java.lang.illegalargumentexception这个异常的解释是"方法的参数错误"，很多j2me的类库中的方法在一些情况下都会引发这样的错误，比如音量调节方法中的音量参数如果写成负数就会出现这个异常，再比如g.setcolor(int red,int green,int blue)这个方法中的三个值，如果有超过255的也会出现这个异常，因此一旦发现这个异常，我们要做的，就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。6. java.lang.illegalaccessexception这个异常的解释是"没有访问权限"，当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了package的情况下要注意这个异常。其他还有很多异常，我就不一一列举了，我要说明的是，一个合格的程序员，需要对程序中常见的问题有相当的了解和相应的解决办法，否则仅仅停留在写程序而不会改程序的话，会极大影响到自己的开发的。关于异常的全部说明，在api里都可以查阅。算术异常类：ArithmeticExecption空指针异常类：NullPointerException类型强制转换异常：ClassCastException数组负下标异常：NegativeArrayException数组下标越界异常：ArrayIndexOutOfBoundsException违背安全原则异常：SecturityException文件已结束异常：EOFException文件未找到异常：FileNotFoundException字符串转换为数字异常：NumberFormatException操作数据库异常：SQLException输入输出异常：IOException方法未找到异常：NoSuchMethodExceptionjava.lang.AbstractMethodError抽象方法错误。当应用试图调用抽象方法时抛出。java.lang.AssertionError断言错。用来指示一个断言失败的情况。java.lang.ClassCircularityError类循环依赖错误。在初始化一个类时，若检测到类之间循环依赖则抛出该异常。java.lang.ClassFormatError类格式错误。当Java虚拟机试图从一个文件中读取Java类，而检测到该文件的内容不符合类的有效格式时抛出。java.lang.Error错误。是所有错误的基类，用于标识严重的程序运行问题。这些问题通常描述一些不应被应用程序捕获的反常情况。java.lang.ExceptionInInitializerError初始化程序错误。当执行一个类的静态初始化程序的过程中，发生了异常时抛出。静态初始化程序是指直接包含于类中的static语句段。java.lang.IllegalAccessError违法访问错误。当一个应用试图访问、修改某个类的域（Field）或者调用其方法，但是又违反域或方法的可见性声明，则抛出该异常。java.lang.IncompatibleClassChangeError不兼容的类变化错误。当正在执行的方法所依赖的类定义发生了不兼容的改变时，抛出该异常。一般在修改了应用中的某些类的声明定义而没有对整个应用重新编译而直接运行的情况下，容易引发该错误。java.lang.InstantiationError实例化错误。当一个应用试图通过Java的new操作符构造一个抽象类或者接口时抛出该异常.java.lang.InternalError内部错误。用于指示Java虚拟机发生了内部错误。java.lang.LinkageError链接错误。该错误及其所有子类指示某个类依赖于另外一些类，在该类编译之后，被依赖的类改变了其类定义而没有重新编译所有的类，进而引发错误的情况。java.lang.NoClassDefFoundError未找到类定义错误。当Java虚拟机或者类装载器试图实例化某个类，而找不到该类的定义时抛出该错误。java.lang.NoSuchFieldError域不存在错误。当应用试图访问或者修改某类的某个域，而该类的定义中没有该域的定义时抛出该错误。java.lang.NoSuchMethodError方法不存在错误。当应用试图调用某类的某个方法，而该类的定义中没有该方法的定义时抛出该错误。java.lang.OutOfMemoryError内存不足错误。当可用内存不足以让Java虚拟机分配给一个对象时抛出该错误。java.lang.StackOverflowError堆栈溢出错误。当一个应用递归调用的层次太深而导致堆栈溢出时抛出该错误。java.lang.ThreadDeath线程结束。当调用Thread类的stop方法时抛出该错误，用于指示线程结束。java.lang.UnknownError未知错误。用于指示Java虚拟机发生了未知严重错误的情况。java.lang.UnsatisfiedLinkError未满足的链接错误。当Java虚拟机未找到某个类的声明为native方法的本机语言定义时抛出。java.lang.UnsupportedClassVersionError不支持的类版本错误。当Java虚拟机试图从读取某个类文件，但是发现该文件的主、次版本号不被当前Java虚拟机支持的时候，抛出该错误。java.lang.VerifyError验证错误。当验证器检测到某个类文件中存在内部不兼容或者安全问题时抛出该错误。java.lang.VirtualMachineError虚拟机错误。用于指示虚拟机被破坏或者继续执行操作所需的资源不足的情况。java.lang.ArithmeticException算术条件异常。譬如：整数除零等。java.lang.ArrayIndexOutOfBoundsException数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。java.lang.ArrayStoreException数组存储异常。当向数组中存放非数组声明类型对象时抛出。java.lang.ClassCastException类造型异常。假设有类A和B（A不是B的父类或子类），O是A的实例，那么当强制将O构造为类B的实例时抛出该异常。该异常经常被称为强制类型转换异常。java.lang.ClassNotFoundException找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。java.lang.CloneNotSupportedException不支持克隆异常。当没有实现Cloneable接口或者不支持克隆方法时,调用其clone()方法则抛出该异常。java.lang.EnumConstantNotPresentException枚举常量不存在异常。当应用试图通过名称和枚举类型访问一个枚举对象，但该枚举对象并不包含常量时，抛出该异常。java.lang.Exception根异常。用以描述应用程序希望捕获的情况。java.lang.IllegalAccessException违法的访问异常。当应用试图通过反射方式创建某个类的实例、访问该类属性、调用该类方法，而当时又无法访问类的、属性的、方法的或构造方法的定义时抛出该异常。java.lang.IllegalMonitorStateException违法的监控状态异常。当某个线程试图等待一个自己并不拥有的对象（O）的监控器或者通知其他线程等待该对象（O）的监控器时，抛出该异常。java.lang.IllegalStateException违法的状态异常。当在Java环境和应用尚未处于某个方法的合法调用状态，而调用了该方法时，抛出该异常。java.lang.IllegalThreadStateException违法的线程状态异常。当县城尚未处于某个方法的合法调用状态，而调用了该方法时，抛出异常。java.lang.IndexOutOfBoundsException索引越界异常。当访问某个序列的索引值小于0或大于等于序列大小时，抛出该异常。java.lang.InstantiationException实例化异常。当试图通过newInstance()方法创建某个类的实例，而该类是一个抽象类或接口时，抛出该异常。java.lang.InterruptedException被中止异常。当某个线程处于长时间的等待、休眠或其他暂停状态，而此时其他的线程通过Thread的interrupt方法终止该线程时抛出该异常。java.lang.NegativeArraySizeException数组大小为负值异常。当使用负数大小值创建数组时抛出该异常。java.lang.NoSuchFieldException属性不存在异常。当访问某个类的不存在的属性时抛出该异常。java.lang.NoSuchMethodException方法不存在异常。当访问某个类的不存在的方法时抛出该异常。java.lang.NullPointerException空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。java.lang.NumberFormatException数字格式异常。当试图将一个String转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常。java.lang.RuntimeException运行时异常。是所有Java虚拟机正常操作期间可以被抛出的异常的父类。java.lang.SecurityException安全异常。由安全管理器抛出，用于指示违反安全情况的异常。java.lang.StringIndexOutOfBoundsException字符串索引越界异常。当使用索引值访问某个字符串中的字符，而该索引值小于0或大于等于序列大小时，抛出该异常。java.lang.TypeNotPresentException类型不存在异常。当应用试图

java.lang.nullpointerexception 解释是"程序遇上了空指针",就是调用了未经初始化的对象或者是不存在。java.lang.classnotfoundexception 解释是"指定的类不存在"，这里主要考虑一下类的名称和路径是否正确即可。java.lang.arrayindexoutofboundsexception 解释是"数组下标越界"，现在程序中大多都有对数组的操作，因此在调用数组的时候一定要认真检查，看自己调用的下标是不是超出了数组的范围。FileNotFoundException 解释是“文件未找到异常”。IOException 解释是”输入输出流异常“。

Java的所有类 都是从java.lang.Object类继承而来的，而Object类提供下面的方法对对象进行复制：protected Object clone()子类也可以将这个方法覆盖掉，用自己的逻辑实现自己的复制方法。可以被使用clone()方法的类都必须实现Cloneable接口，Cloneable接口只起一个作用就是在运行时期通知Java虚拟机可以安全地在这个类上使用clone方法。

public class AAA{public void seta(int aa){this.a = aa;}public int geta(){return this.a;}public void setb(int bb){this.b = bb;}public int getb(){return this.b;}}public class diaoyong(int a,int b){AAA aaa = new AAA()aaa.seta(a);aaa.setb(b);....println("a : "+aaa.geta())....println("b : "+aaa.getb())}楼主是这个意思吧？

可以使用clone来实现，clone用于为引用类型的复制1.使用clone方法的类必须先实现Cloneable接口，不然clone方法会直接返回CloneNotSupportedException不支持克隆的异常2、实现Cloneable接口的类应该使用公共方法重写 Object.clone（它是受保护的）。某个对象实现了此接口就克隆它是不可能的。即使 clone 方法是反射性调用的，也无法保证它将获得成功。3、在Java.lang.Object类中克隆方法是这么定义的：protected Object clone() throws CloneNotSupportedException创建并返回此对象的一个副本。表明是一个受保护的方法，同一个包中可见。按照惯例，返回的对象应该通过调用 super.clone 获得。详见关于clone的API文档

b中没有对应的clone方法 啊！！！

我们知道在Java中存在这个接口Cloneable,实现该接口的类都会具备被拷贝的能力,同时拷贝是在内存中进行,在性能方面比我们直接通过new生成对象来的快

直接implements Cloneable然后clone();

java深复制的例子：1、创建Employer类，实现Cloneable接口：class Employer implements Cloneable{ private String username; public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } @Override public Object clone() throws CloneNotSupportedException { return super.clone(); }}2、创建Employee类，实现Cloneable接口，并改写clone方法，实现深复制：class Employee implements Cloneable{ private String username; private Employer employer; public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public Employer getEmployer() { return employer; } public void setEmployer(Employer employer) { this.employer = employer; } @Override public Object clone() throws CloneNotSupportedException { //克隆Employee对象并手动的进一步克隆Employee对象中包含的Employer对象 Employee employee = (Employee)super.clone(); employee.setEmployer((Employer) employee.getEmployer().clone()); return employee; }}3、这样，在客户端拷贝的两个Employee对象的Employer就互不影响了：public static void main(String[] args) throws CloneNotSupportedException { Employer employer = new Employer(); employer.setUsername("arthinking"); Employee employee = new Employee(); employee.setUsername("Jason"); employee.setEmployer(employer); //employee2由employee深复制得到 Employee employee2 = (Employee) employee.clone(); //这样两个employee各自保存了两个employer employee2.getEmployer().setUsername("Jason"); System.out.println(employee.getEmployer().getUsername()); System.out.println(employee2.getEmployer().getUsername());}

JAVA代码规范：(1) 类名首字母应该大写。字段、方法以及对象（句柄）的首字母应小写。对于所有标识符，其中包含的所有单词都应紧靠在一起，而且大写中间单词的首字母。例如： ThisIsAClassName thisIsMethodOrFieldName 若在定义中出现了常数初始化字符，则大写static final基本类型标识符中的所有字母。这样便可标志出它们属于编译期的常数。 Java包（Package）属于一种特殊情况：它们全都是小写字母，即便中间的单词亦是如此。对于域名扩展名称，如com，org，net或者edu等，全部都应小写（这也是Java 1.1和Java 1.2的区别之一）。 (2) 为了常规用途而创建一个类时，请采取"经典形式"，并包含对下述元素的定义： equals() hashCode() toString() clone()（implement Cloneable） implement Serializable (3) 对于自己创建的每一个类，都考虑置入一个main()，其中包含了用于测试那个类的代码。为使用一个项目中的类，我们没必要删除测试代码。若进行了任何形式的改动，可方便地返回测试。这些代码也可作为如何使用类的一个示例使用。 (4) 应将方法设计成简要的、功能性单元，用它描述和实现一个不连续的类接口部分。理想情况下，方法应简明扼要。若长度很大，可考虑通过某种方式将其分割成较短的几个方法。这样做也便于类内代码的重复使用（有些时候，方法必须非常大，但它们仍应只做同样的一件事情）。 (5) 设计一个类时，请设身处地为客户程序员考虑一下（类的使用方法应该是非常明确的）。然后，再设身处地为管理代码的人考虑一下（预计有可能进行哪些形式的修改，想想用什么方法可把它们变得更简单）。 (6) 使类尽可能短小精悍，而且只解决一个特定的问题。下面是对类设计的一些建议： ■一个复杂的开关语句：考虑采用"多形"机制 ■数量众多的方法涉及到类型差别极大的操作：考虑用几个类来分别实现 ■许多成员变量在特征上有很大的差别：考虑使用几个类 (7) 让一切东西都尽可能地"私有"--private。可使库的某一部分"公共化"（一个方法、类或者一个字段等等），就永远不能把它拿出。若强行拿出，就可能破坏其他人现有的代码，使他们不得不重新编写和设计。若只公布自己必须公布的，就可放心大胆地改变其他任何东西。在多线程环境中，隐私是特别重要的一个因素--只有private字段才能在非同步使用的情况下受到保护。 (8) 谨惕"巨大对象综合症"。对一些习惯于顺序编程思维、且初涉OOP领域的新手，往往喜欢先写一个顺序执行的程序，再把它嵌入一个或两个巨大的对象里。根据编程原理，对象表达的应该是应用程序的概念，而非应用程序本身。 (9) 若不得已进行一些不太雅观的编程，至少应该把那些代码置于一个类的内部。 (10) 任何时候只要发现类与类之间结合得非常紧密，就需要考虑是否采用内部类，从而改善编码及维护工作（参见第14章14.1.2小节的"用内部类改进代码"）。 (11) 尽可能细致地加上注释，并用javadoc注释文档语法生成自己的程序文档。 (12) 避免使用"魔术数字"，这些数字很难与代码很好地配合。如以后需要修改它，无疑会成为一场噩梦，因为根本不知道"100"到底是指"数组大小"还是"其他全然不同的东西"。所以，我们应创建一个常数，并为其使用具有说服力的描述性名称，并在整个程序中都采用常数标识符。这样可使程序更易理解以及更易维护。 (13) 涉及构建器和异常的时候，通常希望重新丢弃在构建器中捕获的任何异常--如果它造成了那个对象的创建失败。这样一来，调用者就不会以为那个对象已正确地创建，从而盲目地继续。 (14) 当客户程序员用完对象以后，若你的类要求进行任何清除工作，可考虑将清除代码置于一个良好定义的方法里，采用类似于cleanup()这样的名字，明确表明自己的用途。除此以外，可在类内放置一个boolean（布尔）标记，指出对象是否已被清除。在类的finalize()方法里，请确定对象已被清除，并已丢弃了从RuntimeException继承的一个类（如果还没有的话），从而指出一个编程错误。在采取象这样的方案之前，请确定finalize()能够在自己的系统中工作（可能需要调用System.runFinalizersOnExit(true)，从而确保这一行为）。 (15) 在一个特定的作用域内，若一个对象必须清除（非由垃圾收集机制处理），请采用下述方法：初始化对象；若成功，则立即进入一个含有finally从句的try块，开始清除工作。 (16) 若在初始化过程中需要覆盖（取消）finalize()，请记住调用super.finalize()（若Object属于我们的直接超类，则无此必要）。在对finalize()进行覆盖的过程中，对super.finalize()的调用应属于最后一个行动，而不应是第一个行动，这样可确保在需要基础类组件的时候它们依然有效。 (17) 创建大小固定的对象集合时，请将它们传输至一个数组（若准备从一个方法里返回这个集合，更应如此操作）。这样一来，我们就可享受到数组在编译期进行类型检查的好处。此外，为使用它们，数组的接收者也许并不需要将对象"造型"到数组里。 (18) 尽量使用interfaces，不要使用abstract类。若已知某样东西准备成为一个基础类，那么第一个选择应是将其变成一个interface（接口）。只有在不得不使用方法定义或者成员变量的时候，才需要将其变成一个abstract（抽象）类。接口主要描述了客户希望做什么事情，而一个类则致力于（或允许）具体的实施细节。 (19) 在构建器内部，只进行那些将对象设为正确状态所需的工作。尽可能地避免调用其他方法，因为那些方法可能被其他人覆盖或取消，从而在构建过程中产生不可预知的结果（参见第7章的详细说明）。 (20) 对象不应只是简单地容纳一些数据；它们的行为也应得到良好的定义。 (21) 在现成类的基础上创建新类时，请首先选择"新建"或"创作"。只有自己的设计要求必须继承时，才应考虑这方面的问题。若在本来允许新建的场合使用了继承，则整个设计会变得没有必要地复杂。 (22) 用继承及方法覆盖来表示行为间的差异，而用字段表示状态间的区别。一个非常极端的例子是通过对不同类的继承来表示颜色，这是绝对应该避免的：应直接使用一个"颜色"字段。 (23) 为避免编程时遇到麻烦，请保证在自己类路径指到的任何地方，每个名字都仅对应一个类。否则，编译器可能先找到同名的另一个类，并报告出错消息。若怀疑自己碰到了类路径问题，请试试在类路径的每一个起点，搜索一下同名的.class文件。 (24) 在Java 1.1 AWT中使用事件"适配器"时，特别容易碰到一个陷阱。若覆盖了某个适配器方法，同时拼写方法没有特别讲究，最后的结果就是新添加一个方法，而不是覆盖现成方法。然而，由于这样做是完全合法的，所以不会从编译器或运行期系统获得任何出错提示--只不过代码的工作就变得不正常了。 (25) 用合理的设计方案消除"伪功能"。也就是说，假若只需要创建类的一个对象，就不要提前限制自己使用应用程序，并加上一条"只生成其中一个"注释。请考虑将其封装成一个"独生子"的形式。若在主程序里有大量散乱的代码，用于创建自己的对象，请考虑采纳一种创造性的方案，将些代码封装起来。 (26) 警惕"分析瘫痪"。请记住，无论如何都要提前了解整个项目的状况，再去考察其中的细节。由于把握了全局，可快速认识自己未知的一些因素，防止在考察细节的时候陷入"死逻辑"中。 (27) 警惕"过早优化"。首先让它运行起来，再考虑变得更快--但只有在自己必须这样做、而且经证实在某部分代码中的确存在一个性能瓶颈的时候，才应进行优化。除非用专门的工具分析瓶颈，否则很有可能是在浪费自己的时间。性能提升的隐含代价是自己的代码变得难于理解，而且难于维护。 (28) 请记住，阅读代码的时间比写代码的时间多得多。思路清晰的设计可获得易于理解的程序，但注释、细致的解释以及一些示例往往具有不可估量的价值。无论对你自己，还是对后来的人，它们都是相当重要的。如对此仍有怀疑，那么请试想自己试图从联机Java文档里找出有用信息时碰到的挫折，这样或许能将你说服。 (29) 如认为自己已进行了良好的分析、设计或者实施，那么请稍微更换一下思维角度。试试邀请一些外来人士--并不一定是专家，但可以是来自本公司其他部门的人。请他们用完全新鲜的眼光考察你的工作，看看是否能找出你一度熟视无睹的问题。采取这种方式，往往能在最适合修改的阶段找出一些关键性的问题，避免产品发行后再解决问题而造成的金钱及精力方面的损失。 (30) 良好的设计能带来最大的回报。简言之，对于一个特定的问题，通常会花较长的时间才能找到一种最恰当的解决方案。但一旦找到了正确的方法，以后的工作就轻松多了，再也不用经历数小时、数天或者数月的痛苦挣扎。我们的努力工作会带来最大的回报（甚至无可估量）。而且由于自己倾注了大量心血，最终获得一个出色的设计方案，成功的快感也是令人心动的。坚持****草草完工的诱惑--那样做往往得不偿失

大家继续回答啊！

hashtable和hashmap，从存储结构和实现来讲基本上都是相同的，最大的不同就是hashtable是线程安全的，put等方法都加了synchronized关键字。另外就继承关系上面有点区别，这里就从如下几个方面来分析一下hashtable，从中穿插着和hashmap的对比说明。1、继承关系[java] view plain copy public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable 这里和hashmap的唯一区别就是hashtable继承Dictionary，这个抽象类没有实现任何方法，按照官方的说法是这个类已经过时了，hashMap则是继承abstractMap。2、关键类，这个类实现Iterator的功能，它实现了Enumeration和Iterator接口，其实Enumeration和Iterator的功能差不多，至于为什么需要同时实现两个接口，有一种说法是历史原因，具体的话我们就不去分析说明了，这里的Enumerator就是一个迭代器的功能，有hashNext和next方法。[java] view plain copy private class Enumerator<T> implements Enumeration<T>, Iterator<T> { Entry[] table = Hashtable.this.table; int index = table.length; Entry<K,V> entry = null; Entry<K,V> lastReturned = null; int type; /** * Indicates whether this Enumerator is serving as an Iterator * or an Enumeration. (true -> Iterator). */ boolean iterator; /** * The modCount value that the iterator believes that the backing * Hashtable should have. If this expectation is violated, the iterator * has detected concurrent modification. */ protected int expectedModCount = modCount; Enumerator(int type, boolean iterator) { this.type = type; this.iterator = iterator; } public boolean hasMoreElements() { Entry<K,V> e = entry; int i = index; Entry[] t = table; /* Use locals for faster loop iteration */ while (e == null && i > 0) { e = t[--i]; } entry = e; index = i; return e != null; } public T nextElement() { Entry<K,V> et = entry; int i = index; Entry[] t = table; /* Use locals for faster loop iteration */ while (et == null && i > 0) { et = t[--i]; } entry = et; index = i; if (et != null) { Entry<K,V> e = lastReturned = entry; entry = e.next; return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e); } throw new NoSuchElementException("Hashtable Enumerator"); } // Iterator methods public boolean hasNext() { return hasMoreElements(); } public T next() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); return nextElement(); } public void remove() { if (!iterator) throw new UnsupportedOperationException(); if (lastReturned == null) throw new IllegalStateException("Hashtable Enumerator"); if (modCount != expectedModCount) throw new ConcurrentModificationException(); synchronized(Hashtable.this) { Entry[] tab = Hashtable.this.table; int index = (lastReturned.hash & 0x7FFFFFFF) % tab.length; for (Entry<K,V> e = tab[index], prev = null; e != null; prev = e, e = e.next) { if (e == lastReturned) { modCount++; expectedModCount++; if (prev == null) tab[index] = e.next; else prev.next = e.next; count--; lastReturned = null; return; } } throw new ConcurrentModificationException(); } } } 3、关键属性和方法hashtable和hashmap的关键属性和方法的实现基本没有区别，或者说没有区别，最大的区别就是前者的方法有synchronized关键字，是线程安全的方法，后者不是线程安全的方法，另外hashtable不支持null的key和value，hashmap支持null的key和value。具体的方法实现和hashmap是一样的，这里就不在重复的分析了。最后总结，hashtable是线程安全的hashmap。