Java中对每种基本类型都有一个对应的包装类，这里主要讲解包装类的作用和包装类使用时的一些注意点。
 
包装类的作用
 
作用主要有以下两方面： 
 - 编码过程中只接收对象的情况，比如List中只能存入对象，不能存入基本数据类型；比如一个方法的参数是Object时，不能传入基本数据类型，但可以传入对应的包装类； 
 - 方便类型之间的转换，比如String和int之间的转换可以通过int的包装类Integer来实现，具体如下。 
 int a = new Integer("123"); 
 或者 
 int a = Integer.parseInt("123");
 
包装类使用时的注意点
 
这里先看一段代码：
 
public class StudyBox {
    public static void main(String[] args) {

        Integer a = 100, b = 100, c = 150, d = 150;
        Long e = 150l;
        System.out.println(a == b);
        System.out.println(c == d);
        System.out.println(c.equals(d));
        System.out.println(d.equals(e));
        System.out.println(e.equals(d));
    }

}
 
这段代码的输出结果如下：
 
true
false
true
false
false
 
第一个、第三个输出很好理解，但是其他三个输出可能就会让人有些疑惑。
 
代码解释
 
这里以int型对应的包装类Integer为例来说明： 
 在上段代码中，初始化Integer类型的a，是将int型数据100装箱然后赋值给变量a，其中装箱操作使用的是静态工厂方法valueOf(int i)，下面我们看一下这个方法的源码：
 
/**
 * Returns an {@code Integer} instance representing the specified
 * {@code int} value.  If a new {@code Integer} instance is not
 * required, this method should generally be used in preference to
 * the constructor {@link #Integer(int)}, as this method is likely
 * to yield significantly better space and time performance by
 * caching frequently requested values.
 *
 * This method will always cache values in the range -128 to 127,
 * inclusive, and may cache other values outside of this range.
 *
 * @param  i an {@code int} value.
 * @return an {@code Integer} instance representing {@code i}.
 * @since  1.5
 */
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}
 
在这个方法注释的第二段中，说明了这个方法一定会缓存-128到127的值，也有可能会缓存这个范围以外的值，这就是上面代码中第二个输出是false的原因。即-128到127的值会被Integer类缓存起来（在Integer类中通过IntegerCache类来实现），从valueOf(int i)的代码中可以看出，对象a和b是同一个对象，所以==比较是true；而c和d是不同的对象，所以==比较是false。
 
另外，使用equals()来进行对象比较时，Integer会先检查类型是否一致，若不一致直接返回false，这也就是第四个和第五个输出false的原因。具体如以下源码：
 
public boolean equals(Object obj) {
     if (obj instanceof Integer) {
          return value == ((Integer)obj).intValue();
      }
      return false;
}
 
总结
 
以上内容若有错误之处，还请各位大神指点，不胜感激，同时也欢迎各位一起来探讨相关问题。
 
参考资料
 
解决Java包装类比较时遇到的问题

一、什么是包装类
 
包装类（Wrapper Class）： Java是一个面向对象的编程语言，但是Java中的八种基本数据类型却是不面向对象的，为了使用方便和解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八种基本数据类型对应的类统称为包装类(Wrapper Class)，包装类均位于java.lang包。
 
二、包装类的用途
 
为了使用方便Java中将8中基本数据类型进行了封装：除了Integer和Character类以后，其它六个类的类名和基本数据类型一直，只是类名的第一个字母大写即可。
 
boolean —> Boolean
 char —> Character
 byte—> Byte
 short—> Short
 long—> Long
 int —> Integer
 float—> Float
 double—> Double
 对于包装类说，用途主要包含两种：
 a、作为 和基本数据类型对应的类 类型存在，方便涉及到对象的操作。
 b、包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。
 
三、包装类的实际使用（以int和integer为例）
 
1.int和integer类之间的转换
 在实际转换时，使用Integer类的构造方法和Integer类内部的intValue方法实现这些类型之间的相互转换：
 
        int n=5;
        Integer n1=new Integer(n);
        System.out.println("int类型转换为integer类："+n1);
        //
        Integer i=new Integer(50);
        int i1 = i.intValue();
        System.out.println("integer类转换为int类型："+i1);
 
2、Integer类内部的常用方法
 Integer类的主要方法有：parseInt方法和toString方法。
 
    //parseInt方法： 数字字符串类型转成int类型
        String ss="123";
        int ii = Integer.parseInt(ss);
        System.out.println("字符类型转成整型："+ii);
        //toString方法：int类型转成数字字符串类型
        int ii2=123;
        String ss2 = Integer.toString(ii2);
        System.out.println("int类型转成数字字符串类型:"+ss);
 
JDK自从1.5版本以后，就引入了自动拆装箱的语法，也就是在进行基本数据类型和对应的包装类转换时，系统将自动进行，这将大大方便程序员的代码书写。
 自动装箱：将 基本数据类型 封装为对象类型，来符合java的面向对象的思想。
 自动拆箱：将对象重新转化为基本数据类型。
 
  //5是基本数据类型，通过自动装箱变成对象类型。
        //编译器执行了Integer iii = Integer.valueOf(5)
        Integer iii=5;
        //自动拆箱，实际上执行了 int iii2 = iii.intValue()
        int iii2=iii;
        System.out.println(iii2);
 
valueOf（）源码分析：
 
public static Integer valueOf(int i) {
     assert IntegerCache.high>= 127;
     if (i >= IntegerCache.low&& i <= IntegerCache.high)
     return IntegerCache.cache[i+ (-IntegerCache.low)];
     return new Integer(i); 
}
 
说明：Integer iii=5;相当于编译器执行了Integer iii = Integer.valueOf(5)操作。这个方法就是返回一个 Integer 对象，只是在返回之前，看作了一个判断，判断当前 i 的值是否在 [-128,127] 区别，且 IntegerCache 中是否存在此对象，如果存在，则直接返回引用，否则，创建一个新的对象。
 3.包装类的缓存值
 各个包装类缓存值范围
 
boolean：true和false 
byte：-128～127 
char：0～127 
short：-128～127 
int：-128～127 
long：-128～127 
 
特别注意：对于float和double没有缓存。
 在对上述值进行装箱的时候（如：Character c1=127;or Integer i= Integer.valueOf(1); 这个不行哦：Integer i2=new Integer(1)；因为这是新建了一个对象出来。）,并不是创建一个新对象而是使用缓存中的对象，如果超出范围则需要新建立对象。
 四、常见的面试题
 
1.Java中Int与Integer的区别？
 
一、int 是基本类型，直接存数值；而integer引用数据类型。
二、Int的声明不需要实例化，且变量声明后的初始值为0；Integer的是一个类，初始值为null，需要进行实例化，才能对变量数据进行处理。
三、Integer类是int的包装类，实际开发中Integer被看成一个对象，可以进行数据转换等操作。
 
2.判断下面程序片段输出的结果：
 
        Integer num1 = 200;   
        Integer num2 = 200;           
        System.out.println("num1==num2: "+(num1==num2));                    
        Integer num3 = 100;   
        Integer num4 = 100;   
        System.out.println("num3==num4: "+(num3==num4)); 
 
输出结果：num1num2:false 和num3num4:true
 说明：
 
首先要明确equal方法与==的区别：
 
List item equals() 比较的是**两个对象的值（内容）**是否相同。
List item “==” 比较的是**两个对象的引用（内存地址）**是否相同，也用来比较两个基本数据类型的变量值是否相等。
 
java定义：在自动装箱时对于值从–128到127之间的值，它们被装箱为Integer对象后，会存在内存中被重用，始终只存在一个对象而如果超过了从–128到127之间的值，被装箱后的Integer对象并不会被重用，即相当于每次装箱时都新建一个 Integer对象；
 
感恩作者，写的非常好
 作者：谁是谁的小确幸 来源：CSDN
 原文：https://blog.csdn.net/qq_29119581/article/details/78327759
 版权声明：本文为博主原创文章，转载请附上博文链接！

1.什么是框架？
 
 
 
其实框架，就是别人写好了包装起来的一套工具，把你原先必须要写的，必须要做的一些复杂的东西都写好了放在那里，你只要调用他的方法，就可以实现一些本来要费好大劲的功能。形象一点说吧，假如你盖房子，你是自己一砖一瓦的盖简单呢，还是拿一个现成的架子往上面添东西简单呢？结果不言而喻吧，有一个半成品的架子，你只需要添上一些你自己额外需要加的东西就好了。这就是框架的好处。假如，好多好多地方都要用这么一套逻辑，那么我们会定义成一个方法（函数），就免去了写同样代码的麻烦，其实这个方法，就是一个框架啦，只不过非常小而已。
 
 
 
 
web开发的MVC模式，M是模型，V是视图（表现层），C是控制层。框架就是M层啦，他把一套不涉及任何业务相关的东西都写好了包装起来，你去用就可以了，C的控制层，他是没法写的，因为不同的系统有不同的业务逻辑，框架不可能帮你把业务逻辑也写进去啦。就好比你盖房子的架子，他只能做到一个架子，不是因为他不能完全弄好，而是因为他没法去加，他也不知道你到底是需要什么颜色的瓦片，但是相比来看，框架把很多复杂的东西都弄好了，你只要在上面添加你独有的东西就可以了。
 
 
 
 
综上所述，框架可以理解为一个毛坯房，有了这个毛坯房你可以将他装修成自己想要的样子，而不需要再一砖一瓦的去盖房子（省略了你盖房子主体架构这些步骤）。
 
 
2.框架的作用是什么？
 
 
 
框架可以帮助省略掉一些基本的相同底层代码的反复书写，只需调用框架的方法就可以实现你想要的功能。
 
 
3.为什么要学习框架？
 
 
 
学习框架的目的就是提高项目的编写效率，使你可以有更多的时间去编写属于自己独特的东西，而不需要将大量的时间花费在底层代码的书写上。
 

首先了解什么是包装和授权。 
 我们知道，面向对象程序设计中有一个理念就是封装，而实际上面向对象也让程序员在使用一些类（自己定义或则别人定义）对象的时候非常方便。包装就是一个希望将某个对象（或类），进行重新打包，装换成另外一种更适合当前使用场合的对外接口。相似娱乐界对明星的包装一样，其实本质没有什么改变，只是表面变得更容易受当下人欢迎而已。用到程序编程中，就是将程序包装成，当前环境跟适合的样子（主要是对外接口）。
 
一个例子，假如一个类中包含了许多的数据属性，同时也包含了许多的基本操作函数，但是我们要求得这个类的对象的某个值（来自于对这个类对象中的各个数据属性和操作函数的多次操作），那么是不是每次都需要做一遍这样的事情呢？理论上是这样的，有人会说，那为什么不在当初定义类的时候就定义一个这样的函数呢？对！但是，当初定义的时候或许想不到这些，而更为重要的是，如果将某个类定义的过分应用于某个情景，那么这个类就并不好在其他地方使用，而如果把它实际到适合在许多情景中使用，那又会是类变得特别的负责，所以基本上，我们认为类应该设计的比较基本为好。
 
所以，有没有解决这一问题的办法呢？有，那就是封装！
 
在不同的应用场景将那个各个方法都较为基础的类包装成一个适合在该地方使用的包装类。
 
那么包装这个设计思想有哪些方法和以实现呢？ 
 我们说既然是面向对象设计，那自然不能脱离类来讲咯（实际上包装的对象可以是任何对象）。我们找方法的范围也减少了。这样包装的概念就是将一个类所能干的事情，通过不同的方式转换成另外一个类，它们的内容本质（这里主要是说数据信息）不变，只是对外操作的接口做了相应的转变，或者添加了，或者减少了，或者转变了，或者限制了等等。
 
一个类与另外一个类的关系只有两种一种是继承关系（包括祖先），另外一种是包含的关系。也就是derivation和composition两种关系。
 
通过继承的方式似乎可以，将原来的类成员先全部继承，然后可以对函数进行重写覆盖，也可以添加性函数等等。这是一个好方法，但是，在有些编程语言中如python2.2之前，基本数据类型不属于类，那样就不能被类继承，就不能进行所谓的包装。
 
所以还可以通过另外一个方法来做到一点，那就是创建一个类，而这个类往往只包含一个数据成员对象，那就是它要封装的类的对象。通俗的讲，就是让这个封装类包含这个被封装类的实例。然后通过在这个封装类中各种方法的设置，实质上就是从这个包含对象的接口传递、转换其相应的功能到这个包装类上。让外界感觉似乎就是在操作该被封装的类一样。可以看出，封装类在转换的时候有很多弹性，所以完全可以做到前面所说的包装效果。
 
其实，我们可这么想，在type和class还不是一回事的时候，我们没有办法使用继承的方法来对基本数据类型进行封装，所以只能通过这个手段了。但是现在type和class的统一是基本趋势。但仍然不会有违通过composition的方法来进行包装。实际上两种包装手段可以呈现出一种互补的态势，可能大家有一些各自不适合的地方。
 
而授权是包装的一个特性，授权的过程，就是说所有的更新的功能都是由新类的某部分来处理，但已存在的功能就授权给对象的默认属性。而实现这一功能的关键便是 getattr() 特殊方法。这个方法的作用是：当试图访问一个实例的属性时，本地属性会首先被找到，如果本地没有就会去类属性和祖先类属性里找，如果那里也没有的话，就会调用实例的 _getattr_() 方法。因此这里就给我们提供了一个将属性访问重定向到被包装的类型（伪父类）的机会。其具体的实现方法便是，在 getattr() 中调用内建的 getattr() 函数：
 
下面是一个例子，这个例子在原有的类的基础上，增加了几个功能，也就是得到类的创建时间(ctime)，修改时间(mtime)和访问时间(atime)
 
from time import time,ctime
class TimedWrapMe(object):
    def __init__(self,obj):
        self.__data=obj
        self.__ctime=self.__mtime=self.__atime=time()
    def get(self):
        self.__atime=time()
        return self.__data
    def gettimeval(self,t_type):
        if not isinstance(t_type,str) or t_type[0] not in 'cma':
            raise TypeError("argument of 'c','m','a' req'd' ")
        print('_%s__%stime' % (self.__class__.__name__,t_type[0]))
        return getattr(self,'_%s__%stime' % (self.__class__.__name__,t_type[0]))#attention!get private data attribute
    def gettimestr(self,t_type):
        return ctime(self.gettimeval(t_type))
    def setr(self,obj):
        self.__data=obj
        self.__mtime=self.__atime=time()
    def __repr__(self):
        self.__atime=time()
        return 'self.__data'
    def __str__(self):
        self.__atime=time()
        return str(self.__data)
    def __getattr__(self, item):
        self.__atime=time()
        return getattr(self.__data,item)
a=TimedWrapMe(9)
print(getattr(a,'_TimedWrapMe__ctime'))
print(a.gettimestr('c'))
print(repr(a))
 
下面还有一个例子，实现以大写的形式往文件写入： 
 在写这个例子的时候遇到了点问题
 
class UpperOpen(object):
    def __init__(self,filename,mode='r',buf=-1):
        self.file=open(filename,mode,buf)
    def __str__(self):
        return str(self.file)
    def __repr__(self):
        return repr(self.file)
    def write(self,line):
        self.file.write(line.upper())
    def __getattr__(self, attr):
        return getattr(self.file,attr)
f=UpperOpen('in.txt','w')
f.write('fdsa dsa fd afewqr dsaf e\n')
f.write('i am good')
f.close()
f=UpperOpen('in.txt','r')
for line in f:
    print(line)
 
像上面这样写的时候在3.4.3下，会提示如下错误，说f不能迭代 
 
 
如果显示的调用iter函数的话是可以的：
 
f=UpperOpen('in.txt','r')
it=f.__iter__()
for line in it:
    print(line)
 
或者重写iter函数也是可以的
 
class UpperOpen(object):
    def __init__(self,filename,mode='r',buf=-1):
        self.file=open(filename,mode,buf)
    def __str__(self):
        return str(self.file)
    def __repr__(self):
        return repr(self.file)
    def __iter__(self):
        return self.file.__iter__()
    def write(self,line):
        self.file.write(line.upper())
    def __getattr__(self, attr):
        return getattr(self.file,attr)
f=UpperOpen('in.txt','w')
f.write('fdsa dsa fd afewqr dsaf e\n')
f.write('i am good')
f.close()
f=UpperOpen('in.txt','r')
for line in f:
    print(line)
 
但是getattr不应该会搜索到self.file的$__iter__$属性吗，不明白为什么这样不行，在《python编程思想 第二版》上，就是那么写的也没有问题，难道又是因为我下的是3.4.3？希望哪位python大神指点