案例一：

  我们在实际生活中收发数据的时候是持续不断的，所以我们需要在发送端用键盘录入数据实现循环发数据(如果输入"quit"停止),接收端循环把接收到的数据打印到控制台上。

• 发送端

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

public class SendDemo {
    public static void main(String[] args) throws IOException {
        //创建发送端对象
        DatagramSocket ds = new DatagramSocket();
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        //不断循环输入数据
        while(true){
            //获取录入的信息
            System.out.println("请输入一个字符串：");
            String line = sc.nextLine();
            //如果输入quit，则退出输入
            if("quit".equals(line)){
                break;
            }else{
                //否则将数据打包，传送出去
                byte[] bys = line.getBytes();
                DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getLocalHost(), 12306);
                ds.send(dp);
            }
        }   
        //释放资源
        ds.close();
    }

}

• 接收端

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        //创建接收端Socket对象
        DatagramSocket ds = new DatagramSocket(12306);
        //循环接收数据
        while(true){
            //创建包对象
            byte[] bys = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bys, bys.length);
            //接收数据
            ds.receive(dp);
            //解析数据
            //获取发送端ip对象
            InetAddress address = dp.getAddress();
            //获取数据
            byte[] data = dp.getData();
            //获取数据长度
            int length = dp.getLength();
            //输出数据
            System.out.println("发送端ip地址为："+address);
            System.out.println(new String(data,0,length));
        }
    }

}

案例二：

  使用TCP协议发送数据，并将接收到的数据转换成大写返回

步骤：
  客户端发出数据
  服务器端接收数据
  服务器端转换数据
  服务器端发出数据
  客户端接收数据

• 客户端

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;

public class ClientTest {
    public static void main(String[] args) throws IOException, IOException {
        // 1.创建客户端Socket对象
        Socket s = new Socket(InetAddress.getLocalHost(), 12306);

        // 2.获取输入流对象，用来接收键盘录入的信息
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入一个字符串：");
        String str = br.readLine();

        // 3.创建输出流对象,发送数据
        PrintWriter pw = new PrintWriter(s.getOutputStream(), true);
        pw.println(str);

        // 12.获取输入流对象
        BufferedReader br2 = new BufferedReader(new InputStreamReader(s.getInputStream()));

        // 13.接收数据
        String line = br2.readLine();

        // 14.输出数据
        System.out.println(line);

        // 15.释放资源
        s.close();
        br.close();
    }

}

• 服务器端

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        // 4.创建服务器端Socket对象
        ServerSocket ss = new ServerSocket(12306);

        // 5.监听
        Socket s = ss.accept();

        // 6.创建输入流对象
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));

        // 7.读取数据
        String str = br.readLine();

        // 8.转换数据
        String newStr = str.toUpperCase();

        // 9.获取输出流对象
        PrintWriter pw = new PrintWriter(s.getOutputStream(), true);

        // 10.返回数据
        pw.println(newStr);

        // 11.释放资源
        s.close();
    }

}

拓展：
  （1）System系统类
    static InputStream in :标准输入流，是一个数据源指向的是 键盘录入的 字节输入流
    static PrintStream out :标准输出流，是一个数据目的指向的是 控制台的 字节输出流
  （2）PrintWriter 字符打印流
    可以直接输出一个字符串，并且自动加换行，还可以自动刷新。仅用于输出!
    构造方法：

    PrintWriter pw = new PrintWriter(OutputStream is,boolean autoFlush); 

    普通方法：println() 写数据的方法 相当于OutputStream的writer方法

案例三：

  模拟用户登录案例改写
  模拟数据库,把用户的登录信息放在数据库里面，用输入的用户信息创建一个用户对象，用这个用户对象和数据库中的用户对象进行比较，得出结果。

补充：
  静态代码块：随着类的加载而加载，只加载一次，加载类时需要做的一些初始化，比如加载驱动。格式：

static {
    初始化数据
}

• 用户类

public class User {
    private String name;
    private String passWord;

    public User() {
    }

    public User(String name, String passWord) {
        super();
        this.name = name;
        this.passWord = passWord;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    //contains方法的底层比较调用的是equals方法，初始的equals方法比较的是两个对象的地址值，所以需要重写equals方法 
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        User other = (User) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (passWord == null) {
            if (other.passWord != null)
                return false;
        } else if (!passWord.equals(other.passWord))
            return false;
        return true;
    }
}

• 用户数据库类（模拟数据库）

import java.util.ArrayList;
import java.util.List;

public class UserDB {
    private static List<User> users = new ArrayList<User>();
    static {
        users.add(new User("zhangsan", "123"));
        users.add(new User("lisi", "456"));
        users.add(new User("wangwu", "789"));
        users.add(new User("itheima", "itheima"));
    }

    public static List<User> getUsers() {
        return users;
    }

}

• 客户端

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;


public class ClientTest {
    public static void main(String[] args) throws IOException {
        // 创建客户端Socket对象
        Socket s = new Socket(InetAddress.getLocalHost(), 12306);

        // 创建键盘输入流对象,接收数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入用户名：");
        String name = br.readLine();
        System.out.println("请输入密码：");
        String passWord = br.readLine();

        // 创建输出流对象,输出数据
        PrintWriter pw = new PrintWriter(s.getOutputStream(), true);
        pw.println(name);
        pw.println(passWord);

        // 创建输入流对象,接收数据
        BufferedReader br2 = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String str = br2.readLine();
        System.out.println(str);

        // 释放资源
        s.close();
        br.close();
    }

}

• 服务器端

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.List;

public class ServerTest {
    public static void main(String[] args) throws IOException {
        // 创建服务器端Socket对象
        ServerSocket ss = new ServerSocket(12306);

        // 监听
        Socket s = ss.accept();

        // 创建输入流对象,接收用户名和密码
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String name = br.readLine();
        String passWord = br.readLine();
        User user = new User(name, passWord);

        // 创建输出流
        PrintWriter pw = new PrintWriter(s.getOutputStream(), true);

        // 判断用户名和密码是否相同
        if (UserDB.getUsers().contains(user)) {
            pw.println("登陆成功");
        } else {
            pw.println("登录失败");
        }

        // 释放资源
        s.close();

    }

}