Day1
1. cmd （win+R）打开
1.1常用命令
-
盘符： -----> 切换磁盘
-
dir -----> 查看当前路径下的内容
-
cd 目录 ---> 进入此目录
-
cd .. ---> 回到上一级目录
-
cd 目录1\目录2 ---> 进入多级目录
-
cd \ ---> 回到盘符目录
-
cls ---> 清屏
-
exit ---> 退出
1.2环境变量
why？ ---- > 目的是在任意的目录下都可以打开指定软件的软件，就把该软件的路径放到系统变量的path中
2. Java概述
2.1 JDK，JRE，JVM
jdk下的目录解释
-
bin 存放Java工具
-
conf 配置文件
-
include 平台特定的头文件
-
jmods 各种模块
-
legal 各模块的授权文档
-
lib 工具的补充jar包
jdk：JVM，核心类库，开发工具（jdb ： 调试工具，jhat：内存分析工具）
jre：JVM，核心类库，运行工具
2.2 编译和运行
javac 编译 ---> cd进入此Java文件目录下 javac 文件名.java
java 运行 ----> 直接输入文件名运行
Java新版本会自动配置环境变量，但建议我们手动去操作下，新建JAVA_HOME,把jdk路径放到其中，不带bin，再把Java home 引用到 path中，%JAVA_HOME%bin。
2.3 notepad++ 的设置
右键点击java文件，选择edit with notepad++。
点击设置，再点击首选项。在弹出的页面当中，左侧选择新建，中间选择Java，右侧选择ANSI。
Day2
1. 注释
单行，多行，文档注释/** */
2. 关键字
被Java赋予了特定含义的英文单词。
当我们在代码中写了关键字之后，程序在运行的时候，就知道要做什么事情了。
2.1 第一个关键字class
类：Java项目最基本的组成单元，一个完整的Java项目有可能会有成千上万个类来组成的。
class后面跟随的就是这个类的名字，简称：类名。
在类名后面会有一对大括号，表示这个类的内容。
举例：
public class HelloWorld{
}
3.字面量
作用：告诉程序员，数据在程序中的书写格式。
| 字面量类型 | 说明 | 程序中的写法 |
|---|---|---|
| 整数 | 不带小数的数字 | 666，-88 |
| 小数 | 带小数的数字 | 13.14，-5.21 |
| 字符 | 必须使用单引号，有且仅能一个字符 | ‘A’，‘0’， ‘我’ |
| 字符串 | 必须使用双引号，内容可有可无 | “HelloWorld”，“黑马程序员” |
| 布尔值 | 布尔值，表示真假，只有两个值：true，false | true 、false |
| 空值 | 一个特殊的值，空值 | 值是：null |
null不能直接输出打印，要打印加“ ”
\t 在打印时，把前边字符串的长度补齐到8，或者8的整数倍，最少补一个，最多补8个
4.变量
4.1 什么是变量？
变量就是在程序中临时存储数据的容器。但是这个容器中只能存一个值。
4.2 变量的定义格式
数据类型 变量名 = 数据值；
4.2.1 格式详解
数据类型：限定了变量当中能存储什么类型的数据。
如果要存10，那么数据类型就需要写整数类型。
如果要存10.0，那么数据类型就需要写小数类型。
变量名：其实就是这个容器的名字。
当以后想要使用变量里面的数据时，直接使用变量名就可以了。
数据值：真正存储在容器中的数据。
分号：表示语句的结束，就跟以前写作文时候的句号是一样的。
4.2.2 变量的使用方式
-
输出打印
-
参与计算
-
修改记录的值
4.2.3 变量的注意事项
-
变量名不能重复
-
在一条语句中，可以定义多个变量。但是这种方式影响代码的阅读，所以了解一下即可。
-
变量在使用之前必须要赋值。
计算机中的数据存储原理
进制概念
二：0b，八：0，十六：0x
任意进制转10进制：系数（数值位的数字）*基数（任意进制）的权次（从右往左0）幂 相加
十进制转任意进制：除基取余法，倒着拼接
ASCII美国信息交换标准代码：
a：97 A：65 0：48
-
文本数据：数字，字母，汉字 二进制存储
-
图片数据
分辨率，像素，三原色（红绿蓝）RGB（0-255，0-ff）
分辨率由像素点组成，每个像素点包含三原色
黑白图，灰度表（0-255）
-
声音数据：波形采样存储
5. 数据类型
5.1 Java语言数据类型的分类
-
基本数据类型
-
引用数据类型
5.2 基本数据类型的四类八种
| 数据类型 | 关键字 | 内存占用 | 取值范围 |
|---|---|---|---|
| 整数 | byte | 1 | 负的2的7次方 ~ 2的7次方-1(-128~127) |
| short | 2 | 负的2的15次方 ~ 2的15次方-1(-32768~32767) | |
| int | 4 | 的2的31次方 ~ 2的31次方-1 | |
| long | 8 | 负的2的63次方 ~ 2的63次方-1 | |
| 浮点数 | float | 4 | 1.401298e-45 ~ 3.402823e+38 |
| double | 8 | 4.9000000e-324 ~ 1.797693e+308 | |
| 字符 | char | 2 | 0-65535 |
| 布尔 | boolean | 1 | true，false |
说明
e+ 38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方。
在java中整数默认是int类型，浮点数默认是double类型。
需要记忆以下几点
byte类型的取值范围：
-128 ~ 127
int类型的大概取值范围：
-21亿多 ~ 21亿多
整数类型和小数类型的取值范围大小关系：
double > float > long > int > short > byte
6. 标识符
给类，方法，变量等起的名字。
业内大多数程序员都在遵守阿里巴巴的命名规则。
6.1 硬性要求：
必须要这么做，否则代码会报错。
-
必须由数字、字母、下划线_、美元符号$组成。
-
数字不能开头
-
不能是关键字
-
区分大小写的。
6.2 软性建议：
如果不这么做，代码不会报错，但是会让代码显得比较low。
6.2.1 小驼峰命名法
适用于变量名和方法名
-
如果是一个单词，那么全部小写，比如：name
-
如果是多个单词，那么从第二个单词开始，首字母大写，比如：firstName、maxAge
6.2.2 大驼峰命名法
适用于类名
-
如果是一个单词，那么首字母大写。比如：Demo、Test。
-
如果是多个单词，那么每一个单词首字母都需要大写。比如：HelloWorld
不管起什么名字，都要做到见名知意。
阿里巴巴命名规范细节：
-
尽量不要用拼音。但是一些国际通用的拼音可视为英文单词。
正确：alibaba、hangzhou、nanjing
错误：jiage、dazhe
-
平时在给变量名、方法名、类名起名字的时候，不要使用下划线或美元符号。
错误：_name
正确：name
7. 键盘录入
键盘录入的实际功能Java已经帮我们写好了，不需要我们自己再实现了，而Java写好的功能都放在了Scanner这个类中，所以，我们只要直接使用Scanner这个类就可以了。
使用步骤：
第一步：
导包：其实就是表示先找到Scanner这个类在哪。
第二步：
创建对象：其实就表示申明一下，我准备开始用Scanner这个类了。
第三步：
接收数据：也是真正干活的代码。
代码示例：
//导包，其实就是先找到Scanner这个类在哪
import java.util.Scanner;
public class ScannerDemo1{
public static void main(String[] args){
//2.创建对象，其实就是申明一下，我准备开始用Scanner这个类了。
Scanner sc = new Scanner(System.in);
//3.接收数据
//当程序运行之后，我们在键盘输入的数据就会被变量i给接收了
System.out.println("请输入一个数字");
int i = sc.nextInt();
System.out.println(i);
}
}
8. IDEA
8.1 IDEA中层级结构介绍
8.1.1 结构分类
-
project（项目、工程）
-
module（模块）
-
package（包）
-
class（类）
8.1.2 结构介绍
为了让大家更好的吸收，package这一层级，我们后面再学习，先学习最基础的project、module、class。
project（项目、工程）
淘宝、京东、黑马程序员网站都属于一个个项目，IDEA中就是一个个的Project。
module（模块）
在一个项目中，可以存放多个模块，不同的模块可以存放项目中不同的业务功能代码。在黑马程序员的官方网站中，至少包含了以下模块：
-
论坛模块
-
报名、咨询模块
为了更好的管理代码，我们会把代码分别放在两个模块中存放。
package（包）
一个模块中又有很多的业务，以黑马程序员官方网站的论坛模块为例，至少包含了以下不同的业务。
-
发帖
-
评论
为了把这些业务区分的更加清楚，就会用包来管理这些不同的业务。
class（类）
就是真正写代码的地方。
8.1.3 小结
-
层级关系
project - module - package - class
-
包含数量
project中可以创建多个module module中可以创建多个package package中可以创建多个class
这些结构的划分，是为了方便管理类文件的。
Day3
1.隐式转换
1.1 概念：
也叫自动类型提升。
就是把一个取值范围小的数据或者变量，赋值给另一个取值范围大的变量。此时不需要我们额外写代码单独实现，是程序自动帮我们完成的。
1.2 简单记忆：
就是小的给大的，可以直接给。
1.3 两种提升规则：
-
取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算。
-
byte、short、char三种类型的数据在运算的时候，都会直接先提升为int，然后再进行运算。
1.4取值范围从小到大的关系：
byte short int long float double
2.字符串的+操作
核心技巧：
-
当+操作中出现字符串时，此时就是字符串的连接符，会将前后的数据进行拼接，并产生一个新的字符串。
-
当连续进行+操作时，从左到右逐个执行的。
3.字符的+操作
规则：
当+操作中出现了字符，会拿着字符到计算机内置的ASCII码表中去查对应的数字，然后再进行计算。
4.算术运算符的总结
分类：
+ - * / % 这些操作跟小学数学几乎是一模一样的。
注意点：
-
/ 和 % 的区别：他们两个都是做除法运算，/取结果的商。% 取结果的余数。
-
整数操作只能得到整数，如果想要得到小数，必须有浮点数参与运算。
算术运算符的高级用法：
是以+为例进行的讲解，其余减法，乘法，除法的运算规则也是一样的。
特例：字符串只有+操作，没有其他操作。
5.自增自减运算符
5.1 分类：
++ 自增运算符 -- 自减运算符
++：就是把变量里面的值+1
--：就是把变量里面的值-1
5.2 使用方式：
-
放在变量的前面，我们叫做先++。 比如：++a
-
放在变量的后面，我们叫做后++。 比如：a++
5.3 注意点：
不管是先++，还是后++。单独写在一行的时候，运算结果是一模一样的。
6. 赋值运算符
最为常用的： =
运算过程：就是把等号右边的结果赋值给左边的变量
7. 扩展赋值运算符
分类：
+=、-=、*=、/=、%=
运算规则：
就是把左边跟右边进行运算，把最终的结果赋值给左边，对右边没有任何影响。
注意点：
扩展的赋值运算符中隐层还包含了一个强制转换。
以+=为例。
a += b ;实际上相当于 a = (byte)(a + b);
8. 关系运算符
又叫比较运算符，其实就是拿着左边跟右边进行了判断而已。
分类：
| 符号 | 解释 |
|---|---|
| == | 就是判断左边跟右边是否相等，如果成立就是true，如果不成立就是false |
| != | 就是判断左边跟右边是否不相等，如果成立就是true，如果不成立就是false |
| > | 就是判断左边是否大于右边，如果成立就是true，如果不成立就是false |
| >= | 就是判断左边是否大于等于右边，如果成立就是true，如果不成立就是false |
| < | 就是判断左边是否小于右边，如果成立就是true，如果不成立就是false |
| <= | 就是判断左边是否小于等于右边，如果成立就是true，如果不成立就是false |
注意点：
-
关系运算符最终的结果一定是布尔类型的。要么是true，要么是false
-
在写==的时候，千万不要写成=
9. 逻辑运算符
& 和 | 的使用：
&：逻辑与（而且）
两边都为真，结果才是真，只要有一个为假，那么结果就是假。
|：逻辑或（或者）
两边都为假，结果才是假，只要有一个为真，那么结果就是真。
^（异或）的使用：
在以后用的不多，了解一下即可。
计算规则：如果两边相同，结果为false，如果两边不同，结果为true(同0异1)
!（取反）的使用：
是取反，也叫做非。
计算规则：false取反就是true，true取反就是false
温馨提示：取反最多只用一个。
10. 短路逻辑运算符
分类： && ||
&&：
运算结果跟&是一模一样的，只不过具有短路效果。
||：
运算结果跟|是一模一样的。只不过具有短路效果。
逻辑核心：
当左边不能确定整个表达式的结果，右边才会执行。
当左边能确定整个表达式的结果，那么右边就不会执行了。从而提高了代码的运行效率。
总结：
&& 和 & 、||和|的运行结果都是一模一样的。
但是短路逻辑运算符可以提高程序的运行效率。
11. 三元运算符
又叫做：三元表达式或者问号冒号表达式。
格式：
关系表达式 ？ 表达式1 ：表达式2 ；
计算规则：
-
计算关系表达式的值。
-
如果关系表达式的值为真，那么执行表达式1。
-
如果关系表达式的值为假，那么执行表达式2。
注意点：
三元运算符的最终结果一定要被使用，要么赋值给一个变量，要么直接打印出来。
12. 运算符的优先级
在Java中涉及了很多的运算符，每一种运算符都有各自的优先级。但是这些优先级不需要记忆。
咱们只要知道其中一点：
小括号优先于所有。
运算符优先级决定了表达式中运算执行的先后顺序，通常优先级由高到底的顺序依次是：增量和减量运算→算术运算符→比较运算→逻辑运算→赋值运算。Java中常用的运算符的优先级如下图所示：
13. 原码，反码，补码
原码
十进制数据的二进制表现形式，最左边是符号位，0为正，1为负。
反码（解决原码不能计算负数的问题）
正数的补码反码是其本身，负数的反码是符号位保持不变，其余位取反。
0有两种表示。0000 0000，1111 1111.
补码（解决负数跨0）
正数的补码是本身，负数的补码是反码加1.
完美解决正数负数的运算。
0 0000 0000 ，1 0000 0001 ，-1 1111 1111，-2 1111 1110，-128 1000 0000（人为规定）
&
0为false，1为true，两个都为true，才为true。
|
0为false，1为true，一个为true，都为true。
<<
左移，低位补0 ，左移一次乘以2.
>>
右移，高位补原来数值位，低位补0 右移一次除2
>>>
无符号右移，高位补0
Day4
1. 流程控制语句
在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。
1.1 流程控制语句分类
顺序结构
判断和选择结构(if, switch)
循环结构(for, while, do…while)
1.2 顺序结构
顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
2. 判断语句：if语句
2.1 if语句格式1
格式：
if (关系表达式) {
语句体;
}
执行流程：
①首先计算关系表达式的值
②如果关系表达式的值为true就执行语句体
③如果关系表达式的值为false就不执行语句体
④继续执行后面的语句内容
第一种格式的细节：
-
如果我们要对一个布尔类型的变量进行判断，不要写==，直接把变量写在小括号中即可。
-
如果大括号中的语句体只有一条，那么大括号可以省略不写
如果大括号省略了，那么if只能控制距离他最近的那一条语句。
建议：自己不要去写，如果别人这么写了，你要能看懂即可。
2.2 if语句格式2
格式：
if (关系表达式) {
语句体1;
} else {
语句体2;
}
执行流程：
①首先计算关系表达式的值
②如果关系表达式的值为true就执行语句体1
③如果关系表达式的值为false就执行语句体2
④继续执行后面的语句内容
2.3 if语句格式3
格式：
if (关系表达式1) {
语句体1;
} else if (关系表达式2) {
语句体2;
}
…
else {
语句体n+1;
}
执行流程：
①首先计算关系表达式1的值
②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
④…
⑤如果没有任何关系表达式为true，就执行语句体n+1。
3. switch语句
3.1 格式
switch (表达式) {
case 1:
语句体1;
break;
case 2:
语句体2;
break;
...
default:
语句体n+1;
break;
}
3.2 执行流程：
-
首先计算出表达式的值
-
其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结 束。
-
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
3.3 switch的扩展知识：
-
default的位置和省略情况
default可以放在任意位置，也可以省略
-
case穿透
不写break会引发case穿透现象
-
switch在JDK12的新特性
int number = 10;
switch (number) {
case 1 -> System.out.println("一");
case 2 -> System.out.println("二");
case 3 -> System.out.println("三");
default -> System.out.println("其他");
}
-
switch和if第三种格式各自的使用场景
当我们需要对一个范围进行判断的时候，用if的第三种格式
当我们把有限个数据列举出来，选择其中一个执行的时候，用switch语句
比如：
小明的考试成绩，如果用switch，那么需要写100个case，太麻烦了，所以用if简单。
如果是星期，月份，客服电话中0~9的功能选择就可以用switch
case后可以写多个值。
case 1, 2, 3, 4, 5 -> System.out.println("工作日");
case 6, 7 -> System.out.println("休息日");
4. 循环结构
4.1 for循环结构（掌握）
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形 成死循环。
4.1.1 for循环格式：
for (初始化语句;条件判断语句;条件控制语句) {
循环体语句;
}
格式解释：
-
初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
-
条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
-
循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情
-
条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
执行流程：
①执行初始化语句
②执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续
for循环书写技巧：
-
确定循环的开始条件
-
确定循环的结束条件
-
确定循环要重复执行的代码
4.2 while循环
4.2.1 格式：
初始化语句;
while(条件判断语句){
循环体;
条件控制语句;
}
4.3 do...while循环
本知识点了解即可
格式：
初始化语句;
do{
循环体;
条件控制语句;
}while(条件判断语句);
特点：
先执行，再判断。
4.4 三种格式的区别：
for和while循环，是先判断，再执行。
do...while是先执行，再判断。
当知道循环次数或者循环范围的时候，用for循环。
当不知道循环次数，也不知道循环范围，但是知道循环的结束条件时，用while循环。
5. 无限循环
5.1 概念：
又叫死循环。循环一直停不下来。
5.2 for格式：
for(;;){
System.out.println("循环执行一直在打印内容");
}
5.3 while格式：
while(true){
System.out.println("循环执行一直在打印内容");
}
5.4 do...while格式：
do{
System.out.println("循环执行一直在打印内容");
}while(true);
5.5 无限循环的注意事项：
-
最为常用的格式：while
-
无限循环下面不能再写其他代码了，因为永远执行不到。
6.条件控制语句
-
break
-
continue
break:
不能单独存在的。可以用在switch和循环中，表示结束，跳出的意思。
continue:
不能单独存在的。只能存在于循环当中。
表示：跳过本次循环，继续执行下次循环。
7. Random
Random跟Scanner一样，也是Java提前写好的类，我们不需要关心是如何实现的，只要直接使用就可以了。
使用步骤：
-
导包
import java.util.Random; 导包的动作必须出现在类定义的上边。
-
创建对象
Random r = new Random (); 上面这个格式里面，只有r是变量名，可以变，其他的都不允许变。
-
生成随机数
int number = r.nextInt(随机数的范围); 上面这个格式里面，只有number是变量名，可以变，其他的都不允许变。 随机数范围的特点：从0开始，不包含指定值。比如：参数为10，生成的范围[0,10)
代码示例：
//1.导包
import java.util.Random;
public class RandomDemo1 {
public static void main(String[] args) {
//2.创建对象
Random r = new Random();
//3.生成随机数
int number = r.nextInt(100);//包左不包右，包头不包尾
//0 ~ 99
System.out.println(number);
}
}
Day5
1.数组
概念：
指的是一种容器，可以同来存储同种数据类型的多个值。
但是数组容器在存储数据的时候，需要结合隐式转换考虑。
建议：
容器的类，和存储的数据类型保持一致。
举例：
整数1 2 3 4 56 就可以使用int类型的数组来存储。
小数1.1 1.2 1.3 1.4 就可以使用double类型的数组来存储。
字符串"aaa" "bbb" "ccc" 就可以使用String类型的数组来存储。
2.数组的定义
格式一：
数据类型 [] 数组名
比如：int [] array
格式二：
数据类型 数组名 []
比如： int array []
详解：
数据类型：限定了数组以后能存什么类型的数据。
方括号：表示现在定义的是一个数组。
数组名：就是一个名字而已，方便以后使用。
注意点：
方法括号跟数组名，谁写在前面，谁写在后面都是一样的。
平时习惯性使用第一种方式。
3.数组的静态初始化
完整格式：
数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3，元素4...};
比如：
int[] arr = new int[]{11,22,33};
double[] arr = new double[]{1.1,1.2,1.3};
格式详解：
数据类型：限定了数组以后能存什么类型的数据。
方括号：表示现在定义的是一个数组。
数组名：其实就是名字而已，方便以后使用，在起名字的时候遵循小驼峰命名法。
arr namesArr
new：就是给数组在内存中开辟了一个空间。
数据类型：限定了数组以后能存什么类型的数据。
前面和后面的数据类型一定要保持一致。
int[] arr = new double[]{11,22,33};//错误写法
方括号：表示现在定义的是一个数组。
大括号：表示数组里面的元素。元素也就是存入到数组中的数据。
多个元素之间，一定要用逗号隔开。
注意点：
-
等号前后的数据类型必须保持一致。
-
数组一旦创建之后，长度不能发生变化。
简化格式:
数据类型[] 数组名 = {元素1，元素2，元素3，元素4...};
比如：
int[] array = {1,2,3,4,5};
double[] array = {1.1,1.2,1.3};
4.地址值
int[] arr = {1,2,3,4,5};
System.out.println(arr);//[I@6d03e736
double[] arr2 = {1.1,2.2,3.3};
System.out.println(arr2);//[D@568db2f2
打印数组的时候，实际出现的是数组的地址值。
数组的地址值：就表示数组在内存中的位置。
以[I@6d03e736为例：
[ ：表示现在打印的是一个数组。
I：表示现在打印的数组是int类型的。
@：仅仅是一个间隔符号而已。
6d03e736：就是数组在内存中真正的地址值。（十六进制的）
但是，我们习惯性会把[I@6d03e736这个整体称之为数组的地址值。
5.数组元素访问
格式：
数组名[索引];
作用：
-
获取数组中对应索引上的值
-
修改数组中对应索引上的值
一旦修改之后，原来的值就会被覆盖了。
6.索引
也叫角标、下标
就是数组容器中每一个小格子对应的编号。
索引的特点：
-
索引一定是从0开始的。
-
连续不间断。
-
逐个+1增长。
7.数组的遍历
遍历：就是把数组里面所有的内容一个一个全部取出来。
数组的长度：数组名.length;
通用代码：
for(int i = 0; i < arr.length; i++){
//在循环的过程中，i依次表示数组中的每一个索引
sout(arr[i]);//就可以把数组里面的每一个元素都获取出来，并打印在控制台上了。
}
8.数组的动态初始化
格式：
数据类型[] 数组名 = new 数据类型[数组的长度];
举例：
//1.定义一个数组，存3个人的年龄，年龄未知 int[] agesArr = new int[3]; //2.定义一个数组，存班级10名学生的考试成绩，考试成绩暂时未知，考完才知道。 int[] scoresArr = new int[10];
数组的默认初始化值：
整数类型：0
小数类型：0.0
布尔类型：false
字符类型：'\u0000'
引用类型：null
9.数组两种初始化方式的区别
静态初始化：int[] arr = {1,2,3,4,5};
动态初始化：int[] arr = new int[3];
静态初始化：手动指定数组的元素，系统会根据元素的个数，计算出数组的长度。
动态初始化：手动指定数组长度，由系统给出默认初始化值。
使用场景：
只明确元素个数，但是不明确具体的数据，推荐使用动态初始化。
已经明确了要操作的所有数据，推荐使用静态初始化。
10.数组常见问题
当访问了数组中不存在的索引，就会引发索引越界异常。
避免：
针对于任意一个数组，索引的范围： 最小索引：0 最大索引：数组的长度 - 1 数组名.length - 1
public class ArrDemo6 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,5,5,5,5};
//用索引来访问数组中的元素
System.out.println(arr[1]);
System.out.println(arr[10]);//ArrayIndexOutOfBoundsException
}
}
11. 数组技巧
循环遍历比较值时候，可以让最大最小为数组第一个值。
循环次数直接从下标为1开始，提高效率。
12. java内存分配
栈
方法运行时使用的内存，比如main方法运行，进入方法栈中执行
堆
存储对象或数组，new来创建的，都存在堆内存里
方法区
存储可以运行的class文件
本地方法栈
JVM在使用操作系统功能的时侯使用，和我们开发无关
寄存器
给CPU使用，跟开发无关。
普通变量与数组在栈中的存储
普通变量 ，int a = 3,在栈中开出一块空间，起名为a，把字面量3直接存入其中。
数组，int [] arr = new int [2],首先在栈中开辟一块空间，起名为arr，表示其是一个数组，在堆中开辟一块连续的空间，记录下其长度，把默认值赋给他，地址的头是0x3643636，把这个值赋给栈中的arr，也就是说，普通变量堆里存的是值，而数组堆里存的是地址。此时若执行sout.arr，则会打印出数组的地址。
总结
只要new出来的一定会在堆里面开辟小空间，new了很多次，堆里面就有很多个小空间，每个空间里都存有各自的数据。
当两个数组指向同一个小空间时，其中一个数组对小空间的值进行了修改，则另一个再次访问时候，值也会发生改变。
13.二维数组
作用：将数据进行分组管理
13.1二维数组初始化
静态初始化
int [][] arr1 = {{1,2,3},{4,5}};
动态初始化
int [][] arr2 = new int[3][4];
13.2二维数组赋值
arr2 [0][1]= 3; arr1 [0][1] = 3;
给一组赋值
for (int i = 0; i < arr2.length; i++) {
for (int j = 0; j < arr2 [i].length; j++) {
arr2 [i][j] = 1;
}
}
遍历二维数组
for (int i = 0; i < arr2.length; i++) {
for (int j = 0; j < arr2 [i].length; j++) {
System.out.print(arr2[i][j]+" ");
}
System.out.println();
}
Day6
1. 方法概述
1.1 方法的概念
方法（method）是程序中最小的执行单元
-
注意：
-
方法必须先创建才可以使用，该过程称为方法定义
-
方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用
-
重复的代码，具有独立的功能的代码可以抽取到方法中。
-
方法好处，提高代码重用性。提高代码可维护性。
-
3.2 形参和实参
-
形参：方法定义中的参数
等同于变量定义格式，例如：int number
-
实参：方法调用中的参数
等同于使用变量或常量，例如： 10 number
4.带返回值方法的定义和调用
4.1 带返回值方法定义和调用
-
定义格式
public static 数据类型 方法名 ( 参数 ) { return 数据 ; } -
范例
public static boolean isEvenNumber( int number ) { return true ; } public static int getMax( int a, int b ) { return 100 ; }-
注意：
-
方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
-
-
-
调用格式
方法名 ( 参数 ) ; 直接调用 数据类型 变量名 = 方法名 ( 参数 ) ; 赋值调用 输出调用 -
范例
isEvenNumber ( 5 ) ; boolean flag = isEvenNumber ( 5 );
-
注意：
-
方法的返回值通常会使用变量接收，否则该返回值将无意义
-
-
5. 方法的注意事项
5.1 方法的注意事项
-
方法不能嵌套定义
-
示例代码：
public class MethodDemo { public static void main(String[] args) { } public static void methodOne() { public static void methodTwo() { // 这里会引发编译错误!!! } } }
-
-
void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据
-
示例代码：
public class MethodDemo { public static void main(String[] args) { } public static void methodTwo() { //return 100; 编译错误，因为没有具体返回值类型 return; //System.out.println(100); return语句后面不能跟数据或代码 } }
-
5.2 方法的通用格式
-
格式：
public static 返回值类型 方法名(参数) { 方法体; return 数据 ; } -
解释：
-
public static 修饰符，目前先记住这个格式
返回值类型 方法操作完毕之后返回的数据的数据类型
如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
方法名 调用方法时候使用的标识
参数 由数据类型和变量名组成，多个参数之间用逗号隔开
方法体 完成功能的代码块
return 如果方法操作完毕，有数据返回，用于把数据返回给调用者
-
-
定义方法时，要做到两个明确
-
明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型
-
明确参数：主要是明确参数的类型和数量
-
-
调用方法时的注意：
-
void类型的方法，直接调用即可
-
非void类型的方法，推荐用变量接收调用
-
6. 方法重载
6.1 方法重载
-
方法重载概念
方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
-
多个方法在同一个类中
-
多个方法具有相同的方法名
-
多个方法的参数不相同，类型不同或者数量不同
-
-
注意：
-
重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
-
重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载
-
-
正确范例：
public class MethodDemo { public static void fn(int a) { //方法体 } public static int fn(double a) { //方法体 } } public class MethodDemo { public static float fn(int a) { //方法体 } public static int fn(int a , int b) { //方法体 } } -
错误范例：
public class MethodDemo { public static void fn(int a) { //方法体 } public static int fn(int a) { /*错误原因：重载与返回值无关*/ //方法体 } } public class MethodDemo01 { public static void fn(int a) { //方法体 } } public class MethodDemo02 { public static int fn(double a) { /*错误原因：这是两个类的两个fn方法*/ //方法体 } }
6.2 方法重载练习
-
需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）
-
思路：
-
①定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数
-
②定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数
-
③定义所有的重载方法，两个byte类型与两个short类型参数
-
④完成方法的调用，测试运行结果
-
-
代码：
public class MethodTest { public static void main(String[] args) { //调用方法 System.out.println(compare(10, 20)); System.out.println(compare((byte) 10, (byte) 20)); System.out.println(compare((short) 10, (short) 20)); System.out.println(compare(10L, 20L)); } //int public static boolean compare(int a, int b) { System.out.println("int"); return a == b; } //byte public static boolean compare(byte a, byte b) { System.out.println("byte"); return a == b; } //short public static boolean compare(short a, short b) { System.out.println("short"); return a == b; } //long public static boolean compare(long a, long b) { System.out.println("long"); return a == b; } }
6.3 获取索引
伪造索引，当所需的索引不在循环中，定义一个索引初始值，然后让他自增，使其变为一个索引。
需求：
定义一个方法获取数字，在数组中的索引位置，将结果返回给调用处，如果有重复的，只要获取第一个即可。
代码示例：
package com.itheima.demo;
public class Test4 {
public static void main(String[] args) {
//定义一个方法获取数字，在数组中的索引位置，将结果返回给调用处
//如果有重复的，只要获取第一个即可
int[] arr = {1,2,3,4,5};
int index = contains(arr, 3);
System.out.println(index);
}
//1. 我要干嘛？判断数组中的某一个数是否存在
//2. 需要什么？数组 数字
//3. 调用处是否需要继续使用？返回
//获取number在arr中的位置
public static int contains(int[] arr, int number) {
//遍历arr得到每一个元素
for (int i = 0; i < arr.length; i++) {
//拿着每一个元素跟number比较
if(arr[i] == number){
//如果相等，表示找到了
return i;
}
}
//当循环结束之后，如果还不能返回索引，表示数组中不存在该数据
//可以返回-1
return -1;
}
}
7.方法的内存原理
基本数据类型：数据值是存储在自己的空间中
特点：赋值时赋给其他变量的是真实值，传参时形参的改变不会引起实参的改变
引用数据类型：数据值存储在其他空间中
特点：赋值时赋给其他变量的是地址值
8.综合案例技巧
循环录入值时候，可以把循环迭代因子放在录入成功的代码后，此时才会有变化 ，这样做的好处是不合法的值不会录入，循环不发生改变。
Day8
1. 类和对象
1.1 类和对象的理解
客观存在的事物皆为对象 ，所以我们也常常说万物皆对象。
-
类
-
类的理解
-
类是对现实生活中一类具有共同属性和行为的事物的抽象
-
类是对象的数据类型，类是具有相同属性和行为的一组对象的集合
-
简单理解：类就是对现实事物的一种描述
-
-
类的组成
-
属性：指事物的特征，例如：手机事物（品牌，价格，尺寸）
-
行为：指事物能执行的操作，例如：手机事物（打电话，发短信）
-
-
-
类和对象的关系
-
类：类是对现实生活中一类具有共同属性和行为的事物的抽象
-
对象：是能够看得到摸的着的真实存在的实体
-
简单理解：类是对事物的一种描述，对象则为具体存在的事物
-
1.2 类的定义
类的组成是由属性和行为两部分组成
-
属性：在类中通过成员变量来体现（类中方法外的变量）
-
行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）
类的定义步骤：
①定义类
②编写类的成员变量
③编写类的成员方法
public class 类名 {
// 成员变量
变量1的数据类型 变量1；
变量2的数据类型 变量2;
…
// 成员方法
方法1;
方法2;
}
1.3 对象的使用
-
创建对象的格式：
-
类名 对象名 = new 类名();
-
-
调用成员的格式：
-
对象名.成员变量
-
对象名.成员方法();
-
-
示例代码
/*
创建对象
格式：类名 对象名 = new 类名();
范例：Phone p = new Phone();
使用对象
1：使用成员变量
格式：对象名.变量名
范例：p.brand
2：使用成员方法
格式：对象名.方法名()
范例：p.call()
*/
public class PhoneDemo {
public static void main(String[] args) {
//创建对象
Phone p = new Phone();
//使用成员变量
System.out.println(p.brand);
System.out.println(p.price);
p.brand = "小米";
p.price = 2999;
System.out.println(p.brand);
System.out.println(p.price);
//使用成员方法
p.call();
p.sendMessage();
}
}
2. 对象内存图
执行流程：
-
将Test类字节码读取加入到方法区，方法区中有main方法的临时存储
-
调用main方法，把main方法加入到栈中，读取Student s = new Student（）；
-
把student类字节码加入到方法区，其中方法区中有属于student类的成员变量和成员方法的临时存储
-
在栈中开辟一片空间（Student s），命名为s，这个空间存储的数据类型为Student类型（但是他只会记录一个地址）
-
在堆里边开辟一片空间（new Student）
-
执行默认初始化，给堆里边的初始变量赋给，0和null，方法中存的是方法区中的成员方法的地址
-
显示初始化（在student中显示的指出name和age的值），构造方法初始化，覆盖堆中的数据
-
把这个堆的地址值传给栈中的s，赋值给他
-
执行set方法，把数据赋给堆里的数据，进行覆盖
-
Student s2 = s；（ 将student类字节码加入到方法区，已经执行过，在不执行），声明一个s2的小空间，如4，之后不在堆里开辟，而是把s的地址传给s2，s2指向之前s的堆地址。
-
在执行s2的赋值，则会同步修改s的值
-
当执行结束后，栈中在没有对象指向堆中的空间，则堆中的空间变为垃圾，被gc回收
-
执行完main方法main出栈
-
此时栈和堆全为空
基本数据类型和引用数据类型，本质是基本中存的是字面量，而引用则是地址，真实的数据值在堆里边
this的本质，记录方法调用者的地址
成员变量在堆里面（堆内存的对象中）生命周期与对象有关，局部变量在栈中 （栈中的方法中）生命周期与方法有关
2.1 单个对象内存图
-
成员变量使用过程
-
成员方法调用过程
2.2 多个对象内存图
-
成员变量使用过程
-
成员方法调用过程
-
总结：
多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象共用的一份
3. 成员变量和局部变量
3.1 成员变量和局部变量的区别
-
类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）
-
内存中位置不同：成员变量（堆内存）局部变量（栈内存）
-
生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，随着方法的调用完毕而消失）
-
初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）
4. 封装
4.1 封装思想
-
封装概述 是面向对象三大特征之一（封装，继承，多态）
对象代表什么，就得封装对应的数据，并提供数据对应的行为
-
封装代码实现 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 成员变量private，提供对应的getXxx()/setXxx()方法
4.2 private关键字
private是一个修饰符，可以用来修饰成员（成员变量，成员方法）
-
被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
-
提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
-
提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰
-
4.3 private的使用
-
需求：定义标准的学生类，要求name和age使用private修饰，并提供set和get方法以及便于显示数据的show方法，测试类中创建对象并使用，最终控制台输出 林青霞，30
-
示例代码：
/* 学生类 */ class Student { //成员变量 private String name; private int age; //get/set方法 public void setName(String n) { name = n; } public String getName() { return name; } public void setAge(int a) { age = a; } public int getAge() { return age; } public void show() { System.out.println(name + "," + age); } } /* 学生测试类 */ public class StudentDemo { public static void main(String[] args) { //创建对象 Student s = new Student(); //使用set方法给成员变量赋值 s.setName("林青霞"); s.setAge(30); s.show(); //使用get方法获取成员变量的值 System.out.println(s.getName() + "---" + s.getAge()); System.out.println(s.getName() + "," + s.getAge()); } }
4.4 this关键字
-
this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
-
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
-
方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量
-
public class Student {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void show() {
System.out.println(name + "," + age);
}
}
5. 构造方法
5.1 构造方法概述
构造方法是一种特殊的方法
-
作用：创建对象 Student stu = new Student();
-
格式：
public class 类名{
修饰符 类名( 参数 ) {
}
}
-
功能：主要是完成对象数据的初始化
-
示例代码：
class Student {
private String name;
private int age;
//构造方法
public Student() {
System.out.println("无参构造方法");
}
public void show() {
System.out.println(name + "," + age);
}
}
/*
测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
s.show();
}
}
5.2 构造方法的注意事项
-
构造方法的创建
如果没有定义构造方法，系统将给出一个默认的无参数构造方法 如果定义了构造方法，系统将不再提供默认的构造方法
-
构造方法的重载
如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法
-
推荐的使用方式
无论是否使用，都手工书写无参数构造方法
-
重要功能！
可以使用带参构造，为成员变量进行初始化
-
示例代码
/*
学生类
*/
class Student {
private String name;
private int age;
public Student() {}
public Student(String name) {
this.name = name;
}
public Student(int age) {
this.age = age;
}
public Student(String name,int age) {
this.name = name;
this.age = age;
}
public void show() {
System.out.println(name + "," + age);
}
}
/*
测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s1 = new Student();
s1.show();
//public Student(String name)
Student s2 = new Student("林青霞");
s2.show();
//public Student(int age)
Student s3 = new Student(30);
s3.show();
//public Student(String name,int age)
Student s4 = new Student("林青霞",30);
s4.show();
}
}
5.3 标准类制作
① 类名需要见名知意
② 成员变量使用private修饰
③ 提供至少两个构造方法
-
无参构造方法
-
带全部参数的构造方法
④ get和set方法
提供每一个成员变量对应的setXxx()/getXxx()
⑤ 如果还有其他行为，也需要写上
扫一扫
1785
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
