IO流（JAVA）

已于 2023-11-09 21:07:39 修改
阅读量182 收藏
点赞数
分类专栏： Java学习 文章标签： java 开发语言
于 2023-11-02 21:03:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74139128/article/details/134191133
版权

File

File的构造方法
public class dome {
    public static void main(String[] args) {
        File f1 = new File("D:\\Java\\hello");
        System.out.println(f1);

        File f2 = new File("D:","Java\\hello");
        System.out.println(f2);

        File f3 = new File("D:");
        File f4 =new File(f3,"Java\\hello");
        System.out.println(f4);
    }
}
File创建功能
public class dome {
    public static void main(String[] args) throws IOException {

        //如果存在就flast,否则true
        //创建文件
        File f1 = new File("D:\\Java\\hello.txt");
        System.out.println(f1.createNewFile());//不能与目录名相同

        //创建目录
        //如果存在就flast,否则true
        File f2 = new File("D:\\Java\\JavaFile");
        System.out.println(f1.mkdir());

        System.out.println(f2.mkdirs());
    }
}
File的判断以及获取功能
public class dome {
    public static void main(String[] args) throws IOException {
        File f1 = new File("D:\\Java\\JavaFile\\hello.txt");
        System.out.println(f1.isDirectory());   //判断是不是目录
        System.out.println(f1.isFile());        //判断是不是文件
        System.out.println(f1.exists());        //判断路径名是否存在

        System.out.println("-------");
        System.out.println(f1.getAbsolutePath());//返回绝对路径
        System.out.println(f1.getPath());       //返回封装路径
        System.out.println(f1.getName());       //返回文件名称

        System.out.println("-------");
        File f2 = new File("D:\\Java");
        String[] list = f2.list();              //返回此目录中的文件名
        for(String ss : list){
            System.out.println(ss);
        }
        System.out.println("-------");

        File[] files = f2.listFiles();
        for(File f : files){
//            System.out.println(f);        返回绝对路径
//            System.out.println(f.getName());        返回文件名

            //真正用途
            if(f.isFile()){//如果是文件就输出
                System.out.println(f.getName());
            }
        }
    }
}

File的删除

public class dome {
    public static void main(String[] args) throws IOException {
//        D:\Java\JavaFile\hello.txt        绝对路径
//        Java_Code\Filedele                相对路径
        File f = new File("Java_Code\\Filedele.txt");
        f.createNewFile();
        System.out.println(f.delete());

        File f1 = new File("Java_Code\\date");
        f1.mkdir();
        System.out.println(f1.delete());//目录下有内容需要先删文件
    }
}
案例：递归遍历目录
public class dome {
    public static void main(String[] args) throws IOException {
        File f = new File("D:\\WeChat");
//        String[] list = f.list();
//        for(String it : list){
//            System.out.println(it);
//        }
        getAllFilePath(f);

    }
    public static void getAllFilePath(File e){
        File[] files = e.listFiles();
        if(files!=null){
            for(File it : files){
                if(it.isDirectory()){
                    getAllFilePath(it);
                }
                else {
                    System.out.println(it.getPath());
                }
            }
        }
    }
}

字节流

那么这两种流都在什么情况下使用呢?

如果数据通过Window自带的记事本软件打开，我们还可以读懂里面的内容就使用字符流

否则使用字节流。如果你不知道该使用哪种类型的流，就使用字节流

字节流写数据
public class dome {
    public static void main(String[] args) throws IOException {
        //创建字节输出流
        FileOutputStream out = new FileOutputStream("Java_Code\\date\\test.txt");//创建了文件

        out.write(100);//用ALCSS码写进去
        out.write(57);

        //释放资源
        out.close();//关闭此文件的输出流并且释放与此流相关的任何系统资源
    }
}
输入的三种方式
public class dome {
    public static void main(String[] args) throws IOException {
        FileOutputStream out = new FileOutputStream("Java_Code\\Date\\test.txt");
//        out.write(100);
//        out.write(25);
//        byte[] bytes = {100,90,97,98};
//        byte[] bytes = "abcde".getBytes();
//        out.write(bytes);

        byte[] bytes = "abcde".getBytes();
        out.write(bytes,1,3);
        out.close();
    }
}

 输入时的两个小问题

1.追加写入

2.换行

public class dome {
    public static void main(String[] args) throws IOException {
        FileOutputStream f = new FileOutputStream("Java_Code\\Date\\test.txt");
        
        // FileOutputStream f = new FileOutputStream("Java_Code\\Date\\test.txt",true);在末尾追加写入
        for(int i=0;i<=4;i++){
            f.write("hello".getBytes());
            f.write("\t\n".getBytes());
            /*
                    在windows:\r\n
                    在Linux :\n
                    在mac   :\r
             */
        }
        f.close();
    }
}
字节流读数据

一次一个字节

public class dome {
    public static void main(String[] args) throws IOException {
        FileInputStream f = new FileInputStream("Java_Code\\Date\\test.txt");
        int bye;
        while((bye=f.read())!=-1){
            System.out.print((char)bye);
        }
    }
}

一次读入一个字节组

public class dome {
    public static void main(String[] args) throws IOException {
        FileInputStream f = new FileInputStream("Java_Code\\Date\\test.txt");
        byte[] b= new byte[1024];//整数倍
        int len;
        while((len=f.read(b))!=-1){
            System.out.println(new String(b,0,len));
        }
        f.close();
    }
}

复制图片

public class dome {
    public static void main(String[] args) throws IOException {
        FileInputStream f = new FileInputStream("D:\\Java\\domepng.png");
        FileOutputStream f1 = new FileOutputStream("Java_Code\\Date\\test.png");
        byte[] b= new byte[10240];
        int len;
        while((len=f.read(b))!=-1){
            f1.write(b,0,len);
        }
        f.close();
        f1.close();
    }
}
字节缓冲流
public class dome {
    public static void main(String[] args) throws IOException {
//        BufferedOutputStream f = new BufferedOutputStream(new FileOutputStream("Java_Code\\Date\\test.txt"));//字节缓冲输入流
        BufferedInputStream f0 = new BufferedInputStream(new FileInputStream("Java_Code\\Date\\test.txt"));  //字节缓冲输出流
//        f.write("hooo".getBytes());
        byte[] b = new byte[1024];
        int len;
        while((len=f0.read(b))!=-1){
            System.out.println(new String(b,0,len));
        }
//        f.close();
        f0.close();
    }
}

案例：复制视频（字节缓冲流复制一个数组较快）

public class dome {
    public static void main(String[] args) throws IOException {
        long l = System.currentTimeMillis();
        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("Java_Code\\Date\\text.mp4"));
        BufferedInputStream in = new BufferedInputStream(new FileInputStream("D:\\Java\\domemp4.mp4"));
        int len;
        byte[] b = new byte[20*1024];
        while((len = in.read(b))!=-1){
            out.write(b,0,len);
        }
        out.close();
        in.close();
        long l1 = System.currentTimeMillis();
        System.out.println(l1-l+"毫秒");

    }
}

字符流

编码与解码
public class dome {
    public static void main(String[] args) throws IOException {
        String s = "中国";//默认UTF-8编码
        byte[] bys = s.getBytes("UTF-8");//[-28, -72, -83, -27, -101, -67]
//        byte[] bys = s.getBytes();//[-28, -72, -83, -27, -101, -67]
//        byte[] bys = s.getBytes("GBK");//[-42, -48, -71, -6]
//        System.out.println(Arrays.toString(bys));
        String res = new String(bys);//中国
//        String res = new String(bys,"GBK");//中国
        System.out.println(res);

    }
}
public class dome {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("Java_Code\\Date\\dome.txt"));
//        OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("Java_Code\\Date\\dome.txt"),"GBK");
        out.write("中国");
        out.close();

        InputStreamReader in = new InputStreamReader(new FileInputStream("Java_Code\\Date\\dome.txt"));
//        InputStreamReader in = new InputStreamReader(new FileInputStream("Java_Code\\Date\\dome.txt"),"GBK");
        char[] b = new char[1024];
        int len;
        while((len=in.read(b))!=-1){
            System.out.println(new String(b,0,len));
        }
        in.close();
    }
}
字符流写数据的5种方式
public class dome {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("Java_Code\\Date\\test.txt"));
        //1
        out.write(97);//此时写不进去数据，因为数据最终要通过FileOutputStream写进去，此时还在缓冲区
        out.flush();//通过刷新流写进数据
        out.write(98);
        //2
        char[] c ={97,98,99};
        out.write(c);//也需要刷新流
        //3
        out.write(c,1,2);//也需要刷新流
        //4
        String s = "wtret";
        out.write(s);//也需要刷新流
        //5
        out.write(s,1,3);//也需要刷新流

        out.close();//此时会自动执行一次刷新流,且释放资源后就不能在写数据了

    }
}
字符流读数据的两种方式
public class dome {
    public static void main(String[] args) throws IOException {
        InputStreamReader in = new InputStreamReader(new FileInputStream("D:\\Java\\dometxt.txt"));
//        int c;
//        while((c=in.read())!=-1){
//            System.out.print((char)c);
//        }
        int len;
        char[] c = new char[1024];
        while((len=in.read(c))!=-1){
            System.out.println(new String(c,0,len));
        }
        in.close();
    }
}

案例：

public class dome {
    public static void main(String[] args) throws IOException {
//        OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("Java_Code\\Date\\test.txt"));
//        InputStreamReader in = new InputStreamReader(new FileInputStream("D:\\Java\\dometxt.txt"));
//        int len;
//        char[] c = new char[1024];
//        while((len=in.read(c))!=-1){
//            out.write(c,0,len);
//        }
//        out.close();
//        in.close();
        
        //涉及到编码问题还需要第一张方式
        FileReader fr = new FileReader("Java_Code\\Date\\test.txt");
        FileWriter fw = new FileWriter("D:\\Java\\dometxt.txt");
        int len;
        char[] c = new char[1024];
        while((len=fr.read(c))!=-1){
            fw.write(c,0,len);
        }
        fr.close();
        fw.close();
    }
}
字符缓冲流
public class dome {
    public static void main(String[] args) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter("Java_Code\\Date\\test.txt"));
        bw.write("hello\r\n");
        bw.write("你好\r\n");
        bw.flush();
        BufferedReader br = new BufferedReader(new FileReader("Java_Code\\Date\\test.txt"));
        int len;
        char[] c = new char[1024];
        while((len=br.read(c))!=-1){
            System.out.println(new String(c,0,len));
        }
        br.close();
        bw.close();
    }
}
字符缓冲流的特有功能
public class dome {
    public static void main(String[] args) throws IOException {
//        BufferedWriter bw = new BufferedWriter(new FileWriter("Java_Code\\Date\\test.txt"));
//        for(int i=0;i<=10;i++){
//            bw.write("hello"+i);
//            bw.newLine();//输入一个又系统决定的换行符，例如windows的\r\n
//        }
//        bw.close();
        BufferedReader br = new BufferedReader(new FileReader("Java_Code\\Date\\test.txt"));
        String s;
        while((s=br.readLine())!=null){//一次读入一行数据，如果没有，则输出null,不包括换行
            System.out.println(s);
        }
        br.close();
    }
}

总结

 需要学习的案例

单级文件夹复制

public class dome {
    public static void main(String[] args) throws IOException {
        File fd = new File("D:\\javatest");
        String dname = fd.getName();
        File fsrc = new File("Java_Code\\Date",dname);
        if(!fsrc.exists()){
            fsrc.mkdir();
        }
        File[] files = fd.listFiles();
        for(File it :files){
            String s = it.getName();
            File fsrc1 = new File(fsrc,s);
            cop(it,fsrc1);
        }
    }
    public static void cop(File boot,File src) throws IOException {
        BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream(src));
        BufferedInputStream br = new BufferedInputStream(new FileInputStream(boot));
        int len ;
        byte[] b = new byte[1024];
        while((len=br.read(b))!=-1){
            bo.write(b,0,len);
        }
        bo.close();
        br.close();
    }
}

多级文件夹复制

public class dome {
    public static void main(String[] args) throws IOException {
        dir(new File("D:\\Javatest"),new File("Java_Code\\Date"));
    }
    public static void dir(File boot,File src)throws IOException{
        File f = new File(src,boot.getName());
        if(!f.exists()){
            f.mkdir();
        }
        File[] files = boot.listFiles();
        for(File it : files){
            File ff = new File(f,it.getName());
            if(!it.isFile()){
                dir(it,f);
            }
            else cop(it,ff);
        }
    }
    public static void cop(File boot,File src)throws IOException{
        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(src));
        BufferedInputStream in = new BufferedInputStream(new FileInputStream(boot));
        int len;
        byte[] b = new byte[20*1024];
        while((len=in.read(b))!=-1){
            out.write(b,0,len);
        }
        out.close();
        in.close();
    }
}

异常处理

public class dome {
    public static void main(String[] args) {

    }
    //JDK9处理异常
    public static void show3() throws IOException{
        BufferedReader fr = new BufferedReader(new FileReader("D:\\Java\\dometxt.txt"));
        BufferedWriter fw = new BufferedWriter(new FileWriter("Java_Code\\Date\\test.txt"));
        try(fr;fw){
            int len;
            char[] a = new char[1024];
            while ((len = fr.read(a)) != -1) {
                fw.write(a, 0, len);
            }
        }
        catch (IOException e){
            e.printStackTrace();
        }
    }
    //JDK7处理异常--通常用这个
    public static void show2() {
        try(BufferedReader fr = new BufferedReader(new FileReader("D:\\Java\\dometxt.txt"));
            BufferedWriter fw = new BufferedWriter(new FileWriter("Java_Code\\Date\\test.txt"));){
            int len;
            char[] a = new char[1024];
            while ((len = fr.read(a)) != -1) {
                fw.write(a, 0, len);
            }
        }
        catch (IOException e){
            e.printStackTrace();
        }
    }
    //处理异常
    public static void show1() {
        BufferedReader fr=null;
        BufferedWriter fw = null;
        try {
            fr = new BufferedReader(new FileReader("D:\\Java\\dometxt.txt"));
            fw = new BufferedWriter(new FileWriter("Java_Code\\Date\\test.txt"));
            int len;
            char[] a = new char[1024];
            while ((len = fr.read(a)) != -1) {
                fw.write(a, 0, len);
            }
        }
        catch (IOException e){
            e.printStackTrace();
        }finally {
            fr.close();
            fw.close();
        }
    }
    //抛出异常
    public static void show() throws IOException{
        BufferedReader fr = new BufferedReader(new FileReader("D:\\Java\\dometxt.txt"));
        BufferedWriter fw = new BufferedWriter(new FileWriter("Java_Code\\Date\\test.txt"));
        int len;
        char[] a = new char[1024];
        while((len=fr.read(a))!=-1){
            fw.write(a,0,len);
        }
        fr.close();
        fw.close();
    }
}

特殊操作流

标准输入输出流
public class dome {
    public static void main(String[] args) {
        BufferedReader fr = new BufferedReader(new InputStreamReader(System.in));//从键盘输入数据，标准输入流
        //和Scanner一样
        PrintStream out = System.out;
        out.printf("你好");
        System.out.printf("你好");//标准输出流
    }
}
字节打印流与字符打印流
public class dome {
    public static void main(String[] args) throws IOException {
//        //字节打印流
//        PrintStream ps = new PrintStream("Java_Code\\Date\\test.txt");
//
//        //字节输出流的方法
//        ps.write(97);
//
//        //特有方法
//        ps.print("hello");
//        ps.println("20");
//        ps.close();


        //字符打印流
        PrintWriter pw = new PrintWriter(new FileWriter("Java_Code\\Date\\test.txt"),true);//如果true,则自动刷新
        pw.println("aa");
        /*
                pw.write("aa");
                pw.write("\r\n");
                pw.flush();
         */
        pw.close();
    }
}

案例：字符打印流复制文件

public class dome {
    public static void main(String[] args) throws IOException {
        BufferedReader fr = new BufferedReader(new FileReader("D:\\Java\\dometxt.txt"));
        PrintWriter pw = new PrintWriter(new FileWriter("Java_Code\\Date\\test.txt"));
        String s;
        while((s=fr.readLine())!=null){
            pw.println(s);
        }
        fr.close();
        pw.close();
    }
}
对象序列化流与反序列化流
public class dome {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //对象序列化流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Java_Code\\Date\\test.txt"));
        Student s = new Student("张三",2,3,4);//对象序列化需要类继承Serializable
        oos.writeObject(s);
        oos.close();

        //对象反序列化流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Java_Code\\Date\\test.txt"));
        Object o = ois.readObject();
        Student ss = (Student)o;
        System.out.println(ss.getName());
        ois.close();
    }
}
IO框架

特殊文本，日志技术

Properties
public class dome {
    public static void main(String[] args) throws Exception {
        //创建一个Properties对象
        Properties properties = new Properties();

        //将文件加载进properties中
        properties.load(new FileReader("Java_Code\\Date\\test.properties"));

//        System.out.println(properties);
        //从文件中寻找数据
        String s1 = properties.getProperty("王伟伟");
        System.out.println(s1);

        Set<String> strings = properties.stringPropertyNames();
        for(String it : strings){
            System.out.println(it+"----->"+properties.getProperty(it));
        }

        //存储进数据
        properties.setProperty("李华","121323");
        properties.store(new FileWriter("Java_Code\\Date\\test.properties"),"此文本储存的是密码");
    }
}
XML
<?xml version="1.0" encoding="UTF-8" ?>
<!-- 注释-->
<!-- 上面的生命必须放在第一行，必须存在-->
<users>
    <users id = "1">
        <name>李华</name>
        <age>12</age>
        <sex>男</sex>
        <![CDATA[
            3 < 2
        ]]>
        <!-- 特殊数据区，可以写任何数据-->
    </users>
    <users id = "2">
        <name>张三</name>
        <age>13223</age>
        <sex>女</sex>
    </users>
    <!--
     &lt;  代替 <
     &gt;  代替 >
     &amp; 代替 &
     &apos;代替 '
     &quot;代替 "
     -->
</users>

不能AC的小菜鸡
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
javaIO流javaIO流javaIO流
07-02
javaIO流javaIO流
java基础之IO流
06-18
java基础之IO流，基础简介知识，帮助你了解java的io技术
Java_IO.rar_IO流 java_java io流
09-21
一个介绍文件流操作的文章 内含代码.....
IO流 javaio java 流
06-01
IO流 javaio java 流
java IO流详细笔记
07-12
Java IO流详解
JAVAEE之多线程进阶（2）_ CAS概念、实现原理、ABA问题及解决方案
2301_80653026的博客
05-29 1472
CAS全称Compare and swap，字面意思:”比较并交换“，它是一条 CPU 并发原语，用于判断内存中某个值是否为预期值，如果是则更改为新的值，这个过程是原子的。全称 Compare and swap, 即 “比较并交换”. 相当于通过一个原子的操作, 同时完成 “读取内存, 比较是否相等, 修改内存” 这三个步骤. 本质上需要 CPU 指令的支撑。
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 951
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 979
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 778
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 279
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 251
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
Java面向数据编程1.1版本
极道Jdon的技术博客
05-28 508
虽然将所有这些方法都集中在 Item 上似乎是合理的，因为它们都与购买流程交互，但增加了 predictLowStock（与基于机器学习的预购系统交互）、registerForRecommendations（另一个 ML 系统，这次是物品建议）和 reportPurchase（登记潜在危险物品的购买），让我们怀疑所有这些操作是否真的属于同一个接口。：这是不同上下文场景的方式，放在Item一个类或接口中肯定不对，如同学生借书，将借书这个动作建模在学生这个类或接口一样，借书时一种具体场景。
java多线程创建方式
weixin_57763462的博客
05-28 1071
这种方式是通过创建一个实现了Runnable接口的类，并实现run()方法来创建线程。然后将这个类的对象作为参数传递给Thread类的构造器，并调用Thread对象的start()方法来启动线程。这种方式是通过创建一个实现了Callable接口的类，实现call()方法，并使用FutureTask或者ExecutorService来创建线程。这种方式的优点在于，由于Java不支持多重继承，如果你的类需要继承其他类，那么实现Runnable接口将是唯一的选择。// 在这里定义线程的执行逻辑。
Redis学习笔记【基础篇】
qq_42192253的博客
05-30 1025
这样以来，我们就可以把不同类型的数据区分开了。从而避免了key的冲突问题。HSET key field value：添加或者修改hash类型key的field的值。获取sorted set 中的指定元素的排名：ZRANK key member。HGET key field：获取一个hash类型key的field的值。通过给key添加前缀加以区分，不过这个前缀不是随便加的，有一定的规范。HMSET：批量添加多个hash类型key的field的值。HMGET：批量获取多个hash类型key的field的值。
C语言基础——数组
2302_80177460的博客
05-27 1062
C语言基础——字符串与数组及部分操作符-CSDN博客），这里再简单说明一下吧。我们都知道，如果我们在C语言中想要创建很多个变量，如果是一个一个创建的话那效率太低下了，这个时候或许会有人想到用循环来搞定，但是我们再细想想，如果用循环来表示的话我们应该把这组数据储存在哪里呢，如果只是创建一个变量的话那么后一次循环会覆盖掉前一次循环，但是如果创建很多个变量的话又不好在循环之中插入，这个时候我们便可以使用我们心心念念的数组啦。我们这一章节就来具体看看数组到底是什么吧。
Java入门基础教程-字面量、变量、关键字与标识符
码客笔记
05-27 164
变量是存储数据值的容器，其值可以在程序执行过程中被修改。变量有一个名字（即标识符），并且总是与特定的数据类型相关联。在Java中，变量的声明和初始化是分开的，但也可以同时进行。大家不要被这个词搞晕了，它其实很简单，我们知道计算机是来处理数据的，字面量其实就是告诉程序员数据在程序中的书写格式。所谓标志符其实就是我们自己取的名字。像前面我们取的类名，变量名其实都是标志符。如何识别那些单词是关键字？
继承与无参构造器
2301_79842503的博客
05-30 227
在Java中，当你创建一个子类的实例时，如果子类构造函数没有显式地调用父类的构造函数，那么编译器会自动插入一个对父类无参构造函数的调用（如果父类中存在这样的构造函数）。这是Java中构造函数链式调用的一个基本规则，确保父类在子类之前被正确初始化。这个过程是Java中对象初始化的一个重要部分，确保在子类访问或修改从父类继承的任何状态之前，父类已经完成了其自己的初始化。的构造函数内部，你输出了"Student()无参构造器后执行了"，这是在。的构造函数执行之后发生的。的构造函数执行之前，编译器会自动先调用。
Java进阶学习笔记27——StringBuilder、StringBuffer
CCH2024的专栏
05-26 288
Java进阶学习笔记
Servlet搭建博客系统
Smarmot的博客
05-31 631
现在我们可以使用Servlet来搭建一个动态(前后端可以交互)的博客系统.(使用Hexo只能实现一个纯静态的网页,即只能在后台自己上传博客)
javaio流字节流
12-14
Java IO流是用来处理设备之间的数据传输的，Java对数据的操作是通过流的方式进行的。Java用于操作流的类都在IO包中。Java IO流分为字节流和字符流两种类型。字节流以字节为单位进行操作，而字符流以字符为单位进行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值