JavaSE复习总结(一)

川长思鸟来 2022-07-20 12:06 172阅读 0赞

# 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.自己调自己，就是递归  
方法调用时，流程发生改变。方法调用的执行过程：

![Center][]  
  
  
  
  
方法的重载（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)\{  
  
\}

[Center]: /images/20220719/5fed46d50d854ca8b3b211ef255aaa97.png