第十三章学习总结

最新推荐文章于 2024-03-13 19:19:51 发布

咕咕噜噜噜

最新推荐文章于 2024-03-13 19:19:51 发布

阅读量451

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/Yt_Yt_/article/details/84785366

201711671112 《JAVA程序设计》第十三章学习总结

教材学习内容总结

13.1 URL类

1、URL是java.net包中一个重要的类，使用URL创建对象的应用程序称为客户端程序。

2、一个url对象封装着一个具体的资源引用，同乘包含最基本的三部分信息：协议、地址和资源。

3、构造方法： public URL(String spec) throws MalformedURLException

\ (String protocol,String host,String file)

4、对象调用InputStream openSream()方法可以返回一个输入流，该输入流只想URL对象所包含的资源。通过该输入流可以将服务器上的资源信息读入到客户端

用户需在同一个线程中读取URL资源，以免堵塞主线程

Example13_1

package Example13_1;
import java.net.*;
import java.io.*;
import java.util.*;
public class Example13_1 {
	public static void main(String[] args) {
		Scanner scanner;
		URL url;
		Thread readURL;  //负责读取资源的线程
		Look look=new Look(); //线程的目标对象
		System.out.println("输入URL资源，例如：http://www.yahoo.com");
		scanner=new Scanner(System.in);
		String source=scanner.nextLine();
		try {
			url=new URL(source);
			look.setURL(url);
			readURL=new Thread(look);
			readURL.start();
		}
		catch(Exception exp) {
			System.out.println(exp);
		}
	}

}
class Look implements Runnable{
	URL url;
	public void setURL(URL url) {
		this.url=url;
	}
	public void run() {
		try {
			InputStream in=url.openStream();
			byte[]b=new byte[1024];
			int n=-1;
			while((n=in.read(b))!=-1) {
				String str=new String(b,0,n);
				System.out.print(str);
			}
		}
		catch(IOException exp) {}
	}
}

13.2

1、InetAddress类用途，在后面程序中作为其他类的方法的参数

2、两种表示地址的方式，①域名 www.~ ②IP地址 202.108.32.452 域名容易记住，在连接网络时输入一个主机的域名后，域名服务器负责将域名砖混成IP地址，这样才能和主机建立连接。

3、可以使用InetAdress类的静态方法getByName(String s)将一个域名或IP地址传递给该方法的参数s，获得一个InetAdress类对象，该对象含有主机地址的域名和IP地址

package Example13_2;
import java.net.*;
public class Example13_2 {
	public static void main(String[] args) {
		try {
			InetAddress address_1=InetAddress.getByName("www.sina.com.cn");
			System.out.println(address_1.toString());
			InetAddress address_2=InetAddress.getByName("166.111.222.3");
			System.out.println(address_2.toString());
		}
		catch(UnknownHostException e) {
			System.out.println("无法找到www.sina.com.cn");
		}
	}
}

4、可以使用InetAdress类的静态方法getLocalHost()获得一个InetAdress类对象

13.3

1、端口号规定为一个16位的0~65535之间的整数，0~1023被预先定义的服务器通信占用，应该使用1024~65535这些端口中的某一个，以免发生端口冲突

2、客户端程序使用Socket类负责连接到服务器的套接字对象。构造方法是 Socket(String host,int port),参数host是服务器的IP地址，port是一个端口号

try{Soclet clientSocket=new Socket("http://192.168.0.78",2010);

}

catch(IOException e){}

3、clientSocket可以使用方法getInputStream()获得一个输入流，客户端用输入流可以读取服务器写入到输出流中的数据，使用getOutputStream（）获得一个输出流，服务器用输入流可以读取客户写入到输出流中的数据

4、为了使客户成功地连接到服务器，服务器必须建立一个ServerSocket（int，port）

package Example13_3_2;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class Example13_3_2 {
	public static void main(String[] args) {
		String[]answer= {"南非","进入世界杯了","哈哈。。。问题真逗！"};
		ServerSocket serverForClient=null;
		Socket socketOnServer=null;
		DataOutputStream out=null;
		DataInputStream in=null;
		try {
			serverForClient=new ServerSocket(2010);
		}
		catch(IOException e1) {
			System.out.println(e1);
		}
		try {
			System.out.println("等待客户呼叫");
			socketOnServer=serverForClient.accept();//阻塞状态除非有客户呼叫
			out=new DataOutputStream(socketOnServer.getOutputStream());
			in=new DataInputStream(socketOnServer.getInputStream());
			for(int i=0;i<answer.length;i++) {
				String s=in.readUTF();   //in读取信息，阻塞状态
				System.out.println("服务器收到客户的提问："+s);
				out.writeUTF(answer[i]);
				Thread.sleep(500);
			}
		}
		catch(Exception e) {
			System.out.println("客户已断开"+e);
		}
	}
}
package Example13_3_1;  //客户端

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;

public class Example13_3_1 {
	public static void main(String[] args) {
		String[]mess= {"2010世界杯在哪举行？","巴西进入世界杯了吗？","中国进入世界杯了吗？"};
		Socket mysocket;
		DataInputStream in=null;
		DataOutputStream out=null;
		try {
			mysocket=new Socket("127.0.0.1",2010);
			in=new DataInputStream(mysocket.getInputStream());
			out=new DataOutputStream(mysocket.getOutputStream());
			for(int i=0;i<mess.length;i++) {
				out.writeUTF(mess[i]);
				String s=in.readUTF();  //in读取信息，阻塞状态
				System.out.println("客户端收到服务器的回答："+s);
				Thread.sleep(500);
			}
		}
		catch(Exception e) {
			System.out.println("服务器已断开"+e);
		}
	}
}

13.4

1、基于UDP通信的基本模式是：将数据打包，称为数据包，然后数据包发往目的地；接受发来的数据包。然后查看数据包中的内容

2、用DatagramPacket类将数据打包，即用DatagramPacket类创建一个对象

DatagramPacket（byte data【】，int length，InetAddress address，int port）

有两个性质：含有data数组指定的数据；该数据包将发送到地址是address，端口号是port的主机上。

3、用DatagramSocket类的不带参数的构造方法创建一个对象，负责发送数据包

DatagramSocket mail_out=new DatagramSocket();

mail_out.send(data_pack);

用DatagramSocket类的DatagramSocket（int port）的构造方法创建一个对象，参数必须和待接收的数据包的端口号相同

package Example13_5_1;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

public class Example13_5_1 {
	public static void main(String[] args) {
	    Scanner scanner=new Scanner(System.in);
		Thread readData;           //读取资源的线程
		ReceiveLetterForZhang receiver=new ReceiveLetterForZhang();
		try {
			readData=new Thread(receiver);
			readData.start();   //负责接收信息的线程
			byte[]buffer=new byte[1];
			InetAddress address=InetAddress.getByName("127.0.0.1");
			DatagramPacket dataPack=new DatagramPacket(buffer,buffer.length,address,666);
			DatagramSocket postman=new DatagramSocket();
			System.out.print("输入发送给李四的信息：");
			while(scanner.hasNext()) {
				String mess=scanner.nextLine();
				buffer=mess.getBytes();
				if(mess.length()==0)
					System.exit(0);
				buffer=mess.getBytes();
				dataPack.setData(buffer);
				postman.send(dataPack);
				System.out.print("继续输入发送给李四的信息：");
			}
		}
		catch(Exception e) {
			System.out.println(e);
		}
	}
}
class ReceiveLetterForZhang implements Runnable{
	public void run() {
		DatagramPacket pack=null;
		DatagramSocket postman=null;
		byte data[]=new byte[8192];
		try {
			pack=new DatagramPacket(data,data.length);
			postman=new DatagramSocket(888);
		}
		catch(Exception e) {}
		while(true) {
			if(postman==null) break;
			else
				try {
					postman.receive(pack);
					String message=new String(pack.getData(),0,pack.getLength());
					System.out.printf("%25s\n", "收到:"+message);
				}
			catch(Exception e) {}
		}
	}
}

package Example13_5_2;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

public class Example13_5_2 {
	public static void main(String[] args) {
	    Scanner scanner=new Scanner(System.in);
		Thread readData;           //读取资源的线程
		ReceiveLetterForLi receiver=new ReceiveLetterForLi();
		try {
			readData=new Thread(receiver);
			readData.start();   //负责接收信息的线程
			byte[]buffer=new byte[1];
			InetAddress address=InetAddress.getByName("127.0.0.1");
			DatagramPacket dataPack=new DatagramPacket(buffer,buffer.length,address,888);
			DatagramSocket postman=new DatagramSocket();
			System.out.print("输入发送给张三的信息：");
			while(scanner.hasNext()) {
				String mess=scanner.nextLine();
				buffer=mess.getBytes();
				if(mess.length()==0)
					System.exit(0);
				buffer=mess.getBytes();
				dataPack.setData(buffer);
				postman.send(dataPack);
				System.out.print("继续输入发送给张三的信息：");
			}
		}
		catch(Exception e) {
			System.out.println(e);
		}
	}
}
class ReceiveLetterForLi implements Runnable{
	public void run() {
		DatagramPacket pack=null;
		DatagramSocket postman=null;
		byte data[]=new byte[8192];
		try {
			pack=new DatagramPacket(data,data.length);
			postman=new DatagramSocket(666);
		}
		catch(Exception e) {}
		while(true) {
			if(postman==null) break;
			else
				try {
					postman.receive(pack);
					String message=new String(pack.getData(),0,pack.getLength());
					System.out.printf("%25s\n", "收到:"+message);
				}
			catch(Exception e) {}
		}
	}
}