任务调度;
Timer类，
/**
了解
Timer()
schedule(TimerTask task, Date time)
schedule(TimerTask task, Date firstTime, long period)
自学 quartz
*/
public class TimeDemo01 {
public static void main(String[] args) {
Timer timer =new Timer();
timer.schedule(
new TimerTask(){//TimerTask是一个抽象类需要创建它的子类，重写run方法
@Override
public void run() {
System.out.println("so easy....");
}
},
new Date(System.currentTimeMillis()+),
);
}
}
///public abstract class TimerTask implements Runnable,TimerTask是一个抽象类和线程类。
//void java.util.Timer.schedule(TimerTask task, Date firstTime, long period)。
//new Date(System.currentTimeMillis()+1000)表示一秒后。
多线程总结：
一、创建线程
.继承Thread
.实现Runnable
.实现Callable
二、线程的状态
.新生-start-就绪-运行-阻塞-终止
.终止线程的方法（重点）
.sleep方法
三、线程信息
.Thread.currentThread()
.
网络编程关注的是网络底层的交互。
一、网络：将不同区域的计算机连接到一起，分为：局域网、城域网、互联网。
二、地址:ip地址，确定网络上的一个绝对地址。
三、端口号（2个字节，-65525共65536个）：由于计算机上有很多程序，用于区分 计算机上的软件的。
.在同一个协议下，端口号不能重复。不同协议下tcp和udp下端口号可以重复。
.1024以下的不要使用，是操作系统预留的，例如80->http，->ftp。
四、资源定位：url：统一资源定位符，uri:统一资源。uri只有资源，url不仅仅有 资源还有定位（L表示location）。
五、数据传输： .协议（一个约定，比如规定现在上课说话的语言，用的书籍，不然大家听不懂）：tcp和udp协议，
1.1 TCP协议：类似于电话，需要先建立连接。面向连接，点到点通信，完全可靠，效率相当低下。
1.2 UDP：类似于短信，非面向连接，效率高，传输不可靠数据可能丢失。
.传输： （jsp、servlet在网络分层中是应用层，传输层（TCP/UDP）,网络层（IP）,数据链路层是操作系统。应用层是建立在传输层和网络层之上的。）
2.1 先封装：应用层数据进过一层一层的封装后传到物理链路层。
2.2 后拆封：物理链路层的数据进过一层一层的拆封后传到应用层。
Java封装的类：(数据传输过程中里面还是流)
.InnetAddress InetSocketAddress
.URL
.TCP:ServerSocket Socket
.UDP:DatagramSocket DatagramPacket
每个类都有构造器，只是访问权限不一样。
InetAddress类：
确定ip地址和域名解析（DNS，dns作用是将www..com转换为61.135.253.），但是没有端口信息。
InetSocketAddress类：
包含端口，用于socket通信。
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.UnknownHostException;
/**
* 没有封装端口
*/
public class InetDemo01 {
public static void main(String[] args) throws UnknownHostException{
//使用getLocalHost方法创建InetAddress对象
InetAddress addr = InetAddress.getLocalHost();
System.out.println(addr.getHostAddress()); //返回：192.168.1.100
System.out.println(addr.getHostName()); //输出计算机名
//根据域名得到InetAddress对象
addr = InetAddress.getByName("www.163.com");
System.out.println(addr.getHostAddress()); //返回 163服务器的ip:61.135.253.15
System.out.println(addr.getHostName()); //输出：www.163.com
//根据ip得到InetAddress对象
addr = InetAddress.getByName("61.135.253.15");
System.out.println(addr.getHostAddress()); //返回 163服务器的ip:61.135.253.15
System.out.println(addr.getHostName()); //输出ip而不是域名。如果这个IP地 址不存在或DNS服务器不允许进行IP地址和域名的映射，getHostName方法就直接返回这个IP地址。
}
}
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
/**
* 封装端口:在InetAddress基础上+端口
*/
public class InetSockeDemo01 {
// InetAddress是ip地址对象，
// InetSocketAddress包含ip地址和端口的对象
public static void main(String[] args) throws UnknownHostException {
InetSocketAddress address = new InetSocketAddress("127.0.0.1",);//在本机开一个端口
address = new InetSocketAddress(InetAddress.getByName("127.0.0.1"),);//这行和上面那行是一样的。
System.out.println(address.getHostName());//WIN7U-20130526M
System.out.println(address.getPort());//
InetAddress addr =address.getAddress();
System.out.println(addr.getHostAddress()); //返回：地址，127.0.0.1
System.out.println(addr.getHostName()); //输出计算机名，WIN7U-20130526M
}
}
URI(Uniform resource identifier)统一资源标示符，用来唯一的标识一个资源。
URL(Uniform resource Locator)统一资源定位器，不仅仅表示一种资源还表示这个资源的位置。
URL由4部分组成：协议、存放资源的主机域名、资源文件名和端口号。（我们自己敲的url时会自动省略http协议和80端口，因为是默认的。）
URL类：１.创建(绝对路径和相对路径构建)
import java.net.MalformedURLException;
import java.net.URL;
public class URLDemo01 {
public static void main(String[] args) throws MalformedURLException {
//绝对路径构建
URL url = new URL("http://www.baidu.com:80/index.html?uname=bjsxt");
System.out.println("协议:"+url.getProtocol());//协议:http
System.out.println("域名:"+url.getHost());//域名:www.baidu.com
System.out.println("端口:"+url.getPort());//端口:80
System.out.println("资源:"+url.getFile());//资源:/index.html?uname=bjsxt
System.out.println("相对路径:"+url.getPath());//相对路径:/index.html
System.out.println("锚点:"+url.getRef()); //锚点:null
System.out.println("参数:"+url.getQuery());//?参数 :存在锚点 返回null ,不存在，返回正确，参数:uname=bjsxt
//相对路径构建
url = new URL("http://www.baidu.com:80/a/");
url = new URL(url,"b.txt");
System.out.println(url.toString());//http://www.baidu.com:80/a/b.txt
}
}
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.URL;
/**
* 获取资源：源代码
*/
public class URLDemo02 {
public static void main(String[] args) throws IOException {
URL url = new URL("http://www.baidu.com"); //主页 默认资源
//获取资源 网络流
/*
InputStream is =url.openStream();
byte[] flush = new byte[1024];
int len =0;
while(-1!=(len=is.read(flush))){//每次读取1024字节到flush数组,len表示真实读取进flush的字节长度。
System.out.println(new String(flush,0,len));
}
is.close();
乱码的愿意1.编码，2.字节数不够。*/
BufferedReader br =
new BufferedReader(new InputStreamReader(url.openStream(),"utf-8"));//网页utf-8编码，所以这里读进br也要utf-8
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("baidu2.html"),"utf-8"));//写入到文件baidu2.html也要utf-8,baidu2.html在工程目录下。
String msg =null;
while((msg=br.readLine())!=null){//读取进br
//System.out.println(msg);
bw.append(msg);//写入到文件baidu2.html
bw.newLine();
}
bw.flush();
bw.close();//close一定会flush()
br.close();
}
}
UDP通信：以数据为中心，不安全，非面向连接，数据可能丢失，效率高。
一、类：DatagramSocket DatagramPacket.
.客户端
1.1 创建客户端 Datagramsocket类 + 指定端口，
1.2 准备数据
1.3 打包 DatagramPacket + 服务器地址及端口
1.4 发送
1.5 释放资源
.服务器端
2.1 创建服务端 Datagramsocket类 + 指定端口，
2.2 准备接收的容器 （字节数组） 封装DatagramPacket
2.3 接收数据
2.4 分析
2.5 释放资源
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
/**
* 服务端
* 1、创建服务端 +端口
* 2、准备接受容器
* 3、封装成 包
* 4、接受数据
* 5、分析数据
* 6、释放
*/
public class MyServer {
public static void main(String[] args) throws IOException {
//1、创建服务端 +端口
DatagramSocket server = new DatagramSocket();
//2、准备接受容器
byte[] container = new byte[];
//3、把这个容器封装成 包 DatagramPacket(byte[] buf, int length)
DatagramPacket packet =new DatagramPacket(container, container.length) ;
//4、接受数据到packet
server.receive(packet);
//5、分析数据
byte[] data =packet.getData();
int len =packet.getLength();
System.out.println(new String(data,,len));
//6、释放
server.close();
}
}
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
/**
* 客户端
* 1、创建客户端 +端口
* 2、准备数据
* 3、打包（发送的地点 及端口）
* 4、发送
* 5、释放
* 思考: 89.12 数据+类型
*
* 即使服务器关闭了，运行客户端也不会报错，因为这是UDP。
*/
public class MyClient {
public static void main(String[] args) throws IOException {
//1、创建客户端 +端口
DatagramSocket client = new DatagramSocket();
//2、准备数据
String msg ="udp编程";
byte[] data =msg.getBytes();
//3、数据打包（发送的地点 及端口） DatagramPacket(byte[] buf, int length, InetAddress address, int port)
DatagramPacket packet = new DatagramPacket(data,data.length,new InetSocketAddress("localhost",));
//4、发送
client.send(packet);
//5、释放
client.close();
}
}
看网页也是一种流的传输，下载也是一种流。
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
/**
* 服务端
* 1、创建服务端 +端口
* 2、准备接受容器
* 3、封装成 包
* 4、接受数据
* 5、分析数据 字节数组-->double
* 6、释放
*/
public class Server {
public static void main(String[] args) throws IOException {
//1、创建服务端 +端口
DatagramSocket server = new DatagramSocket();
//2、准备接受容器
byte[] container = new byte[];
//3、封装成 包 DatagramPacket(byte[] buf, int length)
DatagramPacket packet =new DatagramPacket(container, container.length) ;
//4、接受数据
server.receive(packet);
//5、分析数据
double data =convert(packet.getData());
System.out.println(data);
//6、释放
server.close();
}
/**
* 字节数组 +Data 输入流
字节数组转成double
*/
public static double convert(byte[] data) throws IOException{
DataInputStream dis =new DataInputStream(new ByteArrayInputStream(data));
double num =dis.readDouble();
dis.close();
return num;
}
}
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
/**
* 客户端
* 1、创建客户端 +端口
* 2、准备数据 double -->字节数组 字节数组输出流
* 3、打包（发送的地点 及端口）
* 4、发送
* 5、释放
*/
public class Client {
public static void main(String[] args) throws IOException {
//1、创建客户端 +端口
DatagramSocket client = new DatagramSocket();
//2、准备数据
double num =89.12;
byte[] data =convert(num);
//3、打包（发送的地点 及端口） DatagramPacket(byte[] buf, int length, InetAddress address, int port)
DatagramPacket packet = new DatagramPacket(data,data.length,new InetSocketAddress("localhost",));
//4、发送
client.send(packet);
//5、释放
client.close();
}
/**
double转成字节数组，DataOutputStream和DataInputStream是处理数据类型的。
*/
public static byte[] convert(double num) throws IOException{
byte[] data =null;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
DataOutputStream dos =new DataOutputStream(bos);
dos.writeDouble(num);//把内存中的num(89.12)转成字节数组输出到容器bos,
dos.flush();
//获取数据
data = bos.toByteArray();
dos.close();
return data;
}
}
UDP是数据里面去找服务器。
Socket通信：基于tcp协议，建立稳定连接的点对点通信，实时、快速、安全、占用系统资源多、效率相对低。
请求-相应模式：
客户端：在网络通讯中，第一次主动发起通讯的程序称为客户端程序。
服务器：第一次通讯中等待连接的程序称为服务器端程序。
Socket：发送TCP消息
ServerSocket：创建服务器
一、面向连接：请求-相应 Request-Response
二、服务器：ServerSocket，客户端Socket 客户端和服务端相当于有一个管道，这个管道就是socket，服务端的一个端口有可能有多个客户端来连接，每一个连接都有一个Socket。客户端和服务端都有一个端口，服务端的端口要指定，客户端的端口是自动分配的不需要指定。
（http协议底层的传输也是tcp协议，浏览器是一个基于tcp的客户端，只不过交互用的是http应用协议，tcp是http底层的协议。）
import java.io.BufferedWriter;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
/**
必须先启动服务器 后连接
1、创建服务器 指定端口 ServerSocket(int port)
2、接收客户端连接
3、发送数据+接收数据
*/
public class Server {
public static void main(String[] args) throws IOException {
//1、创建服务器 指定端口 ServerSocket(int port)
ServerSocket server = new ServerSocket();
//2、接收客户端连接 阻塞式，Socket代表这条管道，这个管道也可以代表这个客户端。
Socket socket =server.accept();//这行代码是服务端接收了客户端的连接，这就是服务端和客户端连接的那个管道，2者得到的是同一个管道。
System.out.println("一个客户端建立连接");
//3、发送数据到客户端
String msg ="欢迎使用";
//输出流
/*
BufferedWriter bw = new BufferedWriter(
new OutputStreamWriter( //OutputStreamWriter是一个转换流
socket.getOutputStream()));
bw.write(msg);
bw.newLine();//在bw中加一个换行符，客户端读的时候br.readLine()是一行一行的读。
bw.flush();*/
//socket.getOutputStream()套接字的输出流，内部还是流。
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
dos.writeUTF(msg);
dos.flush();
}
}
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;
/**
1、创建客户端 必须指定服务器+端口 此时就在连接
Socket(String host, int port)
2、接收数据 +发送数据
*/
public class Client {
public static void main(String[] args) throws UnknownHostException, IOException {
//1、创建客户端 必须指定服务器+端口 此时就在连接，这个客户端发送数据也是需要端口的只不过端口是系统自己分配（UDP的端口是要写的）。
Socket client = new Socket("localhost",);//这里就和服务器建立了连接，这个Socket就是服务端和客户端连接的那个管道。
//2、接收服务器来的数据
/*
BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
String echo =br.readLine(); //阻塞式方法逐行的读取，br中要有行的结束符。
System.out.println(echo);*/
try {
DataInputStream dis = new DataInputStream(client.getInputStream());
String echo = dis.readUTF();
System.out.println(echo);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
接收多个客户端：
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
必须先启动服务器 后连接
1、创建服务器 指定端口 ServerSocket(int port)
2、接收客户端连接
3、发送数据+接收数据
接收多个客户端
*/
public class MultiServer {
public static void main(String[] args) throws IOException {
//1、创建服务器 指定端口 ServerSocket(int port)
ServerSocket server = new ServerSocket();
//2、接收客户端连接 阻塞式
while(true){ //死循环 一个accept()一个客户端
Socket socket =server.accept();
System.out.println("一个客户端建立连接");
//3、发送数据
String msg ="欢迎使用";
//输出流
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
dos.writeUTF(msg);
dos.flush();
while(true){
System.out.println("qqqqqqq\n");
}
}
}
}