java基础题

一、基础：（共25题）

                  1.数据库，比如100用户同时来访，要采取什么技术解决；(JDBC)
                  答：可采用连接池。

                  2.String,  StringBuffer  StringBuilder的区别。(Core Java)
                  答：String的长度是不可变的；
                  StringBuffer的长度是可变的，如果你对字符串中的内容经常进行操作，特别是内容要修改时，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toString()方法；线程安全；
                  StringBuilder是从 JDK 5
                  开始，为StringBuffer该类补充了一个单个线程使用的等价类；通常应该优先使用 StringBuilder
                  类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。

                  3.写一个函数要求输入一个字符串和一个字符长度，对该字符串进行分隔；(Core Java)
                  答：函数代码如下：
                  public String[] split(String str, int chars){
                  int n = (str.length()+ chars - 1)/chars;
                  String ret[] = new String[n];
                  for(int i=0; i<n; i++){
                  if(i < n-1){
                  ret[i] = str.substring(i*chars , (i+1)*chars);
                  }else{
                  ret[i] = str.substring(i*chars);
                  }
                  }
                  return ret;
                  }

                  4.java和javasciprt的区别；(Core Java)
                  答：javascript与Java是两个公司开发的不同的两个产品。Java是SUN公司推出的新一代面向对象的程序设计语言，特别适合于Internet应用程序开发；而javascript是Netscape公司的产品，其目的是为了扩展Netscape
                  Navigator功能,而开发的一种可以嵌入Web页面中的基于对象和事件驱动的解释性语言, 它的前身是Live
                  Script；而Java的前身是Oak语言。下面对两种语言间的异同作如下比较：
                  1）基于对象和面向对象：
                  Java是一种真正的面向对象的语言，即使是开发简单的程序，必须设计对象。
                  javascript是种脚本语言，它可以用来制作与网络无关的，与用户交互作用的复杂软件。它是一种基于对象（Object
                  Based）和事件驱动（Event Driver）的编程语言。因而它本身提供了非常丰富的内部对象供设计人员使用。
                  2）解释和编译：
                  Java的源代码在执行之前，必须经过编译；
                  javascript是一种解释性编程语言，其源代码不需经过编译，由浏览器解释执行。
                  3）强类型变量和类型弱变量：
                  Java采用强类型变量检查，即所有变量在编译之前必须作声明；
                  javascript中变量声明，采用其弱类型。即变量在使用前不需作声明，而是解释器在运行时检查其数据类型。
                  4）代码格式不一样。

                  5.语句float f=1.3；编译能否通过？(Core Java)
                  答:不能；应该用强制类型转换，如下所示：float f=(float)1.3；

                  6.以下二条语句返回值为true的有：(Core Java)
                  答：A B  
                  A：“beijing”==“beijing”；
                  B：“beijing”.equalsIgnoreCase（new String（“beijing”））；

                  7.类Example A继承 Exception，类 ExampleB继承Example A；
                  有如下代码片断：(Core Java)
                  try{
                  throw new ExampleB(“b”)；
                  }catch（ExampleA  e）{
                  System.out.printfln（“ExampleA”）；
                  }catch（Exception  e）{
                  System.out.printfln（“Exception”）；
                  }
                  输出的内容应该是：A
                  A：ExampleA   B：Exception    C：b    D：无

                  8.java多线程有几种实现方法,都是什么?同步有几种实现方法，都是什么；(Core Java)
                  答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口；
                  同步的实现方面有两种，分别是synchronized,wait与notify

                  9.Arraylist与Vector区别；(Core Java)
                  答：就ArrayList与Vector主要从二方面来说：
                  1. 同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
                  2. 数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半

                  10.HashMap Hashtable 区别；(Core Java)
                  答：都属于Map接口的类，实现了将惟一键映射到特定的值上，区别主要有：
                  1. 历史原因:Hashtable是继承于陈旧的Dictionary类的，HashMap是Java
                  1.2引进的Map接口的一个实现；
                  2. 同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的；
                  3. 值：只有HashMap可以让你将空值作为一个表的条目的key或value；
                  4.
                  HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey；因为contains方法容易让人引起误解。

                  11.Collction和Collections的区别；(Core Java)
                  答：Collections是个java.util下的类，它包含有各种有关集合操作的静态方法；
                  Collection是个java.util下的接口，它是各种集合结构的父接口。

                  12.面向对象的特征有哪些方面；(Core Java)
                  答：封装、继承、多态：
                  1）封装：指把一个类的内部实现隐藏起来，对外提供公开一致的接口，从而具有更好的可维护性；
                  2）继承：使一个类自动获得另一个类的方法和属性；
                  3）多态：指子类可以当作父类用。

                  13.Overload和Override的区别；Overloaded的方法是否可改变返回值类型；(Core Java)
                  答：方法的覆盖Overriding和重载Overloading是Java多态性的不同表现。覆盖Overriding是父类与子类之间多态性的一种表现（又称为运行时多态），重载Overloading是一个类中多态性的一种表现（也称为编译时多态）。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被覆盖(Overriding)，子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。
                  Overloaded的方法是可以改变返回值的类型。

                  14.定义类A和类B如下：(Core Java)
                  class  A {
                  int  a=1;
                    double  d=2.0;
                     void  show(){
                         System.out.println("Class A: a="+a +"\td="+d);
                     }
                  }
                  class B extends A{
                     float  a=3.0f;               
                     String  d="Java program.";  
                     void  show(){ 
                         super.show( );      
                         System.out.println("Class B:  a="+a +"\td="+d);
                     }
                  }
                  (1) 若在应用程序的main方法中有以下语句：
                  A  a=new A();
                  a.show();
                  则输出的结果如何？
                  答：输出结果为：Class A: a=1d=2.0 
                  (2) 若在应用程序的main方法中定义类B的对象b：
                  A  b=new B();
                  b.show();
                  则输出的结果如何？
                  答：输出结果为：Class A: a=1d=2.0
                  Class B:  a=3.0d=Java program.

                  15.接口和抽象类的区别；(Core Java)
                  答：抽象类与接口都用于抽象，但是抽象类(JAVA中)可以有自己的部分实现，而接口则完全是一个标识(同时有多重继承的功能)。成员方法中包含抽象方法的类被叫做抽象类（abstract
                  class）；不能创建abstract  类的实例，然而可以创建一个引用变量，其类型是一个抽象类，并让它指向具体子类的一个实例；不能有抽象构造函数或抽象静态方法；Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。
                  接口（interface）是抽象类的变体，在接口中，所有方法都是抽象的；多继承性可通过实现这样的接口而获得；接口只可以定义static    final成员变量；当类实现特殊接口时，它定义所有这种接口的方法；允许使用接口名作为引用变量的类型。

                  16.详细描述MVC；(Web)
                  答：基于Java的Web应用系统采用MVC架构模式，即model（模型）、view（视图）、control（控制）分离设计。这是目前WEB应用服务系统的主流设计方向。
                  Model：即处理业务逻辑的模块，每一种处理一个模块；
                  View：负责页面显示，显示MODEL处理结果给用户，主要实现数据到页面转换过程；
                  Control：负责每个请求的分发，把form数据传递给MODEL处理，把处理结果的数据传递给VIEW显示。

                  17.页面中有一个命名为bank No的下拉列表，写脚本获取当前选项的索引值；(Web)
                  答：用java或javascript的处理方式分别如下：
                  Java： request.getParameter(“bank No”);
                  javascript： var selectItems = document.getElementsByName(“bank
                  No”);
                            selectItems[0].value;

                  18.javasct常用的方面；(Web)
                  答：常用于数据输入校验和页面特殊效果等。

                  19.常用的web容器和开发工具；(Web)
                  答：最常用的容器包括：tomcat、weblogic；
                  开发工具有：eclipse,jbuilder

                  20.请画出Servlet 2.2以上Web Application的基本目录结构（时间2分钟）(Web)
                  答：目录结构如下图所示：

                       webapps
                                          |
                                      Applocation
                                          |
                                  __________________
                                  |                 |
                  JSP页面           WEB-INF            
                                                    |
                                           ___________________
                                           |         |          |
                                     Class       lib     web.xml

                  21.后序遍历下列二叉树，访问结点的顺序是？（数据结构）
                  答：DJGEBKNIFCA
                        A
                       /   \
                      B    C
                  /  \     \
                    D   E     F
                        /      / \
                       G     N  I
                       /       \
                      J         K

                  22.写一种常见排序；（算法）
                  答：C++中冒泡排序：
                  void swap( int& a, int& b ){
                  int c=a; a = b; b = c;
                  }
                  void bubble( int* p, int len ){
                  bool bSwapped;
                  do {
                  bSwapped = false;
                  for( int i=1; i<len; i++ ){
                  if( p[i-1]>p[i] ){
                  swap( p[i-1], p[i] );
                  bSwapped = true;
                  }
                  }
                  }while( bSwapped );
                  }

                  23.一个byte几个单位。(计算机基础)
                  答：8bit。

                  24.常用UNIX命令(Linux的常用命令)（至少10个）；(Unix)
                  答：ls pwd mkdir rm cp mv cd ps ftp telnet ping env more echo

                  25.写一个一小段程序检查数字是否为质数; (C++)
                  以上的程序你采用的哪种语言写的.采用该种语言的理由是什么,
                  答：代码如下：
                  #include <math.h>
                  bool prime( int n ){
                  if(n<=0) exit(0);

                     for( int i=2; i<=n; i++ )
                         for( int j=2; j<=sqrt(i); j++)
                             if((n%j==0) && (j!=n))
                                 return false;
                     return true;
                  }
                  C++，运行效率高









                   二、难度适中：（共37题）

                  1.张表,学生表S,课程C,学生课程表SC,学生可以选修多门课程,一门课程可以被多个学生选修,通过SC表关联；(SQL)
                  1)写出建表语句；
                  答：建表语句如下（mysql数据库）：
                  create table s(id integer primary key, name varchar(20));
                  create table c(id integer primary key, name varchar(20));
                  create table sc(
                  sid integer references s(id),
                  cid integer references c(id),
                  primary key(sid,cid)
                  );
                  2)写出SQL语句,查询选修了所有选修课程的学生；
                  答：SQL语句如下：
                  select stu.id, stu.name from s stu
                  where (select count(*) from sc where sid=stu.id) =
                  (select count(*) from c);
                  3)写出SQL语句,查询选修了至少5门以上的课程的学生。
                  答：SQL语句如下：
                  select stu.id, stu.name from s stu
                  where (select count(*) from sc where sid=stu.id)>=5;

                  2.数据库表(Test)结构如下：(SQL)
                  IDNAMEAGEMANAGER(所属主管人ID)
                  106A30104
                  109B19104
                  104C20111
                  107D35109
                  112E25120
                  119F45NULL
                  要求:列出所有年龄比所属主管年龄大的人的ID和名字?
                  答：SQL语句如下：
                  select employee.name from test employee where employee.age>
                  (select manager.age from test manager where
                  manager.id=employee.manager);

                  3.有3个表（15分钟）：(SQL)
                  Student 学生表 (学号，姓名，性别，年龄，组织部门)
                  Course 课程表 (编号，课程名称)
                  Sc 选课表 (学号，课程编号，成绩)
                  表结构如下：

                  1)写一个SQL语句，查询选修了’计算机原理’的学生学号和姓名（3分钟）
                  答：SQL语句如下：
                  select stu.sno, stu.sname from Student stu
                  where (select count(*) from sc where sno=stu.sno and cno =
                  (select cno from Course where cname='计算机原理')) != 0;
                  2)写一个SQL语句，查询’周星驰’同学选修了的课程名字（3分钟）
                  答：SQL语句如下：
                  select cname from Course where cno in (select cno from sc
                  where sno=(select sno from Student where sname='周星驰'));
                  3)写一个SQL语句，查询选修了5门课程的学生学号和姓名（9分钟）
                  答：SQL语句如下：
                  select stu.sno, stu.sname from student stu
                  where (select count(*) from sc where sno=stu.sno) = 5;
                  4.写四个线程，两个对j加1，两个对j减1；(Core Java)
                  答：代码如下：
                  package test;
                  public class TestThread {
                  int j;
                  public TestThread(int j) {
                  this.j = j;
                  }
                  private synchronized void inc(){
                  j++;
                  System.out.println(j + "--Inc--" +
                  Thread.currentThread().getName());
                  }
                  private synchronized void dec(){
                  j--;
                  System.out.println(j + "--Dec--" +
                  Thread.currentThread().getName());
                  }
                  public void run() {
                  (new Dec()).start();
                  new Thread(new Inc()).start();
                  (new Dec()).start();
                  new Thread(new Inc()).start();
                  }
                  class Dec extends Thread {
                  public void run() {
                  for(int i=0; i<100; i++){
                  dec();
                  }
                  }
                  }
                  class Inc implements Runnable {
                  public void run() {
                  for(int i=0; i<100; i++){
                  inc();
                  }
                  }
                  }
                  public static void main(String[] args) {
                  (new TestThread(5)).run();
                  }
                  }

                  5. 写一个方法,输入一个文件名和一个字符串,统计这个字符串在这个文件中出现的次数。(Core Java)
                  答：代码如下：
                  public int countWords(String file, String find) throws
                  Exception {
                  int count = 0;
                  Reader in = new FileReader(file);
                  int c;
                  while ((c = in.read()) != -1) {
                  while (c == find.charAt(0)) {
                  for (int i = 1; i < find.length(); i++) {
                  c = in.read();
                  if (c != find.charAt(i)) break;
                  if (i == find.length() - 1) count++;
                  }
                  }
                  }
                  return count;
                  }

                  6.sleep()和wait()的区别；(Core Java)
                  答：sleep()方法是使线程停止一段时间的方法。在sleep
                  时间间隔期满后，线程不一定立即恢复执行。这是因为在那个时刻，其它线程可能正在运行而且没有被调度为放弃执行，除非：
                  (a)“醒来”的线程具有更高的优先级
                  (b)正在运行的线程因为其它原因而阻塞。
                  wait()是线程交互时，如果线程对一个同步对象x
                  发出一个wait()调用，该线程会暂停执行，被调对象进入等待状态，直到被唤醒或等待时间到。

                  7.GC是什么？为什么要用它；(Core Java)
                  答：GC是垃圾收集器；Java 程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用方法：
                  System.gc() 或Runtime.getRuntime().gc()

                  8.用程序给出随便大小的10个数，序号为1-10，按从小到大顺序输出，并输出相应的序号。(Core Java)
                  答：代码如下：
                  package test;

                  import java.util.ArrayList;
                  import java.util.Collections;
                  import java.util.Iterator;
                  import java.util.List;
                  import java.util.Random;

                  public class RandomSort {

                  public static void printRandomBySort() {
                  Random random = new Random(); // 创建随机数生成器
                  List list = new ArrayList();
                  for (int i = 0; i < 10; i++) { // 生成10个随机数，并放在集合list中
                  list.add(random.nextInt(1000));
                  }
                  Collections.sort(list); // 对集合中的元素进行排序
                  Iterator it = list.iterator();
                  int count = 0;
                  while (it.hasNext()) { // 顺序输出排序后集合中的元素
                  System.out.println(++count + ":" + it.next());
                  }
                  }

                  public static void main(String[] args) {
                  printRandomBySort();
                  }
                  }

                  9.写一个函数，2个参数，1个字符串，1个字节数，返回截取的字符串，要求字符串中的中文不能出现乱码：如（“我ABC”，4）应该截为“我AB”，输入（“我ABC汉DEF”，6）应该输出为“我ABC”而不是“我ABC+汉的半个”。(Core
                  Java)
                  答：代码如下：
                  public String subString(String str, int subBytes) {
                  int bytes = 0; // 用来存储字符串的总字节数
                  for (int i = 0; i < str.length(); i++) {
                  if (bytes == subBytes) {
                  return str.substring(0, i);
                  }
                  char c = str.charAt(i);
                  if (c < 256) {
                  bytes += 1; // 英文字符的字节数看作1

                  } else {
                  bytes += 2; // 中文字符的字节数看作2
                  if(bytes - subBytes == 1){
                  return str.substring(0, i);
                  }
                  }
                  }
                  return str;
                  }

                  10.连接池的工作原理；(JDBC)
                  答：连接池中保存有指定个数的数据库连接，当需要时程序可从池中获取可用连接，并在程序使用过之后不关闭连接，并放回连接池中，以供其他的程序在需要时来取用，这样可以大量的节省销毁和创建连接的资源消耗。

                  11.JNDI是什么？
                  答：是java命名和目录接口服务

                  12.什么是web容器；(Web)
                  答：容器是一个软件的概念，提供了一个组件运行的环境。Web容器或ejb容器都是其中的一种。例如tomcat就是一个开源的服务器，是jsp/servlet的容器。

                  13. forward和redirect区别；(Web)
                  答：前者仅是容器中控制权的转向，在客户端浏览器地址栏中不会显示出转向后的地址；后者则是完全的跳转，浏览器将会得到跳转的地址，并重新发送请求链接，这样，从浏览器的地址栏中可以看到跳转后的链接地址。所以，前者更加高效，在前者可以满足需要时，尽量使用forward()方法，并且，这样也有助于隐藏实际的链接；在有些情况下，比如，需要跳转到一个其它服务器上的资源，则必须使用sendRedirect()方法。

                  14.struts的入口类；(Web)
                  答：ActionServlet是Struts的入口类，所有的struts请求都经由该类转发处理

                  15.用你熟悉的语言写一个连接ORACLE数据库的程序,能够完成修改和查询工作；(JDBC)
                  答：JDBC示例程序如下：
                  public void testJdbc(){
                     Connection con = null;
                  PreparedStatement ps = null;
                  ResultSet rs = null;
                  try{
                  //step1：注册驱动；
                  Class.forName("oracle.jdbc.driver.OracleDriver");
                  //step 2：获取数据库连接；
                  con=DriverManager.getConnection(
                  "jdbc:oracle:thin:@192.168.0.39:1521:TARENADB",
                  "sd0605","sd0605");
                             /*******************************查
                  询******************************/
                             //step 3：创建Statement；
                  String sql = "SELECT id, fname, lname, age, FROM Person_Tbl";
                  ps = con.prepareStatement(sql);
                             //step 4：执行查询语句，获取结果集；
                  rs = ps.executeQuery();
                             //step 5：处理结果集—输出结果集中保存的查询结果；
                  while (rs.next()){
                  System.out.print("id = " + rs.getLong("id"));
                  System.out.print(" , fname = " + rs.getString("fname"));
                  System.out.print(" , lname = " + rs.getString("lname"));
                  System.out.print(" , age = " + rs.getInt("age"));
                  }
                         /*******************************JDBC 修
                  改*********************/
                         sql = "UPDATE Person_Tbl SET age=23 WHERE id = ?";
                  ps = con.prepareStatement(sql);
                  ps.setLong(1, 88);
                  int rows = ps.executeUpdate();
                  System.out.println(rows + " rows affected.");
                  } catch (Exception e){
                  e.printStackTrace();
                  } finally{
                  try{
                  con.close(); //关闭数据库连接，以释放资源。
                  } catch (Exception e1) {
                  }
                  }
                  }

                  16.servlet的生命周期以及与其相关的类接口和相关方法；(Web)
                  答：servlet有良好的生存期的定义，包括加载和实例化、初始化、处理请求以及服务结束。这个生存期由javax.servlet.Servlet接口的init,service和destroy方法表达。

                  17.关于hibernate:
                  1)在hibernate中，在配置文件呈标题一对多，多对多的标签是什么；
                  2)Hibernate的二级缓存是什么；
                  3)Hibernate是如何处理事务的；
                  答：1）一对多的标签为：<one-to-many> ；多对多的标签为：<many-to-many>；
                  2）sessionFactory的缓存为hibernate的二级缓存；
                  3）Hibernate的事务实际上是底层的JDBC Transaction的封装或者是JTA
                  Transaction的封装；默认情况下使用JDBCTransaction。

                  18.JSP中两种 include方式的区别；(Web)
                  答：动态include用jsp:include动作实现，它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数；静态include用<%@include
                  %>指令实现，适用于包含静态页面

                  19.javascipt的优缺点和内置对象；(Web)
                  答：关于javascipt：
                  1）优点：简单易用，与Java有类似的语法，可以使用任何文本编辑工具编写，只需要浏览器就可执行程序，并且事先不用编译，逐行执行，无需进行严格的变量声明，而且内置大量现成对象，编写少量程序可以完成目标；
                  2）缺点：不适合开发大型应用程序
                  3）javascript有11种内置对象：
                  Array,String,Date,Math,Boolean,Number,Function,Global,Error,RegExp,Object

                  20.get和post的区别？(Web)
                  答：form中的get和post方法，在数据传输过程中分别对应了HTTP协议中的GET
                  和POST方法。二者主要区别如下：
                   1）Get是用来从服务器上获得数据，而Post是用来向服务器上传递数据；
                   2）Get将表单中数据的按照variable=value的形式，添加到action所指向的URL
                  后面，并且两者使用“?”连接，而各个变量之间使用“&”连接；Post是将表单中的数据放在form的数据体中，按照变量和值相对应的方式，传递到action所指向URL；
                   3）Get是不安全的，因为在传输过程，数据被放在请求的URL中，
                  Post的所有操作对用户来说都是不可见的；
                   4）Get传输的数据量小，这主要是因为受URL长度限制，而Post可以传输大量
                  的数据，所以在上传文件只能使用Post；
                   5）Get限制form表单的数据集必须为ASCII字符，而Post支持整个ISO10646
                  字符集；
                   6）Get是form的默认方法。

                  21.JSP的九个内置对象及其作用、JSP的动作；(Web)
                  答:JSP共有以下9种基本内置组件：
                  1)request ：用户端请求，此请求会包含来自GET/POST请求的参数
                  2)response ：网页传回用户端的回应
                  3)pageContext ：网页的属性是在这里管理
                  4)session ：与请求有关的会话期 ，可以存储用户的状态信息
                  5)application ：servlet 正在执行的内容 ，可用于查找有关servlet引擎和环境的信息
                  6)out ：用来传送回应的输出
                  7)config ：servlet的构架部件 ，用于存取servlet实例的初始化参数
                 page ：JSP网页本身
                  9)exception ：针对错误网页，未捕捉的例外；
                  JSP共有以下6种基本动作：
                  1)jsp:include：在页面被请求的时候引入一个文件。
                  2)jsp:useBean：寻找或者实例化一个JavaBean。
                  3)jsp:setProperty：设置JavaBean的属性。
                  4)jsp:getProperty：输出某个JavaBean的属性。
                  5)jsp:forward：把请求转到一个新的页面。
                  6)jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记

                  22.写出你熟悉的开源框架以及各自的作用。
                  答：框价：hibernate,spring,struts.
                    Hibernate主要用于数据持久化；
                     Spring 的控制反转能起到解耦合的作用；
                     Struts 主要用于流程控制；
                  服务器类：Apache Tomcat Jboss等

                  24.简述你对Struts框架的理解；(Web)
                  答：Struts是采用Java Servlet/JavaServer
                  Pages技术，开发Web应用程序的开放源码的framework。
                  采用Struts能开发出基于MVC(Model-View-Controller)设计模式的应用构架；Struts有如下的主要功能：

                  1)包含一个controller servlet，能将用户的请求发送到相应的Action对象。
                  2)JSP自由tag库，并且在controller servlet中提供关联支持，帮助开发员创建交互式表单应用。
                  3)提供了一系列实用对象：XML处理、通过Java reflection
                  APIs自动处理JavaBeans属性、国际化的提示和消息。

                  25.JSP标签的作用?如何定义；(Web)
                  答：作用:分离jsp页面的内容和逻辑；
                  业务逻辑开发者可以创建自定义标签；
                  封装业务逻辑；
                  可重用并且易维护；
                  易于手工修改、易于工具维护；
                  提供简洁的语法；
                  定义:
                  写标签处理器；
                  写tld文件；
                  讲标签处理器和tld文件放到同一个包里面；
                  把jsp页面和标签库配置部署在一起。

                  26.写一个自定义标签；(Web)
                  答：代码如下：
                  import javax.servlet.jsp.tagext.*;
                  import javax.servlet.jsp.*;
                  import java.io.*;
                  public class TimeTag extends SimpleTagSupport{
                  private boolean isServer = true;
                  public void setServer(boolean isServer){
                  this.isServer = isServer;
                  }
                  public void doTag() throws JspException, IOException{
                  JspWriter out = getJspContext().getOut();
                  if(isServer) {
                  out.println(new java.util.Date());
                  }else{
                  out.println("<script language=\"javascript\">");
                  out.println("document.write(new Date());");
                  out.println("</script>");
                  }
                  }
                  }

                  27.写出熟悉的JSTL标签；(Web)
                  答：如下：
                  <c:if>
                  <c:forEach>
                  <c:set>
                  <c:import>
                  <c:redirect>

                  28.说出struts中的标签；(Web)
                  答：如下：
                  <bean:message  />           <html:errors />
                  <bean:include  />             <html:messages />
                  <bean:define />               <html:html>
                  <bean:write />                <html:form>
                  <bean:resource />             <html:link>
                  <bean:cokkie />                <html:text>
                  <bean:heder />                <logic:present />
                  <bean:parameter />            <logic:equal />
                  <bean:size />

                  29.如何从form表单中得取checkbox的值；(Web)
                  答：可在页面把checkbox的name属性取同一个，value属性取每个条目的id,后台用getParamter(“name”)能取到checkbox的一组值。

                  30.简述HttpSession的作用、使用方法，可以用代码说明。（时间3分钟）(Web)
                  答：HttpSession中可以跟踪并储存用户信息，把值设置到属性中，有2个方法：setAttribute(),getAttrribute()；
                  例如：在一个方法中用session.setAttribute(“student”,student);在session中设置一个属性名为student,值为一个名为student的对象。而后可在同一session范围内用getAttribute(“student”)取出该属性，得到student对象。

                  31.找出程序中的问题，并写出理由（5分钟）(Web)
                  import javax.servlet.*;
                  import javax.servlet.http.*;
                  import javax.sql.*;
                  import javax.naming.*;
                  import java.sql.*;
                  import java.io.IOException;

                  public class TestServlet extends HttpServlet{
                  private Connection conn;
                  protected void doGet(HttpServletRequest
                  req,HttpServletResponse res)
                  throws IOException,ServletException{
                  try{
                  Class.forName(“COM.ibm.db2.jdbc.app.DB2Driver”);
                  conn =
                  DriverManager.getConnection(“jdbc:db2:mydb”,”db2”,”db2”);
                  PreparedStatement stmt = conn.prepareStatement("delete from
                  mytb where id=?");
                  for (int i=0;i<5;i++) {
                  stmt.setInt(1,i);
                  stmt.executeUpdate();
                  }
                  conn.close();
                  }
                  catch (Exception ex)
                  {
                  ex.printStackTrace();
                  }
                  }
                  }
                  答：其中doGet方法的访问限制修饰符应该为public，因为protected修饰的方法只能被
                  同包中的类或其子类才可访问，这将导致web容器无法调用该方法。

                  32.写出Singleton模式。写出你熟悉的设计模式；(OOA/D)
                  答：有两种方式：
                  第一种方法：
                  public class Singleton{
                  private Singleton(){}
                  private static Singleton singleton=new Singleton();
                  public static Singleton getInstance(){
                  return singleton;
                  }
                  }
                  第二种方法：
                  public class Singleton{
                  private Singleton(){}
                  private static Singleton singleton=null;
                  public static Singleton getInstance(){
                  If(singleton==null) singleton=new
Singleton();//需要的时候才new,节省空间。
                  return singleton;
                  }
                  }
                  一般采用第一种方式。

                  33.设计模式有哪些？
                  答：包括单类模式，工厂模式，MVC模式，观察者模式，代理模式，试配器模式，门面模式等等共23种之多。

                  34.UML分析设计中常用的几种图；(UML)
                  答：用例图，静态图（包括类图、对象图、和包图）、行为图、交互图（顺序图、合作图），实现图。

                  35.你对软件开发中迭代的含义的理解；(UML)
                  答：软件开发中，各个开发阶段不是顺序执行的，应该是并行执行,也就是跌代的意思。这样对于开发中的需求变化，及人员变动都能得到更好的适应。

                  36.统计一篇文章中单词个数（c++）；
                  答：代码如下：
                  #include<iostream>
                  #include<fstream>
                  using namespace std;

                  int main(){
                  ifstream fin("t.txt");
                  if(!fin){
                  cout<<"can't open file"<<endl;
                  return -1;
                  }
                  int count = 0;
                  char buf[256];
                  memset(buf, 0, 256);
                  while(1){
                  fin2>>buf;
                  if(fin2.eof())
                  break;
                  count++;
                  }
                  cout<<"The number of the words is : "<<count<<endl;
                  fin2.close();
                  return 0;
                  }

                  37.XML的两种解析方式和定义方式；（XML）
                  答：解析方式有：
                  DOM：处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问；
                  SAX：不同于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问。
                  定义方式：DTD(文档类型定义)和Schema。


三、较难：（共9题）
                  1.线程中为什么不推荐使用stop；(Core Java)
                  答：此方法已过时。 该方法具有固有的不安全性。用 Thread.stop
                  来终止线程将释放它已经锁定的所有监视器（作为沿堆栈向上传播的未检查 ThreadDeath
                  异常的一个自然后果）。如果以前受这些监视器保护的任何对象都处于一种不一致的状态，则损坏的对象将对其他线程可见，这有可能导致任意的行为。stop
                  的许多使用都应由只修改某些变量以指示目标线程应该停止运行的代码来取代。目标线程应定期检查该变量，并且如果该变量指示它要停止运行，则从其运行方法依次返回。如果目标线程等待很长时间（例如基于一个条件变量），则应使用
                  interrupt 方法来中断该等待。

                  2.编程题：设有ｎ个人依围成一圈，从第１个人开始报数，数到第ｍ个人出列，然后从出列的下一个人开始报数，数到第ｍ个人又出列，…，如此反复到所有的人全部出列为止。设ｎ个人的编号分别为1，2，…，n，打印出出列的顺序；要求用java实现。(Core
                  Java)
                  答：代码如下：
                  package test;
                  public class CountGame {
                  private static boolean same(int[] p,int l,int n){
                  for(int i=0;i<l;i++){
                  if(p[i]==n){
                  return true;
                  }
                  }
                  return false;
                  }
                  public static void play(int playerNum, int step){
                  int[] p=new int[playerNum];
                  int counter = 1;
                  while(true){
                  if(counter > playerNum*step){
                  break;
                  }
                  for(int i=1;i<playerNum+1;i++){
                  while(true){
                  if(same(p,playerNum,i)==false) break;
                  else i=i+1;
                  }
                  if(i > playerNum)break;
                  if(counter%step==0){
                  System.out.print(i + " ");
                  p[counter/step-1]=i;
                  }
                  counter+=1;
                  }
                  }
                  System.out.println();
                  }
                  public static void main(String[] args) {
                  play(10, 7);
                  }
                  }

                  3.抽象方法可以是native？可以是同步的吗？(Core Java)
                  答：都不能。

                  4.JDBC，Hibernate分页怎样实现？(JDBC)
                  答：方法分别为：
                  1) Hibernate的分页：
                  Query query = session.createQuery("from Student");
                  query.setFirstResult(firstResult);//设置每页开始的记录号
                  query.setMaxResults(resultNumber);//设置每页显示的记录数
                  Collection students = query.list();
                  2) JDBC的分页：根据不同的数据库采用不同的sql分页语句
                  例如: Oracle中的sql语句为: "SELECT * FROM (SELECT a.*, rownum r FROM
                  TB_STUDENT) WHERE r between 2 and 10" 查询从记录号2到记录号10之间的所有记录

                  5.JDO是什么?
                  答：JDO是java data
                  object的简称，是Java对象持久化的新的规范，JDO提供了透明的对象存储，因此对开发人员来说，存储数据对象完全不需要额外的代码（如JDBC
                  API的使用）。这些繁琐的例行工作已经转移到JDO产品提供商身上，使开发人员解脱出来，从而集中时间和精力在业务逻辑上。另外，JDO很灵活，因为它可以在任何数据底层上运行。JDBC只是面向关系数据库（RDBMS)，JDO更通用，提供到任何数据底层的存储功能，比如关系数据库、文件、XML以及对象数据库（ODBMS）等等，使得应用可移植性更强。

                  6.请写出spring中I0C的三种实现机制。(Spring)
                  答：三种机制为：通过setter方法注入、通过构造方法注入和接口注入。

                  7.EJB的事务是如何实现的？何时进行回滚；(EJB)
                  答：是通过使用容器或Bean自身管理事务的；
                  当产生一个系统异常时容器就自动回滚事务。

                  8.写一个方法1000的阶乘。(C++)
                  答：C++的代码实现如下：
                  #include <iostream>
                  #include <iomanip>
                  #include <vector>
                  using namespace std;

                  class longint {
                  private:
                  vector<int> iv;
                  public:
                  longint(void) { iv.push_back(1); }
                  longint& multiply(const int &);
                  friend ostream& operator<<(ostream &, const longint &);
                  };
                  ostream& operator<<(ostream &os, const longint &v) {
                  vector<int>::const_reverse_iterator iv_iter = v.iv.rbegin();
                  os << *iv_iter++;
                  for ( ; iv_iter < v.iv.rend(); ++iv_iter) {
                  os << setfill('0') << setw(4) << *iv_iter;
                  }
                  return os;
                  }
                  longint& longint::multiply(const int &rv) {
                  vector<int>::iterator iv_iter = iv.begin();
                  int overflow = 0, product = 0;
                  for ( ; iv_iter < iv.end(); ++iv_iter) {
                  product = (*iv_iter) * rv;
                  product += overflow;
                  overflow = 0;
                  if (product > 10000) {
                  overflow = product / 10000;
                  product -= overflow * 10000;
                  }
                  *iv_iter = product;
                  }
                  if (0 != overflow) {
                  iv.push_back(overflow);
                  }
                  return *this;
                  }
                  int main(int argc, char **argv) {
                  longint result;
                  int l = 0;
                  if(argc==1){
                  cout << "like: multiply 1000" << endl;
                  exit(0);
                  }
                  sscanf(argv[1], "%d", &l);
                  for (int i = 2; i <= l; ++i) {
                  result.multiply(i);
                  }
                  cout << result << endl;
                  return 0;
                  }

                  9.怎么处理XML的中文问题；（XML）
                  答：示例代码如下：
                  package xml;

                  import javax.xml.parsers.DocumentBuilder;
                  import javax.xml.parsers.DocumentBuilderFactory;
                  import javax.xml.transform.OutputKeys;
                  import javax.xml.transform.Transformer;
                  import javax.xml.transform.TransformerFactory;
                  import javax.xml.transform.dom.DOMSource;
                  import javax.xml.transform.stream.StreamResult;
                  import org.w3c.dom.Document;
                  import org.w3c.dom.Element;

                  public class DOMTest {
                  private String outFile = "c:\\test.xml";

                  public static void main(String args[]) {
                  DOMTest test = new DOMTest();
                  try {
                  DocumentBuilder builder = DocumentBuilderFactory.newInstance()
                  .newDocumentBuilder();
                  Document doc = builder.newDocument();
                  Element root = doc.createElement("Tarena");
                  Element zhang = doc.createElement("张");
                  zhang.appendChild(doc.createTextNode("我是张丽芳"));
                  root.appendChild(zhang);
                  doc.appendChild(root);
                  Transformer transformer = TransformerFactory.newInstance()
                  .newTransformer();
                  //设置xml的编码
                  transformer.setOutputProperty(OutputKeys.ENCODING, "gb2312");
                  //设置缩近格式
                  transformer.setOutputProperty(OutputKeys.INDENT, "yes");
                  transformer.transform(new DOMSource(doc),
                  new StreamResult(test.outFile));
                  } catch (Exception e) {
                  System.out.println(e.getMessage());
                  }
                  }
                  }








因为是全英文的模块描述,大概意思是:
                  /**补充完该类,不修改main方法,使得get()方法可以取到值*/

                  import java.util.*;

                  public class StudentTest {

                  private static final class Student{
                  private String name;

                  public Student(String name) {
                  this.name = name;
                  }
                  }

                  public static void main(String[] args){
                  Map p=new HashMap();
                  p.put(new Student("lily"), "sister");
                  System.out.println(p.get("lily"));
                  }
                  }
                  /**使IsSafe方法返回值是true,修改second方法,但不能试用sleep/pool,要效率第一*/

                  public class ThreadTest {

                  private boolean sat=false;

                  public void first(){
                  sat=true;
                  }
                  public void second(){

                  }
                  public boolean isSafe(){
                  return sat;
                  }
                  public static void main(String[] arg[]){

                  final ThreadTest b=new ThreadTest();
                  (new Thread(){
                  public void run(){
                  b.second();
                  }
                  }).start();
                  (new Thread(){
                  public void run(){
                  b.first();
                  }
                  }).start();
                  }
                  }
                  /**考虑下面程序对软件大环境的影响(本人不离解模块的描述什么意思,经理告诉我的最后)*/
                  import java.io.FileInputStream;

                  public class TestInputStream {

                  public static void main(String[] args){
                  FileInputStream in=new FileInputStream(f);
                  int i=in.read();
                  in.close();
                  }
                  }

评论

1 楼 zy19982004 2011-03-22  

6.以下二条语句返回值为true的有：(Core Java)
                  答：A B 
                  A：“beijing”==“beijing”；
                  B：“beijing”.equalsIgnoreCase（new String（“beijing”））；

B true??