Java基础知识2023年最新版
Java基础
- 1.变量
-
- 1.1什么是变量
- 1.2java的内存应用
-
- 栈内存：（先进后出）
- 堆内存：（先进先出）
- 1.3变量的命名规范
- 1.4java常用关键字
- 2.运算符
-
- 2.1赋值运算
- 2.2逻辑运算（与、或、非）
- 2.3比较运算
- 2.4算数运算
-
- 自增
- 自减
- 2.5 三目运算
- 2.6运算符优先级
- 3.流程控制
-
- 3.1顺序结构
- 3.2判断结构
- 3.3switch选择结构
- 4.循环结构
-
- for循环
- foreach循环
- while循环
- do...while循环
- 跳转语句(控制循环结构)
-
- break、continue语句和return语句。
- 5.数组（数据类型 [] 数组名 = 初值 ）
-
- 数值使用：
-
- 数组打印：
- 数组排序：
- 复制数组：
- 变量和数组的区别：
- 6.方法（存在与类中）
-
- 方法的四种运用：
- 方法重载和方法重写
- 成员（全局）变量和局部变量
-
- this关键字
- super关键字
- 7.面向对象：（封装，继承，多态）
-
- 封装（private：在同一个类中可见）
- 继承（extends）
- 多态（存在条件：继承，重写，父类引用子类对象）
-
- 向下转型：
- 向上转型：
- 8.修饰符（访问和非访问）
- 9.抽象（abstract）
- 10.接口——抽象方法的集合（声明：interface，实现：implements）
-
- 规则
- 接口实现
- 接口继承（和类继承相似,子接口继承父接口）
- 11.异常
-
- 捕获异常
- 抛出异常
-
- throws关键字
- throw关键字
- 12java高级应用
-
- 集合（动态的数组）
-
- Collection 方法分类
- collection接口
- 13.工具类（API）
-
- 常用类：
-
- Object类：所有父类的子类
- String类：
-
- StringBuffer：
- 包装类：
-
- Integer常用方法：
- Character常用方法:
- java.util类
-
- Math常用方法：
- Date构造方法：
- Calendar常用方法
- Randow
- 14.Io流
-
- File类
- 字节输出/输入流
- 字符输入/输出流
- 流
1.变量
byte a；
short b；
int c；
long d；
float e;
double f;
char g;
boolean h;
String i;
1.1什么是变量
变量由数据类型和自己自定义的名称组成，如果未将变量进行赋值则这些数据类型的默认数据为：
| 数据类型 | 字节 | 默认值 |
|---|---|---|
| byte | 1 | 0 |
| short | 2 | 0 |
| int | 4 | 0 |
| long | 8 | 0L |
| float | 4 | 0.0F |
| double | 8 | 0.0D |
| char | 2 | \u0000 |
| boolean | - | - |
| String | - | null |
1.2java的内存应用
在java中，内存分为两种一个是栈内存，另一个是堆内存
栈内存：（先进后出）
存放基本类型的变量，对象的引用和调用
堆内存：（先进先出）
存放所有new出来的对象和数组
1.3变量的命名规范
1.变量一般用英文单词表示，首字母小写，遵循驼峰命名规范（变量的名称可以包含字母、数字、下划线、美元符号，但是不能以字母开头命名）
2.不能用java的关键字做变量名，idea里面有颜色的一般是关键字（变量的名称不能是java中的关键字和保留字，但可以包含关键字和保留字）
3.变量名称严格区分大小写，并且命名尽量做到见名知意
1.4java常用关键字
| 用于定义数据类型的关键字 | byte、short、int、long、float、double、char、boolean、class、interface、void |
|---|---|
| 用于定义数据类型值的关键字 | true、false、null |
| 用于定义流程控制的关键字 | if、else、switch、case、default、while、do、for、break、continue、return |
| 用于定义访问权限修饰符的关键字 | private、protected、public |
| 用于定义类，函数，变量修饰符的关键字 | abstract、final、static、synchronized |
| 用于定义类与类之间关系的关键字 | extends、implements |
| 用于定义建立实例及引用实例，判断实例的关键字 | new、this、super、instanceof |
| 用于异常处理的关键字 | try、catch、finally、throw、throws |
| 用于包的关键字 | package、import |
| 其他修饰符关键字 | native、strictfp、transient、volatile、assert |
2.运算符
2.1赋值运算
在代码中的‘=’就是赋值运算符，目的是将‘=’右边的数据，赋值给=左边的空间
int num1 = 10;
int num2 = 20;
System.out.print(num1+",");
System.out.println(num2);
输出结果为10，20
2.2逻辑运算（与、或、非）
- 与（&，&&）
要求，逻辑运算的左右条件都为true
int num1 = 10;
int num2 = 20;
if (num1<num2&&num1>5){
System.out.println("条件符合");
}else{
System.out.println("条件不符合");
}
结果：条件符合
- 或（|，||）
要求逻辑运算的左右条件其中有一个条件为true或左右条件都为true
int num1 = 10;
int num2 = 20;
if (num1 == 10||num2== 10){
System.out.println("条件符合");
}else{
System.out.println("条件不符合");
}
}
结果：条件符合
- 非（！）
要求逻辑运算的条件为false
int num1 = 10;
if (!(num1>11)){
System.out.println("条件符合");
}else{
System.out.println("条件不符合");
}
结果：条件符合
2.3比较运算
比较运算符是用来对运算符左右两个变量的值进行比较，得到结果是boolean类型，因为无论是何种比较，结果只有真或假两种。
int num1 = 10;
int num2 = 20;
System.out.println(num1>num2);结果为false
System.out.println(num1<num2);结果为true
System.out.println(num1>=num2);结果为false
System.out.println(num1<=num2);结果为true
System.out.println(num1==num2);结果为false
System.out.println(num1!=num2);结果为true
双等号用来比较基本数据类型是否相等或两个对象的内存地址而String属于引用数据类型，equals专门用来判断两个字符串的值是否相等
String num1 ="苹果";
String num2 = "香蕉"
System.out.println(num1.equals(num2));
结果为false
2.4算数运算
加、减、乘、除、取余、自增、自减、+=、-=、*=、/=、%=
int num1 = 10;
int num2 = 20;
System.out.println(num1+num2);结果为30
System.out.println(num1-num2);结果为-10
System.out.println(num1*num2);结果为200
System.out.println(num1/num2);结果为0.5
System.out.println(num1%num2);结果为10
System.out.println(num1+=10);结果为20
System.out.println(num1-=10);结果为0
System.out.println(num1*=);结果为100
System.out.println(num1/=);结果为1
System.out.println(num1%=);结果为0
其中重点说一下自增和自减
如num1++是先输出后赋值，++num1是先赋值后输出
自减和自增情况一样
自增
int num1 = 10;
System.out.print(num1+++",");
System.out.println(num1);
结果为10，11
int num1 = 10;
System.out.print(++num1+",");
System.out.println(num1);
结果为11，11
自减
int num1 = 10;
System.out.print(num1--+",");
System.out.println(num1);
结果为10，9
int num1 = 10;
System.out.print(--num1+",");
System.out.println(num1);
结果为9，9
2.5 三目运算
- 表达式？结果1：结果2；
当表达式结果为true，则执行结果1的代码；当表达式结果为false，则执行结果2的代码。
String num1 = "苹果";
String num2 = "香蕉";
int num3 = num1.equals(num2)?100 : 200;
System.out.println(num3);
结果为：200
2.6运算符优先级
（）> ! > 算数运算符 > 比较运算符 > && > || > 赋值运算符
3.流程控制
3.1顺序结构
按照原本的方式进行执行，从上到下，从左到右
3.2判断结构
if(表达式){}
if(表达式){}else{}
if(表达式){}else if{}else{}
if(表达式){}else if{}else if{}...else{}
if(表达式){if(表达式){else[]}} --多从表达，多从嵌套
3.3switch选择结构
switch(表达式) {
case 值1：
语句体1;
break;
case 值2：
语句体2;
break;
…
default：
语句体n+1;
break;
}
switch也可以进行多从嵌套
4.循环结构
循环语句：就是在满足一定条件的情况下反复执行某一个操作
for循环
条件成立的时候才会去执行循环体
for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
for(int x=1; x<=10; x++) {
System.out.println("HelloWorld");
}
foreach循环
通常用来遍历数组来使用
for (声明语句 : 表达式) {
//代码句子
}
int [] numbers = {10, 20, 30, 40, 50};
for ( int x : numbers ) {
System.out.print( x );
System.out.print(",");
}
while循环
条件成立的时候才会去执行循环体，直到条件不符合结束
- 基本格式
while(判断条件语句) { 循环体语句; } - 扩展格式
初始化语句; while(判断条件语句) { 循环体语句; 控制条件语句; } int x=1; while(x<=10) { System.out.println("HellloWorld"); x++; }
do…while循环
至少会执行一次循环体
for循环语句和while循环语句的小区别：
使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。
跳转语句(控制循环结构)
break、continue语句和return语句。
for(int x=1; x<=10; x++) {
if(x > 3) {
//break;
continue;
}
System.out.println("HelloWorld");
}
continue与break区别：
break 退出当前循环
continue 退出本次循环
break的作用：跳出单层循环
continue的作用：结束一次循环，继续下一次的循环
return的作用：
可以从一个方法返回，并把控制权交给调用它的语句。
直接结束整个方法，从而结束循环。
5.数组（数据类型 [] 数组名 = 初值 ）
1.存储基本数据类型和引用数据类型
2.处理同类型多数据，可以看做成一个容器
3.数组的长度一旦给定，就不能修改
4.数组由零开始访问元素，如int [] array = new int [5],这一数组里面有6个数据；
5.声明数组时不规定数组长度
6.创建数组并赋值的方式必须在一条语句中完成
数值使用：
声明数组→分配内存空间→数组元素赋值→使用数组元素
数组打印：
1.一维（for循环打印，foreach遍历数组），二维（多层for循环嵌套）
2.一维 Arrays.toString(数组名) ，多维Arrays.deepToString(数组名)
3.使用Arrays.asList(数组名)
Arrays.asList()注意事项
（1）该方法不适用于基本数据类型，但可以用基本数据类型的封装类。
（2）该方法将数组与列表链接起来，当更新其中之一时，另一个自动更新
（3）不支持add和remove方法
| 基本数据类型 | 封装数据类型 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
float，Double，没有实现
Byte、Short、Integer、Long、Character、Boolean 实现常量池的技术。
这 5 种包装类默认创建了数值[-128，127] 的相应类型的缓存数据，但是超出此范围仍然会去创建新的对象。
数组排序：
1.Arrays.sort(数组名) 根据需求升序或者降序打印
2.冒泡排序（比较两个相邻的元素，将值大的元素交换到右边）
复制数组：
Arrays.copyOf()(要复制的数组，顶新数组的长度);
变量和数组的区别：
声明一个变量就是在内存空间中划出一块空间
声明一个数组就是在内存空间中划出一串连续的相同类型的空间
6.方法（存在与类中）
方法的四种运用：
1.无参无返回
2.无参有返回
3.有参无返回
4.有参有返回
5.构造方法（特殊）
retrun有关事项：
1.return的结果要和返回值类型相同
2.一个方法中可以有多个return，但被执行的只能有一个
3.return返回值时，只能返回一个值
4.return即表示结束一个方法，也可以将返回值返回给调用当前方法的调用者
方法重载和方法重写
| 区别点 | 重载方法 | 重写方法 |
|---|---|---|
| 参数列表 | 必须修改 | 一定不能修改 |
| 返回类型 | 可以修改 | 一定不能修改 |
| 异常 | 可以修改 | 可以减少或删除，一定不能抛出新的或者更广的异常 |
| 访问 | 可以修改 | 一定不能做出更严格的限制（可以降低限制） |
成员（全局）变量和局部变量
| 区别点 | 成员（全局）变量 | 局部变量 |
|---|---|---|
| 作用域不同 | 成员变量的作用域在整个类内部中都是可见的 | 局部变量的作用域仅限于定义它的方法 |
| 初始值不同 | java会给成员变量一个初始值 | java不会给局部变量赋予初始值 |
注意事项：
在一个方法中，不允许有同名的局部变量，不同方法中可以有同名的局部变量
在同一个类中，成员变量和局部变量同名时，局部变量有更高的优先级
this关键字
1.调用属性（区分局部变量和成员(全局)变量）
2.调用方法——表示本对象自己的方法（this.方法名）
public class Text {
public void show(){
System.out.println("种类:虎");
System.out.println("颜色：黄色");
System.out.println("年龄：8");
}
public void eat(){
this.show();
System.out.println("爱好：我喜欢吃肉");
}
public static void main(String[] args) {
Text t2 = new Text();
t2.eat();
}
}
//输出结果：
种类:虎
颜色：黄色
年龄：8
爱好：我喜欢吃肉
3.调用构造方法——（this(参数)）
注意事项：
1.以重载方法为依据,重载后除了方法名不变外都可以改变
2,这种“this（参数）”方式只能在“构造方法中使用
3.this(参数)”必须写在主调方法的第一行
4.不能出现相互循环调用，如构造方法1⇌构造方法2
4.外部类名.this.属性
public class Text {
int a = 0;
void m1(){
int a = 10;
System.out.print(a+",");
System.out.print(this.a+",");
System.out.println(Text.this.a);
}
public static void main(String[] args) {
Text t = new Text();
t.m1();
}
}
输出结果：
10，0，0
super关键字
1.调用父类方法super.(方法名)
2.调用父类构造函数super(有参或无参）
7.面向对象：（封装，继承，多态）
像这些抽象类的东西最好几句话就能总结，类中总是要定义变量，方法。
变量可以说成是属性，方法呢可以说成是行为，属性定义了最开始的譬如身高、体重、名字、职业、爱好等等等等，行为就好理解了，我做了什么事情，这些就是行为。
封装（private：在同一个类中可见）
封装过后只能用getter方法获取值
两种赋值方式(构造器赋值和setter方法赋值)
继承（extends）
子类拥有父类非 private 的属性、方法
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展
子类可以用自己的方式实现父类的方法
多态（存在条件：继承，重写，父类引用子类对象）
强制类型转换要到instanceof关键字
向下转型：
将一个指向子类对象的父类引用赋给一个子类的引用（慎用，可能会溢出值报错）
向上转型：
将父类引用到指向子类对象
8.修饰符（访问和非访问）
访问
1.default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法
2.private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
3.public : 对所有类可见。使用对象：类、接口、变量、方法
4.protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
非访问
1.static 修饰符，用来修饰类方法和类变量
2.final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的
3.abstract 修饰符，用来创建抽象类和抽象方法
4.synchronized 修饰符，主要用于线程的编程，synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符
5.volatile 修饰符，volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
9.抽象（abstract）
抽象方法无方法体,抽象类不能被实例化
10.接口——抽象方法的集合（声明：interface，实现：implements）
规则
一个类通过实现接口的方式，从而来继承接口的抽象方法
接口不是类。类描述对象的属性和方法。接口则包含类要实现的方法
接口无法被实例化，但可以被实现
接口中的所有方法必须是抽象对象
接口中的变量都是静态常量
一个类只能继承一个抽象类，而一个类可以实现多个接口
接口中不能含有静态代码块以及静态方法
接口中的方法不能再接口中实现，只能由实现接口的类来实现接口中的方法
接口实现
1.当类实现接口的时候，类要实现接口中所有的方法。否则，类必须要声明为抽象的类
2.类要使用implements关键字实现接口在类声明中，implement关键字放在class
接口继承（和类继承相似,子接口继承父接口）
11.异常
所有的异常类是从java.lang.Exception类继承的子类
Error用来指示运行时环境发生的错误
Exception有两个子类IOException类和RumtimeException类
| 异常类型 | 说明 |
|---|---|
| Exception | 异常层次结构的父类 |
| ArithmeticException | 算术错误情形，如以零作除数 |
| ArrayIndexOutOfBoundsException | 数组下标越界 |
| NullPointerException | 尝试访问 null 对象成员 |
| ClassNotFoundException | 不能加载所需的类 |
| IllegalArgumentException | 方法接收到非法参数 |
| ClassCastException | 对象强制类型转换出错 |
| NumberFormatException | 数字格式转换异常，如把"abc"转换成数字 |
捕获异常
try{
//程序代码
}catch(Exception e){
e.printStackTrace
在命令行打印异常信息在程序中出错的位置及原因。
}catch(异常类型 2 异常的变量名2){
// 程序代码
}finally{
//程序代码
无论是否发生异常，finally 代码块中的代码总会被执行。
}
抛出异常
throws关键字
访问权限修饰符 返回值类型 方法名(形参列表) throws 异常类型(异常类){
//实际书写的位置是形参列表的最后一个括号后面
}
throw关键字
访问权限修饰符 返回值类型 方法名(形参列表) {
throw new Exception("展示的异常信息");
}
12java高级应用
集合（动态的数组）
使用变量存数据，数据量多时，每一个变量都要自行去取，操作繁琐
使用数组存数据，在创建数组时需指定其长度，数组在使用时长度不可改变，并且数据量不是一成不变的，后续超过指定长度后要进行数组扩容
集合拥有可变长度的容器来存储数据，会自己调整数据
Collection 方法分类
1.修改 add(E) 、remove(Obejct)
2.查询 size()、isEmpty()、contains(Obejct)、iterator()、toArray()、toArray(T[])
3.批量数据操作：
containsAll(Collection)、clear()、 addAll(Collection)、stream()
removeIf(Predicate)、parallelStream() retainAll(Collection)
-add[E]单次添加数据、addAll(Collection< ? extends E>)批量添加数据
集合类型：set(集)，list(列表),map(映射)
集合接口:collection和map,list,set
数组长度是不可变的，集合长度是可变的
collection接口
有序且重复的元素——list集合
无需且有重复的元素——set集合
13.工具类（API）
常用类：
Object类：所有父类的子类
Object常用方法
| 方法名 | 作用 | 返回值 |
|---|---|---|
| hashCode() | 获取对象hash值 | int |
| toString() | 将对象信息变为字符串返回 | String |
| equals(Object obj) | 判断两个内存地址是否一样 | boolean |
| getClass | 获取类名 | Objecrt |
String类：
1.String是一个final修饰过的引用数据类型，他的值一旦创建便不能修改,被final修饰的不能被继承
2.字符串存在与常量池。如果new String()会在堆内存中开辟空间，如果是直接赋值，会在常量池中开辟空间
3.String的构造方法：
public String()
public String(bytel] bytes)
public String(bytell bytes,int offset,int length)
public String(char[] value)
public String(charl] value,int offset,int count)
public String(String original)
常用方法：
| 方法名 | 作用 | 返回值 |
|---|---|---|
| isEmpty() | 判断是否为空 | boolean |
| length() | 取到该String的长度 | int |
| equals(Object obj) | 判断两个字符串是否相等 | int |
| equalslgnoreCase(String as) | 不区分大小写比较 | Object |
| charAt(int index) | 返回该下标的char | char |
| substring(int start) | 截取字符串下标从start开始 | String |
| substring(int strat,int end) | 截取区间字符串从start开始到end结束(包头不包尾) | String |
| repalce(char old,char new) | 去掉字母首位空格 | String |
| indexOf() | 寻找某个字符串在目标字符串的位置 | int |
String的转换功能
| 方法名 | 作用 | 返回值 |
|---|---|---|
| getBytes() | 转换成bytes型数组 | byte[] |
| toCharArrav() | 转换成char型数组 | char[] |
| String valueOf(charl] chs) | 将入参类型转换为String | String |
| toLowerCase() | 将所有英文字母转换为小写字母 | String |
| toUpperCase() | 将所有英文字母转换为大写字母将指定字符 | String |
| concat(String str) | 串连接到此字符串的结尾 | String |
StringBuffer：
用来解决String更改字符串造成的时间浪费和空间浪费
StringBuffer和String的区别：内存操作不同
String每次进行更改会产生一个新的对象
StringBuffer不会产生新的对象而是对原有的对象上进行更改
常用方法
| 方法名 | 作用 | 返回值 |
|---|---|---|
| append(String str) | 追加字符串 | StringBuffer |
| insert(int offset,String str) | 指定位置追加字符串 | StringBuffer |
| deleteCharAt(int index) | 删除下标处的字符 | StringBuffer |
| delete(int start,int end) | 删除下标区间的字符 | StringBuffer |
| replace(int start,int end,String str) | 替换区间字符 | StringBuffer |
| reverse() | 反转字符串 | StringBuffer |
| substring(int start,int end) | 截取区间字符串从start开始到end结束 (包头不包尾) | String |
| substring(int start) | 截取字符串 | String |
| split() | 拆分字符串 | String[] |
包装类：
基本数据类型不具备面向对象,相当基本数据类型有与之对应的引用数据
对象型包装类，不继承任何其他类（Object的直接子类）
数值型包装类，继承于Number类
- 装箱：把基本数据类型封装成包装类
- 拆箱：将包装类中包装的基本数据类型数据取出
Integer常用方法：
| 方法名 | 作用 | 返回值 |
|---|---|---|
| intValue() | 转换成int | int |
| parselnt(String s) | String转换成int | int |
| valueOf(String s ) | String转换成Integer | Integer |
| String toBinaryString(int i) | 转换成2进制 | String |
| toOctalString | 转换成8进制 | String |
| toHexString(int i) | 转换成16进制 | String |
| toHexString(int i) | 十进制到其他进制 | String |
| parselnt(String s,int radix) | 其他进制到十进制 | int |
Character常用方法:
| 方法名 | 作用 | 返回值 |
|---|---|---|
| isUpperCase(char ch) | 判断指定字符是否为大写字母 | boolean |
| isLowerCase(char ch) | 判断指定字符是否为小写字母 | boolean |
| isDigit(char ch) | 如果字符串中只含有数字则返回True | boolean |
| toUpperCase(char ch) | 将小写字符转换为大写 | char |
| toLowerCase(char ch) | 将大写字符转换为小写 | char |
java.util类
Math常用方法：
| 方法名 | 作用 | 返回值 |
|---|---|---|
| abs(int a) | 取绝对值 | int |
| ceil(double a) | 返回最小值 | double |
| floor(double a) | 返回最大值 | double |
| max(int a,int b) | 取最大值 | int |
| pow(double adouble b) | 求幂 | double |
| random0 | 随机数 | double |
| round(float a) | 四舍五入成整数 | int |
| sart(double a) | 求double值的正平方根 | double |
Date构造方法：
public Date()
public Date (long date)
public Date(String s)
public Date(int year,int month,int date)
public Date(int year,int month,int date,int hrs,int min)
- Date常用方法：
public long getTime0)//获取时间
public void setTime(long time)//设置时间
Calendar常用方法
| 方法名 | 作用 | 返回值 |
|---|---|---|
| getInstance() | 获取日期 | Calendar |
| get(int field) | 获取年/月日/时/分/秒 | int |
| add(int fieldint amount) | 计算时间 | void |
| set(int year,int monthint date) | 设置时间 | void |
Randow
· 常用方法：
| 方法名 | 作用 | 返回值 |
|---|---|---|
| nextInt0) | 生产一个随机数 | int |
| nextInt(int n) | 生成一个0~n之间的随机数 | int |
14.Io流
File类
是文件和目录路径名的抽象表示形式
File类常用方法：
| 方法 | 作用 | 返回值 |
|---|---|---|
| createNewFile() | 创建名称的空文件，不创建文件夹 | boolean |
| isDirectory) | 判断是否是目录 | boolean |
| isFile() | 判断是否是文件 | boolean |
| exists() | 判断文件或目录是否存在 | boolean |
| getAbsolutePath() | 返回此对象表示的文件的绝对路径名 | String |
| getPath( | 返回此对象表示的文件的相对路径名 | String |
| getName( | 返回此对象表示的文件或目录的名称 | String |
| length() | 返回文件的长度，单位为字节 | long |
字节输出/输入流
1.字节流和字符流的基本操作是相同的，但是要想操作媒体流就需要用到字节流
2.字节流因为操作的是字节，所有可以用来操作媒体文件
3.读写字节流：InputStream输入流
OutputStream输出流
字符输入/输出流
1,字符流是可以直接读写字符的IO流，字符流读取字符，就要先读取到字节数据，然后转为字符;如果要写出字符，需要把字符转为字节再写出
2。读写字节流：Reader输入流和Writer输出流
流
1.从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组、和行的高效读取
2.将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组、和字符串的高效写入。可以指定缓冲区的大小，或者接受默认的大小