Java读书笔记

Java读书笔记之CoreJava

第一章：Java语言基础

1、JAVA的特性

Simple简单（去掉了C++中许多奇怪的语法）

Object-Oriented面向对象（OOP）

Network-Savvy网络通信（支持HTTP，FTP，TCP/IP等多种网络协议）

Robust健壮性（健壮性主要体现在Java在编译是就能发现某些存在的问题，且优化了C 和C++中的指针，不会造成内存泄露。）

Secure安全性

Architecture Neutral体系结构中立

Portable可移植性（Java固定了数据类型的大小）

Interpreted解释型语言（存在争议，可能介于编译和解释之间）

High Performance高性能

Multithreaded多线程

Dynamic动态性

Java和C++的区别：Java去掉了C++中的头文件，指针运算，结构体，联合体以及运算符重载等语法，且Java以接口替代了C++中的多重继承。

JIT（Just In Time）virtual machines have the option of translating the most frequently executed bytecodes sequences into machine code, a process called just-in-time compilation。

2、JAVA运行的环境

(1)、环境变量配置

在Windows下（XP）：

--下载Windows版本的JDK，双击进行安装，建议安装目录C:\java\jdk1.6.0_06 --设置环境变量：

JAVA_HOME c:\java\jdk1.6.0_06（java安装目录）

PATH 添加到原有路径的最前方，%JAVA_HOME%\bin（不要删除原来的）

CLASSPATH .;%JAVA_HOME%\lib

在Linux下：

--下载一个Linux Platform的JDK，建议下载RPM自解压格式的（RPM in self- extracting file，jdk1.6.0_06-linux-i586-rpm.bin）；

--在shell下执行命令：

chmod 755 jdk1.6.0_06-linux-i586-rpm.bin

./jdk1.6.0_06-linux-i586-rpm.bin

--设置环境变量：

在Linux系统的用户主目录下新建终端vi .bash_profile在其中添加如下参数：JAVA_HOME = /opt/jdk1.6.0_06

PATH = $JAVA_HOME/bin:.

CLASSPATH = .

export PATH

export CLASSPATH

上述配置完成后在命令提示行(Windows)或终端（Liunx）运行java –version如果可以查看JDK的版本信息，则证明配置环境变量成功。

(2)、编译、执行JAVA文件

javac filename.java编译程序

java filename执行程序

注意:当使用java –classpath 执行程序的时候，这个classpath的优先级高于系统设置的classpath。

3、JAVA中的基础知识点

（1）、JAVA语言大小写敏感(case sensitive)

（2）、JAVA合法标识符的原则：字母、下划线、美元符为首字母，后面可以是任意长度的字母、数字、下划线和美元符的字符序列（但不能是JAVA的保留字）（3）、JAVA语言的一般命名原则：（见文知意）

★对于类、接口：每个单词的首字母大写，一般不使用缩写。（名词）

★对于变量：首个单词小写，其后的每一个单词的首字母大写。（名词）

★对于方法：首个单词小写，其后的每一个单词的首字母大写。（动词）

★对于常量：全部大写。使用_进行连接（名词）

★对于包：全部小写，一般为公司组织域名的逆序。（名词）

（4）、JAVA的文件名必须和文件内的公有类名相同（一个源文件只能有一个public类）。

注意：当文件中不存在公有类的时候：则源文件可以随意命名，只要符合JAVA语言的标识符规范即可。

（5）、JAVA的注释：

// 单行注释，可用于源文件的任何位置。

/*……*/ 多行注释，可用于源文件的任何位置。

/**……*/ JAVA注释，使用javadoc命令可以生成HTML注释，可用于源文件的任何位置。

方法注释的参数有@param、@return、@throws

文档注释一般参数有@author、@version、@since、@deprecated

@see

将文档生成在指定目录javadoc -d docDirectory packageName

如果要生成的文档在多个包中javadoc -d docDirectory *.java （6）、一个JAVA源文件可以不包含任何代码定义，即使它是一个空文件，编译也不会产生异常。（这里的空指的是类体内不包含任何代码）

（7）、关于main方法，完整定义为public static void main(String[]args) public不是必须的，但是如果没有public修饰的话，编译不会出错，但是

该程序因为JVM找不到执行入口而无法被执行。

static是必须的，它可以在不构造实例的情况下调用main方法。

返回值必须是void，不能定义为其他，定义为其他尽管不会产生编译错误，

但是无法运行。

args是一个字符串类型的数组，用于接收命令行参数。（可以不叫args）

args数组即使不接收任何参数，也会创建一个长度为0的数组。

Main方法的另一种形式public static void main(String...args);（8）、这个例子值得注意，假设有两个类Employee和EmployeeTest，后者负责测试前者，如果两个类在两个文件中，javac Employee*.java可以同时编译两

个文件，但是如果是javac EmployeeTest.java呢？答案是也可以编译通

过，这里要说明的是，当JVM在编译EmployeeTest时，发现其中有Employee

类，于是就去找Employee.class，如果找不到，JVM则会找Employee.java

这个文件，找到后对其进行编译，然后再编译EmployeeTest。特别说明的是，

如果找到的Employee.java时间戳早于Employee.class，那么JVM会重

新编译Employee.java。

（9）JAVA语言的程序结构

★包语句(package):公司域名逆序。（除了注释的第一行）

编译时：javac com/suki/PayrollApp.java

运行时：java com.suki.PayrollApp

★导入语句(import)（包语句之后，类声明之前）

注意:import java.util.*;

import java.sql.*;

当使用Date date = new Date(long time);时编译会出错。

解决方法import java.util.Date;

如果同时想要使用这两个包中的Date类怎么办呢？

java.util.Date today = new java.util.Date(...);

java.sql.Date today = new java.sql.Date(...);

静态导入：静态导入实现无需在使用其他类的静态成员时前缀的类名，使代码更为简洁，import static

如：import static https://www.360docs.net/doc/e29143092.html,ng.Math;（针对静态方法）

import static https://www.360docs.net/doc/e29143092.html,ng.Math.*（针对静态属性）

Import static https://www.360docs.net/doc/e29143092.html,ng.Math.PI; （针对静态属性）

这样在类中就能直接应用PI这个属性了。

不推荐使用静态导入，引起代码费解。（Math类比较适合使用静态导入）★类声明语句(class declaration)

（10）、classpath问题

Classpath包含三方面的内容：

根目录(base directory)；

当前目录(.)

需要使用到的class的path(一般为jar)

在Windows系统以;为分隔符，unix系统以:为分隔符。

JAVASE6可以使用*来将jar文件放入classpath中。

4、JAVA中的的数据类型

（1）、JAVA数据类型分为基本类型（primitive）和引用类型(reference)

其中基本类型包括：

★整型byte（1字节）、short（2字节）、int（4字节）、long(8字节)

★布尔型boolean（1个字节）

★浮点型float（4个字节）、double（8个字节）

★字符型char（2个字节）一个char可保存一个汉字。

注意：

★整型数据默认为 int 类型，如果使用long类型，则必须加后缀l或L，建议用L。

★浮点型数据默认为double类型，如果使用float类型，则必须加后缀f或F。当然也可以在double类型后添加后缀D或d。

★整型数据可以有三种，十进制，八进制（0为前缀），十六进制（0x为前缀）。

★整型数据、浮点型数据除零的问题（见后的除法运算）

★浮点型数据运算不精确的问题（如2.0-1.1不等于0.9）见后的BigDecimal类。

★特殊字符 \b退格 \n换行 \t制表符 \r回车 \\反斜杠等。

★boolean类型的取值只有true和false。

★在赋值语句中，默认类型为整型的无小数点整型文字值作为右操作数时，可以将其赋值给取值范围比整型小的变量，如byte，前提是文字值对应的实际型数值在变量类型的取值范围内。而默认的double型的数据文字值不能赋给float类型。

（2）strictfp关键字

对于浮点型数据参与的运算，有可能由于处理器的不同而造成的结果的不同，比如Intel的处理器在处理浮点型数据的时候会把其转为80位浮点，而有些处理器则会按照64位浮点来运算，解决方法：strictfp关键字。

strictfp的意思是FP-strict，也就是说精确浮点的意思。在Java虚拟机进行浮点运算时，如果没有指定strictfp关键字时，Java的编译器以及运行环境在对浮点运算的表达式是采取一种近似于我行我素的行为来完成这些操作，以至于得到的结果往往无法令人满意。而一旦使用了strictfp来声明一个类、接口或者方法时，那么所声明的范围内Java的编译器以及运行环境会完全依照浮点规范IEEE-754来执行。因此如果想让浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，那就请用关键字strictfp。

可以将一个类、接口以及方法声明为strictfp，但是不允许对接口中的方法以及构造函数声明strictfp关键字。

一旦使用了关键字strictfp来声明某个类、接口或者方法时，那么在这个关键字所声明的范围内所有浮点运算都是精确的，符合IEEE-754规范的。例如一个类被声明为strictfp，那么该类中所有的方法都是strictfp的。

在JDK5中，有一个https://www.360docs.net/doc/e29143092.html,ng.StrictMath类来代替https://www.360docs.net/doc/e29143092.html,ng.Math类，就是因为Math的浮点运算会产生精确性问题。

（3）、JAVA中的变量初始化

★对于成员变量来说，系统会有默认的初始化：

byte 0、short 0、int 0、long 0L、

float 0.0f、double 0.0d、char \u0000

boolean false

★对于局部变量（定义在方法中的变量）则必须显式初始化，否则编译会出错；且局部变量只能在该方法体内使用，不能跨方法访问。可在不同的方法中声明同名的局部变量。★对于数组元素，不论是基本类型的数组还是引用类型的数组，其都会默认初始化（同上）（4）、JAVA中基本数据类型的转换：

自动转换：是系统根据转换规则自动完成的，在编译期完成，基本类型的自动转换在赋值、方法调用和算术运算3中情况下都会发生。

规则如下：

双操作数

★如果两个操作数中有一个是double类型的，则系统先将另一个操作数的数

值转换为double型的，然后再运算，否则

★如果两个操作数中有一个是float类型的，则系统先将另一个操作数的数值

转换为float型的，然后再运算，否则

★如果两个操作数中有一个是long类型的，则系统先将另一个操作数的数值转

换为long型的，然后再运算，否则

★两个操作数都将被转为int类型进行运算。（低于int的类型会自动提升）

★如果采用+=、*=等缩略形式的运算符，则系统会强制将运算结果转换成目标

变量类型。

单操作数

★++、--运算对于byte、short、char类型来说不会提升数据类型到int，且运算结果类型也不变。

★取正（+）、取负（-）、取反（~）时，如果是byte、short、char类型，则会先被提升为int类型，再参与算术运算。

★如果操作数为long或int型，无论何种单目操作都不会发生类型转换，且运算结果类型不变。

实箭头表示转换不会丢失精度，虚箭头表示转换会丢失精度

基本类型的造型（强制类型转换）

基本类型的造型是指程序员明确地声明，需要把取值范围宽的类型转换为取值范围窄的类型，如果没有明确使用 (类型) 造型声明，则会出现编译错误。强制类型转换（造型）发生在运行期。

注意：布尔类型数据和其他类型数据无法互相造型。

如果想转换的话可以采用条件表达式(boolean b)?1:0。

造型的结果可能引起精度的丢失。

此外还要注意超过数据类型范围的造型造成的是结果的改变。

如byte b = (byte)300;其最终的值是44。

5、JAVA中的运算

单目运算：++、--、取正+、取负-、按位取反~、逻辑取反！、造型()

其中++运算要注意：++在前，先加再赋值；++在后，先赋值再加。（--类似）

取负（-）对象最好用括号括起来。

算术运算：+加法、-减法、*乘法、/除法、%取模

★加法/减法：

当基本类型数据做运算时，如果+或-两边是byte、short、char时，会自动转换为int类型，其他情况取决于两个操作数中取值范围较宽的类型。

注意：在JAVA中 byte b += 10是可以通过编译的，但是byte b = 10 + 10是不能通过编译的，要改为byte b = (byte)(10 + 10);

当加减运算产生的结果发生数据溢出时，不会抛出ArithmeticException.只是会出现精度丢失现象。

+号的另一个功用：当加号两边至少有一个操作数为字符串时，+号起的是连接作用。

例如：1+ ”a” + 2的结果是1a2;1+2+”a”的结果是3a;”a”+1+2的结果则是a12; ★乘法：

当*号两边的数据类型为char、byte、short时，其均会自动转为int类型，除此以外运算的结果取决于两个操作数中取值范围较宽的类型。

当乘法运算产生的结果发生数据溢出时，不会抛出ArithmeticException.只是会出现精度丢失现象。

★除法：

当/号两边的数据类型均为整型时，结果为整型（不管能否除尽）。如：7/2结果为3。

当/号两边的数据有一个是浮点类型时，结果为浮点类型。

如果左操作数为整型，当/号的右操作数为0时，则会抛出算术异常。

如果左操作数是浮点型，当/号的右操作数为0时，不会抛出算术异常

对于浮点型数据，即使/号的右操作数为0，也不会抛出算术异常。

其常见的结果有三种Infinity;-Infinity;NaN

其中NaN的情况有0.0/0、0.0/0.0、0/0.0

Infinity的情况为2.0/0

-Infinity的情况为-2.0/0

★取模：

取模运算的实质是用左操作数连续减去右操作数，直到相减的结果小于有操作数，此时的结果即为余数。

当取模运算中有负数作为操作数时，取模运算结果的符号取决于左操作数的符号。

如果左操作数为整型，当%号的右操作数为0时，则会抛出算术异常。

如果左操作数是浮点型，当%号的右操作数为0时，不会抛出算术异常

对于浮点型数据，即使%号的右操作数为0，也不会抛出算术异常。

例如：2.0%0、-2.0%0、0.0%0、0%0.0、0.0%0.0的结果均为NaN

移位运算：

JAVA中提供了三种移位运算：左移(<<) 右移(>>) 无符号右移(>>>)

移位运算的操作数只能是整型char、byte、short、int、long

左移<<：在低位补零，高位舍弃，其实质相当于 *2

右移>>: 如果值为正，则在高位补零，低位舍弃，如果值为负，则在高位补1，低位舍弃，相当于 /2

无符号右移>>>：不论正负与否高位均补零，低位舍弃。

移位运算要注意：对于移动位大于该数据类型位数的时候，先取模再移位。

例如：对一个int类型的数据左移33位相当于左移1位。

比较运算：

JAVA中的比较运算有<小于、>大于、<=小于等于、>=大于等于、==等于、!=不等于字符char类型可以和其他类型进行比较，因为每一个字符都对应一个标准字符码。

此外还有一个特殊的比较运算符instanceof，用于在运行期检测对象的所属的类型，左操作数为一个对象引用表达式，通常为一个引用变量或数组元素，可以取值

为null，返回为false，不会抛出任何异常。右操作数必须为一个类、接口、

数组，但不能是https://www.360docs.net/doc/e29143092.html,ng.Class或者代表类名称的字符串对象。

例如：下述代码均返回true

JButton[] buttons = new JButton[5];

System.out.println(buttons instanceof Object);

System.out.println(buttons instanceof Component[]);

System.out.println(buttons instanceof Object[]);

位运算：

JAVA中的位运算有按位与&、按位或|、按位异或^、按位非~

★按位与&：当两个操作数的对应位均为1时，结果为1，否则为0；

★按位或|：当两个操作数的对应为均为0时，结果为0，否则为1；

★按位异或^：当两个操作数的对应为相同时结果为0，不同时结果为1；

★按位非~：一元运算，输入为0，输出为1，输入为1，输出为0；

★除了按位非~之外其余的三种运算都可以使用布尔类型。这里有个奇怪的现象，就是使用布尔类型在进行其他三种运算时，布尔值true对应位的值为1，

false对应位的值为0，

当boolean按位与时，都是true结果才为true;

当boolean按位或时，都是false结果才为false;

当boolean按位非时，相同为false，不同为true；

注意：位运算的对象只能为整型数据（实际上只能是int或long，其余的自动类型转换了）。布尔类型和其他基本类型数据间不能进行位运算。

根据计算机中二进制正负数之间的关系，按位取反运算可以采用取负减一法，即~i = (-i)-1此种变换适于计算操作数很大的情况。

逻辑运算：

JAVA中提供了&、|、&&、||、!五种逻辑运算。

★&&运算符为短路运算，只要第一个值为false就不会去做后面的运算而直接将整个表达式的结果赋值为false。

★||运算为短路运算，只要第一个值为true就不会去做后面的运算而直接将整个表达式的结果赋值为true。

条件运算：

?表达式1:表达式2

如果boolean表达式结果为true，输出表达式1的内容，否则输出表达式2的内容，相当于一个简化版本的if…else语句。

赋值运算：

JAVA中的赋值运算有=、+=、-=、*=、/=、%=、^=等，只需注意一点：左操作数必须是个变量。

赋值运算的核心在于数据类型转换。

运算符优先级

6、JAVA中的流程控制

（1）、顺序结构：按照语句出现的先后顺序依次执行的程序结构。

（2）、分支结构：

★if……else结构，标准形式如下：

if(boolean_condition_expression){

Statement_block;

}else{

Statement_block;

}

if……else结构可以是最简单的if形式，

也可以是复杂的嵌套形式if……else if……else形式。

注意：在多个if存在的情况下，else和最近的一个if配对。（建议使用{}）

★switch结构，标准形式如下：

switch(n){

case 0: statement;break;

case 1: statement;break;

……

Default:statement;

☆n为选择因子，如果和后面的某个case匹配成功，就执行其后的语句，直

到遇到break退出，如果一个case语句后没有break语句，那么意味着它

会继续按顺序执行之后的每一个case语句直到遇到break退出或所有的

case语句执行完毕为止。

☆JAVA中n的类型只能为byte、short、char、int和Enum类型。

☆case语句后与选择因子n匹配的数必须是常量。

☆default语句不是必须的，其也可以放在switch结构的任意位置，一般

放于尾部。按照JAVA的约定,如果switch语句中的选择因子n和所有的

case均不匹配时会执行default语句，要注意的是，如果default语句不

是放在整个结构的最后，那么执行完default语句后，后面的case语句还

是会被执行。

（3）、循环结构

JAVA中提供了三种循环结构：while、do…while、for

其中JDK5.0提供了增强的for循环，用于遍历数组和集合。

★while(boolean_condition_expression){

repeated_statements_block;

}

★do{

repeated_statements_block;

}while(boolean_condition_expression);此处的分号要小心

对于do…while循环来说，其至少会执行一次。

★for(init_statement;condition_expression;span_statement) { repeated_statements_block};

for循环执行时，首先执行init_statement，然后进行条件判断，条件为true

时执行repeated_statements_block，然后执行span_statement语句。

之后判断条件是否满足，满足的话继续执行repeated_statements_block

代码，然后再执行span_statement语句，如此循环下去，直到条件不满足停

止循环。

在init_statement部分可以同时初始化多个变量，其声明格式为：

DataType var1 = value1,var2 = value2……（严格遵守）注意：for(double x = 0; x != 10; x += 0.1)这样的循环是无限循环。

★foreach结构

for(declaration : expression)前面的声明是一个变量，其类型与

数组或集合内元素的类型兼容，表达式是将要遍历的数组或集合。

JAVA中使用break和continue来代替C/C++中goto的作用。

★break：单独使用break语句时，表示跳出当前循环，继续执行其他语句。

配合标签使用（标签的格式为Label:只能放于循环体之前）时，跳到

标签位置继续执行其他语句。

★continue：单独使用continue语句时，跳出外层循环起始处，从外层循环

开始循环。

配合标签使用时，表示调到标签之后，从标签处开始执行循环。

对于for循环来说，continue语句其实直接跳到了span_statement处。

（单一循环）

break和continue 的用法

7、数组

（1）、JAVA中的数组是一个具有相同类型元素的有序集合，数组中每个元素的类型相同，并且与数组声明的类型一致。

（2）、使用一个数组必须采取三个步骤：声明数组、创建数组、初始化数组。

（3）、声明数组的方式：Datatype[] arrayName或者Datatype arrayName[] 需要注意的是：声明数组的时候并没有给数组分配内存空间。

（4）、创建一个数组就是根据数组的大小为数组分配内存空间，JAVA中规定在构造数组的时候必须指定数组的长度，语法为new Datatype[size];

（5）、指定一个数组大小可以有两种方式：采用变量指定，采用明确的数字指定，由于数组长度直到运行期才被使用所以采用第一种方式优于第二种方式。但是要注意，采用变量指定数组大小之后，数组的length不能再改变。

（6）、JAVA中数组的长度只能是byte、short或int类型，不能为long和浮点型。（7）、数组的初始化方式有两种：

静态初始化，如int[] array = {1, 2, 3};(此种初始化必须将其元素全部初始化，不能出现这样的情况int array = {1,,3};否则编译会出错)。

动态初始化：如int[] array = new int[2];int[0]=1;int[1]=2; （8）、数组也可以默认初始化，初始化的值和成员变量初始化完全相同，而且不论数组是成员变量还是局部变量，数组均可默认初始化。

（9）、数组拥有属性length，length可以为0，数组的下标为[0,lenth-1]。（10）、虽然数组长度不能改变，但是可以改变数组的内容（改为同类型的）。

（11）、匿名数组（Anonymous Array）:new int[] {17, 19, 23, 29, 31, 37 }; 第二章：面向对象编程(OOP)

1、面向对象基础

（1）、面向对象强调数据结构第一，算法第二，而面向过程强调算法第一，数据结构第二。（2）、封装（Encapsulation）就是对属性和方法的载体类的访问只能通过其提供的接口（方法）来访问，把实现细节隐藏起来。也就是说，具体实现对程序员来说是透明的。

★封装的好处在于对类内部的改变不会影响到其他代码。

★封装的实现：将成员变量定义为private，而访问这些变量的方法定义为public。

★封装是程序重用（reuse）和可靠 (reliability)的关键。

（3）、继承（Inheritance）

★当继承一个类的时候，不仅可以继承行为（方法），还可以继承数据（成员变量）。

私有的数据成员和方法不能被继承。

★JAVA中所有的类都是Object类的子类。

★虽然子类继承了父类的成员变量，但是对于父类私有的成员变量，子类并不能直接访问。

（4）、多态（polymorphism）:指子类和父类具有同名的重写方法，并且允许父类引用指向子类对象，即允许把一个子类对象赋予一个父类的引用型变量。在运行期由系统自动判定应该调用子类的方法还是父类的方法。多态是运行期行为。

动态绑定：Automatically selecting the appropriate method at runtime is called dynamic binding

动态绑定的执行过程：

编译器首先会找到子类与父类中所有的和被调用方法的方法签名相同的方法。

注意，父类中只找public的。

编译器会自动进行重载方法判断（如果存在重载方法）。

JVM在运行时根据实际的对象类型调用其方法。

静态绑定：If the method is private, static, final, or a

constructor, then the compiler knows exactly which method to call. This is called static binding.

注意：多态性只存在于方法之上，如果父类对象的引用指向子类，调用方法时调用的是子类的重写方法，调用属性时调用的是父类的属性（指的是父类与子类存在

同名的属性时，不过这样的可能性不大，因为只有属性为public时才能测试通过）。

注意：当父类对象指向子类引用时，只能调用父类中已有的方法，不能调用子类中新添加的方法，虽然其实际类型是子类。

这里有个经典的例子：

假设有Employee类，其有子类Manager类。

Manager[] manangers = new Manager[2];

Employee[] employees = manangers;

Employees[1] = new Employee();

编译通过，运行时会抛ArrayStroeException。因为多态是运行期行为。

但这样是正确的：

Employee[] employees = new Employee[2];

Employees[0] = new Manager();

因为两个数组其实指向的都是同一个Manager数组，这个数组中存放的是

Manager对象。

（5）、对象（Objects）：对象具有三个特征——行为、状态和特性。

注意：Date date = new Date();这里的date不是对象，而只是对象的引用。（6）、类（Classes）

★类之间的关系：

依赖关系Dependence (”us es–a”)：如果一个类的某个方法使用了另一个类的对象，我们称前者依赖后者，那么这两个类之间存在依赖关系。如Person

类中有一个transport方法要求传入一个Car类的对象，即Person要

使用Car运输，那么Person类就依赖于Car类

聚集关系Aggregation (”has–a”) ：指的是一个类中包含有另一个类的对象，如Book类里面包含有Date类。聚集是通过把一个类定义为另一个类的

属性来实现的。

继承关系Inheritance (”is–a”)：指的两个类存在继承关系，如Student类和Person类之间就是继承关系。

（7）、内聚(cohesion)和耦合（coupling）

内聚和耦合是OOD的两个概念。具备良好质量的OOD应该达到高内聚、低耦合的要求。高耦合、低内聚会降低软件系统的稳定性、可扩展性、可复用性。

★内聚——一个类内部组成具有单一、明确目标的程度。高内聚是一种理想的状态，其中类成员支持单一、明确的角色或职责。

★耦合——一个类和另一个类联系的紧密程度。低耦合是一种理想的状态，通过设计良好封装的类，把类与类之间的相互吸引减至最低，一个类内部的改变不会波及到其他类的变动。

UML中关于类关系的描述

（8）、JavaBean组件

JavaBean组件是具有属性的JAVA类，其属性一般为private的。因为属性是私有的，因此从类外访问属性的唯一方法就是通过类提供的非私有方法。JavaBean

组件中更改属性值的方法成为setter方法，获取属性的方法成为getter方法。

命名原则：public void set+属性名首字母大写（参数）。

public (set方法参数的类型) get+属性名首字母大写（）。

布尔类型，可设置为is+属性名首字母大写。

Public是必须的。

扩展：对于JAVA中Listener的命名规则:

对于添加Listener addXXXListener(XXX监听器);

对于删除Listener removeXXXListener(XXX监听器类型);

（9）、构造方法（Constructors）

★构造方法和类名相同。

★构造方法在一个类中可以有一个或多个（即使不写构造方法，系统会有默认的无参构造方法，但如果自定义了带有参数的构造方法，系统不会再创建无参构造器。）★构造方法可以包含0个或多个参数。

★构造方法没有返回类型。

★构造方法只有new关键字能调用。

★构造方法的修饰符只能由public和private修饰。

★构造方法不能被继承。

★构造器可以抛出异常，如果父类的默认无参构造器抛出了异常，那么子类的默认无参构造方法必须处理父类抛出的异常。

★对于子类的构造方法，如果没有调用子类的其他构造方法，那么其必须调用父类的构造方法，默认会调用父类的无参构造方法，如果父类没有无参构造方法，那么

子类必须显式调用父类的其他构造方法（super），否则编译出错。

★构造方法的执行过程为：构造器直接调用其父类构造器，其父类的构造器再调用它的父类的构造器，直到调用Object类的构造器为止。

★接口没有构造器，抽象类的构造器在其实现类实例化时被调用。

（10）、接口（interface）[抽象类见后的abstract关键字]

★接口是一个纯的抽象类。接口的语法为interface interfaceName{}。

★接口默认的声明为public abstract，因为其必须要由实现类实现。

★接口中包含的方法全部为public abstract修饰的方法，其均没有方法体。

★接口中定义的属性全部为public static final修饰的属性，其均为常量。

★接口实现通过implements关键字。实现类必须重写接口中所有的方法，否则只能将接口的实现类必须声明为抽象类。

★接口可以继承接口，通过extends关键字实现，且可以继承多个接口，逗号分开。

★接口中的方法不能被static、native、strictfp、final关键字修饰。

★接口不能继承其他的类。

注意：接口中的方法和常量可以有下面的声明方式(全部合法）

常量声明：(常量一旦声明不能重新赋值)

public static final int x = 1; public int x = 1; int x = 1; static int x = 1;

final int x = 1; public static int x = 1;

public final int x = 1; static final int x = 1;

方法声明：

void method();

public void method1();

abstract void method1();

public abstract void method1();

abstract public void method1();

（11）、引用类型的转换

★自动转换

引用类型的转换是由系统根据转换规则自动完成，不需要程序员显式声明不同类型数据之间的转换。转换在编译期完成。‘

引用类型自动转换在赋值、方法调用以及方法返回三种情况下均会发生。

合法的引用类型转换原则是指一个子类的对象可以被父类的引用变量所引用，其实质是继承概念的延伸，表达的是子类向父类的上溯转换。

类可以被转换为类和接口，不能被转换为数组。如果转换为类，则转换的目标必须是被转换类的父类；如果转换为接口，则被转换类必须使该接口的实现类。

接口可以被转换为类和接口，不能被转换为数组。如果转换为类，则转换的目标类必须是Object类；如果转换的是接口，则转换的目标接口必须使被转换接口继承的接口。

数组可以被转换为类，接口或数组。如果转换为类。则转换的目标类必须是Object 类；如果转换为接口，则接口必须是Cloneable或Serializable；如果转换为数组，则被转换数组元素类型必须是可被转换为目标数组的元素类型。

★强制造型（cast）

强制类型转换是指程序员根据造型规则明确地进行不同引用类型数据之间的转换。

如果没有造型语句(类型），则编译会出错。引用类型的强制造型分两步：编译期的语法检查和运行期的实际类型转换。因此可能出现编译通过而运行抛异

常的情况（ClassCastException）。

final类造型：final类可以被造型为非final类、final类和接口，但不能

被造型为数组。如果造型为非final类，则造型的目标非final类必须是被

造型final类的父类；如果造型为final类，则造型的目标final类和

被造型的final类必须是一个类，如果造型为接口，则被造型的final类总

是实现这个接口。

非final可以被造型为非final类、接口或数组。如果造型为非final类，则

被造型的非final类和目标非final类必须存在继承关系，但不要求造型顺

序；如果造型为接口，则被造型的非final类实现了该接口，如果造型为数

组，则目标数组必须是Object类。

接口可以被造型为非final类，final类和接口。如果造型为final类和非

final类，则目标类必须实现了此接口或Serializable接口，如果造型为

接口，则两个接口存在继承关系。

数组可以被造型为非final类或数组。如果造型为非final类，则被造型的数组必须是Object类；如果造型为数组，则被造型数组的元素必须可以造型为目标数组的元素类型。

注意一点：为了避免出现造型失败，造型前使用instanceof关键字进行检查（12）、方法重写(override)和方法重载(overload)

★重写：所谓方法重写是指父类中的一个方法在子类中获得重新定义，方法名、参数列表、返回类型均不改变。

规则：

重写方法必须和被重写方法具有相同的方法名、参数列表和返回值类型。

参数列表中要求数目、类型、顺序必须完全一致。

只有继承存在的情况下才能重写方法。

JAVASE5开始允许协变返回类型，即重写方法返回的类型是可以是被重

写方法返回类型的子类。

重写方法的访问控制修饰符的范围不能小于被重写方法。

重写方法抛出的异常必须和被重写方法一致或是其子类，或着不抛出。

注意：对于接口中的方法重写，其修饰符只能是public的。

注意：普通的成员方法的重写是一种多态行为，而静态方法实在类编译的时候就确定了，也就是说静态方法绑定到类，成员方法绑定到对象，即静态方法不能重写。

对于父类私有的方法来说，子类中如果有同样的方法不会构成重写。(即私有方法不

能被重写，因为重写依赖于继承，而私有方法不能被继承。)

★重载：所谓方法重载是指一个类中定义多个方法名相同，参数列表不同的方法，所谓参数列表不同指的是参数的类型、数目不同（二者之间有一个符合即

构成方法重载）。

规则：

重载方法必须拥有不同的参数列表，数目、类型、排列顺序三者有一即可。

重载方法在同一个类中定义。

重载方法的返回类型、访问修饰符以及抛出的异常均不能作为重载的判断

标准。

重载方法之间可以相互调用（指的是参数类型相同、数目不同的重载方法）。 Static关键字不能作为方法重载判定的标准。

（13）、Object类

★Object类是所有JAVA类的父类，如果一个类没有使用关键字extends继承一个类，其默认继承了Object类。

★equals()方法。equals()方法默认执行的是==的比较，参看Object类的源

码可知。因此要想实现自定义类的比较需要重写此方法自定义比较的规则。

在API中有几个类已重写了equals()方法，如String、Date和封装类。

equals()方法遵循一些原则：

自反性如果x不为null，x.equals(x)为true。

对称性 x.equals(y)为true，那y.equals(x)为true。

传递性 x.equals(y)为true,y.equals(z)为true，那x.equals(z) 返回值也为true。

一致性多次调用x.equals(y)结果均为true。

非空性如果x取值不为null，那么x.equals(null)为false。

equals()方法的一般写法：(以 Person类为例）

public boolean equals(Object object){参数只能是Object类if(this == object)return true;

if(object == null)return false;

if(this.getClass() != object.getClass())return false;

Person person = (Person)Object;

return ((https://www.360docs.net/doc/e29143092.html,).equals(https://www.360docs.net/doc/e29143092.html,))

&& (this.age == person.age);

}

上面代码中的getClass()可以用instanceof测试。但不推荐使用instanceof。

假设有一个Employee类和一个Manager类，后者继承自前者，分别有两个类的

对象e和m，假设他们有相同的名字、薪水和入职日期。现在有e.equals(m)，

如果使用(m instanceof e)来判断，肯定为true，但是根据equals对称性

原则，要求m.equals(e)的返回结果为true，这时的(e instanceof m)返

回的要么是false要么抛出异常。

如果子有自己判断equals相等的原则，那么对称性原则要求强制使用getClass();

如果子类使用父类判断equals相等的原则，那么为了使不同子类之间的equals比较能够进行，可以使用instanceof来判定。instanceof superclass。

public boolean equals(Person person)这个不叫方法重写。

★hashCode()方法，其主要作用是配合equals()方法来使用。

重写equals()方法是必须重写hashCode()方法。因为两个对象如果用

equals()方法比较相等的话，那么他们的hashCode()方法返回值也

必须相等。

如果两个对象的hashCode(()方法返回值不相等，则两个对象的equals()

方法比较返回false，即两个对象一定不相等，

如果两个对象equal()方法返回值为false，则两个对象的hashCode()

方法返回值并不一定要求一定不相等（即其hashCode可以相等）。

hashCode()方法遵循原则：

多次调用x.hashCode()的返回值均是相等整数。

hashCode()方法在重写是根据equals()方法比较的内容重写：

如Person的hashCode方法重写为:

public int hashCode(){

return 7 * name.hashCode() +

13 * new Integer(age).hashCode();}

★toString()方法:返回的是该对象的字符串表示。

只要对象和一个字符串通过 + 号进行连接的话，会自动调用该对象的toString()方法。★对于一维数组对象，调用的是Arrays.toString(arrayName)方法进行打印。

★对于多维数组对象，调用的是Arrays.deepToString(arrayName)方法进行打印。

子类中对于父类的equals()、hashCode()、toString()方法的重写是通过super 调用父类中的equals()、hashCode()、toString()方法再加上子类自己添加的内容（这里假设父类已重写了Object的equals()hashCode()和toString()方法）。

★clone()方法：protected修饰，用于拷贝对象，所有使用clone()方法的

类都应该实现Cloneable接口（数组除外）。

浅克隆：如果一个类中不包含引用类型的属性（如Date类型的属性），那么使用

super.clone()方法可以实现该类对象的拷贝。

深克隆：如果一个类中包含引用类型的属性，那么该类的每个引用类型的属性也必须分别调用clone()方法才能保证对该类对象实现正确的拷贝。

假如有一个员工类：其有String类型的name属性和Date类型的hireDate

属性。那么如何对其进行clone呢？首先Employee类必须实现Cloneable

接口，然后重写里面的clone方法。

public Employee clone(){

Employee cloned = null;

try{

cloned = (Employee) super.clone();

cloned.hireDay = (Date) hireDay.clone();

}catch(CloneNotSupportedException e){

e.printStackTrace();

}

return cloned;

}

对于任何数组对象，其clone方法都是public的。

int[] luckyNumbers = { 2, 3, 5, 7, 11, 13 };

int[] cloned = (int[]) luckyNumbers.clone();

cloned[5] = 12; // doesn't change luckyNumbers[5]

2、JAVA关键字

（1）、this关键字

★this关键字代表了当前对象，即this关键字引用的是当前创建的类实例对象的句柄。如this.方法名，this.属性名。

★this关键字可以用在构造器中，表示调用该类的其他构造器，以避免代码重复。语法形式为this(...)。其必须在构造器的第一行。但是不能调用自身。

★this关键字用于构造方法时，不能同时使用super关键字。

★this关键字也可以用于调用本类的其他方法。this.方法名。

★this关键字不能用于static方法内。

（2）、super关键字

★Super关键字代表了父类对象，即super关键字引用的是房钱创建的类实例对

象的父类的句柄。

★super关键字可以用在构造器中，表示调用父类的构造器（如果子类没有调用其他的构造器，也没有显式调用父类的构造器，其默认调用的是父类的无参构造

器，如果父类没有无参构造，那么编译出错）。语法形式为super(...)。其

必须位于构造器的第一行。

★super关键字用于构造方法时，不能同时使用this关键字。

★super关键字也可以用于调用父类的普通方法。super.方法名。

（3）、abstract关键字

★abstract关键字只能修饰类和方法，不能修饰变量，因为该关键字表明的是未

实现的含义，而属性不存在未实现。

★abstract关键字修饰的方法为抽象方法，其不包含方法体。

★abstract关键字修饰的类为抽象类。抽象类可以不包含抽象方法，但是含有抽

象方法类一定要声明为抽象类，抽象类也可以包含非抽象方法。

★子类继承抽象类，必须完全实现其所有的抽象方法，否则子类只能声明为抽象

类。当一个类实现一个接口时，必须完全实现接口内所有的抽象方法，否则也

必须声明为抽象类。

★抽象类有构造方法，但是不能直接调用，否则编译出错。抽象类不能被实例化。

根据多态性，抽象类可以指向其实现类。

★抽象类不能被final修饰符修饰，因为抽象类需要子类继承实现，而final修

饰的类是不能被继承的。

★抽象方法不能被声明为final的，也不能被private修饰符修饰，因为抽象方

法需要被子类继承而实现，而final修饰的方法和private修饰的方法是不能被继承的。

（4）、final关键字

★final关键字可以修饰类、属性、方法，表示该修饰的对象具有不可变性。

★final修饰基本数据类型的变量为一个常量，其值是只读的。Final修饰的变量必须在使用前被初始化，三种初始化方法：声明后直接赋值；构造方法中赋值；

静态语句块中赋值。

★final修饰引用变量，表示该变量一旦分配给一个值就不能再改变，即该变量一旦引用了一个对象后，再也不能引用其他对象，更不能将其他对象的句柄赋值

给它。但是可以改变final变量所引用对象的内容。

★final修饰符位于方法前，表示该方法不能被子类重写，但是可以被重载。

★final修饰符位于类前，表示该类不能被继承，声明为final的类，其所有的

方法默认为final的，但是属性不是final的。

★final修饰符是唯一可以用于方法局部变量的修饰符。

（5）、native关键字

★native关键字只能用于修饰方法。一个在方法名前加上native关键字的方法

为本地方法，其目的是利用本地资源来扩展JAVA功能，与JAVA的机制无关。

★本地方法如同抽象方法，没有方法体，因为对本地方法的实现，不是JAVA语言，而是采用依赖于本地平台的其他语言编写的代码来实现的，它们位于JVM之外，可以通过System.loadLibrary()方法载入，其通常放在静态代码块

中来装入本地方法，如果System.loadLibrary()方法没有载入成功，会

抛出UnsatisfiedLinkError。

★Object类中的clone和notify方法都是本地方法。

★本地方法可以被private修饰符修饰。

（6）、static关键字

★static关键字不能修饰顶层类，可以修饰内部类。可以修饰属性、方法、代码块。

该修饰符表明所修饰的对象属于类范畴，而非类实例。

★static关键字修饰的类属性有两种引用方式，类名.属性名；或者对象名.属性名。

推荐使用前者，因为后者可读性不好。

★类的静态属性被整个类所共享，因此，任何一个类实例改变了属性的值，所有类的实例拥有的这个属性值都会同步改变，其不能被序列化。

★方法中声明的变量不能是静态的，因为方法中声明的变量是局部的。

★static修饰的方法除了可以访问其内部定义的变量外，只能访问被static修饰符所修饰的静态变量。如果需要访问非静态的属性，则必须通过对象.属性

的方式。

★对于静态方法和非静态方法的调用方式是不同的。对于非静态方法的调用是在运行期决定的，而对静态方法的调用是在编译期决定的。

★静态代码块主要用于初始化，该代码块只被执行一次，即首次装载类时被执行，如果存在多个静态代码块，那么按照出现的先后顺序被执行。相反，非静态代码

块每次创建新对象时均会执行。

辨析：静态方法和非静态方法

静态方法：可以直接访问本类的静态属性，其他的静态方法，可以在其内部声明非静态变量，但不能声明静态变量，静态方法中不能使用this和super关键字。

非静态方法：不能声明静态变量，可以声明非静态变量，可以调用本类的所有方法（包括静态和非静态），可以调用本类的所有属性（包括静态和非静态）。

经典代码：

public class Hello{

static{

System.out.println("Hello, World");

}

}不写main方法的HelloWorld,但是在输出之后会报错。晕死~~~

（7）、transient关键字

★transient关键字只能修饰属性，表示该变量不能被序列化。

★一个变量一旦被transient修饰，表明其不再是对象持久状态的一部分，该变

量的内容在序列化后，无法获得访问。

★transient关键字的作用是保证变量的安全性，即使是private变量，在序列化的时候可以通过读取文件或拦截网络传输来得到。

（8）、访问权限修饰符(public、protected、default、private)[不考虑内部类]★访问权限修饰符不能修饰局部变量，只有final可以修饰局部变量。

★一个属性或类只能有一个访问权限修饰符。

★public修饰符可以修饰类、属性、方法、构造方法。

★public修饰符访问权限最大，其修饰的类、属性、方法可以在任意位置被访问。

★protected修饰符可以修饰属性、方法、构造方法。

★protected修饰符修饰的属性、方法只能被本类或本类的子类访问，即使子类在不同的包中。(同一个包中的类也可以访问)

★default修饰符(默认没有修饰符)可以修饰类、属性、方法、构造方法、代码块。

★default修饰符修饰的类、属性、方法等只能在本包中被访问。

★private修饰符可以修饰属性、方法、构造方法。

★private修饰的属性、方法只能被本类访问

注意：访问范围控制从类到成员，如果类不可见，其成员不管被任何访问修饰符所修饰，均不可见。即要确定成员的可见性，首先要确定类的可见性。

如果类A和类B在不同的包中且访问修饰符均为default，假设A是B的

父类，即使导入了A，编译依然不会通过。而且也不能声明返回类型为A

的方法或A类型的变量（A和B无继承时也成立）。

关于protected的奇怪之处：

package parent

public class Parent{

protected int x = 3;

}

package child

public class Child extends Parent{

public void test(){

System.out.println("x is " + x);--->正确

Parent parent = new Parent();--->正确

System.out.println("parent's x is" + p.x);-->不正确

}

}

结论：protected访问权限只允许子类跨包访问，在子类中不允许使用父类的引用调用父类中的protected修饰的变量或方法。即子类可跨包访问，而父类

遵守的是default访问权限（即从包外访问protected修饰的变量和方法

只能通过继承实现）。此外，如果有一个类（Other）和子类处于同一个包中，

其中有子类对象的引用，子类对象的引用也不能访问父类中protected修饰

的变量或方法，这时的protected权限在子类中其实变成了private权限，

因此类外是不能访问的。

★protected = package + subclass

3、JAVA编程的几点建议

（1）、对于属性（数据）应该总是设置为private。

（2）、初始化所有的数据，包括成员变量和局部变量（尽可能不要依赖于默认初始化）。（3）、不是所有的属性都要求有setter和getter方法，如出生日期不需要setter。（4）、类内部的标准定义顺序

Public 属性---> default属性--->private属性

普通方法--->静态方法

（5）、对于方法、属性的命名要见文知意。

4、内部类（inner class）

（1）、内部类又称嵌套类，是指定义在一个类内部的类，内部类所在的类为外部类。内部类可以分为四种：静态内部类、普通内部类、局部内部类和匿名内部类。

（2）、对于内部类的引用：

如果是非静态的内部类，在外部类的外面引用的语法为

Outer.Inner in = new Outer().new Inner();或者是

Outer ounterObject = new Outer();

Outer.Inner in = outerObject.new Inner();

在外部类的内部引用的语法为：Inner in = new Inner();

如果是静态内部类，语法为：

Outer.Inner in = new Outer.Inner();

(3)、内部类的文件名：OuterClass$InnerClass.class;匿名内部类比较特殊，其文

件名为OuterClass$数字。

(4)、在JAVA中，对内部类的继承没有任何限制，满足单继承即可。也可以实现接口。

(5)、在JAVA中，对内部类的嵌套层次没有限制。

(6)、对于内部类，其如同类的其他成员一样，对整个类具有访问权限，可以访问所在类的

所有属性、包括私有属性。即使是定义在一个方法中的内部类，也可以访问这些类

的成员属性。一个内部类附属于外部类的。

(7)、静态内部类（static inner class):只能访问所属外部类中静态的成员变量。

静态内部类实际上是外部类的静态成员。