代码规范
命名规范
- 项目名: 见名知意,英文,小写
- 包名: 公司反域名;小写
- 类名: 见名知意,驼峰原则,不能有特殊符号,支持_,数字不能放开头
- 类名如果有多个单词,每个单词大写,其他小写,多个单词直接不能有空格
- HelloWorld
- 变量名/属性名: 首字母小写,如果有多个单词,后续单词首字母大写
- orderNumber
- 方法名
- 首字母小写,如果有多个单词,后续单词首字母大写
- main
- findUserById
代码规范
- 花括号,左花括号前不换行,右花括号一定要换行
- 缩进,每层嵌套要向内缩进一个tab键,即4个空格
- 要合理加注释
变量【重点】
variab ：变量
使用：
- 声明
- 数据类型 变量名；
- 赋值
- 变量名 = 值；
- 调用
- 调用输出或运算
变量的目的：
数据类型【重点】
java 的数据类型分为两大类：基本类型 和 引用类型
1. 基本类型
- 整型
- byte
- short
- int
- long
- 浮点型
- float
- double
- 布尔型
- boolean
- 字符型
- char
2.引用数据类型(以后讲)
String (重要)
-
字符串进行比较 使用
.equals();不能使用==if (userName.equals("admin") && password == 123456) { // 字符串的比较用 equals(),此处使用 == 返回结果一直为 false return true; } else { return false; }
运算符
1. 算术运算
算术运算就是对数据进行数学运算.
- 加法 +
- 数字相加
- 字符串拼接
- 减法 -
- 乘法 *
- 除法 /
- 数字相除
- 整数相除直接取整,不是四舍五入,直接舍弃小数点
- 取余 %
- 数字相除的余数
- 主要用来判断奇偶性
- 任何整数除以2的余数为0--> 偶数
- 任何整数除以2的余数为1--> 奇数
- 自增++ & 自减--
- 将值本身自增1或者自减1
2. 赋值运算
赋值运算,是将数据赋值给变量.
- 赋值 =
- 是右边的值赋值给左边的变量
- 相加后再赋值 +=
- 将变量与值相加后再赋值变量本身
- a += 3
- 类似的还有 -=,*= ,/= ,%=
3. 关系运算
关系运算,就是数据的关系,
关系运算的符号:
>大于
<小于
>=大于等于
<=小于等于
!=不等
==相等语法:
a >= b , 关系运算的结果是布尔类型,即只有true或者false
4. 逻辑运算
逻辑运算:
- 与 &
- 全对才对,一错就错
- 或 |
- 全错才错,一对就对
- 非 !
- 将布尔值取反
- 短路与 &&
- 短路或 ||
语法:
关系表达式1 & 关系表达式2;
关系表达式1 | 关系表达式2;
!关系表达式
特点:
逻辑运算的结果是布尔值,即true或false
5. 三目运算
三目运算又叫三元运算.即参与运算的主体有三个
语法：
布尔表达式 ？执行语句1 ：执行语句2
三目运算的结果 由执行语句决定
执行流程：
判断布尔表达式
当布尔表达式为 true 时，执行语句1；
为 false 时，执行语句 2
举例：
int i =12; int j = 6; int a = i > j ? i : j; System.out.println(a); //结果: 12
例题：
//求 i j k 之间的最大值
int i = 3;
int j = 7;
int k = 5;
int a = ((i > j ? i : j) > k) ? (i > j ? i : j) : k;
int b = i > k ? (i > j ? i : j) : (k > j ? k : j);//简化
System.out.println(a);
System.out.println(b);
//结果：7
拓展：求四个数之间的最大值
int i = 11;
int j = 7
int k = 5;
int m = 6;
int c = i > j ? (i > k ? (i > m ? i : m) : (k > m ? k : m))
: (j > k ? (j > m ? j : m) : (k > m ? k : m));
// 结果：11
流程控制【重要】
分支语句
1. switch..case
语法特点:
- 表达式内写是整型,String,枚举类型（可以转换为整型的数据也可以，如：byte short char）
- case后的值是常量
- break可有可无,没有的话会造成case击穿
执行流程:- 根据switch后的值去跟case后的值比较是否相等
- 如果相等,就执行case内的语句
- 执行语句完遇到break,switch结构执行结束,后续case default都不再执行
- 如果switch后的值与case后的值不相等,那就与下一个case的值匹配
- 如果都不相等,执行default语句
总结:
switch语句使用做相等的判断
elseif语句使用做范围判断
2. if
执行流程:
1 执行到if,就判断值
2 如果值是true,就执行if内部的代码
3 如果值是false,就跳过if内的代码
4 无论if判断true还是false,后续代码都会执行
3. if..else if
if..else可以实现多分支语句,选一执行
键盘录入
使用的是Java自有技术Scanner实现键盘录入数据.
使用步骤:
导入Scanner的包
让程序知道Scanner功能是哪里提供
在程序中创建Scanner的对象
这个步骤,今天先记成固定步骤.
调用Scanner的方法完成键盘录入
接收录入的数据
正常使用数据
循环语句【重要】
1. 循环四要素
- 循环初始值
- 循环控制条件
- 循环体
- 循环迭代
2. while
while 一般用于迭代未知的情况下
语法:
while (布尔表达式) {
// 循环的内容
}执行流程：
- 执行到while时,开始判断表达式
- 如果表达式结果为true,就执行{}内的内容
- 执行完后,继续回头再判断while内的表达式
- 如果为true,继续执行{}内的内容
- 执行完后,继续回头执行while内容
- 只有当while后的内容判断为false时就跳过{},不再循环
ps: while循环,又叫做当型循环,即当判断为true时循环,当判断为false时不循环
3. do..while
相对于
while来说，do...while至少会执行一次语法:
do {
// 循环体
// 循环迭代
}while(布尔表达式);执行流程
- 先执行do内的代码
- 再判断while后表达式,
- 如果结果为ture,就继续执行do内的代码
- 然后再判断while,直到while后的内容false就不再循环
4. for【重点】
for 循环是编程中最常用的
语法：
for(初始值;条件;迭代) {
循环体;
}for循环的执行流程
- 循环初始值,只执行一次
- 进行判断
- 判断为true,就向下执行循环体
- 循环体执行完,回头执行i++
- 然后再判断,如果为true,继续向下执行循环体
- 继续自增,直到判断为false,循环不再执行
流程控制关键词
1. break
break : 打断
用法:
- 在 switch..case 语句中使用，打断 switch 执行
- 在循环中使用 break ,打断循环，循环不再执行(打断的是距离它最近的一次循环)
for (int i = 0; i <= 10；++i) { for (int j = 0; j <= 10；++j) { if (j == 5) { break;// 结束的是 j 的循环 } System.out.println(j); } System.out.println(i); }结束循环(只会结束距离它最近的那一个循环)，循环内部语句不再执行，执行循环下边的语句
2. break 练习
import java.util.Scanner;// 模拟 ATM 登录
public class Demo01 {
public static void main(String[] args) {
int userId = 12345;
int password = 123;
Scanner scanner = new Scanner(System.in);
System.out.print("请输入账号:");
int a = scanner.nextInt();
System.out.print("请输入密码:");
int b = scanner.nextInt();
for (int i = 0; i < 3; ++i) {
if ( a == userId && b == password) {
System.out.println("登录成功!");
break;
} else if (i != 2) {
System.out.println("账号或密码不正确!");
System.out.print("请重新输入账号:");
a = scanner.nextInt();
System.out.print("请重新输入密码:");
b = scanner.nextInt();
} else {
System.out.println("已锁死");
scanner.close();
}
}
}
}
3. continue
continue : 继续
用法：
- continue 只能在循环中使用；
- 结束当前循环，继续执行下次循环
for (int i = 1; i <= 10; i++) { if (i % 2 ==0) { continue; } System.out.println(i); } // 结果：1 3 5 7 9
4. continue 练习
逢 7 过
for (int i = 1; i <= 100; i++) { if (i % 7 == 0 || i % 10 == 7 || i / 10 == 7 ) { continue; } else { System.out.println(i); } }
return 关键词
return : 返回
用法：程序方法结束标志
方法(函数)【重要】
1. 概述
method ：方法
方法的定义(什么是方法):
方法又叫做函数，为了完成某个功能的代码块
方法的好处：
- 满足开发时的一个原则，单一职责原则
- 方便代码的维护
- 方便复用代码
2. 方法的定义
1. 注意事项
public static void main(String[] args){
}
以上就是一个完整的方法
public : 这是一个访问修饰符,目前来说就是固定,不用理解
static : 这是静态修饰符,目前来说就是固定,不用理解
void : void 是空,此处是写的返回值类型,即方法执行后返回数据的类型,如果不返回数据,就 写void
main : main是方法名,方法名要见名知意定义即可,主不过主方法main特殊,只能叫main
() : 参数列表,何为参数?
参数就是方法执行所需的数据
()内可以写多个参数,多个参数之间逗号隔开
String[] : 数据类型
args : 参数名,其实就变量名
{} : 方法体,就是该方法执行的具体动作
- 方法不能嵌套
- 定义的方法需要在main方法内调用才可以执行
- 目前定义的方法,只能在当前类中的main方法调用,其他类中不能使用,后续学面向对象时会使用到
2. 权限修饰符
权限修饰符(从小到大)：
private ： 私有的。
- 可以修饰成员变量,构造方法,成员方法,不能修饰类(外部类,内部类不考虑)
- 被private修饰的成员,只能在定义它们的类中使用,在其他类中不能调用。
缺省 : 不写 例： class setName() {}
- 类,成员变量,成员方法,构造方法都能使用默认权限,即不写任何关键字
- 默认权限即同包权限,同包权限的元素只能在定义它们的类中使用,以及同包的类中被调用
protected : 受保护的
- 可以修饰成员变量,成员方法,构造方法,不能修饰类(外部类,内部类不考虑)
- 被private修饰的成员,只能在定义它们的类中使用,在其他类中不能调用。
- 如果有不同包的类想调用它们,那么这个类必须是定义它们的类的子类。
public ： 公共的。
可以修饰类,成员变量,成员方法,构造方法
被public修饰的成员,可以在任何一个类中被调用,不管同包或不同包,是权限最大的一个修饰符
3.无参无返回值函数
public static void test() {
}
// 无参是指,方法的参数列表为空
// 无返回值是指,方法执行完没有返回数据,方法定义成void
4.有参无返回值函数
参数是什么意思?
参数就是方法执行所需的数据.调用方法时由 实参 传递给 形参，形参 和 实参 的变量名可以相同，但一个 {} 内不能出现重复的变量名
参数的定义:
参数其实就是变量,在方法的参数列表,()内定义变量即可
即: 数据类型 变量名;
调用有参数的方法时
1)必须传入参数
2)调用方法时传入数据的类型要与参数一致
5. 无参有返回值
什么叫返回值?
就是指方法执行完返回的数据
如何返回?
1) 在方法体中使用return 值;来返回数据
2) 改变方法定义,将返回值类型定义成合适的类型,不写void返回值返回给谁?
方法的返回值,返回给方法的调用者
调用者如何接收返回值?
就像变量赋值一样接收
强调特殊!!! --> 只能返回一个值
6. 有参数有返回值
参数就是方法执行所需的数据
返回值就是方法执行完返回的数据
现在定义方法时,可以将它们综合应用
递归
阶乘为例
public static int getJc(int num) { if (num == 1) { return 1; } return num * getJc(num -1); }执行流程 以 5！为例：
① 5 * getJc (4)
② 5 * 4 *getJc(3)
③ 5 * 4 * 3 *getJc(2)
④ 5 * 4 * 3 * 2 *getJc(1)
⑤ 5 * 4 * 3 * 2 *1
逐层返回：
① 5 * 4 * 3 * 2
② 5 * 4 * 6
③ 5 * 24
④ 120
数组【重、难点】
1. 为什么需要数组
变量只能承载一个值,如果需要承载多个数据,用变量将变的十分麻烦
数组可以一次承载多个数据
2. 数组的特点
- 数组可以装载多个数据
- 数组的长度固定
- 数组所存储的数据类型是一致的
3. 使用数组
1.1 创建数组
1.1.1 动态创建
语法:
数据类型[] 数组名 = new 数据类型[长度]
注意:
- 数据类型是所有的基本类型 和 引用类型
- 前后的数据类型要保持一致
- 数组名, 相当于变量名
- new 固定关键词,新建
- 长度, 指的是数组的容量,可以装载多少个数据
动态创建:
创建的数组内是默认值,使用时要动态赋值
创建数组时只给定长度,不指定内容
演示:
// 创建数组 int[] arr = new int[3];
数组的底层结构
1.1.2 静态创建
静态创建:
在创建数组的同时,直接将值给定,不给定长度
语法:
标准格式 : 数据类型[] 数组名 = new 数据类型[] {值1, 值2, ...};
简化格式: 数据类型[] 数组名 = {值1, 值2, ...};
1.2 数组的取值 && 赋值
取值语法:
数据类型 变量 = 数组名[下标];// 变量用以接收从数组中取的值
赋值语法:
数组名[下标] = 值;
4. 数组的遍历(重点)
遍历 : 所谓遍历,就是将数组的元素一个一个的取出
数组对象内的 length
属性,可以直接获取数组的长度
1. 数组的遍历方法
public static void foreach(int[] arr) {
for (int i = 0; i < arr.length; i++) {
sysout(arr[i]);
}
}
2. 数组的倒序输出
public static void foreach(int[] arr) {
for (int i = 0; i < arr.length; i++) {
sysout(arr[arr.length - 1 - i]);
}
}
3. 在一个数组中，找出所有的 指定数据的下标位置
// [1,2,8,4,5,7,8,7,8,9] public static void main(String[] args) { int[] arr = {1,2,8,4,5,7,8,7,8,9}; int[] index = new int[arr.length]; Scanner scanner = new Scanner(System.in); System.out.print("请输入要查询的元素: "); int findNum = scanner.nextInt(); int arr2 = getAllIndex(arr, index, findNum); if (arr2 > 0) { for (int i = 0; i < arr2; i++) { System.out.println(index[i]); } } public static int getAllIndex(int[] arr, int[] index, int findNum) { int count = 0; for (int i = 0; i < arr.length; i++) { if (findNum == arr[i]) { index[count] = i; count++; } } return count; } }
// 在一个数组中，找出所有的指定数据的下标位置并返回
/*
* 1 需要返回多个下标,需要使用数组来返回数据
* 所以,方法的返回值类型指定为int[]
* 2 用来装下标的数组的长度?
* 跟原数组长度一样.
* 3 再创建一个数组,长度是找到下标的个数
* 然后进行数组拷贝
*/
public static int[] getAllIndexByElement(int e) {
int[] arr = {1,2,8,4,5,7,8,7,8,9};
// 创建一个数组,用来存储所有的下标
int[] indexArr = new int[arr.length];
// 声明一个初始的下标
int index = 0;
for (int i = 0; i < arr.length; i++) {
if (e == arr[i]) {
indexArr[index] = i;
index++;
}
}
// 新建一个数组
int[] retArr = new int[index];
// 拷贝数组, 根据情况使用
for (int i = 0; i < retArr.length; i++) {
// 将之前数组的元素取出,赋值给新的数组
retArr[i] = indexArr[i];
}
return retArr;
}
}
当只获取数组的一部分时可以通过拷贝数组来完成
5. 数组在方法中的使用
1. 数组作为方法的返回值使用
方法的定义,返回值类型是各种数据类型;java的数据类型有两大类,
基本类型和引用类型.引用类型中有数组,类,接口
public static 返回值数据类型 方法名(){}
例如
public static int[] findIndex(){
return null;// 因为数组是引用类型,引用类型默认值都是null
// null意味着在内存没有创建对象
}
2.数组作为方法的参数使用
方法的定义
public static void 方法名(数据类型 参数名) {}
例如
public static void 方法名(int[] arr) {}
6. 数组排序
1. 冒泡排序
排序数组: 6 5 4 3 2 1
第一趟:
- 5 6 4 3 2 1
- 5 4 6 3 2 1
- 5 4 3 6 2 1
- 5 4 3 2 6 1
- 5 4 3 2 1 6
第二趟 :
- 4 5 3 2 1 6
- 4 3 5 2 1 6
- 4 3 2 5 1 6
- 4 3 2 1 5 6
第三趟 :
- 3 4 2 1 5 6
- 3 2 4 1 5 6
- 3 2 1 4 5 6
第四趟 :
- 2 3 1 4 5 6
- 2 1 3 4 5 6
第五趟
1 2 3 4 5 6
代码实现
// 外层循环控制循环次数 ;( - 1 的目的是减少一次比较)
// 到 arr.length - 1 次后,已达到效果
for(int i = 0; i < arr.length - 1; i++) {
// 内层循环控制相邻元素的比较次数(- i 的目的是较少每次比较的次数)
for (int j = 0; j < arr.length - 1 - i) {
if (arr[j] > arr[j+1]) {
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = arr[i];
}
}
}
2. 选择排序
数组 : {1,2,8,4,5,7,8,7,8,9}
- 定义一个变量 minIndex 用于存储元素 i 的下标,从第一个开始,假设其是最小值
- 再一个一个与其他元素比较,若有元素小于 i , 则将该元素的下标赋给 minIndex
- 再定义 temp 变量,将元素 i 与 minIndex 交换位置
public static void selectSort(int[] arr) {
// 控制比较次数
for (int i = 0; i < arr.length - 1; i++) {
int minIndex = i;
// 寻找小于 arr[minIndex] 的元素
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
// 交换位置
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = arr[i];
}
3. 快速排序
7. Arrays 工具类
Arrays是Java提供的一个操作数组的工具类.提供了很多方法操作数组,常用的有两个:
toString()
sort()Arrays 通过
类名.方法名()直接调用 如:
Arrays.toString
1. toString()
将数组的元素以
字符串返回
import java.util.Arrays;int[] arr = {9,6,8,5,4,5,10,7,3,8,2,1}; // 将数组以字符串形式返回 String line = Arrays.toString(arr); System.out.println(line);
2.sort()
将数组排序,只能进行升序
public static void main(String[] args) {int[] arr = {9,6,8,5,4,5,10,7,3,8,2,1}; // 将数组以字符串形式返回 String line = Arrays.toString(arr); System.out.println(line); // 升序排序 Arrays.sort(arr); // 遍历 System.out.println(Arrays.toString(arr)); }
8. 引用类型的理解
引用类型的理解
java 的数据类型 : 基本类型 和 引用类型
引用类型 : 数组 类 接口
基本类的值传递和引用类型的值传递
基本类 :只是将
实参将值赋给给方法中的形参,形参的值的改变,并不会影响实参的值引用类型 :
引用类型的值传递的是地址值,所以形参的值的改变会影响实参
1. 基本类型值传递
public static void main(String[] args) { int a = 1; System.out.println("1 a = " + a); // 1changeBasicValue(a); // 基本类型,是指传递,只是将1赋值给变量a System.out.println("4 a = " + a); // 1 } // 改变基本类型变量的值 /* * 基本类型是进行值传递 * ---------------- * 方法执行会进栈,方法执行完会弹栈 */ public static void changeBasicValue(int a) {// a是值1 System.out.println("2 a = " + a); // 1 a = a * 10; System.out.println("3 a = " + a); // 10 }
栈结构 : 先进后出
方法执行: 先进栈-->执行方法-->出栈
2. 引用类型值传递
凡是
new对象,都会在堆中创建对象
public static void main(String[] args) { int[] arr = { 4, 2, 1, 3, 5 }; System.out.println("1 " + Arrays.toString(arr)); changeArray(arr); // 参数赋值,传递是地址值,即是引用 System.out.println("4 " + Arrays.toString(arr)); }/* * 数组是引用类型,引用类型是引用传递 * --------------------------- * 凡是new对象,都会在堆中创建对象 * 对对象得出操作,对所有方法都生效 */ public static void changeArray(int[] arr) {// 是数组的地址 System.out.println("2 " + Arrays.toString(arr)); for (int i = 0; i < arr.length - 1; i++) { // 假设当前位置值最小 int minIndex = i; // 循环一趟,找到最小值的下标 for (int j = i + 1; j < arr.length; j++) { if (arr[j] < arr[minIndex]) { minIndex = j; } } // 开始换位 int temp = arr[minIndex]; arr[minIndex] = arr[i]; arr[i] = temp; } System.out.println("3 " + Arrays.toString(arr)); } // 改变基本类型变量的值 /* * 基本类型是进行值传递 ---------------- 方法执行会进栈,方法执行完会弹栈 */ public static void changeBasicValue(int a) { System.out.println("2 a = " + a); // 1 a = a * 10; System.out.println("3 a = " + a); // 10 }
单词
关键字
byte :字节
short : 短
long : 长
double : 双倍
float : 浮点数
break : 打破
continue : 继续
return : 返回
others
mismatch : 不匹配
method : 方法
equals : 匹配(用于字符串比较)
array : 数组
stack : 栈
heap : 堆
index : 索引
avg : 平均数
element : 元素
argumernts : 参数
sort : 排序
foreach : 遍历
replace : 替换
Bug
Scanner 跳行问题
Scanner scanner = new Scanner(System.in);
System.out.print("请输入姓名：");
String name = scanner.nextLine();
System.out.print("请输入年龄：");
int age = scanner.nextInt();
scanner.nextLine() ;// 解决跳行
System.out.print("请输入性别：");
String sex = scanner.nextLine();// 使用 nextLine 这行直接跳过，解决办法 在 6 行添加 scanner.nextLine() 或者改用 next
System.out.print("请输入地址:");
String address = scanner.next();
