java中异步socket类的实现和源代码
java中异步socket类的实现和源代码
作者：dozb
我们知道,java中socket类一般操作都是同步进行，常常在read的时候socket就会阻塞直到有数据可读或socket连接断开的时候才返回，虽然可以设置超时返回，但是这样比较低效，需要做一个循环来不停扫描数据是否可读。看来，在同一个线程中，要是想实现异步读写不太容易。
下面介绍的这个类实现了伪异步socket通讯。基本思想就是在现有socket类的基础上进行封装，当sock et连接建立成功后，立即创建一个socket数据接收线程，专门负责阻塞式的socket读取(read)，而当前线程负责数据的发送(send)。另外定义了一个接口，包括了socket的各种事件的回调。我们要实现这个接口，在接口实现类中创建异步socket对象，并且传递接口类到异步socket对象中，目的是有socket事件的时候回调我们的方法。
下面是接口：
SocketExHandler.java
package https://www.wendangku.net/doc/1617577849.html,;
import https://www.wendangku.net/doc/1617577849.html,.*;
/**
* Title:
* Description:
* Copyright: Copyright (c) 2001
* Company: https://www.wendangku.net/doc/1617577849.html,
* @author dozb
* @version 1.0
*/
/**
* 异步Socket Client Interface
* 使用方法：
* 1.定义类 MySocketClientEx 实现SocketExHandler接口,实现 OnReceive OnClose OnConnect 事件
* 2.在类中实现start方法 MySocketEx = new SocketEx(this,ip,port)
* 3.在类中实现stop方法 delete MySocketEx
* 4.当有数据到达时会触发OnReceive事件
* 5.当对方SOCKET关闭时会触发OnClose事件
* 6.当SOCKET建立时会触发OnConnect事件
*/
/**
* 异步Socket Server Interface
* 使用方法：
* 1.定义类 MySocketServerEx 实现SocketExHandler接口,实现 OnReceive OnListen OnClose OnAccept 事件
* 2.在类中实现start方法 MySocketEx = new ServerSocketEx(this,ip,por t)
* 3.在类中实现stop方法 delete MySocketEx
* 4.当开始监听时会触发OnListen事件
* 5.当SOCKET关闭时会触发OnClose事件
* 6.当有客户端SOCKET要建立连接时会触发OnAccept事件
*/
public interface SocketExHandler
{
//当客户端sock数据到达时触发
public void OnReceive(Object socket,byte buf[],int nLen);
//当客户端sock连接建立成功时触发
public void OnConnect(Object socket);
//当服务端sock监听开始时触发
public void OnListen(Object socket);
//当服务端sock接受一个新的sock连接时触发
public void OnAccept(Object socket,SocketEx ClientSocket) ;
//当sock关闭时触发
public void OnClose(Object socket);
}
下面是异步客户端socket类：
SocketEx.java
package https://www.wendangku.net/doc/1617577849.html,;
import java.io.*;
import https://www.wendangku.net/doc/1617577849.html,.*;
import java.util.*;
import https://www.wendangku.net/doc/1617577849.html,.SocketExHandler;
/**
* Title:
* Description:
* Copyright: Copyright (c) 2001
* Company: https://www.wendangku.net/doc/1617577849.html,
* @author dozb
* @version 1.0
*/
public class SocketEx implements Runnable
{
public static final boolean isdebug = true;//调试
/**
*构造函数.
*/
public SocketEx(SocketExHandler seh,Socket ClientSocket){this. seh = seh;thisSocket = ClientSocket; InitNotify();}
public SocketEx(SocketExHandler seh,String host,int port) thr ows IOException {this.seh = seh;thisSocket = new Socket(host,port);In itNotify();}
public SocketEx(SocketExHandler seh, InetAddress address, int port ) throws IOException {this.seh = seh;thisSocket = new Socket(ad dress, port);InitNotify();}
public SocketEx(SocketExHandler seh, String host, int port, I netAddress localAddr, int localPort ) throws IOException {this.seh = seh;thisSocket = new Socket(host,port,localAddr,localPort );InitNotif y();}
public SocketEx(SocketExHandler seh, InetAddress address, int port, InetAddress localAddr, int localPort ) throws IOException {thi s.seh = seh;thisSocket = new Socket(address, port, localAddr,localPor t );InitNotify();}
/**
* 实现Socket的可见方法.
*/
public synchronized void close() throws IOException {IsRunni ng = false;thisSocket.close();}
public InetAddress getInetAddress() {return thisSocket.getIne tAddress();}
public InputStream getInputStream() throws IOException{
return thisSocket.getInputStream(); }
public InetAddress getLocalAddress() { r eturn thisSocket.getLo calAddress() ; }
public int getLocalPort() { return thisSocket.getLocalPort() ; }
public OutputStream getOutputStream() throws IOException{retu rn thisSocket.getOutputStream(); }
public int getPort() { return thisSocket.getPort() ; }
public int getSoLinger() throws SocketException{ return t hisSocket.getSoLinger(); }
public synchronized int getSoTimeout() throws SocketException { return thisSocket.getSoTimeout(); }
public boolean getTcpNoDelay() throws SocketException {
return thisSocket.getTcpNoDelay(); }
public void setSoLinger( boolean on, int val ) throws SocketE xception { thisSocket.setSoLinger(on,val); }
public synchronized void setSoTimeout( int timeout ) throws S ocketException {thisSocket.setSoTimeout( timeout ) ; }
public void setTcpNoDelay( boolean on ) throws SocketExceptio n {thisSocket.setTcpNoDelay(on); }
public String toString() { return thisSocket.toString() ; }
/**
* 获取Socket
*/
public Socket GetSocket(){return thisSocket;}
/**
* 初始化异步Socket
*/
private void ShowMsg(String Msg)
{
if(isdebug)
System.out.println(Msg);
}
private void InitNotify()
{
if(NotifyThread != null) return ;
try{
biStream = new BufferedInputStream(getInputStr eam());
thisSocket.setSoTimeout(0);
}catch(IOException e){
ShowMsg("InitNotify() IOException.");
}
IsRunning = true;
NotifyThread = new Thread(this,"SocketEx_NoitfyThread ");
NotifyThread.setDaemon(true);
NotifyThread.start();
if(seh !=null)
seh.OnConnect(this);
}
/**
* 关闭Socket
*/
private void Close()
{
try{
close();
}catch(Exception eclose){
ShowMsg("Close() Exception.");
}
}
protected void finalize() throws Throwable
{
Close();
super.finalize();
}
/**
* Thread 运行
*/
public void run()
{
while(IsRunning){
try{
if(getInputStream().read(buf,0,1) <= 0) //试读一个字节
{
DoClose();
return ;
}
if(!DoReceive(getInputStream().availab le()))
return ;
}catch(Exception e){
ShowMsg("run() Exception.");
DoClose();
return ;
}
try{
Thread.sleep(0); //
}catch(InterruptedException e){
ShowMsg("run() InterruptedException. ");
DoClose();
return ;
}
}
}
/**
* 当有数据到达时的回调方法.
*/
private boolean DoReceive(int nCanReadCount)
{
try{
int len = 0,nCurrReadCount=0,nStart=1;
do{
for(int i=nStart;i< BUFLEN;i++)
buf[i]=0;
if(nCanReadCount == 0)
{
if(seh !=null)
seh.OnReceive(this,buf, nStart);
return true;
}
if(nCanReadCount >(BUFLEN-2))
{
nCurrReadCount = BUFLEN-2;
}
else
{
nCurrReadCount = nCanReadCount;
}
len = biStream.read(buf,nStart,nCurrRe adCount);
if(len == 0)
{
DoClose();
return false;
}
nCanReadCount -= len;
buf[len+nStart] = 0;
if(seh !=null)
seh.OnReceive(this,buf,len+nStart);
nStart = 0;
}while(nCanReadCount >0);
}catch(Exception excpt){
ShowMsg("DoReceive() Exception.");
DoClose();
return false;
}
return true;
}
/**
* 当Socket建立连接时的回调方法.
*/
private void DoConnect()
{
if(seh !=null)
seh.OnConnect(this);
}
/**
* 当Socket关闭时的回调方法.
*/
private void DoClose()
{
try{
if(IsRunning)
{
Close();
if(seh !=null)
seh.OnClose(this);
IsRunning = false;
}
}catch(Exception e){
ShowMsg("DoClose() Exception.");
}
}
/**
* 以下实现不要改动!!!!
*/
private Thread NotifyThread=null;
private boolean IsRunning = false;
private Socket thisSocket = null;
private static final int BUFLEN = 4097;
private byte buf[] = new byte[BUFLEN];
private BufferedInputStream biStream = null;
private SocketExHandler seh=null;
}
下面是异步socketserver类：
ServerSocketEx .java
package https://www.wendangku.net/doc/1617577849.html,;
import java.io.*;
import https://www.wendangku.net/doc/1617577849.html,.*;
import java.util.*;
/**
* Title:
* Description:
* Copyright: Copyright (c) 2001
* Company: https://www.wendangku.net/doc/1617577849.html,
* @author dozb
* @version 1.0
*/
public class ServerSocketEx extends ServerSocket implements Runnable {
/**
* 以下实现不要改动!!!!
*/
public ServerSocketEx(SocketExHandler seh, int port ) throws IOException {super(port);this.seh = seh; Listen();}
public ServerSocketEx(SocketExHandler seh, int port, int back log ) throws IOException {super(port,backlog);this.seh = seh; L isten ();}
public ServerSocketEx(SocketExHandler seh, int port, int back log, InetAddress bindAddr ) throws IOException {super(port,backlog, b indAddr);this.seh = seh;Listen();}
public void setTimeout(int timeout) {
this.timeout = timeout;
}
public static Vector GetClientPool(){return ClientPool;};
public static void CloseAllClients(){
for(int i=0;i< ClientPool.size();i++)
{
try{
SocketEx s=(SocketEx)ClientPool.elemen tAt(i);
if(s != null) s.close();
}catch(Exception e){}
}
ClientPool.removeAllElements();
}
public static void PutClient(SocketEx s){ClientPool.addElemen t(s);};
/**
* 关闭Socket
*/
public void Close()
{
IsRunning = false;
try{
close();
}catch(Exception eclose){
}
}
protected void finalize() throws Throwable
{
Close();
super.finalize();
}
* Thread 运行
*/
public void run()
{
while(IsRunning){
acceptConnections();
}
DoClose();
}
// -------------------- Private methods
private void Listen() throws IOException
{
InitNotify();
if(seh !=null)
seh.OnListen(this);
}
/**
* 初始化异步Socket
*/
private void InitNotify()throws IOException
{
if(NotifyThread != null) return ;
try{
setSoTimeout(this.timeout);
} catch( IOException ex ) {
IsRunning=false;
throw ex;
}
IsRunning = true;
NotifyThread = new Thread(this,"ServerSocketEx_Noitfy Thread");
NotifyThread.setDaemon(true);
NotifyThread.start();
}
/**
* 当Socket关闭时的回调方法.
private void DoClose()
{
try{
if(seh !=null)
seh.OnClose(this);
//NotifyThread.stop();
}catch(Exception e){
}
}
private void processSocket(Socket s) throws IOException
{
SocketEx se = new SocketEx(seh,s);
PutClient(se);
if(seh !=null)
seh.OnAccept(this,se);
}
private void acceptConnections() {
try {
if(IsRunning == false)
return;
Socket socket = acceptSocket();
if(IsRunning != false && socket != null) {
processSocket(socket);
}
} catch(Throwable e) {
IsRunning = false;
}
}
private Socket acceptSocket() {
Socket accepted = null;
try {
if(IsRunning == true) {
accepted = accept();
if(IsRunning == false) {
if(null != accepted) {
accepted.close(); // rude, but un likely!
accepted = null;
}
}
}
} catch(InterruptedIOException iioe) {
// normal part -- should happen regularly so
// that the endpoint can release if the server
// is shutdown.
// you know, i really wish that there was a
// way for the socket to timeout without
// tripping an exception. Exceptions are so
// 'spensive.
} catch (SocketException e) {
if (IsRunning != false) {
IsRunning = false;
}
} catch(Throwable e) {
IsRunning = false;
}
return accepted;
}
private static final int TIMEOUT = 5000;
private int timeout = TIMEOUT;
private Thread NotifyThread=null;
private boolean IsRunning=false;
private SocketExHandler seh=null;
private static Vector ClientPool=new Vector();
}
下面是几个工具类：
TimerClient.java
package com.ly.util;
/**
* TimerClient Interface
*
* @version 1.0, 8 October 1995
*
*/
public interface TimerClient
{
void timerEvent(int id);
}
TimerCtl.java
package com.ly.util;
import java.util.Vector;
import java.util.Enumeration;
//import com.borland.jb.util.Diagnostic;
/**
* Timer Component
*
* Note:
* - The successful operation of this timer requires clients to exec ute simple, short
* code snippets when called back by the engine. Otherwise the qu eue's delivery
* mechanism will be held up
*
* Further work:
* - When Thread.Interrupt is implemented we can switch from the bus y wait model to
* the calculated wait model. Without the interrupt the thread wa its for the
* calculated interval before waking up. This is a problem if ano ther shorter
* request arrives. For now we'll assume the minimum resolution o f the timer is
* 100ms.
*
* @version 1.0, 2 October 1995
*
*/
public class TimerCtl
{
static TimerTasks timerTasks;
public TimerCtl() {
}
/*
* Start a timer running
*/
public static void startTimer(TimerClient client, int eventId, long delay, boolean repeat) {
// create the timer if necessary
if (timerTasks == null) {
timerTasks = new TimerTasks();
timerTasks.start();
}
//Diagnostic.out.println("TIMER: startTimer"+eventId);
// add the new task to the queue
timerTasks.add(client, eventId, delay, repeat);
}
/*
* Stop a timer
*/
public static void stopTimer(TimerClient client, int eventId) {
//Diagnostic.out.println("TIMER: stopTimer"+eventId);
if(timerTasks != null)
timerTasks.end(client, eventId);
}
}
class TimerTasks extends Thread
{
Vector tasks = new Vector();
boolean suspended = false;
boolean sleeping = false;
/**
* Thread task runner
*/
public void run() {
// Loop forever
while (true) {
long sleepTime = 0;
// Ensure that the tasks class is protected
synchronized (tasks) {
//Diagnostic.out.println("TIMER: Tick");
// Scan the job list for any jobs which may fire.
// Mark one-shot jobs for deletion
// Calculate the maximum time we can sleep for
sleepTime = scan();
// Delete DeletePending jobs. DeletePending jobs result from one-shots which have
// been sent, and repeat jobs which have been cancelled. Job s may have been
// cancelled during the Scan process.
purge();
}
// Suspend timer if necessary
if (tasks.size() == 0) {
//Diagnostic.out.println("TIMER: Suspend");
try {
synchronized(this) {
suspended = true;
wait();
}
}
catch (InterruptedException e) {
}
}
else {
//Diagnostic.out.println("TIMER: Suggested Sleeping for "+sle epTime);
if (sleepTime >= 0) {
try {
sleeping = true;
sleep(sleepTime);
sleeping = false;
}
catch (InterruptedException i) {
//Diagnostic.out.println("TIMER: Caught me napping");
}
}
}
}
}
/**
* Add a new task
*/
public void add(TimerClient client, int eventId, long delay, boolea n repeat) {
TimerTask t = new TimerTask(client, eventId, delay, repeat);
synchronized (tasks) {
tasks.addElement((Object)t);
}
// Want instant response - wake the thread if it's napping
// unfortunately the interrupt() method is not working
// if (sleeping)
// interrupt();
if (suspended) {
synchronized(this) {
notify();
//Diagnostic.out.println("TIMER: Resume");
suspended = false;
}
}
}
/**
* Find the job and mark it for deletion
*/
public void end(TimerClient client, int eventId) {
synchronized (tasks) {
for (int i = 0; i < tasks.size(); i++) {
TimerTask t = (TimerTask)tasks.elementAt(i);
//if (!t.deletePending && t.client == client && t.eventId == eventId)
if (t.deletePending == false && t.client == client && t.event Id == eventId) {
// JPBS - if we don't reset 'repeat', deletePending will be set again
t.repeat = false;
t.deletePending = true;
break;
}
}
}
}
/**
* Clear out all the dead wood
void purge() {
for (int i = 0; i < tasks.size(); i++) {
TimerTask t = (TimerTask)tasks.elementAt(i);
if (t.deletePending) {
//Diagnostic.out.println("TIMER: purged");
tasks.removeElementAt(i);
i--;
}
}
}
long scan() {
// The value added to the current time determines the MAX time un til
// the next scan
// This is 100 now since thread.interrupt() is not implemented
long nextTime = System.currentTimeMillis() + 100;
for (int i = 0; i < tasks.size(); i++) {
TimerTask t = (TimerTask)tasks.elementAt(i);
// if not already deletePending, test (and possibly send the ev ent)
// as a result, the job may be flagged for deletion.
// May also be a non-repeating job and so require self deletion if (!t.deletePending)
t.test();
// if the task didn't get deleted - see what it contributes to the time
if (!t.deletePending)
nextTime = Math.min(nextTime, t.timeNext);
//Diagnostic.out.println("TIMER: Scanning "+t.eventId+" "+(t.de letePending == true ? "DEL" : ""));
return nextTime - System.currentTimeMillis();
}
}
class TimerTask
{
TimerClient client;
int eventId;
long timePrev;
long timeDelay;
long timeNext;
boolean repeat;
boolean deletePending;
public TimerTask(TimerClient client, int eventId, long timeDelay, b oolean repeat) {
this.client = client;
this.eventId = eventId;
this.timeDelay = timeDelay;
this.repeat = repeat;
// schedule the next click - now + delay
timeNext = System.currentTimeMillis() + timeDelay;
deletePending = false;
//Diagnostic.out.println("TIMER: Adding New Task");
}
public void test() {
if (System.currentTimeMillis() >= timeNext) {
//Diagnostic.out.println("TIMER: fire");
// Fire the event
client.timerEvent(eventId);
socket编程实现客户端和服务器端通信
#include "" #include <> #include
电路实验报告1--叠加原理
电路实验报告1-叠加原理的验证 所属栏目：电路实验- 实验报告示例发布时间：2010-3-11 实验三叠加原理的验证 一、实验目的 验证线性电路叠加原理的正确性，加深对线性电路的叠加性和齐次性的认识和理解。 二、原理说明 叠加原理指出：在有多个独立源共同作用下的线性电路中，通过每一个元件的电流或其两端的电压，可以看成是由每一个独立源单独作用时在该元件上所产生的电流或电压的代数和。 线性电路的齐次性是指当激励信号（某独立源的值）增加或减小K 倍时，电路的响应（即在电路中各电阻元件上所建立的电流和电压值）也将增加或减小K倍。 三、实验设备 高性能电工技术实验装置DGJ-01：直流稳压电压、直流数字电压表、直流数字电流表、叠加原理实验电路板DGJ-03。 四、实验步骤 1．用实验装置上的DGJ-03线路, 按照实验指导书上的图3-1，将两路稳压电源的输出分别调节为12V和6V，接入图中的U1和U2处。 2．通过调节开关K1和K2，分别将电源同时作用和单独作用在电路中，完成如下表格。 表3-1
3．将U2的数值调到12V，重复以上测量，并记录在表3-1的最后一行中。 4．将R3(330 )换成二极管IN4007，继续测量并填入表3-2中。 表3-2 五、实验数据处理和分析 对图3-1的线性电路进行理论分析，利用回路电流法或节点电压法列出电路方程，借助计算机进行方程求解，或直接用EWB软件对电路分析计算，得出的电压、电流的数据与测量值基本相符。验证了测量数据的准确性。电压表和电流表的测量有一定的误差，都在可允许的误差范围内。 验证叠加定理：以I1为例，U1单独作用时，I1a=8.693mA,，U2单独作用时，I1b=-1.198mA，I1a+I1b=7.495mA，U1和U2共同作用时，测量值为7.556mA，因此叠加性得以验证。2U2单独作用时，测量值为-2.395mA，而2*I1b=-2.396mA，因此齐次性得以验证。其他的支路电流和电压也可类似验证叠加定理的准确性。 对于含有二极管的非线性电路，表2中的数据不符合叠加性和齐次性。 六、思考题 1．电源单独作用时，将另外一出开关投向短路侧，不能直接将电压源短接置零。 2．电阻改为二极管后，叠加原理不成立。
《Java范例开发大全》
下面是377个Java的例子。如果你是牛人，看看你能做出多少？ 如果有人不相信这些例子都是Java做的，可以看看清华大学的《Java范例开发大全》实例1开发第一个Java程序 实例2自动提升 实例3自动转换 实例4常用基础类型之强制转换 实例5算术运算符 实例6关系运算符 实例7逻辑运算符 实例8位运算符 实例9移位运算符 实例10转型运算符 实例11常量与变量 实例12各种进制的转换 实例13 Java中的进制与移位运算符 实例14判断输入的年份是否为闰年 实例15抽奖活动 实例16xx乘法表 实例17如何列出素数 实例18 Java中的递归 实例19男生女生各多少人
实例20求xx数 实例21求任意一个正数的阶乘 实例22求n的n次方 实例23利用for循环输出几何图形 实例24xx 实例25求1到100之间的和 实例26存上100元需要多少天 实例27输出100之间的所有偶数 实例28如何判断回文数字 实例29输出100之间的所有奇数 实例30求最大的随机数 实例31判断字母分类 实例32优良及差 实例33打印任意一年日历 实例34一年四季的划分 实例35除0发生的算术异常（ArithmeticException） 实例36数组下标越界异常（ArrayIndexOutOfBoundsException）实例37数组元素类型不匹配异常（ArrayStoreException） 实例38强制类型转换异常（ClassCastException） 实例39索引越界异常（IndexOutOfBoundsException） 实例40空指针异常（NullPointerException）
实现socket通信
基于visual c++之windows核心编程代码分析（10）实现socket通信 分类：VC++编程技术Visual C++2010编程技术Visual Studio2012 Windows8 2011-12-17 11:32 120人阅读评论(0) 收藏举报在多台计算机之间实现通信，最常见的方法有两种：Socket通信与UDP通信。 Socket是一种基于TCP/IP协议，建立稳定连接的点对点通信，它的特点是安全性高，数据 不会丢失，但是很占系统资源。 在JAVA中，ServerSocket类和Socket类为我们实现了Socket 通信，建立通信的一般步骤是： 1。建立服务器 ServerSocket ss = new ServerSocket(端口号); Socket socket = ss.accept(); 这样，我们就已经建立了服务器，其中accept()方法会阻塞，知道有客户发送一个连接请求，我们可以通过 socket.getInputStream()和socket.getOutputStream()来获得输入输出流，如调用socket.getInputStream()获得一个输入流，实际上这个流就是连接对方的一个输出流，流的操作与文件流操作相同，我们可以用操作文件的方法来操作它们。 2。建立客户端 Socket socket = new Socket(主机名，端口号) 客户端只需这一句代码就可以与服务器取得连接，这里的主机名应为服务器的IP地址，端口号是服务器用来监听该程序的端口，同样可以通过socket.getInputStream()和 socket.getOutputStream()来获得输入输出流。在以上程序中，已经实现了一个最简单的客户端和服务器的通信。但是，还有一些问题。 首先，这个通信只执行一次，程序就将结束。因为我们只读了一次输入流，如果想要建立客户与服务器之间的稳定的会话，就要用到多线程： Thread thread = new Thread(new Sender()); thread.start();
如何用记事本编写一个简单的java代码
如何用记事本编写一个简单的j a v a代码 Document serial number【UU89WT-UU98YT-UU8CB-UUUT-UUT108】
一：怎么用记事本写第一个java代码 第一步：新建txt文档 首先我们在F盘新建一个txt文档，并命名为,如下图所示： 第二步：编写代码 我们双击打开：如下图所示 第三步：编写好代码 我们在记事本中写代码，写好后如下所示：
然后我们同时按Ctrl+s键保存，然后关闭记事本即可 上面的源代码如下： public class Test{//这里的Test为类名，这里类名要与我们刚才新建的记事本的名字必须一致，首字母大写 public static void main(String[] args){//java中的主函数的写法 "HelloWorld");//java中的输出语句写法 } } 第三步：打开控制台界面 我们在计算机中，打开如下图界面，
然后在这里，输入cmd,并按回车，然后弹出如图所示
第四步：在控制台中运行并输出 我们用鼠标点击一下里面黑色部分，然后输入F:然后回车，然后再输入javac 然后回车，最后输入java Test，就可以看到结果了，如下图所示：
红色圈出来部分就是结果了 二：温馨提示： 1，上面演算中在控制台中首先输入F：的原因是因为我在F盘建立一个文本文档，并命名为，如果你是把你的文档文档建立在D盘，则应该输入D: 以此类推。 2，如果你是在F盘下的CH文件夹建立一个记事本，并命名为，则输入的情况如下， cd CH表示转到CH这个文件夹下，然后再输入回车，再输入java Test 就可以看到运行结果了
基于Socket技术的企业局域网通信软件设计与实现毕业设计
基于Socket技术的企业局域网通信软件设计与实现毕业设计 目录 1 绪论 (3) 1.1 研究背景 (3) 1.2 国外研究现状 (4) 1.2.1 国外研究现状 (4) 1.2.2 国研究现状 (4) 1.3 课题研究容及组织结构 (5) 1.3.1 研究容 (5) 1.3.2 组织结构 (5) 1.4 本章小结 (5) 2 系统核心技术 (6) 2.1 网络传输协议及Socket技术 (6) 2.1.1 网络传输协议 (6) 2.1.2 TCP协议 (6) 2.1.3 UDP协议 (7) 2.1.4 Socket (8) 2.1.5 点对点技术 (9) 2.2 加密算法 (10) 2.2.1 DES算法 (10) 2.2.2 MD5算法 (12) 2.3 多媒体技术 (13) 2.3.1 https://www.wendangku.net/doc/1617577849.html, (13) 2.3.2 Microsoft.DirectX SDK (13) 2.3.3 音频压缩算法 (14) 2.4 .Net技术 (14) 2.4.1 多线程 (14) 2.4.2 动态库 (15) 2.4.3 媒体控制接口 (15)
2.4.4 图形设备接口 (15) 2.4.5 正则表达式 (16) 2.5 三层架构技术 (16) 2.6 本章小结 (17) 3 系统需求分析 (18) 3.1 系统概述 (18) 3.2 系统业务分析 (18) 3.3 客户端需求 (20) 3.3.1 客户端主面板 (20) 3.3.2 用户私聊 (20) 3.3.3 群组聊天 (21) 3.3.4 视频会议 (21) 3.4 服务器需求 (21) 3.4.1 服务器主界面 (22) 3.4.2 员工信息管理 (22) 3.4.3 历史聊天记录管理 (22) 3.4.4 群共享管理 (22) 3.4.5 聊天记录数据图查看 (22) 3.5 非功能需求 (22) 3.5.1 可靠性 (23) 3.5.2 友好性 (23) 3.6 本章小结 (23) 4 系统设计 (24) 4.1 系统整体架构 (24) 4.2 客户端 (25) 4.2.1 聊天模块 (25) 4.2.2 群组聊天模块 (27) 4.2.3 视频会议模块 (28) 4.3 服务器端 (28) 4.3.1 数据快速查看模块 (28)
如何写一个正确的JAVA程序
若在定义中出现了常数初始化字符，则大写基本类型标识符中地所有字母.这样便可标志出它们属于编译期地常数.个人收集整理勿做商业用途 包()属于一种特殊情况：它们全都是小写字母，即便中间地单词亦是如此.对于域名扩展名称，如，，或者等，全部都应小写(这也是和地区别之一).个人收集整理勿做商业用途() 为了常规用途而创建一个类时，请采取“经典形式”，并包含对下述元素地定义：() () () ()( ) () 对于自己创建地每一个类，都考虑置入一个()，其中包含了用于测试那个类地代码.为使用一个项目中地类，我们没必要删除测试代码.若进行了任何形式地改动，可方便地返回测试.这些代码也可作为如何使用类地一个示例使用.个人收集整理勿做商业用途() 应将方法设计成简要地、功能性单元，用它描述和实现一个不连续地类接口部分.理想情况下，方法应简明扼要.若长度很大，可考虑通过某种方式将其分割成较短地几个方法.这样做也便于类内代码地重复使用(有些时候，方法必须非常大，但它们仍应只做同样地一件事情). () 设计一个类时，请设身处地为客户程序员考虑一下(类地使用方法应该是非常明确地).然后，再设身处地为管理代码地人考虑一下(预计有可能进行哪些形式地修改，想想用什么方法可把它们变得更简单).个人收集整理勿做商业用途 () 使类尽可能短小精悍，而且只解决一个特定地问题.下面是对类设计地一些建议：■一个复杂地开关语句：考虑采用“多形”机制 ■数量众多地方法涉及到类型差别极大地操作：考虑用几个类来分别实现 ■许多成员变量在特征上有很大地差别：考虑使用几个类. () 让一切东西都尽可能地“私有”——.可使库地某一部分“公共化”(一个方法、类或者一个字段等等)，就永远不能把它拿出.若强行拿出，就可能破坏其他人现有地代码，使他们不得不重新编写和设计.若只公布自己必须公布地，就可放心大胆地改变其他任何东西.在多线程环境中，隐私是特别重要地一个因素——只有字段才能在非同步使用地情况下受到保护.个人收集整理勿做商业用途 () 谨惕“巨大对象综合症”.对一些习惯于顺序编程思维、且初涉领域地新手，往往喜欢先写一个顺序执行地程序，再把它嵌入一个或两个巨大地对象里.根据编程原理，对象表达地应该是应用程序地概念，而非应用程序本身.个人收集整理勿做商业用途() 若不得已进行一些不太雅观地编程，至少应该把那些代码置于一个类地内部. () 任何时候只要发现类与类之间结合得非常紧密，就需要考虑是否采用内部类，从而改善编码及维护工作(参见第章小节地“用内部类改进代码”).个人收集整理勿做商业用途() 尽可能细致地加上注释，并用注释文档语法生成自己地程序文档. () 避免使用“魔术数字”，这些数字很难与代码很好地配合.如以后需要修改它，无疑会成为一场噩梦，因为根本不知道“”到底是指“数组大小”还是“其他全然不同地东西”.所以，我们应创建一个常数，并为其使用具有说服力地描述性名称，并在整个程序中都采用常数标识符.这样可使程序更易理解以及更易维护.个人收集整理勿做商业用途 () 涉及构建器和异常地时候，通常希望重新丢弃在构建器中捕获地任何异常——如果它造成了那个对象地创建失败.这样一来，调用者就不会以为那个对象已正确地创建，从而盲目地继续.个人收集整理勿做商业用途
利用Socket实现双机通信(DOC)
计算机科学与技术学院 课程设计报告 2015— 2016学年第一学期 课程名称计算机网络 设计题目利用Socket实现双机通信姓名 学号 专业班级 指导教师 2016 年1 月8 日
目录 一、目的与要求 ................................................................................. - 3 - 二、什么是Winsock与Socket .......................................................... - 3 - 三、TCP/IP 简介................................................................................. - 4 - 1、TCP/IP 简介 ............................................................................... - 4 - 2、作用............................................................................................ - 4 - 四、java Socket网络编程 .................................................................. - 5 - 五、设计方案 ..................................................................................... - 5 - 1. 服务器端： ................................................................................. - 6 - 2. 客户端: ........................................................................................ - 9 - 六、运行结果： ............................................................................... - 14 - 七、课程设计的总结体会................................................................ - 15 - 八、参考资料： ............................................................................... - 15 - 简单的即时通信软件
看完这30个技巧让你写好Java代码
看完这30个技巧让你写好Java代码 2019.8整理 成为一个优秀的Java程序员，有着良好的代码编写习惯是必不可少的。下面就让我们来看看代码编写的30条建议吧。 (1) 类名首字母应该大写。字段、方法以及对象（句柄）的首字母应小写。对于所有标识符，其中包含的所有单词都应紧靠在一起，而且大写中间单词的首字母。例如： 若在定义中出现了常数初始化字符，则大写static final基本类型标识符中的所有字母。这样便可标志出它们属于编译期的常数。 Java包（Package）属于一种特殊情况：它们全都是小写字母，即便中间的单词亦是如此。对于域名扩展名称，如com，org，net或者edu等，全部都应小写（这也是Java 1.1和Java 1.2的区别之一）。 (2) 为了常规用途而创建一个类时，请采取”经典形式”，并包含对下述元素的定义：
(3) 对于自己创建的每一个类，都考虑置入一个main()，其中包含了用于测试那个类的代码。为使用一个项目中的类，我们没必要删除测试代码。若进行了任何形式的改动，可方便地返回测试。这些代码也可作为如何使用类的一个示例使用。 (4) 应将方法设计成简要的、功能性单元，用它描述和实现一个不连续的类接口部分。理想情况下，方法应简明扼要。若长度很大，可考虑通过某种方式将其分割成较短的几个方法。这样做也便于类内代码的重复使用（有些时候，方法必须非常大，但它们仍应只做同样的一件事情）。 (5) 设计一个类时，请设身处地为客户程序员考虑一下（类的使用方法应该是非常明确的）。然后，再设身处地为管理代码的人考虑一下（预计有可能进行哪些形式的修改，想想用什么方法可把它们变得更简单）。 (6) 使类尽可能短小精悍，而且只解决一个特定的问题。下面是对类设计的一些建议： ?一个复杂的开关语句：考虑采用”多形”机制 ?数量众多的方法涉及到类型差别极大的操作：考虑用几个类来分别实现 ?许多成员变量在特征上有很大的差别：考虑使用几个类 (7) 让一切东西都尽可能地”私有”–private。可使库的某一部分”公共化”（一个方法、类或者一个字段等等），就永远不能把它拿出。若强行拿出，就可能破坏其他人现有的代码，使他们不得不重新编写和设计。若只公布自己必须公布的，就可放心大胆地改变其他任何东西。在多线程环境中，隐私是特别重要的一个因素–只有private字段才能在非同步使用的情况下受到保护。 (8) 谨惕”巨大对象综合症”。对一些习惯于顺序编程思维、且初涉OOP领域的新手，往往喜欢先写一个顺序执行的程序，再把它嵌入一个或两个巨大的对象里。根据编程原理，对象表达的应该是应用程序的概念，而非应用程序本身。 (9) 若不得已进行一些不太雅观的编程，至少应该把那些代码置于一个类的内部。 (10) 任何时候只要发现类与类之间结合得非常紧密，就需要考虑是否采用内部类，从而改善编码及维护工作（参见第14章14.1.2小节的”用内部类改进代码”）。 (11) 尽可能细致地加上注释，并用javadoc注释文档语法生成自己的程序文档。
叠加方式的组合体图形的绘制
一、叠加方式的组合体图形的绘制 以下图支架为例说明以叠加为主要形成方式的组合体的画图步骤。 1．形体分析 ⑴分析所画组合体是由哪些基本几何体组成的？ ⑵分析各基本几何体的相对位置和相邻表面的关系，如是否平齐？相 交？相切？ 2．视图选择 （1）首先将组合体摆平放正，尽量使组合体的对称面、主要轴线或大的端面与投影面平行或垂直。 （2）选择主视图，将最能反映所画组合体形体特征的投影方向作为主视图的投影方向。（3）兼顾其它视图，尽量使俯、左视图中的虚线最少。 3．布置图面 （1）根据所画组合体的实际尺寸，选取适当的比例和图幅大小。 （2）画作图基线，以确定组合体三视图的位置。一般用作图基线表示组合体的主要端面、对称面或中心线、主要轴线等的投影位置。 （3）三视图之间应距离恰当，留有足够的标注尺寸的空间。整张图面力求匀称、协调。4．画底稿（用H或2H型铅笔画底稿） （1）根据形体分析，先画主要形体（大形体），后画次要形体（小形体）。 （2）各形体均应先画其基本轮廓，后完成局部细节。 （3）每一局部均应先画反映其形体特征的那个投影，后完成其它两投影。 （4）三个视图一起画。 5．检查、清理和加深图面（用B或2B型铅笔加深粗实线，用HB 或H型铅笔加深细实线、细点画线、标注尺寸、写字等） （1）检查底稿，认真校核。查看各视图是否符合投影规律？表面相交、相切关系是否表达正确等？ （2）清理图面，擦去不需要的作图线，拾遗补缺。 （3）加深图线。其加深步骤为：先曲后直、先上后下、先左后右、最后加深斜线。同类线型应一起加 6.最后完成的支架三视图见下图 （1）支架分析：
（2）布置图面： （3）画底稿
利用Socket实现双机通信(计算机网络课程设计)
目录 1、目录 (1) 2、题目 (2) 3、设计任务 (2) 4、WinSocket简介及特点原理 (2) 5、T C P简介及特点原理 (3) 6、Vis ual C++简介 (7) 7、设计方案 (8) 8、系统的原理框图和程序流程图 (10) 9、实验中的问题 (14) 10、实验结果及分析 (14) 11、课程设计的总结体会 (16) 12、参考文献 (16)
利用Socket实现双机通信 一、设计任务 1.利用WinSock来实现双机通信，理解TCP状态机图。 2.要求使用WinSock编程，采用其中的TCP面向连接方式，实现文本数据的交换。 二、WinSocket简介及特点原理 2.1、什么是socket 所谓socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。 Socket接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，程序员可以用它们来开发TCP/IP网络上的应用程序。要学Internet上的TCP/IP网络编程，必须理解Socket接口。Socket接口设计者最先是将接口放在Unix操作系统里面的。如果了解Unix系统的输入和输出的话，就很容易了解Socket了。网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。Socket 也具有一个类似于打开文件的函数调用Socket()，该函数返回一个整型的Socket 描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。 常用的Socket类型有两种：流式Socket（SOCK_STREAM）和数据报式Socket
Socket通信原理
Socket通信原理 对TCP/IP、UDP、Socket编程这些词你不会很陌生吧？随着网络技术的发展，这些词充斥着我们的耳朵。那么我想问： 1. 什么是TCP/IP、UDP？ 2. Socket在哪里呢？ 3. Socket是什么呢？ 4. 你会使用它们吗？ 什么是TCP/IP、UDP？ TCP/IP（Transmission Control Protocol/Internet Protocol）即传输控制协议/网间协议，是一个工业标准的协议集，它是为广域网（WANs）设计的。 UDP（User Data Protocol，用户数据报协议）是与TCP相对应的协议。它是属于TCP/IP协议族中的一种。 这里有一张图，表明了这些协议的关系。 图1 TCP/IP协议族包括运输层、网络层、链路层。现在你知道TCP/IP与UDP的关系了吧。
Socket在哪里呢？ 在图1中，我们没有看到Socket的影子，那么它到底在哪里呢？还是用图来说话，一目了然。 图2 原来Socket在这里。 Socket是什么呢？ Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。你会使用它们吗？ 前人已经给我们做了好多的事了，网络间的通信也就简单了许多，但毕竟还是有挺多工作要做的。以前听到Socket编程，觉得它是比较高深的编程知识，但是只要弄清Socket 编程的工作原理，神秘的面纱也就揭开了。 一个生活中的场景。你要打电话给一个朋友，先拨号，朋友听到电话铃声后提起电话，这时你和你的朋友就建立起了连接，就可以讲话了。等交流结束，挂断电话结束此次交谈。生活中的场景就解释了这工作原理，也许TCP/IP协议族就是诞生于生活中，这也不一定。
《Java程序设计》题目样例
【题目样例】 一、单选题 1．下面哪个特性不是Java具有的（D ）。 A、“纯”面向对象 B、安全性高 C、可移植性好 D、运行速度快 2．下面哪个类型是Java中不支持的（C ）。 A、布尔类型 B、字符串 C、指针 D、数组 3．下面哪个不属于Java语言的关键字（B ）。 A、native B、const C、final D、finally 4．下面关于数组的使用，不正确的是（C ）。 A、int a[] = {1, 2, 3}; B、int a[][] = {{ 1, 2 }, { 3, 4} }; C、int a = new int[6] for (int i=0; i<6; i++) a[i] = i * i; D、int a[][] =new int[2][ ]; int a[1] = new int [4]; int a[2] = new int[5]; 5．应用程序的main方法中有以下语句，则输出的结果是（A ）。 String obj = new String("abcxyz"); for(int i = obj.length() - 1; I > 0; i--) System.out.print(obj.charAt(i)); A、zyxcba B、xyz C、zyxcb D、abcxyz 6．下面函数，哪一组不属于方法重载（A ）。 A、int fun(int a, int b, float c) { … } float fun(int b, int a, float c) { … } B、int fun(int a, int b) { … } int fun(int a, int a, float c) { … } C、int fun(int a) { … } int fun(int a, int b) { … } D、int fun(int a, float b) { … } int fun(float b, int a) { … } 7．若创建RandomAccessFile类对象raf2： RandomAccessFile raf2 = new RandomAccessFile("1.txt", "rw")，该语句的功能是（B ）。 A、打开当前目录下的文件1.txt，但只能向文件写入数据，不能从文件读取数据。 B、打开当前目录下的文件1.txt，既可以向文件写入数据，也可以从文件读取数据。 C、打开当前目录下的文件1.txt，但不能向文件写入数据，只能从文件读取数据。 D、以上说法都不对。 8．应用程序main方法中有以下语句，则输出的结果是（A ）。 String s = "java@123456@"; int n = s.indexOf("@"); int k = s.indexOf("@", 5); String s2 = s.substring(n + 1, k);
Photoshop实例简单步骤
Lesson1 ●选择：选区可为圆，方，一行，一列，选择模式可以+、-、交叉，选区 可以移动，在单一选区情况下，鼠标放在选区中就可以移动（可以看到鼠标变形）。 ●填充：油漆桶和渐变工具，对选区上前景色（最好新建一层来做）。 ●层：图象由许多层组成，每层上面可以有不同的元素，这样便于对一幅 图象中的各个元素分别操作。 ●移动：移动一层中图象的位置。 Eg1 球,阴影,倒影. 1、新建一画布(400*400象素), 注意选择”RGB模式”(绘制的图中可以出现彩 色,如果是”灰度模式”则图中只有黑白色),用渐变色填充（上蓝下黑，线 形填充）形成背景 2、新建一个图层，选出一正圆区域（按住shift）,用径向填充（白灰）画一球。 3、选取图层中刚才画出的小球(按住ctrl鼠标点图层),新建一图层后在刚才的 选区中用黑色填充(前景色变黑,用油漆桶填充). 4、在图层中用自由变换功能拖动图案,使其出现倒影效果,在选取的情况下降低 透明度. Eg2 圆环,羽化,亮度调整 1、新建一画布(400*400象素)，注意选择”灰度模式”(绘制的图中只有黑白 色,如果是”RGB模式”则图中可以出现彩色),使用白色背景。 2、新建一图层,选出一正圆形选区用灰色填充 3、在在同一图层上选取一圆,比刚才圆小,放在大圆正中,删去小圆中选种部 分,显示出一环型. 4、选中该环型图层中的圆环,使用选择菜单中的羽化命令,目的是接下来的颜 色过度平滑. 5、向斜上方移动选取,露出部分圆环边缘,后进行反选,对反选区域执行图象 菜单--调整命令里面的亮度和对比度调整,把亮度调暗. 6、选中该环型图层中的圆环,再次使用选择菜单中的羽化命令
用socket实现进程间通信
实验报告 班级011291 班 学生姓名 学号 实验成绩
一、实验题目： 实现最简单实用的通信程序socket. 二、实验目的： 通过对socket的编写，了解socket通信的原理.了解TCP通信的整个过程.以及Linux下C语言的socket函数. 三、实验设备及环境： 1. 硬件设备：PC机一台 2. 软件环境：安装Linux操作系统，并安装相关的程序开发环境，如C \C++\tsh\bsh等编程语言环境。 四、实验内容及要求： 用C语言编程实现linux简单的聊天室功能。 ?用户程序命名为2.c;服务器程序命名为1.c ?要求client可以通过socket连接server ?Client与server可以相互通信，实现交互 五．代码(针对实验1，2，请将最终源代码粘贴至此；正式报告中将下面例子删除) 服务端: #include
#include
JAVA编程实例大全及详解答案(50例)
JA V A编程实例大全及详解答案(50例) 【程序1】 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？ //这是一个菲波拉契数列问题 public class lianxi01 { public static void main(String[] args) { System.out.println("第1个月的兔子对数: 1"); System.out.println("第2个月的兔子对数: 1"); int f1 = 1, f2 = 1, f, M=24; for(int i=3; i<=M; i++) { f = f2; f2 = f1 + f2; f1 = f; System.out.println("第" + i +"个月的兔子对数: "+f2); } } } 【程序2】 题目：判断101-200之间有多少个素数，并输出所有素数。 程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。 public class lianxi02 { public static void main(String[] args) { int count = 0; for(int i=101; i<200; i+=2) { boolean b = false; for(int j=2; j<=Math.sqrt(i); j++) { if(i % j == 0) { b = false; break; } else { b = true; } } if(b == true) {count ++;System.out.println(i );} } System.out.println( "素数个数是: " + count);
基于C++的socket通信实例
刚刚学windows编程，所以想写学习笔记，这是一个简单的Socket 程序例子，开发环境是vc6： 首先是TCP server端： [cpp]view plaincopy 1.#include "stdafx.h" 2.#include
java简单图形用户界面代码
package dsr; import java.awt.*; import java.awt.event.*; import javax.swing.*; import java.io.*; import https://www.wendangku.net/doc/1617577849.html,.Socket; public class Login extends JFrame implements ActionListener{ //定义组件 JPanel northPanel,southPanel,centerPanel,centerPanel1,centerPanel11,centerPanel12; JButton loginBtn,registerBtn,cancalBtn; JLabel userLbl,passwordLbl,titleLbl; JTextField userTxt; JPasswordField passwordPwd; static String name; public Login () { super("用户登录"); northPanel=new JPanel(); southPanel=new JPanel(); centerPanel1=new JPanel(); centerPanel11=new JPanel(); centerPanel12=new JPanel(); //标题 titleLbl=new JLabel("欢迎进入考试系统"); titleLbl.setFont(new Font("隶书",Font.BOLD,24)); northPanel.add(titleLbl); this.add(northPanel,BorderLayout.NORTH); //中间部分 centerPanel1.setLayout(new BorderLayout()); userLbl=new JLabel("用户名"); userTxt=new JTextField(12); centerPanel11.add(userLbl); centerPanel11.add(userTxt); centerPanel1.add(centerPanel11,BorderLayout.NORTH); passwordLbl=new JLabel("密码"); passwordPwd=new JPasswordField(12); centerPanel12.add(passwordLbl); centerPanel12.add(passwordPwd);
Photoshop经典实例教程3000例《免费版》
Photoshop经典实例教程3000例 1、教你打造偏色艺术色调教程 2、 ·教你打造偏色艺术色调教程 3、 Photoshop┾製造制造另类婚纱照片 4、⒈款粉帥氣de游戲做圖 5、 PS(IR)可爱的棒棒糖 6、 ps打造唯美色调 7、 PS打造超炫人物效果 8、一款比较自然的眨眼教程 9、 Photoshop最简易的磨皮法 10、Photoshop] 制作下雨的效果 11、小菱形背景和圆点背景的做法 12、[Photoshop] PS打造淡彩风格的幻眼效果 13、Photoshop] 用Photoshop滤镜打造梦幻艺术效果 14、Photoshop] 巧用PS打造镶满诱人钻石的文字 15、Photoshop] PS制作幽冥火焰 16、Photoshop] 简单的叠影制作方法 17、Photoshop] 制作冬季恋歌浪漫雪景效果 18、Photoshop] 用Photoshop设计另类树皮人体 19、Photoshop] 教你设计绚丽光芒效果 20、Photoshop] 教你设计胶片风情电影海报 21、Photoshop] 教你设计神秘炫光黑洞效果 22、Photoshop] PS特效字：闪亮钻石效果 23、[Photoshop] 巧绘晶莹剔透的水晶樱桃 24、Fireworks] QQ空间初级玩家必学的11条技巧 25、Flash] 给FLASH初学者的10点制作经验 26、Flash] Flash全屏效果全攻略 27、Photoshop] 利用PS图层样式绘制彩色玻璃立体文字 28、Photoshop] Photoshop制作逼真的洁白羽毛 29、Photoshop] 用PS把秋景照片变为冬景效果 30、[Photoshop] Photoshop教你给MM的衣服换个颜色 31、Photoshop] 用PS制作周迅的怀旧效果图 32、Photoshop] 转用PS轻松给MM衣服添加图案 33、Photoshop] 用PS的动态画笔制作鞭炮 34、Photoshop] 教你做天使翅膀的卡通效果 35、Photoshop] 制作融化的冰淇淋 36、Photoshop] 打造宇宙场景爆炸星球特效 37、Photoshop] 教你设计恐怖电影海报 Photoshop] 制作奔驰中的汽车 [Photoshop] 蝴蝶结边框 [Photoshop] Photoshop高级柔化处理人物照片Photoshop] 神奇的Photoshop修图美容－－很实用
- JS折叠菜单实例方法简单实用
- 简单叠加体的三视图-
- 叠加方式的组合体图形的绘制
- AI实例：制作镜头
- 通过简单示例学习链接脚本基本语法
- photoshop 操作实例16讲(附带素材图)
- 3.11 简单的重叠数计算
- 什么是 剧场效应 我们先用一个简单形象的例子 来说明一下什
- 3.11 简单的重叠计数
- Photoshop经典实例教程3000例《免费版》
- Matlab100个实例程序
- “选人用人机制绝非各个单项制度的简单叠加”等十七则
- 叠加方式的组合体图形的绘制
- 简单叠加示例
- 人教版三年级数学 简单的重叠问题
- 电路实验报告1--叠加原理
- 用画图的方法解决简单的重叠问题
- 简单叠加体的三视图
- 叠加分析
- 简单叠加体的三视图