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

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

* 回复内容中包含的链接未经审核，可能存在风险，暂不予完整展示！ 一 我的理解1 . 感觉接口最大的作用还是实现多态。而多态让程序结构的设计更加的优雅。比如java并发中的两个重要接口Runnable和Callable 就是非常好的例子。比如我们要设计一个执行线程的容器（java中已有实现好的线程池机制），要接收一个任务做参数，我们不可能给每一个任务去设计一个方法。接口就为所有的任务类型提供了一种标准，意思是你的任务只要符合这个标准，我的程序就可以处理。---------------------------------------------------2. 于是开发者就可以自由开发了创建一个任何属于自己的任务 Runnable myTask = new MyTask();只要告诉执行器我这是一个runnable就好了，具体执行JVM去动态处理XXXExecutor.execut(myTask)。。。。。-------------------------------------------------------------------回顾这个例子，我觉得既可以说接口是一种标准，亦可以说是类抽象上的又一层抽象写到这，我觉得java爽爆了。。。二 官方----------------------------又完善了下---------------------------------------下列分别是官方和大神的讨论, 是英文的, 如果你觉得哪里读不通, 可以采纳并追加询问哈. JAVA的接口理解是非常重要的. 希望可以帮到你.3 关于接口定义(官方, 解决What的问题)What Is an Interface? (The Javau2122 Tutorials > Learning the Java Language > Object-Oriented Programming Concepts)https://docs.o****.com/javase/tutorial/java/concepts/interface.html4 关于为什么要使用接口(解决How的问题)Why do we need interfaces in Java? - Stack Overflowhttp://s***********.com/questions/3528420/why-do-we-need-interfaces-in-java

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。

类和接口。声明像素类Pixel继承Point类，因为像素是一个带颜色的坐标点。用JAVA。 如果对您有帮助，请记得采纳为满意答案，谢谢！祝您生活愉快！vaela

当然是B啦

总之一句话，某个类想要有 clone 功能，这个类必须 implements Cloneable;然后覆写 public Object clone();这个方法即可；如下格式：public class C implements Cloneable{public C clone(){try{return (C)super.clone();}catch(Exception e){}return null;}}

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

/**定义用户**/publicclassUser{privateStringname;privateAddressaddress;//constructors,gettersandsetters}/**地址**/publicclassAddress{privateStringcity;privateStringcountry;//constructors,gettersandsetters}重载clone()方法Object父类有个clone()的拷贝方法，不过它是protected类型的，我们需要重写它并修改为public类型。除此之外，子类还需要实现Cloneable接口来告诉JVM这个类是可以拷贝的。重写代码让我们修改一下User类，Address类，实现Cloneable接口，使其支持深拷贝。/***地址*/publicclassAddressimplementsCloneable{privateStringcity;privateStringcountry;//constructors,gettersandsetters@OverridepublicAddressclone()throwsCloneNotSupportedException{return(Address)super.clone();}}/***用户*/publicclassUserimplementsCloneable{privateStringname;privateAddressaddress;//constructors,gettersandsetters@OverridepublicUserclone()throwsCloneNotSupportedException{Useruser=(User)super.clone();user.setAddress(this.address.clone());returnuser;}}需要注意的是，super.clone()其实是浅拷贝，所以在重写User类的clone()方法时，address对象需要调用address.clone()重新赋值。扩展：为什么要克隆？大家先思考一个问题，为什么需要克隆对象？直接new一个对象不行吗？答案是：克隆的对象可能包含一些已经修改过的属性，而new出来的对象的属性都还是初始化时候的值，所以当需要一个新的对象来保存当前对象的“状态”就靠clone方法了。那么我把这个对象的临时属性一个一个的赋值给我新new的对象不也行嘛？可以是可以，但是一来麻烦不说，二来，大家通过上面的源码都发现了clone是一个native方法，就是快啊，在底层实现的。提个醒，我们常见的Objecta=newObject();Objectb;b=a;这种形式的代码复制的是引用，即对象在内存中的地址，a和b对象仍然指向了同一个对象。而通过clone方法赋值的对象跟原来的对象时同时独立存在的。

问题1:声明实现cloneable接口是为了让Employee类的对象能够通过调用自身的clone()方法实现实现“深层复制”操作，所谓“深层复制”指的就是对象字段的内容能够自我克隆，即此时此刻对象的安全拷贝，这与创建此对象的类的另一个新实例所使用的通常的内存分配方式不同，因为后者只是用被复制对象字段的内容初始化新对象的所有字段，实现cloneable接口就能保证对象使用前者的内存分配方式，尽管它只是一个标志（只有字段，没有方法），但是它有底层的一些功能。如果不实现cloneable,那么在Employee类的对象上调用clone()方法就会抛出CloneNotSupportedException异常。问题2:object类中有原始的clone()方法，但是Employee类继承自object类（object类是所有类的超类），所以override其clone()方法时可以将object类型改变为子类Employee的类型.问题3：因为从上面的代码不能看出Date类是否实现了cloneable接口，如果没有实现就必须抛出CloneNotSupportedException，否则在对象salary上调用clone方法将会导致在运行时出现问题。问题4：子类对象转化为父类时是隐式转换，父类对象转化为子类时是显式转换，必须使用（）进行强制类型转换。问题5：从这里看来，salary对象引用指向的是Date类，如果Date类中没有重写clone()方法，那么salary.clone()返回的是Date类的超类对象的拷贝，这时就得使用强制类型转换。 如果帮助到您，请记得采纳为满意答案哈，谢谢！祝您生活愉快！ vae.la

是的，，，

---------转载自网络-------1 Cloneable是标示接口与java.io.Serializable类似，用于告知JVM该对象实现clone。并且super.clone()可以返回一个复制。2 很多时候，会把protected的clone方法修改为public，暴露给其他人可以使用

用继承吧，你想要源码？？？

自己写的一个类。在JDK中是没有定义这样一个类的。Employee的意思是员工，人员的意思

// 调试过了．强烈要求加分哈class Employee{ private int id; private String sex; private String name; private String duty; private float salary; private int holidays; public int money=0; public Employee(int id,String sex,String name,String duty, float salary,int holidays) { this.setId(id); this.setSex(sex); this.setName(name); this.setDuty(duty); this.setSalary(salary); this.setHolidays(holidays); } public void setId(int id) { this.id=id; } public int getId() { return this.id; } public void setSex(String sex) { this.sex=sex; } public String getSex() { return this.sex; } public void setName(String name) { this.name=name; } public String getName() { return this.name; } public void setDuty(String duty) { this.duty=duty; } public String getDuty() { return this.duty; } public void setSalary(float salary) { this.salary=salary; } public float getSalary() { return this.salary; } public void setHolidays(int holidays) { this.holidays=holidays; } public int getHolidays() { return this.holidays; } public void display() { System.out.println("姓名: "+this.name+", 性别: "+this.sex+", 职务: "+this.duty); } public int getDecMoney(int day) { if(day<=3) { this.money=day*30; }else { if(day>3) { this.money=day*50; } } return this.money; }}public class Main{ public static void main(String args[]) { Employee p=new Employee(001,"男","张三","经理",3000,7); p.display(); System.out.println("该员工因请假天扣除工资"+p.getDecMoney(7)+"元"); }}

package com.test;public class Employee { private String name; private int id; private String address; private double salary; public Employee(){ //无参构造器 } public Employee(String name,int id,String address,double salary){ //构造器 this.name = name; this.id = id; this.address = address; this.salary = salary; } public double js(){ //计算工资的方法 return 0; } public String print() { //输出员工基本信息 return "姓名：" + name + " 职工号：" + id + " 地址：" + address; } public String getName() { //对一些属性的设置和修改方法 return name; } public void setName(String name) { this.name = name; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } public double getSalary() { return salary; } public void setSalary(double salary) { this.salary = salary; } public static void main(String[] args) { ZsEmp z = new ZsEmp(); z.setName("正式员工"); z.setId(1001); z.setAddress("China"); LsEmp l = new LsEmp(); l.setName("临时员工"); l.setId(1002); l.setAddress("China"); Employee[] emps = new Employee[2]; emps[0] = z;emps[1] = l; for(Employee e : emps){ System.out.println(e.print()+"，他的工资："+e.js()); } } }class ZsEmp extends Employee{ //正式员工 @Override public double js() { double s = 3000; //不知道具体的计算方法是怎样，这里简单写了 return s; }}class LsEmp extends Employee{ //临时员工 @Override public double js() { double s = 1000; return s; }}

这么简单,不做

String t=URLEncoder.encode(内容, 字符编码);//字符编码和文档编码一致String t=URLEncoder.encode(txt, "GBK");//使用常见的gbk编码你在页面上写的话在使用前要导包或者直接写java.net.URLEncoder.encode(txt, "GBK");

request.setCharacterEncoding("UTF-8"); 是设置页面编码为utf8java.net.Encoder.encode("xxx","UTF-8"); 这个是把字符用url编码的建议统一编码。charset和pageencoding，还有html里面content-type都需要设置统一。

是的，不指定字符编码的方法已经被废止。改为String t=URLEncoder.encode(内容, 字符编码);//字符编码和文档编码一致比如String t=URLEncoder.encode(txt, "GBK");//使用常见的gbk编码

1）encodeURIComponent和decodeURIComponent在前端使用2）URLEncoder.encode和URLDecoder.decode在后台使用知识点：1）encodeURIComponent和URLEncoder.encode的区别在于前者对下面五个符号不编码! %21 " %27 ( %28 ) %29 ~ %7E2）decodeURIComponent和URLDecoder.decode暂时还看不出有何区别解释：前后台交互传输数据的过程中，如果含有!"()~，同样的内容会传输不同的编码结果，但是对方都能解码。在具体应用时，如果有比较前后台编码的逻辑，最好测一下这几个符号。如果编程环境已解决此问题最好，否则就要考虑一下修补之事了。

有不同版本jar包可能没删

用法，惯例。java里面1usage是用法，惯例的意思。Java是一种计算机编程语言，拥有跨平台、面向对象、泛型编程的特性，广泛应用于企业级Web应用开发和移动应用开发。

用法，惯例。java里面1usage是用法，惯例的意思。Java是一种计算机编程语言，拥有跨平台、面向对象、泛型编程的特性，广泛应用于企业级Web应用开发和移动应用开发。

在实际部署的生产环境能够以较低的风险及成本实现对业务逻辑级别性能问题的追踪。本文将介绍如何集成 Perf4j 到 Java 应用程序中并生成性能数据。系统日志是应用程序问题诊断及运行维护的重要工具。Logback、Log4j 是常用于 Java 平台的日志记录 API. 目前大部分产品只是将系统重要参数、状态的变化及异常信息通过日志输出。本文将要介绍的 Perf4j 是一款专门用于 Java 服务器端代码计时、记录日志和监控结果的开源工具包。Perf4j 对常用日志工具包进行了扩展，能够将得到的原始性能数据进行统计并发布到可定制的输出源，如控制台、日志文件、JMX 等。Perf4j 提供了多种方式与 Java 代码集成，开发和系统维人员能够灵活地将 Perf4j 的 API 嵌入到各种不同架构的应用程序中。Perf4j 目前依托于开源项目协作平台 Codehaus 进行文档及代码管理，下一步该项目计划迁移到 Github 平台，以便更多的社区及开发人员可以参与到开发及维护中来。Perf4j 欢迎使用者提出新的功能需求并且鼓励将定制或扩展的代码贡献到 Perf4j 源码中。本文中示例代码使用的 Perf4j 版本是 0.9.16，读者需在下载类包或配置 Maven 时留意。阅读文章之前，您要对 Java 注解、JMX、面向方面编程有一些了解。特别是 JConsole 的使用及 Spring AOP 的配置方式要较为熟悉。文章首先阐明在何种应用场景下应优先考虑使用 Perf4j。然后是具体讲解 Pef4j 与应用程序的集成方式。最后会介绍如何将收集的数据生成便于分析的可视化图表。应用场景在 Java 平台上遇到性能问题时，如 CPU 占用过高、系统响应缓慢，通常的分析方法是使用 JVM 剖析工具在系统瓶颈临界点前一段时间抓取 CPU 占用分布，再对 CPU 占用率最高的几个方法排查。Perf4j 的优势在于能够持续跟踪统计所关注功能代码的执行效率，对于前后两个版本出现较大差异的方法进行深入分析，可以在开发周期中尽早发现问题。Perf4j 还可以用在产品环境中，从运营的早期开始，将其统计的数据做为系统的性能和健康指标长期监测。首选 Perf4j 的应用场景：Java 本地代码调用（JNI） 分布式系统、集群部署 面向服务体系结构（SOA） 远程方法调用（RMI）开发人员必须将本地方法、远程方法及 Web services 的性能问题隔离出来，以防干扰对 Java 应用程序本身的分析。通过日志记录则是最简单的方式；采用分布式架构或集群部署的系统相对复杂，不同的网络环境、基础硬件和操作系统的差异、虚拟主机中资源与配置的差异等造成很难采用统一的工具来监测代码级别的性能指标。而日志记录则可以轻松加入到各种程序中，且是资源与时间成本最低的方式。Perf4j 提供了 CSV 格式的转换工具，开发人员可以借助第三方工具方便地将统计结果汇总分析。集成到应用程序下面将分两种方式具体讲述如何利用 Per4j 提供的 API。在实际的项目中，应根据现有的程序框架及监测目的灵活选择。另外，针对 WebSphere 应用服务器的自有日志系统，还必须采取额外的措施来确保 Perf4j 的正常工作。对代码段计时Perf4j 中 org.perf4j.StopWatch 是整个 API 中的基础工具。这是一个封装良好的计时器。可以把 StopWatch 嵌入到代码中任何地方。这种方式往往使得复杂的方法得到分解，从而有利于精确定位问题的根源。以下通过清单 1 和清单 2 来介绍其具体用法。清单 1.StopWacth 基本用法public static void basicStopWatch() throws InterruptedException{ // 创建 StopWacth 时开始计时，之后也可以用 stopWatch.start() 重新设定计时开始时间点 StopWatch stopWatch = new StopWatch("TransactionA"); // 执行需要计时的代码 Thread.sleep(2 * 1000L); String result = stopWatch.stop(); System.out.print(result); }清单 1 中最后输出的结果示例：start[1340442785756] time[1995] tag[TransactionA]。在构造函数中设定 tag[TransactionA] 用来区分不同的业务逻辑，可以把它看成是性能分析中的事务（Transaction）。如果需要将多段代码分开统计，可采用 LoggingStopWatch 类的 lap() 方法定义多个事务。清单 2.LoggingStopWatch 用法public static void loggingStopWacth() throws InterruptedException{ LoggingStopWatch stopWatch = new LoggingStopWatch(); // 设定阈值，小于此阈值的结果将不会被记录下来 stopWatch.setTimeThreshold(1*1000L); Thread.sleep(2 * 1000L); // 停止当前计时，开始新的起始时间点 stopWatch.lap("TransactionB"); Thread.sleep(500L); stopWatch.stop("TransactionC"); }清单 2 中使用了 LoggingStopWatch 类，其 stop() 方法只是将执行时间数据通过 System.err.println() 输出。若与 Log4j 框架集成，则需要使用 LoggingStopWatch 的子类 Log4JStopWatch, 目前 Perf4j 还支持 Apache Commons Logging、java.util.logginLogback，对应使用 CommonsLogStopWatch、 JavaLogStopWatch、Slf4JStopWatch。

用Calendar计算。Calendar这个类对于日期的任何操作都几乎能满足需求，只是参数设置有些麻烦。大体思路是用两个Calendar设置对应的两个日期。然后用gettime判断是否日期相等。不相等就对于其中一个日期做加减就可以了。跨月跨年都不用担心的。

Circle.java/*** @Description TODO* @Author Becolette* @Date 2017-4-11 下午09:13:39* @Modified By Becolette at 2017-4-11 for TODO*/public class Circle {private double radius; // 半径public double getRadius() {return radius;}public void setRadius(double radius) {this.radius = radius;}public double getArea(double radius) {return Math.PI * radius * radius;}public double getLength(double radius) {return 2 * Math.PI * radius;}}Test1.javaimport java.text.DecimalFormat;import java.util.Scanner;/*** @Description TODO* @Author Becolette* @Date 2017-4-9 下午07:52:35* @Modified By Becolette at 2017-4-9 for TODO*/public class Test1 {/*** @Description TODO* @Author Becolette* @Date 2017-4-9 下午07:52:35* @Modified By Becolette at 2017-4-9 for TODO*/public static void main(String[] args) {Circle circle = new Circle();DecimalFormat df = new DecimalFormat("#.00");Scanner input = new Scanner(System.in);System.out.println("输入半径:");double r = input.nextDouble();System.out.print("周长=" + df.format(circle.getLength(r)) + " 面积=" + df.format(circle.getArea(r)));System.out.println("周长=" + df.format(2 * circle.getLength(r)) + " 面积=" + df.format(2 * circle.getArea(r)));}}

你没描述清楚你的问题

自己找书看

手写：package com.lijun.pojo;import java.util.Date;/** * 账户类，保存账户信息。<br /> * @author wangfeimeinv*/public class Account { private int id;//账号。 private Double balance;//账户余额。 private Double annuallnterestRate;//当年利率。 private Date dateCreated;//账户开户的日期。 //以下是myeclipse自动生成的get、set方法，或把private改成public。 //这是无参构造方法。 public Account () { id = 0; balance = 0; annuallnterestRate = 0; dateCreated = new Date(); } /** *@return 返回月利率。 */ public Double getMonthlyInterestRate() { } /** * 从账户提取特定数额的款。 */ public Double withDraw (Double mony) { } /** * 向账户存特定数额的款。 */ public Double deposit () { }}赚两个积分先。

/*** Created by dell on 2017/7/5.** @author dell* @date 2017/07/05*/public class Circle {public static double π = Math.PI;//圆心private Center center;//半径private Double radius;//获取圆心位置public Center getCenter() {return center;}//设置圆心位置public void setCenter(Center center) {this.center = center;}//设置圆心位置 , 输入x , y 数值设置public void setCenter(Double x , Double y ) {this.center = new Center();this.center.setX(x);this.center.setY(y);}//获取半径public Double getRadius() {return radius;}//设置半径public void setRadius(Double radius) {this.radius = radius;}//获取圆面积public double getArea(){return this.radius * this.radius * π ;}//判断两个圆关系public String check(Circle circle){double d = Math.sqrt((this.center.getX() - circle.center.getX()) *(this.center.getX() - circle.center.getX())+(this.center.getY()-circle.center.getY())*(this.center.getY()-circle.center.getY()));if(d > this.getArea() + circle.getArea()){return "相离";}else if(d == this.getArea() + circle.getArea()){return "相切";}else{return "相交";}}//圆心内部类class Center{// x坐标private Double x;// y坐标private Double y;public Double getX() {return x;}public void setX(Double x) {this.x = x;}public Double getY() {return y;}public void setY(Double y) {this.y = y;}}// 测试public static void main(String[] args) {Circle circle1 = new Circle();circle1.setRadius(5d);circle1.setCenter(1d,1d);Circle circle2 = new Circle();circle2.setRadius(2.5d);circle2.setCenter(1d,2d);System.out.println("圆一面积:" + circle1.getArea());System.out.println("圆二面积:" + circle2.getArea());System.out.println("圆一与圆二关系:" + circle1.check(circle2));}}

SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");System.out.println(sdf.format(new Date()));

首先还是推荐lz看源代码简单的讲之所以调用了toString()方法,不是什么编译器默认的，而是因为lz你调用的是out.print()方法仔细看源代码，在PringStream类中,print方法是这样写的 public void print(Object obj) { write(String.valueOf(obj)); }此时调用了String的静态方法valueof这个方法是这样的 public static String valueOf(Object obj) { return (obj == null) ? "null" : obj.toString();//注意看，这里调用了toString方法 }而所有的java对象都派生自Object，如果没有对该方法做重写则会调用super.toString()Object中这个方法是这样定义的 public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode()); }所以打印结果为classname+@hashcode当重写了toString方法后，根据java的动态绑定原理，调用的为当前对象的toString()方法，所以当你重写了student的toString方法后，打印结果不再是ttt@123456,而是学号:1姓名:小明 补充一点:作为比较，当调用print(String s)时，虽然同为对象，但并没有调用toString()方法，打印结果也不是java.lang.String@hashcode了

日期也折合成小时吗？

if(obj instanceof Integer){}else if(obj instanceof String){}

上楼的答案是对的

2。本地系统就是本地服务器，本地容器。3。显示的初始化不就是new一个吗！toString()是Object类的一个方法，任何类都有这个方法，因为Object是所有类的祖类。System.out.println(对象);系统会调用该对象的toString()方法，你可以覆盖该方法，以达到你想要的效果。（比如String类。）

toDouble就是把一个数字转为两位数字表示 你想一想数字时钟如果是8点那么是不是会显示08?这个的意思就是如果时间是个位数那么前面加0 否则不变(加空字符串是为了转成字符串 学习js的变量类型就应该知道)后面那句我理解不了你什么意思 你说的那个条件只在toDouble里面出现 这个第一个问题已经问过了 而且也没有什么i

//将时间的String类型转成double类型 double changetoDouble(String str){ DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Double etDay=0.0; Double etTime=0.0; try { etDay = Double.parseDouble(df.parse(str).getTime()/ (1000 * 60 * 60 * 24) + ""); etTime = df.parse(str).getHours()/24.0 + df.parse(str).getMinutes()/(24.0*60)+ df.parse(str).getSeconds()/(24.0*60*60); } catch (NumberFormatException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (ParseException e) { // TODO Auto-generated catch block e.printStackTrace(); } return etDay+etTime; }

你这个死锁的原因是break，内层循环因为无条件break变得没有意义，如果你想在循环中使用break退出循环，可以使用if条件然后break

您可以为 Windows 平台启用 Java 控制台。为 Windows 平台启用 Java 控制台1. 单击“开始”--“设置”--“控制面板”。2. 双击“Java Plug-in”图标。3. 单击“初级”选项卡。4. 选择“显示控制台”并单击“应用”。查看用于浏览器的 Java 控制台Internet Explorer1. 在浏览器菜单条中单击“工具”。2. 选择“Sun Java 控制台”。Mozilla 和 Netscape 7.11. 在浏览器菜单条中单击“工具”。2. 选择“Web 开发”--“Java 控制台”。Netscape Communicator 4.791. 在浏览器菜单条中单击“Communicator”。2. 选择“工具”--“Java 控制台”

烦都烦死

将Object page = pages.get(0);改成Map page = pages.get(0);int i = page.get("pageNo");

已经写好了，留学联系方式吧。我帮你写的是一个java项目，多个类文件。需要你就发个邮件给我吧。

for(int i=0;i<list.size();i++){ System.out.println("第"+i+"个值="+list.get(i));}

索引超出范围了

Invalid index 0, size is 0表示看到这个很蛋疼。。。难道你在 list.get(index) 的时候不先判断 if(list!=null && list.size()>0){ list.get(index);}不先判断么？然后你再看做了什么之后你的list 是变为size = 0的

是因为存在数据，而今天没有数据了，你的数组length为0，而你还在取array[0]，当然就数组下标越界了。（1）看到上述报错的第一反应是，越界了。List.size()为0,但却引用了index为0的值，并且此时List不为空。（2）那什么情况下会出现List不为null，但是List.size() == 0呢？下面给出示例:List list = new ArrayList();此时list被创建，即list不为null，但是还没有被赋值，则list.size() == 0。所以在使用List时应当同时判断(list != null && list.size() > 0)。（3）此种问题的解决方案：在使用list.get(0 ...... N)进行取值前对list和list.size()进行判断。

List中没有元素，然后你请求下标为1的元素，就给你报这个错误

B喽,add(2,"B")是错误的

就是数组越界了，意思是你某个地方调用了数组的下标为3但是这个数组的实际大小是0。所以有这种错误。你检查一下你的代码看哪里调用某个数组。

代码如下:local food=redis.call("hget",KEYS[1],"food");food=food+ARGV[1];redis.call("hset",KEYS[1],"food",food);local diamond=redis.call("hget",KEYS[1],"diamond");diamond=diamond+ARGV[2];redis.call("hset",KEYS[1],"diamond",diamond);

我也是，崩溃，翻译别人c++效率很高的算法过来都超时，java是咋了？

不太清楚你说的boolean是原子性是什么意思，只知道他是java的基本类型。刚搜索了下，你说的原子性应该是线程安全吧。boolean需要转换成AtomicBoolean类型才是原子性的。我刚搜了下一个类似的文章你可以看下。http://topmanopensource.iteye.com/blog/1735978

用FreeTTS实现Java语音程序1. Download FreeTTS: http://freetts.sourceforge.net/2. 解压后运行：D:softwarefreetts-1.2libjsapi.exe, 选择agree.3. 写helloworld程序，语音读出"MPLS alarm: link down"：import java.util.Locale;import javax.speech.Central;import javax.speech.EngineList;import javax.speech.synthesis.Synthesizer;import javax.speech.synthesis.SynthesizerModeDesc;import javax.speech.synthesis.Voice;public class HelloWorld { public HelloWorld() { } public static void main(String args[]) { try { SynthesizerModeDesc desc = new SynthesizerModeDesc("FreeTTS en_US general synthesizer", "general", Locale.US, null, null); Synthesizer synthesizer = Central.createSynthesizer(desc); if (synthesizer == null) { System.exit(1); } synthesizer.allocate(); synthesizer.resume(); desc = (SynthesizerModeDesc) synthesizer.getEngineModeDesc(); Voice voices[] = desc.getVoices(); if(voices != null && voices.length > 0){ synthesizer.getSynthesizerProperties().setVoice(voices[0]); synthesizer.speakPlainText("MPLS alarm: link down", null); synthesizer.waitEngineState(0x10000L); } synthesizer.deallocate(); } catch (Exception ex) { ex.printStackTrace(); } }}

1.Quartz中的触发器TriggerJob 包含了要执行任务的逻辑，但是 Job 对何时该执行却一无所知。这个事情留给了 Trigger。Quartz Trigger 继承了抽象的 org.quartz.Trigger 类。当前，Quartz 有三个可用的 Trigger：Java代码·org.quartz.SimpleTrigger·org.quartz.CronTrigger·org.quartz.NthIncludeDayTrigger2.SimpleTrigger的介绍正如其名所示，SimpleTrigger对于设置和使用是最为简单的一种 Quartz Trigger。它是为那种需要在特定的日期/时间启动，且以一个可能的间隔时间重复执行 n 次的 Job 所设计的。我们前面已经在一个简单的Quartz的例子里使用过了SimpleTrigger，我们通过Java代码Trigger trigger = TriggerUtils.makeSecondlyTrigger(10);来获取到我们的Trigger，而得到的实际上就是SimpleTrigger类的一个实现；我们实际上还可以对上面的代码进行小小的改造：Java代码Trigger trigger =new SimpleTrigger("myTrigger",Scheduler.DEFAULT_GROUP,new Date(),null,SimpleTrigger.REPEAT_INDEFINITELY,60000L);对于Quartz而言，它还不能满足我们的触发情况，所以它仅仅是用于一些简单的触发情况；3.org.quartz.CronTriggerCronTrigger 允许设定非常复杂的触发时间表。然而有时也许不得不使用两个或多个 SimpleTrigger 来满足你的触发需求，这时候，你仅仅需要一个 CronTrigger 实例就够了。顾名思义，CronTrigger 是基于 Unix 类似于 cron 的表达式。例如，你也许有一个 Job，要它在星期一和星期五的上午 8:00-9:00 间每五分钟执行一次。假如你试图用 SimpleTrigger 来实现，你或许要为这个 Job 配置多个 Trigger。然而，你可以使用如下的表达式来产生一个遵照这个时间表触发的 Trigger;比如：Java代码try {CronTrigger cTrigger = new CronTrigger("myTrigger",Scheduler.DEFAULT_GROUP, "0 0/5 8 ? *MON,FRI");} catch (ParseException ex) {ex.printStackTrace();}因为 CronTrigger 内建的如此强的灵活性，也与生俱来可用于创建几乎无所限制的表达式，且因为支持unix的cron表达式，则做为企业应用，我们的操作系统一般也都以unxi操作系统为主，所以掌握CronTrigger 的使用费用有必要，我们将在后面对CronTrigger 进行详细的介绍；4.org.quartz.NthIncludedDayTriggerorg.quartz.NthIncludedDayTrigger 是 Quartz 开发团队最新加入到框架中的一个 Trigger。它设计用于在每一间隔类型的第几天执行 Job。例如，你要在每个月的 15 号执行开票的 Job，用 NthIncludedDayTrigger就再合适不过了。Quartz的 Caldendar 也可与 Trigger 关联以此把周末与节假日考虑进来，并在必要时跳开这些日期。接下来的代码片断描绘了如何创建一个 NthIncludedDayTrigger.Java代码NthIncludedDayTrigger trigger =new NthIncludedDayTrigger("MyTrigger",Scheduler.DEFAULT_GROUP);trigger.setN(15);trigger.setIntervalType(NthIncludedDayTrigger.INTERVAL_TYPE_MONTHLY);5.Job与Trigger的关系大家都知道，一个作业，比较重要的三个要素就是Schduler，jobDetail，Trigger；而Trigger对于job而言就好比一个驱动器；没有触发器来定时驱动作业，作业就无法运行；对于Job而言，一个job可以对应多个Trigger，但对于Trigger而言，一个Trigger只能对应一个job；所以一个 Trigger 只能被指派给一个 Job；

作业题最好还是自己做吧~

import java.util.Scanner; public class bank { int number,id; int year,month,day; float money; String name; void set(int y,int m,int d) { year=y; month=m; day=d; } public String toString() { return year+"年"+month+"月"+day+"日"; } public float money1(int n) { money=money+n; return money; } public float money2(int x) { if(money<x) return 0; money=money-x; return money; } public static void main(String args[]) { bank b=new bank(); b.set(2009,8,6); b.money=0; b.number=1; b.id=20102; b.name="张三"; System.out.println("用户名："+b.name); System.out.println("身份证号："+b.id); System.out.println("开户日期是："+b.toString()); System.out.print("请输入存入的数额："); Scanner sc = new Scanner(System.in); int i = sc.nextInt(); b.money1(i); System.out.print("账户余额："+b.money); System.out.println(); System.out.print("请输入取款余额："); Scanner cc = new Scanner(System.in); int j = cc.nextInt(); b.money2(j); System.out.print("账户余额："+b.money); } }

100

代码写好了，币种和金额作为Money类的属性存储到List中，再将List中重复币种的金额相加，如下（注意在Eclipse或者MyEclispse里面运行时，添加相关的包）：public class Money { private String type; //币种 private int value; //金额 //初始化币种和金额 public Money(String type,int value){ this.type=type; this.value=value; } //这个构造器仅仅用于获得一个Money类去调用isSameType()方法，注意这个类只能在本类中使用 Money(){} //获取相同类型的币种并且将它们的金额总和放在一个list中 public List isSameType(List<Money> list){ List l = new ArrayList<Money>(); if(list!=null){ for (int i = 0; i < list.size(); i++) { int sumMoney=list.get(i).value; for(int j = i+1;j<list.size();j++){ if(list.get(i).type.equals(list.get(j).type)){ sumMoney=sumMoney+list.get(j).value; list.remove(list.get(j)); j=j-1;//删除一个元素以后还原指针位置 } } Money m =new Money(list.get(i).type,sumMoney); l.add(m); } } return l; } public String toString(){ return "币种类型："+ this.type+" 金额总和："+this.value; } public static void main(String[] args) { //初始化 List<Money> list = new ArrayList<Money>(); Money m1 = new Money("dollar",6); Money m2 = new Money("renmbi",8); Money m3 = new Money("dollar",7); Money m4 = new Money("dollar",9); Money m5 = new Money("lubu",4); Money m6 = new Money("renmbi",10); Money m7 = new Money("lubu",3); Money m8 = new Money("taidao",15); list.add(m1);//注意这里加入两次m1 list.add(m1); list.add(m2); list.add(m3); list.add(m4); list.add(m5); list.add(m6); list.add(m7); list.add(m8); Money m = new Money(); //求和 List l = m.isSameType(list); for (int i = 0; i < l.size(); i++) { System.out.println(l.get(i)); } }}

money实体类:public class Money {//1 定义整形成员变量yuan,jiao,fenprivate int yuan;private int jiao;private int fen;public Money(int yuan,int jiao,int fen){//2 构造方法，初始化成员yuan,jiao,fenthis.yuan = yuan;this.jiao = jiao;this.fen = fen;}public int getYuan() {return yuan;}public void setYuan(int yuan) {this.yuan = yuan;}public int getJiao() {return jiao;}public void setJiao(int jiao) {this.jiao = jiao;}public int getFen() {return fen;}public void setFen(int fen) {this.fen = fen;}}入口点/主方法：public class MoneyShow {public void show(Money money){//3 void show()方法按XX元XX角XX分格式输出System.out.println(money.getYuan()+"元"+money.getJiao()+"角"+money.getFen()+"分");}public static void main(String[] args) {int yuan = 10,jiao = 5,fen = 3;Money money = new Money(yuan,jiao,fen);//4 创建Money对象，再调用show()方法输出MoneyShow ms = new MoneyShow();ms.show(money);}}

c语言更容易。C++组报名量很大，占了一大多半，但发奖是按比例来的，所以c++选手拿省一相对来说是有难度的，国赛也是。Java组就很有优势了，只要你学的好，算法也精通，省一问题不大，压力更小。省赛每个组别设置一、二、三等奖，比例分别为10%、20%、30%，总比例为实际参赛人数的60%，零分卷不得奖。省赛一等奖选手获得直接进入全国总决赛资格。所有获奖选手均可获得由工业和信息化部人才交流中心及大赛组委会联合颁发的获奖证书。“蓝桥杯”不同组别所需知识：1、Java高职高专组：基本语法、面向对象、网络编程、接口、集合、IO、多线程、内部类、异常。（数据结构、swing等图形界面不涉及，不涉及html、JSP、Tomcat、开源框架等web开发方面，不涉及JDBC、SQL等数据库编程方面）。2、Java本科B组：解题所涉及的知识：Java高职高专组全部知识 + 数据结构（高校《数据结构》教材中出现的经典结构，及其通过组合、变形、改良等方法创造出的变种）。

没有引用~ 或者说是一个匿名的引用。

最后不要用这个 据说不怎么安全. 因为其它人可以进行直接传参数进行操作

取决于eval的参数字符串计算后返回的值。该方法只接受原始字符串作为参数，如果 string 参数不是原始字符串，那么该方法将不作任何改变地返回。

1、eval 太神秘了，以至于很多人用错。所以不推荐使用。2、 eval不容易调试。用chromeDev等调试工具无法打断点调试，所以麻烦的东西也是不推荐使用的…3、说到性能问题，在旧的浏览器中如果你使用了eval，性能会下降10倍。在现代浏览器中有两种编译模式：fast path和slow path。fast path是编译那些稳定和可预测（stable and predictable）的代码。而明显的，eval不可预测，所以将会使用slow path ，所以会慢。还有一个是，在使用类似于Closure Compiler等压缩（混淆）代码时，使用eval会报错。（又慢又报错，我还推荐吗？）4、关于安全性，我们经常听到eval是魔鬼，他会引起XSS攻击，实际上，如果我们对信息源有足够的把握时，eval并不会引起很大的安全问题。而且不光是eval，其他方式也可能引起安全问题。比如：莫名其妙给你注入一个<script src="">标签，或者一段来历不明的JSON-P请求，再或者就是Ajax请求中的eval代码…所以啊，只要你的信息源不安全，你的代码就不安全。不单单是因为eval引起的。你用eval的时候会在意XSS的问题，你越在意就越出问题，出的多了，eval就成噩梦了。5、效率问题是程序逻辑问题。对于一些有执行字符串代码需求的程序中，不用eval而用其他方式模拟反而会带来更大的开销。

基本上所有语言(有eval的)都不建议用 eval, 除非您很确定知道自己在干甚麼又别无他法. eval 之所以不建议使用是因为安全性隐患, 此话适用於所有编程语言, 正常来说只有两种处境下才会用 eval, 一是在写病毒码, 如以 utf-7 (没写错, 是utf-7) 编写代码 让使用者, 甚至防毒软件都看不懂真正要执行的代码是甚麼, 另一个是做测试, 除错; 成品 (production) 绝不该出现 eval 的语句. 这是因为 eval 的东西都不会再有别的防御机制去审视要执行的是甚麼, 比如您要 eval 一个表单里的某串 text, 这就足以让植入式(病毒)码 (injection code) 长驱直入, 成为您页面里的一部分.当然, 一个更低层次的问题就是, 其实与其在 eval 里写代码, 还不如写句正正式式的代码, 在 eval 里要写很多 " " \ , 写著写著都眼花了.

JavaScript eval() 函数JavaScript 全局对象定义和用法：eval() 函数可计算某个字符串，并执行其中的的 JavaScript 代码。语法：eval(string)返回值：通过计算 string 得到的值（如果有的话）。说明：该方法只接受原始字符串作为参数，如果 string 参数不是原始字符串，那么该方法将不作任何改变地返回。因此请不要为 eval() 函数传递 String 对象来作为参数。如果试图覆盖 eval 属性或把 eval() 方法赋予另一个属性，并通过该属性调用它，则 ECMAScript 实现允许抛出一个 EvalError 异常。抛出：如果参数中没有合法的表达式和语句，则抛出 SyntaxError 异常。如果非法调用 eval()，则抛出 EvalError 异常。如果传递给 eval() 的 Javascript 代码生成了一个异常，eval() 将把该异常传递给调用者。扩展资料：调用eval函数的三种情况：1、直接调用直接调用时，eval函数相关的执行环境属性ThisBinding，LexicalEnvironment，VariableEnvironment的值如下:a) ThisBinding是调用eval函数时，调用方执行环境的ThisBindingb) LexicalEnvironment是调用eval函数时，调用方执行环境的LexicalEnvironmentc) VariableEnvironemnt是调用eval函数时，调用方执行环境的VariableEnvironment2、间接调用所谓间接调用，即将eval赋值给另一个变量后在调用3、严格模式下的eval在严格模式下，eval的LexicalEnvironment，VariableEnvironment指向属于eval自己的Lexcial Environment，而不是调用方的Lexical Environment，但是ThisBinding还是调用方的ThisBinding。同时，在严格模式下如果eval直接调用，那么eval的Lexical Environment的outer指针指向调用方的Lexical Environment，否则，如果是间接调用，那么eval的Lexical Environment的outer指针指向全局环境的Lexical Environment。参考资料来源：百度百科--eval()

可以应用java中的上转型对象，实现java编程的多态。 上转型对象不是父类创建的对象，而是子类对象的“简化”状态，它不关心子类新增的功能，只关心子类继承和重写的功能。 当一个类有很多子类时，并且这些子类都重写了父类中的某个方法。当使用上转型对象在调用这个方法时就可能具有多种形态。因为不同的子类在重写父类的方法时可能产生不同的行为。也就是说，不同对象的上转型对象调用同一方法可能产生不同的行为。 例如下面的程序你测试一下就可以理解这样的用法。class Animal{ void cry(){}}class Dog extends Animal{ void cry(){ System.out.println("Wang!Wang!......"); } }class Cat extends Animal{ void cry(){ System.out.println("miao~~miao~~..."); } }public class Example5_9{ public static void main(String args[]){ Animal animal; animal=new Dog(); //animal是Dog对象的上转型对象 animal.cry(); animal=new Cat(); //animal是Cat对象的上转型对象 animal.cry(); }}

Java如何写Evaluate函数，函数内部能够动态执行Java代码：比如public String Evaluate(String S){...}S="return 5 ";Evaluate(S) 返回 5

新建一个工程然后把目录下面的文件都贴到你新建的工程目录下面__OK!..给分吧..