Java概念性问题8

以下内容来自学习整理：

如何获取ServletContext设置的参数值？B

A context.getParameter()
B context.getInitParameter()
C context.getAttribute()
D context.getRequestDispatcher()

　　getParameter()是获取POST/GET传递的参数值； getInitParameter获取Tomcat的server.xml中设置Context的初始化参数
　　getAttribute()是获取对象容器中的数据值； getRequestDispatcher是请求转发。

　　Web容器在启动时为每个Web应用创建一个ServletContext对象，ServletConfig对象中维护了ServletContext的引用，开发人员在编写servlet时，可以通过ServletConfig.getServletContext方法获得ServletContext对象。由于一个WEB应用中的所有Servlet共享同一个ServletContext对象，因此Servlet对象之间可以通过ServletContext对象来实现通讯。ServletContext对象通常也被称之为context域对象。
　　多个Servlet通过ServletContext对象实现数据共享。 在InitServlet的Service方法中利用ServletContext对象存入需要共享的数据 ServletContext context = this.getServletContext(); context.setAttribute(“name”, “haha”);
　　
　　在其它的Servlet中利用ServletContext对象获取共享的数据
　　ServletContext context = this.getServletContext();
　　String name = context.getAttribute(“name”);
　　
　　获取WEB应用的初始化参数。 在DemoServlet的doPost方法中测试获取初始化参数的步骤如下:
　　ServletContext context = this.getServletContext();
　　String url = context.getInitParameter(“url”);

下面有关webservice的描述，错误的是？Ｂ

Ａ　Webservice是跨平台，跨语言的远程调用技术
Ｂ　Webservice通信机制实质就是json数据交换
Ｃ　Webservice采用了soap协议（简单对象协议）进行通信
Ｄ　WSDL是用于描述 Web Services 以及如何对它们进行访问
Webservice是跨平台，跨语言的远程调用技术;
它的通信机制实质就是xml数据交换;
它采用了soap协议（简单对象协议）进行通信

WSDL 可描述网络服务（Web Services），WSDL 指网络服务描述语言 (Web Services Description　Language)。WSDL 是一种使用 XML 编写的文档。这种文档可描述某个 Web service。它可规定服务的位置，以及此服务提供的操作（或方法）

---

　　Web service顾名思义是基于web的服务，它是一种跨平台，跨语言的服务。
我们可以这样理解它，比如说我们可以调用互联网上查询天气信息的web服务，把它嵌入到我们的B/S程序中，当用户从我们的网点看到天气信息时，会认为我们为他提供很多的服务，但其实我们什么也没做，只是简单的调用了一下服务器上的一端代码而已。　　
　　Web　service 可以将你的服务发布到互联网上让别人去调用，也可以调用别人发布的web service，和使用自己的代码一样。
　　它是采用XML传输格式化的数据，它的通信协议是SOAP(简单对象访问协议).

以下J2EE中常用的名词解释错误的是？Ｂ

Ａ　EJB容器：Enterprise java bean 容器
Ｂ　JNDI：JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接口即可。
Ｃ　JMS：JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。
Ｄ　JAF：JAVA安全认证框架。提供一些安全控制方面的框架。

J2EE中常用的名词解释
1.web容器：给处于其中的应用程序组件（JSP，SERVLET）提供一个环境，使JSP,SERVLET直接和容器中的环境变量接接口互，不必关注其它系统问题。主要有WEB服务器来实现。例如：TOMCAT,WEBLOGIC,WEBSPHERE等。该容器提供的接口严格遵守J2EE规范中的WEB APPLICATION 标准。我们把遵守以上标准的WEB服务器就叫做J2EE中的WEB容器。
2.Web container：实现J2EE体系结构中Web组件协议的容器。这个协议规定了一个Web组件运行时的环境，包括安全，一致性，生命周期管理，事务，配置和其它的服务。一个提供和JSP和J2EE平台APIs界面相同服务的容器。一个Web container 由Web服务器或者J2EE服务器提供。
3.EJB容器：Enterprise java bean 容器。更具有行业领域特色。他提供给运行在其中的组件EJB各种管理功能。只要满足J2EE规范的EJB放入该容器，马上就会被容器进行高效率的管理。并且可以通过现成的接口来获得系统级别的服务。例如邮件服务、事务管理。一个实现了J2EE体系结构中EJB组件规范的容器。 这个规范指定了一个Enterprise bean的运行时环境，包括安全，一致性，生命周期，事务， 配置，和其他的服务。
4.JNDI：（Java Naming & Directory Interface）JAVA命名目录服务。主要提供的功能是：提供一个目录系统，让其它各地的应用程序在其上面留下自己的索引，从而满足快速查找和定位分布式应用程序的功能。
5.JMS：（Java Message Service）JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。
6.JTA：（Java Transaction API）JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接口即可。
7.JAF：（Java Action FrameWork）JAVA安全认证框架。提供一些安全控制方面的框架。让开发者通过各种部署和自定义实现自己的个性安全控制策略。
8.RMI/IIOP:（Remote Method Invocation /internet对象请求中介协议）他们主要用于通过远程调用服务。例如，远程有一台计算机上运行一个程序，它提供股票分析服务，我们可以在本地计算机上实现对其直接调用。当然这是要通过一定的规范才能在异构的系统之间进行通信。RMI是JAVA特有的。RMI-IIOP出现以前，只有RMI和CORBA两种选择来进行分布式程序设计。RMI-IIOP综合了RMI和CORBA的优点，克服了他们的缺点，使得程序员能更方便的编写分布式程序设计，实现分布式计算。首先，RMI-IIOP综合了RMI的简单性和CORBA的多语言性（兼容性），其次RMI-IIOP克服了RMI只能用于Java的缺点和CORBA的复杂性（可以不用掌握IDL）。

HttpServlet容器响应Web客户请求流程如下

HttpServlet容器响应Web客户请求流程如下：
1）Web客户向Servlet容器发出Http请求；
2）Servlet容器解析Web客户的Http请求；
3）Servlet容器创建一个HttpRequest对象，在这个对象中封装Http请求信息；
4）Servlet容器创建一个HttpResponse对象；
5）Servlet容器调用HttpServlet的service方法，这个方法中会根据request的Method来判断具体是执行doGet还是doPost，把HttpRequest和HttpResponse对象作为service方法的参数传给HttpServlet对象；
6）HttpServlet调用HttpRequest的有关方法，获取HTTP请求信息；
7）HttpServlet调用HttpResponse的有关方法，生成响应数据；
8）Servlet容器把HttpServlet的响应结果传给Web客户。

doGet() 或 doPost() 是创建HttpServlet时需要覆盖的方法.

给出以下代码 请给出结果：（B）

A 运行时抛出异常
B true
C Fred
D 第三行编译错误
匿名内部类http://www.cnblogs.com/nerxious/archive/2013/01/25/2876489.html
http://blog.csdn.net/justloveyou_/article/details/53245561
http://blog.csdn.net/justloveyou_/article/details/52798666

下面哪些赋值语句是正确的（ABD）

A long test=012
B float f=-412
C int other =(int)true
D double d=0x12345678
E byte b=128
基本类型会进行转化
A：012默认是int类型，赋给long类型没错。 正确
B：-412默认也是int类型，赋给float没错。 正确
C：很明显布尔类型不能强转成其他数值类型。 错误
D：0x12345678默认应该是int类型，赋给double没错。 正确
E：128 > 127默认是int类型，byte默认范围是(-128 ~ 127)。错误
基本类型与基本封装类型
A和B选项如果为 Long Float，则是需要在数值后面加L和F，但是他们是基本类型，会进行转化，所以不需要带
A和B中long和float，正常定义需要加l和f，但是long和float属于基本类型，会进行转化，所以不会报出异常。AB正确
boolean类型不能和任何类型进行转换，会报出类型异常错误。所以C错。
D选项可以这样定义，D正确。
E选项中，byte的取值范围是-128—127。报出异常： cannot convert from int to byte.所以E选项错误。

Java.Thread的方法resume()负责重新开始被以下哪个方法中断的线程的执行（D）。

A stop
B sleep
C wait
D suspend
suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的 resume() 被调用，才能使得线程重新进入可执行状态，suspend()函数让当前线程进入停滞状态,除非收到resume()信号，否则不唤醒。
总之：、
resume与suspended一起使用
wait与notify(notifyAll)一起使用
sleep会让线程暂时不执行

resume()已过时。该方法只与 suspend() 一起使用，但 suspend()已经遭到反对，因为它具有死锁倾向。

方法的重写（override）两同两小一大原则：

方法名相同，参数类型相同
子类返回类型小于等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。

Web程序中，当前用户上下文信息应该保存在下面哪个对象中（C）

A page
B request
C session
D Application
JSP 四大作用域： page (作用范围最小)、request、session、application（作用范围最大）。
存储在application对象中的属性可以被同一个WEB应用程序中的所有Servlet和JSP页面访问。（属性作用范围最大）
存储在session对象中的属性可以被属于同一个会话（浏览器打开直到关闭称为一次会话，且在此期间会话不失效）的所有Servlet和JSP页面访问。
存储在request对象中的属性可以被属于同一个请求的所有Servlet和JSP页面访问（在有转发的情况下可以跨页面获取属性值），例如使用PageContext.forward和PageContext.include方法连接起来的多个Servlet和JSP页面。
存储在pageContext对象中的属性仅可以被当前JSP页面的当前响应过程中调用的各个组件访问，例如，正在响应当前请求的JSP页面和它调用的各个自定义标签类。

application：全局作用范围，整个应用程序共享，就是在部署文件中的同一个webApp共享，生命周期为：应用程序启动到停止。
session：会话作用域，当用户首次访问时，产生一个新的会话，以后服务器就可以记住这个会话状态。生命周期：会话超时，或者服务器端强制使会话失效。
request：请求作用域，就是客户端的一次请求。 题目说的上下文信息，概念很模糊。这三个都有上下文信息。

application表示的是web应用的作用域， session表示的是一次对话的作用域 request表示的是一次请求的作用域 page表示的是当前页面的作用域（在JSP文件中表示this）

instanceof运算符能够用来判断一个对象是否为:C

A 一个类的实例
B 一个实现指定接口的类的实例
C 全部正确
D 一个子类的实例

interface A{}class B implements A{}class C extends B{}public class Iinstanceof {    public static void main(String[] args) {        A ab=new B();        A ac=new C();        B bc=new C();        B bb=new B();        C cc=new C();        //对象实现一个接口，用这个对象和这个接口进行instanceof判断，都为true。        System.out.println("ab instanceof A="+(ab instanceof A));        System.out.println("ac instanceof A="+(ac instanceof A));        System.out.println("bc instanceof A="+(bc instanceof A));        System.out.println("bb instanceof A="+(bb instanceof A));        System.out.println("cc instanceof A="+(cc instanceof A));        //对象和父类进行instanceof判断，都为true        System.out.println("ab instanceof B="+(ab instanceof B));        System.out.println("ac instanceof B="+(ac instanceof B));        System.out.println("bc instanceof B="+(bc instanceof B));        System.out.println("bb instanceof B="+(bb instanceof B));        System.out.println("cc instanceof B="+(cc instanceof B));        //对象和他的子类进行instanceof判断为false        System.out.println("ab instanceof C="+(ab instanceof C));        System.out.println("ac instanceof C="+(ac instanceof C));        System.out.println("bc instanceof C="+(bc instanceof C));        System.out.println("bb instanceof C="+(bb instanceof C));        System.out.println("cc instanceof C="+(cc instanceof C));    }}程序输出： ab instanceof A=true ac instanceof A=true bc instanceof A=true bb instanceof A=true cc instanceof A=true ab instanceof B=true ac instanceof B=true bc instanceof B=true bb instanceof B=true cc instanceof B=true ab instanceof C=false ac instanceof C=true bc instanceof C=true bb instanceof C=false cc instanceof C=true

下面有个hibernate延迟加载，说法错误的是？C

A Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）
B Hibernate3 提供了属性的延迟加载功能
C get支持延迟加载，load不支持延迟加
D hibernate使用Java反射机制，而不是字节码增强程序来实现透明性
　　load方法来得到一个对象时，此时hibernate会使用延迟加载的机制来加载这个对象，即：当 我们使用session.load()方法来加载一个对象时，此时并不会发出sql语句，当前得到的这个对象其实是一个代理对象，这个代理对象只保存了实 体对象的id值，只有当我们要使用这个对象，得到其它属性时，这个时候才会发出sql语句，从数据库中去查询我们的对象。
　　相对于load的延迟加载方式，get就直接的多，当我们使用session.get()方法来得到一个对象时，不管我们使不使用这个对象，此时都会发出sql语句去从数据库中查询出来。

阅读如下代码。 请问，对语句行 test.hello(). 描述正确的有（A）

package NowCoder;class Test {    public static void hello() {        System.out.println("hello");    }}public class MyApplication {    public static void main(String[] args) {        // TODO Auto-generated method stub        Test test=null;        test.hello();    }}

A就相当于Test.hello()
值得一说的是有些人以为是空指针，这里你们所说的空指针必须是去引用堆对象才会有空指针
而这个hello是static类型的，static的方法本身就没有指针，所以当然不会有空指针

原码补码反码

变量a是一个64位有符号的整数，初始值用16进制表示为：0x7FFFFFFFFFFFFFFF;变量b是一个64位有符号的整数，初始值用16进制表示为：0x8000000000000000。则a+b的结果用10进制表示为多少？
A 1
B -1
C 2^63+2^62+…+2^2+2^1+2^0
D –(2^63+2^62+…+2^2+2^1+2^0)

（1）a+b的16进制表示为：OxFFFFFFFFFFFFFFF（16位F），转为2进制为111……111（64位1，每个F->4位2）。
（2）有符号数：是针对二进制来讲的。用最高位作为符号位，“0”表“+”，“1”代表“-”。所以a+b的结果是一个负数。
（3）计算机中负数是以补码的形式保存的，将补码转换成原码的计算方式如下：
　　①. 对于正数，原码与补码相同。
　　②.对于负数，将补码除符号位之外，按位取反，末位加1，即得到原码。
（4）a + b = 111……111（64位1）
　　取反：100……000（1位1，后面63位0）
　　 加一：100……00（中间62位0）
　　10进制：-1。

下面的输出结果是什么？Ｂ

Ａ　true
Ｂ　false
==判断的是对象引用地址是否相同，
String str=new String(“hello”);
这句话new了一个新的String对象，所以地址与”hello”字符串常量的地址不同，答案为false
如果判断字符串是否相等应给用str.equals(“hello”)方法

public class Demo {    public static void main(String args[]) {        String str1 = new String("hello");        String str2 = new String("hello");        String str3 = "hello";        String str4 = "hello";        String str5 = "he"+"llo";        String str6 = "he";        String str7 = "llo";        System.out.println(str1==str2);        System.out.println(str1==str3);        System.out.println(str3==str4);        System.out.println(str3=="hello");        System.out.println(str4==(str6+str7));    }}上面代码的输出结果是：falsefalsetruetruefalseString str1 = new String("hello");这种方式创建的字符串，和正常创建对象一样，保存在堆区。String str3 = "hello";这种方式创建的字符串，保存在字符串常量区。

假设如下代码中，若t1线程在t2线程启动之前已经完成启动。代码的输出是（Ｂ）

public static void main(String[]args)throws Exception {    final Object obj = new Object();    Thread t1 = new Thread() {        public void run() {            synchronized (obj) {                try {                    obj.wait();                    System.out.println("Thread 1 wake up.");                } catch (InterruptedException e) {                }            }        }    };    t1.start();    Thread.sleep(1000);//We assume thread 1 must start up within 1 sec.    Thread t2 = new Thread() {        public void run() {            synchronized (obj) {                obj.notifyAll();                System.out.println("Thread 2 sent notify.");            }        }    };    t2.start();}

Ａ　Thread 1 wake up
Thread 2 sent notify.
Ｂ　Thread 2 sent notify.
Thread 1 wake up
Ｃ　A、B皆有可能
Ｄ　程序无输出卡死
　　执行obj.wait();时已释放了锁，所以t2可以再次获得锁，然后发消息通知t1执行，但这时t2还没有释放锁，所以肯定是执行t2，然后释放锁，之后t1才有机会执行。

　　notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。

---

线程间协作：wait、notify、notifyAll
　　在 Java 中，可以通过配合调用 Object 对象的 wait() 方法和 notify()方法或 notifyAll()方法来实现线程间的通信。在线程中调用 wait() 方法，将阻塞等待其他线程的通知（其他线程调用 notify() 方法或notifyAll() 方法），在线程中调用 notify() 方法或 notifyAll() 方法，将通知其他线程从 wait() 方法处返回。
　　Object 是所有类的超类，它有 5个方法组成了等待/通知机制的核心：notify()、notifyAll()、wait()、wait(long)和wait(long，int)。在 Java 中，所有的类都从 Object
继承而来，因此，所有的类都拥有这些共有方法可供使用。而且，由于他们都被声明为 final，因此在子类中不能覆写任何一个方法。

这里详细说明一下各个方法在使用中需要注意的几点。
wait()
public final void wait() throws InterruptedException,IllegalMonitorStateException
该方法用来将当前线程置入休眠状态，直到接到通知或被中断为止。在调用wait()之前，线程必须要获得该对象的对象级别锁，即只能在同步方法或同步块中调用 wait()方法。进入wait()方法后，当前线程释放锁。在从 wait()返回前，线程与其他线程竞争重新获得锁。如果调用wait()时，没有持有适当的锁，则抛出 IllegalMonitorStateException，它是 RuntimeException的一个子类，因此，不需要 try-catch 结构。

notify()
public final native void notify() throws IllegalMonitorStateException
该方法也要在同步方法或同步块中调用，即在调用前，线程也必须要获得该对象的对象级别锁，的如果调用notify()时没有持有适当的锁，也会抛出 IllegalMonitorStateException。该方法用来通知那些可能等待该对象的对象锁的其他线程。如果有多个线程等待，则线程规划器任意挑选出其中一个wait()状态的线程来发出通知，并使它等待获取该对象的对象锁（notify 后，当前线程不会马上释放该对象锁，wait所在的线程并不能马上获取该对象锁，要等到程序退出 synchronized代码块后，当前线程才会释放锁，wait所在的线程也才可以获取该对象锁），但不惊动其他同样在等待被该对象notify的线程们。当第一个获得了该对象锁的wait 线程运行完毕以后，它会释放掉该对象锁，此时如果该对象没有再次使用 notify 语句，则即便该对象已经空闲，其他 wait状态等待的线程由于没有得到该对象的通知，会继续阻塞在 wait 状态，直到这个对象发出一个 notify 或notifyAll。这里需要注意：它们等待的是被 notify 或notifyAll，而不是锁。这与下面的 notifyAll()方法执行后的情况不同。

notifyAll()
public final native void notifyAll() throws IllegalMonitorStateException
该方法与 notify ()方法的工作方式相同，重要的一点差异是：notifyAll 使所有原来在该对象上 wait 的线程统统退出 wait 的状态（即全部被唤醒，不再等待 notify 或notifyAll，但由于此时还没有获取到该对象锁，因此还不能继续往下执行），变成等待获取该对象上的锁，一旦该对象锁被释放（notifyAll线程退出调用了 notifyAll 的 synchronized代码块的时候），他们就会去竞争。如果其中一个线程获得了该对象锁，它就会继续往下执行，在它退出 synchronized 代码块，释放锁后，其他的已经被唤醒的线程将会继续竞争获取该锁，一直进行下去，直到所有被唤醒的线程都执行完毕。

深入理解
如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用wait()方法，它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行，直到执行完了synchronized 代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。

下列关于容器集合类的说法正确的是？Ｃ

Ａ　LinkedList继承自List
Ｂ　AbstractSet继承自Set
Ｃ　HashSet继承自AbstractSet
Ｄ　WeakMap继承自HashMap

有如下4条语句：(Ｃ)以下输出结果为false的是:

Integer i01=59;int i02=59;Integer i03=Integer.valueOf(59);Integer i04=new Integer(59);

Ａ　System.out.println(i01==i02);
Ｂ　System.out.println(i01==i03);／／缓存　－１２８－－１２７
Ｃ　System.out.println(i03==i04);
Ｄ　System.out.println(i02==i04);
http://cs-css.iteye.com/blog/1815296