java知识点大全（转）

第一章

1．float f4[] = new float[] { 1.0f. 2.0f. 3.0f}，这样写数组定义是错误的，因为数组元素隔离应该用“逗号”而不是“点”。

2．一个对象被释放（没在被任何对象引用）后，垃圾收集器并不会立刻回收它，而是等到运行该段代码的示例下次被被垃圾收集器扫描的时候才回收该对象的。

3．如果你用==去比较两个字符串对象，你实际上是在比较两个字符串是否是引用同一个对象，而不是比较他们的内容是否相等；比较内容是否相等使用equal方法是最简单的。

4．jAVA平 台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变 的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以 使用StringBuffers来动态构造字符数据。

5．方法的重 写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载 Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方 法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。换句话说：方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。

6．请特别注意， finally 块区域中的代码虽然在 return 语句之前被执行，但是 finally 块区域中的代码是不能够通过重新赋值的方式来改变 return 语句的返回值。

7．catch(X x) can catch subclasses of X.“catch语句能够捕捉子类异常”是正确的。

8．Assertion expressions should not contain side effects.断言表达式不能包含边界效应。

9．若Switch语句中没有使用break或continue语句则满足某个条件后的其他语句也同样会执行。

10．Switch中的表达式必须是和int相容的表达式（如float类型就是错误的。）

11．如果两个对象互相引用，则当他们形成隔离区使则可以被垃圾回收器回收！！！。

12．如果一个for循环中存在一个switch语句，则在该switch语句中的break语句只退出当前switch。

13．默认的构造函数调用父类的无参数构造函数。

14．注意考试陷阱“0”和“O”的区别。如return 0是错误的return o才是正确的。

15．If语句中只能使用布尔表达式，不能向switch语句一样使用整型值。

16．方法重写发生在类继承时，子类可以重写一个父类中已有的方法，必须在返回类型和参数列表一样时才能说是重写，否则就是重载，java中方法重写的一个重要 而且容易被忽略的规则是重写的方法的访问权限不能比被重写的方法的访问权限低！重写的另一个规则是重写的方法不能比被重写的方法抛弃(throws)更多 种类的异常，其抛弃的异常只能少，或者是其子类，不能以抛弃异常的个数来判断种类，而应该是异常类层次结果上的种类。

17．线程的执行是从方法“run( )”开始的，该方法是由系统调用的。程序员手工调用方法start()，使线程变为可运行状态。

18．静态方法不能直接访问非静态成员

19．native关键字指明是对本地方法的调用，在JAVA中是只能访问但不能写的方法，它的位置在访问权限修饰语的后面及返回值的前面。

20．main()方法的参数是字符串数组，参数名可以任意定义。

21．方法覆盖时，子类方法的访问权限不能小于父类方法的访问权限。

22．用“==”进行比较时，符号两边的数据类型必须一致（可相互转换的基本类型除外），否则编译出错。

23．构造函数没有方法，他们没有返回值且不可被继承。

24．FlowLayout的特性是其中的控件大小不随着容器尺寸的变化而变化，但控件的相对位置会有所改变。

25．Java中的标识符是以字符开头，字符包括字母、下划线“_”、美圆符“$”。不能以数字开头，也不能是Java关键字。

26．整型变量默认初始化值为0。

27．自动变量（没有public、private等修饰符的变量）不能被static修饰。

28．int a[][] = new int[][]定义数组是不对的而这样定义数组int []a[] = new int[10][10]是对的。

29．JAVA语言的任何关键字都没有大写（打头）字母。

30．访问修饰符

private：方法或变量只能在该类内部才能被访问

    protected：方法或变量只能在同一个包里面的类或该类的子类才能访问

    public：方法或变量其他任何类都可以访问

31．native：标识一个变量是使用平台不独立的语言编写的。

32．throw：扔出的是异常对象，在方法中使用；throw：扔出的是异常类，在方法定义时使用。

33．byte：8位有符号值（-27～+27-1）

    char：16位无符号值（0～216-1）

    short：16位有符号值（-215～+215-1）

    int：32位有符号值（-231～+231-1）

    float：32位有符号值（-231～+231-1）

    long：64位有符号值（-263～+263-1）

    double：64位有符号值

   

   

   

34．const和goto是JAVA中不用的两个保留字。其中public const用static final代替其功能

35．根据JAVA语言规范，null, true, and false只是（文字的）常量，不是关键字

36．JAVA语言全部关键字列表

    

37．JAVA语言对十六进制中的字母不区分大小写即大小写表示的值是一样的。

38．float f = 23.9067985表达式是错误的，因为floating-pointer（浮点值）默认数值是double类型，把他赋给一个float类型的变量会出现编译错误；以下两种形式是对的：float f = 23.9067985F或double f = 23.9067985

39．boolean类型变量的值只能是true和false；同理if语句的条件表达式也必须是boolean类型。

40．可以赋给char类型变量一个整型值，如一下语句是合法的：

    char c = (char) 70000; // The cast is required;

char d = (char) -98; // Ridiculous, but legal

备注：0～65535范围内的值可以直接赋，这个范围以外的值需要使用char()来转换后在赋值。

41．这样的数组声明也是对的如：String[] ManagerName [];另外在数组声明语句中绝对不能 

     出现数组长度的定义。整型数组默认元素值是0。new语句中一定要给出数组的长度！如下定义是错误的：int []Test = new int[];对于多维数组，则在new语句中最少要给出第一个长度参数值，如int[][] ratings = new int[3][]是对的，int[][] ratings = new int[][]和int[][] ratings = new int[][3]就是错误的。

42．new语句执行以后，只是生成了一个该类型的（类）变量，并不存在该类型的实际实例。

43．访问数组元素时若元素标号超出了数组元素界限，则只会出现运行异常，不会出现编译异常，如int [] TestArray = new int[5],若代码中出现TestArray[5]则编译不会出错，直到程序运行到还行时才会出现运行错误。

44．直接调用数组的length属性就可显示数组的长度（即数组拥有多少个元素）；

45．数组赋值执行默认的转化规则，如int[] Test = new int[15]，Test[0] = ‘b’是对的；同理，只要具体是值是数组定义变量类型的（同一类）或其子类，都可以成功赋值。

46．如果一个数组被声明为接口类型，则数组元素可以引用任何该接口的类的实例。

47．子类的数组变量可以直接赋（值）给父类的数组变量如：

Car[] cars;

Honda[] cuteCars = new Honda[5];

cars = cuteCars; // OK because Honda is a type of Car

48．维度不同的数组变量之间（即使符合IS-A标准）不能互相赋值。

49．变量没有被初始化就使用会出现编译错误（编译不通过）如：

    string strTemp;

    system.out.println(strTemp.toLowerCase);

    编译时会报变量没有初始化的编译错误；但是若该变量是类成员变量的话，即使没有在构造函数中显示初始化它，系统也会自动给它一个默认的null值。这时候编译会通过，只是在使用该变量的时候才会报错。

50．数组定义（用new方法构造该数组）时，（数组元素）默认初始化为数组类型的默认值。

51．在方法或方法参数列表中定义的变量叫本地变量（Local variable），注意：本地变量在使用之前一定要手动赋值（因为它不会象成员变量那样被构造函数自动初始化），否则编译不会通过，即使是在判断语句中也不能使用未被手动赋值的本地变量。【编者按：实例（引用）变量经常会被初始化为null。】

52．即使在判断分支中只有一个分支使用了为手动初始化的本地变量，而且该分支也不可能会执行，系统编译时仍然会报错。

53．主函数public static void mani（string[] args）{}中的参数数组名不一定非得取名“args”

54．当一个对象数组被初始化后，在数组中的对象不会自动被初始化，但是所有的引用都会得到默认值null。JAVA语言中boolean变量的默认值是false。

55．JAVA语言中的所有数字都是带符号的（signed不是JAVA语言的关键字）。

【第二章】

1． 每个JAVA源文件中只能存在一个public类；

2． 文件名称必须和public类名相同；

3． package语句必须放在源文件（代码）的第一行；

4． 导入语句（import）必须放在package语句和类声明语句之间；

5． 修饰符号分为两大类：访问修饰符（public、protected、private）

非访问修饰符（strictfp、final、abstract)

6． JAVA中一共有四个访问控制级别：

默认访问又叫package访问级别(package，default access)：

没有任何访问修饰符限制，范围是当前package（即

当前类能够被处在同一个package中的其他任意类访问）

注意：如果在一个package中定义了一个默认访问类，即使另一个package引用了该package，也同样不能访问该

package中的默认访问类。而protected访问修饰符和default唯一的区别就是支持(跨越)不同的package。

但是：对于父类中的protected的方法这并不意味着子类能够象对待public的父类方法一样(操作)。如果package外的一个子类得到了一个对父类的引用，子类不能使用“．”操作符访问父类的protected属性(方法)。总之一句话：package外的子类不能使用父类的引用（父类类型的变量）访问父类的protected成员，要访问父类中protected成员的唯一方法就是通过继承（inheritance）即是在声明子类的定义中访问它，切记！

另外：被子类继承的成员一旦被继承，对子类而言被继承的成员都是private成员。默认成员只对同一package中的子类可见。

public访问级别(public access)：

                  任何package中的任何类都可以访问该类（当然如果两

个类不在同一个package中的话在一个pakcage中必须声

明引用另一个package）；

备注：类只能使用public或默认访问限制（即没有任何访问修饰符）

成员属性和成员方法则可以使用public、protected、default、private四种访问

级别。

7． 我们说一个类A能访问另一个类B，包含以下三个意思（情况）：

<1>在类A（的代码中）能够创建类B的实例；

<2>类A能够扩展类B即能够成为类B的子类；

<3>在类A（的代码中）能够类B中的属性和方法；

8． 关键字strictfp只能用来修饰类和方法，不能用来修饰变量。声明一个类为strictfp意思说该类中的任何方法都会遵守浮点（运算）的IEEE754标准。如果没有说明，则方法中用到的浮点（运算）可能是平台不独立。

9． 抽象类（abstract）的方法前也可以用abstract关键字修饰，但是一定要注意用该关键字修饰的方法（函数）是以“（）；”结尾而不是以“{}”结尾的！另外，只要类中有一个方法是abstract类型的，则整个类都必须声明为abstract型的。然而如果在抽象类中存在非抽象的方法则是合法（允许）的。备注：子类必须实现抽象父类的所有抽象方法，除非该子类也是一个抽象类。

    public abstract class A {

abstract void foo();

}

class B extends A {

void foo(int I) {

}

}

    这段代码是错误的，因为虽然子类实现了一个方法foo，但是该方法只是对父类方法的重载（overload）不是重叠（override），因为两个方法的参数不同，故编译会出错。备注：抽象方法不能是final或private类型，因为抽象方便必须被子类继承。

10．实例变量（instance variable）就是指类成员变量（member），能够使用public、protected、和private修饰符。同时也能使用transient、final、abstract、strictftp、native修饰符。

    切记：对于final类型的实例变量，必须在声明的时候就手工给它赋，因为构造函数不会给他自动赋值，不然编译会出错，另外记住：transient只用在实例变量上，同理volatile也是一样。

   本地变量（local variable）是指在方法内声明的变量，只能用final修饰符来修饰。

   本地变量经常在栈（stack）里面而不是在堆（heap）里面。如果本地变量是对一个对象的引用，那么对象本身仍然是在堆（heap）里面的。另外，本地变量可以是对一个对象的引用，但是如果这个（引用对象的）本地变量被修饰符final修饰后，你只可以使用该变量修改它引用的对象，而却不能修改该变量的（引用）值以让他引用另外的对象。

    没有final对象（object），只有final引用（reference）。本地变量没有默认值，只能手工赋值。

    切记：在接口（interface）中声明的变量默认都是（public static）final的。

  

11．类访问关系表

 

12．只有一个修饰符能应用在本地变量（local variable）上，那就是final。方法内的参数就等同于本地变量，因此在方法的参数列表中的参数前也可以使用修饰符final。

13．abstract除了不能同时和private及final一起使用以外，同理也不能和synchronized、strictfp、native一起使用，因为后面三个都是描述具体实现的修饰符。另外，它还不能和static一起使用。

14．Synchronized修饰符只能应用于方法（method）上而不能应用到变量（variable）上，它表示同时只能有一个线程（thread）访问该方法。

    Native修饰符和Synchronized一样只能应用到方法上，表示该方法是用平台独立的语言实现的（非跨平台）。

    Strictfp修饰符号能同时应用到类和方法上。

15．静态（static）方法内不能访问任何非静态变量。备注：main（）函数本身就是一个静态方法，若main（）方法没有定义成static类型，则编译时不会促错，只是在运行时才提示出错的。再重复一次：在静态（static）方法中不能访问非静态变量（static variable）。是类在调用静态main（）方法，而不是类的实例。但有一点：JAVA却允许使用一个对象引用变量去访问类的静态成员（member）。另外还要记住比较好理解的一点：静态方法不能被重叠（override），但可以被（子类）重定义（redefine）。

    接口和类不能被声明为static或protected!!同理，transicient只能用于变量声明。

同理，synchronized只能使用于方法声明。

16．一个源代码文件中只能有一行package语句；

17．JVM解析（编译）的顺序是：明文引入（explicit import）类，当前package中的类，最后才是默认引入（implicit import）类

18．一个抽象类（abstract class）中可以分别定义抽象（abstract）和非抽象（nonabstract）两种类型的方法；而接口（interface）中只能定义抽象的方法（换句话说接口就是一个100％抽象类）。在实现（接口）的类中，所有接口中的方法都必须被实现并且要被定义为public。另外：（concrete subclass）子类必须实现抽象父类中定义的所有方法。

   一个抽象类不需要实现它的父（抽象）类的任何方法。

19．一个接口（interface）应满足如下条件：

   <1>接口中的所有方法都默认都是public&abstract的（不需要明确的修饰符修饰）；

   <2>接口中的方法不能是static类型的；

   <3>接口中的所有变量都必须是public、static、final类型的（换句话说就是常量）；

   <4>（一个）接口只能扩展一个或多个接口（不能扩展其他）；就口不能实现其他接口或类；   

20．实现了一个接口的类应该满足的条件：

   <1>在类中要实现接口中定义的所有方法；

   <2>符合所有的重叠（orveride）规则；

   <3>（声明没有检查的异常）这条拿不太准确；

   <4>保持接口方法中的所有参数（列表）和返回类型；

   <5>备注：一个类可以实现多个接口（接口之间用“，”分开）；

21．Final reference变量必须在构造函数（完成）执行之前被初始化；

22．不正确的maini（）方法的定义或缺少main()方法则会引起运行时错误（runtime error），不会引起编译错误；

23．在实现接口的类中不能声明比它所实现的接口中定义的更宽的异常类。．

24．Private访问修饰符限制对同一个类的成员的访问！

25．非嵌套类（nonnested）不能被声明为protected。

26．在一个实现接口的类中，所有实现的接口中的方法都必须是public类型的。

【第三章】

1．整数默认是int类型（23位），但如下赋值却是正确的：byte b = 26;因为编译器会自动转换(切记：若是byte b = 129则会编译出错，因为数值大于了字节型变量的上限)；但是两个字节型(byte)的变量相加就会得到一个整型（int），而不是一个字节型的。如a、b、c都是字节变量，则a=b+c;会编译不通过；

2．Button b = new Button();该行代码作了三件事

   <1>在堆（heap）中创建一个引用Button类对象的引用变量；

   <2>在堆（heap）中创建一个新的Button类对象；

   <3>把新创建的Button对象（地址）赋给对象引用变量b;

4．父类类型的（对象）引用变量能引用子类类型的对象，反之则不行；

5．对于非字符类的引用类型的变量，互相赋值后引用的是同一个（实体）对象，而对于字符类引用类型的变量，则互相赋值后引用的却不是同一个（实体）对象。

6．boolean b = 100 > 99;这种赋值语句(格式)是正确的；

7．“>”、“>=”、“<”、“<=”同样能应用与字符（character）类型的数值比较；

8．如果一个对象的任一父类实现了某个接口（interface），则该对象instance of这个接口时其结果都将是true；

9．数组也是对象，即使是整型数组。Instance of object判断结果同样会是真。

  

10．可比较的数据类型只有：数值型、布尔型、字符型和对象引用变量（类型）；

11．整型数值和浮点数值是可以比较的，如5.0 == 5L结果返回true。

12．If判断语句中的判断条件只能是布尔型，但唯一一个可以列外的情况就是布尔变量的赋值语句可以出现在判断条件中如：boolean b；if (b=true){}是合法的，然而if(x=0)

    却是不合法的；

13．无论是整数除以0求余（%）还是浮点数除以0求余（%）编译时都不会报错，但是注意：浮点数除以0求余（%）运行时也不会出错（输出结果为无穷大）；整数除以0求余（%）则运行时会报错，若是整数直接除以0（/0）则编译时间就不会通过；

14．整数（数字）和字符串相加（＋）得到的仍是字符串，整数和整数相加得到的仍是整数。

15．final变量不能被“++”或“--”修饰；

16．移位操作符只能用在整型数值上，浮点型数值不能被执行移位操作。无符号右移操作符

   “>>>”得到的结果永远是正值。

17．当用cast去格式化一个输出值的时候，即使被格式化的数字大于了变量的容量范围，系统编译和运行都不会出错；如byte bTest = (byte)130,运行和编译都不会出错；

18．逻辑或（&&）和逻辑与（||）两边的表达式都必须是布尔型(boolean)；

19．位或（&）和位与（|）两边的表达式则可以是布尔型(boolean)或整型数值；备注：位或（&）的优先级大于和位与（|）的优先级；

20．对象（类型的变量）被传递时是拷贝一个对象的引用值，而原始类型（变量）被传递时间则是直接拷贝一个变量本身的值；

21．浮点型（float-point）类型的（32位）数值值默认是double类型（64位）的；

22．Instanceof操作符只能应用于对象类型（操作）；

23．If语句中的判断条件必须是boolean类型的，不能使用等号（＝），但是对于boolean类型的变量有一种情况可以例外，例如if (boolVariable = true){}; 同理，switch语句中的判断对象只能是整型的（int，当然也包括会自动转换成int的char、byte、shortint）变量；特别注意：case语句中参数要求同switch语句，另外再加一条，参数中若是变量，则该变量必须是final类型的！！不能两个case语句用同一个标签；如下的例子也是错误的：switch（byteVariable）{case 129:}129超过了byte界限。

24．Switch语句中default：判断并不一定非得要放在最后，也可以放在其他case语句之

    但需要注意的是若default语句执行的话，default后面的判断（若是没有break语句的话）也同样会全部都执行；

25．注意：do{} while(判断条件)；最后的分号一定不能少！！

26．continue语句必须在一个loop（循环）语句中，否则会编译出错；然而break语句则可以同时出现在loop（循环）语句和switch语句中；

27．带标号的continue和break语句必须出现在有同样标号的loop（循环）语句中，否则

    编译会出错；

28．catch语句必须紧跟在try语句之后；catch语句之间不能存在任何其他语句；try…catch

    语句中可以不存在catch语句但是若没有catch语句则必须存在finally语句；

29．类“Exception”继承类“Throwable”；Errors不是Exception，因为他不是继承Exception得来的；

31．切记：在catch语句中子类异常一定要写在父类异常之前，否则编译不通过；

32．一个方法能声明的异常一定要被声明，除非该异常是RuntimeException子类；就是说RuntimeException类的子异常类可以不用声明；规则：每个方法要么是处理所有检测到的异常，要么通过thrown语句声明所有检测到但没有处理的异常，否则将编译出错；

33． 因为Error不是Exception的子集，所以在要扔出Error的方法中不需要声明该Error；

34．自定义的异常（继承Exception异常类）都是checked异常，意思是他在被扔出之前必须先被定义；

35．Assertion语句的第一个表达式（Expression）的值必须是布尔型（boolean）；整个Assertion语句的值必须是true，否则就会得到AssertionError;   

37．在Version1.4中Assertion语句默认是关闭的（Disable）；

38．

39．注意：不要在public方法中使用assertion语句校验参数输入（的正确性）；但是在private方法中使用是合法（正确）的；不要用assertion去校验命令行参数；不要在产生边界效应的地方使用assertion；

40．Error类（或其子类）或Exception类都是unchecked类（不用声明或处理）；

41．Boolean b1；if(!b1)不是测试b1是不是“true”，而是把b1的值设定为true！！

42．“loop”不是JAVA关键字！！强烈提醒：“continue”只能用在loop（循环）结构中；

43．若在一个方法中有异常扔出，那么：也么在调用该方法的方法定义中声明扔出同类异常，也么在try语句中调用该方法；

44．如果一个方法没有处理它在try语句中声明的异常，那么在该（被扔出的异常）异常被传播到调用该方法的方法那里之前会先执行finally语句；

45．在assertion语句中，“：”后面的表达式必须是有返回值的（方法调用）；

【第五章】重载、重叠（重定义）

01．方法可以被重载和重叠，但是：构造函数只能被重载；

02．在用父类型变量引用其子类型对象时，该引用调用的方法必须是父类具有或者是父类和子类共同具有的方法，而不能调用只有子类具有的方法；

03．当子类重叠（override）父类中的方法时，其对所重叠的方法的限制（修饰符）不能大于其父类对该方法的限制；

04．子类中重叠（override）父类的方法时应满足如下几点要求：

(1.)参数列表要完全匹配；(2.)返回类型要完全匹配；

(3.)访问修饰符的限制程度一定要等于或低于父类（方法）访问修饰符的限制；

(4.)子类（方法）中不能抛出新的或比父类（方法）更宽的检测异常；

(5.)final类型的方法不能被重叠（override）；

(6.)不能被继承的方法（如private方法）是不能被重叠（override）的；

05．子类中重载（overload）父类的方法时应满足如下几点要求：

(1.)参数列表必须要改变；(2.)返回类型可以改变；

(3.)访问修饰符可以改变；

(4.)子类（方法）中可以抛出新的或比父类（方法）更宽的检测异常；

(5.)可以载同一个类之内或其子类中重载方法；

06．在调用重载函数时是重载函授参数列表中的（参数）引用类型（reference type）而不是对象类型（object type）决定调用哪一个重载函数的。

    总而言之：哪一个重叠方法被调用是在运行时由（实际的）“对象类型”决定的；哪一个重叠方法被调用时在编译时由“引用类型”决定的；

08．   

09．构造函数调用顺序：先调用子类的构造函数，再依次调用其父类的构造函数；

10．构造函数使用规则：

(1.)构造函数可以使用任何访问修饰符(private、protected、public)；

(2.)在类定义中存在和构造函数同名的方法是合法的；

(3.)只要在类定义中提供了任何带参数的构造函数，系统将自动取消不带参数的默认构造函数；

(4.)每一个构造函数必须把对重载构造函数的调用语句（this（））或对父类构造函数的调用语句（super()）作为他的第一条语句（但在同一个构造函数中不能同时出现this（）和super（））；备注：调用（类本身）自己的构造函数使用this方法（this（…）总是意味着调用同一个类中的另外一个构造函数）；

    若用户没有在构造函数中显示编写这两行语句，则系统会自动加上一条语句即：

    Super（）；

(5.)抽象类也同样具有构造函数；然而接口却没有构造函数；

(6.)构造函数不能直接通过语句（代码）调用；

(7.)构造函数一定不能有返回值，而且其名称一定要和类名完全一致！

11．构造函数不能被继承，也不能被重叠（override），因为他不是方法！！

12．在构造函数中调用的方法必须是static方法，因为非static方法（和实例对象有关）只能在构造函数运行以后才能被使用；

13．重载一个方法必须改变参数列表，只改变返回类型是不行的！！换句话说只要你改变了参数列表就算重载了该方法；

14．关于方法返回类型：

   (1.)在返回对象引用的方法中，返回类型可以是null；

(2.)数组是合法的返回类型；

(3.)在返回void类型的方法中，不能返回任何东西；

(4.)

15．接口（interface）没有构造函数，抽象类有构造函数；构造函数不能被继承也不能被重载；

16．如果一个类中存在public的实例变量，则称该类是不符合封装规范的；

17．保护访问修饰符（proteted）比默认访问修饰符（defa ult）更限制更宽松一些；

18．若在父类中只有带参数的构造函数，那么在继承父类的子类的构造函数中就必须显示的调用带参数的super（…）语句；

19．字节型（变量）是一种包装类（wrapper object）对象，不是原始数据类型；

20．Float类型的值不能赋给long类型的变量；

21．在JAVA中，每一个字符都是一个16位的unicode字符；

22．字符串对象一旦被赋值，就不允许再改变；然而引用字符串对象的字符串变量的值却是可以改变的；

23．String x = "Java";x.concat(" Rules!");System.out.println("x = " + x);输出结果仍然是”Java”，因为第二条语句只是创建了一个临时字符串对象，该字符串对象的值是”Java Rules”，但并没有把这个新的字符串对象赋值给(字符串)变量x；

24．String s = "abc"; // 创建一个字符串对象和一个字符串变量；

    String s = new String("abc"); // 创建两个字符串对象（一个是非缓冲池对象一个是缓冲池对象）和一个字符串变量；

25．（1）charAt(int index)返回字符串对象第index位置的字符（位置是从0开始计算的）；

（2）Concat（string str）把字符串str追加到调用该方法的字符串对象末尾；

（3）public Boolean equalsIgnoreCase(String s)返回调用该方法的字符串对象的值是否和字符串对象s的值相等（忽略大小写）；

（4）切记：数组有length属性，字符串有length方法；

（5）public String replace(char old, char new)用new替换调用该方法的字符串对象中的old字符；

（6）public String substring(int begin)切记：这里begin是从0开始算

public String substring(int begin, int end)切记：这里begin是从0开始算，而end却是从1开始算！！

（7）ceil（参数只能是双精度型）返回大于等于参数的最小的整型数；注意：Math.ceil(-9.8) //返回值为–9.0

（8）floor（参数只能是双精度型）返回小于等于参数的最大的双精度型数；注意：Math.floor(-8.1) // 返回值是–9.0

（9）round(float a)其结果等于floor（a+0.5f）

（10）random()随机返回一个大于或等于0且小于1的双精度数；

（11）parseXxx() 返回命名的(包装类对应的)原始类型值（带一个字符串参数）；

        XxxValue（）返回一个原始类型值（不带任何参数）；The xxxValue()它可以转换任何包装类对象的值到原始类型；

（12）valueOf()返回一个新的调用该方法的包装类对象；

double d4 = Double.parseDouble("3.14"); //转化一个字符串到原始数据类型；

System.out.println("d4 = " + d4); // 结果是 "d4 = 3.14"

Double d5 = Double.valueOf("3.14"); //创建一个双精度对象；

System.out.println(d5 instanceof Double ); // 结果是"true"

Valueof和ParseXxx都能仍出NFE(数字格式异常)；

（13）toDegrees()返回一个弧度值（小数）对应的角度（值）；如Math.toDegrees(Math.PI * 2.0) // 返回 360.0

（14）toRadians()返回一个角度值对应的弧度（值）；如

       Math.toRadians(360.0) // 返回 6.283185, which is 2 * Math.PI

26．JAVA中任何对象都拥有toString方法；

27．StringBuffer对象和String对象的不同之处就是StringBuffer对象的内容可以直接修改（主要用于大批量的数据输入输出）；如：StringBuffer sb = new StringBuffer("abc");

sb.append("def");System.out.println("sb = " + sb); // 输出内容是： "sb = abcdef"

28．Math类的构造函数是private的，并且标记为final，故不存在Math类的实例对象；

29．浮点数可以整除0，但是整型数却不可以整除0；

30．

31．包装类（Wrapper Class）对象（值）是不可变的，一旦他们被赋予了一个值这个值将是不可改变的；

32．每个包装类（除了Chapter只有一个构造函数）都带两个构造函数，一个以原始类型作参数，一个以字符串类型作参数；

33．一个Boolean对象不能作为IF条件判断语句的判断条件的，如Boolean b = new Boolean(“false”)；则语句 if（b）将编译不通过；

34．有三种类型可以比较其值是否相等：原始类型（primitive type）、引用类型（reference type）和对象（Object）；＝＝用在两个原始类型变量之间是比较这两个原始类型的值是否相等；而用在两个引用类型之间则是比较这两个变量是否是引用同一个实例对象；

    例如：String x1 = "abc";String x2 = "abc";则x1==x2返回真值（因为两个字符串变量在栈中实际是一个字符串（地址））；而String x1 = "abc";String x2 = "ab";

    X2 = x2 + “c”;则x1==x2返回假值；x1.equals(x1)返回真值；

35．StringBuffer类没有重叠方法equals；String类和Wrapper（包装）类都是final类并重叠了方法equals；

36．

    

37．String类有一个length方法，数组（array）有一个length属性；

38．abs()方法在参数为Integer.MIN_VALUE或Long.MIN_VALUE时可以返回负值；

39．Sqrt（）方法在参数为负数或NaN时返回值日为NaN；（备注：NaN不等于任何值，包括它自己）；

40．String类没有append方法，因为它本身（一旦赋值）就不能改变；

41．Max方法只能带两个参数（整型、长整型或双精度类型）；

42．三角函数（sin、cos等）需要输入的参数是弧度值（radian）不是角度值（degree）；

43．Valueof（）方法返回的是一个整型对象，而parseInt（）方法需要的输入的是字符串参数而不是整型值作参数；

44．不同类型的引用变量（如父类和子类变量），当（合法）引用同一个对象时（如两个变量同时引用同一个子类对象），他们是相等的（==和equal方法的值都是true）；

【第七章】对象和集合

01．

02．equals(), hashCode(),toString() 方法前的访问修饰符都是public；如下形式的重叠是非法的如：class Boo {

public boolean equals(Boo b) { }

}//因为该方法改变了equals方法的参数(本来应该是对象类型(object b))；

03．如果两个对象相等，那么他们的hash码（hashcode）也肯定相等；

04．

05．本章需要掌握的几个核心接口：

06．本章需要掌握的几个核心类：

07．集合类（Collection class）和接口层次

   

08．注意区分：Collection只是一个接口（interface），它仅仅包含一些通用方法的声明；而Collections则是一个包含许多静态的（static）实用方法的类；

09．在哈希表（HashTable）中，实际上并不存在哪一个节点是第一个，哪一个节点是第二个的说法；换句话说在在哈希表（HashTable）中数据（记录）的存放是杂乱无章的（备注：哈希表中不允许存在值为NULL的记录）；然而连接哈希表（LinkedHashTable）却是有序的；

10．向量类（Vector）是除了ArrayList之外唯一能实现随机访问的类；

11．集合（Set）的一个重要特点是：所有的元素都是唯一的；（可以是顺序或分类的）

12．树集合（TreeSet）是一个可分类的（Sorted）集合（Collections）；

13．哈希图（HashMap）是一个非排序、非分类的图（Map）；

14．

15．图（Map）最大特点是：唯一的标识符(unique identifier)（关键字（Key）是不允许重复的）；

16．链表（List）最大的特点是：索引（Index）；（顺序、允许重复、带索引）

17．哈希图（HashMap）是访问最快的图（Map）；树图（TreeMap）维护关键字的自然顺序（Natural Order）；

18．最简单的调用垃圾收集的操作是：System.gc();

19．原则上不推荐重载finalize()方法，即使重载也不要把重要的代码放在该方法中；

20．当通过system.out.println()打印对象时，对象的toString方法会自动被调用；

21．JAVA语言提供了一种机制,就是在（特定）对象被删除之前，可以先运行一些指定代码，这种机制就是finalize()方法；

22．equals(), hashCode(), and toString() 是 public (finalize()是 protected).

23．如果你没有重叠（override）equals()方法，两个不同（类）的对象是不能被认为相等的；

24．如果两个对象相等，他们的哈希代码（hashcode）必定相等；

25．JAVA中所有的对象都存在于堆（heap）中；

26．Java applications can run out of memory；

27．Finalize()方法仅在对象被删除之前运行一次，而且仅能运行一次；

28．StringBuffer不能重叠（override）方法equals()和hashCode()；

29．即使是比较不同的对象，equals()方法也会返回真（true）值；

30．ArrayList的方法不能够同步（sychronized）；

31．HashTable是唯一的一个支持同步（sychronized）的类；

32．TreeSet不允许存在相同的入口（Entry），如：输入为：“B”、“A”、“B”、“C”,则输出为：“A”、“B”、“C”

33．LinkedHashMap是一个可以用来满足缓冲需要的集合类（Collections Class）；

34．垃圾回收器只回收堆（heap）里面的对象（应该是用new方法创建的对象）；

35．所有的对象都存放在垃圾收集器可以回收的堆里（heap）；

【第八章】INNER类

01．一个Inner类（inner class）中不能存在任何静态的声明；唯一的访问inner类（对象）的途径就是通过一个活动的外部类（outer class）实例去访问它；Inner（inner class）本身就是外部类（outer class）的一个成员；

02．在静态代码（static code）中不存在this引用（reference）；

03．在外部类（outer Class）的实例代码之内，对inner类（inner class）的引用不需要带外部类名；然而在外部类（outer Class）的实例代码之外，对inner类（inner class）的引用必须要带外部类名；

04．在本地方法（method-local）内定义地inner类只能在定义它地方法内才可以实例化；

05．Inner类对象不能访问（方法内地）本地变量（local variable），除非该变量被Final修饰符修饰；

06．唯一能用在本地方法（内）的inner类的修饰符是abstract和final（public、protected、private等都不能用）；

07．接口是不能被直接实例化的，如Runnable r = new Runnable(); // 是错误的，不能直接实例化一个接口；然而如下形式却是合法的：Runnable r = new Runnable() { // curly brace instead of semicolon public void run() { }};因为它是实例化一个接口的实现；

08．注意：静态嵌套类（static nested class）本身并不是一个静态类（因为JAVA中本来就没有静态类一说），它仅仅是包含它的类的一个静态成员；

09．一个inner类实例能够访问外部类（outer class）的任何成员，包括private成员；

10．为了实例化一个inner类，你首先必须拥有一个外部类（outer class）的引用；

11．本地方法内的inner类不能使用在方法中定义的变量，除非该变量被final修饰符修饰；

12．实例化一个静态嵌套类时不需要外部类的实例；实例化静态嵌套类时同时需要外部类和嵌套类的类名；

13．对于静态嵌套类的实例化必须使用全局名称命名格式（如：outerclass.innerclass  m ＝ new outerclass.innerclass）；

14．在静态嵌套类中能够声明和定义非静态（NoStatic）的方法；

15．在创建inner类的实例时必须使用外部类（enclosing class）引用（变量）的new方法；如：Class F00{class Bar{}},Foo f =new Foo(); Foo.Bar b = f.new Bar();

16．本地方法内(method-local)的inner类只能被标记为final或abstract，他和其他Inner类一样，可以访问外部类（enclosing class）的所有成员（包括私有成员）；

17．匿名inner类（annoymous inner class）的创建语法只允许在关键字new之后存在一种命名的数据类型（要么是一个单个的接口（interface）要么是一个单个的类（class））；

18．切记：如果你使用了一个父类的引用变量去引用一个子类的实例对象，那么该引用变量只用调用父类中存在的成员（而不能调用只在子类中存在的成员）；

19．备注：匿名类

   Popcorn p = new Popcorn() {

public void pop() {

System.out.println("anonymous popcorn");

}

};

第一行代码并不是生成一个引用Popcorn类实例的变量，而是一个引用匿名类（annoymous）的变量（该匿名类是Popcorn类的子类，他重载了方法pop（））；

【第九章】线程

01．你可以通过两种途径定义和初始化一个线程：（1）扩展java.lang.Thread类；该方法一般重叠（override）run()方法，当然你也可以重载该方法，但是重载的run方法将不会被系统（自动）调用，除非用户手动调用；(2)实现Runnable接口；

02．使用isAlive（）方法是判断一个线程是否是已经启动但还没有执行run()方法的最好途径；

03．只能在线程（Thread）实例上调用run()方法，而不是在Runnable（）接口实例上调用run()方法；

04．当一个线程执行完它的run()方法，它将不再是一个执行线程（execution thread）！！

    备注：当一个线程执行完以后，不可以再调用它的start（）方法（使它重新成为执行线程）；

05．线程状态：

New：线程实例已被实例化，但是还没有调用start（）方法（Not Alive）； 

Runnable：可以随时被运行（但还没有运行）（Alive）；

Running：线程正在运行；

Waiting/blocked/sleeping：线程时活动的，但是没有运行；

Dead：结束

06．JAVA中所有类都自动继承了如下三个方法：

public final void wait()

public final void notify()

public final void notifyAll()

07．进程调用sleep（）方法后并不会立刻再回到运行中（running）状态，只会回到runnable（等待执行）状态；另外注意：因为sleep()是一个静态方法，所以不会出现一个进程调  

用另一个进程的sleep（）方法的情况；

08．实例化一个线程

   首先，你要实例化你的Runnalbe类：MyRunnable r = new MyRunnable();

    然后，创建一个Thread类的实例(somebody has to run your job…)：

Thread t = new Thread(r); //传递你的Runnable对象到Thread

    如果你使用不带参数的构造函数去创建Thread对象(如Thread t = new Thread())，当进程运行的时候它将直接调用它自己的(默认)run()方法；但是当你把runnable对象作为参数传递给带参数的进程创建构造函数时，它将运行你自己定义的而不是系统默认的run()方法。

09．每一个JAVA对象都内嵌一个锁（LOCK），但是该锁只是在该对象有同步的方法（synchronized method）代码时才开始活动；备注：（1）不是类中所有的方法都必须是同步的(synchronized)；（2）在一个类中可以同时存在两个同步方法，但是在同一时刻一个线程只能访问其中的一个同步方法；（3）一个线程可同时访问多个不同的锁（Lock，来自不同的对象）；（4）可以只把方法中的一个模块标记为同步的（synchronized）；

10．

11．wait(), notify(), and notifyAll()方法的调用必须来自于同步上下文（环境）（synchronized context）；一个线程在没有拥有对象的锁（lock）之前不能调用对象

 的这些方法；

12．一个线程为了（能）调用wait（）或thread（）方法，它必须拥有对象的锁。当线程等待时，它暂时释放锁给其他线程使用，但它必须在再次得到它时才能继续执行；一般语法（形式）如下：

    synchronized(anotherObject) { // this has the lock on anotherObject(拥有对象锁)

try {

anotherObject.wait();

// the thread releases the lock and waits

// To continue, the thread needs the lock,

// so it may be blocked until it gets it.

} catch(InterruptedException e){}

}

前面的代码在对象“anotherObject”调用notify（）方法之前一直处于等待状态；

//The preceding code waits until notify() is called onanotherObject.

synchronized(this) {

notify();

}

13．在类（对象）java.lang.Object中只存在方法：wait(), notify(),  notifyAll()

    在类（对象）java.lang.Thread中只存在方法：start（），sleep（），Join（），Yield（）   

14．当一个对象调用sleep（）方法后，它将仍然拥有它在调用该方法前拥有的一切锁；

15．可以通过两种途径解决两个以上的进程同步访问同一个关键资源问题。一是同步方法（在方法前添加关键字“synchronized”）；二是同步代块（在一段代码前添加关键字“synchronized”）。同步代码块是需要给定一个参数（对象），该对象拥有代码块需要同步的锁；

16．方法可以同步（synchronized），变量（variable）不可以；

17．在同一个线程上执行两次start（）方法会出现运行时错误而不是编译错误；同理，如果调用wait()方法的线程若没有获得对象的锁也会出现运行错误而不是编译错误；

18．因为类Thread实现了Runnable，所以如下的代码是正确的：

MyThread t = new MyThread();

Thread x = new Thread(t);

x.start();

19．Sleep()方法必须包含在Try…Catch语句中；或者调用它的（用户定义的）方法必须仍出InterruptedException；

20．静态方法可以被同步；

21．切记：一般情况下背景线程应该设置最低优先级（1或Thread.MIN_PRIORITY）；

22．如下方法运行后保证线程退出“运行”状态：wait()、sleep（）、aliveThread.Join（）；

 

(1.)        可以通过扩展一个实际（普通）类来生成一个抽象类（Abstract Class）；

(2.)        类和接口不能被标记为static；同时类（非嵌套类）和接口也不能被标记成protected；

(3.)        Transient只能用来修饰变量（接口中的变量不能使用protected或transient来修饰，接口中的方法不能使用static和final来修饰）；

(4.)        接口中定义的变量都默认是default final&static修饰的，故一旦被初始化将不能再被修改；

(5.)        若一个抽象类实现一个接口，在该抽象类的定义中可以不存在接口的任何实现；

(6.)        位与（&）比位或（|）有较高的优先级；

(7.)        当数组作为方法的参数时，若在方法中改变了数组的值，实际数组的值也将改变；

(8.)        Case语句中的表达式必须是常量（或final类型的变量），static类型的都不行！！

(9.)        If…else if 语句中，只要有一个判断匹配上了，下面（else if 语句）的就不再判断；

(10.)    Continue语句只能用在loop结构中；

(11.)    一旦程序中仍出运行异常（RunException），则finally块语句就马上会执行，程序就会终止；如果没有方法处理该异常，则finally语句会在异常向下传播之前先执行；如果有方法处理该异常，则会先执行异常处理方法然后再执行finally语句；

(12.)    断言只能仍出错误而不仍出异常（assertions throw errors and not exceptions,）；

(13.)    断言错误（AssertionErrors）是不能够被处理的；

(14.)    断言语句冒号后面的部分必须是一个值（即使是返回值为void的方法都不行）！！

(15.)    构造函数不能有返回值；

(16.)    原始数据类型（值）不能显示转化（case）为对象类型？

(17.)    ParseInt（…）需要带一个字符串参数；

(18.)    不是同一个类层次上的对象不能通过equals方法比较；

(19.)    Boolean字符串大小写是不敏感的；

(20.)    HashTable是唯一一个能提供synchronized方法的类；

(21.)    本地方法内的（local－method）inner类可以标记为“abstract”；

(22.)    static int i = 0;这样声明变量是不对的；

(23.)    一条CASE语句中不能包含两个或以上的判断值；

(24.)    如果两个对象互相引用（形成了隔离区），则这两个对象可以被垃圾收集器收集；

(25.)    默认的构造函数只会初始化（类）成员变量，不会初始化（类）方法变量；

(26.)    Switch 后面的变量可以是byte类型和char类型；

(27.)    若类中不存在public static void main(String[] args)函数的话，编译不会出错，只是程序不能运行；

(28.)    这样定义数组是错误的：boolean results[] = new boolean [3] {true, false, true};

(29.)    Object是不能被仍出的；

      Integer a = new Integer(10);Integer b = new Integer(10); a==b是错误的；

float f = ‘1’;是对的

float f = “1”;是错误的

(30.)    数组若是在使用之前没有只声明而没有初始化的话，编译不会出错，运行会出错；

访问超出数组界线的元素情况也是一样；