函数、数组_在堆内存中建立对象的特有属性，并进行默认初始化-CSDN博客

http://blog.csdn.net/dgy5258565/article/details/17399631
http://blog.csdn.net/dgy5258565/article/details/17539179
数组的内存结构

    Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

  栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。

  堆内存：

     （1）数组和对象，通过new建立的实例都存放在堆内存中。

     （2）每一个实体都有内存地址值

     （3）实体中的变量都有默认初始化值

     （4）实体不在被使用，会在不确定的时间内被垃圾回收器回收

数组常见操作
选择排序：

public class test {  

    public static void main(String[] args) {  
        int arr[]={2,4,5,1,3};  
        int max;  
        //外循环进行元素顺序调换  
        //内循环获得每趟中部分数组中的最大元素下标  
        for(int i=1;i<arr.length;i++){  
            max=0;  
            for(int j=1;j<=arr.length-i;j++){  
                if(arr[j]>arr[max]){  
                    max=j;  
                }  
                int temp=arr[arr.length-i];//将此趟的部分数组的最后一个元素值存入temp  
                arr[arr.length-i]=arr[max];//将此趟的部分数组的最大元素值存入最后元素的位置  
                arr[max]=temp;//将temp中的值放入之前最大元素的位置上。  
            }  
        }  
        //遍历输出  
        for(int i:arr){  
            System.out.println(i);  
        }  
    }  
}

        for(int i=1;i<arr.length;i++){  
            for(int j=0;j<arr.length-i;j++){  
                if(arr[j]>arr[j+1]){  
                    /*相邻元素进行比较，若较前元素大于较后元素， 
                     * 将其调转位置 
                     * */  
                    int temp=arr[j];  
                    arr[j]=arr[j+1];  
                    arr[j+1]=temp;  
                }  
            }  
        }

当函数内需要用到调用该函数的对象时，就用this来表示这个对象。即但凡本类功能内部使用到了本类对象，就都用this表示。
构造方法的重载
* A：当在描述事物时，要不要在类中写构造方法呢？这时要根据描述事物的特点来确定，当描述的事物在创建其对象时就要明确属性的值，这时就需要在定义类的时候书写带参数的构造方法。
* 若创建对象时不需要明确具体的数据，这时可以不用书写构造方法（不书写也有默认的构造方法）。
* 构造方法和一般方法区别
* A: 目前为止，学习两种方法，分别为构造方法和一般方法，那么他们之间有什么异同呢？
1.格式不同
构造方法 : 修饰符类名(参数类型参数 …){
初始化成员变量
}
一般方法: 需要有返回值类型
2.作用不同
构造方法一般用来给成员变量初始化;
一般方法根据需求而定;
3.调用方式不同
构造方法创建对象时调用, 或者this() super() 语句调用
普通方法需要对象调用或者静态方法直接调用静态方法.
4.执行不同
构造方法在对象创建时就执行了，而且只执行一次。
一般方法是在对象创建后，需要使用时才被对象调用，并可以被多次调用。

this语句：用于构造函数间互相调用。this（）；

this()语句只能定义在构造函数的第一行。因为初始化要先执行。
this代表其所在函数所属对象的引用。即this代表本类对象的引用。简单说，哪个对象在调用this所在的函数，this就代表哪个对象
http://blog.csdn.net/dgy5258565/article/details/17539179
一、静态（static）
1、static关键字
当成员被静态修饰后，就多了一种调用方式，除了被对象调用外，还可以直接被类名调用。格式：类名.静态成员
被static修饰后的成员具备以下特点：
（1）随着类的加载而加载（随着类的消失而消失，说明静态的生命周期最长）（放在方法去，周期很长。先加载后消亡）
（2）优先于对象存在（静态先存在，对象后存在）
（3）被所有对象所共享
（4）可以直接被类名调用

注意：（1）静态方法只能访问静态成员（非静态方法既可以访问静态也可以访问非静态。）
（2）静态方法中不可以写this，super关键字（因为静态优先于对象存在，所以静态方法中不可以出现this）
（3）主函数是静态的
什么时候定义静态变量？
当对象中出现共享数据时，该数据被静态所修饰，对象中的特有数据要定义成非静态存在于堆内存中。
注意：
接口中的每个成员变量都默认使用public static final修饰。
所有接口中的成员变量已是静态常量，由于接口没有构造方法，所以必须显示赋值。可以直接用接口名访问。
interface Inter {
public static final int COUNT = 100;
}
访问接口中的静态变量
Inter.COUNT
//
final的特点
final修饰类不可以被继承，但是可以继承其他类。
final**修饰的变量**称为常量，这些变量只能赋值一次。
final int i = 20;
引用类型的变量值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改。
final Person p = new Person();
Person p2 = new Person();
p = p2; //final修饰的变量p，所记录的地址值不能改变
p.name = “小明”;//可以更改p对象中name属性值
p不能为别的对象，而p对象中的name或age属性值可更改。
修饰成员变量，需要在创建对象前赋值，否则报错。(当没有显式赋值时，多个构造方法的均需要为其赋值。)
class Demo {
//直接赋值
final int m = 100;

//final修饰的成员变量，需要在创建对象前赋值，否则报错。
final int n; 
public Demo(){
    //可以在创建对象时所调用的构造方法中，为变量n赋值
    n = 2016;
}

}
对象的初始化过程：

Person p = new Person(“zhangsan”,20);
该语句做了什么事情？
对象的初始化过程：
1、因为new用到了Person.class，所以会先找到Person.class文件并加载到内存中。（new Person（）；）
2、执行该类中的静态代码块，如果有的话，给Person.class类进行初始化。
3、在堆内存中开辟空间，分配内存地址。（例如内存中开辟了空间，分配地址为0x0023）
4、在堆内存中建立对象的特有属性，并进行默认初始化。（建立特有属性name和age，默认初始化：name=null；age=0；）
5、对属性进行显示初始化。（类中定义属性的时候已经有显示的定义值，例：private String name=”lisi”。则对属性显示初始化：name=”lisi”,age=0）
6、对对象进行构造代码块初始化。
7、对对象进行对应的构造函数初始化。（进行构造函数初始化：name=”zhangsan”,age=20）
8、将内存地址赋给栈内存中的p变量。（将内存地址0x0023赋给p，则p指向对象Person(“zhangsan”,20)）
饿汉式：类一进入内存就建立了对象，即在类中就先初始化对象。
单例设计模式使用：
对于事物该怎么描述，还怎么描述。
当需要该事物的对象保证在内存中唯一时，就将以上的三步加上即可。

class Single{  
    private Single(){}//私有化构造函数，禁止其他程序建立本类对象。  
    private static Single s=new Single();//在类中创建一个本类对象,对其进行静态私有修饰。  
    public static Single getInstance(){  
        return s;  
    }//向外提供本类对象。  
}  

public class SingleDmo {  

    public static void main(String[] args) {  
        Single ss=Single.getInstance();//获得Single类类型的对象。  
        Single s1=Single.getInstance();//s1和ss都是同一个对象。  
    }  

}

class Single{  
    private int num;  
    public void setNum(int num){  
        this.num=num;  
    }  
    public int getNum(){  
        return num;  
    }  
    private Single(){}//私有化构造函数，禁止其他程序建立本类对象。  
    private static Single s=new Single();//在类中创建一个本类对象,对其进行静态私有修饰。  
    public static Single getInstance(){  
        return s;  
    }//向外提供本类对象。  
}  
  //创建对象得到限制？
public class SingleDmo {  

    public static void main(String[] args) {  
        Single s1=Single.getInstance();//获得Single类类型的对象。  
        Single s2=Single.getInstance();//s1和s2都是同一个对象。  
        //分别赋两个值  
        s1.setNum(5);  
        s2.setNum(6);  
        //输出的都是6.因为两个对象其实都是一个对象，先给对象中num赋的5被后来的6覆盖了。  
        System.out.println("s1:"+s1.getNum());  
        System.out.println("s2:"+s2.getNum());  
    }  

}

class Single{  
    private Single(){}  
    private static Single s=new Single();//**先初始化**对象  
    public static Single getInstance(){  
        return s;  
    }//向外提供本类对象。  
}

懒汉式出现问题：
例如A程序和B程序，A程序判断完s==null，cpu切换到另一程序，A程序挂起；接着cpu开始执行B程序，B程序判断完s==null，cpu又切换到另一程序，B程序挂起。等到A程序恢复执行，则建立一个对象s，接下来当B程序开始执行，B又会进行创建对象s，由于这是单例设计，所以这里两个对象会冲突报错，产生安全问题。
这个问题可以用synchronized关键字（同步）来对程序加锁解决（

class Single{  
    private Single(){}  
    private static Single s=null;  
    public static  Single getInstance(){  
        if(s==null){  
            synchronized(Single.class){  
                if(s==null){  
                    s=new Single();  
                    return s;  
                }  
            }  
        }  
    }//向外提供本类对象。  
}