真不敢相信，儿童节的坑到现在都还没有填，现在又开一个坑，得亏是平时记录的，只需要整理添加就好了，立个Flag，明天填坑
下面是学JavaSE课程的笔记总结，加粗的部分是我认为的重点。嗯，小胖子，加油！（感谢刘老师）
设置环境变量
1.新建JAVA_HOME变量, 找到Jdk的安装路径 ，将此路径作为变量值。确定
2.编辑path变量， 在该变量下面追加一条%JAVA_HOME%\bin
3.新建classpath变量，将它的值设置为.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar
程序运行顺序： java编译程序 执行
1，Java源程序（.java）------------------------------>Java字节码文件（.class）----------------->（JVM虚拟机）--------------->操作系统
跨平台JVM（JVM挖新坑）
byte 字节型 1字节
short 短整型 2字节
int 标准整型 4字节
long 长整型 8字节
float 浮点型 4字节 精确到小数点后6位
double 双精度浮点型 8字节 ..............12
char 字符型 单个字符， 2字节
boolean 是和否 true false
运算符的优先级列表
优先级
1. 一元 -（负号） ！ ++（前置） --（前置）
2. 算术 + - * / %
3. 条件 > >= < <= == !=
4. 逻辑 && ||
5. 赋值 = += -= *= /= %=
6. ++（后置） --（后置）
7. ，
8. ；
9. {}
if语句
一般语法
if (条件表达式) {
执行代码
}
原理：条件表达式的结果为真，则执行{}中的代码，条件表达式的结果为假，则不执行。
if...else语句
一般语法
if (条件表达式) {
执行代码1
} else {
执行代码2
}
多条件判断
if....else if语句
一般语法
if (条件表达式1) {
执行代码1；
} else if (条件表达式2) {
执行代码2；
} else if (条件表达式3) {
执行代码3；
}
.....
else if (条件表达式n) {
执行代码n；
}
关于多条件分支的注意事项：
无论有多少个分支，最终执行的最多只能有一个。也有可能一个都不执行。
如果没有任何一个条件表达式能成立，就一个都不执行。
else可选，视具体情况而定。
循环结构
重复执行某一个部分代码
for
在明确知道循环次数，或者明确的知道循环起点和终点的情况，
一般语法
for (表达式1; 表达式2; 表达式3) {
循环体； （需要重复执行的部分）
}
循环的运行原理
起点：初始值
终点：循环终止条件，当此条件为真时，继续下一轮循环，条件为假时，循环跳出。
增量：每次增加的量
while适合于不明确循环次数的，与break食用美滋滋
一般语法
while (条件表达式 循环终止条件) {
循环体
}
do...while
至少会执行一次的，适用于
一般语法
do {
//循环体
} while(循环终止条件);
while和do...while区别
while不能加分号， 但do...while一定要有分号。
嵌套循环
在一个循环当中套入另外一个循环。
关于break关键字
在循环中可以达到跳出循环的目的。
如果break是出现在嵌套循环中，只能跳出属于它的那一层。
若要跳到指定位置，在循环前指定一个标签名称，使用break跳出即可。
数组
批量处理相同类型的数据。
数组就是多个相同类型的变量在内存中连续存放。
声明并创建数组的一般语法
数据类型[] 数组名 = new 数据类型[长度];
索引从0开始分配
某一个元素的索引总是会与我们自然认知有1的偏差。
Java中的数组，自带length属性，自己管理自己的长度。
数组名.length
Java中的数据类型分为两类
一、基本数据类型（8个） 不用new
二、引用数据类型 （除了上述8个以外）， 需要new
数组的技巧性用法，
1. 将没有规律的一组数字放入数组中，可以达到有规律的操作方式。
2. 数组索引从0开始是个很讨厌的问题，但是巧妙地在前面强行合理地加元素，比如0，可以解决这个问题。
一、函数的定义
一般语法
返回值类型 函数名(形式参数列表) { 函数头
//代码， 函数体
}
函数头用于说明当前函数是做什么功能的
函数体则是用代码来描述是怎么做的。
不可以在某一个函数的里面来定义另外一个函数。
关于return关键字
1. 将此关键字后面的值，作为函数的最终结果，返回给函数的调用者。
2. 某个函数运行到return关键字，则当前函数的运行终止。
二、函数的调用
函数定义了之后，在没有被调用的情况下，并不执行。
函数用来将庞大的复杂的代码进行分割，进行模块化处理。
如果某个函数，设定了返回值类型，那么就一定要有return语句。
如果函数的内部由于逻辑有多个分支，一定要确保每个分支都能有return语句，而不是某个分支，另外的分支则没有。
还要确保，return关键字后面的值一定要与函数头部分设定的返回值类型要一致。
如果某个函数没有设定返回值类型，则可以没有return语句。
在调用函数时，必须确保传递的实参要与函数设定的形参保持一致。
1. 数量一致
2. 类型一致
3. 顺序一致（针对于有多个参数的情况下）
线性思维，
函数的意义
1. 分割复杂的功能，分解若干个小的功能，逐一实现的目的。
2. 思路清晰，在解决某一个小功能，不用过多去关注其他的功能，各个击破。
3. 代码逻辑层次分明，便于阅读。
4. 可以有效地解开过于复杂的嵌套关系，使代码逻辑更清爽。
面向对象(物体) Object
类
对象和类的区别
类 对象
集合 个体
抽象 具体
模板 实例
数据结构 数据
程序=算法+数据结构
是组成java程序的基本单元
java认为，类之外是不能写任何逻辑代码的，一切逻辑代码都必须现在类当中。
类最简单的意义：函数是代码的容器，那么类就是函数的容器。
一般语法
class 类名 {
成员列表，包括变量成员（属性）和方法成员（行为）
}
类名可以按照命名规则随便取，但尽量使用有意义的单词，类名习惯上首字母大写。
类并不可以直接使用，要使用类，就必须先创建其对象。
实例化，
一般语法
类名 对象名 = new 类名();
类的初始化过程：
1，加载类名.class文件进内存
2，在栈内存开辟空间（对象名）
3，在堆内存为对象开辟空间
4，对对象成员变量进行默认初始化
5，对对象成员变量进行显示初始化
6，通过构造方法对对象的成员变量赋值
7，对象初始化完成，把对象地址赋值给对象名
类名()实际上是表示构造方法。
只要实例化了对象，就相当于在内存中分配了空间，用于保存与当前对象有关的数据或方法。
之后可以通过对象名去操作其中的成员。
. 成员运算符，通过该符号可以访问到对象中的成员。
原则上，任何一个类都可以实例化任意多对象，并且各个对象之间相互独立，并不关联。
类最简单的意义：函数是代码的容器，那么类就是函数的容器。
类是进行封装的基本形式。
类本质上是一种自定义的，相对复杂的数据类型。
如果编程语言没有提供的，某种相对复杂的数据类型，自己来定义它。
封装：将一些基本，零散的属性或方法捆绑在一起，可以描述一个更为复杂的物体。
构造方法，对象的初始化问题
在实例化某个对象的同时，就让其属性已经赋值。
构造方法
语法
与类同名，一定不能有返回值类型
通常情况下，被修饰为public的。
执行
不能通过常规手段去显式调用构造方法
构造方法只能被new关键字隐式地执行。
在实例化一个对象时，一定要执行构造方法。如果构造方法不能顺利地执行，将导致对象也无法创建。
对于某一个对象而言，构造方式在创建该对象时，必须执行且只能执行一次。
特点
如果某个类，没有人为地定义构造方法，编译器将自动地为其生成一个缺省构造方法。为了维护实例化对象一定要执行构造方法的原则。
只要一旦人为地定义了构造方法，缺省构造方法就自动消失。
Java中，同一个作用域当中，变量是不可以重名。
方法（函数）重载
在Java中允许出现方法同名的情况。
构成方法重载的三个必要条件
1. 在同一作用域（同一个类中）
2. 方法名完全一样。
3. 参数列表必须不一样。
一组（多个）方法构成了方法重载以后，在调用此方法时，编译器将自动根据调用时传递的实际参数来确定，到底是谁执行。找到形参与实参对应的那个方法执行。但如果没有找到任何匹配的方法，则语法报错。
注意事项
1. 方法的关键点是，参数必须各不相同。确保在这一组函数中，每个函数的参数列表都是独一无二的。
参数列表的不一样可以是三个方面的
a, 类型不一样
b, 数量不一样
c, 顺序不一样
2. 方法重载与返回值无关。返回值同与不同对于方法重载没有任何影响。
一般来讲，构成方法重载的一组方法应当是完全一样的，或是非常接近的功能。功能完全不同的方法不能写成重载关系。
构造方法重载
在某一个类中，提供多个参数列表不同的构造方法，构造方法重载。
构造方法的重载实际上为类的使用者提供了多种实例化对象的方案，使实例化对象的做法更为灵活，自由。
类的伟大意义
1. 函数的容器
2. 封装的一种表现形式。
3. 自定义的数据类型。
4. 好用的功能模块。
打包和导包
包实际上是更高层次的一种封装机制。
方法是代码的容器。
类是方法的容器。
包是类的容器。
实际上，包的体系就是文件夹体系。编译后按照包的体系创建文件夹体系，再分别保存源文件和类文件。
注意事项：
package 语句只能位于整个源文件的第一句。
良好的编码习惯是，一个源文件只写一个类。
如果在同一个包中的类，相互访问，没有限制。
如果出现了跨包访问的情况，则必须导入类。
import
2. 类本身的访问权限
用来修饰类，来决定当前类是否能被包外部访问，一个关键字，两种机制
public 被修饰为public的类允许被包外访问，必须要导import
缺省 此访问权限不允许被包外访问。
注意事项
被修饰为public的类必须与源文件同名。
一个源文件只写一个类。
this
有当前类的对象的意思。可以理解为类似第一人称代名词“我”
当出现了属性与参数同名的情况下，用this关键字来区分是属性还是参数。但是如果没有类似的歧义，则this是可以省略的。
在一个类中，可以在其中的某一个构造方法内，通过this关键字来显式调用另外一个构造方法。
static
静态的，被修饰为静态的成员允许在类没有被实例化以前直接访问。
被修饰为static的方法中无法直接去访问非static的成员。
关于变量的初始化问题
对于局部变量而言，没有初始值，就直接访问，将报错。
对于成员变量而言，没有初始值，自动默认初始化为0。
继承的基本语法
Java允许在一个现有的类的基础之上，派生出另外一个新类。
继承的一般语法
class 子类名 extends 父类名 {
}
当两个之间发生了继承关系，子类可以将父类的成员据为已有。
Java中的继承两大基本原则
1. 继承是单方向的。
子类可以使用父类的成员，但反之（父类不可以使用子类的成员）不可以
同一个父类允许派生出多个子类。
继承关系具有可延续性
2. 继承只能单继承，不能多继承。
任何一个类最多只能有一个直接父类。（间接父类不在此限制，有可能多代继承）。ps:想实现多继承效果，食用接口的咯。
继承的伟大意义
1. 为多态创造基本条件。
2. 使数据兼容成为可能。
在有包，有继承的情况下，访问权限开始复杂化。
一、类成员的访问权限，三个关键字，四种规则
public全开放
protected两个条件（同包，父子）具备其一，就可以访问，被修饰为protected的成员，只针对第4种类关系不能访问。
缺省只承认同包关系，其他关系一概不承认。被修饰为缺省的成员，只能被第1种和第2种关系的类访问，其他不可以。
private全封闭（除了自己本类以外，其他都不可以，子类都不可以）
类和类之间的关系
1. 同包的父子。
2. 同包非父子
3. 非同包父子
4. 非同包非父子
基本原则：数据成员私有化，方法成员公开化
进阶技巧：模棱两可的情况下，公开最小化原则。
封装的根本意义：尽可能少的公开细节。
二、类本身的访问权限，一个关键字，二种规则
public
缺省
继承的意义
如果单单只是从语法的层面上看，任何一个类都可以继承于另外一个类。
如果从逻辑上讲，父类和子类之间一定要具备子集关系，才可以继承。
如果两个类发生了继承关系，就可以用父类的引用去实例化子类的对象。但反之不行。
实际上，两个类之间发生了继承关系，本质上就是让两种数据类型能够兼容。
用父类的引用操作子类实例的做法，引用转型。
如果父子类中出现了同名的成员，会有什么状况。
1. 如果同名属性。
一般利用super和this来区分。
2. 同名方法
a ， 父子类中出现同名方法，但参数列表却不同。重载。
b, 父子类中出现了同名的方法，并且参数一模一样。重写。
重写
就是子类定义与父类中完完全全一模一样的方法，实际上就相当于子类中定义的这个方法，把父类中的同名覆盖掉了。
两个类中，出现了重写情况，实际上就是谁调谁的方法。
重载的三大前提条件：
1. 同一作用域（同一个类，父子类对于子类而言也叫同一作用域 ）
2. 同名
3. 参数不同
引用转型+重写
多态
在有方法重写的情况下，如果出现引用转型，通过父类引用实际调用到了子类的方法，称为多态。
多态的必要前提条件是继承。继承的真正目的，是为多态创造前提条件。
多态
抽象类抽象方法
有时候，为了实现多态效果，不得不在父子类中造成方法重写，但是父类中的方法又无法具体实现，可以考虑将父类中的方法定义为抽象方法。
定义抽象方法的一般语法
访问权限 abstract 返回值类型 方法名(形参列表) ；
实际上，抽象方法就是没有方法体（只有方法头）的方法。
包含有抽象方法的类，就必须定义为抽象类。
定义抽象类的一般语法
访问权限 abstract class 类名 {}
抽象类的特殊之处
1. 抽象类严禁实例化，但可以声明引用。
2. 抽象类如果有子类，意味着其子类继承了父类的抽象方法。
a, 如果子类继续维持父类的抽象方法不实现，就必须把自己也定义为抽象的。该子类也是抽象类，遵循抽象类的所有规则。
b. 如果子类不想继续成为抽象类，就必须对于父类的抽象方法提供具体实现，就是为抽象方法写方法体。
抽象方法的本质就是抽象父类强制要求其子类必须实现的方法原型。
接口
如果某个类，其中定义的所有方法都是抽象的，可以考虑将其定义为接口。
定义接口的一般语法
访问权限 interface 接口名 {
}
接口中不能有任何方法实体（{}），所有的方法必须抽象，abstract关键字可以省略。
接口有何特殊
1. 接口严禁实例化，但是可以声明引用。
2. 接口允许有实现类。
接口实现类的一般语法。
访问权限 class 类名 implements 接口名{
}
如果实现类不提供对于接口的抽象方法的具体实现，该实现类就是抽象类。
如果实现类不想成为抽象，就必须对接口中的抽象方法提供具体实现。
接口的意义
单继承，多实现。
1. 如果实现了多个接口，那就必须要把多个接口中的所有抽象方法都实现。
2. 父类的引用可以指向子类的实例，接口的引用也可以指向实现类的实例。
让数据兼容最大化。
Java的API
应用程序编程接口。
由编程语言自身提供的，直接拿来使用的一些固化的功能。
类库，佐证封装，继承，多态
java.lang包
Java第一包
与JVM相关的类
与异常相关的类
与数据类型相关的类
与线程相关的类
..........
按照基本原则，在使用任何一个不同包的类时，一般需要先导入
java.lang包是整个Java体系中唯一一个不需要明确导入的包。
java.lang中，针对8个原始数据类型，提供了相对应的8个包装类。
import java.lang.Integer; int
import java.lang.Short; short
import java.lang.Byte; byte
import java.lang.Boolean; boolean
import java.lang.Long; long
import java.lang.Float; float
import java.lang.Double; double
import java.lang.Character; char
在某些特定的情况下，如果不方便直接使用原始数据类型，就可以考虑使用对应的引用数据类型（包装类）
所有的包装类都提供了一个构造方法，可以将对应的原始数据类型值实例化一个引用数据类型的值。
在Java中，任何一个数据都至少有三种基本表现形式。
在这三种表现形式中，该如何自由的转化。
1. 基本数据类型转引用数据类型
直接利用对应的包装类提供的构造方法来实例化对象即可。
2. 引用数据类型转化为基本数据类型 拆箱
所有的包装类都提供了一个命名类似于xxxValue()的方法，用于将引用数据类型还原成为原始数据类型。命名中的xxx对应的是数据类型名称。
3. 将字符串转化为原始数据类型
任何一个包装类都提供一个静态的命名类似于parseXxx的方法，用于将字符串转化为对应的原始数据类型。其中的Xxx对应具体的数据类型
4. 将原始数据类型转字符串
任何原始数据类型直接与“”相加，即可得到字符串表现形式。
5. 将字符串转引用数据类型。
任何包装类都提供一个名为valueOf的方法，用于将字符串转化为对应的包装类对象。
6. 将引用数据类型转字符串
任何一个包装类都提供一个名为toString的方法，将引用数据类型转化为字符串。
java.lang.String类
此类提供对于字符串的操作。
字符串在Java中是引用数据类型。
在String类中提供了一系列的方法来对于字符串进行常见的操作。
length方法
用于求出当前字符串的长度（字符的数量）。
原型
int length()
将当前字符串的字符数量以整数方式返回。
两个原始数据类型的变量进行相等判断，肯定是用==
两个引用数据类型的对象进行相等判断，一定不能使用==，只能使用equals方法。
equals方法（String已经默认重写了）
用于判断两个字符串是否相等。
原型
boolean equals(String str)
判断当前字符串与参数字符串是否一致，如果相等返回true，否则返回false
判断相等规则是大小写字母敏感的。
equalsIgnoreCase方法
用于判断两个字符串是否相等，在忽略大小写的情况下。
原型
boolean equalsIgnoreCase(String str)
规则同上
endsWith方法
原型
boolean endsWith(String str)
判断当前字符串是否以参数指定的字符串作为后缀，如果是，返回true，否则返回false
startsWith
原型
boolean startsWith(String str)
判断当前字符串是否以参数指定的字符串作为开头，如果是，返回true，否则返回false
toUpperCase方法
原型
String toUpperCase()
将当前字符串转化为大写形式，并以新的字符串返回。
toLowerCase方法
同上，转小写。
indexOf方法
原型
int indexOf(char ch)
在当前字符串中查找，有没有出现过参数指定的某个字符。
如果指定字符出现过，返回其出现时的索引。
.....................没有出现过，返回-1
如果指定字符出现过多次，返回第一次出现的索引。
lastIndexOf方法
原型与上类似。
在当前字符串中查找，有没有出现过参数指定的某个字符。
如果指定字符出现过，返回其出现时的索引。
.....................没有出现过，返回-1
如果指定字符出现过多次，返回最后一次出现的索引。
substring方法
原型：
String substring(int beginIndex, int endIndex)
参数指定起始索引，和终止索引，将两个索引之间的字符串返回。
截取出来的子串，包含起始索引，但不包含终止索引。
此方法提供了重载
String substring(int beginIndex)
从起始索引一直截取到最后。
charAt方法
原型
char charAt(int index)
参数指定一个有效索引，将此索引位置上的那个字符返回。
注意：
charAt方法极度容易与indexOf搞混。
charAt是根据索引找字符。
indexOf是根据字符找索引。
关键字final限制此类不可以被继承。
java.lang.Math
此类中定义了一系列与数学计算相关的方法。
特点
1. 此类不能被实例化（此类只提供一个唯一的私有化的构造方法。）
2. 此类是不可以被继承的。（此类被修饰为final）
3. 此类中的所有方法全部被修饰为static，直接通过类名调用即可。
这是整个Java体系中，最单纯的一个类。可以将此类就看做是一个方法的容器而已。
此类中除了一系列数学有关的方法以外，还定义有两个常用的数学常量。(E,PI)
java.lang.Object
1. 此类是整个Java体系中，所有其他类的最上层父类。
2. 整个Java体系中，其他的所有类都直接或间接继承于Object类。
3. 自定义的类没有明确指定父类，默认继承于Object
Object的意义
1. 它是整个Java类体系的最上层的根。通过这个根将所有的Java类都形成一个体系。
2. Object是一条分界线，它之下是C，是汇编，是面向过程，它之上是Java，是面向对象。
3. 根据父类引用可以操作子类的原则，实际上，Object的引用可以操作任何一个类的对象，或者可以理解为，Object的引用是一个万能应用。
推导
1. 如果有某个方法的形参设定为Object类型，那就意味着可以把除了8种原始数据类型以外的任意数据类型作为实参传递给它。
void function(Object obj)
2. Object的本质就是可以操作除了8中原始数据类型以外的所有东西。
java.util
Java第二包。
java.util.Scanner类
java.util.Random类 随机类。
java.util.Calendar 日历类
此类提供了对于现行历法的所有与时间和日期有关的操作。
1. 此类也是不可以直接实例化。工厂模式。
2. 只能通过此类提供一个静态方法来获得其实例。
三个常识
1. 月份的问题（从0开始，话说好多从0开始）
2. 星期的问题（星期天开始）
3. 时间基准点的概念。1970-1-1 0:0:0
可以利用Calendar类的实例来获得与时间有关的数据。
get
每次调用get方法可以获得一个时间组成部分的值。
原型
int get(int field)
参数用于指定，要获取那个值
将指定的值以返回值的方式返回。
set
用于调整日历对象中的任意时间值。
原型
void set(int field, int vlaue)
参数field用于指定要调整哪个部分的值，具体规则与get相似
参数vlalue用于指定要调整到什么值。
异常语法，
自定义异常，异常的继承体系
final
集合框架
三个方面能力
1. 基础算法
2. 使用API 以上两点主要是解决了功能实现的问题。
3. 代码结构 以面向对象的方式来编程代码。
a. 不是所有的代码都在main方法里。
b. 不是所有的方法都是static的。
c. 尽量地将功能封装到类里面，通过该类的实例，调用它的方法即可完成要求的功能。
功能较为完善的类。
类的本质：
1. 方法的容器
2. 自定的数据类型
3. 类是功能完善的模块。
补充关键字final
三种用途
1. 用于修饰类
public final class MyClass{
}
public OneClass extends MyClass {} //报错，不允许
被final修饰的类不可以被继承。
2. 用于修饰方法
public class MyClass{
public fianl void function() {....}
}
public OneClass extends MyClass {
public void function() {....} //报错，不允许
}
表示被final修饰的方法不可以被重写。
3. 用于修饰属性
被final修饰的属性，将成为常量，不可以被再赋值
public class MyClass {
public static final int NUMBER = 100;
final int number = 100;
public void function() {
number = 100; //报错，不允许
}
}
细节
1. 定义的final常量一般来说，要赋初始值。
2. 常量的定义最好采用全大写的方式。
3. 大多数的情况下，常量一般是static, 因为常量一般无需副本。
补充异常的继承体系，和自定义异常类型
Java当中提供一系列常见的异常类型，分别对应于各种不同情况的异常。
实际上不同的异常类型就是类，都是直接或间接的Exception的子类，它们的命名都采用类似于XxxException的方式。
java.lang.Exception是其他所有异常的父类，它是不指定具体类型的异常，涵盖所有的异常。
如果某个特定的异常类型没有被java提供，也可以考虑自己定义一个异常。
自定义一个类，继承于Exception,并且命名也按照XxxException的方式。
集合
更强大的数组，不需要指定长度，随着数据量的增长，自动调节自己的容量。
更适合来保存引用数据类型（对象）。
实际上，集合对于各种不同的数据结构的具体实现。
数组的特点
1. 在定义数组时，必须指定数组的长度。
2. 数组一旦声明，长度不可改变。
关于数组的length属性，与集合中size方法的区别
1. length是属性，size是方法。
2. length不会有改变，size会随着元素数量的改变而发生变化。
3. length实际上表示的是数组的最大容量，而size则是表示集合中容纳的元素个数。
原则上，对于集合而言，可以存放任何引用数据类型（一切Object的子类）
泛型就是要求在集合时，必须指定具体的数据类型。
常见操作
add 两种重载 增
get 查
remove 删
set 改
辅助操作
size
clear
isEmpty
ArrayList 线性表 动态数组
常见的4个操作
增 删 改 查
add 两种重载
remove
set
get
辅助性
size
clear
isEmpty
因为ArrayList是List接口的实现类，而上述若干个方法实际上是由List接口所提供的规范标准。
LinkedList 链表
也是List的实现类，也必须遵守List的规范，实际它的常见用法与ArrayList几乎一样。
Vector
也是List的实现类，常见用法与ArrayList相似。
ArrayList 线性表 检索高效，增删低效
LinkedList 链表 检索低效，增删高效
Vector 优点：线程安全。
HashMap 键值对
常用操作
put 增，改（使用重复键）
remove 删
get 查
size
clear
isEmpty
键值对集合与索引无关。元素存放是不讨论顺序的。
通常情况下，键值对无法利用循环的方式进行遍历。键是取值对象的唯一办法。
如果非要遍历键值对集合
1. 键采用有规律的键，对于有规律的键进行循环，达到遍历的目的。
2. 利用迭代器。
java.io包
以操作磁盘文件为例，来描述输入/输出流的基本概念。
java.io.File类
此类不可以对于文件进行读/写的操作。
在代码中定位磁盘文件，对于文件的常见属性进行操作。
路径描述中的\与转义字符的\发生混淆，路径中\一定要写成\\
\t
\n
\r
常用方法
length
delete
exists
creatNewFile 带有throws方法，调用它必须放进try...catch
补充，接口与接口实现类的意义。
作为接口的实现类而言，处于语法的硬性要求，它必须提供对于接口中的所有的抽象方法的具体实现。
可以理解为：接口实际上就是给它的实现类指定了强制性的标准，强迫自己的实现类必须要提供的功能。
函数（方法）的完整概念
访问权限 修饰符 返回值类型 方法名(形参列表) 异常类型 {
方法体
}
修饰符：final static abstract
java.io包
java.io.File类
操作磁盘上的文件，只能操作基本属性，不能进行读/写。
有大量的带有throws的方法，对于这种方法的调用，必须放进try...catch。
length
delete
exists
creatNewFile 此方法只能创建文件。
File类除了能够操作磁盘上文件以外，还能操作文件夹
isFile 判断是否为文件
isDirectory 判断是否为目录（文件夹）
mkdir 创建新的目录
getName 以字符串的形式返回当前File对象的名称（仅仅只有名称）
getPath 以字符串的形式返回当前File对象的绝对路径
D:\abc\xyz\input.txt
File[] listFiles() 如果当前File对象是个目录的话，此方法返回当前目录下的所有子对象。
读/写
流对象
两对概念
字节流（二进制流）/字符流（文本流）
字符流只能用来操作文本文件，
字节流可以用来操作所有文件（不区分文件类型）
输入流（读）/输出流（写）
参照物：内存
字节流的命名一般都以XxxStream作为后缀
其中
XxxInputStream 针对某个特定情况的二进制读取（输入）流
XxxOutputStream 。。。。。。。。。。。。写入（输出）流
字节流（二进制流）是操作文件最高效，最简单的流，但不考虑字符集编码的问题。
字符流的命名一般都以XxxWriter或XxxReader作为后缀
其中
XxxWriter 针对某种特定情况的文本写入（输出）流
XxxReader ...............................................读取（输入）流
FileInputStream类
int read()
此方法一次读取文件中一个字节的内容，并且将读到的内容以整数的方式返回。
FileOutputStream类
默认情况下，每次重新打开文件进行写操作，都是以覆盖写入的方式来进行的。
如果想要追加写入，在构造方法中传递第二个参数。
二进制流操作文件，相对比较简单，效率高，所有的文件都通用，不考虑字符集问题。
对于读文件，read()方法
对于写文件，writer()方法 注意追加和覆盖的问题，还有一个换行的问题。
如果要彻底解决乱码问题，使用文本流
字节流
字符流
操作的是文本，字符串，请尽量使用字符流。字符流只能操作文本。
复制文件，字节流，所有的类型通吃。
输入（读）
输出（写）
IO流
还有一部分，再挖一个坑，嗯，比如Swing，毕竟第一个小程序俄罗斯方块深得胖心，啦啦啦