Java知识点总结

JAVA知识点总结

1．JAVA的特点：

1简单易用、完全面向对象；

○2与平台无关性、可扩展性强；

○3可移植性高、支持分布式编程；

○4健壮、安全可靠并性能优异；

○5支持多线程开发技术；

○6支持动态开发。

○：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[]){

n(“这个编写的第一个java程序！！！”);

}

}

在运行程序之前先配置环境变量：

path变量值为：JDK安装目录下bin;

classpath变量值为：JDK安装目录下lib; 或 .;JDK安装目录下

在dos命令窗口中输入以下命令进行运行：

编译命令：javac

运行命令：java Test

生成文档命令：javadoc

编程规范

A、命名规定

包 ：包名应该是小写的名词。

如：package s

类：类名应该是名词，大小写混合，每个单词的首字母大写。

如：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

byte

char

short

int

long

float

位长 默认值

1

8

16

16

32

64

32

64

false

0

‘u0000’

0

0

0

0.0

0.0

true,false

-128~127

‘u0000’~‘uffff’

-32768~32767

-2147483648~2147483647

-9223372~9223372

±1.4E-45~±3.4028235E+38

±4.9E-324~±1.7976931348623157E+308

取值范围

双精度型 double

注意：

整数类型数据用于描述一个一定大小范围内的整数。

浮点类型数据用于描述一个范围很大的实数；

浮点类型数据有一定的精度限制。

字符类型为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

b=4;-b;

5+5

6-4

3*4

5/5

5%5

a=2;b=++a;

a=2;b=a++;

a=2;b=--a;

a=2;b=a--;

“he”+“llo”

3

-4

10

2

12

1

0

a=3;b=3;

a=3;b=2;

a=1;b=1;

a=1;b=2;

“hello”

两个整数之间的相除（/）运算结果还是整数，其结果是除的结果的整数部分。

例如：5/2结果为2

要获得实数结果，运算中至少一个浮点数。

例如：5/2.0结果为2.5

2)、关系运算符

运算符

==

!=

<

>

<=

>=

3)、赋值运算符

运算符

=

+=

－=

*=

/=

%=

4)、逻辑运算符

运算符

&

|

^

!

&&

||

运算

AND(与)

OR(或)

XOR(异或)

NOT(非)

AND(短路与)

OR(短路或)

范例

false & true

false | true

false ^ true

!true

false && true

false || true

结果

false

true

true

false

false

true

运算

赋值

加等于

减等于

乘等于

除等于

模等于

范例

a=3;b=2;

a=3;b=2;a+=b;

a=3;b=2;a－=b;

a=3;b=2;a*=b;

a=3;b=2;a/=b;

a=3;b=2;a%=b;

结果

a=3;b=2;

a=5;b=2;

a=1;b=2;

a=6;b=2;

a=1;b=2;

a=1;b=2;

运算

相等于

不等于

小于

大于

小于等于

大于等于

范例

4==3

4!=3

4<3

4>3

4<=3

4>=3

结果

false

true

false

true

false

true

在使用短路与（&&）时，如果第一个操作数（或表达式）为“假”，则不再计算第二个操作数（或表达式），直接返回“假”。

在使用短路或（||）时，如果第一个操作数（或表达式）为“真”，则不再计算第二个

操作数（或表达式），直接返回“真”。

逻辑运算符只能用于布尔（boolean）类型之间；其结果值为布尔（boolean）类型。

5)、位运算符

运算符

&

|

^

<<

>>

>>>

～

运算

按位与

按位或

按位异或

左移位

右移位

按位取反

计算规则

只有参加运算的两位都为1，‘&’运算的结果才为1，否则为0。

只有参加运算的两位都为0，‘|’运算的结果才为0，否则为1。

只有参加运算的两位不同，‘^’运算的结果才为1，否则为0。

左移指定位数，右边补0。

右移高位是0，左边补0；高位是1，左边补1。

1取反是0,0取反是1。

无符号右移位 左边补0。

位运算符只可用于整数类型、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(表达式)......条件语句；

（2）、for（表达式）....... 循环语句；

（3）、while（表达式）....... 循环语句；

（4）、do.....while(表达式）......循环语句；

（5）、switch 多分支选择结构；

（6）、continue 结束本次循环语句；

（7）、break 终止执行switch或循环语句；

（8）、return 从方法返回语句。

1、 条件语句

分为四种：

单分支条件语句

语法格式为：if(条件表达式){

语句或语句块；

}

二分支条件语句

语法格式为：if(条件表达式){

语句或语句块1；

}else{

语句或语句块2；

}

嵌套条件语句

语法格式为：if(条件表达式){

if(条件表达式){

语句或语句块；

}

}else{

语句或语句块2；

}

多分支条件语句

语法格式为：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

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;]

}

注意：

条件表达式的返回值类型必须是以下类型之一：int、byte、char、short。

case子句中的值常量N必须是常量，而且所有case子句中的值应是不同的。

default子句是可选的。

break语句用来在执行完一个case分支后，是程序跳出switch语句，即终止switch语句的执行。

在一些特殊情况下，多个不同的case值要执行一组相同的操作，这时可以不用break。

6、 continue结束本次循环语句

使用continue语句可以立刻重新开始下一轮的循环，而不再执行循环后面的语句。

7、 break终止执行switch和循环语句

使用break语句可以立刻终止循环，开始执行循环后面的语句。

8、 return从方法返回语句

return语句主要作用是退出当前方法，将程序控制转移到方法的调用者。

一般格式为： return [值或表达式]；

16、方法调用语句

方法调用语句是执行对象的某个方法。

一个完整的方法调用语句由某个方法调用加上一个分号构成。

调用语法格式为：类对象名称.方法名（参数）;

例如：

n(“This is a statement call a method!”);

调用对象的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;

数组的初始化有两种方法：一种是直接初始化，另一种是动态初始化。

直接初始化

格式： 类型 数组名[ ] = { 值1，值2，…，值n};

举例：int a[ ] = {1,2,3};

int b[ ]; b = {1,2,3};

动态初始化：

格式：

（1）声明时初始化：

类型 数组名[ ] = new 类型[ 数组长度];

（2）声明后初始化：

类型 数组名[ ];

数组名 = new 类型[数组长度];

2、访问数组元素

数组元素是通过数组名和下标来访问。未被初始化的数组，不能进行访问。

格式：数组名[下标]

Java中，数组的下标从0开始，直到 <数组长度-1>结束。

获得数组的长度，通过length属性来获得。

3、数组的复制

方法：

opy(源数组,源数组起始位置,目标数组,目标数组起始位置,长度)；

★注：不管是要复制的数组，还是被复制的数组，都必须先初始化。

举例：

int a[ ] = {1,2,3}, b[ ] = new int[3];

opy(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]”);

n(“a[0]=” + a[0] + “ a[1]=” + a[1] );

a[0].append(“ is Modified”); //追加字符串

n(“a[0]=” + a[0]);

5、二维数组和多维数组

前面提到过，数组的元素也可以是数组，如果一个数组的每一个元素都是一个一维数组，这样就构成一个二维数组。

定义格式：类型 数组名[ ][ ]; 或 类型[ ][ ] 数组名;

举例： int a[ ][ ]; double[ ][ ] b;

这几种定义不合法：int a[2][ ]; int b[ ][2]; int c[2][2];

二维数组的初始化：二维数组的初始化也有直接和动态初始化两种方式。

直接初始化格式： 类型 数组名[][]= {{ 值1，值2，…，值n} ,{ 值1，值2，…，值n}....};

举例：int a[ ][ ] = {{1,2,3},{4,5,6},{7,8,9}};

动态初始化格式

1类型 数组名=new 类型[长度1][长度2]； 长度1表示行，长度2表示列。

○ 举例：int a[][]=new[3][5];

2类型 数组名=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<;i++){

for(j=0;j

result[i][j] = 0;

for(k=0;k<;k++){

result[i][j] += a[i][k] * b[k][j];

}

}

}

//打印结果

n(“The result of a * b is : ”);

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

for(j=0;j

(result[i][j] + “ ”);

}

n( ); //换行 }

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 = ;

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

(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<;i++){

if(a[i] == 97){

index = i;

break;

}

}

if(index == -1){ //表示该数不存在

n(“ 97这个数不存在！”);

}else{

n(“97这个数的下标是: ” + index);

}

例3：将数据：37 28 51 13 64为例，用『冒泡法』进行升序排列。

下面编写程序代码：(冒泡法)

int a[ ] = {37,28,51,13,64};

int i, j, n, temp;

n = ;

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++){

(a[i] + “

}

”);