Thinking In Java----2017.1.8 访问权限、多态以及一些知识点。

 

1.Java的数学运算都是在栈中进行的

 

2.基本类型和基本类型的包装类。基本类型有：byte、short、char、int、long、boolean。基本类型的包装类分别是：Byte、Short、Character、Integer、Long、Boolean。注意区分大小写。二者的区别是：基本类型体现在程序中是普通变量，基本类型的包装类是类，体现在程序中是引用变量。因此二者在内存中的存储位置不同：基本类型存储在栈中，而基本类型包装类存储在堆中。上边提到的这些包装类都实现了常量池技术，另外两种浮点数类型的包装类则没有实现。另外，String类型也实现了常量池技术。（常量池里如果有需要的string,则直接用，否则往常量池里加新的）

3. 以上提到的几种基本类型包装类均实现了常量池技术，但他们维护的常量仅仅是【-128至127】这个范围内的常量，如果常量值超过这个范围，就会从堆中创建对象，不再从常量池中取。

4. String类型也实现了常量池技术，但是稍微有点不同。String型是先检测常量池中有没有对应字符串，如果有，则取出来；如果没有，则把当前的添加进去。

 

5. 冲突类处理：如果你import的2个以上的包都有同一个名称的类，在你使用这个名称的类时，你应该明确指定它来自哪里。如：java.util.Vector v = new Java.util.Vector()；

6. privata关键字: 除了包含该成员的类之外，其他任何类都无法访问这个成员。任何可以肯定只是该类的助手的方法，都可以指定它为private的。

7. protected关键字：主要用于继承，但是它也实现了包访问权限，即包内的其他类也可以访问protected元素。一般都是把域作为private的，而把父类相关方法设置为protected的，这是一种机制。

       

8.封装的概念：访问权限的控制常被称为具体实现的隐藏。把数据和方法包装进类中，加上具体实现的隐藏，常共同被称作封装。

9.类访问权限:

a.)类只有public和包访问权限，无private和protected.

b.)一个class文件只能有1个public class，且文件名必须和这个public class完全相同。

c.)如果你不想别人生成这个类对象，你可以把这个类的构造器指定为private的，这样别人就无法应用了。

d.)如果你不想别人随意生成这个类对象，又可以使用这个类的话，有2中方法：

1.)class A{

private A(){}

public static A makeA(){

return new A();

}

}

2.)class A{

private static A a = new A();

private A(){}

public static A getA(){

return a;

}

}

这是一种单例模式。

 

没有public修饰的类都是包访问权限的类。

 

10.Java中初始化的地方 ：

A.)定义对象的时候;

B.)构造器里;

C.)惰性初始化 例如if(string ==“Test”);

D.)实例初始化（初始化块);

11.关于继承的规则：

在Java中，如果父类成员没有生命访问权限，那么只有在同1个包中的子类可以使用父类 成员，而其他包中的子类只能使用父类中生命了public的成员，因此，有一个很有用的规则如下。

通常情况下：我们应该做的是父类里的数据成员都指定为private的，而方法应该都指定public的（具体看你的应用场景。）

12.关于生成子类对象时，父类对象的问题：

当你生成1个子类对象的时候，这个子类对象其实包含了1个父类的子对象，这个子对象和你直接创建的对象是一样的。二者区别在于后者来自于外部，而前者的自对象被包装在子类对象的内部。

13.带参数的父类构造器：

如果你的父类构造器没有默认无参数的构造器，而是有参构造器，那么你的子类必须用super关键字显式的调用基类构造器，否则，编译器会显示找不到父类构造器，

并且你在子类构造器中第一件应该做的事就是调用父类带参构造器。

 

14.复用代码的几种形式：

a) 组合；

b) 继承；

c) 代理； 例如  class playerControl{

 

Public void play(String what){}

    Public void start(String what){}

 

}

 

Class  playerProxy{

 

playerControl control  = new playerControl();

 

Public void play(String what){

Control.play(what);

}

    Public void start(String what){

    Control.start(what);

    }

 

}

 

代理的优势可以提供想要的方法子集，而不用全盘接受。

比如说我们有1个类是Player,它有玩足球的一系列相关方法，它有玩篮球、羽毛球、游泳的一系列相关方法。但是我们可能只是需要1个BasketBallPlayer，它不应该有关于玩足球、羽毛球的方法。因此，如果通过继承来构造我们的BasketBallPlayer.class，这显得很不合理，我们应该利用代理，让我们的新类只拥有某个方法子集就好。

 

 

 

 

15.finally的子句的意思是无论如何，这部分代码一定要执行。

16.@Override注解可以防止我们在不想重载的时候进行了重载。

17.正常情况下，大部分采用组合的形势，但是如果要使用继承，应该考虑一下：

自己是否需要新的子类向基类进行向上转型，如果需要向上转型，则继承是必要的。

 

 

final关键字相关：

 

 

18.final修饰的四元素： a.) 成员变量； b.)方法; c.)类; d.)本地变量（方法中的或者代码块中的变量）。

19.使用final修饰数据的2种可能原因:

a) 我们不希望这个数据被改变，

b) 一个永不改变的编译时常量：编译器可以将编译时常量带入任何它需要的计算式，这就意味着在编译时就可以进行一些计算(执行计算式)，可以减少运行时负担。

 

20.final关键字修饰对象引用：final关键字修饰的”引用”，即

 final Object o1 = new Object(1)；

     那么就不能 o1 = new Object(2);了 ，因为它不能再指向另一个对象了。

     然而对象的值是可以变的，比如：

            Object里有1个int i ;

            o1.i++;是可以的，因为它改变的是对象的属性。 而不是引用。

      而数组也是引用，比如int[] a = new int[]{1,2,3}

     我们可以改变a[i],比如a[1] = 10;因为数组也是引用。

            所以一般情况下final修饰应用没有修饰基本类型作用大。

21.空白final：所谓空白final，就是指被声明是final的但是没有初始化的域。

22.空白final的作用：它可以使得一个类中的final域做到因对象不同而值不同，具体做法是在不同的构造器中对final域进行初始化。使得不同构造器中的final域是不同的

23.final一些原则：必须在域的定义处初始化或者在构造器中进行初始化，这正是final域在使用前总是被初始化的原因所在。

24.final参数（本地变量）：引用------->无法改变引用指向新的对象。

    基本数据类型------>无法改变值。

25.final方法使用的2点原因:

a) 明确禁止覆盖。（其实更深层次的是禁止动态绑定）

b) 以前是为了效率，不过在JAVA SE5/6时，让编译器和JVM来处理效率的问题，所以该条省略。

26.private和final：private方法因为它是外部用不到的，所以它隐含是final的， 对于private方法，可以理解为它不是基类的接口的一部分，而是隐藏于类中的程序代码，如果我们在子类当中有相同名称的方法的话，它并不是覆写基类方法，因为基类方式是private的，而是新生成了1个方法，所以即使名字相同，也不会报错。

27.final类:出于设计或者安全，你不希望它有子类，不可以继承它。它的所有方法都是final的,无法覆写。

28.类的代码(可以理解为static代码)在初次使用时才加载：类的编译代码保存在它自己的独立文件中，该文件只在需要的时候才会被加载。

 

一个很好的关于final总结地址:

http://www.importnew.com/7553.html

 

Java中的final关键字非常重要，它可以应用于类、方法以及变量。这篇文章中我将带你看看什么是final关键字？将变量，方法和类声明为final代表了什么？使用final的好处是什么？最后也有一些使用final关键字的实例。final经常和static一起使用来声明常量，你也会看到final是如何改善应用性能的。

final关键字的含义?

final在Java中是一个保留的关键字，可以声明成员变量、方法、类以及本地变量。一旦你将引用声明作final，你将不能改变这个引用了，编译器会检查代码，如果你试图将变量再次初始化的话，编译器会报编译错误。

什么是final变量？

凡是对成员变量或者本地变量(在方法中的或者代码块中的变量称为本地变量)声明为final的都叫作final变量。final变量经常和static关键字一起使用，作为常量。下面是final变量的例子：

1 2	public static final String LOAN = "loan"; LOAN = new String("loan") //invalid compilation error

final变量是只读的。

什么是final方法?

final也可以声明方法。方法前面加上final关键字，代表这个方法不可以被子类的方法重写。如果你认为一个方法的功能已经足够完整了，子类中不需要改变的话，你可以声明此方法为final。final方法比非final方法要快，因为在编译的时候已经静态绑定了，不需要在运行时再动态绑定。下面是final方法的例子：

1 2 3 4 5 6 7 8 9 10 11 12

class PersonalLoan{     public final String getName(){         return "personal loan";     } }   class CheapPersonalLoan extends PersonalLoan{     @Override     public final String getName(){         return "cheap personal loan"; //compilation error: overridden method is final     } }

什么是final类？

使用final来修饰的类叫作final类。final类通常功能是完整的，它们不能被继承。Java中有许多类是final的，譬如String, Interger以及其他包装类。下面是final类的实例：

1 2 3 4 5 6 7

final class PersonalLoan{       }       class CheapPersonalLoan extends PersonalLoan{  //compilation error: cannot inherit from final class   }

final关键字的好处

下面总结了一些使用final关键字的好处

1. final关键字提高了性能。JVM和Java应用都会缓存final变量。

2. final变量可以安全的在多线程环境下进行共享，而不需要额外的同步开销。

3. 使用final关键字，JVM会对方法、变量及类进行优化。

不可变类

创建不可变类要使用final关键字。不可变类是指它的对象一旦被创建了就不能被更改了。String是不可变类的代表。不可变类有很多好处，譬如它们的对象是只读的，可以在多线程环境下安全的共享，不用额外的同步开销等等。

相关阅读：为什么String是不可变的以及如何写一个不可变类。

关于final的重要知识点

1. final关键字可以用于成员变量、本地变量、方法以及类。

2. final成员变量必须在声明的时候初始化或者在构造器中初始化，否则就会报编译错误。

3. 你不能够对final变量再次赋值。

4. 本地变量必须在声明时赋值。

5. 在匿名类中所有变量都必须是final变量。

6. final方法不能被重写。

7. final类不能被继承。

8. final关键字不同于finally关键字，后者用于异常处理。

9. final关键字容易与finalize()方法搞混，后者是在Object类中定义的方法，是在垃圾回收之前被JVM调用的方法。

10. 接口中声明的所有变量本身是final的。

11. final和abstract这两个关键字是反相关的，final类就不可能是abstract的。

12. final方法在编译阶段绑定，称为静态绑定(static binding)。

13. 没有在声明时初始化final变量的称为空白final变量(blank final variable)，它们必须在构造器中初始化，或者调用this()初始化。不这么做的话，编译器会报错“final变量(变量名)需要进行初始化”。

14. 将类、方法、变量声明为final能够提高性能，这样JVM就有机会进行估计，然后优化。

15. 按照Java代码惯例，final变量就是常量，而且通常常量名要大写：

1	private final int COUNT = 10;

1. 对于集合对象声明为final指的是引用不能被更改，但是你可以向其中增加，删除或者改变内容。譬如：

1 2 3 4

private final List Loans = new ArrayList(); list.add(“home loan”);  //valid list.add("personal loan"); //valid loans = new Vector();  //not valid

我们已经知道final变量、final方法以及final类是什么了。必要的时候使用final，能写出更快、更好的代码的。

 

多态：

1.将1个方法调用和方法体关联起来---被称作绑定:绑定分为前期绑定和后期绑定。Java中除了static方法和final方法之外，其他所有方法都是后期绑定。

2.后期绑定机制：就是在运行时根据对象的类型进行绑定，又叫运行时绑定。

3.final方法其实就是旨在关闭动态绑定。

 

 

4.方法向上转型: class Circle extends Shape

 public Shape next(){

return new Circle();

}

 

5.多态是一像“将改变的事物与未变的事物分离开来”的重要事物。

-------------------------------------------------------------------------------------------------------------------------------

                                         其他知识点：

1.一个对象创建的过程：

http://blog.csdn.net/lingzhou1/article/details/8476709

 

如果是Person p = new Person();

 

1.首先在硬盘指定位置找到Person.class文件，然后将该文件加载进内存。

2.执行main方法时，在内存的栈区中为main（）方法开辟1个空间，然后再main方法的栈区中分配了1个变量p 。

3.在堆内存中开辟了一段实体空间，分配了1个内存首地址。

4.在该空间中进行属性的空间分配，并进行默认初始化。

5.对空间的属性进行显示初始化。

6.进行实体的构造代码块初始化。

7.构造函数初始化。

8.将首地址赋值给p，p变量就引用了该实体。

 

 

 

 

 

 

http://blog.csdn.net/anjayxc/article/details/6063210

 

 

这是没有涉及继承的情况，对于涉及了继承的情况总结如下：

假设有个名为Mouse4j的类，继承自Mouse，Mouse又继承自Animal

 

1.当首次创建型为Mouse4j的对象时，Java解释器查找类路径，定位Mouse4j.class文件。

2.Java解释器会根据Mouse4j.class定位其基类Mouse.class、再根据Mouse.class定位到基类Animal.class文件，有关静态初始化的动作从基类到子类依次执行。 

3.当你用new Mouse4j()创建对象的时候，首先将在堆上为Mouse4j对象（包括其基类Mouse和Animal中的域）分配足够的存储空间。 (这里要注意:在堆上的子类对象是拥有其基类的域的！)

4.这块存储空间会被清零，这就自动地将Mouse4j中的所有基本类型数据（包括其基类Mouse和Animal中的）设置成了默认值（对数字来说就是0，对布尔型和字符型也相同），而引用（包括其基类Mouse和Animal中的）则被置成了null。

5.执行基类Animal中所有出现于域定义处的初始化动作。

6.执行基类Animal构造器。

7.执行基类Mouse中所有出现于域定义处的初始化动作。

8.执行基类Mouse构造器。

9.执行子类Mouse4j中所有出现于域定义处的初始化动作。

10.执行子类Mouse4j构造器。

 

即：class是从子类到基类依次查找，有关静态初始化的动作从基类到子类依次执行。 

在为所创建对象的存储空间清零后,找到继承链中最上层的基类,执行a、b两步：
a.执行其出现在域定义处的初始化动作
b.然后再执行其构造器
然后从基类到子类依次执行这两步操作。

 

2.关于静态块什么时候初始化的问题:

博客地址:

http://www.cnblogs.com/ivanfu/archive/2012/02/12/2347817.html

 

 

java的static块执行时机 

之前一直认为static块是在class load的时候执行，今天在验证Spring初始化Context loader的时候，发现bean的static块并没有执行。

Java代码：

1 Class A{   
2    static{
3       System.out.println("static block invoked!")
4    }
5 }

 

那么static块到底在什么时候运行的呢？如果了解JVM原理，我们知道，一个类的运行分为以下步骤：

1. 装载

2. 连接

3. 初始化

    其中装载阶段又三个基本动作组成：

1.     通过类型的完全限定名，产生一个代表该类型的二进制数据流

2.     解析这个二进制数据流为方法区内的内部数据结

3.     构创建一个表示该类型的java.lang.Class类的实例

    另外如果一个类装载器在预先装载的时遇到缺失或错误的class文件，它需要等到程序首次主动使用该类时才报告错误。

 

    连接阶段又分为三部分：

1. 验证，确认类型符合Java语言的语义，检查各个类之间的二进制兼容性(比如final的类不用拥有子类等)，另外还需要进行符号引用的验证。

2. 准备，Java虚拟机为类变量分配内存，设置默认初始值。

3. 解析(可选的) ，在类型的常量池中寻找类，接口，字段和方法的符号引用，把这些符号引用替换成直接引用的过程。

   

　　当一个类被主动使用时，Java虚拟就会对其初始化，如下六种情况为主动使用：

1. 当创建某个类的新实例时（如通过new或者反射，克隆，反序列化等）

2. 当调用某个类的静态方法时

3. 当使用某个类或接口的静态字段时

4. 当调用Java API中的某些反射方法时，比如类Class中的方法，或者java.lang.reflect中的类的方法时

5. 当初始化某个子类时

6. 当虚拟机启动某个被标明为启动类的类（即包含main方法的那个类）

    Java编译器会收集所有的类变量初始化语句和类型的静态初始化器，将这些放到一个特殊的方法中：clinit。 

　
实际上，static块的执行发生在“初始化”的阶段。初始化阶段，jvm主要完成对静态变量的初始化，静态块执行等工作。

下面我们看看执行static块的几种情况：

1、第一次new A()的过程会打印""；因为这个过程包括了初始化

2、第一次Class.forName("A")的过程会打印""；因为这个过程相当于Class.forName("A",true,this.getClass().getClassLoader());

3、第一次Class.forName("A",false,this.getClass().getClassLoader())的过程则不会打印""。因为false指明了装载类的过程中，不进行初始化。不初始化则不会执行static块。

 参考资料：深入Java虚拟机 

 3.static的优点和缺点:

 

http://blog.csdn.net/lingzhou1/article/details/8476709

 

 

  static：关键字是一个修饰符。用于修饰成员（成员变量 和成员函数）。

    特点：

       1.想要实现对象中的共性数据的对象共享。可以讲这个数据进行静态修饰。

       2.被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。

       3.静态随着类的加载而加载。而且优先于对象存在。 

     弊端：

      1.有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。

      2.静态方法只能访问静态成员，不可以访问非静态成员。

        因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。

     3.静态方法中不能使用this,super关键字。

       因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。

     4.主函数是静态的。

      什么时候定义静态成员呢？

     成员分两种：

     1.成员变量。（数据共享时静态化）

      该成员变量的数据是否是所有对象都一样；

     如果是，那么该变量需要被静态修饰，因为是共享数据。如果不是，那么就说这是对象的特有数据，要存储到对象中。

     2.成员函数。（方法中没有调用特有数据时就定义成静态）

     如何判断成员函数是否需要被静态修饰呢？

     只要参考，该函数内是否访问了对象中的特有数据。如果有访问特有数据，那方法不能被静态修饰。如果没有访问过特有数据，那么这个方法需要被静态修饰。

 

     静态的生命周期很长。静态代码块就是一个有静态关键字标示的一个代码区域。定义在类中。完成类的初始化。静态代码块随着类的加载而执行，而且只执行一次（new多个对象就只执行一次）。如果和主函数在同一个类中，优先于主函数执行。

    主函数的解释：保证所在类的独立运行。是程序的入口。被JVM调用。

    静态代码块、构造代码块、构造函数同时存在时的执行顺序：

   静态代码块--构造代码块--构造函数。

 

4.Java内存分配的问题：

 

http://blog.csdn.net/yangyuankp/article/details/7651251

 

 

 

 

         l  寄存器：JVM内部虚拟寄存器，存取速度非常快，程序不可控制。

         l  栈：保存局部变量的值，包括：1.用来保存基本数据类型的值；2.保存类的实例，即堆区对象的引用(指针)。也可以用来保存加载方法时的帧。

         l  堆：用来存放动态产生的数据，比如new出来的对象。注意创建出来的对象只包含属于各自的成员变量，并不包括成员方法。因为同一个类的对象拥有各自的成员变量，存储在各自的堆中，但是他们共享该类的方法，并不是每创建一个对象就把成员方法复制一次。

         l  常量池：JVM为每个已加载的类型维护一个常量池，常量池就是这个类型用到的常量的一个有序集合。包括直接常量(基本类型，String)和对其他类型、方法、字段的符号引用(1)。池中的数据和数组一样通过索引访问。由于常量池包含了一个类型所有的对其他类型、方法、字段的符号引用，所以常量池在Java的动态链接中起了核心作用。常量池存在于堆中。

总结常量值：在堆中，保存了除float之外的基本类型和String类型，所有的对其他类型、方法、字段的符号引用。

         l  代码段：用来存放从硬盘上读取的源程序代码。

         l  数据段：用来存放static定义的静态成员。

 

下面是内存表示图：

 

 

 

 

         上图中大致描述了Java内存分配，接下来通过实例详细讲解Java程序是如何在内存中运行的（注：以下图片引用自尚学堂马士兵老师的J2SE课件，图右侧是程序代码，左侧是内存分配示意图，我会一一加上注释）。

 

预备知识：

 

         1.一个Java文件，只要有main入口方法，我们就认为这是一个Java程序，可以单独编译运行。

         2.无论是普通类型的变量还是引用类型的变量(俗称实例)，都可以作为局部变量，他们都可以出现在栈中。只不过普通类型的变量在栈中直接保存它所对应的值，而引用类型的变量保存的是一个指向堆区的指针，通过这个指针，就可以找到这个实例在堆区对应的对象。因此，普通类型变量只在栈区占用一块内存，而引用类型变量要在栈区和堆区各占一块内存。

 

示例：

 

         1.JVM自动寻找main方法，执行第一句代码，创建一个Test类的实例，在栈中分配一块内存，存放一个指向堆区对象的指针110925。

         2.创建一个int型的变量date，由于是基本类型，直接在栈中存放date对应的值9。

         3.创建两个BirthDate类的实例d1、d2，在栈中分别存放了对应的指针指向各自的对象。他们在实例化时调用了有参数的构造方法，因此对象中有自定义初始值。

 

         调用test对象的change1方法，并且以date为参数。JVM读到这段代码时，检测到i是局部变量，因此会把i放在栈中，并且把date的值赋给i。

 

         把1234赋给i。很简单的一步。

 

         change1方法执行完毕，立即释放局部变量i所占用的栈空间。

 

         调用test对象的change2方法，以实例d1为参数。JVM检测到change2方法中的b参数为局部变量，立即加入到栈中，由于是引用类型的变量，所以b中保存的是d1中的指针，此时b和d1指向同一个堆中的对象。在b和d1之间传递是指针。

 

         change2方法中又实例化了一个BirthDate对象，并且赋给b。在内部执行过程是：在堆区new了一个对象，并且把该对象的指针保存在栈中的b对应空间，此时实例b不再指向实例d1所指向的对象，但是实例d1所指向的对象并无变化，这样无法对d1造成任何影响。

 

         change2方法执行完毕，立即释放局部引用变量b所占的栈空间，注意只是释放了栈空间，堆空间要等待自动回收。

 

         调用test实例的change3方法，以实例d2为参数。同理，JVM会在栈中为局部引用变量b分配空间，并且把d2中的指针存放在b中，此时d2和b指向同一个对象。再调用实例b的setDay方法，其实就是调用d2指向的对象的setDay方法。

 

         调用实例b的setDay方法会影响d2，因为二者指向的是同一个对象。

 

         change3方法执行完毕，立即释放局部引用变量b。

 

         以上就是Java程序运行时内存分配的大致情况。其实也没什么，掌握了思想就很简单了。无非就是两种类型的变量：基本类型和引用类型。二者作为局部变量，都放在栈中，基本类型直接在栈中保存值，引用类型只保存一个指向堆区的指针，真正的对象在堆里。作为参数时基本类型就直接传值，引用类型传指针。

 

小结：

 

         1.分清什么是实例什么是对象。Class a= new Class();此时a叫实例，而不能说a是对象。实例在栈中，对象在堆中，操作实例实际上是通过实例的指针间接操作对象。多个实例可以指向同一个对象。

         2.栈中的数据和堆中的数据销毁并不是同步的。方法一旦结束，栈中的局部变量立即销毁，但是堆中对象不一定销毁。因为可能有其他变量也指向了这个对象，直到栈中没有变量指向堆中的对象时，它才销毁，而且还不是马上销毁，要等垃圾回收扫描时才可以被销毁。

         3.以上的栈、堆、代码段、数据段等等都是相对于应用程序而言的。每一个应用程序都对应唯一的一个JVM实例，每一个JVM实例都有自己的内存区域，互不影响。并且这些内存区域是所有线程共享的。这里提到的栈和堆都是整体上的概念，这些堆栈还可以细分。

         4.类的成员变量在不同对象中各不相同，都有自己的存储空间(成员变量在堆中的对象中)。而类的方法却是该类的所有对象共享的，只有一套，对象使用方法的时候方法才被压入栈，方法不使用则不占用内存。

 

         以上分析只涉及了栈和堆，还有一个非常重要的内存区域：常量池，这个地方往往出现一些莫名其妙的问题。常量池是干嘛的上边已经说明了，也没必要理解多么深刻，只要记住它维护了一个已加载类的常量就可以了。接下来结合一些例子说明常量池的特性。

 

预备知识：

 

         基本类型和基本类型的包装类。基本类型有：byte、short、char、int、long、boolean。基本类型的包装类分别是：Byte、Short、Character、Integer、Long、Boolean。注意区分大小写。二者的区别是：基本类型体现在程序中是普通变量，基本类型的包装类是类，体现在程序中是引用变量。因此二者在内存中的存储位置不同：基本类型存储在栈中，而基本类型包装类存储在堆中。上边提到的这些包装类都实现了常量池技术，另外两种浮点数类型的包装类则没有实现。另外，String类型也实现了常量池技术。

 

实例：

 

[java] view plain copy print?

1. public class test {  

2.     public static void main(String[] args) {      

3.         objPoolTest();  

4.     }  

5.   

6.     public static void objPoolTest() {  

7.         int i = 40;  

8.         int i0 = 40;  

9.         Integer i1 = 40;  

10.         Integer i2 = 40;  

11.         Integer i3 = 0;  

12.         Integer i4 = new Integer(40);  

13.         Integer i5 = new Integer(40);  

14.         Integer i6 = new Integer(0);  

15.         Double d1=1.0;  

16.         Double d2=1.0;  

17.           

18.         System.out.println("i=i0\t" + (i == i0));  

19.         System.out.println("i1=i2\t" + (i1 == i2));  

20.         System.out.println("i1=i2+i3\t" + (i1 == i2 + i3));  

21.         System.out.println("i4=i5\t" + (i4 == i5));  

22.         System.out.println("i4=i5+i6\t" + (i4 == i5 + i6));      

23.         System.out.println("d1=d2\t" + (d1==d2));   

24.           

25.         System.out.println();          

26.     }  

27. }  

public class test {

    public static void main(String[] args) {    

        objPoolTest();

    }

 

    public static void objPoolTest() {

        int i = 40;

        int i0 = 40;

        Integer i1 = 40;

        Integer i2 = 40;

        Integer i3 = 0;

        Integer i4 = new Integer(40);

        Integer i5 = new Integer(40);

        Integer i6 = new Integer(0);

        Double d1=1.0;

        Double d2=1.0;

        

        System.out.println("i=i0\t" + (i == i0));

        System.out.println("i1=i2\t" + (i1 == i2));

        System.out.println("i1=i2+i3\t" + (i1 == i2 + i3));

        System.out.println("i4=i5\t" + (i4 == i5));

        System.out.println("i4=i5+i6\t" + (i4 == i5 + i6));    

        System.out.println("d1=d2\t" + (d1==d2));

        

        System.out.println();        

    }

}

 

结果：

[plain] view plain copy print?

1. i=i0    true  

2. i1=i2   true  

3. i1=i2+i3        true  

4. i4=i5   false  

5. i4=i5+i6        true  

6. d1=d2   false  

i=i0    true

i1=i2   true

i1=i2+i3        true

i4=i5   false

i4=i5+i6        true

d1=d2   false

 

结果分析：

 

         1.i和i0均是普通类型(int)的变量，所以数据直接存储在栈中，而栈有一个很重要的特性：栈中的数据可以共享。当我们定义了int i = 40;，再定义int i0 = 40;这时候会自动检查栈中是否有40这个数据，如果有，i0会直接指向i的40，不会再添加一个新的40。

         2.i1和i2均是引用类型，在栈中存储指针，因为Integer是包装类。由于Integer 包装类实现了常量池技术，因此i1、i2的40均是从常量池中获取的，均指向同一个地址，因此i1=12。

         3.很明显这是一个加法运算，Java的数学运算都是在栈中进行的，Java会自动对i1、i2进行拆箱操作转化成整型，因此i1在数值上等于i2+i3。

         4.i4和i5 均是引用类型，在栈中存储指针，因为Integer是包装类。但是由于他们各自都是new出来的，因此不再从常量池寻找数据，而是从堆中各自new一个对象，然后各自保存指向对象的指针，所以i4和i5不相等，因为他们所存指针不同，所指向对象不同。

         5.这也是一个加法运算，和3同理。

         6.d1和d2均是引用类型，在栈中存储指针，因为Double是包装类。但Double包装类没有实现常量池技术，因此Doubled1=1.0;相当于Double d1=new Double(1.0);，是从堆new一个对象，d2同理。因此d1和d2存放的指针不同，指向的对象不同，所以不相等。

 

小结：

 

         1.以上提到的几种基本类型包装类均实现了常量池技术，但他们维护的常量仅仅是【-128至127】这个范围内的常量，如果常量值超过这个范围，就会从堆中创建对象，不再从常量池中取。比如，把上边例子改成Integer i1 = 400; Integer i2 = 400;，很明显超过了127，无法从常量池获取常量，就要从堆中new新的Integer对象，这时i1和i2就不相等了。

         2.String类型也实现了常量池技术，但是稍微有点不同。String型是先检测常量池中有没有对应字符串，如果有，则取出来；如果没有，则把当前的添加进去。

       

 

         凡是涉及内存原理，一般都是博大精深的领域，切勿听信一家之言，多读些文章。我在这只是浅析，里边还有很多猫腻，就留给读者探索思考了。希望本文能对大家有所帮助！