个人介绍
大家好我是：一颗松
认真分享技术，记录学习点滴
如果分享对你有用请支持我哦🍺
点赞：👍 留言：✍收藏：⭐️
个人格言： 想法落实的最佳时机就是现在！🏄
文章目录
初学须知
:::info
💡 1. 常用百度
💡 2. 一定要动手敲，并长时间坚持（第一遍可能会很难）
💡 3. 多思考并自行实现功能代码
:::
1 java基础知识梳理
用思维导图，结构化展现java基础大概内容。
2 开发环境搭建
学习编程，必须有自己的开发环境
2.1 安装JDK
- 拓展知识：
- java语言是跨平台语言，一套java代码可以去多个系统软件上运行（Windows、macOS、Linux…）,但前提是需要在系统软件上安装有java运行环境(JRE)；1. JRE：（java Runtime Environment）java运行环境，它包含java虚拟机(JVM)和一些标准类库；2. JVM：(Java Virtual Machine)，java字节码文件(.class)在虚拟机上运行。java程序离不开java虚拟机。3. JDK： Java Development Kit，java语言开发工具包，包含java运行环境JRE和java工具
- JDK、JRE、JVM三者之间是包含与被包含关系
- 安装JDK1. 打开浏览器输入甲骨文公司官网(https://www.oracle.com),在导航栏点击**产品（Products）**进入页面底部，选择**java**
- 进入java页面，翻到页面底部选择Orele JDK
- 进入下载页面根据需求下载
- 安装过程一路next就可以（如果想修改安装目录，最好安装在纯英文目录下）
2.2 配置环境变量
- 为什么要配置环境变量？
答：因为在不配置环境变量的情况下，java的编译运行操作只能在java安装目录下进行，使得工作很难展开。（高版本JDK会自动配置环境变量，存在功能不全问题；建议手动配置）
- 配置工作 1. 找到此电脑，右击选择属性
- 进入属性界面后选择高级系统设置
- 进入系统设置后选择高级，再选择环境变量设置
- 进入环境变量配置页面后在系统环境变量下，选择新建
- 新建JAVA_HOME并配置安装目录到jdk版本目录
- 在path环境变量下，添加新配置;配置内容：“%JAVA_HOME%\bin”
到这里配置就算完成了。
- 怎么检查是否配置成功？
答：在键盘上，按住win键+R键 ，输入“cmd”；
然后在DOS窗口输入“java -version”如果有出现java版本信息，那么恭喜你成功啦
3 java基础语法
清楚基础语法知识对于后期学习是十分必要的，一点一点的必须搞懂；
注意：【java语言中对字母的大小写是严格区分的，大写和小写代表两个东西。】
我们先看一个完整java程序案例：
案例1 — HelloWord案例
publicclassHelloWord{publicstaticvoidmain(String[] args){System.out.println("HelloWrod");}}
3.1 标识符和关键字
- 什么是标识符？
标识符：java开发中用到的名字，就是各种名字：变量名、类名、包名等等；
案例1中：HelloWord是类名、main是方法名，args是变量名；这些都是标识符
名字呢不能乱起，那么该如何命名？【标识符的命名规则】
- 只能由：数字、字母、下划线(_)和“$”组成！不能出现其他任何字符。
- 不能以数字开头
江湖规则1： 小驼峰命名法，一个单词时全小写，多个单词时从第二个单词开始首字母大写，常见在（变量、方法名）
江湖规则2： 大驼峰命名法，每个单词首字母大写常见在（类名）话说不遵守江湖规则是行不通滴；
注意：【标识符要做到见名知意】
- 关键字是什么？
关键字：java中有特殊含义的单词，在高级记事本或者集成开发环境中都会用不同的颜色显示；不需要特意背知道常见，慢慢积累；
java常用关键字：
classpublicstaticprivatebreakcontinuedefaultimportifelseforwhileintshortchardoublefloatswitchlongreturn
3.2 常量和变量
常量和变量都描述的是数据，数据有不同的类型我们首先了解一下java中的数据类型
- 常量：就是值不会发生改变的数据，比如：2，‘a’,"java"等等
此处需要注意的是：
- 浮点型常量：浮点型就是小数类型常量，小数默认是double类型，如果是float类型数值后必须加F或f
- 字符型常量：用单引号括起来的的单个字符如：‘a’、‘6’、'A’等等；
- 字符串常量：用双引号括起来的内容如：“helloword”、“15121”、" "等等；
注意：空字符串""，字符串的值为空；空字符’'会报错
- 变量：变量定义格式
- 数据类型 变量名；
- 数据类型 变量名 = 变量值；
3.3 运算符
- 算术运算符：
符合含义+、-、*、/与数学中使用方法一样%取模（也叫取余）++、- -自增、自减运算符
算术运算符注意事项【面试题】：
- 以下语句会不会报错？为什么？
short num1 = 10,num2;
byte num3 = 20;
num2 = num1+num3; //第一句
//---------------------------------------------------
num2 = 200+30; //第二句
//-------------------------------------------------
num3 = 120+10; //第三句
//-------------------------------------------------
//解析
/*
第一句：会报错，这边存在一个隐式转换；【任何整型变量在计算时都会默认转为int类型】再做计算；此处num1与num3会先转int计算完再赋值，然而num2是short类型，大类型值赋值给小类型会报错；
第二句：不会报错，此处存在常量优化机制，因为200与30都是常量，在编译过程中会将结果计算出来，再给num2赋值；num2是short类型230在它的范围内；所以不会出错；
第三句：会报错，虽然java有常量优化机制，但是，此处优化后的结果是130，超出了byte的范围；【byte范围：-128----+127】
*/
- 赋值运算符：
符号含义=赋值运算符，将符号右边的值赋给左边变量+=加等-=减等/=除等%=取模等
赋值运算案例：
int num2 = 20; //把 常量20赋给num2
//-----------------------------------------------
byte num3 = 20;
num3 += 20; //此处实质是：num3 = (num3类型)（num3+20）
注意： 【类似+=、-=、%=这样的赋值运算存在默认强制转换机制】
判断运算符：
符号含义==、!=、等于、不等于“>”、<、>=、<=大于、小于、大于等于、小于等于逻辑运算符：
符号含义&、!、与、非&&短路与
```
| // 逻辑或
^ // 逻辑异或
|| // 短路或
**两个变量值互换要求：不用第三方变量【面试题】：**
- 方案1 数学思维解决
int num1 = 20;
int num2 = 30;
num1 = num1+num2;
num2 = num1-num2;
num1 = num1-num2;
- 方案2 用异或解决【一个数被另一个数连续异或两次，这个数值不变】
int num1 = 20;
int num2 = 30;
num1 = num1^num2;
num2 = num1^num2;
num1 = num2^num1;
---
## 4 数组
### 4.1 一维数组
**1. 数组概念：**
数组是一个可以存储多个相同数据类型的数据的容器；
**2. 数组的定义与初始化**
> 数据类型 [ ] 数组名；
> 数据类型 数组名 [ ]；
**3. 静态初始化，两种格式：**
> 完整格式1
> 数据类型 [ ] 数组名 = new 数据类型[ ] { 数据1,数据2,数据3… };
> 简化格式2
> 数据类型 [ ] 数组名 = { 数据1,数据2,数据3… };
静态初始化 案例-1
//数组定义初始化完整格式int[] arr1 =newint[]{1,2,3};//数组定义初始化简化格式int[] arr2 ={1,2,3};
**4. 动态初始化格式**
> 数据类型 [ ] 数组名;
> 数组名 = new 数据类型 [ 所需的存储空间];
动态初始化 案例-2
int[] arr3;//定义数组
arr3 =newint[10];//动态初始化
arr3[0]=15;
arr3[1]=20;...
arr[9]=9
**5. 数组元素访问**
>
> - 索引 索引的概念：容器中空间的编号就是索引，索引值从0开始（容器中空间编号从0开始）
> - 元素：数组中存储的数据被称为
访问格式
> 格式：数组名 [索引值]；
> eg: int [] arr2 = {1,2,3};
> arr2[0];
> arr2[1];
> 注意：数组元素以索引值访问时只能，一个一个单独访问，不能同时出现多个索引值;
> –
> 错误示例： arr2[0,1,2];
访问案例
int[] arr2 ={1,2,3};System.out.println("arr2数组中第一元素为："+arr2[0]);
**6. 数组遍历**
数组遍历：就是把数组中的每个元素，依次都访问一遍；
数组遍历，输出所有元素格式：
> for (int i = 0; i < 数组长度; i++) {
> System.*out*.println(“数组值：”+数组名[i]);
> }
**友情提示:**【IDEA快捷键—生成遍历框架【 数组名 .fori +Enter 】
### 案例2—数组案例集
数组遍历输出 案例-3
int[] arr2 ={1,2,3};//定义，静态初始化数组for(int i =0; i < arr2.length; i++){System.out.println("数组值："+arr2[i]);//遍历输出arr2数组中的每个元素}
求数组元素偶数和 案例-4
int[] arr4 ={1,2,3,4};//静态初始化数组int sum =0;for(int i =0; i < arr4.length; i++){if(arr4[i]%2==0){//通过取模筛选出所有偶数
sum += arr4[i];//累加计算偶数和}}System.out.println("数组元素中所有偶数和为："+sum);//输出偶数和
求数组元素中最大值 案例-5
publicstaticvoidmain(String[] args){int[] arr5 ={1,15,20,9,88,8};//静态初始化数组for(int i =1; i < arr5.length; i++){if(arr5[0]<arr5[i]){//筛选出大于arr5[0]的数
arr5[0]= arr5[i];//将筛选出的数，赋值给arr5[0]}}int max = arr5[0];//将arr5[0]赋值给max变量System.out.println("次数组最大值为："+max);}
### 4.2 数组初始化内存分配图解
public static void main(String[] args) {
int [] arr = new int [7]; //动态初始化一个长度为10的数组
}
**方法区：** java中字节码文件会存在方法区；【注意：字节码文件不调用不加载】
**栈内存：** java把内存分为两部分，栈内存和堆内存，基本类型变量存于栈内存，栈内存存储特点，先进栈的内容后出栈；
**堆内存：** 所有new出来的东西存放在堆内存中。
当arr的值为null时，再访问arr数组元素时，就会出现空指针异常，报错如下：
Exception in thread "main" java.lang.NullPointerException
at HelloWord.main(HelloWord.java:8)
### 4.3 二维数组
二维数组就是，一维数组的元素时一维数组；也就是数组存数组，这边不详细展开
---
## 5 流程控制
> 流程控制在各编程语言中通用，所以这是必须要掌握的第4点内容
### 5.1 顺序结构
程序默认是按照从上往下的顺序，执行流程；
### 5.2 分支结构
**5.2.1 if语句（判断条件最终必须为：布尔类型值）**
1. 简单if语句格式：
> 语句格式：
> if (判断条件){
> 语句体; //判断条件成立执行语句体；
> }
int nub1 =1;int nub2 =2;if(nub1>nub2){System.out.println("执行了语句体");//判断条件为false，此语句不执行；}
1. if…else语句格式
> 语句格式：
> if (判断条件){
> 语句体1; //判断条件成立执行语句体1；
> }else{
> 语句体2; //判断条件不成立执行语句体2；
> }
int nub1 =1;int nub2 =2;if(nub1>nub2){System.out.println("执行了语句体1");//判断条件为false，此语句不执行体；}else{System.out.println("执行了语句体2");//判断条件为false，执行此语句体；}
1. if…else if…else…语句格式
> 语句格式：
> if (判断条件1){
> 语句体1; //判断条件成立执行语句体1；
> }else if(判断条件2){
> 语句体2; //判断条件1不成立,判断条件2成立，执行语句体2；
> }else{
> 语句体3; //判断条件1和2都不成立执行语句体3；
> }
### 案例3—成绩奖励（if案例）
/*
考试奖励：
分数>=90:奖励自行车一辆
90>分数>=80:奖励游乐园一日游
80>分数:一顿狂揍
*/publicclassIfTest{publicstaticvoidmain(String[] args){int chengji;Scanner sc =newScanner(System.in);System.out.println("请输入成绩：");
chengji = sc.nextInt();if(chengji <=100&& chengji>=0){if(chengji>=90){System.out.println("恭喜！奖励自行车一辆！");}elseif(chengji>=80&& chengji<90){System.out.println("恭喜！奖励游乐园一日游！");}else{System.out.println("来吧一顿接受狂揍！");}}else{System.out.println("成绩输入有误！");}}}
**5.2.2 switch语句**
switch语句格式：如下伪代码所示
switch(variable){case1:
语句体1;break;case2:
语句体2;break;case3:
语句体3;break;...default:
默认语句;break;}
1. variable的取值范围
- 基本类型：byte、short、int、long
- 引用类型：jdk5开始，允许枚举类型；jdk7开始，允许String
- jdk14开始允许，一个case 后跟多个值：case 1,2,3:
- if与switch选用：范围性的判断用if更合理；switch更适合固定值判断；
1. case穿透（可以优化代码）
> case穿透示例：如果有多个重复的语句体可以使用case穿透
switch(variable){case1:case2:case3://重复语句体；break;default:break;}
1. jdk14以后新特性（可以优化代码）
> case穿透示例：如果有多个重复的语句体可以使用case穿透
switch(variable){case1,2,3://重复语句体；break;default:break;}
### 案例4 — 成绩录入输出评价（switch案例）
等级评语A成绩良好B成绩中等C及格D成绩不合格
System.out.println("请输入成绩：可选项【A、B、C、D】");switch('B'){case'A':System.out.println("成绩良好");break;case'B':System.out.println("成绩中等");break;case'C':System.out.println("及格");break;default:System.out.println("成绩不合格！");break;}
switch语句执行流程：
第一步：拿variable值与case值对比，如果对比结果相等，则进入语句体，直到遇到break；或者执行结束才会退出switch语句；
第二步：如果在case中没有匹配到值，就会进入default语句，直到遇到break;或者执行结束才会退出switch语句。在switch语句中 执行顺序与case 、default的位置无关；
### 知识拓展【三目运算符：】
> **三目运算符格式：**
> 判断条件 ？ 值1 : 值2；
> 执行流程：
> 1 判断条件是否为真？
> 2 如果判断条件为真，则 值1 赋给这这条语句的结果；
> 3 如果判断条件为假，则 值2 赋给这这条语句的结果；
### 案例5—三目运算符操作案例：
publicvoidoperator(){int a,b,c;
a =10;
b =20;//第一种情况判断条件(b>a)为真
c = b>a ? a:b;//c的值为10；//第二种情况判断条件(b<a)为假
c = b<a ? a:b;//c的值为20；}
### 5.3 循环结构
使用循环的条件：
> 某个操作需要重复执行多次
**5.3.1 for循环**
1. *for循环的使用*
//for循环格式：for(初始化语句;条件判断语句;条件控制语句){//循环体语句;}//在for循环中，初始化语句只执行1次；//for循环案例：publicstaticvoidmain(String[] args){for(int i =0;i<3;i++){System.out.println("执行第"+i+"次循环！");}}
1. *for循环执行流程（重中之重）*
for(初始化语句;条件判断语句;条件控制语句){//循环体语句;}
注意：【在for循环中初始化语句只执行一次】
### 案例6 — 求100以内偶数和(for循环案例)
//for循环案例3（1-100之间的偶数和）//实现方案1int sum =0;for(int i =1;i<=100;i++){if(i%2==0){
sum += i;}}System.out.println("1-100之间偶数和为："+sum);//实现方案2int sum =0;for(int i =2;i<=100;i+=2){
sum += i;}System.out.println("1-100之间偶数和为："+sum);
### 案例7 — 打印所有水仙花数（for循环）
需求分析：什么是水仙花数？
答：水仙花数是一个三位数，它的每个位上的数字的 3次幂之和等于它本身。
步骤分析：
> 1 通过for循环筛选出三位数
> 2 通过if按照水仙花数概念，晒出水仙花数
//for循环找出水仙花数for(int i=100;i<=999;i++){int ge,shi,bai;//定义各位、十位、百位变量准备后续操作
ge = i%10;
shi = i/10%10;
bai = i/100;//用if对水仙花数条件进行筛选if(i==(gegege+shishishi+baibaibai)){System.out.println("水仙花数："+i);}}
---
## 6 java中的方法
### 6.1方法的概念与功能
方法概念：具有独立功能的代码块【在其他语言中也叫函数】
**方法作用：**
a. 按功能将代码分类，提高代码可读性
b. 方便后期代码维护
c. 提高代码复用性
> ***IDEA涨知识：Ctrl + F12，打开类的大纲***
### 6.2 方法定义格式：
**6.2.1 方法定义格式：**
无参方法定义格式：
> 修饰符 返回值类型 方法名(){
> return 返回值；
> }
带参方法定义格式：
> 修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2){
> return 返回值；
> }
**6.2.3 形参（形式参数）与实参（实际参数）**
> 形参：定义方法时声明的参数
> 实参：调用时传入的实际参数
//形参publicstaticvoidprints(int num){//此处的 num就是形参//方法体语句}//main方法调用prints()方法时需要传实参publicstaticvoidmain(String[] args){prints(5);//此处5就是实际参数}
### 案例8— 方法定义
//1无参方法publicstaticvoidprints(){System.out.println("*******************");}//2带参方法//案例1 主方法：publicstaticvoidmain(String[] args){//方法体语句}//案例2 自定义方法：publicstaticintsum(int num1,int num2){int sum = num1+num2;return sum;//返回值}
### 6.3 自定义方法的位置：
> 方法与方法之间保持平级关系，方法不允许嵌套定义；
### 6.4 方法的调用与执行：
> 方法不调用不执行：
> 方法的执行顺序与编写顺序无关，只与调用顺序相关；
### 6.5 方法调用内存图解
### 6.6 java方法的值传递与址传递
问题：在java中方法传参到底是值传递还是址传递？
答：java参数传递问题需要分情况讨论：
- 传递的参数为基本类型，则是值传递；
- 传参为引用类型参数，就是址传递；
1. 基本数据类型
> 案例1：【问：num1的值会不会变？ 答：不会】
publicstaticvoidmain(String[] args){int num1 =100;//定义变量num1test1(num1);//把num1，作为参数传给test1方法System.out.println(num1);}publicstaticinttest1(int num1){return num1 =200;//在test1方法中，给num1重新赋值}
基本数据类型作为参数的内存图解：
2. 引用类型数据
> 案例1：【问：num1的值会不会变？ 答：会】
publicstaticvoidmain(String[] args){int[] num1 ={10,11};//定义数组num1test1(num1);//把num1地址，作为参数传给test1方法System.out.println(num1[0]);}publicstaticinttest1(int[] num1){return num1[0]=200;//在test1方法中，给num1[0]重新赋值}
引用类型数据作为参数的内存图解：
### 案例9— 定义方法做输出
publicstaticvoidprints(int freq){if(freq<0){System.out.println("输入次数有误，请重新输入：");}else{for(int i =0; i < freq; i++){System.out.println("学好编程！");}}}
## 7 初识面向对象
> 面向对象是java语言的一大特征，也是java学习分水岭，理解掌握好这块基础对后期学习而言非常必要
### 7.1 类与对象
**7.1.1. 类是什么？**
答：类是把一类事物的属性，行为抽象成一个java文件，用文件来表现这类事物，那么这个文件就是一个类；
**7.1.2. 对象是什么？**
答：对象是类的一个具象，比如：通过一个描述所有人特征的类，可以具象出某一个具体的人如张三；通过人类产生的这个张三，就是人类的一个对象；
**7.1.3. 类的特征**
**a. 类包含成员变量和成员方法**
*定义在类中的变量：叫成员变量
定义在方法中的变量：叫局部变量*
成员变量成员变量是对同一类事物共同属性的一个抽象成员方法成员方法是对同一类事物共同行为的一个抽象
**7.1.4. 类的定义**
定义格式：
> 修饰符 class 类名{
> 成员变量；
> 成员方法；
> }
### 案例9 ----定义学生类
public class Students {
int age; //学生类成员变量age
String name; //学生类成员变量name
void speak(){ //学生类成员方法speak
System.out.println("大家好！我是"+name+"今年"+age+"岁");
}
}
【注意：】类定义时，class前的public有什么用?
答：public修饰的类有最大权限，大家都可以访问，程序的主类必须用public修饰；被public修饰的类，类名与文件名必须保持一致，否则报错；
**7.1.5. 对象的创建和使用**
对象的创建格式：
> 类名 对象名 = new 类名();
### 案例10—根据案例9创建学生对象张三
public static void main(String[] args) {
Students zhangsan = new Students(); //创建学生对象张三
zhangsan.age = 18; //用对象为成员方法赋值
zhangsan.name = "张三";
zhangsan.speak(); //用对象调用成员方法
}
### 7.2 构造方法
构造方法又叫构造器
> 是在构建、创造对象的时候调用的方法，（没有构造方法不能创建对象）
> 注意：【一个类中如果没有手动写构造方法，系统会默认提供一个无参构造方法】
**7.2.1. 构造方法格式**
>
> - 构造方法名 与类名相同
> - 没有返回值类型，连void也没有
> - 没有具体返回值，不能使用return带回结果
> 注意：【在构造方法中“return;”是可以存在的，this代表当前类对象的地址，谁调用代表谁】
> 案例1-构造方法格式
classStudents{//创建Students类String name;//成员变量nameint age;//成员变量age//无参构造方法Students(){}//带参构造方法Students(int age,String name){this.age = age;//通过局部变量为成员变量age赋值this.name = name;//通过局部变量为成员变量name赋值}}
**7.2.2. 构造方法的作用**
> 2.1 本质作用是用于创建对象
> 2.2 可以在创建对象的时候，直接给成员变量赋值
> 案例2–通过构造方法为成员变量赋值
publicclassThisDemo{publicstaticvoidmain(String[] args){Students stu1 =newStudents(18,"小明");//创建对象stu1,并传参}}classStudents{String name;//成员变量int age;//成员变量Students(int age,String name){//构造方法this.age = age;//通过局部变量为成员变量age赋值this.name = name;//通过局部变量为成员变量name赋值}}
```
7.2.3. 构造方法内存解析（案例2解析）
注意：【字节码文件不调用不加载】
7.3 java面向对象的特征
话说java万物皆对象，怎么理解呢？
答：生活中的所有事务我们都可以进行归类，归类后就能找出共性，共同属性，共同行为等等那么就可以将事物抽象成类；一个类可以创建无数对象，这样就便于开，发节省开发成本。也就是万物皆对象。
7.3.1 java的封装
7.3.2 java的继承
7.3.3 java的多态
8 初识javaAPI
javaAPI（Application Programming Interface）应用程序编程接口
8.1 String类
8.2 Random类
9 初识集合
9.1 ArryList集合
学生管理系统实现
版权归原作者 Zinksl 所有， 如有侵权，请联系我们删除。