用eclipse编写输入格式：第一行是两个以空格符分隔的整数n和m；接下来的第二行到第m+1行，每行包含4个以空格分开的元素x，y，w和d来描述一条道路，其中x和y是一条长度为w的道路相连的两个农场的编号，d是字符N.E.S.或W，表示从x到y的道路的方向。输出格式：给出最远的一对农场之间距离的整数。

以下是一个简单的 Java 代码示例，可以实现输入格式的解析和最远距离的计算：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();

        // 构建邻接矩阵，表示道路连接情况和距离
        int[][] dist = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (i == j) {
                    dist[i][j] = 0;
                } else {
                    dist[i][j] = Integer.MAX_VALUE;
                }
            }
        }

        for (int i = 0; i < m; i++) {
            int x = scanner.nextInt() - 1;
            int y = scanner.nextInt() - 1;
            int w = scanner.nextInt();
            char d = scanner.next().charAt(0);

            // 根据道路方向更新距离
            if (d == 'N') {
                dist[x][y] = Math.min(dist[x][y], w);
            } else if (d == 'S') {
                dist[y][x] = Math.min(dist[y][x], w);
            } else if (d == 'E') {
                dist[x][y] = Math.min(dist[x][y], w);
                dist[y][x] = Math.min(dist[y][x], w);
            } else if (d == 'W') {
                dist[x][y] = Math.min(dist[x][y], w);
                dist[y][x] = Math.min(dist[y][x], w);
            }
        }

        // Floyd算法计算最长距离
        for (int k = 0; k < n; k++) {
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (dist[i][k] != Integer.MAX_VALUE && dist[k][j] != Integer.MAX_VALUE) {
                        dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);
                    }
                }
            }
        }

        // 找到最长距离
        int maxDist = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (dist[i][j] != Integer.MAX_VALUE) {
                    maxDist = Math.max(maxDist, dist[i][j]);
                }
            }
        }

        System.out.println(maxDist);
    }
}

注意，这只是一个简单的示例代码，在实际应用中可能需要更多的输入检查和异常处理。同时，这个算法的时间复杂度为 $O(n^3)$，对于较大的 $n$ 值可能会比较慢，可以考虑使用其他更高效的算法。