• Java筑基32-IO流02-节点流&处理流

    目录

    节点流和处理流

    1.处理流设计模式

    2. IO流设计模式-装饰器模式模拟

    3. BufferedReader & BufferedWriter

    4. Buffered拷贝（字符文件）

    5. Buffered字节处理流

    6.Buffered拷贝（字节文件）

    7.对象处理流

    8.标准输入输出流

    转换流

    1）乱码问题引出转换流

    2）InputStreamReader&OutputStreamWriter

    打印流PrintStream&PrintWriter

    1）PrintStream

    2）PrintWriter

    Properties类

    1）配置文件引出Properties

    2）Properties类

    案例

    1）目录文件操作

    2）读取文件操作

    节点流和处理流

    1.处理流设计模式

    2. IO流设计模式-装饰器模式模拟

    1. /**
    2. * @author：飞扬
    3. * @公众hao：程序员飞扬
    4. * @description: IO流设计模式-装饰器模式模拟
    5. */
    6. public abstract class Reader_ {
    7.     
    8.     //抽象类，提供两个空方法
    9.     public void readFile(){}
    10.     
    11.     public void readString(){}
    12. }

    1. /**
    2.  * @author：飞扬
    3.  * @公众hao：程序员飞扬
    4.  * @description: IO流设计模式-装饰器模式模拟
    5.  */
    6. public class FileReader_ extends Reader_{
    7.  
    8.     //模拟节点流，读取文件
    9.     @Override
    10.     public void readFile(){
    11.         System.out.println("读取文件。。。");
    12.     }
    13. }
    1. /**
    2.  * @author：飞扬
    3.  * @公众hao：程序员飞扬
    4.  * @description: IO流设计模式-装饰器模式模拟
    5.  */
    6. public class StringReader_ extends Reader_{
    7.  
    8.     //模拟节点流，处理字符串
    9.     @Override
    10.     public void readString(){
    11.         System.out.println("读取字符串。。。");
    12.     }
    13. }
    1. /**
    2.  * @author：飞扬
    3.  * @公众hao：程序员飞扬
    4.  * @description: IO流设计模式-装饰器模式模拟
    5.  *
    6.  * 模拟处理流/包装流
    7.  */
    8. public class BufferedReader_ extends Reader_{
    9.  
    10.     private Reader_ reader_;
    11.  
    12.     public BufferedReader_(Reader_ reader_) {
    13.         this.reader_ = reader_;
    14.     }
    15.  
    16.     //原始方法
    17.     public void readFile(){
    18.         reader_.readFile();
    19.     }
    20.  
    21.     public void readString(){
    22.         reader_.readFile();
    23.     }
    24.  
    25.     //扩展方法，多次读取文件（也可以加缓冲byte[]等）
    26.     public void readFile(int num){
    27.         for (int i = 0; i < num; i++) {
    28.             reader_.readFile();
    29.         }
    30.     }
    31.  
    32.     //扩展方法，多次读取字符串(也可以批量读取字符串)
    33.     public void readString(int num){
    34.         for (int i = 0; i < num; i++) {
    35.             reader_.readString();
    36.         }
    37.     }
    38. }
    1. /**
    2.  * @author：飞扬
    3.  * @公众hao：程序员飞扬
    4.  * @description: 装饰器模式模拟测试
    5.  */
    6. public class Test_ {
    7.     public static void main(String[] args) {
    8.         BufferedReader_ bufferedReader_ = new BufferedReader_(new FileReader_());
    9.         bufferedReader_.readFile(); //调原始方法
    10.         System.out.println("----");
    11.         bufferedReader_.readFile(3); //调扩展方法
    12.  
    13.         BufferedReader_ bufferedReader_1 = new BufferedReader_(new StringReader_());
    14.         bufferedReader_1.readString(); //调原始方法
    15.         System.out.println("----");
    16.         bufferedReader_1.readString(5); //调扩展方法
    17.  
    18.     }
    19. }

    重点理解体会修饰器模式设计思想的巧妙。

    3. BufferedReader & BufferedWriter

    案例：使用BufferedReader读取文本文件

    1. import java.io.BufferedReader;
    2. import java.io.FileReader;
    3. import java.io.IOException;
    4.  
    5. /**
    6.  * @author：飞扬
    7.  * @公众hao：程序员飞扬
    8.  * @description:
    9.  */
    10. public class BufferedReaderTest {
    11.     public static void main(String[] args) throws IOException {
    12.         String filePath = "d:\\hello.txt";
    13.  
    14.         //创建BufferedReader
    15.         BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
    16.  
    17.         //按行读取，效率高
    18.         String line;
    19.  
    20.         //bufferedReader.readLine()是按行读取文件
    21.         //当返回null时表示读取完毕
    22.         while((line = bufferedReader.readLine()) !=null){
    23.             System.out.println(line);
    24.         }
    25.  
    26.         //关闭流，这里注意，只需要关闭最外层流，因为底层会自动关闭节点流（追源码）
    27.         bufferedReader.close();
    28.     }
    29. }

    BufferedWriter写文件

    1. import java.io.BufferedWriter;
    2. import java.io.FileWriter;
    3. import java.io.IOException;
    4.  
    5. /**
    6.  * @author：飞扬
    7.  * @公众hao：程序员飞扬
    8.  * @description:
    9.  */
    10. public class BufferedWriterTest {
    11.     public static void main(String[] args) throws IOException {
    12.         String filePath = "d:\\栓克油.txt";
    13.         //BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath)); //会覆盖
    14.         BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath,true)); //追加模式
    15.  
    16.         bufferedWriter.write("hello,");
    17.         bufferedWriter.newLine();
    18.         bufferedWriter.write("飞扬");
    19.  
    20.         bufferedWriter.close();
    21.     }
    22. }

    4. Buffered拷贝（字符文件）

    1. import java.io.BufferedReader;
    2. import java.io.BufferedWriter;
    3. import java.io.FileReader;
    4. import java.io.FileWriter;
    5. import java.io.IOException;
    6.  
    7. /**
    8.  * @author：飞扬
    9.  * @公众hao：程序员飞扬
    10.  * @description:
    11.  */
    12. public class BufferedCopy {
    13.  
    14.     public static void main(String[] args) {
    15.  
    16.         String srcFilePath = "d:\\hello.txt";
    17.         String destFilePath = "d:\\bufferedCopy.txt";
    18.  
    19.         BufferedReader bufferedReader = null;
    20.         BufferedWriter bufferedWriter = null;
    21.  
    22.         try{
    23.             bufferedReader = new BufferedReader(new FileReader(srcFilePath));
    24.             bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));
    25.  
    26.             String line;
    27.             while((line = bufferedReader.readLine()) != null){
    28.                 bufferedWriter.write(line);
    29.                 bufferedWriter.newLine();
    30.             }
    31.         }catch (IOException e){
    32.             e.printStackTrace();
    33.         }finally {
    34.             try {
    35.                 if(bufferedWriter != null){
    36.                     bufferedWriter.close();
    37.                 }
    38.                 if(bufferedWriter != null){
    39.                     bufferedWriter.close();
    40.                 }
    41.             } catch (IOException e) {
    42.                 e.printStackTrace();
    43.             }
    44.  
    45.         }
    46.  
    47.     }
    48. }

    5. Buffered字节处理流

    6.Buffered拷贝（字节文件）

    1. import java.io.BufferedInputStream;
    2. import java.io.BufferedOutputStream;
    3. import java.io.FileInputStream;
    4. import java.io.FileOutputStream;
    5. import java.io.IOException;
    6.  
    7. /**
    8.  * @author：飞扬
    9.  * @公众hao：程序员飞扬
    10.  * @description: 字节流拷贝（拷贝二进制文件，如图片，音视频等）
    11.  *
    12.  * 思考：字节流可以操作二进制文件，可以操作文本文件吗，当然可以。。。
    13.  */
    14. public class BufferedCopy2 {
    15.     public static void main(String[] args) {
    16.  
    17.         BufferedInputStream bufferedInputStream = null;
    18.         BufferedOutputStream bufferedOutputStream = null;
    19.         try{
    20.             FileInputStream fis = new FileInputStream("d:\\aaa.jpg");
    21.             FileOutputStream fos = new FileOutputStream("d:\\aaa2.jpg");
    22.             bufferedInputStream = new BufferedInputStream(fis);
    23.             bufferedOutputStream = new BufferedOutputStream(fos);
    24.             
    25.             byte[] b = new byte[1024];
    26.  
    27.             int len;
    28.             while((len=bufferedInputStream.read(b)) != -1){
    29.                 bufferedOutputStream.write(b,0,len);
    30.             }
    31.             System.out.println("拷贝完成~~");
    32.         }catch (IOException e){
    33.             e.printStackTrace();
    34.         }finally {
    35.             try {
    36.                 if(bufferedOutputStream !=null) {
    37.                     bufferedOutputStream.close();
    38.                 }
    39.                 if(bufferedInputStream != null){
    40.                     bufferedInputStream.close();
    41.                 }
    42.             } catch (IOException e) {
    43.                 e.printStackTrace();
    44.             }
    45.         }
    46.  
    47.     }
    48. }

    7.对象处理流

    先回忆下什么是序列化和反序列化

    1. import java.io.FileOutputStream;
    2. import java.io.IOException;
    3. import java.io.ObjectOutputStream;
    4. import java.io.Serializable;
    5.  
    6. /**
    7.  * @author：飞扬
    8.  * @公众hao：程序员飞扬
    9.  * @description: 序列化演示
    10.  */
    11. public class ObjectOutputStream_ {
    12.     public static void main(String[] args) {
    13.         String path = "d:\\data.dat";
    14.  
    15.         try {
    16.             ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(path));
    17.             oos.writeInt(100);  //将整型值100写入流中
    18.             oos.writeBoolean(true);
    19.             oos.writeChar('a');
    20.             oos.writeDouble(9.5);
    21.             oos.writeObject(new Dog("旺财",3));
    22.  
    23.             oos.close();
    24.             System.out.println("序列化输写文件完毕");
    25.         } catch (IOException e) {
    26.             e.printStackTrace();
    27.         }
    28.     }
    29.  
    30. }
    31.  
    32. class Dog implements Serializable {
    33.     private String name;
    34.     private Integer age;
    35.  
    36.     public Dog(String name, int age) {
    37.         this.name = name;
    38.         this.age = age;
    39.     }
    40.  
    41.     @Override
    42.     public String toString() {
    43.         return "Dog{" +
    44.                 "name='" + name + '\'' +
    45.                 ", age=" + age +
    46.                 '}';
    47.     }
    48. }

    1. import java.io.FileInputStream;
    2. import java.io.IOException;
    3. import java.io.ObjectInputStream;
    4.  
    5. /**
    6.  * @author：飞扬
    7.  * @公众hao：程序员飞扬
    8.  * @description:
    9.  */
    10. public class ObjectInputStream_ {
    11.     public static void main(String[] args) {
    12.         String path = "d:\\data.dat";
    13.  
    14.         try {
    15.             //创建流对象
    16.             ObjectInputStream ois = new ObjectInputStream(new FileInputStream(path));
    17.             
    18.             //读取，注意事项
    19.             System.out.println(ois.readInt());
    20.             System.out.println(ois.readBoolean());
    21.             System.out.println(ois.readChar());
    22.             System.out.println(ois.readDouble());
    23.             System.out.println(ois.readObject());
    24.             
    25.             //关闭
    26.             ois.close();
    27.  
    28.         } catch (IOException | ClassNotFoundException e) {
    29.             e.printStackTrace();
    30.         }
    31.  
    32.     }
    33. }

    对象处理流注意事项：

    8.标准输入输出流

    1. /**
    2.  * @author：飞扬
    3.  * @公众hao：程序员飞扬
    4.  * @description:标准输入输出流
    5.  */
    6. public class InputAndOutput {
    7.     public static void main(String[] args) {
    8.  
    9.         //System类的 public final static InputStream in = null;
    10.         //System.in     编译类型    InputStream
    11.         //System.in     运行类型    BufferedInputStream
    12.         //表示的是标准输入  键盘
    13.         System.out.println(System.in.getClass());
    14.  
    15.  
    16.         //System类的 public final static PrintStream out = null;
    17.         //System.out    编译类型    PrintStream
    18.         //System.out    运行类型    PrintStream
    19.         //表示的是标准输出  显示器
    20.         System.out.println(System.out.getClass());
    21.  
    22.         Scanner scanner = new Scanner(System.in);
    23.         System.out.println("输入内容：");
    24.         String next = scanner.next();
    25.         System.out.println("next=" + next);
    26.  
    27.     }
    28. }

    class java.io.BufferedInputStream

    class java.io.PrintStream

    输入内容：

    你好，上海

    next=你好，上海

    转换流

    1）乱码问题引出转换流

    文件内容和编码如下：

    1. import java.io.BufferedReader;
    2. import java.io.FileReader;
    3. import java.io.IOException;
    4.  
    5. /**
    6.  * @author：飞扬
    7.  * @公众hao：程序员飞扬
    8.  * @description: 乱码问题引出转换流
    9.  */
    10. public class CodeQuestion {
    11.     public static void main(String[] args) throws IOException {
    12.         String filePath = "d:\\hello.txt";
    13.         BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
    14.         String s = bufferedReader.readLine();
    15.         System.out.println("读取到的内容：" + s);
    16.         bufferedReader.close();
    17.  
    18.     }
    19. }

    运行输出：

    读取到的内容：aaa����

    发现出现了乱码。

    2）InputStreamReader&OutputStreamWriter

    1. /**
    2.  * @author：飞扬
    3.  * @公众hao：程序员飞扬
    4.  * @description: 字节输入流（转换流）
    5.  */
    6. public class InputStreamReader_ {
    7.     public static void main(String[] args) throws IOException {
    8.         String filePath = "d:\\hello.txt";
    9.  
    10.         InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath),"gbk");
    11.         BufferedReader bufferedReader = new BufferedReader(isr);
    12.         String s = bufferedReader.readLine();
    13.         System.out.println("读取内容=" + s);
    14.  
    15.     }
    16. }

    输出：读取内容=aaa飞扬

    不再出现乱码

    1. import java.io.FileOutputStream;
    2. import java.io.IOException;
    3. import java.io.OutputStreamWriter;
    4.  
    5. /**
    6.  * @author：飞扬
    7.  * @公众hao：程序员飞扬
    8.  * @description: 直接输出流（转换流）
    9.  */
    10. public class OutputStreamReader_ {
    11.     public static void main(String[] args) throws IOException {
    12.         String filePath = "d:\\feiyang.txt";
    13.         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath),"gbk");
    14.         osw.write("hello,飞扬");
    15.  
    16.         osw.close();
    17.     }
    18. }

    执行结果，生成指定编码的文件，不会乱码

    打印流PrintStream&PrintWriter

    1）PrintStream

    1. import java.io.IOException;
    2. import java.io.PrintStream;
    3.  
    4. /**
    5.  * @author：飞扬
    6.  * @公众hao：程序员飞扬
    7.  * @description:    打印流
    8.  */
    9. public class PrintStream_ {
    10.     public static void main(String[] args) throws IOException {
    11.         PrintStream out = System.out;
    12.         out.print("hello,tom");
    13.  
    14.         //也可以直接调用write()打印/输出
    15.         out.write("hello,tom".getBytes());
    16.         out.close();
    17.  
    18.         //可以去修改打印输出的位置/设备
    19.         System.setOut(new PrintStream("d:\\f1.txt"));
    20.         System.out.println("hello，峰峰，你可长点心吧");
    21.     }
    22. }

    输出结果：

    2）PrintWriter

    1. /**
    2.  * @author：飞扬
    3.  * @公众hao：程序员飞扬
    4.  * @description: 打印流PrintWriter
    5.  */
    6. public class PrintWriter_ {
    7.     public static void main(String[] args) throws IOException {
    8.         PrintWriter printWriter = new PrintWriter(new FileWriter("d:\\abc.txt"));
    9.         printWriter.print("你好，上海");
    10.         printWriter.close(); //注意，必须关闭流才会写入
    11.     }
    12. }

    输出结果：

    Properties类

    1）配置文件引出Properties

    新增文件：

    1. /**
    2.  * @author：飞扬
    3.  * @公众hao：程序员飞扬
    4.  * @description:
    5.  */
    6. public class Properties01 {
    7.     public static void main(String[] args) throws IOException {
    8.         BufferedReader br = new BufferedReader(new FileReader("src\\mysql.properties"));
    9.         String line = "";
    10.         while((line = br.readLine()) != null){
    11.             String[] s = line.split("=");
    12.             System.out.println(s[0]+"的值为"+s[1]);
    13.         }
    14.     }
    15. }

    打印输出：

    user的值为root

    password的值为123456

    url的值为jdbc:mysql://localhost:3306/testdb

    driver的值为com.mysql.jdbc.Driver

    结论：读写麻烦，不方便

    2）Properties类

    1. import java.io.FileReader;
    2. import java.io.IOException;
    3. import java.util.Properties;
    4.  
    5. /**
    6.  * @author：飞扬
    7.  * @公众hao：程序员飞扬
    8.  * @description:使用Properties类来读取文件
    9.  */
    10. public class Properties02 {
    11.     public static void main(String[] args) throws IOException {
    12.         //创建Properties对象
    13.         Properties properties = new Properties();
    14.  
    15.         //加载指定配置文件
    16.         properties.load(new FileReader("src\\mysql.properties"));
    17.  
    18.         //把k-v显示控制台
    19.         properties.list(System.out);    //获取列表集合
    20.  
    21.         //根据key获取对应的值
    22.         String url = properties.getProperty("url"); //获取指定属性
    23.         System.out.println(url);
    24.  
    25.     }
    26. }

    打印输出：
    -- listing properties --

    user=root

    password=123456

    url=jdbc:mysql://localhost:3306/testdb

    driver=com.mysql.jdbc.Driver

    jdbc:mysql://localhost:3306/testdb

    1. import java.io.FileOutputStream;
    2. import java.io.IOException;
    3. import java.util.Properties;
    4.  
    5. /**
    6.  * @author：飞扬
    7.  * @公众hao：程序员飞扬
    8.  * @description:使用Properties类保存配置文件，修改配置文件
    9.  */
    10. public class Properties03_ {
    11.     public static void main(String[] args) throws IOException {
    12.         Properties properties = new Properties();
    13.         properties.setProperty("charset","utf-8");
    14.         properties.setProperty("user","汤姆");//此处保存的是unicode编码
    15.         properties.setProperty("pwd","666");
    16.  
    17.         properties.setProperty("pwd","888"); //修改属性值（没有该属性就新增，有就修改）
    18.  
    19.         properties.store(new FileOutputStream("src\\mysql03.properties"),null);//保存
    20.         properties.store(new FileOutputStream("src\\mysql03.properties"),"这是一个注释");//保存（指定注释）
    21.         System.out.println( "保存配置文件成功~");
    22.     }
    23. }

    执行结果：

    案例

    1）目录文件操作

    1. import java.io.BufferedWriter;
    2. import java.io.File;
    3. import java.io.FileWriter;
    4. import java.io.IOException;
    5.  
    6. /**
    7.  * @author：飞扬
    8.  * @公众hao：程序员飞扬
    9.  * @description:
    10.  */
    11. public class Homework01 {
    12.     public static void main(String[] args) throws IOException {
    13.  
    14.         String direPath = "d:\\mytemp";
    15.         File file = new File(direPath);
    16.         if(file.exists()){
    17.             System.out.println("目录已经存在");
    18.         }else{
    19.             boolean mkdir = file.mkdir();
    20.             if(!mkdir){
    21.                 System.out.println("创建" + direPath +"目录失败");
    22.             }else{
    23.                 System.out.println("创建" + direPath +"目录成功");
    24.             }
    25.         }
    26.  
    27.         String filePath = direPath + "\\homework01.txt";
    28.  
    29.         File file1 = new File(filePath);
    30.         if(file1.exists()){
    31.             System.out.println("文件" + filePath + "已存在");
    32.         }else{
    33.             if(file1.createNewFile()){
    34.                 System.out.println("创建" + filePath + "成功");
    35.  
    36.                 BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
    37.                 bufferedWriter.write("我要学java");
    38.                 bufferedWriter.close();
    39.                 System.out.println("文件写入成功");
    40.             }else{
    41.                 System.out.println(filePath + "创建失败");
    42.  
    43.             }
    44.         }
    45.     }
    46.  
    47. }

    运行结果：

    2）读取文件操作

    1. import java.io.BufferedReader;
    2. import java.io.FileReader;
    3. import java.io.IOException;
    4.  
    5. /**
    6.  * @author：飞扬
    7.  * @公众hao：程序员飞扬
    8.  * @description: 读取文件操作
    9.  */
    10. public class Homework02 {
    11.     public static void main(String[] args) {
    12.         String filePath = "D:\\homework02.txt";
    13.         BufferedReader br = null;
    14.         try {
    15.             br = new BufferedReader(new FileReader(filePath));
    16.  
    17.             String line = "";
    18.             int num = 0;
    19.             while ((line = br.readLine()) != null) {
    20.                 System.out.println(++num + line);
    21.             }
    22.  
    23.         } catch (IOException e) {
    24.             e.printStackTrace();
    25.         }finally {
    26.             if(br !=null){
    27.                 try {
    28.                     br.close();
    29.                 } catch (IOException e) {
    30.                     e.printStackTrace();
    31.                 }
    32.             }
    33.         }
    34.  
    35.     }
    36. }

    运行结果：

    3）Properties&序列化

    1. package com.feiyang.basic15_file;
    2.  
    3. import org.junit.jupiter.api.Test;
    4. import java.io.FileInputStream;
    5. import java.io.FileNotFoundException;
    6. import java.io.FileOutputStream;
    7. import java.io.FileReader;
    8. import java.io.IOException;
    9. import java.io.ObjectInputStream;
    10. import java.io.ObjectOutputStream;
    11. import java.io.Serializable;
    12. import java.util.Properties;
    13.  
    14. /**
    15.  * @author：飞扬
    16.  * @公众hao：程序员飞扬
    17.  * @description: Properties读取文件与序列化
    18.  */
    19. public class Homework03 {
    20.     public static void main(String[] args) throws IOException {
    21.         String filePath = "src\\dog.properties";
    22.         Properties properties = new Properties();
    23.         properties.load(new FileReader(filePath));
    24.  
    25.         String name = properties.getProperty("name") + "";
    26.         int age = Integer.parseInt(properties.getProperty("age") + "");
    27.         String color = properties.getProperty("color") + "";
    28.  
    29.         Dog dog = new Dog(name, age, color);
    30.         System.out.println(dog);
    31.  
    32.         //序列化对象
    33.         String serFilePath = "d:\\dog.dat";
    34.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(serFilePath));
    35.         oos.writeObject(dog);
    36.  
    37.         oos.close();
    38.         System.out.println("dog序列化完成");
    39.  
    40.     }
    41.  
    42.     //反序列化
    43.     @Test
    44.     public void m1() throws IOException, ClassNotFoundException {
    45.         String serFilePath = "d:\\dog.dat";
    46.         ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(serFilePath));
    47.         Dog dog = (Dog)objectInputStream.readObject();
    48.         System.out.println(dog);
    49.     }
    50.  
    51. }
    52.  
    53. class Dog implements Serializable {
    54.     private String name;
    55.     private int age;
    56.     private String color;
    57.  
    58.     public Dog() {
    59.     }
    60.  
    61.     public Dog(String name, int age, String color) {
    62.         this.name = name;
    63.         this.age = age;
    64.         this.color = color;
    65.     }
    66.  
    67.     @Override
    68.     public String toString() {
    69.         return "Dog{" +
    70.                 "name='" + name + '\'' +
    71.                 ", age=" + age +
    72.                 ", color='" + color + '\'' +
    73.                 '}';
    74.     }
    75. }

  • 相关阅读:
    WMS系统功能分析-入库
    HTTP协议：最常用的应用层
    python专属的Remote Produce Call框架：rpyc
    我们为何看好投资 DAO？
    关注云栖大会的感受：从工业大脑到全面AI时代的进化
    PLC网关用途、解决问题以及如何实现高效、稳定通信分享
    Nginx反向代理服务器解决负责均衡问题
    Go 语言快速开发入门(基础语法详解，第一节)
    transition过渡
    Ardupilot — AP_OpticalFlow代码梳理
  • 原文地址：https://blog.csdn.net/lu_xin5056/article/details/126834014