java

Transient 　　Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。 Transient 也是java中的保留字,Java有个特点就是序列化，简单地来说就是可以将这个类存储在物理空间（当然还是以文件的形式存在），那么当你从本地还原这个文件时，你可以将它转换为它本身。这可以极大地方便程序中操作，但同时，因为涉及到安全问题，所以并不希望把类里面所有的属性都能存储（因为那样，别人可以通过序列化知道类里面的内容），那么我们就可以用上transient这个关键字，它的意思是临时的，即不会随类一起序列化到本地，所以当还原后，这个关键字定义的变量也就不再存在。

该方法不被序列化有什么问题吗？

深度优先搜索？

看看java API

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

Exception 就是根异常 RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。 可能在执行方法期间抛出但未被捕获的 RuntimeException 的任何子类都无需在 throws 子句中进行声明。 可以去百度一下这个 JDK6API中文参考[沈东良] 有详解

Exception好像是任何异常类的基类

在 Java 应用程序中，异常处理机制为：抛出异常，捕捉异常。抛出异常：当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统，异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。捕获异常：在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器（exception handler）。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适 的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适 的异常处理器，则运行时系统终止。同时，意味着Java程序的终止。对于运行时异常、错误或可查异常，Java技术所要求的异常处理方式有所不同。由于运行时异常的不可查性，为了更合理、更容易地实现应用程序，Java规定，运行时异常将由Java运行时系统自动抛出，允许应用程序忽略运行时异常。对于方法运行中可能出现的Error，当运行方法不欲捕捉时，Java允许该方法不做任何抛出声明。因为，大多数Error异常属于永远不能被允许发生的状况，也属于合理的应用程序不该捕捉的异常。对于所有的可查异常，Java规定：一个方法必须捕捉，或者声明抛出方法之外。也就是说，当一个方法选择不捕捉可查异常时，它必须声明将抛出异常。能够捕捉异常的方法，需要提供相符类型的异常处理器。所捕捉的异常，可能是由于自身语句所引发并抛出的异常，也可能是由某个调用的方法或者Java运行时 系统等抛出的异常。也就是说，一个方法所能捕捉的异常，一定是Java代码在某处所抛出的异常。简单地说，异常总是先被抛出，后被捕捉的。任何Java代码都可以抛出异常，如：自己编写的代码、来自Java开发环境包中代码，或者Java运行时系统。无论是谁，都可以通过Java的throw语句抛出异常。从方法中抛出的任何异常都必须使用throws子句。捕捉异常通过try-catch语句或者try-catch-finally语句实现。总体来说，Java规定：对于可查异常必须捕捉、或者声明抛出。允许忽略不可查的RuntimeException和Error。4.1 捕获异常：try、catch 和 finally1.try-catch语句在Java中，异常通过try-catch语句捕获。其一般语法形式为：try { // 可能会发生异常的程序代码 } catch (Type1 id1){ // 捕获并处置try抛出的异常类型Type1 } catch (Type2 id2){ //捕获并处置try抛出的异常类型Type2 } 关键词try后的一对大括号将一块可能发生异常的代码包起来，称为监控区域。Java方法在运行过程中出现异常，则创建异常对象。将异常抛出监控区域之 外，由Java运行时系统试图寻找匹配的catch子句以捕获异常。若有匹配的catch子句，则运行其异常处理代码，try-catch语句结束。匹配的原则是：如果抛出的异常对象属于catch子句的异常类，或者属于该异常类的子类，则认为生成的异常对象与catch块捕获的异常类型相匹配。例1 捕捉throw语句抛出的“除数为0”异常。public class TestException { public static void main(String[] args) { int a = 6; int b = 0; try { // try监控区域 if (b == 0) throw new ArithmeticException(); // 通过throw语句抛出异常 System.out.println("a/b的值是：" + a / b); } catch (ArithmeticException e) { // catch捕捉异常 System.out.println("程序出现异常，变量b不能为0。"); } System.out.println("程序正常结束。"); } } 运行结果：程序出现异常，变量b不能为0。程序正常结束。例1 在try监控区域通过if语句进行判断，当“除数为0”的错误条件成立时引发ArithmeticException异常，创建 ArithmeticException异常对象，并由throw语句将异常抛给Java运行时系统，由系统寻找匹配的异常处理器catch并运行相应异 常处理代码，打印输出“程序出现异常，变量b不能为0。”try-catch语句结束，继续程序流程。事实上，“除数为0”等ArithmeticException，是RuntimException的子类。而运行时异常将由运行时系统自动抛出，不需要使用throw语句。例2 捕捉运行时系统自动抛出“除数为0”引发的ArithmeticException异常。public static void main(String[] args) { int a = 6; int b = 0; try { System.out.println("a/b的值是：" + a / b); } catch (ArithmeticException e) { System.out.println("程序出现异常，变量b不能为0。"); } System.out.println("程序正常结束。"); } } 运行结果：程序出现异常，变量b不能为0。程序正常结束。例2 中的语句：System.out.println("a/b的值是：" + a/b);在运行中出现“除数为0”错误，引发ArithmeticException异常。运行时系统创建异常对象并抛出监控区域，转而匹配合适的异常处理器catch，并执行相应的异常处理代码。由于检查运行时异常的代价远大于捕捉异常所带来的益处，运行时异常不可查。Java编译器允许忽略运行时异常，一个方法可以既不捕捉，也不声明抛出运行时异常。例3 不捕捉、也不声明抛出运行时异常。public class TestException { public static void main(String[] args) { int a, b; a = 6; b = 0; // 除数b 的值为0 System.out.println(a / b); } } 运行结果：Exception in thread "main" java.lang.ArithmeticException: / by zeroat Test.TestException.main(TestException.java:8)例4 程序可能存在除数为0异常和数组下标越界异常。public class TestException { public static void main(String[] args) { int[] intArray = new int[3]; try { for (int i = 0; i <= intArray.length; i++) { intArray[i] = i; System.out.println("intArray[" + i + "] = " + intArray[i]); System.out.println("intArray[" + i + "]模 " + (i - 2) + "的值: " + intArray[i] % (i - 2)); } } catch (ArrayIndexOutOfBoundsException e) { System.out.println("intArray数组下标越界异常。"); } catch (ArithmeticException e) { System.out.println("除数为0异常。"); } System.out.println("程序正常结束。"); } } 运行结果：intArray[0] = 0intArray[0]模 -2的值: 0intArray[1] = 1intArray[1]模 -1的值: 0intArray[2] = 2除数为0异常。程序正常结束。

IOException FileNotFoundException SqlException NullPointerException ArrayIndexOutOfBoundsException

Error类，表示仅靠程序本身无法恢复的严重错误，比如说内存溢出、动态链接异常、虚拟机错误。应用程序不应该抛出这种类型的对象。假如出现这种错误，除了尽力使程序安全退出外，在其他方面是无能为力的。所以在进行程序设计时，应该更关注Exception类。Exception类，由Java应用程序抛出和处理的非严重错误，比如所需文件没有找到、零作除数，数组下标越界等。它的各种不同子类分别对应不同类型异常。Exception可分为两类：CheckedException和RuntimeException

一楼的这位老大你在误人子弟啊Error 是 Throwable 的子类，用于指示合理的应用程序不应该试图捕获的严重问题。大多数这样的错误都是异常条件。虽然 ThreadDeath 错误是一个“正规”的条件，但它也是 Error 的子类，因为大多数应用程序都不应该试图捕获它。 直接已知子类： AnnotationFormatError, AssertionError, AWTError, CoderMalfunctionError, FactoryConfigurationError, LinkageError, ThreadDeath, TransformerFactoryConfigurationError, VirtualMachineError Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。直接已知子类： AclNotFoundException, ActivationException, AlreadyBoundException, ApplicationException, AWTException, BackingStoreException, BadAttributeValueExpException, BadBinaryOpValueExpException, BadLocationException, BadStringOperationException, BrokenBarrierException, CertificateException, ClassNotFoundException, CloneNotSupportedException, DataFormatException, DatatypeConfigurationException, DestroyFailedException, ExecutionException, ExpandVetoException, FontFormatException, GeneralSecurityException, GSSException, IllegalAccessException, IllegalClassFormatException, InstantiationException, InterruptedException, IntrospectionException, InvalidApplicationException, InvalidMidiDataException, InvalidPreferencesFormatException, InvalidTargetObjectTypeException, InvocationTargetException, IOException, JMException, LastOwnerException, LineUnavailableException, MidiUnavailableException, MimeTypeParseException, NamingException, NoninvertibleTransformException, NoSuchFieldException, NoSuchMethodException, NotBoundException, NotOwnerException, ParseException, ParserConfigurationException, PrinterException, PrintException, PrivilegedActionException, PropertyVetoException, RefreshFailedException, RemarshalException, RuntimeException, SAXException, ServerNotActiveException, SQLException, TimeoutException, TooManyListenersException, TransformerException, UnmodifiableClassException, UnsupportedAudioFileException, UnsupportedCallbackException, UnsupportedFlavorException, UnsupportedLookAndFeelException, URISyntaxException, UserException, XAException, XMLParseException, XPathException

　　1. Collection是集合类的一个顶级接口，其直接继承接口有List与Set　　而Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。　　　　1) 排序(Sort)　　使用sort方法可以根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此列表内的所有元素都必须是使用指定比较器可相互比较的double array[] = {112, 111, 23, 456, 231 };for (int i = 0; i < array.length; i++) {list.add(new Double(array[i]));}Collections.sort(list);for (int i = 0; i < array.length; i++) {System.out.println(li.get(i));}//结果：112,111,23,456,231　　2) 混排（Shuffling）　　混排算法所做的正好与 sort 相反: 打乱在一个 List 中可能有的任何排列的踪迹。也就是说，基于随机源的输入重排该 List, 这样的排列具有相同的可能性。这个算法在实现一个碰运气的游戏中是非常有用的。例如，可用来混排代表一副牌的 Card 对象的一个 List 。另外，在生成测试案例时，也是十分有用的。Collections.Shuffling(list)double array[] = {112, 111, 23, 456, 231 };for (int i = 0; i < array.length; i++) {list.add(new Double(array[i]));}Collections.shuffle(list);for (int i = 0; i < array.length; i++) {System.out.println(li.get(i));}//结果：112,111,23,456,231　　3) 反转(Reverse)使用Reverse方法可以根据元素的自然顺序 对指定列表按降序进行排序。Collections.reverse(list)double array[] = {112, 111, 23, 456, 231 };for (int i = 0; i < array.length; i++) {list.add(new Double(array[i]));}Collections. reverse (list);for (int i = 0; i < array.length; i++) {System.out.println(li.get(i));}//结果：231,456,23,111,112　　4) 替换所以的元素(Fill)　　使用指定元素替换指定列表中的所有元素。String str[] = {"dd","aa","bb","cc","ee"};for(int j=0;j<str.length;j++){li.add(new String(str[j]));}Collections.fill(li,"aaa");for (int i = 0; i < li.size(); i++) {System.out.println("list[" + i + "]=" + li.get(i));}//结果：aaa,aaa,aaa,aaa,aaa　　5) 拷贝(Copy)　　用两个参数，一个目标 List 和一个源 List, 将源的元素拷贝到目标，并覆盖内容。目标 List 至少与源一样长。如果更长，则在目标 List 中的剩余元素不受影响。Collections.copy(list,li): 后面一个参数是目标列表 ,前一个是源列表double array[] = {112, 111, 23, 456, 231 };List list = new ArrayList();List li = new ArrayList();for (int i = 0; i < array.length; i++) {list.add(new Double(array[i]));}double arr[] = {1131,333};String str[] = {"dd","aa","bb","cc","ee"};for(int j=0;j<arr.length;j++){li.add(new Double(arr[j]));}Collections.copy(list,li);for (int i = 0; i <list.size(); i++) {System.out.println("list[" + i + "]=" + list.get(i));}//结果：1131,333,23,456,231　　6) 返回Collections中最小元素(min)　　根据指定比较器产生的顺序，返回给定 collection 的最小元素。collection 中的所有元素都必须是通过指定比较器可相互比较的Collections.min(list)double array[] = {112, 111, 23, 456, 231 };List list = new ArrayList();for (int i = 0; i < array.length; i++) {list.add(new Double(array[i]));}Collections.min(list);for (int i = 0; i <list.size(); i++) {System.out.println("list[" + i + "]=" + list.get(i));}//结果：23　　7) 返回Collections中最小元素(max)　　根据指定比较器产生的顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须是通过指定比较器可相互比较的Collections.max(list)double array[] = {112, 111, 23, 456, 231 };List list = new ArrayList();for (int i = 0; i < array.length; i++) {list.add(new Double(array[i]));}Collections.max(list);for (int i = 0; i <list.size(); i++) {System.out.println("list[" + i + "]=" + list.get(i));}//结果：456　　8) lastIndexOfSubList　　返回指定源列表中最后一次出现指定目标列表的起始位置int count = Collections.lastIndexOfSubList(list,li);double array[] = {112, 111, 23, 456, 231 };List list = new ArrayList();List li = new ArrayList();for (int i = 0; i < array.length; i++) {list.add(new Double(array[i]));}double arr[] = {111};String str[] = {"dd","aa","bb","cc","ee"};for(int j=0;j<arr.length;j++){li.add(new Double(arr[j]));}Int locations = Collections. lastIndexOfSubList (list,li);System.out.println(“===”+ locations);//结果 3　　9) IndexOfSubList　　返回指定源列表中第一次出现指定目标列表的起始位置int count = Collections.indexOfSubList(list,li);double array[] = {112, 111, 23, 456, 231 };List list = new ArrayList();List li = new ArrayList();for (int i = 0; i < array.length; i++) {list.add(new Double(array[i]));}double arr[] = {111};String str[] = {"dd","aa","bb","cc","ee"};for(int j=0;j<arr.length;j++){li.add(new Double(arr[j]));}Int locations = Collections.indexOfSubList(list,li);System.out.println(“===”+ locations);//结果 1　　10) Rotate　　根据指定的距离循环移动指定列表中的元素Collections.rotate(list,-1);如果是负数，则正向移动，正数则方向移动double array[] = {112, 111, 23, 456, 231 };List list = new ArrayList();for (int i = 0; i < array.length; i++) {list.add(new Double(array[i]));}Collections.rotate(list,-1);for (int i = 0; i <list.size(); i++) {System.out.println("list[" + i + "]=" + list.get(i));}//结果：111,23,456,231,112

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、java.util.Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。 Collection ├List │├LinkedList │├ArrayList │└Vector │　└Stack └Set 2、java.util.Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。Java代码 import java.util.ArrayList; import java.util.Collections; import java.util.List; public class TestCollections { public static void main(String args[]) { //注意List是实现Collection接口的 List list = new ArrayList(); double array[] = { 112, 111, 23, 456, 231 }; for (int i = 0; i < array.length; i++) { list.add(new Double(array[i])); } Collections.sort(list); for (int i = 0; i < array.length; i++) { System.out.println(list.get(i)); } // 结果：23.0 111.0 112.0 231.0 456.0 } }

容器，储存对象的，放进去取出来

使用中的区别1、对技术的支持：Tomcat不支持EJB，JBoss是实现了EJB容器，再集成了Tomcat。WebSphere都是对业内多种标准的全面支持，包括EJB、JSB、JMS、JDBC、XML和WML，使Web应用系统的实施更为简单，并且保护了投资，同时也使基于标准的解决方案的开发更加简便。2、应用范围的区别：Tomcat 是一个小型的轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。WebSphere是商业软件,功能齐全强大,主要应用于大型企业的大型项目。3、商业服务和技术支持的区别：Tomcat都是开源免费的，所有它俩也就没有任何商业服务和技术支持，而WebSphere的技术文档和相关服务还是很到位，如果你的服务器哪一天出问题了，只要你能出的起钱，他们的技术工程师立刻就能出现在你面前。4、安全性问题：Tomcat都是开源的，所以它们的安全性相对来说比较低，万一应用服务器本身有什么漏洞，你是没办法向Apache索赔的。WebSphere其容错、系统管理和安全性能已经在全球数以千记的关键任务环境中得以验证。

仔细看看课本吧 好像这样是不对的饿

在applicationContext.xml文件下 <bean id="commonDao".. 配置错误. 缺少<property name="sessionFactory".. 或者 sessionFactory配置错误

安装Tomcat5就能运行了将你的整个程序配置到tomcat/webapps下,启动Tomcat5,打开IE浏览器,先连接tomcathttp://localhost:8080若连接上用http://localhost:8080/你的文件夹名/页面名试试看吧

　　 一 HTTP协议的作用原理 　　WWW是以Internet作为传输媒介的一个应用系统 WWW网上最基本的传输单位是Web网页 WWW的工作基于客户机/服务器计算模型 由Web 浏览器（客户机）和Web服务器（服务器）构成 两者之间采用超文本传送协议（HTTP）进行通信 HTTP协议是基于TCP/IP协议之上的协议 是Web浏览器和Web服务器之间的应用层协议 是通用的 无状态的 面向对象的协议 HTTP协议的作用原理包括四个步骤 　　（ ） 连接 Web浏览器与Web服务器建立连接 打开一个称为socket（套接字）的虚拟文件 此文件的建立标志着连接建立成功 　　（ ） 请求 Web浏览器通过socket向Web服务器提交请求 HTTP的请求一般是GET或POST命令（POST用于FORM参数的传递） GET命令的格式为 　　GET 路径/文件名 HTTP/ 　　文件名指出所访问的文件 HTTP/ 指出Web浏览器使用的HTTP版本 　　（ ） 应答 Web浏览器提交请求后 通过HTTP协议传送给Web服务器 Web服务器接到后 进行事务处理 处理结果又通过HTTP传回给Web浏览器 从而在Web浏览器上显示出所请求的页面 　　例 假设客户机与 /mydir/l建立了连接 就会发送GET命令 GET /mydir/l HTTP/ 主机名为的Web服务器从它的文档空间中搜索子目录mydir的文件l 如果找到该文件 Web服务器把该文件内容传送给相应的Web浏览器 　　为了告知 Web浏览器传送内容的类型 Web服务器首先传送一些HTTP头信息 然后传送具体内容（即HTTP体信息） HTTP头信息和HTTP体信息之间用一个空行分开 　　 常用的HTTP头信息有 　　① HTTP OK 　　这是Web服务器应答的第一行 列出服务器正在运行的HTTP版本号和应答代码 代码 OK 表示请求完成 　　② MIME_Version 　　它指示MIME类型的版本 　　③ content_type 类型 　　这个头信息非常重要 它指示HTTP体信息的MIME类型 如 content_type text/指示传送的数据是HTML文档 　　④ content_length 长度值 　　它指示HTTP体信息的长度（字节） 　　（ ） 关闭连接 当应答结束后 Web浏览器与Web服务器必须断开 以保证其它Web浏览器能够与Web服务器建立连接 　　 二 Java实现Web服务器功能的程序设计 　　根据上述HTTP协议的作用原理 实现GET请求的Web服务器程序的方法如下 　　（ ） 创建ServerSocket类对象 监听端口 这是为了区别于HTTP的标准TCP/IP端口 而取的 　　（ ） 等待 接受客户机连接到端口 得到与客户机连接的socket 　　（ ） 创建与socket字相关联的输入流instream和输出流outstream 　　（ ） 从与socket关联的输入流instream中读取一行客户机提交的请求信息 请求信息的格式为 GET 路径/文件名 HTTP/ 　　（ ） 从请求信息中获取请求类型 如果请求类型是GET 则从请求信息中获取所访问的HTML文件名 没有HTML文件名时 则以l作为文件名 　　（ ） 如果HTML文件存在 则打开HTML文件 把HTTP头信息和HTML文件内容通过socket传回给Web浏览器 然后关闭文件 否则发送错误信息给Web浏览器 　　（ ） 关闭与相应Web浏览器连接的socket字 　　下面的程序是根据上述方法编写的 可实现多线程的Web服务器 以保证多个客户机能同时与该Web服务器连接 　　程序 WebServer java文件 　　//WebServer java 用JAVA编写Web服务器 　　import java io * 　　import * 　　public class WebServer { 　　public static void main（String args[]） { 　　int i= PORT= 　　ServerSocket server=null 　　Socket client=null 　　try { 　　server=new ServerSocket（PORT） 　　System out println（ Web Server is listening on port +server getLocalPort（）） 　　for （ ） {client=server accept（） //接受客户机的连接请求 　　new ConnectionThread（client i） start（） 　　i++ 　　} 　　} catch （Exception e） {System out println（e） } 　　} 　　} 　　/* ConnnectionThread类完成与一个Web浏览器的通信 */ 　　class ConnectionThread extends Thread { 　　Socket client //连接Web浏览器的socket字 　　int counter //计数器 　　public ConnectionThread（Socket cl int c） { 　　client=cl 　　counter=c 　　} 　　public void run（） //线程体 　　{try { 　　String destIP=client getInetAddress（） toString（） //客户机IP地址 　　int destport=client getPort（） //客户机端口号 　　System out println（ Connection +counter+ connected to +destIP+ on port +destport+ ） 　　PrintStream outstream=new PrintStream（client getOutputStream（）） 　　DataInputStream instream=new DataInputStream（client getInputStream（）） 　　String inline=instream readLine（） //读取Web浏览器提交的请求信息 　　System out println（ Received +inline） 　　if （getrequest（inline）） { //如果是GET请求 　　String filename=getfilename（inline） 　　File file=new File（filename） 　　if （file exists（）） { //若文件存在 则将文件送给Web浏览器 　　System out println（filename+ requested ） 　　outstream println（ HTTP/ OK ） 　　outstream println（ MIME_version ） 　　outstream println（ Content_Type text/ ） 　　int len=（int）file length（） 　　outstream println（ Content_Length +len） 　　outstream println（ ） 　　sendfile（outstream file） //发送文件 　　outstream flush（） 　　} else { //文件不存在时 　　String notfound= 　　 Error file not found 　　outstream println（ HTTP/ no found ） 　　outstream println（ Content_Type text/ ） 　　outstream println（ Content_Length +notfound length（）+ ） 　　outstream println（ ） 　　outstream println（notfound） 　　outstream flush（） 　　} 　　} 　　long m = 　　while （m < ） {m ++ } //延时 　　client close（） 　　} catch （IOException e） { 　　System out println（ Exception +e） 　　} 　　} 　　/* 获取请求类型是否为 GET */ 　　boolean getrequest（String s） { 　　if （s length（）> ） 　　{if （s substring（ ） equalsIgnoreCase（ GET ）） return true 　　} 　　return false 　　} 　　/* 获取要访问的文件名 */ 　　String getfilename（String s） { 　　String f=s substring（s indexOf（′ ′）+ ） 　　f=f substring（ f indexOf（′ ′）） 　　try { 　　if （f charAt（ ）==′/′） 　　f=f substring（ ） 　　} catch （StringIndexOutOfBoundsException e） { 　　System out println（ Exception +e） 　　} 　　if （f equals（ ）） f= l 　　return f 　　} 　　/*把指定文件发送给Web浏览器 */ 　　void sendfile（PrintStream outs File file） { 　　try { 　　DataInputStream in=new DataInputStream（new FileInputStream（file）） 　　int len=（int）file length（） 　　byte buf[]=new byte[len] 　　in readFully（buf） 　　outs write（buf len） 　　outs flush（） 　　in close（） 　　} catch （Exception e） { 　　System out println（ Error retrieving file ） 　　System exit（ ） 　　} 　　} 　　} 　　程序中的ConnectionThread线程子类用来分析一个Web浏览器提交的请求 并将应答信息传回给Web浏览器 其中 getrequest（）方法用来检测客户的请求是否为 GET getfilename（s）方法是从客户请求信息s中获取要访问的HTML文件名 sendfile（）方法把指定文件内容通过socket传回给Web浏览器 　　对上述程序的getrequest（）方法和相关部分作修改 也能对POST请求进行处理 　　 三 运行实例 　　为了测试上述程序的正确性 将编译后的WebServer class ConnectionThread class和下面的l文件置于网络的某台主机的同一目录中（如 主机NT SRV的C JWEB目录） 　　程序 l文件 　　 　　 　　 　　 　　 　　 　　 这是用JAVA写出的WEB服务器主页 　　 年 月 日 　　 　　 　　 　　首先在该主机上用java命令运行WebServer class 　　C jweb>java webserver 　　然后在客户机运行浏览器软件 在URL处输入WebServer程序所属的URL地址（如 ） 就在浏览器窗口显示出指定的HTML文档 　　注意 不能缺省端口号 如缺省 则运行该主机的正常WEB服务器 lishixinzhi/Article/program/Java/hx/201311/26626

Math 不是一种数据类型，是js对象；

详见http://jimichan.javaeye.com/admin/show/119815是为继承服务的，这篇文章讲的全面本文着重解析javascript类继承机制，让你从底层了解javascript是怎样实现“继承”这一概念的。 jimichan在javaeye博客发布，转载请说明。 目前 javascript的实现继承方式并不是通过“extend”关键字来实现的，而是通过constructor function和prototype属性来实现继承。首先我们创建一个animal类..........

可以， 不过这个function只能在函数体内访问，之外的都不能访问

JavaScript 函数语法函数就是包裹在花括号中的代码块，前面使用了关键词 function：function functionname(){这里是要执行的代码}当调用该函数时，会执行函数内的代码。可以在某事件发生时直接调用函数（比如当用户点击按钮时），并且可由 JavaScript 在任何位置进行调用。具体其他的带参数之类的建议去看W3C手册根据具体问题类型，进行步骤拆解／原因原理分析／内容拓展等。具体步骤如下：／导致这种情况的原因主要是……

《爪哇舞》据说爪哇舞是巴黎下层社会的一种舞蹈，男人把手放在女人髋骨的两边，女人把手放在男人肩上，随着音乐节奏前进后退。Serge Gainsbourg的这首歌词就像一首小诗，充满铿锵的节奏与韵律，词意更是甜蜜，是很多法国人都会唱的名曲。这首歌最早是给Juliette GRECO唱，Serge Gainsbourg自己也有唱，十几年后他又把这首歌加入雷鬼音乐的元素而更加受到欢迎。2004年Jane Birkin还在Arabesque专辑把它改成阿拉伯曲风的。------madeleine peyroux 唱的是英文版本吧。你这首是serge gainsbourg唱的，没错。http://you.video.sina.com.cn/b/2281672-1402681183.htmlj"avoue /j"en ai bavé/ pas vous/ mon amour 我承认，我吃尽苦头，不是您，我的爱人avant d"avoir eu vent de vous /mon amour 在得到您消息之前，我的爱人ne vous déplaise 没有让你不开怀en dansant la javanaise 跳起一只爪哇舞nous nous aimions 我们彼此相爱le temps d"une chanson 在一首歌的时光里à votre avis qu"avons-nous vu de l"amour 在您看来，我们从爱情中看到什么de vous à moi vous m"avez eu mon amour 从您到我，您拥有了我，我的爱人ne vous déplaise 没有让您不开怀en dansant la javanaise 跳起一只爪哇舞nous nous aimions 我们彼此相爱le temps d"une chanson 在一首歌的时光里hélas avril en vain me voue à l"amour 唉，我白白的将我的四月奉献给了爱情j"avais envie de voir en vous cet amour 我曾想在您那看到这份爱ne vous déplaise 没有让您不开怀en dansant la javanaise 跳起一只爪哇舞nous nous aimions 我们彼此相爱le temps d"une chanson 在一首歌的时光里la vie ne vaut d"etre vécue sans amour 没有爱的生活不值得来过mais c"est vous qui l"avez voulu mon amour 但是您想要得到它，我的爱人ne vous déplaise 没有让你不开怀en dansant la javanaise 跳起一只爪哇舞nous nous aimions 我们彼此相爱le temps d"une chanson 在一首歌的时光里

interface 和 implementation 是对应的关系。implementation 实现了 interface 定义的接口

还请明示你想要什么样的“心形”代码？画一个草图意思一下也是可以的。

老郭是你吗？我看到你图像了。。你也在这里问问题呀。

10分就想完成这么个大作业么-。-

ProtocolBuffers的是一个高效且可扩展的格式结构化数据编码的一种方式。谷歌使用了ProtocolBuffers的几乎所有它的内部RPC协议和文件格式使用protobuf传输的好处有：二进制传输,安全、数据量小.proto文件中我们服务器定义需要传输的数据，及数据类型等。而传输的时候则是使用了通过官方工具生成的具体为.java的消息体http://code.google.com/p/protobuf/https://developers.google.com/protocol-buffers/docs/overview可参考官方网上的具体使用下面介绍如何用将.proto的文件转换成.java的文件1.http://code.google.com/p/protobuf/downloads/list下载 protoc-2.4.1-win32.zip 至本地并解压2.通过命令行将.proto的文件生成为.java的文件官网上是这样写的protoc -I=$SRC_DIR--java_out=$DST_DIR $SRC_DIR/addressbook.proto下面用图形来说明如果操作。下载的部分就不说了

不行，你去把系统破解吧，去刷机！还有我要说下，你别怕刷坏.诺基亚系统刷坏了也没事，还可以从安装，也不用花钱.诺基亚不像苹果.苹果是只有进没有退.诺基亚手机是可以进退.楼主你放心的刷机吧.刷机很简单的塞班上面有教程.

把要执行的那段代码，抽出一个方法，在try... catch 里调用然后catch里捕捉到一场再调用。可以用个循环控制重试的次数。

validation-api-1.0.0.GA.jar

软件包 javax.xml.validation 的描述 此包提供了用于 XML 文档验证的 API。Validation 是验证 XML 文档是否为指定 XML schema 的实例的过程。XML 模式定义了其实例文档将表示的内容模型（也称为 grammar 或 vocabulary）。

这是用JAVAX组件时经常用的，因为JAVAX组件不能直接加到JFRAME上，需要用JFRAM的getContentPane 获得其组件层（javax组件5层之一）。而它返回的是个容器，所以用Container cp句丙保存

container 就是一个可以放组件的容器，其本身也是子类。JFrame是窗口，包括标题栏最大化最小化按钮等等，而container是其中的组件。一般来说JFrame的getContentPane方法都会返回一个代表其中间区域的大的容器，也就是一个container对象，其也是一个JPanel对象

Container是一个容器对象JFrame继承了Container，所以JFrame本身也能add组件由于JFrame还继承了java.awt.Window，所以可以将图形展示出来！综上所述，JFrame继承Container等类，Container有的功能它都有另外继承Window，可对窗口进行操作！（如，展示） 建议去查看API，看下他们的结构

他们两个是有这区别的，一个可以设置自动填充的方式，而另个一个是主要是手动设置。

getContentPane就是调用方法，得到一个容器，这是个空的，你可以加JBUTTON OR JPANEL等，mainFrame.add(westPanel, BorderLayout.WEST);mainFrame.add(eastPanel, BorderLayout.EAST);mainFrame.add(labelInfo, BorderLayout.SOUTH);是LAYOUT 不同啦，它是有5块区域，中心和东南西北，样子大概这样：-----------------------------------------------北-----------------------------------------------西|中心中心中心中心中心|东-----------------------------------------------南-----------------------------------------------如果你别的地方是空的，可能看不出来，设置不同颜色，加上TEXTAREA什么的就看出来了，

contentPane 是Container 的一个对象,而getContentPane() 方法就是返回这个Container 的实例化对象contentPane ...这个contentPane 就是一个对象的名字,可能和Panel有点像,容易让人误解.呵呵

Container是容器的意思,你指的是类名?比如java.awt.Container还是?

在deepEquals()在 java.util.Arraysjdk 帮助文档里是这样写的：deepEquals(Object[] a1, Object[] a2) 如果两个指定数组彼此是深层相等 的，则返回 true。 比较的什么呢？ 比较的是 数组a1 和 数组a2 中的元素是否深层相等 也就是 a1[1].equels(a2[1]), a1[2].equels(a2[2]), a1[3].equels(a2[3])........给你找了一个例子：import java.util.*;public class deepEqualsArray { public static void main(String[] args) { //creating an object array Object o[]={"Rose","India","Net","Limited","Rohini"}; //Object o1[]={"Rose","India","Net","Limited","Rohini"}; Object o1[]={"Rohini","Limited","Net","India","Rose"}; boolean b=Arrays.deepEquals(o, o1); System.out.println("Array are equal:-" +b); }} 另外我查了下jdk源码 deepEquals(Object[] a1, Object[] a2) 你可以看着理解一下 public static boolean deepEquals(Object[] a1, Object[] a2) { if (a1 == a2) return true; if (a1 == null || a2==null) return false; int length = a1.length; if (a2.length != length) return false; for (int i = 0; i < length; i++) { Object e1 = a1[i]; Object e2 = a2[i]; if (e1 == e2) continue; if (e1 == null) return false; // Figure out whether the two elements are equal boolean eq; if (e1 instanceof Object[] && e2 instanceof Object[]) eq = deepEquals ((Object[]) e1, (Object[]) e2); else if (e1 instanceof byte[] && e2 instanceof byte[]) eq = equals((byte[]) e1, (byte[]) e2); else if (e1 instanceof short[] && e2 instanceof short[]) eq = equals((short[]) e1, (short[]) e2); else if (e1 instanceof int[] && e2 instanceof int[]) eq = equals((int[]) e1, (int[]) e2); else if (e1 instanceof long[] && e2 instanceof long[]) eq = equals((long[]) e1, (long[]) e2); else if (e1 instanceof char[] && e2 instanceof char[]) eq = equals((char[]) e1, (char[]) e2); else if (e1 instanceof float[] && e2 instanceof float[]) eq = equals((float[]) e1, (float[]) e2); else if (e1 instanceof double[] && e2 instanceof double[]) eq = equals((double[]) e1, (double[]) e2); else if (e1 instanceof boolean[] && e2 instanceof boolean[]) eq = equals((boolean[]) e1, (boolean[]) e2); else eq = e1.equals(e2); if (!eq) return false; } return true; }对于equals 我就不多说了 就是比较的在堆内存里存放的值， “==”是比较栈内存中的地址

强类型要求事先知道类型。想直接转，必须有类型的定义。只有逐个判断，转换。可以使用反射o.getClass() 和 MyClassObject.class 比较。

public class Test {public static void main(String[] args) {Animal a1 = new Cat();Animal a2 = new Pig();a1.speek();a2.speek();action(a1);action(a2);}static void action(Animal a){if(a instanceof Cat){((Cat) a).catchMouse();}if(a instanceof Pig){((Pig) a).eat();}}}interface Animal {void speek();}class Cat implements Animal {@Overridepublic void speek() {System.out.println("Cat speek");}void catchMouse() {System.out.println("Cat catch mouse");}}class Pig implements Animal {@Overridepublic void speek() {System.out.println("Pig speek");}void eat() {System.out.println("Pig eat");}}

if(o instanceof Number){}instanceof 关键字判断 前面的那个实例 是不是后面这个类或者其子孙类的实例

运行时类型识别(Run-timeTypeIdentification,RTTI)主要有两种方式，一种是我们在编译时和运行时已经知道了所有的类型，另外一种是功能强大的“反射”机制。要理解RTTI在Java中的工作原理，首先必须知道类型信息在运行时是如何表示的，这项工作是由“Class对象”完成的，它包含了与类有关的信息。类是程序的重要组成部分，每个类都有一个Class对象，每当编写并编译了一个新类就会产生一个Class对象，它被保存在一个同名的.class文件中。在运行时，当我们想生成这个类的对象时，运行这个程序的Java虚拟机(JVM)会确认这个类的Class对象是否已经加载，如果尚未加载，JVM就会根据类名查找.class文件，并将其载入，一旦这个类的Class对象被载入内存，它就被用来创建这个类的所有对象。一般的RTTI形式包括三种：1.传统的类型转换。如“(Apple)Fruit”，由RTTI确保类型转换的正确性，如果执行了一个错误的类型转换，就会抛出一个ClassCastException异常。2.通过Class对象来获取对象的类型。如Classc=Class.forName(“Apple”);Objecto=c.newInstance();3.通过关键字instanceof或Class.isInstance()方法来确定对象是否属于某个特定类型的实例，准确的说，应该是instanceof/Class.isInstance()可以用来确定对象是否属于某个特定类及其所有基类的实例，这和equals()/==不一样，它们用来比较两个对象是否属于同一个类的实例，没有考虑继承关系。反射如果不知道某个对象的类型，可以通过RTTI来获取，但前提是这个类型在编译时必须已知，这样才能使用RTTI来识别。即在编译时，编译器必须知道所有通过RTTI来处理的类。使用反射机制可以不受这个限制，它主要应用于两种情况，第一个是“基于构件的编程”，在这种编程方式中，将使用某种基于快速应用开发(RAD)的应用构建工具来构建项目。这是现在最常见的可视化编程方法，通过代表不同组件的图标拖动到图板上来创建程序，然后设置构件的属性值来配置它们。这种配置要求构件都是可实例化的，并且要暴露其部分信息，使得程序员可以读取和设置构件的值。当处理GUI时间的构件时还必须暴露相关方法的细细，以便RAD环境帮助程序员覆盖这些处理事件的方法。在这里，就要用到反射的机制来检查可用的方法并返回方法名。Java通过JavaBeans提供了基于构件的编程架构。第二种情况，在运行时获取类的信息的另外一个动机，就是希望能够提供在跨网络的远程平台上创建和运行对象的能力。这被成为远程调用(RMI)，它允许一个Java程序将对象分步在多台机器上，天通苑java培训认为这种分步能力将帮助开发人员执行一些需要进行大量计算的任务，充分利用计算机资源，提高运行速度。

使用instanceOf关键字，比如if(e instanceOf java.lang.NullPointException){}

java里没有typerof ,要用instanceof基础类型不行,要用对象Integer i = 0;if (i instanceof Integer) { System.out.println("haha");}String str = "abc";if (str instanceof Object) { System.out.println("haha");}

if(typeof xxx=="object"){}if(xxx instanceof Object){}

1，2楼正解

if(list.get(0).getCLass.equals(Task.class))

http://bbs.csdn.net/topics/90376738这个帖子，自己去看。

string []args的意思就是main函数需要一个字符串类型的数组，args是数组名，改成其他的也是可以的在这个地方定义一个a，代表函数的一个形参，可以说是一个形式上的参数的因为a是Animal类型的 ，首先判断一下a是不是dog类型的，因为Animal包括dog类型，可能a还是cat类型，所以先判断一下a instanceof Dog这个不是跟dog比较，二是判断a是不是dog类行

(Object) A.class == (Object) B.class肉眼可见 A和B肯定不是同一个类一般是A传给了一个Object，B也传给了一个Object，可以直接使用.class ==相比较，也只能是Object.class才能比较这里说的类的类型是否相同，类的子类和父类对比也是false；如果要对比两个对象是否相同（内存地址是否相同）用.equals()即可

用instanceof关键字判断，参考下面代码Object param = params.get(i); if (param instanceof Integer) { int value = ((Integer) param).intValue(); prepStatement.setInt(i + 1, value); } else if (param instanceof String) { String s = (String) param; prepStatement.setString(i + 1, s); } else if (param instanceof Double) { double d = ((Double) param).doubleValue(); prepStatement.setDouble(i + 1, d); } else if (param instanceof Float) { float f = ((Float) param).floatValue(); prepStatement.setFloat(i + 1, f); } else if (param instanceof Long) { long l = ((Long) param).longValue(); prepStatement.setLong(i + 1, l); } else if (param instanceof Boolean) { boolean b = ((Boolean) param).booleanValue(); prepStatement.setBoolean(i + 1, b); } else if (param instanceof Date) { Date d = (Date) param; prepStatement.setDate(i + 1, (Date) param); }

怎样判断一个JavaScript变量是array还是obiect？答案：1、如果你只是用typeof来检查该变量，不论是array还是object，都将返回‘objec"。此问题的一个可行的答案是是检查该变量是不是object，并且检查该变量是否有数字长度（当为空array时长度也可能为0）。然而，参数对象【argumentsobject】（传给制定函数的所有参数），也可能会适用于上述方法，技术上来说，参数对象并不是一个array。此外，当一个对象有a.length属性的时候，这个方法也不成立。复制代码代码如下://Realarray正在的数组varmy_array=[];//Imposter!冒名顶替的！varmy_object={};my_object.length=0;//Potentiallyfaulty潜在的错误functionis_this_an_array(param){if(typeofparam==="object"&&!isNaN(param.length)){console.log("Congrats,youhaveanarray!");}else{console.log("Bummer,notanarray");}}//Works成功is_this_an_array(my_array);//Works,butisincorrect成功了，但是不正确is_this_an_array(my_object);2、回答这个问题的另一个答案是用一个更加隐蔽的方法，调用toString()方法试着将该变量转化为代表其类型的string。该方法对于真正的array可行；参数对象转化为string时返回[objectArguments]会转化失败；此外，对于含有数字长度属性的object类也会转化失败。复制代码代码如下://Realarray真正的数组varmy_array=[];//Imposter!冒名顶替的！varmy_object={};my_object.length=0;//Rocksolid坚如磐石（检验函数）functionis_this_an_array(param){if(Object.prototype.toString.call(param)==="[objectArray]"){console.log("Congrats,youhaveanarray!");}else{console.log("Bummer,notanarray");}}//Works成功了is_this_an_array(my_array);//Notanarray,yay!不是数组（array）！is_this_an_array(my_object);3、此外，在可能不可靠的多框架DOM环境中，instanceof是个完美合适的操作。扩展阅读："InstanceofConsideredHarmful…"http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray复制代码代码如下:varmy_array=[];if(my_arrayinstanceofArray){console.log("Congrats,youhaveanarray!");}4、对于Javascript1.8.5（ECMAScript5），变量名字.isArray()可以实现这个目的https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/isArray复制代码代码如下:varmy_array=[];if(Array.isArray(my_array)){console.log("Congrats,youhaveanarray!");}

一、算术运算符：　　单目：+（取正）-（取负） ++（自增1） - -（自减1）　　双目：+ - * / %（取余）　　三目：a>b?true:false 说明：当a大于b的时候，为true（也就是冒号之前的值），否则为false；这整个运算符包括一个关系运算符（可以是“>”"<""!="等等），一个“？”，一个“：”，冒号前后需要有两个表达式或者是值或者是对象。二、关系运算：　　等于符号:==，不等于符号: != ，大于符号:>， 小于符号:= ，小于等于符号: <= 。三、位运算符 逻辑运算符：　　位运算符　与（&）、非（~）、或（|）、异或（^）&：当两边操作数的位同时为1时，结果为1，否则为0。如1100&1010=1000　　| ：当两边操作数的位有一边为1时，结果为0，否则为1。如1100|1010=1110　　~：0变1,1变0　　^：两边的位不同时，结果为1，否则为0.如1100^1010=0110　　逻辑运算符　　与（&&）、非（!）、或（||）四、赋值运算符　　= += -= *= /= %= &= ^= |= <>=五、instanceof运算符　　该运算符是双目运算符，左面的操作元是一个对象，右面是一个类。当左面的对象是右面的类创建的对象时，该运算符运算结果是true，否则是false。六、 运算符综述　　Java 的表达式就是用运算符连接起来的符合Java 规则的式子.运算符的优先级决定了表达式中运算执行的先后顺序.例如,x<y&&!z相当于(x<y)&&(!z),没有必要去记忆运算符号的优先级别,在编写程序时可尽量的使用括号来实现你想要的运算次序,以免产生难以阅读或含糊不清的计算顺序.运算符的结合性决定了并列相同级别的运算符的先后顺序,例如,加减的结合性是从左到右,8-5+3 相当于(8-5)+3.逻辑否运算符 的结合性是右到左, x 相当于!(!x).表3.4是Java所有运算符的优先级和结合性。七 位移运算符　　< 带符号左移 >>带符号右移 >>> 无号右移　　例子： int a1 = 8; // 0000 0000 0000 1000　　System.out.println(a1>>>2); //// 0000 0000 0000 0010　　输出为 2

Java的运算符可分为4类：算术运算符、关系运算符、逻辑运算符和位运算符。1.算术运算符Java的算术运算符分为一元运算符和二元运算符。一元运算符只有一个操作数；二元运算符有两个操作数，运算符位于两个操作数之间。算术运算符的操作数必须是数值类型。(1)一元运算符：一元运算符有：正（+）、负（－）、加1（++）和减1（－－）4个。加1、减1运算符只允许用于数值类型的变量，不允许用于表达式中。加1、减1运算符既可放在变量之前（如＋＋i），也可放在变量之后（如i＋＋），两者的差别是：如果放在变量之前（如＋＋i），则变量值先加1或减1，然后进行其他相应的操作（主要是赋值操作）；如果放在变量之后（如i＋＋），则先进行其他相应的操作，然后再进行变量值加1或减1。例如：int i=6，j，k，m，n;j = +i; //取原值，即j=6k = -i; //取负值，即k=-6m = i++; //先m=i,再i=i+1，即m=6，i=7m = ++i; //先i=i+1,再m=i，即i=7，m=7n = j--; //先n=j,再j=j-1，即n=6，j=5n = --j; //先j=j-1,再n=j，即j=5，n=5在书写时还要注意的是：一元运算符与其前后的操作数之间不允许有空格，否则编译时会出错。(2)二元运算符二元运算符有：加（+）、减（－）、乘（*）、除（／）、取余（%）。其中+、－、*、／完成加、减、乘、除四则运算，%是求两个操作数相除后的余数。%求余操作举例：a % b = a － (a / b) * b取余运算符既可用于两个操作数都是整数的情况，也可用于两个操作数都是浮点数（或一个操作数是浮点数）的情况。当两个操作数都是浮点数时，例如7.6 % 2.9时，计算结果为：7.6 － 2 * 2.9 = 1.8。当两个操作数都是int类型数时，a%b的计算公式为：a % b = a － （int）(a / b) * b当两个操作数都是long类型（或其他整数类型）数时，a%b的计算公式可以类推。 当参加二元运算的两个操作数的数据类型不同时，所得结果的数据类型与精度较高（或位数更长）的那种数据类型一致。例如：7 / 3 //整除，运算结果为27.0 / 3 //除法，运算结果为2.33333,即结果与精度较高的类型一致7 % 3 //取余，运算结果为17.0 % 3 //取余，运算结果为1.0-7 % 3 //取余，运算结果为-1，即运算结果的符号与左操作数相同7 % -3 //取余，运算结果为1，即运算结果的符号与左操作数相同 2.关系运算符关系运算符用于比较两个数值之间的大小，其运算结果为一个逻辑类型的数值。关系运算符有六个：等于（==）、不等于（!=）、大于（>）、大于等于（>=）、小于（<）、小于等于（<=）。例如：9 <= 8 //运算结果为false9.9 >= 8.8 //运算结果为true"A" < "a" //运算结果为true，因字符"A"的Unicode编码值小于字符"a"的要说明的是，对于大于等于（或小于等于）关系运算符来说，只有大于和等于两种关系运算都不成立时其结果值才为false，只要有一种（大于或等于）关系运算成立其结果值即为true。例如，对于9 <= 8，9既不小于8也不等于8，所以9 <= 8 的运算结果为false。对于9 >= 9，因9等于9，所以9 >= 9的运算结果为true。 3.逻辑运算符逻辑运算符要求操作数的数据类型为逻辑型，其运算结果也是逻辑型值。逻辑运算符有：逻辑与（&&）、逻辑或（||）、逻辑非（!）、逻辑异或（^）、逻辑与（&）、逻辑或（|）。真值表是表示逻辑运算功能的一种直观方法，其具体方法是把逻辑运算的所有可能值用表格形式全部罗列出来。Java语言逻辑运算符的真值表如下：逻辑运算符的真值表A B A&&B A||B !A A^B A&B A|Bfalse false false false true false false falsetrue false false true false true false truefalse true false true true true false truetrue true true true false false true true 前两列是参与逻辑运算的两个逻辑变量，共有4种可能，所以表2.5共有4行。后6列分别是6个逻辑运算符在逻辑变量A和逻辑变量B取不同数值时的运算结果值。要说明的是，两种逻辑与（&&和&）的运算规则基本相同，两种逻辑或（||和|）的运算规则也基本相同。其区别是：&和|运算是把逻辑表达式全部计算完，而&&和||运算具有短路计算功能。所谓短路计算，是指系统从左至右进行逻辑表达式的计算，一旦出现计算结果已经确定的情况，则计算过程即被终止。对于&&运算来说，只要运算符左端的值为false，则因无论运算符右端的值为true或为false，其最终结果都为false。所以，系统一旦判断出&&运算符左端的值为false，则系统将终止其后的计算过程；对于 || 运算来说，只要运算符左端的值为true，则因无论运算符右端的值为true或为false，其最终结果都为true。所以，系统一旦判断出|| 运算符左端的值为true，则系统将终止其后的计算过程。例如，有如下逻辑表达式：(i>=1) && (i<=100)此时，若i等于0，则系统判断出i>=1的计算结果为false后，系统马上得出该逻辑表达式的最终计算结果为false，因此，系统不继续判断i<=100的值。短路计算功能可以提高程序的运行速度。作者建议读者：在程序设计时使用&&和||运算符，不使用&和|运算符。 用逻辑与（&&）、逻辑或（||）和逻辑非（!）可以组合出各种可能的逻辑表达式。逻辑表达式主要用在 if、while等语句的条件组合上。例如：int i = 1;while(i>=1) && (i<=100) i++; //循环过程上述程序段的循环过程将i++语句循环执行100次。 4.位运算符位运算是以二进制位为单位进行的运算，其操作数和运算结果都是整型值。位运算符共有7个，分别是：位与（&）、位或（|）、位非（~）、位异或（^）、右移（>>）、左移（<<）、0填充的右移（>>>）。位运算的位与（&）、位或（|）、位非（~）、位异或（^）与逻辑运算的相应操作的真值表完全相同，其差别只是位运算操作的操作数和运算结果都是二进制整数，而逻辑运算相应操作的操作数和运算结果都是逻辑值。位运算示例运算符 名称 示例 说明& 位与 x&y 把x和y按位求与| 位或 x|y 把x和y按位求或~ 位非 ~x 把x按位求非^ 位异或 x^y 把x和y按位求异或>> 右移 x>>y 把x的各位右移y位<< 左移 x<<y 把x的各位左移y位>>> 右移 x>>>y 把x的各位右移y位，左边填0 举例说明：（1）有如下程序段：int x = 64; //x等于二进制数的01000000int y = 70; //y等于二进制数的01000110int z = x&y //z等于二进制数的01000000即运算结果为z等于二进制数01000000。位或、位非、位异或的运算方法类同。（2）右移是将一个二进制数按指定移动的位数向右移位，移掉的被丢弃，左边移进的部分或者补0（当该数为正时），或者补1（当该数为负时）。这是因为整数在机器内部采用补码表示法，正数的符号位为0，负数的符号位为1。例如，对于如下程序段：int x = 70; //x等于二进制数的01000110int y = 2;int z = x>>y //z等于二进制数的00010001即运算结果为z等于二进制数00010001，即z等于十进制数17。对于如下程序段：int x = -70; //x等于二进制数的11000110int y = 2;int z = x>>y //z等于二进制数的11101110即运算结果为z等于二进制数11101110，即z等于十进制数-18。要透彻理解右移和左移操作，读者需要掌握整数机器数的补码表示法。（3）0填充的右移（>>>）是不论被移动数是正数还是负数，左边移进的部分一律补0。 5.其他运算符 （1）赋值运算符与其他运算符的简捷使用方式赋值运算符可以与二元算术运算符、逻辑运算符和位运算符组合成简捷运算符，从而可以简化一些常用表达式的书写。赋值运算符与其他运算符的简捷使用方式运算符 用法 等价于 说明+= s+=i s=s+i s，i是数值型-= s-=i s=s-i s，i是数值型*= s*=i s=s*i s，i是数值型/= s/=i s=s/i s，i是数值型%= s%=i s=s%i s，i是数值型&= a&=b a=a&b a，b是逻辑型或整型|= a|=b a=a|b a，b是逻辑型或整型^= A^=b a=a^b a，b是逻辑型或整型<<= s<<=i s=s<<i s，i是整型>>= s>>=i s=s>>i s，i是整型>>>= s>>>=i s=s>>>i s，i是整型 （2）方括号[]和圆括号（）运算符方括号[]是数组运算符，方括号[]中的数值是数组的下标，整个表达式就代表数组中该下标所在位置的元素值。圆括号（）运算符用于改变表达式中运算符的优先级。（3）字符串加（+）运算符当操作数是字符串时，加（+）运算符用来合并两个字符串；当加（+）运算符的一边是字符串，另一边是数值时，机器将自动将数值转换为字符串，这种情况在输出语句中很常见。如对于如下程序段：int max = 100;System.out.println（"max = "+max）;计算机屏幕的输出结果为：max = 100，即此时是把变量max中的整数值100转换成字符串100输出的。（4）条件运算符（？：）条件运算符（？：）的语法形式为：<表达式1> ？<表达式2> : <表达式3>条件运算符的运算方法是：先计算<表达式1>的值，当<表达式1>的值为true时，则将<表达式2>的值作为整个表达式的值；当<表达式1>的值为false时，则将<表达式3>的值作为整个表达式的值。如：int a=1，b=2，max;max = a>b？a：b; //max等于2（5）强制类型转换符强制类型转换符能将一个表达式的类型强制转换为某一指定数据类型，其语法形式为：(<类型>)<表达式>（6）对象运算符instanceof对象运算符instanceof用来测试一个指定对象是否是指定类（或它的子类）的实例，若是则返回true，否则返回false。（7）点运算符点运算符“.”的功能有两个：一是引用类中成员，二是指示包的层次等级。6.运算符的优先级以下按优先级从高到低的次序列出Java语言中的所有运算符，表中结合性一列中的“左uf0f0右”表示其运算次序为从左向右，“右uf0f0左”表示其运算次序为从右向左。优先级 运算符 结合性1 . [] () ; ,2 ++ ―― += ! ~ +(一元) -(一元) 右uf0f0左3 * / % 左uf0f0右4 +(二元) -(二元) 左uf0f0右5 << >> >>> 左uf0f0右6 < > <= >= instanceof 左uf0f0右7 = = != 左uf0f0右8 & 左uf0f0右9 ^ 左uf0f0右10 | 左uf0f0右11 && 左uf0f0右12 || 左uf0f0右13 ?： 右uf0f0左14 = *= /= %= += －= <<= >>= >>>= &= ^= |= 右uf0f0左

if（str instanceOf Timestamp）

instanceof

Java中A instanceof B是用来判断内存中实际对象A是不是B类型。出现这种情况经常是需要强制转换的时候class Dog extends Animal譬如dog定义了自己的方法wangwangAnimal anAnimal = new Dog();此时不能直接调用anAnimal.wangwang方法但是可以if( anAnimal instanceof Dog){Dog dog = (Dog)anAnimal;dog.wangwang就可以调用了}

判断对象属于哪种类型的if(obj instanceof class){}其返回true情况如下1.obj是class类的对象2.obj是class类子类的对象

instanceof是什么东东?instanceof是Java的一个二元操作符，和==，>，<是同一类东东。由于它是由字母组成的，所以也是Java的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。举个例子:Strings="IAManObject!";booleanisObject=sinstanceofObject;我们声明了一个String对象引用，指向一个String对象，然后用instancof来测试它所指向的对象是否是Object类的一个实例，显然，这是真的，所以返回true，也就是isObject的值为True。instanceof有一些用处。比如我们写了一个处理账单的系统，其中有这样三个类:publicclassBill{//省略细节}publicclassPhoneBillextendsBill{//省略细节}publicclassGasBillextendsBill{//省略细节}在处理程序里有一个方法，接受一个Bill类型的对象，计算金额。假设两种账单计算方法不同，而传入的Bill对象可能是两种中的任何一种，所以要用instanceof来判断:publicdoublecalculate(Billbill){if(billinstanceofPhoneBill){//计算电话账单}if(billinstanceofGasBill){//计算燃气账单}...}这样就可以用一个方法处理两种子类。然而，这种做法通常被认为是没有好好利用面向对象中的多态性。其实上面的功能要求用方法重载完全可以实现，这是面向对象变成应有的做法，避免回到结构化编程模式。只要提供两个名字和返回值都相同，接受参数类型不同的方法就可以了:publicdoublecalculate(PhoneBillbill){//计算电话账单}publicdoublecalculate(GasBillbill){//计算燃气账单}所以，使用instanceof在绝大多数情况下并不是推荐的做法，应当好好利用多态。

......你新学的吧？服了你了变量用之前必须要声明而char，int，double这些都是声明变量的关键字举个例子char a="你"int b=10;double c=20.0;不是很明白你想问什么要想看变量是什么类型直接看前面声明它的关键字就行了嘛就像char a="你"中的a就是一个字符型数据了

instanceof java.util.Date

instanceof例如：String str="abc";System.out.println(str instanceof String);输出结果：true

instanceof是判断一个对象是否是这个类的子类。if(Animal instanceof Cat){System.out.println("Cat类是Animal的一个子类");}else{System.out.println("Cat类不是Animal的一个子类");}做这个的一般用在上转型中，比如Animal是一个抽象类，拥有一个抽象方法abstract void Speak();Cat类 extends Animal，然后重写了Speak()方法public void Speak(){System.out.println("喵喵喵");}然后在mian方法中用子类去创建父类，Animal Cat = new Cat();进行这个操作的时候最好用if(Animal instanceof Cat){Animal Cat = new Cat(); //把他放在这里做个判断，免得出错，这里当然不会出错，如果 //有多个Animal的子类的话，就会出错了。System.out.println("Cat类是Animal的一个子类");}else{System.out.println("Cat类不是Animal的一个子类");}还是不清楚的看这个http://www.imooc.com/video/2687 关于这个方法getClass()，我在数据库jdbc中用过：Java的每个类都带有一个运行时类对象，该Class对象中保存了创建对象所需的所有信息。可以用.class返回此 Object 的运行时类Class对象，也可以用getClass()获得。获得此对象后可以利用此Class对象的一些反射特性进行操作，例如：this.getClass().newInstance(); //用缺省构造函数创建一个该类的对象this.getClass().getInterfaces(); //获得此类实现的接口信息this.getClass().getMethods();//获得此类实现的所有公有方法Class.forName(" ... JDBC driver class name...."); // Class类的静态方法forName, 向DiverManager注册这个JDBC driver类

Java的运算符可分为4类：算术运算符、关系运算符、逻辑运算符和位运算符。1.算术运算符 Java的算术运算符分为一元运算符和二元运算符。一元运算符只有一个操作数；二元运算符有两个操作数，运算符位于两个操作数之间。算术运算符的操作数必须是数值类型。 (1)一元运算符： 一元运算符有：正（+）、负（－）、加1（++）和减1（－－）4个。 加1、减1运算符只允许用于数值类型的变量，不允许用于表达式中。加1、减1运算符既可放在变量之前（如＋＋i），也可放在变量之后（如i＋＋），两者的差别是：如果放在变量之前（如＋＋i），则变量值先加1或减1，然后进行其他相应的操作（主要是赋值操作）；如果放在变量之后（如i＋＋），则先进行其他相应的操作，然后再进行变量值加1或减1。 例如： int i=6，j，k，m，n; j = +i; //取原值，即j=6 k = -i; //取负值，即k=-6 m = i++; //先m=i,再i=i+1，即m=6，i=7 m = ++i; //先i=i+1,再m=i，即i=7，m=7 n = j--; //先n=j,再j=j-1，即n=6，j=5 n = --j; //先j=j-1,再n=j，即j=5，n=5 在书写时还要注意的是：一元运算符与其前后的操作数之间不允许有空格，否则编译时会出错。 (2)二元运算符 二元运算符有：加（+）、减（－）、乘（*）、除（／）、取余（%）。其中+、－、*、／完成加、减、乘、除四则运算，%是求两个操作数相除后的余数。%求余操作举例： a % b = a － (a / b) * b 取余运算符既可用于两个操作数都是整数的情况，也可用于两个操作数都是浮点数（或一个操作数是浮点数）的情况。当两个操作数都是浮点数时，例如7.6 % 2.9时，计算结果为：7.6 － 2 * 2.9 = 1.8。 当两个操作数都是int类型数时，a%b的计算公式为： a % b = a － （int）(a / b) * b 当两个操作数都是long类型（或其他整数类型）数时，a%b的计算公式可以类推。 当参加二元运算的两个操作数的数据类型不同时，所得结果的数据类型与精度较高（或位数更长）的那种数据类型一致。 例如： 7 / 3 //整除，运算结果为2 7.0 / 3 //除法，运算结果为2.33333,即结果与精度较高的类型一致 7 % 3 //取余，运算结果为1 7.0 % 3 //取余，运算结果为1.0 -7 % 3 //取余，运算结果为-1，即运算结果的符号与左操作数相同 7 % -3 //取余，运算结果为1，即运算结果的符号与左操作数相同 2.关系运算符 关系运算符用于比较两个数值之间的大小，其运算结果为一个逻辑类型的数值。关系运算符有六个：等于（==）、不等于（!=）、大于（>）、大于等于（>=）、小于（<）、小于等于（<=）。 例如： 9 <= 8 //运算结果为false 9.9 >= 8.8 //运算结果为true "A" < "a" //运算结果为true，因字符"A"的Unicode编码值小于字符"a"的 要说明的是，对于大于等于（或小于等于）关系运算符来说，只有大于和等于两种关系运算都不成立时其结果值才为false，只要有一种（大于或等于）关系运算成立其结果值即为true。例如，对于9 <= 8，9既不小于8也不等于8，所以9 <= 8 的运算结果为false。对于9 >= 9，因9等于9，所以9 >= 9的运算结果为true。 3.逻辑运算符 逻辑运算符要求操作数的数据类型为逻辑型，其运算结果也是逻辑型值。逻辑运算符有：逻辑与（&&）、逻辑或（||）、逻辑非（!）、逻辑异或（^）、逻辑与（&）、逻辑或（|）。 真值表是表示逻辑运算功能的一种直观方法，其具体方法是把逻辑运算的所有可能值用表格形式全部罗列出来。Java语言逻辑运算符的真值表如下： 逻辑运算符的真值表 A B A&&B A||B !A A^B A&B A|B false false false false true false false false true false false true false true false true false true false true true true false true true true true true false false true true 前两列是参与逻辑运算的两个逻辑变量，共有4种可能，所以表2.5共有4行。后6列分别是6个逻辑运算符在逻辑变量A和逻辑变量B取不同数值时的运算结果值。 要说明的是，两种逻辑与（&&和&）的运算规则基本相同，两种逻辑或（||和|）的运算规则也基本相同。其区别是：&和|运算是把逻辑表达式全部计算完，而&&和||运算具有短路计算功能。所谓短路计算，是指系统从左至右进行逻辑表达式的计算，一旦出现计算结果已经确定的情况，则计算过程即被终止。对于&&运算来说，只要运算符左端的值为false，则因无论运算符右端的值为true或为false，其最终结果都为false。所以，系统一旦判断出&&运算符左端的值为false，则系统将终止其后的计算过程；对于 || 运算来说，只要运算符左端的值为true，则因无论运算符右端的值为true或为false，其最终结果都为true。所以，系统一旦判断出|| 运算符左端的值为true，则系统将终止其后的计算过程。 例如，有如下逻辑表达式： (i>=1) && (i<=100) 此时，若i等于0，则系统判断出i>=1的计算结果为false后，系统马上得出该逻辑表达式的最终计算结果为false，因此，系统不继续判断i<=100的值。短路计算功能可以提高程序的运行速度。 作者建议读者：在程序设计时使用&&和||运算符，不使用&和|运算符。 用逻辑与（&&）、逻辑或（||）和逻辑非（!）可以组合出各种可能的逻辑表达式。逻辑表达式主要用在 if、while等语句的条件组合上。 例如： int i = 1; while(i>=1) && (i<=100) i++; //循环过程 上述程序段的循环过程将i++语句循环执行100次。 4.位运算符 位运算是以二进制位为单位进行的运算，其操作数和运算结果都是整型值。 位运算符共有7个，分别是：位与（&）、位或（|）、位非（~）、位异或（^）、右移（>>）、左移（<<）、0填充的右移（>>>）。 位运算的位与（&）、位或（|）、位非（~）、位异或（^）与逻辑运算的相应操作的真值表完全相同，其差别只是位运算操作的操作数和运算结果都是二进制整数，而逻辑运算相应操作的操作数和运算结果都是逻辑值。 位运算示例 运算符 名称 示例 说明 & 位与 x&y 把x和y按位求与 | 位或 x|y 把x和y按位求或 ~ 位非 ~x 把x按位求非 ^ 位异或 x^y 把x和y按位求异或 >> 右移 x>>y 把x的各位右移y位 << 左移 x<<y 把x的各位左移y位 >>> 右移 x>>>y 把x的各位右移y位，左边填0 举例说明： （1）有如下程序段： int x = 64; //x等于二进制数的01000000 int y = 70; //y等于二进制数的01000110 int z = x&y //z等于二进制数的01000000 即运算结果为z等于二进制数01000000。位或、位非、位异或的运算方法类同。 （2）右移是将一个二进制数按指定移动的位数向右移位，移掉的被丢弃，左边移进的部分或者补0（当该数为正时），或者补1（当该数为负时）。这是因为整数在机器内部采用补码表示法，正数的符号位为0，负数的符号位为1。例如，对于如下程序段： int x = 70; //x等于二进制数的01000110 int y = 2; int z = x>>y //z等于二进制数的00010001 即运算结果为z等于二进制数00010001，即z等于十进制数17。 对于如下程序段： int x = -70; //x等于二进制数的11000110 int y = 2; int z = x>>y //z等于二进制数的11101110 即运算结果为z等于二进制数11101110，即z等于十进制数-18。要透彻理解右移和左移操作，读者需要掌握整数机器数的补码表示法。 （3）0填充的右移（>>>）是不论被移动数是正数还是负数，左边移进的部分一律补0。 5.其他运算符 （1）赋值运算符与其他运算符的简捷使用方式 赋值运算符可以与二元算术运算符、逻辑运算符和位运算符组合成简捷运算符，从而可以简化一些常用表达式的书写。 赋值运算符与其他运算符的简捷使用方式 运算符 用法 等价于 说明 += s+=i s=s+i s，i是数值型 -= s-=i s=s-i s，i是数值型 *= s*=i s=s*i s，i是数值型 /= s/=i s=s/i s，i是数值型 %= s%=i s=s%i s，i是数值型 &= a&=b a=a&b a，b是逻辑型或整型 |= a|=b a=a|b a，b是逻辑型或整型 ^= A^=b a=a^b a，b是逻辑型或整型 <<= s<<=i s=s<<i s，i是整型 >>= s>>=i s=s>>i s，i是整型 >>>= s>>>=i s=s>>>i s，i是整型 （2）方括号[]和圆括号（）运算符 方括号[]是数组运算符，方括号[]中的数值是数组的下标，整个表达式就代表数组中该下标所在位置的元素值。 圆括号（）运算符用于改变表达式中运算符的优先级。（3）字符串加（+）运算符 当操作数是字符串时，加（+）运算符用来合并两个字符串；当加（+）运算符的一边是字符串，另一边是数值时，机器将自动将数值转换为字符串，这种情况在输出语句中很常见。如对于如下程序段： int max = 100; System.out.println（"max = "+max）; 计算机屏幕的输出结果为：max = 100，即此时是把变量max中的整数值100转换成字符串100输出的。（4）条件运算符（？：） 条件运算符（？：）的语法形式为： <表达式1> ？<表达式2> : <表达式3> 条件运算符的运算方法是：先计算<表达式1>的值，当<表达式1>的值为true时，则将<表达式2>的值作为整个表达式的值；当<表达式1>的值为false时，则将<表达式3>的值作为整个表达式的值。如： int a=1，b=2，max; max = a>b？a：b; //max等于2（5）强制类型转换符 强制类型转换符能将一个表达式的类型强制转换为某一指定数据类型，其语法形式为： (<类型>)<表达式>（6）对象运算符instanceof 对象运算符instanceof用来测试一个指定对象是否是指定类（或它的子类）的实例，若是则返回true，否则返回false。（7）点运算符 点运算符“.”的功能有两个：一是引用类中成员，二是指示包的层次等级。 6.运算符的优先级 以下按优先级从高到低的次序列出Java语言中的所有运算符，表中结合性一列中的“左uf0f0右”表示其运算次序为从左向右，“右uf0f0左”表示其运算次序为从右向左。 优先级 运算符 结合性 1 . [] () ; , 2 ++ ―― += ! ~ +(一元) -(一元) 右uf0f0左 3 * / % 左uf0f0右 4 +(二元) -(二元) 左uf0f0右 5 << >> >>> 左uf0f0右 6 < > <= >= instanceof 左uf0f0右 7 = = != 左uf0f0右 8 & 左uf0f0右 9 ^ 左uf0f0右 10 | 左uf0f0右 11 && 左uf0f0右 12 || 左uf0f0右 13 ?： 右uf0f0左 14 = *= /= %= += －= <<= >>= >>>= &= ^= |= 右uf0f0左--感谢原作者。

nstanceof和typeof都能用来判断一个变量是否为空或是什么类型的变量。 typeof用以获取一个变量的类型，typeof一般只能返回如下几个结果：number,boolean,string,function,object,undefined。我们可以使用typeof来获取一个变量是否存在，如if(typeof a!="undefined"){}，而不要去使用if(a)因为如果a不存在（未声明）则会出错，对于Array,Null等特殊对象使用typeof一律返回object，这正是typeof的局限性。 如果我们希望获取一个对象是否是数组，或判断某个变量是否是某个对象的实例则要选择使用instanceof。instanceof用于判断一个变量是否某个对象的实例，如var a=new Array();alert(a instanceof Array);会返回true，同时alert(a instanceof Object)也会返回true;这是因为Array是object的子类。再如：function test(){};var a=new test();alert(a instanceof test)会返回true。 谈到instanceof我们要多插入一个问题，就是function的arguments，我们大家也许都认为arguments是一个Array，但如果使用instaceof去测试会发现arguments不是一个Array对象，尽管看起来很像。另外：测试 var a=new Array();if (a instanceof Object) alert("Y");else alert("N");得"Y"但 if (window instanceof Object) alert("Y");else alert("N");得"N"所以，这里的instanceof测试的object是指js语法中的object，不是指dom模型对象。使用typeof会有些区别alert(typeof(window) 会得 object

什么时候用多态：在定义一个方法时，将方法的形参尽量定义为一个接口，或者是一个抽象类，这样当这个方法被掉用时，需要传入数，这时候，你就可以有选择性的传递参数了，你可以传递实现这个接口的任意一个类，这样程序的可扩展性就是最好的instanceOf：1.用instanceof来测试它所指向的对象是否是某个类。2.instanceof在对象类型的强制转换，先判断是否是某种类型，是的话再强制转换成改类型。传送门：http://baike.baidu.com/view/1989052.htm?fr=ala0_1_1

The instanceof operator compares an object to a specified type. You can use it to test if an object is an instance of a class, an instance of a subclass, or an instance of a class that implements a particular interface.说白了，就是看一个实例是不是一个指定的类型或者是不是它的子类型或者是不是它的接口实现。BB都是一个类，而AA是一个实例

编译器先做了类型是否可以转换的检测。只有有继承关系的类才可以在编译阶段互相转换。你可以编译一下，看看输出的编译错误信息，错误信息很明确的指出了错误原因。Incompatible conditional operand types翻译：条件操作数类型不兼容

判断A 是不是B类型的 返回一个bool值~~~英文字面上的意思也能看出来

http://blog.csdn.net/gqm1982/archive/2007/04/20/1572703.aspx上面有详细解释，多在百度是搜一搜

你追踪一下demand这个变量，看哪里出问题了

分类: 电脑/网络 >> 程序设计 >> 其他编程语言 问题描述: 在JAVA程序中instanceof是什么意思 解析: instanceof是什么东东? instanceof是Java的一个二元操作符，和==，>，<是同一类东东。由于它是由字母组成的，所以也是Java的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。举个例子: String s = "I AM an Object!";boolean isObject = s instanceof Object; 我们声明了一个String对象引用，指向一个String对象，然后用instancof来测试它所指向的对象是否是Object类的一个实例，显然，这是真的，所以返回true，也就是isObject的值为True。 instanceof有一些用处。比如我们写了一个处理账单的系统，其中有这样三个类: public class Bill {省略细节} public class PhoneBill extends Bill {省略细节} public class GasBill extends Bill {省略细节} 在处理程序里有一个方法，接受一个Bill类型的对象，计算金额。假设两种账单计算方法不同，而传入的Bill对象可能是两种中的任何一种，所以要用instanceof来判断: public double calculate(Bill bill) { if (bill instanceof PhoneBill) { 计算电话账单 } if (bill instanceof GasBill) { 计算燃气账单 } ... } 这样就可以用一个方法处理两种子类。 然而，这种做法通常被认为是没有好好利用面向对象中的多态性。其实上面的功能要求用方法重载完全可以实现，这是面向对象变成应有的做法，避免回到结构化编程模式。只要提供两个名字和返回值都相同，接受参数类型不同的方法就可以了: public double calculate(PhoneBill bill) { 计算电话账单 } public double calculate(GasBill bill) { 计算燃气账单 } 所以，使用instanceof在绝大多数情况下并不是推荐的做法，应当好好利用多态。

getfile

hover就是鼠标放上去后，标签的样式，可以给a标签注册一个onmouseover和onmouseout事件，在事件处理函数中改变标签的样式。<a href="" id="aa">dsdfdsfdfsdfds</a><script>document.getElementById("aa").onmouseover=function(){document.getElementById("aa").style="color:red;";}document.getElementById("aa").onmouseout=function(){document.getElementById("aa").style="color:blue;";}</script>

从语言特性来说，Objective-C和Java比不合适，因为设计理念不同，Objective-C和C++可以比，Java和C#比。Java和C#编译出的代码都需要一个运行环境才能跑，类似虚拟机的方式执行代码，Objective-C和C++编译出的代码则可以直接给交给CPU运行。有运行环境的语言，执行效率低很多，优点是开发简单。不过既然现在这两个是最流行的移动开发语言，硬把两者放一起比就相当于拿Google和Apple平台比，还是有意义的:(1)执行效率:如上面所说，Objective-C效率高得多，所以Android手机的电池表现和性能表现很难均衡。(2)开发效率:也如上面所说，Java开发更简便。不过在苹果的努力下，Objective-C开发MacOSX应用已经可以使用GC(自动垃圾回收)，开发iOS应用有ARC(自动引用计数)，反正都不再需要手动管理内存了，以前管理内存是Obj-C程序员的噩梦。(3)跨平台:除了苹果的系统，已经没什么系统应用能用 Objective-C 开发了，但Objective-C可以和C++混合编译，C++的跨平台威力可秒杀Java，所以很多软件都是用C++开发核心、在苹果的平台上用Obj-C做个壳。当然，Java也能调用C++开发的代码，但两种语言格格不入(效率差距、类型差异)，开发出的代码一点都不优雅，无法与Obj-C / C++的融合媲美。平手。(4)开源库:Objective-C的开源库丰富程度虽然比不上Java，但Objective-C可以和C++混合编译，C++开源库就可以和Java比了。不过考虑到跨语言开发还是比单语言开发麻烦一些，Java胜。

java.sql下，不需要jar。输入statement后，使用鼠标移动到其上importpackage，或者ctrl+shift+m单个引入，或者ctrl+shift+o引入所有未导入的包。再观察其所在包。