2. Java集合可分为三类: Set, List, Map.其中Set代表无序的,不可重复的集合;List代表有序的,可重复的集合;Map代表具有映射关系的集合;

3. java1.5之前,java集合会丢失集合中对象的数据类型,把所有对象当成Object类型处理.

4. java集合主要由两个接口派生而出:Collection和Map

1. Collection接口

    Iterator接口隐藏了各种Conllection实现类的底层细节,向应用程序提供了遍历Conllection集合的统一编程接口.Iterator仅用于遍历集合,且必须依附于Collection对象.

    Iterator接口采用快速失败机制,一旦在迭代的时候检测到该集合已经被修改,通常是程序中的另外的线程,程序立即引发异常.

    代码清单:CollectionTest.java

package Test.test;

import java.util.Collection;

import java.util.HashSet;

import java.util.Iterator;

public class CollectionTest {

    public static void main(String[] args) {

        Collection books = new HashSet();

        books.add("Java基础");

        books.add("J2EE基础");

        books.add("J2EE高级");

        System.out.println(books);//Collection的实现类重写了toString()方法

        Iterator it = books.iterator();

        while (it.hasNext()) {

            String book = (String)it.next();

            System.out.println("book:"+book);

            if ("J2EE基础".equals(book)) {

                //it.remove();//remove方法删除上一次next方法返回的元素

                books.remove(book);

                // 在Iterator 迭代books时,另一个线程去修改books元素,则会引发java.util.ConcurrentModificationException

                // 异常,而同样的如果要删除的是最后一个对象,就不会发生异常.

            }

        }

        System.out.println(books);

    }

}

1. 类和对象

     类可以认为是自定义的数据类型,.类用于描述某一类对象的共同特征,对象是类的具体存在.

java中的对象及其属性数据是存放在堆(heap)内存中的,而引用变量则是存放在栈内存中的.

    Person p = new Person();

    系统会生成两个实体,一个是引用变量p,一个是Person对象.栈内存中的引用变量p指向堆内存中的Person对象,变量p只是存储了一个地址值,本身不包含任何实际数据.堆内存中的数据不允许直接访问,只能通过该对象的引用去访问该对象.

    Person p1 = p;

    将p变量赋给p1,也就是将p变量保存的地址值赋给p1.这样p1也指向了堆内存中的同一个对象,这样不管是通过p还是p1访问对象的属性和方法,结果都是访问同一个对象的属性和方法,返回的结果都是一样的.也就是说堆内存中的对象可以有多个引用.

    p = null;

    当堆内存中的某个对象没有引用执行它时,程序将无法再访问到这个对象,这个对象也就是无用的了,垃圾回收机制将回收这个对象,释放该对象所占用的内存空间.因此,如果需要垃圾回收机制回收某个对象,只要切断该对象的所有引用即可,也就是将相关的引用赋为null.

内存示意图:

2. 面向对象的特征

    1. 封装

     对象的状态信息隐藏在对象内部,不允许外部程序直接访问对象内部信息,而是通过该类所提供的方法来实现对内部信息的操作和访问.类似客观世界中的属性都是隐藏在对象内部的,外部无法直接操作和修改.良好的封装是通过对外暴露足够的方法来操作和访问类的内部信息.

　　访问控制级别从private到public逐次变大

    2. 继承

       1. java不支持多重继承,每个子类只有一个直接父类

       2. Object类是一切类的父类

       3. 子类继承不能继承父类的私有的成员变量和成员方法.

           在抽象类中定义了私有的成员方法或变量,子类不能访问到父类的私有成员,所以子类中重写父类的私有方法,实际上是新建了一个方法;在接口定义中的成员是不能为私有的,否则编译会报错,因为接口是用来公开的,私有的变量和方法不能被继承或实现.

       4. 覆盖和被覆盖的方法必须同是实例方法或同时类方法

       5. 子类中的变量可以覆盖父类中同名的变量,但并不是覆盖,而只是屏蔽,父类的变量并未改变

       6. 调用子类构造方法之前,系统会先调用父类的构造方法,如果有多个父类,则从上到下依次调用

       7. 内存机制中,父类和子类是占用同一块内存空间的,只是子类在父类的基础上增加自己的属性和方法.

       8. 在子类中可通过super访问父类中的成员.

       9. 系统创建某个类的对象时,系统总会隐式地创建该类父类的对象.在子类方法中,super指向该方法调用者的子类对象的父类对象.

代码清单: 继承

abstract class A {    

      int i=1;    

      public void printI() {    

        System.out.println("i="+i);    

      }    

}    

    public class B  extends A{    

      int i=2;    

      public void printI() {

          super.printI();

      }

      public static void main(String[] args) {    

        B b=new B();    

        b.printI();    //i=1;

      }    

    }  

 3. 多态

     1. 相同类型的变量,执行同一个方法时呈现出不同的行为特征,就是多态.多态发生在编译时类型和运行时类型不一致时.

     2. 引用类型在编译阶段只能调用其编译时类型所具有的方法,运行时则执行它运行时类型所具有的方法

     3. 引用变量只能调用声明该变量的所用的类包含的方法,通过引用变量只能访问到编译时类所定义的属性.

     例如 BaseClass bsc = new SubClass()通过变量bsc只能调用BaseClass所定义的方法,而不能访问sub(),所以bsc.sub()会编译不通过.可以通过bsc访问test(),但运行时调用的是SubClass类的方法.通过bsc访问的属性book是BaseClass的属性.

class BaseClass {

    public int book = 1;

    public void base() {

        System.out.println("父类的普通方法");

    }

    public void test() {

        System.out.println("父类被覆盖的方法");

    }

}

public class SubClass extends BaseClass{

    public String book = "JAVA";

    public void test() {

        System.out.println("子类覆盖父类的方法");

    }

    public void sub() {

        System.out.println("子类的普通方法");

    }

    public static void main(String[] args) {

        System.out.println("=======BaseClass bc = new BaseClass();=======");

        BaseClass bc = new BaseClass();

        System.out.println(bc.book);

        bc.test();

        bc.base();

        System.out.println("=======SubClass sc = new SubClass();=======");

        SubClass sc = new SubClass();

        System.out.println(sc.book);

        sc.test();

        sc.base();

        System.out.println("=======BaseClass bsc = new SubClass();=======");

        BaseClass bsc = new SubClass();// 编译时类型和运行时类型不一致时,发生多态

        System.out.println(bsc.book);//打印:1,对象的属性不具有多态性,只能访问编译时类型中的属性

        bsc.test();//子类覆盖父类的方法,运行时调用的是运行时类型所定义的方法.

        bsc.base();//父类的普通方法

        //bsc.sub();// 只能访问编译时类型中所定义的方法

    }

}

1. 定义

    1. 同一个数组中只能存储一种数据类型的数据

    2. 存储的数据类型可以是基本数据类型,也可以是引用数据类型

    3. 数组也是一种类型,是一种引用数据类型.所以数组在定义的时候并未分配内存.

2. 初始化

    1. 静态初始化

        由程序员显示指定每个数组元素的初始值,由系统决定需要的数组长度

    2. 动态初始化

        由系统程序员指定数组长度,由系统按照数据类型指定数组元素初始值.

    数组的初始化过程,就是为数组的数组元素分配内存空间的过程.静态初始化和动态初始化不能同时进行,

也就是不能即指定数组长度,又为数组元素指定初始值.

    如果数组是引用类型的,每个数组元素中的数据就是引用数据类型,这时的引用数据类型是保存在堆内存中

的,而每个引用数据类型又指向另一块堆内存空间,存储有效的数据.

3. 内存中的数组

int[] arrayA = new int[3];

    如上,arrayA只是一个引用变量,和创建类时一样,引用变量放在栈内存中.只有在new时,才会在堆内存中为对象分配内存空间.当将一个数组变量a,赋给数组变量b时,即将引用变量b也执行堆内存中a变量指向的对象实例,这样两个变量a和b都指向了同一个数组对象,而第二个数组则变成了垃圾,由系统垃圾回收机制在适当的时候回收这个对象所占用的内存.

    代码清单: 数组的定义和初始化

public class ArrayTest {

    public static void main(String[] args) {

        int[] a = {1,2,3};//静态初始化

        int[] b = new int[4];//动态初始化

        System.out.println("数组a的长度:"+a.length);

        for (int i=0;i<a.length;i++) {

            System.out.println("a["+i+"]="+a[i]);

        }

        System.out.println("数组b的长度:"+b.length);

        for (int i=0;i<b.length;i++) {

            System.out.println("b["+i+"]="+b[i]);

        }

        b = a;

        System.out.println("数组b的长度:"+b.length);

    }

    /*

    result:

    数组a的长度:3

    a[0]=1

    a[1]=2

    a[2]=3

    数组b的长度:4

    b[0]=0

    b[1]=0

    b[2]=0

    b[3]=0

    数组b的长度:3

    */

}

4. 多维数组

    java中的多维数组实质上还是一维数组.比如二维数组,数组元素也是引用,而数组元素中的引用指向一维

数组.

    代码清单: 多维数组

import java.util.Arrays;

 // Arrays类中包含常用的方法,包括复制数组,排序,查找,对比,填充等功能

public class ArrayTest2 {

    public static void main(String[] args) 

    {

        int[][] a = new int[3][2];//定义一个二维数组a

        // 首先a是一个长度为3的一维数组

        for (int i = 0; i < a.length ; i++ )

        {

            System.out.println(Arrays.toString(a[i]));//每个数组元素都是一个引用一维数组的引用变量

        }

        a[0][0] = 1;

        a[0][1] = 2;

        //在这个一维数组中的元素又是一个一维数组

        System.out.println("二维数组的元素是一维数组:");

        for (int j = 0; j < 2; j++) {

            System.out.println("a[0][" + j + "]=" + a[0][j]);

        }

        System.out.println("重新赋值后的二维数组:");

        for (int i = 0; i < a.length ; i++ )

        {

            System.out.println(Arrays.toString(a[i]));

        }

        // 二维数组的遍历

        System.out.println("二维数组的遍历:");

        for (int i=0;i<3;i++) {

            for (int j=0;j<2;j++) {

                System.out.println("a["+i+"]["+j+"]="+a[i][j]);

            }

        }

    }

    /*

    [0, 0]

    [0, 0]

    [0, 0]

    二维数组的元素是一维数组:

    a[0][0]=1

    a[0][1]=2

    重新赋值后的二维数组:

    [1, 2]

    [0, 0]

    [0, 0]

    二维数组的遍历:

    a[0][0]=1

    a[0][1]=2

    a[1][0]=0

    a[1][1]=0

    a[2][0]=0

    a[2][1]=0

    */

}

1. 条件语句后的语句,如果只有一句,可以省略花括号;还可以是一个空语句,也就是只有一个分号

2. switch语句中每个case语句中应该已break结尾,否则会执行完后面的所有case

3. break和continue语句用来控制循环结构.break用来结束整个循环体,continue用来结束当前循环.在嵌套循环中,二者都可以配合标签来结束标签所标识的循环.

   程序清单: 结束标识的循环

public class BreakTest {

    public static void main(String[] args) {

        outFor://标记外部的循环

        for (int i=0;i<3;i++) {

            //内部循环

            for (int j=0;j<3;j++) {

                System.out.println("i="+i+",j="+j);

                if (j==1) {

                    break outFor; //跳出外部循环

                    /* result:

                    i=0,j=0

                    i=0,j=1

                    */

                    //continue outFor;

                    /* result:

                    i=0,j=0

                    i=0,j=1

                    i=1,j=0

                    i=1,j=1

                    i=2,j=0

                    i=2,j=1

                    */

                }

            }

        }

    }

}

1. 比较运算符 “==”

    如果进行比较的两个操作数是数值型的,则是比较两个操作数的值,只有二者的值相等,就返回true.

    如果进行比较的是引用类型,则当二者都执行相同的实例时,才返回true.

    程序清单：String类型的比较

public class StringTest {

    public static void main(String[] args) {

        String str1 = new String("123");

        String str2 = new String("123");

        System.out.println(str1 == str2);//这里返回false

        System.out.println(str1.equals(str2));//true

        String str3 = "123";

        String str4 = "123";

        System.out.println(str3 == str4);//这里返回true

        System.out.println(str3.equals(str4));//true

    }

}

　　如代码所示，两个new得到的String对象虽然值相等,str1.equals(str2)返回true,但由于两个分别是不

同的对象实例对象,在堆内存中占有不同的内存空间,所以str1 == str2返回false.当执行str3 = "123"时,系

统会先从缓存中检查是否有一个内容为"123"的实例存在,如果没有则会在缓存中创建一个String对象"123",

执行str4 = “123”时,缓存中已经有了相同内容的对象,系统则不再生成对象,直接将str4指向那个对象.所

以str3 == str4会返回true.

     同样的系统会把一些创建成本大,需要频繁使用的对象进行缓存,从而提高程序的运行性能.再比如

Integer类.

     程序清单,Integer的比较

public class IntegerTest {

    public static void main(String[] args) {

        Integer ia = 1;

        Integer ib = 1;

        System.out.println(ia == ib); //true

        Integer ic = 128;

        Integer id = 128;

        System.out.println(ic == id); //false

    }

}

　　系统会将int整数自动装箱成Integer实例,新建实例时,系统会先创建一个长度为256的Integer数组,

其中存放-128到127的Integer实例,当再需要一个在这个范围中的Integer对象时,系统会直接将引用变量

指向相应的实例对象,ia和ib都指向相同的Integer对象所以上面的ia == ib 返回true;而当需要创建的

Integer对象不在这个范围中时,系统则会新创建对象,实际上ic和id是两个不同的对象,则ic == id 返回false.

2. 逻辑运算符

　程序清单：|| 和 | 的区别

public class LogicTest {

    public static void main(String[] args) {

        int a = 1;

        int b = 2;

        if (a == 1 || b++ == 3) {

            System.out.println("a="+a+",b="+b);//a=1,b=2

        }

        if (a == 1 | b++ ==3) {

            System.out.println("a="+a+",b="+b);//a=1,b=3

        }

    }

}

　　"||" 当前面的结果为true时,不会在计算后面的结果,会直接返回true;"|"总是会计算前后两个表达式.

• 一. 结构化开发方法:

1.主张按照功能来分析系统需求,也称为面向功能程序设计

2.结构化程序设计首先采用结构化分析方法(Structrued Analysis SA)对系统进行需求分析,然后使用结构化设计(Structrued Design SD)方法对系统进行概要设计,详细设计,最后采用结构化编程(Structrued Program SP)的方式来实现系统

3.最小程序单元是"函数",每个函数完成一个功能.

• 二. 面向对象开发方法:

     1.从现实世界中的客观存在事物出发来构造软件系统,并在系统构造中尽可能地运用人类的自然思维方式,强调以现实世界中的客观存在为中心,来思考问题,认识问题,并根据事物的本质特点,将它们抽象为系统中的类,作为系统的基本构造单元.

     2.使用类,对象,继承,封装,消息等基本概念来进行程序设计.

     3.区别于"基于对象".基于对象也使用了对象,但无法利用现有的对象去产生新的对象,也就是说不能继承.比如javascript

     4.面向对象的三个基本特征:   

         封装:

       将对象的实现细节隐藏起来,在通过公用的方法来暴露该对象的功能.java提供private,protected和public三个访问控制修饰符实现良好的封装

         继承:

       提供了extends来让子类继承父类.继承是实线软件复用的重要手段.

         多态:

       使用继承关系来实现复用时,子类对象可以直接赋给父类变量.

    5.java中的类主要有两种结构关系:

       a 一般-特殊:继承关系,如人-男人,是一种"is a"的关系

       b 整体-部分:组合关系,如人-胳膊,是一种"has a"的关系

    整型有三张表示方式:

• 10进制 :int i = 10;
• 8进制   :int i = 013;
• 16进制 :int i = 0xaF;

2. 字符型

    字符型有四种表示方式:

• 单个字符     : char c = ‘a’;
• 转义字符     : char c = ‘\n’;
• unicode编码: char c = ‘\u9999’;
• int            : char c = 97;

3. 浮点型

     浮点型有两种表示方式:

• 10进制数    : 5.123
• 科学计数法  : 5.123E2

public class FloatTest {

    public static void main(String[] args) 

    {

        //浮点型数据必须包含小数点,否则会当作int处理

        //浮点型默认是double型的,默认是64位的,所以定义float类型是,必须在最后加f表示float型

        float f = 5.0f;

        float af = 5.123456789f;

        double df = 5.12345678987654321;

        //浮点数是使用二进制数据的科学计数法表示,所以不可能精确表示一个浮点数.下面将看到的值已经发生了改变

        System.out.println("af="+af);

        System.out.println("df="+df);

        //result:af=5.123457,df=5.123456789876543

        double a = 0.0;

        double c = Double.NEGATIVE_INFINITY;

        float d = Float.NEGATIVE_INFINITY;

        //看到float和double的负无穷大的是相等的。

        System.out.println(c == d);

        //0.0除以0.0将出现非数

        System.out.println(a / a);

        //两个非数之间是不相等的

        System.out.println(a / a == Float.NaN);

        //所有正无穷大都是相等的

        System.out.println(6.0 / 0 == 555.0/0);

        //负数除以0.0得到负无穷大

        System.out.println(-8 / a);

        System.out.println(0.0 / 0.0);

        //result:NaN

        //下面代码将抛出除以0的异常

        System.out.println(0 / 0);

    }

}

4. 布尔型

    只能是"true"或"false",不能和其他基本数据类型相转换

5. 类型转换

   a. 自动类型转换

数据范围小的变量或数值可以直接赋给数据范围大的变量或数值,系统可以自动转换

   b. 强制类型转换

        类似将一个大瓶子的水倒入一个小瓶子中,如果大瓶子中的水过多,将可能导致溢出.

     代码清单:强制类型转换

public class Conversion {

    /**

     * @param args

     */

    public static void main(String[] args) {

        /*

         * int是32位的,例如233:

         *     0000 0000 0000 0000 0000 0000 1110 1001

         * 将int赋给byte,byte是8位的,所以会将前面的24截取掉,变成了

         *                                1110 1001

         *  整数在计算机中是以补码的形式保存的,正数的补码和原码相同,负数的补码是原码取反加1,最高位不变.所以

         *  11101001                               

         *     | 减1,成反码

         *  11101000

         *     | 取反成原码

         *  10010111 也就是-23

        */

        int intValue = 233;

        byte byteValue = (byte)intValue;

        System.out.println(byteValue);

        double doubleValue = 3.98;

        int intValue1 = (int)doubleValue;

        System.out.println(intValue1);

    }

}

       1. java中方法不能单独存在,所有方法必须定义在类中.

       2. 从逻辑上说,一个方法要么属于一个对象,要么属于一个类(使用static修改的方法)

       3. 永远不可能独立执行方法,执行方法必须使用类或对象作为调用者.包括隐式的this对象

1. 常用的修饰符:

    static 可用于修饰方法,属性等成员.修饰成员表示这个成员是属于这个类所共有的,而不是属于这个类的某一个实例.不使用static的成员则表示,这些成员是属于该类的某一个实例,而不是属于这个类.静态成员不能访问非静态成员.

2. 方法的参数传递机制

       java方法的参数传递机制:值传递.所谓值传递,就是将实际参数的副本传入方法内,而参数本身不受任何影响.

       基本数据类型和引用类型都是采用值传递的方式进行.但如果传递的是引用类型,虽然传入方法内的是引用类型变量的一个副本,但两个引用类型变量都是指向了同一个堆内存中的对象,通过任何一个引用变量对对象进行操作,都会对这个对象产生影响.

public class Test { 

//基本数据类型的值传递
private static void swap(int a ,int b) {
  int tmp = a;
  a = b;
  b = tmp;
  System.out.println("swap()方法中:a="+a+",b="+b);
}
// 引用类型的值传递
private static void swap2(Obj o) {
  int tmp = o.a;
  o.a = o.b;
  o.b = tmp;
  System.out.println("swap2()方法中:a="+o.a+",b="+o.b);
}
public static void main(String[] args) {
  int a = 10;
  int b = 20;
  swap(a,b);
  System.out.println("swap()方法外:a="+a+",b="+b);
  Obj o = new Obj();
  swap2(o);
  System.out.println("swap2()方法中:a="+o.a+",b="+o.b);
}
} 

3. 形参长度可变的方法

   长度可变的形参只能位于形参队列的最后,一个方法中只能出现一个长度可变的形参.这个长度可变的形参可以传入多个参数,也可以传入一个数组

public class Test3 { 

public String test(String... Strs) {
  String result = "";
  for (String tmp : Strs) {
   result += tmp;
  }
  return result;
}
public static void main(String[] args) {
  Test3 t = new Test3();
  System.out.println(t.test("Hello","!","world"));//可以传入多个String
  String[] tmp = {"Hello","!","world"};
  System.out.println(t.test(tmp));//也可以传入一个String数组
} 

} 

4. 方法重载

   1. 出现在同一个类中

   2. 方法名相同,方法的形参列表不同

   3. 方法的其他属性如返回值类型,修饰符等与方法重载无关

5. 方法重写

    1. 出现在继承中,子类和父类同名的方法之间

    2. 方法名,方法形参列表相同;返回值类型,子类比父类更小或相等;抛出的异常,子类比父类更小或相等;访问权限,子类比父类更大或相等;二者必须同时为实例方法,或同时为类方法

    3. 私有的父类方法,是不能被重写的

6. 构造器

   1. 每个java类都至少有一个构造器,如果没有显式的提供,系统会提供一个无参数的执行体为空的构造器

   2. 构造器可以重载,每个不同的构造器之间可使用this相互调用,且只能在第一行调用

    1. java语言是编译型还是解释型?

    编译型语言指使用特定的编译器,针对特定的平台(操作系统)将源代码一次性翻译成可被该平台硬件执行的机器码(包括机器指令和操作数),并包装成该平台所能识别的可执行的程序.这个过程称为编译(Compile).编译生成的可执行的程序可以脱离开发环境,在特定的平台上运行.解释型语言指使用专门的解释器对源代码逐行解释成特定平台的机器码,并立即执行.解释型语言相当于将编译型语言中的编译和解释工作混合在一起同时进行.

    解释型语言每执行一次源代码就需要重新编译一次,因此执行效率比较低,但解释型语言跨平台确比较容易,只需要提供特定平台的解释器,该解释器就会负责将源代码解释成特定平台上的机器指令.而编译型语言的运行效率较高,但移植比较麻烦.如果需要移植,则需要将源代码复制到新的平台上,针对该平台进行修改并重新编译.

    java语言既是编译型语言也是解释型语言.

       java语言在编译的时候不是生成特定平台相关的机器码,而是生成与平台无关的字节码,只面向JVM(Java Virtual Machine).

       这种字节码必须由JVM解释执行.

    2. 关于JVM

    JVM可以看做是一个抽象的计算机,和实际的计算机一样,也具有指令集和存储区域.它负责执行指令,还要负责管理数据,内存和寄存器.不同平台上的JVM是不同的,但是它们都提供相同的编程接口.所以JVM是java语言可以跨平台的关键部分,只要不同的平台实现不同的JVM,编译后的class文件就可以在该平台上运行.

2. 关于Java的部分概念

    1. JDK=Java SE Development Kit,java标准版开发包,包括java编译器,运行时环境(JRE)以及常用的java类库等

    2. JRE=Java Runtime Environment.java运行时环境.包含JVM以外,还有其他类的加载器,字节码校验器以及大量的基础类库.

    3. Java EE SDK . 包括JDK.学习java EE的软件和开发包(Software Development Kit)

3. java的环境配置

   1. 在windows下用户变量和系统变量的区别?

   系统变量对所有用户有效,用户变量只对当前用户有效.对于当前用户而言,两者没有区别,只是系统变量中的配置会优先于用户变量中的配置.

   2. classPath需要配置吗?

   JDK1.4以前的版本需要手动的设置classPath变量,让JRE去搜索java类文件.需要配置当前路径(.)及%JAVA_HOME%\lib\dt.jar和%JAVA_HOME%\lib\tools.jar.但在JDK1.5中可以不配置classPath变量,JRE可以自动搜索当前路径下的类文件和自动加载dt.jar和tools.jar,同时如果配置了classPath变量,则JRE会严格按照变量的路径去搜索类文件.也就是说如果要配置classPath路径就一定要配置准确,否则还是要报错的.

   3. classPath变量中的路径尽量不要出现空格,否则可以引发错误

4. java的垃圾回收机制(Garbage Collection GC)

    1. java语言不需要程序员直接控制内存回收.垃圾回收的发生有不可预知性,不建议使用finalize()和System.gc()来建议系统进行垃圾回收,因为这样做不不能精准的控制垃圾回收机制.可以通过暗示使垃圾回收机制可以尽快的回收那些不再使用的对象.也就是将该对象的引用变量设置为null.

    2. java程序的内存分配和回收都是由JRE在后台进行维护.通常JRE会提供一个超级线程来进行检测和控制,一般是在CPU空闲或内存不足的情况下自动进行的,程序员无法精确控制垃圾回收的时间和顺序.

    3. java运行时的数据存放在堆内存,垃圾回收机制就是负责这部分内存中的资源.它并不能回收其他如磁盘IO等物理资源.

    4. 垃圾回收机制的缺点是它的开销会影响程序的性能.JVM所做的就是监控程序中所有的对象,确认哪些是无用的对象,并最终释放这些无用的对象.而且java的垃圾回收机制还不是很完备,它并不能保证可以100%地收集所有废弃的内存.

    5. 垃圾回收的精确性主要包括2个方面:

       a. 垃圾回收机制可以精确地标记活着的对象.Java中的对象具有唯一性.

       b. 垃圾回收机制可以精确地定位对象之间的引用关系.这是实现归并和复制等算法的必要条件,通过这种引用关系,可以保证所有相关的对象都能被可靠的回收及重新分配,从而有效地减少内存碎片的产生

    6. 现在的JVM有多种不同的垃圾回收机制,每种机制会因其算法差异而表现各异.有的当垃圾回收开始时就停止应用程序的运行,有的当垃圾回收运行时,同时允许应用程序运行,还有的同一时间垃圾回收有多个线程在运行.