java - 如何使用递归重新创建图形？

Question

我有一个图形，它由规则间隔的不同大小的圆圈水平线组成。这是图片:

我正在尝试使用递归而不是代码中使用的 if 语句重新创建此图形，但尝试后，我不确定如何执行此操作。希望得到一些帮助，这是我的代码:

package weekFour;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;


import javax.swing.*;

@SuppressWarnings("serial")
public class Circle extends JPanel {
    private int circX  = 10;
    private static int windowW = 1700;
    private static int windowH = 1000;

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

        Graphics2D g2 = (Graphics2D) g;
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); //smoothes out edges

        Color c5 = new Color(50, 50, 50);
        Color c4 = new Color(100, 100, 100);
        Color c3 = new Color(150, 150, 150);
        Color c2 = new Color(200, 200, 200);
        Color c1= new Color(250, 250, 250);

        for (int i = 0; i < 1; i++) {
            g2.setColor(c1);
            g2.fillOval(522 + 75*i, 138, 666, 666);
            g2.setColor(c1);
            g2.drawOval(522 + 75*i, 138, 666, 666);
        }

        for (int i = 0; i < 3; i++) {
            g2.setColor(c2);
            g2.fillOval(244 + 522*i, 365, 180, 180);
            g2.setColor(c2);
            g2.drawOval(244 + 522*i, 365, 180, 180);
        }

        for (int i = 0; i < 10; i++) {
            g2.setColor(c3);
            g2.fillOval(130 + 174*i, 428, 60, 60);
            g2.setColor(c3);
            g2.drawOval(130 + 174*i, 428, 60, 60);
        }

        for (int i = 0; i < 25; i++) {
            g2.setColor(c4);
            g2.fillOval(60 + 87*i, 444, 25, 25);
            g2.setColor(c4);
            g2.drawOval(60 + 87*i, 444, 25, 25);
        }

        for (int i = 0; i < 120; i++) {
            g2.setColor(c5);
            g2.fillOval(circX + 29*i, 450, 12, 12);
            g2.setColor(c5);
            g2.drawOval(circX + 29*i, 450, 12, 12);
        }

    }   


    private static void createAndShowGui() { 
        JFrame frame = new JFrame("MyTaskToo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().add(new Circle());
        frame.setSize(windowW, windowH);
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGui();
            }
        });
    }
}

感谢您的宝贵时间。

Answer 1

这就是我解决这个问题的方法，虽然我们必须使用绿色圆圈而不是灰色圆圈来解决这个问题，但其实并没有那么不同。

注意:对于有时为一些琐碎的事情提出的吸引人的评论感到抱歉，但我们的评论会得到分数，安全总比抱歉好。也许它们会改变你对思维过程的一些洞察。

这里是启动程序并设置窗口信息的主要方法。

public class Q2Main {

public static void main(String[] args) {
    // here we are just setting out the window end putting the circles drawin in Q2Circles into this window.
    JFrame window = new JFrame();
    window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    window.setSize(1000, 500);
    window.getContentPane().add(new Q2Circles(5));
    window.setVisible(true);
}}

这就是奇迹发生的地方:

public class Q2Circles extends JPanel {

    // this allows the user to specify how many loops of recursion they want the programme to complete before finishing
    int recursionsToDo;

    public Q2Circles(int recursionMax){
        super();
        recursionsToDo = recursionMax;
    }

    /*
        this method is automatically called when we run the constructor as it inherits from the JFram superclass. here
        we are setting out the size of the circle by getting the size of the window to make it proportional to the rest
        of the screen and circles.
        we then pass these values into the drawCircle method to draw the circle
     */
    public void paintComponent(Graphics g){
        Rectangle rectangle = this.getBounds();
        int diameter = rectangle.width/3;
        int centerPoint = rectangle.width/2;

        drawCircle(g, 1, centerPoint, diameter);

    }

    /*
        This method is where the magic of the programme really takes place. first of all we make sure we haven't completed
        the necessary recursions. we the set the color by dividing it by the amount of times we have recursed, this will
        have the affect of getting darker the more times the method recurses. we then sset the color. finaly we fill the
        oval (draw the circle). because we want to move depending on the times it has recursed and size of the previous
        we do it based on the size of the elements from the previous call to this method. Getting the right numbers
        though was just alot of trial and error.

        we then increment the recursion counter so that we know how many times we have recursed and that can then be
        used at different points where needed. e.g for setting the color.

        each recursive call used the dimension of the other recursive calls to make the whole picture. Although the
        first recursive call creates the circles on the right of the screen. the second call draws the circle on the
        left of the screen and the last one does the circles in the middle, they all use eachothers values to make it
        complete. without one recursive step, more is missing than just what is created by that recursive call on its own.

        in all honesty though, there is alot of duplication, like the large middlecircle.


     */
    public void drawCircle(Graphics g, int amountOfRecursions, int center, int diameter){
        if (amountOfRecursions <= recursionsToDo){
            int recursionsCount = amountOfRecursions;

            int greenColor = Math.round(225 / (amountOfRecursions));
            g.setColor(new Color(0,  greenColor, 0));
            g.fillOval(center - (diameter/2), 200 - (diameter/2), diameter, diameter);

            recursionsCount++;

            drawCircle(g, recursionsCount, Math.round(center + diameter), diameter/3);
            drawCircle(g, recursionsCount, Math.round(center - diameter), diameter/3);
            drawCircle(g, recursionsCount, Math.round(center), diameter/3);

        }
    }}