12.网络编程

1.InetAddress类的使用

1.实现网络通信需要解决的两个问题

1.如何准确地定位网络上一台或多台主机；定位主机上的特定的应用

2.找到主机后如何可靠高效地进行数据传输

2.网络通信的两个要素（解决上述问题）

1.对应问题一：IP和端口号

2.对应问题二：提供网络通信协议：TCP/IP参考模型（应用层、传输层、网络层、物理+数据链路层）

3.通信要素一：IP和端口号

概念介绍

• MAC地址：在设备与设备之间数据通信时用来标记收发双方（网卡的序列号即唯一标识，物理地址）

• IP地址：在逻辑上标记一台电脑，用来指引数据包的收发方向（相当于电脑的序列号）

• 网络掩码：用来区分ip地址的网络号和主机号

• 默认网关：当需要发送的数据包的目的ip不在本网段内时，就会发送给默认的一台电脑，成为网关

• 集线器：已过时，用来连接多态电脑，缺点：每次收发数据都进行广播，网络会变的拥堵

• 交换机：集线器的升级版，有学习功能知道需要发送给哪台设备，根据需要进行单播、广播

• 路由器：连接多个不同的网段，让他们之间可以进行收发数据，每次收到数据后，ip不变，但是MAC地址会变化

• DNS：用来解析出IP（类似电话簿）

• http服务器：提供浏览器能够访问到的数据

  

1.IP的理解

​ 1.IP:唯一的标识 Internet 上的计算机（通信实体）

​ 2.在Java中使用InetAddress类代表IP

​ 3.IP分类：IPv4 和 IPv6 ; 万维网 和 局域网

​ IPV4：以点分十进制表示，如192.168.0.1 4 x 1byte(即8bit：0-255)

​ 4个字节组成（32位）大概42亿，30亿都在北美，亚洲4亿。2011年初已经用尽。

​ IPV6：

​ IPV6：写成8个无符号整数，每个整数用4个十六进制位表示，数之间用冒号（：）分开，如：3ffe:3201:1401:1280:c8ff:fe4d:db39:1984

​ 8 x （4 x 16bit） 128位（16个字节）

​ 4.域名: www.baidu.com www.mi.com www.sina.com www.jd.com

​ 域名解析：域名容易记忆，当在连接网络时输入一个主机的域名后，

​ 域名服务器(DNS)负责将域名转化成IP地址，这样才能和主机建立连接。

​ 5.本地回路地址：127.0.0.1 对应着：localhost

1. IP地址分类

每一个IP地址包括两部分：网络地址和主机地址。

IP地址通常由点分十进制(例如：192.168.1.1)的方式来表示,IP地址要和子网掩码(用来区分网络位和主机位)配合使用。

eg：192.168.1.1 网络位：192.168.0.0 主机位：后两位

A类地址

一个A类IP地址由1字节的网络地址和3字节主机地址组成，网络地址的最高位必须是“0”，

地址范围：1.0.0.1-126.255.255.254 0111 1111->127(但127为保留地址，不可使用，所以只到126)

子网掩码：255.0.0.0

二进制表示为：00000001 00000000 00000000 00000001 - 01111110 11111111 11111111 11111110

可用的A类网络有126个（127为保留地址），每个网络能容纳1677214个主机（256x256-2）

B类地址

一个B类IP地址由2个字节的网络地址和2个字节的主机地址组成，网络地址的最高位必须是“10”，

地址范围：128.1.0.1-191.255.255.254

子网掩码：255.255.0.0

二进制表示为：10000000 00000001 00000000 00000001 - 10111111 11111111 11111111 11111110

可用的B类网络有16384个，每个网络支持的最大主机数为256的2次方-2=65534台。

C类地址

一个C类IP地址由3字节的网络地址和1字节的主机地址组成，网络地址的最高位必须是“110”

范围：192.0.1.1-223.255.255.254

子网掩码：255.255.255.0

二进制表示为: 11000000 00000000 00000001 00000001 - 11011111 11111111 11111110 11111110

C类网络可达2097152个，每个网络支持的最大主机数为256-2=254台

D类地址

D类IP地址第一个字节以“1110”开始，它是一个专门保留的地址，并不指向特定的网络，目前这一类地址被用在多点广播（Multicast）中。

E类地址

以“1111”开始，为将来使用保留，仅作实验和开发用。

私有地址

在这么多网络IP中，国际规定有一部分IP地址是用于我们的局域网使用，也就是属于私网IP，不在公网中使用的，它们的范围是：

10.0.0.0～10.255.255.255
172.16.0.0～172.31.255.255
192.168.0.0～192.168.255.255

2.注意事项

1. 每一个字节都为0的地址（“0.0.0.0”）对应于当前主机。
2. IP地址中的每一个字节都为1的IP地址（“255．255．255．255”）是当前子网的广播地址。
3. IP地址中凡是以“1111”开头的E类IP地址都保留用于将来和实验使用。
4. IP地址中不能以十进制“127”作为开头，该类地址中数字127.0.0.1到127.255.255.255用于回路测试，如：127.0.0.1可以代表本机IP地址，用 http://127.0.0.1 就可以测试本机中配置的Web服务器
5. 网络ID的第一个8位组也不能全置为“0”，全“0”表示本地网络。

3. IPV6

由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。

为了扩大地址空间，拟通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，表示成ABCD:EF01:2345:6789:ABCD:EF01:2345:6789，号称可以为全世界的每一粒沙子编上一个网址，这样就解决了网络地址资源数量不够的问题。

2.端口号

标识正在计算机上运行的进程（程序）

端口号：用两个字节表示的整数，它的取值范围是0~65535。(2个字节)

其中，0~1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败。

• MySQL 3306
• Tomcat 8080
• Oracle 1521
• HTTP协议默认端口号 80
• HTTPS协议默认端口号 443

利用协议+IP地址+端口号 三元组合，就可以标识网络中的进程了，那么进程间的通信就可以利用这个标识与其它进程进行交互

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

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

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

InetAddress类

​ 此类的一个对象就代表着一个具体的IP地址

​ 1.实例化

​ getByName(String host) 、 getLocalHost()

​ 2.常用方法

​ getHostName() / getHostAddress()

4.通信要素二：网络通信协议

• 网络通信协议：通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。
• TCP/IP协议： 传输控制协议/因特网互联协议( Transmission Control Protocol/Internet Protocol)，是Internet最基本、最广泛的协议。它定义了计算机如何连入因特网，以及数据如何在它们之间传输的标准。它的内部包含一系列的用于处理数据通信的协议，并采用了4层的分层模型，每一层都呼叫它的下一层所提供的协议来完成自己的需求。

1.分型模型

上图中，TCP/IP协议中的四层分别是应用层、传输层、网络层和链路层，每层分别负责不同的通信功能。

• 链路层：链路层是用于定义物理传输通道，通常是对某些网络连接设备的驱动协议，例如针对光纤、网线提供的驱动。

• 网络层：涉及寻址和路由器选择（定义了基于IP协议的逻辑地址；连接不同的媒介类型；选择数据通过网络的最佳路径）

  ​ 网络层的主要协议有IP(Internet protocol：IPv4,IPv6)、CMP协议（Internet Control Message Protocol，互联网控制报文协议）、

  ​ IGMP（Internet Group Management Protocol，互联网组管理协议）、ARP(Address Resolution Protocol，地址解析协议)和

  ​ RARP(Reverse Address Resolution Protocol，反地址解析协议)等

• 运输层：传输层的基本功能是为两台主机间的应用程序提供端到端的通信。

  ​ 传输层从应用层接受数据，并且在必要的时候把它分成较小的单元，传递给网络层，并确保到达对方的各段信息正确无误

  ​ 主要使网络程序进行通信，在进行网络通信时，可以采用TCP协议，也可以采用UDP协议。

• 应用层：提供应用程序的网络接口；主要负责应用程序的协议，例如HTTP协议、FTP协议等。

"物理层"：线路里的电信号，以及无线网络里的无线信号

"数据链路层"：媒体访问控制地址（MAC），碰撞检测，指数退避，以及其他一些底层协议（负责操控"物理层"，）

"网络层"：负责各种报文交换和路由

"传输层": UDP 和 TCP 。。。

"会话层"：使用 TCP 和 UDP 来创建连接，传递信息，然后关掉连接

开放式系统互联通信参考模型 - Open System Interconnection

2.TCP和UDP的区别

生活中场景举例：TCP类似打电话，UDP类似发送短信

TCP协议：
使用TCP协议前，须先建立TCP连接，形成传输数据通道
传输前，采用“三次握手”方式，点对点通信，是可靠的
TCP协议进行通信的两个应用进程：客户端、服务端。
在连接中可进行大数据量的传输
传输完毕，需释放已建立的连接，效率低

UDP协议：
将数据、源、目的封装成数据包，不需要建立连接
每个数据报的大小限制在64K内 发送不管对方是否准备好，接收方收到也不确认，故是不可靠的，可以广播发送
发送数据结束时无需释放资源，开销小，速度快

​ UDP典型应用场景：播放网络视频（开销是小，速度快，可以丢失一些数据(数据报)，但整体不影响使用，）

2.TCP网络编程

传输控制协议 (Transmission Control Protocol)。TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。

客户端Socket的工作过程包含以下四个基本的步骤

1.创建 Socket：根据指定服务端的 IP 地址或端口号构造 Socket 类对象。

​ 若服务器端响应，则建立客户端到服务器的通信线路。若连接失败，会出现异常。

2.打开连接到 Socket 的输入/出流： 使用 getInputStream()方法获得输入流，使用getOutputStream()方法获得输出流，进行数据传输

3.按照一定的协议对 Socket 进行读/写操作：

​ 通过输入流读取服务器放入线路的信息（但不能读取自己放入线路的信息），通过输出流将信息写入线程。

4.关闭 Socket：断开客户端到服务器的连接，释放线路

服务器程序的工作过程包含以下四个基本的步骤

1.调用 ServerSocket(int port) ：创建一个服务器端套接字，并绑定到指定端口上。用于监听客户端的请求。

2.调用 accept()：监听连接请求，如果客户端请求连接，则接受连接，返回通信套接字对象(Socket)。

3.调用 该Socket类对象的 getOutputStream() 和 getInputStream ()：获取输出流和输入流，开始网络数据的发送和接收。

4.关闭ServerSocket和Socket对象：客户端访问结束，关闭通信套接字。

代码示例1：

客户端发送信息给服务端，服务端将数据显示在控制台上

tip：先启动服务器(指定端口号)，然后客户端才可到根据服务器的ip+端口即Socket去访问服务器

//客户端
@Test
public void client()  {
    Socket socket = null;
    OutputStream os = null;
    try {
        //1.创建Socket对象，指明服务器端的ip和端口号
        InetAddress inet = InetAddress.getByName("192.168.14.100");
        socket = new Socket(inet,8899);
        //2.获取一个输出流，用于输出数据
        os = socket.getOutputStream();
        //3.写出数据的操作
        os.write("你好，我是客户端mm".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();

       //不建议这样写，可能会有乱码 字节数组.length=1024 每次读的数据不一定能拼成完整的汉字(不同编码汉字占不同字节)
//        byte[] buffer = new byte[1024];
//        int len;
//        while((len = is.read(buffer)) != -1){
//            String str = new String(buffer,0,len);
//            System.out.print(str);
//        }
        //4.读取输入流中的数据
        baos = new ByteArrayOutputStream();
        byte[] buffer = new byte[5];
        int len;
        while((len = is.read(buffer)) != -1){
            baos.write(buffer,0,len);
        }
	//ByteArrayOutputStream内维持着1个byte[],每次读的数据都会不断放入其中，toString时整体拼成字符串，就不会出现乱码
        System.out.println(baos.toString());

        System.out.println("收到了来自于：" + socket.getInetAddress().getHostAddress() + "的数据");

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(baos != null){
            //5.关闭资源
            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();
            }
        }
    }
}

代码示例2：

客户端发送文件给服务端，服务端将文件保存在本地。

/*
这里涉及到的异常，应该使用try-catch-finally处理
 */
@Test
public void client() throws IOException {
    //1.
    Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
    //2.
    OutputStream os = socket.getOutputStream();
    //3.
    FileInputStream fis = new FileInputStream(new File("beauty.jpg"));
    //4.
    byte[] buffer = new byte[1024];
    int len;
    while((len = fis.read(buffer)) != -1){
        os.write(buffer,0,len);
    }
    //5.
    fis.close();
    os.close();
    socket.close();
}

/*
这里涉及到的异常，应该使用try-catch-finally处理
 */
@Test
public void server() throws IOException {
    //1.
    ServerSocket ss = new ServerSocket(9090);
    //2.
    Socket socket = ss.accept();
    //3.
    InputStream is = socket.getInputStream();
    //4.
    FileOutputStream fos = new FileOutputStream(new File("beauty1.jpg"));
    //5.
    byte[] buffer = new byte[1024];
    int len;
    while((len = is.read(buffer)) != -1){
        fos.write(buffer,0,len);
    }
    //6.
    fos.close();
    is.close();
    socket.close();
    ss.close();

}

代码示例3：

从客户端发送文件给服务端，服务端保存到本地。并返回“发送成功”给客户端。并关闭相应的连接。

/*
    这里涉及到的异常，应该使用try-catch-finally处理
     */
@Test
public void client() throws IOException {
    //1.
    Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
    //2.
    OutputStream os = socket.getOutputStream();
    //3.
    FileInputStream fis = new FileInputStream(new File("beauty.jpg"));
    //4.
    byte[] buffer = new byte[1024];
    int len;
    while((len = fis.read(buffer)) != -1){
        os.write(buffer,0,len);
    }
    //关闭数据的输出
    socket.shutdownOutput();

    //5.接收来自于服务器端的数据，并显示到控制台上
    InputStream is = socket.getInputStream();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    byte[] bufferr = new byte[20];
    int len1;
    while((len1 = is.read(buffer)) != -1){
        baos.write(buffer,0,len1);
    }

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

    //6.
    fis.close();
    os.close();
    socket.close();
    baos.close();
}

/*
这里涉及到的异常，应该使用try-catch-finally处理
 */
@Test
public void server() throws IOException {
    //1.
    ServerSocket ss = new ServerSocket(9090);
    //2.
    Socket socket = ss.accept();
    //3.
    InputStream is = socket.getInputStream();
    //4.
    FileOutputStream fos = new FileOutputStream(new File("beauty2.jpg"));
    //5.
    byte[] buffer = new byte[1024];
    int len;
    while((len = is.read(buffer)) != -1){
        fos.write(buffer,0,len);
    }

    System.out.println("图片传输完成");

    //6.服务器端给予客户端反馈
    OutputStream os = socket.getOutputStream();
    os.write("你好，美女，照片我已收到，非常漂亮！".getBytes());

    //7.
    fos.close();
    is.close();
    socket.close();
    ss.close();
    os.close();

}

三次握手与四次挥手

在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”。

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

  • 第一次握手，客户端向服务器端发出连接请求，等待服务器确认。
  • 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。
  • 第三次握手，客户端再次向服务器端发送确认信息，确认连接。整个交互过程如下图所示。
  

• 四次挥手:

  TCP协议中，在发送数据结束后，释放连接时需要经过四次挥手。

  • 第一次挥手：客户端向服务器端提出结束连接，让服务器做最后的准备工作。此时，客户端处于半关闭状态，即表示不再向服务器发送数据了，但是还可以接受数据。
  • 第二次挥手：服务器接收到客户端释放连接的请求后，会将最后的数据发给客户端。并告知上层的应用进程不再接收数据。
  • 第三次挥手：服务器发送完数据后，会给客户端发送一个释放连接的报文。那么客户端接收后就知道可以正式释放连接了。
  • 第四次挥手：客户端接收到服务器最后的释放连接报文后，要回复一个彻底断开的报文。这样服务器收到后才会彻底释放连接。这里客户端，发送完最后的报文后，会等待2MSL，因为有可能服务器没有收到最后的报文，那么服务器迟迟没收到，就会再次给客户端发送释放连接的报文，此时客户端在等待时间范围内接收到，会重新发送最后的报文，并重新计时。如果等待2MSL后，没有收到，那么彻底断开。

  

  

3.UDP网络编程

1.说明

用户数据报协议(User Datagram Protocol)。UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。

由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输例如视频会议都使用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。

但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议。

类 DatagramSocket 和 DatagramPacket 实现了基于 UDP 协议网络程序。

UDP数据报通过数据报套接字 DatagramSocket 发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。

DatagramPacket 对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。

UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接。如同发快递包裹一样。

特点:每次数据被限制在64kb以内，超出这个范围就不能发送了

2.流程：

1. DatagramSocket（数据报套接字：发送和接受数据的功能）与 DatagramPacket（数据包）

2. 建立发送端，接收端

3. 建立数据包DatagramPacket

4. 调用Socket的发送、接收方法

5. 关闭Socket

发送端与接收端是两个独立的运行程序

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

    DatagramSocket socket = new DatagramSocket();

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

    socket.send(packet);

    socket.close();

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

    DatagramSocket socket = new DatagramSocket(9090);

    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()));

    socket.close();
}

4.URL编程

1.URL(Uniform Resource Locator)的理解:

统一资源定位符，对应着互联网的某一资源地址

2.URL的5个基本结构：

URL的基本结构由5部分组成：

<传输协议>://<主机名>:<端口号>/<文件名>#片段名?参数列表

片段名：即锚点，例如看小说，直接定位到章节

参数列表格式：参数名=参数值&参数名=参数值....

示例：

http://localhost:8080/examples/beauty.jpg?username=Tom

http://192.168.1.100:8080/helloworld/index.jsp#a?username=shkstart&password=123

[jdbc:mysql://localhost:3306/atguigu?useUnicode=true&characterEncoding=utf8](http://localhost:8080/examples/beauty.jpg?username=Tom
jdbc:mysql://localhost:3306/atguigu?useUnicode=true&characterEncoding=utf8)

3.如何实例化:

• 构造器：

public URL (String spec)：通过一个表示URL地址的字符串可以构造一个URL对象
例如：URL url = new URL ("http://www. atguigu.com/");
	 URL url = new URL("http://localhost:8080/examples/beauty.jpg?username=Tom");

public URL(URL context, String spec)：通过基 URL 和相对 URL 构造一个 URL 对象
例如：URL downloadUrl = new URL(url, “download.html")

public URL(String protocol, String host, String file); 
例如：new URL("http", "www.atguigu.com", “download. html");

public URL(String protocol, String host, int port, String file); 
例如: URL gamelan = new URL("http", "www.atguigu.com", 80, “download.html");

• URL类的构造器都声明抛出非运行时异常，必须要对这一异常进行处理，通常是用 try-catch 语句进行捕获。

4.常用方法

一个URL对象生成后，其属性是不能被改变的，但可以通过它给定的方法来获取这些属性

public String getProtocol( ) //获取该URL的协议名   eg：http
public String getHost( ) //获取该URL的主机名      eg：localhost
public String getPort( ) //获取该URL的端口号      eg：8080
public String getPath( ) //获取该URL的文件路径     eg：/examples/beauty.jpg
public String getFile( ) //获取该URL的文件名      eg：/examples/beauty.jpg?username=Tom
public String getQuery( ) //获取该URL的查询名     eg：username=Tom

5.可以读取、下载对应的url资源：

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");
		//获取与服务器的连接对象，因为此处是基于http的连接，所以可强制为HttpURLConnection
        urlConnection = (HttpURLConnection) url.openConnection();
        urlConnection.connect();//通过连接对象与服务器进行连接

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

        byte[] buffer = new byte[1024];
        int len;
        while((len = is.read(buffer)) != -1){
            fos.write(buffer,0,len);
        }

        System.out.println("下载完成");
    } 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();
        }
    }
}

6.URI、URL和URN的区别

URI，是uniform resource identifier，统一资源标识符，用来唯一的标识一个资源。

而URL是uniform resource locator，统一资源定位符，它是一种具体的URI，即URL可以用来标识一个资源，而且还指明了如何locate这个资源。

而URN，uniform resource name，统一资源命名，是通过名字来标识资源，比如mailto:java-net@java.sun.com。

也就是说，URI是以一种抽象的，高层次概念定义统一资源标识，而URL和URN则是具体的资源标识的方式。URL和URN都是一种URI。

在Java的URI中，一个URI实例可以代表绝对的，也可以是相对的，只要它符合URI的语法规则。

而URL类则不仅符合语义，还包含了定位该资源的信息，因此它不能是相对的。