今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
1.throw和throws的区别？
2.什么时候需要声明异常，什么时候不需要声明异常？
3.异常有几种处理方式？
4.什么是并发，什么是并行？
5.什么是进程，什么是线程？
6.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用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
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是声明异常，表示当前方法不处理异常，而是提醒该方法的调用者来处理当前异常。如果方法内通过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抛出异常，而没有用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用在方法内，用来抛出一个异常对象，将这个对象传递到调用者处，并结束当前执行的方法。
格式：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是抛出异常，在我们人为的抛出异常时使用。throws是声明异常，如果方法内通过throw抛出编译异常，并且没有捕获处理，那么必须通过throws进行声明，让调用者去处理。
2.什么时候需要声明异常，什么时候不需要声明异常？
答：需要声明：当方法抛出编译器异常，且没有捕获处理就需要声明异常；不需要声明异常：当方法抛出编译器异常但是有捕获处理或者当方法抛出运行期异常就不需要声明异常。
3.异常有几种处理方式？
答：两种。（1）声明异常throws（2）使用try...catch捕获异常
4.什么是并发，什么是并行？
答：并发：多个线程在一个时间段同时被一个cpu执行；并行：多个线程在同一时刻被多个cpu同时执行。
5.什么是进程，什么是线程？
答：进程：指一个内存中运行的应用程序，每个进程都有一个独立的内存空间；线程：线程是进程的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。
6.run()方法和start()方法的区别？
答：run（）方法是但线程的，只是属于主线程中被main方法调用；start（）是开启多线程的方法，start（）被调用时，JVM会调用子线程中的run方法。

1.throw和throws的区别？
答：
        throw：是将异常进行抛出；
        throws：是对抛出的异常进行声明，让调用者处理；
2.什么时候需要声明异常，什么时候不需要声明异常？
答：
        编译期的异常抛出后，必须进行声明；而运行期的异常可以不进行声明，会默认交给JVM去处理
3.异常有几种处理方式？
答：
        一共有两种；
        throws：将抛出的异常进行声明给调用者；
        try...catch：将抛出的异常进行捕获处理；
4.什么是并发，什么是并行？
答：
        并发：短时间切换执行多个线程，即多个线程在同一时间段内执行；
        并行：同时执行多个线程，即多个线程同一时刻执行；
5.什么是进程，什么是线程？
答：
        进程：一个在内存运行的程序；
        线程：进程中的一个执行单位；
                即一个程序里可以有多个进程，而一个进程里可以包含多个线程；
6.run()方法和start()方法的区别？
答：
        区别：
                run方法是运行一段代码；而start方法是开启新线程，让run方法运行；
                如果直接调用run方法，只是调用了一个类方法，还是单线程运行并不能开启多线程运行；而调用了start方法，start方法会开启一个新线程，来执行run方法，从而实现多线程运行的目的；

1.throw和throws的区别？
throw是一个将异常抛出的关键字
throws是一种声明异常的关键字

2.什么时候需要声明异常，什么时候不需要声明异常？
异常分为两种，一种是编译期异常，另一种是运行期异常，运行期异常可以不声明，交给JAVA虚拟机去处理此类异常，编译期异常需要自己进行处理，可以使用throws方法去声明或者使用try...catch方法声明。

3.异常有几种处理方式？
异常有两种处理方式
一种是当方法内部抛出异常时，交给别人处理，使用throws处理该异常，把异常声明交给方法的调用者处理，最终给JAVA虚拟机处理；
另一种是自己处理异常，使用try()catch()方法去捕获这个异常，针对不同的异常类型使用不同的处理方法。

4.什么是并发，什么是并行？
并发：一段时间（很短）多个线程交替执行（cpu在很短时间内，切换了很多个线程进行执行）
并行：多个线程在某一时刻同时执行

5.什么是进程，什么是线程？
进程：指在内存中运行的应用程序
线程：指进程中不同功能的执行过程

6.run()方法和start()方法的区别？
需要多线程执行代码时，run()方法负责重写需要在另一个线程执行的代码，在main方法中通过调用对象的start()方法进行多线程任务的开启，使run()方法运行，直接调用对象的run()方法依旧是单线程的运行方式。

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抛出后必须用throws声明, 运行期异常可以不声明交由JVM处理

3.异常有几种处理方式？
有2种处理方式;
1.throws声明被抛出的异常,让调用者处理;
2.try...catch捕获异常

4.什么是并发，什么是并行？
并发:在一段时间内交替执行(如cpu在很短的时间内切换很多个线程执行)
并行:同时执行

5.什么是进程，什么是线程？
进程:计算机中的某个程序的一组功能
线程:计算机任务的一个执行单元, 一个进程可以拥有多个线程

6.run()方法和start()方法的区别？
直接调用run()方法不会创建新线程,会在主线程中执行;
start()方法会创建一个新线程来执行run方法中的内容.

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.什么时候需要声明异常，什么时候不需要声明异常？
如果没有j将抛出的异常进行捕捉处理，就需要声明异常，让调用者去处理
反之不用声明异常
3.异常有几种处理方式？
两种
1.使用try...eatch来处理异常
2.使用声明异常throws，让调用者处理
4.什么是并发，什么是并行？
并发:CPU在一段时间内处理多个线程
并行：在同一时间内处理多个线程
5.什么是进程，什么是线程？
进程是指在内存中运行的应用程序
线程是进程中的一个执行单位
6.run()方法和start()方法的区别？
staet（）方式是开启线程，而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，宏观上让所有线程一起执行，也叫并发。

今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
1.throw和throws的区别？
throw:它用来抛出一个指定的异常对象。
throws：关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).
2.什么时候需要声明异常，什么时候不需要声明异常？
声明异常：如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理。
不需要声明异常：运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。所以不需要声明。
3.异常有几种处理方式？
三种。
抛出异常throw：它用来抛出一个指定的异常对象。
声明异常throws：关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).
捕获异常try…catch：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程
6.run()方法和start()方法的区别？
run()方法：定义Thread类的子类，要重写该类的run()方法，该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用在方法内，用来抛出一个异常对象，将这个对象传递到调用者处，并结束当前执行的方法。
格式：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是用来抛出一个异常,是作用在方法内,用来抛出一个异常.并把异常返回到方法的调用者处,如果方法的调用者并没有处理这个异常,那么会继续返回到方法的调用者处,如果还没有处理,那么最后会返回到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：
        throw关键字必须写在方法的内部；
        throw关键字后面new的对象必须是Exception或者Exception子类对象
        throw关键字抛出的指定异常对象，我们必须处理
throws：
        throws关键字必须写在方法声明处
        throws关键字后面声明的对象必须是Exception或者Exception的子类对象
        方法内部如果抛出多个异常对象，throws后面也必须声明多个异常
        调用了一个声明抛出异常的方法，我们必须处理声明的异常

2.        什么时候需要声明异常，什么时候不需要声明异常？
如果遇到的是编译期异常，我们必须要处理。这时我们就可以声明异常，然后进行处理；
如果遇到的是运行期异常，我们可以不做处理。也就不用声明异常了

3.异常有几种处理方式？
throws：处理异常的第一种方式，抛出异常给调用者处理
try…catch：处理异常的第二种方式，利用try…catch捕获异常，并处理

4.什么是并发，什么是并行？
并发：一段的时间内，发生多件事情
并行：在一个时间点上，多件事情同时进行

5.什么是进程，什么是线程？
进程：进入到内存的程序，就是一组功能的程序
线程：计算机中的任务的一个执行单元（CPU和任务之间的执行通道）
一个进程可以拥有多个线程
6.run()方法和start()方法的区别？
run（）：方法里面的代码是线程要执行的代码，在没有创建Thread子类对象开启新的线程之前不会执行；
start（）：开启一个子线程的方法，方法里面自动调用了run（）方法。

1.throw和throws的区别？
（1）throw是一个关键字，是用来New一个指定的异常。
（2）throws是声明异常，把异常向方法的调用处报告。。


2.什么时候需要声明异常，什么时候不需要声明异常？
（1）编译期间有异常需要声明或者try catch。
（2）运行期则不需要


3.异常有几种处理方式？
两种。
（1）异常声明，throws 把异常报告给方法的调用处，自己不处理，如果自己是main方法则会向上抛出给JVM由JVM中断处理。
（2）try...catch  捕获异常

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

5.什么是进程，什么是线程？
一个应用程序至少包含一个进程，一个进程至少包含一个线程
（1）进程：进入到内存的程序，就是一组功能的程序。
（2）线程：CPU和任务之间的执行通道。是执行任务的单元。