. java.lang.nullpointerexception  ，异常的解释是"程序遇上了空指针"，
2. java.lang.classnotfoundexception  异常的解释是"指定的类不存在"，  
3. java.lang.arithmeticexception  这个异常的解释是"数学运算异常"，  
4. java.lang.arrayindexoutofboundsexception  异常的解释是"数组下标越界"，
5. java.lang.illegalargumentexception  这个异常的解释是"方法的参数错误"，

神之梦 发表于 2013-7-15 20:06
2，列举五个RuntimeException？

NullPointerException，UnknownTypeException,ClassCastException，SystemException, IllegalArgumentException

第3题

1. public class DoSomething implements Runnable {   
   
2.     private String name;   
   
3.    
   
4.     public DoSomething(String name) {   
   
5.         this.name = name;   
   
6.     }   
   
7.    
   
8.     public void run() {   
   
9.         for (int i = 0; i < 5; i++) {   
   
10.             for (long k = 0; k < 100000000; k++) ;   
    
11.             System.out.println(name + ": " + i);   
    
12.         }   
    
13.     }   
    
14. }   
    
15.    
    
16. 
    
17. public class TestRunnable {   
    
18.     public static void main(String[] args) {   
    
19.         DoSomething ds1 = new DoSomething("阿三");   
    
20.    
    
21.         Thread t1 = new Thread(ds1);   
    
22.         t1.start();   
    
23.     }   
    
24. }   
    

复制代码

字符流：Reader和 Writer
字节流：InputStream  ,OutputStream
flush():刷新流
close():关闭资源

第一题  面向对象的三大特征：封装，继承、多态

5，final修饰的类、方法、变量的特点？提示：变量分为基本数据类型的变量和引用型变量。

...........

final特点：
1、可以修饰类，方法，变量
2、被修饰的类不可被继承
3、被修饰的方法不可被覆盖
4、被修饰的变量：
基本数据类型值不可被改变
引用型变量不能被赋值，但是指向的对象可被改变。

第5题:
final修饰的类不可以被继承。
final修饰的方法不可以被覆盖。
final修饰的变量是一个常量。只能被赋值一次。

我发下题之后，之前发的题大家就不要答了，要赶在我发题之前写出答案！

final修饰的类：此类无法再衍生其他的子类
final修饰的方法：子类继承时不得覆盖此成员方法
final修饰的变量：此成员变量的值在初始化之后不可改变，也就是“常数”

第6题：重载和重写的区别？

5、用final修饰的类不能被继承；修饰的方法不能重写；修饰基本数据类型变量是常量，引用型变量是指向不变，但是指向内的内容可以更改

第6题:
重写是子类的方法覆盖父类的方法，要求方法名和参数都相同
重载是在同一个类中的两个或两个以上的方法，拥有相同的方法名，但是参数却不相同，方法体也不相同

覆盖==重写 叫法不同罢了
父类中有个print()方法，子类里面再一个print()方法，这

样子类对父类方法的重写。
重载是指在“一个类”中，你写了多个方法，他们的方法名

相同，但是参数不同，这样算是重载。比如你在一个类中写

了print()和print(String a)两个同名函数。
重载的要素是 方法原型相同 参数的个数，类型，顺序不同

与返回值无关

1、通过实现Runnable接口线程创建
2、通过继承Thread类创建线程
两种方法的比较：
直接继承Thread类，这种方法的特点是： 编写简单，可以直接操纵线程；但缺点也是很明显的，因为若继承Thread类，就不能再从其他类来继承了。
使用Runnable接口，这种方法的特点是： 可以将Thread类与所要处理的任务的类分开，形成清晰地模型；还可以从其他类继承。
另外，若直接继承Thread类，在类中this即指当前线程；
若使用Runnable接口，要在类中获得当前线程，必须使用Thread.currentThread()方法。

通过继承Thread类创建线程的简单代码
public class testThread {
        public static void main(String[] args) {
                Thread t = new MyThread();
                t.start();
        }
}
class MyThread extends Thread{
        public void run(){
                for(int i=0;i<100;i++){
                        System.out.println(" "+ i);
                }
        }

神之梦 发表于 2013-7-15 20:00
1，送分题，早起的鸟有虫吃：java面向对象的三个特征？

封装，继承，多态三个特征

前面白答了{:soso_e105:}

神之梦 发表于 2013-7-15 20:12
3，示例代码，如何启动一个线程。两种方法一种即可，并简述这两种方法？

（1）继承Thread类;(2)实现Runnable接口。
这两种方式无论哪种都要重写run()。另外，若是要继承Thread类，则要先明确该类是否已有明确的父类。由于JAVA不支持多继承，若是有，则不能继承Thread类；若是没有，在选择使用两种中哪一中时要考虑是否有操作到到实例属性，有才选继承Thread类。而继承Thread类后开启多线程后，各个线程是无法共享实例的属性的而实现Runnable接口由于是将实现Runnable接口的类的子类实例当成实参传递给Thread类的构造方法。所以运行的是该子类实例重写的RUN（），所以属性能被各个线程所共享。
以下是继承Thread类的示例：

1. public class ThreadDemo{
   
2.     public static void main(String[] args) {
   
3.         Demo d1 = new Demo("one");//创建了一个Thread类的子类对象
   
4.         Demo d2 = new Demo("two");
   
5.         d1.start();
   
6.         d2.start();
   
7. 
   
8.        for(int x=0; x<20; x++){
   
9.             System.out.println("main----"+x);
   
10.             }
    
11.        }
    
12. }
    
13. 
    
14. class Demo extends Thread{
    
15.        private String name;
    
16.        Demo(String name){
    
17.             this.name = name;
    
18.          }
    
19.        public void run(){
    
20.           System.out.println("name="+"-------------"+name);
    
21.         }
    
22. }

复制代码

6、
重载的条件：
1.必须在同一个类中
2.方法名必须相同
3.参数列表不能相同。
重写的条件：
1. 在不同的类中
2. 发生方法重写的两个方法返回值，方法名，参数列表必须完全一致
3. 子类抛出的异常不能超过父类相应的方法抛出的异常
4.子类方法的访问级别不能低于父类相应方法的访问级别（public，package，protected，private）
5.方法体不同