【Java 18】网络编程 - 概述、网络编程要素、IP和端口号、网络协议、TCP、UDP、URL

最新推荐文章于 2022-11-26 14:53:57 发布
最新推荐文章于 2022-11-26 14:53:57 发布
阅读量174 收藏
点赞数
分类专栏： Java Learning Java 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a903003911/article/details/108374157
版权
Java 同时被 3 个专栏收录
32 篇文章 0 订阅
订阅专栏
笔记
25 篇文章 0 订阅
订阅专栏
Java Learning
20 篇文章 0 订阅
订阅专栏

网络编程 - 概述、网络编程要素、IP和端口号、网络协议、TCP、UDP、URL

网络编程

image-20200902193546395

1 网络编程概述

image-20200902193649174

image-20200902193655798

  • 网络编程中有两个主要的问题：

    • 如何准确地定位网络上一台或多台主机；定位主机上的特定的应用
    • 找到主机后如何可靠高效地进行数据传输

  • 网络编程中的两个要素：

    • 对应问题一：IP和端口号
    • 对应问题二：网络通信协议：TCP/IP参考模型（应用层、传输层、网络层、物理+数据链路层）

2 网络通信要素概述

image-20200902193707141

image-20200902193714769

image-20200902193721360

3 通信要素1：IP和端口号

IP：Internet Protocol

3.1 内容

image-20200902193729487

image-20200902193735312

image-20200902193741129

通信要素一：IP和端口号

  • IP：唯一的标识 Internet 上的计算机（通信实体）

  • 在Java中使用InetAddress类代表IP

  • IP分类：IPv4 和 IPv6；万维网 和 局域网

  • 域名：www.baidu.com

  • 本地回路地址：127.0.0.1

    对应着：localhost

  • 如何实例化InetAddress（无构造器）：

    • 两个获取InetAddress实例方法：
      • public static InetAddress getByName(String host)
      • public static InetAddress getLocalHost()
    • 两个常用方法：
      • public String getHostName()：获取此 IP 地址的主机名【域名】
      • public String getHostAddress()：返回 IP 地址字符串（以文本表现形式）【IP地址】

  • 端口号：正在计算机上运行的进程

    要求：不同进程有不同的端口号

    范围：被规定维一个16位的整数0~65535

  • 端口号与IP地址的组合得出一个网络套接字：Socket

3.2 InetAddress类

3.2.1 概述

image-20200902193750310

image-20200902193754856

3.2.2 方法

image-20200902193802436

3.2.3 代码实例

image-20200902193809116

public class InetAddressTest {

    public static void main(String[] args) {

        try {
            //File file = new File("hello.txt");
            InetAddress inet1 = InetAddress.getByName("192.168.10.14");
            System.out.println(inet1);

            InetAddress inet2 = InetAddress.getByName("www.wumiaojie.com");
            System.out.println(inet2);

            InetAddress inet3 = InetAddress.getByName("127.0.0.1");
            System.out.println(inet3);

            //获取本机IP
            InetAddress inet4 = InetAddress.getLocalHost();
            System.out.println(inet4);

            //getHostName()
            //获取此IP地址的主机名
            System.out.println(inet2.getHostName());

            //getHostAddress()
            //返回IP地址字符串
            System.out.println(inet2.getHostAddress());

        } catch (UnknownHostException e) {
            e.printStackTrace();
        }

    }

}

4 通信要素2：网络协议

4.1 内容

image-20200902193817196

4.2 TCP/IP协议簇

image-20200902193821425

4.3 TCP和UDP

image-20200902193829305

4.4 TCP三次握手和四次挥手

image-20200902193837418

  1. 三次握手

    客户端：你好，我是吴

    服务端：你好，我知道你是吴，我是王

    客户端：你好，我知道你知道我是吴，我是吴

  2. UDP：（可用于视频直播）

    导弹全部一次性多量发送，被拦截率低，不管有没有打中

image-20200902193848157

一般是客户端主动断开连接

客户端：我现在想断开连接了

服务端：我接受到你想断开连接的信息了

服务端：我现在已经断开连接了

客户端：发个信息确认是否断开【有没有后话，无则断开了】

4.5 Socket

端口号与IP地址的组合得出一个网络套接字：Socket

image-20200902193854944

image-20200902193903944

5 TCP网络编程

5.1 基于Socket的TCP编程

image-20200902193913536

image-20200902234329888

image-20200902234349504

image-20200902234358105

image-20200902234405254

5.2 代码实例

客户端岛

服务器岛

客户端岛生产了一些产品想卖给服务器岛

于是客户端岛整了一小船（Socket），船里装东西

船有运送的目的，即服务器岛（IP）

服务器岛有多个港口（ServerSocket），船要停在哪里，就需要只能具体的港口号码（端口号）

package com.wmiao.java;

import org.junit.Test;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author wmiao
 * @version 1.0
 * @description: 实现TCP的网络编程
 * 客户端发送信息给服务端，服务端将数据显示在控制台上
 * @date 2020/9/3 0:02
 */

public class TCPTest1 {

    //客户端
    @Test
    public void client() {

        Socket socket = null;
        OutputStream os = null;
        try {
            //1.创建客户端的Socket对象，指明服务器端的ip和端口号
            InetAddress inet = InetAddress.getByName("127.0.0.1");
            socket = new Socket(inet, 8899);

            //2.获取一个输出流，用于输出数据
            os = socket.getOutputStream();

            //3.写出数据的操作
            os.write("你好啊".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.资源的关闭
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    //服务器
    @Test
    public void server(){

        ServerSocket ss = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            //1.创建服务器端的ServerSocket对象，指明自己的端口号
            ss = new ServerSocket(8899);
            //2.调用accept()，表示接收崽子于客户端的socket
            socket = ss.accept();
            //3.获取输入流
            is = socket.getInputStream();

            //不建议这样写，可能有乱码
//        byte[] buffer = new byte[1024];
//        int len;
//        while ((len = is.read(buffer)) != -1){
//            String str = new String(buffer,0,len);
//            System.out.println(str);
//        }

            //4.读取输入流中的数据
            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[5];
            int len;
            while ((len = is.read(buffer)) != -1){
                baos.write(buffer,0,len);//写到了ByteArrayOutputStream类里面的数组，不足会扩容
            }

            System.out.println(baos.toString());

            //获取客户端发送者信息
            //System.out.println("收到了来自于：" + socket.getInetAddress().getHostAddress() + "的数据");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5.关闭资源
            if (baos != null) {
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (ss != null) {
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

}

服务端获取客户端发送者信息

//获取客户端发送者信息
System.out.println("收到了来自于：" + socket.getInetAddress().getHostAddress() + "的数据");

5.3 例题

image-20200902234410693

package com.wmiao.java;

import org.junit.Test;

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author wmiao
 * @version 1.0
 * @description: 例题2：客户端发送文件给服务端，服务端将文件保存在本地
 * @date 2020/9/3 1:26
 */

public class TCPTest2 {

    //客户端
    @Test
    public void client() {
        Socket socket = null;
        OutputStream os = null;
        FileInputStream fis = null;

        try {
            //1.创建客户端的Socket对象，指明服务器端的ip和端口号
            socket = new Socket(InetAddress.getByName("127.0.0.1"),8899);
            //2.获取一个输出流，用于输出数据
            os = socket.getOutputStream();

            //3.创建一个输入流对象，用于从硬盘读入文件到内存
            fis = new FileInputStream(new File("爱情与友情.jpg"));

            //4.文件读入操作 + 文件传输服务端操作
            byte[] buffer = new byte[20];
            int len;
            while ((len = fis.read(buffer)) != -1){
                os.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5.资源的关闭
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    //服务器
    @Test
    public void server(){
        ServerSocket ss = null;
        Socket socket = null;
        InputStream is = null;
        FileOutputStream fos = null;

        try {
            //1.创建服务器端的ServerSocket对象，指明自己的端口号
            ss = new ServerSocket(8899);
            //2.调用accept()，表示接收崽子于客户端的socket
            socket = ss.accept();
            //3.获取输入流
            is = socket.getInputStream();

            //4.创建一个输出流，用于从内存将文件保存到硬盘
            fos = new FileOutputStream(new File("爱情与友情1.jpg"));

            //5.读取输入流中的数据 + 将数据通过FileOutputStream流保存到硬盘
            byte[] buffer = new byte[20];
            int len;
            while ((len = is.read(buffer)) != -1){
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //6.资源的关闭
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (ss != null) {
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }

}

package com.wmiao.java;

import org.junit.Test;

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author wmiao
 * @version 1.0
 * @description: 例题三：从客户端发送文件给服务端，服务端保存到本地。并返回“发送成功”给
 * 客户端。并关闭相应的连接
 * @date 2020/9/3 2:10
 */

public class TCPTest3 {

    //客户端
    @Test
    public void client() {
        Socket socket = null;
        OutputStream os = null;
        FileInputStream fis = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;

        try {
            //1.创建客户端的Socket对象，指明服务器端的ip和端口号
            socket = new Socket(InetAddress.getByName("127.0.0.1"),8899);
            //2.获取一个输出流，用于输出数据
            os = socket.getOutputStream();

            //3.创建一个输入流对象，用于从硬盘读入文件到内存
            fis = new FileInputStream(new File("爱情与友情.jpg"));

            //4.文件读入操作 + 文件传输服务端操作
            byte[] buffer = new byte[20];
            int len;
            while ((len = fis.read(buffer)) != -1){
                os.write(buffer,0,len);
            }

            /*
            重要：这里要告诉服务器端传输数据结束的指示
            socket.shutdownOutput();
            */
            //关闭数据的输出
            socket.shutdownOutput();

            //5.客户端接收服务器端的反馈：“发送成功”
            // 接受来自于服务器端的数据，并显示到控制台上
            is = socket.getInputStream();

            baos = new ByteArrayOutputStream();
            byte[] buffer2 = new byte[20];
            int len2;
            while ((len2 = is.read(buffer2)) != -1){
                baos.write(buffer2,0,len2);
            }

            System.out.println(baos.toString());

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //6.资源的关闭
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (baos != null) {
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    //服务器
    @Test
    public void server(){
        ServerSocket ss = null;
        Socket socket = null;
        InputStream is = null;
        FileOutputStream fos = null;
        OutputStream os = null;

        try {
            //1.创建服务器端的ServerSocket对象，指明自己的端口号
            ss = new ServerSocket(8899);
            //2.调用accept()，表示接收崽子于客户端的socket
            socket = ss.accept();
            //3.获取输入流
            is = socket.getInputStream();

            //4.创建一个输出流，用于从内存将文件保存到硬盘
            fos = new FileOutputStream(new File("爱情与友情3.jpg"));

            //5.读取输入流中的数据 + 将数据通过FileOutputStream流保存到硬盘
            byte[] buffer = new byte[20];
            int len;
            while ((len = is.read(buffer)) != -1){
                fos.write(buffer,0,len);

                /*
                重要：is.read(buffer)是一个阻塞式的方法【没有明确告诉我，我就不会退出循环】
                 */

            }

            //6.服务器端给客户端反馈：“发送成功”
            os = socket.getOutputStream();
            os.write("你好，图片我已经收到，发送成功".getBytes());

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //7.资源的关闭
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (ss != null) {
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}

image-20200902234437616

5.4 练习

image-20200902234442887

image-20200902234641583

6 UDP网络编程

6.1 内容

image-20200902234655895

6.2 常用方法

image-20200902234701362

image-20200902234707443

6.3 代码实例

image-20200902234712494

image-20200902234717364

image-20200902234726270

package com.wmiao.java;

import org.junit.Test;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/**
 * @author wmiao
 * @version 1.0
 * @description: TODO
 * @date 2020/9/3 2:52
 */

public class UDPTest {

    //发送端
    @Test
    public void sender(){

        DatagramSocket socket = null;
        try {
            socket = new DatagramSocket();

            String str = "我是UDP方式发送的导弹";
            byte[] data = str.getBytes();
            InetAddress inet = InetAddress.getLocalHost();
            DatagramPacket packet = new DatagramPacket(data,0,data.length,inet,8899);

            socket.send(packet);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (socket != null) {
                socket.close();
            }
        }

    }

    //接收端
    @Test
    public void receiver(){

        DatagramSocket socket = null;
        try {
            socket = new DatagramSocket(8899);

            byte[] buffer = new byte[100];
            DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);

            socket.receive(packet);

            System.out.println(new String(packet.getData(), 0, packet.getLength()));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (socket != null) {
                socket.close();
            }
        }

    }

}

7 URL编程

7.1 URL类内容

image-20200902234743519

7.2 URL类构造器

image-20200902234751276

image-20200902234801922

7.3 URL类常用方法

image-20200902234810432

image-20200902234818452

7.6 代码实例

package com.wmiao.java;

import java.net.MalformedURLException;
import java.net.URL;

/**
 * @author wmiao
 * @version 1.0
 * @description: TODO
 * @date 2020/9/3 3:17
 */

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

        try {
            URL url = new URL("http://192.168.1.100:8080/helloworld/index.jsp#a?username=shkstart&password=123");

            //public String getProtocol( ) 获取该URL的协议名
            System.out.println("getProtocol() :"+url.getProtocol());
            //public String getHost( ) 获取该URL的主机名
            System.out.println("getHost() :"+url.getHost());
            //public String getPort( ) 获取该URL的端口号
            System.out.println("getPort() :"+url.getPort());
            //public String getPath( ) 获取该URL的文件路径
            System.out.println("getPath() :"+url.getPath());
            //public String getFile( ) 获取该URL的文件名
            System.out.println("getFile() :"+url.getFile());
            //public String getQuery( ) 获取该URL的查询名
            System.out.println("getQuery() :"+url.getQuery());

        } catch (MalformedURLException e) {
            e.printStackTrace();
        }

    }
}

7.5 针对HTTP协议的URLConnection类

image-20200902234823687

image-20200902234829326

package com.wmiao.java;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

/**
 * @author 吴淼杰
 * @version 1.0
 * @description: TODO
 * @date 2020/9/3 3:32
 */

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

        HttpURLConnection urlConnection = null;
        InputStream is = null;
        FileOutputStream fos = null;
        try {
            URL url = new URL("http://localhost:8080/examples/beauty.jpg");

            urlConnection = (HttpURLConnection) url.openConnection();

            urlConnection.connect();

            is = urlConnection.getInputStream();
            fos = new FileOutputStream("day10\\beaty.jpg");

            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1){
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (urlConnection != null) {
                urlConnection.disconnect();
            }
        }

    }
}

7.6 URI、URL和URN的区别

image-20200902234834671

8 小结

image-20200902234840019

白雪青冢 黄河黑山
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java之初步识别网络编程：IP、端口号、TCP/UDP、Socket、URL等
小贺想改变
10-27 783
Java之初步认识网络编程：IP、端口号、TCP/UDP、Socket、URL等
java网络编程，三要素协议、ip地址、端口号，Socket类、ServerSocket类
ZXLzhuzhu的博客
06-08 413
网络编程 网络编程三要素 协议 协议:计算机网络通信必须遵守的规则，已经介绍过了，不再螯述。 IP地址 IP地址:指互联网协议地址(Internet Protocol Address)，俗称IP。IP地址用来给一个网络中的计算机设备做唯一的编号。假如我们把“个人电脑比作”一台电话”的话，那么“IP地址”就相当于“电话号码”。 IP地址分类 IPv4:是一个32位的二进制数，通常被分为4个字节，表示成a.b.c.d的形式，例如192.168.65.100。其中 abd都是0~255之间的十进制整数，那么
java代码，如何获取请求中 网络协议、IP、端口号、项目根路径
Mabo666的博客
06-12 4395
pubulic static String getRequestPrefix(HttpServletRequest request){           //获取网络协议            String networkProtocol = request.getScheme();            //网络IP            String ip = request.getServ...
Java——网络编程之三要素：IP地址、端口、协议
smile4548656的博客
04-24 1396
Java——网络编程之三要素：IP地址、端口、协议一、计算机网络二、网络编程三、网络编程三要素四、IP地址五、InetAddress六、端口七、协议 一、计算机网络 计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统、网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。 二、网络编程 在网络通信协议下，实现网络互连的不同计算机上运行的程序间可以进行数据交换 三、网络编程三要素 IP地址 要想让网络中的计算机能够互相通信，必须
Java SE完整版精品优质课件 自学入门必看的优秀Java基础知识培训教案 第14章_java网络编程(共42页).pptx
08-29
1. **网络编程概述**：Java为开发者提供了丰富的网络编程API，使得开发网络应用变得简单。Java的网络库是跨平台的，隐藏了底层的网络细节，确保了开发者在不同操作系统上的编程一致性。网络编程的目标是实现计算机间...
JAVA网络编程——简单概述，分别通过TCP、UDP传输信息，以及利用URL下载资源
sormous的博客
04-21 204
网络编程概述目的网络通信的要素IP(InetAddress)端口(InetSocketAddress)通信协议TCP文件传输 概述 计算机网络：计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。 目的 传递交流信息，数据交换，通信。 网络通信的要素 如何定位到网络...
网络编程 TCP/UDP
最新发布
qq_59079296的博客
11-26 138
计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。：无线电台---传播交流信息，数据交换，通信。1.如何准确定位网络上的一台主机 端口，定位到这个计算机上的某个资源2.找到这个主机，如何传输数据javaweb 网页编程： B/S网络编程： TCP/IP C/S。
【狂神说笔记—— Java基础11-网络编程】
weixin_46055348的博客
07-11 485
【狂神说笔记—— Java基础11-网络编程】
面向过程与面向对象-人把大象装冰箱
Wmiao
08-04 1978
面向过程（Procedure Oriented Programming） 强调的是功能行为，以函数为最小单位，考虑怎么做 //C //① 把冰箱门打开 //② 把大象塞进冰箱 //③ 把冰箱门关闭 void FriOpen(){ ---- } void EleInFri(){ ---- } void FriClose(){ ---- } ----------- int main(){ FriOpen(); EleInFri(); FriClose();
Java - 什么是JavaBean？简述
Wmiao
08-05 879
JavaBean Write once, run anywhere, reuse everywhere. 一次性编写，任何地方执行，任何地方重用。 JavaBean 是一种JAVA语言写成的可重用组件。 通俗讲，就是一类特殊的Java类。 所谓JavaBean，是指符合以下标准的Java类： 类是公共的 提供无参的公共的构造器，即提供默认构造方法 有属性，且有对应的getter、setter方法 一般属性是private的。 执行java.io.Serializable 接口 public clas
【Java 05】面对对象（中） - Eclipse快捷键、对象数组、继承性
Wmiao
08-07 461
一 面对对象中一 1 Eclipse快捷键 补全代码：Alt + / 将未写完的代码补充 快速修复：Ctrl + 1 如果出现错误，鼠标移动到那个位置，Ctrl + 1，则可以出现错误信息，并提供修复方法 批量导包：Ctrl + Shift + o 未导包的全部导包 单行注释：Ctrl + / 多行注释：Ctrl + Shift + / **取消多行注释：Ctrl + Shift + \ ** 复制指定行的代码：Ctrl + Alt + ↓ 或 Ctrl + Alt + ↑
Java - import关键字简述
Wmiao
08-06 425
import关键字（导入） 1 作用 可在源文件中显式的使用import结构导入指定包下的类，接口（一般编译器可在写入所需要的对象时就自动导入了） package com.miaojie.java import java.util.Arrays public class PackageImportTest{ public static void main(String[] args){ String info = Arrays.toString(new int[]{1,2,3})
【Java 16】泛型 - 集合中使用泛型、自定义泛型结构、泛型在继承上的体现、通配符
Wmiao
08-31 344
泛型泛型1 为什么要有泛型2 在集合中使用泛型3 自定义泛型3.1 泛型类、泛型接口3.2 泛型方法4 泛型在继承上的体现5 通配符的使用5.1 使用5.2 使用注意点5.3 有限制的通配符5.3.1 简述5.3.2 练习题6 泛型应用举例7 自定义泛型类的使用 泛型 1 为什么要有泛型 2 在集合中使用泛型 ArrayList<Integer> list = new ArrayList<>();//jdk7新特性， 类型推断 list.add(78); list.add
Java - package关键字简述
Wmiao
08-06 334
package关键字 1 目的 为了更好的实现项目中类的管理，比如不同专业不同届所分成的班级 2 使用 使用package声明类或接口所属的包，声明在源文件的首行 package com.miaojie.java public class Test{ } 3 遵循规则、规范 pakeage，属于标识符，遵循标识符的命名规则，规范（xxxyyyzzz）、“见名知意”… 4 com.miaojie.java中的 . 的意思 每“.”一次，代表一层文件目录 5 补充 同一个包下，不能命名同名的接口、类 不同
【Java 17】IO流 - File类、IO流原理及流的分类、抽象基类、节点流、缓冲流、转换流、标准输入、输出流、打印流、数据流、对象流、随机存取文件流、NIO.2
Wmiao
09-02 333
IO流 -File类、IO流原理及流的分类、抽象基类、节点流、缓冲流、转换流、标准输入、输出流、打印流、数据流、对象流、随机存取文件流、NIO.2IO流1 File类的使用1.1 File类的使用1.2 常用构造器1.3 路径分隔符1.4 常用方法1.5 小练习2 IO流原理及流的分类2.1 IO流原理2.2 流的分类2.3 IO流体系3 抽象基类3.1 读入3.1.1 代码步骤规范3.1.2 read()3.1.3 read(char[] cbuf)3.2 写出3.2.1 步代码骤规范3.2.2 writ
【Java 11】多线程 - 程序、进程、线程、线程的创建和使用、线程的生命周期、线程的同步、线程的通信、JDK5.0新增线程创建方式
Wmiao
08-18 297
一 Idea 1 快捷补全 new Method() 使用Alt + Enter 可补全 Method method = new Method()； psvm : 可生成 main 方法 sout : System.out.println() 快捷输出 soutp=System.out.println("方法形参名 = " + 形参名); soutv=System.out.println("变量名 = " + 变量); soutm=System.out.println(“当前类名.当前方法”
Java - 权限修饰符个人小部分总结
Wmiao
08-05 285
3 权限修饰符 封装性的体现，需要权限修饰符来配合，来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小 3.1 四大权限修饰符 以下是Java提供的四种权限修饰符，权限从小到大 private 缺省（default） protected public Java中有四种权限修饰符： public > protected > (default) > private 同一个类（我自己） YES
【Java 10】异常处理 - try-catch-finally、throws、throw、自定义异常类
Wmiao
08-13 276
异常处理 1 异常概述与异常体系结构 1.1 异常体系结构 2 常见异常 FileNotFoundException IOXException @Test public void test(){ File file = new File("hello.txt"); FileInputStream fis = new FileInputStream(file); int data = fis.read(); while(data != -1){
Java网络编程详解：IP, 端口与协议
“Java基础篇：网络编程.pdf”文档主要涵盖了Java网络编程的基础知识，包括通信要素、TCP网络编程、UDP网络编程以及URL编程。文档详细介绍了如何利用Java进行网络连接，强调了Java在网络编程中的易用性和跨平台特性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值