黑马程序员技术交流社区
标题: 【厦门校区JavaEE就业6期-每日总结】异常、线程 [打印本页]
作者: 厦门校区 时间: 2019-3-25 16:13
标题: 【厦门校区JavaEE就业6期-每日总结】异常、线程
今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
1.throw和throws的区别？
2.什么时候需要声明异常，什么时候不需要声明异常？
3.异常有几种处理方式？
4.什么是并发，什么是并行？
5.什么是进程，什么是线程？
6.run()方法和start()方法的区别？
作者: 黑马六期-董安平 时间: 2019-3-25 20:48
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()方法只能调用一次
作者: 黑马六期-董安平 时间: 2019-3-25 20:49
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()方法只能调用一次
作者: 魏政 时间: 2019-3-25 21:13
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，宏观上让所有线程一起执行，也叫并发。
作者: 魏政 时间: 2019-3-25 21:13
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，宏观上让所有线程一起执行，也叫并发。
作者: 魏政 时间: 2019-3-25 21:14
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，宏观上让所有线程一起执行，也叫并发。
作者: 曾伟清 时间: 2019-3-25 21:30
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方法。
作者: 陈伟彬 时间: 2019-3-25 21:31
1.throw和throws的区别？
答：
throw：是将异常进行抛出；
throws：是对抛出的异常进行声明，让调用者处理；
2.什么时候需要声明异常，什么时候不需要声明异常？
答：
编译期的异常抛出后，必须进行声明；而运行期的异常可以不进行声明，会默认交给JVM去处理
3.异常有几种处理方式？
答：
一共有两种；
throws：将抛出的异常进行声明给调用者；
try...catch：将抛出的异常进行捕获处理；
4.什么是并发，什么是并行？
答：
并发：短时间切换执行多个线程，即多个线程在同一时间段内执行；
并行：同时执行多个线程，即多个线程同一时刻执行；
5.什么是进程，什么是线程？
答：
进程：一个在内存运行的程序；
线程：进程中的一个执行单位；
即一个程序里可以有多个进程，而一个进程里可以包含多个线程；
6.run()方法和start()方法的区别？
答：
区别：
run方法是运行一段代码；而start方法是开启新线程，让run方法运行；
如果直接调用run方法，只是调用了一个类方法，还是单线程运行并不能开启多线程运行；而调用了start方法，start方法会开启一个新线程，来执行run方法，从而实现多线程运行的目的；
作者: 郑海波 时间: 2019-3-25 21:31
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()方法依旧是单线程的运行方式。
作者: 陈志铖 时间: 2019-3-25 21:32
1.throw和throws的区别？
throw关键字，它用来抛出一个指定的异常对象。
如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理.
2.什么时候需要声明异常，什么时候不需要声明异常？
编译时异常一定要声明异常,运行期不一定声明异常
3.异常有几种处理方式？
两种 throws try..catch
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多
个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创
建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程
中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
6.run()方法和start()方法的区别？
该run()方法的方法体就代表了线程需要完成的任务
调用线程对象的start()方法来启动该线程
作者: 陈驰煜 时间: 2019-3-25 21:32
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方法中的内容.
作者: 罗加铭 时间: 2019-3-25 21:32
1.throw和throws的区别？
答：throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行；关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常)
2.什么时候需要声明异常，什么时候不需要声明异常？
答：运行异常不需要声明异常，编译异常需要声明异常
3.异常有几种处理方式？
答：两种处理方式，一种是将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理
另一种是在方法中使用try-catch的语句块来处理异常。
4.什么是并发，什么是并行？
答：
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序
6.run()方法和start()方法的区别？
答：run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体；start()方法用来启动该线程
作者: 李伟艺 时间: 2019-3-25 21:34
今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
1.throw和throws的区别？
throw是抛出异常
throws是声明异常
2.什么时候需要声明异常，什么时候不需要声明异常？
如果没有j将抛出的异常进行捕捉处理，就需要声明异常，让调用者去处理
反之不用声明异常
3.异常有几种处理方式？
两种
1.使用try...eatch来处理异常
2.使用声明异常throws，让调用者处理
4.什么是并发，什么是并行？
并发:CPU在一段时间内处理多个线程
并行：在同一时间内处理多个线程
5.什么是进程，什么是线程？
进程是指在内存中运行的应用程序
线程是进程中的一个执行单位
6.run()方法和start()方法的区别？
staet（）方式是开启线程，而run（）只是一个普通的方法
作者: 魏政 时间: 2019-3-25 21:36
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，宏观上让所有线程一起执行，也叫并发。
作者: 林艺彬 时间: 2019-3-25 21:37
今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
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()方法：是启动线程对象的方法。
作者: 龚荣章 时间: 2019-3-25 21:42
1.throw和throws的区别？
throw关键字，它用来抛出一个指定的异常对象。
如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理.
2.什么时候需要声明异常，什么时候不需要声明异常？
编译时异常一定要声明异常,运行期不一定声明异常
3.异常有几种处理方式？
两种 throws try..catch
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多
个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创
建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程
中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
6.run()方法和start()方法的区别？
该run()方法的方法体就代表了线程需要完成的任务
调用线程对象的start()方法来启动该线程
作者: 魏政 时间: 2019-3-25 21:44
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，宏观上让所有线程一起执行，也叫并发。
作者: 高坂火龙果 时间: 2019-3-25 21:44
黄志斌：
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()方法中所写的内容.
作者: javawjs 时间: 2019-3-25 21:45
王佳盛
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（）方法。
作者: 刘曾铭 时间: 2019-3-25 21:48
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和任务之间的执行通道。是执行任务的单元。
作者: 龙舟 时间: 2019-3-25 21:48
1.throw和throws的区别？
①throw关键字，它用来抛出一个指定的异常对象。
②关键字throws运用于方法声明之上,用于表示当前方法不处理异常,
而是提醒该方法的调用者来处理异常(抛出异常).
2.什么时候需要声明异常，什么时候不需要声明异常？
如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理。
3.异常有几种处理方式？
①多个异常分别处理。
②多个异常一次捕获，多次处理
③多个异常一次捕获一次处
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，
一个应用程序可以同时运行多个进程；
进程也是程序的一次执行过程，是系统运行程序的基本单位；
系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，
一个进程中至少有一个线程。一个进程中是可以有多个线程的，
这个应用程序也可以称之为多线程程
6.run()方法和start()方法的区别？
run方法是单线程，start方法是多线程
作者: 李煜霖 时间: 2019-3-25 21:50
throw关键字是指人为地抛出一个异常
throws运用于方法声明之上，表示在编译期遇到异常不做处理的情况下，提醒该方法的调用者来处理这个异常
2.什么时候需要声明异常，什么时候不需要声明异常？
运行期异常或运行期异常的子类可以不声明异常
编译期异常需要声明异常
3.异常有几种处理方式？
运行期异常或运行期异常的子类可以不处理，交给JVM处理
编译期异常就只能往上抛给JVM处理（throws）或者用try...catch接收异常
4.什么是并发，什么是并行？
并发：一段（很短）时间执行的数量，是交替执行的
并行：是同时执行的，在同一时间点上，一定有很多个线程被CPU正在执行
5.什么是进程，什么是线程？
进程：计算机中的一组功能
线程：计算机中的任务的一个执行单元（CPU和任务之间的通道）
6.run()方法和start()方法的区别？
run()方法是只在主线程中调用一个fun()方法，没有开启一个新的线程
而start()方法是开启了一个新的线程，在新的线程中调用run()方法
作者: 开心的小孩 时间: 2019-3-25 21:50
陈鹏涛
今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
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 方法。
作者: java基础6期刘伟 时间: 2019-3-25 21:50
1.throw和throws的区别？
throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).
2.什么时候需要声明异常，什么时候不需要声明异常？
如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异 常需要声明异常。
父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能用声明异常抛出 。
3.异常有几种处理方式？
三种：抛出，捕获，声明。
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多 个进程；
进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创 建、运行到消亡的过程。
线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。
一个进程 中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
6.run()方法和start()方法的区别？
start（）是开启线程的对象，而run（）JVM虚拟机调用的
作者: 管文祥 时间: 2019-3-25 21:50
今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
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()方法却是同步的因此也就无法达到多线程的目的。
作者: 黄振明 时间: 2019-3-25 21:50
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():用于启动线程
作者: 黑马6期陈华 时间: 2019-3-25 21:50
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（）方法：是自定义线程类对象的启动方法，调用了此方法，才能实现自定义线程类对象的启动，这将创建一个新的线程与主线程同步执行。
作者: Wyt1935 时间: 2019-3-25 21:50
、吴元陶：
1.throw和throws的区别？
throw关键字，它用来抛出一个指定的异常对象。
如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理.
2.什么时候需要声明异常，什么时候不需要声明异常？
编译时异常一定要声明异常,运行期不一定声明异常
3.异常有几种处理方式？
两种 throws try..catch
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多
个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创
建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程
中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
6.run()方法和start()方法的区别？
该run()方法的方法体就代表了线程需要完成的任务
调用线程对象的start()方法来启动该线程
作者: zhaizhile 时间: 2019-3-25 21:50
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()方法
作者: 王旭艺 时间: 2019-3-25 21:51
1.throw和throws的区别？
答：throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束
当前方法的执行；关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒
该方法的调用者来处理异常(抛出异常).
2.什么时候需要声明异常，什么时候不需要声明异常？
答：运行异常不需要声明异常，编译异常需要声明异常
3.异常有几种处理方式？
答：两种处理方式，一种是将问题标识出来，报告给调用者。如果方法内通过throw抛出了
编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理
另一种是在方法中使用try-catch的语句块来处理异常。
4.什么是并发，什么是并行？
答：并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程
序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统
运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一
个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序
6.run()方法和start()方法的区别？
答：run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体；
start()方法用来启动该线程
作者: 管文祥 时间: 2019-3-25 21:51
今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
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()方法却是同步的因此也就无法达到多线程的目的。
作者: 卢勇炜 时间: 2019-3-25 21:52
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()方法用来启动该线程，
作者: 徐代成 时间: 2019-3-25 21:53
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()方法的
作者: 张广发 时间: 2019-3-25 21:53
1.throw和throws的区别？
throw关键字，它用来抛出一个指定的异常对象。
如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理.
2.什么时候需要声明异常，什么时候不需要声明异常？
编译时异常一定要声明异常,运行期不一定声明异常
3.异常有几种处理方式？
两种 throws try..catch
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多
个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创
建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程
中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
6.run()方法和start()方法的区别？
该run()方法的方法体就代表了线程需要完成的任务
调用线程对象的start()方法来启动该线程
作者: 陈前凌 时间: 2019-3-25 21:53
1.throw和throws的区别？
throws是用来声明一个方法可能抛出的所有异常信息 ；通常不用显示的捕获异常，可由系统自动将所有捕获的异常信息抛给上级方法；
throw则是指抛出的一个具体的异常类型；需要用户自己捕获相关的异常，而后在对其进行相关包装，最后在将包装后的异常信息抛出。
2.什么时候需要声明异常，什么时候不需要声明异常？
编译期异常是需要程序员自己处理的，处理的方式有两种，一种是声明异常，这时候需要对异常进行声明。另一种是用try...catch处理异常，这时候不用对异常进行声明；
运行期的异常可以不用程序员自己处理，可以不用对异常进行声明。
3.异常有几种处理方式？
处理的方式有两种，一种是声明异常，这时候需要对异常进行声明。另一种是用try...catch处理异常，这时候不用对异常进行声明
4.什么是并发，什么是并行？
并发：多个时间同一时间段发生
并行：多个时间同一时刻发生
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序
6.run()方法和start()方法的区别？
在多线程中,如果创建的对象直接调用run()方法,那么只是执行了该方法,并不是开启了线程,而使用start()方法调用的话,则是表示开启新的线程,并执行run()方法中所写的内容
作者: 陈鉴 时间: 2019-3-25 21:54
1.throw和throws的区别？
throw关键字，它用来抛出一个指定的异常对象。
如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理.
2.什么时候需要声明异常，什么时候不需要声明异常？
编译时异常一定要声明异常,运行期不一定声明异常
3.异常有几种处理方式？
两种 throws try..catch
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多
个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创
建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程
中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
6.run()方法和start()方法的区别？
该run()方法的方法体就代表了线程需要完成的任务
调用线程对象的start()方法来启动该线程
作者: 林志鹏 时间: 2019-3-25 21:54
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()方法却是同步的因此也就无法达到多线程的目的。
作者: 余建强 时间: 2019-3-25 21:54
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()方法
作者: 叶彬彬 时间: 2019-3-25 21:54
1.throw和throws的区别？
throw：用在方法内，用来抛出一个异常对象，将异常对象传递到调用者处，并结束当前方法的执行
throws：用于方法的声明之中，表示该方法对异常不作处理，而是提醒该方法的调用者处理异常
2.什么时候需要声明异常，什么时候不需要声明异常？
编译期异常，需要声明
运行期异常，不一定需要声明
3.异常有几种处理方式？
抛出异常：抛出异常对象，将异常对象传递到调用者处，用于方法中
声明异常：将问题标识出来，不处理，提醒调用者处理
捕获异常：对异常语句进行捕获，并处理
4.什么是并发，什么是并行？
并发：在一个时间段里，进行多个事件
并行：在同一个时刻进行多个事件
5.什么是进程，什么是线程？
进程：一组功能的集合，是进入到内存的程序
线程：CPU和任务之间的执行通道，是任务的执行单元
6.run()方法和start()方法的区别？
run()方法是线程需要完成的任务
start()方法是线程执行的入口
作者: 廖艺铭 时间: 2019-3-25 21:55
1.throw和throws的区别？
throw：用来抛出一个指定的异常对象
throws：用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常)
2.什么时候需要声明异常，什么时候不需要声明异常？
当抛出的异常是运行期异常不需要声明
编译期异常需要声明
3.异常有几种处理方式？
两种
声明异常throws
捕获异常try…catch
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生
并行：指两个或多个事件在同一时刻发生（同时发生）
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多
个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创
建、运行到消亡的过程
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程
中是可以有多个线程的，这个应用程序也可以称之为多线程程序
6.run()方法和start()方法的区别？
run：设置线程任务
start：开启新的线程,执行run方法
作者: JavaEE06蒋才东 时间: 2019-3-25 21:55
1.throw和throws的区别？
throw是抛出异常，是运行程序时才会报出异常，不会影响编译
throws是声明异常，是编译程序时会报出异常，会影响编译失败
2.什么时候需要声明异常，什么时候不需要声明异常？
当方法内部抛出编译异常对象时需要声明异常
当方法内部抛出的是运行异常时不需要声明异常
3.异常有几种处理方式？
1. 多个异常分别处理。
2. 多个异常一次捕获，多次处理。
3. 多个异常一次捕获一次处理。
4.什么是并发，什么是并行？
并发是两个以上事件在短时间内发生
并行是两个事件以上在同一时刻同时发生
5.什么是进程，什么是线程？
进程是进入内存中的程序，一组功能的集合
线程是进程中的一个执行单元
6.run()方法和start()方法的区别？
run()方法里的方法体是线程需要完成的任务
start()方法是调用这个对象的方法来启动线程，执行run()方法
作者: 黄成龙 时间: 2019-3-25 21:56
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()方法：线程启动的方法
作者: 钟扬辉 时间: 2019-3-25 21:56
1.throw和throws的区别？
throw:用在方法内，用来抛出指定的异常对象
throws：继续将问题声明出去
2.什么时候需要声明异常，什么时候不需要声明异常？
将异常向方法的调用处抛出，自己不处理。
如果向自己进行异常处理，就不需要声明异常，用捕获异常
3.异常有几种处理方式？
两种方式，声明和捕获
4.什么是并发，什么是并行？
并发：一个时间段之内，发生多件事情
并行：在同一时间点上，有多个事情正在执行
5.什么是进程，什么是线程？
进程：一组功能的集合，是进入到内存的程序
线程：cpu和任务之间的执行通道，是任务的执行单元
6.run()方法和start()方法的区别？
run()方法的方法体就代表了线程需要完成的任务,因此把 run()方法称为线程执行体。 调用线程对象的start()方法来启动该线程
作者: 厦门第六期刘鹏 时间: 2019-3-25 21:56
1.throw和throws的区别？
throw关键字，它用来抛出一个指定的异常对象。
如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理.
2.什么时候需要声明异常，什么时候不需要声明异常？
编译时异常一定要声明异常,运行期不一定声明异常
3.异常有几种处理方式？
两种 throws try..catch
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多
个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创
建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程
中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
6.run()方法和start()方法的区别？
该run()方法的方法体就代表了线程需要完成的任务
调用线程对象的start()方法来启动该线程
作者: 黑马林伟明 时间: 2019-3-25 21:56
1.throw和throws的区别？
throw：用在方法内，用来抛出一个异常对象，将异常对象传递到调用者处，并结束当前方法的执行
throws：用于方法的声明之中，表示该方法对异常不作处理，而是提醒该方法的调用者处理异常
2.什么时候需要声明异常，什么时候不需要声明异常？
编译期异常，需要声明
运行期异常，不一定需要声明
3.异常有几种处理方式？
抛出异常：抛出异常对象，将异常对象传递到调用者处，用于方法中
声明异常：将问题标识出来，不处理，提醒调用者处理
捕获异常：对异常语句进行捕获，并处理
4.什么是并发，什么是并行？
并发：在一个时间段里，进行多个事件
并行：在同一个时刻进行多个事件
5.什么是进程，什么是线程？
进程：一组功能的集合，是进入到内存的程序
线程：CPU和任务之间的执行通道，是任务的执行单元
6.run()方法和start()方法的区别？
run()方法是线程需要完成的任务
start()方法是线程执行的入口
作者: 庄家琦 时间: 2019-3-25 21:56
一.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()方法来启动该线程
作者: 黄杰南 时间: 2019-3-25 21:56
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()方法中所写的内容.
作者: 唐彬桂 时间: 2019-3-25 21:58
今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
1.throw和throws的区别？
throw是抛出异常
throws是解决异常的一种方法，他是直接抛给JVM解决。
2.什么时候需要声明异常，什么时候不需要声明异常？
编译期异常时需要声明异常，运行期异常不需要声明异常
3.异常有几种处理方式？
两种
1.throws
2.try .... catch
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，
一个应用程序可以同时运行多 个进程；进程也是程序的一次执行过程，
是系统运行程序的基本单位；系统运行一个程序即是一个进程从创 建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，
一个进程中至少有一个线程。一个进程 中是可以有多个线程的，
这个应用程序也可以称之为多线程程序
6.run()方法和start()方法的区别？
run()方法是定义线程的任务。
start()方法是开启线程
作者: chenopen 时间: 2019-3-25 21:58
陈开明：
1.throw和throws的区别？
throw:定义在方法内，用来抛出一个指定的异常，将这个异常对象传递到调用者处，并结束当前方法的执行。
throws：运用于方法声明之上，用于表示当前方法不处理异常，而是提醒该方法的调用者来处理异常（抛出异常）。
2.什么时候需要声明异常，什么时候不需要声明异常？
当异常属于编译时异常时候，需要声明异常；当异常属于运行时异常时候，不需要声明异常。
3.异常有几种处理方式？
如果属于运行时异常，不需要处理，只要抛出异常，JVM会自动处理这些异常。
如果属于编译时异常。有两种处理方式。
方式一：交给别人处理。可以使用throws关键字处理异常类，会把异常对象抛出给方法的调用者处理，
最终交给JVM处理，使用throws处理程序会停止。
方式二：自己处理。使用try...catch...处理。遇到异常后，会继续执行下面的程序。
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生。
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
6.run()方法和start()方法的区别？
run()方法的方法体代表了线程需要完成的任务，因此把run()方法称为线程执行体。
start()方法用来开启线程。
作者: 6期江岳 时间: 2019-3-25 21:58
1.throw和throws的区别？
throw是在方法进行数据判断是否合法时，如果不合法则抛出该异常。
throws是当出现异常时，不解决而是声明异常让调用处解决该异常。
2.什么时候需要声明异常，什么时候不需要声明异常？
如果时运行期异常可以不声明，是编译期异常如果不捕获就一定需要声明该异常。
3.异常有几种处理方式？
两种：（1）try...catch捕获处理异常（2）throws声明异常让调用处处理。
4.什么是并发，什么是并行？
并发：在一个时间段内发生的；
并行：在同一个时间点同时发生的；
5.什么是进程，什么是线程？
进程：是一组功能的集合，进入内存的程序
线程：一个功能与CPU的执行通道，是任务的执行单元
6.run()方法和start()方法的区别？
run()是Thread中的运行方法，所有需要运行的代码都需要写在run()方法里
start()是开起子线程的方法，其中会自动调用run()执行其中的代码
作者: omasoo 时间: 2019-3-25 21:59
李伟斌
1.throw和throws的区别？
答：throw关键字是在创建自定义异常时使用。
throws关键字是处理异常的一种方法。
2.什么时候需要声明异常，什么时候不需要声明异常？
答：编译时异常一定要声明异常,运行期不一定声明异常
3.异常有几种处理方式？
答：两种处理方式throws和try..catch。
4.什么是并发，什么是并行？
答：并发是一段时间内发生的，并行是一瞬间发生的。
5.什么是进程，什么是线程？
答：进程是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多
个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创
建、运行到消亡的过程。
线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程
中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
6.run()方法和start()方法的区别？
run（）调用要执行的方法。
start（）是线程启动的方法。
作者: 沈松宏 时间: 2019-3-25 23:20
今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
1.throw和throws的区别？
throw写在方法内,throws写在方法名后
throw是将异常抛出,
throws是对抛出的异常进行声明
2.什么时候需要声明异常，什么时候不需要声明异常？
编译异常需要声明异常,运行异常不需要声明异常
3.异常有几种处理方式？
throws和try..catch
4.什么是并发，什么是并行？
并发指的是两件事在同一时间段内发生
并行指的是两件事在同一时刻发生
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多
个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创
建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程
中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
6.run()方法和start()方法的区别？
直接调用run()方法不会创建新线程,会在主线程中执行;
start()方法会创建一个新线程来执行run方法中的内容.
作者: 林奕全 时间: 2019-3-25 23:27
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()方法依然是单线程的运行方式。
作者: 叶振鹏 时间: 2019-3-25 23:54
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()方法只能调用一次
作者: 吴越 时间: 2019-3-26 09:49
1.throw和throws的区别？
答：throw关键字用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
throws关键字用在方法声明处，对于方法内通过throw抛出的编译时异常，如果没有捕获处理，就需要通过throws进行声明，将问题标识出来。
2.什么时候需要声明异常，什么时候不需要声明异常？
答：如果方法内通过throw抛出编译时异常，而没有捕获处理，那么必须通过throws进行声明异常，将问题标识出来。
如果抛出的编译时异常被捕获处理，或者抛出的是运行期异常，则不需要声明异常。
3.异常有几种处理方式？
答：异常有两种处理方式：一种是进行try...catch捕获处理，另一种就是继续将问题声明出去，使用throws声明处理。
4.什么是并发，什么是并行？
答：并发：指两个或多个事件在同一个时间段内发生（交替执行）。
并行：指两个或多个事件在同一时刻发生（同时执行）。
5.什么是进程，什么是线程？
答：进程：一个应用程序可以同时运行多个进程，每个进程都有一个独立的内存空间，是系统运行程序的基本单位。
线程：是CPU和任务之间的执行通道，是任务的执行单元，一个进程中可以有多个线程。
一个应用程序可以有多个进程，一个进程可以有多个线程。
6.run()方法和start()方法的区别？
run()方法的方法体代表了线程需要完成的任务,把run()方法称为线程执行体；
start()方法用于启动线程，本身并没有记载线程相关的任务。
作者: 卢春旭 时间: 2019-3-26 21:40
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，宏观上让所有线程一起执行，也叫并发。
作者: 小翔vvvv 时间: 2019-3-26 21:47
叶凌青
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，宏观上让所有线程一起执行，也叫并发。
作者: 蓝建华 时间: 2019-3-26 21:50
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方法中调用它的话就直接创建了一
作者: LIUXIAOMING 时间: 2019-3-29 23:13
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()方法却是同步的因此也就无法达到多线程的目的。
作者: 厦门第六期刘鹏 时间: 2019-3-30 21:43
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，宏观上让所有线程一起执行，也叫并发。
作者: 陈志铖 时间: 2019-3-30 21:56
声明异常把异常抛出给调用的方法,最终可以让虚拟机处理,中断程序;
try...catch自己处理异常,程序可以继续运行
作者: 陈鉴 时间: 2019-3-30 21:57
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()方法却是同步的因此也就无法达到多线程的目的。
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |