JAVA学习笔记（高级篇）【网络编程】

最新推荐文章于 2023-02-04 11:07:28 发布
最新推荐文章于 2023-02-04 11:07:28 发布
阅读量291 收藏
点赞数
分类专栏： 笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LQwraith/article/details/118056892
版权

网络编程

网络编程入门

概述

在网络通信协议下，实现网络互联的不同计算机上运行的程序间可以进行程序间的数据交换。

网络编程三要素

  • IP地址：要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号 ，通过这个标识号来指定要接收数据的计算机和识别发送的计算机，而IP地址就是这个标识号。也就是设备的标识
  • 端口：网络的通信，本质上是两个应用程序的通信。每台计算机都有很多的应用程序，那么在网络通信时,如何区分这些应用程序呢?如果说IP地址可以唯一标识网络中的设备, 那么端口号就可以唯一标识设备中的应用程序了。也就是应用程序的标识
  • 协议：通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议,它对数据的传输格式、传输速率、传输步骤等做了统规定, 通信双方必须同时遵守才能完成数据交换。常见的协议有UDP协议和TCP协议

IP地址

网络设备的唯一标识，分为两大类：

  • IPV4：是给每个连接在网络上的主机分配一个32bi地址。 按照TCP/IP规定, IP地址用二进制来表示，每个IP地址长32bit,也就是4个字节。例如一个采用二进制形式的IP地址是“11000000 10101000 00000001 01000010" ,这么长的地址，处理起来也太费劲了。为了方便使用，IP地址经常被写成十进制的形式，中间使用符号“." 分隔不同的字节。于是，. 上面的IP地址可以表示为“192.168.1.66” 。IP地址的这种表示法叫做“点分十进制表示法”，这显然比1和0容易记忆得多
  • IPV6：由于互联网的蓬勃发展, IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。为了扩大地址空间，通过IPv6重新定义地址空间，采用128位地址长度,每16个字节一组， 分成8组十六进制数,这样就解决了网络地址资源数量不够的问题

InetAddress的使用

InetAddress：此类表示Internet协议（IP）地址

方法名说明
static InetAddress getByName(String host)确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址
String getHostName()获取此IP地址的主机名
String getHostAddress()返回文本显示中的IP地址字符串
	 public static void main(String[] args) throws UnknownHostException {
        InetAddress address = InetAddress.getByName("Wraith");

        String name = address.getHostName();
        String ip = address.getHostAddress();

        System.out.println(name);
        System.out.println(ip);
    }

在这里插入图片描述

端口和协议

端口

设备上应用程序的唯一标识
端口号：端口号:用两个字节表示的整数，它的取值范围是0-65535。其中，0-1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败

协议

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

UDP协议

用户数据报协议
UDP是无连接通信协议，即在数据传输时,数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时,发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。
由于使用UDP协议消耗资源小，通信效率高,所以通常都会用于音频、视频和普通数据的传输。
例如视频会议通常采用UDP协议，因为这种情况即使偶尔丢失一两个数据包， 也不会对接收结果产生太影响。但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议

TCP协议

传输控制协议
TCP协议是面向连接的通信协议，即传输数据之前,在发送端和接收端建立逻辑连接,然后再传输数据,它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”

三次握手

TCP协议中,在发送数据的准备阶段,客户端与服务器之间的三次交互，以保证连接的可靠

  • 第一次握手,客户端向服务器端发出连接请求,等待服务器确认
  • 第二次握手，服务器端向客户端回送一个响应, 知客户端收到了连接请求
  • 第三次握手，客户端再次向服务器端发送确认信息，确认连接
    完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。

由于这种面向连接的特性,TCP协议可以保证传输数据的安全，所以应用十分广泛。例如上传文件、下载文件、 浏览网页等

UDP通信程序

UDP协议是一种不可靠的网络协议, 它在通信的两端各建立一个Socket对象， 但是这两个Socket只是发送,接收数据的对象
因此对于基于UDP协议的通信双方而言，没有所谓的客户端和服务器的概念
Java提供了DatagramSocket类作为基于UDP协议的Socket

UDP发送数据

  • 创建发送端的Socket对象(DatagramSocket)
    DatagramSocket()
  • 创建数据,并把数据打包
    DatagramPacket(byte[] buf, int length, InetAddress address, int port)
  • 调用DatagramSocket对象的方法发送数据
    void send(DatagramPacket p)
  • 关闭发送端
    void close()
   public static void main(String[] args) throws IOException {
        //创建发送端的Socket对象
        DatagramSocket ds = new DatagramSocket();
        //创建数据并把数据打包
        byte[] bys = "hello,my homie".getBytes(StandardCharsets.UTF_8);
        DatagramPacket dp = new DatagramPacket(bys,bys.length, InetAddress.getByName("192.168.1.35"),10086);
        //调用DatagramSocket对象的方法发送数据
        ds.send(dp);
        //关闭发送端
        ds.close();
    }

UDP接收数据

  • 创建接收端的Socket对象(DatagramSocket)
    DatagramSocket(int port)
  • 创建一 个数据包，用于接收数据
    DatagramPacket(byte[] buf, int length)
  • 调用DatagramSocket对象的方法接收数据
    void receive(DatagramPacketp)
  • 解析数据包， 并把数据在控制台显示
    byte[] getData()
    int getLength()
  • 关闭接收端
    void close()
     //创建接收端Socket对象
        DatagramSocket ds = new DatagramSocket(10086);
        //创建数据包用于接受数据
        byte[] bys = new byte[1024];
        DatagramPacket dp = new DatagramPacket(bys,bys.length);
        //调用DatagramSocket对象的方法接受数据
        ds.receive(dp);
        //解析数据包，并把数据在控制台显示
        System.out.println(new String(dp.getData(),0,dp.getLength()));
        //关闭接收端
        ds.close();

练习

  • UDP发送数据:数据来自于键盘录入，直到输入的数据是886,发送数据结束
  • UDP接收数据:因为接收端不知道发送端什么时候停止发送，故采用死循环接收

发送端

  public static void main(String[] args) throws IOException {
        //创建发送端的Socket对象
        DatagramSocket ds = new DatagramSocket();
        //封装键盘录入数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line;
        while((line = br.readLine())!=null) {
            if ("886".equals(line)) {
                break;
            }
            //创建数据并把数据打包
            byte[] bys = line.getBytes();
            DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.1.35"), 12345);
            //调用DatagramSocket对象的方法发送数据
            ds.send(dp);
        }
        //关闭发送端
        ds.close();
    }

接收端

public static void main(String[] args) throws IOException {
        //创建接收端Socket对象
        DatagramSocket ds = new DatagramSocket(12345);
        //创建数据包用于接受数据
        while(true){
        byte[] bys = new byte[1024];
        DatagramPacket dp = new DatagramPacket(bys,bys.length);
        //调用DatagramSocket对象的方法接受数据
        ds.receive(dp);
        //解析数据包，并把数据在控制台显示
        System.out.println(new String(dp.getData(),0,dp.getLength()));
        }
        //关闭接收端
//        ds.close();
    }

TCP通信程序

TCP通信协议是一种可靠的网络协议， 它在通信的两端各建立一个Socket对象, 从而在通信的两端形成网络虚拟链路,一旦建立 了虚拟的网络链路,两端的程序就可以通过虚拟链路进行通信

TCP发送数据

  • 创建客户端的Socket对象(Socket)
    Socket(String host, int port)
  • 获取输出流，写数据
    OutputStreamgetOutputStream()
  • 释放资源
    void close()
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.35", 10000);
        //获取输出流，写数据
        OutputStream os = s.getOutputStream();
        os.write("hello,my sweetheart".getBytes());
        //释放资源
        s.close();
    }

TCP接受数据

  • 创建服务 器端的Socket对象(ServerSocket)
    ServerSocket(int port)
  • 监听客户端连接， 返回一个Socket对象
    Socket accept()
  • 获取输入流， 读数据，并把数据显示在控制台
    InputStream getInputStream()
  • 释放资源
    void close()

客户端发数据

    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.35", 12345);
        //获取输出流，写数据
        OutputStream os = s.getOutputStream();
        os.write("hello,my sweetheart".getBytes());
        //释放资源
        s.close();
    }

服务端读数据

  public static void main(String[] args) throws IOException {
        //创建服务器端ServerSocket对象
        ServerSocket ss = new ServerSocket(12345);
        //Socket accept()侦听要连接到此套接字并接受它
        Socket s= ss.accept();
        //获取输入流，读数据，并把数据显示在控制台
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String (bys,0,len);
        System.out.println(data);
        //释放资源
        s.close();
        ss.close();
    }

练习

Demo1（服务器给出反馈）

  • 客户端:发送数据，接收服务器反馈
  • 服务器:接收数据，给出反馈
    客户端
 public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.35", 12345);
        //获取输出流，写数据
        OutputStream os = s.getOutputStream();
        os.write("hello,my sweetheart".getBytes());
        //接受服务器反馈
        InputStream is= s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys,0,len);
        System.out.println(data);
        //释放资源
        s.close();
    }

服务器端

 public static void main(String[] args) throws IOException {
        //创建服务器端ServerSocket对象
        ServerSocket ss = new ServerSocket(12345);
        //Socket accept()侦听要连接到此套接字并接受它
        Socket s= ss.accept();
        //获取输入流，读数据，并把数据显示在控制台
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String (bys,0,len);
        System.out.println(data);
        //给出反馈
        OutputStream os = s.getOutputStream();
        os.write("数据已收到".getBytes());
        //释放资源
//        s.close();
        ss.close();
    }

Demo2（客户端数据来自于键盘录入）

  • 客户端：数据来自于键盘录入，直到输入的数据是886，发送数据结束
  • 服务器：接收到的数据在控制台输出

客户端

    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.35", 12345);
        //数据来自键盘录入，直到输入886，发送数据结束
        BufferedReader br =new BufferedReader(new InputStreamReader(System.in));
        //封装输入对象
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        String line;
        while((line=br.readLine())!=null){
            if("886".equals(line)){
                break;
            }
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //释放资源
        s.close();
    }

服务器端

public static void main(String[] args) throws IOException {
        //创建服务器端ServerSocket对象
        ServerSocket ss = new ServerSocket(12345);
        //Socket accept()侦听要连接到此套接字并接受它
        Socket s= ss.accept();
        //获取输入流，读数据，并把数据显示在控制台
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String line;
        while((line= br.readLine())!=null){
            System.out.println(line);
        }
//        s.close();
        ss.close();
    }

Demo3（服务器数据写入文本文件）

  • 客户端:数据来自于键盘录入，直到输入的数据是886,发送数据结束
  • 服务器:接收到的数据写入文本文件

客户端

    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.35", 12345);
        //数据来自键盘录入，直到输入886，发送数据结束
        BufferedReader br =new BufferedReader(new InputStreamReader(System.in));
        //封装输入对象
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        String line;
        while((line=br.readLine())!=null){
            if("886".equals(line)){
                break;
            }
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //释放资源
        s.close();
    }

服务器端

 public static void main(String[] args) throws IOException {
        //创建服务器端ServerSocket对象
        ServerSocket ss = new ServerSocket(12345);
        //监听客户端链接，返回一个对应的Socket对象
        Socket s= ss.accept();
        //获取输入流，读数据
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        BufferedWriter bw =new BufferedWriter(new FileWriter("TCP.txt"));

        String line;
        while((line= br.readLine())!=null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
//        s.close();
        bw.close();
        ss.close();
    }

Demo4（客户端数据来自于文本文件）

  • 客户端:数据来自于文本文件
  • 服务器:接收到的数据写入文本文件
    客户端
 public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.35", 12345);
        //封装文本文件的数据
        BufferedReader br =new BufferedReader(new FileReader("FileOutputStreamDemo.java"));
        //封装输出流写数据
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        String line;
        while((line=br.readLine())!=null){
          bw.write(line);
          bw.newLine();
          bw.flush();
        }
        //释放资源
        br.close();
        s.close();
    }

服务器端

 public static void main(String[] args) throws IOException {
        //创建服务器端ServerSocket对象
        ServerSocket ss = new ServerSocket(12345);
        //监听客户端链接，返回一个对应的Socket对象
        Socket s= ss.accept();
        //接收数据
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        //把数据写入文本文件
        BufferedWriter bw =new BufferedWriter(new FileWriter("Copy.java"));

        String line;
        while((line= br.readLine())!=null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
//        s.close();
        bw.close();
        ss.close();
    }

Demo5（上传文件服务器给出反馈）

  • 客户端:数据来自于文本文件，接收服务器反馈
  • 服务器:接收到的数据写入文本文件，给出反馈
  • 出现问题:程序-直等待
  • 原因:读数据的方法是阻塞式的
  • 解决办法:自定义结束标记;使用shutdownOutput()方法(推荐)

客户端

    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.35", 12345);
        //封装文本文件的数据
        BufferedReader br =new BufferedReader(new FileReader("FileOutputStreamDemo.java"));
        //封装输出流写数据
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        String line;
        while((line=br.readLine())!=null){
          bw.write(line);
          bw.newLine();
          bw.flush();
        }
        s.shutdownOutput();
        //接受反馈
        BufferedReader brSend = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String data = brSend.readLine();
        System.out.println(data);
        //释放资源
        br.close();
        s.close();
    }

服务器端

   public static void main(String[] args) throws IOException {
        //创建服务器端ServerSocket对象
        ServerSocket ss = new ServerSocket(12345);
        //监听客户端链接，返回一个对应的Socket对象
        Socket s= ss.accept();
        //接收数据
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        //把数据写入文本文件
        BufferedWriter bw =new BufferedWriter(new FileWriter("Copy.java"));

        String line;
        while((line= br.readLine())!=null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //给出反馈
        BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        bwServer.write("文件上传成功");
        bwServer.newLine();
        bwServer.flush();

//        s.close();
        bw.close();
        ss.close();
    }

Demo6（多线程实现文件上传）

  • 客户端:数据来自于文本文件，接收服务器反馈
  • 服务器:接收到的数据写入文本文件,给出反馈,代码用线程进行封装，为每一个客户端开启一个线程

客户端

public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.35", 12345);
        //封装文本文件的数据
        BufferedReader br =new BufferedReader(new FileReader("FileOutputStreamDemo.java"));
        //封装输出流写数据
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        String line;
        while((line=br.readLine())!=null){
          bw.write(line);
          bw.newLine();
          bw.flush();
        }
        s.shutdownOutput();
        //接受反馈
        BufferedReader brSend = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String data = brSend.readLine();
        System.out.println(data);
        //释放资源
        br.close();
        s.close();
    }

服务器端

 public static void main(String[] args) throws IOException {
        //创建服务器端ServerSocket对象
        ServerSocket ss = new ServerSocket(12345);

        while (true) {
            //监听客户端链接，返回一个对应的Socket对象
            Socket s = ss.accept();
            //为每一个客户端开一个线程
            new Thread(new ServerThread(s)).start();
        }
    }

服务器多线程类

public class ServerThread implements Runnable {
    private Socket s;
    public ServerThread(Socket s) {
        this.s=s;
    }

    @Override
    public void run() {
        //接受数据写到文本文件
        try {
            BufferedReader br =new BufferedReader(new InputStreamReader(s.getInputStream()));
//            BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));

            int count = 0;
            File file =new File("Copy["+count+"].java");
            while(file.exists()) {
                count++;
                file = new File("Copy[" + count + "].java");
            }
            BufferedWriter bw = new BufferedWriter(new FileWriter(file));
            String line;
            while((line= br.readLine())!=null){
                bw.write(line);
                bw.newLine();
                bw.flush();
            }
            //给出反馈
            BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
            bwServer.write("文件上传成功");
            bwServer.newLine();
            bwServer.flush();

            //释放资源
            s.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
西邮王嘉尔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java高级笔记
qq_27295923的博客
09-09 522
异常 （一）概念 1．异常的产生 异常就是程序中发生的所有不正常的现象,类似于人会生病是一样的道理,异常是Java的重大特色,合理地使用异常处理,可以让我们程序更加健壮. 异常是导致程序中断执行的一种指令流,异常一旦出现并且没有进行合理的处理的话,那么程序就将中断执行. 一旦产生异常之后发现产生异常的语句以及后面的语句将不再执行,默认情况下是进行异常信息的输出,而后自动结束程序的执行. 程序员要做...
JAVA高级学习笔记
qq_43120640的博客
09-15 519
JAVA高级笔记 一、多线程 程序、进程、线程 了解 优点 创建多线程方式一：继承Thread类 创建一个继承与Thread类的子类 重写Thread类的run() 方法 --> 将此线程执行的操作声明在run() 中 创建Thread类的子类的对象 通过此对象去调用Thread的start() 方法 public class ThreadTest { public static void main(String[] args) { MyThread m
Java 笔记之网络编程入门
qq_32473523的博客
12-17 225
网络编程入门 网络编程概述 计算机网络：是将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议管理和协调下，实现资源共享和信息传递的计算机系统。 网络编程：在网络通信协议下，实现网络互连的不同计算机上运行的程序间可以进行数据交换。 网络编程的三要素 1.IP地址：要想让网络中的计算机能够相互通信，必须为每台计算机指定一个标识号，通过这个标识号来指定要接受数据的计算机和识别发送的计算机，而IP地址就是这个标识号。也就是设备的标识。
JAVA高级笔记
zhangMY12138的博客
08-05 522
工具类 Object类 它是所有类默认继承的父类，在Object类中定义的方法，所有的类都默认继承。 equals方法：判断两个对象是否“相等” Object中equals方法相当于“==”，比较的是内存地址 A instanceof B 变量（对象）A是否是类（Class）B的实例 True  A是B的一个对象 False  A对象的类型不是B 通过重写equals方法完成自己判断...
Java笔记高级篇
最新发布
QWQ___qwq的博客
02-04 592
简单性：相对于其他编程语言而言，java较为简单，例如：java不再支持多继承，C++是支持多继承的，多继承比较复杂，C++中有指针，java中屏蔽了指针的概念，避免了绝大部分的指针越界和内存泄露的问题，这里说明一下，java语言低层是用C++实现的，并不是C语言。健壮性：java的健壮性与自动垃圾回收机制有关，自动垃圾回收机制简称GC机制，java语言运行过程中产生的垃圾是自动回收的，不需要程序员关心。面向对象：java是纯面向对象的，更符合人的思维模式，易于理解。java的编译与运行。
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
Java并发编程学习笔记
04-11
Java并发编程是Java开发中必不可少的一部分，涉及到多线程、同步机制、线程池以及并发工具类等多个核心知识点。以下是对这些主题的详细说明： 1. **线程安全与锁 Synchronized 底层实现原理**： 线程安全是指在多...
java学习笔记markdown
03-12
通过学习这份Markdown版的Java学习笔记，不仅可以掌握Java编程的基础，还能了解到一些高级话题，为成为熟练的Java开发者打下坚实基础。同时，Markdown格式使得笔记易于编辑和分享，是个人学习和团队协作的理想选择。
java学习笔记
12-22
Java学习笔记涵盖了大量的Java基础知识，包括面向对象编程和高级特性。以下是对这些知识点的详细解释： **基础语法** 1. **数据类型**：Java有基本数据类型和引用数据类型。基本数据类型包括整型（byte, short, int...
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
Java高级应用学习笔记
10-12
Java学习的笔记，希望对大家有帮助！这都是辛苦在网上找的
JAVA基础与高级学习笔记
llzqxl的博客
05-31 631
JAVA基础学习笔记 JAVA基础 java会出现内存溢出和泄露。 JDK与JRE的关系。 a. JDK（Java Development Kit Java开发工具包） JDK是提供给JAVA开发人员使用的，其中包含了Java的开发工具，也包含了JRE，所以安装装了JDK就不用再单独安装JRE了。其中的开发工具：编译工具（javac.exe）,打包工具（jar.exe）、javadoc等。 b. JRE（Java Runtime Enviroment Java运行环境） 包括Java虚拟机（Jav
JavaSE高级篇学习笔记
bryn_li的博客
09-21 1096
基本数据类型的封装类 1.byte Byte char Character short Short int Integer long Long folat Float double Double boolean Boolean 2.自动装箱与拆箱 装箱：把基本数据类型转化为封装类型
Java高级笔记
m0_46925846的博客
01-20 933
Java高级笔记 文章目录Java高级编程自学笔记（康师傅）第一章 多线程一、基本概念：程序、进程、线程多线程的优点 第一章 多线程 一、基本概念：程序、进程、线程 程序： 是为完成特定任务，用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象 进程： 是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程，有他自身的产生，存在和消亡的过程。---------生命周期 线程： 进程可进一步细化为线程，是一个程序内部的一条执行路径 >若一个进程同一时间并
JAVA学习笔记（高级篇）【集合进阶】
LQwraith的博客
06-13 1396
JAVA集合 集合
java笔记高级部分
weixin_33923762的博客
06-08 162
你有没有用过linux？你都用它来做什么？ Linux是一个长时间运行比较稳定的操作系统，我们一般用它来当做服务器。 说一下linux下面的一些常用的命令？ Pwd 获取当前路径 Cd 跳转到目录 Su - u 切换到管理员 Ls-ls 列举目录 你是使用什么来连接远程的Linux服务器的？ 使用xshell、putty等ssh客户端来连接服务器，使用xftp、winscp等sf...
Java高级编程找不到数据库_JAVA高级编程基础自学笔记---数据库编程（JDBC）
weixin_39946274的博客
02-24 235
JDBC严格来讲并不是一门技术，它属于一种服务。服务的特点：所有操作流程都是固定的，提供数据库有操作的标准(它就是一组相关的标准接口)，而不同的数据库的生产商要依据此标准自己的具体实现。用户不关注厂商的实现。JDBC一定是按照固定的代码编写形式使用的。 连接Oracle数据库(重点) 下面按照指定的不再来实现数据库的连接操作：1.配置数据库驱动程序本次将使用oracle数据库提供的数据库连接的...
JAVA高级应用学习笔记----流
weixin_33811539的博客
10-24 98
Stream (流):数据从一端到另一端字节流:读写二进制的对象字符流:读写的都是字符方法:ReaderWrite文件:相关记录数据的集合 JAVA.io.File**************************************java.io.file的常用方法：File(File parent,String child)文件路径...
CoreJava学习笔记：基础术语与编程规范解析
"CoreJava学习笔记，包含了学习方法、Java基础术语、环境变量配置以及包的使用等内容，适合Java初学者参考。" Java是世界上最流行的编程语言之一，尤其在企业级应用开发领域占据着主导地位。CoreJava是Java的基础，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值