IO流的小细节（很小很细很重要）

朱雀 2023-06-27 06:17 2阅读 0赞

**[Java中的IO流（一）：][Java_IO]  
https://blog.csdn.net/Veer\_c/article/details/103833045  
[Java中的IO流（二）：][Java_IO 1]  
https://blog.csdn.net/Veer\_c/article/details/103833423  
[Java中的IO流（三）：][Java_IO 2]  
https://blog.csdn.net/Veer\_c/article/details/103833811**

**LineNumberReader：**  
public int getLineNumber():获取行号  
public void setLineNumber(int lineNumber):设置起始行号  
String readLine()：读取一行  
**注意： 如果你没有设置行号的，默认从0开始，如果设置行号后，则从设置的行号开始算起。**  
案例：读取文件，每次读取一行打印并且加上行号

package com.edu_01;
    import java.io.FileReader;
    import java.io.IOException;
    import java.io.LineNumberReader;
    public class LineNumberReaderDemo { 
        public static void main(String[] args) throws IOException { 
            //创建LineNumberReader对象
            //public LineNumberReader(Reader in)
            LineNumberReader lnr = new LineNumberReader(new FileReader("a.txt"));
            //默认起始行号从0开始
            //一次读取一行
            String line;
            while ((line = lnr.readLine())!=null) { 
                //打印每一行的行号和内容
                System.out.println(lnr.getLineNumber()+":"+line);
            }
            //关流
            lnr.close();
        }
    }

**操作基本数据类型的流**  
可以操作基本类型的流对象。  
DataInputStream:读数据  
DataOutputStream:写数据  
**注意： 读写顺序必须一致，即当你向文件中写入数据的时候，写的什么数据类型，读的时候就必须用什么数据类型去读，不然会出现错误。**  
案例：给流中写基本类型的数据，并且读取。

public class DataOutputStreamDemo { 
        public static void main(String[] args) throws IOException { 
            //写数据
            //write();
            read();
        }
        private static void read() throws IOException { 
            //DataInputStream:读数据
            //创建对象：public DataInputStream(InputStream in)
            DataInputStream dis = new DataInputStream(new FileInputStream("dos.txt"));
            //读数据了,按什么顺序写入就必须按照什么顺序读出来
            System.out.println(dis.readByte());
            System.out.println(dis.readShort());
            System.out.println(dis.readInt());
            System.out.println(dis.readLong());
            System.out.println(dis.readChar());
            System.out.println(dis.readFloat());
            System.out.println(dis.readDouble());
            System.out.println(dis.readBoolean());
            //关流
            dis.close();
        }
        private static void write() throws IOException { 
            //public DataOutputStream(OutputStream out)
            DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt"));
            //给流关联的文件中写入基本类型的数据
            dos.writeByte(20);
            dos.writeShort(200);
            dos.writeInt(2000);
            dos.writeLong(20000L);
            dos.writeChar(97);
            dos.writeFloat(12.34F);
            dos.writeDouble(23.34);
            dos.writeBoolean(true);
            //关流
            dos.close();
        }
    }

**内存操作流：解决临时数据存储的问题。**  
操作字节数组(演示着一个案例即可)  
ByteArrayInputStream  
ByteArrayOutputStream  
byte\[\] toByteArray() 将之前写入内存的流转换成字节数组  
**注意：在写入文件的时候，是直接将文件写入内存中，写的时候可以用不同的方式，在读取的时候，必须将写入文件的数据封装成相应的数组，这样才能读取出来的。**  
**操作字符数组**  
CharArrayReader  
CharArrayWrite  
**操作字符串**  
StringReader  
StringWriter  
**操作字节数组**  
ByteArrayInputStream  
ByteArrayOutputStream  
将数据写到流中保存在内存，并且读取

package com.edu_03;
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    public class ByteArrayOutputStreamDemo { 
        public static void main(String[] args) throws IOException { 
            //给内存中写数据public ByteArrayOutputStream()
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            //给内存中调用方法写数据
            baos.write("hello".getBytes());
            //将写入内存中的数据读取出来
            byte[] buf = baos.toByteArray();//调用这个方法，将之前写入内存中的数据存储到字节数组中
            ByteArrayInputStream bais = new ByteArrayInputStream(buf);//将刚才存储到字节数组中的内容关联上bais
            //只有这样之后，我们才可以直接从bais中读取我们想要的内容
            //一次读取一个字节
            int by;
            while ((by=bais.read())!=-1) { 
                System.out.print((char)by);
            }
            //关流
            bais.close();
            baos.close();
        }
    }

**打印流：**  
字节打印流 PrintStream  
字符打印流 PrintWriter  
**特点：**  
A:只能操作目的地，不能操作数据源  
B:可以操作任意类型的数据  
C:如果启动了自动刷新，能够自动刷新  
D:可以操作文件的流  
**注意：可以直接操作的流：看流对象的API,如果其构造方法同时有File和String类型的参数，就可以直接操作文件。**  
案例1：利用字符打印流给文件中书写数据（String类型），需要手动刷新。

package com.edu_04;
    import java.io.IOException;
    import java.io.PrintWriter;
    public class PrintWriterDemo { 
        public static void main(String[] args) throws IOException { 
            //使用打印流给文件中写入hello,java,world
            //public PrintWriter(String fileName)
            PrintWriter pw = new PrintWriter("pw.txt");
            //给流关联的文件中写数据
            pw.write("hello");
            pw.write("java");
            pw.write("world");
            //刷新
            pw.flush();
            //3.关流
            pw.close();
        }
    }

此时，我们没有开启自动刷新功能。  
如何启动自动刷新：利用构造  
PrintWriter(OutputStream out, boolean autoFlush)  
PrintWriter(Writer out, boolean autoFlush)  
boolean autoFlush :需要传递一个Boolean类型的参数，当传递进来的参数为True时，表示自动刷新已经开始。  
如果启用了自动刷新，则只有在调用 println、printf 或 format 的其中一个方法时才可能完成此操作。  
println():如果启动了自动刷新，能够实现刷新，而且还实现了自动换行。  
案例2：利用字符流给文件中写数据（int类型，boolean类型），启动自动刷新。

package com.edu_04;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.PrintWriter;
    public class PrintWriterDemo2 { 
        public static void main(String[] args) throws IOException { 
            //创建字符打印流对象，并开启自动刷新
            //public PrintWriter(Writer out,boolean autoFlush)
            PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
            //给流中写数据
            //pw.write("hello");
            //pw.write("java");
            //注意：如果已经开启了自动刷新功能，必须调用则 println、printf 或 format的时候，才可以实现自动刷新
            pw.println("hello");
            pw.println("java");
            pw.println("world");//调用println这个方法给文件中写数据，1.写数据 2.换行 3.刷新
            //可以操作任意类型的数据
            pw.println(true);
            pw.println(12.34);
            //关流
            pw.close();
        }
    }

**强调：实现自动刷新必须要俩个条件：**  
1，必须利用  
PrintWriter(OutputStream out, boolean autoFlush)  
PrintWriter(Writer out, boolean autoFlush) 的构造方法  
2.必须在调用 println、printf 或 format 的其中一个方法时才可以开启自动刷新  
当调用上面三个其中一个方法时，他会完成的操作是：  
1.写入代码 2.换行 3 .自动刷新

**标准输入输出流**  
System类下有这样的两个成员变量：  
标准输入流：public static final InputStream in  
标准输出流：public static final PrintStream out  
案例1：利用标注输入流进行键盘录入，录入后读取流并打印在控制台

package com.edu_05;
    import java.io.IOException;
    import java.io.InputStream;
    public class SystemIn { 
        public static void main(String[] args) throws IOException { 
            // public static final InputStream in 
            //将键盘录入的数据封装在了输入流中
            //Scanner sc = new Scanner(System.in);
            InputStream is = System.in;
            //将键盘录入的数据从输入流中读取出来
            int by;
            while ((by=is.read())!=-1) { 
                System.out.print((char)by);
            }
            //关流
            is.close();
        }
    }

案例2：用IO流实现键盘录入，一次读取一行数据。  
分析：由于是每次读取一行，所以我们可以BuffferedReader()  
InputStream is = System.in;  
此时读取的是字节流，而BufferedReader()需要的是字符流，所以传递进来的参数必须是字符流，因此我们需要将字节流转换成字符流 InputStreamReader()

package com.edu_05;
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    public class SystemIn2 { 
        public static void main(String[] args) throws IOException { 
            /* 案例2：用IO流实现键盘录入，一次读取一行数据 * InputStream is = System.in; * InputSreamReader isr = new InputStreamReader(is) * BufferedReader br = new BufferedReader(isr); */
            //将上面的分析写为一部
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            //一次读取一行数据
            System.out.println("请输入你的姓名");
            String name = br.readLine();
            System.out.println("请输入你的年龄");
            String age = br.readLine();
            System.out.println(name+":"+age);
        }
    }

案例：解析输出语句System.out.println(“helloworld”);

package com.edu_05;
    import java.io.PrintStream;
    /* 标准输出流： * public static final PrintStream out */
    public class SystemOut { 
        public static void main(String[] args) { 
    // PrintStream ps = System.out;
    // ps.println(true);
            //上面两行合并为一行,底层调用的字节打印流中的方法
            System.out.println(true);
        }
    }

**注意：这句语句的本质是System中有一个out的静态字段，所以我们可以通过System调用out字段，返回一个标准的输出类，然后再调用println（）方法，打印数据**

合并流：SequenceInputStream类可以将多个输入流串流在一起，合并为一个输入流，因此，该流也被称为合并流。  
构造：  
SequenceInputStream(InputStream s1, InputStream s2) ：将s1和s2合并成一个输入流，先读取s1后读取s2  
案例1：  
我要把DataStreamDemo.java和ByteArrayStreamDemo.java写到一个文件Copy.java  
数据源：  
DataStreamDemo.java  
ByteArrayStreamDemo.java  
目的地：  
Copy.java  
package com.edu\_06;

import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.SequenceInputStream;
    public class SequenceInputStreamDemo { 
        public static void main(String[] args) throws IOException { 
            //创建合并流对象
            //SequenceInputStream(InputStream s1, InputStream s2) ：将s1和s2合并成一个输入流，先读取s1后读取s2
            //将两个数据源合而为一
            SequenceInputStream sis = new SequenceInputStream(new FileInputStream("PrintWriterDemo.java"), new FileInputStream("SystemIn2.java"));
            //封装目的地
            FileOutputStream fos = new FileOutputStream("copy2.java");
            //一下读写一个字节数组
            byte[] buf = new byte[1024];
            int len;
            while ((len=sis.read(buf))!=-1) { 
                //读多少写多少
                fos.write(buf, 0, len);
            }
            //关流
            fos.close();
            sis.close();
        }
    }

**对象的序列化和反序列化**  
序列化流：把对象按照流一样的方式写到文件或者在网络中传输。  
反序列化流：把文件或者网络中的流对象数据还原对象。  
ObjectOutputStream：序列化流  
writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。  
ObjectInputStream：反序列化流  
Object readObject() 从 ObjectInputStream 读取对象。

//1.先创建出一个学生类
    package com.edu_07;
    import java.io.Serializable;
    public class Studnet implements Serializable{ 
        //实现这个接口不需要实现任何方法，这个接口说白了就是仅仅给Student类，打上了一个可以被序列化的标示
        private String name;
        private int age;
        public String getName() { 
            return name;
        }
        public void setName(String name) { 
            this.name = name;
        }
        public int getAge() { 
            return age;
        }
        public void setAge(int age) { 
            this.age = age;
        }
        public Studnet(String name, int age) { 
            super();
            this.name = name;
            this.age = age;
        }
        public Studnet() { 
            super();
            // TODO Auto-generated constructor stub
        }
        @Override
        public String toString() { 
            return "Studnet [name=" + name + ", age=" + age + "]";
        }
    }
    //2. 利用序列化流将对象写入文本中
    package com.edu_07;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectOutputStream;
    public class ObjectOutputStreamDemo { 
        public static void main(String[] args) throws IOException { 
            //创建序列化流对象
            //public ObjectOutputStream(OutputStream out)
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));
            //创建一个学生对象，将学生对象写入文件中
            Studnet s = new Studnet("刘德华", 50);
            oos.writeObject(s);
            // java.io.NotSerializableException
            //类通过实现 java.io.Serializable 接口以启用其序列化功能
            //关流
            oos.close();
        }
    }
    //3.利用反序列化流将存储到文件的对象读取出来
    import java.io.FileInputStream;
    import java.io.ObjectInputStream;
    public class ObjectInputStreamDemo { 
        public static void main(String[] args) throws Exception { 
            //创建反序列化流对象
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt"));
            //读取文件中存储的对象，以实现反序列化
            //readObject()
            Object object = ois.readObject();
            System.out.println(object);
            //关流
            ois.close();
        }
    }

注意：如果一个类不是实现Serializable接口无法把实例化，会抛出异常java.io.NotSerializableException类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化，所以我们可以通过让对象的所属类来实现序列化接口。

**Properties**  
Properties:Properties 类表示了一个持久的属性集,属性列表中每个键及其对应值都是一个字符串。  
特点：Properties 可保存在流中或从流中加载。  
案例：使用map集合的put方法给集合中存储数据并且遍历

package com.edu_08;
    import java.util.Properties;
    import java.util.Set;
    public class ProppertiesDemo { 
        public static void main(String[] args) { 
            //创建Properties对象，本质上上是一个map几个，但是键值都是String类型
            Properties prop = new Properties();
            //给对象中存储元素
            prop.put("zhangjie", "xiena");
            prop.put("huangxiaoming", "baby");
            prop.put("wanglaoshi", "zhangziyi");
            //map集合遍历
            //获取键的集合
            Set<Object> keys = prop.keySet();
            for (Object key : keys) { 
                System.out.println(key+":"+prop.get(key));
            }
        }
    }

**Properties的特有功能：**  
添加元素  
public Object setProperty(String key,String value)  
获取元素  
public String getProperty(String key)  
public Set stringPropertyNames()  
案例：使用它的特有功能添加元素并遍历

package com.edu_08;
    import java.util.Properties;
    import java.util.Set;
    public class PropertiesDemo2 { 
        public static void main(String[] args) { 
            //创建Properties这个集合
            Properties prop = new Properties();
            //调用public Object setProperty(String key,String value)
            prop.setProperty("huangxiaoming", "baby");
            prop.setProperty("dengchao", "sunli");
            prop.setProperty("libai", "wanglun");
            //1.获取所有键的集合
            //public Set<String> stringPropertyNames()
            Set<String> keys = prop.stringPropertyNames();
            //遍历键，根据键找值
            for (String key : keys) { 
                System.out.println(key+":"+prop.getProperty(key));
            }
        }
    }

**可以和IO流进行结合使用：**  
把文件中的数据加载到集合中。注意：文件中的数据必须是键值对象形式的（例如：String1=String2)  
public void load(InputStream inStream)  
public void load(Reader reader)  
案例：创建一个键值对文件，将文件中的键值对加载到集合中，输出集合

package com.edu_08;
    import java.io.FileReader;
    import java.io.IOException;
    import java.util.Properties;
    import java.util.Set;
    public class PropertiesDemo3 { 
        public static void main(String[] args) throws IOException { 
            //创建集合
            Properties prop = new Properties();
            //将文件中的键值对，加载到集合中
            prop.load(new FileReader("prop.txt"));
            //遍历集合
            Set<String> keys = prop.stringPropertyNames();
            for (String key : keys) { 
                System.out.println(key+":"+prop.getProperty(key));
            }
        }
    }

把集合中的数据存储到文本文件中，并且是按照键值对形式存储的。  
public void store(OutputStream out,String comments)  
public void store(Writer writer,String comments)  
案例：将创建的键值对集合加载到文件中

package com.edu_08;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.util.Properties;
    public class PropertiesDemo4 { 
        public static void main(String[] args) throws IOException { 
            //创建集合
            Properties prop = new Properties();
            //给集合中存储数据
            prop.setProperty("liudehua", "50");
            prop.setProperty("liming", "60");
            prop.setProperty("zhangxueyou", "40");
            //将集合中的元素，存储到文本文件中
            prop.store(new FileWriter("prop2.txt"), "name=age");
        }
    }

案例：我有一个文本文件，我知道数据是键值对形式的，但是不知道内容是什么。 请写一个程序判断是否有“lisi”这样的键存在，如果有就改变其值为”100”。  
分析：  
1.我们可以先将文本加载到集合中，然后获取所有的键的集合  
2.在判断集合中是否有这样的键，如果有的话，重新给集合中添加这样的键值对，  
3.最后将修改后的集合，写入到文本中

package com.edu_09;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.util.Properties;
    import java.util.Set;
    public class PropTest { 
        public static void main(String[] args) throws IOException { 
            /* zhangsan=3 lisi=4 wangwu=5 1.创建集合对象 2.将文件中的键值对加载到集合中 3.获取多有的键的集合，遍历，判断 4.如果存在lisi，的话，给集合中重新存储键值对lisi=100 5.将集合中的数据存储到文件中 */
            //1.创建集合对象
            Properties prop = new Properties();
            // 2.将文件中的键值对加载到集合中
            prop.load(new FileReader("prop3.txt"));
            //3.获取多有的键的集合，遍历，判断
            Set<String> keys = prop.stringPropertyNames();
            // 4.如果存在lisi，的话，给集合中重新存储键值对lisi=100
            for (String key : keys) { 
                if ("lisi".equals(key)) { 
                    prop.setProperty(key, "100");
                }
            }
            //5.将集合中的数据存储到文件中
            prop.store(new FileWriter("prop3.txt"), null);
        }

案例：我有一个猜数字小游戏的程序，请写一个程 序实现在测试类中只能用分 超过5次提示：游戏试玩已结束，请付费。  
分析：  
1.先创建一个运行游戏的类，注意一定是静态的，因为只有静态才能调用静态。  
2.创建一个文本，里面存入count=1,然后将文本加载到集合中。  
3.然后将取出的文本，获取count对应的次数。  
4. 判断，如果次数大于0，就开始执行游戏，每运行一次后，次数加一，然后添加到集合中。  
5，将集合中数据，加载到文本中。

// 1.创建以游戏类，
    package com.edu_01;
    import java.util.Scanner;
    public class GuessNumber { 
        public static void startGame(){ 
            int ran = (int) (Math.random()*100+1);
            Scanner sc = new Scanner(System.in);
            while (true) { 
                System.out.println("请输入你猜测得数字");
                int number = sc.nextInt();
                if (number>ran) { 
                    System.out.println("大了");
                }else if (number<ran) { 
                    System.out.println("小了");
                }else if (number==ran) { 
                    System.out.println("猜对了");
                    break;
                }
            }
        }
    }
    // 2.创建测试类
     package com.edu_01;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.util.Properties;
    public class PropTest { 
        public static void main(String[] args) throws IOException { 
            //1.将文件中的键值对加载到集合中
            Properties prop = new Properties();
            prop.load(new FileReader("count.txt"));
    
            //2.拿出已经玩耍的次数做判断
            String count = prop.getProperty("count");
            //将String类型转换为int类型
            int number = Integer.parseInt(count);
            if (number>4) { 
                System.out.println("次数已到，请付费");
            }else { 
                //开启游戏
                GuessNumber.startGame();
                number++;
                //将自增的次数重新存储到文件中
                prop.setProperty("count", number+"");
                //将新的prop集合存储到文件中
                prop.store(new FileWriter("count.txt"), null);
            }
        }
    }

# 路阻且长之Java学习： #

**[API中的重要类（一）：][API]  
https://blog.csdn.net/Veer\_c/article/details/103803248  
[API中的重要类（二）：][API 1]  
https://blog.csdn.net/Veer\_c/article/details/103807515  
[API中的重要类（三）：][API 2]  
https://blog.csdn.net/Veer\_c/article/details/103808054**

**[Java多线程（一）：][Java]  
https://blog.csdn.net/Veer\_c/article/details/103842078  
[Java多线程（二）：][Java 1]  
https://blog.csdn.net/Veer\_c/article/details/103842263  
[Java多线程（三）：][Java 2]  
https://blog.csdn.net/Veer\_c/article/details/103842317  
[Java多线程（四）：][Java 3]  
https://blog.csdn.net/Veer\_c/article/details/103842602**

**[网络编程上（UDP）：][UDP]  
https://blog.csdn.net/Veer\_c/article/details/103843591  
[网络编程下（TCP）：][TCP]  
https://blog.csdn.net/Veer\_c/article/details/103843825**

**[MySQL数据库（一）：][MySQL]  
https://blog.csdn.net/Veer\_c/article/details/103844059  
[MySQL数据库（二）：][MySQL 1]  
https://blog.csdn.net/Veer\_c/article/details/103844537  
[MySQL数据库（三）：][MySQL 2]  
https://blog.csdn.net/Veer\_c/article/details/103844739**

**[JDBC技术（一）：][JDBC]  
https://blog.csdn.net/Veer\_c/article/details/103845176  
[JDBC技术（二）：][JDBC 1]  
https://blog.csdn.net/Veer\_c/article/details/103879890  
[JDBC技术（三）：][JDBC 2]  
https://blog.csdn.net/Veer\_c/article/details/103880021  
[JDBC技术（四）：][JDBC 3]  
https://blog.csdn.net/Veer\_c/article/details/103882264**

**[HTML的基础框架（一）：][HTML]  
https://blog.csdn.net/Veer\_c/article/details/103882385  
[HTML的基础框架（二）：][HTML 1]  
https://blog.csdn.net/Veer\_c/article/details/103882684**

**[CSS入门（一）][CSS]  
https://blog.csdn.net/Veer\_c/article/details/103882856**  
**[CSS入门（二）：][CSS 1]  
https://blog.csdn.net/Veer\_c/article/details/103883102**

**[JavaScript实用案例与常见问题（一）：][JavaScript]  
https://blog.csdn.net/Veer\_c/article/details/103894959  
[JavaScript实用案例及常见问题（二）：][JavaScript 1]  
https://blog.csdn.net/Veer\_c/article/details/103895166**

**[BOM编程详解：][BOM]  
https://blog.csdn.net/Veer\_c/article/details/103895433**

[Java_IO]: https://blog.csdn.net/Veer_c/article/details/103833045
[Java_IO 1]: https://blog.csdn.net/Veer_c/article/details/103833423
[Java_IO 2]: https://blog.csdn.net/Veer_c/article/details/103833811
[API]: https://blog.csdn.net/Veer_c/article/details/103803248
[API 1]: https://blog.csdn.net/Veer_c/article/details/103807515
[API 2]: https://blog.csdn.net/Veer_c/article/details/103808054
[Java]: https://blog.csdn.net/Veer_c/article/details/103842078
[Java 1]: https://blog.csdn.net/Veer_c/article/details/103842263
[Java 2]: https://blog.csdn.net/Veer_c/article/details/103842317
[Java 3]: https://blog.csdn.net/Veer_c/article/details/103842602
[UDP]: https://blog.csdn.net/Veer_c/article/details/103843591
[TCP]: https://blog.csdn.net/Veer_c/article/details/103843825
[MySQL]: https://blog.csdn.net/Veer_c/article/details/103844059
[MySQL 1]: https://blog.csdn.net/Veer_c/article/details/103844537
[MySQL 2]: https://blog.csdn.net/Veer_c/article/details/103844739
[JDBC]: https://blog.csdn.net/Veer_c/article/details/103845176
[JDBC 1]: https://blog.csdn.net/Veer_c/article/details/103879890
[JDBC 2]: https://blog.csdn.net/Veer_c/article/details/103880021
[JDBC 3]: https://blog.csdn.net/Veer_c/article/details/103882264
[HTML]: https://blog.csdn.net/Veer_c/article/details/103882385
[HTML 1]: https://blog.csdn.net/Veer_c/article/details/103882684
[CSS]: https://blog.csdn.net/Veer_c/article/details/103882856
[CSS 1]: https://blog.csdn.net/Veer_c/article/details/103883102
[JavaScript]: https://blog.csdn.net/Veer_c/article/details/103894959
[JavaScript 1]: https://blog.csdn.net/Veer_c/article/details/103895166
[BOM]: https://blog.csdn.net/Veer_c/article/details/103895433