一、数据类型简介：
 
1.JavaScript（以下简称js）的数据类型分为两种：原始类型（即基本数据类型）和对象类型（即引用数据类型）；
 
2.js常用的基本数据类型包括undefined、null、number、boolean、string；
 
3.js的引用数据类型也就是对象类型Object，比如：Object、array、function、data等；
 
二、基本数据类型特点：
 
1.基本数据类型是按值访问的，就是说我们可以操作保存在变量中的实际的值；
 
2.基本数据类型的值是不可变的，任何方法都无法改变一个基本数据类型的值，比如一个字符串：
 
  let name = 'zhangsan'
  name.substr()
  console.log(name) // 输出：zhangsan
  let age = 'firstblood'
  age.toUpperCase()
  console.log(age) // 输出：firstblood
 
通过上面的例子，我们可以发现原来定义的变量name的值始终没有发生改变，而调用substr()和toUpperCase()方法后返回的是一个新的字符串，跟原来定义的变量name并没有什么关系。
 
再看下面的代码：
 
  let name = 'zhangsan'
  name = 'lisi'
  console.log(name) // 输出：lisi
 
上面的例子看来name的值好像“改变了”，这里的基础数据类型是string，也就是“zhagnsan”，这里的“zhangsan”是不可以改变的，name只是指向“zhagnsan”的一个指针，指针的指向不可以改变，所以下面的name = 'lisi'，将name指向了“lisi”，这里的“lisi”也是不可以改变的。也就是说这里的改变只是“指针指向的改变”。
 
3.基本数据类型不可以添加属性和方法：
 
  let user = 'zhangsan'
  user.age = 18
  user.method = function () {
    console.log('12345')
  }
  console.log(user.age) // 输出：undefined
  console.log(user.method) // 输出：undefined
 
上面的代码可以看出，基本数据类型是不能添加属性和方法的，再次说明基本数据类型是不可变的。
 
4.基本数据类型的赋值是简单的赋值（如果从一个变量向另一个变量赋值基本类型的值，会在变量对象上创建一个新值，然后把该值赋值到位新变量分配的位置上）：
 
  let a = 18
  let b = a
  a++
  console.log(a) // 输出：19
  console.log(b) // 输出：18
 
上面的代码，a中保存的值是18，当使用a的值来初始化b时，b中也保存了值18，但是b中的18和a中的18完全是独立的，b中的值只是a中值的一个副本，所以这两个变量可以参与任何操作而不会相互影响。
 
5.基本数据类型的比较是值的比较：
 
  var a = '{}'
  var b = '{}'
  console.log(a === b) // 输出：true
 
6.基本类型的值在内存中占据固定大小的空间，被保存在栈内存中。（从一个变量向另一个变量复制基本类型的值，会创建这个值的一个副本）；
 
假如有以下几个基本类型的变量：
 
  let name = 'zhangsan'
  let age = 18
  let weight = '60kg'
 
他的存储结构如下图（栈区包括了变量的标识符和变量的值）：
 
 
三、基本数据类型详解：
 
1.number类型
 
①number类型包含整数和浮点数（浮点数数值必须包含一个小数点，且小数点后至少有一位数字）。
 
浮点数会自动转换为整数，如下：
 
  let num = 1.00
  console.log(num) // 输出：1，自动转换为了整数
 
②浮点数的最高精度是17位，看下面的例子：
 
  let a = 0.1
  let b = 0.2
  console.log(a + b) // 输出：0.30000000000000004
 
上面的例子，结果竟然不是0.3，至于其他变成语言，也会遇到这种情况（关于浮点数计算会产生误差问题，其他有些变成语言也会出现类似情况。）
 
③NaN：非数字类型，特点：涉及到任何关于NaN的操作，都会返回NaN，而且NaN不等于自身。如下：
 
  let name = 'lisi'
  console.log(name / 10) // 输出：NaN
  console.log(NaN === NaN) // 输出：false
 
④isNaN()函数用于判断是否是一个非数字类型，如果传入的参数是一个非数字类型，那么返回true，否则返回false；
 
⑤isNaN()函数传入一个参数，函数会先将参数转换为数值，如果参数类型为对象类型，会先调用对象的valueOf()方法，再确定该方法返回的值是否可以转换为数值类型，如果不能，再调用对象的toString()方法，再确定返回值；
 
⑦数值转化：
 
Number()，转型函数，可以用于任何数据类型
 
parseInt()，将值转换为整型，用的较多
 
parseFloat()，将值转换为浮点型
 
2.string类型
 
①字符串类型中的单双引号作用一样；
 
②字符串有length属性，可以取得字符串的长度：
 
  let str = 'Hello world'
  console.log(str.length) // 输出：11
 
③字符串的值是不可变的，要改变一个字符串的值，首先要销毁原来的字符串，再用另一个包含新值得字符串区填充该字符串；
 
④字符串转换：
 
String()，转型函数，适用于任何数据类型（null，undefined转换后为null和undefined）
 
toString()方法可以把一个逻辑值转换为字符串，并返回结果（null、undefined没有toString()方法）
 
  let ab = 'zhangsan'
  let bc = null
  let cd = undefined
  console.log(ab.toString())  // 输出：zhangsan
  // console.log(bc.toString())  // error 报错
  // console.log(cd.toString())  // error 报错
  console.log(String(ab))  // 输出：zhangsan
  console.log(String(bc))  // 输出：null
  console.log(String(cd))  // 输出：undefined
 
3.boolean类型
 
①这个类型只有两个值，true和false；
 
②Boolean()，转型函数，将某个值转换为Boolean类型
 
4.null类型
 
①null类型被看做空对象指针，只有一个值，即null值，所以在用typeof操作符去检测null类型的值得时候，结果是object类型；
 
②如果你定义了一个变量，但是想在以后把这个对象当做一个对象来使用，最好将该对象初始化为null值
 
5.undefined类型
 
①只有一个值，即undefined，如果声明了一个变量，但是未给变量初始化值，那么这个变量的值就是undefined：
 
  let name = 'zhangsan'
  let age
  console.log(name) // 输出：zhangsan
  console.log(age) // undefined，因为声明了age，但是没有给初始化值
 
②调用函数时，应该提供的参数没有提供，该参数等于undefined；
 
③对象没有赋值的属性，该属性的值为undefined；
 
④函数没有返回值，默认返回undefined。
 
 
 
 
 
 
 
参考文章：
 
https://mp.weixin.qq.com/s/YMpKnUUKPPIG6FD6CGzfTg  
 
http://www.jb51.net/article/101341.htm

C51基本数据类型
 
C51中基本数据类型主要是指变量类型。变量是指其值可以改变的量。一个变量实质上是代表了内存中的某个存储单元。程序中的变量a，就是指用a命名的某个存储单元，用户对变量a进行的操作就是对该存储单元进行的操作；给变量a赋值，实质上就是把数据存人该变量所代表的内存单元中。
 
变量有类型的区分，如整形变量、实型变量、字符型变量等。C语言在定义变量的同时说明该变量的类型，系统就能根据定义及其类型为它分配相应数量的存储空间。C51中变量类型与通用C语言基本相同，C51基本变量类型如表1.5.1所示。
 
表1.5.1 C51基本变量类型
 
 
数据类型
 
 
长度
 
 
值域
 
 
unsigned char
 
 
单字节
 
 
0-255
 
 
char
 
 
单字节
 
 
-128-127
 
 
unsigned int
 
 
双字节
 
 
0-65535
 
 
int
 
 
双字节
 
 
-32768-32767
 
 
unsigned long
 
 
四字节
 
 
0-232-1
 
 
long
 
 
四字节
 
 
-231-231-1
 
 
float
 
 
四字节
 
 
3.4e-38-3.4e38
 
 
*
 
 
1-3字节
 
 
对象的地址
 
注：C51中int与short相同，float与double相同，在表中就不列出了。另外unsigned前缀表示无符号类型，无前缀表示有符号类型，即signed类型。
 
每种基本变量类型介绍如下：
 
（1）char类型
 
即字符型变量，长度是一个字节，通常用于定义处理字符数据的变量或常量。分无符号字符类型unsigned char和有符号字符类型char，默认值为char类型。unsigned char类型用字节中所有的位来表示数值，所可以表达的数值范围是0～255。char类型用字节中最高位字节表示数据的符号，“0”表示正数，“1”表示负数，负数用补码表示。所能表示的数值范围是-128～+127。注意：这种数据类型在C51中最常见，因为51单片机是8位单片机，其内部寄存器绝大部分都是8位，故而8位字符变量与8位的字符型变量可以直接进行数据交换。
 
（2）int类型
 
即整型变量，长度为两个字节，用于存放一个双字节数据。分有符号整型数int和无符号整型数unsigned int，默认值为int类型。int表示的数值范围是-32768～+32767，字节中最高位表示数据的符号，“0”表示正数，“1”表示负数。unsigned int表示的数值范围是0～65535。
 
（3）long类型
 
即长整型变量，长度为四个字节，用于存放一个四字节数据。分有符号长整型long 和无符号长整型unsigned long，默认值为long类型。long表示的数值范围是-2147483648～+2147483647，字节中最高位表示数据的符号，“0”表示正数，“1”表示负数。unsigned long表示的数值范围是0～4294967295。
 
（4）float类型
 
即浮点型变量，在十进制中具有7位有效数字，是符合IEEE－754标准的单精度浮点型数据，占用四个字节。因浮点数的结构较复杂在此不做详细的讨论。另外由于double类型与float类型一样也是占用四个字节，故在此也不讨论。
 
（5）*类型
 
即指针类型，其本身就是一个变量，在这个变量中存放的指向另一个数据的地址。这个指针变量要占据一定的内存单元，对不同的处理器长度也不尽相同，在C51中它的长度一般为1～3个字节。
 
 
 
 

 
基本数据类型和封装类型的区别
 
基本数据类型
基本数据类型介绍
   
封装数据类型
基本数据类型对应的封装类介绍
   
基本数据类型与封装类对应关系对照表
String类
他们的区别
总结
 

 
基本数据类型
 
首先,我们应该想了解什么是Java基本数据类型.通俗的说,按照字面意思就是我们学java语言最基本要知道的类型,可以说如果你连最基本的类型都不知道就好比你建房子不知道砖块是什么东西一样.
 
Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
 
基本数据类型介绍
 
 
byte类型:
 
   byte 数据类型是8位、有符号的，以二进制补码表示的整数；
   最小值是 -128（-2^7）；
   最大值是 127（2^7-1）；
   默认值是 0；
   byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
   例子：byte a = 100，byte b = -50。
 
 
short类型:
 
	short 数据类型是 16 位、有符号的以二进制补码表示的整数
	最小值是 -32768（-2^15）；
	最大值是 32767（2^15 - 1）；
	Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
	默认值是 0；
	例子：short s = 1000，short r = -20000。
 
 
int类型 (初学者最常见的类型)
 
	int 数据类型是32位、有符号的以二进制补码表示的整数；
	最小值是 -2,147,483,648（-2^31）；
	最大值是 2,147,483,647（2^31 - 1）；
	一般地整型变量默认为 int 类型；
	默认值是 0 ；
	例子：int a = 100000, int b = -200000。
 
 
long类型
 
	long 数据类型是 64 位、有符号的以二进制补码表示的整数；
	最小值是 -9,223,372,036,854,775,808（-2^63）；
	最大值是 9,223,372,036,854,775,807（2^63 -1）；
	这种类型主要使用在需要比较大整数的系统上；
	默认值是 0L；
	例子： long a = 100000L，Long b = -200000L。
	"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。
 
 
float类型
 
	float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
	float 在储存大型浮点数组的时候可节省内存空间；
	默认值是 0.0f；
	浮点数不能用来表示精确的值，如货币；
	例子：float f1 = 234.5f。
 
 
double类型
 
	double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
	浮点数的默认类型为double类型；
	double类型同样不能表示精确的值，如货币；
	默认值是 0.0d；
	例子：double d1 = 123.4。
 
 
boolean类型
 
	boolean数据类型表示一位的信息；
	只有两个取值：true 和 false；
	这种类型只作为一种标志来记录 true/false 情况；
	默认值是 false；
	例子：boolean one = true。
 
 
char类型
 
	char类型是一个单一的 16 位 Unicode 字符；
	最小值是 \u0000（即为0）；
	最大值是 \uffff（即为65,535）；
	char 数据类型可以储存任何字符；
	例子：char letter = 'A';。
 
 
注意
 
此处没有Sring类型,八大类型中不包括String类型,许多初学者会误以为String类型是基本数据类型.其实不是的.Sring类型虽然常用,但他是封装类型.为什么是封装类型,以下会讲明原因
 
封装数据类型
 
既然提供了基本类型，为什么还要使用封装类呢？(具体可百度,这里只是粗略讲下)
 
java是一种面向对象语言,在面向对象程式设计方法中，封装（英语： Encapsulation）是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。
 封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。
 要访问该类的代码和数据，必须通过严格的接口控制。
 封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。
 适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。
 
通俗一点来说,将基本数据类型比作建房子所需要的砖块.封装类就是将砖块包装一下,贴上一些标识,加上一些水泥.这样我们在用的时候方便查找哪块砖放哪,同时砖块也更加坚固了(因为加上了水泥).
 
封装的优点
 
 
良好的封装能够减少耦合。
 
 
类内部的结构可以自由修改。
 
 
可以对成员变量进行更精确的控制。
 
 
隐藏信息，实现细节。
 
 
基本数据类型对应的封装类介绍
 
基本数据类型一般将单词首字母大写即可得到所对应的的封装类.为什么说一般呢,因为有几个特殊的.一下列列举了八大基本数据类型对应的封装类
 
	byte	基本数据类型 对应 Byte		封装类
	short 	基本数据类型 对应 Short		封装类
	int		基本数据类型 对应 Interger	封装类
	long	基本数据类型 对应 Long		封装类
	float	基本数据类型 对应 Float		封装类
	double	基本数据类型 对应 Double		封装类
	boolean	基本数据类型 对应 Boolean	封装类
	char	基本数据类型 对应 Character	封装类
 
基本数据类型与封装类对应关系对照表
 
 
String类
 
注意.String是一个单独的封装类,他没有对应的基本数据类型.它也是常用的封装类,具体常用方法可以查询JDK_API.
 
他们的区别
 
我会用最简单的例子讲解int类型和Interger的区别.其他的大家可以自行测试,这样可以加强自己的记忆.毕竟自己动手和听别人讲是两种学习方式.古人云,读万卷书,不如行万里路也是这个道理.
 
    public static void main(String[] args) {
        Integer integer=new Integer(5);
        int  a=5;

        System.out.println("我是int数据类型,我的值为 : "+ a);
        System.out.println("我是Integer封装类型,我的值为 : "+integer);
        
    }
}
 
可以看到int类型和Interger创建是用了不同的方法.
 创建Interger类时,我们需要New一个Integer(),然后传入一个参数5,而int直接取个名在赋值一个5;然后打印结果,看一下他们的结果是否一样
 
 可以看到他们输出的值都是5,你会问了.这没啥不一样啊?.别急,我们改进一下代码再看一看也不迟.
 
    public static void main(String[] args) {
        Integer integer=new Integer(5);
        int  a=5;


        System.out.println("我是int数据类型,我的值为 : "+ a);
        System.out.println("我是Integer封装类型,我的值为 : "+integer);

        if(integer==a){
            System.out.println("我们是一样的,我们没有区别!!");
        }else{
            System.out.println("我们不一样,你是白云,我是黑土!!");
        }
    }
}
 

 我去,你看,又相同了…
 额,容我解释一下,这里涉及到的自动拆箱的知识了.大家也可以具体百度一下这里的知识,通过上面的代码可以发现,如果你只是引用他们的值得话,他们是没有区别的.
 
而他们的区别在于Integer是一个类,他可以调用类的方法,而int基本数据类型不行.列如已下的例子,他们相加不会等于10,而是会等于55,因为integer调用了toString()方法将integer的赋值转化为字符串了,整数型加字符串结果会等于字符串.
 
    public static void main(String[] args) {
        Integer integer=new Integer(5);
        int  a=5;


        System.out.println("我的结果是: ");
        System.out.println(a+integer.toString());

    }
}
 

 这里还有许多方法我就不一一列举了.最常用的就那么几种.现在编辑器可以直接调用出来,
 
 
总结
 
基本数据类型和对应封装类如果你只是想使用他们具体的赋值,他们之间本质上是没有区别的.如果你不单单想用一个赋值,是想用里面的方法解决许多繁琐的问题.那就使用封装类吧.因为封装类就是在基本类型不够用的的基础上一出来的.封装类提供了许多的方法供君选择.它可以简化程序员的敲代码的量.由于这是我第一次写博客,如果有什么错误可以在评论里指出来.也可以一起交流代码问题,共同学习,共同进步.
 
大家也可以关注我哦,以后会不定时更新更多有趣好玩的代码知识,共同学习,共同进步

详解一、八种基本数据类型常识
 
1.1、基本常识表
 
 
对于上图有以下几点需要注意：
 
java八种基本数据类型分为四类八种，四类分别为整型、浮点型、布尔型、字符型；八种分别为byte、short、int、long、float、double、boolean、char；
java八种基本数据类型的字节数:分别为1、2、4、8个字节；1字节(byte、boolean)、 2字节(short、char)、4字节(int、float)、8字节(long、double)；
整数的默认类型为int，浮点数的默认类型为double；
八种基本数据类型的包装类：除了char的是Character、int类型的是Integer，其他都是首字母大写
关于值的范围问题，需要注意char类型是无符号的，不能为负，所以是0开始的；
详解二、直接量与类型转换
 
2.1、直接量
 
整数型的直接量默认为int类型
浮点型的直接量默认为double类型
@Test
	public void d() {
		int a=100;//这个100就是直接量
		a=a+100;//但是这个a+100不是直接量
		double b=3.14;
	}
 
2.2、类型转换
 
1.自动转换：低类型的向高类型的转换 
 
        如下图：顺着箭头的方向是可以自动转换的；
 
 
2.强制转换：高类型的向底类型转换，但可能会数据溢出或者精度丢失
 
 
 
以上现象在实际中可以出现这三种问题：
 
定义变量时出现的类型转换
@Test
	public void e(){
		long a=200;//200是直接量，默认为int类型这里是自动转换为弄类型
		
		/*long b=100000000000;*/
		//100000000000是个整数直接量，默认应该为int类型，但是超出了int类型的取值范围
		
		long c=1000000000000L;
		//在整数直接量后面将了一个L，表示该直接量不再默认为int类型，为long类型，所以没错
		
		/*float d=34.3;*/
		//浮点型直接量默认为double,double类型大，所以不能直接转换为float
		
		float e=34.3f;
		//在浮点数直接量后面加上一个f，表示该直接量不再默认为double，为float类型
	}
 
    以上为几种正常的情况，但是有一种特殊的情况，就是int型直接量可以直接赋给byte、short、char类型变量，只要不超出变量类型的取值范围
 
@Test 
	public void f() {
		byte a=100;
		short b=200;
		char c=100;//注意char类型是一种特殊的int类型，可以不用写成单引号括起来的
		
		/*byte d=128;直接量128超出了byte类型的取值范围*/
		
		/*char e=-1;直接量-1不在char类型的取值范围内*/
		
	}
 
 
 
 
数据运算时的类型转换
 
          （1）运算时，运算结果会向较大的类型转换
 
@Test
	public void g() {
		int a=3;
		double b=4;
		System.out.println(a+b);//输出7.0
		
		float c=3.2f;
		/*c=c+3.14; 编译错误,运算之后变为double类型*/	
	}
 
         （2）特殊的：byte、short、char三种数据类型参与运算时，先一律转化为int类型；
 
	@Test
	public void h() {
		byte a=3;
		byte b=4;
		/*byte c=a+b;
		 * 编译错误,此处由于byte类型参与运算时，先直接转换为int类型，
		 * 所以最后的结果也是int类型，但是得出的结果不能叫做int类型的直接量，所以编译错误
		 * */
		int d=a+b;
	}
 
强制转换
          高等级转为低等级的时候，必须强制转换，但实际工作中不推荐使用强制转换，可能会失精度或数据溢出；
 
@Test
	public void j() {
		int a=128;
		byte b=(byte)a;
		System.out.println(b);//输出-128，出现了数据溢出
		
		double c=1.23;
		int d=(int)c;
		System.out.println(d);//输出1，精度丢失
	}
 
       补充说明：不是只有强制转换的时候会出现数据，例如下面这种情况
 
@Test
	public void k() {
		int a=10000000;
		int b=10000000;
		int c=a*b;
		System.out.println(c);//输出276447232，得到的结果超出了int类型的范围，数据溢出
	}
 
详解三、对应包装类及使用
 
3.1、基本介绍
 
       java是一门面向对象的语言，但是8中基本数据类型不具备面向对象的特征，所以实际使用中很不便所以为java八种基本数据类型提供了对应的包装类。
 
 
基本数据类型
 
 
对应包装类
 
 
包装类的父类
 
 
byte
 
 
java.lang.Byte
 
 
java.lang.Number
 
 
short
 
 
java.lang.Short
 
 
java.lang.Number
 
 
int
 
 
java.lang.Integer
 
 
java.lang.Number
 
 
long
 
 
java.lang.Long
 
 
java.lang.Number
 
 
float
 
 
java.lang.Float
 
 
java.lang.Number
 
 
double
 
 
java.lang.Double
 
 
java.lang.Number
 
 
boolean
 
 
java.lang.Boolean
 
 
java.lang.Object
 
 
char
 
 
java.lang.Character
 
 
java.lang.Object
 
对应包装类比较特殊的就是int对应的Integer和char对应的Character；
对应包装类的直接父类：前6个由于是数，直接父类为Number，而后两个的直接父类就是Object类；
3.2、常用方法一：静态方法 valueOf()
 
参数为基本数据类型，返回包装类对象；
参数为String字符串（Character类没有以String为  参数的该方法）,返回包装类对象；
@Test
	public void a() {
	/*1.参数为基本数据类型		
	 * 作用：将基本数据类型转换为对应包装类 * */
		Integer i=Integer.valueOf(10);
		System.out.println(i);//输出10
	
	/*2.参数为String字符串时，
	 * 作用：返回指定字符串值的包装类对象
	 * 	*/
		Integer a=Integer.valueOf("100");
		System.out.println(a);//输出100
		
		Integer b=Integer.valueOf("100a")为
		System.out.println(b);//运行错误，字符串的值不少一个int类型的
		
	}
 
3.3、常用方法二：静态方法parseXXX(String str)
 
Character类没有该方法；
作用：将字符串装换为对应的基本数据类型（注意此处和上面的valueOf方法返回值的不同）；
@Test
	public void b() {
		/*作用：将给定字符串装换为对应的基本数据类型
		 * 前提是该字符串必须正确描述该基本数据类型表示的值*/
		int a=Integer.parseInt("100");
		System.out.println(a);//输出100
		
		int b=Integer.parseInt("100a");
		System.out.println(b);//运行错误，字符串的值不为int类型
				
	}
 
3.4、常用方法二：非静态方法XXXValue()
 
因为是非静态方法，所以不能像上面两个方法用类名调用了；
数字类的包装类（八种包装类中父类是Number的的六个类）才有该方法；
作用：将当前包装类对象转换为对应的基本数据类型；
@Test
	public void c() {
		/*作用：将包装类对象转换为对应的基本数据类型*/
		
		Integer a=Integer.valueOf(100);//将基本数据类型转换为包装类对象
		int b=a.intValue();//将包装类对象转换为对应的基本数据类型
		System.out.println(b);//输出100
		
		Double c=Double.valueOf(2.33);
		double d=c.doubleValue();
		System.out.println(d);
	}
 
3.5、自动拆箱与装箱
 
简介：jdk1.5之后的新特性。该特性是编译器认可的，是在编译器自动将基本数据类型和包装类相互转换，节省了麻烦。
自动拆箱 包装类——>基本数据类型 (原理是调用了xxxValue方法)    
自动装箱 基本数据类型——>包装类 (原理是调用了valueOf方法)
@Test
	public void d() {
		/*自动装箱：valueOf*/
		Integer i=123;//原理是 Integer i=Integer.valueOf(123);
		
		/*自动拆箱*/
		int i1=i+1;//原理是	int i1=i.intValue()+1;
		
		Integer a=123;
		Integer b=123;
		Integer c=a+b;
		/*原理为Integer c=Integer.valueOf(a.intValue()+b.intValue());*/
	}
 
3.6、关于valueOf()方法源码研究
 
通过按住Ctrl键，鼠标点击该方法即可查看源码，以Integer类的valueOf(int i)的源码为例
 public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
 
关于源码的理解：Integer类的valueOf(int i)方法首先会判断i是否在-128~127之间，如果在的话，就返回的对象是Integer类中静态数组cache中的对象，如果不是在这之间，就会重写创建一个新的对象。
通过查看其它类的该方法的源码之后，可以得到该表：
 
 
包装类
 
 
valueOf(X i)返回对象的原则
 
 
Byte
 
 
直接取，数组范围为（-128,127），且byte值的范围也是（-128,127）
 
 
Short
 
 
（-128，127）之间在数组中取，否则new
 
 
Integer
 
 
（-128，127）之间在数组中取，否则new
 
 
Long
 
 
（-128，127）之间在数组中取，否则new
 
 
Float
 
 
直接new
 
 
Double
 
 
直接new
 
 
Boolean
 
 
直接返回，不new
 
 
Character
 
 
0-127之间从数组中取，否则new
 
详解四、相关面试题
 
4.1、类型转换
 
注意一些喜欢忽视的类型转换
public static void main(String[] args) {
		int a=10;
		double b=3.4;
		System.out.println(a>b?a:b);
		System.out.println(a);
	}
/*输出：10.0   10
解析：这里是一个很容易让人不注意的类型转化，这里a与b参与了运算，
所以类型向类型大的方向转化，10就变成了10.0，但是a本身是没有变化的*/
 
4.2、+=的情况
 
public static void main(String[] args) {
		short a=1;	//第一行
		 a=a+1;		//第二行
		 a+=1;		//第三行
}
/*第几行的代码会出错？
答案：第二行会出错，由于a+1变为了int类型,而int类型不能直接赋值给short类型
但是+=这种情况是特殊的，所以不会出错；
*/
 
4.3、自动装箱
 
包装类和基本数据类型比较时，只要值相等就相等
public static void main(String[] args) {
		Integer a1=127;
		Integer a2=127;
		int a3=127;
		Integer b1=128;
		Integer b2=128;
		int b3=128;
		System.out.println(a1==a2);
		System.out.println(a1==a3);
		System.out.println(b1==b2);
		System.out.println(b1==b3);	
}
/*输出：true true false true
解析：自动装箱时采用valueOf方法，由于127在静态数组的范围内，所以不是new的，
而128的两个引用是指向new出现对象的，所以第一个是true，第三个是false。
而包装类和基本数据类型比较时，只要数值是相等的，就相等
*/
 
4.4、char类型存储汉字
 
     char类型能不能存储一个汉字？为什么？
 
     解析：能，char类型采用的是Unicode编码，Unicode编码包含汉字，所以char类型自然是可以存储一个汉字的
 
4.5、浮点数精度问题
 
public static void main(String[] args) {
		System.out.println(0.1*3==0.3);
		System.out.println(0.1*4);
}
/*输出：false 0.4
解析：有些浮点数不能准确的表示出来，与整数相乘之后出精度丢失，常见为小数位含3的
*/
 
第一篇技术博客！记载一下2018.12.20 10:14:20！
 
觉得写的还可以的话不要忘记点赞哦！
 
觉得哪里写的有问题的话，欢迎评论指出问题，我们讨论讨论！