今日学习目标

  • 网络编程
  • TCP通信
  • Junit单元测试
  • 单列设计模式
  • 多列设计模式

  • 工厂设计模式

    1 网络编程

    1.1 网络编程三要素

  • IP地址 : 设备在网络中的地址，是唯一的标识。

  • 端口 : 设备在网络中的地址，是唯一的标识。

  • 数据在网络中传输的规则，常见的协议有UDP协议和TCP协议。

    1.2 IP地址

  • P地址常见分类 : ipv4和ipv6

  • 常用命令：
    • ipconfig：查看本机IP地址
    • IP地址：检查网络是否连通
  • 特殊IP地址：
    • 127.0.0.1：是回送地址也称本地回环地址，可以代表本机的IP地址，一般用来测试使用
  • InetAddress类: | 构造方法 | 作用 | | —- | —- | | static InetAddress getByName(String host) | 在给定主机名的情况下确定主机的 IP 地址 | | String getHostName() | 获取此 IP 地址的主机名 | | String getHostAddress() | 返回 IP 地址字符串（以文本表现形式） |

1.3 端口

  • 端口：应用程序在设备中唯一的标识。
  • 端口号:用两个字节表示的整数，它的取值范围是0~65535,其中0~1023之间的端口号用于一些知名的网络服务或者应用,我们自己使用1024以上的端口号就可以了

  • 注意：一个端口号只能被一个应用程序使用

    1.4 通信协议

  • 协议：计算机网络中，连接和通信的规则被称为网络通信协议

  • UDP协议:
    • UDP是面向无连接通信协议.
    • 速度快，有大小限制一次最多发送64K，数据不安全，易丢失数据。

  • TCP协议:

    • TCP协议是面向连接的通信协议

    • 速度慢，没有大小限制，数据安全

      2 TCP通信

      2.1 TCP发送数据

      ```java import java.io.IOException; import java.io.OutputStream; import java.net.Socket; /* 客户端 : 发送数据的步骤 1 创建客户端的Socket对象 : Socket(String host, int port) 与指定服务端连接

      1.    参数说明：
      2.    host 表示服务器端的主机名，也可以是服务器端的IP地址，只不过是String类型的
      3.    port 表示服务器端的端口

      2 通获Socket对象取网络中的输出流，写数据

      1.    OutputStream getOutputStream()

      3 释放资源

      1.    void close()

    */ public class ClientDemo { public static void main(String[] args) throws IOException {

    1.   // 创建客户端的Socket对象(Socket) 与指定服务端连接
    2.   Socket socket = new Socket("127.0.0.1", 10010);
    4.   // 通获Socket对象取网络中的输出流，写数据
    5.   OutputStream os = socket.getOutputStream();
    6.   os.write("hello".getBytes());
    8.   // while(true){}
    10.   // 释放资源
    11.   os.close();
    12.   socket.close();

    } } ```

    2.2 TCP接收数据

    ```java import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket;

/* 服务端接收数据 :

  1. 1 创建服务器端的Socket对象 : ServerSocket类
  2.     ServerSocket(int port)  : 构造方法需要绑定一个端口号 , port就是端口号
  4. 2 监听客户端连接,并接受连接，返回一个Socket对象
  5.     Socket accept() : 该方法会一直阻塞直到建立连接
  7. 3 获取网络中的输入流，用来读取客户端发送过来的数据
  8.     InputStream getInputStream()
  10. 4 释放资源 : 服务端一般不会关闭
  11.     void close()

*/ public class ServerDemo { public static void main(String[] args) throws IOException { // 1 创建服务器端的Socket对象 : ServerSocket类 // ServerSocket(int port) : 构造方法需要绑定一个端口号 , port就是端口号 ServerSocket serverSocket = new ServerSocket(10010);

// 2 监听客户端连接,并接受连接，返回一个Socket对象 // Socket accept() : 该方法会一直阻塞直到建立连接 Socket socket = serverSocket.accept(); // // 3 获取网络中的输入流，用来读取客户端发送过来的数据 // InputStream getInputStream() InputStream is = socket.getInputStream(); int by; System.out.println(“read方法执行前”); while ((by = is.read()) != -1) { System.out.print((char) by); } System.out.println(“read方法执行后”); } }

  1. <a name="NyH7d"></a>
  2. #### 2.3 TCP练习1
  4. - 代码需要敲熟练:
  5. ```java
  6. public class ClientDemo {
  7.     public static void main(String[] args) throws IOException {
  8.         // 创建客户端的Socket对象(Socket) 与指定服务端连接
  9.         Socket socket = new Socket("127.0.0.1", 10010);
  11.         // 通获Socket对象取网络中的输出流，写数据
  12.         OutputStream os = socket.getOutputStream();
  13.         os.write("hello".getBytes());
  14.         // 像服务端写入结束标记
  15.         socket.shutdownOutput();
  17.         BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  18.         String line = br.readLine();
  19.         System.out.println(line);
  21.         // 释放资源
  22.         br.close();
  23.         os.close();
  24.         socket.close();
  25.     }
  26. }
  1. public class ServerDemo {
  2.     public static void main(String[] args) throws IOException {
  3. //        1 创建服务器端的Socket对象 : ServerSocket类
  4. //        ServerSocket(int port)  : 构造方法需要绑定一个端口号 , port就是端口号
  5.         ServerSocket serverSocket = new ServerSocket(10010);
  7. //        2 监听客户端连接,并接受连接，返回一个Socket对象
  8. //        Socket accept() : 该方法会一直阻塞直到建立连接
  9.         Socket socket = serverSocket.accept();
  10. //
  11. //        3 获取网络中的输入流，用来读取客户端发送过来的数据
  12. //        InputStream getInputStream()
  13.         InputStream is = socket.getInputStream();
  14.         int by;
  16.         while ((by = is.read()) != -1) {
  17.             System.out.print((char) by);
  18.         }
  20.         BufferedWriter bos = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
  21.         bos.write("你谁啊");
  23.         bos.close();
  24.         is.close();
  25.         socket.close();
  26.         serverSocket.close();
  27.     }
  28. }

2.4 TCP练习2

  1. public class ClientDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         // 创建客户端Socket对象
  4.         Socket socket = new Socket("127.0.0.1", 10086);
  6.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\传智播客\\安装包\\好看的图片\\liqin.jpg"));
  8.         BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
  10.         int by;
  11.         while ((by = bis.read()) != -1) {// 从本地中读一个字节
  12.             bos.write(by);// 往服务器写一个字节
  13.             bos.flush();
  14.         }
  15.         // 写结束标记
  16.         socket.shutdownOutput();
  18.         // 把网络中的字节输入流 , 封装成高效的字符输入流
  19.         BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  20. //        String line;
  21. //        while ((line = br.readLine()) != null) {
  22. //            System.out.println(line);
  23. //        }
  24.         String msg = br.readLine();// 读到换行才叫读到一行, 所以必须写服务器必须写newLine
  25.         System.out.println(msg);
  27.         // 释放资源
  28.         bis.close();
  29.         socket.close();
  30.     }
  31. }
  1. public class ServerDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         // 创建服务端的连接对象
  4.         ServerSocket serverSocket = new ServerSocket(10086);
  5.         Socket socket = null;
  6.         BufferedInputStream bis = null;
  7.         BufferedWriter socketBw = null;
  9.         while (true) {
  10.             // 获取Socket对象
  11.             socket = serverSocket.accept();
  13.             // 获取网络中的字节输入流  在封装成高效的字节输入流对象
  14.             bis = new BufferedInputStream(socket.getInputStream());
  16.             // 创建本地的字节输出流 , 封装成高效的字节输出流
  17.             BufferedOutputStream bw = new BufferedOutputStream(new FileOutputStream("day13_demo\\图片\\a.jpg"));
  19.             int by;
  20.             while ((by = bis.read()) != -1) {
  21.                 bw.write(by);
  22.                 bw.flush();
  23.             }
  25.             //关闭本地流
  26.             bw.close();
  28.             // 获取网络中的字节输出流 , 封装成高效的字符输出流
  29.             socketBw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
  30.             socketBw.write("谢谢你");
  31.             socketBw.newLine();// 必须有换行 , 因为readLine读到换行结束
  32.             socketBw.flush();
  33.         }
  35.         // 释放资源
  36. //        socketBw.close();
  37. //        bis.close();
  38. //        socket.close();
  39. //        serverSocket.close();
  40.     }
  41. }

2.5 TCP练习3

  1. public class ClientDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         // 创建客户端Socket对象
  4.         Socket socket = new Socket("127.0.0.1", 10086);
  6.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\传智播客\\安装包\\好看的图片\\liqin.jpg"));
  8.         BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
  10.         int by;
  11.         while ((by = bis.read()) != -1) {// 从本地中读一个字节
  12.             bos.write(by);// 往服务器写一个字节
  13.             bos.flush();
  14.         }
  15.         // 写结束标记
  16.         socket.shutdownOutput();
  18.         // 把网络中的字节输入流 , 封装成高效的字符输入流
  19.         BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  20. //        String line;
  21. //        while ((line = br.readLine()) != null) {
  22. //            System.out.println(line);
  23. //        }
  24.         String msg = br.readLine();// 读到换行才叫读到一行, 所以必须写服务器必须写newLine
  25.         System.out.println(msg);
  27.         // 释放资源
  28.         bis.close();
  29.         socket.close();
  30.     }
  31. }
  1. public class ServerDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         // 创建服务端的连接对象
  4.         ServerSocket serverSocket = new ServerSocket(10086);
  6.         ExecutorService executorService = Executors.newFixedThreadPool(10);
  7.         while (true) {
  8.             // 获取Socket对象
  9.             Socket socket = serverSocket.accept();
  10.             executorService.submit(new ServerThread(socket));
  11.         }
  13.         // 释放资源
  14. //        socketBw.close();
  15. //        bis.close();
  16. //        socket.close();
  17. //        serverSocket.close();
  18.     }
  19. }
  1. public class ServerThread implements Runnable {
  2.     Socket socket = null;
  3.     BufferedOutputStream bw = null;
  5.     public ServerThread(Socket socket) {
  6.         this.socket = socket;
  7.     }
  9.     @Override
  10.     public void run() {
  12.         try {
  13.             // 获取网络中的字节输入流  在封装成高效的字节输入流对象
  14.             BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
  16.             // 创建本地的字节输出流 , 封装成高效的字节输出流
  17.             bw = new BufferedOutputStream(new FileOutputStream("day13_demo\\图片\\" + UUID.randomUUID() + ".jpg"));
  19.             int by;
  20.             while ((by = bis.read()) != -1) {
  21.                 bw.write(by);
  22.                 bw.flush();
  23.             }
  24.             // 获取网络中的字节输出流 , 封装成高效的字符输出流
  25.             BufferedWriter socketBw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
  26.             socketBw.write("谢谢你");
  27.             socketBw.newLine();// 必须有换行 , 因为readLine读到换行结束
  28.             socketBw.flush();
  29.         } catch (IOException e) {
  30.             e.printStackTrace();
  31.         } finally {
  32.             //关闭本地流
  33.             try {
  34.                 bw.close();
  35.             } catch (IOException e) {
  36.                 e.printStackTrace();
  37.             }
  38.         }
  39.     }
  40. }

3 Junit单元测试

3.1 Junit4单元测试概述

  • 单元测试就是编写测试代码，可以准确、快速地保证程序的正确性，Junit是Java单元测试的框架

  • JUnit4可以通过注解的方式来标记方法 , 让方法存某种意义 ，常见的注解有：

    • @BeforeClass 全局只会执行一次，而且是第一个运行（标记的方法需要是一个静态无参无返回值方法）
    • @Before 在测试方法运行之前运行（非静态无参无返回值方法）
    • @Test 测试方法（此方法必须是非静态无参无返回值方法）, 主要用于测试的方法
    • @After 在测试方法运行之后运行（非静态无参无返回值方法）
    • @AfterClass 全局只会执行一次，而且是最后一个运行（标记的方法需要是一个静态无参无返回值方法）
    • @Ignore 忽略此方法

      3.2 Junit的基本使用

  • 生成Junit测试框架

    • 右键选择 Generate（Alt+Insert）/ go to 选项 , 选择Test…

  • 可以在注释后面给个毫秒值单位

    • @Test(timeout = 1000)

      3.3 断言

  • 预先判断某个条件一定成立，如果条件不成立，则直接报错。

  • 使用 :
  • 格式:Assert.assertEquals(期望值,实际值) ```java //第一个参数表示期望值 //第二个参数表示实际值 // 如果实际值和期望值相同，说明结果正确就测试通过,如果不相同，说明结果是错误的,就会报错 Assert.assertEquals( 期望值, 实际值); Assert.assertEquals(“异常原因”， 期望值, 实际值);

//例如： int result = add(100,200); Assert.assertEquals(300, result); 

  1. <a name="Ox6YD"></a>
  2. ### 4 单例设计模式
  3. <a name="gxcvi"></a>
  4. #### 4.1 单例设计模式的作用
  6. - 一个类只有一个对象实例。
  7. - 可以节省内存，共享数据
  8. <a name="NdFyq"></a>
  9. #### 4.2 单例设计模式的类型
  11. - 饿汉单例设计模式
  12. - 懒汉单例设计模式
  13. <a name="pRpky"></a>
  14. #### 4.3 实现单例模式的步骤
  16. - 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
  17. - 在该类内部产生一个唯一的实例化对象，并且将其封装为private static类型的成员变量。
  18. - 定义一个静态方法返回这个唯一对象。
  19. <a name="mU5fA"></a>
  20. #### 4.3 饿汉单例设计模式
  22. - 饿汉单例设计模式就是使用类的时候已经将对象创建完毕
  23. ```java
  24. public class Singleton {
  25.     // 1.将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
  26.     private Singleton() {}
  28.     // 2.在该类内部产生一个唯一的实例化对象，并且将其封装为private static 类型的成员变量。
  29.     private static final Singleton instance = new Singleton();
  31.     // 3.定义一个静态方法返回这个唯一对象。
  32.     public static Singleton getInstance() {
  33.         return instance;
  34.     }
  35. }

4.4 懒汉单例设计模式

  • 懒汉单例设计模式就是调用getInstance()方法时对象才被创建

    1. public class Singleton {
    3.    // 1.将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
    4.   private Singleton() {}
    6.   // 2.在该类内部产生一个唯一的实例化对象，并且将其封装为private static类型的成员变量。
    7.   private static Singleton instance; // 0x001
    9.   // 3.定义一个静态方法返回这个唯一对象。要用的时候才例化出对象
    11.   public static synchronized Singleton getInstance() {
    12.       if(instance == null) {
    13.           instance = new Singleton();
    14.       }
    15.       return instance;
    16.   }
    17. }

  • 注意事项:

    • 懒汉单例设计模式在多线程情况下可能会实例化出多个对象,不能保证单列状态,所以加上关键字synchronized,保证同步安全

      5 多例设计模式

      5.1 多例设计模式的作用

  • 通过多例模式可以保证项目中，应用该模式的类有固定数量的实例。

  • 多例类要自我创建并管理自己的实例，还要向外界提供获取本类实例的方法。
  • 使用场景：线程池:
    • Executors.newFixedThreadPool(3);

      5.2.实现步骤

  1. 创建一个类, 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象
  2. 在类中定义该类被创建对象的总数量
  3. 在类中定义存放类实例的list集合
  4. 在类中提供静态代码块,在静态代码块中创建类的实例

  5. 提供获取类实例的静态方法

    5.3.实现代码

    ```java /* 需求 : 某一个学科有固定3位老师，年级中上该课程的老师就是这三位老师其中一位

    1.      要求使用多例模式 ,每次获取的都是这三位老师其中一位

    实现步骤 :

    1.  1.创建一个类,  将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
    2.  2.在类中定义该类被创建对象的总数量
    3.  3.在类中定义存放类实例的list集合
    4.  4.在类中提供静态代码块,在静态代码块中创建类的实例
    5.  5.提供获取类实例的静态方法

    */ public class Teacher { // 1.创建一个类, 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。 private Teacher() { }

    // 2.在类中定义该类被创建对象的总数量 private static int maxCount = 3;

    // 3.在类中定义存放类实例的list集合 private static ArrayList list = new ArrayList<>();// {teacher1 , teacher2 , teacher3}

    // 4.在类中提供静态代码块,在静态代码块中创建类的实例 static {

    1.  for (int i = 0; i < maxCount; i++) {
    2.      list.add(new Teacher());
    3.  }

    }

    // 5.提供获取类实例的静态方法 public static Teacher getInstance() {

    1.  int index = new Random().nextInt(3);// [0 - 2]
    2.  return list.get(index);

    }

}

  1. <a name="IMfWZ"></a>
  2. ### 6 工厂设计模式
  3. <a name="SxkEX"></a>
  4. #### 6.1 概述
  6. - 工厂模式:它提供了一种创建对象的最佳方式。之前我们创建类对象时, 都是使用 new 对象的形式创建, 除new 对象方式以外, 工厂模式也可以创建对象.
  7. <a name="jmx9L"></a>
  8. #### 6.2 作用
  10. - 解决类与类之间的耦合问题,防止因为对象的改变而影响到其他调用这个对象的类
  11. <a name="YIh3f"></a>
  12. #### 6.3案例实践
  13. ```java
  14. /*
  15.   - 需求：定义汽车工厂类，生产各种品牌的车
  17.   - 实现步骤
  18.       - 编写一个Car接口, 提供run方法
  19.       - 编写一个Falali类实现Car接口,重写run方法
  20.       - 编写一个Benchi类实现Car接口
  21.       =============================================
  22.       - 提供一个CarFactory(汽车工厂),用于生产汽车对象
  23.       - 定义CarFactoryTest测试汽车工厂
  24.  */
  25. public class CarTest {
  26.     public static void main(String[] args) {
  27.         Car benchi = CarFactory.getInstance(Brand.BENCHI);
  28.         System.out.println(benchi);
  29.     }
  30. }
  32. // 汽车接口
  33. interface Car {
  34.     public abstract void run();
  35. }
  37. // 编写一个Falali类实现Car接口,重写run方法
  38. class Falali implements Car {
  39.     public Falali() {
  40.     }
  42.     @Override
  43.     public void run() {
  44.         System.out.println("法拉利破百需要3秒...");
  45.     }
  46. }
  48. // 编写一个Benchi类实现Car接口
  49. class Benchi implements Car {
  50.     @Override
  51.     public void run() {
  52.         System.out.println("奔驰破百需要5秒...");
  53.     }
  54. }
  56. // 汽车品牌枚举
  57. enum Brand {
  58.     BENCHI, FALALI, BAOMA, BINLI, AODI;
  59. }
  61. // 提供一个CarFactory(汽车工厂),用于生产汽车对象
  62. class CarFactory {
  63.     private CarFactory() {
  64.     }
  66.     public static Car getInstance(Brand brand) {
  67.         switch (brand) {
  68.             case FALALI:
  69.                 return new Falali();
  70.             case BENCHI:
  71.                 return new Benchi();
  72.             default:
  73.                 return null;
  74.         }
  75.     }