java面试题

1 、java中StringBuffer和String有什么区别阿

        其实很简单,就是一个变量和常量的关系
         StringBuffer对象的内容可以修改
         而String对象一旦产生后就不可以被修改,重新赋值其实是两个对象

        比较
         StringBuffer str = new StringBuffer("a");
        str.append("bc");

        String str2 = "a";
           str2 = str2 + "bc";

         str引用的一直是同一对象
          而str2引用的在两句中是完全不同的对象

          StringBuffer是可以改变字符串长度的,而String则不可以   
          若要String改变值,需要改变String变量的引用

 2 set、 map、 list的区别

            set     --其中的值不允许重复,无序的数据结构   
            list--其中的值允许重复,因为其为有序的数据结构   
            map--成对的数据结构,健值必须具有唯一性  

3 抽象类和接口的区别

   1.接口可以多重继承   ,抽象类不可以    
  2.接口定义方法,不给实现;而抽象类可以实现部分方法  
  3.接口中基本数据类型的数据成员,都默认为static和final,抽象类则不是  
  如果事先知道某种东西会成为基础类,  
  那么第一个选择就是把它变成一个接口。  
  只有在必须使用方法定义或者成员变量的时候,才应考虑采用抽象类。

 

----------------------------

补充

其实abstract class表示的是"is a"关系,interface表示的是"like a"关系,大家在选择时可以作为一个依据,当然这是建立在对问题领域的理解上的,比如:如果我们认为AlarmDoor在概念本质上是报警器,同时又具有Door的功能,那么上述的定义方式就要反过来了。 
-----------

2007-09-20日又面试,遇到问题,谨记

java.io.Reader 和 java.io.InputStream 组成了 Java 输入类。Reader 用于读入16位字符,也就是 Unicode 编码的字符;而 InputStream 用于读入 ASCII 字符和二进制数据。

Java 中,有不同类型的 Reader 输入流对应于不同的数据源:
    FileReader 用于从文件输入;
    CharArrayReader 用于从程序中的字符数组输入;
    StringReader 用于从程序中的字符串输入;
    PipedReader 用于读取从另一个线程中的 PipedWriter 写入管道的数据。
相应的也有不同类型的 InputStream 输入流对应于不同的数据源:FileInputStream,ByteArrayInputStream,StringBufferInputStream,PipedInputStream。另外,还有两种没有对应 Reader 类型的 InputStream 输入流:
    Socket 用于套接字;
    URLConnection 用于 URL 连接。
这两个类使用 getInputStream() 来读取数据。

-----------------------------

java线程的实现 通过两种方式 : Thread类和Runnable接口

 要记住的一件重要的事情是main() 函数也是一个线程,并可用来做有用的工作。程序员只有在需要多个线程时才需要创建新的线程。
  Thread 类
  Thread 类是一个具体的类,而非抽象类.该类封装了线程的行为。要创建一个线程,必须创建一个从 Thread 类继承的新类。程序员必须覆盖 Thread 的 run() 函数来完成有用的工作。用户并不直接调用此函数;而是必须调用 Thread 的 start() 函数,该函数再调用 run()。下面的代码说明了它的用法:
  创建两个新线程:

import java.util.*;

class TimePrinter extends Thread {
 int pauseTime;
 String name;
 public TimePrinter(int x, String n) {
  pauseTime = x;
  name = n;
 }

 public void run() {
  while(true) {
   try {
    System.out.println(name + ":" + new    
           Date(System.currentTimeMillis()));
    Thread.sleep(pauseTime);
   } catch(Exception e) {
    System.out.println(e);
   }
  }
 }

 static public void main(String args[]) {
  TimePrinter tp1 = new TimePrinter(1000, "Fast Guy");
  tp1.start();
  TimePrinter tp2 = new TimePrinter(3000, "Slow Guy");
  tp2.start();

 }
}

  在本例中,我们可以看到一个简单的程序,它按两个不同的时间间隔(1 秒和 3 秒)在屏幕上显示当前时间。这是通过创建两个新线程来完成的,包括 main() 共三个线程。但是,因为有时要作为线程运行的类可能已经是某个类层次的一部分,所以就不能再按这种机制创建线程。虽然在同一个类中可以实现任意数量的接口,但 Java 编程语言只允许一个类有一个父类。同时,某些程序员避免从 Thread 类导出,因为它强加了类层次。对于这种情况,就要 runnable 接口。

  Runnable 接口
  此接口只有一个函数,run(),此函数必须由实现了此接口的类实现。但是,就运行这个类而论,其语义与前一个示例稍有不同。我们可以用 runnable 接口改写前一个示例。
  创建两个新线程而不强加类层次:
import java.util.*;

class TimePrinter implements Runnable {
 int pauseTime;
 String name;
 public TimePrinter(int x, String n) {
  pauseTime = x;
  name = n;
 }

 public void run() {
  while(true) {
   try {
    System.out.println(name + ":" + new Date(System.currentTimeMillis()));
    Thread.sleep(pauseTime);
   } catch(Exception e) {
    System.out.println(e);
   }
  }
 }

 static public void main(String args[]) {
  Thread t1 = new Thread(new TimePrinter(1000, "Fast Guy"));
  t1.start();
  Thread t2 = new Thread(new TimePrinter(3000, "Slow Guy"));
  t2.start();
 }
}

  请注意,当使用 runnable 接口时,不能直接创建所需类的对象并运行它;必须从 Thread 类的一个实例内部运行它。许多程序员更喜欢 runnable 接口,因为从 Thread 类继承会强加类层次。
  synchronized 关键字
  到目前为止,我们看到的示例都只是以非常简单的方式来利用线程。只有最小的数据流,而且不会出现两个线程访问同一个对象的情况。但是,在大多数有用的程序中,线程之间通常有信息流。试考虑一个金融应用程序,它有一个 Account 对象,如下例中所示:
  一个银行中的多项活动:
public class Account {
 String holderName;
 float amount;
 public Account(String name, float amt) {
 holderName = name;
 amount = amt;
}

public void deposit(float amt) {
 amount += amt;
}

public void withdraw(float amt) {
 amount -= amt;
}

public float checkBalance() {
 return amount;
}
}

  在此代码样例中潜伏着一个错误。如果此类用于单线程应用程序,不会有任何问题。但是,在多线程应用程序的情况中,不同的线程就有可能同时访问同一个 Account 对象,比如说一个联合帐户的所有者在不同的 ATM 上同时进行访问。在这种情况下,存入和支出就可能以这样的方式发生:一个事务被另一个事务覆盖。这种情况将是灾难性的。但是,Java 编程语言提供了一种简单的机制来防止发生这种覆盖。每个对象在运行时都有一个关联的锁。这个锁可通过为方法添加关键字 synchronized 来获得。这样,修订过的 Account 对象(如下所示)将不会遭受像数据损坏这样的错误:
  对一个银行中的多项活动进行同步处理:
public class Account {
 String holderName;
 float amount;
 public Account(String name, float amt) {
 holderName = name;
 amount = amt;
}

public synchronized void deposit(float amt) {
 amount += amt;
}

public synchronized void withdraw(float amt) {
 amount -= amt;
}

public float checkBalance() {
 return amount;
}
}

  deposit() 和 withdraw() 函数都需要这个锁来进行操作,所以当一个函数运行时,另一个函数就被阻塞。请注意, checkBalance() 未作更改,它严格是一个读函数。因为 checkBalance() 未作同步处理,所以任何其他方法都不会阻塞它,它也不会阻塞任何其他方法,不管那些方法是否进行了同步处理.


阅读更多
上一篇jsp面试题
下一篇java抽象类和接口的区别
想对作者说点什么? 我来说一句

Java 面试题 Java 面试题

2009年12月20日 127KB 下载

Java面试题 Java面试题

2009年12月05日 141KB 下载

Java面试题

2017年09月22日 22.93MB 下载

JAVA面试题(下).pdf

2017年09月01日 3.57MB 下载

javamianshiti

2010年01月31日 121KB 下载

java面试题java面试题java面试题

2008年11月16日 405KB 下载

java面试题 java面试题

2010年08月06日 33KB 下载

JAVA 面试题

2008年11月29日 137KB 下载

JAVA面试题JAVA面试题

2011年04月20日 757KB 下载

没有更多推荐了,返回首页

关闭
关闭