1、Java语言基础
标识符
关于java语言当中的标识符
标识符定义
- 在java源程序当中凡是程序员有权利自己命名的单词都是标识符。
- 标识符在EditPlus编辑器当中以黑色字体高亮显示
- 标识符可以标识的元素：类名、方法名、变量名、接口名、常量名…
标识符的命名规则
（按照这个规则，否则编译器会报错，这是语法）
- 一个合法的标识符只能由“数字、字母、下划线、美元符号”组成，不能含有其他符号
- 不能以数字开头
- 严格区分大小写
- 关键字不能做标识符
- 理论上无长度限制，但是最好不要太长
标识符的命名规范
（只是一种规范，不属于语法，不遵守规范编译器不会报错）
- 见名知意（这个标识符在起名的时候，最好一看这个单词就知道啥意思。）
- 遵循驼峰命名方式，什么是驼峰（一高一低，一高一低…）
驼峰有利于单词与单词之间很好的进行分隔
BiaoShiFuTest，这个很好，一眼就能看出来是4个单词 - 类名、接口名：首字母大写，后面每个单词首字母大写。
StudentTest、UserTest ，这是类名、接口名。 - 变量名、方法名：首字母小写，后面每个单词首字母大写。
nianLing（NianLing这样就不符合了。）
mingZi（MingZi这样也不符合了。） - 常量名：全部大写，并且单词和单词之间采用下划线衔接。
关键字
关键字定义
在SUN公司开发Java语言的时候，提前定义好了一些具有特殊含义的单词，这些单词全部小写，具有特殊含义，不能用作标识符
- 凡是在EditPlus中以蓝色字体形式存在的都是关键字，具有特殊含义
- 切记：
java语言中的所有关键字都是全部小写
java语言是严格区分大小写的，public和Public不一样
Class和class不一样，static和Static也不一样
关键字
public
static
void
class
byte
short
int
long
float
double
boolean
char
true
false
if
else
while
for
private
protected
…
不需要单独拿出来记忆，编写程序的过程中记忆
字面值
-
字面值：
- 10、100
- 3.14
- “abc”
- ‘a’
- true、false
-
字面值就是数据
-
字面值是java源程序的组成部分之一，包括标识符和关键字他们都是java源程序的组成部分
-
数据在现实世界当中是分门别类的，所以数据在计算机编程语言当中也有类型的：【数据类型】
- 10、100 属于整数型字面值
- 3.14 属于浮点型字面值
- true,false 属于布尔型字面值
- “abc”、“中国人” 属于字符串型字面值
- ‘A’、‘人’ 属于字符串型字面值
-
注意：java语言当中所有的字符串型字面值必须使用双引号括起来
java语言当中所有的字符型字面值必须使用单引号括起来
变量
变量的定义
- 变量本质上来说是内存中的一块空间，这块空间有“数据类型”、“名字”
、“字面值” - 变量包含三部分：数据类型、名称、字面值（数据）
- 变量是内存中存储数据的最基本的单元
变量的作用
- 不同的数据类型底层会分配不同大小的空间
- 数据类型是指导程序在运行阶段应该分配多大的内存空间
变量要求：变量中存储的具体的“数据”必须和变量“数据类型”一致，当不一致的时候编译报错
声明/定义变量的语法格式
数据类型 变量名;
- 数据类型：int、float、char…
- 变量名：只要是合法的标识符就行，规范中要求：首字母小写，后面每个单词首字母大写
例如：int i;
其中int是数据类型，i是变量名
变量声明后的赋值
语法格式：变量名 = 字面值;
要求：字面值的数据类型必须和变量的数据类型一致
= 等号是一个运算符，叫做赋值运算符，赋值运算符先运算等号右边的表达式，表达式执行结束之后的结果赋值给左边的变量
-
声明和赋值可以放到一起完成
int i = 10； -
变量赋值之后，可以重新赋值，变量的值可以变化
int i = 10;
i = 20; -
有了变量的概念后，内存空间得到了重复的使用
访问变量
访问一个变量包括两种访问形式
- 第一种：读取变量中保存的具体数据 get/获取
- 第二种：修改变量中保存的具体数据 set/设置
i = 20; //set
System.out.println(i); // get
变量在一行上可以声明多个
int a, b, c;
java中的变量必须先声明，再赋值，才能访问。
int i; 程序执行到这里，内存空间并没有开辟出来，变量i并没有初始化，所以没有赋值之前是无法访问的。
- 在同一个作用域中，变量不能重名，不能重复声明，可以重复赋值。
变量的作用域
变量的作用域就是变量的有效范围
在这个范围之内是可以被访问的，只要出了这个范围该变量就无法访问了
变量的分类
根据变量声明的位置来分类
- 局部变量：在方法体当中声明的变量叫做局部变量
- 成员变量：在方法体之外（类体之内）声明的变量叫做成员变量，成员变量没有手动赋值系统会默认赋值（局部变量不会）
在不同的作用域当中，变量名是可以相同的
在同一个作用域当中，变量名不能重名
java遵循“就近原则”
类体中不能直接编写java语句（除声明变量之外）
数据类型
数据类型的作用
程序当中有很多数据，每一个数据都是有相关类型的，不同数据类型的数据占用空间大小不同
数据类型的作用是知道JVM在运行程序的时候给该数据分配多大的内存空间
数据类型的分类
java中的数据类型包括两种：
- 基本数据类型
- 引用数据类型
类、接口、数组…
基本数据类型
基本数据类型包括四大类八小种：
- 整数型
byte,short, int, long - 浮点型
float, double - 布尔型
boolean - 字符型
char
- 字符串“abc”不属于基本数据类型，属于“引用数据类型”，字符属于基本数据类型：
- 字符串使用双引号 “abc”
- 字符使用单引号 ‘a’
八种基本数据类型各自占用空间大小是多少
| 基本数据类型 | 占用空间大小（单位：字节） |
|---|---|
| byte | 1 |
| short | 2 |
| int | 4 |
| long | 8 |
| float | 4 |
| double | 8 |
| boolean | 1 |
| char | 2 |
计算机在任何情况下都只能识别二进制，例如：只认识010101000111…
（现代的计算机底层都采用交流电的方式，接通和断开就两种状态，计算机只识别1或0，其他不认识）
二进制
数据的一种表示形式。十进制表示满十进一原则，二进制表示满二进一原则
例如：十进制
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
例如：二进制
0 1 10 11 100 101 110 111 1000 1001 …
0 1 2 3 4 5 6 7 8 9
字节（byte）
1 Byte = 8 bit （1个字节 = 8个比特位）
一个比特位就是一个二进制位（一个1或一个0）
1 KB = 1024 Byte
1 MB = 1024 KB
1 GB = 1024 MB
1 TB = 1024 GB
1 TB = 1024 * 1024 * 1024 * 1024 * 8
- 整数型当中的byte类型，占用1个字节，所以byte类型的数据占用8个比特位。
- 关于java中的数据类型，数字都是有正负之分的，所以在数字的二进制当中有一个二进制位被称为“符号位”。并且这个“符号位”在所有二进制位的最左边，0表示正数，1表示负数。
- byte类型最大值：01111111 （2的7次方 - 1，即127）
- byte类型最小值：-128
- byte类型取值范围：-128 ~ 127，可以表示256个不同的数字（256个不同的二进制）
字符编码
计算机只认识二进制，那么计算机是怎么表示现实世界当中的文字的呢？
-
八种基本数据类型当中，byte、short、int、long、float、double、boolean这7种数据类型计算机在表示的时候比较容易，因为底层都是数字，十进制的数字和二进制之间存在一种固定的转换规则
-
但是八种基本数据类型当中char类型表示的是现实世界中的文字，文字和计算机二进制之间“默认”情况下不存在任何转换关系的。
-
为了让计算机可以表示现实世界当中的文字，人为提前制定好“文字”和“二进制”之间的对照关系，这种对照转换关系被称为：字符编码
-
计算机最初只支持英文，最先出现的字符编码是：ASCII码（采用一个字节编码）
‘a’ --> 97 (01100001)
‘A’ --> 65
‘0’ --> 48‘a’ – （按照ASCII解码）–> 01100001
01100001 —按照ASCII编码 --> ‘a’编码和解码的时候采用同一套字典/对照表，不会出现乱码
当编码和解码的时候采用的不是同一套对照表，会出现乱码问题 -
随着计算机的发展，后来出现了一种编码方式，是国际化标准组织ISO制定的，这种编码方式支持西欧语言，向上兼容ASCII码，仍然不支持中文。这种编码方式是：ISO-8859-1，又称为latin-1
-
随着计算机向亚洲发展，计算机开始支持中文、日文、韩文等国家文字，其中支持简体中文的编码方式：GB2312 < GBK < GB18030
-
支持繁体中文：大五码（big5）
-
后来出现了一种编码方式统一了全球所有的文字，容量较大，这种编码方式叫做：unicode编码，unicode编码方式有多种具体的实现：
- UTF-8
- UTF-16
- UTF-32…
-
java语言源代码采用的是unicode编码方式，所以“标识符”可以用中文
八种基本数据类型的取值范围
| 类型 | 取值范围 | 默认值 |
|---|---|---|
| byte | [-128 ~ 127] | 0 |
| short | [-32768 ~ 32767] | 0 |
| int | [-2147483648 ~ 2147483647] | 0 |
| long | 0 | |
| float | 0.0 | |
| double | 0.0 | |
| boolean | [true, false] | false(在C语言中，true是1，false是0) |
| char | [0 ~ 65535] | \u0000 |
注意：short和char所表示的种类总数是一样的，只不过char可以表示更da 大的正整数，因为char没有负数。
数据类型-char类型
public class DataTypeTest01
{
public static void main(String[] args){
char c = 'a';
// 一个中文占用2个字节，char类型正好是2个字节，所以java中的char类型变量可以存储一个中文字符
char x = '国';
//编译错误，ab是字符串不能用单引号括起来
//char y = 'ab';
//"a"是字符串类型，k变量是char类型，类型不兼容，编译错误
//char k = "a";
}
}
转义字符 \
转义字符出现在特殊字符之前，会将特殊字符转换成普通字符
'\n'：换行符
\ 反斜杠在java语言当中具有转义功能
System.out.println() 和System.out.print()区别：println输出之后换行，print表示输出，但是不换行'\t'：制表符'\\'：代表一个普通的反斜杠字符，第一个反斜杠具有转义功能，将后面的反斜杠转移为普通的反斜杠字符。'\u4e2d'：\u反斜杠u联合起来后面的一串数字是某个文字的unicode编码
数据类型-整数型
- java语言当中的“整数型字面值”被默认当做int类型来处理，要让这个“整数型字面值”被当做long类型来处理的话，需要在“整数型字面值”后面添加1/L，建议使用大写的L
- java语言当中的整数型字面值有三种表示方式：
- 十进制（是一种缺省默认的方式）
- 八进制（在编写八进制整数型字面值的时候需要以0开始）
- 十六进制（在编写十六进制整数型字面值的时候需要以0x开始）
//123这个整数型字面值是int类型
//i变量声明的时候也是int类型
//int类型的123赋值给int类型的变量i，不存在类型转换
int i = 123;
//456整数型字面值被当做int类型，占用4个字节
//x变量在声明的时候是long类型，占用8个字节
//int类型的字面值456赋值给long类型的变量x，存在类型转换
//int类型转换成long类型
//int类型是小容量
//long类型大容量
//小容量可以自动转换成大容量，称为自动类型转换机制
long x = 456;
//编译错误：过大的整数：2147483648
//2147483648被当做int类型4个字节处理，但是这个字面值超出int类型范围
//long z = 2147483648;
//解决错误
//2147483648字面值一上来就上就当做long类型来处理，在字面值后面添加L
//2147483648L是8个字节的long类型
//z是long类型变量，以下程序不存在类型转换
long z = 2147483648L;
public class DatTypeTest05
{
public static void main(String[] args){
//100L是long类型字面值，x是long类型变量
//不存在类型转换，直接赋值
long x = 100L;
//x变量是long类型，8个字节，y变量是int类型，4个字节
//编译报错，大容量不能直接赋值给小容量
int y = x;
//大容量转换成小容量，需要进行强制类型转换
//强制类型转换需要加“强制类型转换符”
//加上强制类型转换符之后编译通过了，但是运行阶段可能损失精度
//所以强制类型转换谨慎使用，因为损失精度之后可能损失很严重
//强转原理：
//原始数据：00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100
//强转之后的数据：00000000 00000000 00000000 01100100
//将左边的二进制砍掉（所有的数据强转的时候都是这样完成的）
int y = (int)x;
//理论上以下代码会报错，因为是int类型的字面值，转换成byte类型的变量
//是将大容量int转换成小容量byte，没有加强制类型转换符
//但是实际上以下代码没有报错，可以编译成功。因为SUN公司对byte类型的规定，在java语言中，只要赋值的整数型字面值没有超过byte类型的最大值，就不会报错，如果超过了byte类型的最大值，就会报错。
byte b = 50; // 可以
byte c = 127; //可以
byte b1 = 128; // 编译报错
//纠正错误，需要使用强制类型转换符，但是一定会损失精度
//原始数据：00000000 00000000 00000000 10000000
//强转之后：10000000（这是存储在计算机内部的，这是一个补码）
byte b1 = (byte)128; //-128
}
}
当一个整数型字面值没有超出byte、char、short的取值范围，这个字面值可以直接赋值给byte、char、short类型的变量。这种机制目的是为了方便程序员的编程。
原码、补码、反码
计算机的二进制有三种表示形式：原码、反码、补码
计算机在任何情况下底层表示和存储数据的时候采用了补码形式
正数的补码：和原码相同
负数的补码：负数的绝对值对应的二进制码所有的二进制位取反，再加1
补码：10000000
原码计算过程：10000000 - 1 --> 01111111 --> 10000000 --> 128 --> -128
数据类型-浮点型
float 单精度（4个字节），double 双精度（8个字节，精度较高）
double的精度太低（相对来说的），不适合做财务软件。财务涉及到钱的问题，要求精度较高，所以SUN公司在基础SE类库当中为程序员准备了精确度更高的类型，只不过这种类型是一种引用数据类型，不属于基本数据类型，它是：java.math.BigDecimal
其实java程序中SUN提供了一套庞大的类库，java程序员是基于这套基础的类库来进行开发的。所以要知道SE类库的字节码在哪，java的SE类库的源码在哪
- SE类库字节码：Java\jdk-14.0.1\lib\jrt-fs.jar （jdk14）
- SE类库源码：Java\jdk-14.0.1\lib\src.zip （jdk14）
在java语言中，所有的浮点型字面值（3.0），默认被当做double类型来处理，要想该字面值当做float类型来处理，需要在字面值后面添加F/f
- double和float在计算机内部二进制存储的时候存储的都是近似值
public class DataTypeTest06
{
public static void main(String[] args){
//3.0是double类型的字面值，d是double类型的变量，不存在类型转换
double d = 3.0;
//5.1是double类型的字面值，f是float类型的变量，大容量转换成小容量需要加强制类型转换符，所以以下程序编译错误
float f = 5.1;
//解决方案
//第一种方式：强制类型转换
//float f = (float)5.1;
//第二种方式：没有类型转换
float f = 5.1f;
}
}
数据类型-布尔型
boolean
在java语言中boolean类型只有两个值：true、false，没有其他值
不像c语言当中，0和1可以表示假和真
在底层存储的时候boolean类型占用1个字节，因为实际存储的时候false底层是0，true底层是1
布尔类型在实际开发当中非常重要，经常使用在逻辑运算和条件控制语句当中。
数据类型-类型转换
关于基本数据类型之间的互相转换：转换规则
- 八种基本数据类型当中除布尔类型之外剩下的7种类型之间都可以互相转换
- 小容量向大容量转换，称为自动类型转换，容量从小到大排序：
byte < short(char) < int < long < float < double
注：任何浮点类型不管占用多少个字节，都比整数型容量大
char和short可表示的种类数量相同，但是char可以取更大的正整数 - 大容量转换成小容量，叫做强制类型转换，需要加强制类型转换符，程序才能编译通过，但是在运行阶段可能会损失精度，所以谨慎使用
- 当整数字面值没有超出byte，short，char的取值范围，可以直接赋值给byte，short，char类型的变量
- byte，short，char混合运算的时候，各自先转换成int类型再做运算
- 多种数据类型混合运算，先转换成容量最大的那种类型再做运算
注意：
byte b = 3; //可以编译通过，3没有超出byte类型取值范围
int i = 10; byte b = i / 3; //编译报错，编译器只检查语法，不会“运算”i/3
运算符
算术运算符
+ 求和
- 相减
* 乘积
/ 商
% 求余数
++ 自加1
-- 自减1
注意：一个表达式当中有多个运算符，运算符有优先级，不确定的加小括号，优先级得到提升。
关系运算符
> 大于
>= 大于等于
< 小于
<= 小于等于
== 等于
!= 不等于
= 是赋值运算符
== 是关系运算符
关系运算符的运算结果一定是布尔类型：true/false
逻辑运算符
& 逻辑与
| 逻辑或
! 逻辑非
^ 逻辑异或（两边的算子只要不一样，结果就是true）
&& 短路与
|| 短路或
- 逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型
- 短路与和逻辑与最终的运算结果是相同的，只不过短路与存在短路现象
- 短路或和逻辑或最终的运算结果是相同的，只不过短路或存在短路现象
- 从某个角度看，短路与更智能。由于后面的表达式可能不执行，所以执行效率较高。这种方式在实际的开发中使用较多。短路与比逻辑与使用的多，短路与更常用
- 但是在某些特殊的业务逻辑中，要求运算符两边的算子必须全部执行，此时必须使用逻辑与，不能使用短路与，使用短路与可能导致右边的表达式不执行。
- 发生短路与的情况：第一个表达式执行结果是false，会发生短路与
- 发生短路或的情况：第一个表达式执行结果是true，会发生短路或
//逻辑与和短路与
int x = 10;
int y = 8;
//逻辑与
System.out.println( x < y & ++x < y);
System.out.println(x); //11
int x = 10;
int y = 8;
//短路与
//x<y结果是false，整个表达式结果已经确定是false，所以后面的表达式没有再执行，这种现象被称为短路现象
//短路与才会有短路现象，逻辑与是不会存在短路现象的
System.out.println( x < y && ++x < y);
System.out.println(x); //10
赋值类运算符
赋值类运算符包括两种：
- 基本的赋值运算符
= - 扩展的赋值运算符
+=
-=
*=
/=
%=
- 赋值类的运算符优先级：先执行等号右边的表达式，将执行结果赋值给左边的变量
- 注意以下代码：
byte i = 10; i += 5; //等同于：i = (byte)(i + 5); int k = 10; k += 5; //等同于：k = (int)(k + 5); long x = 10L; int y = 20; y += x; //等同于 y = (int)(y + x); - 重要结论：扩展类的赋值运算符不改变运算结果类型，假设最初这个变量的类型是byte类型，无论怎么进行追加或追减，最终该变量的数据类型还是byte类型
字符串连接运算符
- +运算符在java语言当中有两个作用：
- 加法运算，求和
- 字符串的连接运算
- 当“+”运算符两边的数据都是数字的话，一定是进行加法运算
- 当“+”运算符两边的数据只要有一个数据是字符串，一定会进行字符串连接运算。并且，连接运算之后的结果还是一个字符串类型。
- 在一个表达式当中可以出现多个“+”，在没有添加小括号的前提下，遵循自左向右的顺序依次运算
三元运算符/三目运算符/条件运算符
语法规则
布尔表达式 ? 表达式1 ：表达式2
三元运算符的执行原理
当布尔表达式的结果是true的时候，选择表达式1作为整个表达式的执行结果
当布尔表达式的结果是false的时候，选择表达式2作为整个表达式的执行结果
控制语句
选择结构
- if，if…else
- switch
if 语句
if语句又被称为分支语句/条件控制语句
对于java中的if语句来说，只要有一个分支执行，整个if语句全部结束
if语句的语法结构：四种编写方式
- 第一种：
if（布尔表达式）{
java语句；
java语句；
…
} - 第二种：
if（布尔表达式）{
java语句；
java语句；
…
}else{
java语句；
java语句；
…
} - 第三种：
if（布尔表达式）{
java语句；
java语句；
…
}else if（布尔表达式）{
java语句；
java语句；
…
}else if（布尔表达式）{
java语句；
java语句；
…
}else if（布尔表达式）{
java语句；
java语句；
…
}… - 第四种：
if（布尔表达式）{
java语句；
java语句；
…
}else if（布尔表达式）{
java语句；
java语句；
…
}else if（布尔表达式）{
java语句；
java语句；
…
}else if（布尔表达式）{
java语句；
java语句；
…
}else{
java语句；
java语句；
…
}
注意：以上的第二种编写方式和第四种编写方式都带有else分支，这两种方式可以100%保证会有分支执行
所有的控制语句都是可以嵌套使用的。嵌套使用的时候，代码格式要打保证完美。（该缩进的时候必须缩进）
if 语句的分支中只有一条java语句的话，大括号可以省略不写。（但是不推荐这么使用）
接收用户键盘输入
从“键盘”到“内存”，（输入的过程）
public class KeyInputTest
{
public static void main(String[] args){
//第一步：创建键盘扫描器对象
java.util.Scanner s = new java.util.Scanner(System.in);
//第二步：调用Scanner对象的next()方法开始接收用户键盘输入
//程序执行到这里会停下来，等待用户的输入
//当用户输入的时候，并且最终敲回车键的时候，键入的信息会自动赋值给userInputContent
//程序执行到这里，用户输入的信息已经到内存中了
//接收文本（以字符串的形式接收）
String userInputContent = s.next();
//接收数字（以整数型int的形式来接收）
int num = s.nextInt();
//将内存中的数据输出到控制台
System.out.println("您输入了：" + userInputContent)；
}
}
switch 语句
- switch语句也属于选择结构，也是分支语句
- switch语句的语法结构：
switch(int或String类型的字面值或变量){ case int或String类型的字面值或变量: java语句; ... break; case int或String类型的字面值或变量: java语句; ... break; case int或String类型的字面值或变量: java语句; ... break; ... default : java语句; .... } - switch语句的执行原理：
switch后面小括号当中的“数据”和case后面的“数据”进行一一匹配，匹配成功的分支执行。
按照自上而下的顺序依次匹配 - 匹配成功的分支执行，分支当中最后又“break;”语句的话，整个switch语句终止。
- 匹配成功的分支执行，分支当中没有“break;”语句的话，直接进入下一个分支执行（不进行匹配），这种现象被称为case穿透现象（提供break;语句可以避免穿透）
- 所有分支都没有匹配成功，当有default的语句，会执行default分支当中的程序
- switch后面和case后面只能是int或String类型的数据，不能是探测其他类型
- byte，short，char也可以直接写到switch和case后面，因为他们可以进行自动类型转换，byte，short，char可以自动转换成int类型
- case可以合并：
int i = 10; switch(i){ case 1: case 2: case 3: case 10: System.out.println("Test Code!"); }
public class SwitchTest01
{
public static main(String[] args){
/*
long x = 100L;
switch(x){} //编译报错，switch后面的括号里面需要int或String类型的字面值或变量，需要强制类型转换
*/
//解决编译错误
long x = 100L;
switch ((int)x){}
}
}
循环结构
- for
- while
- do…while()
在程序当中总有一些需要反复的/重复的执行的代码，将把需要反复执行的代码片段放到“循环体”，再联合“计数器”，共同控制这段需要反复执行的代码。
for循环
- 语法结构
for ( 初始化表达式 ；布尔表达式；更新表达式){ //是需要重复执行的代码片段（循环体：由java语句构成） } - for循环的执行过程/执行原理
- 初始化表达式、布尔表达式、更新表达式都不是必须的（但是两个分号是必须的）
- 初始化表达式最先执行，并且在整个for循环当中只执行一次
- 布尔表达式必须是true/false，不能是其他值
- for的执行过程：
- 先执行初始化表达式，并且该表达式只执行一次
- 判断布尔表达式的结果是true还是false
- 布尔表达式true
- 执行循环体
- 执行更新表达式
…
- 布尔表达式false
- 循环结束
- 布尔表达式true
- 循环语句和条件判断语句嵌套使用（for和if的嵌套）
while循环
-
while循环的语法结构：
while (布尔表达式){ 循环体； } -
while循环的执行原理
先判断布尔表达式的结果：- true
- 执行循环体
- false
- 循环结束
- true
-
while循环的循环次数
0 ~ N次
while循环的循环体可能执行次数为0次
do …while循环
- do …while循环的语法结构
do{
循环体；
}while（布尔表达式）； - do …while循环的执行原理
- do …while循环的执行次数
do …while循环的循环体代码片段执行次数是：1-N次（至少一次） - 使用do …while循环的注意事项
do …while循环语句最终由一个“分号”别丢了
控制循环结构
- break
- continue
break语句
- break是java语言当中的关键字，被翻译为“中断/折断”
- break + “；”可以成为一个单独的完整的java语句：break;
- break语句使用在switch语句当中，用来终止switch的语句执行
- break语句同样可以使用在循环语句当中，用来终止循环的执行。
- 在默认情况下，break语句终止的是离它最近的循环语句
- break；语句使用在for,while,do…while循环语句当中用来跳出循环，终止循环的执行。因为当程序循环到某个条件的时候，后续的循环没必要执行了，在执行也是耗费资源，所以可以终止循环，这样可以提高程序的执行效率。
continue语句
- continue表示：继续/go on /下一个
- continue也是一个continue关键字加一个分号构成一个单独的完整的java语句，主要出现循环语句当中用来控制循环的执行。
- break和continue的区别：
break表示循环不执行了，终止循环。
continue表示直接进入下一次循环继续执行
方法
方法的基础语法
方法的本质：方法就是一段代码片段，并且这段代码片段可以完成某个特定的功能，并且可以被重复的使用。
方法，对应的英语单词：Method
方法在c语言中叫做函数 /Function
方法定义在类体当中，在一个类中可以定义多个方法，方法编写的位置没有先后顺序，可以随意。
方法体中不能再定义方法。
方法体由java语句构成，方法体中的代码自上而下按顺序运行。
方法的定义
语法结构：
[修饰符列表] 返回值类型 方法名（形式参数列表）{
方法体；
}
修饰符列表
可选项，不是必须的
目前统一写成：public static
方法的修饰符列表当中有static关键字的话，调用方法：类名.方法名（实际参数列表）
返回值类型
- 返回值：一个方法是可以完成某个特定功能的，这个功能结束之后大多数都是需要返回最终执行结果的，执行结果可能是一个具体存在的数据。而这个具体存在的数据就是返回值
- 返回值类型：返回值是一个具体存在的数据，数据都是有类型的，此处需要指定的是返回值的具体类型
- 返回值类型可以指定的类型：java任意一种类型都可以，包括基本数据类型和所有的引用数据类型
- 也可能这个执行结束之后不返回任何数据，java规定，当一个方法执行结束后不返回任何数据的话，返回值类型位置必须编写：void关键字
- 返回值类型可以是：byte short int long float double boolean char String void …
- 返回值类型若不是void，表示这个方法执行结束之后必须返回一个具体的数值，当方法执行结束的时候没有返回任何数据的话编译器报错。返回值的方法：
return 值；，并且要求“值”的数据类型必须和“方法的返回值类型”一致，否则编译器报错。 - 返回值类型是void的时候，在方法体中不能编写
return 值；这样的语句，但是要注意可以编写return;这样的语句 - 只要带有return关键字的语句执行，return语句所在的方法结束。（不是JVM结束，是return所在的方法结束）
方法名
只要是合法的标识符就行
方法名最好见名知意
方法名最好是动词
方法名首字母要求小写，后面每个单词首字母大写
形式参数列表：简称形参
形参是局部变量：int a; double b; float c; Sting s; …
形参的个数可以是：0-N个
多个形参之间用“，”隔开
形参中起决定性作用的是形参的数据类型，形参的名字就是局部变量的名字
方法在调用的时候，实际给这个方法传递的真实数据被称为：实际参数，简称实参
- 实参列表和形参列表必须满足：
数量相同、类型对应相同
例如：
public static int sum（int a, int b）{
}
方法调用
sum("abc", "def"); 编译器报错
sum(10, 20); //（10， 20）是实参列表
方法体
方法体必须由大括号括起来，方法体当中的代码有顺序，遵循自上而下的顺序依次执行。并且方法体由java语句构成，每一个java语句以“；”结尾
方法的调用
方法只定义不去调用是不会执行的，只有在调用的时候才会执行
语法规则：（方法的修饰符列表中有static）
类名.方法名（实参列表）；（这是一条java语句，表示调用某个类的某个方法，传递这样的实参）
//public表示公开的
//class表示定义类
//MethodTest03是一个类名
public class MethodTest03{ //表示定义一个公开的类，起名MethodTest03，由于是公开的类，所以源文件名必须和类名一致：MethodTest03.java
//类体，类体中不能直接编写java语句，除声明变量外
//方法出现在类体中
//方法
//public表示公开的
//static表示静态的
//void表示方法执行结束之后不返回任何数据
//main是方法名：主方法
//(String[] args)：形式参数列表，其中String[]是一种引用数据类型，args是一个局部变量的变量名
//主方法是程序的入口
public static void main(String[] args){
//这里的程序是一定会执行的，main方法是JVM负责调用的，是一个入口位置
//从这里作为七点开始执行程序
}
}
- 方法的修饰符列表当中有static关键字，完整的调用方式是：类名.方法名（实参列表）
- 但是有的时候“类名.”可以省略，可以省略的情况：
建议在一个源文件中只写一个class。m1(){ m2(); //m1方法和m2方法在同一个类体当中的时候，“类名.”可以省略不写 }
- 方法的返回值不是void的时候，要求方法必须要执行
return 值；这样的语句来完成值的返回，没有这个语句编译器会报错。 - 一个方法有返回值的时候，当调用这个方法，方法返回了一个值，对于调用者来说，这个返回值可以选择接收，也可以选择不接收。但是大部分情况下都是选择接收的。
- 调用方法执行结束后的返回值采用变量接收，变量的数据类型需要和返回值的数据类型相同，或者可以自动类型转换
return语句
- 带有return关键字的java语句只要执行，所在的方法执行结束
- 在“同一个作用域”当中，return语句下面不能编写任何代码，因为这些代码永远都执行不到，编译会报错。
public class MethodTest09
{
public static void main(String[] args){
}
//编译报错：缺少返回语句，以下程序编译器认为无法百分百保证“return 1；”会执行
public static int m(){
int a = 10;
if (a > 3){
return 1;
}
}
}
- 在返回值类型是void的方法当中使用
return ；语句，return ；语句出现在返回值为void的方法中主要是为了用来结束当前方法
方法在执行过程中JVM的内存分配？
- 方法只定义，不调用，是不会执行的，并且在JVM中也不会给该方法分配“运行所属”的内存空间。只有在调用这个方法的时候，才会动态的给这个方法分配所属的内存空间。
- 在JVM内存划分上有三块主要的内存空间（除了这三块之外还有其他的内存空间）：
- 方法区内存
- 堆内存
- 栈内存
- 关于“栈”数据结构：
- 栈：stack，是一种数据结构
- 数据结构反应的是数据的存储形态
- java有一套庞大的类库支撑
- javaSE当中的集合章节使用了大量的数据结构
- 常见的数据结构：数组、队列、栈、链表、二叉树、哈希表/散列表…
- 方法代码片段存储位置？方法执行的时候执行过程的内存在哪里分配？
- 方法代码片段属于.class字节码文件的一部分，字节码文件在类加载的时候，将其放到了代码区当中，所以JVM的三块主要的内存空间中方法区内存最先有数据、存放了代码片段。
- 代码片段虽然在方法区内存当中只有一份，但是可以被重复调用。每一次调用这个方法的时候，需要给该方法分配独立的活动场所，在栈内存中分配。（栈内存中分配方法运行的所属内存空间）
- 方法在调用的瞬间，会给该方法分配内存空间，会在栈中发生压栈动作，方法执行结束之后，给该方法分配的内存空间会全部释放，此时发生出栈动作。
- 压栈：给方法分配内存
- 出栈：释放该方法的内存空间
- 局部变量在“方法体”中声明，局部变量在运行阶段内存在栈中分配。
注意：在EditPlus中，字体颜色为红色的表示一个类的名字，并且这个类是JavaSE类库中自带的，我们自定义的类名，字体颜色是黑色，是标识符。但是其实JavaSE类库中自带的类，例如：String.class，System.class，这些类名也是标识符。只要是类名就一定是标识符。
方法在调用的时候，传递参数时传递的是变量中保存的值。
方法的重载机制Overload
(有些语言不支持这种机制)
- 方法重载又被称为：Overload
- 考虑使用方法重载的情况
功能相似的时候，尽可能让方法名相同
（但是功能不同/不相似的时候，尽可能让方法名不同。） - 什么条件满足之后构成方法重载？
- 在同一个类中
- 方法名相同
- 参数列表不同：数量不同，顺序不同，类型不同
- 方法重载和什么有关系？和什么没有关系？
- 方法重载和方法名+参数列表有关系
- 方法重载和返回值类型无关
- 方法重载和修饰符列表无关
方法的递归调用
- 递归的定义
方法自身调用自身a(){ a(); } - 递归是很耗费内存的，递归算法可以不用的时候尽量不用
- 以下程序运行的时候发生错误（不是异常，是错误Error）：java.lang.StackOverflowError
栈内存溢出错误。错误无法挽回，只有一个结果，就是JVM停止工作。
public class RecursionTest01
{
public static void main(String[] args){
doSome();
}
public static void doSome(){
doSome();
}
}
- 递归必须有结束条件，没有结束条件一定会发生栈内存溢出错误
- 递归即使有了结束条件，即使结束条件是正确的，也可能会发生栈内存溢出错误，因为递归的太深了
注意：递归可以不使用尽量不用，但是有些情况下该功能的实现依靠递归方式，比如：目录拷贝
扫一扫
1051
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
