Java进阶2 数组内存和对象的内存管理知识

Java进阶2 数组内存和对象的内存管理知识 20131028

前言：

在面试的时候，如果是Java的编程语言，也许你认为没有什么可以问的，只能够说明你对于Java了解的太浅了，几乎就是两个星期的节奏速成，没有在底层掌握Java编程语言。那么面试的时候，你就会发现很多的不会，所以在这个时候切记说你懂Java。

还有有些人面试Java认为就是面试SSH框架，其实个人理解方面，除了那种很小型的公司还有不懂技术的什么什么类型的企业，就会拿SSH器标准你。说一下自己的情况：

我的第一编程语言是C++，同时Java是自己的辅助，可以算的上是本科生中学习Java最好的之一（谦虚点了），但是我自己真的对于SSH没有掌握，因为为了面试去学习SSh框架感觉很不值，自己不喜欢为了学习框架而去学习框架。对于Java中的框架，没有1000也有2000的样子，这么多的框架怎么学啊，所以当有需要的时候才可以去学习。我自己掌握Spring的IOC机制，因为在暑假期间的时候确实需要，还有就是数据接口的框架，我自己掌握的是Mybatis框架技术，所以没有去学习Hibernate框架。其实学习Java的关键不是说你会使用多少的框架，而是对于Java编程语言的真正意义上的掌握，而现在大多数人掌握的Java水平只是出于一种简单的语法，根本不了解Java低层次的更深层次的知识，这样面试的时候，你就会暴露出来，因为面试官问你的问题基本在教材中找不到答案，其实Java是一门轻松入门，但是如果想学懂得话，那就真的需要下点苦功夫了。

Chapter 1 Java数组内存分配

1.Java是一种静态编程语言，对应的Java数组也是静态的即，数组被初始化之后，数组占用的空间和数组的长度是不变的。数组初始化的方式有两种：静态初始化和动态初始化。

静态初始化：程序员显示的指定每一个元素的初始值，有系统决定数组的长度；

动态初始化：程序员指定数组的长度，由系统初始化数组的值，数组还可以使用length访问数组的长度。

数组中的所有元素实质上都保存在内存的堆中，数组的名字保存在栈中。

对于字符串数组的话，其实使用的是string pool 实现的，所以在堆中的内存中存放的知识字符串的地址。

2.数组一定要初始化吗

了解Java中数组的内存分配，其实java数组的名字是保存在栈中的，他本身不是数组对象，而是对数组对象的引用，只要让数组的名字指向有效的数组对象即可使用数组变量。这里的数组变量只是一个引用变量，类似C的指针，数组的初始化其实不是对数组变量执行初始化，而是在堆中创建数组对象，在堆中分配一块连续的内存空间。

int []arr = null;

System.out.println(arr);这一段代码是没有任何问题的，因为访问的是arr变量而不是arr的成员方法或者是属性

arr.length就会报错，抛出NullPointerException，因为通过引用变量访问一个还未引用的有效的对象的时候，就会出现这种异常。

public class TestMain {

public static void main(String[] args) {

Person [] students;

students = new Person[2];

//students[0].printInfo(); // error NullPointerException

//students[1].printInfo(); // error NullPointerException

Person a = new Person(10,12.0);

Person b = new Person(138,24.9);

students[0] = a;

students[1] = b;

System.out.println("before change : ");

students[0].printInfo();

a.age = 100;

a.height = 50.9;

System.out.println("after changed : ");

students[0].printInfo();

/*

* 实际上students[0] 和 a 执行的是同一个对象，当修改了a 的时候，对应的students[0]也会随之修改

* 数组内容同样只是对于对象的一个引用，其中的指向的内容才是实际的对象。

*/

}

}

class Person{

public int age;

public double height;

public Person(int a, double height){

this.age = a; this.height = height;

}

public void printInfo(){

System.out.println("age:" + this.age + ", height:" + this.height);

}

}

Chapter 2 对象及其内存管理

虽然Java是有JVM管理内存的，但是作为程序员，也必须了解Java内存管理机制，我们编写源代码不能够仅仅停留在代码层面上，需要考虑每一行代码对于系统的内存影响。Java的内存管理机制比较那一理解，所以可能会感觉Java内存管理和实际开发距离比较远。这是一种错误的理解，虽然JVM会关心程序的内存回收，但是并不意味着我们程序员可以随意的使用系统的内存。

Java内存管理分为两个方面：内存分配和内存回收。内存分配指的是创建Java对象是JVM为该对象在对内存中分配内存空间；内存回收指的是当该Java对象失去引用的时候，变成垃圾，JVM的垃圾回收机制自动清理该对象，并且回收对象占用的内存空间。

JVM内存回收机制是由一条后台线程维护的，而且该线程也是十分消耗资源的，如果我们在程序中肆无忌惮的创建新对象，让系统分配内存，那么这些分配的内存都将有GVM的垃圾回收机制完成回收，这样做的不好的地方是：

不断的分配内存空间是操作系统的内存空间减少，会降低程序的性能；同时大量已经分配内存的回收是的来及回收的负担加重，降低程序的性能。这一章主要介绍内存管理中的内存分配的知识。

2.1实例变量和类变量

成员变量和局部变量

对于局部变量的话存在三种情况：

形参：在方法签名中定义的局部变量，有放大调用者负责为其赋值，随着方法的结束而消亡。

方法内的局部变量：在方法中定义的局部变量，必须在方法内部显示的初始化，从初始化开始生效，并且随着方法的结束失效；

代码块的局部变量：在代码块中显示的初始化，在代码块结束的时候，变量消亡。

成员变量有两种：静态成员变量和普通的成员变量。静态成员变量也就是说成员属于该类而不是Class中的某一个对象。静态变量的初始化，也就是类变量的初始化是在编译的时候，随着class的初始化而得到初始化的，所以静态变量会造编译阶段的时候就已经完成初始化，所以在普通的成员变量可以使用它，无论是在静态 变量之前还是在静态变量之后。但是对于静态成员变量和静态成员变量就会存在一个先后的问题：

public class ErrorDef{

static int num1 = num2 + 3;

static int num2 = 10;

}

但是对于下面的情况是对的

public class RightDef{

int num1 = num2 + 10;

static int num2 = 10;

}

public class TestMain {

int num1 = num2 + 10;

static int num2; //default 0

public static void main(String[] args) {

TestMain main = new TestMain();

System.out.println(main.num2); //0

System.out.println(main.num1);// 10

}

}

在JVM中每一个Class对应一个对象，每一个Class可以创建多个Java对象。所以静态变量只会有一份。在某种意义上来所其实Class也是一个对象，所以的类都是Class的实例。每一个类初始化之后，系统会为该类创建一个对应的Class实例，程序可以通过反射来获得某个类所对应的Class实例： Person.class ，或者是Class.forName(“Person”)即可。

普通的成员变量的初始化时机：对于实例变量来说，他说与Java对象本身，每一次创建一个Java对象，都会需要为实例变量分配内存空间，并且实例变量执行初始化。在程序中可以在三个地方初始化成员变量：

在声明成员变量的时候初始化；非静态的代码块儿中初始化；构造函数中初始化。前两种方式比后一种方式更早的执行。前两种的话，取决于器在程序中代码的位置。仅限于Java编程语言。我们整理一段Java代码：

public class A {

{

a=2;// 创建A的对象的时候，会执行这一段代码，没创建一个对象都会调用这一段代码，执行当然是在构造函数执行之前，而且可以提前初始化值，但是不可以右值，只可以左值。

}

public int a; //只是一个引用

{

System.out.println("code block a = " +a );

}

static {//静态代码块，在加载类的时候执行，切只会执行一次

System.out.println("static A ");

}

public A(){

System.out.println("A.A()");

System.out.println("in A.A() before change a = " + a);

a = 3;

}

}

public class Base {

public A objA;//不会调用构造函数 当然如果我们在这里显示初始化的话，就会调用，在Base构造函数之前调用A的构造函数，执行一系列操作。

static {

System.out.println("Base static code");

}

{

System.out.println("Base code ");

}

public Base(){

System.out.println("Base.Base()");

objA = new A();

}

}

Main{

Base b= new Base();

}

main start

Base static code

Base code

Base.Base()

static A

code block a = 2

A.A()

in A.A() before change a = 2

在Java中，成员变量在声明的时候初始化的底层实现：

double weight = 23.45;其实是分为两部分实现的，当床架Java对象的时候，根据该语句会为其分配内存空间，但是没有初始化值，weight = 23.45;这一句代码会被提取出来到Java的构造器中执行，但不是构造函数。

对于Java编译的知识我们如果想要了解的更详细的话，可以将源代码编译之后生成class 然后使用 javap –c ClassName输出，查看编译的情况。

对于类的变量初始化时机：定义的时候直接初始化；或者使用静态代码块初始化变量。两种方式的执行顺序按照其在代码中声明的顺序执行。

下面看一段代码：

public class Price {

final static Price INSTANCE = new Price(2.9);

static double initPrice = 20;

public double currPrice;

public Price(double discount){

this.currPrice = this.initPrice - discount;

}

}

public class TestMain {

public static void main(String[] args) throws ClassNotFoundException {

System.out.println(Price.INSTANCE.currPrice);

Price p = new Price(2.9);

System.out.println(p.currPrice);

}

}

//在第一次使用Price类的时候，静态变量调用类的构造函数进行初始化，但是这个时候声明的initPrice没有进行初始化，默认是0，而不是20，所以在调用构造函数的时候会产生复数。

String a = "yang";

System.out.println(System.identityHashCode(a));

String b = "yang";

System.out.println(System.identityHashCode(b));

String c = new String("yang");

System.out.println(System.identityHashCode(c));

2.2继承的执行顺序

public class Base {

static {

System.out.println("Base static code");

}

{

System.out.println("Base not static code ");

}

public Base(){

System.out.println("Base.Base()");

}

public Base(int a){

System.out.println("Base.Base(int )");

}

}

public class Mid extends Base{

static{

System.out.println("Mid static code");

}

{

System.out.println("Mid not static code");

}

Mid(){

super();

System.out.println("Mid.Mid()");

}

Mid(int a){

super(a);

System.out.println("Mid.Mid(int)");

}

}

public class Sub extends Mid {

static {

System.out.println("Sub static code");

}

{

System.out.println("Sub not static code");

}

Sub(){

super(4);

System.out.println("Sub.Sub() ");

}

}

public static void main(String[] args) {

Sub sub = new Sub();

}

Base static code

Mid static code

Sub static code

Base not static code

Base.Base(int )

Mid not static code

Mid.Mid(int)

Sub not static code

Sub.Sub()

执行顺序的理解，其实首先执行的是父类的非静态代码区域，然后是父类的构造函数，但是super默认会执行默认的构造函数，当我们不显示的super执行父类的构造函数类型的时候，需有默认的构造函数，否则会直接报错。其实在super就是指明执行哪一个父类的构造函数。

只要在程序中创建Java对象，系统总是调用最顶层的父类的初始化操作，包括初始化块和构造函数，然后依次向下调用所有的类的初始化操作，最终执行的是本类的初始化操作，返回本类的实例，至于父类中调用哪一个构造函数，分为如下几种情况：1.子类的构造函数中使用super显式的调用父类中的构造函数，系统会根据super的参数列表匹配父类的构造函数，这个是静态绑定，也就是在编译阶段就已经确定了。注意一点如果使用super的话，必须在构造函数中的第一句使用super指明父类的构造函数。2.子类的构造函数中执行体中的第一行代码使用this关键字现实的调用该类中的重载的构造函数，系统图会根据this调用里传入的实参列表来确定该类中的另一个构造器，执行该类的另一个构造函数。3.既没有super关键字，也没有this关键字调用，系统将会在执行子类的构造器之前，隐式的调用默认的父类构造函数。

2.3 访问子类对象中的实例变量

子类中的方法可以访问父类中的实例变量，这是因为子类继承父类就会获得父类的成员变量和方法；但是父类的方法不能够访问子类的实例变量，因为父类不知道他被那个子类继承，他的子类会增加那些变量。

下面分析一段代码：父类 Base ，子类Sub extends Base ， 在main中创建一个子类的对象。

public class Base {

private int val = 2;

public Base(){

System.out.println("Base().val =" + this.val);

System.out.println("Base.Base()");

this.display();

System.out.println(this.getClass());

}

public void display(){

System.out.println("Base.val = " + val);

}

public Base(int a){

System.out.println("Base.Base(int )");

}

}

public class Sub extends Base {

private int val= 22;

Sub(){

System.out.println("Sub.Sub() ");

val = 222;

}

public void display(){

System.out.println("Sub val="+val);

}

}

public static void main(String[] args) throws ClassNotFoundException {

Sub sub = new Sub();

}

输出结果是：

Base().val =2首先调用父类的构造函数，其中使用this输出的变量val是在子类中的声明变量val初始化的2

Base.Base()//首先调用父类的构造函数

Sub val=0//这里我们就有点凌乱了，为什么是0,整理一下，首先是初始化类的构造函数，因为集成，所以首先是执行的父类的初始化，所以在上一条中我们输出的结果是在父类中初始化代码块的2，之后我们在父类中使用this直接调用成员变量的话，那么是调用的Base类的成员变量所以显示的是2，但是我们在后面使用的是调用函数，那么就会有多态问题的出现，这个时候调用函数就是更具具体对象的类型去调用函数。所以这里使用this.display()会根据类的多态调用的是子类中的函数。但是在这个时候，我们子类对象知识分配了内存空间，而没有初始化内存，所以这个时候没有执行到子类的成员变量的初始化，但是我们调用子类的成员变量当然是没有初始化的值0.

class yang.main.Sub//我们在程序父类中输出类的值，会发现this指针实际上是子类。

Sub.Sub()。

在这里我们在整理一个概念：Java对象在内存中的空间并不是有构造代码块实现的内存分配，在构造代码块执行之前，其实对象在内存中的空间已经分配，构造代码块完成的是对内存区域的初始化工作。但是在分配内存空间的时候，没有初始化，默认值都是0.，对于应用类型的变量则是NULL。

总结：当变量编译时的类型和运行时类型是不同的，通过变量访问它的而引用对象的实例变量的时候，该实例变量的值是由声明该变量的类型决定的。但是通过该变量弟阿勇他引用对象的成员函数的时候，则会根据他实际的类型确定的。

2.4父类实例的内存控制

public class Base {

public int val = 2;

public void display(){

System.out.println("Base.val = " + val);

}

}

public class Sub extends Base {

public int val= 22;

public void display(){

System.out.println("Sub val="+val);

}

}

public static void main(String[] args) throws ClassNotFoundException {

Base b = new Base();

System.out.println(b.val); //2

b.display(); // 2

Sub sub = new Sub();

System.out.println(sub.val);//22

sub.display();//22

Base btod = new Sub();

System.out.println(btod.val);//2

btod.display();//22

Base btod2 = sub;

System.out.println(btod2.val);//2

btod2.display();//22

}

总结：不管声明对象是哪一种类型的，只要他们实际指向的是一个子类，那么他调用方法就会将多态体现出来；但是如果调用的是成员变量，那么变量的值总是和声明这些对象的类型一致。

对于继承的话，其实继承了父类中的所有的函数和成员变量，但是因为在访问权限上会做一些限制，其实子类在内存中仅仅有一个对象，但是对于父类中的内容是被隐藏掉。

Java程序中允许出现return this的语句但是不会允许出现 return super，因为在Java中不允许直接将super当成一个引用变量使用。

如果在子类中定义了父类中已经定义的变量，这样在Java是允许的，但是会在子类中隐藏掉，我们可以使用super关键字访问

class Parent{public String tag = “yang”;}

class Derived extends Parent{ public String tag = “teng”;}

Main:

Derived d = new Derived();

System.out.println(d.tag);// complie error

System.out.println(((Parent)d).tag); right yang ;

2.4final 修饰符

2.4.1final 修饰变量

被final修饰的实例变量必须显示的指定初始化值，而且只能够在三个位置指定初始化的值

定义final实例变量的时候指定初始值；在非静态代码块中为final实例变量指定初始化值；在构造函数中初始化值。对于final实例变量JVM无法默认初始化值，因此必须有程序员初始化。

对于final 静态变量，就是是使用static声明的变量的话，那么只能在两个地方进行初始化，一个是静态代码块中，一个是声明的地方。

2.4.2执行宏替换

使用final声明的变量在编译阶段的话会执行宏替换，类似C中的define

再有就是Java会缓存所有的字符串常量，如执行String a = “yang”; String b = “yang”; a==b is true ，因为Java的字符串缓冲池的作用，其实指向的是同一个对象的地址。字符串的话如果可以在编译阶段 就可以确定的字符串，那么就会直接进行编译优化，进行替换，前提是在表达式中不存在变量，全部都是常量。

2.4.3final方法是不可以被重写的

class A{ final void funA(){}}

class B extends A {void funA(){} //error}

追梦的飞飞

于广州中山大学图书馆 20131028

HomePage: http://yangtengfei.duapp.com