JavaSE

最新推荐文章于 2024-10-09 11:13:12 发布

wade53

最新推荐文章于 2024-10-09 11:13:12 发布

阅读量773

点赞数

文章标签： java javase

本文链接：https://blog.csdn.net/qq_16060543/article/details/108697001

版权

JavaSE

基础部分

三元运算符自动提升

Integer内部定义了IntegerCache结构，保存了一个-128~127的数组，可以直接使用数组中的元素，超出就要new

带标签的break,continue

label for(…){

for(…)

{

break label;

}

数组初始值

全为0

boolean: false

String: null

简易数据记录

String=“收入\t”+“类型\t”+"\n"

Add=输入的收入+输入的类型

String+=Add+"\n"

面向对象

成员：属性、方法、构造器；代码块】内部类

三大特征：封装性、继承性、多态性（抽象性）

类中属性VS局部变量

前者在类中声明

后者在方法内、方法形参、代码块内、构造器形参、构造器内部变量中声明

匿名对象

用于只调用类或对象的方法

如new Person().getAge();

节省内存空间

重载与重写

（考虑static的问题）

重载：参数不同，在同一类的同名方法

可变个数形参

类型名 … 变量名

直接和多个实参匹配

可重载、重载时会与数组参数冲突（本质与数组一样）

只能存在一个，并且放在最后

(char数组println打印的是字符串)

封装性

权限从小到大：private<缺省<protected<public

构造器

如：

class Person {

public person (){

}

类名{

权限修饰词类名（列表）{

}

作用

1.创建对象

2.初始化对象的属性

可重载

子类无法继承父类重载的构造器

JavaBean

符合以下条件的Java类

1.类是公共的

2.有一个无参的公共的构造器

3.有属性且有对应的get\set方法

UML类图

不同包内同名类的调用

第一个用import

第二个要写全com.包名.java类.类名（全类名）

Object类

Object是所有类的父类，任何类都默认继承Object。

equals方法与“==”

==是运算符，用于基本数据类型变量（比较保存数据，不一定类型相同）和引用数据类型变量（比较两个对象的地址是否相同）

equals是方法，只适用于引用数据类型变量，Object类中定义的equals与==作用相同，一般需要重写（String，Date，File，包装类等已重写，比较的是实体内容）

equals重写注意事项

用instanceof判断是否是该类或该类子类

tostring

Object类中得到的是类名+@+内存地址

一般重写返回所需的实体内容

Super关键字

与this类似：调用父类的属性、方法、构造器

final关键字

final修饰类：最后一个子类，无法被继承

final修饰方法：不可再被重写，即最终版

final修饰变量：此时的变量变成常量，不可再修改，可在代码块、构造器中赋值（一般用大写字母）

final修饰形参时，该形参是常量

class FinalTest{
   final int n=0;//声明时赋值
   
   final int m;
   {
   m=1;//非静态代码块中赋值
   }
   
   final int x;
   public FinalTest(){
   x=3;//构造器中赋值
   }
   
   
}

static final只能修饰属性，全局常量

Static关键字

P320应用实例

用来修饰属性、方法、代码块、内部类

静态变量

修饰的属性为静态属性（共同使用或是说全局变量）：每个对象用的是同一个变量（静态变量、类变量）随着类的加载而加载（比对象创建早），内存在方法区的静态域

非静态属性（实例变量）：每个对象拥有独立的变量，随着对象的创建而加载

静态方法

使用：类.静态方法

静态方法只可以调用静态的方法或属性

非静态的都可以调用

静态方法中不能使用this和super

多态性

多态是面向对象中的三大主要特征，多态性是在继承性的基础上扩展出来的，可以实现父子类之间转换处理。

①方法的重载：同一个方法名称可以根据传入的参数的类型或个数的不同实现不同功能的执行；

②方法的覆写：同一个方法可以根据使用的子类的不同有不同的实现；

③对象的多态性：父子实例之间的转换处理，它有两种模式：

·对象向上转型：父类父类实例 = 子类实例、自动完成转换；

·对象向下转型：子类子类实例 = (子类)父类实例、强制完成转换；

从实际的转型处理来讲，大部分情况下考虑最多的一定是对象的向上转型（90%）、对于对象的向下转型往往都在使用子类的特殊功能（子类可以对父类进行功能扩充）的时候（3%）。

对象向上转型（接收或返回参数的统一性）

向下转型的主要特点在于需要使用到一些子类自己特殊的定义处理

多态是对于方法而言，不适用于属性！！！

向上转型（常用）

用于调用子类中的重写方法！！！

父类类名=new 子类

向下转型（少用）

`把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转型。
如father就是一个指向子类对象的父类引用，

把father赋给子类引用son 即Son son =（Son）father；
其中father前面的（Son）必须添加，进行强制转换。

用于调用子类的特有方法

注意一般使用要加instanceof

包装类

八种基本数据类型封装到类里面，具有类的特征和一些功能

自动装箱：int num=10; Integer in1=num;

自动拆箱：int num3=in1;

String类转为基本数据类型或包装类：

int num=Integer.parseInt(String str)

设计模式

创建型模式

结构型模式

行为型模式

单例设计模式

饿汉式

效率高，对象加载时间过长占据空间、线程安全

``public class singleTon {`
       `Bank b1=Bank.getInstance();`
`}`

`class Bank{`
	`//私有化构造器`
	`private  Bank() {`
}
//内部创建对象
private static Bank instance =new Bank();
//
public static Bank getInstance() {
	return instance;
}
}

懒汉式

效率相对较低，延迟对象创建

public class singleTon {
       Bank b1=Bank.getInstance();
}

class Bank{
	//私有化构造器
	private  Bank() {
}
//内部创建对象
private static Bank instance =new Bank();
//
public static Bank getInstance() {
	return instance;
}
}

模板方法设计模式

如下图：

抽象类DemoTime中getTime()方法是固定不变的，变的是method()抽象方法

public class AbstractTest {
	 public static void main(String[] args) {
		DemoTime t1=new Methods();
		t1.getTime();
	}
}

 abstract class DemoTime{
	public void getTime() {
		long start=System.currentTimeMillis();
		method();
		long end=System.currentTimeMillis();
		System.out.println(end-start);
	}
	public abstract void method();
}

class Methods extends DemoTime{

	@Override
	public void method() {
		int sum=0;
		for(int i=0;i<10000;i++) {
			for(int j=0;j<i;j++) {
				sum+=j;
			}
		}
		System.out.println(sum);
		
	}
	
}

代理模式（Proxy）

不让真实角色被访问

public class Proxytest {

	public static void main(String[] args) {
		Server server=new Server();
		ProxyServer proxy=new ProxyServer(server);
		proxy.browse();
	}
}

interface network{
	public void browse();
}
//被代理类
class Server implements network{

	@Override
	public void browse() {
		System.out.println("访问网络");
		
	}
	
}
//代理类
class ProxyServer implements network{
	
	private network work;
	

	public ProxyServer(network work) {
		this.work=work;
	}

	public void check() {
		System.out.println("检查工作");
	}

	@Override
	public void browse() {
		check();
		work.browse();
	}
	
}

Main()语法

必须是public和static且没有返回值

main方法的参数String[] args可以调用且用于实现人机交互

控制台带参运行（类似python）

public class Maintest {
	public static void main(String[] args){
		int sum=0;
	     for(int i=0;i<args.length;i++){
	     System.out.println("args_"+i+"="+args[i]);
	     sum+=Integer.parseInt(args[i]);//字符串转整数
	     }
	     System.out.println(sum);
	     
	}
}

class Main{
	public static void main(String[] args){
	     for(int i=0;i<args.length;i++){
	     System.out.println(i+"="+args[i]);
	     }
	}
}

代码块

只能用static修饰

用来初始化类、对象

静态代码块：初始化类的属性

非静态代码块：对对象的属性初始化

//代码块（随着对象的创建而执行）
{
System.out.println("hello");
}
//静态代码块(随着类的加载而实行)
static {
System.out.println("hello,static");
}

抽象类、抽象方法

抽象类不能实例化，类似模板

抽象类中一定要有构造器（无参）

有抽象方法的类一定是抽象类

抽象类不一定有抽象方法

抽象方法只有声明，没有方法体

public abstract void method();

抽象类的匿名子类

Person p=new Person(){

     //抽象方法的重写

};

接口

接口和类是并列的两个结构

如何定义接口

JDK7及以前：

只能定义全局常量（public static final（可以省略））和

抽象方法（public abstract）

JDK8：

除了以上这些，还有静态方法和默认方法

定义的静态方法只能用接口调用，默认方法（default）通过实现类调用，默认方法可重写也可继承

实现类实现的多个接口中有同名默认方法，会出现接口冲突，一般需要重写

子类调用接口被重写的默认方法：接口名.super.方法名

接口中不能定义构造器

实现接口

通过类来实现（1个类可以实现n个接口）

public class InterfaceTest {
	public static void main(String[] args) {
		Plane p1=new Plane();
		p1.fly();
		p1.stop();
	}
}

interface Flyable{
	
	 int MAX_SPEED=7900;
	 int MIN_SPEED=1;
	 void fly();
	 void stop();
}

class Plane implements Flyable{

	@Override
	public void fly() {
		System.out.println("起飞，最大速度为"+MAX_SPEED);
		
	}

	@Override
	public void stop() {
		System.out.println("起飞，最大速度为"+MIN_SPEED);
	}
	
}

内部类

当一个类的某个部分需要一个完整的结构进行描述，即在一个类内部定义一个类

注意：局部内部类想调用所在的方法、构造器、代码块里的变量时，该变量必须是final

规范

不能与外部类重名

成员内部类

//非静态成员内部类
	class Dog{
		
	}
	//静态成员内部类
	static class Cat{
		
	}

局部内部类（方法、代码块、构造器内）

//局部内部类
    public Person(){
        class CC{
            
        }
    }

	public void method() {
		class AA{
			
		}
	}
	
	{
		class BB{
			
		}
	}

实例化

静态内部类可使用"外部类.内部类"来实现实例化

非静态内部类需要先创建外部类对象

开发中使用内部类

返回一个实现了某个接口的对象

public (interface) getInterface(){
    方法一：
    class MyInterface implements (interface){
        ...
            @Override
            ...
    }
    return new MyInterface();
    
    方法二：
        return new Interface(){
        ...
            @Override
            ...
    };
}

异常处理

ERROR

JVM虚拟无法解决的问题：栈溢出(StackOverFlowError)、堆溢出(OOM)。一般只能改代码，不写针对性的

Exception

通常说的异常，空指针调用、读取不存在文件、数组下标越界、网络连接中断等

手动抛出异常new Exception/RuntimeException

public class ExceptionTest {
	
	@Test
    public void ExceptionDemo(){
    	Student s1=new Student();
    	try {
    		s1.setId(-1);
    	}
    	catch(Exception e){
    		System.out.println(e.getMessage());
    	}
    }
    
}

class Student{
	private int id;
	public void setId(int id) throws Exception {
		if(id<0)throw new Exception("输入有错");
		else this.id=id;
	}
}

用户自定义异常

public class MyException extends RuntimeException{
       static final long Version=1L;
       public MyException() {
    	   
       }
       public MyException(String msg) {
    	   super(msg);
       }

}

处理方法

1.遇到后停止程序

2.遇到后给出提示以及处理

结构

1.try-catch-finallly

public void ExceptionDemo(){
    	int[] arr=null;
    	try {
    		arr[0]=1;
    	}
    	catch(NullPointerException e){//空指针调用异常
    		System.out.println("arr是"+arr);
    	}
    }

finally:一定会执行的代码部分，即使catch中仍有异常或有return，一般用于断开连接，释放内存

2.throw+异常类型

往上一级抛出异常

然后用try-catch捕抓异常

父类抛出异常要不小于子类重写抛出异常

3.常用异常函数

getMessage();获取异常信息（返回字符串）

printStackTrace();

常用类

String

面试题：String str=new String(“abc”);方式创建对象，在内存中创建了几个对象：一个是堆空间的new 结构，一个是char[]对应的常量池数据"abc"

拼接操作：

常量与常量的拼接结果也是在常量池，且常量池中不会存在相同内容的常量

只要=右边出现一个变量，结果就在堆中

如果拼接结果调用intern()方法，返回值就在常量池中（无论调用方法的String在哪，一定在返回常量池的对应内容）

String与char[]之间的转换：

S->c : 调用String中的toCharArray()

c->S : 调用String中的构造器

String与byte[]之间的转换：

S->b : 调用String中的getBytes()//使用默认的字符集UTF-8进行转换,gbk含中文

b->S : 直接使用构造器

SimpleDateFormat类：

格式化：日期->字符串

使用SimpleDateFormat类的format方法（一般是默认，可以自定义）

解析：字符串->日期

使用SimpleDateFormat类的parse方法（一般是默认，可以自定义）

P481课后练习

一般SimpleDateFormat类创建都是使用带参构造器，然后无论是解析还是格式都要与构造器内格式一致

public static void main(String[] args) {
    Date date = new Date();
    System.out.println(date);
    SimpleDateFormat s1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

    System.out.println(s1.format(date));
}

Calendar类：（抽象类）

比较器

自然排序Comparable

对象要实现Comparable接口，重写compareTo方法

重写compareTo()的规则：如果当前对象大于形参对象，返回整数，等于返回0，小于返回负数

 public static void main(String[] args) {
        Goods[] arr=new Goods[4];
        arr[0]=new Goods("xiaomi",18);
        arr[1]=new Goods("hongmi",20);
        arr[2]=new Goods("iphone",25);
        arr[3]=new Goods("nuojiya",10);
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

class Goods implements Comparable{

    private String name;
    private int prise;

    public Goods(String name, int prise) {
        this.name = name;
        this.prise = prise;
    }

    @Override
    public String toString() {
        return "Goods{" +
                "name='" + name + '\'' +
                ", prise=" + prise +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        if(o instanceof Goods)
        return Integer.compare(this.prise, ((Goods) o).prise);
        throw  new RuntimeException("输入有误");
//        return 0;
    }

定制排序Comparator

一般都是一次性的，在Arrays.sort()里面new一个匿名类实现接口，重写compare方法

枚举类enum

方法一：

在类中使用private static final 定义枚举内容

用private 定义构造器和属性

方法二：

使用enum关键字

public enum Season {
    //1.第一行提高枚举对象（必须的）
    SPRING("春天","春暖花开"),SUMMER("夏天","夏日炎炎"),AUTUMN("秋天","秋高气爽"),WINTER("冬天","冰天雪地");
    //2.用private final 定义属性
    private final String season_dec;
    private final String season_name;
    private Season(String s, String d) {
       this.season_name=s;
       this.season_dec=d;
    }

    public String getSeason_dec() {
        return season_dec;
    }

    public String getSeason_name() {
        return season_name;
    }

    @Override
    public String toString() {
        return "Season{" +
                "season_dec='" + season_dec + '\'' +
                ", season_name='" + season_name + '\'' +
                '}';
    }
}

enum的常用方法

values()//获取所有状态

Season[] values=Season.values();
for(int i=0;i<values.length;i++){
    System.out.println(values[i].toString());
}

valueOf()//获取指定状态

Season season=Season.valueOf("WINTER");
System.out.println(season.toString());

枚举类实现接口的使用

让枚举类的对象分别实现接口的抽象方法

SPRING("春天","春暖花开"){
    @Override
    public void show() {
        
    }
}

注解

自定义注解必须配上注解的信息处理流程（使用反射）才有意义

元注解：

用来修饰其他注解的注解

自定义注解一般使用两个元注解：Retention(生命周期)、Target(可修饰结构)

集合

public void test1(){
    //collection接口使用方法
    Collection c1=new ArrayList();
    //add用来添加元素
    c1.add("AA");
    c1.add(123);//自动装箱
    //size用来获取元素个数
    System.out.println(c1.size());
    //addAll用来添加集合
    Collection c2=new ArrayList();
    c2.add("BB");
    c2.addAll(c1);
    System.out.println(c2.size());
    System.out.println(c2);
    //isEmpty判断集合是否为空
    //clear清空元素
    c2.clear();
    System.out.println(c2.isEmpty());
}

迭代器

hasNext判断有没有后面的

next返回后面的

Iterator iterator=c1.iterator();
while(iterator.hasNext()){
    System.out.println(iterator.next());
}

List接口

ArrayList、LinkedList、Vector的异同：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iGFKUO2U-1600600427541)(C:\Users\wade\Desktop\后端开发\屏幕截图(522)].png)

共同点：存储有序的、可重复的数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xdgqqifo-1600600427543)(C:\Users\wade\Desktop\后端开发\屏幕截图(523)].png)

Set接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yuOgPbr0-1600600427546)(C:\Users\wade\Desktop\后端开发\Set类.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9rk4Swob-1600600427548)(C:\Users\wade\Desktop\后端开发\HashSet概念.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yof8IdaU-1600600427551)(C:\Users\wade\Desktop\后端开发\七上八下.jpg)]

// 1. initialize the hash set
Set<Integer> hashSet = new HashSet<>();
// 2. add a new key
hashSet.add(3);
hashSet.add(2);
hashSet.add(1);
// 3. remove the key
hashSet.remove(2);
// 4. check if the key is in the hash set
if (!hashSet.contains(2)) {
    System.out.println("Key 2 is not in the hash set.");
}
// 5. get the size of the hash set
System.out.println("The size of has set is: " + hashSet.size());
// 6. iterate the hash set
for (Integer i : hashSet) {
    System.out.print(i + " ");
}
System.out.println("are in the hash set.");
// 7. clear the hash set
hashSet.clear();
// 8. check if the hash set is empty
if (hashSet.isEmpty()) {
    System.out.println("hash set is empty now!");
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R3MdCJGB-1600600427555)(C:\Users\wade\Desktop\后端开发\TreeSet介绍.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yty09YjW-1600600427558)(C:\Users\wade\Desktop\后端开发\TreeSet排序设置.jpg)]

Map接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bV4aL5ci-1600600427561)(C:\Users\wade\Desktop\后端开发\Map类.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x4wAhBdR-1600600427563)(C:\Users\wade\Desktop\后端开发\Map结构的理解.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-moOAWZ8K-1600600427565)(C:\Users\wade\Desktop\后端开发\Map接口常用方法.jpg)]

Iterator iterator=map.keySet().iterator();//获取key的set
while(iterator.hasNext()){
    System.out.println(iterator.next());
}
System.out.println("................");

iterator=map.values().iterator();//获取value的collection
while(iterator.hasNext()){
    System.out.println(iterator.next());
}
System.out.println("................");

iterator=map.entrySet().iterator();//获取entry的set
while(iterator.hasNext()){
    System.out.println(iterator.next());
}

Map.Entry entry=(Map.Entry)iterator.next();//强转获取entry
System.out.println(entry.getKey());

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VmBGds3c-1600600427568)(C:\Users\wade\Desktop\后端开发\HashMap常用变量.jpg)]

HashMap底层原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e4mpnGAu-1600600427570)(C:\Users\wade\Desktop\后端开发\HashMap底层原理.jpg)]

泛型

用于限制内容类型

泛型类

关于泛型类异常

抛出一个T类型的对象oa作为异常，这是不允许的。因为在没指定上界的情况下，T会被擦拭成Object类，而Object类显然不会是Throwable的子类，因此它不符合异常的有关规定。第二个错误的原因也是一样的。

编译器在处理catch语句时，将它当作静态上下文来看待，尽管这么做给程序员带来了一点不便。但考虑到catch语句必须在异常发生时才会执行，而且必须有足够的运行时信息，而泛型在这一方面不如非泛型类，所以这么做仍然是可以接受的。

泛型方法

void MyFunc() //声明具有一个类型参数的泛型方法
{
Type genericType = typeof(T); //在泛型方法体内部获取类型参数的类型信息
//do…
}

声明泛型方法时，方法的参数列表和返回值可以指定相同或不相同的类型参数，如果不相同则一般参数列表的类型参数在前，返回值的类型参数在后：U MyFunc<T, U>(T obj) { return default(U); }，此时依然不能使用编译器的类型推断功能；如果相同，则在调用时可以使用编译器的类型推断功能省略类型参数的显式指定

与所在类是不是泛型无关

可声明为静态，泛型参数是在调用方法时确定，并非实例化类时确定

泛型的继承

泛型中不考虑子父类继承

通配符

List<String> list1 = null;
List<Object> list2 = null;

List<?> list = null;
list=list1;
list=list2;

不能向通配符的list中添加数据，除了添加null

读取：允许读取数据，读取的数据类型为Object

有限制条件的通配符：

<? extends ...>可在子类及自己之间传递读取数据只能获取一个父类或自己的数据不能添加数据，因为不知道添加的是否比？还小的子类 <? super ...>可在父类及自己之间传递读取数据只能获取Object类数据可以添加数据 # IO流 1.造文件 2.造流 3.读写操作 4.关闭流（先关闭外层流，再关闭内层流，一般关闭外层流，内） ## 原理及分类字符流：文本数据字节流：非文本数据节点流：作用在文件上处理流：在已有流的情况下外包一层流 ## File类 File类的一个对象是一个文件或者一个文件夹 ### 构造器构造器一：public File(String path) 相对路径,相对于当前module 绝对路径包含盘符在内的路径较通用的路径分隔符“seperator” 构造器二：public File(String parent, String child) child是parent中的文件构造器三：public File(File file, String path) path是file中的文件 ### 常用方法重命名要求：（比如file1重命名为file2）file1需要存在，file2不能存在，相当于剪切 ## 非文本处理（字节流） ```java FileInputStream fileInputStream= null; FileOutputStream fileOutputStream= null; try { File img=new File("src\\movie1.jpg"); File dec=new File("movie1(1).jpg"); fileInputStream = new FileInputStream(img); fileOutputStream = new FileOutputStream(dec); byte[] bytes=new byte[5]; int len; while((len=fileInputStream.read(bytes))!=-1){ fileOutputStream.write(bytes,0,len); } } catch (IOException e) { e.printStackTrace(); } finally { try { fileInputStream.close(); } catch (IOException e) { e.printStackTrace(); } try { fileOutputStream.close(); } catch (IOException e) { e.printStackTrace(); } } } ``` ## 缓冲流作用：提高流的读取、写入的速度缓冲流要用flush()将写入的数据输出 ## 对象流（处理流之一）处理基本数据类型数据或者对象的处理流序列化：用ObjectOutputStream类保存基本类型数据或对象的机制反序列化：用ObjectInputStream类读取基本类型数据或对象的机制不能序列化static和transient修饰的成员变量可序列化： 1.实现接口Serializable 2.定义全局属性serialVersionUID 3.内部的所有属性都必须是可序列化的 serialVersionUID 的理解：以序列化对象进行版本控制，如果没写，会自动生成，若类的实例变量做了修改，serialVersionUID 可能发生变化，反序列化时会出错。 ## 随机存取文件流RandomAccessFile类直接继承于Object类，从头开始覆盖文件，既可以作为输入流，又可以作为输出流作为输出流时如果写出到的文件不存在，创建新文件；如果存在，默认从头开始覆盖输入的数量 ```java FileInputStream fileInputStream= null; FileOutputStream fileOutputStream= null; try { File img=new File("src\\movie1.jpg"); File dec=new File("movie1(1).jpg"); fileInputStream = new FileInputStream(img); fileOutputStream = new FileOutputStream(dec); byte[] bytes=new byte[5]; int len; while((len=fileInputStream.read(bytes))!=-1){ fileOutputStream.write(bytes,0,len); } } catch (IOException e) { e.printStackTrace(); } finally { try { fileInputStream.close(); } catch (IOException e) { e.printStackTrace(); } try { fileOutputStream.close(); } catch (IOException e) { e.printStackTrace(); } } } ``` ## 缓冲流作用：提高流的读取、写入的速度缓冲流要用flush()将写入的数据输出 ## 对象流（处理流之一）处理基本数据类型数据或者对象的处理流序列化：用ObjectOutputStream类保存基本类型数据或对象的机制反序列化：用ObjectInputStream类读取基本类型数据或对象的机制不能序列化static和transient修饰的成员变量可序列化： 1.实现接口Serializable 2.定义全局属性serialVersionUID 3.内部的所有属性都必须是可序列化的 serialVersionUID 的理解：以序列化对象进行版本控制，如果没写，会自动生成，若类的实例变量做了修改，serialVersionUID 可能发生变化，反序列化时会出错。 ## 随机存取文件流RandomAccessFile类直接继承于Object类，从头开始覆盖文件，既可以作为输入流，又可以作为输出流作为输出流时如果写出到的文件不存在，创建新文件；如果存在，默认从头开始覆盖输入的数量使用seek()修改指针位置覆盖数据（