某公司面试题目

最近去某公司面试，做了一些题目，很多不会，写下来供参考一下：

 

1，overload和overided的区别？

override（重写）
1、方法名、参数、返回值相同。
2、子类方法不能缩小父类方法的访问权限。
3、子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。
4、存在于父类和子类之间。
5、方法被定义为final不能被重写。
overload（重载）
1、参数类型、个数、顺序至少有一个不相同。  
2、不能重载只有返回值不同的方法名。
3、存在于同类中。

 

2，一些代码的输出结果：

 

public static void print(int[] array,int i)

{

            try{

                

                       System.out.println("arry["+i+"]="+array[i]);

                      } 

                finally{

 

                      System.out.println("---");

                    }

}

 

 

public static void main(String[] arrg)

{

 

                  int[]  arry = new  int[3] ;

 

             try{

 

                for( int i=0;;i++)

                  {

                        print(arry,i);

                          }

                 }

                catch(Exception e)

              {

                e.printStackTrace();

               }

              finally{

                     System.out.println("what is up?");

                 }

}  

 

output:

 

arry[0]=0
---
arry[1]=0
---
arry[2]=0
---
---
java.lang.ArrayIndexOutOfBoundsException: 3
 at testOracle.print(testOracle.java:9)
 at testOracle.main(testOracle.java:33)
what is up?

 

3,Arraylist,Vector,ArrayLinked的区别

 

一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程不安全的，不是同步的
二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半

 ArrayLinked是用链表实现的数组，顺序访问速度比较快。

Arraylist适合于随机访问。

 

4，jms支持那两种消息模型？

1、P2P模型
在P2P模型中，有下列概念：消息队列(Queue)、发送者(Sender)、接收者(Receiver)。每个消息都被发送到一个特定的队列，接收者从队列中获取消息。队列保留着消息，直到它们被消费或超时。
 每个消息只有一个消费者(Consumer)（即一旦被消费，消息就不再在消息队列中）
 发送者和接收者之间在时间上没有依赖性，也就是说当发送者发送了消息之后，不管接收者有没有正在运行，它不会影响到消息被发送到队列。
 接收者在成功接收消息之后需向队列应答成功 
 2、Pub/Sub模式
在Pub/Sub模型中，有下列概念： 主题（Topic）、发布者（Publisher）、订阅者（Subscriber）。客户端将消息发送到主题。多个发布者将消息发送到Topic，系统将这些消息传递给多个订阅者。
 每个消息可以有多个消费者
 发布者和订阅者之间有时间上的依赖性。针对某个主题(Topic)的订阅者，它必须创建一个订阅之后，才能消费发布者的消息，而且，为了消费消息，订阅者必须保持运行的状态。
当然，为了缓和这种严格的时间相关性，JMS允许订阅者创建一个可持久化的订阅。这样，即使订阅者没有被激活（运行），它也能接收到发布者的消息。
如果你希望发送的消息可以不被做任何处理、或者被一个消费者处理、或者可以被多个消费者处理的话，那么可以采用Pub/Sub模型。

 

5，ejb 的home interface和 remote interface作用是什么?

remote接口定义了业务方法，用于EJB客户端调用业务方法。
home接口是EJB工厂用于创建和移除查找EJB实例

 

6,ebj findejb list ejb?

 

7,RMI远程调用的过程？

1. 创建远程接口及声明远程方法（HelloInterface.java）
2. 实现远程接口及远程方法（继承UnicastRemoteObject）(Hello.java)
3. 启动RMI注册服务，并注册远程对象（HelloServer.java）
4. 客户端查找远程对象，并调用远程方法（HelloClient）
5. 执行程序：启动服务HelloServer；运行客户端HelloClient进行调用

 

8，什么是事务？acid分别是什么？ 

事务是作为单个逻辑工作单元执行的一系列操作。一个逻辑工作单元必须有四个属性，称为原子性、一致性、隔离性和持久性 (ACID) 属性，只有这样才能成为一个事务。

原子性

事务必须是原子工作单元；对于其数据修改，要么全都执行，要么全都不执行。

一致性

事务在完成时，必须使所有的数据都保持一致状态。在相关数据库中，所有规则都必须应用于事务的修改，以保持所有数据的完整性。事务结束时，所有的内部数据结构（如 B 树索引或双向链表）都必须是正确的。

隔离性

由并发事务所做的修改必须与任何其他并发事务所做的修改隔离。事务识别数据时数据所处的状态，要么是另一并发事务修改它之前的状态，要么是第二个事务修改它之后的状态，事务不会识别中间状态的数据。这称为可串行性，因为它能够重新装载起始数据，并且重播一系列事务，以使数据结束时的状态与原始事务执行的状态相同。

持久性

         事务完成之后，它对于系统的影响是永久性的。该修改即使出现系统故障也将一直保持。

9，jdbc数据库驱动有几种方式？

（1）JDBC-ODBC桥加ODBC驱动程序

  JavaSoft桥产品利用ODBC驱动程序提供JDBC访问。注意，必须将ODBC二进制代码（许多情况下还包括数据库客户机代码）加载到使用该驱动程序的每个客户机上。因此，这种类型的驱动程序最适合于企业网（这种网络上客户机的安装不是主要问题），或者是用Java编写的三层结构的应用程序服务器代码。

  （2）本地API

  这种类型的驱动程序把客户机API上的JDBC调用转换为Oracle、Sybase、Informix、DB2或其它DBMS的调用。注意，象桥驱动程序一样，这种类型的驱动程序要求将某些二进制代码加载到每台客户机上。

  （3）JDBC网络纯Java驱动程序

  这种驱动程序将JDBC转换为与DBMS无关的网络协议，之后这种协议又被某个服务器转换为一种DBMS协议。这种网络服务器中间件能够将它的纯Java客户机连接到多种不同的数据库上。所用的具体协议取决于提供者。通常，这是最为灵活的JDBC驱动程序。有可能所有这种解决方案的提供者都提供适合于Intranet用的产品。为了使这些产品也支持Internet访问，它们必须处理Web所提出的安全性、通过防火墙的访问等方面的额外要求。几家提供者正将JDBC驱动程序加到他们现有的数据库中间件产品中。

  （4）本地协议纯Java驱动程序

  这种类型的驱动程序将JDBC调用直接转换为DBMS所使用的网络协议。这将允许从客户机机器上直接调用DBMS服务器，是Intranet访问的一个很实用的解决方法。由于许多这样的协议都是专用的，因此数据库提供者自己将是主要来源，有几家提供者已在着手做这件事了。

 

10，jta和jts分别是什么？

Java ^TM2 Platform, Enterprise Edition(J2EE)简化了分布式事务管理应用程序的编写。J2EE包括了两套规范，用来支持分布式的事务，一种是Java Transaction API(JTA)，另一种是Java Transaction Service(JTS)。JTA是一种高层的，与实现无关的，与协议无关的API，应用程序和应用服务器可以使用JTA来访问事务。JTS则规定了支持JTA的事务管理器的实现规范，在高层API之下实现了OMG Object Transaction Service(OTS) 1.1规范的Java映射。JTS使用Internet Inter-ORB Protocol(IIOP)来传播事务。作为J2EE平台实现的一部分，SUN实现了一个支持JTS的事务管理器，同时还实现了JTA。

 

11，unit test .system test ,check-in test ,depress test分别是什么？

 

12，用你熟悉的linu写一个脚本，查找包含tranction或Tranction的他txt文件 。

 

find -name '*tranction*.txt' or '*Tranction*.txt'

 

13，用junit写单元测试代码。

/**
*
* 测试对象
* User: leizhimin
* Date: 2008-3-13 14:58:58
*/
public class Calcuator {
    public double add(double n1, double n2) {
        return n1 + n1;
    }
}     

 

/**
* 测试用例
* File: TestCalcuator.java
* User: leizhimin
* Date: 2008-3-13 15:00:17
*/
public class TestCalcuator extends TestCase {
    public void testAdd(){
        Calcuator calcuator=new Calcuator();
        double result=calcuator.add(1,2);
        assertEquals(3,result,0);
    }

}

 

/**
* 测试用例
* File: TestCalcuator2.java
* User: leizhimin
* Date: 2008-3-13 16:13:29
*/
public class TestCalcuator2 extends TestCase  {
    public void testAdd(){
        Calcuator calcuator=new Calcuator();
        double result=calcuator.add(1,2);
        assertEquals(3,result,0);
    }
}

 

/**
* 测试单元
* File: TestAll.java
* User: leizhimin
* Date: 2008-3-13 16:17:10
*/
public class TestAll extends TestSuite {
    public static Test suite() {
        TestSuite suite = new TestSuite("TestSuite Test");
        suite.addTestSuite(TestCalcuator.class);
        suite.addTestSuite(TestCalcuator2.class);
        return suite;
    }
    public static void main(String args[]){
        TestRunner.run(suite());
    }
}

 

 

当面提问的问题有：

 

1，写一个银行账户的类，需要有存取钱的功能？

 

public Class User

{

 

          private String name=null;

 

          private int cardNum =0;

 

 

          private  int posiNum =0;

 

 

            public  int QueryCount()

          {

 

                   return posiNum ;

           }

 

          public boolean withDrawl(int out)

         {

 

                 if(out>posiNum )

                   return false;

                  posiNum = posiNum  - out;

 

                    return true;

         }

 

         public int save(int saveNum)

      {

            posiNum = posiNum  + saveNum;

           

          return posiNum

      }

 

 

}

 

   写出来后，又提了一个需求，如何保证可以同步操作。于是又作了一下修改。

 

public Class User

{

 

          private String name=null;

 

          private int cardNum =0;

 

 

          private  int posiNum =0;

 

 

            public  int QueryCount()

          {

 

                   return posiNum ;

           }

 

          public synchronized  boolean withDrawl(int out)

         {

 

                 if(out>posiNum )

                   return false;

                  posiNum = posiNum  - out;

 

                    return true;

         }

 

         public synchronized  int save(int saveNum)

      {

            posiNum = posiNum  + saveNum;

           

          return posiNum

      }

 

 

}

 

之后又提了一个问题，增加一个转帐的方法，需要保证线程安全

 

public void transfer(User a,User b,int num)

{

           //加锁

             a.withDrawl(num);

              b.save(num); 

         //解锁   

}

 

2，有两个类

 

   第一个：class1  ；第二类是：class2.

 

   class1的代码中有 class2 intance= new class2 ();

  class2的包路径已经放到classpath上，执行 java class1是否能正常执行。为什么？

 

答：可以 ，因为是同一个类加载器加载的

 

3，两个已经排好序的数组，其中一个数组有足以容纳另一个数组的位置，要求用最少的移动和空间来实现把短的数组

 

合并到长的数组中，结果必须是排好序的。时间复杂度是多少？

public class mixcture {
 
 
 public static void main(String[] args){
  
  
  int[] array1 ={2,3,5};
  int[] array2 = new int[20];
  array2[0]=4;
  array2[1]=5;
  array2[2]=8;
  array2[3]=10;
  
  int size1= array1.length;
  int size2 = array2.length;
  int real = 0;
  
 
  
  for(int i=0;i<size2;i++)
  {
   if(array2[i]==0)
   {
    real = i;
    break;
   }
  }
  
  int all = size1 + real;
  
  int stop = 0;
  
  int j = real-1;
  
  int cursor = j;
  
  for(int i = size1-1;i>=0;i--)   
  {
   cursor = j;
   for(j = cursor;j>=0;j--)
   {
    if(array1[i]>array2[j])
    {
     array2[all-1] = array1[i];
     all--;
     break;
    }else if(array1[i]==array2[j])
    {
     array2[all-1] = array1[i];
     array2[j]=0;
     all--;
     j--;
     break;
    }
    else
    {
     array2[all-1] = array2[j];
     array2[j]=0;
    }
    System.out.println("array2["+(all-1)+"]="+array2[all-1]);
    //System.out.println("array2["+(all-2)+"]="+array2[all-2]);
    System.out.println("stop="+stop);
    System.out.println("all="+all);
    System.out.println("i="+i);
    System.out.println("j="+j);
    all--;
    stop = i;
   }
  }
  
  if(stop>0)
  {
   for(int i=0;i<=stop;i++)
    array2[i] = array1[i];
  }
  
  for(int i=0;i<size2;i++)
  System.out.println(array2[i]);
  //System.out.println(array2.toString());
 }

}

 

时间复杂度是O(n^2)