In Java, UDP (User Datagram Protocol) datagram sockets are used for communication between two machines over a network using the UDP protocol. UDP is a connectionless protocol, which means that packets can be sent without establishing a connection first.

Here is an example of how to use UDP datagram sockets in Java:

import java.net.*;

public class UDPServer {
    public static void main(String[] args) throws Exception {
        DatagramSocket serverSocket = new DatagramSocket(9876);

        byte[] receiveData = new byte[1024];
        byte[] sendData = new byte[1024];

        while (true) {
            DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
            serverSocket.receive(receivePacket);
            String sentence = new String(receivePacket.getData());
            InetAddress IPAddress = receivePacket.getAddress();
            int port = receivePacket.getPort();
            String capitalizedSentence = sentence.toUpperCase();
            sendData = capitalizedSentence.getBytes();
            DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, port);
            serverSocket.send(sendPacket);
        }
    }
}

In this example, a UDP datagram socket is created on port 9876. The DatagramPacket class is used to receive and send packets of data. The receive() method of the DatagramSocket is used to wait for an incoming packet. Once a packet is received, the DatagramPacket is used to get the data, the sender's IP address, and the sender's port number. The data is then modified (in this case, converted to uppercase) and sent back to the client using the send() method of the DatagramSocket.

Here is an example of how to use a UDP datagram socket to send data:

import java.net.*;

public class UDPClient {
    public static void main(String[] args) throws Exception {
        DatagramSocket clientSocket = new DatagramSocket();
        InetAddress IPAddress = InetAddress.getByName("localhost");
        byte[] sendData = new byte[1024];
        byte[] receiveData = new byte[1024];
        String sentence = "hello";
        sendData = sentence.getBytes();
        DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, 9876);
        clientSocket.send(sendPacket);
        DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
        clientSocket.receive(receivePacket);
        String modifiedSentence = new String(receivePacket.getData());
        System.out.println("FROM SERVER:" + modifiedSentence);
        clientSocket.close();
    }
}

In this example, a UDP datagram socket is created on an anonymous port. The getByName() method of the InetAddress class is used to get the IP address of the server (in this case, localhost). The data to be sent is stored in a byte array and sent to the server using the send() method of the DatagramSocket. The client then waits to receive a response from the server using the receive() method of the DatagramSocket. Once the response is received, the data is converted to a string and printed to the console. Finally, the DatagramSocket is closed.

It is important to note that UDP is a connectionless protocol, which means that there is no guarantee that packets will be delivered in order, or even delivered at all. Therefore, applications that use UDP must be designed to handle lost or out-of-order packets. Additionally, because UDP packets are limited in size, larger messages must be split up into multiple packets and reassembled on the receiving end.