本篇文章给大家带来的内容是关于Java中的包装类是什么？Java包装类的应用场景介绍 ，有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。
今天讲一下 Java 包装类的的由来，及自动装箱、拆箱的概念和原理。
什么是包装类型
Java 设计当初就提供了 8 种 基本数据类型及对应的 8 种包装数据类型。我们知道 Java 是一种面向对象编程的高级语言，所以包装类型正是为了解决基本数据类型无法面向对象编程所提供的。
下面是基本数据类型与对应的包装类型。基本数据类型包装类型byteByte
booleanBoolean
shortShort
charCharacter
intInteger
longLong
floatFloat
doubleDouble
下面是包装类型的继承结构图。
从以上图表可以对基本类型和包装类型有一个全面的了解。
包装类应用场景
1、集合类泛型只能是包装类；// 编译报错
List list1 = new ArrayList<>();
// 正常
List list2 = new ArrayList<>();
2、成员变量不能有默认值；private int status;
基本数据类型的成员变量都有默认值，如以上代码 status 默认值为 0，如果定义中 0 代表失败，那样就会有问题，这样只能使用包装类 Integer，它的默认值为 null,所以就不会有默认值影响。
3、方法参数允许定义空值；private static void test1(int status){
System.out.println(status);
}
看以上代码，方法参数定义的是基本数据类型 int，所以必须得传一个数字过来，不能传 null，很多场合我们希望是能传递 null 的，所以这种场合用包装类比较合适。
还有更多应用场景就不一一例举了，欢迎留言共同探讨包装类的更多的应用场景。
自动装箱、拆箱
Java 5 增加了自动装箱、拆箱机制，提供基本数据类型和包装类型的相互转换操作。
自动装箱
自动装箱即自动将基本数据类型转换成包装类型，在 Java 5 之前，要将基本数据类型转换成包装类型只能这样做，看下面的代码。Integer i1 = new Integer(8);
Integer i2 = Integer.valueOf(8);
// 自动装箱
Integer i3 = 8;
以上 3 种都可以进行转换，但在 Java 5 之前第 3 种方法是编译失败的，第 3 种方法也正是现在的自动装箱功能。另外，第一种构造器方法也不推荐使用了，已经标为废弃了。
其实自动装箱的原理就是调用包装类的 valueOf 方法，如第 2 个方法中的 Integer.valueOf 方法。
自动拆箱
自动拆箱即自动将包装类型转换成基本数据类型，与自动装箱相反，有装就有拆，很好理解。// 自动拆箱
int i4 = i3;
int i5 = i3.intValue();
继续上面的例子，把 i3 赋值给 i4 就是实现的自动拆箱功能，自动装箱的原理就是调用包装类的 xxValue 方法，如 i5 中的 Integer 的 intValue 方法。
自动装箱、拆箱不只是体现在以上的例子，在方法接收参数、对象设置参数时都能自动装箱拆箱。

（1）@public (公开的)在有对象的前提下，任何地方都可以直接访问。
（2）@protected （受保护的）只能在当前类和子类的对象方法中访问
（3）@private （私有的）只能在当前类的对象方法中才能直接访问
（4）@package (框架级别的)作用域介于私有和公开之间，只要处于同一个框架中就可以直接通过变量名访问




我个人理解框架就是包装好的程序，里面有定义好的数据类型，各种类和方法，#import<>之后就可以用里面的数据类型和方法，想想是不是跟我们自己写的程序或自己写的一个类一样。
我个人的理解是框架就是一个已经封装好的无数个方法，类的集合，oc是面向对象的，所以我们只需要知道这个方法的作用是什么，不需要知道他怎么做的。
框架式一种把头文件、库、图片、声音等内容聚集在一个独立单元中的集合体。Cocoa就是一个框架集，其中包括Foundation和AppKit框架



框架就是常用函数，类，方法的声明组合包装到一起。我们通常包含自己写的。h文件，Foundtion更广更大而已。
1、Foundation框架

    Foundation框架是其他所有ios框架的基础
   Foundation框架包含了很多开发中常用的数据类型：结构体 、枚举、类 
   
比如，你使用一个NSString类的实例存储用户输入的userName。你还使用了Foundation框架的initWithFormat方法创建了一个字符串。

    使用Foundation框架你可以实现：创建和管理集合，比如数组和字典；访问存储在应用程序里的图片和其它资源；创建和管理字符串；提交和接收通知；创建日期和时间对象；自动发现IP网络上的设备；操作URL流；执行异步代码。
   要想使用Foundation中的数据类型，包含它的主文件即可#import<Foundation/Foundation.h>

2、但是其实还有UIKit、和Core Graphics框架，你可以去网上搜一下，它们的具体用法http://www.open-open.com/lib/view/open1343210425380.html


什么是框架？

??框架，即framework。其实就是某种应用的半成品，就是一组组件，供你选用完成你自己的系统。简单说就是使用别人搭好的舞台，你来做表演。而且，框架一般是成熟的，不断升级的软件。

??为什么要用框架？

??因为软件系统发展到今天已经很复杂了，特别是服务器端软件，设计到的知识，内容，问题太多。在某些方面使用别人成熟的框架，就相当于让别人帮你完成一些基础工作，你只需要集中精力完成系统的业务逻辑设计。而且框架一般是成熟，稳健的，他可以处理系统很多细节问题，比如，事物处理，安全性，数据流控制等问题。还有框架一般都经过很多人使用，所以结构很好，所以扩展性也很好，而且它是不断升级的，你可以直接享受别人升级代码带来的好处。

??框架一般处在低层应用平台（如J2EE）和高层业务逻辑之间的中间层。

首先介绍定义：闭包可以让一个函数访问并操作其声明时的作用域中的变量和函数，并且，即使声明时的作用域消失了，也可以调用

应用：
私有变量

回调与计时器

绑定函数上下文

偏应用函数

函数重载：缓存记忆、函数包装

即时函数：独立作用域、简洁代码、循环、类库包装、通过参数限制作用域内的名称
正文

看了很多文章，都在说闭包的定义和闭包的优缺点。我呢，再加上闭包的应用吧。

闭包的定义很多文章里都有，我记得有一种角度说只要能访问外部变量的就是闭包，还有一种角度所有函数都是闭包。

我觉得这些回答是正确的，但是不太方便面试官继续问下去，或者说是不好引导面试官。所以，如果是我在面试，我会用忍者秘籍里的定义：闭包是一个函数在创建时允许该自身函数访问并操作该自身函数之外的变量时所创建的作用域。这个还有点绕口，更清晰的版本是：闭包可以让一个函数访问并操作其声明时的作用域中的变量和函数，并且，即使声明时的作用域消失了，也可以调用。要注意的是：闭包不是在创建的那一时刻点的状态的快照，而是一个真实的封装，只要闭包存在，就可以对其进行修改。

最简单的闭包：

// 全局作用于就是一个闭包

var outerVal = ‘lionel’;

function outerFn(){

console.log(outerVal)

}

outerFn() // lionel

复制代码复杂点的，也是我们印象中的：

var outerVal = ‘lionel’;

var later;

function outerFn(){

var innerVal = ‘karma’;

function innerFn(){

console.log(outerVal, innerVal);

}

later = innerFn;

}

outerFn();  // 此时outerFn的作用域已经消失了

later();  // lionel karma

复制代码难以理解的，这个例子我们可以理解到，闭包不是快照：

var later;

function outerFn(){

function innerFn(){

console.log(lateVal)

}

later = innerFn;

}

console.log(lateVal); // undefined

var lateVal = ‘lionel’; // 变量提升,闭包声明的那一刻存在这个变量

outerFn();

innerFn(); // lionel

复制代码缺点大家很熟悉了，闭包里的信息会一直保存在内存里。解决方法是，在你觉得可以的地方，清除引用，像上面的例子中，使用 later = null 即可，这样就可以在下次垃圾回收中，清除闭包。

下面我们重点来看一下闭包的实际应用。

一、私有变量

闭包常见的用法，封装私有变量。用户无法直接获取和修改变量的值，必须通过调用方法；并且这个用法可以创建只读的私有变量哦。我们从下面的例子来理解：

function People(num) { // 构造器

var age = num;

this.getAge = function() {

return age;

};

this.addAge = function() {

age++;

};

}

var lionel = new People(23); // new方法会固化this为lionel哦

lionel.addAge();

console.log(lionel.age);      // undefined

console.log(lionel.getAge()); // 24

var karma = new People(20);

console.log(karma.getAge()); // 20

复制代码如下图，lionel中并不存在age属性，age只存在new的那个过程的作用域中，并且，getAge和addAge中,我们可以看到他们的作用域中都包含一个People的闭包。
二、回调和计时器

这部分我没有多聊的，

三、绑定函数上下文

刚看到这个应用可能有点懵，仔细想想其实我们看到很多次了，那就是bind()函数的实现方式，这里再贴一次简单实现的代码：

Function.prototype.myBind = function() {

var fn = this,

args = […arguments],

object = args.shift();

return function() {

return fn.apply(object, args.concat(…arguments))

}

}

复制代码这里要注意的是：bind()并不是apply和call的替代方法。该方法的潜在目的是通过匿名函数和闭包控制后续执行上下文。

四、偏应用函数

偏应用函数返回了一个含有预处理参数的函数,以便后期可以调用。具体还是看代码吧

Function.prototype.partial = function() {

var fn = this,

args = […arguments];

return function() {

var arg = 0;

var argsTmp = […args]

for (var i=0; i<argsTmp.length && arg < arguments.length; i++) {

if (argsTmp[i] === undefined) {

argsTmp[i] = arguments[arg++]

}

}

return fn.apply(this, argsTmp)

}

}

function addAB(a ,b) {

console.log( a + b);

}

var hello = addAB.partial(‘hello ‘, undefined);

hello(‘lionel’); // hello lionel

hello(‘karma’); // hello karma

var bye = addAB.partial(undefined, ’ bye’)

bye(‘lionel’); // lionel bye

bye(‘karma’); // karma bye

复制代码上面的例子可能有点难以理解，下面是一个简化版的例子：

function add(a) {

return function(b) {

console.log( a + b);

};

}

var hello = add(‘hello ‘)

hello(‘lionel’); // hello lionel

hello(‘karma’); // hello karma

复制代码emmm… 写到这里去研究了半天柯里化和偏函数的区别，最终找到一篇文章符合我的想法：偏函数与函数柯里化，不对的地方请指正。

五、函数重载

1 缓存记忆

我们可以通过闭包来包装一个函数,，从而让调用我们函数的人，不知道我们采用了缓存的方法，或者说，不需要调用者额外做什么,就可以缓存计算结果，如下代码

Function.prototype.memoized = function(key) {

this._values = this._values || {};

return this._values[key] !== undefined ?

this._values[key] + ’ memoized’ :

this._values[key] = this.apply(this, arguments);

}

Function.prototype.memoize = function() {

var fn = this;

return function() {

// return fn.memoized.apply(fn, arguments);

console.log(fn.memoized.apply(fn, arguments))

}

}

var computed = (function(num){

// 这里有超级超级复杂的计算,耗时特别久

console.log(’----计算了很久-----’)

return 2

}).memoize();

computed(1); // ----计算了很久-----     2

computed(1); // 2 memoized

复制代码2 函数包装

下面的这个例子写的没有书里的好。

function wrap(object, method, wrapper){

var fn = object[method];

return object[method] = function() {

return wrapper.apply(this, [fn.bind(this)].concat(…arguments))

}

}

let config = {

baseUrl: ‘真实url’,

getBaseUrl: function(){

console.log(this.baseUrl)

}

}

if(process.env.NODE_ENV === ‘development’){

wrap(config, getBaseUrl, function(){

console.log(‘测试url’)

})

config.getBaseUrl(); // 测试url

}else{

config.getBaseUrl() // 真实url

}

复制代码六、即时函数

针对为什么即时函数会放在闭包里介绍,下图是一个很好的说明:
1 独立作用域

(function(){

var numClicks = 0;

button.click = function(){

alert(++numClicks)

}

})

复制代码2 简洁代码

// 例如有如下data

data = {

a: {

b: {

c: {

get: function(){},

set: function(){},

add: function(){}

}

}

}

}

// 第一种调用这三个方法的代码如下, 繁琐

data.a.b.c.get();

data.a.b.c.set();

data.a.b.c.add();

// 第二种方法如下, 引入多余变量

var short = data.a.b.c;

short.get();

short.set();

short.add();

// 第三种使用即时函数 优雅

(function(short){

short.get();

short.set();

short.add();

})(data.a.b.c)

复制代码3 循环

这部分是经典的for循环中调用setTimeout打印i，之所以打印i为固定值，是因为闭包并不是快照，而是变量的引用，在执行到异步队列时，i已经改变。

解决方法就是再用一个闭包和即时函数。

4 类库包装

// 下方的代码展示了,为什么jquery库中,它可以放心的用jquery而不担心这个变量被替换

(function(){

var jQuery = window.jQuery = function() {

// Initialize

};

// …

})()

复制代码5 通过参数限制作用域内的名称

// 当我们担心jquery中的$符号,被其他库占用,导致我们代码出问题的时候,
// 用下面的方法,就可以放心大胆的用啦(不过要注意:如果jQuery也被占用的话就...)
(function($){

$.post(…)

})(jQuery)

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

基本数据类型对象包装类的最常见作用
就是用于基本数据类型和字符串类型之间做转换
基本数据类型转成字符串
1. 基本数据类型+""

2. 基本数据类型.toString(基本数据类型值);

如： Integer.toString(34);//将34整数变成"34";

字符串转成基本数据类型
xxx a = Xxx.parseXxx(String);

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

double b = Double.parseDouble("12.23");

boolean b = Boolean.parseBoolean("true");

Integer i = new Integer("123");

int num = i.intValue();

十进制转成其他进制。
toBinaryString();
toHexString();
toOctalString();

Integer.toHexString(60)

其他进制转成十进制。
parseInt(string,radix);

int x = Integer.parseInt("3c",16);

jdk1.5后的新特性
自动装箱
Integer i=14;//相当于 Integer i =new Integer(14);
x+=2;//注意i 不可为null 否则会报错

包装类特点
Integer i=128;
Integer j=128;
System.out.println(i==j);//false 地址不一样
Integer a=127;
Integer b=127;
System.out.println(a==b);//true 当Integer 范围在byte字面值范围(-128~127) 堆区不会再去额外开辟一个数值的空间 因为-128~127这个范围的数值早已经存在，不再需要创建空间，从而提高效率