JAVA基础9天笔记

第一天

1. 命令符快捷键

Tab ：命令提示符窗口里，打首字母后按Tab 可以搜索所有带有该首字母的文件夹/文件。

快速在该路径打开命令提示符窗口：在文件夹目录路径框位置写cmd

快速搜索使用过的命令：在命令提示符窗口里，按↑/↓键即可

notepad快速打开命令提示符窗口: 文件->打开文件所在文件夹->命令行

2.配置环境变量

若不配置：只能在有java软件的文件夹bin里用

配置：所有文件夹可用

如何配置：右键我的电脑->设置->属性->高级系统设置->环境变量->系统变量->

方法1：新建（变量名：JAVA_HOME，值：java所在文件夹路径【不到bin路径】) 和编辑（变量名为Path的值：%JAVA_HOME%\bin;放在最前面），

方法2：新建（变量名：JAVA_HOME，值：java所在文件夹路径【不到bin路径】) 和编辑（变量名为Path的值：java所在文件夹路径加分号放在最前面）

如果有classpath，需要删除

3.JAVA程序开发步骤

编写（后缀名改成java）->编译（将后缀名为java的文件编译成后缀名为class的字节码文件）->运行（运行后缀名为class的文件）

在编写时：

括号成对出现，不要写单个，避免遗忘另一个

字母大小写

英文的符号：例如双引号，分号

class类名称和文件名称一致

在编译时：

在该文件路径下编译

在运行时：

不要加class后缀

修改java源代码时，需要重新编译生成新的class文件，才能出现改后效果

4.注释和常量

单行：//这里是注释内容

双行：/*里面是注释内容 */

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hzi2jnu2-1614822567694)(E:\JAVA\NOTEBOOK\基础班\day01\day01图片\注释和常量.jpg)]

5.数据类型

引用数据类型：字符串 （String）

数据类型的表示范围与内存范围无直接关系

6.变量

变量名相当于一个容器，变量值就是暂时放入容器的数值

定义变量需要赋值（定义变量时，需要数值，才能使用）

变量名不能重复

Long类型为防止整数过大（默认int类型），数值后面需加L

Float类型为防止类型不兼容（默认double类型），数值后面需加F

7.标识符：

会在变量名、类名、方法名这些地方出现

组成：数字（不能以此开头）、字母、下划线、美元符

不能是关键字，区分大小写 （eg：Class不是关键字class，所以Class可用，class作为关键字不可用）

常见命名：

​ 小驼峰法：方法、变量

标识符为一个单词时：首字母小写

标识符为多个单词时：首单词首字母小写，之后单词首字母大写

​ 大驼峰法：类（类的功能名，eg：求和为Sum）

标识符为一个单词时：首字母大写

标识符为多个单词时：每个单词首字母大写

8.数据类型转换

自动类型提升：小 -> 大 （可行）

强制类型转换：大 -> 小 （出现两种情况）

情况1： 安全强转 （大类型小数值–>小类型大数值，该小类型的数值范围可包括小数值）

整数情况2：不安全强转（（大类型大数值–>小类型小数值，该小类型的数值范围不包括大数值）称为数据溢出

浮点情况3：不安全强转（小数转为整数，称为精度缺少）

​ 强制类型转换格式：

目前数据类型 变量名 = （目前数据类型） 需强转的变量名/变量值

第二天

1.算数运算符

/ ：除法操作，整数除以整数只能得到整数 （eg：8/6=1）

% ：取余操作，两个数相除取余数 （eg：8%6=2）

​ 用于判断：是否是某数字的倍数

​ 奇偶数

+：三种用法

​ 1.数学运算

​ 2.当数学运算中有包含字符，字符会转换成数字进行运算

​ (eg：int a = ‘a’ +1 该字符‘a’会转换成97 所以a=98)

美国设计编制了一张字符和二进制的对照表（ASCII）：

字符为该国家常用的字母、数字、运算字符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tFs5rlEV-1614822567698)(E:\JAVA\NOTEBOOK\基础班\day02图片\字符对应数字.png)]

byte, short, char 在参与运算的时候会自动转换成int类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aDQjb0p6-1614822567699)(E:\JAVA\NOTEBOOK\基础班\day02图片\自动提升为int类型.PNG)]

​ 3. 进行字符串的拼接（字符串连接符）

任何数据类型和字符串进行+操作，都会变成字符串

（eg：“Hello”+5+10–> Hello510）

有小括号，先算小括号，小括号为优先级

无字符串情况先运算，等碰到字符串再变成字符串

（eg：5+10+“Hello”+5+10–>15Hello510）

2.赋值运算符

=： 把右边的数值赋值给左边类型的变量名

+=：把右边的数值和左边的变量名的变量相加，得出的结果赋值给左边

赋值的式子前面不需要加类型

​ （eg：int i=10；i+=20；–> i =30）

​ （eg：short s=10; s+=20或者s=(short)(s+20);–> s =30）

也可说： 变量值自增右边的数值

组合赋值运算符隐含强制类型转换

剩下的-=，/=，%=的赋值过程与+=同理

3.自增自减

自增：++ （对变量自增1）

自减： – （对变量自减1）

独立使用（最长见用法）：

​ 符号前后都可放，更多情况放后面 （eg：i++）

参与操作使用：

​ 符号放后面：先做赋值，再自增或自减

​ 符号放前面：先自增或自减，再做赋值

[ eg：int a = i++ System.out.println(5+i++)

​ System.out.println(i++) ]

4.关系运算符和逻辑运算符

关系运算符：

​ <，>，==，！=，<=,>=

得出的结果是boolean类型

1.逻辑运算符

​ 多个条件是否同时成立：& 与

​ 是否成立其一： | 或

​ 判断条件是否不同（不同是true）：^ 异或

​ 对条件返回的布尔值取反： ! 非

​

得出的结果也是boolean类型

逻辑运算符与关系运算符一起使用

2.短路逻辑运算符

短路与：&&

​ 单个与&，两边都要执行

​ eg： int i =10; intj =20;

System.out.println((i++>100)&(j++>100))

​ 短路与&&，两个都要true,才是true

一个是true + 一个是false=false

若是第一个是false，第二个则不执行，

若是第一个是true，第二个才会执行

& true&false false

​ false&true false

&& true&&false false

​ false&&true false

短路或：||

一个是true + 一个是false=true

一个是true + 一个是true=true

若是第一个是true，第二个则不执行，

若是第一个是false，第二个才会执行

| true&false true

​ true&true false

​ false&true true

​ false&false false

|| true&false true

​ true&true false

​ false&true true

​ false&false false

5三元运算符

三元：

​ 数据类型 变量名 = 关系表达式 ？ 表达式1 ：表达式2；

若是关系表达式的值为true，表达式1的值就赋值给变量名

若是关系表达式的值为false，表达式2的值就赋值给变量名

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yzjWE0IY-1614822567701)(E:\JAVA\NOTEBOOK\基础班\day02图片\三元举例.PNG)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HEAH4btg-1614822567702)(E:\JAVA\NOTEBOOK\基础班\day02图片\三元举例2.PNG)]

表达式的值可以是数值，也可以是字符串

（见OperatorTest02, 在java practice文件夹里 ）

6.数据输入

使用步骤如图

见代码ScannerTest,在 java practive 里面

7.流程控制语句

7.1 顺序结构

​ 控制程序执行流程的代码

​ 最基本，最简单，流程控制，无特定语法结构，

​ 按代码顺序依次执行

7.2 分支结构（if, switch）

1.1 if语句

​ 可条件判断，也可条件匹配

格式： if (关系表达式) { 语句体 };

先计算值 -->若为true达成条件–> 执行语句体

​ —>若为false–>不执行

然后再继续执行后面的代码

关系表达式eg：a>b

语句体：System.out.println(“输出内容”)

1.2 if…else语句

格式： if (关系表达式) { 语句体1 }; else{ 语句体 2 };

先计算值 -->若为true–> 执行语句体1

​ —>若为false–>执行语句体 2

1.3 if…else…if 语句

格式： if (关系表达式) { 语句体1 }; else if{ 语句体 2 };…else {最后一个语句体}

先计算值 -->1.若为true–> 执行语句体1

​ —>2.若为false–>执行语句体 2

​ 3.—>语句体 2所得的值若为true–>结束

​ 4.—>语句体 2所得的值若为false–>执行语句体 3

​ 5.—>以此类推

​ 6.1—>若所有关系表达式都为false–>就执行最后一个语句体

​ 6.2—>或者先将所有会出现错误的可能性先用关系式写在最前面，可节省电脑性能

程序健壮性：设计程序时需考虑全面，

​ 输入范围内和输入范围外的情况

​ 需要进行的数据测试：正确数据，边界数据，错误数据

上图最后的一个else需要补充意外情况

该方法节约电脑性能

if 和 switch 的区别

if:可以进行范围的判断，也可以进行值的匹配

switch：只能进行值的匹配

第三天

2. switch语句

（例如月份、星期）

只适用：条件匹配（不能范围判断）

语句灵活，多匹配选项可上下切换，包括default

default 最后执行，不受位置影响

break 关键作用是结束switch，只有遇到break才会结束程序

表达式里面可用：byte、char、short、int、string、枚举

7.3 循环结构 （for, while, do…while）

1. For

1.1格式

for(初始化语句;条件判断语句;条件控制语句){语句体；}

初始化：循环第一次后，初始化变量

​ （循环结束后，该变量访问不到）

条件判断：若满足条件–>继续循环。反之结束

条件控制：每次循环后，对初始化变量进行操作

​ （通常为自增/自减）

​ 条件控制可以放到循环体

语句体/循环体：System.out.println (需要循环的内容);

​ 或者嵌入其他结构语句（eg：嵌入if语句判断满足条件后再进行操作）

​

1. 2用For 来求和

先定义一个变量Sum （累加器）

再用For 格式进行循环（在语句体的位置对Sum进行变量操作）

最后输出Sum

1.3 for的好处

提高代码复用性：减少代码编写

提高可维护性：若修改代码，过程简化，避免出错

知道循环次数，建议用for

1.4 for循环打印水仙花数

水仙花数：三位数

分析：

​ 1.使用循环找所有的三位数，挨着进行判断 100-999

​ 2.判断 个位³+十位³+百位³=这个数本身 （i）

​ 公式：

​ 个位： %10

​ 十位： /10%10

​ 百位：/100%10

见day03图片：for循环

2.while循环

格式

不知道循环次数，建议用while

java practice --> WhileDemo代码

3.do…while语句

4.死循环

永远停不下来，判断条件永远成立 （eg忘记条件自增）

循环停止条件：判断条件不成立，停止循环

代码不要写在死循环后面

可按Ctrl+c停止循环

死循环在达到某种条件后，手动停止

5.跳转控制语句

break：终止循环语句的执行

continue：跳过当前循环，继续下一次循环

6.循环嵌套

循环中还有循环

内层循环1圈完整的循环=外层循环第一个变量

内层循环n圈完整的循环=外层循环1圈完整的循环（n个变量）

（类似时针分针，内层=分针，外层=时针

​ 分针走完1圈60分钟，时针走完1格1小时）

行是外圈，列是内圈

轮数是外圈，次数是内圈

8.随机数

在一个范围内，随机生成一个数

1.导包 import java.util.Random;

2.创建对象 Random ran = new Random ();

3.生成随机数 int num=ran.nextInt (结束数字);

随机数范围从0开始，例如结束数字为10，那么取值范围为0-9

生成任意范围随机数 int num=ran.nextInt （后-前+1）+前

后：结束数字

前：开始数字

第四天

1.IDEA开发环境

1.自动编译，直接点击运行代码，直接显示代码效果

2.自动导包

3.对文件的进行划分 项目-模块-包-类

4.快速补全代码

2.数组

概念： java中的一种容器，存储的是同一种类型

数组的定义格式

1 数据类型[]变量名 eg： int[] arr

2 数据类型 变量名[] eg： int arr []

数组初始化

1 动态

格式： 数据类型 [] 变量名 =new 数据类型 [数组长度]

不固定值，直到要用时

创建一数组，并指定长度，系统会分配默认值给每个元素

int 类型：默认值为0

boolean类型： false

char类型： /u000 不可见字符

string类型： null 所有引用数据类型，默认值都是null

eg：

int[] arr = new int [3];

System.out.println (arr);

其中打印的arr得出的 [@8880ec60

这串是int [3]在内存储存的地址，而不是结果

索引

索引值：数据中存储元素的编法，用于访问数组中的数据

从0开始，连续，逐增1

异常

索引越界：当访问的数组的索引值超过最大索引值的时候

空指针异常：当引用数据类型的值是null的时候，且使用该变量去访问元素、调用方法，都会发生空指针异常

2 静态

格式

1.标准写法：int [] arr=new int [] {1,2,3,4,5};

2.省略写法： int [] arr={1,2,3,4,5};

里面的数值称为元素

3 动态和静态的区别和共性

区别

1.创建：动态不指定内容由系统分默认值

​ 静态制定数组中元素内容

2.元素内容：动态不知道元素内容的情况下创建的

​ 静态知道

3.数组定义：动态可拆分数组定义，先定义再赋值

​ 静态标准格式可拆分，省略格式不可拆分必须定义赋值一起写

共性

数组是定长的，定义时必须指定长度，长度一旦确定在【运行期间】不可改变

4 如何获取数组长度

打印arr.length

或者用快捷键 arr.fori生成for循环

快捷键：快速生成指定长度的for循环： 循环次数.fori

​ 想遍历数组：数组名.fori

5

假定一个最大值

获取数组中每个元素，和max进行比较

若获取元素大，替换max变量值

5.数组遍历（见第5天9）

6.数组元素交换（见第6天4）

3.java 虚拟机

1.栈：

存储局部变量

方法执行是在栈中执行

方法执行进栈，执行完毕出栈

2.堆：所有new出来的东西都在堆中

在堆中开辟一块内存，里面的地址值会交给栈内存中的变量引用

当没有任何变量引用该地址时，就会被垃圾回收器回收

3.方法区：

java类编译之后，会在方法中生成信息

4.本地方法栈：

java中有些方法不是java语言编写的，需要本地方法栈加载

5.寄存器：

跟操作系统相关的内容

第五天

1.方法

循环是对重复代码的抽取，
方法是对逻辑的抽取，
eg:每次考试的过程一样，分数不一样，考试逻辑抽取到方法中，
考试分数有参数决定

概念：方法=函数，特殊功能代码集

函数：定义一个计算公式，将数据按公式进行计算得出结果

好处：提高代码复用性。定义一次，多次使用

分析：1.明确参数列表 2.明确返回值类型

2.定义

方法先定义，定义位置在类中方法外

语法格式： 【public】【static】返回值类型 方法名称（参数列表）{方法体；}

带参数定义格式： public static void 方法名（参数1，参数2，参数3）{方法体；}

返回值类型：void

参数列表中的参数：形参 （形式参数）

调用方法的时候传递的参数：实参 （实际参数）

3.调用

调用位置：方法是在方法中调用的

方法格式：方法名称（参数列表）；

方法不调用不执行

调用时–>找定义好的方法代码–>依次执行

编译阶段：检测先有方法定义，才能调用

运行阶段：从main方法开始运行，

代码是方法的调用=去找相应方法

参数列表：方法执行时需要接收的数据，用变量进行站位，

将来调用时传的数据=变量赋值的数据

定义方法求两个数的较大值--> 需要将结果进行返回
返回值类型 没有void

定义方法打印两个数的较大值-->先求出两个数的较大值，再方法中打印输出

封装性：将实现的逻辑隐蔽，之外提供访问方式

4.返回值

返回值：public static 返回值类型 方法名 （参数列表）
1.如果该方法需要返回数据，需要指定返回值类型
返回值类型=返回值数据的数据类型
2.若不需要返回数据，返回类型写void
3.如果写了有返回值类型，方法中必须有return 返回值数据；
4.return返回到方法的调用处

return：
1.return后面跟的数据=返回值的数据，
return数据类型=方法定义是的返回值类型
2.若方法定义时，有返回值类型-->必须在方法中进行数据返回
若没有返回值类型-->可以写return，此时表示方法结束，后面代码不执行

一个方法只做一件事：

/*定义方法1：求两个数的和-->有返回值，只做了求和
定义方法2：打印两个数的-->无返回值，方法中即求和又打印

不定义返回值void在方法中打印
问题：打印语句是写死的，用户可能不想打印这个数据，想用这个数据用在别的地方
解决： 一般讲数据计算的过程 和对结果的处理 分开
单一职责： 强烈建议一个方法只需要做一件事，不希望做多件事 解耦合

5.方法调用格式

1.单独调用： 一般使用无返回值方法（void）

直接调用方法，不适用变量接收返回值。

有返回值和无返回值的方法都可以单独调用

但是有返回值的方法单独调用没有意义

eg： getsum2（参数1，参数2）

2.赋值调用（常用）：调用方法，并使用变量去接收方法的返回值

eg： int sum = getsum2(参数1，参数2)

有return的，void变成int

3.打印调用：

在输出语句中调用方法，输出语句会将方法的返回值打印输出

只能用于有返回值的方法，需要打印时拿到方法的返回值

打印调用只能对方法的返回值使用1次，

若以后再想用这个结果，无法使用

6.注意事项

7.方法重载

概念：方法名称相同，参数列表不同

相关：方法名称、参数列表(保证方法名称相同，参数列表不同)

无关：返回值类型

参数列表不同：类型，数量，顺序

计算器

问题：若需要定义的功能类似，但参数不同，

需要定义很多方法， 对用户体验不好，

他想实现1个功能，要记很多方法名称

解决方法：

只记一个方法名称就能完成多个加法计算操作

多个方法只需要定义同一个方法名

8.方法传递

基本数据类型的方法传递：不影响实际参数，数值是在栈内存存放

随着方法出栈消失，所以不影响实际参数

数组的方法传递：引用数据类型的形式参数影响实际参数

因为传递的是地址值，数组的元素是在堆内存存放

9.数组遍历

发现问题：数组的遍历操作在程序中非常普遍，

可将遍历操作封装成方法，

将来可调用遍历方法完成任意数组的遍历

E:\JAVA\intelliJ\111\day05\src\method1\printAll.java

E:\JAVA\intelliJ\111\day05\src\method1\print1.java

第六天

1.Debug

断点：追踪执行流程

标记断点之后，程序运行debug会停在断点，

可手动执行程序，

可标记多个断点，断点间可跳跃，代表执行两个断点间的代码

程序可重新运行debug

可查看所有断点位置，并在断点执行期间，取消断点

可在断点执行期间直接结束

2.查看方法调用的执行流程

断点没法跳过键盘录入的数值，

若断点在键盘录入的后面需先录入才能停到断点位置

3.断点按钮

​ 1.step over:执行下一步，遇到方法不会进入方法，直接获取方法的执行结果

​ 2.step into:执行下一步，遇到方法进入方法执行

​ 3.force step into:执行下一步，遇到方法进入，遇到java编写的方法也进入（进入源码）

​ 4.step out:程序执行在方法中，跳出方法，默认方法执行完毕

​ 5.drop frame：跳出方法，让方法回到未执行状态

​ 6.run to cursor:跳到光标所在行，中间代码默认执行

若是断点和光标间有断点，会先跳到下一个断点位置

4.数组元素交换

​ 1.数组元素交换就是对称元素位置的互换

​ 2.之前遍历数组，都是一个索引值int i =0

这个需求需要首尾互换，需要两个索引值完成

​ 3.完成两个元素的内容交换

完成两个变量的值的交换

需要第三个变量做倒手

int temp=arr[min];

arr[min]=arr[max];

arr[max]=temp;

​ 4.停止交换

1）min=max 停止交换

2）当max>min停止交换

第七天（分水岭）

1.面向对象

面向对象（以后的思考方式）：

做一件事，不需要自己考虑现实步骤

找一个能帮我们完成这件事的人（此人为对象），

让他完成，给出反馈

三大特征：封装，继承，多态

在开发中怎么做？（面向对象的思想）

实现一个需求（功能），先看java有没有给我们提供相应代码

eg：随机数， 键盘录入，按照指定格式打印数组，数组排序，保留几位小数，求立方…

找到java中这些类（已写好这些功能），创建对象，调用这个对象的方法帮我们

若没有找到，再去自己编写一个类（可重复利用），实现这个方法

面向过程（前6天的思考方式）：

完成一件事要亲力亲为

考虑每个实现步骤和细节

2.类和对象

类：

对现实生活事物的描述

类是对象的数据类型

对象的模板

是方法的集合，里面有很多方法

维度：属性（该事物具有的信息特征） + 行为 （该事物能做的事）

eg：想完成计算机基础加减乘除功能，可设计4个方法归于1个类中

存储位置：看得见摸得着，存在硬盘上.java文件

对象

只要有实体，万物皆对象

根据类创建的实体

可根据1个类创建多个对象，给对象赋不同的值

存储位置：根据.java文件串讲，在堆内存中的空间

局部变量：

定义在方法中的变量

在栈内存

之前写的变量都是局部变量，定义在main方法中

不赋值不能使用（在调用方法的时候需要赋值才能使用）

成员变量：

定义在类中方法外的变量

在堆内存

不赋值会有默认初始值

整数 0， 小数0.0

字符 不可见字符

布尔 false

引用数据类型null

1个类只负责一件事

做两个类：

1个类负责定义功能

​ 定义成员变量（属性）

​ 定义成员方法（行为）

1个类负责运行代码

​ 对变量赋值

​ 调用变量

​ 打印

​ 运行

3.private封装

封装:将细节隐藏，对外提供访问方式

把类似（有关联）的内容打包放一起，外界可以通过对象的方式去访问

private 关键字使用步骤：
1.定义类时，类中成员变量需要加上private关键字，
私有（只能在本类中访问，外界不能直接访问）
2.类中提供对应getXxx和setXxx方法，外界通过get和set方法进行取值和赋值
3.在测试类中，只能通过该get和set方法进行对象中成药变量的取值和赋值，
防止用户随意对成员变量赋值

问题：在类中定义的成员变量，赋值的时候符合语法，但不符合常理

解决：对成员变量赋值时，在规定方位内赋值成功，否则赋值失败

java中的封装思想：对外隐藏实现细节，只提供访问方式

1. 方法就是一种封装–>在调用方法时，不需要分析方法是如何实现的，
   只需要知道：方法名、参数、返回值

2. private 关键字也是一种封装–> 不对外提供变量的直接访问，
   而是将访问封装为一种方法，用户想访问必须通过方法访问

方法是对细节的封装，类是对方法的封装

4.this关键字

定义对外访问方式： 
getXxx setXxxx 在后期学习框架时，会根据方法名进行自动封装
快捷键：右键--generate--getter and setter --按ctrl全选
或者alt+insert--getter and setter--按ctrl全选

在负责定义功能的类中（堆内存）
1.定义变量名
eg：private String name;
2. 定义方法setXxx， 限制条件
eg：public void setName (String n){name=n;}
3.定义方法getXxx，返回Xxx
eg: public void getName () {return name;}
4.方法中的变量的访问：选择就近原则
eg：在1中赋值了name，在2中让 String name，且name=name
这时候string 中的name是等式中的第一个，而不是第二个
这时候需要用this.name=name, 用this.name指代1中的name

this关键字： 谁调用方法，this就是谁

在负责运行代码的类中（测试）（main方法里栈内存）
1.定义new 
eg: student2 s1=new student2();
student2 为负责定义功能的类名
2.变量名.setXxx（输入内容）；
eg: s1.setName("Lee");
3.在打印里面输入变量名.getXxx
eg: System.out.println (s1.getName)
4.以上3点都需要在main方法里面

封装性的好处：

1、提高代码的复用性

2、相似功能的方法集合在一起，便于使用和管理

5.构造方法

构造方法：用于创建对象

用于创建对象时初始化对象鸿的内容

1.无参构造：创建对象时，不传递任何参数

2.有参构造：创建对象时，传递参数

参数会赋值给对象中的成员变量

3.若不写任何构造方法， 编译器会赠送一个无参构造

4.如果有写有参构造，编译器不会自动赠送无参构造，需要手动写

5.编写时，需要两种都写

格式：

修饰符 类名 (参数) {}

修饰符一般用public

1.有成员变量
2.构造方法
   有参构造
   无参构造
3.成员方法
   普通成员变量方法
   get/set方法

设计程序的必备要求

高内聚（把相关内容都放一起），

低耦合（保证这些功能互相之间不依赖）

1.可维护性

当我们需要修改代码时，只需要修改1次，

所有用到的地方都会跟着改变

2.可扩展性

当需要增加功能时，只需要添加一个方法，就能完成功能的扩展，

不需要动其他的方法

3.可复用性

一段代码可重复利用，减少编码篇幅

4.灵活性

各个模块（方法）间可随意组合

第八天

1.API

Application Programming Interface 应用程序编程借口

java所有类、借口、抽象类的字典

若想使用java提供好的类，可查询API，找到对应的类，

查看对应的方法， 调用

操作步骤

1.在API中搜索想要使用的类

2.看包路径（eg：java.util）

3.看构造方法/构造方法摘要

4.看成员方法/方法摘要

String 类是在java.lang的包里面，不需要导包

2.String 类型的特点

字符串长度不可改变，值不可更改

字符串的值可以被共享（将字符串存在字符串常量池中，下次引用时，可去常量池里找）

常量池在堆内存中

字符串效果上相当于字符数组拼接，但是底层使用字节数组存储

直接引号“”引起来的字符串，会被放在字符串常量池中

可提高执行效率，每次用到相同字符串对象，可先去找，如果有就直接引用，若没有就再创建，再放到池子中

3.字符串的遍历

1.需要知道循环的次数，就是字符串的长度

2.需要拿到索引值，就可以获取到字符串的每一个字符

3.若表示获取的每个索引值位置上的字符

​ char c = s.charAt（索引值）；

只要有索引值的字符串（String）或可变字符序列(StringBuilder)都可以用 变量名.charAt（索引值）

变量名为String或者StringBuilder的变量名

4.==和equals

==

在基础数据类型的情况下比较的是值

在引用数据类型的情况下比较的是地址值

equals

在应用数据情况的下比较的是值，比较的是内容

5.字符串反转和拼接

字符串因为不可变的特点，所以我们不可能在原有基础上改变，必须生成一个新的字符串

正确例子：

*StringBuilder sb = new StringBuilder(); *

sb.append(“d”); sb.append(“e”); sb.append(“f”);

String s = sb.reverse().toString();

字符串不能反转，所以要先用可变序列（StringBuilder）进行反转，然后再转换成字符串

若是用String s = sb.toString().reverse(); 就是是错误的

可倒叙遍历，然后再拼接

要拼接就需要用到new StringBuilder然后再用append拼接

StringBuilder/append/链式编程

字符缓冲区
由于实际开发总字符串拼接是非常频繁的操作
若一直用String字符串进行拼接，效率低下
使用StringBuilder提高程序的执行效率
对象每次拼接不会产生新的对象，而是在原有对象的基础上改变
所以是对同个对象进行操作

StringBuilder属于类

是一个可变的字符序列

StringBuilder(”字符串内容“)

append是追加内容

链式编程

使用返回值作为下一个调用方法的对象

链式编程只能调用1次方法，

若想多次调用，建议用普通方式

E:\JAVA\intelliJ\111\day08\src\practice\stringbuilder.java

String和StringBuilder二者之间如何进行互相转换

String–>StringBuilder：通过StringBuilder的构造方法StringBuilder（String s）

StringBuilder–>String：String调用StringBuilder中的toString方法

toString：返回此对象本身（它已经是一个字符串！）

第九天

1.ArrayList集合

成员方法

public boolean remove (Object o)

删除指定的元素，返回删除是否成功

public E remove (int index)

删除指定索引处的元素，返回被删除的元素

public E set (int index, E element)

修改指定索引处的元素，返回被修改的元素

public E get(int inxex)

返回指定索引处的元素

public int size ()

返回集合中的元素的个数

public boolean add (E e)

将指定的元素追加到此集合的末尾

public void add (int index,E element)

在此集合中的指定位置插入指定的元素

集合：装数组的容器，且长度可变

• 初始化长度是10（集合初始化长度就是一个长度为10的数组）

• 当集合中元素数量<=10，不需要扩容，直接往集合中添加元素

  若>10，集合会扩容

• 只能存引用数据类型，

  若想存数，只能用基本数据类型的包装类

• 创建长度不指定长度，直接打印变量名得到集合内容

• 集合获取长度 数组名.size

数组：也是容器，

但是长度在运行期间不可改变，不能往数组中添加元素，

固定长度的容器，在存储或删除数据会特别麻烦

若数据数量发生变化，每次都要重新创造新的数组，非常消耗资源

创建对象必须指定长度，直接打印数组名得到地址值

数组获取长度 数组名.length

ArrayList

此为泛型：广泛的数据类型

括号里面的E是想储存的数据类型，若想存String就填String

public class addfactor {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("java");
        System.out.println(list);
		boolean b1 = list.add("777");
        System.out.println("是否添加成功:"+b1);//777会添加到列表的尾部
        list.add("555");//在集合列表的尾部添加指定元素
        list.add(3,"aaa");//可在集合指定位置添加指定元素，但不能跳跃添加，3为索引值
        System.out.println(list);
         boolean b2 = list.remove("java");//会将第一次出现的java元素删除
        System.out.println("删除是否成功："+b2);
        System.out.println(list);
        String remove = list.remove(2);//删除指定索引位置上的元素，返回值是被删元素
        System.out.println("被删除的元素是："+remove);

ArrayList若想存储学生对象，就需要创建一个学生类

2.学生管理系统

1.增删改查功能

ean remove (Object o)

删除指定的元素，返回删除是否成功

public E remove (int index)

删除指定索引处的元素，返回被删除的元素

public E set (int index, E element)

修改指定索引处的元素，返回被修改的元素

public E get(int inxex)

返回指定索引处的元素

public int size ()

返回集合中的元素的个数

public boolean add (E e)

将指定的元素追加到此集合的末尾

public void add (int index,E element)

在此集合中的指定位置插入指定的元素

集合：装数组的容器，且长度可变

• 初始化长度是10（集合初始化长度就是一个长度为10的数组）

• 当集合中元素数量<=10，不需要扩容，直接往集合中添加元素

  若>10，集合会扩容

• 只能存引用数据类型，

  若想存数，只能用基本数据类型的包装类

• 创建长度不指定长度，直接打印变量名得到集合内容

• 集合获取长度 数组名.size

数组：也是容器，

但是长度在运行期间不可改变，不能往数组中添加元素，

固定长度的容器，在存储或删除数据会特别麻烦

若数据数量发生变化，每次都要重新创造新的数组，非常消耗资源

创建对象必须指定长度，直接打印数组名得到地址值

数组获取长度 数组名.length

ArrayList

此为泛型：广泛的数据类型

括号里面的E是想储存的数据类型，若想存String就填String

public class addfactor {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("java");
        System.out.println(list);
		boolean b1 = list.add("777");
        System.out.println("是否添加成功:"+b1);//777会添加到列表的尾部
        list.add("555");//在集合列表的尾部添加指定元素
        list.add(3,"aaa");//可在集合指定位置添加指定元素，但不能跳跃添加，3为索引值
        System.out.println(list);
         boolean b2 = list.remove("java");//会将第一次出现的java元素删除
        System.out.println("删除是否成功："+b2);
        System.out.println(list);
        String remove = list.remove(2);//删除指定索引位置上的元素，返回值是被删元素
        System.out.println("被删除的元素是："+remove);

ArrayList若想存储学生对象，就需要创建一个学生类

2.学生管理系统

1.增删改查功能