JAaveSE基础知识附上代码实现3-CSDN博客

本文链接：https://blog.csdn.net/qq_41826183/article/details/88109249

###20.01_IO流(IO流概述及其分类)
* 1.概念
   * IO流用来处理设备之间的数据传输
   * Java对数据的操作是通过流的方式
   * Java用于操作流的类都在IO包中
   * 流按流向分为两种：输入流，输出流。
   * 流按操作类型分为两种：
       * 字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的
       * 字符流 : 字符流只能操作纯字符数据，比较方便。
* 2.IO流常用父类
   * 字节流的抽象父类：
       * InputStream
       * OutputStream
   * 字符流的抽象父类：
       * Reader
       * Writer
* 3.IO程序书写
   * 使用前，导入IO包中的类
   * 使用时，进行IO异常处理
   * 使用后，释放资源

###20.02_IO流(FileInputStream)
* read()一次读取一个字节
*
       FileInputStream fis = new FileInputStream("aaa.txt");   //创建一个文件输入流对象,并关联aaa.txt
       int b;                                                   //定义变量,记录每次读到的字节
       while((b = fis.read()) != -1) {                           //将每次读到的字节赋值给b并判断是否是-1
           System.out.println(b);                               //打印每一个字节
       }

       fis.close();                                           //关闭流释放资源
###20.03_IO流(read()方法返回值为什么是int)
* read()方法读取的是一个字节,为什么返回是int,而不是byte
*
       因为字节输入流可以操作任意类型的文件,比如图片音频等,这些文件底层都是以二进制形式的存储的,如果每次读取都返回byte,有可能在读到中间的时候遇到111111111
       那么这11111111是byte类型的-1,我们的程序是遇到-1就会停止不读了,后面的数据就读不到了,所以在读取的时候用int类型接收,如果11111111会在其前面补上
       24个0凑足4个字节,那么byte类型的-1就变成int类型的255了这样可以保证整个数据读完,而结束标记的-1就是int类型
###20.04_IO流(FileOutputStream)
* write()一次写出一个字节
*
       FileOutputStream fos = new FileOutputStream("bbb.txt");   //如果没有bbb.txt,会创建出一个
       //fos.write(97);                       //虽然写出的是一个int数,但是在写出的时候会将前面的24个0去掉,所以写出的一个byte
       fos.write(98);
       fos.write(99);
       fos.close();
###20.05_IO流(FileOutputStream追加)
* A:案例演示
   * FileOutputStream的构造方法写出数据如何实现数据的追加写入
*
       FileOutputStream fos = new FileOutputStream("bbb.txt",true);   //如果没有bbb.txt,会创建出一个
       //fos.write(97);                       //虽然写出的是一个int数,但是在写出的时候会将前面的24个0去掉,所以写出的一个byte
       fos.write(98);
       fos.write(99);
       fos.close();

###20.06_IO流(拷贝图片)
* FileInputStream读取
* FileOutputStream写出

       FileInputStream fis = new FileInputStream("致青春.mp3");   //创建输入流对象,关联致青春.mp3
       FileOutputStream fos = new FileOutputStream("copy.mp3");//创建输出流对象,关联copy.mp3

       int b;
       while((b = fis.read()) != -1) {
           fos.write(b);
       }

       fis.close();
       fos.close();

###20.07_IO流(拷贝音频文件画原理图)
* A:案例演示
* 字节流一次读写一个字节复制音频
* 弊端:效率太低

###20.08_IO流(字节数组拷贝之available()方法)
* A:案例演示
   * int read(byte[] b):一次读取一个字节数组
   * write(byte[] b):一次写出一个字节数组
   * available()获取读的文件所有的字节个数
* 弊端:有可能会内存溢出

       FileInputStream fis = new FileInputStream("致青春.mp3");
       FileOutputStream fos = new FileOutputStream("copy.mp3");
       byte[] arr = new byte[fis.available()];                   //根据文件大小做一个字节数组
       fis.read(arr);                                           //将文件上的所有字节读取到数组中
       fos.write(arr);                                           //将数组中的所有字节一次写到了文件上
       fis.close();
       fos.close();

###20.09_IO流(定义小数组)
* write(byte[] b)
* write(byte[] b, int off, int len)写出有效的字节个数

###20.10_IO流(定义小数组的标准格式)
* A:案例演示
   * 字节流一次读写一个字节数组复制图片和视频
       FileInputStream fis = new FileInputStream("致青春.mp3");
       FileOutputStream fos = new FileOutputStream("copy.mp3");
       int len;
       byte[] arr = new byte[1024 * 8];                   //自定义字节数组

       while((len = fis.read(arr)) != -1) {
           //fos.write(arr);
           fos.write(arr, 0, len);                           //写出字节数组写出有效个字节个数
       }

       fis.close();
       fos.close();
###20.11_IO流(BufferedInputStream和BufferOutputStream拷贝)
* A:缓冲思想
   * 字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，
   * 这是加入了数组这样的缓冲区效果，java本身在设计的时候，
   * 也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流
* B.BufferedInputStream
   * BufferedInputStream内置了一个缓冲区(数组)
   * 从BufferedInputStream中读取一个字节时
   * BufferedInputStream会一次性从文件中读取8192个, 存在缓冲区中, 返回给程序一个
   * 程序再次读取时, 就不用找文件了, 直接从缓冲区中获取
   * 直到缓冲区中所有的都被使用过, 才重新从文件中读取8192个
* C.BufferedOutputStream
   * BufferedOutputStream也内置了一个缓冲区(数组)
   * 程序向流中写出字节时, 不会直接写到文件, 先写到缓冲区中
   * 直到缓冲区写满, BufferedOutputStream才会把缓冲区中的数据一次性写到文件里
* D.拷贝的代码

       FileInputStream fis = new FileInputStream("致青春.mp3");           //创建文件输入流对象,关联致青春.mp3
       BufferedInputStream bis = new BufferedInputStream(fis);           //创建缓冲区对fis装饰
       FileOutputStream fos = new FileOutputStream("copy.mp3");       //创建输出流对象,关联copy.mp3
       BufferedOutputStream bos = new BufferedOutputStream(fos);       //创建缓冲区对fos装饰

       int b;
       while((b = bis.read()) != -1) {
           bos.write(b);
       }

       bis.close();                       //只关装饰后的对象即可
       bos.close();

* E.小数组的读写和带Buffered的读取哪个更快?
   * 定义小数组如果是8192个字节大小和Buffered比较的话
   * 定义小数组会略胜一筹,因为读和写操作的是同一个数组
   * 而Buffered操作的是两个数组

###20.12_IO流(flush和close方法的区别)
* flush()方法
   * 用来刷新缓冲区的,刷新后可以再次写出
* close()方法
   * 用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出
###20.13_IO流(字节流读写中文)
* 字节流读取中文的问题
   * 字节流在读中文的时候有可能会读到半个中文,造成乱码
* 字节流写出中文的问题
   * 字节流直接操作的字节,所以写出中文必须将字符串转换成字节数组
   * 写出回车换行 write("\r\n".getBytes());

###20.14_IO流(流的标准处理异常代码1.6版本及其以前)
* try finally嵌套

       FileInputStream fis = null;
       FileOutputStream fos = null;
       try {
           fis = new FileInputStream("aaa.txt");
           fos = new FileOutputStream("bbb.txt");
           int b;
           while((b = fis.read()) != -1) {
               fos.write(b);
           }
       } finally {
           try {
               if(fis != null)
                   fis.close();
           }finally {
               if(fos != null)
                   fos.close();
           }
       }

###20.15_IO流(流的标准处理异常代码1.7版本)
* try close

       try(
           FileInputStream fis = new FileInputStream("aaa.txt");
           FileOutputStream fos = new FileOutputStream("bbb.txt");
           MyClose mc = new MyClose();
       ){
           int b;
           while((b = fis.read()) != -1) {
               fos.write(b);
           }
       }
* 原理
   * 在try()中创建的流对象必须实现了AutoCloseable这个接口,如果实现了,在try后面的{}(读写代码)执行后就会自动调用,流对象的close方法将流关掉

###20.16_IO流(图片加密)
* 给图片加密

       BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.jpg"));
       BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.jpg"));

       int b;
       while((b = bis.read()) != -1) {
           bos.write(b ^ 123);
       }

       bis.close();
       bos.close();

###20.17_IO流(拷贝文件)
* 在控制台录入文件的路径,将文件拷贝到当前项目下

       Scanner sc = new Scanner(System.in);
       System.out.println("请输入一个文件路径");
       String line = sc.nextLine();               //将键盘录入的文件路径存储在line中
       File file = new File(line);                   //封装成File对象
       FileInputStream fis = new FileInputStream(file);
       FileOutputStream fos = new FileOutputStream(file.getName());

       int len;
       byte[] arr = new byte[8192];               //定义缓冲区
       while((len = fis.read(arr)) != -1) {
           fos.write(arr,0,len);
       }

       fis.close();
       fos.close();

###20.18_IO流(录入数据拷贝到文件)
* 将键盘录入的数据拷贝到当前项目下的text.txt文件中,键盘录入数据当遇到quit时就退出

       Scanner sc = new Scanner(System.in);
       FileOutputStream fos = new FileOutputStream("text.txt");
       System.out.println("请输入:");
       while(true) {
           String line = sc.nextLine();
           if("quit".equals(line))
               break;
           fos.write(line.getBytes());
           fos.write("\r\n".getBytes());
       }

       fos.close();
###20.19_day20总结
* 把今天的知识点总结一遍。

###22.01_IO流(序列流)(了解)
* 1.什么是序列流
   * 序列流可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个之后继续读第二个, 以此类推.
* 2.使用方式
   * 整合两个: SequenceInputStream(InputStream, InputStream)
   *
           FileInputStream fis1 = new FileInputStream("a.txt");           //创建输入流对象,关联a.txt
           FileInputStream fis2 = new FileInputStream("b.txt");           //创建输入流对象,关联b.txt
           SequenceInputStream sis = new SequenceInputStream(fis1, fis2);   //将两个流整合成一个流
           FileOutputStream fos = new FileOutputStream("c.txt");           //创建输出流对象,关联c.txt

           int b;
           while((b = sis.read()) != -1) {                                   //用整合后的读
               fos.write(b);                                               //写到指定文件上
           }

           sis.close();
           fos.close();
###22.02_IO流(序列流整合多个)(了解)
* 整合多个: SequenceInputStream(Enumeration)
*
       FileInputStream fis1 = new FileInputStream("a.txt");   //创建输入流对象,关联a.txt
       FileInputStream fis2 = new FileInputStream("b.txt");   //创建输入流对象,关联b.txt
       FileInputStream fis3 = new FileInputStream("c.txt");   //创建输入流对象,关联c.txt
       Vector<InputStream> v = new Vector<>();                   //创建vector集合对象
       v.add(fis1);                                           //将流对象添加
       v.add(fis2);
       v.add(fis3);
       Enumeration<InputStream> en = v.elements();               //获取枚举引用
       SequenceInputStream sis = new SequenceInputStream(en);   //传递给SequenceInputStream构造
       FileOutputStream fos = new FileOutputStream("d.txt");
       int b;
       while((b = sis.read()) != -1) {
           fos.write(b);
       }

       sis.close();
       fos.close();

###22.03_IO流(内存输出流*****)(掌握)
* 1.什么是内存输出流
   * 该输出流可以向内存中写数据, 把内存当作一个缓冲区, 写出之后可以一次性获取出所有数据
* 2.使用方式
   * 创建对象: new ByteArrayOutputStream()
   * 写出数据: write(int), write(byte[])
   * 获取数据: toByteArray()
   *
           FileInputStream fis = new FileInputStream("a.txt");
           ByteArrayOutputStream baos = new ByteArrayOutputStream();
           int b;
           while((b = fis.read()) != -1) {
               baos.write(b);
           }

           //byte[] newArr = baos.toByteArray();               //将内存缓冲区中所有的字节存储在newArr中
           //System.out.println(new String(newArr));
           System.out.println(baos);
           fis.close();
###22.04_IO流(内存输出流之黑马面试题)(掌握)
* 定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)
*
           FileInputStream fis = new FileInputStream("a.txt");               //创建字节输入流,关联a.txt
           ByteArrayOutputStream baos = new ByteArrayOutputStream();       //创建内存输出流
           byte[] arr = new byte[5];                                       //创建字节数组,大小为5
           int len;
           while((len = fis.read(arr)) != -1) {                           //将文件上的数据读到字节数组中
               baos.write(arr, 0, len);                                   //将字节数组的数据写到内存缓冲区中
           }
           System.out.println(baos);                                       //将内存缓冲区的内容转换为字符串打印
           fis.close();

###22.05_IO流(对象操作流ObjecOutputStream)(了解)
* 1.什么是对象操作流
   * 该流可以将一个对象写出, 或者读取一个对象到程序中. 也就是执行了序列化和反序列化的操作.
* 2.使用方式
   * 写出: new ObjectOutputStream(OutputStream), writeObject()

           public class Demo3_ObjectOutputStream {

               /**
               * @param args
               * @throws IOException
               * 将对象写出,序列化
               */
               public static void main(String[] args) throws IOException {
                   Person p1 = new Person("张三", 23);
                   Person p2 = new Person("李四", 24);
           //       FileOutputStream fos = new FileOutputStream("e.txt");
           //       fos.write(p1);
           //       FileWriter fw = new FileWriter("e.txt");
           //       fw.write(p1);
                   //无论是字节输出流,还是字符输出流都不能直接写出对象
                   ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e.txt"));//创建对象输出流
                   oos.writeObject(p1);
                   oos.writeObject(p2);
                   oos.close();
               }

           }
###22.06_IO流(对象操作流ObjectInputStream)(了解)
* 读取: new ObjectInputStream(InputStream), readObject()
   *
           public class Demo3_ObjectInputStream {

               /**
               * @param args
               * @throws IOException
               * @throws ClassNotFoundException
               * @throws FileNotFoundException
               * 读取对象,反序列化
               */
               public static void main(String[] args) throws IOException, ClassNotFoundException {
                   ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e.txt"));
                   Person p1 = (Person) ois.readObject();
                   Person p2 = (Person) ois.readObject();
                   System.out.println(p1);
                   System.out.println(p2);
                   ois.close();
               }

           }

###22.07_IO流(对象操作流优化)(了解)
*　将对象存储在集合中写出

   Person p1 = new Person("张三", 23);
   Person p2 = new Person("李四", 24);
   Person p3 = new Person("马哥", 18);
   Person p4 = new Person("辉哥", 20);

   ArrayList<Person> list = new ArrayList<>();
   list.add(p1);
   list.add(p2);
   list.add(p3);
   list.add(p4);

   ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("f.txt"));
   oos.writeObject(list);                                   //写出集合对象

   oos.close();
* 读取到的是一个集合对象

       ObjectInputStream ois = new ObjectInputStream(new FileInputStream("f.txt"));
           ArrayList<Person> list = (ArrayList<Person>)ois.readObject();   //泛型在运行期会被擦除,索引运行期相当于没有泛型
                                                                           //想去掉黄色可以加注解                   @SuppressWarnings("unchecked")
           for (Person person : list) {
               System.out.println(person);
           }

       ois.close();
###22.08_IO流(加上id号)(了解)
* 注意
   * 要写出的对象必须实现Serializable接口才能被序列化
   * 不用必须加id号

###22.09_IO流(打印流的概述和特点)(掌握)
* 1.什么是打印流
* 该流可以很方便的将对象的toString()结果输出, 并且自动加上换行, 而且可以使用自动刷出的模式
* System.out就是一个PrintStream, 其默认向控制台输出信息

           PrintStream ps = System.out;
           ps.println(97);                   //其实底层用的是Integer.toString(x),将x转换为数字字符串打印
           ps.println("xxx");
           ps.println(new Person("张三", 23));
           Person p = null;
           ps.println(p);                   //如果是null,就返回null,如果不是null,就调用对象的toString()
* 2.使用方式
   * 打印: print(), println()
   * 自动刷出: PrintWriter(OutputStream out, boolean autoFlush, String encoding)
   * 打印流只操作数据目的

           PrintWriter pw = new PrintWriter(new FileOutputStream("g.txt"), true);
           pw.write(97);
           pw.print("大家好");
           pw.println("你好");               //自动刷出,只针对的是println方法
           pw.close();

###22.10_IO流(标准输入输出流概述和输出语句)
* 1.什么是标准输入输出流(掌握)
   * System.in是InputStream, 标准输入流, 默认可以从键盘输入读取字节数据
   * System.out是PrintStream, 标准输出流, 默认可以向Console中输出字符和字节数据
* 2.修改标准输入输出流(了解)
   * 修改输入流: System.setIn(InputStream)
   * 修改输出流: System.setOut(PrintStream)
   *
           System.setIn(new FileInputStream("a.txt"));               //修改标准输入流
           System.setOut(new PrintStream("b.txt"));               //修改标准输出流

           InputStream in = System.in;                               //获取标准输入流
           PrintStream ps = System.out;                           //获取标准输出流
           int b;
           while((b = in.read()) != -1) {                           //从a.txt上读取数据
               ps.write(b);                                       //将数据写到b.txt上
           }

           in.close();
           ps.close();
###22.11_IO流(修改标准输入输出流拷贝图片)(了解)
       System.setIn(new FileInputStream("IO图片.png"));       //改变标准输入流
       System.setOut(new PrintStream("copy.png"));        //改变标准输出流

       InputStream is = System.in;                           //获取标准输入流
       PrintStream ps = System.out;                       //获取标准输出流

       int len;
       byte[] arr = new byte[1024 * 8];

       while((len = is.read(arr)) != -1) {
           ps.write(arr, 0, len);
       }

       is.close();
       ps.close();
###22.11_IO流(两种方式实现键盘录入)(了解)
* A:BufferedReader的readLine方法。
   * BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
* B:Scanner

###22.12_IO流(随机访问流概述和读写数据)(了解)
* A:随机访问流概述
   * RandomAccessFile概述
   * RandomAccessFile类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能。
   * 支持对随机访问文件的读取和写入。

* B:read(),write(),seek()

###22.13_IO流(数据输入输出流)(了解)
* 1.什么是数据输入输出流
   * DataInputStream, DataOutputStream可以按照基本数据类型大小读写数据
   * 例如按Long大小写出一个数字, 写出时该数据占8字节. 读取的时候也可以按照Long类型读取, 一次读取8个字节.
* 2.使用方式
   * DataOutputStream(OutputStream), writeInt(), writeLong()

           DataOutputStream dos = new DataOutputStream(new FileOutputStream("b.txt"));
           dos.writeInt(997);
           dos.writeInt(998);
           dos.writeInt(999);

           dos.close();
   * DataInputStream(InputStream), readInt(), readLong()

           DataInputStream dis = new DataInputStream(new FileInputStream("b.txt"));
           int x = dis.readInt();
           int y = dis.readInt();
           int z = dis.readInt();
           System.out.println(x);
           System.out.println(y);
           System.out.println(z);
           dis.close();
###22.14_IO流(Properties的概述和作为Map集合的使用)(了解)
* A:Properties的概述
   * Properties 类表示了一个持久的属性集。
   * Properties 可保存在流中或从流中加载。
   * 属性列表中每个键及其对应值都是一个字符串。
* B:案例演示
   * Properties作为Map集合的使用

###22.15_IO流(Properties的特殊功能使用)(了解)
* A:Properties的特殊功能
   * public Object setProperty(String key,String value)
   * public String getProperty(String key)
   * public Enumeration<String> stringPropertyNames()
* B:案例演示
   * Properties的特殊功能

###22.16_IO流(Properties的load()和store()功能)(了解)
* A:Properties的load()和store()功能
* B:案例演示
   * Properties的load()和store()功能

###22.17_day22总结
* 把今天的知识点总结一遍。

* B:read(),write(),seek()

###22.17_day22总结
* 把今天的知识点总结一遍。

* B:read(),write(),seek()

###22.17_day22总结
* 把今天的知识点总结一遍。

###24.01_多线程(多线程的引入)(了解)
* 1.什么是线程
   * 线程是程序执行的一条路径, 一个进程中可以包含多条线程
   * 多线程并发执行可以提高程序的效率, 可以同时完成多项工作
* 2.多线程的应用场景
   * 红蜘蛛同时共享屏幕给多个电脑
   * 迅雷开启多条线程一起下载
   * QQ同时和多个人一起视频
   * 服务器同时处理多个客户端请求

###24.02_多线程(多线程并行和并发的区别)(了解)
* 并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
* 并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。
* 比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行。
* 如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。

###24.03_多线程(Java程序运行原理和JVM的启动是多线程的吗)(了解)
* A:Java程序运行原理
   * Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。

* B:JVM的启动是多线程的吗
   * JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。

###24.04_多线程(多线程程序实现的方式1)(掌握)
* 1.继承Thread
   * 定义类继承Thread
   * 重写run方法
   * 把新线程要做的事写在run方法中
   * 创建线程对象
   * 开启新线程, 内部会自动执行run方法
   *

           public class Demo2_Thread {

               /**
               * @param args
               */
               public static void main(String[] args) {
                   MyThread mt = new MyThread();                           //4,创建自定义类的对象
                   mt.start();                                               //5,开启线程

                   for(int i = 0; i < 3000; i++) {
                       System.out.println("bb");
                   }
               }

           }
           class MyThread extends Thread {                                   //1,定义类继承Thread
               public void run() {                                           //2,重写run方法
                   for(int i = 0; i < 3000; i++) {                           //3,将要执行的代码,写在run方法中
                       System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
                   }
               }
           }

###24.05_多线程(多线程程序实现的方式2)(掌握)
* 2.实现Runnable
   * 定义类实现Runnable接口
   * 实现run方法
   * 把新线程要做的事写在run方法中
   * 创建自定义的Runnable的子类对象
   * 创建Thread对象, 传入Runnable
   * 调用start()开启新线程, 内部会自动调用Runnable的run()方法

           public class Demo3_Runnable {
               /**
               * @param args
               */
               public static void main(String[] args) {
                   MyRunnable mr = new MyRunnable();                       //4,创建自定义类对象
                   //Runnable target = new MyRunnable();
                   Thread t = new Thread(mr);                               //5,将其当作参数传递给Thread的构造函数
                   t.start();                                               //6,开启线程

                   for(int i = 0; i < 3000; i++) {
                       System.out.println("bb");
                   }
               }
           }

           class MyRunnable implements Runnable {                           //1,自定义类实现Runnable接口
               @Override
               public void run() {                                           //2,重写run方法
                   for(int i = 0; i < 3000; i++) {                           //3,将要执行的代码,写在run方法中
                       System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
                   }
               }

           }

###24.06_多线程(实现Runnable的原理)(了解)
* 查看源码
   * 1,看Thread类的构造函数,传递了Runnable接口的引用
   * 2,通过init()方法找到传递的target给成员变量的target赋值
   * 3,查看run方法,发现run方法中有判断,如果target不为null就会调用Runnable接口子类对象的run方法

###24.07_多线程(两种方式的区别)(掌握)
* 查看源码的区别:
   * a.继承Thread : 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法
   * b.实现Runnable : 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法

* 继承Thread
   * 好处是:可以直接使用Thread类中的方法,代码简单
   * 弊端是:如果已经有了父类,就不能用这种方法
* 实现Runnable接口
   * 好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
   * 弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂
###24.08_多线程(匿名内部类实现线程的两种方式)(掌握)
* 继承Thread类

       new Thread() {                                                   //1,new 类(){}继承这个类
           public void run() {                                           //2,重写run方法
               for(int i = 0; i < 3000; i++) {                           //3,将要执行的代码,写在run方法中
                   System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
               }
           }
       }.start();
* 实现Runnable接口

       new Thread(new Runnable(){                                       //1,new 接口(){}实现这个接口
           public void run() {                                           //2,重写run方法
               for(int i = 0; i < 3000; i++) {                           //3,将要执行的代码,写在run方法中
                   System.out.println("bb");
               }
           }
       }).start();

###24.09_多线程(获取名字和设置名字)(掌握)
* 1.获取名字
   * 通过getName()方法获取线程对象的名字
* 2.设置名字
   * 通过构造函数可以传入String类型的名字
   *
           new Thread("xxx") {
               public void run() {
                   for(int i = 0; i < 1000; i++) {
                       System.out.println(this.getName() + "....aaaaaaaaaaaaaaaaaaaaaaa");
                   }
               }
           }.start();

           new Thread("yyy") {
               public void run() {
                   for(int i = 0; i < 1000; i++) {
                       System.out.println(this.getName() + "....bb");
                   }
               }
           }.start();
   * 通过setName(String)方法可以设置线程对象的名字
   *
           Thread t1 = new Thread() {
               public void run() {
                   for(int i = 0; i < 1000; i++) {
                       System.out.println(this.getName() + "....aaaaaaaaaaaaaaaaaaaaaaa");
                   }
               }
           };

           Thread t2 = new Thread() {
               public void run() {
                   for(int i = 0; i < 1000; i++) {
                       System.out.println(this.getName() + "....bb");
                   }
               }
           };
           t1.setName("芙蓉姐姐");
           t2.setName("凤姐");

           t1.start();
           t2.start();

###24.10_多线程(获取当前线程的对象)(掌握)
* Thread.currentThread(), 主线程也可以获取
   *
           new Thread(new Runnable() {
               public void run() {
                   for(int i = 0; i < 1000; i++) {
                       System.out.println(Thread.currentThread().getName() + "...aaaaaaaaaaaaaaaaaaaaa");
                   }
               }
           }).start();

           new Thread(new Runnable() {
               public void run() {
                   for(int i = 0; i < 1000; i++) {
                       System.out.println(Thread.currentThread().getName() + "...bb");
                   }
               }
           }).start();
           Thread.currentThread().setName("我是主线程");                   //获取主函数线程的引用,并改名字
           System.out.println(Thread.currentThread().getName());       //获取主函数线程的引用,并获取名字
###24.11_多线程(休眠线程)(掌握)
* Thread.sleep(毫秒,纳秒), 控制当前线程休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000纳秒 1000000000

           new Thread() {
               public void run() {
                   for(int i = 0; i < 10; i++) {
                       System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa");
                       try {
                           Thread.sleep(10);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }
               }
           }.start();

           new Thread() {
               public void run() {
                   for(int i = 0; i < 10; i++) {
                       System.out.println(getName() + "...bb");
                       try {
                           Thread.sleep(10);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }
               }
           }.start();
###24.12_多线程(守护线程)(掌握)
* setDaemon(), 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出
   *
           Thread t1 = new Thread() {
               public void run() {
                   for(int i = 0; i < 50; i++) {
                       System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa");
                       try {
                           Thread.sleep(10);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }
               }
           };

           Thread t2 = new Thread() {
               public void run() {
                   for(int i = 0; i < 5; i++) {
                       System.out.println(getName() + "...bb");
                       try {
                           Thread.sleep(10);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }
               }
           };

           t1.setDaemon(true);                       //将t1设置为守护线程

           t1.start();
           t2.start();
###24.13_多线程(加入线程)(掌握)
* join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
* join(int), 可以等待指定的毫秒之后继续
   *
           final Thread t1 = new Thread() {
               public void run() {
                   for(int i = 0; i < 50; i++) {
                       System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa");
                       try {
                           Thread.sleep(10);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }
               }
           };

           Thread t2 = new Thread() {
               public void run() {
                   for(int i = 0; i < 50; i++) {
                       if(i == 2) {
                           try {
                               //t1.join();                       //插队,加入
                               t1.join(30);                       //加入,有固定的时间,过了固定时间,继续交替执行
                               Thread.sleep(10);
                           } catch (InterruptedException e) {

                               e.printStackTrace();
                           }
                       }
                       System.out.println(getName() + "...bb");

                   }
               }
           };

           t1.start();
           t2.start();
###24.14_多线程(礼让线程)(了解)
* yield让出cpu

###24.15_多线程(设置线程的优先级)(了解)
* setPriority()设置线程的优先级

###24.16_多线程(同步代码块)(掌握)
* 1.什么情况下需要同步
   * 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
   * 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.
* 2.同步代码块
   * 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
   * 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的

           class Printer {
               Demo d = new Demo();
               public static void print1() {
                   synchronized(d){               //锁对象可以是任意对象,但是被锁的代码需要保证是同一把锁,不能用匿名对象
                       System.out.print("黑");
                       System.out.print("马");
                       System.out.print("程");
                       System.out.print("序");
                       System.out.print("员");
                       System.out.print("\r\n");
                   }
               }

               public static void print2() {
                   synchronized(d){
                       System.out.print("传");
                       System.out.print("智");
                       System.out.print("播");
                       System.out.print("客");
                       System.out.print("\r\n");
                   }
               }
           }
###24.17_多线程(同步方法)(掌握)
* 使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的

       class Printer {
           public static void print1() {
               synchronized(Printer.class){               //锁对象可以是任意对象,但是被锁的代码需要保证是同一把锁,不能用匿名对象
                   System.out.print("黑");
                   System.out.print("马");
                   System.out.print("程");
                   System.out.print("序");
                   System.out.print("员");
                   System.out.print("\r\n");
               }
           }
           /*
           * 非静态同步函数的锁是:this
           * 静态的同步函数的锁是:字节码对象
           */
           public static synchronized void print2() {
               System.out.print("传");
               System.out.print("智");
               System.out.print("播");
               System.out.print("客");
               System.out.print("\r\n");
           }
       }

###24.18_多线程(线程安全问题)(掌握)
* 多线程并发操作同一数据时, 就有可能出现线程安全问题
* 使用同步技术可以解决这种问题, 把操作数据的代码进行同步, 不要多个线程一起操作

public class Demo2_Synchronized {

               /**
               * @param args
               * 需求:铁路售票,一共100张,通过四个窗口卖完.
               */
               public static void main(String[] args) {
                   TicketsSeller t1 = new TicketsSeller();
                   TicketsSeller t2 = new TicketsSeller();
                   TicketsSeller t3 = new TicketsSeller();
                   TicketsSeller t4 = new TicketsSeller();

                   t1.setName("窗口1");
                   t2.setName("窗口2");
                   t3.setName("窗口3");
                   t4.setName("窗口4");
                   t1.start();
                   t2.start();
                   t3.start();
                   t4.start();
               }

           }

           class TicketsSeller extends Thread {
               private static int tickets = 100;
               static Object obj = new Object();
               public TicketsSeller() {
                   super();

               }
               public TicketsSeller(String name) {
                   super(name);
               }
               public void run() {
                   while(true) {
                       synchronized(obj) {
                           if(tickets <= 0)
                               break;
                           try {
                               Thread.sleep(10);//线程1睡,线程2睡,线程3睡,线程4睡
                           } catch (InterruptedException e) {

                               e.printStackTrace();
                           }
                           System.out.println(getName() + "...这是第" + tickets-- + "号票");
                       }
                   }
               }
           }

###24.19_多线程(火车站卖票的例子用实现Runnable接口)(掌握)

###24.20_多线程(死锁)(了解)
* 多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁
   * 尽量不要嵌套使用

           private static String s1 = "筷子左";
           private static String s2 = "筷子右";
           public static void main(String[] args) {
               new Thread() {
                   public void run() {
                       while(true) {
                           synchronized(s1) {
                               System.out.println(getName() + "...拿到" + s1 + "等待" + s2);
                               synchronized(s2) {
                                   System.out.println(getName() + "...拿到" + s2 + "开吃");
                               }
                           }
                       }
                   }
               }.start();

               new Thread() {
                   public void run() {
                       while(true) {
                           synchronized(s2) {
                               System.out.println(getName() + "...拿到" + s2 + "等待" + s1);
                               synchronized(s1) {
                                   System.out.println(getName() + "...拿到" + s1 + "开吃");
                               }
                           }
                       }
                   }
               }.start();
           }

###24.21_多线程(以前的线程安全的类回顾)(掌握)
* A:回顾以前说过的线程安全问题
   * 看源码：Vector,StringBuffer,Hashtable,Collections.synchroinzed(xxx)
   * Vector是线程安全的,ArrayList是线程不安全的
   * StringBuffer是线程安全的,StringBuilder是线程不安全的
   * Hashtable是线程安全的,HashMap是线程不安全的
###24.22_多线程(总结)

###25.01_多线程(单例设计模式)(掌握)
* 单例设计模式：保证类在内存中只有一个对象。

* 如何保证类在内存中只有一个对象呢？
   * (1)控制类的创建，不让其他类来创建本类的对象。private
   * (2)在本类中定义一个本类的对象。Singleton s;
   * (3)提供公共的访问方式。 public static Singleton getInstance(){return s}
* 单例写法两种：
   * (1)饿汉式开发用这种方式。
   *
           //饿汉式
           class Singleton {
               //1,私有构造函数
               private Singleton(){}
               //2,创建本类对象
               private static Singleton s = new Singleton();
               //3,对外提供公共的访问方法
               public static Singleton getInstance() {
                   return s;
               }

               public static void print() {
                   System.out.println("11111111111");
               }
           }
   * (2)懒汉式面试写这种方式。多线程的问题？
   *
           //懒汉式,单例的延迟加载模式
           class Singleton {
               //1,私有构造函数
               private Singleton(){}
               //2,声明一个本类的引用
               private static Singleton s;
               //3,对外提供公共的访问方法
               public static Singleton getInstance() {
                   if(s == null)
                       //线程1,线程2
                       s = new Singleton();
                   return s;
               }

               public static void print() {
                   System.out.println("11111111111");
               }
           }
   * (3)第三种格式
   *
           class Singleton {
               private Singleton() {}

               public static final Singleton s = new Singleton();//final是最终的意思,被final修饰的变量不可以被更改
           }
###25.02_多线程(Runtime类)
* Runtime类是一个单例类
   *
           Runtime r = Runtime.getRuntime();
           //r.exec("shutdown -s -t 300");       //300秒后关机
           r.exec("shutdown -a");               //取消关机

###25.03_多线程(Timer)(掌握)
* Timer类:计时器

           public class Demo5_Timer {
               /**
               * @param args
               * 计时器
               * @throws InterruptedException
               */
               public static void main(String[] args) throws InterruptedException {
                   Timer t = new Timer();
                   t.schedule(new MyTimerTask(), new Date(114,9,15,10,54,20),3000);

                   while(true) {
                       System.out.println(new Date());
                       Thread.sleep(1000);
                   }
               }
           }
           class MyTimerTask extends TimerTask {
               @Override
               public void run() {
                   System.out.println("起床背英语单词");
               }

           }

###25.04_多线程(两个线程间的通信)(掌握)
* 1.什么时候需要通信
   * 多个线程并发执行时, 在默认情况下CPU是随机切换线程的
   * 如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印
* 2.怎么通信
   * 如果希望线程等待, 就调用wait()
   * 如果希望唤醒等待的线程, 就调用notify();
   * 这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用

###25.05_多线程(三个或三个以上间的线程通信)
* 多个线程通信的问题
   * notify()方法是随机唤醒一个线程
   * notifyAll()方法是唤醒所有线程
   * JDK5之前无法唤醒指定的一个线程
   * 如果多个线程之间通信, 需要使用notifyAll()通知所有线程, 用while来反复判断条件
###25.06_多线程(JDK1.5的新特性互斥锁)(掌握)
* 1.同步
   * 使用ReentrantLock类的lock()和unlock()方法进行同步
* 2.通信
   * 使用ReentrantLock类的newCondition()方法可以获取Condition对象
   * 需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法
   * 不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了

###25.07_多线程(线程组的概述和使用)(了解)
* A:线程组概述
   * Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。
   * 默认情况下，所有的线程都属于主线程组。
       * public final ThreadGroup getThreadGroup()//通过线程对象获取他所属于的组
       * public final String getName()//通过线程组对象获取他组的名字
   * 我们也可以给线程设置分组
       * 1,ThreadGroup(String name) 创建线程组对象并给其赋值名字
       * 2,创建线程对象
       * 3,Thread(ThreadGroup?group, Runnable?target, String?name)
       * 4,设置整组的优先级或者守护线程
   * B:案例演示
       * 线程组的使用,默认是主线程组
*
       MyRunnable mr = new MyRunnable();
       Thread t1 = new Thread(mr, "张三");
       Thread t2 = new Thread(mr, "李四");
       //获取线程组
       // 线程类里面的方法：public final ThreadGroup getThreadGroup()
       ThreadGroup tg1 = t1.getThreadGroup();
       ThreadGroup tg2 = t2.getThreadGroup();
       // 线程组里面的方法：public final String getName()
       String name1 = tg1.getName();
       String name2 = tg2.getName();
       System.out.println(name1);
       System.out.println(name2);
       // 通过结果我们知道了：线程默认情况下属于main线程组
       // 通过下面的测试，你应该能够看到，默任情况下，所有的线程都属于同一个组
       System.out.println(Thread.currentThread().getThreadGroup().getName());

   * 自己设定线程组
*
       // ThreadGroup(String name)
       ThreadGroup tg = new ThreadGroup("这是一个新的组");

       MyRunnable mr = new MyRunnable();
       // Thread(ThreadGroup group, Runnable target, String name)
       Thread t1 = new Thread(tg, mr, "张三");
       Thread t2 = new Thread(tg, mr, "李四");

       System.out.println(t1.getThreadGroup().getName());
       System.out.println(t2.getThreadGroup().getName());

       //通过组名称设置后台线程，表示该组的线程都是后台线程
       tg.setDaemon(true);
###25.08_多线程(线程的五种状态)(掌握)
* 看图说话
* 新建,就绪,运行,阻塞,死亡

###25.09_多线程(线程池的概述和使用)(了解)
* A:线程池概述
   * 程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池
* B:内置线程池的使用概述
   * JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
       * public static ExecutorService newFixedThreadPool(int nThreads)
       * public static ExecutorService newSingleThreadExecutor()
       * 这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
       * Future<?> submit(Runnable task)
       * <T> Future<T> submit(Callable<T> task)
   * 使用步骤：
       * 创建线程池对象
       * 创建Runnable实例
       * 提交Runnable实例
       * 关闭线程池
   * C:案例演示
       * 提交的是Runnable
*
       // public static ExecutorService newFixedThreadPool(int nThreads)
       ExecutorService pool = Executors.newFixedThreadPool(2);

       // 可以执行Runnable对象或者Callable对象代表的线程
       pool.submit(new MyRunnable());
       pool.submit(new MyRunnable());

       //结束线程池
       pool.shutdown();

###25.10_多线程(多线程程序实现的方式3)(了解)
* 提交的是Callable

*
// 创建线程池对象
ExecutorService pool = Executors.newFixedThreadPool(2);

       // 可以执行Runnable对象或者Callable对象代表的线程
       Future<Integer> f1 = pool.submit(new MyCallable(100));
       Future<Integer> f2 = pool.submit(new MyCallable(200));

       // V get()
       Integer i1 = f1.get();
       Integer i2 = f2.get();

System.out.println(i1);
System.out.println(i2);

// 结束
pool.shutdown();

public class MyCallable implements Callable<Integer> {

           private int number;

           public MyCallable(int number) {
               this.number = number;
           }

           @Override
           public Integer call() throws Exception {
               int sum = 0;
               for (int x = 1; x <= number; x++) {
                   sum += x;
               }
               return sum;
           }

       }
* 多线程程序实现的方式3的好处和弊端
   * 好处：
       * 可以有返回值
       * 可以抛出异常

   * 弊端：
       * 代码比较复杂，所以一般不用

###25.11_设计模式(简单工厂模式概述和使用)(了解)
* A:简单工厂模式概述
   * 又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例
* B:优点
   * 客户端不需要在负责对象的创建，从而明确了各个类的职责
* C:缺点
   * 这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护
* D:案例演示
   * 动物抽象类：public abstract Animal { public abstract void eat(); }
   * 具体狗类：public class Dog extends Animal {}
   * 具体猫类：public class Cat extends Animal {}
   * 开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。
*
       public class AnimalFactory {
           private AnimalFactory(){}

           //public static Dog createDog() {return new Dog();}
           //public static Cat createCat() {return new Cat();}

           //改进
           public static Animal createAnimal(String animalName) {
               if(“dog”.equals(animalName)) {}
               else if(“cat”.equals(animale)) {

               }else {
                   return null;
               }
           }
       }
###25.12_设计模式(工厂方法模式的概述和使用)(了解)
* A:工厂方法模式概述
   * 工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。
* B:优点
   * 客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性
* C:缺点
   * 需要额外的编写代码，增加了工作量
* D:案例演示
*
       动物抽象类：public abstract Animal { public abstract void eat(); }
       工厂接口：public interface Factory {public abstract Animal createAnimal();}
       具体狗类：public class Dog extends Animal {}
       具体猫类：public class Cat extends Animal {}
       开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。发现每次修改代码太麻烦，用工厂方法改进，针对每一个具体的实现提供一个具体工厂。
       狗工厂：public class DogFactory implements Factory {
           public Animal createAnimal() {…}
       }
       猫工厂：public class CatFactory implements Factory {
           public Animal createAnimal() {…}
       }

###25.13_GUI(如何创建一个窗口并显示)
* Graphical User Interface(图形用户接口)。
*
       Frame f = new Frame(“my window”);
       f.setLayout(new FlowLayout());//设置布局管理器
       f.setSize(500,400);//设置窗体大小
       f.setLocation(300,200);//设置窗体出现在屏幕的位置
       f.setIconImage(Toolkit.getDefaultToolkit().createImage("qq.png"));
       f.setVisible(true);

###25.14_GUI(布局管理器)
* FlowLayout（流式布局管理器）
   * 从左到右的顺序排列。
   * Panel默认的布局管理器。
* BorderLayout（边界布局管理器）
   * 东，南，西，北，中
   * Frame默认的布局管理器。
* GridLayout（网格布局管理器）
   * 规则的矩阵
* CardLayout（卡片布局管理器）
   * 选项卡
* GridBagLayout（网格包布局管理器）
   * 非规则的矩阵
###25.15_GUI(窗体监听)
   Frame f = new Frame("我的窗体");
   //事件源是窗体,把监听器注册到事件源上
   //事件对象传递给监听器
   f.addWindowListener(new WindowAdapter() {
   public void windowClosing(WindowEvent e) {
   //退出虚拟机,关闭窗口
           System.exit(0);
       }
   });

###25.16_GUI(鼠标监听)
###25.17_GUI(键盘监听和键盘事件)
###25.18_GUI(动作监听)
###25.19_设计模式(适配器设计模式)(掌握)
* a.什么是适配器
   * 在使用监听器的时候, 需要定义一个类事件监听器接口.
   * 通常接口中有多个方法, 而程序中不一定所有的都用到, 但又必须重写, 这很繁琐.
   * 适配器简化了这些操作, 我们定义监听器时只要继承适配器, 然后重写需要的方法即可.
* b.适配器原理
   * 适配器就是一个类, 实现了监听器接口, 所有抽象方法都重写了, 但是方法全是空的.
   * 适配器类需要定义成抽象的,因为创建该类对象,调用空方法是没有意义的
   * 目的就是为了简化程序员的操作, 定义监听器时继承适配器, 只重写需要的方法就可以了.
###25.20_GUI(需要知道的)
* 事件处理
   * 事件: 用户的一个操作
   * 事件源: 被操作的组件
   * 监听器: 一个自定义类的对象, 实现了监听器接口, 包含事件处理方法,把监听器添加在事件源上, 当事件发生的时候虚拟机就会自动调用监听器中的事件处理方法
###25.21_day25总结
   把今天的知识点总结一遍。

day26授课目录：

###26.01_网络编程(网络编程概述)(了解)
* A:计算机网络
* 是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。
* B:网络编程
* 就是用来实现网络互连的不同计算机上运行的程序间可以进行数据交换。

###26.02_网络编程(网络编程三要素之IP概述)(掌握)
* 每个设备在网络中的唯一标识
* 每台网络终端在网络中都有一个独立的地址，我们在网络中传输数据就是使用这个地址。
* ipconfig：查看本机IP192.168.12.42
* ping：测试连接192.168.40.62
* 本地回路地址：127.0.0.1 255.255.255.255是广播地址
* IPv4：4个字节组成，4个0-255。大概42亿，30亿都在北美，亚洲4亿。2011年初已经用尽。
* IPv6：8组，每组4个16进制数。
* 1a2b:0000:aaaa:0000:0000:0000:aabb:1f2f
* 1a2b::aaaa:0000:0000:0000:aabb:1f2f
* 1a2b:0000:aaaa::aabb:1f2f
* 1a2b:0000:aaaa::0000:aabb:1f2f
* 1a2b:0000:aaaa:0000::aabb:1f2f

###26.03_网络编程(网络编程三要素之端口号概述)(掌握)
* 每个程序在设备上的唯一标识
* 每个网络程序都需要绑定一个端口号，传输数据的时候除了确定发到哪台机器上，还要明确发到哪个程序。
* 端口号范围从0-65535
* 编写网络应用就需要绑定一个端口号，尽量使用1024以上的，1024以下的基本上都被系统程序占用了。
* 常用端口
   * mysql: 3306
   * oracle: 1521
   * web: 80
   * tomcat: 8080
   * QQ: 4000
   * feiQ: 2425

###26.04_网络编程(网络编程三要素协议)(掌握)
* 为计算机网络中进行数据交换而建立的规则、标准或约定的集合。
* UDP
* 面向无连接，数据不安全，速度快。不区分客户端与服务端。
* TCP
　　* 面向连接（三次握手），数据安全，速度略低。分为客户端和服务端。
* 三次握手: 客户端先向服务端发起请求, 服务端响应请求, 传输数据

###26.05_网络编程(Socket通信原理图解)(了解)
* A:Socket套接字概述：
   * 网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字。
   * 通信的两端都有Socket。
   * 网络通信其实就是Socket间的通信。
   * 数据在两个Socket间通过IO流传输。
   * Socket在应用程序中创建，通过一种绑定机制与驱动程序建立关系，告诉自己所对应的IP和port。

###26.06_网络编程(UDP传输)(了解)
* 1.发送Send
   * 创建DatagramSocket, 随机端口号
   * 创建DatagramPacket, 指定数据, 长度, 地址, 端口
   * 使用DatagramSocket发送DatagramPacket
   * 关闭DatagramSocket
* 2.接收Receive
   * 创建DatagramSocket, 指定端口号
   * 创建DatagramPacket, 指定数组, 长度
   * 使用DatagramSocket接收DatagramPacket
   * 关闭DatagramSocket
   * 从DatagramPacket中获取数据
* 3.接收方获取ip和端口号
   * String ip = packet.getAddress().getHostAddress();
   * int port = packet.getPort();

###26.07_网络编程(UDP传输优化)
* 接收端Receive
*
       DatagramSocket socket = new DatagramSocket(6666);                       //创建socket相当于创建码头
       DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);       //创建packet相当于创建集装箱

       while(true) {
           socket.receive(packet);                                               //接收货物
           byte[] arr = packet.getData();
           int len = packet.getLength();
           String ip = packet.getAddress().getHostAddress();
           System.out.println(ip + ":" + new String(arr,0,len));
       }
* 发送端Send

       DatagramSocket socket = new DatagramSocket();       //创建socket相当于创建码头
       Scanner sc = new Scanner(System.in);

       while(true) {
           String str = sc.nextLine();
           if("quit".equals(str))
               break;
           DatagramPacket packet =                            //创建packet相当于创建集装箱
                   new DatagramPacket(str.getBytes(), str.getBytes().length, InetAddress.getByName("127.0.0.1"), 6666);
           socket.send(packet);           //发货
       }
       socket.close();
###26.08_网络编程(UDP传输多线程)
* A发送和接收在一个窗口完成

public class Demo3_MoreThread {

           /**
           * @param args
           */
           public static void main(String[] args) {
               new Receive().start();

               new Send().start();
           }

       }

       class Receive extends Thread {
           public void run() {
               try {
                   DatagramSocket socket = new DatagramSocket(6666);                   //创建socket相当于创建码头
                   DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);   //创建packet相当于创建集装箱

                   while(true) {
                       socket.receive(packet);                                               //接收货物
                       byte[] arr = packet.getData();
                       int len = packet.getLength();
                       String ip = packet.getAddress().getHostAddress();
                       System.out.println(ip + ":" + new String(arr,0,len));
                   }
               } catch (IOException e) {

                   e.printStackTrace();
               }
           }
       }

       class Send extends Thread {
           public void run() {
               try {
                   DatagramSocket socket = new DatagramSocket();       //创建socket相当于创建码头
                   Scanner sc = new Scanner(System.in);

                   while(true) {
                       String str = sc.nextLine();
                       if("quit".equals(str))
                           break;
                       DatagramPacket packet =                            //创建packet相当于创建集装箱
                               new DatagramPacket(str.getBytes(), str.getBytes().length, InetAddress.getByName("127.0.0.1"), 6666);
                       socket.send(packet);           //发货
                   }
                   socket.close();
               } catch (IOException e) {

                   e.printStackTrace();
               }
           }
       }

###26.09_网络编程(UDP聊天图形化界面)

###26.10_网络编程(UDP聊天发送功能)


###26.11_网络编程(UDP聊天记录功能)


###26.12_网络编程(UDP聊天清屏功能)

###26.13_网络编程(UDP聊天震动功能)

###26.14_网络编程(UDP聊天快捷键和代码优化)

###26.15_网络编程(UDP聊天生成jar文件)

###26.16_网络编程(TCP协议)(掌握)
* 1.客户端
   * 创建Socket连接服务端(指定ip地址,端口号)通过ip地址找对应的服务器
   * 调用Socket的getInputStream()和getOutputStream()方法获取和服务端相连的IO流
   * 输入流可以读取服务端输出流写出的数据
   * 输出流可以写出数据到服务端的输入流
* 2.服务端
   * 创建ServerSocket(需要指定端口号)
   * 调用ServerSocket的accept()方法接收一个客户端请求，得到一个Socket
   * 调用Socket的getInputStream()和getOutputStream()方法获取和客户端相连的IO流
   * 输入流可以读取客户端输出流写出的数据
   * 输出流可以写出数据到客户端的输入流

###26.17_网络编程(TCP协议代码优化)
* 客户端

       Socket socket = new Socket("127.0.0.1", 9999);       //创建Socket指定ip地址和端口号
       InputStream is = socket.getInputStream();           //获取输入流
       OutputStream os = socket.getOutputStream();           //获取输出流
       BufferedReader br = new BufferedReader(new InputStreamReader(is));
       PrintStream ps = new PrintStream(os);

       System.out.println(br.readLine());
       ps.println("我想报名就业班");
       System.out.println(br.readLine());
       ps.println("爷不学了");
       socket.close();
* 服务端

       ServerSocket server = new ServerSocket(9999);   //创建服务器
       Socket socket = server.accept();               //接受客户端的请求
       InputStream is = socket.getInputStream();       //获取输入流
       OutputStream os = socket.getOutputStream();       //获取输出流

       BufferedReader br = new BufferedReader(new InputStreamReader(is));
       PrintStream ps = new PrintStream(os);

       ps.println("欢迎咨询传智播客");
       System.out.println(br.readLine());
       ps.println("报满了,请报下一期吧");
       System.out.println(br.readLine());
       server.close();
       socket.close();

###26.18_网络编程(服务端是多线程的)(掌握)
   ServerSocket server = new ServerSocket(9999);   //创建服务器
       while(true) {
           final Socket socket = server.accept();               //接受客户端的请求
           new Thread() {
               public void run() {
                   try {
                       BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                       PrintStream ps = new PrintStream(socket.getOutputStream());
                       ps.println("欢迎咨询传智播客");
                       System.out.println(br.readLine());
                       ps.println("报满了,请报下一期吧");
                       System.out.println(br.readLine());
                       socket.close();
                   } catch (IOException e) {
                       e.printStackTrace();
                   }
               }
           }.start();
       }
   }

###26.19_网络编程(练习)
* 客户端向服务器写字符串(键盘录入),服务器(多线程)将字符串反转后写回,客户端再次读取到是反转后的字符串
###26.20_网络编程(练习)
* 客户端向服务器上传文件
###26.21_day26总结
* 把今天的知识点总结一遍。

day27授课目录：

###27.01_反射(类的加载概述和加载时机)
* A:类的加载概述
   * 当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。
   * 加载
       * 就是指将class文件读入内存，并为之创建一个Class对象。任何类被使用时系统都会建立一个Class对象。
   * 连接
       * 验证是否有正确的内部结构，并和其他类协调一致
       * 准备负责为类的静态成员分配内存，并设置默认初始化值
       * 解析将类的二进制数据中的符号引用替换为直接引用

   * 初始化就是我们以前讲过的初始化步骤
* B:加载时机
   * 创建类的实例
   * 访问类的静态变量，或者为静态变量赋值
   * 调用类的静态方法
   * 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
   * 初始化某个类的子类
   * 直接使用java.exe命令来运行某个主类

###27.02_反射(类加载器的概述和分类)
* A:类加载器的概述
   * 负责将.class文件加载到内存中，并为之生成对应的Class对象。虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行。
* B:类加载器的分类
   * Bootstrap ClassLoader 根类加载器
   * Extension ClassLoader 扩展类加载器
   * Sysetm ClassLoader 系统类加载器
* C:类加载器的作用
   * Bootstrap ClassLoader 根类加载器
       * 也被称为引导类加载器，负责Java核心类的加载
       * 比如System,String等。在JDK中JRE的lib目录下rt.jar文件中
   * Extension ClassLoader 扩展类加载器
       * 负责JRE的扩展目录中jar包的加载。
       * 在JDK中JRE的lib目录下ext目录
   * Sysetm ClassLoader 系统类加载器
       * 负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径

###27.03_反射(反射概述)
* A:反射概述
   * JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；
   * 对于任意一个对象，都能够调用它的任意一个方法和属性；
   * 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
   * 要想解剖一个类,必须先要获取到该类的字节码文件对象。
   * 而解剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象。

* B:三种方式
   * a:Object类的getClass()方法,判断两个对象是否是同一个字节码文件
   * b:静态属性class,锁对象
   * c:Class类中静态方法forName(),读取配置文件
* C:案例演示
   * 获取class文件对象的三种方式

###27.04_反射(Class.forName()读取配置文件举例)
* 榨汁机(Juicer)榨汁的案例
* 分别有水果(Fruit)苹果(Apple)香蕉(Banana)桔子(Orange)榨汁(squeeze)

public class Demo2_Reflect {

           /**
           * 榨汁机(Juicer)榨汁的案例
           * 分别有水果(Fruit)苹果(Apple)香蕉(Banana)桔子(Orange)榨汁(squeeze)
           * @throws Exception
           */
           public static void main(String[] args) throws Exception {
               /*Juicer j = new Juicer();
               //j.run(new Apple());
               j.run(new Orange());*/
               BufferedReader br = new BufferedReader(new FileReader("config.properties"));   //创建输入流对象,关联配置文件
               Class<?> clazz = Class.forName(br.readLine());                                   //读取配置文件一行内容,获取该类的字节码对象
               Fruit f = (Fruit) clazz.newInstance();                                           //通过字节码对象创建实例对象
               Juicer j = new Juicer();
               j.run(f);
           }

       }
       interface Fruit {
           public void squeeze();
       }

       class Apple implements Fruit {
           public void squeeze() {
               System.out.println("榨出一杯苹果汁儿");
           }
       }

       class Orange implements Fruit {
           public void squeeze() {
               System.out.println("榨出一杯桔子汁儿");
           }
       }

       class Juicer {
           public void run(Fruit f) {
               f.squeeze();
           }

       }
###27.05_反射(通过反射获取带参构造方法并使用)
* Constructor
   * Class类的newInstance()方法是使用该类无参的构造函数创建对象, 如果一个类没有无参的构造函数, 就不能这样创建了,可以调用Class类的getConstructor(String.class,int.class)方法获取一个指定的构造函数然后再调用Constructor类的newInstance("张三",20)方法创建对象

###27.06_反射(通过反射获取成员变量并使用)
* Field
* Class.getField(String)方法可以获取类中的指定字段(可见的), 如果是私有的可以用getDeclaedField("name")方法获取,通过set(obj, "李四")方法可以设置指定对象上该字段的值, 如果是私有的需要先调用setAccessible(true)设置访问权限,用获取的指定的字段调用get(obj)可以获取指定对象中该字段的值

###27.07_反射(通过反射获取方法并使用)
* Method
* Class.getMethod(String, Class...) 和 Class.getDeclaredMethod(String, Class...)方法可以获取类中的指定方法,调用invoke(Object, Object...)可以调用该方法,Class.getMethod("eat") invoke(obj) Class.getMethod("eat",int.class) invoke(obj,10)

###27.08_反射(通过反射越过泛型检查)
* A:案例演示
* ArrayList<Integer>的一个对象，在这个集合中添加一个字符串数据，如何实现呢？

###27.09_反射(通过反射写一个通用的设置某个对象的某个属性为指定的值)
* A:案例演示
* public void setProperty(Object obj, String propertyName, Object value){}，此方法可将obj对象中名为propertyName的属性的值设置为value。

###27.10_反射(练习)
* 已知一个类，定义如下：
   * package cn.itcast.heima;
   *        public class DemoClass {
               public void run() {
                   System.out.println("welcome to heima!");
               }
           }
   * (1) 写一个Properties格式的配置文件，配置类的完整名称。
   * (2) 写一个程序，读取这个Properties配置文件，获得类的完整名称并加载这个类，用反射的方式运行run方法。

###27.11_反射(动态代理的概述和实现)
* A:动态代理概述
   * 代理：本来应该自己做的事情，请了别人来做，被请的人就是代理对象。
   * 举例：春节回家买票让人代买
   * 动态代理：在程序运行过程中产生的这个对象,而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理

   * 在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。我们有更强大的代理cglib，Proxy类中的方法创建动态代理类对象
   * public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
   * 最终会调用InvocationHandler的方法
   * InvocationHandler Object invoke(Object proxy,Method method,Object[] args)

###27.12_设计模式(模版(Template)设计模式概述和使用)
* A:模版设计模式概述
   * 模版方法模式就是定义一个算法的骨架，而将具体的算法延迟到子类中来实现
* B:优点和缺点
   * a:优点
       * 使用模版方法模式，在定义算法骨架的同时，可以很灵活的实现具体的算法，满足用户灵活多变的需求
   * b:缺点
       * 如果算法骨架有修改的话，则需要修改抽象类
1,装饰
2,单例
3,简单工厂
4,工厂方法
5,适配器
6,模版

###27.13_JDK5新特性(自己实现枚举类)
* A:枚举概述
   * 是指将变量的值一一列出来,变量的值只限于列举出来的值的范围内。举例：一周只有7天，一年只有12个月等。
* B:回想单例设计模式：单例类是一个类只有一个实例
   * 那么多例类就是一个类有多个实例，但不是无限个数的实例，而是有限个数的实例。这才能是枚举类。
* C:案例演示
   * 自己实现枚举类
1,自动拆装箱
2,泛型
3,可变参数
4,静态导入
5,增强for循环
6,互斥锁
7,枚举

###27.14_JDK5新特性(通过enum实现枚举类)
* A:案例演示
   * 通过enum实现枚举类

###27.15_JDK5新特性(枚举的注意事项)
* A:案例演示
   * 定义枚举类要用关键字enum
   * 所有枚举类都是Enum的子类
   * 枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略。建议不要省略
   * 枚举类可以有构造器，但必须是private的，它默认的也是private的。
   * 枚举类也可以有抽象方法，但是枚举项必须重写该方法
   * 枚举在switch语句中的使用

###27.16_JDK5新特性(枚举类的常见方法)
* A:枚举类的常见方法
   * int ordinal()
   * int compareTo(E o)
   * String name()
   * String toString()
   * <T> T valueOf(Class<T> type,String name)
   * values()
   * 此方法虽然在JDK文档中查找不到，但每个枚举类都具有该方法，它遍历枚举类的所有枚举值非常方便
* B:案例演示
   * 枚举类的常见方法

###27.17_JDK7新特性(JDK7的六个新特性回顾和讲解)
* A:二进制字面量
* B:数字字面量可以出现下划线
* C:switch 语句可以用字符串
* D:泛型简化,菱形泛型
* E:异常的多个catch合并,每个异常用或|
* F:try-with-resources 语句

###27.18_JDK8新特性(JDK8的新特性)
* 接口中可以定义有方法体的方法,如果是非静态,必须用default修饰
* 如果是静态的就不用了

       class Test {
           public void run() {
               final int x = 10;
               class Inner {
                   public void method() {
                       System.out.println(x);
                   }
               }

               Inner i = new Inner();
               i.method();
           }

       }

局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
###27.19_day27总结
* 把今天的知识点总结一遍。