一、JDK环境搭建
1、环境变量的配置
目的：为了能在任意目录下可以使用到javac.exe和java.exe
方式一：
1）我的电脑点击鼠标右键，选择属性
2）找到高级系统设置，点击进去
3）找到环境变量，点击进去
4）找到系统变量，找到path变量
5）在path变量中，添加bin目录的路劲即可，类似：D：\dev\jdk1.8.0_241\bin
方式二：
1）我的电脑点击鼠标右键，选择属性
2）找到高级系统设置，点击进去
3）找到环境变量，点击进去
4）找到环境变量，创建一个新的变量JAVA_HOME，变量值为bin目录的上一级
5）将JDK的目录放入JAVA_HOME，即D：\dev\jdk1.8.0_241\bin
6）将JAVA_HOME配置到path中，%JAVA_HOME%\bin
验证配置成功：任意目录下打开dos命令输入javac.exe和java.exe
2、JDK/JRE/JVM
JDK：Java语言开发环境，里面包含JRE和开发相关的工具包（一些文件夹和应用程序）
JRE：Java语言运行环境，里面包含JVM（Java虚拟机）和核心类库
JVM：Java虚拟机
JDK>JRE>JVM
3、Java介绍
Java是一门面向对象编程语言，不仅吸收了C++的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因为Java语言具有功能强大和简单易用两大特征。Java语言作为静态面向对象编程语言代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。
J2ME(Java2 Micro Edition Java2平台的微型版应用与移动、无线以有限资源的环境)
J2SE(Java2 Satndard Edition Java2平台的标准版）应用于桌面环境
J2EE(Java2 Enterprise Edition Java2平台的企业版)应用于基于java的应用服务器
4、Java语言的跨平台性
通过Java语言来写的程序，是可以在任何平台（操作系统）上运行
如何实现跨平台：依赖于Java虚拟机，针对不同的平台版本有不同的版本的Java虚拟机。
5、DOS操作
打开DOS窗口：
1）Windows+R+cmd+回车
2）Windows+X+A+回车（Windows）
3）长按shift+鼠标右键+powershell窗口
常见的DOS命令：
dir：展示当前文件夹中所有的子文件和子文件夹的一些信息
cd..：返回到上级目录
cd/：退回到根目录（盘符）
c：（h：）：切换盘符
cd+指定目录：进入到指定目录中
cls：清空
exit：退出dos窗口
二、Java基础学习
1、注释
注释的分类：
1）单行注释：//注释内容
2）多行注释：/*注释内容*/
3）文档注释：/**注释内容*/
注释的作用：
1）用于解释说明，提高代码阅读性
2）可以帮助找到错误
注释的注意事项：
单行注释可以嵌套；
多行注释不可以嵌套；
2、关键字
Java给我们提供好的单词，这些单词在Java中具有特殊的意义；
关键字的注意事项：
1）关键字都是小写
2）main不是关键字
3、标识符
我们自己起的名字
标识符的组成规则：
是由26个大小写英文字符，下划线和美元符号，还有数字组成的
标识符的注意事项：
1）不能以数字开头
2）标识符不能与关键字重名
4、常量
永恒不变的量
常量的分类：
整数常量：
小数常量：
字符常量：必须用单引号括起来，引号里面有且只能有一个字符
字符串常量：必须用双引号括起来，双引号里面可以有一个、多个或者没有数据均可
布尔常量：true、false
空常量：只有一个值
自定义常量：
5、进制
在计算机中数据都会变成二进制，由多个0或者1组成，而每一个0或者1都是一个位，也叫1 bit。
注意：在计算机中进行存储和运算的最小单位是字节（byte）
1 byte=8 bit
1 KB=1024 byte
1 MB=1024 kb
1 GB=1024 MB
1 TB=1024 GB
分类：
十进制：10
二进制：0b
八进制：0
十六进制：A-10/ B-11/C-12/D-13/E-14/F-15；0x
进制转换：
8421 快速转换法
6、原码、反码、补码
计算机在对数据进行运算的原理：
正数的原码反码补码的转换规则：正数的原码反码补码是一样的
负数的原码反码补码的转换规则：负数的原码变反码，符号不变，其余的0变1,1变0；负数的反码变补码，只需要+1；
符号位：二进制的最左边的哪一位就称为符号位，正位的符号位是0，负数的符号位是1。
7、变量
概念：在一定范围内可以发生变化的量
定义格式：
格式一：数据类型 变量名 = 数据；
int a= 12；（直接定义变量）
格式二：数据类型 变量名；
变量名 = 数据；
int i ；
i =2 ；（间接定义，先声明变量，再定义）
说明：当我们在程序中写了int a= 12这样一句代码，在内存中会开辟一块内存空间，该空间的名字就是我们起的变量名a，该空间中存储的数据的数据类型就是我们给的int类型，该空间中存储的数据就是我们给的12
注意：
①当我们给float类型变量赋值是需要在数据的后面加上f或者F；
②当我们再给long类型赋值的时候建议加上L或者l；
③当我们想要使用某个变量时一定要先赋值再使用；
④当我们想要给某个变量赋值时一定要考虑该变量的范围，不然容易报错；
⑤在同一对花括号内不能定义同名变量；
8、数据类型
Java中数据类型分类：2大类4小类8小种
基础数据类型：4类8种
整型：
byte：1个字节
short：2个字节
int：4个字节
long：8个字节
浮点型：
float ：4个字节
double ：8个字节
字符型：
char：2个字节
布尔型：
boolean：1个字节
引用数据类型（以后学）
9、数据类型的转换
分类：
①隐式类型转换：指小的数据类型会自动提升为大的数据类型 
②强制类型转换：指大的数据类型被强制转换成小的数据类型
强制数据类型转换的格式：小的数据类型 小的数据类型的变量名 = （小的数据类型）大的数据类型的变量名；
注意：我们能不使用强制转换，尽量不要使用，因为转不好会出现问题；
10、 ASCII编码表
11、运算符
1）算术运算符：
① +：
在Java中+号的含义：加减乘除的加；正负的正；连接符（任意数据类型以字符串相连接）；
② -：
③*：
④/：整数除于整数的结果为整数
⑤ %：模，取余
⑥++：
单独使用：
参与运算：
++在前：先自身加1，然后再参与运算
int i =1；
int j = ++i；
System.out.printIn（j）；//2
System.out.printIn（i）；//2
++在后：先参与运算，然后才自身加1
int i =1；
int j = i++；
System.out.printIn（j）；//1
System.out.printIn（i）；//2
⑦--：
2）赋值运算符 
3）关系运算符
关系运算符得出的结果一定是boolean类型，要么为true要么为false
>
<
>=
<=
==： 比较两边数据是否相等
==和=的区别：==是比较，=是赋值
12、switch语句
格式：
switch（表达式）{
case 取值1：
语句体1；
break；
case 取值2：
语句体2；
break；
default：
语句体；
break；
}
执行流程：当程序执行到switch的时候，会进入到awitch找第一个case进行匹配，若匹配成功则执行case里面的语句体内容和break；若未匹配成功就继续向下走找到第二个case继续匹配；若所有的case都不匹配则执行default的语句体内容。
练习：
注意：
①switch中的表达式的数据的数据类型可以为：byte、short、int、char、string、枚举
②default可以放置在任意一行，无论放在哪里都会先去找第一个case去匹配，如果所有的case都不匹配才执行default的语句体，default可以省略不写，但是建议写上；
③break可以不写，就容易造成switch的穿透想象；如果匹配过一次或者执行过default之后，都不会进行二次匹配，但是语句体内容该执行还是会执行；
④switch结束标记：break、遇到结尾 }
switch和if的区别：
①如果是判断某个区间范围时推荐使用if
②如果判断是某几个数据时推荐使用switch
13、局部代码块
代码块：由一对花括号括起来的称为代码块
局部代码块：写在main（程序执行的入口）里面的代码块称为局部代码块
局部代码块的作用：
能够变量更早的在内存中消失，节省内存空间
练习：
以下代码不合理之处以框出：
14、循环
1）for：
格式：
for（初始化条件；判断条件；控制条件）{
语句体；
}
初始化条件：就是定义一个变量并进行赋值
判断条件：关系运算符
控制条件：自增加
语句体：重复执行的内容
执行流程：
初始化条件--》判断条件--》语句体--》控制条件
--》判断条件--》语句体--》控制条件
--》判断条件--》语句体--》控制条件
.................
知道判断条件不满足，循环结束
2）while：
格式：
初始化条件；
while（判断条件）{
语句体；
控制条件；
}
执行流程：
初始化条件--》判断条件--》语句体--》控制条件
--》判断条件--》语句体--》控制条件
--》判断条件--》语句体--》控制条件
.................
知道判断条件不满足，循环结束
练习：
3）do while：
格式：
初始化条件；
do{
语句体；
控制条件；
}while（判断条件）；
执行流程：
初始化条件--》语句体--》控制条件--》判断条件
--》语句体--》控制条件--》判断条件
--》语句体--》控制条件--》判断条件
....................
--》语句体--》控制条件--》直到判断条件不满足的时候循环结束
练习：
4） while、for、do..........while的区别
while和do......while的区别：
do......while：①语句体和控制条件至少会执行一次；
② 语句体和控制条件和判断条件执行的次数是一样多的；
while和for：①语句体和控制条件可以一次都不执行；
②语句体和控制条件比判断条件执行少一次
while和for：
while：初始化条件在while循环结束之后，依旧可以继续使用
for：初始化条件一旦for循环结束，就不用了
明确循环次数建议使用for，不明确循环次数使用while；
15.死循环
16.break和continue
17.循环嵌套
指将一个循环放入到另外一个循环里面
注意：外层循环控制行数，内层循环控制列数
18.数组
数组是个容器，引用数据类型
数组的作用：
用来装数据，方便对数据进行管理和操作。
数组容器的特点：
①数组容器一旦初始化，长度就固定不能更改；
②数组容器中既可以存储基本数据类型，也可以存储引用数据类型
③一个数组容器中的所有元素的数据类型必须是相同的。
数组的定义格式：
格式一：
元素的数据类型[ ] 数组的名字 = new 元素的数据类型[元素的个数（数组的长度）]；
int [ ] arr =new int[5];
格式二：
元素的数据类型[] 数组的名字 = new 元素的数据类型[]{元素1，元素2.........}；
int [ ] arr =new int[]{12,23,58.........};
格式三：
元素的数据类型[] 数据的名字 = new {元素1，元素2，.......}；
int [ ] arr =new int{12,23,58.........};
数据容器的使用：
①创建数组容器：int [] arr = new int[3]
②容器中存储数据：
存数据格式：数据名[索引]=数据；
索引：就是编号，从0开始编号依次往后，最大编号是容器的长度减一
③从容器中取数据
取数据格式：数据名[索引]
int a= arr[0]
遍历：将容器中的数据挨个获取出来并打印出来
数据名.length=获取数组容器的长度
for (int i =0;i<3;i++){
System.out.println(arr[i]);
}
数组的内存图：
Java的内存分配：
堆
栈
方法区
本地方法栈
寄存器
二维数组的内存图：
练习题：
统计水仙花数总计有多少个：
数组遇到的错误：
①ArrayIndexOutOfBoundsException：数组索引越界异常（超出了数据的最大索引）
②NullPointExcepttion：空指针异常，
数组常见的操作：
①遍历： 
②获取最值：
方式一：max存储的是元素
方式二：max存储的是索引
③基本查找
④数组反转
⑤排序
方式一：选择排序
方式二：冒泡排序
二维数组：
元素为以为数组的数组称为二维数组
二维数组定义格式：
格式一：元素的数据类型[][] 数组名字 = new 元素的数据类型 [二维数组的长度] [一维数组的长度];
int [][] arr = new int[3][2];
二维数组中有3个一维数组，每一个一维数组中有2个元素
格式二：元素的数据类型[][] 数组名字 = new 元素的数据类型 [二维数组的长度] [];
int [][] arr = new int[3][];
二维数组中有3个一维数组，每一个一维数组中有不确定有几个元素，而且每一个一维数组中的元素的个数是可以不一样的
格式三：元素的数据类型[][] 数组名字 = {{元素1，元素2，.....}，{元素1，元素2，......}，.......};
int [][] arr = {{1,2,3}，{4,5}，......}；
二维数组中有3个一维数组；每一个一维数组中第一个一维数组有3个元素，第二个一维数组有2个元素
19.方法（函数）
1）含义：具有（特定功能）的一段独立的小程序（代码块）
2）方法的作用：
提高代码的复用性；
提高代码的维护性；
3）方法的定义格式：
修饰符 返回值类型 方法的名字（数据类型 变量名，数据类型 变量名，.......）{
执行语句；（该方法的功能的代码实现）
return 返回值；
}
写方法的注意事项：明确参数列表和返回值类型
例子：
4）方法的使用
方法的调用：
①单独调用：方法名（参数）
注意：如果方法的返回值类型为void时只能单独调用
②输出调用：SystemOutPrintln（方法名（参数））；
注意：如果方法的返回值类型为void时不能输出调用；如果方法有具体返回值的时候使用单独调用没有任何意义；
③赋值调用：数据类型 变量名= 方法名（参数）；
注意：如果方法的返回值类型为void时只能赋值调用
5）方法的执行流程
以上述列子为例的执行流程如下：
6）常见方法的返回值类型
①byte
②short
③int
④long
⑤float
⑥double
⑦boolean
⑧char
⑨string
⑩数组
⑪void的方法
7）使用方法的注意事项
①方法与方法是平级关系，所以不能嵌套定义；
②方法的返回值类型和返回值要匹配
③当方法没有具体的返回值时，返回值类型就为void
void：没有什么特殊的含义，而且只能写在返回值类型的位置上，代表该方法没有返回值；
注意：当方法的返回值类型为void时return关键字是可以省略不写的；
return关键字的作用：可以返回具体的数据，哪里调用返哪里；作为方法借宿的标识；
8）方法内存图
调用方法则进栈，进栈之后执行里面的代码，代码执行成功后在栈里消失
9）基本数据类型和引用数据类型参数传递的问题
案例一：
案列二：
形式参数：形参，在定义方法的时候小括号里面的变量就是形式参数
实际参数：实参，在调用方法的时候传递里面的数据就是实际参数
10）方法的重载
含义：在同一个类中，出现两个方法的名字相同，参数列表不同（参数个数、数据类型、对应顺序不同）的两个方法
同名方法进行调用时优先数据类型相同的优先调用：
20.面向对象和面向过程
c语言是面向过程
java语言是面向对象
面向过程：强调过程，即重点强调每一个方法，每一个过程，面向方法，面向过程。
面向对象：强调对象，
面向对象和面向过程的关系：面向对象是基于面向过程的，是建立在面向过程基础之上的。
面向对象的好处：
①它是一种更符合我们人类思考习惯的思想
②它可以将复杂的事情简单化
③他可以将我们程序员从执行者变成指挥者
例子：
类和对象
类：是事物的属性和行为的集合
对象：是类的具体的体现
如果拿“人”为累的话，那对象就是类中具体的你我他。
在Java程序中写类和对象：
练习：
类的定义：要用关键字class
类的格式：
class 类名{
类的属性；
类的行为；
}
步骤：
①知道你要写的类是什么，从显示生活中去寻找
②该类事物中有哪些属性
属性：事物的外在特征
③该类事物中有哪些行为
行为：事物所具备的功能，一般都是动词
例子：
类的使用：也就是对象的使用
类的对象内存模型分析： 
21.成员变量和局部变量
局部变量：定义在方法中或者方法声明上的变量
成员变量：定义在类中，方法外的变量
成员变量和局部变量的区别：
①定义位置不同：
局部变量：定义在方法中或者方法的声明上
成员变量：定义在类中方法外
②内存位置不同
局部变量：存储在栈中的方法中
成员变量：存储在堆中的对象中
③初始值不同
局部变量：没有默认初始值，想要使用一定要先赋值再使用
成员变量：有默认值，如果不赋值也可以使用
string类型的变量默认的初始值为null
int类型的变量默认的初始值为0
boolean类型的变量默认的初始值为false
double类型的变量默认的初始值为0.0
char类型的变量默认的初始值为“\u0000”
④生命周期不同
局部变量：因为是存储在方法中，所以随着方法的存在而存在，随着方法的消失而消失。
成员变量：因为是存储在对象中，所以随着对象的存在而存在，随着对象的消失而消失。
⑤作用域范围
局部变量：出了方法就无法使用
成员变量：在本类中的方法都可以使用
22.匿名对象
概念：没有名字的对象
匿名对象的格式：
new 类名（）；
new person（）；
匿名对象使用属性和方法：
new 类名（）.属性名；
new 类名（）.方法名（）；
匿名对象的特点：
一次性
只能使用一次
匿名对象可以使用的时候：
当我们只需要使用一次对象的属性或者方法的时候，就可以选择使用匿名对象。
匿名对象可以作为实际参数进行传递
例子：
23.构造方法
概念：方法名和类名相同，和普通方法的格式不一样的特殊方法
定义格式：
修饰符 类名（形参，.......）{
执行语句；
}
作用：
①用来创建对象
②用于对象属性进行初始化
特点：
①构造方法没有返回值类型；
②构造方法没有返回值；（有return，一般不写）
③构造方法的名字一定要和类名相同（普通方法的名字可以和类名相同）
注意事项：
①如果我们没有手动写构造方法的话，系统会默认带一个无参构造；如果手动写了构造方法的话系统默认带无参构造就会消失
②构造方法也是方法，满足方法的重载，即一个类中可以写多个构造方法
一个类中可以写多个构造方法的作用：
可以根据不同的需求调用不同的构造方法；
有参的构造方法可以给属性赋值
在我们创建对象的时候，内存中做了那些事情：
24.五子棋
绘制棋盘：
25.static关键字
概念：它是一个修饰符，代表静态的意思，它可以修饰成员变量和成员方法，不能修饰构造方法。
特点：
①被static所修饰的成员是随着字节码文件对象的加载而加载，所以是优先于对象存在于内存中
②static所修饰的成员被该类下所有的对象所共享
③static所修饰的成员可以通过类名.直接调用
类名.属性名；
类名.方法名（）；
注意事项：
①静态方法中不能有this关键字
②静态方法中可以调用静态成员变量和静态成员方法，但是不可以调用非静态成员变量和非静态成员方法；（非静态方法中可以调用静态成员变量和成员方法，也可以调用非静态的成员变量和成员方法）
26.继承
面向对象三大特征之一（封装、继承、多态）
概念：一个类的对象可以使用另一个类的对象中的成员，这种关系称为继承。
格式：
继承的好处：
①提高代码的复用性
②让类与类之间产生了继承关系，这是构成多态的前提条件
继承的弊端：
①提高了耦合性
开发原则：高内聚，低耦合
高内聚：指一个人的能力越强越好
低耦合：指一个人的关系越少越好
继承的特点：
在java中，类只支持单继承，不尅多继承，可以多层继承，不可以循环继承。
继承的注意事项：
①子类不能继承父类中被private关键字所修饰的成员变量和成员方法
②子类不能继承父类中的构造方法
继承使用场景：
当两个类之间存在“is a”的关系是就可以使用继承
就近原则：
在子父类继承中构造方法的关系：
①子类中的所有构造方法的第一行，默认都有一个super（）
会出现以上现象：
因为有继承，说明子类可以使用父类的成员变量，那也意味着父类的成员变量一定要有值才可以被使用，所以在创建类对象的时候会调用子类的构造方法，而子类的构造方法中会先去调用父类的构造方法，目的就是给父类的成员变量默认初始化。
②在子类中所有的构造方法中，第一行要么是super（参数）要么是this（参数），他们不可以共存。
③之类中所有的构造方法中至少有一个构造方法里面调用的是super（参数）
子父类继承中成员方法的关系：
在父类中有一个成员方法，在子类中有一个成员方法
如果这两个方法的名字都不相同的话：
如果这两个方法的名字都相同的话：打印出来的结果为子类的内容，这叫做方法的重写或者覆盖。
方法的重写（override）：在子父类继承中，子类中出现与父类方法的声明完全一直的方法。
方法的重写（override）和方法的重载（overload）的区别：
重写：在同一个类中，两个方法的名字相同，参数列表不同
重载：在子父类继承中，子类中的方法和父类中方法是完全一致。
证明方法是重写的方法：只需要在方法的声明上面加上@override（可加可不加）
重写的注意事项：
①子类不能重写父类中私有的成员方法
②子类重写父类方法的访问权限修饰符要大于等于父类的方法的访问权限修饰符（public >protected >默认 >private）
③子类方法的返回值类型可以和父类重写方法的返回值类型不一致
但是有条件，父类方法的返回值类型是子类方法的返回值类型的父类
④静态方法只能重写静态方法
只要和静态相关的，三大特征都不适用，因为静态超出了面向对象的范围
27.super关键字
概念：super是 父类内存空间的标记，在用法上我们可以当做父类对象得引用来使用，但是不能说super是父类对象的引用。
28.封装
面向对象三大特征之一
概念：隐藏对象的属性和实现细节，进对外提供公共的访问方式。
隐藏对象的属性：想要隐藏对象的属性，只需要在定义属性的前面加上private关键字即可
提供公共的访问方式：
29.private关键字
概念：是一个修饰符，代表私有的意思，可以修饰成员变量和成员方法以及构造方法
特点：被private修饰的成员变量和成员方法只能在本类中使用，不能在其他类中使用。
加上private关键字之后的标准代码：
内存图：
30.this关键字
概念：代表对象的引用，那个对象调用this所在的方法，this就代表那个对象。
作用：
①可以解决局部变量隐藏成员变量的问题
②可以调用本类中的成员变量、成员方法和构造方法
加上this关键字之后的标准代码：
31.多态
面向对象三大特征之一
概念：一个对象在不同时刻表现出来的不同状态
前提条件：
①要有继承关系
②要有方法的重写
③要有父类引用指向子类对象
多态间子父类之间成员变量的关系：多态调用成员变量的时候，编译看左边，运行看左边（等号的左边）
多态间子父类之间成员方法的关系：多态调用成员方法，编译看左边，运行看右边
多态间子父类在静态成员的关系：
多态的好处：
①提高了代码的扩展性
②父类引用作为形式参数，子类对象作为实际参数
例子：
public class Demo02{
public static void main（String [ ] args）{
AnimalTool.print(new Cat());
AnimalTool.print(new Dog());
AnimalTool.print(new Pig());
AnimalTool.print(new Bird());
}
}
class AnimalTool{
public static void print(Animal animal){
animal.eat();
}
}
class Animal{
}
class Dog extends Animal{
public void eat(){
System.out.printLn("吃狗头")
}
}
class Cat extends Animal{
public void eat(){
System.out.printLn("吃鱼")
}
}
class Pig extends Animal{
public void eat(){
System.out.printLn("吃菜")
}
}
class Bird( extends Animal{
public void eat(){
System.out.printLn("吃虫子")
}
}
多态的弊端：
①
②
32.
14万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
