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


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

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

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

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

6.run()方法和start()方法的区别？
run方法是单线程，start方法是多线程

throw关键字是指人为地抛出一个异常
throws运用于方法声明之上，表示在编译期遇到异常不做处理的情况下，提醒该方法的调用者来处理这个异常

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

运行期异常或运行期异常的子类可以不声明异常
编译期异常需要声明异常

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

运行期异常或运行期异常的子类可以不处理，交给JVM处理
编译期异常就只能往上抛给JVM处理（throws）或者用try...catch接收异常

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

并发：一段（很短）时间执行的数量，是交替执行的
并行：是同时执行的，在同一时间点上，一定有很多个线程被CPU正在执行

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

进程：计算机中的一组功能
线程：计算机中的任务的一个执行单元（CPU和任务之间的通道）

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

run()方法是只在主线程中调用一个fun()方法，没有开启一个新的线程
而start()方法是开启了一个新的线程，在新的线程中调用run()方法

陈鹏涛
今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
1.throw和throws的区别？
throw:
         可以使用throw关键字在指定的方法中抛出指定的异常
         throws关键字必须写在方法声明处

   
         throw关键字必须写在方法的内部


         throw关键字后边new的对象必须是Exception或者Exception的子类对象

  
         throw关键字抛出指定的异常对象,我们就必须处理这个异常对象

           
         throw关键字后边创建的是RuntimeException或者是
         RuntimeException的子类对象,我们可以不处理,默认交给JVM处理(打印异常对象,中断程序)

      
         throw关键字后边创建的是编译异常(写代码的时候报错),我们就必须处理这个异常,要么throws,要么try...catch
   

throws :
        throws关键字后边声明的异常必须是Exception或者是Exception的子类

     
        方法内部如果抛出了多个异常对象,那么throws后边必须也声明多个异常

           
        如果抛出的多个异常对象有子父类关系,那么直接声明父类异常即可

        
       调用了一个声明抛出异常的方法,我们就必须的处理声明的异常

      
       要么继续使用throws声明抛出,交给方法的调用者处理,最终交给JVM

         
       要么try...catch自己处理异常

2.什么时候需要声明异常，什么时候不需要声明异常？
      声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，
      而没有捕获处理（稍后讲 解该方式），那么必须通过throws进行声明，让调用者去处理。
      运行时期异常间RuntimeException是不需要声明的
3.异常有几种处理方式？
        1. 多个异常分别处理。
        2. 多个异常一次捕获，多次处理。
        3. 多个异常一次捕获一次处理。
4.什么是并发，什么是并行？
       并发：一段时间（很短）执行的数量（cpu在很短的时间之内，切换了很多个线程执行，cpu是并发的执行进程）（cpu交替执行）
      

并行：同时执行（在同一时间点上，一定有多ige线程同时被cpu正在执行着，）（同时执行）

5.什么是进程，什么是线程？
     线程：计算机一个任务执行单元（cpu和任务之间的执行通道）


     进程：计算机种一组功能

6.run()方法和start()方法的区别？
      run()在Thread类的子类中重写Thread类中的run方法,设置线程任务(开启线程要做什么?)
      start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

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

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

3.异常有几种处理方式？
三种：抛出，捕获，声明。
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。

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

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

6.run()方法和start()方法的区别？
start（）是开启线程的对象，而run（）JVM虚拟机调用的

今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
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关键字处理运行期异常，必须写在方法内，new的对象必须是Exception的子类对象，且抛出指定的异常对象，我们就必须处理这个异常对象
throws关键字处理编译器异常，是方法声明异常，声明的异常对象必须是Exception或Exception的子类，如果声明抛出了一个异常，我们必须对
这个异常进行处理，要么使用throws声明抛出，交给方法的调用者处理，最终由JVM处理，要么用try...catch自己处理异常-->中断处理

2.什么时候需要声明异常，什么时候不需要声明异常？
编译时期出现的异常需要用throws声明异常，声明了这个异常就必须对这个异常进行处理，要么throws声明抛出异常给方法的调用者处理，要么使用
try...catch自己处理这个异常，若没有最终由main方法抛给JVM处理-->中断处理
运行时期出现的异常不用声明异常，可不做处理或者抛给JVM处理

3.异常有几种处理方式？
答：由两种方式。
(1)throws关键字:用于方法声明异常，当方法内部抛出了异常对象的时候，我们必须处理这个异常对象，使用throws关键字处理异常对象，会将异常
对象抛给方法的调用者(如果没有处理这个异常，抛给main方法)，最终由JVM处理-->中断处理
(2)try...catch关键字:捕获异常，在方法中使用try...catch的语句来自己处
理这个异常。

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

5.什么是进程，什么是线程？
答：
进程：运行在内存中的应用程序，一个内存可以运行多个进程
线程：线程是进程的一个执行单元，是任务连接cpu的通道，线程可以是单个的，也可以是多个的

6.run()方法和start()方法的区别？
答：
run():创建线程对象需重写run()，完成线程执行的逻辑.
start():用于启动线程

1.throw和throws的区别？
（1）throw是手动抛出一个指定的异常类对象，并直接结束方法；
（2）throws是声明可能会抛出的异常，用来提醒方法的调用者处理此异常。
2.什么时候需要声明异常，什么时候不需要声明异常？
（1）当一个异常类是Exception的子类时，如果可能要抛出这个类的异常对象，就需要在方法的头部末尾加上throws来声明异常；
（2）当需要抛出的异常对象的类是继承了RuntimeException类时，就不需要声明异常，JVM将自动接收异常对象并作中断处理；
（3）当异常已经被try-catch方式处理以后，就不再需要声明异常了。
3.异常有几种处理方式？
（1）throw抛出。
（2）try-catch自己处理。
4.什么是并发，什么是并行？
（1）并发：两个或多个事件在同一段时间段内发生，多个任务由CPU交替执行。相对并行更慢。
（2）并行：两个或多个事件在同一个时刻发生，多个任务由CPU同时执行。相对并发更快。
5.什么是进程，什么是线程？
（1）线程：计算机中的任务的一个执行单元，也是CPU和任务之间的执行通道。


（2）进程：计算机中的一组功能。

6.run()方法和start()方法的区别？
（1）run（）方法是自定义线程类对象的重写了父类Thread中run（）方法的方法，可以被主线程单独调用，但是在这种情况下，新的线程将不会被创建，JVM中仍然只有一个主线程。
（2）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.什么时候需要声明异常，什么时候不需要声明异常？
声明异常throw抛出了编译时:就是将问题标识出来,报告给调用者;
如果方法内通过throw抛出了编译时异常,而没有捕获处理,那么必须通过throws进行声明,让调用者去处理

如果在方法中使用try-catch有的语句块来处理异常,则不用声明

3.异常有几种处理方式？
1,该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)
2,方法中使用try-catch有的语句块来处理异常


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

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

进程:是指一个内存中运行的应用程序,每个进程都有一个独立的内存空间,一个应用程序可以同时运行多个进程;
进程也是程序的一次执行过程,是系统运行程序的基本单位;
系统运行一个程序既是一个进程从创建,运行到消亡的过程

线程:是指进程中的一个执行单位,负责当前进程中程序的执行,一个进程中至少包含有一个线程,一个进程中是可以有多个线程的,这个应用程序也可以称为多线程程序

简言之:一个程序运行后至少有一个进程,一个进程中可以包含多个线程

6.run()方法和start()方法的区
继承thread类创建子类时重写run()方法
启用新的线程是用start()方法

1.throw和throws的区别？

    答：throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束

当前方法的执行；关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒

该方法的调用者来处理异常(抛出异常).

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

   答：运行异常不需要声明异常，编译异常需要声明异常

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

   答：两种处理方式，一种是将问题标识出来，报告给调用者。如果方法内通过throw抛出了

编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理
另一种是在方法中使用try-catch的语句块来处理异常。

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

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

5.什么是进程，什么是线程？
   
     进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程

序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统

运行一个程序即是一个进程从创建、运行到消亡的过程。
     线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一

个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序

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

    答：run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体；

start()方法用来启动该线程

今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
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关键字，它用来抛出一个指定的异常对象；
       throws是声明异常，让调用者去解决，最终由JVM在输出控制台输出，中断处理。

2.什么时候需要声明异常，什么时候不需要声明异常？
答：如果将抛出的异常进行捕捉处理，就不需要声明异常，以及在运行期
异常也不需要声明异常，反之则要声明。

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

4.什么是并发，什么是并行？
答：（1）并发：指两个或多个事件在同一个时间段内发生。
       （2）并行：指两个或多个事件在同一时刻发生（同时发生）
5.什么是进程，什么是线程？
答：（1）进程是内存中运行的应用程序
       （2）线程是进程中的一个执行单位
       （3）一个进程至少包含一个线程，一个应用程序至少包含一个进程。
6.run()方法和start()方法的区别？
答：（1）run()方法定义的是线程的任务，,因此把run()方法称为线程执行体；
       （2）调用start()方法用来启动该线程，

1.throw和throws的区别？

throw:它用来抛出一个指定的异常对象。throw是用在方法内，将异常对象传递给调用处
throws:它是声明异常，throws是用在方法声明处，用于表示当前方法不处理异常，而是提醒该方法调用者处理

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

如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理。
当异常属于运行期异常或者通过try...catch...自己解决异常时就不需要声明异常了

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

(1)抛出异常throw,首先会创建一个异常对象，封装一些异常信息，通过throw关键字将异常传递给调用处，并结束当前方法的执行
(2)通过try...catch...方法捕获异常。首先将可能出现异常的代码块放到try代码块中，catch模块用来捕获异常，并处理异常

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

并发：一段时间内，一个CPU执行多个线程
并行：多个CPU同时执行多个线程

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

进程：就是指进入到内存中运行的程序
线程：就是进程的一个执行单元

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

run()方法就是代表线程需要完成的任务
start()方法就是通过线程对象来启动run()方法的

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

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

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

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

4.什么是并发，什么是并行？
并发：多个时间同一时间段发生
并行：多个时间同一时刻发生

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

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

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

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

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

3.异常有几种处理方式？
异常有两种处理方式:声明异常和捕获异常
声明异常throws：将异常传递给方法的调用者处理;调用者来处理异常(抛出异常)；
ry...catch抓取(捕获)异常：对异常进行捕获，可以对异常进行指定处理分为:
1. 一次捕获一次处理
2. 多次捕获多次处理。
3. 一次捕获多次处理

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

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

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

1.throw和throws的区别？
1).throw:在Java中,提供了一个throw关键字,它用来抛出一个指定的异常对象
2).throws:throws是声明异常,将问题标识出来,报告给调用者,如果方法内通过throw抛出了
编译时异常,而没有捕获处理,那么必须通过throws进行声明,让调用者去处理

2.什么时候需要声明异常，什么时候不需要声明异常？
如果方法内通过throw抛出了编译时异常,而没有捕获处理,那么必须通过throws进行声明,
反之则不需要声明异常

3.异常有几种处理方式？
三种方式,一种是直接抛出异常throws,一种是声明异常throws,还有一种是捕获异常try...catch

4.什么是并发，什么是并行？
并发:一段时间(很短)执行的(CPU在很短的时间之内,切换了很多个线程进行执行,CPU是并发的执行线程)
数量
并行:同时执行(在同一时间内,多条线程同时执行)

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

6.run()方法和start()方法的区别？
调用start()会自动调用run()方法,调用run()方法程序不会执行run()方法

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

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

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

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

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

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

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