day13-网络编程

今日目标

  • 网络编程
  • TCP通信
  • 单例设计模式
  • 多例设计模式
  • 工厂设计模式

1 网络编程

1.1 软件架构

  • C/S结构 ：全称为Client/Server结构，是指客户端和服务器结构。常见程序有ＱＱ、迅雷等软件
  • B/S结构 ：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有谷歌、火狐等
  • 两种架构各有优势，但是都离不开网络的支持。网络编程 , 就是在一定的协议下，实现两台计算机的通信的程序
  • day12-网络编程 - 图1

1.2 什么是网络编程

  • 在网络通信协议下，不同计算机上运行的程序，可以进行数据传输

1.3 网络编程三要素

  • IP地址 : 设备在网络中的地址，是唯一的标识。
  • 端口 : 设备在网络中的地址，是唯一的标识。
  • 数据在网络中传输的规则，常见的协议有UDP协议和TCP协议。

1.4 IP地址

  • IP：全称”互联网协议地址”，也称IP地址。是分配给上网设备的数字标签。常见的IP分类为：ipv4和ipv6
    简单来说 : 就是设备在网络中的唯一标识 , 想要连接哪一台电脑 , 就找到此电脑在网络中的ip地址

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

  • 常用命令：

    • ipconfig：查看本机IP地址
    • IP地址：检查网络是否连通

  • 特殊IP地址：

    • 127.0.0.1：是回送地址也称本地回环地址，可以代表本机的IP地址，一般用来测试使用

  • 为了方便我们对IP地址的获取和操作，Java提供了一个类InetAddress 供我们使用
    InetAddress：此类表示Internet协议（IP）地址

    • | static InetAddress getByName(String host) | 在给定主机名的情况下确定主机的 IP 地址 | | —- | —- | | String getHostName() | 获取此 IP 地址的主机名 | | String getHostAddress() | 返回 IP 地址字符串（以文本表现形式）。 |

1.5 端口

  • 端口：应用程序在设备中唯一的标识。

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

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

1.6 通信协议

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

  • UDP协议

    • 用户数据报协议(User Datagram Protocol)
    • UDP是面向无连接通信协议。
    • 速度快，有大小限制一次最多发送64K，数据不安全，易丢失数据。

  • TCP协议

    • 传输控制协议 (Transmission Control Protocol)
    • TCP协议是面向连接的通信协议。
    • 速度慢，没有大小限制，数据安全

2 TCP通信

2.1 TCP发送数据

  1. package com.itheima.tcp_demo.demo1;
  3. import java.io.IOException;
  4. import java.io.OutputStream;
  5. import java.net.Socket;
  7. /*
  8.     客户端 :
  10.     发送数据的步骤
  11.         1 创建客户端的Socket对象 : Socket(String host, int port) 与指定服务端连接
  12.             参数说明：
  13.             host 表示服务器端的主机名，也可以是服务器端的IP地址，只不过是String类型的
  14.             port 表示服务器端的端口
  16.         2 通获Socket对象取网络中的输出流，写数据
  17.             OutputStream getOutputStream()
  19.         3 释放资源
  20.             void close()
  22.  */
  23. public class ClientDemo {
  24.     public static void main(String[] args) throws IOException {
  25.         // 创建客户端的Socket对象(Socket) 与指定服务端连接
  26.         Socket socket = new Socket("127.0.0.1", 10010);
  28.         // 通获Socket对象取网络中的输出流，写数据
  29.         OutputStream os = socket.getOutputStream();
  30.         os.write("hello".getBytes());
  32.         // while(true){}
  34.         // 释放资源
  35.         os.close();
  36.         socket.close();
  37.     }
  38. }

2.2 TCP接收数据

  1. package com.itheima.tcp_demo.demo1;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.net.ServerSocket;
  6. import java.net.Socket;
  8. /*
  9.      服务端接收数据 :
  11.     1 创建服务器端的Socket对象 : ServerSocket类
  12.         ServerSocket(int port)  : 构造方法需要绑定一个端口号 , port就是端口号
  14.     2 监听客户端连接,并接受连接，返回一个Socket对象
  15.         Socket accept() : 该方法会一直阻塞直到建立连接
  17.     3 获取网络中的输入流，用来读取客户端发送过来的数据
  18.         InputStream getInputStream()
  20.     4 释放资源 : 服务端一般不会关闭
  21.         void close()
  22.  */
  23. public class ServerDemo {
  24.     public static void main(String[] args) throws IOException {
  25. //        1 创建服务器端的Socket对象 : ServerSocket类
  26. //        ServerSocket(int port)  : 构造方法需要绑定一个端口号 , port就是端口号
  27.         ServerSocket serverSocket = new ServerSocket(10010);
  29. //        2 监听客户端连接,并接受连接，返回一个Socket对象
  30. //        Socket accept() : 该方法会一直阻塞直到建立连接
  31.         Socket socket = serverSocket.accept();
  32. //
  33. //        3 获取网络中的输入流，用来读取客户端发送过来的数据
  34. //        InputStream getInputStream()
  35.         InputStream is = socket.getInputStream();
  36.         int by;
  37.         System.out.println("read方法执行前");
  38.         while ((by = is.read()) != -1) {
  39.             System.out.print((char) by);
  40.         }
  41.         System.out.println("read方法执行后");
  42.     }
  43. }

2.3 TCP通信原理分析

day12-网络编程 - 图2

2.4 TCP三次握手

day12-网络编程 - 图3

2.5 TCP练习1

  1. package com.itheima.tcp_demo.test1;
  3. import java.io.*;
  4. import java.net.Socket;
  6. /*
  7.     客户端 :
  9.     发送数据的步骤
  10.         1 创建客户端的Socket对象 : Socket(String host, int port) 与指定服务端连接
  11.             参数说明：
  12.             host 表示服务器端的主机名，也可以是服务器端的IP地址，只不过是String类型的
  13.             port 表示服务器端的端口
  15.         2 通获Socket对象取网络中的输出流，写数据
  16.             OutputStream getOutputStream()
  18.         3 释放资源
  19.             void close()
  21.  */
  22. public class ClientDemo {
  23.     public static void main(String[] args) throws IOException {
  24.         // 创建客户端的Socket对象(Socket) 与指定服务端连接
  25.         Socket socket = new Socket("127.0.0.1", 10010);
  27.         // 通获Socket对象取网络中的输出流，写数据
  28.         OutputStream os = socket.getOutputStream();
  29.         os.write("hello".getBytes());
  30.         // 像服务端写入结束标记
  31.         socket.shutdownOutput();
  33.         BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  34.         String line = br.readLine();
  35.         System.out.println(line);
  37.         // 释放资源
  38.         br.close();
  39.         os.close();
  40.         socket.close();
  41.     }
  42. }
  1. package com.itheima.tcp_demo.test1;
  3. import java.io.*;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  7. /*
  8.      服务端接收数据 :
  10.     1 创建服务器端的Socket对象 : ServerSocket类
  11.         ServerSocket(int port)  : 构造方法需要绑定一个端口号 , port就是端口号
  13.     2 监听客户端连接,并接受连接，返回一个Socket对象
  14.         Socket accept() : 该方法会一直阻塞直到建立连接
  16.     3 获取网络中的输入流，用来读取客户端发送过来的数据
  17.         InputStream getInputStream()
  19.     4 释放资源 : 服务端一般不会关闭
  20.         void close()
  21.  */
  22. public class ServerDemo {
  23.     public static void main(String[] args) throws IOException {
  24. //        1 创建服务器端的Socket对象 : ServerSocket类
  25. //        ServerSocket(int port)  : 构造方法需要绑定一个端口号 , port就是端口号
  26.         ServerSocket serverSocket = new ServerSocket(10010);
  28. //        2 监听客户端连接,并接受连接，返回一个Socket对象
  29. //        Socket accept() : 该方法会一直阻塞直到建立连接
  30.         Socket socket = serverSocket.accept();
  31. //
  32. //        3 获取网络中的输入流，用来读取客户端发送过来的数据
  33. //        InputStream getInputStream()
  34.         InputStream is = socket.getInputStream();
  35.         int by;
  37.         while ((by = is.read()) != -1) {
  38.             System.out.print((char) by);
  39.         }
  41.         BufferedWriter bos = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
  42.         bos.write("你谁啊");
  44.         bos.close();
  45.         is.close();
  46.         socket.close();
  47.         serverSocket.close();
  48.     }
  49. }

2.6 TCP练习2

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

2.7 TCP练习3

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

3 单例设计模式

学习目标

  • 能够使用单例设计模式设计代码

内容讲解

  • 正常情况下一个类可以创建多个对象
  1. public static void main(String[] args) {
  2.     // 正常情况下一个类可以创建多个对象
  3.     Person p1 = new Person();
  4.     Person p2 = new Person();
  5.     Person p3 = new Person();
  6. }
  • 如果说有时一个对象就能搞定的事情 , 非要创建多个对象 , 浪费内存!!!

3.1 单例设计模式的作用

  • 单例模式，是一种常用的软件设计模式。通过单例模式可以保证项目中，应用该模式的这个类只有一个实例。
    即一个类只有一个对象实例。

  • 好处 ：可以节省内存，共享数据

3.2 单例设计模式实现步骤

  1. 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
  2. 在该类内部产生一个唯一的实例化对象，并且将其封装为private static 类型的成员变量。
  3. 定义一个静态方法返回这个唯一对象。

3.3 单例设计模式的类型

根据创建对象的时机单例设计模式又分为以下两种:

  1. 饿汉单例设计模式

  2. 懒汉单例设计模式

=============================================================================================

3.4 饿汉单例设计模式

  • 饿汉单例设计模式就是使用类的时候已经将对象创建完毕
    不管以后会不会使用到该实例化对象，先创建了再说。很着急的样子，故被称为“饿汉模式”。

  • 代码如下：

    1. public class Singleton {
    2.   // 1.将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
    3.   private Singleton() {}
    5.   // 2.在该类内部产生一个唯一的实例化对象，并且将其封装为private static 类型的成员变量。
    6.   private static final Singleton instance = new Singleton();
    8.   // 3.定义一个静态方法返回这个唯一对象。
    9.   public static Singleton getInstance() {
    10.       return instance;
    11.   }
    12. }

  • 需求：定义一个皇帝类，要求对象只能存在一个。

    1. package com.itheima.singledesign;
    2. /*
    3.   需求 : 使用单例模式(饿汉式) , 要求此类只能有一个对象
    5.   步骤 :
    6.       1. 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
    7.       2. 在该类内部产生一个唯一的实例化对象，并且将其封装为private static 类型的成员变量。
    8.       3. 定义一个静态方法返回这个唯一对象。
    9. */
    10. public class King {
    11.   // 1. 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
    12.   private King(){}
    13.   // 2. 在该类内部产生一个唯一的实例化对象，并且将其封装为private static 类型的成员变量。
    14.   private static final King KING = new King();
    15.   // 3. 定义一个静态方法返回这个唯一对象。
    16.   public static King getInstance(){
    17.       return KING;
    18.   }
    19. }

=============================================================================================

3.5 懒汉单例设计模式

  • 懒汉单例设计模式就是调用getInstance()方法时对象才被创建
    也就是说先不急着实例化出对象，等要用的时候才实例化出对象。不着急，故称为“懒汉模式”。
    代码如下：

public class Singleton {

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

}

  2. - ##### 注意 ：
  4. - 懒汉单例设计模式在多线程环境下可能会实例化出多个对象，不能保证单例的状态，所以加上关键字：synchronized，保证其同步安全。
  8. - 需求：使用懒汉单例 ，改写皇帝类的单例模式
  10. ```java
  11. package com.itheima.singledesign;
  13. /*
  14.     需求 : 使用单例模式(懒汉式) , 要求此类只能有一个对象
  16.     步骤 :
  17.         1. 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
  18.         2. 在该类内部定义一个private static修饰的成员变量 . 此变量不需要赋值
  19.         3. 定义一个静态方法返回这个唯一对象。 此方法需要加上synchronized关键字保证在多线程中也只有一个实例对象
  20.  */
  21. public class King2 {
  22.     // 1. 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
  23.     private King2() {
  24.     }
  26.     // 2. 在该类内部定义一个private static修饰的成员变量 . 此变量不需要赋值
  27.     private static King2 king;// null
  29.     // 3. 定义一个静态方法返回这个唯一对象。 此方法需要加上synchronized关键字保证在多线程中也只有一个实例对象
  30.     public static synchronized King2 getInstance() {
  31.         if (king == null) {
  32.             king = new King2();
  33.         }
  34.         return king;
  35.     }
  36. }

知识小结

  • 单例模式可以保证系统中一个类只有一个对象实例。

  • 实现单例模式的步骤：

    • 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
    • 在该类内部产生一个唯一的实例化对象，并且将其封装为private static类型的成员变量。
    • 定义一个静态方法返回这个唯一对象。

4 多例设计模式

学习目标

  • 能使用多例设计模式设计代码

内容讲解

4.1 多例设计模式的作用

  • 多例模式，是一种常用的设计模式之一。通过多例模式可以保证项目中，应用该模式的类有固定数量的实例。
    多例类要自我创建并管理自己的实例，还要向外界提供获取本类实例的方法。

  • 使用场景：线程池

    1. 线程池 = Executors.newFixedThreadPool(3);

4.2.实现步骤

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

4.3.实现代码

  • 某一个学科有固定3位老师，年级中上该课程的老师就是这三位老师其中一位
    要求使用多例模式 ,每次获取的都是这三位老师其中一位
  1. package com.itheima.moreinstance_demo;
  3. import com.itheima.homework.work.Student;
  5. import java.util.ArrayList;
  6. import java.util.Random;
  8. /*
  9.     需求  : 某一个学科有固定3位老师，年级中上该课程的老师就是这三位老师其中一位
  10.             要求使用多例模式 ,每次获取的都是这三位老师其中一位
  12.     实现步骤 :
  13.         1.创建一个类,  将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
  14.         2.在类中定义该类被创建对象的总数量
  15.         3.在类中定义存放类实例的list集合
  16.         4.在类中提供静态代码块,在静态代码块中创建类的实例
  17.         5.提供获取类实例的静态方法
  18.  */
  19. public class Teacher {
  20.     // 1.创建一个类,  将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
  21.     private Teacher() {
  22.     }
  24.     // 2.在类中定义该类被创建对象的总数量
  25.     private static int count = 3;
  27.     // 3.在类中定义存放类实例的list集合
  28.     private static ArrayList<Teacher> list = new ArrayList<>();
  30.     // 4.在类中提供静态代码块,在静态代码块中创建类的实例
  31.     static {
  32.         for (int i = 0; i < count; i++) {
  33.             list.add(new Teacher());
  34.         }
  35.     }
  37.     // 5.提供获取类实例的静态方法
  38.     public static Teacher getInstance() {
  39.         int index = new Random().nextInt(count);// [0,3)
  40.         return list.get(index);
  41.     }
  43. }

4.4 小结

  • 多例模式作用 : 可以保证项目中一个类有固定个数的实例, 在实现需求的基础上, 能够提高实例的复用性.
    实现多例模式的步骤 ：

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

5 工厂设计模式

学习目标

  • 能够使用工厂设计模式设计代码

内容讲解

5.1 概述

  • 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。之前我们创建类对象时, 都是使用 new 对象的形式创建, 除new 对象方式以外, 工厂模式也可以创建对象.

5.2 作用

  • 解决类与类之间的耦合问题

5.3案例实践

  • 需求：定义汽车工厂类，生产各种品牌的车

  • 实现步骤

    • 编写一个Car接口, 提供run方法
    • 编写一个Falali类实现Car接口,重写run方法
    • 编写一个Benchi类实现Car接口,重写run方法
    • 提供一个CarFactory(汽车工厂),用于生产汽车对象
    • 定义CarFactoryTest测试汽车工厂

实现代码

  1. package com.itheima.factorydesign_demo;
  3. /*
  4.   - 需求：定义汽车工厂类，生产各种品牌的车
  6.   - 实现步骤
  7.       - 编写一个Car接口, 提供run方法
  8.       - 编写一个Falali类实现Car接口,重写run方法
  9.       - 编写一个Benchi类实现Car接口
  10.       - 提供一个CarFactory(汽车工厂),用于生产汽车对象
  11.       - 定义CarFactoryTest测试汽车工厂
  12.  */
  13. public class CarTest {
  14.     public static void main(String[] args) {
  15.         Car car = CarFactory.getInstance(CarBrand.FALALI);
  16.         car.run();
  17.     }
  18. }
  20. // 定义车的品牌枚举
  21. enum CarBrand {
  22.     // 枚举项
  23.     FALALI, BENCHI, DAZHONG, BAOMA;
  24. }
  26. // 生产汽车对象的工厂
  27. class CarFactory {
  28.     // 私有构造
  29.     private CarFactory() {
  30.     }
  32.     public static Car getInstance(CarBrand brand) {
  33.         switch (brand) {
  34.             case FALALI:
  35.                 return new Falali(1);
  36.             case BENCHI:
  37.                 return new Benchi();
  38.             default:
  39.                 return null;
  40.         }
  41.     }
  42. }
  44. //// 生产汽车对象的工厂
  45. //class CarFactory {
  46. //    // 私有构造
  47. //    private CarFactory() {
  48. //    }
  49. //
  50. //    public static Car getInstance(String brand) {
  51. //        switch (brand) {
  52. //            case "Falali":
  53. //                return new Falali(1);
  54. //            case "Benchi":
  55. //                return new Benchi();
  56. //            default:
  57. //                return null;
  58. //        }
  59. //    }
  60. //}
  62. // 编写一个Car接口, 提供run方法
  63. interface Car {
  64.     public abstract void run();
  65. }
  67. class Falali implements Car {
  68.     public Falali(int num) {
  69.     }
  71.     @Override
  72.     public void run() {
  73.         System.out.println("法拉利破百需要3秒!");
  74.     }
  75. }
  77. class Benchi implements Car {
  78.     @Override
  79.     public void run() {
  80.         System.out.println("奔驰破百需要5秒!");
  81.     }
  82. }

知识小结

  • 工厂模式的存在可以改变创建对象的方式,降低类与类之间的耦合问题.