java

阅读 / 问答 / 标签

JAVA list 如何创建一个enum 类的list import java.util.*;public class EnumDemo { public static void main(String[] args){ List<Enum<Grade>> list = new ArrayList<Enum<Grade>>(); }}enum Grade { A, B, C, D, F, INCOMPLETE};

JAVA中的一个小问题 按道理：范型。

java map Map<Stirng,String> map=new HashMap<String,String>();

java的一个问题，求解决…… public final class String implements Serializable, Comparable<String>, CharSequence

java中定义Map 报错求解！！！！！！！！！！ 应该这样写：protected Map getKeyMethodMap(){Map<String,Object> map = new HashMap<String,Object>();map.put("login","adminLogin");return map;}Map<?,?>这里面的对象要看你自己的需求填写。

用javascript写onmouseover 事件,改变文本框字体颜色的代码怎么写啊? <table> <tr onmouseover="this.style.backgroundColor="#FF0000"" onmouseout="this.style.backgroundColor="#00FF00""> <td>dddddddddddddddddddddddddddddddddddddddd</td> </tr> </table>

onmousemove在JavaScript表什么意思啊?? 事件：onmousemove 当鼠标移到所指的对象上。。。onmouseout 当鼠标离开所指的对象

javascript鼠标移入移出事件 要么就hover的时候增加width来连接二级菜单要么就二级菜单加个底层背景.大小可以接上一级菜单不过只有右边可以离开二级菜单时隐藏了或者做成点击事件.直接解决

使用JavaScript代码给每个li列表加两个鼠标事件onmouseover和onmouseout 这个css就能实现吧？li div{display:none;}li:hover div{display:block;}

用JavaScript写出当鼠标悬停在按钮上时WEB页面从绿色变为红色，当鼠标移开时页面从红色变为蓝色的代码 <body bgcolor="#00ff00"><input type="button" id="btn" value="按钮" onmouseover="over();" onmouseout="out();" /></body><script>function over(){document.bgColor = "#ff0000";}function out(){document.bgColor = "#0000ff";}</script>

javascript在使用过程中，浏览器之间存在什么样的差异 基本没什么差异、、但是会有一些属性是个别浏览器特有的，其它浏览器没有。。

javascript如何为一个节点的子节点添加事件 document.getElementById("aaa").document.getElementsByTagName("p").addEvent("onclick",test);

如何用javascript设置table的td的id 分类: 电脑/网络 >> 程序设计 >> 其他编程语言问题描述: <TABLE id="aaa"> <TR> <TD>s1</TD> <TD>s2</TD> </TR> <TR> <TD>s3</TD> <TD>s4</TD> </TR> </TABLE> 一个表格如上,如何用javascript把内容为s3的td的ID设置为ss3 ???? 解析: 参考一下这段，把代码直接贴到文件即可使用 <style>body,td,div,a,input{font:menu;line-height:150%}</style> <table cellspacing=1 cellpadding=1 border=0 width=100% id=t136><tbody><form method=post enctype="multipart/form-data"><input type=hidden name=deal value=true><input type=hidden name=frmID value=22><input type=hidden name=thisdir value=><input type=hidden name=TID value=><tr class="page_speeder_1153071515" bgcolor=ACD0FD><td colspan=2>呵呵</td></tr><tr bgcolor=EFEFD6><td colspan=2><font color=000080>哈哈</font></td></tr><input type=hidden name=frmShowURL value=payment><input type=hidden name=ID value=><tr bgcolor=F0F0F0><td>xixi</td><td>xixi </td></tr><tr bgcolor=F9F9F9><td>hehe</td><td><input type=text class=border_index name=newdir style="ime-mode:disabled"><font color=000080>hehe</font> </td></tr><tr bgcolor=F0F0F0><td>新图片上传</td><td><div> <input type=button onclick=addNew() value=增加 class=button_index><font color=000080>(按一次增加按钮就可以上传一张图片。)</font></div></td></tr><tbody></table></form><script> var i=0,arr=new Array("F9F9F9","F0F0F0"); function addNew(){ tr=document.all.t136.insertRow(); tr.style.backgroundColor=arr[i%2]; tr.insertCell().innerText="图片"+(++i); tr.insertCell().innerHTML="<input type=file name=pic"+i+" class=border_index> <a href=javascript:void(0) onclick=del()>删除</a>" } function del(){ document.all.t136.deleteRow(window.event.srcElement.parentElement.parentElement.rowIndex); for(i=0;i<document.all.t136.rows.length-5;i++){ document.all.t136.rows[i+5].cells[0].innerText="图片"+(i+1); document.all.t136.rows[i+5].cells[1].children[0].name="pic"+(i+1); document.all.t136.rows[i+5].style.backgroundColor=arr[i%2]; } } </script>

javascript的parentNode，parentElement parentElement 是IE专用属性，parentNode 是W3C标准属性，parentElement 指的是该元素的父元素，parentNode指的是该DOM元素节点的上级节点

java为什么没有@desc注解了 简单的举例一下，Annotation的作用:编写文档代码分析编译检查。如使用注解注入bean，好处是1,使用时，不再以平常的new 构造器来创建类的一个实例，丢弃了右边的new 。。。，只有左边的bean声明，并在声明上方添加@resource（name=“。。。。”）注入。只要在编写程序时添加一些要用到注解，以及注解的说明，就可以生成相应的javaDoc文档，以便开发人员快速了解程序的整体轮廓。这是不用注解难以做到的2.java虚拟机可以识别注解，通过注解告诉虚拟机要实现的功能，修正一些编译期人为的错误，如我们要重写toString,但是却写成tostring,如果没有注解，编译器就不会作编译时检查，就把这个tostring当初普通的方法，不会报错。3.使用主流框架开发时，通常会在xml文件配置bean等的注入类型，而xml文件开启注解支持后自动配置，不需要人工配置，减少开发时间，提高开发效率等。。。。

java 虚拟机报错毫无头绪,很着急请大家帮忙！ “The crash happened outside the Java Virtual Machine in native code. # See problematic frame for where to report the bug. ”，明确的跟你说了，虚拟机Crash，是因为本地代码（native code）的问题，并且通过问题描述提示（problematic frame）可以找到bug产生的地方。好好检查下代码！

最早出现的Web编程语言是什么？ A、VRML B、HTML C、JAVA D、ASP 根据题意大概是 Java 吧，因为 HTML 一般不算编程语言。

最早出现的Web编程语言是什么？ A、VRML B、HTML C、JAVA D、ASP 楼主的概念没有搞清楚，没有明确的“Web编程语言”这个概念HTML是数据描述语言，是XML的一个子集（它属于XML的一种），确切得说它是对数据的一种描述VRML则是另一种数据描述语言数据描述语言的作用是描述数据，比如说你的浏览器要和服务器交流，那么一个说中文一个说英文大家肯定听不懂，于是就有了HTML，服务器给你传送了一个HTML，你的浏览器拿到的是HTML这个纯文本的东西，但它认识，并且会把它转化成一个漂亮的页面。HTML就是这个作用，它用<center>告诉你这个字要居中，用<img src="...">告诉你还需要下载某个图片，等等，它不是编程语言，而是一种对数据格式的描述。JAVA和ASP则是脚本语言，类似的还有php, python, 包括C/C++之类的也可以归纳进来。它的作用是生成HTML页面。比如我的网页有一个表格，这些表格的数据来自于后台数据库。于是我可以用JAVA（通常是JSP）或者ASP把数据从数据库读出来，整理成一个HTML文件，再把这个文件传送给客户。目前最流行的脚本语言是PHP, ASP, JSP，它们简单而强大。当然C/C++也可以实现这些功能，比如百度知道的后台就有C++的模块，因为它更快速。若问诞生时间，毫无疑问C/C++最早，分别是1972年和1980年，它们诞生于互联网出生之前。Java生于94年，asp比它晚两年。而对于数据描述语言，HTML诞生于1990年，是专门伴随着Web而出生的。而VRML始于1994年

java3d的同类比较 GL4Java、VRML、JAVA3D的比较由于 OPENGL的跨平台特性，许多人利用OPENGL编写三维应用程序，不过对于一个非计算专业的人员来说，利用OPENGL编写出复杂的三维应用程序是比较困难的，且不说C/C++语言和java的掌握需要花费大量时间精力，当我们需要处理复杂问题的时候，我们不得不自己完成大量非常繁琐的工作。当然，对于编程高手来说，OPENGL是他们发挥才能的非常好的工具。VRML2.0(VRML97)自1997年12月正式成为国际标准之后，在网络上得到了广泛的应用，编写VRML程序非常简单（VRML语言可以说比BASIC、JAVASCRIPT等语言还要简单），同时可以编写三维动画片、三维游戏、用于计算机辅助教学，因而其应用前景非常广阔尤其适合在中国推广应用。不过由于VRML语言功能还不是很强（如没有形体之间的碰撞检查功能），与JAVA语言等其它高级语言的连接较难掌握，因而失去了一些计算机高手的宠爱。但我们认为，我们可以让大学里的文理科学生利用VRML编写多媒体应用程序，让学生很快地对编写程序感兴趣，从而使国内的计算机水平得到提高。DIRECT3D是Microsoft公司推出的三维图形编程API，它主要应用于三维游戏的编程，相关的学习资料难于获得，由于它一般需要VC等编程工具进行编程，需要编程人员具有较高的C++等高级语言的编程功底，因而难以普及。JAVA3D是建立在 JAVA2（JAVA1.2)基础之上的，JAVA语言的简单性使JAVA3D的推广有了可能。OPENGL和JAVA3D之间的比较可以看成汇编语言与 C语言之间的比较，一个是低级的，一个是高级的（也许这样比较不太恰当）。JAVA3D给我们编写三维应用程序提供了一个非常完善的API，它可以帮助我们：生成简单或复杂的形体（也可以直接调用现有的三维形体）使形体具有颜色、透明效果、贴图。可以在三维环境中生成灯光、移动灯光。可以生成雾、背景、声音等。可以使形体变形、移动、生成三维动画。可以编写非常复杂的应用程序，用于各种领域如VR。

请教javascript echo是什么意思? echo好像是doc的输出函数吧，跑到js里去了？

Java 用uilayerexception抛出异常，但是事务没有回滚，已经添加到数据库了 java是编程语言里比较难学的一门，如果有心从事编程方向的工作，最好到专业机构学习并有更多的项目实践，更贴近市场，这样更有利于将来的发展。

java中for(a b:c){}是什么意思？如何执行的？ 循环c对象赋值给a类型的b对象

为什么我的电脑不能运行java web start 说具体点

如何配置Java环境安装eclipse 配置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界面设计？ 进行eclipse可视化java界面设计步骤如下：一、先新建一个普通的java工程。二、为这个java工程添加有可视化界面的java类，选择新建中的other选项。三、找到windows build里的jFrame，即主界面，进行新建有界面的java。四、点击Design进入可视化编辑界面、

eclipse怎么编写JAVA程序，怎么新建 点file new一个java project 。再点出现的项目。new 一个 package ，（这一步可以不要），③new一个class文件。可以了

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

eclipse怎么运行？需要什么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）。

怎样用eclipse编写java程序 新建java项目即可

eclipse怎么新建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项目、包、类了，可以开始编写相应的实现代码了~

eclipse怎么新建Java文件 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差不多，但由于其开放源码，任何人都可以免费得到，并可以在此基础上开发各自的插件，因此越来越受人们关注。

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

怎么配置eclipse+java开发环境 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开发环境就配置好了

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

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

eclipse怎么运行？需要什么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）。

java中的 desedekeyspec spec;是什么意思 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 密钥的密钥内容。

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

我的世界国际版和java版有什么区别，是一个东西吗？ 在内容上，游戏算法机制有所不同导致了有些物品的属性有差。根本区别是基岩版是由C语言编写的，Jave版是Java编写的。

java怎么避免BufferedReader读取文件频繁的gc。代码如下。 BufferedReader 的缓存开大一点；或者如果确定文件大小，一次性读进一个byte[] 用ByteArrayInputStream 包起来

java大神求教！请问这图里面的generate方法要怎么理解？ generate方法中还缺点东西，没有把随机生成出来的letters数组下标所对应的元素，放入chs数组中

JAVA环境变量都设置好了，但是在命令行java -version就是有错误。 jdk的问题啊，重装一个试试

有关java client——server 间传送文件的问题，本想通过server把client1 发来的信息传送给client2 client必须保持长连接，简单说，你的client和server之间的连接是不能断开的，你每次启动client都是直接尝试读取然后断掉链接的话，c1在传输文件的时候，c2的连接已经断掉了，server还如何和c2之间通讯呢？

如何配置pom.xml用maven打包java工程 给你个例子自己看看吧，太多了，不会再问吧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><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><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><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><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>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><dependency><groupId>joda-time</groupId><artifactId>joda-time</artifactId><version>2.9.4</version></dependency><dependency><groupId>commons-lang</groupId><artifactId>commons-lang</artifactId><version>2.6</version></dependency><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId><version>${slf4j_version}</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.1.39</version></dependency><dependency><groupId>com.google.code.gson</groupId><artifactId>gson</artifactId><version>2.2.4</version></dependency><dependency><groupId>org.beetl</groupId><artifactId>beetl-core</artifactId><version>2.0.11</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><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><dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>2.8.0</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>

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

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

怎么看JAVA开源项目的源码？ 有个开源代码托管平台叫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，全是英文，要能读懂源代码，需要有很好的英文阅读能力，祝你好运。

Java代码优化的常用方法有什么 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

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

用java如何将查询的结果在table中显示 数据库吗？数据库+SE？

Java中所有的运行时异常，带中文解释 算术异常类：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的使用方法之一。

java hashtable 初始化为啥是11

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。

java游戏开发设计概念 (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编码中的字符，布尔型。

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

如何写出好的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 线上文档找出一些有用的信息时，你所遭遇的挫败应该足以让你相信这一点。

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

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，江湖永无相见！

在java中的异常处理中的异常对象是什么 Exception

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

Java。如何将一个LinkedList里的元素全部复制到另一LinkedList容器里？ LinkedList newList = new LinkedList(oldList);或者，LinkedList实现了Cloneable接口，直接调用clone()也可以。

java程序员面试时被问到：如何在j2ee项目中处理高并发量访问？该怎么回答？请仔细看题干再回答 http://blog.csdn.net/y_h_t/article/details/6322823你是一名java程序员，这些应该知道些吧

如何学习JAVA 零基础开始学习

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技巧：深拷贝的两种方式 ⑴浅复制(浅克隆)被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。⑵深复制(深克隆)被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。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#

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

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

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

在哪里可以看到JAVA的object类中clone方法的源代码?

这方法在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里用tableModel接收从数据库查询出来的数据该怎么做求详解，最好可以教我一下怎么实现 利用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的内容。

java.util.Vector 是顺序的，还是链式的？其他的集合呢？ 顺序的，带Linked的是链接的。LinkedList是链表。set是无序的

Java工程师转大数据难度高吗？ 不清楚，我也准备转

在java中 clone为什么要用super.clone(）方法？ 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() 就行了。

java的linkedList怎么没有isEmpty方法 有呀，其实你可以敲一下代码就知道。

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

如何使Java中的InputStream的深层复制

我们知道在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()方法。

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

在java中，如何复制一个对象?比如说string对象 clone()方法

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

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

首页上一页 19 20 21 22 23 24 25 26 27 28 29 下一页尾页

猜你想看

实验新西兰按钮心脏 list window ind wn 可能标识 tar 方案 roi llm ark mark 英语音标 POL

大家在看

hamada posh koji avcc yammy proposes lingos lingoes mojave vimicro pentile wannacry veggie veggieg serto turnup netants turnto