java基础知识笔记
第一章：Java基础：
1️⃣ 初识 Java:
1、常识知识：
语言：人与人交流沟通的表达方式
计算机语言：人与计算机之间进行信息交流沟通的一种特殊语言
编程语言分类：
编译型
优点：执行效率高
缺点：平台依赖重，跨平台不方便
解释型
优点：易于跨平台
缺点：源代码在一般情况下不便于加密,执行效率相对没有那么高
混合型：
可编译可解释
- 计算机语⾔发展历史
- 第⼀代 计算机语⾔：01010100010111000
- 第⼆代 汇编语⾔00000011写成汇编语⾔就是 ADD，只要还原成⼆进制， 汇编语⾔就可以被 CPU 直接执⾏，所以它是最底层的低级语⾔
- 第三代 ⾼级语⾔
- ⾯向过程：c，Fortran ⾯向对象：c++，java，c#
Java名称的由来
在最初，Java语言是叫做oak（橡树）。是因为刚开始公司门口有一颗橡树。所以就叫做橡树。然后发现oak已经被美国橡树公司注册了，就不能再继续使用了。所以需要改名。而程序员最爱喝的是咖啡，盛产咖啡的岛叫做爪哇岛，由此语言就叫做Java了。
Java的三大平台
-
JavaSE
Java 语言的（标准版），用于桌面应用的开发，是其他两个版本的基础。
-
JavaME
Java 语言的（小型版），用于嵌入式消费类电子设备。
-
JavaEE 至臻
Java 语言的（企业版），用于 Web 方向的网站开发。
Java 基础语法
java⽂件名：
⽂件名必须和类名相同，后缀为.java； 否则会出错
类class：
表示声明⼀个类，类名的⾸字⺟需要⼤写，多个单词的话需要使⽤驼峰形式
HelloWorld、UserAccount、User
⽅法：
⽅法名需要⼩写字⺟开头，若有⼏个单词，则后续的采⽤驼峰形式
主⽅法：
固定搭配，需要硬记，所有程序的主⼊⼝ public static void main(String [] args)
所有变量、名称都是⼤⼩写敏感的！！！！
//程序入口：登陆器；进去之后才会出现游戏界面；
//所有执行的程序；都需要入口方法来执行；
//main 英文含义叫主体；
//访问权限修饰符：公开的访问权限：Public 公开的；所有人都可以访问;
//在程序里 指 在项目下所有包 都可以i访问；
//stactic 英文叫静态的；--动态的；
//静态 和 动态 IP; 动态时刻在改变； 199；188；166；
//一变不变； 一直在一个地方; 类种静态方法；
//void 空的；没有返回值；
//main 方法名；（参数）
//String[] 数组 args 参数名；
public static void main(String[] args) {
//程序入口方法；并且声明了访问权限：public 公开的；在项目下所有类是不是都可以访问；
//stactic 是来声明这个方法是静态方法；类方法；
//void 空的； main 方法名；（参数）；
//String[] args 参数名；
//Main 主体 声明声明什么内容呢？
//输出语句：
//由Main 来执行；
System.out.println("Hello wolrd");
//程序 让你说一句话：Hello wolrd；
System.out.print("Hello wolrd");
System.out.println("贴在一起");
//程序告诉cpu ;你不换行打印一句话：光标处；
Java跨平台工作原理
平台：指的是操作系统。
- Windows
- MacOS
- Linux
跨平台
Java 程序不需要进行任何修改，就可以在任意操作系统上运行。
注意：不是所有的语言都具备这样的特征。比如：C#只能在windows上运行。
编写的Java代码并不是直接运行在操作系统当中的。而是运行在安装的JVM虚拟机中的。每一个操作系统都会对应各自版本的虚拟机。
jdk:
JVM、JRE、JDK关系？
-
JVM
-
Java Virtual Machine Java 虚拟机，简单看成⼀个操作系统，java程序会⾸先被编译
-
为.class的字节码，根据字节码指令进⾏识别并调⽤上层操作系统
-
JRE
-
Java Runtime Environment java 运⾏时环境, 是整个 Java 程序运⾏的核⼼
-
JDK
-
Java Development Kit 是我们的开发⼯具包，它集成了 JRE, 是整个 Java 开发的核⼼
-
总结
-
JRE = 基本类库 + JVM，没有JRE，java程序⽆法运⾏
-
JDK = JRE+JVM+开发⼯具包
-
Java核⼼优势:⼀次编译，到处运⾏，能够跨平台运⾏的核⼼在于 JVM
-
**JRE ** (Java Runtime Environment) ：是Java程序的运行时环境，包含
JVM和运行时所需要的核心类库。 -
JDK (Java Development Kit)：是Java程序开发工具包，包含
JRE和开发人员使用的工具。
我们想要运行一个已有的Java程序，那么只需安装JRE 即可。
我们想要开发一个全新的Java程序，那么必须安装JDK 。
小贴士：
三者关系： JDK > JRE > JVM
JDK的安装目录介绍
| 目录名称 | 说明 |
|---|---|
| bin | 该路径下存放了JDK的各种工具命令。javac和java就放在这个目录。 |
| conf | 该路径下存放了 JDK 的相关配置文件 |
| include | 该路径下存放了一些平台特定的头文件 |
| jmods | 该路径下存放了 JDK 的各种模块 |
| legal | 该路径下存放了 JDK 各模块的授权文档 |
| lib | 该路径下存放了 JDK 工具的一些补充 JAR 包 |
什么是注释
注释：就是对代码的解释和说明。其目的是让人们能够更加轻松地了解代码。为代码添加注释，是十分必须要的，它不影响程序的编译和运行。
注释的分类
-
单行注释
格式：
// 注释信息 -
多行注释
格式：
/* 注释信息 */ -
文档注释
格式：
格式：/** 注释信息 */
project（项目、工程）
淘宝、京东、网站都属于一个个项目，IDEA中就是一个个的Project。
module（模块）
在一个项目中，可以存放多个模块，不同的模块可以存放项目中不同的业务功能代码。在黑马程序员的官方网站中，至少包含了以下模块：
- 论坛模块
- 报名、咨询模块
为了更好的管理代码，我们会把代码分别放在两个模块中存放。
package（包）
一个模块中又有很多的业务，以黑马程序员官方网站的论坛模块为例，至少包含了以下不同的业务。
- 发帖
- 评论
为了把这些业务区分的更加清楚，就会用包来管理这些不同的业务。
class（类）
就是真正写代码的地方。
小结
-
层级关系
project - module - package - class
-
包含数量
project中可以创建多个module
module中可以创建多个package
package中可以创建多个class 这些结构的划分，是为了方便管理类文件的。
IDEA中层级结构介绍
结构分类
- project（项目、工程）
- module（模块）
- package（包）
- class（类）
关键字
Java自己保留的一些单词，作为特殊功能的，例如：public、class、byte、short、int、long、double…
我们不能用来作为类名或者是变量名称，否则报错。
注意：关键字很多，不用刻意去记。
| abstract | assert | boolean | break | byte |
|---|---|---|---|---|
| case | catch | char | class | const |
| continue | default | do | double | else |
| enum | extends | final | finally | float |
| for | goto | if | implements | import |
| instanceof | int | interface | long | native |
| new | package | private | protected | public |
| return | strictfp | short | static | super |
| switch | synchronized | this | throw | throws |
| transient | try | void | volatile | while |
标志符
标志符就是由一些字符、符号组合起来的名称，用于给类，方法，变量等起名字的规矩。
基本要求：由数字、字母、下划线(_)和美元符($)等组成
强制要求：不能以数字开头、不能是关键字、区分大小写
基本命令规范
变量名称：满足标识符规则，建议全英文、有意义、首字母小写，满足“驼峰模式”，例如：int studyNumber = 59。
类名称： 满足标识符规则，建议全英文、有意义、首字母大写，满足“驼峰模式”，例如：HelloWorld.java。
面试题1：
Java跨平台工作原理:
你是怎么理解Java是一门「跨平台」的语言，也就是「一次编译，到处运行的」？
精确答案：
JVM 虚拟机本身不允许跨平台，每一个操作系统都有对应版本的虚拟机。允许跨平台的是 Java 程序；
Java源代码会被编译为class文件，class文件是运行在JVM之上的。
当我们日常开发安装JDK的时候，可以发现JDK是分「不同的操作系统」，JDK里是包含JVM的，所以Java依赖着JVM实现了『跨平台』
JVM是面向操作系统的，它负责把Class字节码解释成系统所能识别的指令并执行
面试题2：
聊聊源码文件(.java)到代码执行的过程
精确回答：
4个步骤：编译->加载->解释->执行
编译：将源码文件编译成JVM可以解释的class文件。
编译过程会对源代码程序做 「语法分析」「语义分析」「注解处理」等等处理，最后才生成字节码文件。
加载：将编译后的class文件加载到JVM中。
「解释」这个阶段它做的事情可以总结为：把字节码转换为操作系统识别的指令
在解释阶段会有两种方式把字节码信息解释成机器指令码，一个是字节码解释器、一个是即时编译器(JIT)。
「执行」这个阶段它做的事情可以总结为：操作系统把解释器解析出来的指令码，调用系统的硬件执行最终的程序指令。
2️⃣基本数据类型和变量
变量的定义
变量：在程序运行过程中，其值可以发生改变的量。生活中也有很多 变量 比如年龄 、等等；
当 Java 程序运行过程中，我们需要存储一些数据，此时就可以在内存开辟一个个变量空间来存储这些可变的数据。
通俗的来讲：变量就是一个数据存储空间的表示，不同数据存入具有不同内存地址的空间，彼此相互独立。从本质上讲，变量是内存中的一小块区域，其值可以在一定范围内变化。
所以，变量的组成是由：变量名、变量类型、变量值三个部分组成。
变量名
变量名也就是标识符，其实就是为了方便区分不同的变量。但这个名也不是随便起的，在长久的演化中，我们有了约定俗成的规范。
1.可以使用数字、字母，下划线和 $ 符号组成，但数字不能开头。
2.不能使用关键字（public、void等）和保留字（goto、def等）！关键字：被系统定义了特殊含义的单词。保留字：现在还不是关键字，未来可能有特殊含义。
3.起名要见名知意。例如：name 一看就知道是名字，password是密码等。
4.采用小驼峰式命名法（Lower Camel Case）。(所谓小驼峰命名法，即首字母小写，如果有多个单词那么后面的每个单词首字母大写。e.g. userPassword) ；另外因为支持下划线，所以有些时候会有下划线连接法命名的变量。e.g. user_password。
变量的定义格式：
数据类型 变量名 = 初始化值; // 声明变量并赋值
int age = 18;
System.out.println(age);
// 先声明，后赋值（使用前赋值即可）
数据类型 变量名;
变量名 = 初始化值;
double money;
money = 55.5;
System.out.println(money);
int c,d; // 声明int类型的变量c和d，中间使用逗号隔开
c = 30;
d = 40;
System.out.println(c);
System.out.println(d);
使用变量时的注意事项
1. 在同一对花括号中，变量名不能重复。
2. 变量在使用之前，必须初始化（赋值）。
3. 定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。因为整数默认是int类型，整数太大可能超出int范围。
4. 定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。因为浮点数的默认类型是double， double的取值范围是大于float的，类型不兼容。
Java中的数据类型
Java是一个强类型语言，Java中的数据必须明确数据类型。在Java中的数据类型包括基本数据类型和引用数据类型两种。
Java中的基本数据类型：
| 数据类型 | 关键字 | 内存占用 | 取值范围 |
|---|---|---|---|
| 整数 | 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 |
常量概述
在程序运行中，我们需要使用一些数据，但是这些数据在存储好后不应该再次发生变化（例如：π）。这时候，单纯使用变量存储，毕竟叫变量，难保未来可能被不小心重新赋值。
此时我们可以使用常量来解决此问题。
在Java中，其值不能改变的变量被称为常量。常量被final修饰，被final修饰则无法二次修改值。
常量的命名规范：(为了和变量做出区别，所以它也有一些小要求)
1.常量名所有字母都要大写。
2.如果有多个单词，多个单词之间使用下划线分隔。例如：MY_NAME
3.只能被赋值一次（被final修饰），通常定义时即对其初始化。
面试题：
常量概述
在程序运行中，我们需要使用一些数据，但是这些数据在存储好后不应该再次发生变化（例如：π）。这时候，单纯使用变量存储，毕竟叫变量，难保未来可能被不小心重新赋值。
此时我们可以使用常量来解决此问题。
在Java中，其值不能改变的变量被称为常量。常量被final修饰，被final修饰则无法二次修改值。
常量的命名规范：(为了和变量做出区别，所以它也有一些小要求)
1.常量名所有字母都要大写。
2.如果有多个单词，多个单词之间使用下划线分隔。例如：MY_NAME
3.只能被赋值一次（被final修饰），通常定义时即对其初始化。
类型转换
理解类型转换的故事举例： 假设现在有一个100斤的小麦口袋，还有一个40斤的大米口袋，如果我想把两个口袋换着装东西，40斤大米口袋内的大米自然可以放到100斤小麦口袋里(自动类型转换)，但是反之则不行，如果非要这么做，多余的小麦肯定会洒出来（强制类型转换）。
// 口袋：100斤小麦
double mian = 100;
// 口袋：40斤大米
int mi = 40;
mi = (int)mian;
赋值运算符：
= 号 表示赋值给XXX；
算术运算符：
算术运算符中+，-，*，/，%
++(自增)，–(自减)
/ 和 % 的区别：
/ 是取两个数相除的商：
% 是取两个数相处的余数；
%是取模运算符，就是我们常说的求余数操作。
有区别的：
int a = 3; int b = a++; //执行完后,b=3。先给b赋值，再自增。
a = 3; b = ++a; //执行完后,b=4。a先自增，再给b赋值
**条件运算符** （三目运算符）
x ? y : z
其中 x 为 boolean 类型表达式，先计算 x 的值，若为 true，则整个运算的结果为表达 式 y 的值，否则整个运算结果为表达式 z 的值。
int score = 80;
int x = -100;
String type =score<60?“不及格”:“及格”;
int flag = x > 0 ? 1 : (x == 0 ? 0 : -1);
System.out.println("type= " + type);
System.out.println("flag= "+ flag);
**运算符优先级的问题**
变量的分类：局部变量、实例变量、静态变量
常量的声名格式
final type varName = value ;
### 3️⃣ 选择结构（流程控制）
不论哪一种编程语言，都会提供两种基本的流程控制结构：分支结构和循环结构。其中分支结构用于实现根据条件来选择性地执行某段代码，循环结构则用于实现根据循环条件重复执行某段代码。
## 顺序结构
任何编程语言中最常见的程序结构就是顺序结构。顺序结构就是程序从上到下逐行地执行，中间没有任何判断和跳转。如果main方法的多行代码之间没有任何流程控制，则程序总是从上向下依次执行，排在前面的代码先执行，排在后面的代码后执行。
## 分支结构：if语句第一种格式
- **if语句第一种格式：**
if(条件表达式)｛
语句体;
｝
**执行流程**
- 首先判断条件表达式看其结果是true还是false
- 如果是true就执行语句体
- 如果是false就不执行语句体
```java
public static void main(String[] args){
System.out.println("开始");
// 定义两个变量
int a = 10; int b = 20;
//变量使用if判断
if (a == b){
System.out.println("a等于b"); }
int c = 10;
if(a == c){
System.out.println("a等于c");
}
System.out.println("结束");｝
if(关系表达式) {
语句体1;
}else {
语句体2;
}
执行流程
- 首先判断关系表达式看其结果是true还是false
- 如果是true就执行语句体1
- 如果是false就执行语句体2
分支结构：if语句第三种格式
- if语句第三种格式：** if...else if ...else
if (判断条件1) {
执行语句1;
} else if (判断条件2) {
执行语句2;
}
...
}else if (判断条件n) {
执行语句n;
} else {
执行语句n+1;
}
```
- 执行流程
- 首先判断关系表达式1看其结果是true还是false
- 如果是true就执行语句体1，然后结束当前多分支
- 如果是false就继续判断关系表达式2看其结果是true还是false
- 如果是true就执行语句体2，然后结束当前多分支
- 如果是false就继续判断关系表达式…看其结果是true还是false
- …
- 如果没有任何关系表达式为true，就执行语句体n+1，然后结束当前多分支。
分支结构：if…else嵌套
在if的语句块中，或者是在else语句块中，
又包含了另外一个条件判断（可以是单分支、双分支、多分支）
执行的特点：
（1）如果是嵌套在if语句块中的
只有当外部的if条件满足，才会去判断内部的条件
（2）如果是嵌套在else语句块中的
只有当外部的if条件不满足，进入else后，才会去判断内部的条件
分支结构：switch选择结构
switch(表达式){
case 常量值1:
语句块1;
【break;】
case 常量值2:
语句块2;
【break;】
。。。
【default:
语句块n+1;
【break;】
】
}
执行过程：
（1）入口
①当switch(表达式)的值与case后面的某个常量值匹配，就从这个case进入；
②当switch(表达式)的值与case后面的所有常量值都不匹配，寻找default分支进入;不管default在哪里
（2）一旦从“入口”进入switch，就会顺序往下执行，直到遇到“出口”，即可能发生贯穿
（3）出口
①自然出口：遇到了switch的结束}
②中断出口：遇到了break等
> 注意：
>
> （1）switch(表达式)的值的类型，只能是：4种基本数据类型（byte,short,int,char），两种引用数据类型（JDK1.5之后枚举、JDK1.7之后String）
>
> （2）case后面必须是常量值，而且不能重复
面试题1：
说说if和switch的区别?
1.if和switch判断条件的数据类型不同，if的判断条件数据类型是布尔类型，switch的判断条件数据类型一般是int类型。
2.if elseif 流程语句中可以允许有多个判断条件为true但只会执行第一个判断条件为true的语句体，switch语句中case条件取值是不能重复的。
3.写法上，当if 流程语句中只有一个判断条件的时候语句体的{}可以省略不写，switch语句中只有一个case条件语句体的{}也不能省略，当switch语句有多个case时，每个case后面的break关键字不能省略，不然可能会发生向下穿透的问题。
总结：
从结构化程序设计角度出发，程序有三种结构：顺序结构、选择结构和循环结构
选择结构
if 单选择结构 if-else 双选择结构 if-else if-else 多选择结构
switch 多选择结构
多选择结构与 switch 的关系：当布尔表达式是等值判断的情况，可使用多重选择
结构或 switch 结构，如果布尔表达式区间判断的情况，则只能使用多重选择结构
4️⃣ 循环结构
for循环结构（掌握）
循环：
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，
当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形 成死循环。
for循环格式：
for (初始化语句;条件判断语句;条件控制语句) {
循环体语句;
}
格式解释：
初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情
条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
public class ForTest01 {
public static void main(String[] args) {
//需求：输出数据1-5 for(int i=1; i<=5; i++) {
System.out.println(i); }System.out.println("--------");
//需求：输出数据5-1
for(int i=5; i>=1; i--) {
System.out.println(i);
}
}
}
while结构（掌握）
while循环完整格式：
初始化语句;
while (条件判断语句) {
循环体语句;
条件控制语句;
}
while循环执行流程：
①执行初始化语句
②执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续
跳转控制语句（掌握）
跳转控制语句（break）
跳出循环，结束循环
跳转控制语句（continue）
跳过本次循环，继续下次循环
注意： continue只能在循环中进行使用！
break 语句
- break语句用于终止某个语句块的执行
- break : 只能用于结束所在循环, 或者结束所在switch分支的执行。
- break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是
哪一层语句块 - 使用场合
break常用于switch结构和循环结构中
5️⃣一维数组与多维数组
数组概述和特点
数组的定义
数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先
后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）
来访问它们。数组的三个基本特点：
-
长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
-
其元素必须是相同类型，不允许出现混合类型。
-
数组类型可以是任何数据类型，包括基本类型和引用类型。
-
数组变量属于引用类型
数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员 变量。数组本身就是对象，Java 中对象是在堆中的，因此数组无论保存原始类型还是其 他对象类型，数组对象本身是在堆中存储的。
数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。下面针对这三
种方式分别讲解
数组的静态初始化 int [ ] a = { 1, 2, 3 };// 静态初始化基本类型数组；
Man[ ] mans = { new Man(1, 1), new Man(2, 2) };// 静态初始化引用类型数组；
动态初始化 数组定义与为数组元素分配空间并赋值的操作分开进行。
数组的动态初始化 int[ ] a1 = new int[2];//动态初始化数组，
先分配空间；
a1[0]=1;//给数组元素赋值； a1[1]=2;//给数组元素赋值；
3.数组的默认初始化 数组是引用类型，它的元素相当于类的实例变量，
因此数组一经分配空间，其中的每个 元素也被按照实例变量同样的方式被隐式初始化。
数组的默认初始化
int a2[ ] = new int[2]; // 默认值：0,0
boolean[ ] b = new boolean[2]; // 默认值：false,false
String[ ] s = new String[2]; //
数组的遍历
数组元素下标的合法区间：[0, length-1]。我们可以通过下标来遍历数组中的元素，遍历
时可以读取元素的值或者修改元素的值
for-each 循环
增强 for 循环 for-each 是 JDK1.5 新增加的功能，专门用于读取数组或集合中所有的元
素，即对数组进行遍历。
多维数组
多维数组可以看成以数组为元素的数组。可以有二维、三维、甚至更多维数组，但是实
际开发中用的非常少。最多到二维数组（学习容器后，我们一般使用容器，二维数组用的都
很少）
public static void main(String[ ] args) {
// Java中多维数组的声明和初始化应按从低维到高维的顺序进行
int[ ][ ] a = new int[3][ ];
a[0] = new int[2];
a[1] = new int[4];
a[2] = new int[3];
// int a1[ ][ ]=new int[ ][4];//非法
面试题:
1、数组的特点：
数组是相同类型数据的有序集合。
数组的四个基本特点：
其长度是确定的
其元素必须是相同类型
可以存储基本数据类型和引用数据类型
数组变量属于引用类型
数组的初始化：静态初始化、动态初始化和默认初始化。
数组的长度:数组名.length，下标的合法区间[0,数组名.length-1]。
数组拷贝:System 类中的 static void arraycopy(object src，int srcpos，object dest， int
destpos，int length)方法。
数组操作的常用类 java.util.Arrays 类
打印数组:Arrays.toString(数组名);
数组排序:Arrays.sort(数组名);
二分查找:Arrays.binarySearch(数组名,查找的元素);