Java知识点总结.doc

JAVA知识点总结
1．JAVA的特点：
简单易用、完全面向对象；
与平台无关性、可扩展性强；
可移植性高、支持分布式编程；
健壮、安全可靠并性能优异；
支持多线程开发技术；
支持动态开发。
2.JVM：Java虚拟机（JVM是Java实现跨平台的基础）。
Java的源程序（*.java） 编译（命令：java+文件名.java） Java字节码（*.class 编译时自动形成，与源程序名一致) 运行（命令：java+源程序的文件名） JVM（Windows、Linux)
开发工具，Javac及基础核心类
JDK
运行环境，Java及基础核心类
3.编写第一个Java程序：
Java源文件扩展名为：”.java”
一个源文件中最好只有一个java类，但是可以包含多个类
public修饰的类，文件名与类名必须一致(包括大小写)
被运行的类中需要有一个方法：
public static void main(String[ ] args){}
一个源文件中最多有一个public修饰的类
例如：public class Test{
public static void main(String args[]){
System.out.println(“这个编写的第一个java程序！！！”);
}
}
在运行程序之前先配置环境变量：
path变量值为：JDK安装目录下\bin;
classpath变量值为：JDK安装目录下\lib; 或 .;JDK安装目录下\lib\tools.jar
在dos命令窗口中输入以下命令进行运行：
编译命令：javac Test.java
运行命令：java Test
生成文档命令：javadoc Test.java
4.Java编程规范
A、命名规定
包 ：包名应该是小写的名词。
如：package shipping.objects
类：类名应该是名词，大小写混合，每个单词的首字母大写。
如：class AccountBook
接口：接口名的大小写应该与类名一样。
如：interface Account
方法：方法名应该动词，大小写混合，首字母小写。每个方法名中，以大写字母区分单词。限制使用下划线。
如：balanceAccount( )
变量：所有的变量应该是大小写混合，首字母小写。由大写字母区分单词。限制下划线的使用。
如：currentCustomer
常数：基本类型常数应该是全部大写的由下划线区分的单词。
如：HEAD_COUNT、MAXIMUM_SIZE、MIN_VALUE
B、程序主体结构规定
控制结构：所有语句，即使是一条语句，如果是某控制结构的一部分，都要使用大括号（{ }）括起来。
空格：在任意行上只放置一条语句，并且使用2或4个空格缩进使代码更易读。
Java代码的位置：所有代码都存在于一个类里
例如：修饰符 class 类名
{
程序代码
}
注意：
Java是严格区分大小写的；
功能执行语句以(;)结束，这个分号必须是英文输入法中的(;)；
连续的字符串不能换行，可使用(+)连接。
5、Java代码的注释
作用：
1)、解释程序中某些部分的作用和功能，提高程序的可读性。
2)、可以使用注释暂时屏蔽某些语句，在程序调试时使用。
注释的形式：
1)、单行注释
int c = 10; // 定义一个整型
2)、多行注释
/*
int c = 10; // 定义一个整型
int x = 5;
*/
注意：/*…*/中可以嵌套”//”注释，但不能嵌套”/*…*/”。
3)、文档注释
“/** ...............*/”。
6、Java中的标识符
1)、变量，方法，类和对象的名称都是标识符，程序员需要标识和使用的东西都需要标识符。
2)、在Java语言里标识符以字母或下划线、$符号开头，后面字符可以是字母、数字、下划线、$符号。（其他符号都不能用来命名标识符）
3)、标识符对字母大小写非常敏感，必须区分大小写，但是没有长度限制。
4)、关键字不能用作标识符命名。
5)、标识符中不能包含空格。
6)、标识符是由Unicode字符组成的，因此可以使用汉字作为标识符(不推荐，尽量不用)；7、关键字
Java中一些赋以特定的含义、并用做专门用途的单词称为关键字，也可叫保留字。关键字不能作为普通的标识符使用。
所有Java关键字都是小写的，IF、THIS、NEW等都不是Java关键字；
goto和const虽然从未使用，但也作被为Java保留关键字；
关键字含义说明：
boolean:布尔值
byte:字节 false：布尔值假
char:字符类型 字面值 null:空
int:整型 true:布尔值真
基本数据类型
long:长整型
short:短整型 const
float:单精度型 保留字
double:双精度型 goto
void:无类型

abstract:抽象
private:私有
public:公有
static:静态
修饰符 final:定义常量
native:Java调用别的语言（C++）程序时使用
volatile:短暂
transient:短暂
synchronized:处理线程是使用
try:异常处理 break:退出循环
catch:捉异常 case:流程控制语句
异常处理 finally:无论有没有 continue:循环继续
throw:抛出异常 default:缺省
throws:抛出异常 do:循环语句
控制语句 while:循环语句
class:类 if:条件语句
extends:继承 else:条件语句
implements:实现接口 for:for循环语句
instanceof:引入包 return:返回
interface:判断一个对象是否属于某个类 switch:条件判断
面向对象 new:创建新对象
package:包
super:超类
this:自己

8、java基本数据类型
整数类型(byte, short, int, long)

数值型 浮点类型(float, double)

基本数据类型 字符型(char)

布尔型（boolean）

数据类型 类(class)

接口(interface)
引用(复合)数据类型
数组

字符串（String）

基本数据类型包括：整型、浮点型、字符型、逻辑型（布尔型）。
数据类型
名称
位长
默认值
取值范围
布尔型
boolean
1
false
true,false
字节型
byte
8
0
-128~127
字符型
char
16
‘\u0000’
‘\u0000’~‘\uffff’
短整型
short
16
0
-32768~32767
整型
int
32
0
-2147483648~2147483647
长整型
long
64
0
-9223372036854775808~9223372036854775807
浮点型
float
32
0.0
±1.4E-45~±3.4028235E+38
双精度型
double
64
0.0
±4.9E-324~±1.7976931348623157E+308
注意：
整数类型数据用于描述一个一定大小范围内的整数。
浮点类型数据用于描述一个范围很大的实数；
浮点类型数据有一定的精度限制。
字符类型为char，它用于表示一个字符,使用单引号’在 Java中char类型为16字节，采用Unicode表示。
逻辑类型为boolean，它用于表示真和假；boolean类型只有两个值真(true), 假(false)；
boolean类型有自己的运算，不能参与其他数据类型之间的运算。
9、常量
常量就是程序里持续不变的值，是不能改变的数据。
声明常量的格式如下：
final 类型 常量名[，常量名]=值；
Java中的常量包括整型常量、浮点型常量、布尔常量、字符常量等。
整型常量：
十进制：不能以0开头，多个0～9之间的数字
十六进制: 以0x或0X开头 0x8a 0X56d
八进制：必须以0开头 034 0376
长整型：必须以L结尾 87L 345L
浮点数常量：
float型：2e3f 0.6f
double型：4.1d 1.23d
布尔常量：true 和 false
字符常量： ‘a’ ‘5’
字符串常量：“hello” “8698” “\nmain” 转义字符\n表示换行
null常量：null，表示对象的引用为空。
10、变量
在java语言中存储一个数据信息，必须将它保存到一个变量中。变量在使用前必须有定义，即有确定的类型和名称。
声明变量的语法：
类型 变量名[, 变量名][=初值];
例如：int i； char c; float a, b, c;
变量的声明有三种形式：
1、 声明变量。
例如: int i;
2、 变量赋值。在变量赋值之前要先声明变量。
例如：int i;
i=5;
3、 变量的初始化。
例如：int i = 8;
11、基本数据类型之间的兼容性
基本数据类型之间的转换：“小”的数据类型可以直接赋给“大”的数据类型。“大”的不能赋值给“小”的数据类型（会出现编译错误）。
数据类型大小关系如下：
整数类：long > int > short > byte
浮点型：double > float
整型数据类型可以赋给浮点数据类型比如：
float short float int float long double long
注意：
char 可以赋给long和int ，但是不能赋给short 和byte（编译错误） 。
char 可以赋给float和double。
当整数型常量被声明为long类型时，只能赋值给long型变量。
当整数型常量在0~65535之间时，可以被赋值给char型变量。
char型常量可以被赋值给整数类变量，只要整数变量的类型可以容纳char型文字常量所表示的数值。
浮点型常量默认为double型，而double型常量不能赋值给float型变量。
boolean与其他数据类型没有兼容性。
12、数据类型转换
1、自动类型转换（隐式类型转换）
需要同时满足两个条件：
1)、两种类型彼此兼容
2)、目标类型的取值范围要大于源类型
2、强制类型转换（显示类型转换）
当两种类型不兼容，或目标取值类型范围小于源类型时，自动类型转换无法进行，需要进行强制类型转换。
数据类型强制转换的格式为：
（数据类型）数据表达式；
例如：int i = 5; byte b = (byte)i;
13、变量的作用域
变量的作用域指一个变量起作用的范围，它决定了一个变量何时可以访问、何时不可以访问。Java中任何变量的作用域都从该变量声明之后开始，并且只在该声明的语句块中使用，也就是该变量只能在声明它的那个花括号{}中使用。
变量有分为成员变量和局部变量。
成员变量：在类中声明的变量称为成员变量，又叫全局变量。
使用范围：通常在类开始处声明，可在整个类中使用。
局部变量：在方法或块（块由两个花括号）中声明的变量称为局部变量。
使用范围：从声明处开始到它所在方法或块的结束处。
例：
{
int x = 4;
//这之间只有x可以访问
int y = 1;
//x和y可以访问
{
int z = 2;
//x、y、z都可以访问
z = 5;
}
x = 4；
//只有x和y可以访问，不可以访问z
}
14、Java中的运算符
算术运算符、关系运算符、赋值运算符、逻辑运算符、位运算符、条件运算符
1)、算术运算符
运算符
运算
范例
结果
+
正号
+3
3
-
负号
b=4;-b;
-4
+
加
5+5
10
-
减
6-4
2
*
乘
3*4
12
/
除
5/5
1
%
取模（求余）
5%5
0
++
自增（前）
a=2;b=++a;
a=3;b=3;
++
自增（后）
a=2;b=a++;
a=3;b=2;
--
自减（前）
a=2;b=--a;
a=1;b=1;
--
自减（后）
a=2;b=a--;
a=1;b=2;
+
字符串相加
“he”+“llo”
“hello”
两个整数之间的相除（/）运算结果还是整数，其结果是除的结果的整数部分。
例如：5/2结果为2
要获得实数结果，运算中至少一个浮点数。
例如：5/2.0结果为2.5
2)、关系运算符
运算符
运算
范例
结果
==
相等于
4==3
false
!=
不等于
4!=3
true
<
小于
4<3
false
>
大于
4>3
true
<=
小于等于
4<=3
false
>=
大于等于
4>=3
true
3)、赋值运算符
运算符
运算
范例
结果
=
赋值
a=3;b=2;
a=3;b=2;
+=
加等于
a=3;b=2;a+=b;
a=5;b=2;
－=
减等于
a=3;b=2;a－=b;
a=1;b=2;
*=
乘等于
a=3;b=2;a*=b;
a=6;b=2;
/=
除等于
a=3;b=2;a/=b;
a=1;b=2;
%=
模等于
a=3;b=2;a%=b;
a=1;b=2;
4)、逻辑运算符
运算符
运算
范例
结果
&
AND(与)
false & true
false
|
OR(或)
false | true
true
^
XOR(异或)
false ^ true
true
!
NOT(非)
!true
false
&&
AND(短路与)
false && true
false
||
OR(短路或)
false || true
true
在使用短路与（&&）时，如果第一个操作数（或表达式）为“假”，则不再计算第二个操作数（或表达式），直接返回“假”。
在使用短路或（||）时，如果第一个操作数（或表达式）为“真”，则不再计算第二个操作数（或表达式），直接返回“真”。
逻辑运算符只能用于布尔（boolean）类型之间；其结果值为布尔（boolean）类型。
5)、位运算符
运算符
运算
计算规则
&
按位与
只有参加运算的两位都为1，‘&’运算的结果才为1，否则为0。
|
按位或
只有参加运算的两位都为0，‘|’运算的结果才为0，否则为1。
^
按位异或
只有参加运算的两位不同，‘^’运算的结果才为1，否则为0。
<<
左移位
左移指定位数，右边补0。
>>
右移位
右移高位是0，左边补0；高位是1，左边补1。
>>>
无符号右移位
左边补0。
～
按位取反
1取反是0,0取反是1。
位运算符只可用于整数类型、char类型，不可应用于浮点类型。
6)、条件运算符
条件运算符是一个三目运算符，也是唯一的一个三元运算符，符号为“? :”,在程序中能实现简单的判断功能。
语法格式：
表达式1?表达式2:表达式3
其中表示1是一个布尔表达式，如果表达式1结果为true，则执行表达式2，否则执行表达式3。
举例说明：求a，b的最大值。
int a=4,b=6,max;
max=a>b?a:b;//将a和b中的较大值赋给max
15、Java中的控制语句
（1） 、if(表达式)......else.......条件语句；
（2） 、for（表达式）....... 循环语句；
（3） 、while（表达式）....... 循环语句；
（4） 、do.....while(表达式）......循环语句；
（5） 、switch 多分支选择结构；
（6） 、continue 结束本次循环语句；
（7） 、break 终止执行switch或循环语句；
（8） 、return 从方法返回语句。
1、 条件语句
分为四种：
l 单分支条件语句
语法格式为：if(条件表达式){
语句或语句块；
}
l 二分支条件语句
语法格式为：if(条件表达式){
语句或语句块1；
}else{
语句或语句块2；
}
l 嵌套条件语句
语法格式为：if(条件表达式){
if(条件表达式){
语句或语句块；
}
}else{
语句或语句块2；
}
l 多分支条件语句
语法格式为：if(条件表达式1){
语句或语句块1；
}else if(条件表达式2){
语句或语句块2；
} ……
……
} else if(条件表达式n){
语句或语句块n；
}else{
语句0；
}
2、 for循环语句
语法格式为：for(变量初始化表达式；循环条件表达式；迭代部分)
｛
语句或语句块；//循环体
｝
for循环有一个特殊的循环，叫死循环。表现形式为：
boolean isOk = true; 或 for(;;){}
for(;isOk;){}
for循环可以再嵌套for循环。
注意：在for循环的初始化或迭代部分，可以有多个表达式，表达式之间用逗号隔开。例如： int count =0;
for(int a= 1,b=10;a<b;a++,b－－){
count++;
} 共循环多少次？
3、 while循环语句
语法格式为：while(循环条件 表达式)｛
语句或语句块；
｝
4、 do-----while循环语句
语法格式为：do{
语句或语句块；
｝while(表达式)；（注意分号绝对不能省略）

5、 switch-----case多分支选择语句
语法格式为：switch(条件表达式)｛
case 常量1:
语句1；
break;
case 常量2:
语句2；
break;
……
case 常量N:
语句N;
break;
[default:语句;break;]
}
注意：
l 条件表达式的返回值类型必须是以下类型之一：int、byte、char、short。
l case子句中的值常量N必须是常量，而且所有case子句中的值应是不同的。
l default子句是可选的。
l break语句用来在执行完一个case分支后，是程序跳出switch语句，即终止switch语句的执行。
l 在一些特殊情况下，多个不同的case值要执行一组相同的操作，这时可以不用break。
6、 continue结束本次循环语句
使用continue语句可以立刻重新开始下一轮的循环，而不再执行循环后面的语句。
7、 break终止执行switch和循环语句
使用break语句可以立刻终止循环，开始执行循环后面的语句。
8、 return从方法返回语句
return语句主要作用是退出当前方法，将程序控制转移到方法的调用者。
一般格式为： return [值或表达式]；
16、方法调用语句
方法调用语句是执行对象的某个方法。
一个完整的方法调用语句由某个方法调用加上一个分号构成。
调用语法格式为：类对象名称.方法名（参数）;
例如：
System.out.println(“This is a statement call a method!”);
调用对象System.out的println方法。
17、表达式语句
表达式语句就是由一个表达式加一个分号构成的语句。
例如常见的赋值语句：i=i+1;而i=i+1只是一个表达式。
18、空语句
空语句就是只有一个分号构成的语句。例如： ;
19、复合语句
复合语句又叫块，由{}将一些语句括起来就构成一个复合语句。
例如：{
a=b+c;
t=a*100;
}
20、数组
（1）定义：是用来存储一组或多组相同类型数据的数据类型。
（2）数据类型：可以是基本数据类型（例如：数字型、字符型、布尔型），也可以是复合数据类型（例如：数组、类、字符串和接口）。
※数组本身就是一种复合数据类型，因此，数组的元素也可以是数组，这样就构成了二维数组和多维数组。
（3）数组作为复合数据类型，与基本数据类型最大的区别：
数组是通过引用来控制的，而基本数据类型是通过值来控制的。
1、一维数组的声明：
格式： 类型 数组名[ ]; 或 类型[ ] 数组名;
举例：int a[ ]; String[ ] b;
数组的初始化有两种方法：一种是直接初始化，另一种是动态初始化。
l 直接初始化
格式： 类型 数组名[ ] = { 值1，值2，…，值n};
举例：int a[ ] = {1,2,3};
int b[ ]; b = {1,2,3};
l 动态初始化：
格式：
（1）声明时初始化：
类型 数组名[ ] = new 类型[ 数组长度];
（2）声明后初始化：
类型 数组名[ ];
数组名 = new 类型[数组长度];
2、访问数组元素
数组元素是通过数组名和下标来访问。未被初始化的数组，不能进行访问。
格式：数组名[下标]
Java中，数组的下标从0开始，直到 <数组长度-1>结束。
获得数组的长度，通过length属性来获得。
3、数组的复制
方法：
System.arraycopy(源数组,源数组起始位置,目标数组,目标数组起始位置,长度)；
★注：不管是要复制的数组，还是被复制的数组，都必须先初始化。
举例：
int a[ ] = {1,2,3}, b[ ] = new int[3];
System.arraycopy(a,0,b,0,3); //将数组a复制到b
4、对象数组：
举例：
//定义一个对象数组，StringBuffer是一个字符串缓存类
StringBuffer a[ ] = new StringBuffer[2];
//给对象赋值
a[0] = new StringBuffer(“Array[0]”);
a[1] = new StringBuffer(“Array[1]”);
System.out.println(“a[0]=” + a[0] + “ a[1]=” + a[1] );
a[0].append(“ is Modified”); //追加字符串
System.out.println(“a[0]=” + a[0]);
5、二维数组和多维数组
前面提到过，数组的元素也可以是数组，如果一个数组的每一个元素都是一个一维数组，这样就构成一个二维数组。
定义格式：类型 数组名[ ][ ]; 或 类型[ ][ ] 数组名;
举例： int a[ ][ ]; double[ ][ ] b;
这几种定义不合法：int a[2][ ]; int b[ ][2]; int c[2][2];
二维数组的初始化：二维数组的初始化也有直接和动态初始化两种方式。
l 直接初始化格式： 类型 数组名[][]= {{ 值1，值2，…，值n} ,{ 值1，值2，…，值n}....};
举例：int a[ ][ ] = {{1,2,3},{4,5,6},{7,8,9}};
l 动态初始化格式
类型 数组名=new 类型[长度1][长度2]； 长度1表示行，长度2表示列。
举例：int a[][]=new[3][5];
类型 数组名=new 类型[长度1][]；
数组名[0]=new 类型[长度20];
数组名[1]=new 类型[长度21];
……
数组名[长度1-1]=new 类型[长度2n];
举例：int a[][];
a=new int[3][];
a[0]=new int[5];
a[1]=new int[8];
a[2]=new int[6];
6、二维数组的应用
举例：两个矩阵相乘的例子。
//声明并初始化数组
int a[ ][ ] = {{8,13},{4,7},{5,2}};
int b[ ][ ] = {{3,4,11},{6,1,10}};
int result[ ][ ] = new int[3][3];
int i,j,k;
//通过嵌套循环实现矩阵相乘的运算
for(i=0;i<a.length;i++){
for(j=0;j<b[0].length;j++){
result[i][j] = 0;
for(k=0;k<b.length;k++){
result[i][j] += a[i][k] * b[k][j];
}
}
}
//打印结果
System.out.println(“The result of a * b is : ”);
for(i=0;i<result.length;i++){
for(j=0;j<result [i].length;j++){
System.out.print(result[i][j] + “ ”);
}
System.out.println( ); //换行 }
7、一维数组的应用
例1：将整数序列{3,15,28,11,34,78,95,27,18}首末颠倒过来。
int a[ ] = {3,15,28,11,34,78,95,27,18};
int i, length, temp;
length = a.length;
for(i=0;i<(length/2);i++){
//以下将数组元素a[i]和a[length -1 - i]的值互换
temp = a[i];
a[i] = a[length -1 –i];
a[length -1 –i] = temp;
}
for(i=0;i<length;i++){
System.out.print(a[i] + “ ”);
}
例2：从数据：32 25 78 69 13 97 86 38 62 9 中找到数据97所在的位置。
『用顺序查找（线性查找）方法编写程序』。
//声明并初始化数组
int a[ ] = {32,25,78,69,13,97,86,38,62,9};
int index = -1,i;
//逐个元素与97相比较，找到则退出循环，否则继续
for(i=0;i<a.length;i++){
if(a[i] == 97){
index = i;
break;
}
}
if(index == -1){ //表示该数不存在
System.out.println(“ 97这个数不存在！”);
}else{
System.out.println(“97这个数的下标是: ” + index);
}
例3：将数据：37 28 51 13 64为例，用『冒泡法』进行升序排列。
下面编写程序代码：(冒泡法)
int a[ ] = {37,28,51,13,64};
int i, j, n, temp;
n = a.length;
for(j=1;j < n ;j++ ){ //共执行 n－1 轮
for(i=0;i< n – j; i++){ //第j轮
if (a[i] > a[i+1]){
//交换a[i]与a[i+1]的值
temp = a[i];
a[i] = a[i+1];
a[i+1] = temp;
}
}
}
//打印排序后的结果
for(i=0;i < n;i++){
System.out.print(a[i] + “ ”);
}