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

}