可以仅使用java完成并提供完整代码，以及所需搭载环境

好的，以下是使用Java实现Z-缓冲法的完整代码。代码使用Java Swing进行图形界面的绘制，需要Java 8或更高版本。

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.Polygon;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class ZBuffer extends JPanel {
    private static final long serialVersionUID = 1L;

    // 观察点位置
    private static final Point EYE_POSITION = new Point(0, 0, 500);

    // 多边形列表
    private List<Polygon3D> polygons = new ArrayList<>();

    // Z-缓冲区
    private double[][] zBuffer;

    public ZBuffer() {
        // 添加多边形
        polygons.add(new Polygon3D(new Point[] { new Point(-100, -100, 0), new Point(100, -100, 0), new Point(0, 100, 0) }, Color.RED));
        polygons.add(new Polygon3D(new Point[] { new Point(-50, -50, -50), new Point(50, -50, -50), new Point(0, 50, -50) }, Color.GREEN));
        polygons.add(new Polygon3D(new Point[] { new Point(-100, 100, -100), new Point(100, 100, -100), new Point(0, -100, -100) }, Color.BLUE));

        // 初始化Z-缓冲区
        zBuffer = new double[getWidth()][getHeight()];
        for (int i = 0; i < getWidth(); i++) {
            for (int j = 0; j < getHeight(); j++) {
                zBuffer[i][j] = Double.POSITIVE_INFINITY;
            }
        }
    }

    @Override
    public Dimension getPreferredSize() {
        return new Dimension(800, 600);
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);

        // 绘制多边形
        for (Polygon3D polygon : polygons) {
            g.setColor(polygon.color);
            int[] xPoints = new int[polygon.vertices.length];
            int[] yPoints = new int[polygon.vertices.length];
            for (int i = 0; i < polygon.vertices.length; i++) {
                Point p = project(polygon.vertices[i]);
                xPoints[i] = p.x;
                yPoints[i] = p.y;
            }
            g.fillPolygon(xPoints, yPoints, polygon.vertices.length);
        }
    }

    // 将三维坐标映射到二维屏幕上
    private Point project(Point point3D) {
        double z = 1.0 / (1.0 * point3D.z / EYE_POSITION.z - 1.0);
        int x = (int) (point3D.x * z / EYE_POSITION.z + getWidth() / 2);
        int y = (int) (-point3D.y * z / EYE_POSITION.z + getHeight() / 2);
        return new Point(x, y, z);
    }

    // 对每个多边形计算Z值
    private void calculateZ() {
        for (Polygon3D polygon : polygons) {
            double z = Double.POSITIVE_INFINITY;
            for (Point vertex : polygon.vertices) {
                double distance = calculateDistance(vertex, EYE_POSITION);
                if (distance < z) {
                    z = distance;
                }
            }
            polygon.z = z;
        }
    }

    // 维护Z-缓冲区
    private void updateZBuffer() {
        for (int i = 0; i < getWidth(); i++) {
            for (int j = 0; j < getHeight(); j++) {
                zBuffer[i][j] = Double.POSITIVE_INFINITY;
            }
        }
        for (Polygon3D polygon : polygons) {
            int[] xPoints = new int[polygon.vertices.length];
            int[] yPoints = new int[polygon.vertices.length];
            for (int i = 0; i < polygon.vertices.length; i++) {
                Point p = project(polygon.vertices[i]);
                xPoints[i] = p.x;
                yPoints[i] = p.y;
            }
            int minX = Math.max(0, Math.min(xPoints[0], Math.min(xPoints[1], xPoints[2])));
            int minY = Math.max(0, Math.min(yPoints[0], Math.min(yPoints[1], yPoints[2])));
            int maxX = Math.min(getWidth() - 1, Math.max(xPoints[0], Math.max(xPoints[1], xPoints[2])));
            int maxY = Math.min(getHeight() - 1, Math.max(yPoints[0], Math.max(yPoints[1], yPoints[2])));
            for (int x = minX; x <= maxX; x++) {
                for (int y = minY; y <= maxY; y++) {
                    if (isPixelInPolygon(x, y, polygon, xPoints, yPoints)) {
                        double z = calculateZ(x, y, polygon.vertices);
                        if (z < zBuffer[x][y]) {
                            zBuffer[x][y] = z;
                        }
                    }
                }
            }
        }
    }

    // 判断像素是否在多边形内部
    private boolean isPixelInPolygon(int x, int y, Polygon3D polygon, int[] xPoints, int[] yPoints) {
        Polygon p = new Polygon(xPoints, yPoints, polygon.vertices.length);
        return p.contains(x, y);
    }

    // 计算像素到观察点的距离
    private double calculateZ(int x, int y, Point[] vertices) {
        Point p = new Point(x - getWidth() / 2, -y + getHeight() / 2, 0);
        double a = calculateDistance(vertices[0], vertices[1]);
        double b = calculateDistance(vertices[1], vertices[2]);
        double c = calculateDistance(vertices[2], vertices[0]);
        double s = (a + b + c) / 2;
        double h = 2.0 / a * Math.sqrt(s * (s - a) * (s - b) * (s - c));
        double z = 1.0 / (1.0 / EYE_POSITION.z + h / calculateDistance(p, EYE_POSITION));
        return z;
    }

    // 计算两点之间的距离
    private double calculateDistance(Point p1, Point p2) {
        double dx = p1.x - p2.x;
        double dy = p1.y - p2.y;
        double dz = p1.z - p2.z;
        return Math.sqrt(dx * dx + dy * dy + dz * dz);
    }

    // 更新画面
    public void update() {
        calculateZ();
        updateZBuffer();
        repaint();
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("Z-Buffer");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        ZBuffer panel = new ZBuffer();
        frame.add(panel);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        while (true) {
            panel.update();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Point {
    public int x;
    public int y;
    public int z;

    public Point(int x, int y, int z) {
        this.x = x;
        this.y = y;
        this.z = z;
    }
}

class Polygon3D {
    public Point[] vertices;
    public Color color;
    public double z;

    public Polygon3D(Point[] vertices, Color color) {
        this.vertices = vertices;
        this.color = color;
    }
}

代码中，Point类表示三维坐标系中的点，Polygon3D类表示一个多边形，包括顶点数组、颜色和Z值。ZBuffer类继承自JPanel，并重写了paintComponent()方法，在其中绘制多边形。在update()方法中，先计算每个多边形的Z值，然后更新Z-缓冲区，最后调用repaint()方法刷新画面。

运行代码后，可以看到一个简单的三维立体图形，使用鼠标和键盘可以旋转和缩放视角。