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

今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
1.throw和throws的区别？throw是在方法中抛出一个指定的异常对象,将这个异常对象传递给方法的调用者,并结束方法的继续执行;
throws是声明异常,运用于方法的声明之上,,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常);如果方法内通过throw抛出了编译时异常，而没有try...catch处理，那么必须通过throws进行声明，让方法的调用者去处理。

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

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

如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常;
父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出.



4.什么是并发，什么是并行？
并发是多个事情在一段时间内发生,比如火车上乘客上厕所,只有一个厕所,大家在一段时间内轮流上;
并行是多个时间在同一时刻发生,比如老师上课,对于学生来说,每个人同时都在听同一个人讲课;

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


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

系统通过调用线程类的start()方法来启动一个线程，此时该线程就处于就绪状态，而非运行状态，也就意味着这个线程可以被jvm来调度执行。在调度过程中，JVM通过调用线程类的run()方法来完成实际的操作，当run()方法结束后此线程就会终止。
如果直接调用线程类的run()方法，这会被当作一个普通的函数调用，程序中仍然只有主线程这一个线程，也就是说start()方法能够异步的调用run()方法，但是直接调用run()方法却是同步的因此也就无法达到多线程的目的。

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关键字是声明一个异常，写于方法定义时方法名的后面，表明调用该方法可能产生一个异常。

2.什么时候需要声明异常，什么时候不需要声明异常？
编译期异常是需要程序员自己处理的，处理的方式有两种，一种是声明异常，这时候需要对异常进行声明。另一种是用try...catch处理异常，这时候不用对异常进行声明；
运行期的异常可以不用程序员自己处理，可以不用对异常进行声明。

3.异常有几种处理方式？
处理的方式有两种，一种是声明异常，这时候需要对异常进行声明。另一种是用try...catch处理异常，这时候不用对异常进行声明。

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

5.什么是进程，什么是线程？
进程：是程序中一组功能的执行单位，每个应用程序可以开辟一个或多个进程，每个进程都有一个独立的内存空间；
线程：是进程中的一个执行单元，一个进程可以有一个或多个线程，对于一个进程中的多个线程来说，多个线程共享进程的内存块。

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

1.throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。throws将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理。
关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常。
2.异常分为运行期异常和编译期异常，运行期异常不需要自己处理，JVM会处理。编译器异常必须自己处理，当方法内throw抛出异常后，在本方法没有进行捕获处理就需要在方法上声明这个异常，交给调用处处理。
3.异常有两种处理方式，throws声明异常和捕获（try...catch）处理
4.并发:指两个或多个事件在同一个时间段内发生。
   并行：两个或多个事件在同一时刻发生（同时发生）。
5.进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
6.start()：该方法是在当前线程中启动一个新的线程，而新启动的线程会调用run()方法，同时该方法不能重复调用；
run()  ：该方法和普通的方法一样，可以重复执行，不会创建新的线程。

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

run()方法为线程执行体
start()方法是用来启动该线程

1.throw和throws的区别？
throws是用来声明一个方法可能抛出的所有异常信息 ；通常不用显示的捕获异常，可由系统自动将所有捕获的异常信息抛给上级方法；
throw则是指抛出的一个具体的异常类型；需要用户自己捕获相关的异常，而后在对其进行相关包装，最后在将包装后的异常信息抛出。
通常在一个方法（类）的声明处通过throws声明方法（类）可能抛出的异常信息，而在方法（类）内部通过throw声明一个具体的异常信息。

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

3.异常有几种处理方式？
两种处理方式：
1.对代码块用try..catch进行异常捕获处理；
1.在 该代码的方法体外用throws进行抛出声明，告知此方法的调用者这段代码可能会出现这些异常，你需要谨慎处理。此时有两种情况：
        （1）如果声明抛出的异常是编译期异常，此方法的调用者必须显示地用try..catch块进行捕获或者继续向上层抛出异常。
        （2）如果声明抛出的异常是运行期异常，此方法的调用者可以选择地进行异常捕获处理。

4.什么是并发，什么是并行？
并发：指应用能够交替执行不同的任务
并行:指应用能够同时执行不同的任务,

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

6.run()方法和start()方法的区别？
系统通过调用线程类的start()方法来启动一个线程，在调度过程中，JVM通过调用线程类的run()方法来完成实际的操作，当run()方法结束后此线程就会终止。如果直接调用线程类的run()方法，这会被当作一个普通的函数调用，程序中仍然只有主线程这一个线程，也就是说start()方法能够异步的调用run()方法，但是直接调用run()方法却是同步的因此也就无法达到多线程的目的。
所以只有通过调用线程类的start()方法才能达到多线程的目的。

1.throw和throws的区别？throw用来抛出一个异常，用于方法内
throws用来声明这个异常，用于定义一个方法时方法名后面
2.什么时候需要声明异常，什么时候不需要声明异常？
RuntimeException运行时异常，不需要声明
编译期异常需要程序员自己来声明
3.异常有几种处理方式？
异常的处理方式有两种，一种是通过throws关键字来声明异常，还有一种是通过try...catch来捕获异常，这时候不需要再声明异常
4.什么是并发，什么是并行？
并发表示：一段时间内做了多个事，比如先打完电话，打完电话后再吃饭
并行表示：几个人同时在做一件事，比如一边吃饭一边打电话
5.什么是进程，什么是线程？
进程是程序的一个功能，一个程序可以有多个进程，每个进程都有独立的内存空间
线程是进程中的一个执行单元，一个进程可以有多个线程
6.run()方法和start()方法的区别？

run（）方法中要覆盖重写的是新开辟的线程需要执行的内容
start（）方法用来启动线程thread中的run（方法）

1.throw和throws的区别？

throw 是在方法内抛出异常，throws是抛出异常让调用方法解决或者调用方法也throws让虚拟机解决

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

编译器的异常时用throws给调用方法try-catch方法解决就不用声明，如果调用方法也用throws返回给虚拟机解决就要声明。

运行期异常不用进行声明，方法在运行时时出现异常会默认一个声明。

3.异常有几种处理方式？
1.throws声明异常交给虚拟机解决，2.try-catch自己定义方法解决

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

一段时间交替轮流发生的事件叫并发，俩哥事件在同一时刻同时进行叫并行

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

程序的执行单位，每个程序都可以有一个或多个进程，每个程序至少有一个进程，进程有着自己独立的空间

线程是程序的执行单位，一个程序可以有多个线程，多个线程共享所在进程的独立空间。
6.run()方法和start()方法的区别？

run()定义线程执行流程体

start()方法开启线程运行

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


2.什么时候需要声明异常，什么时候不需要声明异常？
答：如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理，如果有通过tr...catch处理异常或者异常不需要处理的就不需要声明异常。


3.异常有几种处理方式？
答：处理异常可以通过try...catch也可以通过throw抛出后用throws声明。


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


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



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

答：run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体，需要重写不需要调用。可通过调用线程对象的start()方法来启动该线程。

今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
1.throw和throws的区别？
        throw  抛出异常
        throws 声明异常
       
2.什么时候需要声明异常，什么时候不需要声明异常？
        编译期异常是自己处理
        运行期异常不需要处理
3.异常有几种处理方式？
        throws 声明
        try catch 处理
4.什么是并发，什么是并行？
        并发,一段时间内发生的事件
        并行,一个瞬间内发生的事件
5.什么是进程，什么是线程？
        进程是程序中一组功能的执行单位每个应用程序可以开辟一个或多个进程，每个进程都有一个独立的内存空间
        线程是进程中的一个执行单元，一个进程可以有一个或多个线程，对于一个进程中的多个线程来说，多个线程共享进程的内存块。
6.run()方法和start()方法的区别？
        重写的run方法使用start方法运行,将需要在新开辟的线程中执行的代码体写进run()方法中
        start()方法：线程启动的方法

1.throw和throws的区别？ 答：1.throw为抛出异常在可能出现问题的代码出用try...catch包围后若出现异常就可以用此关键字抛出一个异常然后捕获到异常后我们自己处理这个异常
        2.throws是在方法名后面声明的可以声明总异常也可以声明具体的异常，任何方法调用这个有声明的异常也要自己声明下，最后交给虚拟机处理。
        3.两种作用都是抛出异常，区别在于 throws是声明在方法名后面的，throw是声明在方法类的。
2.什么时候需要声明异常，什么时候不需要声明异常？
答：1.在代码有可能发生异常的时候需要声明异常，在有try...catch包围后不需要再方法后面声明异常和代码没有异常的时候不需要声明异常
3.异常有几种处理方式？
  答：1.总共有两种方式处理，第一种是我们用try...catch包围后自己处理，此种方法的好处在于在异常代码的后续代码可以接着执行，第二种方法是直接抛给调用者处理，缺             点 是，JVM处理异常简单粗暴，会直接打印错误信息然后终止程序的执行，这样在异常代码后面的任何代码都显得没有意义了。
4.什么是并发，什么是并行？
答：1.并发的意思是单个线程来回执行一个任务，并行的意思是多个线程一起执行任务。
5.什么是进程，什么是线程？
答：进程，代表一个程序，线程代表一个程序里面的一个或者多个功能任务，
6.run()方法和start()方法的区别？

答：要想创建线程需要继承Thread类重写run方法，但是重写了方法之后不代表线程创建成功需要创建该类的对象，然后调用start方法后线程才会启动，调用了start方法后会有系统去创建启动一条线程。区别：run方法创建线程，start方法启动线程

1.throw和throws的区别？throw抛出异常，用于方法内
throws声明异常，用于定义一个方法时方法名后面

2.什么时候需要声明异常，什么时候不需要声明异常？
编译器的异常时用throws给调用方法try-catch方法解决就不用声明，如果调用方法也用throws返回给虚拟机解决就要声明。
运行期异常不用进行声明，方法在运行时出现异常会默认一个声明。

3.异常有几种处理方式？
一声明异常，这时候需要对异常进行声明
二用try...catch处理异常，这时候不用对异常进行声明

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

5.什么是进程，什么是线程？
进程：是程序中一组功能的执行单位，每个应用程序可以开辟一个或多个进程，每个进程都有一个独立的内存空间；
线程：是进程中的一个执行单元，一个进程可以有一个或多个线程，对于一个进程中的多个线程来说，多个线程共享进程的内存块

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

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

1.throw和throws的区别？
答：throw是"抛出"，在异常发生处抛出异常时使用，创建异常对象,写在方法内，抛出异常到调用处。
throwas是“声明”，写在方法参数列表后。指方法中的异常处没有自己处理异常时，需要把异常抛出给调用处，让调用处进行处理。声明异常的作用。


2.什么时候需要声明异常，什么时候不需要声明异常？
答：在方法中的异常处进行了try...catch处理时，不需要进行声明异常，自己已经处理。如果方法的异常处没有进行try...catch处理，而是将异常抛出，那么方法就要进行throws声明异常，让调用处进行处理。 还有一种情况，不需要进行声明处理，如果异常是运行期异常，就可以不进行声明异常交JVM处理。

3.异常有几种处理方式？
答：异常有两种处理方式：1.throws声明异常 2.try...catch捕获异常

4.什么是并发，什么是并行？
答：并发是在一段时间内交替进行，交替发生。 并行是在同一时刻同时发生。

5.什么是进程，什么是线程？
答：进程就是一个软件的一组功能（一个软件最少有一个进程，软件进入内存），线程是处理进程的一个单元。
一个软件至少包含一个进程，可以包含多个进程。
一个进程至少包含一个线程，可以包含多个线程（多线程的程序）。
软件运行从硬盘进入内存中，进程产生。进程是软件的执行过程。线程是进程的执行单元。

6.run()方法和start()方法的区别？
答：在创建线程类Thread类是必须要重写run（）方法，要把需要子线程执行的内容写到run内。run（）方法是开辟子线程需要实现的功能。
而是子线程对象调用start（）是启动子线程的方法。

1.throw和throws的区别？throw:用在方法内,用来跑出一个异常对象,将这个异常对象传递到调用者,并结束当前的方法;
throws:用来进行异常类的声明,若方法可能有多个异常情况,在throws后面可以写多个异常类.
2.什么时候需要声明异常，什么时候不需要声明异常？
编译器需要声明异常,
运行期则不需要声明异常
3.异常有几种处理方式？
两种方式
一个是声明异常 用thorws
一个是用捕捉异常
try{
              thorw(......)
}catch{
              .............
}
4.什么是并发，什么是并行？
并发: 在一个时间段的时候发生的几个操作
并行:在一个时间点,同时操作几件事
5.什么是进程，什么是线程？
进程:是一个程序运行时候有一个独立的位置内存空间;一个程序不止一个进程
线程:是进程中的一个执行单元,负责当前进程的执行;
一个进程可以拥有至少一个线程;
6.run()方法和start()方法的区别？

线程的run()方法是由java虚拟机直接调用的，如果我们没有启动线程（没有调用线程的start()方法）而是在应用代码中直接调用run()方法，那么这个线程的run()方法其实运行在当前线程（即run()方法的调用方所在的线程）之中，而不是运行在其自身的线程中.

run();定义线程
start();开启线程

1.throw和throws的区别？
throw是抛出异常，通常在定义方法的时候，对传进来的参数进行验证，如果数据不合理，通过throw抛出异常来告诉调用者。
throws是声明异常，写在方法定义的后面，如果抛出的异常没有解决的方法，那么就向上告知给调用者，这时候就需要用到throws。
2.什么时候需要声明异常，什么时候不需要声明异常？
声明异常：就是在方法中如果出现抛出异常，而在方法内没有解决异常问题，那么就告知方法的调用处来解决这个异常。如果在方法中已经用捕获异常（try{} catch(){}）解决了抛出的异常，那么就不需要告知调用者这个异常。
3.异常有几种处理方式？
两种：声明异常跟捕获异常；
（throws）声明异常把抛出的异常向上告知调用处，调用处告知jvm，jvm打印异常同时程序停止。
（try{} catch(){}）捕获异常，可以在方法出解决抛出的异常，或者通过声明异常在调用处解决异常，程序继续执行。
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多
个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创
建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程
中是可以有多个线程的，这个应用程序也可以称之为多程线程。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
6.run()方法和start()方法的区别？
run()方法：在多线程创建用来重写子线程的内容的一个方法；
start()方法：使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

1.throw和throws的区别？throw是抛出异常，在方法内创建。throws是声明异常，定义在方法名后面，说明这个方法有可能出现异常。
2.什么时候需要声明异常，什么时候不需要声明异常？
出现编译期异常的时候，我们必须处理这个异常，如果用thorws处理的话就是声明异常，如果用try。。catch处理的话就不用声明。如果是运行期异常的话就可以不用声明异常默认交给JVM去做中断处理。
3.异常有几种处理方式？有两种，一种是用throw抛出异常然后throws声明将它交给虚拟机去做中断处理，另外一种是采用try。。。catch我们自己用自己的想要的方式去处理这个异常。
4.什么是并发，什么是并行？
并发是指两个或多个事件在同一时间段发生；并行是两个或者多个事件在同一时间发生，也就是同时发生。
5.什么是进程，什么是线程？
进程是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。 线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
6.run()方法和start()方法的区别？
run（）方法的方法体代表了线程需要完成的任务，也被称为线程执行体；我们可以定义一个Thread的子类去重写run（）写上我们需要实现的功能，用Thread类里面的方法start（）方法去启动一个子线程跟主线程去抢占cpu的执行时间。

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


2.什么时候需要声明异常，什么时候不需要声明异常？
答：如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理，如果有通过tr...catch处理异常或者异常不需要处理的就不需要声明异常。


3.异常有几种处理方式？
答：处理异常可以通过try...catch也可以通过throw抛出后用throws声明。


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


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



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

答：run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体，需要重写不需要调用。可通过调用线程对象的start()方法来启动该线程。

1.throw和throws的区别？
答：throw关键字是在指定的方法中抛出指定的异常，可以理解为是当程序运行出现的异常的时候把异常抛出方法，返回给方法的调用处。throw一般写在方法体中。
throws关键字是用来声明可能出现的异常，表示的是该方法运行可能出现的异常，会把出现的异常返回方法调用处，throws一般写在方法名后。

2.什么时候需要声明异常，什么时候不需要声明异常？
答：异常分为两种，分别为编译器异常和运行期异常。
编译期异常的处理有2种，一种是通过throw抛出异常，不在方法内对异常进行消化，需要把异常抛出，返回方法调用处，所以需要在方法声明处进行声明方法可能出现的异常，另一种是通过try...catch捕捉异常，这种异常处理方式会把方法执行可能出现的异常直接在方法体中，把异常消化掉，无需把异常抛出方法，所以无需声明异常。
运行期的异常可处理可不处理，所以无需声明异常。

3.异常有几种处理方式？
答：异常有2种处理方式。
一种是通过throws声明异常，并将异常返回方法调用处，如果方法调用处也无法处理异常并需要抛出异常，继续返回至调用者，直至最后又jvm处理。
另外一种是通过try....catch捕捉异常，在方法种把可能出现的异常捕捉并处理。

4.什么是并发，什么是并行？
答：并发是一段时间内发生了2个或者2个以上的事件。
并行是在同一时间内发生了2个或者2个以上的事件。

5.什么是进程，什么是线程？
答：进程指的是应用软件的一组功能，每个程序拥有至少一个的进程，程序可以拥有多进程，每一个进程在内存种都拥有自己独立的内存空间。
线程指的是进程执行的一个执行单位，一个进程拥有至少一个的线程，进程可以拥有多个线程，多个线程可以指向同一个进程内存位置。

6.run()方法和start()方法的区别？
答：在创建多线程类的对象时，run()方法是主程序需要执行并行执行的代码内容写进方法体中，即线程执行体；
start()方法则是用来启动该线程的方法。

1.throw和throws的区别？
Throw：当程序运行到throw关键字并会产生异常时，就将异常抛出。Throw在方法内使用。
Throws：是声明一个或者多个异常，在方法名后面定义。声明该方法可能产生定义异常类型的异常。
2.什么时候需要声明异常，什么时候不需要声明异常？
在编译期时要自己来处理异常。一般有两种方式，1.用throw把异常抛出，然后用throws声明异常。
2.用try。。。Catch来处理异常，不用声明异常。

3.异常有几种处理方式？
两种处理方式：1.一种是声明异常，用throw把异常抛出，然后用throws声明异常。
3.用try。。。Catch来处理异常，不用声明异常。
4.什么是并发，什么是并行？
并发:就是两个或者多个事件在同一个时间段内发生。
并行：就是两个或者多个事件在同一时刻发生（是两个时间一起发生）。
5.什么是进程，什么是线程？
进程：就是程序的一个功能，一个程序有多个进程，每个进程有独立的内存空间。
线程：就是程序的执行单位，每个进程的内存空间可以多个线程共享，程序可以有多个线程。

6.run()方法和start()方法的区别？
Run（）：用来写新开辟的线程执行代码。
Start（）：用来开启新线程的方法。