黑马程序员_毕向东JAVA基础_网络编程（概述&UDP&TCP）

最新推荐文章于 2015-11-01 21:03:00 发布

不倒的青春

最新推荐文章于 2015-11-01 21:03:00 发布

阅读量1.1k

点赞数

本文链接：https://blog.csdn.net/u010710575/article/details/9148289

版权

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------

网络编程

步骤：

1.找到对方IP；

2.数据要发送到对方指定的应用程序上，为了标识这些应用程序，所以给这些网络应用程序都用数字进行标识。为了方便称呼这个数字，叫做端口。

3.定义通信规则。这个规则称为协议。

国际组织定义通用的协议：TCP/IP

本地回环地址：127.0.0.0 locahost

端口 0~65535 ，其中0~1024系统使用或保留端口。

IP地址对应对象：InetAddress

主要的方法：

InetAddress：构造方法私有，不能直接创建对象。

InetAddressgetByName(String host):在给定主机名的情况下确定主机的ip地址。

InetAddressgetLocalHost()：返回本地主机。

InetAddress[]getAllByName(String host)

ip.getHostAddress(),

ip.getHostName()

InetAddress[] getAllByName(String host) throws UnknownHostException

对应一个name对应多个主机的状态（例如百度），最好获取IP不取name

网络通信其实就是Socket间的通信

传输协议：TCP ，UDP

他们之间的区别：

UDP：

a) 将数据及源和目的封装成数据包中，不需要建立连接。

b) 每个数据包的大小限制在64k内。

c) 因无连接，是不可靠协议。

d) 不需要建立连接，速度快。

TCP：

a) 面向连接的，必须先建立连接，形成传输数据的通道。

b) 在连接中进行大数据量传输。

c) 通过三次握手完成连接，是可靠协议。通过TCP连接传递的数据，无差错、不丢失、不重复、并且按照顺序到达。

d) 因为必须建立连接，效率会稍低。

Socket

Socket就是为网络服务提供的一种机制。

通信的两端都有Socket。

网络通信其实就是Socket间的通信。

数据在两个Socket间的IO传输。

UDP传输

A） DatagramSocket与DatagramPacket

B）建立发送端，接收端。

C）建立数据包

D）调用Socket的发送接收方法。

E）关闭Socket。

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

import java.net.*;
/*
需求，通过UDP传输方法，将一段文字数据发送出去。
思路：
1.建立UDP socket服务。
2.提供数据，并将数据封装到数据包中。
3，通过socket服务的发送功能，将数据包发送出去。
4.关闭资源。
*/
class UdpSend 
{
	public static void main(String[] args) throws Exception
	{
		//创建UDP服务，通过DatagramSocket对象。
		DatagramSocket ds = new DatagramSocket();
		//确定数据，将数据封装到包中。

		byte[] buf = "udp come on".getBytes();
		DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.2"),10000);
		//通过Socket服务，将已有的数据包发送出去。
		ds.send(dp);
		//关闭资源
		ds.close();
		
	}
}

/*
需求：
定义一个应用程序，用于接受Udp协议传输的数据并处理。
思路：
1.定义UDP socket服务。通常会监听一个端口，其实就是给这个接受网络应用程序定义数字标识，
方便于明确哪些数据过来该应用程序可以处理。
2.定义一个数据包，因为要存储接受到的字节数据。
因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
3.通过socket服务的receive方法将收到的数据存入已定义好的数据包中。
4.通过数据包对象的特有功能。将这些不同的数据取出。打印在控制台上。
5.关闭资源。
*/
class UdpRece
{
	public static void main(String[] args)throws Exception
	{
		//创建 UDP Socket，建立端点
		DatagramSocket ds = new DatagramSocket(10000);
		//定义数据包，用于存储数据。
		byte[] buf = new byte[1024];
		DatagramPacket dp = new DatagramPacket(buf,buf.length);
		//通过服务的receive方法，将收到的数据存入数据包中。
		ds.receive(dp);
		//通过数据包的方法，获取其中的数据。
		String ip = dp.getAddress().getHostAddress();//获取地址。
		String data = new String(dp.getData(),0,dp.getLength());//将字符数组，初始化为字符串对象。

		int port = dp.getPort();

		System.out.println(ip+"::"+data+"::"+port);
		//关闭资源
		ds.close();

	}
}

（二）键盘录入信息，进行通信

import java.net.*;
import java.io.*;
class UdpSend2 
{
	public static void main(String[] args)throws Exception
	{
		DatagramSocket ds = new DatagramSocket();

		BufferedReader bufr = 
			new BufferedReader(new InputStreamReader(System.in));//通过键盘录入
		String line = null;

		while ((line = bufr.readLine())!= null)
		{
			if(line.equals("886"))
				break;
			byte[] buf = line.getBytes();

			DatagramPacket dp = 
				new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.2"),10001);
			ds.send(dp);
		}
		ds.close();
	}
}

class UdpRese2
{
	public static void main(String[] args)throws Exception
	{
		DatagramSocket ds = new DatagramSocket(10001);
		while (true)
		{
			byte[] buf = new byte[1024];
			DatagramPacket dp =
				new DatagramPacket(buf,buf.length);
			ds.receive(dp);
			String ip = dp.getAddress().getHostAddress();
			String data = new String(dp.getData(),0,dp.getLength());
			System.out.println(ip+"::"+data);
		}
	}
	
}

（三）聊天程序

/*
编写一个聊天程序。
有收数据的部分，和发数据的部分。
这两部分需要同时执行。
需要用到多线程技术。
一个线程收，一个线程控制发。

因为收和发动作不一致，所以要定义两个Run方法。
这两个方法要封装到不同的类中。
*/
import java.net.*;
import java.io.*;

class Send implements Runnable
{
	private DatagramSocket ds;
	public Send(DatagramSocket ds)
	{
		this.ds = ds;
	}
	public void run()
	{
		try
		{
			BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
			String line = null;
			while ((line = bufr.readLine())!= null)
			{
				if(line.equals("886"))
					break;
				byte[] buf = line.getBytes();
				DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.2"),10002);
				ds.send(dp);
			}
		}
		catch (Exception e)
		{
			throw new RuntimeException("发送失败");
		}
	}
}


class Rece implements Runnable
{
	private DatagramSocket ds;
	public Rece(DatagramSocket ds)
	{
		this.ds = ds;
	}
	public void run()
	{
		try
		{
			while (true)
			{
				byte[] buf = new byte[1024];
				DatagramPacket dp = new DatagramPacket(buf,buf.length);
				ds.receive(dp);
				
				String ip = dp.getAddress().getHostAddress();
				String data = new String(dp.getData(),0,dp.getLength());
				System.out.println(ip+"::"+data);
			}
		}
		catch (Exception e)
		{
			throw new RuntimeException("接受失败");
		}
	}
}

class  ChatDemo
{
	public static void main(String[] args)throws Exception
	{
		DatagramSocket sendSocket = new DatagramSocket();
		DatagramSocket receSocket = new DatagramSocket(10002);

		new Thread(new Send(sendSocket)).start();
		new Thread(new Rece(receSocket)).start();

	}
}

TCP传输

A) Socket和ServerSocket

B) 建立客户端和服务器端

C) 建立连接后，通过Socket中的IO流进行数据的传输。

D) 关闭socket。

同样，客户端与服务器端是两个独立的应用程序。

注意：先启动服务端，因为是面向连接的。

PrintWriter：既能接受字符流，又能接受字节流。还能自动刷新。

为了可以让多个客户端同时并发访问服务端：服务端最好是将每个客户端封装到一个单独的线程中，这样，就可以同时处理多个客户端请求。

如何定义线程呢？

只要明确每一个客户端要在服务端执行的代码即可。将该代码存入到run方法中。

/*
演示TCP传输

1.tcp分客户端和服务器端。
2.客户端对应的对象是Socket。
		服务端对应的对象是ServerSocket。

*/
/*
客户端：
通过查阅Socket对象，发现该对象建立时，就可以去连接指定主机。
因为TCP是面向连接的。所以在建立Socket服务时，就要有服务端存在，
并连接成功，形成通路后，在该通道进行数据传输。


需求，给服务端发送文本数据。
步骤：
1.创建Socket服务，并指定要连接的主机和端口。
*/
import java.io.*;
import java.net.*;
class TcpClient 
{
	public static void main(String[] args) throws Exception
	{
		//创建客户端socket服务，指定主机和端口。
		Socket s = new Socket("192.168.1.2",10003);

		OutputStream out = s.getOutputStream();
		out.write("tcp come on".getBytes());
		s.close();
	}
}


/*
需求：定义端点接受数据并打印在控制台上。

服务端：
1.建立服务端的socket服务，ServerSocket。
	并监听一个端口。
2.获取连接过来的客户端对象。
	通过ServerSocket的accept方法。这个方法是阻塞式的。
3.客户端如果发过来数据，那么服务端要使用对应的客户端对象。
	获取到该客户端对象的读取流对象读取过来的数据，并打印在控制台上。
4.关闭服务端。（可选操作）
*/
class  TcpServer
{
	public static void main(String[] args)throws Exception 
	{
		//建立服务器socket服务，并监听一个端口
		ServerSocket ss = new ServerSocket(10003);
		//通过accept方法获取连接过来的客户端对象
		Socket s = ss.accept();
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"::");
		//获取客户端噶送过来的数据，要么使用客户端对象的读取流来读取数据。
		InputStream in = s.getInputStream();
		

		byte[] buf = new byte[1024];
		int len = in.read(buf);
		
		System.out.println(new String(buf,0,len));
	}
}

import java.io.*;
import java.net.*;
/*
演示Tcp的传输： 客户端与服务端互访。

需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息。


*/


/*
客户端：
1.建立socket连接，指定连接主机和端口
2.获取socket流中的输出流，将数据写入流中，通过网络发送给服务端。
3.获取socket流中的输入流，将服务端反馈的数据获取到，并打印。
4.关闭客户端资源。
*/

class  TcpClient2
{
	public static void main(String[] args) throws Exception
	{
		Socket s = new Socket("192.168.1.2",10004);

		OutputStream ops = s.getOutputStream( );
		ops.write("服务端，你好".getBytes());

		InputStream ips = s.getInputStream();
		byte[] buf = new byte[1024];
		int len = ips.read(buf);
		System.out.println(new String(buf,0,len));
		s.close();
	}
}


class  TcpServer2
{
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss = new ServerSocket(10004);
		Socket s = ss.accept();
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"连接");
		InputStream ips = s.getInputStream();
		byte[] buf = new byte[1024];
		int len = ips.read(buf);
		System.out.println(new String(buf,0,len));
		

		OutputStream ops = s.getOutputStream( );
		ops.write("客户端，你好".getBytes());

	
	}
}

上传文件

import java.io.*;
import java.net.*;
class TextClient
{
	public static void main(String[] args)throws Exception
	{
		Socket s = new Socket("192.168.1.2",10006);

		BufferedReader bufr = new BufferedReader(new FileReader("IpDemo.java"));

		PrintWriter pw = new PrintWriter(s.getOutputStream(),true);

		String line = null;

		while ((line = bufr.readLine())!= null)
		{
			pw.println(line);
		}
		s.shutdownOutput();//结束标记

		BufferedReader bufin = new BufferedReader(new InputStreamReader(s.getInputStream())); 

		String str = bufin.readLine();
		System.out.println(str);
		bufr.close();
		s.close();
	}
}


class TextServer
{
	public static void main(String[] args)throws Exception 
	{
		ServerSocket ss = new ServerSocket(10006);
		Socket s = ss.accept();
		String ip  = s.getInetAddress().getHostAddress();
		System.out.println(ip+"。。。。连接");
		BufferedReader bufr = new BufferedReader(new InputStreamReader(s.getInputStream()));
		PrintWriter pw = new PrintWriter(new FileWriter("server.txt"),true);
		String line = null;
		while ((line = bufr.readLine())!= null)
		{
			pw.println(line);
		}

		PrintWriter pww = new PrintWriter(s.getOutputStream(),true);
		pww.println("上传成功");
		s.close();
		ss.close();
	}
}

/*
需求：建立一个文本转换服务器。
客户端给服务端发送文本，服务端会将文本转成大写返回给客户端。
而且，客户端可以不断进行文本转换，当客户端输入over时转换结束。
*/



/*
分析：
客户端：既然是操作设备上的数据，那么就可以使用io技术。并按照io的操作规律来思考。
源：键盘录入。
目的：网络输出流。而且操作的是文本数据，可以选择字符流。

步骤：
1.建立服务
2.获取键盘录入
3.将数据发送服务端。
4.获取服务端返回数据。
5.关闭资源。

都是文本数据，可以使用字符流进行操作，提高效率。加入缓冲区。
*/

import java.io.*;
import java.net.*;

class TransClient
{
	public static void main(String[] args)throws Exception 
	{
		Socket s = new Socket("192.168.1.2",10005);

		//源,定义读取键盘数据的流对象。
		BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
		//目的，将数据写入到socket输出流，发送该服务端。
		//BufferedWriter bufout = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

		PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
		
		//定义一个socket读取流，读取服务端返回大写信息
		BufferedReader bufin = new BufferedReader(new InputStreamReader(s.getInputStream()));
		String line = null;
		
		while ((line = bufr.readLine())!=null)
		{
			if ("over".equals(line))
			{
				break;
			}
			pw.println(line);
			//bufout.write(line);
			//bufout.newLine();//结束标记。。。注意
			//bufout.flush();//缓冲区，刷新
			String str = bufin.readLine();
			System.out.println("大写"+str);
		}
		//关闭资源
		bufr.close();
		s.close();
		
	}
}
/*
服务端：
源：socket读取流。
目的：socket输出流
都是文本，装饰。
*/
class TransServer
{
	public static void main(String[] args)throws Exception 
	{
		ServerSocket ss = new ServerSocket(10005);
		Socket s = ss.accept();

		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"::连接");
		//源，读取Socket读取流中的数据
		BufferedReader bufin = new BufferedReader(new InputStreamReader(s.getInputStream()));
		//目的，Socket输出流，将大写数据写入到socket输出流中，并发送给客户端。
		//BufferedWriter bufout = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

		PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
		String line = null;
		while ((line = bufin.readLine())!= null)
		{
			System.out.println(line);
			pw.println(line.toUpperCase());
			//bufout.write(line.toUpperCase());
			//bufout.newLine();
			//bufout.flush();
		}

		s.close();
		ss.close();

	}

}

上传图片（并发）

/*
需求：上传图片。


*/

/*
客户端 
1.服务端点。
2.读取客户端已有的图片数据。
3.通过socket输出流将数据发给服务端。
4.读取服务端反馈信息。
5.关闭。
*/
import java.io.*;
import java.net.*;


class PicClient 
{
	public static void main(String[] args) throws Exception
	{
		if(args.length!=1)
		{
			System.out.println("请选择Png格式图片");
			return;
		}
		File file = new File(args[0]);
		if(!(file.exists() &&file.isFile()))
		{
			System.out.println("该文件有问题，要么不存在，要么不是文件");
			return;
		}
		if (!file.getName().endsWith(".png"))
		{
			System.out.println("图片格式错误，请重新选择");
			return;
		}
		if (file.length()>1024*1024*5)
		{
			System.out.println("文件过大，没安好心");
			return;
		}



		Socket s = new Socket("192.168.1.2",10007);
		//定义文件读取流
		FileInputStream fis = new FileInputStream(file);
		//向socket流写入数据
		OutputStream out = s.getOutputStream();
		byte[] buf = new byte[1024];
		int len = 0;
		while ((len = fis.read(buf))!= -1)
		{
			out.write(buf,0,len);
		}

		//结束标记
		s.shutdownOutput();
		//读取socket流中的数据。
		InputStream in = s.getInputStream();
		byte[] bufin = new byte[1024];
		int num = in.read(bufin);
		System.out.println(new String(bufin,0,num));

		fis.close();
		s.close();

	}
}

/*
服务端。

*/
class  PicServer
{
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss = new ServerSocket(10007);
		Socket s = ss.accept();
		//读取socket流中的数据
		InputStream in = s.getInputStream();

		//获取客户端Ip地址
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"客户连接");
		//将数据写入到文件中。
		FileOutputStream fos = new FileOutputStream("k2.png");
		//缓冲。。
		byte[] buf = new byte[1024];
		int len = 0;
		while ((len = in.read(buf))!= -1)
		{
			fos.write(buf,0,len);
		}

		//socket输出流
		OutputStream out = s.getOutputStream();
		out.write("上传成功".getBytes());
		fos.close();
		s.close();
		ss.close();

	}
}

class PicThread implements Runnable
{
	private Socket s;
	PicThread(Socket s)
	{
		this.s = s;
	}
	public void run()
	{
		try
		{
			//定义计数器
			int count = 1;
			//读取socket流中的数据
			InputStream in = s.getInputStream();

			//获取客户端Ip地址
			String ip = s.getInetAddress().getHostAddress();
			System.out.println(ip+"客户连接");
			//将数据写入到文件中。
			File file = new File(ip+"("+count+")"+".png");
			while (file.exists())
			{
				file = new File(ip+"("+(count++)+")"+".png");
			}

			FileOutputStream fos = new FileOutputStream(file);
			//缓冲。。
			byte[] buf = new byte[1024];
			int len = 0;
			while ((len = in.read(buf))!= -1)
			{
				fos.write(buf,0,len);
			}

			//socket输出流
			OutputStream out = s.getOutputStream();
			out.write("上传成功".getBytes());
			fos.close();
			s.close();
			
		}
		catch (Exception e)
		{
			throw new RuntimeException("失败。");
		}
	}
}
//并发执行的服务端
class PicServer2
{
	public static void main(String[] args)throws Exception
	{
		ServerSocket ss = new ServerSocket(10007);
		while (true)
		{
			Socket s = ss.accept();
			new Thread(new PicThread(s)).start();
		}
	}
}

登录服务器，并反馈信息

/*
客户端通过键盘录入用户名。
服务端对这个用户名进行校验。

如果该用户名存在，在服务端显示XXX，已登录。
并在客户端显示XXX，欢迎光临。

如果该用户名不存在，在服务端显示XXX，尝试登录。
并在客户端显示XXX，该用户不存在。

最多登录三次。
*/

import java.io.*;
import java.net.*;

class  LoginClient
{
	public static void main(String[] args) throws Exception
	{
		
		Socket s = new Socket("192.168.1.2",10010);
		//读取键盘输入
		BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
		//向socket流中写入数据
		PrintWriter out = new PrintWriter(s.getOutputStream(),true);
		//从socket流总读取数据。
		BufferedReader bufin = new BufferedReader(new InputStreamReader(s.getInputStream()));
		//判断
		for (int x = 0;x < 3 ; x++ )
		{

			String line = bufr.readLine();
			if (line == null)
			{
				System.out.println("输入无效");
				break;

			}
			out.println(line);
			String info = bufin.readLine();
			
			System.out.println("info:"+info);

			if (info.contains("欢迎"))
				break;
			
		}
		bufr.close();
		s.close();
	}
}

class UserThread implements Runnable
{
	private Socket s;
	UserThread(Socket s)
	{
		this.s = s;
	}
	public void run()
	{
		//获取连接的客户端IP地址。
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"....已连接");
		try
		{
			for (int i = 0; i < 3 ;i++ )
			{
				//读取socket流中的数据。
				BufferedReader bufin = new BufferedReader(new InputStreamReader(s.getInputStream()));

				String name = bufin.readLine();
				if (name == null)
				{
					break;
				}
				//读取本地文件中的数据
				BufferedReader bufr = new BufferedReader(new FileReader("User.txt"));
				//向socket流中反馈数据。
				PrintWriter out = new PrintWriter(s.getOutputStream(),true);

				String line = null;
				boolean flag = false;
				while ((line =bufr.readLine())!= null)
				{
					if(line.equals(name))
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					System.out.println(name+"已登录");
					out.println(name+"，欢迎光临");
					break;
				}
				else
				{
					System.out.println(name+"尝试登录");
					out.println(name+"，用户名不存在");

				}
			}
			s.close();
		}
		catch (Exception e)
		{
			throw new RuntimeException("校验失败"+ip);
		}
	}
}



class  LoginServer
{
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss = new ServerSocket(10010);
		while (true)
		{
			Socket s = ss.accept();
			new Thread(new UserThread(s)).start();
		}
		
	}
}

浏览器客户端与自定义服务器

浏览器也是一个客户端，它可以对HTML进行解析。
Dos下的telnet是window提供的远程登陆客户端，命令“telnet ip 地址口号”可以用连接到网络上的任意一台主机。
Tomcat服务器：默认使用的是8080端口，启动Tomcat服务器，在浏览器是输入“本地地址：8080”就可以看到Tomcat的主页。

/* 
演示客户端和服务端。 
1.客户端：浏览器。 
服务端：自定义 
 
 
2. 
客户端是浏览器 
服务端：TomCat服务器。 
 
3. 
客户端：自定义 
服务器：TomCat服务器。 
 
*/  
import java.net.*;  
import java.io.*;  
class ServerDemo   
{  
    public static void main(String[] args) throws Exception  
    {  
        ServerSocket ss = new ServerSocket(11000);  
  
        Socket s = ss.accept();  
        String ip = s.getInetAddress().getHostAddress();  
        System.out.println(ip+"....connected");  
  
        InputStream in = s.getInputStream();  
  
        byte[] buf = new byte[1024];  
        int len = in.read(buf);  
        System.out.println(new String(buf,0,len));  
  
        PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
          
        out.println("<font color ='red' size = '10'>客户端你好");  
  
        s.close();  
        ss.close();  
  
    }  
}  

import java.io.*;  
import java.net.*;  
  
class MyIE   
{  
    public static void main(String[] args) throws Exception  
    {  
        //浏览器内部建立Socket客户端  
        Socket s = new Socket("192.168.1.2",8080);  
        //想服务器发送请求消息头  
        PrintWriter out = new PrintWriter(s.getOutputStream(),true);//别忘了加true  
        out.println("GET /myweb/demo.html HTTP/1.1");  
        out.println("Accept: */*");  
        out.println("Accept-Language: zh-cn");  
        out.println("Host: 192.168.1.2:11000");  
        out.println("Connection: Keep-Closed");  
        out.println();  
        out.println();//请求消息头末尾一定要有一行空行。  
          
        System.out.println("over1");  
        //读取服务器发送过来的响应消息头和数据体。  
        BufferedReader bufr =   
            new BufferedReader(new InputStreamReader(s.getInputStream()));  
        String line = null;  
        while((line=bufr.readLine())!=null)  
        {  
            System.out.println(line);  
        }  
  
        s.close();  
  
    }  
}  
/*  
http://192.168.1.2:11000/myweb/demo.html  
  
客户端http请求消息头，  
/*GET / HTTP/1.1
Accept: text/html, application/xhtml+xml, 
Accept-Language: zh-CN
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)
Accept-Encoding: gzip, deflate
Host: 192.168.12.101:10086
Connection: Keep-Alive
*/  
   
/* 
 
服务器：HTTP响应消息头 
HTTP/1.1 200 OK 
Server: Apache-Coyote/1.1 
Accept-Ranges: bytes 
ETag: W/"315-1358328614234" 
Last-Modified: Wed, 16 Jan 2013 09:30:14 GMT 
Content-Type: text/html 
Content-Length: 315 
Date: Wed, 16 Jan 2013 10:03:30 GMT

URL
URL-：代表一个统一资源定位符，它是指向互联网“资源”的指针。资源可以是简单的文件或目录，也可以是对更为复杂的对象的引用，例如对数据库或搜索引擎的查询。
URI 是统一资源标识符，而 URL是统一资源定位符。因此，笼统地说，每个 URL都是 URI，但不一定每个 URI都是 URL。这是因为 URI还包括一个子类，即统一资源名称 (URN)，它命名资源但不指定如何定位资源。
常用方法示例：
intgetDefaultPort() ：获取与此 URL关联协议的默认端口号。
String getFile() ：获取此 URL的文件名。
String getHost() ：获取此 URL的主机名（如果适用）。
String getPath() ：获取此 URL的路径部分。
int getPort() ：获取此 URL的端口号。
String getProtocol()：获取此 URL的协议名称。
String getQuery() ：获取此 URL的查询部分。

import java.net.*;  
class  URLDemo  
{  
    public static void main(String[] args) throws Exception  
    {  
        //URL url=new URL("http://192.168.1.2:11000/myweb/demo.html");  
        URL url=new URL("http://192.168.1.2:11000/myweb/demo.html?name=haha&age=30");  
        System.out.println("getProtocol():"+url.getProtocol()); //http            
        System.out.println("getHost():"+url.getHost());//192.168.1.2  
        System.out.println("getDefaultPort():"+url.getDefaultPort());//80，如果关联的协议没有默认的端口，则值为-1；  
        System.out.println("getPort():"+url.getPort()); //  11000,如果没有设置则为-1；  
        System.out.println("getPath():"+url.getPath());// /myweb/demo.html  
        System.out.println("getFile():"+url.getFile());///myweb/demo.html?name=haha&age=30  
        System.out.println("getQuery():"+url.getQuery());//name=haha&age=30  
  
    /*  int port = url.getPort(); 
        if(port==-1) 
            port =80; 
        getPort（） = -1 
    */  
    }  
}

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------