`
_kudy
  • 浏览: 17007 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

javase_22(TCP的理解)

 
阅读更多
TCP传输
Socket(客户端)和ServerSocket(服务端)
建立客户端和服务器端
建立连接后,通过Socket中的IO流进行数据的传输
关闭Socket()当关闭这个流,其实就是把底层的流所关闭
同样,客户端与服务器端程序是两个独立运行的应用程序.


基本思路:(客户端)
客户端需要明确服务器的IP地址和端口,这样才可以试图去建立连接.如果连接失败,会出现异常.

连接成功,说明客户端与服务器端建立了通道,那么通过IO流就可以进行数据的传输,而Socket对象已经提供了输入流和输出流对象,通过
getInputStream(), getOutputStream()获取即可.

与服务端通信结束,关闭Socket.

基本思路:(服务器端)
服务端需要明确它要处理的数据是从那个端口进入的.

当有客户端访问时,要明确是那个客户端,可通过accept()获取已经连接的客户端对象,并且通过该对象与客户端通过IO流进行数据的传输.

当客户端访问结束,关闭该客户端.

生动的比喻:
　　必须要建立114服务台,客户才可以拨打的道理..当TCP服务器程序运行到ServerSocket.accept方法等待客户的连接,在正常的情况下,accept方法会发生阻塞,一直等到客户连接请求的到来.该方法才会返回.如果没有客户端请求来的情况下,accept方法没有发生阻塞,那么肯定前面的程序是有问题的.,通常端口被其他的程序所占用.

利用循环从客户端里面读取数据,并且在服务端显示出来?不要把问题那么复杂,该多线程就多线程-->该怎么走.比喻用到多线程.-->休息一下.等待它读取数据.要不然.我都还没有读取数据.-->你这边就已经执行了.


客户端
通过Socket建立对象并指定要连接的服务端主机与端口 
Socket s = new Sockte("127.0.0.0.1",8888);
InputStream ips = s.getInputS	tream();
OutputStream ops = s.getOutputStream();
S.close();//底层的流必须要关闭/.


服务端:
建立服务端需要监听的一个端口: 
ServerSocket ss = new ServerSocket(8888);
//获取到客户端的Socket .
Socket ss = Ss.accept();
InputStream ips = s.getInputStream();
OutputStream ops = s.getOutputStream();
byte [] buf = new byte[1024];
Ips.read(buf);
int num = ips.read(buf);
String str = new String(buf,0,num);
Ss.close();
S.close();


简单的TCP客户端与服务端:

客户端: 
package com.javami.kudyDemo.Tcp;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class TcpClient
{

	/**
	 * 客户端
	 */
	public static void main(String[] args)
	{
		Socket socket = null;
		try
		{
			//连接到指定的主机端口号上
			socket = new Socket("127.0.0.1",8888);
			
			//-->读取服务端的数据
			InputStream ips = socket.getInputStream();
			//-->发送服务端的数据
			OutputStream ops = socket.getOutputStream();
			ops.write("服务器你最近还好吗?".getBytes());//转换成字节流
			ops.write("可以同时写两个数据吗??".getBytes());//转换成字节流
			byte [] buf = new byte[ips.available()];
			ips.read(buf);
			System.out.println(new String(buf));
		}
		catch(IOException e)
		{
			
		}finally
		{
			try
			{
				if(socket!=null)
						socket.close();
			}catch(IOException e)
			{
				e.printStackTrace();
			}
		}
		
	}

}


服务端: 
package com.javami.kudyDemo.Tcp;

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

public class TcpServer
{
	/*
	 * 服务端
	 */
	public static void main(String[]args)
	{
		ServerSocket ss = null;;
		Socket socket = null;
		try
		{
			ss = new ServerSocket(8888);
			socket = ss.accept();//监听端口--->和客户端已经绑定起来
			InputStream ips = socket.getInputStream();
			OutputStream ops = socket.getOutputStream();
			byte[] buf = new byte[ips.available()];//个数为多少
			ips.read(buf);
			System.out.println(new String(buf));
			ops.write("我最近过得还好~你不需要担心我服务器的寿命".getBytes());
		}catch(IOException e)
		{
			e.printStackTrace();
		}finally
		{
			try
			{
				if(ss!=null)
					ss.close();
			}catch(IOException e)
			{
				e.printStackTrace();
			}
		}
	}
}


字母转换大写功能:
客户端: 

package com.javami.kudyDemo.Tcp;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class MyClient
{

	/**
	 *客户端
	 *循环边度边写的概念!!这一步不考虑多线程的问题
	 */
	public static void main(String[] args)
	{
		Socket socket = null;
		try
		{
			socket = new Socket("127.0.0.1",8888);
			InputStream ips = socket.getInputStream();
			OutputStream ops = socket.getOutputStream();
			byte[]buf = new byte[ips.available()];
			System.out.println(new String(buf));
			System.out.println("请输入内容:");
			while(true)
			{
				BufferedReader br =
						new BufferedReader(new InputStreamReader(System.in));
					
				String line = br.readLine();
				if("quit".equals(line))
					break;
				ops.write((line+"\r\n").getBytes());
				byte[] b = new byte[ips.available()];
				ips.read(b);
				System.out.println("转换后的效果:"+new String(b));
			}

		}catch(IOException e)
		{
			e.printStackTrace();
		}finally
		{
			if(socket!=null)
				try
				{
					socket.close();
				} catch (IOException e)
				{
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
		}
	}

}


服务端: 

package com.javami.kudyDemo.Tcp;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class MyServer
{
	/**
	 * 服务端
	 */
	public static void main(String[] args)
	{
		ServerSocket ss = null;
		try
		{
			//监听端口
			ss = new ServerSocket(8888);
			Socket socket = ss.accept();//等待客户端的连接 返回连接后的对象
			InputStream ips =socket.getInputStream();
			OutputStream ops = socket.getOutputStream();
			while(true)
			{
				BufferedReader br = //把读取到的内容转换成字符流
						new BufferedReader(new InputStreamReader(ips));
				String line =  br.readLine();
				if("quit".equals(line))
					break;
				String toLine = line.toUpperCase();//转换成大写字母
				ops.write(toLine.getBytes());
				 
			}
		}catch(IOException e)
		{
			e.printStackTrace();
		}finally
		{
			if(ss!=null)
				try
				{
					ss.close();
				} catch (IOException e)
				{
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
		}
	}

}


一个程序开启了多线程-->Thread-0线程去执行..-->Main线程也在执行的.
必须让main线程等待一下.让其有一个消化的过程.

字母的转换:(使用了多线程解决问题)
客户端类 

package com.javami.kudyDemo.Tcp;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class ReverseClinet
{
	public static void main(String[]args) throws InterruptedException, UnknownHostException, IOException
	{
			Socket socket = null;
			socket = new Socket("127.0.0.1",8888);
			InputStream ips = socket.getInputStream();
			OutputStream ops = socket.getOutputStream();
			//接收欢迎语,必须要先休息一下.因为那边写入数据.如果不休息.
			//由于是开了线程执行的.main主线程就打印出来.所以打印到你的内容必定是空白的
			Thread.sleep(10);
			int len = ips.available();
			byte[] buf = new byte[len];
			ips.read(buf);
			System.out.println(new String(buf));
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			System.out.println("开始吧!!");
			while(true)
			{
				String line = br.readLine();
				ops.write((line+"\r\n").getBytes());//写入进去
				int l = ips.available();
				byte[] b = new byte[l];
				Thread.sleep(10);
				ips.read(b);
				System.out.println(new String(b));
			}
	}
}


服务端: 
package com.javami.kudyDemo.Tcp;

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

/*
 * 服务器提供字符反向服务
 *多线程的思路:
 *我等待用户的连接..当有用户连接.我交给别的线程去执行.对象是仍然没有变.-->socket重点.
 *必须要循环监听.如果不循环监听...当一个服务端和客户端再运行..我就结束了..
 */
public class ReverseServer
{
	public static void main(String[]args)
	{
		ServerSocket ss = null;
		try
		{
			 ss = new ServerSocket(8888);
			while(true)
			{
				Socket socket = ss.accept();
				new Thread(new ReverseServers(socket)).start();
			}
		} catch (IOException e)
		{
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally
		{
			if(ss!=null)
				try
				{
					ss.close();
				} catch (IOException e)
				{
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
		}
	}
}


-->它的哥们 

package com.javami.kudyDemo.Tcp;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;

public class ReverseServers implements Runnable
{
	Socket socket ;
	public  ReverseServers(Socket socket)
	{
		this.socket = socket;
	}
	public  void run()
	{
		try
		{
			InputStream ips = socket.getInputStream();
			OutputStream ops = socket.getOutputStream();
			ops.write("启动服务器提供反转功能:".getBytes());
			while(true)
			{
				BufferedReader br =
					new BufferedReader(new InputStreamReader(ips));//把读取到的数据转换成字符流
				String line = br.readLine();
				if("quit".equals(line))
					break;
				StringBuilder sb = new StringBuilder(line);
				String newLine = sb.reverse().toString();//转换
				ops.write(newLine.getBytes());
			}
		}catch(IOException e)
		{
			e.printStackTrace();
		}finally
		{
			if(socket!=null)
				try
				{
					socket.close();
				} catch (IOException e)
				{
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
		}
	}
}


TCP网络程序的工作原理:

TCP客户端程序与TCP服务端程序的交互过程:
服务器端程序创建一个ServerSocket,然后调用accpept方法等待客户来连接.
客户端程序创建一个Socket并请求服务端建立连接.
服务器端接收客户的连接请求,并创建一个新的Socket与该客户建立专线连接.
建立了连接的两个Socket在一个单独的线程(由服务端程序创建)上对话.
服务器端开始等待i新的连接请求,当新的连接请求到达时,重复上述过程.




文件上传案例分析
一、需求分析
1.多线程的服务器
2.客户端程序
3.上传文件名
4.上传文件

二、实现步骤
1.实现多线程服务器
1)创建ServerSocket对象，监听指定的端口，7888
2)循环调用accept方法，等待客户端的连接，次方法阻塞，返回一个客户端Socket
3)开启新线程，运行一个服务对象，将socket给这个对象
2.实现客户端程序
1)创建Socket对象，连接服务器  127.0.0.1  7888
3.发送和接收欢迎语
服务器端： 获得输入输出流， 发送欢迎语， out.write();
客户端： 获得输入输出流， 接收欢迎语， in.read();
4.发送文件名，创建文件
1)客户端：
读键盘，获得文件路径名 BufferedReader
创建文件对象， File
判断文件是否存在，文件是否为标准文件 isFile
获得文件名：getName
将文件名上传给服务器，out.write
等待接收服务器反馈的信息
2)服务器端：
接收文件名，in.read();
创建文件对象， 在指定目录下创建 createNewFile
判断是否创建成功，文件已存在或创建失败， 将是否可以继续上传的信息发给客户端 out.write
5.上传文件
1)客户端：
如果可以开始上传文件了
BufferedInputStream包装FileInputStream
BufferedOutputStream包装 socket.getOutputStream()
实现流的对拷，逐个字节拷贝，
2)服务器端
接收客户端上传的数据写入新创建的文件中
BufferedInputStream包装socket.getInputStream()
BufferedOutputStream包装 FileOutputStream
实现流的对拷，逐个字节拷贝。

文件的上传功能小项目

客户端: 
package com.javami.kudyDemo;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;

public class UploadClient
{

	public static void main(String[] args)
	{
		Socket socket = null;
		try
		{
			socket = new Socket("127.0.0.1",8888);
			InputStream ips = socket.getInputStream();
			OutputStream ops = socket.getOutputStream();
			//接收欢迎语句
			Thread.sleep(10);//-->等待线程的写入
			int len = ips.available();
			byte[] buf = new byte[len];
			ips.read(buf);
			System.out.println(new String(buf));
			
			//上传文件名
			BufferedReader br =
					new BufferedReader(new InputStreamReader(System.in));
			System.out.println("请输入你的文件名:");
			File file = null;
			while(true)
			{
				String fileName = br.readLine();
				if("quit".equals(fileName))
						return ;
				file = new File(fileName);
				if(file.isFile())
				{
					ops.write(file.getName().getBytes());
					break;//如果是文件--写入进去
				}
				if(!file.isFile())
					System.out.println("该文件不存在,请重新输入");
				else
					System.out.println("只支持标准文件的上传");
			}
			
			//等待服务端的反馈:
			buf = new byte[1024];
			len = ips.read(buf);
			String info = new String(buf,0,len);
			System.out.println(info);
			if(!"可以上传文件".equals(info))
				return;
			long fileSize = file.length();
			ops.write(String.valueOf(fileSize).getBytes());
			Thread.sleep(100);
			
			//上传文件
			upload(file,ops);
			
			//等待服务端的反馈
			len = ips.read(buf);
			System.out.println(new String(buf,0,len));
		}catch(Exception  e)
		{
			e.printStackTrace();
		}finally
		{
			
		}
	}

	private static void upload(File file, OutputStream ops) throws IOException
	{
		BufferedInputStream bis = 
				new BufferedInputStream(new FileInputStream(file));//读取林的内容
		BufferedOutputStream bos = new BufferedOutputStream(ops);//写入内容
		System.out.println("文件上传中~~~~");
		int ch ;
		while((ch=bis.read())!=-1)
		{
			bos.write(ch);
		}
		bos.flush();//这个刷新一下就可以.因为让底层去关.要不然就会发生冲突
		bis.close();//这个必须要关
	}

}


服务端: 
package com.javami.kudyDemo;

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

public class UploadServer
{
	/*
	 * 必须要用到多线程去做.如果你没有使用多线程..那么main线程只能和一个连接打交道..
	 * while
	 * 
	 */
	public static void main(String[]args)
	{
		ServerSocket ss = null;
		try
		{
			System.out.println("服务器已经开启,正在监听8888端口");
			ss = new ServerSocket(8888);
			while(true)//我while循环没有结束-->在监听啦~~~
			{		
				Socket socket = ss.accept();//当每一个线程都进来的时候,这里会发生阻塞
				System.out.println("成功与一个客户端建立连接"+
							socket.getInetAddress().getHostAddress());
				new Thread(new UploadServers(socket)).start();
			}
		} catch (IOException e)
		{
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally
		{
			if(ss!=null)
				try
				{
					ss.close();
				} catch (IOException e)
				{
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
		}
	}
}


客户端的哥们--> 

package com.javami.kudyDemo;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class UploadServers implements Runnable
{

	Socket socket ;
	public UploadServers(Socket socket)
	{
		this.socket = socket;
	}

	@Override
	public void run()
	{
		try
		{
			InputStream ips = socket.getInputStream();
			OutputStream ops = socket.getOutputStream();
			ops.write("连接成功,本站支持文件的上传".getBytes());
			
			//接收文件名
			byte[] buf = new byte[1024];
			int len = ips.read(buf);
			String fileName = new String(buf,0,len);
			System.out.println("拿到文件名:"+fileName);
			
			//创建文件
			File file = new File("f:/a",fileName);
			if(!file.createNewFile())
			{
				ops.write("该文件已经存在".getBytes());
				return;
			}
			ops.write("可以上传文件".getBytes());
			
			//接收文件的大小
			len = ips.read(buf);
			String str = new String(buf,0,len);
			int fileSize = (int)Integer.parseInt(str);
			
			//接收客户端的文件
			saveFile(ips,file,fileSize);//接收的内容.我的文件名  --> 接收过来的长度
			//接收从客户端发送过来的文件
			ops.write("文件上传完毕,恭喜-->使用了".getBytes());
		} catch (IOException e)
		{
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}

	private void saveFile(InputStream ips, File file, int fileSize) throws IOException
	{
		BufferedInputStream bis = 
				new BufferedInputStream(ips);//读取内容-->会发生阻塞..
		BufferedOutputStream bos = 
				new BufferedOutputStream(new FileOutputStream(file));
		int ch;
		System.out.println("文件上传中,请等下------");
		for(int i=0; i<fileSize; i++)
		{
			ch = bis.read();
			bos.write(ch);
		}
		bos.close();//不需要把底层的所关闭~~
	}

}


----------以下内容为自己非用编译工具下..功能实现得比较简单点.以上一样..
客户端: 

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
class MyChlient 
{
	/*
		客户端
		:
		文件的上传功能
	*/
	public static void main(String[] args) 
	{
		Socket socket = null;
		try
		{
			socket = new Socket("127.0.0.1",8888);
			InputStream ips = socket.getInputStream();
			OutputStream ops = socket.getOutputStream();
			Thread.sleep(10);
			byte [] buf = new byte[1024];
			int len = ips.read(buf);
			System.out.println(new String(buf,0,len));

			//发送文件名
			BufferedReader br = 
						new BufferedReader(new InputStreamReader(System.in));
			String line ;
			System.out.println("请输入文件的路径:");
			File file ;
			while(true)
			{
				line = br.readLine();
				file = new File(line);
				if(file.isFile())
				{
					ops.write(file.getName().getBytes());//把文件的名字发过去
					break;
				}
				if(!file.exists())
					System.out.println("该目录不存在");
				else
					System.out.println("不给力~~~");
			}

			//接收客户端反馈信息
			len = ips.read(buf);
			String info = new String(buf,0,len);
			if(!"已经成功创建文件".equals(info))
				return;
			System.out.println(info);

			//上传文件
			BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
			BufferedOutputStream bos = new BufferedOutputStream(ops);
			int ch;
			while((ch=bis.read())!=-1)
			{
				bos.write(ch);
			}
			bos.flush();//底层的流我们要刷新一下
			bis.close();//关闭一下流
	
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			try
			{
				if(socket!=null)
				socket.close();
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
		}
	}
}
服务端:
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.net.ServerSocket;
class MyServer 
{
	public static void main(String[] args) 
	{
		ServerSocket ss = null;
		try
		{
			ss = new ServerSocket(8888);
			System.out.println("服务器正在监听8888端口");
			while(true)
			{
				Socket socket = ss.accept();
				System.out.println(socket.getInetAddress().getHostAddress());//获取到连接上来的主机
				new Thread(new ThreadServer(socket)).start();
			}
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}finally
		{
			try
			{
				if(ss!=null)
					ss.close();
			}
			catch (Exception e)
			{
				e.printStackTrace();
			}
		}
	}
}

服务端的多线程实现类
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
class ThreadServer implements Runnable
{
	Socket socket;
	public ThreadServer(Socket socket)
	{
		this.socket = socket;
	}
	public void run()
	{
		try
		{
			InputStream ips = socket.getInputStream();
			OutputStream ops = socket.getOutputStream();
			ops.write("欢迎光临本小站,本小站提供文件上传的服务:".getBytes());

			//接收用户发送的文件名
			File file;
			byte[] buf = new byte[1024];
			int len = ips.read(buf);
			String fileName = new String(buf,0,len);
			System.out.println("服务器已经获取到文件名:"+fileName);
			file = new File("f:/upload",fileName);
			if(!file.createNewFile())
			{
				ops.write("文件已经存在".getBytes());
				return;
			}
			ops.write("已经成功创建文件".getBytes());

			//接收用户的文件
			byte [] b = new byte[ips.available()];
			BufferedOutputStream bos =
				new BufferedOutputStream(new FileOutputStream(file));//我们把内容写到这边来
			int ch;
			while((ch=ips.read())!=-1)
			{
				bos.write(ch);
			}
			bos.close();
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}finally
		{
			try
			{
				if(socket!=null)
					socket.close();
			}
			catch (Exception e)
			{
				e.printStackTrace();
			}
		}
	}
}


个人心得:..
不要分心,相信自己做的.一定要努力....天道酬勤.
分享到：
javase_21(DUp的学习-->*)
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    JavaSE_Demo

    这个"JavaSE_Demo"很可能是包含了一系列的Java编程实例，帮助学习者深入理解Java SE的各种特性和功能。以下是对Java SE的一些关键知识点的详细说明： 1. **基础语法**：Java是一种面向对象的编程语言，其基础语法...

    基于UDP协议的Socket通信.rar_UDP_javase_网络编程

    在IT行业中，网络编程是...同时，对于网络编程，理解网络层次模型、熟悉TCP/IP协议族的相关知识也是非常重要的。通过学习和实践，你可以掌握更多关于UDP Socket通信的知识，为开发高效、可靠的网络应用打下坚实基础。

    JavaSE6_API

    JavaSE6_API是Java Standard Edition 6的官方API文档，它是Java开发的重要参考资料，涵盖了Java 6版本中的核心类库和接口。这个文档为开发者提供了详细的类、接口、方法和异常描述，帮助他们理解和使用Java平台的...

    v512_张利国_JavaSE项目_源代码

    8. **网络编程**：JavaSE提供Socket和ServerSocket类进行TCP/IP通信，DatagramSocket和DatagramPacket类进行UDP通信。如果项目涉及网络通信，那么这部分代码将非常重要。 9. **Swing与AWT**：这两个是Java的图形...

    javaapi和源码-javase_review:回顾JavaSE深入了解源代码，并实现JDKAPI。源代码分析文章可以找到@我的博客

    java ... 第二级别：深刻理解【JVM的类加载机制？网络IO？TCP/IP和HTTP、HTTPS？并发的相关知识？】 java.lang.reflect java.net javax.net.* java.nio.* java.util.concurrent.* 第

    基于TCP协议的JavaSE购物商场系统.rar

    描述中提到的"源代码"意味着我们可以深入理解系统的架构和逻辑，学习如何在JavaSE环境下利用TCP进行网络编程。这通常包括服务器端的Socket编程，用于监听和处理来自客户端的连接请求，以及客户端的Socket编程，用于...

    王道JavaSE阶段测试

    合理利用意味着根据自己的学习进度和理解情况，适时地进行自我测试，了解自己在JavaSE学习过程中的强项和弱点。阶段性测试能够帮助学习者在每个阶段结束后评估自己的进步，及时发现不足，避免在后续的学习中出现概念...

    File-transfer-system-based-on-TCP.rar_tcp实现文件

    标题中的“File-transfer-system-based-on-TCP.rar”指的是一个基于TCP协议实现的文件传输系统，而“tcp实现文件”标签...通过阅读这份文档，可以更深入地理解如何在实际项目中构建这样一个基于TCP的文件传输系统。

    javase+项目练习(一)

    总的来说，这个"javase+项目练习(一)"不仅提供了理论知识的学习，更是一个实践操作的好机会，通过实际编码加深对JavaSE的理解，提升编程技能。同时，结合MATLAB的相关知识，可以拓宽项目实施的范围，使你成为更全面...

    javase笔记.7z

    JavaSE，全称为Java Standard Edition，是Java平台的标准版，主要面向桌面应用和服务器端开发。...学习JavaSE不仅需要掌握这些基础知识，还要通过实践不断深化理解，才能成为一名优秀的Java开发者。

    03_javaSE.rar

    Java SE（Java Standard Edition）...通过“03_javaSE.rar”中的资源，你可以深入理解每个API的工作原理，通过实例代码加深理解，并提升编程能力。无论是进行桌面应用开发还是构建后台服务，这些知识都将起到关键作用。

    JavaSE实战——客户端上传文件到服务端

    在JavaSE实战项目中，客户端上传文件到服务端是一个常见的任务，这涉及到Java网络编程、文件操作以及TCP协议的理解和应用。在这个过程中，开发者需要掌握以下几个核心知识点： 1. **Java网络编程基础**：Java提供了...

    JavaSE精华笔记.zip

    Java提供了丰富的网络编程API，如Socket和ServerSocket，支持TCP/IP和UDP通信。这部分内容会涉及网络连接、数据传输、套接字编程等，对于开发网络应用非常有用。 8. **8.反射.pdf**： 反射是Java的一个高级特性，...

    javaSE阶段学习项目--图书馆管理系统

    这个项目是针对Java初学者设计的，旨在帮助他们深入理解并应用JavaSE的基础知识。项目采用三层架构思想进行开发，这三层分别是表现层（Presentation Layer）、业务逻辑层（Business Logic Layer）和数据访问层（Data...

    JAVASE中文版文档说明

    这份"JAVASE中文版文档说明"包含了关于Java SE的所有关键知识点，旨在帮助中文用户更好地理解和掌握Java编程语言。 1. **Java简介**: Java是由Sun Microsystems开发的一种面向对象的编程语言，具有“一次编写，到处...

    javaSE课件

    Java SE（标准版）是Java开发平台的核心组件，...通过这个"javaSE课件"，你将能够系统地学习以上各个知识点，并深入理解Java SE平台在网络编程方面的应用。记得理论结合实践，编写代码并调试，才能真正掌握这些技能。

    asnrt_javase-3.14.15.zip_asn runtime_asnrt

    ASN.1（Abstract Syntax Notation One）是一种标准的数据表示法，广泛用于通信协议、数据库和软件工程，特别是网络协议如TCP/IP和SS7。ASN.1定义了一种规范，可以将复杂的数据结构编码和解码成二进制形式，便于在...

    JavaSE思维导图

    这个思维导图涵盖了从基础语法到数据库连接的广泛JavaSE知识点，旨在帮助学习者系统地理解和掌握Java编程。 1. **基础语法** - 变量与数据类型：包括基本数据类型（如int、char、float等）、引用数据类型（如类、...

    【狂神说】JavaSE系列.zip

    8. **网络编程**：JavaSE提供了Socket和ServerSocket类用于网络通信，可以构建简单的TCP/IP服务。 9. **泛型**：泛型是Java 5引入的新特性，用来在编译时检查类型安全，并且所有的强制转换都是自动和隐式的，提高了...

Magicbox
Global site tag (gtag.js) - Google Analytics