2D游戏引擎的Graphics2D封装程序

Question

我正在尝试编写一个2D游戏引擎，我想实现一个视口系统，这样当我在某个视口中绘制时，游戏坐标将自动转换为屏幕坐标，无需手动进行转换。

我想要做的是创建一个Graphics2D包装器，添加一个setViewport方法。

我认为有两种选择:

1. 创建一个类，其中包含一个Graphics2D的实例，具有与Graphics2D相同的所有方法以及setViewport，并且只是在Graphics2D实例上调用相应的方法。 2. 子类化Graphics2D，仅添加一个setViewport方法，然后从Graphics2D转换到这个新类。

我尝试了第二种方法，因为第一种方法似乎非常不可行，但遇到了ClassCastException。我无法将Graphics或Graphics2D转换为这个新类。在转换之前打印图形对象（Graphics或Graphics2D），两者都显示为sun.java2d.SunGraphics2D。

我在子类化和转换时是否犯了根本性错误？如果没有，我该如何解决这个问题？

- elaid

---

我认为任何试图对Graphics2D进行子类化的解决方案都不会很好地工作。 - Hovercraft Full Of Eels

我正在跟着大学课程的幻灯片（实际上并没有参加这门课）学习，它们说“创建一个Graphics2D的包装器，其中包含一个类似于setViewport()的方法-在绘制视口时，切换您的Graphics2D包装器内部的标志，每当绘制形状时，您需要转换游戏->屏幕坐标-在每个对象自己的onDraw()调用中进行单独的游戏对象变换-完成绘制视口后取消标记您的包装器”。还有其他对包装器的解释吗？ - elaid

有趣 - 你有这个幻灯片集的链接吗？ - Hovercraft Full Of Eels

“包装器还有其他的解释吗？” 包装器是一个将被包装类作为成员（字段）持有的类。这是组合。 - user1803551

我现在所做的（并且这个解决方案可能会改变）就是这样。我创建了一个包含Graphics2D对象的新类，并将所有方法调用都转移到该对象上（编写所有方法花费了一些时间）。这样我可以添加任何我需要的方法，比如问题描述中的setViewport()方法。不过，似乎应该有一种更简单/更优雅的方式来创建这个功能。 - elaid

Answer 1

我为自己编写的游戏创建了一个坐标系统。这里提供CoordinateSystem类作为示例。

以下是CoordinateSystem类的内容。

package com.ggl.game.utilities;

import java.awt.Dimension;
import java.awt.Point;
import java.awt.geom.Point2D;

/**
 * <p>
 * This class creates a Cartesian and Polar coordinate system to overlay a Swing
 * drawing area (usually a <code>JPanel</code>). The user of the class sets a
 * limit as to how far the X axis or the Y axis extends in the negative and
 * positive direction from (0, 0). Point (0, 0) will be placed in the center of
 * the drawing area.
 * </p>
 * <p>
 * Since the drawing area is usually not square, the limit applies to the
 * shorter dimension. The actual limits can be retrieved from this class, and
 * will change if the user of the application changes the drawing area size by
 * maximizing or normalizing the application <code>JFrame</code> window.
 * </p>
 * <p>
 * Using a Cartesian or Polar coordinate system frees the user of this class
 * from having to worry about Swing pixel coordinates.
 * </p>
 * 
 * @author Gilbert G. Le Blanc
 * @version 1.0 - 23 February 2015
 * 
 * @see com.ggl.game.utilities.Polar2D
 * @see java.awt.geom.Point2D
 * @see javax.swing.JFrame
 * @see javax.swing.JPanel
 */
public class CoordinateSystem {

    private double conversionFactor;
    private double xLimit;
    private double yLimit;

    private int height;
    private int width;

    /**
     * <p>
     * This creates a Cartesian and Polar coordinate system over a Swing drawing
     * area (usually a <code>JPanel</code>). If the drawing area is square, the
     * X axis extends from -limit to limit and the Y axis extends from -limit to
     * limit.
     * </p>
     * <p>
     * If the drawing area is not square, then the smaller dimension, either X
     * or Y, extends from -limit to limit. The larger dimension extends beyond
     * the limit in both directions.
     * </p>
     * <p>
     * Since most displays are not square, the X and Y axis will usually have
     * different limits.
     * </p>
     * 
     * @param limit
     *            - The limit of the X and Y axis in a Cartesian coordinate
     *            system.
     * @param width
     *            - The width of the drawing area in pixels.
     * @param height
     *            - The height of the drawing area in pixels.
     */
    public CoordinateSystem(double limit, int width, int height) {
        this.width = width;
        this.height = height;

        if (width > height) {
            this.xLimit = limit * width / height;
            this.yLimit = limit;
            this.conversionFactor = (limit + limit) / (double) height;
        } else if (width < height) {
            this.xLimit = limit;
            this.yLimit = limit * height / width;
            this.conversionFactor = (limit + limit) / (double) width;
        } else {
            this.xLimit = limit;
            this.yLimit = limit;
            this.conversionFactor = (limit + limit) / (double) width;
        }
    }

    /**
     * This method changes the drawing area dimension, along with the X and Y
     * axis limits.
     * 
     * @param dimension
     *            - A <code>Dimension</code> with the new drawing area
     *            dimension.
     */
    public void setDrawingSize(Dimension dimension) {
        setDrawingSize(dimension.width, dimension.height);
    }

    /**
     * This method changes the drawing area width and height, along with the X
     * and Y axis limits.
     * 
     * @param width
     *            - The width of the drawing area in pixels.
     * @param height
     *            - The height of the drawing area in pixels.
     */
    public void setDrawingSize(int width, int height) {
        xLimit = xLimit / this.width * width;
        yLimit = yLimit / this.height * height;

        this.width = width;
        this.height = height;
    }

    /**
     * This method returns the Cartesian coordinate limit for the X axis.
     * 
     * @return The Cartesian coordinate limit for the X axis.
     */
    public double getxLimit() {
        return xLimit;
    }

    /**
     * This method returns the Cartesian coordinate limit for the Y axis.
     * 
     * @return The Cartesian coordinate limit for the Y axis.
     */
    public double getyLimit() {
        return yLimit;
    }

    /**
     * This method converts a Polar coordinate distance and theta angle in
     * radians to a pixel location on a drawing area.
     * 
     * @param distance
     *            - A Polar coordinate distance
     * @param theta
     *            - A Polar coordinate theta angle in radians
     * @return A pixel location on a drawing area.
     */
    public Point convertPolarToPixels(double distance, double theta) {
        return convertToPixels(new Polar2D.Double(distance, theta));
    }

    /**
     * This method converts a Cartesian coordinate x and y to a pixel location
     * on a drawing area.
     * 
     * @param x
     *            - A Cartesian coordinate x.
     * @param y
     *            - A Cartesian coordinate y.
     * @return A pixel location on a drawing area.
     */
    public Point convertPointToPixels(double x, double y) {
        return convertToPixels(new Point2D.Double(x, y));
    }

    /**
     * This method converts a Polar coordinate to a pixel location on a drawing
     * area.
     * 
     * @param polar
     *            - A Polar coordinate.
     * @return A pixel location on a drawing area.
     */
    public Point convertToPixels(Polar2D polar) {
        double x = polar.getDistance() * Math.cos(polar.getTheta());
        double y = polar.getDistance() * Math.sin(polar.getTheta());
        return convertToPixels(new Point2D.Double(x, y));
    }

    /**
     * This method converts a Cartesian coordinate to a pixel location on a
     * drawing area.
     * 
     * @param cartesian
     *            - A Cartesian coordinate.
     * @return A pixel location on a drawing area.
     */
    public Point convertToPixels(Point2D cartesian) {
        int x = (int) Math
                .round((cartesian.getX() + xLimit) / conversionFactor);
        int y = (int) Math.round((-cartesian.getY() + yLimit)
                / conversionFactor);
        return new Point(x, y);
    }

    /**
     * This method converts a pixel location on a drawing area to a Cartesian
     * coordinate.
     * 
     * @param x
     *            - The x pixel location.
     * @param y
     *            - The y pixel location.
     * @return A Cartesian coordinate.
     */
    public Point2D convertToCartesian(int x, int y) {
        return convertToCartesian(new Point(x, y));
    }

    /**
     * This method converts a pixel location on a drawing area to a Cartesian
     * coordinate.
     * 
     * @param point
     *            - The pixel location.
     * @return A Cartesian coordinate.
     */
    public Point2D convertToCartesian(Point point) {
        double x = (double) point.x * conversionFactor - xLimit;
        double y = (double) -point.y * conversionFactor + yLimit;
        return new Point2D.Double(x, y);
    }

    /**
     * This method converts a pixel location on a drawing area to a Polar
     * coordinate.
     * 
     * @param x
     *            - The x pixel location.
     * @param y
     *            - The y pixel location.
     * @return A Polar coordinate.
     */
    public Polar2D convertToPolar(int x, int y) {
        return convertToPolar(new Point(x, y));
    }

    /**
     * This method converts a pixel location on a drawing area to a Polar
     * coordinate.
     * 
     * @param point
     *            - The pixel location.
     * @return A Polar coordinate.
     */
    public Polar2D convertToPolar(Point point) {
        double x = (double) point.x * conversionFactor - xLimit;
        double y = (double) -point.y * conversionFactor + yLimit;
        double distance = Math.sqrt(x * x + y * y);
        double theta = Math.atan2(y, x);
        return new Polar2D.Double(distance, theta);
    }

}

这里是Polar2D类。它是Point2D类的克隆。

package com.ggl.game.utilities;

/**
 * The <code>Polar2D</code> class defines a point representing a location in
 * distance, theta angle coordinate space.
 * <p>
 * This class is only the abstract superclass for all objects that store a 2D
 * coordinate. The actual storage representation of the coordinates is left to
 * the subclass.
 * 
 * @version 1.0 - 23 February 2015
 * @author Jim Graham (author of Point2D), Gilbert Le Blanc
 */
public abstract class Polar2D implements Cloneable {
    /**
     * The <code>Float</code> class defines a point specified in float
     * precision.
     */
    public static class Float extends Polar2D {
        /**
         * The distance of this <code>Polar2D</code>.
         * 
         * @since 1.7
         */
        public float distance;
        /**
         * The theta angle of this <code>Polar2D</code>.
         * 
         * @since 1.7
         */
        public float theta;

        /**
         * Constructs and initializes a <code>Polar2D</code> with coordinates
         * (0,&nbsp;0).
         * 
         * @since 1.7
         */
        public Float() {
        }

        /**
         * Constructs and initializes a <code>Polar2D</code> with the specified
         * coordinates.
         * 
         * @param distance
         *            The distance to which to set the newly constructed
         *            <code>Polar2D</code>
         * @param theta
         *            The theta angle in radians to which to set the newly
         *            constructed <code>Polar2D</code>
         * @since 1.7
         */
        public Float(float distance, float theta) {
            this.distance = distance;
            this.theta = theta;
        }

        /**
         * Returns the distance of this <code>Polar2D</code> in
         * <code>double</code> precision.
         * 
         * @return the distance of this <code>Polar2D</code>.
         * @since 1.7
         */
        @Override
        public double getDistance() {
            return (double) distance;
        }

        /**
         * Returns the theta angle in radians of this <code>Polar2D</code> in
         * <code>double</code> precision.
         * 
         * @return the theta angle in radians of this <code>Polar2D</code>.
         * @since 1.7
         */
        @Override
        public double getTheta() {
            return (double) theta;
        }

        /**
         * Returns the theta angle in degrees of this <code>Polar2D</code> in
         * <code>double</code> precision.
         * 
         * @return the theta angle in degrees of this <code>Polar2D</code>.
         * @since 1.7
         */
        @Override
        public double getThetaInDegrees() {
            double degrees = 180D / Math.PI * theta;
            return (degrees < 0D) ? degrees + 360D : degrees;
        }

        /**
         * Sets the location of this <code>Polar2D</code> to the specified
         * <code>double</code> distance and theta angle in radians.
         * 
         * @param distance
         *            The distance to which to set this <code>Polar2D</code>
         * @param theta
         *            The theta angle in radians to which to set this
         *            <code>Polar2D</code>
         * @since 1.7
         */
        @Override
        public void setLocation(double distance, double theta) {
            this.distance = (float) distance;
            this.theta = (float) theta;
        }

        /**
         * Sets the location of this <code>Polar2D</code> to the specified
         * <code>float</code> coordinates.
         * 
         * @param distance
         *            The distance to which to set this <code>Polar2D</code>
         * @param theta
         *            The theta angle in radians to which to set this
         *            <code>Polar2D</code>
         * @since 1.7
         */
        public void setLocation(float distance, float theta) {
            this.distance = distance;
            this.theta = theta;
        }

        /**
         * Returns a <code>String</code> that represents the value of this
         * <code>Polar2D</code>.
         * 
         * @return A <code>String</code> representation of this
         *         <code>Polar2D</code>.
         * @since 1.7
         */
        @Override
        public String toString() {
            return "Polar2D.Float[" + distance + ", " + theta + "]";
        }
    }

    /**
     * The <code>Double</code> class defines a point specified in
     * <code>double</code> precision.
     */
    public static class Double extends Polar2D {
        /**
         * The distance of this <code>Polar2D</code>.
         * 
         * @since 1.7
         */
        public double distance;
        /**
         * The theta angle in radians of this <code>Polar2D</code>.
         * 
         * @since 1.7
         */
        public double theta;

        /**
         * Constructs and initializes a <code>Polar2D</code> with (0,&nbsp;0)
         * distance and theta angle in radians.
         * 
         * @since 1.7
         */
        public Double() {
        }

        /**
         * Constructs and initializes a <code>Polar2D</code> with the specified
         * coordinates.
         * 
         * @param distance
         *            The distance to which to set the newly constructed
         *            <code>Polar2D</code>
         * @param theta
         *            The theta angle in radians to which to set the newly
         *            constructed <code>Polar2D</code>
         * @since 1.7
         */
        public Double(double distance, double theta) {
            this.distance = distance;
            this.theta = theta;
        }

        /**
         * Returns the distance of this <code>Polar2D</code> in
         * <code>double</code> precision.
         * 
         * @return The distance of this <code>Polar2D</code>.
         * @since 1.7
         */
        @Override
        public double getDistance() {
            return distance;
        }

        /**
         * Returns the theta angle in radians of this <code>Polar2D</code> in
         * <code>double</code> precision.
         * 
         * @return The theta angle in radians of this <code>Polar2D</code>.
         * @since 1.7
         */
        @Override
        public double getTheta() {
            return theta;
        }

        /**
         * Returns the theta angle in degrees of this <code>Polar2D</code> in
         * <code>double</code> precision.
         * 
         * @return The theta angle in degrees of this <code>Polar2D</code>.
         * @since 1.7
         */
        @Override
        public double getThetaInDegrees() {
            double degrees = 180D / Math.PI * theta;
            return (degrees < 0D) ? degrees + 360D : degrees;
        }

        /**
         * Sets the location of this <code>Polar2D</code> to the specified
         * <code>double</code> coordinates.
         * 
         * @param distance
         *            The distance to which to set this <code>Polar2D</code>
         * @param theta
         *            The theta angle in radians to which to set this
         *            <code>Polar2D</code>
         * @since 1.7
         */
        @Override
        public void setLocation(double distance, double theta) {
            this.distance = distance;
            this.theta = theta;
        }

        /**
         * Returns a <code>String</code> that represents the value of this
         * <code>Polar2D</code>.
         * 
         * @return A <code>String</code> representation of this
         *         <code>Polar2D</code>.
         * @since 1.7
         */
        @Override
        public String toString() {
            return "Polar2D.Double[" + distance + ", " + theta + "]";
        }
    }

    /**
     * This is an abstract class that cannot be instantiated directly.
     * Type-specific implementation subclasses are available for instantiation
     * and provide a number of formats for storing the information necessary to
     * satisfy the various accessor methods below.
     * 
     * @see java.awt.geom.Polar2D.Float
     * @see java.awt.geom.Polar2D.Double
     * @see java.awt.Point
     */
    protected Polar2D() {
    }

    /**
     * Returns the distance of this <code>Polar2D</code> in <code>double</code>
     * precision.
     * 
     * @return The distance of this <code>Polar2D</code>.
     * @since 1.7
     */
    public abstract double getDistance();

    /**
     * Returns the theta angle in radians of this <code>Polar2D</code> in
     * <code>double</code> precision.
     * 
     * @return The theta angle in radians of this <code>Polar2D</code>.
     * @since 1.7
     */
    public abstract double getTheta();

    /**
     * Returns the theta angle in degrees of this <code>Polar2D</code> in
     * <code>double</code> precision.
     * 
     * @return The theta angle in degrees of this <code>Polar2D</code>.
     * @since 1.7
     */
    public abstract double getThetaInDegrees();

    /**
     * Sets the location of this <code>Polar2D</code> to the specified
     * <code>double</code> coordinates.
     * 
     * @param distance
     *            The distance of this <code>Polar2D</code>
     * @param theta
     *            The theta angle in radians of this <code>Polar2D</code>
     * @since 1.7
     */
    public abstract void setLocation(double distance, double theta);

    /**
     * Sets the location of this <code>Polar2D</code> to the same coordinates as
     * the specified <code>Polar2D</code> object.
     * 
     * @param p
     *            the specified <code>Polar2D</code> the which to set this
     *            <code>Polar2D</code>
     * @since 1.7
     */
    public void setLocation(Polar2D p) {
        setLocation(p.getDistance(), p.getTheta());
    }

    /**
     * Returns the square of the distance between two points.
     * 
     * @param distance1
     *            The distance of the first point
     * @Parm theta1 The theta angle in radians of the first point
     * @param distance2
     *            The distance of the second point
     * @param theta2
     *            The theta angle in radians of the second point
     * @return The square of the distance between the two specified points.
     */
    public static double distanceSq(double distance1, double theta1,
            double distance2, double theta2) {
        double x1 = distance1 * Math.cos(theta1);
        double y1 = distance1 * Math.sin(theta1);
        double x2 = distance2 * Math.cos(theta2);
        double y2 = distance2 * Math.sin(theta2);
        return (x1 * x2 + y1 * y2);
    }

    /**
     * Returns the distance between two points.
     * 
     * @param distance1
     *            The distance of the first point
     * @param theta1
     *            The theta angle in radians of the first point
     * @param distance2
     *            The distance of the second point
     * @param theta2
     *            The theta angle in radians of the second point
     * @return The distance between the two specified points.
     */
    public static double distance(double distance1, double theta1,
            double distance2, double theta2) {
        double x1 = distance1 * Math.cos(theta1);
        double y1 = distance1 * Math.sin(theta1);
        double x2 = distance2 * Math.cos(theta2);
        double y2 = distance2 * Math.sin(theta2);
        return Math.sqrt(x1 * x2 + y1 * y2);
    }

    /**
     * Returns the square of the distance from this <code>Polar2D</code> to a
     * specified point.
     * 
     * @param distance
     *            The distance of the specified point
     * @param theta
     *            The theta angle in radians of the specified point
     * @return The square of the distance between this <code>Polar2D</code> and
     *         the specified point.
     */
    public double distanceSq(double distance, double theta) {
        double x1 = distance * Math.cos(theta);
        double y1 = distance * Math.sin(theta);
        double x2 = getDistance() * Math.cos(getTheta());
        double y2 = getDistance() * Math.sin(getTheta());
        return (x1 * x2 + y1 * y2);
    }

    /**
     * Returns the square of the distance from this <code>Polar2D</code> to a
     * specified <code>Polar2D</code>.
     * 
     * @param pt
     *            The specified <code>Polar2D</code>
     * @return The square of the distance between this <code>Polar2D</code> to a
     *         specified <code>Polar2D</code>.
     */
    public double distanceSq(Polar2D pt) {
        double x1 = pt.getDistance() * Math.cos(pt.getTheta());
        double y1 = pt.getDistance() * Math.sin(pt.getTheta());
        double x2 = getDistance() * Math.cos(getTheta());
        double y2 = getDistance() * Math.sin(getTheta());
        return (x1 * x2 + y1 * y2);
    }

    /**
     * Returns the distance from this <code>Polar2D</code> to a specified point.
     * 
     * @param distance
     *            The distance of the specified point
     * @param theta
     *            The theta angle in radians of the specified point
     * @return The distance between this <code>Polar2D</code> and a specified
     *         point.
     */
    public double distance(double distance, double theta) {
        double x1 = distance * Math.cos(theta);
        double y1 = distance * Math.sin(theta);
        double x2 = getDistance() * Math.cos(getTheta());
        double y2 = getDistance() * Math.sin(getTheta());
        return Math.sqrt(x1 * x2 + y1 * y2);
    }

    /**
     * Returns the distance from this <code>Polar2D</code> to a specified
     * <code>Polar2D</code>.
     * 
     * @param pt
     *            the specified <code>Polar2D</code>
     * @return The distance between this <code>Polar2D</code> and the specified
     *         <code>Polar2D</code>.
     */
    public double distance(Polar2D pt) {
        double x1 = pt.getDistance() * Math.cos(pt.getTheta());
        double y1 = pt.getDistance() * Math.sin(pt.getTheta());
        double x2 = getDistance() * Math.cos(getTheta());
        double y2 = getDistance() * Math.sin(getTheta());
        return Math.sqrt(x1 * x2 + y1 * y2);
    }

    /**
     * Creates a new object of the same class and with the same contents as this
     * object.
     * 
     * @return a clone of this instance.
     * @exception OutOfMemoryError
     *                if there is not enough memory.
     * @see java.lang.Cloneable
     * @since 1.7
     */
    @Override
    public Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError();
        }
    }

    /**
     * Returns the hash code for this <code>Polar2D</code>.
     * 
     * @return a hash code for this <code>Polar2D</code>.
     */
    @Override
    public int hashCode() {
        long bits = java.lang.Double.doubleToLongBits(getDistance());
        bits ^= java.lang.Double.doubleToLongBits(getTheta()) * 31;
        return (((int) bits) ^ ((int) (bits >> 32)));
    }

    /**
     * Determines whether or not two points are equal. Two instances of
     * <code>Polar2D</code> are equal if the values of their <code>x</code> and
     * <code>y</code> member fields, representing their position in the
     * coordinate space, are the same.
     * 
     * @param obj
     *            an object to be compared with this <code>Polar2D</code>
     * @return <code>true</code> if the object to be compared is an instance of
     *         <code>Polar2D</code> and has the same values; <code>false</code>
     *         otherwise.
     * @since 1.7
     */
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Polar2D) {
            Polar2D p2d = (Polar2D) obj;
            return (getDistance() == p2d.getDistance())
                    && (getTheta() == p2d.getTheta());
        }
        return super.equals(obj);
    }
}

- Gilbert Le Blanc

---

Gilbert，感谢您的回复并为您的努力和兴趣加一。虽然对于赏金，我正在寻找一个规范的答案，展示如何创建一个Graphics2D包装器类并使用它，正如OP链接中所描述的那样。 - Hovercraft Full Of Eels

Answer 2

一个 OO 设计原则是“组合优于继承”，这可以通过使用包装器类或者装饰者设计模式（我认为课程幻灯片中所指的就是包装器）来实现。因此，你所做的事情实际上是一种优雅的解决方案，有以下几个原因：

• 它保护了对 Graphics2D 实现的未来更改。如果你使用继承，并且不幸地在 Graphics2D 中添加了一个与你的新方法具有相同签名但返回类型不同的新方法，那么你的类将无法编译。如果你使用相同的签名和返回类型，你会覆盖 Graphics2D 中的新方法，这可能导致长达数天的痛苦调试。

• 以这种方式继承违反封装，使软件在长期运行中变得脆弱和容易出错。

• 使用组合，你可以保护你的类免受与之组合的类的未来更改的影响，你的类将把所有方法调用转发到它的私有 Graphics2D 实例并单独处理坐标转换。

• 它还允许轻松扩展，使用继承将限制你的类对当前 Graphics2D 实现的性能。

Java API 中存在这样的例子：Properties 类扩展了 HashTable，这说明了继承的不当使用，因为 Properties 不是 HashTable，不能以相同的方式使用。在这种情况下，对 Properties p.getProperty(key) 的调用可能会产生与 p.get(key) 不同的结果，因为后者没有考虑默认值。

装饰者设计模式：

public class Wrapper {
    private WrappedClass w;

    public Wrapper(WrappedClass w) {
       this.w = w;  
    }

    // Forward calls to WrappedClass methods to the private instance.
    public ReturnType example(Argument a) { return w.example(a); }

    // Add your methods here:
}

尽管这种方法可能看起来很繁琐，但出于上述原因，从长远来看是值得的。此外，Java API 中接口的存在，如上面的 HashSet 的 Set 接口，使编写此类更加容易，尽管我不知道是否存在 Graphics2D 的类似接口。

来源：《Effective Java 第二版》 - Joshua Bloch

- Adel Khial

---

+1并接受提供这种设计决策背后的逻辑推理。这绝对为在基本Graphics2D之上添加更多功能留下了空间。谢谢！ - elaid

Answer 3

一种选择是使用代理。它允许您包装Graphics2D的所有功能，而无需编写每个方法的代码。

GraphicsView接口声明了额外的功能：

import java.awt.Rectangle;

public interface GraphicsView {
    void setViewport(Rectangle r);
    Rectangle getViewport();
    boolean isViewportActive();
    void setViewportActive(boolean active);
}

Graphics2DWrapperFactory是Graphics2D + GraphicsView的代理：

import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Graphics2DWrapperFactory {
    public static Graphics2D wrapGraphics2D(final Graphics2D g) {
        GraphicsView gv = new GraphicsView() {
            // Implement new functionality here...
            private boolean active;
            Rectangle r;
            @Override
            public Rectangle getViewport() {
                System.err.println("getViewport called");
                return r;
            }
            @Override
            public void setViewport(Rectangle r) {
                this.r = r;
                System.err.println("setViewport called");
            }
            @Override
            public boolean isViewportActive() {
                System.err.println("isViewportActive called");
                return active;
            }
            @Override
            public void setViewportActive(boolean active) {
                this.active = active;
                System.err.println("setViewportActive called");
            }
        };
        InvocationHandler invocationHandler = new GraphicsWrapperInvocationHandler(g, gv);
        Class<?> interfaces[] = { Graphics2D.class, GraphicsView.class};
        return (Graphics2D) Proxy.newProxyInstance(g.getClass().getClassLoader(), interfaces, invocationHandler);
    }
    private static class GraphicsWrapperInvocationHandler implements InvocationHandler {
        private final GraphicsView gv;
        private final Graphics2D g2d;
        public GraphicsWrapperInvocationHandler(Graphics2D g, GraphicsView gv) {
            this.g2d = g;
            this.gv = gv;
        }
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            String methodName = method.getName();
            switch(methodName) {
                // If the is calling one of the GraphicsView methods, delegate to gv
                case "setViewport":
                case "getViewport":
                case "isViewportActive":
                case "setViewportActive":
                    return method.invoke(gv, args);
                // Otherwise, it's a Graphics2D methods. Delegate to g2d
                default:
                    return method.invoke(g2d, args);
            }
        }
    }
}

- Devon_C_Miller