《java基础与案例开发详解》（四）

最新推荐文章于 2021-07-06 23:18:16 发布
最新推荐文章于 2021-07-06 23:18:16 发布
阅读量448 收藏 1
点赞数
分类专栏： java 文章标签： java io流 文件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/venus321/article/details/78150789
版权

Java对文件和目录的操作

在java中，对物理存储介质中的文件和目录进行了抽象，使用java.io.File类代表存储介质中的文件和目录。

File类的构造

通常用文件或者目录路径来构造，这个路径可以是绝对路径也可以是相对路径。

File类常用属性和方法

这里写图片描述

这里写图片描述

代码示例：

    File f = new File("E:\\Hello.java");
            System.out.println(f.exists());//文件是否存在
            System.out.println(f.isFile());//是文件吗
            System.out.println(f.isDirectory());//是目录
            System.out.println(f.getName());//获取文件名称
            System.out.println(f.getAbsolutePath());//获取文件绝对地址
            try {
                System.out.println(f.getCanonicalPath());//获取绝对路径的规范表示
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(f.lastModified());//获取文件最后修改时间
            System.out.println(f.length());//获取文件大小，按字节算。
        }

对文件、目录操作

这里写图片描述

浏览目录中文件和子目录的方法

这里写图片描述

代码如下：

//遍历文件是用的是递归
        public static void ergodic(File f) {
            File[] files = f.listFiles();
           for(File file:files) {
               System.out.println(file.getName());
               if(file.isDirectory()) {
                   ergodic(file);
               }
           }

        }
        //递归删除
        public static void delete(File f) {
            if(f.isFile()) {
                f.delete();//如果是文件直接删除
            }else {//如果是目录，需要先删除子文件
                File[] files = f.listFiles();
                for(File file:files) {
                 delete(file);
                }
            }
    f.delete();//删除完子文件之后，最后删除文件夹。

Java IO原理

在java程序中要想获取数据源中的数据，需要在程序和数据源之间建立一个数据输入的通道，这样就能从数据源中获取数据了，如果Java程序中把数据写到数据源中，也需要在程序和数据源之间建立一个数据输出的通道。在java程序中创建流对象时，会自动建立这个数据输入通道，而创建输出流对象时会自动建立这个数据输出通道。

IO原理图

Java中流分类

1) 数据流方向

  • 输入流

  • 输出流

    2) 数据传输单位

  • 字节流

  • 字符流

    3）流功能

  • 节点流：用于直接操作数据源的流。

  • 过滤流：也叫过滤流，是对一个已经存在的流的封装和连接，提供更加强大的读写功能。

IO流的抽象类

这里写图片描述

InputStream常用方法
                 //is.read();//从输入流中读取数据的下一个字节，返回读到的字节值（这个字节值就是一个字节的十进制的值，比如读a，a是一个字符，就占一个字节，所以返回的值就是97），若遇到流结尾返回-1.
                 //is.read(b);//从输入流中读取b.len个字节数据并存储到缓冲区b数组中，返回是实际读到的字节数。
                 //is.read(b, 0,b.length);//读取b.len个字节的数据，并从数组b的off位置开始写到数组中。
OutStream常用方法
                //out.write(b);//将b.length个字节从指定的byte数组写入到输出流
                out.write(97);//指定将规定的一个字节数写入此输出流，（相对应的你写97，就是a）
                //out.write(b, 0, b.length);//将指定的byte数组从偏移量off开始的len个字节写入此输出流。
                out.flush();//刷新此输出流，并强制写出所有缓冲的输出字节。
Reader常用方法

主要以字符为单位进行处理。

            a = reader.read();//读取单个字符，（请注意一个汉字就是一个字符），返回作为整数读取的字符，如果到末尾就是-1
            //reader.read(c);//将字符读入数组中，返回读取的字符数
            //reader.read(c, 0, c.length);//读取len个字符数据，并从数组的off位置开始写到数组中。
Writer常用方法

主要以字符为单位进行处理。

            //w.write("老枪好帅");//写入字符串
            w.write(c);//写入字符数组
            w.write(c);//写入单个字符
            w.write(c, a,c.length);//写入字符数据的一部分
            w.write("", 0, len);//写入字符串的一部分
            w.flush();//刷新该流的缓冲，全部写出来。

文件流

  1. FileInputStream
  2. FileOutputStream
  3. FileReader
  4. FileWriter
            InputStream in = new FileInputStream("");//传入相应处理的文件路径
            OutputStream out  = new FileOutputStream("");
            Reader reader = new FileReader("");
            Writer writer = new FileWriter("");

上面是抽象的Io的实现，你在处理时，根据不同的文件进行相应的选择处理。

缓冲流

为了提高数据的读写速度，java提供了带缓冲流的流类，在使用这些带缓冲功能的流类，它会在内部创建缓冲区数组，在读取字节（创建字节数组）或者字符（创建字符数组）的时候，会把数据先读到缓冲区，然后在返回，在写入字节或者字符，会先把数据填充到内部缓冲区，然后一次性写到目标数据源中。

缓冲区流的分类
  1. BufferInputStream
  2. BufferOutputStream
  3. BufferReader
  4. BufferWriter

缓冲流属于过滤流，也就是说缓冲流不直接操作数据源，而是对直接操作数据源节点流的一个包装，增加功能。

节点流和过滤流区别

下面给出操作字节字符缓冲流代码：

    BufferedOutputStream bos  = null;
        OutputStream out  = null;
        InputStream in  = null;
        BufferedInputStream bis  = null;
        int i = 0;
        try {
             in = new FileInputStream("E:\\Hello.java");
             out  =new FileOutputStream("E:\\Hello1.java");
             bos = new BufferedOutputStream(out);
             bis = new BufferedInputStream(in);
            while((i = bis.read())!=-1){//这里是从缓冲区上一次读一个
                bos.write(i);
            }
            bos.flush();    
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            if(bos!=null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(bis!=null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
 Reader r = null;
      Writer w = null;
      BufferedReader br = null;
      BufferedWriter bw = null;
      String str = null;
     try {
         r = new FileReader("E:\\Hello.java");
         w = new FileWriter("E:\\Hello2.java");
         br = new BufferedReader(r);
         bw = new BufferedWriter(w);
         while((str = br.readLine())!=null) {//这个操作字符流和原来不一样，一次读一行。
             bw.write(str);
         }
         bw.flush();
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }finally {
        if(br!=null) {
            try {
                br.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        if(bw!=null) {
            try {
                bw.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

在实际操作中，还是推荐使用第二种操作文件更方便。

注意在使用过滤流的过程中，它是对底层的节点流封装，所以在我们手动关闭了过滤流的时候，就不需要手动关闭节点流。

转换流

有时我们需要在字节流和字符流中进行转化，使用到InputStream Reader 和OutputStreamWriter。

  1. InputStream Reader
        //InputStreamReader isr = new InputStreamReader(in);//传入字节流，转化成默认字符流读。
        //InputStreamReader isr1 = new InputStreamReader(in, charsetName);//传入字节流，按照指定编码转化为字符流读。

用于将字节流中读取到的字节按字符集解码成字符。

  1. OutputStreamWriter

用于将要写入到字节流中的字符按照置顶字符集编码成字节。

        OutputStreamWriter osw = new OutputStreamWriter(out);//传入字节流，转化成默认的字符流写入
        OutputStreamWriter osw1 = new OutputStreamWriter(out, cs);//传入字节流，按照指定编码转化为字符流写

例子：

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //从键盘上获取的是字符，通过转换流来变成字符流操作，更便捷。

        try {
            while((content = br.readLine())!=null) {
                if(content.equalsIgnoreCase("e")) {
                    break;
                }else {
                    System.out.println(content.toUpperCase());
                }
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
数据流

用于操作Java语言的基本数据类型的数据，主要有这两个类：DataInputStream和DataOutputStream。

这里写图片描述

代码如下:

DataOutputStream dis  = null;
        DataInputStream is = null;
        InputStreamReader isr = null;
        BufferedReader br = null;
        String content = null;
        try {
            dis= new DataOutputStream(new FileOutputStream("E:\\data.txt"));
            dis.writeInt(87);
            dis.writeBoolean(true);
            dis.writeUTF("中国");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            is = new DataInputStream(new FileInputStream("E:\\data.txt"));
            int a = is.readInt();//需要注意的是这里在读取的时候必须使用DataInputStream
            //否则出现乱码
            boolean b = is.readBoolean();
            String c = is.readUTF();

            System.out.println(a);
            System.out.println(b);
            System.out.println(c);

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
对象流

ObjectOutputStream和ObjectInputStream类是用来存储和读取基本类型数据或对象的过滤流，它的强大之处就是可以把Java中的对象写到数据源中，也能把对象从数据源中还原回来。用ObjectOutputStream类保存基本数据类型或者对象叫序列化，用ObjectInputStream类读取基本数据类型或者对象的机制叫做反序列化。ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量。

序列化:

//定义一个可以序列化的类

public class Student implements Serializable{
   private String name;
   private   transient int age;//不能序列化的属性
   private String sex;
public Student(String name, int age, String sex) {
    super();
    this.name = name;
    this.age = age;
    this.sex = sex;
}
public Student() {
    super();
    // TODO Auto-generated constructor stub
}
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 String getSex() {
    return sex;
}
public void setSex(String sex) {
    this.sex = sex;
}
}

在这个序列化中，它的成员变量不能被保存和读取。

序列化的好处在于，它可以将任何实现Serializable接口的对象转化为字节数据。这些数据可以保存在数据源中，以后仍可以恢复成原来的对象状态，即使这些数据通过网络也可以还原。

序列化和反序列化代码：

/*ObjectOutputStream out = null;
            try {
                 out = new ObjectOutputStream(new FileOutputStream("E:\\data2.txt"));
                 out.writeObject(new Student("laoqiang", 23, "男"));
                 out.flush();
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally {
                if(out!=null) {
                    try {
                        out.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }*/
            ObjectInputStream ois = null;
            try {
                ois = new ObjectInputStream(new FileInputStream("E:\\data2.txt"));
            Student s = (Student) ois.readObject();
            System.out.println(s.toString());
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally {
                if(ois!=null) {
                    try {
                        ois.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
序列化版本

凡是实现Serializable接口的类都有一个表示序列化版本标识的静态变量。用来表明类的不同版本之间的兼容性，默认情况下，如果没有直接定义这个变量，它的值是由java运行时根据累的内部细节自动生成，对于不同额java编译器，它的值可能相同也可能不相同。如果对类的源代码修改或者重新编译，该值会变。如果这时还用老版本的类来反序列化的，就会出错。我们建议，用户应该自己定一个，并且给它相应的值。

显式定义serialVersionUID的用途：

  1. 在某些场合，希望类的不同版本对序列化兼容，因此我们需要保证serialVersionUID相同。
  2. 在某些场合，不希望类的不同版本对序列化兼容，因此我们需要保证具有不同的serialVersionUID。
随机存取文件流

RandomAcessFile是一种特殊的流类，它可以在文件的任何地方读取或者写入数据，这是因为它提供文件指针，可以指定下次读取字节的位置。通过seek，可以将文件指针移动到文件内部的任意字节的位置。

随机文件存取流，提供两种方式可读（r），或者是同时读写（rw），不可以单独写。

随机存取文件执限于磁盘文件，不能访问来自网络，或者内存映像的流。

下面的是多线程下载文件：

   private static final String URL= "www.baidu.com" ;
       private static int contentlength = 0;//资源的总字节数
       private static int threadnumber = 10;//线程个数
       private static int everythreaddownoadlength = 0;//每一个线程的需要下载的长度 
       private static int extra = 0;
       private static int start,end = 0;//记录每一个线程的开始和结束
       private static File file = new File("E:\\data3.txt");
        public static void main(String[] args) {
            try {
                URL url = new URL(URL);
                URLConnection conn = url.openConnection();
                contentlength = conn.getContentLength();
                everythreaddownoadlength = contentlength/threadnumber;//计算每个线程需要下载长度
                extra = contentlength%threadnumber;//如果在上面计算每一个线程下载长度不能整除。

                for(int i = 0;i<threadnumber;i++) {
                    start = threadnumber*i;
                    end = start+everythreaddownoadlength-1;//0~9,10~19,20~29
                    if(i ==  threadnumber-1) {//这里的意思，将不能平均的下载量全加给最后一个，因为剩余的不够分给一个线程
                        end = end+extra;
                    }
                    MyThread mt = new MyThread(start, end, file,URL);
                    Thread t = new Thread(mt);
                    t.start();
                }

            } catch (MalformedURLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
}
class MyThread implements Runnable{

    private int start,end,length = 0;
    private File endfile = null;
    private String url = null;
    private BufferedInputStream bis = null;
    private byte[] b = new byte[2048];

    public MyThread(int start, int end, File endfile,String url) {
        super();
        this.start = start;
        this.end = end;
        this.endfile = endfile;
        this.url = url;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        URL url1  =null;
        URLConnection conn = null;
        try {
            url1 = new URL(url);
             conn = url1.openConnection();

        } catch (MalformedURLException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        RandomAccessFile raf = null;
        try {
             raf = new RandomAccessFile(endfile, "rw");
             raf.seek(start);//将文件指针移动到线程开始的位置
             bis = new BufferedInputStream(conn.getInputStream());
             while((length=bis.read(b))!=-1) {
                 raf.write(b, 0, length);//将资源写到目的的文件。
             }

             System.out.println(Thread.currentThread().getName()+"下载好了");

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            if(raf!=null) {
                try {
                    raf.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(bis!=null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

大致思路：获取网路哦资源总长，按照线程个数，让每一个线程从不同开始位置下载。

venus321
关注
专栏目录
java基础案例与开发详解案例源码全
04-04
1.1 Java语言发展简史2 1.2 认识Java语言3 1.2.1 Java语言特性3 1.2.2 JavaApplet4 1.2.3 丰富的类库4 1.2.4 Java的竞争对手5 1.2.5 Java在应用领域的优势7 1.3 Java平台的体系结构7 1.3.1 JavaSE标准版8 1.3.2 JavaEE企业版10 1.3.3 JavaME微型版11 1.4 JavaSE环境安装和配置12 1.4.1 什么是JDK12 1.4.2 JDK安装目录和实用命令工具介绍12 1.4.3 设置环境变量13 1.4.4 验证配置的正确性14 1.5 MyEcilpse工具介绍JavaSE环境安装和配置15 1.6 本章练习16 第2章 2.1 什么是程序18 2.2 计算机中的程序18 2.3 Java程序19 2.3.1 Java程序中的类型19 2.3.2 Java程序开发三步曲21 2.3.3 开发Java第一个程序21 2.3.4 Java代码中的注释23 2.3.5 常见错误解析24 2.4 Java类库组织结构和文档27 2.5 Java虚拟机简介28 2.6 Java技术两种核心运行机制29 2.7 上机练习30 第3章 3.1 变量32 3.1.1 什么是变量32 3.1.2 为什么需要变量32 3.1.3 变量的声明和赋值33 3.1.4 变量应用实例33 3.2 数据的分类34 3.2.1 Java中的八种基本数据类型34 3.2.2 普及二进制36 3.2.3 进制间转换37 3.2.4 基本数据类型间转换38 3.2.5 数据类型应用实例38 3.2.6 引用数据类型39 3.3 关键字.标识符.常量39 3.3.1 变量命名规范39 3.3.2 经验之谈－常见错误的分析与处理40 3.3.3 Java标识符命名规则41 3.3.4 关键字42 3.3.5 常量42 3.4 运算符43 3.4.1 算术运算符43 3.4.2 赋值操作符45 3.4.3 关系操作符47 3.4.4 逻辑操作符48 3.4.5 位操作符49 3.4.6 移位运算符49 3.4.7 其他操作符50 3.5 表达式52 3.5.1 表达式简介52 3.5.2 表达式的类型和值52 3.5.3 表达式的运算顺序52 3.5.4 优先级和结合性问题52 3.6 选择结构54 3.6.1 顺序语句54 3.6.2 选择条件语句54 3.6.3 switch结构59 3.6.4 经验之谈-常见错误的分析与处理65 3.6.5 Switch和多重if结构比较66 3.7 循环语句66 3.7.1 While循环67 3.7.2 经验之谈-常见while错误70 3.7.3 do-while循环72 3.7.4 for循环74 3.7.5 经验之谈-for常见错误76 3.7.6 循环语句小结78 3.7.7 break语句79 3.7.8 continue语句82 3.8 JavaDebug技术84 3.9 本章练习85 第4章 4.1 一维数组90 4.1.1 为什么要使用数组90 4.1.2 什么是数组91 4.1.3 如何使用数组92 4.1.4 经验之谈-数组常见错误97 4.2 常用算法98 4.2.1 平均值,最大值,最小值98 4.2.3 数组排序102 4.2.3 数组复制103 4.3 多维数组105 4.3.1 二重循环105 4.3.2 控制流程进阶107 4.3.3 二维数组111 4.4 经典算法113 4.4.1 算法-冒泡排序113 4.4.2 插入排序115 4.5 增强for循环116 4.6 本章练习117 第5章 5.1 面向过程的设计思想120 5.2 面向对象的设计思想120 5.3 抽象121 5.3.1 对象的理解121 5.3.2 Java抽象思想的实现122 5.4 封装124 5.4.1 对象封装的概念理解124 5.4.2 类的理解125 5.4.3 Java类模板创建125 5.4.4 Java中对象的创建和使用127 5.5 属性130 5.5.1 属性的定义130 5.5.2 变量131 5.6 方法132 5.6.1 方法的定义132 5.6.2 构造方法135 5.6.4 方法重载138 5.6.5 自定义方法138 5.6.6 系统提供方法139 5.6.7 方法调用140 5.6.8 方法参数及其传递问题144 5.6.9 理解main方法语法及命令行参数147 5.6.1 0递归算法147 5.7 this关键字148 5.8 JavaBean149 5.9 包150 5.9.1 为什么需要包？150 5.9.2 如何创建包151 5.9.3 编译并生成包：151
java基础与案例开发详解_《Java基础与案例开发详解》笔记（一）
weixin_29351901的博客
03-08 175
我们都知道学习java，必不可少的就是jdk，jdk也经过了一系列的发展。由上图可见，整个jdk的版本经过3次变化。jdk-j2se-javasejava命令行在cmd下，找到对应的java文件，通过以下两个程序进行编译、运行javac 是用来进行编译的java是用来进行执行的javac hello.javajava hello在这里需要注意的是源文件的名字一定要和java类的名字一致java注解...
《Java基础与案例开发详解》（五）
venus321的博客
10-07 316
Java反射机制 Java反射提供的功能 Java反射常用类 Class类 Java反射机制 反射是Java语言的特征之一，它允许动态地发现和绑定类、方法、字段，以及所有其他的语言所产生的元素，反射可以做的不仅仅是简单的列举类、字段以及方法。通过反射，还能够在需要时完成创建实例、调用方法，和访问字段。反射是Java被视为动态的关键。 Java反射提供的功能 在运行时判
《Java基础与案例开发详解》笔记（一）
venus321的博客
09-14 621
java基础总结与回顾
Java基础与案例开发详解のjava语言基础入门
爱的叹息的专栏
06-26 921
变量是存储数据的基本单元，生活实例与变量之间的关系 变量的声明和赋值三部曲 变量的8种分类和转义字符 小知识和注意事项 普及二进制、八进制、十六进制以及之间的转换 基本数据类型之间的转换 变量命名规范 变量命名常见的三点错误的分析与处理 java标识符命名规则 关键字 常量 运算符种类 表达式优先级 条件语句种类
Java软件开发实战 Java基础与案例开发详解 6-8 接口 共10页.pdf
07-07
在《Java软件开发实战：Java基础与案例开发详解》这一系列教程中，第6章的第8节重点介绍了接口（Interface）的相关知识。接口在Java编程语言中扮演着极其重要的角色，它是一种抽象类型，用于指定一组行为规范或契约...
Java软件开发实战 Java基础与案例开发详解 6-1 继承 共12页.pdf
最新发布
07-07
### Java软件开发实战：Java基础与案例开发详解之继承 #### 6-1 继承 **学前提示：** 在Java面向对象编程中，继承是一个非常重要的概念，它支持代码的重用，使得大型程序更加易于管理和维护。通过继承，一个类可以...
Java软件开发实战 Java基础与案例开发详解 5-4 封装 共18页.pdf
07-07
### Java软件开发实战：Java基础与案例开发详解之封装 #### 一、封装的重要性与概念 在面向对象编程中，“封装”（Encapsulation）是一种重要的编程原则和技术手段，用于隐藏对象内部状态和行为的实现细节，仅暴露...
Java软件开发实战 Java基础与案例开发详解 5-3 抽象 共10页.pdf
07-07
### Java软件开发实战：Java基础与案例开发详解之抽象 #### 一、抽象的基本概念 在面向对象编程中，**抽象**是理解面向对象编程思想的第一步，它主要用于描述如何将现实世界中的实体通过编程语言表达出来。抽象的...
Java软件开发实战 Java基础与案例开发详解 1-2 认识java语言 共10页.pdf
07-07
### Java软件开发实战：Java基础与案例开发详解 #### 1-2 认识Java语言 **1.2.1 Java语言的特性** Java是一种功能强大且用途广泛的编程语言，其核心特性包括： 1. **简单高效**：Java语言的设计理念之一就是简单...
java基础开发与案例详解代码
01-22
java基础开发与案例详解的代码，可以自行研究学习，不难。
JSP基础与案例开发详解2
03-05
JSP基础与案例开发详解书本中的源代码，能够编译运行通过，由于太大这是下半部分，上以传。
JSP基础与案例开发详解配书源码（全部）
10-08
该资源是《JSP基础与案例开发详解》的随书源代码。提供了书中从第一章-第十七章中讲解的开发工具和源代码。 目录如下： 第1章：Jsp开发的基本知识以及一些常用软件的安装和配置。 第2章：网页布局与修饰，为前端开发做一些必要的知识储备。 第3章：JDBC应用，这是JSP开发中与Java联系最为紧密的知识点。 第4章：Serlet应用，这是JSP开发中最核心、最基础的部分。 第5章：JSP应用，这是JSP开发中最基础的部分，是读者必须掌握的部分。 第6章：EL表达式的使用，这是提高JSP编码质量的部分，建议读者掌握。 第7章：自定义标签的使用，这是优化JSP学习中较难于理解的部分，
Java基础与案例开发详解のJava IO流操作
爱的叹息的专栏
07-31 333
Java中对文件和目录的操作都是File对象
Java基础知识（结合案例讲解）
小庄的博客
07-06 2420
1、Java结构和main函数 2、基本类型 3、变量和常量 4、运算符 5、字符串与输入输出 6、选择和循环结构 7、大数和数组
《java基础与案例开发详解》笔记(二)
venus321的博客
09-16 415
构造函数 当在一个类中，没有提供构造函数时，系统会默认提供无参的构造函数。 如果类中包含了自己定义的有参构造函数，则系统不默认提供无参的构造函数，需要自己显性提供。 方法的重载 一个类中可以有多个名字，但是参数列表（参数的类型、个数、顺序）不同的多个方法，调用时，会根据不同的参数列表来选择对应的方法。构造方法也是可以重载的。
Java基础与案例开发详解の反射机制（完整）
爱的叹息的专栏
07-05 583
反射机制主要提供以下功能反射机制所需要的类如下Class类获得Class对象的三种方法package com.burns.test;public class GetClassTest2 { public static void main(String[] args) throws ClassNotFoundException { // 方法一：类型名.class
Java基础与案例开发详解の抽象和封装
爱的叹息的专栏
06-28 755
面向过程和面向对象的设计思想 了解抽象的概念 抽象就是把现实生活中的对象抽象成属性和方法，如下图： 了解封装的概念 抽象和封装的总结 类的创建（类封装图、类创建的步骤） java中对象的创建和使用 属性的定义（属性分常量属性和成员属性） 变量的定义（变量分全局变量和成员变量） 方法的定义 操作的实际实现；方法指定操作对象数据的方式；如何执行所请求的操作范围；在得到操作请
java程序实例讲解_Java基础：程序开发流程及实例讲解[图例]
weixin_35708609的博客
02-17 842
摘要：本文讲解的是java程序设计开发的流程。通过EclipseIDE与Netbeans IDE编程，结合实例讲解，分享自己的java开发经验。开发流程：1.目的及需求分析2.程序设计3.清理与生成；开发工具：基于两大主流开发工具，Netbeans IDE和Eclipse；实例：查看本机物理地址及IP1.基于Eclipse IDE开发1.1目的及需求分析一键查看本地物理地址及IP，免去先打开cmd...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值