19.Java网络编程，UDP,TCP协议,接口接口实现类测试类的实现，lambda表达式，匿名内部类

最新推荐文章于 2022-06-21 22:23:09 发布

胡启行

最新推荐文章于 2022-06-21 22:23:09 发布

阅读量126

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/weixin_42605384/article/details/115282667

版权

Java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

//获取计算机名为sc-202103112315的IP的IP地址,创建对象可以是下面两种方式中的任意一种
//InetAddress address = InetAddress.getByName("sc-202103112315");
InetAddress address = InetAddress.getByName("192.168.232.1");
System.out.println(address);   //输出  /192.168.232.1
String hostName = address.getHostName();
System.out.println(hostName);  //输出主机名 sc-202103112315
String hostAddress = address.getHostAddress();
System.out.println(hostAddress);  //输出IP地址 192.168.232.1

//如果java运行过程中提示：java Address already in use: bind 表明端口已经被占用，需要重新跟换端口测试，即可
/**
端口设置在1024到65535之间即可,
UDP协议：音频，视频，普通数据传输，不需要连接
TCP协议：3次握手，可靠连接以后才传输数据
*/

UDP发送端：
//UDP协议传输，创建发送端的socket对象
DatagramSocket ds = new DatagramSocket();
//要发的数据包内容
byte[] bys = "你好，中国，我来了哦".getBytes();
//创建网络对象
InetAddress address = InetAddress.getByName("SC-202103112315");
//定义应用程序的端口
int port = 10086;
//创建发送数据包
DatagramPacket dp = new DatagramPacket(bys, bys.length, address, port);
//调用发送端socket发送数据
ds.send(dp);
//关闭发送端
ds.close();

/**
可以简写如下：
//UDP协议传输，创建发送端的socket对象
DatagramSocket ds = new DatagramSocket();
//要发的数据包内容
byte[] bys = "你好，中国，我来了哦".getBytes();
//创建发送数据包
DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("SC-202103112315"), 10086);
//调用发送端socket发送数据
ds.send(dp);
//关闭发送端
ds.close();
*/



UDP接收端：
//UDP协议传输，创建接收端的socket对象
DatagramSocket ds = new DatagramSocket(10086);
//定义接收数据的空字符数组
byte[] bys = new byte[1024];
//创建接收数据包
DatagramPacket dp = new DatagramPacket(bys, bys.length);
//接收数据
ds.receive(dp);
//将数据装入字符数组
byte[] datas = dp.getData();
//转成字符串
String s = new String(datas);
System.out.println("接收的数据是：" + s);
//关闭接收端
ds.close();

/**
接收端可以简写如下
//UDP协议传输，创建接收端的socket对象
DatagramSocket ds = new DatagramSocket(10086);
//定义接收数据的空字符数组
byte[] bys = new byte[1024];
//创建接收数据包
DatagramPacket dp = new DatagramPacket(bys, bys.length);
//接收数据
ds.receive(dp);
//输出数据
System.out.println("接收的数据是：" + new String(dp.getData()));
//关闭接收端
ds.close();
*/

/**
UDP实现发送端：键盘录入，发送886退出
UDP接收端：一直接收
*/
//UDP发送端：
public class send1 {
    public static void main(String[] args) throws IOException {
        while (true) {
            //创建键盘录入对象
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入数据：");
            //接收数据
            String s = sc.nextLine();
            if (s.equals("886")){
                System.exit(0);
            }else {
                send(s);
            }
        }
    }
    public static void send(String s) throws IOException {
        //UDP协议传输，创建发送端的socket对象
        DatagramSocket ds = new DatagramSocket();
        //要发的数据包内容
        byte[] bys = s.getBytes();
        //创建网络对象
        InetAddress address = InetAddress.getByName("SC-202103112315");
        //定义应用程序的端口
        int port = 10086;
        //创建发送数据包
        DatagramPacket dp = new DatagramPacket(bys, bys.length, address, port);
        //调用发送端socket发送数据
        ds.send(dp);
        //关闭发送端
        ds.close();
    }
}

//UDP接收端：
public class re1 {
    public static void main(String[] args) throws IOException {

            //UDP协议传输，创建接收端的socket对象
            DatagramSocket ds = new DatagramSocket(10086);
            while (true) {
                //定义接收数据的空字符数组
                byte[] bys = new byte[1024];
                //创建接收数据包
                DatagramPacket dp = new DatagramPacket(bys, bys.length);
                //接收数据
                ds.receive(dp);
                //将数据装入字符数组
                byte[] datas = dp.getData();
                //转成字符串
                String s = new String(datas);
                System.out.println("接收的数据是：" + s);
            }
    }
}

//TCP协议发送端：
public class Send2 {
    public static void main(String[] args) throws IOException {
        //创建客户端的Socket对象
        Socket s = new Socket("192.168.232.1", 10086);
        //获取输出流
        OutputStream os = s.getOutputStream();
        //写数据
        os.write("中国中国我爱你".getBytes());
        //接收服务器的反馈
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys, 0, len);
        System.out.println("客户端"+data);
        //释放资源
        s.close();
    }
}

//TCP协议接收端：
public class re2 {
    public static void main(String[] args) throws IOException {
        //创建服务器的ServerSocket对象
        ServerSocket ss = new ServerSocket(10086);
        //侦听要连接到此套接字并接收它
        Socket s = ss.accept();
        //获取收入流
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        //读取数据
        int len = is.read(bys);
        //数据转成字符串
        String data = new String(bys, 0, len);
        System.out.println("服务器："+data);
        //给出反馈
        OutputStream os = s.getOutputStream();
        os.write("数据已经收到了".getBytes());
        //关闭资源
        s.close();
        ss.close();
    }
}

/**
数据来自键盘输入，客户端输入“886”就断开连接，服务器端接收数据，并把接收到的数据写入到2.txt文件中
*/
//TCP协议服务器端部分
 //创建服务器的ServerSocket对象
        ServerSocket ss = new ServerSocket(10086);
        //监听客户端的连接，返回一个对应的socket对象
        Socket s = ss.accept();
        //获取输入流对象，接收数据
       BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        //把数据写入文本文件
    BufferedWriter bw = new BufferedWriter(new FileWriter("Test\\2.txt"));  //Test是模块名
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);  //打印接收到的内容
            bw.write(line);            //写入文件到2.txt
            bw.newLine();             //换行
            bw.flush();               //刷新
        }
        //释放资源
        ss.close();
        bw.close();

//TCP协议客户端部分
//创建客户端的Socket对象，TCP发送都是客户端向服务器端先发送数据，连接时，先开启服务器，然后开启客户端，不然连接不上会报错
        Socket s = new Socket("192.168.232.1", 10086);
        //1.下面两种客户端发送数据的方式选择一种
        //1.1接收来自及键盘输入的数据
        BufferedReader bis = new BufferedReader(new InputStreamReader(System.in));
        //1.2如果客户端数据不是来自键盘输入而是来自文本文件2.txt内容如下：
         BufferedReader bis = new BufferedReader(new FileReader("Test\\2.txt"));
        //封装数据输出流对象
    BufferedWriter bos = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        String line;
        while ((line = bis.readLine()) != null) {  //来自键盘输入的数据如果不为空
            if ("886".equals(line)) {  //如果输出886，就退出
                break;
            }
            bos.write(line);    //输出流对象写出字符串
            bos.newLine();      //输出流对象换行
            bos.flush();        //刷新
        }
        //释放资源
        s.close();

//客户端：数据来自文本文件，接收服务器反馈
//服务器端：接收到的数据写入文本文件，给出反馈
//TCP协议客户端：
Socket s = new Socket("192.168.232.1", 12086);
        //1.下面两种客户端发送数据的方式选择一种
        //1.1接收来自及键盘输入的数据
        //BufferedReader bis = new BufferedReader(new InputStreamReader(System.in));
        //1.2如果客户端数据不是来自键盘输入而是来自文本文件2.txt内容如下：
        BufferedReader bis = new BufferedReader(new FileReader("Test\\1.txt"));
        //封装数据输出流对象
        BufferedWriter bos = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        String line;
        while ((line = bis.readLine()) != null) {  //来自键盘输入的数据如果不为空
            bos.write(line);    //输出流对象写出字符串
            bos.newLine();      //输出流对象换行
            bos.flush();        //刷新
        }
//        //自定义结束标记（一般不用）
//        bos.write("886");
//        bos.newLine();
//        bos.flush();
        //用函数定义结束标记
        s.shutdownOutput();

        //接收反馈
 BufferedReader brclient = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String data = brclient.readLine();
        System.out.println("服务器反馈:"+data);
        //释放资源
        s.close();
        bis.close();

//TCP协议服务器端：
 //创建服务器的ServerSocket对象
        ServerSocket ss = new ServerSocket(12086);
        //监听客户端的连接，返回一个对应的socket对象
        Socket s = ss.accept();
        //获取输入流对象，接收数据
       BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        //把数据写入文本文件
    BufferedWriter bw = new BufferedWriter(new FileWriter("Test\\2.txt"));  //Test是模块名
        String line;
        while ((line = br.readLine()) != null) {  //等待读取
//            if("886".equals(line)){  //886接收连接标志判断
//                break;
//            }
            System.out.println(line);  //打印接收到的内容
            bw.write(line);            //写入文件到2.txt
            bw.newLine();             //换行
            bw.flush();               //刷新
        }
         //给出反馈
       BufferedWriter bwserver = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));      
        bwserver.write("上传成功");
        bwserver.newLine();             //换行
        bwserver.flush();                //刷新
        //释放资源
        ss.close();
        bw.close();

/**
TCP协议客户端：数据来自文本文件，接收服务器反馈，
TCP协议客户端:接收到的数据写入文本文件，给出反馈，为每一个客户端开起一个线程
*/
//客户端：
Socket s = new Socket("192.168.232.1", 12086);
//1.下面两种客户端发送数据的方式选择一种
//1.1接收来自及键盘输入的数据
//BufferedReader bis = new BufferedReader(new InputStreamReader(System.in));
//1.2如果客户端数据不是来自键盘输入而是来自文本文件2.txt内容如下：
BufferedReader bis = new BufferedReader(new FileReader("Test\\1.txt"));
//封装数据输出流对象
BufferedWriter bos = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
String line;
while ((line = bis.readLine()) != null) {  //来自键盘输入的数据如果不为空
	bos.write(line);    //输出流对象写出字符串
	bos.newLine();      //输出流对象换行
	bos.flush();        //刷新
}
//用函数定义结束标记
s.shutdownOutput();
//接收反馈
BufferedReader brclient = new BufferedReader(new InputStreamReader(s.getInputStream()));
String data = brclient.readLine();
System.out.println("服务器反馈:" + data);
//释放资源
s.close();
bis.close();


//服务器端：
//TCP协议服务器端：
//创建服务器的ServerSocket对象
ServerSocket ss = new ServerSocket(12086);
while(true) {
	//监听客户端的连接，返回一个对应的socket对象
	Socket s = ss.accept();
	//为每一个客户端开启一个线程
	new Thread(new ServerThead(s)).start();
}




//ServerThead.java:线程类
//前面new ServerThead(s)报错的时候
//alt+回车键，生成ServerTgead类一定要继承Runnable才可以
public class ServerThead implements Runnable {
private  Socket s;
public ServerThead(Socket s) {
	//这一句要手写
	this.s = s;
}

@Override
public void run() {
try {
	//获取输入流对象，接收数据
	BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
//解决名称冲突问题，每重启一此客户端和服务器，都会写入copy[0].txt,copy[1].txt,这样不同的名称文件
	int count = 0;
	File file = new File("Test\\copy[" + count + "].txt");
	while (file.exists()) {
		count++;
		file = new File("Test\\copy[" + count + "].txt");
	}
	//把数据写入文本文件
	BufferedWriter bw = new BufferedWriter(new FileWriter(file));  //Test是模块名
	String line;
	while ((line = br.readLine()) != null) {  //等待读取
		System.out.println(line);  //打印接收到的内容
		bw.write(line);            //写入文件到2.txt
		bw.newLine();             //换行
		bw.flush();               //刷新</try>
	}
	//给出反馈
	BufferedWriter bwserver = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
	bwserver.write("上传成功");
	bwserver.newLine();             //换行
	bwserver.flush();                //刷新
	//释放资源
	bw.close();
}catch(IOException e){
}
}
}

//1.定义一个接口Eatable
public interface Eatable {
    void eat();
}

//2.定义一个接口实现类EatableImpl继承Eatable
public class EatableImpl implements Eatable{
    @Override
    public void eat() {
        System.out.println("一天一个苹果，医生远离我");
    }
}

//3.1定义一个测试类EatableTest，这个测试类的执行结果是实现类里面的输出结果：一天一个苹果，医生远离我
//这里就需要接口，实现接口的类，测试类
public class EatableTest {
    public static void main(String[] args) {
        //多态的方式接口，new一个实现类对象
        Eatable e = new EatableImpl();
        //调用自定义函数
        useEatable(e);
    }
    //定义一个方法调用实现类里的eat()方法，把实现类的对象作为参数传入
    private static void useEatable(Eatable e){
        //通过实现类对象.的方式调用eat方法
        e.eat();
    }
}

//3.2定义一个测试类EatableTest，这个测试类的执行结果是实现类里面的输出结果：哈哈哈哈哈哈
//这里就只需要接口和测试类就可以，不需要实现接口的类了
public class EatableTest {
    public static void main(String[] args) {
        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("哈哈哈哈哈哈");
            }
        });
    }
    //定义一个方法调用实现类里的eat()方法，把实现类的对象作为参数传入
    private static void useEatable(Eatable e){
        //通过实现类对象.的方式调用eat方法
        e.eat();
    }
}
//3.3定义一个测试类EatableTest，通过lambda表达式输出，输出结果是：你个小鬼
//这里就只需要接口和测试类就可以，不需要实现接口的类了
public class EatableTest {
    public static void main(String[] args) {
          // lambda表达式输出
        useEatable(()->{
            System.out.println("你个小鬼");
        });
    }
    //定义一个方法调用实现类里的eat()方法，把实现类的对象作为参数传入
    private static void useEatable(Eatable e){
        //通过实现类对象.的方式调用eat方法
        e.eat();
    }
}

//创建一个接口
public interface Flyable {
    void fly(String s);
}

//**
创建一个测试类，输出结果是：
晴空万里无云
飞机自驾游
适合飞行
*/
public class FlyableTest {
    public static void main(String[] args) {
        //通过匿名内部类实现
    useFlyable(new Flyable() {
        @Override
        public void fly(String s) {
            System.out.println(s);
            System.out.println("飞机自驾游");
        }
    });
    //通过lambda表达式实现
        useFlyable((String s)->{
            System.out.println("适合飞行");
        });
    }
    private static void useFlyable(Flyable f){
        f.fly("晴空万里无云");
    }
}

 //当接口有且仅有一个方法的时候才可以使用lambda表达式，
        // 参数类型可以省略如下：
       useAddable(( x, y)->{
           return x*y;
       });

 //当且仅当只有一个参数的时候可以入如下写：
        useAddable(x->{
            System.out.println(s);
        });
 //当只有一个参数和只有一个语句的时候可以如下写：
        useFlyable(s->System.out.println("你好呀"));

胡启行

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
19.Java网络编程，UDP,TCP协议,接口接口实现类测试类的实现，lambda表达式，匿名内部类

//获取计算机名为sc-202103112315的IP的IP地址,创建对象可以是下面两种方式中的任意一种 //InetAddress address = InetAddress.getByName("sc-202103112315"); InetAddress address = InetAddress.getByName("192.168.232.1"); System.out.println(address); //输出 /192.168.232.1
复制链接

扫一扫