包装类和异常

包装类

定义：专门将简单数据类型的数据进行封装，形成对应的包装类

基本数据类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
double	Double
float	Float
char	Character
boolean	Boolean

装箱拆箱：

手动装箱

概念：由基本数据类型，完成向对应的包装类型进行转换

作用：为了更好的存储

方式1：

可以通过每一个包装类的构造方法来完成。在每一个包装类的构造方法中，都有一个与之对应的基本数据类型作为参数的重载方法。此时，直接将需要包装的基本数据类型，写到构造方法的参数中即可完成装箱

Byte b = new Byte((byte)1);
Short s = new Short((short)2);
Integer i = new Integer(3);
Long l = new Long((long)4);
Float f = new Float((float)5.0);
Double d = new Double(6.0);
Character c = new Character('a');
Boolean bool = new Boolean(false);

方式2：

Byte b = Byte.valueOf((byte)1);
Short s = Short.valueOf((short)2);
Integer i = Integer.valueOf(3);
Long l = Long.valueOf((long)4);
Float f = Float.valueOf((float)5.0);
Double d = Float.valueOf(6.0);
Character c = Character.valueOf('a');
Boolean bool = Boolean.valueOf(true);

手动拆箱：

概念：由包装类型，完成向对应的基本数据类型进行转换

作用：为了方便计算

方式：

Byte b = Byte.valueOf((byte)100);
byte newB = b.byteValue();

Short s = Short.valueOf((short)100);
short newS = s.shortValue();

Integer i = Integer.valueOf(100);
int newI = i.intValue();

Long l = Long.valueOf((long)100);
long newL = l.longValue();

Float f = Float.valueOf((float)100.0);
float newF = f.floatValue();

Double d = Double.valueOf(100.0);
double newD = b.doubleValue();

Character c = Character.valueOf('a');
char newC = c.charValue();

Boolean bool = Boolean.valueOf(true);
boolean newBool = bool.booleanValue();

备注：

某些包装类对象，除了可以拆箱成对应的基本数据类型的数据之外，还可以将包装起来的数组转成其他的基本数据类型的数据。例如：Integer，除了有intValue之外，还有byteValue等方法。其实，就是将包装类中包装起来的int数据，强转为byte类型返回结果。在使用的时候，找自己需要的方法去转型即可

自动装箱拆箱

概念：

所谓的自动装箱和自动拆箱，指的是在进行装箱和拆箱的时候，不再使用上面的方法完成装箱和拆箱的操作，在JDK1.5之后，装箱和拆箱是可以自动完成的！只需要一个赋值语句即可

方式：没有什么特殊语法，直接进去赋值即可

//自动拆箱:由一个基本数据类型，到对应的包装类型的转换，只需要一个赋值语句即可完成
Integer i = 10;
//自动拆箱:由一个包装类型，到对应的基本数据类型的转换。只需要一个赋值语句即可完成
int newI = i;

注意：虽然已经有了自动的装箱和拆箱，但是还需要掌握手动的装箱和拆箱，是因为有些情况下，自动的装箱和拆箱无法使用

/*
如果在一个类的重载方法中，有两个方法的参数类型，一个是基本数据类型，一个是对应的包装类型。此时，将无法使用自动装箱和拆箱，必须通过手动的装箱和拆箱完成对应的方法的调用
*/
public static void main(String[] args){
    //此时，10会最先匹配到int类型的参数
    show(10);
    show(Integer.valueOf(10));
}
public static void show(int a){
    System.out.println("我是int型")
    System.out.println(a);
}
public static void show(Integer a){
    System.out.println("我是Integer型")
    System.out.println(a);
}

享元原则：

概念：

享元原则是程序设计的一个基本原则。当我们需要在程序中频繁的使用到一些元数据的时候，此时，我们可以提前将这些元数据准备好，当需要的时候，可以直接拿过来使用，使用完成之后，也可以不进行销毁，以便下次继续使用

包装类中的享元：

将常用到的基本数据类型对应的包装类对象预先存储起来，当使用到这些基本数据类型对应的包装类对象的时候，可以直接拿过来使用，不需要再实例化新的对象

示例：Integer类中，将[-128,127]范围内的数字对应的包装类对象预先存储到了一个Integer.cache数组中，每当我们用到这个范围内的数字的时候，可以直接从这个数组中获取到元素。如果用到了不在这个范围内的数字，再去进行新的包装类对象的实例化，这样，不用频繁的开辟空间，销毁空间，节省了CPU资源

//此时，由于10在缓存范围内，因此可以直接从数组中获取包装类对象
Integer i1 = Integer.valueOf(10);
Integer i2 = Integer.valueOf(10);
System.out.println(i1 == i2);

//此时，由于200不在缓存范围中，因此这个方法会返回一个性的包装对象
Integer i3 = Integer.valueOf(200);
Integer i4 = Integer.valueOf(200);
System.out.println(i3 == i4);

字符串和基本数据类型转换

基本数据类型转型成字符串

概念：

基本数据类型，转成字符串，希望得到的结果是这个数值转成字符串的样式。其实，就是直接给个数字添加上双引号

方式1：

可以将字符串拼接运算符完成。当加号两端有任意一方是字符串的时候，此时都会自动的把另一方也转成字符串，完成字符串的拼接。所以，当需要把一个基本数据类型的书库转成字符串时，只需要在另一拼接上一个空字符串即可

int a = 10;
String str = a + "";

方式2（推荐）：使用String包装类的valueOf完成

String str = String.valueOf(10);

方式三：借助包装类的实例方法toString方法

String str = Integer.valueOf(10).toString();

方式四：借助包装类的静态方法toString方法

String str = Integer.toString();

字符串类型转型基本数据类型

概念：

字符串类型转基本数据类型，其实就是解析出这个字符串中的内容，转型成对应的基本数据类型的表示

注意事项1：基本数据类型转字符串肯定是没有问题的，但是由字符串转到基本数据类型的时候，可能出现问题，字符串中的内容，不一定能够转成希望转成的基本数据类型，如果转换失败，会出现NumberFormatException异常

注意事项2：对于整数来说，字符串如果出现了其他的非数字的字符，都会导致转整数失败，即便是小数点，也不可以转，这里并没有转成浮点数字，再转整数的过程

方式1：使用包装类的静态方法valueOf方法

Integer num = Integer.valueOf("123");

方式二：使用包装类的静态方法parseXXX方法。这里的XXX就是要转换的基本数据类型

int num = Integer.parseInt("123");

备注：以上两种方式，都可以完成字符串类型到基本数据类型之间的转换。如果希望直接转成基本数据类型，推荐使用方式2；如果希望转成包装类型，推荐使用方式1

关于字符类型的特殊说明：

字符串类型，没有类似与上面的方式，可以直接转成字符类型，如果一个字符串，要转成字符，需要使用字符串的一个实例方法charAt（）。使用这个方法，获取字符串中的指定下标位的字符

实现进制之间的转换：

把十进制转成其他进制

Integer.toHexString() //转十六进制

Integer.toOctalString() //转八进制

Integer.toBinaryString() //转二进制

把其他进制转成十进制

Integer.parseInt(数据，进制);

常用类

常用类Math

概念：是一个数学类，这个类中封装了很多用来做数学计算的方法，当我们需要使用到数学计算的时候，要能够想到这个类，这个类中有很多封装好的数学公式，而且都是静态方法，方便调用

常用静态常量

属性	描述	值
PI	圆周率	3.14159265358979323846
E	自然对数	2.7182818284590452354

常用方法：

方法	描述
abs	计算一个数字的绝对值
max	计算两个数字的最大值
min	计算两个数字的最小值
round	计算一个数字的四舍五入
floor	计算一个数字的向下取整
ceil	计算一个数字的向上取整
pow	计算一个数字的指定次幂
sqrt	计算一个数字的平方根
random	获取一个[0,1)范围内的浮点型随机数

常用类Random

概念：是一个专门负责产生随机数的类，在java中，Random类在java.util包中，在使用之前需要导包

（其实，随机数的产生，是有一个固定的随机数算法，带入一个随机数种子，能够生成一个随机数列。但是由于算法时固定的，因此会出现一个BUG，如果随机数的种子相同，那么生成的随机数列也完全相同）

常用方法：

方法	参数	描述
Random	无	通过将系统时间作为随机数种子，实例化一个Random对象
Random	int	通过一个指定的随机数种子，实例化一个Random对象
nextInt	int	生成一个[0,bounds)范围内的整型随机数
nextInt	无	生成一个int范围内的随机数
nextFloat	无	生成一个[0,1)范围的float类型的随机数
nextDouble	无	生成一个[0,1)范围的double类型的随机数
nextBoolean	无	随机生成一个boolean数值

常用类BigInteger，BigDecimal

概念：

这两个类，都是用来表示数字的类，BigDecimal表示浮点型数字，BigInteger表示整型数字。这两个类，可以用来描述非常，非常，非常大的数字，例如整数，long时最大的白哦是范围，但即便是long型，也有它表示不了的情况，BigInteger就是可以表示任意大小的数字

BigInteger：表示整型数字，不限范围

BigDecimal：表示浮点型数字，不限范围，不限小数点后面的数位

常用方法：

方法	参数	描述
构造方法	String	通过一个数字字符串实例化一个对象
add	BigInteger/BigDecimal	加
subtract	BigInteger/BigDecimal	减
multipy	BigInteger/BigDecimal	乘
divide	BigInteger/BigDecimal	除
divideAndRemainder	BigInteger/BigDecimal	除，保留商和余数，将商存到结果数组的第0位，将余数存到结果数组的第1位
xxxValue		转成指定的基本数据类型的结果

常用类Date

概念：是一个用来描述时间，日期的类

比较Data和Date类

Date：日期类
Data：数据类，装的是二进制的数据

java.util.date和java,sql.date包

Java.util.date:对应的是java的日期类型，包括年月日，时分秒
java.sql.date:对应的是数据库的日期类型，只包括年月日
如果需要数据类型和在哪换，从java.sql.date转成java.util.date是自动类型转换，反之是强制类型转换

常用方法：

方法	参数	描述
Date		实例化一个Date对象，来描述系统当前时间
Date	long	通过一个指定的时间戳，实例化一个Date对象，描述指定的时间
getTime		获取当前系统的时间（long型的毫秒数）
equals	Date	判断两个时间是否相同

常用类SimpleDateFormat

概念：是一个用来格式化时间的类，使用这个类，一般两种操作

将一个Date对象，转成指定格式的时间字符串

将一个指定格式的时间字符串，转成Date对象

常用方法：

方法	参数	描述
SimpleDateFormat	String	通过一个指定的时间格式，实例化一个对象
format	Date	将一个Date对象转成指定格式的字符串
parse	String	将一个指定格式的时间字符串，解析成Date对象

paser方法：

将一个字符串，按照指定格式的格式进行解析，如果字符串中的时间格式，和对象实例化的时间给定的格式不同，此时会出现异常

等等…

枚举

枚举的定义：定义枚举类型，需要使用关键字enum，枚举的名字是一个标识符，遵循大驼峰命名

public enum Gender{
    //将这个枚举对象所能取到的值，都列出来
    //枚举中的元素，也是标识符，遵循大驼峰命名法
    Male,Femal
}
public enmu Month{
    Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec
}
public enmu Week{
    Mon,Tue,Wed,Thu,Fri,Sat,Sun
}

枚举的使用：

枚举是一种自定义的数据类型，可以声明变量，在使用的时候，直接使用枚举类型.枚举值这样的形式进行枚举值的获取

public class Test{
    public static void main(String[] args){
        //枚举的使用
        Gender gender1 = Gender.Male;
        Gender gender2 = Gender.Female;
        
        Month m1 = Month.Jan;
        Month m2 = Month.Nov;
        Week week1 = Week.Sat;
    }
}

枚举的理解：

枚举本质上属于Object的一个最终子类，枚举中的元素实际上是枚举（类）的一个静态的，当前类的对象。在枚举中可以添加，普通方法，以及属性

异常：

异常的结构：

在java当中，用Throwable类来买哦书所有的不正常的情况。Throwable有两个子类：

Exception和Error

Error:描述发生在JVM虚拟机级别的错误信息，这些错误信息无法被处理

StackOverflowError：栈溢出错误

Exception:描述程序遇到的异常，异常是可以被捕获处理的

未经处理的异常，会导致程序无法进行编译或者运行，因此在异常部分，重点内容是：异常该如何捕获处理

java中的异常的继承体系：
根类：Throwable
	错误：Error
	异常：Exception
		运行时异常：RunTimeException

异常的分类：

1.根据异常发生的位置

第一：普通的异常，会导致程序无法完成编译。这样的异常称之为编译时异常（NonRunTime Exception）

第二：Exception有一个子类：RunTimeException，在这个类中，对异常进行了自动的处理。这种异常不会影响程序的编译，但是在运行中如果遇到了这种异常，会导致程序执行强制停止，这样的异常称为：运行时异常（RunTimeException）

2.根据创建异常类的主体

第一：系统异常

第二：自定义异常

异常的工作原理：

不捕获就向上抛

异常的捕获处理：

程序一遇异常就终止，不会继续向下走

异常的捕获处理：

try-catch
try-多catch
try-catch-finally
try-finally

两个关键字：

throw：一个异常对象，被实例化完成后，没有任何意义，不影响程序的编译或者运行
throws：用在方法的声明部分，写在参数列表的后面