ｊａｖａ基础知识大全

第一章

    1．floatf4[] = 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 ofX.“catch语句能够捕捉子类异常”是正确的。

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

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

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

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

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

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

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

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[][] = newint[][]定义数组是不对的而这样定义数组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中不用的两个保留字。其中publicconst用static final代替其功能

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

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

    

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

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

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

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

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

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

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

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

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

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

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

Car[] cars;

Honda[] cuteCars = new Honda[5];

cars = cuteCars; // OK because Honda isa type of Car

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

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

    stringstrTemp;

   system.out.println(strTemp.toLowerCase);

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

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

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

没有任何访问修饰符限制，范围是当前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型的。然而如果在抽象类中存在非抽象的方法则是合法（允许）的。备注：子类必须实现抽象父类的所有抽象方法，除非该子类也是一个抽象类。

    publicabstract class A {

abstract void foo();

}

class B extends A {

void foo(int I) {

}

}

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

10．实例变量（instancevariable）就是指类成员变量（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．只有一个修饰符能应用在本地变量（localvariable）上，那就是final。方法内的参数就等同于本地变量，因此在方法的参数列表中的参数前也可以使用修饰符final。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 ofobject判断结果同样会是真。

  

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

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

12．If判断语句中的判断条件只能是布尔型，但唯一一个可以列外的情况就是布尔变量的赋值语句可以出现在判断条件中如：booleanb；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）{case129:}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．Booleanb1；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）而不是对象类型（objecttype）决定调用哪一个重载函数的。

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

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）比默认访问修饰符（default）更限制更宽松一些；

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

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

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

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

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

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

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

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

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

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

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

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

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

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

public String substring(int begin, intend)切记：这里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（）返回一个原始类型值（不带任何参数）；ThexxxValue()它可以转换任何包装类对象的值到原始类型；

（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对象的内容可以直接修改（主要用于大批量的数据输入输出）；如：StringBuffersb = new StringBuffer("abc");

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

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

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

30．

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

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

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

34．有三种类型可以比较其值是否相等：原始类型（primitivetype）、引用类型（referencetype）和对象（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；如下形式的重叠是非法的如：classBoo {

public boolean equals(Boo b) { }

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

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）最大特点是：唯一的标识符(uniqueidentifier)（关键字（Key）是不允许重复的）；

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

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

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 ofmemory；

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类（innerclass）中不能存在任何静态的声明；唯一的访问inner类（对象）的途径就是通过一个活动的外部类（outerclass）实例去访问它；Inner（inner class）本身就是外部类（outer class）的一个成员；

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

19．备注：匿名类

  Popcorn p = new Popcorn() {

public void pop() {

System.out.println("anonymouspopcorn");

}

};

第一行代码并不是生成一个引用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（）方法（NotAlive）； 

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 = newThread())，当进程运行的时候它将直接调用它自己的(默认)run()方法；但是当你把runnable对象作为参数传递给带参数的进程创建构造函数时，它将运行你自己定义的而不是系统默认的run()方法。

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

10．

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

 的这些方法；

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

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

try {

anotherObject.wait();

// the thread releases the lock andwaits

// To continue, the thread needs thelock,

// so it may be blocked until it getsit.

} catch(InterruptedException e){}

}

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

//The preceding code waits untilnotify() is called on anotherObject.

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.)       接口中定义的变量都默认是defaultfinal&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.)    staticint 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是错误的；

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊

：java概述：

1991 年Sun公司的James Gosling（詹姆斯·高斯林）等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器；

1994年将Oak语言更名为Java；

 

Java的三种技术架构:

JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发；

JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础；

JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序；

 

1，JDK：Java Development Kit，java的开发和运行环境，java的开发工具和jre。

2，JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。

3，配置环境变量：让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。

环境变量的配置：

    1）：永久配置方式：JAVA_HOME=%安装路径%\Java\jdk

                     path=%JAVA_HOME%\bin

    2）：临时配置方式：set path=%path%;C:\Program Files\Java\jdk\bin

特点：系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。

classpath的配置:

    1）：永久配置方式：classpath=.;c:\;e:\

    2）：临时配置方式：set classpath=.;c:\;e:\

 

注意：在定义classpath环境变量时，需要注意的情况

如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件；

如果指定了classpath，那么会在指定的目录下查找要运行的类文件。

还会在当前目录找吗？两种情况：

    1）：如果classpath的值结尾处有分号，在具体路径中没有找到运行的类，会默认在当前目录再找一次。

    2）：如果classpath的值结果出没有分号，在具体的路径中没有找到运行的类，不会再当前目录找。

    一般不指定分号，如果没有在指定目录下找到要运行的类文件，就报错，这样可以调试程序。

 

4，javac命令和java命令做什么事情呢？

    要知道java是分两部分的：一个是编译，一个是运行。

    javac：负责的是编译的部分，当执行javac时，会启动java的编译器程序。对指定扩展名的.java文件进行编译。 生成了jvm可以识别的字节码文件。也就是class文件，也就是java的运行程序。

    java：负责运行的部分.会启动jvm.加载运行时所需的类库,并对class文件进行执行.

    一个文件要被执行,必须要有一个执行的起始点,这个起始点就是main函数.

----------------------------------------------------------------------------------------------

二：java语法基础：

 

1，关键字：其实就是某种语言赋予了特殊含义的单词。

    保留字：其实就是还没有赋予特殊含义，但是准备日后要使用过的单词。

2，标示符：其实就是在程序中自定义的名词。比如类名，变量名，函数名。包含0-9、a-z、$、_ ；

    注意：

    1），数字不可以开头。

    2），不可以使用关键字。

3，常量：是在程序中的不会变化的数据。

4，变量：其实就是内存中的一个存储空间，用于存储常量数据。

    作用：方便于运算。因为有些数据不确定。所以确定该数据的名词和存储空间。

    特点：变量空间可以重复使用。

什么时候定义变量？只要是数据不确定的时候，就定义变量。

 

变量空间的开辟需要什么要素呢？

    1，这个空间要存储什么数据？数据类型。

    2，这个空间叫什么名字啊？变量名称。

    3，这个空间的第一次的数据是什么？ 变量的初始化值。

 

变量的作用域和生存期:

变量的作用域：

    作用域从变量定义的位置开始，到该变量所在的那对大括号结束；

生命周期：

    变量从定义的位置开始就在内存中活了；

    变量到达它所在的作用域的时候就在内存中消失了；

 

数据类型：

    1）：基本数据类型：byte、short、int、long、float、double、char、boolean

    2）：引用数据类型:数组、类、接口。

级别从低到高为：byte,char,short(这三个平级)-->int-->float-->long-->double

自动类型转换：从低级别到高级别，系统自动转的；

强制类型转换：什么情况下使用?把一个高级别的数赋给一个别该数的级别低的变量；

 

运算符号：

    1）、算术运算符。

        + - * / %   %:任何整数模2不是0就是1，所以只要改变被模数就可以实现开关运算。

        +:连接符。

        ++,--

    2）、赋值运算符。

        =  += -= *= /= %=

    3）、比较运算符。

        特点：该运算符的特点是：运算完的结果，要么是true，要么是false。

    4）、逻辑运算符。

        &  |  ^  !   &&   ||

        逻辑运算符除了 !  外都是用于连接两个boolean类型表达式。

        &: 只有两边都为true结果是true。否则就是false。

        |:只要两边都为false结果是false，否则就是true

        ^:异或：和或有点不一样。

             两边结果一样，就为false。

             两边结果不一样，就为true.

        & 和 &&区别： &：无论左边结果是什么，右边都参与运算。

                     &&:短路与，如果左边为false，那么右边不参数与运算。

        | 和|| 区别：|：两边都运算。

                   ||：短路或，如果左边为true，那么右边不参与运算。

    5）、位运算符:用于操作二进制位的运算符。

        &  |  ^

        <<  >>   >>>(无符号右移)

    练习：对两个变量的数据进行互换。不需要第三方变量。

            int a  = 3,b = 5;-->b = 3,a = 5;

            a = a + b; a = 8;

            b = a - b; b = 3;

            a = a - b; a = 5;

            a = a ^ b;//

            b = a ^ b;//b = a ^ b ^ b = a

            a = a ^ b;//a = a ^ b ^ a = b;

        练习：高效的算出 2*8 = 2<<3;

5，语句。

    If  switch  do while   while  for

    这些语句什么时候用？

    1）、当判断固定个数的值的时候，可以使用if，也可以使用switch。

    但是建议使用switch，效率相对较高。

switch(变量){

   case值:要执行的语句;break;

   …

   default:要执行的语句;

}

 工作原理：用小括号中的变量的值依次和case后面的值进行对比，和哪个case后面的值相同了

           就执行哪个case后面的语句，如果没有相同的则执行default后面的语句；

 细节：1）：break是可以省略的，如果省略了就一直执行到遇到break为止；

      2）：switch 后面的小括号中的变量应该是byte,char,short,int四种类型中的一种；

      3）：default可以写在switch结构中的任意位置；如果将default语句放在了第一行，则不管expression与case中的value是否匹配，程序会从default开始执行直到第一个break出现。

    2）、当判断数据范围，获取判断运算结果boolean类型时，需要使用if。

    3）、当某些语句需要执行很多次时，就用循环结构。

    while和for可以进行互换。

    区别在于：如果需要定义变量控制循环次数。建议使用for。因为for循环完毕，变量在内存中释放。

 

break:作用于switch，和循环语句，用于跳出，或者称为结束。

break语句单独存在时，下面不要定义其他语句，因为执行不到，编译会失败。当循环嵌套时，break只跳出当前所在循环。要跳出嵌套中的外部循环，只要给循环起名字即可，这个名字称之为标号。

 

continue:只作用于循环结构，继续循环用的。

作用：结束本次循环，继续下次循环。该语句单独存在时，下面不可以定义语句，执行不到。

 

6，函 数：为了提高代码的复用性，可以将其定义成一个单独的功能，该功能的体现就是java中的函数。函数就是体现之一。

java中的函数的定义格式：

    修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数1，…){

      执行语句；

      return 返回值；

    }

当函数没有具体的返回值时，返回的返回值类型用void关键字表示。

如果函数的返回值类型是void时，return语句可以省略不写的，系统会帮你自动加上。

return的作用：结束函数。结束功能。

 

如何定义一个函数？

    函数其实就是一个功能，定义函数就是实现功能，通过两个明确来完成：

    1）、明确该功能的运算完的结果，其实是在明确这个函数的返回值类型。

    2）、在实现该功能的过程中是否有未知内容参与了运算，其实就是在明确这个函数的参数列表(参数类型&参数个数)。

函数的作用：

1）、用于定义功能。

2）、用于封装代码提高代码的复用性。

注意：函数中只能调用函数，不能定义函数。

主函数：

    1）、保证该类的独立运行。

    2）、因为它是程序的入口。

    3）、因为它在被jvm调用。

 

函数定义名称是为什么呢？

答：1）、为了对该功能进行标示，方便于调用。

    2）、为了通过名称就可以明确函数的功能，为了增加代码的阅读性。

 

重载的定义是：在一个类中，如果出现了两个或者两个以上的同名函数，只要它们的参数的个数，或者参数的类型不同，即可称之为该函数重载了。

如何区分重载：当函数同名时，只看参数列表。和返回值类型没关系。

 

7，数 组：用于存储同一类型数据的一个容器。好处：可以对该容器中的数据进行编号，从0开始。数组用于封装数据，就是一个具体的实体。

如何在java中表现一个数组呢？两种表现形式。

1）、元素类型[]变量名 = new 元素类型[元素的个数]；

2）、元素类型[]变量名 = {元素1，元素2...}；

元素类型[] 变量名 = new 元素类型[]{元素1，元素2...}；

---------------------------------------------------------

//二分查找法。必须有前提：数组中的元素要有序。

    public static int halfSeach_2(int[] arr,int key){

        int min,max,mid;

        min = 0;

        max = arr.length-1;

        mid = (max+min)>>1; //(max+min)/2;

        while(arr[mid]!=key){

            if(key>arr[mid]){

               min = mid + 1;

            }

            else if(key<arr[mid])

               max = mid - 1;

            if(max<min)

               return -1;

            mid = (max+min)>>1;

        }

        return mid;

    }

---------------------------------------------------------

java分了5片内存。

1：寄存器。2：本地方法区。3：方法区。4：栈。5：堆。

栈：存储的都是局部变量( 函数中定义的变量，函数上的参数，语句中的变量 )；

    只要数据运算完成所在的区域结束，该数据就会被释放。

堆：用于存储数组和对象，也就是实体。啥是实体啊？就是用于封装多个数据的。

1：每一个实体都有内存首地址值。

2：堆内存中的变量都有默认初始化值。因为数据类型不同，值也不一样。

3：垃圾回收机制。

----------------------------------------------------------------------------------------------

三：面向对象：★★★★★

特点：1：将复杂的事情简单化。

2：面向对象将以前的过程中的执行者，变成了指挥者。

3：面向对象这种思想是符合现在人们思考习惯的一种思想。

 

过程和对象在我们的程序中是如何体现的呢？过程其实就是函数；对象是将函数等一些内容进行了封装。

 

匿名对象使用场景：

1：当对方法只进行一次调用的时候，可以使用匿名对象。

2：当对象对成员进行多次调用时，不能使用匿名对象。必须给对象起名字。

 

在类中定义其实都称之为成员。成员有两种：

1：成员变量：其实对应的就是事物的属性。

2：成员函数：其实对应的就是事物的行为。

 

所以，其实定义类，就是在定义成员变量和成员函数。但是在定义前，必须先要对事物进行属性和行为的分析，才可以用代码来体现。

 

private int age;//私有的访问权限最低，只有在本类中的访问有效。

注意：私有仅仅是封装的一种体现形式而已。

 

私有的成员：其他类不能直接创建对象访问，所以只有通过本类对外提供具体的访问方式来完成对私有的访问，可以通过对外提供函数的形式对其进行访问。

好处：可以在函数中加入逻辑判断等操作，对数据进行判断等操作。

 

总结：开发时，记住，属性是用于存储数据的，直接被访问，容易出现安全隐患，所以，类中的属性通常被私有化，并对外提供公共的访问方法。

这个方法一般有两个，规范写法：对于属性 xxx，可以使用setXXX(),getXXX()对其进行操作。

 

类中怎么没有定义主函数呢？

注意：主函数的存在，仅为该类是否需要独立运行，如果不需要，主函数是不用定义的。

主函数的解释：保证所在类的独立运行，是程序的入口，被jvm调用。

 

成员变量和局部变量的区别：

1：成员变量直接定义在类中。

   局部变量定义在方法中，参数上，语句中。

2：成员变量在这个类中有效。

局部变量只在自己所属的大括号内有效，大括号结束，局部变量失去作用域。

3：成员变量存在于堆内存中，随着对象的产生而存在，消失而消失。

局部变量存在于栈内存中，随着所属区域的运行而存在，结束而释放。

 

构造函数：用于给对象进行初始化，是给与之对应的对象进行初始化，它具有针对性，函数中的一种。

特点：

1：该函数的名称和所在类的名称相同。

2：不需要定义返回值类型。

3：该函数没有具体的返回值。

记住：所有对象创建时，都需要初始化才可以使用。

 

注意事项：一个类在定义时，如果没有定义过构造函数，那么该类中会自动生成一个空参数的构造函数，为了方便该类创建对象，完成初始化。如果在类中自定义了构造函数，那么默认的构造函数就没有了。

 

一个类中，可以有多个构造函数，因为它们的函数名称都相同，所以只能通过参数列表来区分。所以，一个类中如果出现多个构造函数。它们的存在是以重载体现的。

 

构造函数和一般函数有什么区别呢？

1：两个函数定义格式不同。

2：构造函数是在对象创建时，就被调用，用于初始化，而且初始化动作只执行一次。

    一般函数，是对象创建后，需要调用才执行，可以被调用多次。

  

什么时候使用构造函数呢？

分析事物时，发现具体事物一出现，就具备了一些特征，那就将这些特征定义到构造函数内。

 

构造代码块和构造函数有什么区别？

构造代码块：是给所有的对象进行初始化，也就是说，所有的对象都会调用一个代码块，只要对象一建立，就会调用这个代码块。

构造函数：是给与之对应的对象进行初始化，它具有针对性。

 

“Person p = new Person();”

创建一个对象都在内存中做了什么事情？

1：先将硬盘上指定位置的Person.class文件加载进内存。

2：执行main方法时，在栈内存中开辟了main方法的空间(压栈-进栈)，然后在main方法的栈区分配了一个变量p。

3：在堆内存中开辟一个实体空间，分配了一个内存首地址值。new

4：在该实体空间中进行属性的空间分配，并进行了默认初始化。

5：对空间中的属性进行显示初始化。

6：进行实体的构造代码块初始化。

7：调用该实体对应的构造函数，进行构造函数初始化。（）

8：将首地址赋值给p，p变量就引用了该实体。(指向了该对象)

--------------------------------------------------------------------------------------------

封 装（面向对象特征之一）：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：将变化隔离；便于使用；提高重用性；安全性。

封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。

 

This：代表对象，就是所在函数所属对象的引用。

this到底代表什么呢？哪个对象调用了this所在的函数，this就代表哪个对象，就是哪个对象的引用。

开发时，什么时候使用this呢？

在定义功能时，如果该功能内部使用到了调用该功能的对象，这时就用this来表示这个对象。

 

this 还可以用于构造函数间的调用。

调用格式：this(实际参数)；

this对象后面跟上.  调用的是成员属性和成员方法(一般方法)；

this对象后面跟上 ()调用的是本类中的对应参数的构造函数。

 

注意：用this调用构造函数，必须定义在构造函数的第一行。因为构造函数是用于初始化的，所以初始化动作一定要执行。否则编译失败。

 

static：★★★关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。

特点：

1，想要实现对象中的共性数据的对象共享，可以将这个数据进行静态修饰。

2，被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。

3，静态随着类的加载而加载，而且优先于对象存在。

 

弊端：

1，有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。

2，静态方法只能访问静态成员，不可以访问非静态成员。

因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。

3，静态方法中不能使用this，super关键字。

因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。

4，主函数是静态的。

 

什么时候定义静态成员呢？或者说：定义成员时，到底需不需要被静态修饰呢？

成员分两种：

1，成员变量。（数据共享时静态化）

该成员变量的数据是否是所有对象都一样：

如果是，那么该变量需要被静态修饰，因为是共享的数据。

如果不是，那么就说这是对象的特有数据，要存储到对象中。

2，成员函数。（方法中没有调用特有数据时就定义成静态）

    如果判断成员函数是否需要被静态修饰呢？

    只要参考，该函数内是否访问了对象中的特有数据：

    如果有访问特有数据，那方法不能被静态修饰。

    如果没有访问过特有数据，那么这个方法需要被静态修饰。

 

成员变量和静态变量的区别：

1，成员变量所属于对象，所以也称为实例变量。

静态变量所属于类，所以也称为类变量。

2，成员变量存在于堆内存中。

静态变量存在于方法区中。

3，成员变量随着对象创建而存在，随着对象被回收而消失。

静态变量随着类的加载而存在，随着类的消失而消失。

4，成员变量只能被对象所调用。

静态变量可以被对象调用，也可以被类名调用。

所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。

 

静态的注意：静态的生命周期很长。

静态代码块：就是一个有静态关键字标示的一个代码块区域，定义在类中。

作用：可以完成类的初始化，静态代码块随着类的加载而执行，而且只执行一次（new多个对象就只执行一次）。如果和主函数在同一类中，优先于主函数执行。

 

Public：访问权限最大。

static：不需要对象，直接类名即可。

void：主函数没有返回值。

Main：主函数特定的名称。

(String[] args)：主函数的参数，是一个字符串数组类型的参数，jvm调用main方法时，传递的实际参数是 new String[0]。

 

jvm默认传递的是长度为0的字符串数组，我们在运行该类时，也可以指定具体的参数进行传递。可以在控制台，运行该类时，在后面加入参数。参数之间通过空格隔开。jvm会自动将这些字符串参数作为args数组中的元素，进行存储。

 

静态代码块、构造代码块、构造函数同时存在时的执行顺序：静态代码块à构造代码块 à构造函数；

 

生成Java帮助文档：命令格式：javadoc –d文件夹名 –auther –version *.java

/**     //格式

*类描述

 作者名

*@version 版本号

*/

/**

*方法描述

*@param  参数描述

*@return  返回值描述

*/

---------------------------------------------------------------------------------------------

设计模式：解决问题最行之有效的思想。是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

 

java中有23种设计模式：

单例设计模式：★★★★★

解决的问题：保证一个类在内存中的对象唯一性。

比如：多程序读取一个配置文件时，建议配置文件封装成对象。会方便操作其中数据，又要保证多个程序读到的是同一个配置文件对象，就需要该配置文件对象在内存中是唯一的。

 

Runtime()方法就是单例设计模式进行设计的。

 

如何保证对象唯一性呢？

思想：

1，不让其他程序创建该类对象。

2，在本类中创建一个本类对象。

3，对外提供方法，让其他程序获取这个对象。

 

步骤：

1，因为创建对象都需要构造函数初始化，只要将本类中的构造函数私有化，其他程序就无法再创建该类对象；

2，就在类中创建一个本类的对象；

3，定义一个方法，返回该对象，让其他程序可以通过方法就得到本类对象。（作用：可控）

 

代码体现：

1，私有化构造函数；

2，创建私有并静态的本类对象；

3，定义公有并静态的方法，返回该对象。

---------------------------------------------

//饿汉式

class Single{

    private Single(){} //私有化构造函数。

private static Single s = new Single(); //创建私有并静态的本类对象。

    public static Single getInstance(){ //定义公有并静态的方法，返回该对象。

        return s;

    }

}

---------------------------------------------

//懒汉式:延迟加载方式。

class Single2{

    private Single2(){}

private static Single2 s = null;

    public static Single2 getInstance(){

        if(s==null)

            s = new Single2();

        return s;

    }

}

-------------------------------------------------------------------------------------------------

继 承（面向对象特征之一）

好处：

1：提高了代码的复用性。

2：让类与类之间产生了关系，提供了另一个特征多态的前提。

 

父类的由来：其实是由多个类不断向上抽取共性内容而来的。

java中对于继承，java只支持单继承。java虽然不直接支持多继承，但是保留了这种多继承机制，进行改良。

 

单继承：一个类只能有一个父类。

多继承：一个类可以有多个父类。

 

为什么不支持多继承呢？

因为当一个类同时继承两个父类时，两个父类中有相同的功能，那么子类对象调用该功能时，运行哪一个呢？因为父类中的方法中存在方法体。

但是java支持多重继承。A继承B B继承C  C继承D。

多重继承的出现，就有了继承体系。体系中的顶层父类是通过不断向上抽取而来的。它里面定义的该体系最基本最共性内容的功能。

所以，一个体系要想被使用，直接查阅该系统中的父类的功能即可知道该体系的基本用法。那么想要使用一个体系时，需要建立对象。建议建立最子类对象，因为最子类不仅可以使用父类中的功能。还可以使用子类特有的一些功能。

 

简单说：对于一个继承体系的使用，查阅顶层父类中的内容，创建最底层子类的对象。

 

子父类出现后，类中的成员都有了哪些特点：

1：成员变量。

     当子父类中出现一样的属性时，子类类型的对象，调用该属性，值是子类的属性值。

     如果想要调用父类中的属性值，需要使用一个关键字：super

     This：代表是本类类型的对象引用。

     Super：代表是子类所属的父类中的内存空间引用。

     注意：子父类中通常是不会出现同名成员变量的，因为父类中只要定义了，子类就不用在定义了，直接继承过来用就可以了。

2：成员函数。

当子父类中出现了一模一样的方法时，建立子类对象会运行子类中的方法。好像父类中的方法被覆盖掉一样。所以这种情况，是函数的另一个特性：覆盖(复写，重写)

什么时候使用覆盖呢？当一个类的功能内容需要修改时，可以通过覆盖来实现。

3：构造函数。

发现子类构造函数运行时，先运行了父类的构造函数。为什么呢?

原因：子类的所有构造函数中的第一行，其实都有一条隐身的语句super();

super(): 表示父类的构造函数，并会调用于参数相对应的父类中的构造函数。而super():是在调用父类中空参数的构造函数。

为什么子类对象初始化时，都需要调用父类中的函数？(为什么要在子类构造函数的第一行加入这个super()?)

因为子类继承父类，会继承到父类中的数据，所以必须要看父类是如何对自己的数据进行初始化的。所以子类在进行对象初始化时，先调用父类的构造函数，这就是子类的实例化过程。

 

注意：子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super();

如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。

如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。

 

问题：super()和this()是否可以同时出现的构造函数中。

两个语句只能有一个定义在第一行，所以只能出现其中一个。

 

super()或者this():为什么一定要定义在第一行？

因为super()或者this()都是调用构造函数，构造函数用于初始化，所以初始化的动作要先完成。

 

继承的细节：

什么时候使用继承呢？

当类与类之间存在着所属关系时，才具备了继承的前提。a是b中的一种。a继承b。狼是犬科中的一种。

英文书中，所属关系：" is a "

注意：不要仅仅为了获取其他类中的已有成员进行继承。

 

所以判断所属关系，可以简单看，如果继承后，被继承的类中的功能，都可以被该子类所具备，那么继承成立。如果不是，不可以继承。

 

细节二：

在方法覆盖时，注意两点：

1：子类覆盖父类时，必须要保证，子类方法的权限必须大于等于父类方法权限可以实现继承。否则，编译失败。

2：覆盖时，要么都静态，要么都不静态。 (静态只能覆盖静态，或者被静态覆盖)

 

继承的一个弊端：打破了封装性。对于一些类，或者类中功能，是需要被继承，或者复写的。

这时如何解决问题呢？介绍一个关键字，final:最终。

 

final特点：

1：这个关键字是一个修饰符，可以修饰类，方法，变量。

2：被final修饰的类是一个最终类，不可以被继承。

3：被final修饰的方法是一个最终方法，不可以被覆盖。

4：被final修饰的变量是一个常量，只能赋值一次。

 

    其实这样的原因的就是给一些固定的数据起个阅读性较强的名称。

    不加final修饰不是也可以使用吗？那么这个值是一个变量，是可以更改的。加了final，程序更为严谨。常量名称定义时，有规范，所有字母都大写，如果由多个单词组成，中间用_ 连接。

 

抽象类:abstract

抽象：不具体，看不明白。抽象类表象体现。

在不断抽取过程中，将共性内容中的方法声明抽取，但是方法不一样，没有抽取，这时抽取到的方法，并不具体，需要被指定关键字abstract所标示，声明为抽象方法。

抽象方法所在类一定要标示为抽象类，也就是说该类需要被abstract关键字所修饰。

 

抽象类的特点：

1：抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。

2：抽象方法只定义方法声明，并不定义方法实现。

3：抽象类不可以被创建对象(实例化)。

4：只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。

 

抽象类的细节：

1：抽象类中是否有构造函数？有，用于给子类对象进行初始化。

2：抽象类中是否可以定义非抽象方法？

    可以。其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。

3：抽象关键字abstract和哪些不可以共存？final ,private , static

4：抽象类中可不可以不定义抽象方法？可以。抽象方法目的仅仅为了不让该类创建对象。

-----------------------------------------------------------------------------------------------

模板方法设计模式：

解决的问题：当功能内部一部分实现时确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。

abstract class GetTime{

    publicfinal void getTime(){ //此功能如果不需要复写，可加final限定

        long start = System.currentTimeMillis();

        code(); //不确定的功能部分，提取出来，通过抽象方法实现

        long end = System.currentTimeMillis();

        System.out.println("毫秒是："+(end-start));

    }

    publicabstract void code(); //抽象不确定的功能，让子类复写实现

}

class SubDemo extends GetTime{

    public void code(){//子类复写功能方法

        for(int y=0; y<1000; y++){

            System.out.println("y");

        }

    }

}