java

apache的commons系列库，是很多其他库的基础库，比如hibernate和spring，commons-collections是通用集合库，不过一般你写代码用不上，你会直接用jdk里自带的集合类（List，Set，Map等）

sorry

类型转换只能向上转型，从子的向父的转。

Collection是一个超级接口，有很多实现这个接口的类，具体用的话，是用这些实现它的那些类，比如ArrayList等，ArrayList是比较常用的。集合这个知识点在JAVA中还是比较重要的，而且内容也不是一两句能讲清楚的，建议去看看教程，或者API文档，里面有各个接口、类定义的具体方法，以及这些方法的使用方式。ArrayList的一些使用：List list = new ArrayList(); //创建一个ArrayListlist.add(这里存放要添加的元素); //添加元素list.get(int index) ; //返回此列表中指定位置上的元素。list.remove(int index); //移除此列表中指定位置上的元素。list.set(int index, E element) ; // 用指定的元素替代此列表中指定位置上的元素。list.toArray() ; //按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。Collection 也属于容器，容器的话，一般避免不了“增删改查”这四个操作！

（int）（o1.getSalary()-o2.getSalary()）；

Collection和Collections的区别如下：1、java.util.Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。Collection ├List │├LinkedList │├ArrayList │└Vector │　└Stack └Set 2、java.util.Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。

是这样的。虽然n个元素都是一样的，而且是不可改变的，但java实现的时候只用一个空间，存放一个元素来实现这个功能。如果n足够大的话，可以节省空间和性能。使用场景：存放一些不变的信息有用，比如大家的国籍，性别之类的时候。

publicintcompareto(useruser0){returnthis.getorder()-user0.getorder();}compareto里面返回值是个int类型的吧?大于0前者大有点模糊了，您试试就好了。

当然不可以，collections封装的是对collection以及下面的子类处理方法。map是另外一种集合

默认的是升序但你既然知道Comparator,你就可以让它降序例如：比如原来你的comparator方法，返回的是classA{inta;}comparator(Aa1,Aa2){returna1.a-a2.a}//升序comparator(Aa1,Aa2){returna2.a-a1.a}//降序

Collection 和 Collections的区别。 Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。 Collection是个java.util下的接口，它是各种集合结构的父接口。 List, Set, Map是否继承自Collection接口? List，Set是 Map不是 ArrayList和Vector的区别。 一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的 二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半 HashMap和Hashtable的区别 一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现 二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的 三.值：只有HashMap可以让你将空值作为一个表的条目的key或value

1.commons-collections 包的功能 为Java标准的Collections API提供了相当好的补充。在此基础上对其常用的数据结构操作进行了很好的封装、抽象和补充。保证性能的同时大大简化代码。 2.commons-collections 包的分类： 根据集合类型，大致将此包的类归纳为9类： Bag -- 在org.apache.commons.collections包中定义的接口，它extends java.util.Collection，而它的实现类都被放在下面的bag包中。HashBag是Bag接口的一个标准实现。而BagUtils提供一组static的方法让调用者获取经过不同装饰后的Bag实例.具体用法见代码样例 Buffer -- 定义在org.apache.commons.collections包下面的接口，用于表示按一定顺序除去成员对象的collection如队列等。具体的实现类在org.apache.commons.collections.buffer 包下可以找到。最简单直接的Buffer实现类是UnboundedFifoBuffer，提供先进先出的大小可变的队列。而BoundedFifoBuffer则是对其大小进行了限制，是固定大小的先进先出队列。BlockingBuffer要在多线程的环境中才能体现出它的价值，尤其是当我们需要实现某种流水线时这个BlockingBuffer很有用：每个流水线上的组件从上游的BlockingBuffer获取数据，处理后放到下一个BlockingBuffer中依次传递。BlockingBuffer的核心特色通俗点说就是如果你向它要东西，而它暂时还没有的话，你可以一直等待直至拿到为止。PriorityBuffer则提供比一般的先进先出Buffer更强的控制力：我们可以自定义Comparator给它，告诉它怎么判定它的成员的先后顺序，优先级最高的最先走。此外还有执行类型检查的TypedBuffer、或者不可改变的UnmodifiableBuffer等等 Map -- 在java.util.Map的基础上扩展的接口和类。BidiMap，直译就是双向Map，可以通过key找到value，也可以通过value找到key，这在我们日常的代码-名称匹配的时候很方便：因为我们除了需要通过代码找到名称之外，往往也需要处理用户输入的名称，然后获取其代码。需要注意的是BidiMap当中不光key不能重复，value也不可以。MultiMap，就是说一个key不在是简单的指向一个对象，而是一组对象，add()和remove()的时候跟普通的Map无异，只是在get()时返回一个Collection，利用MultiMap，我们就可以很方便的往一个key上放数量不定的对象，也就实现了一对多。LazyMap，意思就是这个Map中的键/值对一开始并不存在，当被调用到时才创建。 Collection -- 用也各collection之间的类型转换。典型的是TypedCollection，它实际上的作用就是提供一个decorate方法，我们传进去一个Collection和需要的类型甄别信息java.lang.Class，它给我们创建一个全新的强类型的Collection。（暂无样例代码，以后补充） Comparator -- 提供了一些Comparator的实现类（都在org.apache.commons.collections.comparators包下面）BooleanComparator – 用于排序一组Boolean对象，指明先true还是先false；ComparableComparator – 用于排序实现了java.lang.Comparable接口的对象（我们常用的Java类如String、Integer、Date、Double、File、Character等等都实现了Comparable接口）；ComparatorChain – 定义一组Comparator链，链中的Comparator对象会被依次执行；FixedOrderComparator – 用于定义一个特殊的顺序，对一组对象按照这样的自定义顺序进行排序；NullComparator – 让null值也可参与比较，可以设定为先null或者后null； ReverseComparator – 将原有的Comparator效果反转；TransformingComparator – 将一个Comparator装饰为具有Transformer效果的Comparator。 Predicate -- 它以一个Object对象为参数，处理后返回一个boolean值，检验某个对象是否满足某个条件。Commons Collections也提供了一组定义好的Predicate类供我们使用，这些类都放在org.apache.commons.collections.functors包中。当然，我们也可以自定义Predicate，只要实现这个Predicate接口即可。 Transformer -- 我们有时候需要将某个对象转换成另一个对象供另一组方法调用，而这两类对象的类型有可能并不是出于同一个继承体系的，或者说出了很基本的Object之外没有共同的父类，或者我们根本不关心他们是不是有其他继承关系，甚至就是同一个类的实例只是对我们而言无所谓，我们为了它能够被后续的调用者有意义的识别和处理，在这样的情形，我们就可以利用Transformer。除了基本的转型Transformer之外，Commons Collections还提供了Transformer链和带条件的Transformer，使得我们很方便的组装出有意义的转型逻辑。 Closure -- 这一组接口和类提供一个操作对象的execute方法，为我们在处理一系列对象时可以将处理逻辑分离出来。ChainedClosure可以包装一组Closure作为整体执行；IfClosure在创建时需要提供给它一个Predicate和两个Closure，执行时先做Predicate判定再决定执行哪一个Closure；SwitchClosure跟SwitchTransformer类似，根据创建时传入的Predicate组和Closure组对应执行；WhileClosure则根据创建时传入的Predicate做判断，如果为true则执行Closure，直到Predicate返回false；等等。 Iterator -- java.util.Iterator接口定义了标准的Collection遍历方法，但是如果不做改变的使用它，我们得到的是从头到尾一次性的遍历。假如我们需要循环遍历，假如我们需要遍历某一段，假如我们需要遍历满足某些条件的元素，等等等等，我们就不能完全依赖于这个Iterator的标准实现了。除非我们宁可在此基础上在调用的代码中多加一些判断，不过这样的话代码就会显得混乱，时间长了就容易变得难以维护。Commons Collections的这一组Iterator为我们带来了便利。

Collection是集合的顶层即可，就像Map一样，也是集合的一个顶层接口； Collections是集合的一个工具类，就像Arrays是数组的一个工具类。它里面有一些操作集合的方法。

String ss="ssssssssss";System.out.print(ss.length());

简洁明了try/catchtry里写可能会发生的异常，如果发生异常了就在catch里处理就好了

Java中的异常处理机制已经比较成熟，我们的Java程序到处充满了异常的可能，如果对这些异常不做预先的处理，那么将来程序崩溃就无从调试，很难找到异常所在的位置。昌平电脑培训将探讨一下Java中异常与错误的处理方法，一起来看看。异常与错误：异常：在Java中程序的错误主要是语法错误和语义错误，一个程序在编译和运行时出现的错误我们统一称之为异常，它是VM(虚拟机)通知你的一种方式，通过这种方式，VM让你知道，你(开发人员)已经犯了个错误，现在有一个机会来修改它。Java中使用异常类来表示异常，不同的异常类代表了不同的异常。但是在Java中所有的异常都有一个基类，叫做Exception。错误：它指的是一个合理的应用程序不能截获的严重的问题。大多数都是反常的情况。错误是VM的一个故障(虽然它可以是任何系统级的服务)。所以，错误是很难处理的，一般的开发人员(当然不是你)是无法处理这些错误的，比如内存溢出。和异常一样，在Java中用错误类来表示错误，不同的错误类代表了不同的错误。但是在Java中所有的错误都有一个基类，叫做Error。综上，我们可以知道异常和错误最本质的区别就是异常能被开发人员处理而错误时系统本来自带的，一般无法处理也不需要我们程序员来处理。1.一个异常是在一个程序执行过程中出现的一个事件，它中断了正常指令的运行2.错误，偏离了可接受的代码行为的一个动作或实例异常的结构分类：1、运行时异常(未检查异常)2、编译时异常(已检查异常)运行异常即是RuntimeException;其余的全部为编译异常在Java中异常Exception和错误Error有个共同的父类Throwable。ErrorExceptionruntimeException几个子类1、java.lang.ArrayIndexOutOfBoundsException数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。2、java.lang.ArithmeticException算术条件异常。譬如：整数除零等。3、java.lang.NullPointerException空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等4、java.lang.ClassNotFoundException找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。

Error（错误）表示系统级的错误和程序不必处理的异常，一般是指与虚拟机相关的问题，是java运行环境中的内部错误或者硬件问题。比如：内存资源不足等。对于这种错误，程序基本无能为力，除了退出运行外别无选择，它是由Java虚拟机抛出的。Exception（违例）表示需要捕捉或者需要程序进行处理的异常，它处理的是因为程序设计的瑕疵而引起的问题或者在外的输入等引起的一般性问题，是程序必须处理的。Exception又分为运行时异常，受检查异常。运行时异常，表示无法让程序恢复的异常，导致的原因通常是因为执行了错误的操作，建议终止程序，因此，编译器不检查这些异常。受检查异常，是表示程序可以处理的异常，也即表示程序可以修复（由程序自己接受异常并且做出处理）， 所以称之为受检查异常。

早期的编程语言（比如C语言）没有异常处理，通常是遇到错误返回一个特殊的值或设定一个标志，并以此判断是不是有错误产生。随着系统规模的不断扩大，这种错误处理已经成为创建大型可维护程序的障碍了。于是在一些语言中出现了异常处理机制，比如在Basic中的异常处理语句“onerrorgoto”，而Java则在C++基础上建立了新的异常处理机制。Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。这种机制为复杂程序提供了强有力的控制方式。同时这些异常代码与“常规”代码分离，增强了程序的可读性，编写程序时也显得更灵活。Java中的异常类在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Throwable类有两个标准子类：java.lang.Error和java.lang.Exception，即错误和异常。错误：Error类，一般是指虚拟机相关的问题，如系统崩溃、虚拟机出错误、动态链接失败等，这一类错误无法恢复或不可能捕获，将导致应用程序中断。异常：Exception类，则是指一些可以被捕获且可能恢复的异常情况，如数组下标越界Array，Index，OutOf，Bounds，Excepton。数字被零除产生异常：ArithmeticException、输入/输出异常：IOException等。提示：Java编译器要求Java程序必须捕获或声明所有非运行时的异常，如：FileNotFoundException、IOException等。因为，对于这类异常来说，如果程序不进行处理，可能会带来意想不到的结果。但运行时出现异常可以不做处理，因为这类异常很普遍，全部处理可能对程序的可读性和运行效率产生影响。Java异常处理形式，Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理。下面是Java异常处理程序的基本形式：try//执行时程序块catchExceptionType1e//对ExceptionType1的处理catchExceptionType2e//对ExceptionType2的处理throwe//再抛出这个“异常”finallytry程序块和catch语句：遇到一个try语句，“异常”的框架就放到堆栈上面，直到所有的try块内的语句都完成。如果下一级的try语句没有对某种“异常”进行处理，堆栈就会，直到遇到有处理这种“异常”的try语句。在try程序后面，应包含一个catch子句来指定你想要捕捉的“异常”的类型。提示：捕获异常的第一步就是用try…选定你要捕获异常的范围，在执行时，括号内的代码会产生异常对象并被抛出。然后你就可以用catch块来处理异常了。throw语句和throws语句：throw语句用来明确地抛出一个“异常”。首先，你必须得到一个Throwable类或其它子类产生的实例句柄，通过参数传到catch子句，或者用new语句来创建一个实例。下面是throw语句的通常形式：throwThrowableInstance，提示：执行throw语句后，运行流程将立即停止，throw的下一条语句也将暂停执行。这里new运算符用于创建一个Throwable类的实例，在后文的面向对象编程一文中将详细讲解。throws语句用来标明一个成员函数可能抛出的各种“异常”。对大多数Exception子类来说，Java编译器会强迫你声明在一个成员函数中抛出的“异常”的类型。如果“异常”的类型是Error或RuntimeException，或它们的子类，这个规则不起作用。如果你想明确地抛出一个RuntimeException，你必须用throws语句来声明它的类型。提示：当然，你可能对上面的说明不是很明白，不过不要紧，编译运行下面的Java程序（已经为你做了详细的注释）你会理解很多!现在我们用下面的例程来说明问题：classThrowsDemo//类名，相应的java源文件应该保存成：ThrowsDemo.javastaticvoidprocedurethrowsIllegalAccessException//throws语句//抛出IllegalAccessException类型的异常System.out.println″insideprocedure″//输出文本信息，以说明是在执行procedure方法时抛出了异常thrownewIllegalAccessException″demo″//新生成一个Throwable类实例，然后抛出异常publicstaticvoidmainStringargs//main方法开始，程序从此处执行try//try语句块开始procedure//调用procedure方法，该方法将Throw（抛出）异常信息catchIllegalAccessExceptione//处理IllegalAccessException类型的异常，catch语句块System.out.println″caught″+e编程并执行程序，其过程如下：Ejavacodeexception>javaThrowsDemoinsideprocedurecaughtjava.lang.IllegalAccessExceptiondemo提示：如上面的代码所示，我们用了一个完整的程序来说明在Java程序中如何使用try…catch…throw等语句。Try…里产生的异常被捕获了下来，然后在catch块里进行处理（这里只是输出异常信息）。throwsIllegalAccessException标明程序将抛出一个IllegalAccessException类型的异常。IllegalAccessExceptione生成一个异常对象，然后用System.out.println输出异常信息。finally语句，有时为了确保一段代码不管发生什么异常都要被执行，可以使用关键词finally来标出这样一段代码。一个成员函数返回到调用它的成员函数，或者通过一个没捕捉到的异常，或者通过一个明确的return语句，finally子句总是恰好在成员函数返回前执行。下面我们以一个比较完整的异常处理程序来说明上面所述的各种异常处理语句的使用问题：classExceptionDemo//异常使用示例，保存为ExceptionDemo.javastaticvoidprocAtrySystem.out.println″insideprocA″thrownewRuntimeException″demo″//抛出异常finallySystem.out.println″procA"sfinally″//注意：不管发生什么等会执行!!staticvoidprocBtrySystem.out.println″insideprocB″return//返回，实际上是在finally语句执行完后才返回finallySystem.out.println″procB"sfinally″publicstaticvoidmainStringargstryprocAcatchExceptioneSystem.out.println″catch″+eprocB提示：在上面的完整程序中，finally后的大括号内的代码是任何情况下都会执行的。另外，在procB中，return语句并没有立即返回，这一点应该特别注意。你可以亲自动手，执行上面的程序试试（编译和执行类似于上例）。到目前为止，关于Java的流程控制已经完全讲完了。要真正理解并掌握它们只有经过大量的练习。而好的方法就是修改上面的每一个程序，让它们实现你想要的功能，并在此基本上理解Java的流程控制。而要写好Java程序，熟悉使用Java的流程控制和异常处理是非常关键的。希望对你能有所帮助。

选择三种进行异处理 一代码块用try..catch进行异捕获处理； 二 该代码体外用throws进行抛声明告知调用者段代码能现些异需要谨慎处理两种情况： 声明抛异非运行异调用者必须显示用try..catch块进行捕获或者继续向层抛异 声明抛异运行异调用者选择进行异捕获处理 三代码块用throw手抛异象两种情况跟二）类似： 抛异象非运行异调用者必须显示用try..catch块进行捕获或者继续向层抛异 抛异象运行异调用者选择进行异捕获处理 （终异抛给main则相于交给jvm自处理jvm简单打印异信息） 处理设计建议 必要使用异才使用异要用异控制程序流程 切忌使用空catch块 检查异非检查异选择 注意catch块顺序 要提供给用户看信息放异信息 避免志信息记录同异 异处理尽量放高层进行 finally释放资

Error、AssertioinError 未定义。编译失败。如果定义了，就是exception elld

java (Ljava/lang/String;Ljava/lang/String;I)V是代码输错了。

C.java.lang.Exception一切异常类的父类

c 异常可分为 error 和Exception

有catch 就说明处理了 就算catch里面什么也不写 那也叫空处理 错误不会影响程序继续运行你说那个 叫 throw 是往外抛异常 如果外层没有处理 即外层没有 try catch 继续向外跑直到被处理 如果一直没处理 就会报错

一、第一种定义方式，继承Exception类public class MyFirstException extends Exception {public MyFirstException() {super();}public MyFirstException(String msg) { super(msg);}public MyFirstException(String msg, Throwable cause) {super(msg, cause);}public MyFirstException(Throwable cause) {super(cause);}//自定义异常类的主要作用是区分异常发生的位置，当用户遇到异常时，//根据异常名就可以知道哪里有异常，根据异常提示信息进行修改。}二、 第二种定义方式：继承Throwable 类public class MySecondException extends Throwable {public MySecondException() {super();}public MySecondException(String msg) {super(msg);}public MySecondException(String msg, Throwable cause) {super(msg, cause);}public MySecondException(Throwable cause) {super(cause);}}

异常的分类：Throwable包含了错误(Error)和异常(Excetion两类)。Exception又包含了运行时异常(RuntimeException, 又叫非检查异常)和非运行时异常(又叫检查异常)。Error是程序无法处理了, 如果OutOfMemoryError、OutOfMemoryError等等, 这些异常发生时, java虚拟机一般会终止线程。运行时异常都是RuntimeException类及其子类,如 NullPointerException、IndexOutOfBoundsException等, 这些异常是不检查的异常, 是在程序运行的时候可能会发生的, 所以程序可以捕捉, 也可以不捕捉. 这些错误一般是由程序的逻辑错误引起的, 程序应该从逻辑角度去尽量避免。检查异常是运行时异常以外的异常, 也是Exception及其子类, 这些异常从程序的角度来说是必须经过捕捉检查处理的, 否则不能通过编译. 如IOException、SQLException等。

抛出 NumberFormatException

getCause（)返回此异常的原因（尝试加载类时发生错误引发的异常；否则返回 null）。

个人认为你的答案是错误的，因为.java.lang.throwable是java.lang.exception的父类，所以所有的类应该都继承了throwable个类吧。你说的异常的类,是只能抽象类了.某子类c,父类p.如果p是普通的类,则c不必重写p内部的方法.重写是可选的.如果p抽象类

分类: 电脑/网络 >> 程序设计 >> 其他编程语言 问题描述: try { int i=11/b; throw new Throwable("Here is my Exception")} ………… 请问throw new throwable是什么意思？ 解析: 抛出一个自定义的异常,这个异常被处理之后会得到, "Here is my Exception"这个值.

参见科技与人文网（网页链接），里面有Java相关问题以及解决方案，异常相关就有80多种，执行异常、异常跟类等等。

Throwable是所有异常的父类，处理语句：try{//代码块}catch(Exception e ){//代码块}finally{//代码块}

早期的编程语言（比如C语言）没有异常处理，通常是遇到错误返回一个特殊的值或设定一个标志，并以此判断是不是有错误产生。随着系统规模的不断扩大，这种错误处理已经成为创建大型可维护程序的障碍了。于是在一些语言中出现了异常处理机制，比如在Basic中的异常处理语句“on error goto”，而Java则在C++基础上建立了新的异常处理机制。Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。这种机制为复杂程序提供了强有力的控制方式。同时这些异常代码与“常规”代码分离，增强了程序的可读性，编写程序时也显得更灵活。Java中的异常类在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Throwable类有两个标准子类：java.lang.Error和java.lang.Exception，即错误和异常。错误：Error类，一般是指虚拟机相关的问题，如系统崩溃、虚拟机出错误、动态链接失败等，这一类错误无法恢复或不可能捕获，将导致应用程序中断。异常：Exception类，则是指一些可以被捕获且可能恢复的异常情况，如数组下标越界Array，Index，OutOf，Bounds，Excepton。数字被零除产生异常：ArithmeticException 、输入/输出异常：IOException等。提示：Java编译器要求Java程序必须捕获或声明所有非运行时的异常，如：FileNotFoundException、IOException等。因为，对于这类异常来说，如果程序不进行处理，可能会带来意想不到的结果。但运行时出现异常可以不做处理，因为这类异常很普遍，全部处理可能对程序的可读性和运行效率产生影响。Java异常处理形式，Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理。下面是Java异常处理程序的基本形式： try //执行时程序块 catch ExceptionType1e //对ExceptionType1的处理 catch ExceptionType2e //对ExceptionType2的处理 throw e //再抛出这个“异常” finally try程序块和catch语句：遇到一个try语句，“异常”的框架就放到堆栈上面，直到所有的try块内的语句都完成。如果下一级的try语句没有对某种“异常”进行处理，堆栈就会展开，直到遇到有处理这种“异常”的try语句。 在try程序后面，应包含一个catch子句来指定你想要捕捉的“异常”的类型。提示：捕获异常的第一步就是用try … 选定你要捕获异常的范围，在执行时，括号内的代码会产生异常对象并被抛出。然后你就可以用catch块来处理异常了。 throw语句和throws语句：throw语句用来明确地抛出一个“异常”。首先，你必须得到一个Throwable类或其它子类产生的实例句柄，通过参数传到catch子句，或者用new语句来创建一个实例。 下面是throw语句的通常形式： throw ThrowableInstance，提示：执行throw语句后，运行流程将立即停止，throw的下一条语句也将暂停执行。这里new运算符用于创建一个Throwable类的实例，在后文的面向对象编程一文中将详细讲解。 throws语句用来标明一个成员函数可能抛出的各种“异常”。对大多数Exception子类来说，Java编译器会强迫你声明在一个成员函数中抛出的“异常”的类型。如果“异常”的类型是Error或RuntimeException，或它们的子类，这个规则不起作用。如果你想明确地抛出一个RuntimeException，你必须用throws语句来声明它的类型。 提示：当然，你可能对上面的说明不是很明白，不过不要紧，编译运行下面的Java程序（已经为你做了详细的注释）你会理解很多! 现在我们用下面的例程来说明问题： class ThrowsDemo //类名，相应的java源文件应该保存成： ThrowsDemo.javastatic void procedure throws IllegalAccessException //throws语句 //抛出IllegalAccessException类型的异常System.out.println ″inside procedure″ //输出文本信息，以说明是在执行procedure方法时抛出了异常throw new IllegalAccessException ″demo″ //新生成一个Throwable类实例，然后抛出异常 public static void main String args //main 方法开始，程序从此处执行 try //try语句块开始procedure //调用procedure方法，该方法将Throw（抛出）异常信息 catch IllegalAccessException e //处理IllegalAccessException类型的异常， catch语句块System.out.println ″caught ″ + e 编程并执行程序，其过程如下： E javacodeexception>java ThrowsDemoinside procedurecaught java.lang.IllegalAccessException demo提示：如上面的代码所示，我们用了一个完整的程序来说明在Java程序中如何使用try…catch…throw等语句。Try … 里产生的异常被捕获了下来，然后在catch块里进行处理（这里只是输出异常信息）。 throws IllegalAccessException标明程序将抛出一个IllegalAccessException类型的异常。IllegalAccessExceptione生成一个异常对象，然后用System.out.println输出异常信息。 finally语句，有时为了确保一段代码不管发生什么异常都要被执行，可以使用关键词finally来标出这样一段代码。一个成员函数返回到调用它的成员函数，或者通过一个没捕捉到的异常，或者通过一个明确的return语句，finally子句总是恰好在成员函数返回前执行。 下面我们以一个比较完整的异常处理程序来说明上面所述的各种异常处理语句的使用问题： class ExceptionDemo //异常使用示例，保存为ExceptionDemo.javastatic void procA try System.out.println ″inside procA″ throw new RuntimeException ″demo″ //抛出异常finally System.out.println ″procA"s finally″ //注意：不管发生什么等会执行!!static void procB try System.out.println ″inside procB″ return //返回，实际上是在finally语句执行完后才返回finally System.out.println ″procB"s finally″ public static void main String args try procA catch Exception e System.out.println ″catch ″+e procB提示：在上面的完整程序中，finally后的大括号内的代码是任何情况下都会执行的。另外，在procB中，return 语句并没有立即返回，这一点应该特别注意。你可以亲自动手，执行上面的程序试试（编译和执行类似于上例）。 到目前为止，关于Java的流程控制已经完全讲完了。要真正理解并掌握它们只有经过大量的练习。而好的方法就是修改上面的每一个程序，让它们实现你想要的功能，并在此基本上理解Java的流程控制。 而要写好Java程序，熟悉使用Java的流程控制和异常处理是非常关键的。

出现这个异常，表明向方法传递了不合法或不正确的参数。检查一下，是否在调用某个方法时，传递了与方法定义时不相符的参数类型。在SSM动态javaweb服务器框架中，经常看到这个异常，很多人说这是参数异常，检查自己在ioc容器中配置的参数是否正确，其实这是项目使用的Java编译器（即Javacompiler）使用的jdk版本和Java的运行环境（即jreJavaruntimeenvironment）版本不匹配造成的。扩展资料：类 Math 提供了常用的数学函数，比如正弦、余弦和平方根。类似地，类 String 和 StringBuffer 提供了常用的字符串操作。类 ClassLoader、Process、Runtime、SecurityManager 和 System 提供了管理类的动态加载、外部进程创建、主机环境查询（比如时间）和安全策略实施等“系统操作”。类 Throwable 包含了可能由 throw 语句抛出的对象(§14.16)。Throwable 的子类表示错误和异常。参考资料来源：百度百科-java.lang

SLF4J 1.6.0　以前的版本，如果打印异常堆栈信息，必须用log.error(Stringmsg,Throwablet)log.info等对应方法．如果msg含有变量，一般用String.format方法格式化msg.如果用error(Stringformat,Object...arguments) 等其它方法，异常堆栈信息会丢失．幸好，SLF4J 1.6.0以后的版本对这个不友好的异常信息log　改进了．error(Stringformat,Object…arguments)　这个方法也会打印异常堆栈信息，只不过规定throwable对象必须为最后一个参数．如果不遵守这个规定，异常堆栈信息不会log出来．

catch(Exception e){处理语句}

异常处理是初学者经常忽视执行的编程技巧。然而，当他们完成了一项大型项目后，就会发现仅仅停留在表面的工作是不够的。在本文中，我们将对异常处理进行讨论，并为大家解释其重要性，尤其是要告诉大家怎样处理这些情况。 　　首先，让我们解释一下什么是异常情况，通常也称例外。正如在其他的编程语言中那样，它也适用于Java：异常情况是那些在运行时出现错误的情况。这些错误并非真正的错误，因为他们是一些例外。我们可以将这些情况理解为必须解决的异常事件，否则程序将无法继续执行。所以我们就有必要了解怎样处理异常事件。 　　在异常事件的例子中最显著的应该是在程序执行时，运行时的分配变成了零。这样程序就无法执行，于是Java就会抛出一个异常事件，确切点说是ArithmeticException。从Java程序员的角度来看，异常事件是对象。抛出异常事件类似于抛出对象。但是，并非所有的对象都可以被抛出。 　　为了充分理解可抛出的异常事件，整个类层次结构的一些部分要被提交。主要的类称为Throwable。这个类拥有两个子类：Exception 和Error。一个异常事件对象应从Throwable的类中传出。意味着它应该是Exception子类或Error子类的一个对象实例。这些都可以在 java.lang数据包中找到。 　　异常处理就是捕捉可能在运行时被抛出的异常事件的一项技术。Java通过try-catch-finally的异常处理语句为我们提供了强大的异常处理解决方案。而在另一方面，你也可以使用已经声明的异常事件，如ArithmeticException, NullPointerException等。其他类扩展了Exception 类，如IOException子类。 　　此外，我们应该注意到异常事件包含了两种情况：检查过的和没检查的。技术上，我们认为没检查过的异常事件RuntimeExceptions。这些不需要在抛出的语句中作出声明，而且对它们的捕捉也是选择性的。不过，它们一般不会有什么影响，如果程序员根本不能发现它们的存在。在大多数情况下，这些都是逻辑性的编程错误，如NullPointerException或者ArrayIndexOutOfBounds。 　　同时，对异常事件进行技术性检查也迫使程序员对其进行处理和管理，意味着要对其进行单独捕捉并覆盖。这些都来自Exceptions类和它的子类，包括我们之前讨论过的RuntimeExceptions。检查过的异常事件要求异常事件处理因为它们有可能导致程序终止。 　　现在，我们对异常事件有了个基本的了解，下面就让我们启动集成开发环境开始编码吧! 　　异常处理 　　前面我们提到了异常处理就是指处理代码中的异常事件，或者在运行时向运行引擎抛出异常事件，在引擎末端它会搜索异常事件处理例程。它使用包含了一系列方法调用的调用堆栈进行搜索。 　　一般而言，异常事件可能因为包含一个异常活动或其他异步异常导致的。我们讨论的异常事件包括了一些基本的处理议题：怎样捕捉和处理这些异常事件。 　　Java允许我们创建自己的Exception对象和类，但是会有一个关键的请求。这些对象和类必须是扩展的Exception类。编码标准要求异常事件应该充分命名，意味着它们的名字就代表了其本身。 　　throw new Exception(“ This is an exception!”) 　　下面，我们看看要怎样捕捉和处理这些异常事件。检查以下代码： 　　try{ 　　// this is the block of code where the exception happens 　　// sometimes called as source/root of exception 　　// or even called as tricky block or tricky method 　　｝ 　　catch{Exception_Typel e) { 　　// dealing with this kind of exception 　　｝ 　　Catch (Exception_Type2 e) { 　　// dealing witn this kind of exception 　　｝ 　　//... unlimited number of catches are possible 　　finally { 　　// this block of code is always executed 　　｝ 　　try-catch-finally语句的第一个部分是尝试阻止。这是异常事件有可能发生的部分。通常，我们建议代码行用最小的数量来编写，因为它们只会在异常事件发生的时候执行。这种情况发生时，执行会跳转去捕捉那些异常事件被比较的块中。如果它们匹配，那么就可以处理异常事件。 　　不论尝试阻止的时候，异常事件会不会发生，或不管能不能得到处理，阻止总会执行。由于它总是被执行，所以我们推荐你在这里做一些清理。因此，正如所预料的那样，执行起来就是具有选择性的。 　　Try-catch模块的结构类似于switch-case的结构。在检查过的需要处理的异常事件中，是有可能在相同方法中将其处理或者抛出的。后者可以通过关键词抛出。在这种情况下，异常事件的种类必须在方法签名中被指定。看这个例子： 　　Void myMethod () throws SomeKindOfException{ 　　// method goes here 　　} 　　接下来，我们将为大家展示更多的异常处理实例。 　　初学者常常与非匹配数据类型纠缠不清。通常，它们会引发一些问题，例如，在做加法时出现非数字型代码。下面给大家展示的代码中，出现了异常处理的工作环境。检查该网页以完成嵌入式Exception种类的清单。现在，我们要处理NumberFormatException 的发生。 　　public static void main (String args[] ) { 　　double sum= 0; 　　for (int i=0; i﹤args. length; ++1) 　　try { 　　sum+= Double.parseDboule (args[i]); 　　} 　　Catch (NumberFormatException e) { 　　Ststem.out.printIn(args[i] + “non-numeric data on”); 　　} 　　System.out.printIn(“Total sum: “+ sum); 　　} 　　正如你所见到的，它和命令行参数一起运行，而且一旦轮到非数字型参数，它就会写入system.out，意指出现的问题。但是项目会继续进行，因为try模块是循环的。否则，没有合适的异常处理，项目就会终止。用这种方式总和还是可以计算处理并在最后显示处理。 　我们来看看另一个例子。在这个例子中，我们会要建立自己的异常实例类，该类扩展了其母Exception类。应用程序会模拟用于异常处理和抛出的堆栈机制，如堆栈是满的或者是空的。检查一下。 　　Public class StackException extends Exception { 　　Public StackException (String text) { 　　Super (text) 　　} 　　} 　　现在让我们创建一个Stack类。注意push和pop方法。它们正抛出StackException，而这一动作由方法签名导入。此外，还有一个if条件，且条件满足时，异常事件会被抛出。否则，一切都会顺利运行。 　　public class Stack { 　　private final int SIZE = 100; 　　private Object st[]; 　　private int size; 　　private int sp; 　　public Stack (int size) { 　　if (size < MAXSIZE) 　　this.size = size; 　　else 　　this.size = MAXSIZE; 　　this.st = new Object [size]; 　　this.sp = -1; 　　} 　　public void push (Object o) throws StackException { 　　if (sp == this.size - 1) 　　throw new StackException ("Stack is full"); 　　this.st [++this.sp] = o; 　　} 　　public Object pop () throws StackException { 　　if (sp == -1) 　　throw new StackException ("Stack is empty"); 　　Object o = this.st [this.sp]; 　　this.sp--; 　　return o; 　　} 　　public boolean isEmpty() { 　　return this.sp == -1; 　　} 　　} 　　好的，现在是时候写一写Main class连同主要方法了。在这一部分，请对try-catch语句给予更多关注。有两类异常情况可以被捕捉到。你也可以很容易地找出它们。 　　public class Main { 　　public static void main (String args[]) { 　　Stack s = new Stack (10); 　　for (int i = 0; i <= 10; ++i) 　　try { 　　s.push (new Integer(i)); 　　} 　　catch (StackException e) { 　　System.out.println (e); 　　} 　　while (! s.isEmpty() ) { 　　try { 　　System.out.println( (Integer)(s.pop()) ); 　　} 　　catch (StackException e) { 　　System.out.println(e); 　　} 　　} 　　} 　　} 　　当然，这里也会有附带输出。如你所见，第一行显示出的就是异常事件，因为我们要用11个要素填补堆栈，因此，在循环到isEmpty是错误的时，异常事件不会抛出。 　　Stack is full 　　练习几次以上的几段代码。如果异常事件被抛出但是却能够正确被处理那就不要感到惊讶。这就是异常处理的神奇之处。 　　总结 　　在这篇文章里我们就异常处理的实用性和重要性进行了分析。我们都知道，不管是检查过的或是未经检查的，程序员都要处理好异常事件，否则可能出现程序的异常终止。我们强调要将理论与实践相结合。坦率地说，本文虽只是冰山一角，但一些基本的知识已经介绍给了大家。希望能在异常处理方面对大家有所帮助。

lang 是 language（语言） 的简写 是java中常用方法最多的包 包含常用类 软件包 java.lang 的描述提供利用 Java 编程语言进行程序设计的基础类。最重要的类是 Object（它是类层次结构的根）和 Class（它的实例表示正在运行的应用程序中的类）。

虚拟机的规格标准强制的规定的：JVM虚拟机目前没有实现捕捉“泛型的抛出对象”，捕捉机制只对非泛型类有效。泛型模板在编译时也会类型具体化。

getCausepublicThrowablegetCause()返回此throwable的cause；如果cause不存在或未知，则返回null。（该Cause是导致抛出此throwable的throwable。）此实现返回由一个需要Throwable的构造方法提供的cause，或者在创建之后通过initCause(Throwable)方法进行设置的cause。虽然通常不需要重写此方法，但子类可以重写它，以返回一个通过某些其他方式设置的cause。这适用于在异常链（异常嵌套）机制被加入到Throwable之前存在“遗留Throwable链机制”的情况。注意，不必重写任何PrintStackTrace方法，所有方法都调用getCause方法来确定throwable的cause。返回：此throwable的cause，如果cause不存在或是未知的，则返回null。

你们真NB，呵呵

抛出异常

记得好像所有的类都是object的子类...再看看别人怎么说的。

Throwable是所有异常Exception和错误Error的祖先

没有错的啊i为0

是遍历的东西的长度 比如你用了个Arraylist al的容器接收了东西要将他遍历出来 就要for循环 比如for（int i;i<al.size();i++）{}这个length就相当于你的size（）这个东西 说不太明白

java中数组是没有length()方法的，只有length属性，数组array.length返回的是该数组的长度。字符串String是有length()方法的，str.length()返回的是该字符串的长度。扩展资料java数组常用方法：1、声明一个数组String[] aArray = new String[5]；String[] bArray = {"a","b","c", "d", "e"}；String[] cArray = new String[]{"a","b","c","d","e"}；2、打印一个数组String[] aArray = new String[5]；String[] bArray = {"a","b","c", "d", "e"}；String[] cArray = new String[]{"a","b","c","d","e"}；3、根据数组创建ArrayListString[] stringArray = { "a", "b", "c", "d", "e" }；ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray))；System.out.println(arrayList)；4、判断数组内部是否包含某个值String[] stringArray = { "a", "b", "c", "d", "e" }；boolean b = Arrays.asList(stringArray).contains("a")；System.out.println(b)；5、连接两个数组int[] intArray = { 1, 2, 3, 4, 5 }；int[] intArray2 = { 6, 7, 8, 9, 10 }；int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2)；6、声明一个内联数组method(new String[]{"a", "b", "c", "d", "e"})String常用方法：1、求字符串某一位置字符charAt(int index)返回字符串中指定位置的字符；注意字符串中第一个字符索引是0，最后一个是length()-1。例如：String str = new String("asdfzxc")；char ch = str.charAt(4)；//ch = z2、提取子串用String类的substring方法可以提取字符串中的子串，该方法有两种常用参数：1)substring(int beginIndex)该方法从beginIndex位置起，从当前字符串中取出剩余的字符作为一个新的字符串返回。2)substring(int beginIndex, int endIndex)该方法从beginIndex位置起，从当前字符串中取出到endIndex-1位置的字符作为一个新的字符串返回。例如：String str1 = new String("asdfzxc")；String str2 = str1.substring(2)；//str2 = "dfzxc"String str3 = str1.substring(2,5)；//str3 = "dfz"3、字符串比较1)compareTo(String anotherString)该方法是对字符串内容按字典顺序进行大小比较，通过返回的整数值指明当前字符串与参数字符串的大小关系。若当前对象比参数大则返回正整数，反之返回负整数，相等返回0。2)compareToIgnore(String anotherString)与compareTo方法相似，但忽略大小写。3)equals(Object anotherObject)//比较当前字符串和参数字符串，在两个字符串相等的时候返回true，否则返回false。4)equalsIgnoreCase(String anotherString)//与equals方法相似，但忽略大小写。例如：String str1 = new String("abc")；String str2 = new String("ABC")；int a = str1.compareTo(str2)；//a>0int b = str1.compareToIgnoreCase(str2)；//b=0boolean c = str1.equals(str2)；//c=falseboolean d = str1.equalsIgnoreCase(str2)；//d=true4、字符串连接concat(String str)将参数中的字符串str连接到当前字符串的后面，效果等价于"+"。例如：String str = "aa".concat("bb").concat("cc")；相当于String str = "aa"+"bb"+"cc"；

数组或字符串的长度

arr：数组名称length：数组长度属性譬如：int[] arr = {1,2,3,4};数组arr有4个元素，即1,2,3,4 ，数组长度即为4，也就是arr.length的值为4

呵呵这里经常会出问题java中数组有一个length（长度）的变量（属性）所以可以用length属性，字符串则有一个length（）方法。比如：int[]a={1,2,3};system.out.println(a.length);strings="hahah";system.out.println(s.length());

length属性是针对Java中的数组来说的，要求数组的长度可以用其length属性；publicstaticvoidmain(String[]args)；String[]list={"ma","cao","yuan"};System.out.println(list.length);ListJava是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

java中数组有没有length()方法，求数组的长度可以使用数组的length属性。int[]arr={1,2,3,4,5};intlength=arr.length;//求数组的长度String有length（）方法，用来求字符串的长度Stringstr="Hello";intlength=str.length()；//求字符串

两个数据都为593，你赋值的时候从第0位开始复制从第7位赋值，没有异常吗？

把ArrayOfString中的数据取出，封装到list中，json有方法直接把list转成json格式的数据JSONArray.fromObject(list)，把这个jsonArray返回前台就可以调用了

phonegapphonegap负责和底层OS通信，调用摄像头、获取网络状态等backbone+underscore做路由以及视图渲染iscroll做布局css3做动画效果

后台response响应回去，然后再跳转到jsp就ok了

var InterValObj; //timer变量，控制时间var count = 120; //间隔函数，1秒执行var curCount;//当前剩余秒数var code = ""; //验证码var codeLength = 6;//验证码长度function sendMessage() { curCount = count; var jbPhone = $("#jbPhone").val(); var jbPhoneTip = $("#jbPhoneTip").text(); if (jbPhone != "") { if(jbPhoneTip == "√ 该手机号码可以注册，输入正确" || jbPhoneTip == "√ 短信验证码已发到您的手机,请查收"){ // 产生验证码 for ( var i = 0; i < codeLength; i++) { code += parseInt(Math.random() * 9).toString(); } // 设置button效果，开始计时 $("#btnSendCode").attr("disabled", "true"); $("#btnSendCode").val("请在" + curCount + "秒内输入验证码"); InterValObj = window.setInterval(SetRemainTime, 1000); // 启动计时器，1秒执行一次 // 向后台发送处理数据 $.ajax({ type: "POST", // 用POST方式传输 dataType: "text", // 数据格式:JSON url: "UserAction_sms.action", // 目标地址 data: "jbPhone=" + jbPhone +"&code=" + code, error: function (XMLHttpRequest, textStatus, errorThrown) { }, success: function (data){ data = parseInt(data, 10); if(data == 1){ $("#jbPhoneTip").html("<font color="#339933">√ 短信验证码已发到您的手机,请查收</font>"); }else if(data == 0){ $("#jbPhoneTip").html("<font color="red">× 短信验证码发送失败，请重新发送</font>"); }else if(data == 2){ $("#jbPhoneTip").html("<font color="red">× 该手机号码今天发送验证码过多</font>"); } } }); } }else{ $("#jbPhoneTip").html("<font color="red">× 手机号码不能为空</font>"); }}//timer处理函数function SetRemainTime() { if (curCount == 0) { window.clearInterval(InterValObj);// 停止计时器 $("#btnSendCode").removeAttr("disabled");// 启用按钮 $("#btnSendCode").val("重新发送验证码"); code = ""; // 清除验证码。如果不清除，过时间后，输入收到的验证码依然有效 }else { curCount--; $("#btnSendCode").val("请在" + curCount + "秒内输入验证码"); }}$(document).ready(function() { $("#SmsCheckCode").blur(function() { var SmsCheckCodeVal = $("#SmsCheckCode").val(); // 向后台发送处理数据 $.ajax({ url : "UserAction_checkCode.action", data : {SmsCheckCode : SmsCheckCodeVal}, type : "POST", dataType : "text", success : function(data) { data = parseInt(data, 10); if (data == 1) { $("#SmsCheckCodeTip").html("<font color="#339933">√ 短信验证码正确，请继续</font>"); } else { $("#SmsCheckCodeTip").html("<font color="red">× 短信验证码有误，请核实后重新填写</font>"); } } }); });});

根据 请求的 request 的 user-agent 判断 ~~~~~~~~

读出来干什么呢，可以读成二进制字节数组

图像置乱?搞成点数组，随机交换 不就乱了。。。

NullPointerException是空指针异常，说明第90行，没有获取到值。没有值传给setName。

add()方法中 b_temp.setNumber(b_temp.getNumber()+b.getNumber()); 这行代码不正确，你不能对b_temp同时即进行setNumber操作又进行getNumber操作

首先找到发生异常的那行，然后寻找逐步向上找源头。如果没有必要查找源头，可以直接绕过它。譬如：1，List<String>books=BooKDAO.findAll();2，intsize=books.size();如果第2行发生空指针异常了，知道books肯定为null了，这时查找BookDAO.的findAll方法，如果findAll()方法又调用了其他的方法，可以继续查下去。如果没有业务需要，可以直接写成：List<String>books=BooKDAO.findAll();intsize=0;if(books!=null){size=books.size();}或者List<String>books=BooKDAO.findAll();intsize=0;try{size=books.size();}catch(NullpointerException){size=0;或者不写或者打印错误}/iknow-pic.cdn.bcebos.com/8694a4c27d1ed21b27f786aba06eddc451da3f45"target="_blank"title="点击查看大图"class="ikqb_img_alink">/iknow-pic.cdn.bcebos.com/8694a4c27d1ed21b27f786aba06eddc451da3f45?x-bce-process=image%2Fresize%2Cm_lfit%2Cw_600%2Ch_800%2Climit_1%2Fquality%2Cq_85%2Fformat%2Cf_auto"esrc="https://iknow-pic.cdn.bcebos.com/8694a4c27d1ed21b27f786aba06eddc451da3f45"/>扩展资料最重要的类是Object（它是类层次结构的根）和Class（它的实例表示正在运行的应用程序中的类）。把基本类型的值当成一个对象来表示通常很有必要。包装器类Boolean、Character、Integer、Long、Float和Double就是用于这个目的。类Math提供了常用的数学函数，比如正弦、余弦和平方根。类似地，类String和StringBuffer提供了常用的字符串操作。类ClassLoader、Process、Runtime、SecurityManager和System提供了管理类的动态加载、外部进程创建、主机环境查询（比如时间）和安全策略实施等“系统操作”。类Throwable包含了可能由throw语句抛出的对象(§14.16)。Throwable的子类表示错误和异常。参考资料：/baike.baidu.com/item/java.lang/5179788"target="_blank"title="java.lang-百度百科">java.lang-百度百科

这应该是网站提供者内部的问题，如果不是你自己开发的网站，很难说

直接拉过去复制了下，运行正常。

Shape.this 指的是什么呢？ 问题应该就出在这里 你检查一下吧，我不明白你的Shape.this是什么意思，你仔细检查一下吧。

2楼好样的

fields 可能是null吧！！！！！！！！！

空指针~~ 可能是异常的这部分有东西还没有加载上的时候就引用了~~ 仔细从程序开始一步一步看看~~

这个异常都是因为调用null对象的方法 , ,就是一个对象还没有没有正常初始化 就先调用它的方法 比如 Object obj=null; obj.toString(); 这就会抛出 这个异常 当...

这个程序我给你改了，你拷到eclipse里看看问题主要在：当最后一次循环时候temp.getLast()这个是空的因为你没有a[9],那么好，少循环一次就解决了。楼主试试class Person { private String lastName; private String firstName; private int age; public Person(String last, String first, int a) { lastName = last; firstName = first; age = a; } public void displayPerson() { System.out.print(" Last name : " + lastName + " First name: " + firstName); System.out.println(", age: " + age); } public String getLast() { return lastName; }}class ArrayInOb { private Person[] a; private int nElems; public ArrayInOb(int max) { a = new Person[max]; nElems = 0; } public void insert(String last, String first, int age) { a[nElems] = new Person(last, first, age); nElems++; } public void display() { for (int j = 0; j < nElems; j++) a[j].displayPerson(); System.out.println(" "); } public void insertionSort() { int in, out; for (out = 1; out < nElems; out++) { Person temp = a[out]; in = out; while (in > 0 && a[in - 1].getLast().compareTo(temp.getLast()) > 0) { a[in] = a[in - 1]; --in; } a[in] = temp; } }}public class objectSort { /** * @param args */ public static void main(String[] args) { int maxSize = 100; ArrayInOb arr; arr = new ArrayInOb(maxSize); arr.insert("Evans", "Patty", 24); arr.insert("Smith", "Doc", 59); arr.insert("Smith", "Lorraina", 37); arr.insert("Smith", "Paul", 37); arr.insert("Yee", "Tom", 43); arr.insert("Hashimoto", "Sato", 21); arr.insert("Stimson", "Henry", 29); arr.insert("Velasquez", "Jose", 72); arr.insert("Creswell", "Lucinda", 18); System.out.println("Before sorting:"); arr.display(); arr.insertionSort(); System.out.println("After sorting:"); arr.display(); }}

你的conn是null，你的getConntion()应该用来赋值给conn吧

我感觉是你的Long型变量为空了。你看一下。仔细看一下提示错误的那一行空指针错误会发生一定是因为你用一个NULL对象。使用它的方法了。解决办法就是首先这个对象在业务上可不可能为NULL如果可能就在调用它的方法前判断if（某对象！=null）{某对象。某方法（）；}如果不可能为空，就debug看一下为什么它是空的。不过编程规约的角度来看一个对象在调用方法之前最好都加上非空的判断。至于你的代码，错误发生在15行请debug看一下nowtime是不是为空nowtime.gettime()是不是为空然后看一下nowtime.gettime()/1000是不是为空就这样，一点点找出错误的原因。希望可以帮到你

!name.equals(g)执行之前应该先对name判空，后面的pwd也是。不能调用null对象的equals方法

java.lang.nullpointerexception在java中是空指针异常，主要跟与对象的操作相关。比如有如下代码：String userName = request.getParameter("username"); If (userName.equals("root")) {//逻辑处理}本代码功能是：检测用户提供的用户名，如果是用户名称为"root"的用户时，就执行一些特别的操作。说明： 在代码段中，如果有用户没有提供表单域"username"的值时，字符串对象userName为null值，不能够将一个null的对象与另一个对象直接比较，就会抛出(java.lang.NullPointerException)空指针错误。为了确保进行操作或引用的对象非空，假若我们要对某对象进行操作或引用，我们首先去检查该对象是否已经实例化且不为空；并且在系统中加入针对对象为空时情况的处理。如：采用String对象保存用户提交的结果；在如果涉及对象的操作时，先检测其是否为空后，检查到对象为空后，可再选择进行以下任一种处理方式：处理方式 1) 检查到对象为空时，设置对象值为空字符串或一个默认值； 处理方式 2) 检测到对象为空时，根本不执行某操作，直接跳转到其他处理中。 处理方式 3) 检查到对象为空时，提示用户操作有错误。

首先找到发生异常的那行，然后寻找逐步向上找源头。如果没有必要查找源头，可以直接绕过它。譬如：1，List<String>books=BooKDAO.findAll();2，intsize=books.size();如果第2行发生空指针异常了，知道books肯定为null了，这时查找BookDAO.的findAll方法，如果findAll()方法又调用了其他的方法，可以继续查下去。如果没有业务需要，可以直接写成：List<String>books=BooKDAO.findAll();intsize=0;if(books!=null){size=books.size();}或者List<String>books=BooKDAO.findAll();intsize=0;try{size=books.size();}catch(NullpointerException){size=0;或者不写或者打印错误}扩展资料最重要的类是Object（它是类层次结构的根）和Class（它的实例表示正在运行的应用程序中的类）。把基本类型的值当成一个对象来表示通常很有必要。包装器类Boolean、Character、Integer、Long、Float和Double就是用于这个目的。类Math提供了常用的数学函数，比如正弦、余弦和平方根。类似地，类String和StringBuffer提供了常用的字符串操作。类ClassLoader、Process、Runtime、SecurityManager和System提供了管理类的动态加载、外部进程创建、主机环境查询（比如时间）和安全策略实施等“系统操作”。类Throwable包含了可能由throw语句抛出的对象(§14.16)。Throwable的子类表示错误和异常。参考资料：java.lang-百度百科

首先找到发生异常的那行，然后寻找逐步向上找源头。如果没有必要查找源头，可以直接绕过它。譬如：1，List<String>books=BooKDAO.findAll();2，intsize=books.size();如果第2行发生空指针异常了，知道books肯定为null了，这时查找BookDAO.的findAll方法，如果findAll()方法又调用了其他的方法，可以继续查下去。如果没有业务需要，可以直接写成：List<String>books=BooKDAO.findAll();intsize=0;if(books!=null){size=books.size();}或者List<String>books=BooKDAO.findAll();intsize=0;try{size=books.size();}catch(NullpointerException){size=0;或者不写或者打印错误}/iknow-pic.cdn.bcebos.com/8694a4c27d1ed21b27f786aba06eddc451da3f45"target="_blank"title="点击查看大图"class="ikqb_img_alink">/iknow-pic.cdn.bcebos.com/8694a4c27d1ed21b27f786aba06eddc451da3f45?x-bce-process=image%2Fresize%2Cm_lfit%2Cw_600%2Ch_800%2Climit_1%2Fquality%2Cq_85%2Fformat%2Cf_auto"esrc="https://iknow-pic.cdn.bcebos.com/8694a4c27d1ed21b27f786aba06eddc451da3f45"/>扩展资料最重要的类是Object（它是类层次结构的根）和Class（它的实例表示正在运行的应用程序中的类）。把基本类型的值当成一个对象来表示通常很有必要。包装器类Boolean、Character、Integer、Long、Float和Double就是用于这个目的。类Math提供了常用的数学函数，比如正弦、余弦和平方根。类似地，类String和StringBuffer提供了常用的字符串操作。类ClassLoader、Process、Runtime、SecurityManager和System提供了管理类的动态加载、外部进程创建、主机环境查询（比如时间）和安全策略实施等“系统操作”。类Throwable包含了可能由throw语句抛出的对象(§14.16)。Throwable的子类表示错误和异常。参考资料：/baike.baidu.com/item/java.lang/5179788"target="_blank"title="java.lang-百度百科">java.lang-百度百科

AddBookAction 应该有一个Double型的参数，但是这个参数从前端传来的是null值，所以在转换的时候出错了。 产生错误的原因是：Double d = Double.parseDouble(null);

你使用了空的指针。在java中虽然号称抛弃了C＋＋中不安全的指针，但其实他所有的东西你都可以理解为指针。这种情况一般发生在你使用了一个对象实例（其实是一个类指针）来调用它的成员函数，但这个实例却为null。 建议先检查一下你的SQL是不是有问题，然后看你的逻辑是不是有问题主要有以下几种原因：1、使用了未初始化的变量（虽然已经声明） 2、使用了未初始化的对象（虽然已经声明） 3，使用了关键字或已存在的类名作变量对象方法或类名。一般报java.lang.NullPointerException的原因有以下几种： 1字符串变量未初始化； 2接口类型的对象没有用具体的类初始化，比如： List lt；会报错 List lt = new ArrayList()；则不会报错了 3当一个对象的值为空时，你没有判断为空的情况。 你可以试着把下面的代码前加一行代码： if(rb!=null && rb!="") 改成： if(rb==null); if(rb!==null&&rb!="")