1.throw和throws的区别？
throw是抛出异常，是运行程序时才会报出异常，不会影响编译
throws是声明异常，是编译程序时会报出异常，会影响编译失败

2.什么时候需要声明异常，什么时候不需要声明异常？
当方法内部抛出编译异常对象时需要声明异常
当方法内部抛出的是运行异常时不需要声明异常

3.异常有几种处理方式？
1. 多个异常分别处理。
2. 多个异常一次捕获，多次处理。
3. 多个异常一次捕获一次处理。

4.什么是并发，什么是并行？
并发是两个以上事件在短时间内发生
并行是两个事件以上在同一时刻同时发生

5.什么是进程，什么是线程？
进程是进入内存中的程序，一组功能的集合
线程是进程中的一个执行单元

6.run()方法和start()方法的区别？
run()方法里的方法体是线程需要完成的任务
start()方法是调用这个对象的方法来启动线程，执行run()方法

1.throw和throws的区别？

throw是在方法中抛出一个指定的异常对象，将这个异常对象传递给方法的调用者，并结束方法的继续执行；
throws是声明异常,运用于方法的声明之上，用于表示当前方法不处理异常，而是提醒该方法的调用者来处理异常(抛出异常)；如果方法内通过throw抛出了编译时异常，而没有try...catch处理，那么必须通过throws进行声明，让方法的调用者去处理。

2.什么时候需要声明异常，什么时候不需要声明异常？

如果方法中通过throw抛出编译时异常并且没有用try...catch处理，那么必须要在方法声明异常，将异常交给调用者处理，声明时可以同时声明多个异常，用逗号隔开;
如果是运行中出现异常，那么可以声明异常处理，也可以选择不需要声明异常。

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

异常有两种处理方式：
(1)一种是声明异常throws，将异常传递给方法的调用者处理，关键字throws运用于方法声明之上，用于表示当前方法不处理异常，而是提醒该方法的调用者来处理异常(抛出异常)；
(2)一种是用try...catch抓取(捕获)异常，Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理，这种处理方法又可以分为：
a. 多个异常分别处理
b. 多个异常一次捕获，多次处理
c. 多个异常一次捕获一次处理

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

并发是多个事情在一段时间内发生；
并行是多个时间在同一时刻发生。

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

进程是一组功能的集合，是进入到内存的程序
线程是CPU和任务之间的执行通道，是任务的执行单元

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

run()方法：将需要在新开辟的线程中执行的代码体写进run()方法中，即线程执行体；
start()方法：线程启动的方法

1.throw和throws的区别？
throw:用在方法内，用来抛出指定的异常对象
throws：继续将问题声明出去
2.什么时候需要声明异常，什么时候不需要声明异常？
将异常向方法的调用处抛出，自己不处理。
如果向自己进行异常处理，就不需要声明异常，用捕获异常
3.异常有几种处理方式？
两种方式，声明和捕获
4.什么是并发，什么是并行？
并发：一个时间段之内，发生多件事情
并行：在同一时间点上，有多个事情正在执行
5.什么是进程，什么是线程？
进程：一组功能的集合，是进入到内存的程序
线程：cpu和任务之间的执行通道，是任务的执行单元
6.run()方法和start()方法的区别？
run()方法的方法体就代表了线程需要完成的任务,因此把 run()方法称为线程执行体。 调用线程对象的start()方法来启动该线程

1.throw和throws的区别？
throw关键字，它用来抛出一个指定的异常对象。
如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理.
2.什么时候需要声明异常，什么时候不需要声明异常？
编译时异常一定要声明异常,运行期不一定声明异常
3.异常有几种处理方式？
两种 throws try..catch
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多
个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创
建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程
中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
6.run()方法和start()方法的区别？
该run()方法的方法体就代表了线程需要完成的任务
调用线程对象的start()方法来启动该线程

1.throw和throws的区别？
throw：用在方法内，用来抛出一个异常对象，将异常对象传递到调用者处，并结束当前方法的执行
throws：用于方法的声明之中，表示该方法对异常不作处理，而是提醒该方法的调用者处理异常

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

3.异常有几种处理方式？
抛出异常：抛出异常对象，将异常对象传递到调用者处，用于方法中
声明异常：将问题标识出来，不处理，提醒调用者处理
捕获异常：对异常语句进行捕获，并处理

4.什么是并发，什么是并行？
并发：在一个时间段里，进行多个事件
并行：在同一个时刻进行多个事件

5.什么是进程，什么是线程？
进程：一组功能的集合，是进入到内存的程序
线程：CPU和任务之间的执行通道，是任务的执行单元

6.run()方法和start()方法的区别？
run()方法是线程需要完成的任务
start()方法是线程执行的入口

一.throw和throws的区别？
throw（创建throw异常对象→抛出传递给调用处→终止程序）
如果不写throws
throw只能实现RuntimeException运行期异常

throws（创建throw异常对象→抛出传递给调用处→终止程序）
throws能实现因编译期数据出现的异常在运行期报错

2.什么时候需要声明异常，什么时候不需要声明异常？
不需要声明异常：RuntimeException类及RuntimeException的子类
需要声明异常：Exception类及Exception类的子类 不含 RuntimeException类

3.异常有几种处理方式？
2种：
声明异常throws将异常抛出至方法的调用处,方法如果都不处理 最后会由JVM进行输出异常,然后中断程序
捕获异常try…catch在方法中,自己进行异常处理,不向上抛,异常处理后代码继续执行

4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生。(一个CPU运行两个任务  交替执行)
并行：指两个或多个事件在同一时刻发生（同时发生）。(两个CPU运行两个任务  同时执行)


5.什么是进程，什么是线程？
- 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
- 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
  简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

6.run()方法和start()方法的区别？
线程类Thread重写该类的run（）方法并在测试类中创建线程对象用start（）方法来启动该线程
run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
调用线程对象的start()方法来启动该线程

1.throw和throws的区别？       throw是用来抛出一个异常,是作用在方法内,用来抛出一个异常.并把异常返回到方法的调用者处,如果方法的调用者并没有处理这个异常,那么会继续返回到方法的调用者处,如果还没有处理,那么最后会返回到JVM,然后JVM就会中断程序,并且把该异常打印出来.如果方法的调用者捕获了次异常,那么会直接在方法内解决,不会再抛到JVM处.
       throws用来声明一个异常,他是写在方法的参数列表后的,使用throws关键字加上异常的类型来声明此方法可能会发生异常,但在此方法中并不处理异常,也会吧异常返回到调用者处.
2.什么时候需要声明异常，什么时候不需要声明异常？
       在JAVA中异常可以分为两种,
        一种是Error,这是系统级错误,这是程序无法解决的.
         还有一种就是Exception,这是需要程序捕捉和处理的异常,Exception分为编译时期异常,此异常是需要声明的,还有一种就是运行时期的异常,此异常是在代码执行过程中发生的异常,不需要声明此异常,直接交给JVM来处理就行
3.异常有几种处理方式？
         throw是用来抛出一个异常,直接把异常返回给方法的调用者,如果调用者都没有处理异常,那么则需要继续抛出,让JVM来处理
         throws是用来声明一个异常,也是直接把异常返回给方法的调用者,如果调用者都没有处理异常,那么则需要继续抛出,让JVM来处理
         try....catch用来捕获异常,把可能产生异常的方法放在try语句块中,catch代码块中则是放该异常的处理方法.
4.什么是并发，什么是并行？
         并发指的是多个事件在同一时间段内发生,他是一个时间段内做很多事.
         并行指的是有多个事件在同一个时间,并行则是同时做很多的事.
5.什么是进程，什么是线程？
        进程指的是内存中运行的一个程序,一个程序可以拥有多个进程.
        线程是进程的一个执行单位,一个进程最少要有一个线程,一个进程可以有多个线程.
6.run()方法和start()方法的区别？

         在多线程中,如果创建的对象直接调用run()方法,那么只是执行了该方法,并不是开启了线程,而使用start()方法调用的话,则是表示开启新的线程,并执行run()方法中所写的内容.

今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
1.throw和throws的区别？
throw是抛出异常
throws是解决异常的一种方法，他是直接抛给JVM解决。

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

3.异常有几种处理方式？
两种
1.throws
2.try .... catch

4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。

5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，
一个应用程序可以同时运行多 个进程；进程也是程序的一次执行过程，
是系统运行程序的基本单位；系统运行一个程序即是一个进程从创 建、运行到消亡的过程。

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

6.run()方法和start()方法的区别？
run()方法是定义线程的任务。
start()方法是开启线程

陈开明：
1.throw和throws的区别？
throw:定义在方法内，用来抛出一个指定的异常，将这个异常对象传递到调用者处，并结束当前方法的执行。
throws：运用于方法声明之上，用于表示当前方法不处理异常，而是提醒该方法的调用者来处理异常（抛出异常）。
2.什么时候需要声明异常，什么时候不需要声明异常？
当异常属于编译时异常时候，需要声明异常；当异常属于运行时异常时候，不需要声明异常。
3.异常有几种处理方式？
如果属于运行时异常，不需要处理，只要抛出异常，JVM会自动处理这些异常。
如果属于编译时异常。有两种处理方式。
方式一：交给别人处理。可以使用throws关键字处理异常类，会把异常对象抛出给方法的调用者处理，
            最终交给JVM处理，使用throws处理程序会停止。
方式二：自己处理。使用try...catch...处理。遇到异常后，会继续执行下面的程序。
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生。
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
6.run()方法和start()方法的区别？
run()方法的方法体代表了线程需要完成的任务，因此把run()方法称为线程执行体。
start()方法用来开启线程。

1.throw和throws的区别？
throw是在方法进行数据判断是否合法时，如果不合法则抛出该异常。
throws是当出现异常时，不解决而是声明异常让调用处解决该异常。
2.什么时候需要声明异常，什么时候不需要声明异常？
如果时运行期异常可以不声明，是编译期异常如果不捕获就一定需要声明该异常。
3.异常有几种处理方式？
两种：（1）try...catch捕获处理异常（2）throws声明异常让调用处处理。
4.什么是并发，什么是并行？
并发：在一个时间段内发生的；
并行：在同一个时间点同时发生的；
5.什么是进程，什么是线程？
进程：是一组功能的集合，进入内存的程序
线程：一个功能与CPU的执行通道，是任务的执行单元
6.run()方法和start()方法的区别？
run()是Thread中的运行方法，所有需要运行的代码都需要写在run()方法里
start()是开起子线程的方法，其中会自动调用run()执行其中的代码

李伟斌

1.throw和throws的区别？
答：throw关键字是在创建自定义异常时使用。
      throws关键字是处理异常的一种方法。
2.什么时候需要声明异常，什么时候不需要声明异常？
答：编译时异常一定要声明异常,运行期不一定声明异常
3.异常有几种处理方式？
答：两种处理方式throws和try..catch。
4.什么是并发，什么是并行？
答：并发是一段时间内发生的，并行是一瞬间发生的。
5.什么是进程，什么是线程？
答：进程是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多
个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创
建、运行到消亡的过程。
线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程
中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
6.run()方法和start()方法的区别？
run（）调用要执行的方法。
start（）是线程启动的方法。

今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
1.throw和throws的区别？
throw写在方法内,throws写在方法名后
throw是将异常抛出,
throws是对抛出的异常进行声明
2.什么时候需要声明异常，什么时候不需要声明异常？
编译异常需要声明异常,运行异常不需要声明异常
3.异常有几种处理方式？
throws和try..catch
4.什么是并发，什么是并行？
并发指的是两件事在同一时间段内发生
并行指的是两件事在同一时刻发生

5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多
个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创
建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程
中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
6.run()方法和start()方法的区别？
直接调用run()方法不会创建新线程,会在主线程中执行;
start()方法会创建一个新线程来执行run方法中的内容.

1.throw和throws的区别？

答:抛出异常用throw,它是用来抛出指定的一个异常对象,如果方法内有可能会产生异常的代码,则会被抛出给方法的调用者,让方法的调用来处理这个异常.

声明异常用throws,  throw抛出异常对象后,方法调用者接收,调用者要么自己try...catch来处理;要么在方法后面throws继续声明该异常,让JVM来处理这个异常,用于告知程序,该方法有可能产生哪些异常.

2.什么时候需要声明异常，什么时候不需要声明异常？

在try方法里面有可能出现异常的代码 出现异常的情况下,需要声明异常.

(1.)当try方法里的代码抛出编译期异常,而且自己没有进行捕获处理的时候,就需要向方法调用者抛出throws声明异常;

(2.)当try方法里的代码抛出编译期异常,但是有自己捕获处理,或者当方法抛出运行期异常的时候就不用抛出声明异常.

答：需要声明：当方法抛出编译期异常，且没有捕获处理就需要声明异常；不需要声明异常：当方法抛出编译器异常但是有捕获处理或者当方法抛出运行期异常就不需要声明异常。

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

两种:

1.throws关键字,声明异常,告诉程序,该方法有可能产生哪些异常

2.try..catch ,自己处理这个异常



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

并发:一段时间内(很短)交替运行,Cpu在多个线程之间来回切换

并行:同一时间点上,同时执行.Cpu在多个线程之间同时执行



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

进程:计算机中的一组功能如应用程序

线程:cpu与任务之间的执行通道,是任务的执行单元

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

执行多线程时，thread接口中的run()方法负责重写需要在另一个线程执行的代码，在main方法中通过调用对象的start()方法进行多线程的开启，运行run()方法，如果直接调用对象的run()方法依然是单线程的运行方式。

1.throw和throws的区别？
答：
throw是抛出异常，即在方法中抛出一个指定的异常对象，将这个异常对象传递给方法的调用者，同时结束当前方法。
throws是声明异常，表示当前方法不处理异常，而是提醒该方法的调用者来处理当前异常。如果方法内通过throw抛出异常，而没有用try....catch处理，那么就必须通过throws进行声明，让方法的调用者去处理。

2.什么时候需要声明异常，什么时候不需要声明异常？
答：
如果方法中有throw抛出异常且没有try....catch处理，那么必须在方法声明异常，将异常交割方法调用者处理。声明是可以同时声明多个异常，用逗号隔开。
如果方法进入运行期，则不需要声明异常，直接交给JVM虚拟机处理。


3.异常有几种处理方式？
答：
两种，一种是声明异常，一种是try...catch处理异常。


4.什么是并发，什么是并行？
答：
并发值两个或多个事件在同一个时间段内发生的情况。
并行则是值两个或多个事情在同一时刻发生的情况。
5.什么是进程，什么是线程？
答：
进程指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程，进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程是进程中的一个执行单元，赋值当前进程中程序的执行，一个进程中至少有一个线程，一个进程中可以有多个线程。
6.run()方法和start()方法的区别？
答：
在main方法下调用run()方法只是调用了线程内的run()方法，而不是调用整个线程，所以此时依旧是单线程调用，只有在main方法下调用start()方法才是启动多线程，同时调用了run()方法，并且start()方法只能调用一次

1.throw和throws的区别？
答：throw关键字用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
throws关键字用在方法声明处，对于方法内通过throw抛出的编译时异常，如果没有捕获处理，就需要通过throws进行声明，将问题标识出来。

2.什么时候需要声明异常，什么时候不需要声明异常？
答：如果方法内通过throw抛出编译时异常，而没有捕获处理，那么必须通过throws进行声明异常，将问题标识出来。
如果抛出的编译时异常被捕获处理，或者抛出的是运行期异常，则不需要声明异常。

3.异常有几种处理方式？
答：异常有两种处理方式：一种是进行try...catch捕获处理，另一种就是继续将问题声明出去，使用throws声明处理。

4.什么是并发，什么是并行？
答：并发：指两个或多个事件在同一个时间段内发生（交替执行）。
并行：指两个或多个事件在同一时刻发生（同时执行）。

5.什么是进程，什么是线程？
答：进程：一个应用程序可以同时运行多个进程，每个进程都有一个独立的内存空间，是系统运行程序的基本单位。
线程：是CPU和任务之间的执行通道，是任务的执行单元，一个进程中可以有多个线程。
一个应用程序可以有多个进程，一个进程可以有多个线程。

6.run()方法和start()方法的区别？
run()方法的方法体代表了线程需要完成的任务,把run()方法称为线程执行体；
start()方法用于启动线程，本身并没有记载线程相关的任务。

1.throw和throws的区别？
throw用在方法内，用来抛出一个异常对象，将这个对象传递到调用者处，并结束当前执行的方法。
格式：throw new 异常类名(参数);
throws运用于方法申明之上，用于表示当前方法不处理异常，而是提醒该方法的调用者来处理异常(抛出异常)
格式：修饰符  返回值类型  方法名(参数)  throws  异常类名1,异常类名2...{   }
2.什么时候需要声明异常，什么时候不需要声明异常？
如果方法内通过通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理。
如果有进行捕获处理(try...catch),就不用声明。
3.异常有几种处理方式？
（1）使用throws声明抛出异常，由该方法的调用者来处理，发生异常处的后续代码不能执行；
（2）使用try...catch捕获异常，如果catch中没有再抛出异常，异常的处的后续代码还可以执行。
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段发生
并行：指两个或多个事件在同一时刻发生(同事发生)
5.什么是进程，什么是线程？
（1）进程是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
（2）线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，几个进程中可以包含多个线程。

6.run()方法和start()方法的区别？
（1）定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务，因此把run()方法称为线程执行体。
（2）调用Thread子类的实例，即创建了线程对象。调用线程对象的start()方法来启动该线程。
（3）Java线程是通过java.lang.Thread类来实现的。JVM启动时会有一个由主方法所定义的线程，可以通过创建Thtead的实例来创建新的线程。每个线程都是通过特定的Thread对象所对应的方法run()来完成其操作的。通过Thread类的start()方法来启动一个线程，这时此线程是处于就绪状态，意味着它可以由JVM调度并执行，并不意味着就会立即运行。当CPU分配给它时间时，它才开始执行。多线程就是分时利用CPU，宏观上让所有线程一起执行，也叫并发。

叶凌青
1.throw和throws的区别？
throw用在方法内，用来抛出一个异常对象，将这个对象传递到调用者处，并结束当前执行的方法。
格式：throw new 异常类名(参数);
throws运用于方法申明之上，用于表示当前方法不处理异常，而是提醒该方法的调用者来处理异常(抛出异常)
格式：修饰符  返回值类型  方法名(参数)  throws  异常类名1,异常类名2...{   }

2.什么时候需要声明异常，什么时候不需要声明异常？
如果方法内通过通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理。
如果有进行捕获处理(try...catch),就不用声明。

3.异常有几种处理方式？
（1）使用throws声明抛出异常，由该方法的调用者来处理，发生异常处的后续代码不能执行；
（2）使用try...catch捕获异常，如果catch中没有再抛出异常，异常的处的后续代码还可以执行。

4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段发生
并行：指两个或多个事件在同一时刻发生(同事发生)

5.什么是进程，什么是线程？
（1）进程是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
（2）线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，几个进程中可以包含多个线程。

6.run()方法和start()方法的区别？
（1）定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务，因此把run()方法称为线程执行体。
（2）调用Thread子类的实例，即创建了线程对象。调用线程对象的start()方法来启动该线程。
（3）Java线程是通过java.lang.Thread类来实现的。JVM启动时会有一个由主方法所定义的线程，可以通过创建Thtead的实例来创建新的线程。每个线程都是通过特定的Thread对象所对应的方法run()来完成其操作的。通过Thread类的start()方法来启动一个线程，这时此线程是处于就绪状态，意味着它可以由JVM调度并执行，并不意味着就会立即运行。当CPU分配给它时间时，它才开始执行。多线程就是分时利用CPU，宏观上让所有线程一起执行，也叫并发。

1.throw和throws的区别？
答：
      throw是抛出异常，即在方法中抛出指定的异常对象，将这个异常对象传递给方法的调用者，同时结束当前方法
      throw时声明异常，表示当前方法不处理的异常。而是将异常给调用处。如果方法内通过throw抛出异常，而没有用try..catch处        理，那么就必须通过throws进行声明，让方法的调用者去处理
2.什么时候需要声明异常，什么时候不需要声明异常？
答：
     如果方法中有throw抛出异常且没有try..catch来处理，那么必须在方法中声明异常，将异常交给调用者处理。声明时可以同时声明多个异常，用逗号隔开。如果方法进入运行期，则不需要声明异常，交给JVM虚拟机处理
3.异常有几种处理方式？
答：
     二种，一个是声明异常，一种是tey..catch处理异常
4.什么是并发，什么是并行？
答：
     并发：是指二个或者多个事件在同一时间段发生
     并行：是指二个或者多个事件在同一时该发生
5.什么是进程，什么是线程？
     进程：进程是指一个内存中运行的应用，每个进程都有一个独立的内存空间，一个应用程序可以同时运行uoge进程，进程也是程序一个执行过程，是系统运行的基本单位，运行系统一个程序即是一个进程冲创建运行到消失的过程
     线程：线程是进程中的要给执行单元，负责当前进程中的程序的执行，一个进程中必须有个线程，一个进程中可以有多个线程，这个程序也可以叫做多线程程序；
6.run()方法和start()方法的区别？
答：
     run()方法中的储存的是执行体，如果直接在mian方法中调用那么就不会创建一个新的线程
     start（）在mian方法中调用它的话就直接创建了一

1.throw和throws的区别？
答：throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
throws是声明异常，运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常)。
2.什么时候需要声明异常，什么时候不需要声明异常？
答：如果方法内通过throw抛出了编译时异常，而没有进行try...catch捕获处理，那么必须通过throws进行声明，让调用者去处理。声明时可以同时声明多个异常,用逗号隔开。
如果异常是运行中异常,那么可以声明异常处理,也可以选择不需要声明异常。
3.异常有几种处理方式？
答：两种。
      (1)声明异常：使用throws关键字对异常进行声明，表示当前不处理该异常，让调用者处理。
      (2)捕获异常：使用throw关键字来抛出一个指定的异常对象，将这个异常对象抛给调用者，并结束当前方法的执行。使用try...catch代码块对异常对象进行捕获，可以对异常进行指定的方式处理，处理后，之后的程序继续运行。
4.什么是并发，什么是并行？
答：并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）
5.什么是进程，什么是线程？
答：进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程。
6.run()方法和start()方法的区别？
答：系统通过调用线程类的start()方法来启动一个线程，此时该线程就处于就绪状态，而非运行状态，也就意味着这个线程可以被JVM来调度执行。在调度过程中，JVM通过调用线程类的run()方法来完成实际的操作，当run()方法结束后此线程就会终止。
如果直接调用线程类的run()方法，这会被当作一个普通的函数调用，程序中仍然只有主线程这一个线程，也就是说start()方法能够异步的调用run()方法，但是直接调用run()方法却是同步的因此也就无法达到多线程的目的。

1.throw和throws的区别？
throw用在方法内，用来抛出一个异常对象，将这个对象传递到调用者处，并结束当前执行的方法。
格式：throw new 异常类名(参数);
throws运用于方法申明之上，用于表示当前方法不处理异常，而是提醒该方法的调用者来处理异常(抛出异常)
格式：修饰符  返回值类型  方法名(参数)  throws  异常类名1,异常类名2...{   }


2.什么时候需要声明异常，什么时候不需要声明异常？
如果方法内通过通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理。
如果有进行捕获处理(try...catch),就不用声明。


3.异常有几种处理方式？
（1）使用throws声明抛出异常，由该方法的调用者来处理，发生异常处的后续代码不能执行；

（2）使用try...catch捕获异常，如果catch中没有再抛出异常，异常的处的后续代码还可以执行。



4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段发生
并行：指两个或多个事件在同一时刻发生(同事发生)


5.什么是进程，什么是线程？
（1）进程是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。

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


简而言之：一个程序运行后至少有一个进程，几个进程中可以包含多个线程。


6.run()方法和start()方法的区别？
（1）定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务，因此把run()方法称为线程执行体。

（2）调用Thread子类的实例，即创建了线程对象。调用线程对象的start()方法来启动该线程。

（3）Java线程是通过java.lang.Thread类来实现的。JVM启动时会有一个由主方法所定义的线程，可以通过创建Thtead的实例来创建新的线程。每个线程都是通过特定的Thread对象所对应的方法run()来完成其操作的。通过Thread类的start()方法来启动一个线程，这时此线程是处于就绪状态，意味着它可以由JVM调度并执行，并不意味着就会立即运行。当CPU分配给它时间时，它才开始执行。多线程就是分时利用CPU，宏观上让所有线程一起执行，也叫并发。