2015.09.01 Java 学习笔记—内存分析精华

掌握以下内容足以够以后学习所用，很好，很详细，一定吃透

内存分析基础知识

1. 栈内存和堆内存
   栈内存:保存堆内存对应的地址数据,如果想要简单的理解,就将说明为对象的名称.
   堆内存:保存真正有用的数据:指的是对象的属性内容,每一块堆内存都是一块内存地址的信息.
   
   关键字new相当于计算机在内存之中自动开辟一块新的堆内存空间, 开辟完之后分配的是类里属性的默认值
   对象只有实例化之后才可以使用,如果使用了未实例化的对象,一定会出现NullPointerExceptiong,而此异常只要是你从事开发工作,一定会一直陪伴这你, 特别需要提醒的是,每当使用了关键字new操作的时候都会分配新的堆内存空间,所以如果现在实例化了两个对象呢?
   
   在日后的开发中,需要开辟新的堆内存空间,那么就是用关键字new
   对象的真实数据都保存在堆内存之中,所以所谓的引用关系,指的就是同一块堆内存空间被不同的栈所指向
   
   
   所以在实际的开发当中尽量不要产生无用的对内存空间,所有无用的堆内存空间最终都会被gc定期回收
   2.成员变量和局部变量
   成员变量包含:实例变量和类变量.(系统会为成员变量执行默认初始化)
   实例变量:从有实例开始,实例变量就存在了,实例被销毁,实例变量销毁.
   类变量:从有类开始,类变量就存在,一个jvm 里类信息只有一个,每个jvm 最多值加载一个类一次,系统就为该实例分配一块内存
   Java程序不允许直接访问堆内存中的对象,只能通过该对象的引用操作该对象
   只要你用这个类声明变量,或者创建实例或者调用这个类的静态方法或静态field都是用到了这个类
   局部变量必须由程序员来初始化,系统不会对局部变量初始化,局部变量存放在相应方法栈中

先掌握一段简单程序内存分析

package com.buaa.day3;
/*执行详解：
 * Test test = new Test();
 * 首先在main方法栈内定义了一个局部变量test，
 * 接着在堆内存里产生Test对象，局部变量test指向此对象
 * 接着int date = 9;
 * 在main方法栈中创建局部变量 date 值为9
 * 
 ************************************************
 *
 * BirthDate d1= new BirthDate(7,7,1970);
 * 首先BirthDate d1，在stack中创建局部变量d1 ，
 * 接着public BirthDate(int d, int m, int y) {day = d;   month = m;  year = y;  }，
 * 在stack里临时产生局部变量 d, m, y
 * 接着new BirthDate(7,7,1970)，将参数传给在堆内存创建BirthDate对象，局部变量 d, m, y消失                                                          
 * 接着d1指向BirthDate对象（即d1存了可以找到BirthDate对象在堆内存的地址）
 * 
 ************************************************
 *
 * test.change1(date);
 * i 的值的变化是先变成9，然后继续执行变成1234，但是由于i是局部变量，当方法执行结束以后i的值自动消失，
 * 所以date的值依然是9没有改变
 *
 ************************************************
 *test.change2(d1);
 *目的是为了改变d1指向堆内存里的值
 *首先test.change2(d1);把d1传进来，d1的值传给处在stack里的局部变量b，b指向了d1指向的堆内存对象值。
 *接着
 *public void change2(BirthDate b) {//b此时是局部变量，规定传入的参数必须是BirthDate的一个引用
 *b = new BirthDate(22,2,2004);//创建对象后b不指向d1对象的内存堆，指向对象b 的内存堆
 *方法调用完毕时，b这个局部变量消失，指向对象的引用就消失了，堆内存里22,2,2004内容无栈指针，所以会被垃圾回收机制回收
 *故不能达到目的}
 *************************************************
 *
 *test.change3(d2);
 *public void change3(BirthDate b) {b.setDay(22);} 局部变量b指向了d2指向的堆内存
 *接着调用public void setDay(int d) {day = d;}此时在方法栈里产生d局部变量，将d2堆内存里的day的值传参为22，此时实现改变堆内存的对象的值
 *
 *
 *
 * */
public class Test{
    public static void main(String args[]){

        Test test = new Test();
        int date = 9;
        BirthDate d1= new BirthDate(7,7,1970);
        BirthDate d2= new BirthDate(1,1,2000);    
        test.change1(date);
        test.change2(d1);
        test.change3(d2);
        System.out.println("date=" + date);
        d1.display();
        d2.display();
    }

    public void change1(int i){i = 1234;}

    public void change2(BirthDate b) {b = new BirthDate(22,2,2004);}

    public void change3(BirthDate b) {b.setDay(22);}
}


class BirthDate {
    private int day;
    private int month;
    private int year;

    public BirthDate(int d, int m, int y) {day = d; month = m; year = y; }

    public void setDay(int d) {day = d;}

    public void setMonth(int m) {month = m;}

    public void setYear(int y) {year = y;}

    public int getDay() {return day;}

    public int getMonth() {return month; }

    public int getYear() {return year; }

    public void display() {System.out.println(day + " - " + month + " - " + year);}
}
/*执行结果：
date=9
7 - 7 - 1970
22 - 1 - 2000
*/

接着掌握这段相对复杂的程序内存分析

package com.buaa.day3;
import static java.lang.System.*;
/*程序解读：
 * Circle c1 = new Circle(new Point(1.0,2.0), 2.0);
 * 首先执行Circle c1 ，c1是一个引用类型的变量，所以给它分配一块栈内存存放一个Circle对象的引用（也就是地址）,
 * 接着new Point(1.0,2.0)在堆内存里分配Point对象，
 * 接着  Circle(Point p, double r) {//把圆心定到原点上。局部变量P指向Point对象，
        o = p; //让Circle对象的成员变量o指向指向Point对象的堆内存
        radius = r;

 * 接着new Circle(new Point(1.0,2.0), 2.0);在堆内存分配Circle对象，并且让Circle对象的成员变量O指向point对象，
 * 这行代码的顺序之所以是这样是因为“=”的优先级比“new”的优先级低。
 * 
 * 执行结果：c1指向Circle对象的堆内存，Circle对象的成员变量O指向了point对象的堆内存
 * 
 * *****************************************************************
 * 
 * Circle c2 = new Circle(5.0);
 * 内存里又分配一块Circle对象，c2指向此对象
 *     Circle(double r) {
        o = new Point(0.0, 0.0);c2指向的Circle对象的成员变量O指向了point对象的堆内存，内容为0.0, 0.0
        radius = r;
    } 
 *  
 * *****************************************************************
 * 
 * c1.getO().getX()
 * c1.getO() 
 * public Point getO() { return o;//分配一块临时内存区域，此区域的值和O里的值一样，指向了Point对象的堆内存，内容为1.0,2.0

    }
 *  c1.getO().getX()返回1.0
 *  
 *  
 *  
 *  
 * */
public class TestCircle {
    public static void main(String args[]) {

        Circle c1 = new Circle(new Point(1.0,2.0), 2.0);
        Circle c2 = new Circle(5.0); 
        out.println("c1:("+c1.getO().getX()+","+c1.getO().getY()+"),"+c1.getRadius());//执行完之后main方法栈内存只剩下c1,c2
        out.println("c2:("+c2.getO().getX()+","+c2.getO().getY()+"),"+c2.getRadius());     
        out.println("c1 area = "+c1.area());
        out.println("c1 area = "+c2.area());
        c1.setO(5,6);
        c2.setRadius(9.0);
        out.println("c1:("+c1.getO().getX()+"," +c1.getO().getY()+"),"+c1.getRadius());
        out.println("c2:("+c2.getO().getX()+","+c2.getO().getY()+"),"+c2.getRadius());
        out.println("c1 area = "+c1.area());
        out.println("c1 area = "+c2.area());
        //验证一个点是否在一个圆之内
        Point p1 = new Point(5.2, 6.3);
        out.println(c1.contains(p1));
        out.println(c1.contains(new Point(10.0,9.0)));

    }
}

class Point {
    private double x;
    private double y;
    Point(double x1, double y1) { 
        x = x1; 
        y = y1;
    }
    public double getX() { return x; }
    public double getY() { return y; }
    public void setX(double i) { x = i; }
    public void setY(double i) { y = i; }
}

class Circle {
    private Point o;
    private double radius;
    Circle(Point p, double r) {//把圆心定到原点上
        o = p; 
        radius = r;
    }
    Circle(double r) {
        o = new Point(0.0, 0.0);
        radius = r;
    }

    boolean contains(Point p) {//计算一个点是否在一个圆中
        double x = p.getX() - o.getX();
        double y = p.getY() - o.getY();
        if(x*x + y*y > radius * radius) return false;
        else return true;
    }


    public void setO(double x, double y) {
        o.setX(x); 
        o.setY(y);
    }
    public Point getO() { return o;//分配一块临时内存区域，此区域的值和O里的值一样，指向了Point对象的堆内存

    }
    public double getRadius() { return radius;}
    public void setRadius(double r) { radius = r;}
    public double area() { 
        return 3.14 * radius * radius;
    }
}
/*执行结果：
c1:(1.0,2.0),2.0
c2:(0.0,0.0),5.0
c1 area = 12.56
c1 area = 78.5
c1:(5.0,6.0),2.0
c2:(0.0,0.0),9.0
c1 area = 12.56
c1 area = 254.34
true
false

*/