异常处理：
        1.基本语法：try...catch
        2.多catch：try...catch...catch...catch
          注意：每个catch的异常类型可以是"平级的"，不分先后顺序；
                可以可以是"子父关系"，父类的必须放在最后；
        3.JDK7的多catch语句:try...catch(异常类型1 |异常类型2 | 异常类型3  e)
          注意：一定要是"平级关系"，不能是"子父关系"
        4.finally语句：
                A:try...catch...finally
                B:特点：无论在try中是否发生异常，都会被执行；
        5.throws和throw:
                A:throws
                        1).用在方法声明处；
                        2).后面写类名；可以有多个；
                        3).运行时：
                                调用处可以不捕获，也可以捕获；
                           非运行时：
                                调用处必须捕获；
                B:throw:
                        1).用在方法体内；
                        2).后面写对象的引用；只能有一个；
                        3).运行时：
                                a).可以不用声明throws
                                b).调用处可以处理，可以不处理；
                           非运行时：
                                a).方法必须声明throws这个类型的异常；
                                b).调用处必须处理；
               
        6.Throwable的几个常用方法：
                1).getMessage():获取异常信息；
                2).toString():调用重写的toString()方法
                3).printStackTrace():打印堆栈异常；
        7.自定义异常：
                1).我们可以根据我们的业务逻辑，编写我们自己的异常类；
                2).自定义一个类，继承自Exception或其它子类即可；
                3).通常会添加一个带String参数的构造方法：指定异常信息；
        8.子类重写父类方法时：
                无论父类方法是否抛出异常，子类方法都可以不抛出任何异常；
                也可以抛出任何的运行时异常；
                如果父类抛出的是"非运行时异常"，子类不能抛出比父类更多的"非运行时异常"
       
       
二.File类：
        1.构造方法：
                public File(String pathname)
                public File(String parent,String child)
                public File(File parent,String child)
        2.创建功能
                public boolean createNewFile()：
                public boolean mkdir()
                public boolean mkdirs()
        3.删除功能
                public boolean delete()
        4.重命名功能
                public boolean renameTo(File dest)
        5.判断功能
                public boolean isDirectory()
                public boolean isFile()
                public boolean exists()
                public boolean canRead()
                public boolean canWrite()
                public boolean isHidden()
        6.基本获取功能
                public String getAbsolutePath()
                public String getPath()
                public String getName()
                public long length()
                public long lastModified()
        7.高级获取功能
                public String[] list()
                public File[] listFiles()

递归：
        1.递归是基于：方法可以自己调用自己；
        2.注意：
                1).一定要有出口，否则就是死递归；
                2).次数不能太多，否则堆栈溢出；
                3).构造方法不能递归调用；
        3.重点练习：
                1).递归输出指定目录下所有的java文件的绝对路径案例
                2).递归删除带内容的目录案例
二.IO流：
        1.IO流概念：
                1.IO流：InputStream和OutputStream
                2.流：是有方向的，线性的；
                3.分类：
                        A.按流向：
                                输出流
                                输入流
                        B.按读写方式：
                                字节流：
                                        输出流：OutputStream
                                                        |--FileOutputStream(覆盖写、追加写)(文件可以不存在)
                                                                1).构造方法：
                                                                        覆盖写：
                                                                        FileOutputStream(String name):
                                                                        FileOutputStream(File file);
                                                                        追加写：
                                                                        FileOutputStream(String name，boolean append):
                                                                        FileOutputStream(File file，boolean append);
                                                                2).写入方法：
                                                                        write(int b):
                                                                        write(byte[] byteArray):
                                                                        write(byte[] byteArray,int off,int len):
                                                                3).关闭流：
                                                                        close();
                                        输入流: InputStream
                                                        |--FileInputStream(文件必须存在，否则报错)
                                                                1).构造方法：
                                                                        FileInputStream(String name):
                                                                        FileInputStream(File file):
                                                                2).读取的方法：
                                                                        int read();//今天学的
                                                                        int read(byte[] byteArray)://下次课
                                                               
                                字符流：
                                        输出流:Writer
                                        输入流:Reader



字节流：
        1.类层次结构：
        OutputStream:
                |--FileOutputStream:
                |--FilterOutputStream:(没学)
                        |--BufferedOutputStream:
        InputStream:
                |--FileInputStream:
                |--FilterInputStream:(没学)
                        |--BufferedInputStream:
        2.写入的方法：
                write(int n):写入一个字节：
                write(byte[] byteArray):写入一个字节数组；
        3.读取的方法：
                int read():读取一个字节：
                int read(byte[] byteArray):读取一个字节数组；
        4.字节流可以对：二进制文件和文本文件进行读写。
        5.当读写二进制文件时：首选带缓冲的字节流；
          当读写文本文件时：如果不需要显示，也可以选择字节流。通常
                           使用带缓冲的字符流。

二：字符流：
        1.类层次结构：
        Writer:
           |--OutputStreamWriter:
                |--FileWriter:
           |--BufferedWriter:
        Reader:
           |--InputStreamReader:
                |--FileReader:
           |--BufferedReader:
        2.写入的方法：
                基本字符流，和缓冲流都具有的：
                        write(int n):写入一个字符：
                        write(char[] charArray):写入一个字符数组；
                        write(char[] charArray,int off,int len):写入字符数组的一部分；
                        write(String s):写入一个字符;
                        write(String s,int off,int len):写入一个字符串的一部分；
                缓冲流特有的：
                        BufferedWriter:
                                newLine();
                        BufferedReader:
                                String s readLine();
        3.当需要对文本文件进行读写，显示：首选使用带缓冲的字符流；


数据输入输出流：
        DataInputStream:数据输入流：
        DataOutputStream:数据输出流：
        可以读写任何的Java的基本数据类型；
二.内存操作流：
        ByteArrayOutputStream:向内存中写入byte[]数组；
        ByteArrayInputStream:从内存中读取byte[]数组；
        作用：
        缓存byte[]数组；就跟StringBuffer缓存String作用相同；
三.打印流：
        1.打印字符流：PrintWriter:
        2.打印字节流：PrintStream:
        特点：
                1.只有输出，没有输入；
                2.可以输出任何类型的数据；
                3.有自动刷新功能，如果启用，部分功能将具有自动刷新功能：
                                println(),printf(),format()
                4.可以操作文件；
四.标准输入输出流：
        1.System.in : InputStream
        2.System.out: PrintStream
        3.将标准输入流转换为带缓冲的输入流：
                BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        4.三种方式实现获取控制台数据：
                1).Scanner();
                2).main()方法的形参；
                3).System.in;
五.随机访问流：
        1.RandomAccessFile:
        2.它不是流，直接继承自Object
        3.它内部结合了InputStream和OutputStream可以对文件进行读写；
        4.构造方法的mode参数：
                "r" 以只读方式打开。调用结果对象的任何 write 方法都将导致抛出 IOException。  
                "rw" 打开以便读取和写入。如果该文件尚不存在，则尝试创建该文件。  
                "rws" 打开以便读取和写入，对于 "rw"，还要求对文件的内容或元数据的每个更新都同步写入到底层存储设备。  
                "rwd" 打开以便读取和写入，对于 "rw"，还要求对文件内容的每个更新都同步写入到底层存储设备。
        5.getFilePointer()获取文件指针；
          seek():设置文件指针；
六.序列化和反序列化：
        1.ObjectOutputStream:序列化；
                writeObject(Object obj):
        2.ObjectInputStream:反序列化：
                Object obj readObject();
        3.注意：
                1).被序列化的对象，必须实现Serializable 接口；
                2).被序列化的对象，建议显示的定义成员常量：serialVersionUID
                3).transient可以修饰成员变量不被序列化；
七.Properties类：
        1.它是Map的实现类，直接继承自:Hashtable。所以它就是一个Map
        2.用它来读写配置文件信息；
        3.特有方法：
                setProperty(String key,String value)：put()
                getProperty(String key):              get()
                stringPropertyNames():                      keySet()
          读写配置文件：
                load(Reader reader):从配置文件中读取属性信息
                store(Writer writer,String comments)：向配置文件中写入信息
八.新IO的方法：
        Path:与平台无关的路径。
        Paths:包含了返回Path的静态方法。
                public static?Path?get(URI?uri):根据给定的URI来确定文件路径。
        Files:操作文件的工具类。提供了大量的方法，简单了解如下方法
                public static?long?copy(Path?source, OutputStream?out) :复制文件
                public static?Path?write(Path path, Iterable<? extends CharSequence> lines,Charset cs,OpenOption... options):
                把集合的数据写到文件。

                        线程实现方式：
        1.继承Thread类；
        2.实现Runnable接口；

二.设置获取线程的名称：
        getName()和setName(String name);
三.设置获取线程的优先级：
        getPriority()和setPriority(int n);
        线程的优先级范围：1--10(从低到高)
四.线程的休眠：sleep(long m):休眠到指定的m毫秒后，将自动醒来；
   加入：join();
   礼让：yield():退回到"就绪状态"，可能会被操作系统重新分配；
   守护：setDaemon(boolean on):on为true，守护线程。主进程结束，守护线程也结束，但不会立即结束，会有一个小缓冲；
   中断：stop()(过时了)
         interrupt():线程一定要处于：Object-->wait();Thread-->sleep();Thread--join()三种状态之一时，才能触发此异常；
五.解决并发性问题：
        1.使用关键字：synchronized
        2.synchronized可以修饰一个代码块：同步代码块
          synchronized可以修饰一个方法：同步方法
        3.静态的方法可以被synchronized修饰。
          静态的方法内部也可以包含synchronized的代码块，但一般锁定是某个类的class对象。

感谢分享，学习了