目录

IO流

多线程

反射机制

注解

IO流

IO（Input  Output）通过IO可以完成硬盘文件的读和写

IO流的分类

    一种方式是按照流的方向进行分类：
            以内存作为参照物：
                往内存中去，叫做输入(Input)。或者叫做读(Read)
                从内存中出来，叫做输出(Output)。或者叫做写(Write)

    

    另一种方式是按照读取数据方式不同进行分类：
            有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位，这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文件等....
                假设文件file.txt，采用字节流的话是这样读的：
                    a中国bc张三fe
                    第一次读：一个字节，正好读到'a'
                    第二次读：一个字节，正好读到'中'字符的一半
                    第三次读：一个字节，正好读到'中'字符的另外一半

            有的流是按照字符的方式读取数据的，一次读取一个字符，这种流是为了方便读取普通文本文件而存在的，这种流不能读取图片、声音、视频等文件，只能读取纯文本文件，连word文件都无法读取
                假设文件file1.txt，采用字符流的话是这样读的：
                    a中国bc张三fe
                    第一次读：'a'字符（'a'字符在windows系统中占用1个字节）
                    第二次读：'中'字符（'中'字符在windows系统中占用2个字节）

故流的分类为输入流、输出流和字节流、字符流

java IO流有四大家族的首领

        java.io.InputStream  字节输入流
        java.io.OutputStream 字节输出流                                                                                              java.io.Reader        字符输入流
        java.io.Writer        字符输出流

四大家族的首领都是抽象类

所有的流都实现了：
            java.io.Closeable接口，都是可关闭的，都有close()方法
            流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭，不然会耗费(占用)很多资源。养成好习惯，用完流一定要关闭

所有的输出流都实现了：
            java.io.Flushable接口，都是可刷新的，都有flush()方法
            养成一个好习惯，输出流在最终输出之后，一定要记得flush()刷新一下。这个刷新表示将通道/管道当中剩余未输出的数据强行输出完（清空管道！）刷新的作用就是清空管道
注意：如果没有flush()可能会导致丢失数据

注意：在java中只要“类名”以Stream结尾的都是字节流；以“Reader/Writer”结尾的都是字符流

java.io包下需要掌握的流有16个：

    文件专属：
        java.io.FileInputStream
        java.io.FileOutputStream
        java.io.FileReader
        java.io.FileWriter

    转换流：（将字节流转换成字符流）
        java.io.InputStreamReader
        java.io.OutputStreamWriter

    缓冲流专属：
        java.io.BufferedReader
        java.io.BufferedWriter
        java.io.BufferedInputStream
        java.io.BufferedOutputStream

    数据流专属：
        java.io.DataInputStream
        java.io.DataOutputStream

    标准输出流：
        java.io.PrintWriter
        java.io.PrintStream

    对象专属流：
        java.io.ObjectInputStream
        java.io.ObjectOutputStream

FileInputStream文件字节输入流

文件字节输入流是万能的，任何类型的文件都可以采用这个流来读。字节的方式，完成输入的操作，完成读的操作（硬盘---> 内存）

FileInputStream类的其它常用方法：
    int available()：返回流当中剩余的没有读到的字节数量
    long skip(long n)：跳过几节不个字读。 

 FileOutputStream文件字节输出流

文件字节输出流，负责写。从内存到硬盘

FileReader文件字符输入流，只能输出普通文本

FileWriter文件字符输出流，只能输出普通文本

BufferedReader带有缓冲区的字符输入流

BufferedWriter带有缓冲的字符输出流

序列化

参与序列化和反序列化的对象，必须实现Serializable接口

Serializable接口只是一个标志接口：
    public interface Serializable {
    }

这个接口当中什么代码都没有，起到标识的作用，Serializable这个标志接口是给java虚拟机参考的，java虚拟机看到这个接口之后，会为该类自动生成一个序列化版本号

这种自动生成序列化版本号有什么缺陷？

    这种自动生成的序列化版本号缺点：一旦代码确定之后，不能进行后续的修改，因为只要修改，必然会重新编译，此时会生成全新的序列化版本号，这个时候java虚拟机会认为这是一个全新的类

结论：
        凡是一个类实现了Serializable接口，建议给该类提供一个固定不变的序列化版本号，这样，以后这个类即使代码修改了，但是版本号不变，java虚拟机会认为是同一个类

public class ObjectOutputStreamTest01 {
    public static void main(String[] args) throws Exception{
        Student s = new Student(1111, "zhangsan");
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("students"));
        oos.writeObject(s);
        oos.flush();
        oos.close();
    }
}

反序列化

public class ObjectInputStreamTest02 {
    public static void main(String[] args) throws Exception{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("xxx"));
        List userList = (List)ois.readObject();
        for(User user : userList){
            System.out.println(user);
        }
        ois.close();
    }
}

多线程

进程和线程

    进程是一个应用程序（1个进程是一个软件）。
    线程是一个进程中的执行场景/执行单元
    一个进程可以启动多个线程

实现线程的两种方式

    第一种方式：编写一个类，直接继承java.lang.Thread，重写run方法

// 定义线程类
public class MyThread extends Thread{
	public void run(){
			
	}
}
// 创建线程对象
MyThread t = new MyThread();
t.start();// 启动线程

    第二种方式：编写一个类，实现java.lang.Runnable接口，实现run方法

// 定义一个可运行的类
public class MyRunnable implements Runnable {
	public void run(){
			
	}
}
Thread t = new Thread(new MyRunnable());// 创建线程对象
t.start();// 启动线程

线程对象引用.start();

    start()方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了，线程就启动成功。启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。run和main是平级的

线程对象的生命周期阶段有：

新建状态、就绪状态、运行状态、阻塞状态、死亡状态

获取当前线程对象：Thread t = Thread.currentThread();

获取线程对象的名字：String name = 线程对象.getName();

修改线程对象的名字：线程对象.setName("线程名字");

关于线程的sleep方法：

    static void sleep(long millis)

     1、静态方法：Thread.sleep(1000);参数是毫秒
     2、作用：让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其它线程使用

静态方法：Thread.yield();让位，当前线程暂停，回到就绪状态，让给其它线程

t.join()线程合并， t合并到当前线程中，当前线程受阻塞，t线程执行直到结束

线程同步机制的语法是：
            synchronized(){
                // 线程同步代码块
            }

数据在多线程并发的环境下会存在的安全问题：

    三个条件：
            条件1：多线程并发
            条件2：有共享数据
            条件3：共享数据有修改的行为

怎么解决线程安全问题呢？

    线程排队执行（不能并发）。用排队执行解决线程安全问题。这种机制被称为：线程同步机制

反射机制

反射机制的作用：

    通过java语言中的反射机制可以操作字节码文件

反射机制的相关类的包在java.lang.reflect.*;

反射机制相关的重要的类有哪些？

        java.lang.Class：代表整个字节码，代表一个类型，代表整个类。

        java.lang.reflect.Method：代表字节码中的方法字节码。代表类中的方法。

        java.lang.reflect.Constructor：代表字节码中的构造方法字节码。代表类中的构造方法

        java.lang.reflect.Field：代表字节码中的属性字节码。代表类中的成员变量（静态变量+实例变量）

注解

英文单词：Annotation

注解Annotation是一种引用数据类型

自定义注解

 [修饰符列表] @interface 注解类型名{

}

使用

第一：注解使用时的语法格式是：
            @注解类型名

第二：注解可以出现在类上、属性上、方法上、变量上等....
        注解还可以出现在注解类型上

Override 表示一个方法声明打算重写超类中的另一个方法声明

元注解

用来标注“注解类型”的“注解”，称为元注解

常见的元注解：Target、Retention

关于Target注解：用来标注“注解类型”的“注解”                                @Target(ElementType.METHOD)：表示“被标注的注解”只能出现在方法上                            @Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, MODULE, PARAMETER, TYPE})                                                                                          表示该注解可以出现在：构造方法上、字段上、局部变量上、方法上....类上...

关于Retention注解：用来标注“注解类型”的“注解”                                                                     @Retention(RetentionPolicy.SOURCE)：表示该注解只被保留在java源文件中                       @Retention(RetentionPolicy.CLASS)：表示该注解被保存在class文件中