网络编程
一、计算机网络
二、计算机网络发展
-
四个阶段
- 诞生阶段：一台主机，多个终端
- 形成阶段：美国国防部高级研究计划局协助开发的ARPANET
- 互联互通阶段：标准化的网络，OSI参考模型和TCP/IP参考模型
- 告诉发展阶段：光纤及高速网络技术，发展为以因特网为代表的互联网
-
分类：按照地理范围
- 局域网
- 城域网
- 广域网
三、OIS参考模型
OSI (Open System Interconnection) 开放式系统互联
- 第七层：应用层负责文件访问和管理、可靠运输服务，远程操作服务。（HTTP，FTP，SMTP）
- 第六层：表示层负责定义转换数据格式及加密，允许选择以二进制或ASCII格式传输。
- 第五层：会话层负责使应用建立和维持会话，使通信在失效时继续恢复通信。（断点续传）
- 第四层：传输层负责是否选择差错恢复协议，数据流重用，错误顺序重排。（TCP，UDP）
- 第三层：网络层负责定义了能够标识所有网络结点的逻辑地址。（IP地址）
- 第二层：链路层在物理层上，通过规程或协议（差错控制）来控制传输数据的正确性。（MAC）
- 第一层：物理层为设备之间的数据通信提供传输信号和物理介质。（双绞线，光导纤维）
四、TCP/IP模型
一组用于实现网络互联的通信协议，将协议分成四个层次
- 第四层：应用负责传送各种最终形态的数据，是直接与用户打交道的层，典型协议是HTTP，FTP等
- 第三层：传输层负责传送文本数据，主要协议是TCP，UDP协议
- 第二层：网络层负责分配地址和传送二进制数据，主要协议是IP协议
- 第一层：接口层负责建立电路连接，是整个网络的物理基础，典型的协议包括以太网，ADSL等等
五、IP
IP协议：Internet Protocol Address 互联网协议地址/网际协议地址。分配给互联网设备的数字标签（唯一标识）
5.1 IP地址
- IPV4：4字节32位整数，并分成4段8位的二进制，每8位之间用圆点隔开，每8位整数可以转换为一个0~255的十进制整数。
- 格式：D.D.D.D 例如：255.255.255.255
- IPV6：16字节128位整数，并分成8段十六进制数，每16位之间用圆点隔开，每16位整数可以转换为一个0~65535的十进制数。
- 格式：X.X.X.X.X.X.X.X 例如：FFFF.FFFF.FFFF.FFFF.FFFF.FFFF.FFFF.FFFF
5.2 IPV4应用分类
- A类：政府机构，1.0.01~126.255.255.254
- B类：中型企业，128.0.0.1~191.255.255.254
- C类：个人用户，192.0.0.1~223.255.255.254
- D类：用户组播，224.0.0.1~239.255.255.254
- E类：用于实验，240.0.0.1~255.255.255.254
- 回环地址：127.0.0.1，指本机，一般用于测试使用
- 查看IP命令：ipconfig
- 测试IP命令：ping D.D.D.D
5.3 Port端口号
端口号：在通信实体上进行网络通讯的程序的唯一标识。整数：0~65535
端口分类
- 公认端口：0~1023
- 注册端口：1024~49151
- 动态或私有端口：49152~65535
常用端口：
- MySql：3306
- Oracle：1521
- Tomcat：8080
- SMTP：25
- Web服务器：80，443
- FTP服务器：21
- netstat -ano 查看端口号
5.5 DNS
DNS(Domain Name System)：“域名系统”的英文缩写，是一种组织成域层次结构的计算机和网络服务命名系统，它用于TCP/IP网络
作用
- 用来将主机名和域名转换为IP地址的工作。
DNS解析过程
输入www.taobao.com时，DNS解析又大致十个过程
- 浏览器先检查自身缓存中有没有被解析过这个域名对应的ip地址，如果有，解析结束。同时域名被缓存的时间也可通过TTL属性来设置。
- 如果浏览器缓存中没有（专业点叫还没命中），浏览器会检查操作系统缓存中有没有对应的已解析过的结果。而操作系统也有一个域名解析的过程
- 如果至此还没有命中域名，才会真正的请求本地域名服务器（LDNS）来解析这个域名，这台服务器一般在你的吃食的某个角落，大约80%的域名解析到这里就完成了
- 如果LDNS仍然没有命中，就直接跳到Root Server域名服务器请求解析
- 根据域名服务器返回给LDNS一个所查询域的主域名服务器地址（国际顶尖域名服务器，如.com .cn .org等）
- 此时LDNS再发送请求给上一步返回的gTLD
- 接受请求的gTLD查找并返回这个域名对应的Name Server的地址，这个Name Server就是网站注册的域名服务器
- Name Server根据映射关系表找到目标ip，返回给LDNS
- LDNS缓存这个域名和对应的ip
- LDNS把解析的结果返回给用户，用户根据TTL值缓存到本地系统缓存中，域名解析过程至此结束
5.5 InetAddress类
概念：表示互联网协议（IP）地址对象，封装了与该IP地址相关的所有信息，并提供获取信息的常用方法。
方法
- public static InetAddress getLocalHost()
- 获取本地主机地址对象
- public static InetAddress getByName(String host)
- 根据主机名称获得地址对象
- public static InetAddress[] getAllByName(String host)
- 获得所有相关地址对象
- public String getHostAddress()
- 获取IP地址字符串
- public String getHostName()
- 获得IP地址主机名
五、TCP/UDP
- TCP协议：Transmission Control Protocol 传输控制协议
- 是一种面向连接的，可靠的，基于字节流的传输层通信协议。数据大小无限制。建立连接的过程需要三次握手，断开连接的过程需要四次挥手
- 标志位
- SYN 发起一个新连接
- ACK 确认序号有效
- FIN 释放一个连接
- UDP协议：User Datagram Protocol 用户数据报协议
- 是一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务，每个包的大小是64K
三次握手
四次挥手
5.1 TCP
基于TCP网络编程
Socket
- Socket（套接字）是网络中的一个通信结点
- 分为客户端Socket和服务器ServerSocket
- 通信要求：IP地址+端口号
开发步骤
- 服务器端
- 创建服务器套接字，并指定端口号
- 侦听，并返回客户端套接字
- 获取输入流，输出流
- 处理数据
- 关闭资源
- 客户端
- 创建客户端套接字，并指定服务器的地址和端口号
- 获取输入流，输出流
- 处理数据
- 关闭资源
5.1.1 案例一：TCP编程实现客户端发送数据给服务端，服务端发送给客户端
//TCP编程实现客户端发送数据给服务端，服务端发送给客户端
//服务器
public class TcpServer {
public static void main(String[] args)throws Exception {
//(1)创建服务器套接字，并指定端口号
ServerSocket listener=new ServerSocket(8899);
//(2)侦听客户端连接，并返回客户端套接字
System.out.println("服务器已启动");
Socket socket = listener.accept();
//(3)获取输入输出流
BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream(),"utf-8"));
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(),"utf-8"));
//(4)处理数据
String data = br.readLine();//遇到换行符才返回
System.out.println("客户端说:"+data);
bw.write("老地方见！");
bw.newLine();
bw.flush();
//(5)关闭资源
br.close();
bw.close();
socket.close();
listener.close();
}
}
//客户端
public class TcpClient {
public static void main(String[] args) throws Exception{
//(1)创建客户端套接字，并指定服务器的地址和端口号
Socket socket=new Socket("10.9.62.184", 8899);
//(2)获取输入输出流
BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream(),"utf-8"));
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(),"utf-8"));
//(3)处理数据
bw.write("好久不见");
bw.newLine();//坑
bw.flush();
String reply = br.readLine();
System.out.println("服务器回复:"+reply);
//(4)关闭资源
br.close();
bw.close();
socket.close();
}
}
5.1.2 案例二：TCP编程实现客户端上传文件给服务器端
//TCP编程实现客户端上传文件给服务器端
//服务器
public class FileServer {
public static void main(String[] args) throws Exception{
//(1)创建服务器套接字，并指定端口号
ServerSocket listener=new ServerSocket(6666);
//(2)侦听，并返回客户端套接字
System.out.println("服务器已启动...");
Socket socket = listener.accept();
//(3)获取输入流
InputStream is = socket.getInputStream();
BufferedInputStream bis=new BufferedInputStream(is);
//(4)处理
FileOutputStream fos=new FileOutputStream("d:\\111.jpg");
int data;
while((data=bis.read())!=-1){
fos.write(data);
}
//(5)关闭
fos.close();
bis.close();
socket.close();
listener.close();
System.out.println("接收完毕");
}
}
//客户端
public class FileClient {
public static void main(String[] args) throws Exception{
//(1)创建客户端套接字，并指定服务器的地址和端口号
Socket socket=new Socket("10.9.62.184", 6666);
//(2)获取输出
OutputStream os = socket.getOutputStream();
BufferedOutputStream bos=new BufferedOutputStream(os);
//(3)处理数据
FileInputStream fis=new FileInputStream("d:\\图片\\copy.jpg");
byte[] buf=new byte[1024];
int len;
while((len=fis.read(buf))!=-1){
bos.write(buf,0,len);
bos.flush();
}
//(4)关闭
bos.close();
fis.close();
socket.close();
System.out.println("发送完毕");
}
}
5.1.3 案例三：TCP实现客户端通信
//TCP实现客户端通信
//服务器
public class ChatServer {
public static ConcurrentHashMap<String,Socket> hashMap=new ConcurrentHashMap<>();
public static void main(String[] args){
//主线程负责侦听
//1 创建ServerSocket,并指定端口号
ServerSocket listener=null;
ExecutorService es= Executors.newCachedThreadPool();
try {
listener=new ServerSocket(8888);
//2 侦听
System.out.println("聊天室已启动...");
while(true) {
Socket socket = listener.accept();
//放入HashMap中
hashMap.put(socket.getInetAddress().getHostAddress(), socket);
System.out.println(socket.getInetAddress().getHostAddress()+"进入聊天室了...");
es.submit(new DataSocket(socket));
}
} catch (IOException e) {
System.out.println("服务器已关闭...");
} finally {
//3关闭
try {
listener.close();
es.shutdown();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//客户端
public class ChatClient {
static boolean flag=true;
public static void main(String[] args) throws Exception{
//(1)创建客户端套接字
Socket socket=new Socket("10.9.62.184", 8888);
new Thread(new Runnable() {
@Override
public void run() {
//处理数据
Scanner input=new Scanner(System.in);
while(true){
String data = input.next();
try {
//获取输出流
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(),"utf-8"));
bw.write(data);
bw.newLine();
bw.flush();
if(data.equals("byebye")||data.equals("886")){
break;
}
} catch (IOException e) {
e.printStackTrace();
}
}
flag=false;
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while(true){
try {
if(!flag){
break;
}
BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream(),"utf-8"));
String s = br.readLine();
System.out.println(s);
} catch (IOException e) {
e.printStackTrace();
}
}
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();
//(4)关闭
// bw.close();
// socket.close();
// System.out.println("已关闭");
}
}
//任务
public class DataSocket implements Runnable {
private Socket socket;
public DataSocket(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
//接收数据
BufferedReader br = null;
try {
InputStream is = socket.getInputStream();
br = new BufferedReader(new InputStreamReader(is, "utf-8"));
String line;
while ((line = br.readLine()) != null) { //(1)如果为null ,说明客户端正常关闭了, (2) 如果客户非正常关闭，抛出异常
转发///
int pos = line.indexOf(":");
if (pos >= 0) {
String ip = line.substring(0, pos);
if (ChatServer.hashMap.containsKey(ip)) {
Socket toSocket = ChatServer.hashMap.get(ip);
OutputStream os = toSocket.getOutputStream();
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os, "utf-8"));
String d = line.substring(pos + 1);
bw.write(socket.getInetAddress().getHostAddress() + ":" + d);
System.out.println("转发:" + socket.getInetAddress().getHostAddress() + ":" + d);
bw.newLine();
bw.flush();
}
}
///
System.out.println(socket.getInetAddress().getHostAddress() + "说:" + line);
if (line.equals("byebye") || line.equals("886")) {
break;
}
}
System.out.println(socket.getInetAddress().getHostAddress() + "退出了聊天");
} catch (Exception e) {
System.out.println(socket.getInetAddress().getHostAddress() + "异常退出了聊天");
System.out.println(e.getMessage());
} finally {
try {
br.close();
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
5.1.4 案例四：注册登陆
//登陆，服务端
public class Login implements Runnable {
@Override
public void run() {
try {
//(1)创建ServerSocket,指定端口号
ServerSocket listener=new ServerSocket(7777);
//(2)侦听，返回套接字
System.out.println("登录服务器已启动...");
Socket socket = listener.accept();
//(3)获取输入输出流
ObjectInputStream ois=new ObjectInputStream(socket.getInputStream());
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
//(4)处理数据
User user = (User) ois.readObject();
//4.1 读取硬盘中的集合对象
List<User> users=Tools.readUsers();
//4.2判断是否存在
boolean flag=false;
for (int i = 0; i < users.size(); i++) {
User u = users.get(i);
if(user.getId().equals(u.getId())&&user.getPwd().equals(u.getPwd())){
flag=true;
break;
}
}
//4.3回复数据
if(flag){
//登录成功
bw.write("登录成功");
}else{
//登录失败
bw.write("用户名或密码错误");
}
bw.newLine();
bw.flush();
//(5)关闭资源
bw.close();
ois.close();
socket.close();
listener.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
//服务端：注册
public class Regist implements Runnable {
@Override
public void run() {
try {
//(1)创建ServerSocket,指定端口号
ServerSocket listener=new ServerSocket(6666);
//(2)侦听，返回套接字
System.out.println("注册服务器已启动...");
Socket socket = listener.accept();
//(3)获取输入输出流
ObjectInputStream ois=new ObjectInputStream(socket.getInputStream());
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
//(4)处理数据
User user = (User) ois.readObject();
//4.1 读取硬盘中的集合对象
List<User> users=Tools.readUsers();
//4.2判断是否存在
boolean flag=false;
for (int i = 0; i < users.size(); i++) {
User u = users.get(i);
if(user.getId().equals(u.getId())){
flag=true;
break;
}
}
//4.3回复数据
if(flag){
//注册失败
bw.write("注册失败，用户id已存在");
}else{
//注册成功
bw.write("注册成功");
//把注册信息写入硬盘
users.add(user);
Tools.writeUsers(users);
}
bw.newLine();
bw.flush();
//(5)关闭资源
bw.close();
ois.close();
socket.close();
listener.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
//工具类：注册数据存储硬盘或从硬盘读取
public class Tools {
public static List<User> readUsers(){
List<User> users=null;
try {
File file=new File("d:\\users.bin");
if(file.exists()){
ObjectInputStream ois2=new ObjectInputStream(new FileInputStream(file));
users=(List<User>) ois2.readObject();
ois2.close();
}else{
users=new ArrayList<>();
}
} catch (Exception e) {
e.printStackTrace();
}
return users;
}
public static void writeUsers(List<User> users){
try {
File file=new File("d:\\users.bin");
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(users);
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//用户类
public class User implements Serializable {
private static final long serialVersionUID=1000L;
private String id;
private String name;
private String pwd;
private int age;
private double score;
public User(String id, String name, String pwd, int age, double score) {
this.id = id;
this.name = name;
this.pwd = pwd;
this.age = age;
this.score = score;
}
public User() {
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
}
//启动线程服务
public class UserServer {
public static void main(String[] args) {
new Thread(new Regist()).start();
new Thread(new Login()).start();
}
}
5.2 UDP
- DatagramSocket：表示用来发送和接收数据报包的套接字
- DatagramPacket：表示数据报包
//UDP实现注册，登陆
//注册
public class Regist implements Runnable {
@Override
public void run() {
ServerSocket listener = null;
Socket socket = null;
ObjectInputStream ois = null;
BufferedWriter bw = null;
ObjectInputStream ois2 = null;
try {
//创建服务器套接字对象，并确定端口
listener = new ServerSocket(6666);
System.out.println("注册服务器已启动。。。");
//侦听，返回套接字
socket = listener.accept();
//获取输入输出流
ois = new ObjectInputStream(socket.getInputStream());
bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), "utf-8"));
//处理数据
User user = (User) ois.readObject();
//读取硬盘中的集合对象
File file = new File("d:\\user.bin");
List<User> users;
if (file.exists()) {
//集合文件存在，读取到对象集合中
ois2 = new ObjectInputStream(new FileInputStream(file));
users = (List<User>) ois2.readObject();
} else {
//文件不存在，新建一个集合，返回一个空集合
users = new ArrayList<>();
}
boolean flag = false;
//判断是否存在
for (int i = 0; i < users.size(); i++) {
User u = users.get(i);
if (user.getId().equals(u.getId())) {
flag = true;
break;
}
}
//回复数据
if (flag) {
//注册失败
bw.write("注册失败，用户ID已存在");
} else {
//注册成功
bw.write("注册成功");
//把注册信息写入硬盘
// ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file,true));
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
users.add(user);
oos.writeObject(users);
oos.close();
}
bw.newLine();
bw.flush();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
if (listener != null) {
try {
listener.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (ois != null) {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (ois2 != null) {
try {
ois2.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (bw != null) {
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
//登陆
public class Login implements Runnable{
@Override
public void run() {
ServerSocket listener = null;
Socket socket = null;
ObjectInputStream ois = null;
BufferedWriter bw = null;
ObjectInputStream ois2 = null;
try {
//创建服务器套接字对象，并确定端口
listener = new ServerSocket(7777);
System.out.println("登陆服务器已启动。。。");
//侦听，返回套接字
socket = listener.accept();
//获取输入输出流
ois = new ObjectInputStream(socket.getInputStream());
bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), "utf-8"));
//处理数据
User user = (User) ois.readObject();
//读取硬盘中的集合对象
File file = new File("d:\\user.bin");
List<User> users;
if (file.exists()) {
//集合文件存在，读取到对象集合中
ois2 = new ObjectInputStream(new FileInputStream(file));
users = (List<User>) ois2.readObject();
ois2.close();
} else {
//文件不存在，新建一个集合，返回一个空集合
users = new ArrayList<>();
}
boolean flag = false;
//判断是否存在
for (int i = 0; i < users.size(); i++) {
User u = users.get(i);
if (user.getId().equals(u.getId())&&user.getPwd().equals(u.getPwd())) {
flag = true;
break;
}
}
//回复数据
if (flag) {
//登陆失败
bw.write("登陆成功");
} else {
//登陆成功
bw.write("登陆失败，用户id或密码错误");
}
bw.newLine();
bw.flush();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
if (listener != null) {
try {
listener.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (ois != null) {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (bw != null) {
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
//客户端
public class RegistClient {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("-------1.注册 2.登陆-------");
int choice = scanner.nextInt();
switch (choice){
case 1:
regist();
break;
case 2:
login();
break;
default:
System.out.println("输入有误");
break;
}
}
public static void regist(){
//1.创建Socket指定服务器的地址和端口号
Socket socket = null;
ObjectOutputStream oos = null;
BufferedReader br = null;
try {
socket = new Socket("10.9.62.210",6666);
//2.获取输入输出流
oos = new ObjectOutputStream(socket.getOutputStream());
br = new BufferedReader(new InputStreamReader(socket.getInputStream(), "utf-8"));
//3.处理数据
//发送
User user = getUser();
//序列化
oos.writeObject(user);
oos.flush();
//读取
String reply = br.readLine();
System.out.println("服务器回复："+reply);
} catch (IOException e) {
e.printStackTrace();
} finally {
if(oos!=null) {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(br!=null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(socket!=null){
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static User getUser(){
Scanner input = new Scanner(System.in);
System.out.println("请输入用户ID");
String id = input.next();
System.out.println("请输入姓名");
String name = input.next();
System.out.println("请输入密码");
String pwd = input.next();
System.out.println("请输入年龄");
int age = input.nextInt();
System.out.println("请输入成绩");
double score = input.nextDouble();
return new User(id, name, pwd, age, score);
}
public static void login(){
//1.创建Socket指定服务器的地址和端口号
Socket socket = null;
ObjectOutputStream oos = null;
BufferedReader br = null;
try {
socket = new Socket("10.9.62.210",7777);
//2.获取输入输出流
oos = new ObjectOutputStream(socket.getOutputStream());
br = new BufferedReader(new InputStreamReader(socket.getInputStream(), "utf-8"));
//3.处理数据
Scanner input = new Scanner(System.in);
System.out.println("请输入用户id");
String id = input.next();
System.out.println("请输入用户密码");
String pwd = input.next();
User user = new User(id, null, pwd, 0, 0);
//发送
// User user = getUser();
//序列化
oos.writeObject(user);
oos.flush();
//读取
String reply = br.readLine();
System.out.println("服务器回复："+reply);
} catch (IOException e) {
e.printStackTrace();
} finally {
if(oos!=null) {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(br!=null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(socket!=null){
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
//启动服务
public class UserServer {
public static void main(String[] args) {
new Thread(new Regist()).start();
new Thread(new Login()).start();
}
}
//用户类
public class User implements Serializable {
private static final long serialVersionUID = 12222l;
private String id;
private String name;
private String pwd;
private int age;
private double score;
public User() {
}
public User(String id, String name, String pwd, int age, double score) {
this.id = id;
this.name = name;
this.pwd = pwd;
this.age = age;
this.score = score;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
}
420
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
