Day01 类名：每个单词首字母大写 main方法是程序的入口 一个java多个源文件可以出现在源文件中class例如，有五个定义class,然后在编译后，将生成5个class文件，有多少class定义会产生多少个定义class文件
public : 还有一个公共的java只有一个文件public类,且public类名必须与文件名一致 class :类，定义类关键词 HelloWorld : 只能是： 大大小小的字母，美元符号$,下划线_,数字，数字不能开始，不能使用关键字和保留字，public的类的类名,必须和文件名一致
命名时要注意： 只有大小写字母 A-Za-z 数字0-9 下划线 _ 美元符号 $ 数字不能打头 不能使用关键词和保留词 关键字 : java已使用的单词 比如 public static void class 保留字 : java关键字尚未使用，但可用于后续新版本 goto 不能单独使用关键字和保留字，如 public1 或者 classpublic 都是可以的
JVM特性: 四大特性: 跨平台 自动垃圾回收机制 多线程 面向对象 是JVM跨平台
数据类型 命名规则 强制 : 数字,大小写字母,美元符号,下划线且不能数字开头 不能使用关键词和保留词
非强制 : 建议望文知义 驼峰命名法 ZhanGao
所有需要命名的地方都应符合本标准 文件名 类名 方法名 变量名 包名
数据存储 1 程序 集合一堆命令 它是一个静态概念，通常保存在硬盘中
2 文件类型 文本，二进制，可执行 文本文件 给人看的 二进制文件 给电脑看的
3 编辑器 编辑器编写文本文件的工具程序
4 数据的存储 数据要运算，必须先存储 5 存储方式 内存 : 无限延伸线 硬盘 : 螺旋线 光盘 : 同心圆
6 存储单位 bit : 比特是电子位 byte : 字节 = 8 bit 最高位作为符号位，以表示符号位(负数)， 1 表示负数 0 表示 正数 -128 ~ 127
Day02
- 数据类型 1.1 本质 指占用内存空间的大小，用位和字节表示 1.2 分类 数据类型 : 基本数据类型 数值型 整数型 Byte 字节型 Short 短整型 Int 整型 Long 长整型 浮点型(小数) Float 单精度浮点型 Double 双精度浮点型 字符型 Char 布尔型 Boolean 引用数据类型 类 数组 接口
1.3 进制 Java没有办法直接表示二进制
十进制表示法 int i_1 = 10; 八进制表示法 int i_2 = 012; 十六进制表示法 int i_4 = 0x1f; 双引号是字符串，里面的数据不会解释，所以 i_4 在内存中找不到0x1f的 System.out.println("i_4"); System.out.println(i_4); 以十六进制展示 System.out.println(Integer.toHexString(i_4)); 1.4 类型使用 1.4.1 整数型 short s_1 = 123; byte b_1 = 123; int i_5 = 2147483647;
java默认为中整数 int(整型) 所以 下面的代码是自动转换类型int值复制给long类型 long l_1 = 2147483647; // 超过int上限 报错 // long l_2 = 2147483648 ; // 如何声明long的值, 加 L/l 建议 L ,因为避免 l和1不容易区分 long l_3 = 1232167864124L; // 最大值 : 9223372036854775807 System.out.println(Long.MAX_VALUE); 1.4.2 浮点型
double d_1 = 1.2; // 因为浮点默认是double,所以 float必须增加声明F/f才可以 float f_1 = 1.2f;
// 强制类型转换为float,double强制转换为float float f_2 = (float) 1.34; System.out.println(f_2); 1.4.3 字符型
- char 字符型 用 英文单引号表示 ‘’ 并且 只有一个字符
- char = 2 byte = 16 bit
- 字符 --> 整数 --> 二进制
- 最初的ASCII编码
-
'a' 97 -
'b' 98 -
'A' 65 -
'B' 66 -
'0' 48 -
'1' 49
采用unicode编码
char c_1 = 'a'; char c_2 = '2'; char c_3 = '张'; char c_4 = ' '; System.out.println((int)c_1); System.out.println((int)c_3); // 测 char c_5 = '\u6D4B'; System.out.println(c_5); - 转义符
-
将有意义字符转换为无意义字符 - 比如 char用 ‘’ 单引号表示 并且 一个字符只能出现 ,假如我想输入 ’ 单引号 怎么办? 转义
-
java 中 \ 表示转移符 -
\t : 制表符 -
\\ : 转义转移符 -
\r\n : 换行符 char c_1 = '\''; char c_2 = '\\'; char c_3 = '\t'; System.out.println(c_1); System.out.println(c_2); System.out.println('\n'); System.out.println(c_3);
Question 需要了解各种转义符 \n还是\r是换行符？
1.4.4 布尔型
-
boolean 不是 bool
-
1 只有两个值 : true/false,没有 1和0
-
2 默认值为false
-
3 不参与任何类型的转换
-
4 占用1字节，都是0表示false, 0000001表示true
-
一般用于过程控制或逻辑判断 boolean b_1 = false; boolean b_2 = true; // 不能转换 // boolean b_3 = (boolean)1;
if (b_2) { System.out.println("为真"); }else{ System.out.println("为假"); }
1.5 类型转换
- 类型转换
- 1 除了8种基本数据类型，boolean此外，可以转换
- 2 精度低到精度高 是自动转换
- 3 精度高到精度低 需要强制转换
- 自动类型转换
- byte --> short --> int --> long --> float --> double
-
char --> char和int并列,并且char可自动转换成int,可自动转换为更高精度 - 其他需要强制转换
-
强制转换可能会失去精度，导致数据不准确 byte b1 = 1; short s1 = b1; int i1 = s1; // char c1 = s1; char c1 = '1'; i1 = c1; char可自动转换成int // s1 = 1; long l1 = c1; float f1 = l1; // l1 = f1; float需要强制转换成long,高精度转换成低精度 byte b2 = (byte) 131; System.out.println(b2); int i2 = 10; byte b3 = (byte) i2; System.out.println(i2);
1.6 混合运算
// 混合运算
// 当一个运算中出现多个类型的值的时候,结果一定是最大类型
int i_1 = 10;
long l_1 = 10;
long b_1 = i_1+l_1;
// byte , short , char , int 四种中任意一种或多种进行运算,结果都是int类型
int b_2 = b3+s1;
1.7 小结 Float,char,boolean三个的使用 自动转换和强制转换 转移符 混合运算
- 变量
2.1 常量 常量 : 整个程序生命周期中,值不能更改
字面量/直接量:也是有数据类型的, 整数默认int,小数默认double Final
// final 修饰的 不可更改
final int i1 = 1;
// i1 = 2;
System.out.println(1);
2.2 变量 可以更改的量,可以再程序执行中对值进行更改 可以复用
2.2.1 全局变量 什么是全局变量的概念 : 允许在类之外创建变量,和类同级别,那么所有的类都可以直接访问该变量,不需要二次引用 所谓二次引用,就是没有使用 . 操作符 xxx.xxxxx 首先 java不允许在类之外创建变量,但是可以将一个类的变量设置为public static修饰的,那么其他类就可以通过 该类的类名.变量名 来进行访问 全局变量的确定 : 安全性较差,容易命名冲突
所以 java引入了包概念,引用一个变量的时候必须通过该包和类才能访问 2.2.2 变量定义/声明
- 变量声明 :
-
数据类型 变量名 ; - 变量定义 :
-
数据类型 变量名 = 赋值 -
数据类型划分内存空间 给空间命名 赋值(把数据保存到空间中) - 域 :
-
空间范围,内存空间的划分 -
一个 {} 大括号 就是一个作用域,变量不能超过向上碰到的第一个大括号,但是向下可以穿透域中嵌套的所有子大括号
Int i = 10;
int a=3,b=2,c=10; 2.2.3 变量分类
- 变量分类 :
-
局部变量 : 方法内部声明的变量是局部变量 -
静态变量 : 类体中使用static修饰的变量是静态变量 -
成员变量 : 类体中没有使用static修饰的变量是成员变量
2.2.4 变量调用
-
局部变量 : 当前方法中,声明之后,直接写变量名调用即可 -
静态变量 : 类名.静态变量名/当前类中调用当前类的静态变量时,类名可以省略,编译之后,JVM会自动补齐为类名调用 -
成员变量 : 对象引用.成员变量名 System.out.println(x1); System.out.println(_02_Var.x1); _02_Var aa = new _02_Var(); System.out.println(aa.x);
2.2.5 默认值
- 局部变量没有默认值,必须先初始化赋值之后 才能使用
- 静态变量和成员变量 有默认值
- 默认值: 整型 : 0 , 浮点型 : 0.0 , 布尔型 : false , 字符型 : \u0000 , 引用类型 : null
2.2.6 变量优先级 变量可以重名吗? 静态变量和成员变量 不能同名 但是局部变量和 静态变量/成员变量 是可以同名的 也就是说 有一个局部变量 i 那么 还可以再创建一个 静态变量/成员变量 i
如果静态变量和局部变量重名,那么优先使用局部变量 如果就想使用静态变量的话,可以使用类名来区分,也就是二次调用
static int age = 18;
public static void main(String[] args) {
int age = 22;
System.out.println(_04_Var.age);
}
- 操作符 3.1 算数运算符
-
运算操作符 +,-,*,/,% ++,–
-
运算符优先级 单目/单元运算符优先级最高 > 双目 > 三目
-
i++ 和 ++i 的区别
int a = 10; int b = 3; System.out.println(a + b); System.out.println(a - b); System.out.println(a * b); System.out.println(a / b); System.out.println(a % b); double d1 = 0.1; double d2 = 0.2; // 0.30000000000000004 // 注意 不要使用小数做比较 System.out.println(d1 + d2); System.out.println("----------------------"); // ++ : 把值取出,+1,再放回去 int k = 100; // 只要是单独出现,不管k在前还是k在后,都一样,原数+1即可 // k++; // ++k; Question k++和++k区别需要完全搞明白 // 201 如果是 k++ ,就会申请一块临时空间,把k中的值先保存到临时空间中,然后k++的这个k 就指向临时空间中的值 // 然后计算++ , 计算完++ 后,继续后续操作 100+k // 如果是 ++k 那么 k 就不需要指向临时空间了 // k++ : k使用的是++之前的值 // ++k : k使用的是++之后的值 // 但是 ++ 优先级 大于 双目和三目 k = k++ +k; System.out.println(k); int w = 10; w = w++ * w; System.out.println(w); int m = 10; int e = 2+m++; System.out.println(e); System.out.println(m); int p= 2; p = 2 + p++ + ++p + p++ + ++p;
// p = 2 + 2 + ++p + p++ + ++p; p=3 // p = 2 + 2 + 4 + 4 + 6; p=6 System.out.println§;
int x = 10;
x = 10 + x++ + ++x +(10 * x++) + ++x;
// x = 10 + 10 + 12 +120 + 14; x=14 System.out.println(x);
int i = 10;
i= i++ + (i +1);
System.out.println(i);
3.2 关系运算符
- 关系运算符
-
运算结果 是 boolean型 (true/false),可以叫布尔型表达式 -
= < <=
- == : = 是赋值操作,java中 判断相等 使用 ==
-
如果是基本类型,比较值的大小 -
如果是引用类型,比较内存地址 - != : 不等于
- 常用于流程控制
3.3 位运算符
- 位运算
-
& 位与 , 两边都是true 结果才是true,也可以两边是数字 -
| 位或 一边为true 结果就为true -
! 位非,取反 !true 就是false , !false 就是true -
^ 异或 ,两边不一样就是true -
~ 按位非,转换为二进制,然后 每位取反 - 逻辑 比较
-
&& : 短路与,如果 第一个就为假,第二个表达式就不执行了,结果为假 -
|| : 短路或,或,如果第一个为真,第二个就不执行了 -
: 右移运算符(考虑符号位,符号位不移动,正数就是正数,负数就是负数)
-
8 >> 2 -
0000000 10 转换为二进制,然后符号位之后补两个0,最右边删除两位 -
右移 8 >> n 就等于 8 / 2^n -
如果是 -8 >>2 就是补1 - << : 左移运算符(不考虑符号位),向最左边补0
-
: 右移运算符(不考虑符号位)
-
如果是正数 和>> 没有区别,因为最前面都是0 -
但是负数就不一样了, >> 只会在符号位之后补1 , 而 >>> 在符号位之前 补0 -
所以 -1 >>> 1 就成了 2147483647 question 位移运算符需要搞清楚
day03 4. 运算符 4.1 赋值运算符
- = 赋值运算符
-
= : 把右边的赋值给左边,如果右边是个运算,需要把运算结果赋值给左边 -
+= : 左边和右边相加,结果赋值给左边 -
-= : 左边 减去 右边 结果赋值给左边 -
*= ..... -
/= ..... -
%= ..... - i = i + 10;
- i += 10;
-
虽然两个式子是等价的,但是还不一样, i++ 和 += 这些写法,不需要强制转换,当然精度还是会丢失,这种写法会自动帮我们强制转换 -
但是像 i = i+10; 这种 如果 i 是byte类型 或者short类型 就需要强制转换,因为byte,short,int,char四种类型进行混合运算时结果是int类型的
4.2 字符串连接符
-
- 即是加减运算符,也是字符串连接符,用于把多个字符串拼接成一个字符串
- 字符串 用 “” 双引号表示
4.3 三目运算符 也可以叫三元运算符
boolean条件表达式 ? 真语句 : 假语句;
- 流程控制 5.1 顺序结构 严格从上往下 从左到右执行 5.2 分支结构 通过某个判断条件,选择性执行某一个分支
5.2.1 if…else…
- 语法结构
- 第一种结构 : 有不执行情况
-
if( boolean表达式 ){ 表达式为true 就执行java代码 为false就不执行 -
java代码; -
java代码; -
} - 第二种结构 : 没有不执行情况
-
if( boolean表达式 ){ 表达式为true 就执行java代码1 为false就执行 else 中 java代码2 -
java代码1; -
java代码1; -
}else{ -
java代码2; -
...... -
} - 第三种结构 : 有不执行情况
-
if( boolean表达式 ){ -
java代码1; -
java代码1; -
}else if( boolean表达式 ){ -
java代码2; -
...... -
} - 第四种结构 : 没有不执行情况
-
if( boolean表达式 ){ -
java代码1; -
java代码1; -
}else if( boolean表达式 ){ -
java代码2; -
...... -
}else{ -
..... -
} - 注意 : if分支语句,只会有一个分支执行,一个执行 整个分支结束
-
上面 1,3 有不执行情况, 2,4 一定会有一个分支执行
5.2.2 Switch
- switch语句
-
1.7之前 只能传入 int整型(能传入整型,也就可以传入 byte,short,char,自动类型转换) -
1.7开始,包括1.7,可以传入 字符串 - 语法 :
-
switch( 值 ){ -
case 值 : -
java代码; -
...... -
break; -
case 值 : -
java代码; -
...... -
break; -
case 值 : -
java代码; -
...... -
break; -
default : -
java代码; -
} - default 可以没有,如果没有的话,就有不执行的情况,
-
如果所有的case 都不符合条件,就执行default
注意 break : 必须要写,如果不写 就会发生case穿透现象
合并 利用case穿透完成
5.3 循环结构 重复执行某些代码很多次
5.3.1 For
- for 循环 :
-
计数循环,在某个次数范围内,重复执行某些代码 - 语法 :
-
for( 表达式1 ; 表达式2 ; 表达式3 ){ -
// 循环体 -
java代码; -
} - …
- 先执行表达式1,并且只执行一次
- 执行表达式2,结果必须是boolean型,如果是true,就执行循环体,如果是false就终止循环
- 假设是true,执行循环体,循环体执行完成后,执行表达式3
- 执行完表达式3之后,再执行表达式2,如果是false 终止循环,如果是true 执行循环体,执行表达式3 , 执行表达式2 …
- 表达式1 : 初始条件
- 表达式2 : 终止条件
- 表达式3 : 步长
- 循环三要素 :
-
初始值,终止条件,步长 -
缺一不可
5.3.2 While
- while循环 是真假循环,在某个条件为真的情况下执行
- 语法 :
-
while( boolean表达式 ){ -
循环体; -
}
5.3.3 Do…while…
- while 有不执行情况,所以执行次数是 0~N次
- 但是 do…while… 能够保证代码 至少执行一次, 1~N次
- 语法 :
-
do{ -
}while(boolean表达式);
5.4 跳转语句 5.4.1 Break
- break语句
-
1 用于switch中,结束分支语句,避免发生case穿透 -
2 用于循环中,终止当前循环 - break 结束循环
- continue 跳过当前次,继续下一次循环
- return 结束方法,并返回一个数据
5.4.2 Continue continue : 跳过当前次循环,继续下次
day04 6. 方法 6.1 概述和作用 一堆代码的集合,可重复使用
1)使程序变得更简短更清晰 2)有利于程序维护 3)提高程序开发效率 4)提高代码重用性
-
方法目的 : 代码重用
-
相同的操作,不用重复写多遍代码 -
方法就是有名字的代码块 : 一个大括号{} 就是一个代码块/语句块/代码段
-
java 中只有方法, c 中只有函数, C++就不一样了,写在类中,叫方法,写在类外叫函数
-
或者说 面向对象语言中 只有方法,面向过程中只有函数
-
函数 是可以直接调用的,不需要二次引用 6.2 方法声明
-
方法声明 :
-
结构 : [修饰符列表] 返回值类型 方法名 (参数1,参数2,参数3......) { 方法体; } -
[] 加中括号 说明 可以有,可以没有,可以有多个 -
修饰符 : -
权限控制 : public , protected , private 三选一 , -
其他修饰 : static ,synchronized -
abstract , final 二选一 -
返回值类型 : 11种数据类型任意一种即可,如果不需要 返回值,就写 void -
方法名 : 合法标识符即可 -
参数列表 -
形参 : 方法的声明处,规定传入的数据的类型以及个数 -
实参 : 方法的调用处,传入具体的数据 -
方法体 : java代码 -
return : 终止方法执行,并且return后不可以写代码 -
1 没有返回值类型的时候(void) : return可以有 可以没有,如果有,return只能起到结束方法运行的作用 -
并且 语法是 return; -
2 如果有返回值的情况下(不是void) : 方法体中 必须要有return语句,并且return语句需要跟一个返回的数据 -
语法是 : 比如返回值为 int return int值 ;
6.3 方法调用
- 方法调用 :
-
方法不调用,不执行,调用才执行,并返回到调用处 - 方法定义的时候,是不执行的,也就意味着,编写方法的时候,不需要考虑先后顺序
-
只需要考虑 调用顺序即可 - 特殊方法main :
-
JVM自动调用main方法
6.4 方法分类
- 方法分类和调用
-
变量分类 : -
局部变量 : 方法内声明的变量 -
静态变量 : 类体中使用static修饰的变量 -
成员变量 : 类体中没有使用static修饰的变量 -
变量调用 : -
局部变量 : 方法内部之间写变量名调用 -
静态变量 : 类名.静态变量名,并且当前类中类名可以省略 -
成员变量 : 对象引用.成员变量名 -
如何区分同名的静态变量和局部变量 : 类名调用 -
方法分类 : -
静态方法 : 使用static修饰的方法,并且静态方法中不能有非静态引用 -
成员方法 : 没有使用static修饰的方法 -
构造方法 : 先不做了解 -
方法调用 : -
静态方法 : 类名.静态方法名(参数);,当前类中 类名 可以省略 -
成员方法 : 对象引用.成员方法名(参数);
6.5 方法重载
- 如何确定方法的唯一性?
-
名字 参数列表 - 方法重载 overload : 方法名相同,参数列表不同就是方法重载
-
参数列表不同 分为 : 个数不同和类型不同
- 栈内存 Question
- 程序 : 可执行文件,静态概念,一般保存在硬盘中
- 进程 : 正在执行的程序,是个动态概念,会把指定的程序载入内存中执行
-
运行起来的程序,就是指载入到内存中的可执行文件,这个时候操作系统会开启一个进程来运行这个文件对象,如果我们想要关闭某个程序,只需要杀死这个进程即可 - java中的内存划分和管理
-
java Runtime Data Area : java运行时数据区域,我们也可以叫JVM内存 -
首先,内存被划分为 五个区域 : 程序计数器 , 方法区/静态区/静态代码段 , 栈内存(虚拟机栈/VM栈) , 堆内存 , 本地方法栈 -
程序计数器 : -
占用较小的一块空间,作用可以看做是当前线程执行的字节码的位置的指示器,分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖于这个计数器来完成 -
可以理解为保存下一条语句的行号,依次向后递增 -
静态区 : -
是用来存放我们的程序文件的,载入到内存之后的程序文件对象的一段空间,java中就是指我们的class文件 -
包括方法,方法在被调用之前,都是以静态的形式被保存到静态区的 -
静态区中还有运行时常量池 -
栈内存 : -
以栈数据结构为模型,创建一段内存空间 -
栈数据结构特性 : 先进后出,像弹夹 -
用来执行方法,局部变量也是在栈内存 -
栈的构成 -
栈空间 : 就是指以栈数据结构为模型的一段内存空间 -
栈帧 : 栈内存中,每一个栈元素,叫栈帧 -
栈顶元素 : 最后一个放进去的栈帧 -
栈底元素 : 第一个放进去的栈帧 -
栈的操作 : -
压栈 : 就是指把元素放入栈空间的过程 -
弹栈 : 就是把元素从栈空间中弹出的过程 -
java中,方法调用,就是压栈操作,方法执行完 就是弹栈操作 -
堆内存 : -
用来存放对象,根据静态区中的class文件对象,创建的对象 -
每个对象空间,分为3块 -
数据部分 : 成员变量 -
头部 : hashCode值 -
类型 : 是哪个类创建的对象,保存的是类文件在静态区的地址,所以在成员方法中是可以直接访问静态属性的 -
本地方法栈 : -
用来执行native声明的方法,比如Object类中的hashCode()方法 - java程序的执行流程 :
-
1 java程序编写 -
文本编辑器,按照java规范编写代码 -
2 java程序的编译 -
javac 进行编译 生成 class文件 -
3 java程序调用 -
java xxxx -
3.1 开启java虚拟机,然后把程序对应的class文件,载入静态区 -
3.2 jvm自动调用该class的main方法,并且只有一个main方法,固定写法,java是单入口程序 -
3.3 main被调用之后,jvm就会在栈内存开辟栈帧,把main中的代码复制进去,然后开始执行 -
3.4 main方法执行流程 -
3.4.1 在main方法中没有其他方法调用 -
执行完main方法之后,main栈帧弹栈,结束,jvm关机 -
3.4.2 main中有其他方法调用 -
如果调用了当前类的方法,会在main方法栈帧之上,开辟新的栈帧,并把对应的代码复制进去开始执行,直到执行结束,返回到main栈帧的调用处,继续执行main方法 -
如果调用了其他类的方法,把对应的类载入到静态区,然后再开辟栈帧,复制代码,执行,执行完返回main,继续执行 -
如果被调用方法中,还有其他方法调用,就继续压栈,一直到main方法执行结束,弹栈,jvm关机 -
程序加载 : -
静态加载 : 程序开始执行,首先把所有和该程序相关的文件,全部一次性从硬盘载入内存 -
动态加载 : 程序开始执行,只会载入当前用到的文件,如果执行过程中,需要其他文件,再去硬盘中载入
11种基本数据类型 8种基本 3种引用 TODO 点击直接到那个地方 day05 8. 递归 8.1 概述和基本应用
- 定义 :
-
在方法体中 调用当前方法 - 基本思想 :
-
以此类推是递归的基本思想 -
也是循环的基本思想 所以循环和迭代是等价的(迭代就是循环) -
初始值,终止条件,步长 -
循环是重复执行循环体,而递归是重复执行方法体 - 应用场景
-
一般树状结构的都可以使用递归查询 -
比如 文件目录,因为不清楚到底有多少子目录,所以没办法使用for循环嵌套 - 常见问题 :
-
累加加和 -
阶乘 -
斐波那契数列 -
汉诺塔 -
文件目录操作
8.2 斐波那契数列
- 斐波那契数列
-
前两位是1 ,每位都等于前两位的和 -
1,1,2,3,5,8,13,21,34,55...... - 传入位数,获取第几位的值是多少
day06 9. 数组
-
数组 是引用数据类型
-
之前我们学习的变量,都只能存储单个元素,想要存储多个元素,就需要使用数组 -
数组 是一个源自底层的数据结构,并且几乎在任何语言中,都是最基础的数据结构 数组 又称为 索引数组(index) 9.1 数据结构
-
数据结构 : 计算机存储、组织数据的方式
-
就是计算机对数据存储的形式,和数据操作的形式 -
精心选择的数据结构可以带来更高的运行或者存储效率 -
数据操作
-
增删改查
9.2 数组概述和特性
-
并且 数组中元素的类型必须一致,意味着空间大小一致 -
数组在内存中是连续的内存空间,也就意味着,找到一个就能找到其他所有 -
默认使用第一个空间作为整个数组的地址,然后通过偏移量 找到其他元素 -
偏移量为 0 就是第一个元素 , 偏移量为1 找到的就是第二个元素, 偏移量为11 找到的就是第12个元素 -
像这种 通过内存地址,直寻法,查找效率极高 -
所以 数组的索引(下标) 是从0开始的 -
因为能够快速找到某个元素,所以想要更改某个元素的时候,只需要使用 = 赋值即可 -
所以 数组 查询和更改 效率极高 -
数组一旦确定,长度不能更改,想要添加或者删除元素,必须新建数组,然后把原数组中需要保留的元素,以及新插入的元素依次复制到新数组中 -
所以这样效率较低 -
数组特性 : 查询更改快,添加删除慢
-
数组 :
-
1 是引用类型 -
会占用两块内存空间 ,栈内存一块,堆内存一块,栈内存保存的是堆内存数组对象的地址 -
2 数组是一种线性连续存储的数据结构 -
3 数组就是一个容器,用来存储其他数据 -
数组可以存储任意元素,不过每一维元素类型必须一致(数组可以多维) -
4 数组长度一旦确定,不可更改 -
数组中 默认有个length属性,保存数组的长度 -
5 数组下标 从 0 开始 -
6 数组查询更改快,添加删除慢
9.3 数组声明
- 数组声明 :
-
1 静态声明 : 就是预先知道数组中的每位元素分别是什么 -
数据类型[] 变量名= {类型值1,类型值2,....}; -
int i = 1; -
int[] is = {1,2,3}; -
int[][] iss = { {1,2,3}, {1,2,3}, {1,2,3}}; -
int[][][] isss = { { {1,2,3}, {1,2,3}, {1,2,3}},{ {1,2,3}, {1,2,3}, {1,2,3}},{ {1,2,3}, {1,2,3}, {1,2,3}}}; -
..... -
2 动态声明 : 就是预先不知道数组中每位元素分别是什么,不过需要确定数组类型以及长度,先用对应的类型默认值占位 -
数据类型[] 变量名 = new 数据类型[长度]; -
int[] is = new int[5]; -
int[][] iss = new int[5][2]; -
int[][][] isss = new int[3][5][2];
9.4 数组使用和遍历 9.4.1 获取数据
- 获取数组中元素
-
数组变量[下标];
9.4.2 设置数据
- 设置
-
数组遍历[下标] = 值;
9.4.3 遍历数组
-
遍历
-
for(int i = 0; i< arr.length ; i++){ int value = arr[i]; System.out.println(value); }增强for循环 foreach 把数组中每一位元素拿出来,赋值给 变量 for(数据类型 变量 : 数组 ){
}
9.4.4 常见异常
9.5 数组传递
- 如果调用方法的时候,直接传递数组
-
方法名 ( new 数据类型[]{类型值1,类型值2,....} );
9.6 Main方法传参
- 二维数组 10.1 声明方式 静态 Int[][] arr = { {1,2,3,4,5}, {1}, {2,3}, … };
动态 : 二维数组中 有5个一维数组,并且每个一维 数组都有3个元素 Int[][] arr = new int[5][3]; 二维数组中有5个一维数组,并且这五个一维数组都是空的 Int[][] arr = new int[5][];
10.2 存储方式
10.3 二维数组使用
10.3.1 获取数据 变量[下标][下标]
10.3.2 设置数据 变量[下标][下标] = 值
10.3.3 数组遍历
10.3.4 二维数组中一维数组元素个数不同 使用动态声明的方式,定义二维数组,并且使二维数组中的一维数组元素个数不同
- 传值和传引用的区别 Here
- 传值和传引用
-
传值 : 指的是基本类型传递 -
传引用 : 指的是引用类型的传递 - 传值之后,如果在对应方法中将值更该,不会影响调用处的值
- 如果是传引用,被调用方法通过引用,把内存中数据更改的话,调用处再次通过地址找到空间后,值就发生更改了
-
数组复制
-
Scanner工具类
-
交换变量的值 14.1 借助中间变量
14.2 加减运算
14.3 移位运算交换
day08 15. 排序 就是让元素按照一个大小规则进行排序存储 1,3,2,5,7,4 1,2,3,4,5,7 7,5,4,3,2,1
比如 我们存储了班级内所有学生考试成绩 Double [] scores = {xxx,xxx,xxx,xxx,xxx,xxx}; 想要查看前三名怎么办? 降序排序,取前三个即可 15.1 冒泡排序
- 冒泡排序 :
-
1 比较相邻的两个元素,如果第一个比第二大,就交换位置 -
2 对每一对相邻的元素做同样的工作,从开始一对到最后一对,当一轮比较完之后,最后的元素,一定是最大的(最小的) -
3 针对所有的元素,重复执行上面操作,除最后一个元素 -
4 持续每次需要比较的队伍越来越少,一直到没有任何一对需要比较,终止 - 1 嵌套循环
- 2 内层循环取决于外层循环
- 3 需要一个中间变量
15.2 选择排序
- 选择排序
-
1 每次都把最小的/最大的放到最左边 -
先拿出第一个,假设是最小的,然后挨个和后面的比较,全部比较完之后,如果有比这个元素小的,就换位 -
2 嵌套循环比较 -
3 中间变量
15.3 API排序
- 查找元素
-
需求 :
-
给定一个数组,判断是否包含某个值,如果包含返回其对应的下标,如果不包含,返回-1 16.1 顺序查找
-
顺序查找 :
-
1 遍历数组,挨个比较 -
2 如果有和目标元素相等的,就返回该下标 -
3 如果循环完,都没有发现相等的,就返回-1 -
优点 :
-
编码简单,没啥逻辑,挨个比较嘛... -
运气好的话,碰巧前几个就是要查找的数据, -
缺点 :
-
查询效率相对较低 -
不能只拼运气好的时候 -
比如 有100W条数据,如果数据在最后几个的话,那么就需要循环执行100W次
16.2 二分查找
- 二分法查找 :
-
1 建立在排序的基础之上 -
2 数据没有重复元素,如果有,先找到那个算哪个 -
3 用于查找固定有序的数据 - 算法实现 :
-
1 确定起始和结束位置 -
2 确定中间数据,判断中间数据是否为目标数据,如果是直接返回 -
3 如果目标数据小于中间数据,则 起始值不变,结束值 为 中间值 -1 -
4 如果目标数据大于中间数据,则 结束值不变,起始值 为 中间值 +1 -
5 如果 起始值 大于 结束值 终止比较,说明不存在 -
6 重复执行以上操作即可
day09 17. 面向对象 17.1 概述
面向过程 : 侧重分步骤 比如做菜 1 买菜,买各种食材,买各种调料 2 开火,烧油 3 翻炒 4 出锅 … 面向对象 : 侧重分类/模块 比如做菜 1 完成做菜,涉及到的事物有 : 厨师,食材,工具 2 找个厨师,交给他 3 厨师.买食材 4 厨师.使用工具做菜
17.2 构造方法
- 编译器功能 : 能把我们代码编译成class文件,并且还会检查代码的语法,也会帮助我们补全不规范的代码
- 比如调用当前类中的静态变量的时候,可以省略类名,但是编译器会帮我们加上
- 同时如果我们类中没有构造方法,编译器也会默认帮我们创建一个公共的无参构造
- 构造方法 :
-
1 作用 : 创建当前类的实例化对象,初始化成员属性 -
2 初始化 : 赋值 -
3 静态变量什么时候初始化 : 类加载阶段(main方法执行之前) -
4 如果不定义构造方法的话,JVM会默认帮我们创建一个公共的无参构造 -
5 如果我们定义了构造方法的话,不管我们定义的是有参还是无参,那么JVM都不会再帮我们默认创建无参构造 -
6 构造方法默认是 : 公共的,静态的,没有返回值的,方法名和类名相同 -
public 类名(){} -
但是我们声明的时候 不能加static,因为构造方法具有双重性 -
如果 只是静态方法,那么 里面不能操作成员变量,也就不能对成员变量初始化赋值 -
如果 只是成员方法,那么就没有办法创建对象了,因为想要创建对象必须调用构造方法,而构造方法如果是成员的,想要调用成员方法必须先有对象 -
所以 构造方法 具有双重性,我们再声明的时候 不可以加static -
构造方法比较特殊 -
7 语法 -
[权限控制修饰符] 类名(参数列表){方法体}
17.3 类和对象
- 对象 :
-
1 代码角度 : new 的一个实例,封装了特有的数据 -
2 数据角度 : 封装数据和逻辑的一种方式 -
3 现实角度 : 对象就是某一个具体的东西,一切皆对象 -
4 设计角度 : 从一个实际的实体中抽象出来某些属性的一种实体表示 - 类 :
-
概念 : 我们再思想上对某个事物/东西/某一类东西的唯一性标识 -
是我们人,在思想上对某个事情/事物的一个界定(定义) -
是我们大脑对客观事物描述的一个标准,一个模板 -
我们再抽离某个概念,就能建立相关事物的类,一定通过他的数学来形成这个概念,通过这些属性来形成这个类 -
然后通过不同的属性值,形成了实体,就是那个具体的对象 -
通过不同的属性,划分不同的类,通过不同的属性值,划分不同的个体 -
属性分为两种 : -
1 静态属性 : 类的行为和功能 -
2 动态属性 : 类对象的行为和功能 - 但是在代码角度来说,类和对象都是保存数据的一种手段
17.4 实例化
- 实例化 :
-
类 变量 = new 构造方法(参数); -
1 加载类到静态区 -
2 调用构造方法(栈内存压栈,开辟栈帧),在堆内存开辟内存空间 -
3 把对应类中的成员属性复制到堆内存中 -
4 再把堆内存内存地址赋值给栈内存遍历
17.5 对象使用
17.6 类的构成
- 类 : 根据具体的事物/需求 抽象出来的属性特征,那么 类中都可以有什么呢?(java死规定)
- 1 main : 入口方法,只要该类不是用来作为启动类的,就可以没有
- 2 成员变量 : 每个对象共有的属性,属性值可以相同也可以不同
- 3 静态变量 : 每个对象共有的属性和值(保存在方法区)
- 4 局部变量
- 5 成员方法
- 6 静态方法
- 7 构造方法
- 8 抽象方法
- 9 静态语句块
- 10 动态语句块
- 11 this
- 12 super
- 类中只能出现这些,但是类中的一切都不是必须的,也可以什么都不写,但是如果写的话只能写这些
- 类库端 : 就是被调用的
- 客户端 : 就调用别人的
17.7 Bean
- javaBean
-
成员变量私有化 -
有对应的getter/setter方法 -
对应的构造方法
17.8 常见异常
- java.lang.NullPointerException :
-
空指针异常,是运行时异常 -
当使用null值(空的引用) 去访问成员属性的时候,就会出现空指针异常
- JVM特性 :
-
跨平台,面向对象,多线程,垃圾自动回收机制 - 垃圾 : 如果没有更多的引用指向这个对象,该对象被视为垃圾数据,等待被回收 Day10
- 面向对象 18.1 传值和传引用 // 基本数据类型 保存值的大小 , 引用数据类型保存内存地址 // 传值 基本类型传递 // 局部变量 属于栈帧私有化 栈帧独享
18.2 区分成员和构造
- 构造方法 :
-
[权限修饰符] 类名(参数) {方法体} - 作用 : 创建对象,初始化成员属性
- 方法声明 : [修饰符列表] 返回值类型 方法名(参数) {方法体}
- 方法名符合命名规则即可 : 字母,下划线,美元符号,数字,不能数字开头,不能使用关键字和保留字,建议望文知义, 驼峰命名法
- 方法目的 : 代码重用性,提高代码效率
- 问题
-
1 成员方法的方法名可以和类名相同吗?(成员方法可以和构造方法同名吗?) -
可以和类名相同 -
2 如何区分同名的成员方法和构造方法? -
看返回值,构造方法木有返回值,成员方法必须有返回值类型,如果没有用void表示
18.3 This 18.3.1 是什么
-
this是每个对象中,保存自身内存地址的一个引用类型的成员变量 -
所以说,this就表示对象自己,相当于我们说 "我" 一样
18.3.2 能干什么
-
this能干什么? -
1 在成员/构造方法中,能够区分同名的局部变量和成员变量 -
2 在构造方法中,也可以用于重载调用当前类中其他的构造方法(必须在第一行) -
3 return this 返回当前对象内存地址,可以做到链式调用
18.3.3 怎么用 18.3.3.1 区分局部变量和成员变量
18.3.3.2 重载调用构造方法
- this重载调用当前类的其他构造方法
-
必须出现在构造方法第一行 - 语法 :
-
this(参数);
18.3.3.3 链式调用
- 链式调用 : xxx.方法().方法().方法()…
- 核心点 : 前者方法返回值一定是可以调用后者方法的 引用
18.3.4 注意 This不能出现在静态上下文中
18.4 Static 18.4.1 是什么 static是一个修饰符关键字,用来区别静态和动态属性 18.4.2 能干什么
- static修饰符
-
1 static修饰的类体中的变量是静态变量 -
2 static修饰的方法是静态方法 -
3 static修饰的语句块是静态语句块
18.4.3 怎么用
- static修饰符 1 static修饰的类体中的变量是静态变量 2 static修饰的方法是静态方法 3 static修饰的语句块是静态语句块
- 语法 : static { java代码; }
- 静态语句块是在类加载阶段执行,并且只执行一次,并且是从上往下执行
- 静态变量也是在类加载阶段初始化,并且和静态语句块没有优先级之分,从上向下执行初/初始化,所以 不能再静态语句块中 提前使用静态变量,而在方法中是可以的
- 什么情况下 类加载 : 访问某个类的静态属性的时候,类加载
18.4.4 实例语句块
- 实例语句块
-
语法 : { -
java代码; -
} -
实例语句块等同于成员方法,只是没有名字 - 执行顺序 : 静态语句块 > main方法 > 实例语句块(需要new对象 才会执行)
18.4.5 静态调用
- 静态调用,使用类名调用
- 那么可以使用对象调用吗? 可以
18.4.6 静态和成员的区别及应用场景
- 变量分类 :
-
静态变量 : 类中使用static修饰 -
成员变量 : 类中非static修饰 -
局部变量 : 方法中声明的变量是局部变量,作用域让当前方法使用 - 初始化时机 :
-
静态变量 : 类加载阶段初始化 -
成员变量 : 创建对象的时候初始化(构造方法) - 应用场景 :
-
静态变量 : 类级别的,是所有对象共享的,比如一个静态变量 age = 10 ,那么说明所有对象都有这个age属性,并且值都是18 -
所有对象共有的属性和值 -
成员变量 : 对象和对象之间有相同的属性,但是可能有不同的值,非对象共享
18.5 封装
封装是把对象的所有组成部分组合在一起，封装使用访问控制符将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。 作用 适当的封装可以让代码更容易理解和维护，也加强了代码的安全性。
18.5.1 软件包机制 18.5.1.1 Package
- 目标 : 当前文件的编译和运行
- 软件包机制 :
-
1 为了解决类的命名冲突问题 -
2 在java中使用package语句定义包 -
3 package语句只能出现在java源文件中的第一行 -
4 包命名通常采用公司域名倒叙 -
5 package限制的是class文件的放置位置(编译之后,把class文件放到哪里去) -
com.tledu.oa.system -
以上包命名可以体现出来 : 这个项目是天亮教育开发的OA项目,当前处于OA项目中的system模块 -
6 完整的类名 是带有包名的 -
7 带有包名的文件,编译应该是这样 -
javac -d 生成路径 java源文件路径 -
javac -d ./ -encoding utf-8 _01_Package.java -
8 运行 -
java 包名.类名 - 什么是文件名 : 能够找到这个文件的全路径
18.5.1.2 Import
// 导入单个类 //import _05_Package.com.B; //import _05_Package.com.C;
import java.util.Date;
// 导入该包下所有类 import _05_Package.com.*;
// 导入该类中所有的静态属性(静态变量/静态方法),让当前类可以不加前缀,直接调用 import static _05_Package.com.B.*; /**
- import :
-
1 引入其他需要的类 -
2 只能出现在package语句执行,class语句之上 -
3 java核心类不需要导入,可以直接用,其他都不行 -
java.lang - 语法 :
-
import 包名.类名; 导入单个类 -
import 包名.*; 导入该包下所有的类 - 注意 : eclipse编程过程中,按空格的时候 会自动导包,如果程序没问题,但是报错,可以查看是不是包导错了
- 导入该类中所有的静态属性(静态变量/静态方法),让当前类可以不加前缀,直接调用
-
import static _05_Package.com.B.*; -
不建议这样使用,在当前类中,不容看出来,这个变量是谁的变量
18.5.2 权限修饰符
- private 私有化权限修饰符 ,除了自己(当前类)之外,都不能访问
- public 公共的权限修饰符 , 谁都能访问
- 不写权限修饰符的时候 : 要么当前类中使用,要么当前包中使用
- protected 受保护的权限修饰符 , 要么同类,要么同包,要么有继承关系
Day11 19. 继承 19.1 是什么
- java 中只支持单继承,一个类只能有一个父类
- 什么是继承 : 提高代码的复用性,父类的功能,子类可以直接使用,使子类功能更加强大
-
在java中 使用extends 关键字表示 -
语法 : public class 类名 extends 父类名{ 类体 } - 目的 : 提高代码重用性
- 一个类如果没有显示继承另外一个类的话,那么该类默认继承 Object
-
java.lang.Object 是java中的祖类(祖宗) -
也就意味着 Object中的属性 是所