Java中类，对象，方法的内存分配

以下针对引用数据类型：
在内存中，类是静态的概念，它存在于内存中的CodeSegment中。
当我们使用new关键字生成对象时，JVM根据类的代码，去堆内存中开辟一块控件，存放该对象，该对象拥有一些属性，拥有一些方法。但是同一个类的对象和对象之间并不是没有联系的，看下面的例子：

class Student{
    static String schoolName;
    String name;
    int age;

    void speak(String name){
        System.out.println(name);
    }

    void read(){
    }
}

class Test{
    public statis void main(String[] args){
        Student a = new Student();
        Student b = new Student();
    }
}

在上面的例子中，生成了两个Student对象，两个对象拥有各自的name和age属性，而schoolName属性由于是static的，被所有的对象所共有，而且每个对象都有权更改这个属性。
而对于方法speak()和read()来讲，它们被所有的对象所共有，但并不是说哪个对象拥有这些方法。方法仅仅是一种逻辑片段而已，它不是实物，严格来讲不能被拥有。
方法存在的意义就是对对象进行修改。（我的理解）
上述speak()方法，虽然两个对象都拥有相同的方法，但是由于其操作的对象不同，所以执行起来的效果也不同。再说一次，方法是看不见摸不着的，它仅仅是一种逻辑操作！只有当作用于具体的对象时，方法才具体化了！
方法在不执行的时候不占用内存空间，只有在执行的时候才会占用内存空间。
就好比说一个人会翻跟斗，他翻跟斗的时候是需要空间的，但是他不翻跟斗的时候是不需要额外的空间的。但是不管他翻不翻跟斗，他始终是具有翻跟斗的技能的。
Java中的内存布局（其他面向对象的语言也是如此）

Java中的内存空间分为四种：
1. code segment（代码段，是不是所谓的方法区？）
存储class文件的内容，即我们写的代码。
2. data segment（数据段）
存储静态变量
3. heap segment
堆空间，存储new出来的对象
4. stack segment
栈空间，存储引用类型的引用（注意，这里存储的不一定是对象所处的物理地址，但是一定能够根据这个内容在堆中找到对应的对象），局部变量和方法执行时的方法的代码

以上面的speak(String name)方法的调用为例来分析下内存：
调用该方法时，首先在栈控件开辟了一块区域存放name引用。然后将传入的那个对象的“地址”赋值给这个引用。于是出现了什么情况？两个引用指向同一个对象。而我们操作对象时是通过对象的引用来执行操作，所以当一个对象有一个以上的引用同时指向它时，就会出现一些比较混乱的事情了。

通过马士兵在课上讲的一个小例子来看看：

public class Test {

    public static void main(String[] args) {
        Test test = new Test();
        int data = 10;
        BirthDate b1 = new BirthDate(5,4,1993);
        BirthDate b2 = new BirthDate(25,5,1992);

        test.change(data);
        test.change1(b1);
        test.change2(b2);
        System.out.println(data);
        b1.display();
        b2.display();
    }

    void change(int i){
        i = 100;
    }

    void change1(BirthDate b){
        b = new BirthDate(1,1,1);
    }

    void change2(BirthDate b){
        b.setDay(100);
    }
}

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

    BirthDate(int day,int month,int year){
        this.day = day;
        this.month = month;
        this.year = year;
    }

    public int getDay() {
        return day;
    }
    public void setDay(int day) {
        this.day = day;
    }
    public int getMonth() {
        return month;
    }
    public void setMonth(int month) {
        this.month = month;
    }
    public int getYear() {
        return year;
    }
    public void setYear(int year) {
        this.year = year;
    }

    public void display(){
        System.out.println("day = "+day+"\nmonth = "+month+"\nyear = "+year);
    }
}

    输出为：

    10
    day = 5
    month = 4
    year = 1993
    day = 100
    month = 5
    year = 1992

从输出结果来看看发生了什么：
1. 调用change(int i)
此时在栈空间中新建了一个i，并把data的值复制给i。这个时候在栈空间中有两个int类型的数，二者的值虽然都为10，但是二者毫无关系，栈空间中有两个10.
在方法体中对i进行赋值，该操作是对i进行的，并不影响data，所以当方法结束时data还是原来的data，连地址都没变一下。同时在方法结束时i自动从栈空间中消失。
2. 调用change1(BirthDate b)
此时在栈空间中新建一个引用b，在调用该方法的时候，将传进来的引用的值复制给b，即b和b1拥有相同的内容，指向同一个对象。在方法体中对b又进行赋值操作，首先在堆空间中new出一个新的对象，然后将b改为指向这个新的对象。该操作也未影响b1。方法结束后，引用b消失，刚才new出来的新对象成了垃圾，等待GC的回收。
3. 调用change2(BirthDate b)
同上，先在对中新建一个引用，名为b，然后将其指向b2所指向的对象。注意，此时调用了该对象的方法，修改了部分属性，所以此操作改变了这个对象，而b2也指向这个对象，所以最后b2的输出发生了变化。

从上面的三个方法可以看出，当方法中的参数列表不为空时：
- 如果参数是引用数据类型，该方法执行的过程首先是创建若干个引用，然后将这些引用的值和传进来的引用的值一一对应复制。复制完之后，传进来的参数（引用）的工作也就完成了。
- 如果参数是基本数据类型，那么首先在栈中创建对应数量个变量，将这些变量的值和传进来的参数一一对应复制。复制完之后也没有外面什么事了。

综上：传参时要注意，如果对传进去的参数（实际上是引用）进行了重新的赋值操作，那么该方法应该有一个返回值，否则该方法是没有意义的，如同上面的change1()。

    方法一般有两个作用：1. 对某变量进行改变。 2. 根据传进来的参数返回另一变量。
    如果一个方法不想有返回值，只是想对某变量进行改变，不要将该对象作为参数传进去，而直接在方法中获得其访问权限然后直接更改。方法的参数列表为空。
    如果一个方法要有返回值，最好先在方法内部new一个临时变量，先将传进来的参数复制一下，逻辑执行完后，把临时变量return出去。

20170620更新：
其实以上问题涉及到的东西是值传递与引用传递。在C++中二者都有，但是在Java中只有值传递。具体到实践中分两种情况：
- 传递的是基本数据类型：
其实传递的是值的拷贝。在方法中对值进行操作，并不影响传进去的那个值。如上面的change()方法，传值进去时只是按照data的样子重新创建了一个i，本质上data和i除了值相同以外，是两个独立的个体。

    传递的是数组对象或者其他对象：
    实际上传递的是对象的引用，但是并不是把引用传过去，而是把引用复制过去。就像上面的change1()方法一样，其本质是将传参b1这个引用的值复制给引用b。b1和b除了值相同外，是两个独立的个体。但是由于二者值相同，所以指向了堆内存中的同一个对象，二者都可以用来操作对象。

总结一下：
传值，传的都是栈中所储存的东西的拷贝。如果传进去的东西是基本数据类型，那么就直接复制一份，对其操作不影响原来的数据。
如果传进去的是一个引用，那么其实也是复制一份，所以指向同一对象。当操作这个引用时，改变了这个引用所指向的对象，看起来会让人觉得当时传进去的是对象本身，不然怎么在方法中对其修改会改变原本的对象呢？其实这是个假象。时刻记住，传进函数的都是栈内存中的东西，堆内存的东西是不会被传进去的。而函数内部能不能改变原来对象的值，就要看你是不是保持了原来传进去的引用所指向的对象没变。

PS：才疏学浅，如有错误请指出，谢谢！