Java知识点总结

admin管理员组

文章数量:1532195

2024年4月7日发(作者：)

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）

基本数据类型包括：整型、浮点型、字符型、逻辑型（布尔型）。

数据类型

布尔型

字节型

字符型

短整型

整型

长整型

浮点型

名称

boolea

n

byte

char

short

int

long

float

位长 默认值

1

8

16

16

32

64

32

64

false

0

‘u000

0’

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] + “

}

”);

本文标签： 语句类型数组变量数据类型