今天我们继续学习了Api和异常体系，请根据自己的理解回答下面问题：
1.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
2.throw和throws的区别？
3.什么时候需要声明异常，什么时候不需要声明异常？
4.异常有几种处理方式？

1.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类就是基本数据类型对应的引用数据类型
区别：
基本数据类型          包装类
byte                        Byte   
short                       Short
int                           Integer
long                        Long
float                        Float
double                    Float
char                        Character
boolean                  Boolean
自动装箱：把基本数据类型转换为对应的包装类类型
自动拆箱：把包装类类型转换为对应的基本数据类型
注意：
引用数据类型需要判断其是否为空值null，
空值在调方法等操作时会出现空指针异常
自动拆箱时会调用intValue()方法

2.throw和throws的区别？
throw是在方法体中使用，作用是抛出一个创建好的异常对象（可以是自定义异常，也可以是提供好的异常），只要在该位置抛出的异常符合业务场景的
throws在方法的声明上使用的，表示该方法在执行的时候，可能会产生某些异常，如果有多个异常产生，需要使用“，”分隔开，在方法声明上声明了异常，不代表方法就一定会产生这个异常，只是可能会产生这个异常
3.什么时候需要声明异常，什么时候不需要声明异常？
编译代码的时候，可能会出现两种异常：编译期异常以及运行期异常
当是运行期异常时，不需要处理，可以使用JVM默认处理方案
当是编译期异常时，则必须处理这个异常，需用try...catch或者throws声明此异常

4.异常有几种处理方式？
异常处理方式有两种
Try…carch:
使用try代码块捕获异常，将有可能产生异常的代码方法try中
Catch:会匹配try中出现的异常，对应给出异常的处理方案，一般来说将异常信息记录到日志文件中（开发中的处理方案），现在是学习阶段，直接将异常信息打印到控制台上
throws
将异常向上抛给方法的调用处，调用处拿到这个异常再次进行选择处理方案，直到将异常抛到main方法，main方法抛给他的调用者JVM，JVM会将异常信息打印到控制台，中断程序

1.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：将数据类型进行封装，然后放入一个类中，这个类为包装类
区别：包装类多元化，基本类型比较单一
自动装箱：基本类型转换成对应的包装类型
自动拆箱：把包装类型转换成对应的基本类型
2.throw和throws的区别？
throw是在方法体中使用
throws是在方法的声明上使用

3.什么时候需要声明异常，什么时候不需要声明异常？
方法在执行时，可能产生某些异常时，需要在方法上声明异常
在方法体中发生异常时，可以不需要声明异常

4.异常有几种处理方式？
两种处理方式
try...catch …或者 throws，如果采用 throws 这种方案， 将来谁调用谁处理

今天我们继续学习了Api和异常体系，请根据自己的理解回答下面问题：

1.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？

将基本类型封装成对象就是包装类。
包装类可以在对象中定义更多的功能方法操作该数据
自动装箱和自动拆箱，即编译器会自动进行基本数据类型和包装类类型的转换，不需要我们手动给出方法操作。
Integer i = 10; //自动装箱
i += 100; // 自动拆箱 自动装箱  Integer.valueOf(Integer.intvalue(i)+100)

2.throw和throws的区别？

throw:
在方法体内，后面跟的是异常对象名
表示抛出异常，由方法体内的语句处理
执行throw  一定是抛出了某种异常
两种处理方式：try...catch..  和 throws
throws:
用在方法声明后面，跟的是异常类名
表示抛出异常，谁调用该方法谁处理该异常
表示有可能出现该异常，不一定会出现

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


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

1.try...catch  自己在代码中给出出现异常的处理方案：
程序从 try 里面的代码开始执行
出现异常，就会跳转到对应的 catch 里面去执行
执行完毕之后，程序还可以继续往下执行，但try里面在异常出现之后的代码不执行了
  2.throws   向上抛，由调用者处理，如果都不处理，最后由JVM按默认方式处理
  
  
  
  
  
  
  
  
  

1.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类是对象,拥有方法和字段.对象的调用都是通过引用对象的地址
包装类是引用传递 而基本类型是值传递

自动装箱：当使用一个基本数据类型给包装类型赋值的时候
自动拆箱：当使用包装类类型和基本类型做运算的时候


2.throw和throws的区别？
throw：抛出一个异常，后面跟的是异常对象，该异常对象可以是自定义的也可以是java提供好的
throws：方法中可能产生的异常类型
3.什么时候需要声明异常，什么时候不需要声明异常？
编译期时候需要声明异常，运行期不需要声明异常

4.异常有几种处理方式？
try catch方式处理异常
throw throws方式处理异常

今天我们继续学习了Api和异常体系，请根据自己的理解回答下面问题：

1.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：将基本数据类型封装成对象。
区别：基本数据类型的包装类可以在对象中定义更多的方法对该基本数据进行操作，
          最常见的是将基本数据类型和String（字符串）之间进行转换。
自动装箱：将基本数据类型转化成对应的包装类。
自动拆箱：将包装类转化成对应的基本数据类型。


2.throw和throws的区别？
（1）throws：
       在方法声明后面，跟的是异常类名；
       表示抛出异常，由方法的调用者来处理；
       表示出现异常的可能性，并不一定会发生异常；
       在方法的声明上使用的，表示该方法在执行的时候，可能会产生某些异常，如果有多个异常产生，
需要使用“，”分隔开，在方法声明上声明了异常，不代表方法就一定会产生这个异常，只是可能会产生这个异常。
（2）throw：
        在方法体内，跟的是异常对象名；
        表示抛出异常，由方法体内的语句处理；
        执行throw一定抛出了某种异常；
        是在方法体中使用，作用是抛出一个创建好的异常对象（可以是自定义异常，也可以是提供好的异常），
只要在该位置抛出的异常符合业务场景的。


3.什么时候需要声明异常，什么时候不需要声明异常？
编译时异常
:  - 都是Exception类及其子类， 必须显示处理，否则程序就会发生错误，无法通过编译
。
运行时异常:
  - 都是RuntimeException类及其子类， 无需显示处理，也可以和编译时异常一样处理
。
当程序发生异常时，如果我们用try....catch来处理的话就不用声明异常
如果我们用throws来处理的话就要声明异常。


4.异常有几种处理方式？
异常处理方式有两种
1，Try…catch:
Try：    使用try代码块捕获异常，将有可能产生异常的代码方法放在try中。
Catch:  会匹配try中出现的异常，对应给出异常的处理方案，一般来说将异常信息记录到日志文件中（开发中的处理方案），
            现在是学习阶段，直接将异常信息打印到控制台上。
2，throws：
     将异常向上抛给方法的调用处，调用处拿到这个异常再次进行选择处理方案，直到将异常抛到main方法，
      main方法抛给他的调用者JVM，JVM会将异常信息打印到控制台，中断程序

1.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
答：包装类使基本数据类型变为引用数据类型
       自动装箱：使基本数据类型转换成对应的包装类
       自动拆箱：是包装类转换成对应的基本数据类型

2.throw和throws的区别？
答：throw 关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到 throw 语句时立即停止，
它后面的语句都不执行。
       throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。
当在主函数中调用该方法时，如果发生异常,就会将异常对象抛给方法调用处。

3.什么时候需要声明异常，什么时候不需要声明异常？
答：当编译时可能会出现异常的时候需要声明异常

4.异常有几种处理方式？
答： 异常的处理方式有两种,分别是使用 throws 和 try...catch...finally
        1. throws 用在方法的声明上后接异常类名,是把异常抛给调用者进行处理
        2.  try...catch...finally 是捕获异常,自己处理,处理完毕后面的程序可以继续运行，
             try 代码块中是可能出现异常的代码，
            catch 代码块,是遇到异常,对异常进行处理的代码，
            finally 代码块是无论是否发生异常,都必须执行的代码,用于释放资源.

1.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类是将基本数据类型封装成对象,经过包装后的基本数据类型会是一个引用数据类型
自动装箱是指将基本数据类型自动转换成引用数据类型,隐藏了方法valueOf,如: String i= 5;
自动拆箱是指将引用数据类型自动转换成基本数据类型,隐藏了方法parseInt,如:int i = "234";

2.throw和throws的区别？
throw位于方法体中,后面跟的是异常对象名,表示抛出一个异常,由方法体内的语句处理,throw 一定抛出一个异常,可以是自定义异常,也可以是提供好的异常
throws位于方法声明后,后面跟的是异常类名,表示抛出一个异常,由方法的调用者处理,throws表示异常是一种可能,并不一定会发生异常

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

4.异常有几种处理方式？
两种处理方法:
Try…carch:
使用try代码块捕获异常，将有可能产生异常的代码方法try中
Catch会匹配try中出现的异常，对应给出异常的处理方案
throws:
将异常向上抛给方法的调用处，调用处拿到这个异常再次进行选择处理方案，直到将异常抛到main方法，main方法抛给他的调用者JVM，JVM会将异常信息打印到控制台，中断程序

1.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类可以将基本数据类型封装成对象，可以在对象方法中进行对这个数据的操作。
基本类型无法进行创建对象。
自动装箱是一个基本数据类型在转化为包装类是不需要再通过手动调用方法进行转化在底层已经自动实现了装箱操作。
自动拆箱是当一个包装类转化成对应的基本数据类型时可以不需要通过手动调用方法就可以实现转化。

2.throw和throws的区别？
throw是使用在方法体中的，用于抛出异常，当执行到throw时，throw后面的程序就不再继续执行。
thows使用在方法的声明时，用来指定可能抛出的异常，当有多个异常时可以通过逗号隔开，如果发生异常就会想异常抛给方法调用处。

3.什么时候需要声明异常，什么时候不需要声明异常？
当程序中有可能出现异常时需要声明异常

4.异常有几种处理方式？
异常有两种处理的方式：
一种是try...catch抓取异常，try{}中是可能出现异常的代码，catch（出现异常的类名）{出现异常需要执行的语句。
第二种是抛出异常throws，将异常抛指方法调用处，让其再进行异常处理是否抓取或者抛出。

1.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
将基本数据类型封装成对象；
自动装箱是把基本数据类型转换为对应的包装类类型；

自动拆装是把包装类类型转换为对应的基本数据类型；


2.throw和throws的区别？
答：throw：用在方法体内，表示抛出异常，由方法体内的语句处理，执行了throw就一定抛出某种异常
    throws：用在方法声明后面，表示抛出异常，由调用者处理，表示存在异常的可能性，不一定会有异常


3.什么时候需要声明异常，什么时候不需要声明异常？
答：编译异常需要声明，运行异常不需要声明

4.异常有几种处理方式？
答：两种，try-catch和throws。
try-catch执行流程：
1.程序从 try 里面的代码开始执行
2.出现异常，JVM会创建一个异常类型的对象，给catch中的e变量赋值
3.跳转到对应的 catch 里面去执行
4.执行完毕之后，程序还可以继续往下执行，是main方法中的程序继续往下执行，但是try中的代码是不会往下执

Throws执行流程：调用者有两种方案，捕获异常或继续向上抛，如果一直向上抛，会直到main方法，直到JVM做默认处理。

今天我们继续学习了Api和异常体系，请根据自己的理解回答下面问题：

1.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
        答：基本数据类型对应的核心类。包装类是引用数据类型。基本数据类型可以直接赋值给对应包装类对象，包装类对象可以直接参与对应的基本数据类型运算，因为编译器会自动添加基本数据类型转包装类对象和包装类对象转基本数据类型的方法。

2.throw和throws的区别？
        答：1.位置不同：throw在方法体后面跟异常对象，throws在方法参数列表后面，后面跟异常类名。2.作用不同：throw用于手动抛出新的异常对象，此时一定有异常对象产生。throws用于将可能出现的异常对象向上抛出，由调用者处理。

3.什么时候需要声明异常，什么时候不需要声明异常？
        答:当代码可能会出现异常时可以在定义方法时用throws抛出，这样每个调用它的方法都会接受到这个异常信息，可以选择处理或者继续向上抛。是一个提醒作用。

4.异常有几种处理方式？
        答：两种：try{}catch(){}和Throws。try{}catch(){}能够处理异常，Throws将异常继续向上抛，直到被try{}catch(){}处理，或者被虚拟机默认处理。

1.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？

将基本数据类型封装成对象；可以用于定义方法；

自动装箱是把基本数据类型转换为对应的包装类类型；

自动拆装是把包装类类型转换为对应的基本数据类型；

2.throw和throws的区别？

throw用在方法体内，跟的是异常对象名，抛出异常由方法体内的语句处理；

throws用在方法声明上，跟的是异常类名，抛出异常由该方法的调用者处理，出现的异常只是种可能性，不一定会发生；

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

编译时异常需要声明，运行时异常不需要声明；

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

两种：try...catch；和throws；

1.基本数据类型对应的引用类型对象，称为基本数据类型的包装类，包装类是引用数据类型
自动装箱：即将基本数据类型直接赋值给对应的引用类型时所发生的封装操作
自动拆箱：即将包装类的数据直接赋值给基本数据类型时所发生的拆箱操作

2.throw，抛出一个异常类，该异常类可以是我们自己写的类，也可以是Java提供的异常类
throws，代码可能抛出的异常

3.当异常属于编译期异常时，需要声明异常，当该异常属于运行时异常时不需要声明异常

4.异常的处理方式
a.jvm默认处理：创建异常对象，打印异常信息到控制台，并结束程序
b.使用try...catch：将可能出现异常的代码写在try代码块中，当出现异常时，由catch捕获，并对异常进行处理
c.使用throws：向上抛出异常到代码的调用处，若非main方法，则可继续选择处理方案，直至main方法，main方法抛出给jvm，由jvm进行默认处理。

1.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类是基本数据类型对应的引用数据类型。 JDK1.5加入的新特性 基本数据类型可以直接赋值给对应的包装类。

2.throw和throws的区别？
throw是写在方法里面的 执行时会创建一个异常对象并抛出该异常对象，throws是在方法定义后面 表示该方法有可能出现throws后面写的异常类型

3.什么时候需要声明异常，什么时候不需要声明异常？
编译时异常必须要声明异常，而运行时异常则不需要声明

4.异常有几种处理方式？
try...catch 捕获异常并给出解决方案
throws 将异常抛给调用者，如果调用者不处理则会一直向上抛最终会到JVM由虚拟机处理
运行时异常不去处理则会由虚拟机默认处理该异常

1.将基本数据类型封装成对象的类。包装类可以用在集合中，提供了更多的方法，用于操作基本数据，更加便于基本数据类型和字符串之间的转换。
自动将基本数据类型转换为包装类即为自动装箱。自动将包装类转换为基本数据类型。
2.1. throw 关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到 throw 语句时立即停止， 它后面的语句都不执行。 2. throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。 当在主函数中调用该方法时，如果发生异常，就会将异常对象抛给方法调用处。
3.当异常可能会影响程序的编译的时候，需要声明异常，编译期异常就需要。
运行时异常不需要声明异常，RuntimeException类及其子类。
4.
2种，throws和try..catch
throws 用在方法的声明上后接异常类名,是把异常抛给调用者进行处理 。
try...catch...finally 是捕获异常,自己处理,处理完毕后面的程序可以继续运行 a) try 代码块中是可能出现异常的代码 b) catch 代码块,是遇到异常,对异常进行处理的代码 c) finally 代码块是无论是否发生异常,都必须执行的代码,用于释放资源.

今天我们继续学习了Api和异常体系，请根据自己的理解回答下面问题：

1.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
答：包装类是引用数据类型，内有对应类型的数值的成员属性，它是为了基本数据的引用类型的包装而生。
能进行基本数据类型和引用数据类型的转化，也有其他的方法可以进行数值的操作。
自动拆装箱机制，是java对频繁的数值与对象的转化的操作，进行优化的一种机制，内里本质仍然是调用包装内的方法。
在进行转化时，该机制自动完成类型的转化，不需要主动去操作。自动拆装箱，需要注意，引用类型的null值时的情况。

2.throw和throws的区别？
答：前者，使用在方法体中，与异常的情景进行匹配，编写了“当遇到这种异常的场景时，抛出的对应的类型的异常对象”
这么一种应激程序，这里是必然会构造异常对象的。throw可以对应自定义的异常类对象，也能对应jdk提供的异常类。
后者，使用在方法的方法定义（函数头），中，格式可以跟一个或者多个异常对象，用逗号相隔。它只有实际产生了异常，
才会向外抛出动作

3.什么时候需要声明异常，什么时候不需要声明异常？
答：进行自定义处理异常时，在try结构中，需要对应于异常的场景，进行new对应的异常对象。
当采用虚拟机默认的处理方案时，或者向外抛出时，不需要声明异常。

4.异常有几种处理方式？
答：异常有两种处理方式，一，通过try 。。catch结构，进行处理。二，通过throw进行处理

1.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类使基本数据类型变为引用数据类型
自动装箱：使基本数据类型转换成对应的包装类
自动拆箱：是包装类转换成对应的基本数据类型

2.throw和throws的区别？
使用的位置不同，throw是必然会抛出异常
throws是有抛出异常的可能性，不一定会执行。

3.什么时候需要声明异常，什么时候不需要声明异常？
当编译时可能会出现异常的时候需要声明异常

4.异常有几种处理方式？
异常处理方式有两种

1.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
解：把基本数据类型包装成引用对象类型。
       区别是一个是基本类型，一个是引用类型。
       基本类型转换成引用类型为自动装箱。
       引用类型转换成基本类型为自动拆箱。
2.throw和throws的区别？
解：区别是throw在方法中抛出异常对象，throws在方法声明后面抛出一个或多个异常。
3.什么时候需要声明异常，什么时候不需要声明异常？
解：编译期异常时，必须声明异常，对异常处理，否则无法通过编译。
      运行时，不检测异常，不需要声明。
4.异常有几种处理方式？
解：两种。try/catch：try包裹可能发生异常的代码，catch捕获异常对象，并且处理异常，可以用三种方式打印异常信息：（1）e.printStackTrace();输出异常类型，信息，出现位置（2）String message=e.getMessage();输出异常信息（3）String s=e.toString();打印异常类型，信息。
    throws在方法声明上抛出异常，代表该方法暂不处理该异常，抛给调用该方法的调用者来处理这个异常，如果调用者不处理，那就继续向上抛，直到没人处理交给jvm虚拟机对异常的默认处理。

今天我们继续学习了Api和异常体系，请根据自己的理解回答下面问题：

1.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？
包装类：将基本数据类型封装成对象。
区别：可以在对象中定义更多的功能方法操作该数据

自动装箱：把基本数据类型转换为对应的包装类类型

自动拆箱：把包装类类型转换为对应的基本数据类型

2.throw和throws的区别？

Throw是在方法体重使用，作用是抛出一个创建好的异常对象（可以是自定义，也可以是java提供好的）
                只要再该位置抛出的异常 符合业务场景的


Throws是在方法的声明上使用的，表示该方法在执行的时候，可能会产生某些异常，如果有多个异常，
用”， “隔开，在方法上声明了异常，不代表方法就一定会产生这个异常，只是可能会产生这个异常

       
3.什么时候需要声明异常，什么时候不需要声明异常？
可能发生异常的时候需要声明异常
程序正常执行的时候不需要声明异常

4.异常有几种处理方式？
有俩种处理方式
try...catch  
throws

1.什么是包装类，和基本类型有什么区别？什么是自动装箱和自动拆箱？

包装类就是对类的封装，可以通过包装类转换成字符串

自动装箱是包装一个对象中的原始数据类型类型的值
自动拆箱是将包装类转换成基本数据类型


2.throw和throws的区别？
throw是用在方法体内，跟的是异常对象名，表示抛出异常，由方法体的语句处理，执行throw一定抛出了某种异常

throws 是用在方法声明后面，跟的是异常类名，表示抛出异常，有该方法的调用者来处理，表示出现异常的一种可能性，不一定会发生这些异常



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

如果是运行期异常就不用申明异常，如果是编译期异常就需要申明异常

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

异常处理方案


1.JVM的默认处理方案


1.产生了一个运行期异常，对应运行期异常来说，编译器是不强求处理的


2.当程序产生一个运行期异常，而我们又没有对它进行处理的时候，JVM虚拟机会处理该异常


3.JVM会创建一个该异常对象，这个对象中包含了异常的信息，异常产生的位置


4.JVM会在控制台调用异常对象的方法，并将这些信息打印在控制台


5.停止程序





2.自己处理方案

解决的是出现异常程序停止问题

两种方案

2.1.try...catch捕获处理

将可能会产生异常的代码，使用try包裹起来，在catch中指定的产生异常的类型，和对应的处理方案，如果产生异常，回去执行catch代码块中的代码，执行完后会继续执行（main方法中的）程序，不会停止



2.2throws 向上抛出

如果使用throw处理异常，会将产生的异常，抛给方法的调用者，调用者拿到这个异常，调用也会有两种方案：捕获异常或者继续向上抛，如果所有的调用者都不进行处理，该异常会被抛到main方法，main方法会再向上抛给JVM，JVM拿到异常，做的默认处理