class TestThread{
  public static void main(String[] args){
    new Thread(new Runnable(){
      public void run(){

      System.out.println("This is a Thread");
      }

   }).start();   

}
}
/*
1.继承Thread类 2.实现Runnable接口
实现避免了单继承的局限性
*/

一实现Runnable接口  二 继承Thread类 用start方法开启线程

FileWriter, ByteArrayInputStream, PrintWriter ,OutputStream, RandomAccessFile

FileReader,FileInputStream,InputStreamReader,DataInputStream,BufferedReader

FileInputStream BufferedInputStream  FileOutputStream BufferedOutputStream  FileReader

赵海洋 发表于 2013-7-15 20:10
第三题：示例代码，如何启动一个线程。两种方法一种即可，并简述这两种方法？（只有四分钟答题时间，不要想 ...

1. class MyThread extends Thread  
   
2. {  
   
3.     private String name;  
   
4.     public MyThread(String name ){  
   
5.        this.name=name;  
   
6.     }  
   
7.     public void run(){  
   
8.         for(int i=0;i<10;i++){  
   
9.             System.out.println("线程"+name+i);  
   
10.         }  
    
11.       
    
12.     }  
    
13. }
    
14. class ThreadDemo{
    
15.         public static void main(String args[]){
    
16.                 MyThread t1=new MyThread("01");
    
17.                 MyThread t2=new MyThread("02");
    
18.                 t1.start();
    
19.                 t2.start();
    
20.         }
    
21. }

复制代码

另一种是实现Runnable接口，覆盖其中的run()方法。

1. package Thread;
   
2. 
   
3. public class FirstThread extends Thread {
   
4.            private int i;
   
5.       
   
6.            public void run(){          //重写线程的run方法
   
7.                   for(;i<100;i++){
   
8.                           
   
9.                           System.out.println(getName()+"  "+i);
   
10.                   }
    
11.                   
    
12.            }
    
13.           public static void main(String[] args){
    
14.                      for(int i=0;i<100;i++){
    
15.                                System.out.println(Thread.currentThread().getName()+" "+i);
    
16.                               
    
17.                                if(i==20){
    
18.                                        new FirstThread().start();
    
19.                                       
    
20.                                        new FirstThread().start();
    
21.                              }
    
22.                      }
    
23.                      
    
24.        
    
25.           }
    
26. 
    
27. }
    

复制代码

第一种是继承Thread方法再调用start()方法启动线程,
还有一种是继承Runnable接口，覆盖run方法

第一题：封装、继承、多态
第二题：
NullPointerException、IndexOutOfBoundsException、ClassCastException、SystemException、 IllegalArgumentException
第三题：
方法1：
class ThreadCreated
{
        public static void main(String[] args)
        {
                PrintedThread printedThread = new PrintedThread();
                printedThread.start();
        }
}


方法2：
class HelloJava implements Runnable
{
        void run()
        {
                while(true)
                {
                        System.out.println("Hello Java!");
                }
        }
}

class MultiThread
{
        public static void main(String[] args)
        {
                Runnable helloJava = new helloJava();
                Thread threadPrint = new thread(helloJava);
                while(true)
                {
                        System.out.println("Hello World!");
                }
        }
}


启动一个线程主要需要用到 Thread 类，创建一个 Thread 类对象，并调用 start 函数，就可以启动一个线程，线程执行 Thread 类中的 run 方法，如果在创建 Thread 类对象的时候，传递一个 Runnable 接口的实例，线程启动后执行 Runnable 接口实例的 run 方法。
第四题：
FileWriter FileReader BufferedWriter BufferedReader FileInputStream

赵海洋 发表于 2013-7-15 20:15
4，写出5个你用过的IO流？

InputStream
OutPutStream
BufferedOutputstream
BufferedInputstream
FileInputStream

赵海洋 发表于 2013-7-15 20:00
答题开始，第一题，送分题：面向对象的三个特征？（在线答题，四分钟后更新下一题，请大家抓紧！）答案直接 ...

面向对象的3大特征：封装，继承，多态

暂停十分钟，下一题20:30给出，前面四道题有来晚的可以继续答题，20:30以前的四道题只要答题就给分！！！！！

Reader， Write，InputStreamReader，BufferedReader， OutputStreamWriter

赵海洋 发表于 2013-7-15 20:05
第二题：列举五个RuntimeException？

第二题：列举五个RuntimeException？
AnnotationTypeMismatchException, ArithmeticException, ArrayStoreException, BufferOverflowException, BufferUnderflowException

封装、继承、多态

赵海洋 发表于 2013-7-15 20:10
第三题：示例代码，如何启动一个线程。两种方法一种即可，并简述这两种方法？（只有四分钟答题时间，不要想 ...

1、通过实现Runnable接口线程创建，定义一个类实现Runnable接口，创建Runnable接口实现类的对象。创建一个Thread类的对象，调用Thread对象的start()方法，启动线程
2、通过继承Thread类创建线程，首先定义一个类去继承Thread父类，重写父类中的run()方法。直接创建一个ThreadDemo2类的对象，调用start方法

1. public class ThreadDemo2 extends Thread {
   
2.        public void run() {}
   
3. public static void main(String[] args) {  
   
4.         new ThreadDemo2().start();      
   
5.     }  
   
6. }  

复制代码

Class MyThread implements Runable{
public
}

1、面向对象的三大特征：封装，继承、多态
1.封装：只隐藏对象的属性和实现细节，仅对外提供公共访问方式
好处：将变化隔离、便于使用、提高复用性、提高安全性
原则：将不需要对外提供的内容隐藏起来；把属性隐藏，提供公共方法对其访问
2.继承：提高代码复用性；继承是多态的前提
注：
①子类中所有的构造函数都会默认访问父类中的空参数的构造函数，默认第一行有super()；若无空参数构造函数，子类中需指定；另外，子类构造函数中可自己用this指定自身的其他构造函数。
3.多态
是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象
好处：提高了程序的扩展性
弊端：当父类引用指向子类对象时，虽提高了扩展性，但只能访问父类中具备的方法，不可访问子类中的方法；即访问的局限性。
前提：实现或继承关系；覆写父类方法。

赵海洋 发表于 2013-7-15 20:15
4，写出5个你用过的IO流？

4，写出5个你用过的IO流？
input output reader writer inputstream outputstream

赵海洋 发表于 2013-7-15 20:00
答题开始，第一题，送分题：面向对象的三个特征？（在线答题，四分钟后更新下一题，请大家抓紧！）答案直接 ...

多态、继承、封装

赵海洋 发表于 2013-7-15 20:00
答题开始，第一题，送分题：面向对象的三个特征？（在线答题，四分钟后更新下一题，请大家抓紧！）答案直接 ...

封装 继承 多态