[置顶] JavaSE复习总结(一)

JavaSE复习总结（一）

基础常识

1.JVM,JRE,JDK

JRE = JVM + 相关类库

JDK = JRE + 工具　

2.下载安装jdk，设置path环境变量

3.第一个java程序HelloWorld

1)创建.java源文件，使用记事本进行编辑

public class HelloWorld {

//main方法，程序的入口方法

public static void main (String[] args) {

System.out.println("hi,boy")；

}

}

2)进入命令行，使用javac进行编译(javac HelloWorld.java)

3)使用java执行程序(java HelloWorld)

javac java

.java源文件 -------->字节码文件-------> 结果

注意：

Java源文件以“java”为扩展名。源文件的基本组成部分是类（class），如本类中的HelloWorld类。

一个源文件中最多只能有一个public类。其它类的个数不限，如果源文件包含一个public类，则文件名必须按该类名命名。

Java应用程序的执行入口是main()方法。它有固定的书写格式：public static void main(String[] args) {...}

Java语言严格区分大小写。

Java方法由一条条语句构成，每个语句以“;”结束。

大括号都是成对出现的，缺一不可。

含有主方法的public类叫公共主类，公共主类的类名必须和源文件名字一致，含有主方法的类叫做主类

4.Java语言的特性：

1)安全 每个Java程序的执行都需要通过类加载器的安全检查

2)面向对象 面向对象关注的是完成事务的角色，将具有相同特性或者相同功能的东西进行抽象，然后统一调用，而不是一步一步的执行。

程序的设计也是以对象为个体。

3)跨平台 Java中利用虚拟机实现跨平台，我们编写程序是面向的是虚拟机(JVM),程序执行时，JVM面对不同的操作系统做出不同的处理。

4)健壮 Java中对指针有了很好的解决

5)分布式 统一网络上的多台电脑解决同一问题

6)性能好

7)简单

8)多线程 多并发

5.注释的使用：

// 行注释

/*

*/段注释(多行注释) 不可以嵌套使用

/**

*/文档注释

基础语法

标识符&关键字

关键字：Java语言中赋予了特殊含义，用作专门用途的字符串

保留字

标识符：凡是自己可以起名字的地方都叫标识符

命名规则：（必须准守，否则报编译错误）

1.由26个英文字母大小写，0~9，_，$组成

2.数字不可以开头

3.不可以直接使用关键字和保留字，但是可以包含关键字和保留字

4.Java严格区分大小写，长度无限制

5.标识符不能包含空格

Java中的命名规范：（建议遵守,不遵守不会报编译错误）

包名：多单词组成时所有字母都小写：xxxyyyzzz

类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz

常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

变量

变量：解决单个数据的存储问题

在内存中的一块被命名的，有特定的数据类型的存储区域，其中的值可以在类型范围内无限次改变

变量的声明

类型 变量名;

初始化赋值，变量刚声明完后的第一次赋值

变量名 = 值;

普通赋值

变量名 = 值;

变量的使用：

只需要通过变量名就可以了。

变量的使用注意事项：

1) 有其作用范围 声明语句所属的一对{}

2) 必须先声明, 后使用

3) 局部变量必须进行初始化赋值

4) 变量必须有名字, 和类型

5) 变量在其范围内不允许重复定义

6) 变量保存的值有其范围和类型

int a = 10； //在内存中开辟一块名字为a，类型为int型的区域，并将10写入这个区域

int b = a； //在内存中开辟一块名字为b，类型为int型的区域，找到名字为a的内存区域，将其中的值复制到一块临时空间，然后写入b

变量的分类：

1.按照数据类型进行分类：

1)基本数据类型：区域中保存的是数据本身

1) 数值型

1) 整数

byte 1 -128~127 1000 0000 -> 0x80 ~ 0111 1111 -> 0x7f

short 2 -32768~32767 1000 0000 0000 0000 -> 0x8000 ~ 0111 1111 1111 1111 -> 0x7fff

int 4 -20多亿~20多亿 0x80000000 ~ 0x7FFFFFFF

long 8 0x80000000000000000 ~ 0x7FFFFFFFFFFFFFFF

char 2 0-65535 0x0 ~ 0xFFFF

2) 浮点数

float 4 10的38次方

double 8 10的308次方

数据的自动转型(小--大) byte -> short -> int -> long -> float -> double

char ->int (char byte short 这三个类型互不兼容) 浮点数默认类型double 整型默认类型int

数据的强转转型(大--小) 若是字面值可以直接在值后面加字母： float f =3.14f long l =1000000000000000000000000l

非字面值必须使用强转符 ( ) 括号中写目标类型

任何数据在计算机底层都是以二进制补码的形式存储。

2) 布尔型

boolean 1 true(1),false(0)

2)引用数据类型：区域中保存的是其他数据的内存地址，是一个无符号整数，大小取决于JDK的版本null地址就是0地址

2.按照变量的范围进行分类

1)局部变量：在方法中声明的变量 范围小，寿命短

2)成员变量：在类中方法外声明的变量 范围大，寿命长

class A {

int i = 1; // 成员变量

void m() {

int i = 0; // 局部变量

}

}

运算符

运算符是一种特殊的符号，用以表示数据的运算，赋值，比较等。

算术运算符：

+ - + - * / % ++ -- +

注意： 1） /: int i = 12; i = i / 5;

2） %：最后的符号只跟被模数相同

3） 前++：先+1，后运算

后++：先运算，后+1

4）+：String字符串与其他数据类型只能做连接运算，且结果为String类型。sysout('*' + '\t' + '*'); vs sysout("*" + '\t' + '*');

System.out.println('a' +'b' + "hello"); //两个字符 + 返回int型(将它们的Unicode码值进行求和)，再和字符串连接

System.out.println("hello" +'a' + 'b');//字符串跟任意字符 +　都是连接运算

赋值运算符：

＝　+= -= *= /= %=

= 基本类型的赋值运算，将值copy写入

+= 累加(既可以实现运算，又不改变运算对象的数据类型) 注：没有涉及强转

-= 累减

*= 累乘

/= 累除

%= 累余

【特别地】

short s = 10;

s = s + 5;//报编译的异常

s = (short)(s + 5);

s += 5;//s = s + 5，但是结果不会改变s的数据类型。(注只是和强转效果一致，但是没有涉及强转)

比较运算符（关系运算符）

== > < >= <= instanceof (用于后边的实例的判断)

【注意】区分== 与 = 区别。 == 比较运算符 = 赋值运算符

进行比较运算操作以后，返回一个boolean类型的值

4>=3 表达的是4 > 3或者 4 = 3.结果是true。

if(i > 1 && i < 10){ }

不能写为：if(1 < i < 10){}

逻辑运算符（运算符的两端是boolean值）

& && | || ^ !

【注意】 & 与 && 的区别， &无论左端真假都要执行右端

&&若左端为假不执行右端

| 与 || 的区别 |无论左端真假都要执行右端

||左端为真不执行右端、

^ 逻辑异或 不同为真

相同为假

我们使用的时候，选择&& ， ||

位运算符(两端是数值类型的数据)

两端的数值类型的数据按位进行运算（这里的位指其二进制位）

<< >> >>> & | ^ ~

<< 左移 （左移一位相当于*2）高效的完成*2操作

>>右移(右移一位相当于/2)高效的完成/2操作 符号位为0补0 为1补1

>>>无符号右移 不管正负都用0补

【例子】1.如何交换m = 12和n = 5的值（利用^高效的交换）

2.将60转换为十六进制输出。

三元运算符

(条件表达式)？ 表达式1 ： 表达式2；

1）既然是运算符，一定会返回一个结果，并且结果的数据类型与表达式1，2的类型一致

2）表达式1与表达式2 的数据类型一致。

3）使用三元运算符的，一定可以转换为if-else。反之不一定成立。

例子：获取两个数的较大值；获取三个数的最大值。

流程控制

分支

1.条件判断: if - else

①if(条件表达式){ }

②if(条件表达式){

//执行的语句1；

}else{

//执行的语句2；

}

③if(条件表达式1){

//执行的语句1；

}else if(条件表达式2){

//执行的语句2；

}else if( 条件表达式3){

//执行的语句3；

}...

}else{

//执行的语句；

}

【注意】

1)一旦满足某个条件表达式，则进入其执行语句块执行，执行完毕，跳出当前的条件判断结构，不会执行其以下的条件结构语句。

2)如果诸多个条件表达式之间为“互斥”关系，多个结构可以上下调换顺序

如果诸多个条件表达式之间为“包含”关系，要求条件表达式范围小的写在范围大的上面。

3)严格的分支语句

2.选择结构 switch - case

switch(变量){

case 值1:

语句1;

//break;

case 值2:

语句2;

//break;

...

default:

语句N;

break;

}

【注意】

1)变量可以为如下的数据类型：byte short int char 枚举 String

2)switch - case 中的break省略掉就不是严格的分支语句

3)可以利用break的特性快速的实现好几个值实现同一个功能

4)case后只能填写变量的值，不能写范围。

5)default是可以省略的。并且其位置也是灵活的，但是通常将其放在case语句之后。

6)一旦满足某个case语句，则进入执行其操作。直至遇到break或者程序终止。

7)若要判断的语句的条件满足switch变量的数据类型，且值不多的情况下，建议选择switch-case .

除此之外，选择if-else.

循环

1.循环的格式：

①初始化条件

②循环条件

③迭代部分

④循环体

while循环

①

while(②){

④

③

}

执行0~N次

do-while循环

①

do{

④

③

}while(②);

执行1~N次

for循环

for(①;②;③){

④

}

执行顺序：① ② ④ ③ ② ④ ③ ② ④ …… ② 迭代语句是每一循环的开始语句（除第一次）

例子：

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

System.out.println(i);

}

2.嵌套循环：循环结构还可以声明循环。让内层循环结构整体充当外层循环的循环体。

若外层循环执行m次，内层循环执行n次，整个程序执行m*n次。

【题目】

******

******

******

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

for(int j = 0;j < 6;j++){

System.out.print("*");

}

System.out.println();

}

说明：外层循环控制行数，内层循环控制列数

【例题】1.九九乘法表

2.输出100内的质数。（两种）（参照for循环经典程序分析博客）

3.无限循环结构

while(true){

} //死循环

do {

} while (true); 死循环

do {

语句1;

语句2;

条件

break;

语句3

语句4

} while (false); 利用do-while的特性完成特殊功能

for

死循环的多种写法:

for (;;) {}

for (初始化;;迭代语句) {}

for (初始化;true;迭代语句) {}

for (初始化; 条件语句;) {}

for(;;){

...

if( ){

break;

}

...

}

或者

while(true){

...

if( ){

break;

}

...

}

往往我们在无限循环结构内部提供循环的终止条件，使用break关键字。否则，此循环将无限制的执行下去，形成死循环！

死循环是我们要避免的。

break&continue

break:

使用在switch-case结构或者循环结构中

中断它所隶属的某个语句块的执行（在循环结构中，一旦执行到break，就跳出当前循环）

break 标签; 中断标签指定的循环体

continue：

使用在循环结构中

中断当次循环, 直接进入下一次循环

while (条件) {

continue;

}

continue 标签 中断标签指定的循环的当次循环, 直接进入标签指定的循环的下一次循环.

小例子：

for(int i = 1;i <= 10;i++){

if(i % 4 == 0){

//break; //123

continue; //123567910

}

System.out.print(i);

}

在嵌套循环中，使用带标签的break和continue。

label:for(int i = 1;i < 5;i++){

for(int j = 1;j <= 10;j++){

if(j % 4 == 0){

//break;

//continue;

//break label;

continue label;

}

System.out.print(j);

}

System.out.println();

}

利用break和continue打印质数

方法（method）

1.方法 : 功能封装(类或对象行为特征的抽象) 方法=函数

方法不能独立存在必须定义在类里，方法不能嵌套

声明方法 :

修饰符 返回值类型 方法名(形参类型1 形参1, 形参类型2 形参2, ....) {

方法体;

return 返回值类型的值;

}

API

public static Type methodName(Type1 parmeter1, Type2 parameter2, ....) {

code;

return value;

}

方法调用：

方法名(实参1,实参2,....);

public static void anotherMethod() {

// 调用方法, 方法名(实参1, 实参2, ....);

Type var = methodName(argument1, argument2, ....);

}

【注意】：

方法 = 方法签名 + 方法体

方法调用依据只能是方法签名（方法的使用说明书）

实参：调用方法是实际传递给形参的值

方法的返回值就是方法调用本身

方法无返回只是，不可以打印输出方法调用

无返回值是，不写return，编译器自动加

方法调用，实参和形参是赋值关系，赋值时并不严格按照形参类型，只要能赋值就行

声明在方法中的局部变量保存在栈中

方法调用： 1.其他方法调用

2.自己调自己，就是递归

方法调用时，流程发生改变。方法调用的执行过程：



方法的重载（overload）

要求：1.同一个类中 2.方法名必须相同 3.方法的参数列表不同（①参数的个数不同②参数类型不同）

补充：方法的重载与方法的返回值类型没有关系！

//如下的四个方法构成重载

//定义两个int型变量的和

public int getSum(int i,int j){

return i + j;

}

//定义三个int型变量的和

public int getSum(int i,int j,int k){

return i + j + k;

}

//定义两个double型数据的和

public double getSum(double d1,double d2){

return d1 + d2;

}

//定义三个double型数组的和

public void getSum(double d1,double d2,double d3){

System.out.println(d1 + d2 + d3);

}

//不能与如上的几个方法构成重载

// public int getSum1(int i,int j,int k){

// return i + j + k;

// }

// public void getSum(int i,int j,int k){

// System.out.println(i + j + k);

// }

//以下的两个方法构成重载。

public void method1(int i,String str){

}

public void method1(String str1,int j){

}