Java对象与内存管理

1.实例变量和类变量的内存分配

日喀则网站制作公司哪家好，找创新互联！从网页设计、网站建设、微信开发、APP开发、响应式网站开发等网站项目制作，到程序开发，运营维护。创新互联2013年至今到现在10年的时间，我们拥有了丰富的建站经验和运维经验，来保证我们的工作的顺利进行。专注于网站建设就选创新互联。

类变量 ：使用static修饰的成员变量是类变量，属于该类本身

实例变量：没有使用static修饰的成员变量是实例变量，属于该类的实例

由于同一个JVM内每个累只对应一个Class对象，因此同一个JVM内的一个类的类变量只需一块内存空间。

对于实例变量而言，该类没创建一次实例，就需要为实例变量分配一块内存空间，所以，程序中有几个实例，实例变量就需要几块内存空间。

2.类变量的初始化时机总是出于实例变量的初始化之前

我们先看下下面三段代码：

1）因为两个实例变量都是在创建变量的时候才开始分配空间，此时num2还没有分配，所以前向引用就会出现编译错误。

  
 
 
 
    
   
  
  
  
  1. int num = num2 + 3;    //非法前向引用,会报错 
    2. 
   
  
  
  
  2. int num2 = 2 
    3.

2）因为两个类变量在JVM加载类的时候分配空间，此时num2还没有分配，所以前向引用就出现变异错误。

  
 
 
 
    
   
  
  
  
  1. static int num = num2 + 3;    //非法前向引用,会报错 
    2. 
   
  
  
  
  2. tatic int num2 = 2 
    3.

3）因为类变量num2在JVM加载类的时候空间已经分配好，而num在创建实例的时候踩分配空间，此时num2已经分配成功了，所以num前向引用成功。

  
 
 
 
    
   
  
  
  
  1. int num = num2 + 3;    //正确使用 
    2. 
   
  
  
  
  2. static int num2 = 2; 
    3.

由上面三段代码块就可以验证得：类变量的初始化时机总是出于实例变量的初始化之前

3.Java对象的初始化方式及其执行顺序

Java对象的初始化方式有三种：1）构造器  2）初始化块  3）定义变量时指定初始化值

如果这三种初始化方式同时出现，也要注意，他们也有一个执行顺序的规定：

1）静态初始化块只在类第一次创建对象的时候运行一次，后面就不会再运行，而类在每次创建对象时，非静态初始化块总是会运行一次。

  
 
 
 
    
   
  
  
  
  1. public class Test{ 
    2. 
   
  
  
  
  2.      static { 
    3. 
   
  
  
  
  3.          System.out.println("执行---静态初始化代码块."); 
    4. 
   
  
  
  
  4.      } 
    5. 
   
  
  
  
  5.       
    6. 
   
  
  
  
  6.      { 
    7. 
   
  
  
  
  7.          System.out.println("执行---非静态初始化代码块."); 
    8. 
   
  
  
  
  8.      } 
    9. 
   
  
  
  
  9.       
    10. 
   
  
  
  
  10.      public static void main(String[] args) { 
    11. 
   
  
  
  
  11.          for (int i = 1; i <= 2; i++) { 
    12. 
   
  
  
  
  12.              System.out.println("创建第 " + i + " 个对象");  
    13. 
   
  
  
  
  13.              new Test(); 
    14. 
   
  
  
  
  14.              System.out.println(); 
    15. 
   
  
  
  
  15.          } 
    16. 
   
  
  
  
  16.      } 
    17. 
   
  
  
  
  17.  } 
    18.

 

运行结果：

2）构造器每次创建对象时，构造器必然有执行的机会，此时，非静态初始化块必定也将获得机会并且运行在构造器之前

  
 
 
 
    
   
  
  
  
  1. public class Test{ 
    2. 
   
  
  
  
  2.   
    3. 
   
  
  
  
  3.      { 
    4. 
   
  
  
  
  4.          System.out.println("执行---非静态初始化代码块."); 
    5. 
   
  
  
  
  5.      } 
    6. 
   
  
  
  
  6.       
    7. 
   
  
  
  
  7.      public Test() { 
    8. 
   
  
  
  
  8.          System.out.println("执行---构造器."); 
    9. 
   
  
  
  
  9.      } 
    10. 
   
  
  
  
  10.       
    11. 
   
  
  
  
  11.      public static void main(String[] args) { 
    12. 
   
  
  
  
  12.          for (int i = 1; i <= 2; i++) { 
    13. 
   
  
  
  
  13.              System.out.println("创建第 " + i + " 个对象");  
    14. 
   
  
  
  
  14.              new Test(); 
    15. 
   
  
  
  
  15.              System.out.println(); 
    16. 
   
  
  
  
  16.          } 
    17. 
   
  
  
  
  17.      } 
    18. 
   
  
  
  
  18.  } 
    19.

 

运行结果:

3）定义变量时指定的初始化值和初始化块中指定的初始值的执行顺序与他们在源程序中的排列顺序相同。

验证代码一：

  
 
 
 
    
   
  
  
  
  1. public class Test{ 
    2. 
   
  
  
  
  2.       
    3. 
   
  
  
  
  3.      String i = "定义变量时指定的初始化值"; 
    4. 
   
  
  
  
  4.   
    5. 
   
  
  
  
  5.      { 
    6. 
   
  
  
  
  6.          i = "初始化块中指定的初始值"; 
    7. 
   
  
  
  
  7.      } 
    8. 
   
  
  
  
  8.       
    9. 
   
  
  
  
  9.      public static void main(String[] args) { 
    10. 
   
  
  
  
  10.          for (int i = 1; i <= 2; i++) { 
    11. 
   
  
  
  
  11.              System.out.println("创建第 " + i + " 个对象");  
    12. 
   
  
  
  
  12.              System.out.println(new Test().i); 
    13. 
   
  
  
  
  13.              System.out.println(); 
    14. 
   
  
  
  
  14.          } 
    15. 
   
  
  
  
  15.      } 
    16. 
   
  
  
  
  16.  } 
    17.

运行结果

验证代码二 ：

 
 
 
 
    
  
  
  
  
  1. public class Test{ 
    2. 
  
  
  
  
  2.   
    3. 
  
  
  
  
  3.      { 
    4. 
  
  
  
  
  4.          i = "初始化块中指定的初始值"; 
    5. 
  
  
  
  
  5.      } 
    6. 
  
  
  
  
  6.       
    7. 
  
  
  
  
  7.      String i = "定义变量时指定的初始化值"; 
    8. 
  
  
  
  
  8.   
    9. 
  
  
  
  
  9.      public static void main(String[] args) { 
    10. 
  
  
  
  
  10.          for (int i = 1; i <= 2; i++) { 
    11. 
  
  
  
  
  11.              System.out.println("创建第 " + i + " 个对象");  
    12. 
  
  
  
  
  12.              System.out.println(new Test().i); 
    13. 
  
  
  
  
  13.              System.out.println(); 
    14. 
  
  
  
  
  14.          } 
    15. 
  
  
  
  
  15.      } 
    16. 
  
  
  
  
  16.  } 
    17.

运行结果：

4.关于父子实例的内存控制

（一般情况下是不用内部类来验证的，但是都是一样的啦，我偷懒下，所以使用了内部类，大家原谅哈）

1）当子类重写父类方法后，父类表面上只是调用属于自己的被子类重写的方法。

  

  
 
 
 
    
   
  
  
  
  1. public class Test{ 
    2. 
   
  
  
  
  2.      class Base { 
    3. 
   
  
  
  
  3.          Base() { 
    4. 
   
  
  
  
  4.              this.info(); 
    5. 
   
  
  
  
  5.          } 
    6. 
   
  
  
  
  6.          public void info() { 
    7. 
   
  
  
  
  7.              System.out.println("Base"); 
    8. 
   
  
  
  
  8.          } 
    9. 
   
  
  
  
  9.          public void getInfo() { 
    10. 
   
  
  
  
  10.              info(); 
    11. 
   
  
  
  
  11.          } 
    12. 
   
  
  
  
  12.      } 
    13. 
   
  
  
  
  13.       
    14. 
   
  
  
  
  14.      public class Child extends Base{ 
    15. 
   
  
  
  
  15.          @Override 
    16. 
   
  
  
  
  16.          public void info() { 
    17. 
   
  
  
  
  17.              System.out.println("Child"); 
    18. 
   
  
  
  
  18.          } 
    19. 
   
  
  
  
  19.      } 
    20. 
   
  
  
  
  20.       
    21. 
   
  
  
  
  21.      public static void main(String[] args) { 
    22. 
   
  
  
  
  22.          Test test = new Test(); 
    23. 
   
  
  
  
  23.          Base base = test.new Child(); 
    24. 
   
  
  
  
  24.          base.info(); 
    25. 
   
  
  
  
  25.          base.getInfo(); 
    26. 
   
  
  
  
  26.      } 
    27. 
   
  
  
  
  27.  } 
    28.

运行结果：

2）上述是属于多态中方法的体现，但是方法有多态，实例变量无多态。

解释下“方法有多态，变量无多态”这句话：意思是，不管怎样，父类表面上只是调用属于自己的被子类重写的方法。而变量不一样，假设父类和子类都有同一个变量名的实例变量，向上转型后，通过父类访问的实例变量得到的值是自身的而非子类的。向下转型后，通过子类访问的实例变量得到的值是自身的而非父类的。

很多书上或教学视频上都讲，创建一个子类对象的时候，Java 会顺着继承结构往上一直找到 Object，然后从 Object 开始往下依次执行构造函数。先执行父类的构造函数，然后在其子类中会创建一个成员变量指向他的父类。其实这个说法是错误的，系统并不会真正的去创建父类对象，只是在子类对象中不仅保存了本身的实例变量，还有它父类的全部实例变量。

  
 
 
 
    
   
  
  
  
  1. public class Test{ 
    2. 
   
  
  
  
  2.      class Base {    //父类 
    3. 
   
  
  
  
  3.          int i = 2; 
    4. 
   
  
  
  
  4.      } 
    5. 
   
  
  
  
  5.       
    6. 
   
  
  
  
  6.      public class Child extends Base{    //子类 
    7. 
   
  
  
  
  7.          int i  = 20; 
    8. 
   
  
  
  
  8.      } 
    9. 
   
  
  
  
  9.       
    10. 
   
  
  
  
  10.      public static void main(String[] args) { 
    11. 
   
  
  
  
  11.          Test test = new Test(); 
    12. 
   
  
  
  
  12.          Child child = test.new Child(); 
    13. 
   
  
  
  
  13.          Base base = child; 
    14. 
   
  
  
  
  14.          System.out.println(" Base.i : " + base.i); 
    15. 
   
  
  
  
  15.          System.out.println("Child.i : " + child.i); 
    16. 
   
  
  
  
  16.      } 
    17. 
   
  
  
  
  17.  } 
    18.

运行结果： 

5.final修饰符

final变来那个在编译时就被确定下来了，相当于一个直接量。

1）final修饰的实例变量赋值时机：

定义final实例变量时 指定初始值　

在非静态初始化模块中为final实例变量指定的初始值

在构造器中为final实例变量指定初始值　　　

2）final修饰的类变量赋值时机：　

定义final类变量时指定初始值

在静态初始化模块中为final实例变量指定的初始值

原文链接：http://www.cnblogs.com/xiaoxuetu/archive/2013/03/27/2985616.html

【编辑推荐】

  1. Java异常处理
  2. Java 安全模型介绍
  3. 探索Java语言与JVM中的Lambda表达式
  4. Java在线教程–接口篇
  5. Java序列化与JSON序列化大比拼

分享文章：Java对象与内存管理
网站链接：http://www.shufengxianlan.com/qtweb/news5/216205.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站策划知识

分类信息网站

成都网站建设流程　　 　成都未宇聚　　 　什邡做网站　　 　济桢教育　　 　禾巨建站　　 　成都免费做网站公司　　 　买链接　　 　眉山服务器托管　　 　LED显示屏　　 　四川艺考培训　　 　做移动网站　　 　小程序开发公司　　 　成都西信机房　　 　成都机房机柜租用　　 　广汉网站建设　　 　网站建设　　 　护栏钻孔机　　 　手机APP开发　　 　解决方案　　 　电商网站建设方案