Java 我的Mandelbrot套装没有'；不产生。什么'；我的方程式怎么了？ //生成器类 公共类生成器{ 双跳； 双粒度改性剂； int迭代速率，范围； 络合数c； 公共发电机（双跳）{ 这个.跳跃=跳跃； 这个.sizeModifier=40； 迭代率=10； 这个范围=100； c=新的复数（）； } 公共无效生成集（）{ DrawSet ds=新的DrawSet（）； int-ticker=0； 对于（双i=-2*范围；i

好，观察

• Generator

  不应创建

  DrawSet

• DrawSet

  不应创建

  graphicswindow

这些是这些类或方法的职责。这是代码的高度耦合并产生副作用

相反，

generate

应该传回它创建的点，然后以您想要的方式应用这些点，

Generator

不应该在意

因为我无法访问您的完整代码，所以我只是将一系列随机点拼凑在一起，以说明这一点

//Generator class
public class Generator {
double jump;
double sizeModifier;
int iterationRate,range;
ComplexNumber c;
public Generator(double jump) {
    this.jump=jump;
    this.sizeModifier=40;
    this.iterationRate=10;
    this.range=100;
    c=new ComplexNumber();
}
    public void generateSet(){
        DrawSet ds = new DrawSet();
        int ticker=0;
        for(double i=-2*range;i<=range;i+=jump){
            for(double j=-2*range;j<=range;j+=jump){
                c= new ComplexNumber((i/range),(j/range));
                double fz=c.square().mod()+c.mod();
                //System.out.println("c mod is: "+c.mod());
                //System.out.println("fz is: "+fz);
                if (fz < 2) {
                    for(int k=0;k<=iterationRate;k++) {
                        //System.out.println("nc:"+nc);
                        ticker++;
                        //System.out.println("ticker:"+ticker);
                        if(ticker==iterationRate) {
                            ds.addPoint(i + 450, j + 450);

                    }
                    if(fz>=2){
                        break;
                    }
                    else {
                        fz = Math.pow(fz, 2) + 1;
                    }
                }
            }
            ticker=0;
        }
    }
}
//Drawset class
public class DrawSet extends JPanel {
private ArrayList<Point> Points;
private ArrayList<Point> nPoints;


GraphicWindow gw;
public DrawSet(){
    this.Points=new ArrayList<>();
    this.nPoints=new ArrayList<>();
    gw = new GraphicWindow(1000,1000);
    gw.add(this);

}
public void addPoint(double x,double y){
    int ix=(int)x;
    int iy=(int)y;
    //int iwidth=(int)width*sizeModifier;
    //int iheight=(int)height*sizeModifier;
    Point a=new Point(ix,iy);
    Points.add(a);
    //System.out.println(Points.size());
}
public void paintComponent(Graphics g) {
        int pointSize = 1;
        super.paintComponents(g);
        System.out.println(Points.size());
        for (int i = 0; i < Points.size(); i++) {
            g.setColor(Color.BLACK);
            g.drawOval((int) Points.get(i).getX(), (int) Points.get(i).getY(), pointSize, pointSize);
        }
    }

导入java.awt.Color；
导入java.awt.Dimension；
导入java.awt.EventQueue；
导入java.awt.Graphics；
导入java.awt.Point；
导入java.util.ArrayList；
导入java.util.Random；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
公开课考试{
公共静态void main（字符串[]args）{
新测试（）；
}
公开考试（）{
invokeLater（新的Runnable（）{
@凌驾
公开募捐{
DrawSet DrawSet=新的DrawSet（）；
发电机=新发电机（100）；
drawSet.setPoints（generator.generateSet（））；
JFrame=新JFrame（）；
框架。添加（绘图集）；
frame.pack（）；
frame.setLocationRelativeTo（空）；
frame.setVisible（true）；
}
});
}
公共类DrawSet扩展了JPanel{
私有数组列表点；
私有数组列表nPoints；
公共绘图集（）{
this.points=new ArrayList（）；
this.nPoints=new ArrayList（）；
}
@凌驾
公共维度getPreferredSize（）{
返回新维度（500500）；
}
公共无效设置点（ArrayList点）{
这个点=点；
重新油漆（）；
}
//公共无效添加点（双x，双y）{
//int ix=（int）x；
//int iy=（int）y；
////int iwidth=（int）宽度*大小修改器；
////int iheight=（int）height*sizeModifier；
//点a=新点（ix，iy）；
//增加（a）点；
////System.out.println（Points.size（））；
//        }
@凌驾
受保护组件（图形g）{
int pointSize=5；
超级组件（g）；
对于（int i=0；i//为了（双i=-2*范围；i观察，
Generator
不应创建
DrawSet
的新实例，
DrawSet
不应创建
graphicswindow
的新实例，这会在代码中造成副作用。更好的解决方案是让
Generator
返回数据集to调用者，让他们在他们认为合适的时候应用-您的代码将紧密耦合并生成一系列意外的副作用谢谢您的回答，但是当我删除if（fz>=2）{break；}时，我的程序将有输出根据我的generateSet方法。在这种情况下，它输出一个圆，该圆是正确的，因为它是距离小于2的所有点的轨迹。我的问题是fz似乎永远不会保持在2的边界内。你想看我的完整代码吗？它没有那么多
import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Point;
import java.util.ArrayList;
import java.util.Random;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Test {

    public static void main(String[] args) {
        new Test();
    }

    public Test() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                DrawSet drawSet = new DrawSet();
                Generator generator = new Generator(100);
                drawSet.setPoints(generator.generateSet());

                JFrame frame = new JFrame();
                frame.add(drawSet);
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class DrawSet extends JPanel {

        private ArrayList<Point> points;
        private ArrayList<Point> nPoints;

        public DrawSet() {
            this.points = new ArrayList<>();
            this.nPoints = new ArrayList<>();
        }

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

        public void setPoints(ArrayList<Point> points) {
            this.points = points;
            repaint();
        }

//        public void addPoint(double x, double y) {
//            int ix = (int) x;
//            int iy = (int) y;
//            //int iwidth=(int)width*sizeModifier;
//            //int iheight=(int)height*sizeModifier;
//            Point a = new Point(ix, iy);
//            Points.add(a);
//            //System.out.println(Points.size());
//        }

        @Override
        protected void paintComponent(Graphics g) {
            int pointSize = 5;
            super.paintComponents(g);
            for (int i = 0; i < points.size(); i++) {
                g.setColor(Color.BLACK);
                g.drawOval((int) points.get(i).getX(), (int) points.get(i).getY(), pointSize, pointSize);
            }
        }
    }

    public class Generator {

        double jump;
        double sizeModifier;
        int iterationRate, range;
        //ComplexNumber c;

        public Generator(double jump) {
            this.jump = jump;
            this.sizeModifier = 40;
            this.iterationRate = 10;
            this.range = 100;
            //c = new ComplexNumber();
        }

        public ArrayList<Point> generateSet() {
            Random rnd = new Random();
            ArrayList<Point> points = new ArrayList<>(range);
            for (int index = 0; index < range; index++) {
                int x = (int)(490 * rnd.nextDouble());
                int  y = (int)(490 * rnd.nextDouble());
                points.add(new Point(x, y));
            }
            return points;

//            DrawSet ds = new DrawSet();
//            int ticker = 0;
//            for (double i = -2 * range; i <= range; i += jump) {
//                for (double j = -2 * range; j <= range; j += jump) {
//                    c = new ComplexNumber((i / range), (j / range));
//                    double fz = c.square().mod() + c.mod();
//                    //System.out.println("c mod is: "+c.mod());
//                    //System.out.println("fz is: "+fz);
//                    if (fz < 2) {
//                        for (int k = 0; k <= iterationRate; k++) {
//                            //System.out.println("nc:"+nc);
//                            ticker++;
//                            //System.out.println("ticker:"+ticker);
//                            if (ticker == iterationRate) {
//                                ds.addPoint(i + 450, j + 450);
//
//                            }
//                            if (fz >= 2) {
//                                break;
//                            } else {
//                                fz = Math.pow(fz, 2) + 1;
//                            }
//                        }
//                    }
//                    ticker = 0;
//                }
//            }
        }
    }
}