今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
1.throw和throws的区别？
2.什么时候需要声明异常，什么时候不需要声明异常？
3.异常有几种处理方式？
4.什么是并发，什么是并行？
5.什么是进程，什么是线程？
6.run()方法和start()方法的区别？

1.throw和throws的区别？
throw用于自定义异常的抛出，throws是用于异常代码的处理

2.什么时候需要声明异常，什么时候不需要声明异常？
当遇到代码编译异常时需要声明异常，当代码是运行异常时不需要声明

3.异常有几种处理方式？
有三种；一是不处理，二是Throws抛给方法调用者，若是在main方法中就抛给JVM处理，三是try...catch在当前方法处理抛出，也有用到JVM

4.什么是并发，什么是并行？
并发是进程的线程在时间轴上交替运行，并行是进程的线程在时间轴上共同运行

5.什么是进程，什么是线程？
进程是应用程序，进程是应用程序中的功能单元，至少有一个

6.run()方法和start()方法的区别？
使用run()，则是单线程执行代码，使用start()，则是多线程执行代码

1.throw和throws的区别？

    throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行。

    throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。当在主函数中调用该方法时，如果发生异常，就会将异常对象抛给方法调用处。

2.什么时候需要声明异常，什么时候不需要声明异常？
编译时期的异常需要声明异常，运行时期的异常不需要声明异常。


3.异常有几种处理方式？

    异常的处理方式有两种,分别是使用throws和try...catch...finally

    throws用在方法的声明上后接异常类名,是把异常抛给调用者进行处理

    try...catch...finally是捕获异常,自己处理,处理完毕后面的程序可以继续运行

a)try代码块中是可能出现异常的代码

b)catch代码块,是遇到异常,对异常进行处理的代码

c)finally代码块是无论是否发生异常,都必须执行的代码,用于释放资源.

4.什么是并发，什么是并行？

并行：指两个或多个事件在同一时刻发生（同时发生）。

并发：指两个或多个事件在同一个时间段内发生。

5.什么是进程，什么是线程？

进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

6.run()方法和start()方法的区别？
run（）：线程的任务代码；
start（）：开启新线程，JVM调用run（）。

1.throw和throws的区别？
   **  throw抛出异常。throws接收throw抛出的异常并抛给调用者
2.什么时候需要声明异常，什么时候不需要声明异常？
     **  运行期不用  编译期必须
3.异常有几种处理方式？
    **  JVM默认处理     try   catch处理
4.什么是并发，什么是并行？
    **   一个人吃两个包子      两个人吃一个包子
5.什么是进程，什么是线程？
    **    一个软件运行       进程的组成部分
6.run()方法和start()方法的区别？
   **run（）是普通方法
   **start() 包装run（）方法  使方法开辟一个新的线程

1.throw和throws的区别？
throw用在方法内，用来抛出一个异常对象.
throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常)

2.什么时候需要声明异常，什么时候不需要声明异常？
异常分为编译时期异常与运行时期异常,其中编译时期 异常是需要声明与处理的,运行时期的异常可以处理也可以不处理,由JVM采取默认的处理方式

3.异常有几种处理方式？
throws:声明异常,向上抛出,由调用者来处理异常
自己处理,方法内部使用try...catch...finally


4.什么是并发，什么是并行？
并发： 在一个时间段内 执行多个程序（快速切换）
并行： 在一个时间点上 同时执行多个程序

5.什么是进程，什么是线程？
进程:每一个应用程序进入内存执行的时候 至少会有一个进程（描述一个程序从创建、运行、到销毁的过程）
线程:：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程
中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

6.run()方法和start()方法的区别？
run()方法是一个自定义类继承Thread后,需要重写run()方法,里面写的是需要同步的代码
start()方法是线程创建后,用来启动线程的方法.

1.throw和throws的区别？
throw必须写在方法内部，用于抛出异常了。当抛出异常没有捕获处理就用throws进行声明，throws必须写在方法声明处，
2.什么时候需要声明异常，什么时候不需要声明异常？
编译时期异常需要声明异常，运行时期异常不需要声明异常
3.异常有几种处理方式？
两种，throws     try...catch
4.什么是并发，什么是并行？
并发：在一个时间段内，执行多个程序（快速切换）
并行：在一个时间点上，同时执行多个程序
5.什么是进程，什么是线程？
进程：每一个应用程序进入内存执行的时候 至少会有一个进程（描述一个程序从创建、运行、到销毁的过程
线程：属于进程中的执行单元，一个进程中至少有一个线程（多个线程），每一个线程都有自己的线程任务
6.run()方法和start()方法的区别？
run方法里面写的是要执行的代码
start方法标志着开启了一个新线程

--------------吴齐宾----------------------
1.throw和throws的区别？
1).throw用在方法体中，并且创建一个异常对象。
2)throws被应用在声明方法时，用来指定可能抛出的异常。
2.什么时候需要声明异常，什么时候不需要声明异常？
如果异常是编译异常时,需要声明异常,如果是运行异常就不需要声明异常
3.异常有几种处理方式？
2种,throw 和Try catch
4.什么是并发，什么是并行？
并行：同时运行多个进程。
并发：在一段时间内运行多个进程
5.什么是进程，什么是线程？
进程指正在运行的程序。
线程是进程中的一个执行单元，负责当前进程中程序的执行
6.run()方法和start()方法的区别？
run()方法.是指调用了run()中的代码块
start()方法是指开启了一个新的线程

余志斌
1.throw和throws的区别？
throws是将异常对象抛给方法的调用者。
throw 一般跟new关键字，创建异常对象。参数为异常原因（可自行描述）。
2.什么时候需要声明异常，什么时候不需要声明异常？
  不通过代码解决异常，而是将异常抛出或者是运行期异常的时候不需要声明异常。
3.异常有几种处理方式？
     抛出或者捕获
4.什么是并发，什么是并行？
   并发：快速切换、单个执行。
   并行： 同时执行。
5.什么是进程，什么是线程？
进程是执行的程序，线程是进程的基本单元。
6.run()方法和start()方法的区别？
run（）方法重写线程的执行任务
start（）方法启动线程。

1.throw和throws的区别？
throw关键字通常用在方法体中
try{
}catch{  throw new  ??????????? }
finally{}
，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行,但在finally修饰的代码块中的代码一定会执行。
throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。

2.什么时候需要声明异常，什么时候不需要声明异常？
如果异常是编译异常时,需要声明异常,如果是运行异常就不需要声明异常
3.异常有几种处理方式？
throws抛出
try...catch...finally捕获
4.什么是并发，什么是并行？
并行：同个时间点运行多个进程。
并发：在一段时间段运行多个进程
5.什么是进程，什么是线程？
应用程序在内存中进行的创建、运行、销毁 的过程叫做进程
进程的执行单元叫做线程负责为进程向内存开辟路径
6.run()方法和start()方法的区别？
run()方法.是指调用了run()中的代码块
start()方法是启动线程的方法

1.throw和throws的区别？

  throw在方法内部后接异常对象，产生异常后抛出异常对象
  throws在方法声明上，在参数列表后，后接异常名，声明可能产生的异常
2.什么时候需要声明异常，什么时候不需要声明异常？
  当使用try...catch处理异常时不需要声明异常。当抛出的异常是运行时期异常时不需要声明异常。

3.异常有几种处理方式？

  两种处理方法，一种是使用try...catch处理异常
                          一种是用throws抛出异常给调用者

4.什么是并发，什么是并行？

  多个事件在同一时间段内发生叫并发（交替非同时）
  多个事件在同一时刻发生叫并行。（同时）

5.什么是进程，什么是线程？

  启动程序进入内存运行，

进入内存的

程序叫进程，一个程序至少有一个进程，可以有多个
  线程是进程的执行单元。一个进程至少有一个线程，可以有多个。

6.run()方法和start()方法的区别？

  run()方法内为需要开启新线程运行的代码。
  Thread的对象调用

start()，通过JVM再调用run()方法开启线程运行程序。

陈建秋
1.throw和throws的区别？

（1） throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行。

（2）throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。当在主函数中调用该方法时，如果发生异常，就会将异常对象抛给方法调用处。

2.什么时候需要声明异常，什么时候不需要声明异常？
  当异常是运行时异常，或者使用try..cath()语句处理异常时，不需要再声明异常。
3.异常有几种处理方式？

异常的处理方式有两种,分别是使用throws和try...catch...finally

4.什么是并发，什么是并行？

并行：指两个或多个事件在同一时刻发生（同时发生）。

并发：指两个或多个事件在同一个时间段内发生。

5.什么是进程，什么是线程？

进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

6.run()方法和start()方法的区别？
     直接调用run方法执行的时候还是在主线程中执行的并没有再开启线程。
     调用start()方法会开启一个线程执行run()方法中的代码

今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
1.throw和throws的区别？
throw：抛出异常，用来创建异常对象，并抛出给调用者。
throws：声明异常，当方法内没有对这个异常进行处理时，需要将这个异常对调用者进行声明，当调用者也没有对异常进行处理时，声明给JVM进行默认处理。
2.什么时候需要声明异常，什么时候不需要声明异常？
当方法内部没有对异常进行处理时就需要声明异常。如果有进行try..catch处理则不需要。
3.异常有几种处理方式？
throw&try..catch
4.什么是并发，什么是并行？
并发：两个及以上事件在同一时间段运行，交替执行。
并行：两个及以上时间在同一时刻进行，同时执行。
5.什么是进程，什么是线程？
进程：进入内存的程序，一个应用程序运行至少有一个进程。
线程：开辟应用程序到CPU的路径，每个应用程序至少有一个线程，可包含多个线程。
6.run()方法和start()方法的区别？
需要重写run方法，定义我们想要的代码内容，但不需要我们调用，属于JVM进行调用。
start方法，是我们使用对象进行调用，调用后，将线程运行信息传递给JVM处理。

1.throw和throws的区别？throw写在方法中，抛出一个异常对象，执行到此是程序终止；
throws写在方法声明处，把异常抛给调用者；
2.什么时候需要声明异常，什么时候不需要声明异常？
编译时期的异常需要声明，运行时期的异常不需要声明；
3.异常有几种处理方式？
thows和try..catch两种；
4.什么是并发，什么是并行？
并发：在同一个时间段内执行多个程序（快速切换）；
并行：在同一个时间点内执行多个程序；
5.什么是进程，什么是线程？
进程：一个程序在进入内存产生至少一个进程，进程就是程序创建，执行，销毁的过程；
线程：是进程的执行单元，一个进程至少有一个线程，每一个线程都有自己的线程任务；
6.run()方法和start()方法的区别？

run（）中写的是要执行的代码块；
start（）标志着一个线程的开启，并且由JVM调用run（）；

yefan
1.throw和throws的区别？  throw 用在方法体内,跟的是异常对象名,只能抛出一个异常对象,
  throws用在方法声明后面,跟的是异常类名,可以跟多个异常类名,由方法的调用者处理
2.什么时候需要声明异常，什么时候不需要声明异常？
   编译时异常时需要声明异常
   运行时异常时不需要声明
3.异常有几种处理方式？
   异常由两种:
          1, 一直往调用者抛,直到jvm执行
          2, 用try....cacht捕获异常
4.什么是并发，什么是并行？
   并发是值;在一段时间内执行多个任务
    并行是值:在一个时间点同事执行多个任务
5.什么是进程，什么是线程？
    进程是值:程序进入内存,程序创建,执行,销毁的过程.
6.run()方法和start()方法的区别？

   run()是调用执行 ,start()方法是开启线程.

1.throw和throws的区别？  throw
  作用:可以使用throw关键字在指定的方法中抛出指定的异常  使用格式:throw new xxxException("异常产生的原因");
  注意:1.throw关键字必须写在方法的内部
        2.throw关键字后边new的对象必须是Exception或者Exception的子类对象
        3.throw关键字抛出指定的异常对象,我们就必须处理这个异常对象
            throw关键字后边创建的是RuntimeException或者是 RuntimeException的子类对象,我们可以不处理,默认交给JVM处理(打印异常对象,中断程序)
            throw关键字后边创建的是编译异常(写代码的时候报错),我们就必须处理这个异常,要么throws,要么try...catch
  throws
  异常处理的一种方式,交给别人处理
  作用:当方法内部抛出异常对象的时候,那么我们就必须处理这个异常对象
        可以使用throws关键字处理异常对象,会把异常对象声明抛出给方法的调用者处理(自己不处理,给别人处理),最终交给JVM处理-->中断处理
        使用格式:在方法声明时使用
        修饰符 返回值类型 方法名(参数列表) throws AAAExcepiton,BBBExcepiton...{
            throw new AAAExcepiton("产生原因");throw new BBBExcepiton("产生原因"); ... }

2.什么时候需要声明异常，什么时候不需要声明异常？
方法内部有出现编译期异常 需要声明异常 即throws xxxxxExcepiton
遇到运行期异常可以不用声明异常 JVM会按照默认的方式处理该异常；
3.异常有几种处理方式？
第一种方式：throws 声明异常，自己本身不处理  丢给调用处 处理；
第二种方式：try.....catch.....  捕获异常  处理异常   自己处理；
4.什么是并发，什么是并行？
并发：交替执行
并行：同时执行
5.什么是进程，什么是线程？
进程：是指一个内存中运行的引用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程，进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序及时一个进程从创建运行到消亡的过程， 即进入到内存中的程序
线程：线程是进程的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
6.run()方法和start()方法的区别？


run（）: run方法 如果是在thread的子实现类中  则代表 线程所要执行的任务代码    如果不是在thread的子实现类中 或者是单独调用run方法 则就是一般的方法调用而已；
start（）： 为开启线程的方法  会去调用到 thread子实现类中的run 方法的内容。

1.        throw和throws的区别？
Throw用在方法内，用来抛出一个异常，程序运行至throw语句变会停止
Throws写在方法声明处，将异常对象抛给调用者处理，最终交给JVM处理
2.什么时候需要声明异常，什么时候不需要声明异常？
没有用try…catch处理的编译期异常需要声明异常，运行期异常不需要声明异常
3.异常有几种处理方式？
Throws，声明抛出异常
Try…catch捕获异常，逻辑处理
4.什么是并发，什么是并行？
并发就是多个事件在同一个时间段发生，每个时刻只能处理一个时事件
并行就是多个事件在同一时刻发生
5.什么是进程，什么是线程？
进程是指正在运行的程序
线程是进程中的执行单元，一个进程中至少有一个线程，也可以有多个线程。
6.run()方法和start()方法的区别？
Run()方法是新线程所需要执行的内容
Start()方法是开启新线程

1throw写在方法内部抛出异常对象，throws写在方法的声明处声明异常对象。
2编译时期异常需要声明异常并且把异常对象向调用者抛出，运行时期异常不需要进行声明有JVM进行解决。
3异常有2种解决方式：第一种使用try...catch进行异常捕获，第二种用throw向上抛出异常。
4并发就是同一时间段多个进程交替执行（每次只执行一个进程）。
并行就是同一时间段多个进程同时执行。
5进程就是程序进入内存执行的一系列过程。
线程就是进程的执行单元，进程想要执行至少需要使用一个线程
6run()方法和start()方法都是Tread类中的方法，run()方法相当于普通方法需要被Tread子类方法重写
而start()方法被Tresd子类方法对象调用时JVM会开辟一个新的线程，然后调用执行被重写的run()方法，总的来说start()方法用来开辟新的线程，run()方法是新线程中所执行的方法。
=====================================================  周楠

1．throw和throws的区别？
throw和throws的区别在于：throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常)
2.什么时候需要声明异常，什么时候不需要声明异常？
在编译过程中报错要声明异常抛出异常给调用者处理；在运行时期报错不需要生命异常，，交给JVM处理不会影响程序的运行。
3.异常有几种处理方式？
两种；throws和try...catch
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一时间段发生；
并行：指两个或多个事件在同一时间点（同时）发生。
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程；
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
6.run()方法和start()方法的区别？
run()执行是线程执行体；start()标志着开启了一个新线程。

=================余金龙=============
1.throw和throws的区别？

1.        throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行。

2.        throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。当在主函数中调用该方法时，如果发生异常，就会将异常对象抛给方法调用处。

2.什么时候需要声明异常，什么时候不需要声明异常？
答：编译时期产生的异常必须申明该异常，并且处理它
      运行时期产生的异常可以不用申明系统默认交给jvm处理
3.异常有几种处理方式？
答：
1.        异常的处理方式有两种,分别是使用throws和try...catch...finally

2.        throws用在方法的声明上后接异常类名,是把异常抛给调用者进行处理

3.        try...catch...finally是捕获异常,自己处理,处理完毕后面的程序可以继续运行

a)        try代码块中是可能出现异常的代码

b)        catch代码块,是遇到异常,对异常进行处理的代码

c)        finally代码块是无论是否发生异常,都必须执行的代码,用于释放资源.

4.什么是并发，什么是并行？

并行：指两个或多个事件在同一时刻发生（同时发生）。

并发：指两个或多个事件在同一个时间段内发生。

5.什么是进程，什么是线程？

进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

一个程序运行后至少有一个进程，一个进程中可以包含多个线程,但一个进程中至少包含一个线程。比如使用迅雷软件下载网络文件时，同时下载多个文件，就使用到了多线程下载。

6.run()方法和start()方法的区别？
答:
1 run方法是线程任务的代码 创建一个类继承Thread 要重写该方法
2 start（）方法在测试类中创建对象来调用该方法，开启多线程

郭林源
1.throw和throws的区别？--->throw写在方法的内部，throws写在方法的参数列表后；throw是抛出异常对象，throws是声明异常，让调用者处理

2.什么时候需要声明异常，什么时候不需要声明异常？--->编译时期异常未使用异常处理逻辑代码时，须声明异常，运行时期异常不需要声明，因为效果是一样的

3.异常有几种处理方式？--->有2种，一种是throw抛出异常，由调用者处理，最终由JDK使用默认方法处理，一种是异常处理逻辑try。。。catch，捕捉异常，可以让开发者更灵活的处理异常

4.什么是并发，什么是并行？--->并发：一个时间段内，运行多个任务，cpu在多任务间快速切换
并行：一个时间点，同时运行多个任务

5.什么是进程，什么是线程？--->一个程序进入内存中执行时，是一个程序的创建-运行-销毁的过程，一个程序运行至少有多个进程；线程就是进程的执行单元，应用程序到cpu的执行路径，一个进程至少有一个线程

6.run()方法和start()方法的区别？--->run方法是Thread类的方法，我们需要重写run方法，编辑线程的任务代码。star方法标志着开启新线程，调用star方法后，JVM会调用run方法，从而开启线程