Hi,everyone Im new to JAVA and not sure how does recursion work in JAVA
I have to use JAVA Turtle to draw snowflake
here is the pseudocode.

procedure snowflakePart( S, N ) :
if N is greater than 0:
move turtle forward S units
if N is greater than 1:
# generate the 5 sub-branches of this snowflake part
turn turtle left 120 degrees
loop 5 times:
call snowflakePart( S/3, N-1 )
turn turtle right 60 degrees
turn turtle right 180 degrees
move turtle backward S units

procedure drawSnowflake( S, N ) :
loop 6 times:
call snowflakePart( S, N )
turn turtle left 60 degrees

``````public static void main(String[] args){
double x0 = 10;
double y0 = 10.0;
double a0 = 0.0;
Turtle turtle  = new Turtle(x0, y0, a0);
double S;
double N;
Scanner sc= new Scanner(System.in);
System.out.print("Enter S: ");
S=sc.nextInt();
Scanner bc= new Scanner(System.in);
System.out.print("Enter N: ");
N=bc.nextInt();
snowflake(S,N,turtle);
}

public static void snowflake(double S, double N,Turtle turtle){
if (N>0){
turtle.goForward(S);
if(N>1){
turtle.turnLeft(120);
for (int g=1; g<=5; g++){
snowflake(S/3,N-1,turtle);
turtle.turnRight(60);
}
turtle.turnRight(180);
}
}
drawSnowflake(S, N,turtle);
}
public static void drawSnowflake(double S, double N,Turtle turtle){

for(int h=1; h<=6; h++){
snowflake(S, N,turtle);
turtle.turnLeft(60);
}

}``````

This is what I have so far. I also tried the pseudocode in python. I got it works fine.

here are the errors in JAVA.
at Turtle.drawSnowflake(Turtle.java:166)
at Turtle.snowflake(Turtle.java:161)
at Turtle.drawSnowflake(Turtle.java:166)
at Turtle.snowflake(Turtle.java:161)
at Turtle.drawSnowflake(Turtle.java:166)

Thanks.

When you get a Java error it comes with a complete description and a stack of line numbers. Please post the full details of your error(s). Also post the full source code - you post identifies the error as being on lines 161/166, but the code you posted only goes …

I don't have time right now to check all your code, but it looks to me like your main should call drawSnowflake (passing N ans S as parameters), and drawSnowflake should call snowflakePart ( AKA snowflake ), but not vice-versa.

## All 8 Replies

When you get a Java error it comes with a complete description and a stack of line numbers. Please post the full details of your error(s). Also post the full source code - you post identifies the error as being on lines 161/166, but the code you posted only goes to line 39!
However, I did notice that your Java snowflake method calls drawSnowflake at the end, which is not in the pseudocode.
You also renamed snowflakePart to snowflake - makes no difference to the compiler, but may reveal something about how you are thinking of it, eg you call snowflake from main, but maybe that should be drawSnowflake?

However, I did notice that your Java snowflake method calls drawSnowflake at the end, which is not in the pseudocode.

I think this is one way to pass the parameters to another function.I don't know how to pass the S and N to drawsnowflakes. and that is the method I googled

You also renamed snowflakePart to snowflake - makes no difference to the compiler, but may reveal something about how you are thinking of it, eg you call snowflake from main, but maybe that should be drawSnowflake?

again, I don't mean to call the function in main. I tried to pass S and N from main to snowflake function

``````/*************************************************************************
*  Compilation:  javac StdDraw.java
*  Execution:    java StdDraw
*
*  Standard drawing library. This class provides a basic capability for
*  creating drawings with your programs. It uses a simple graphics model that
*  allows you to create drawings consisting of points, lines, and curves
*  in a window on your computer and to save the drawings to a file.
*
*  Todo
*  ----
*
*  Remarks
*  -------
*    -  don't use AffineTransform for rescaling since it inverts
*       images and strings
*    -  careful using setFont in inner loop within an animation -
*       it can cause flicker
*
*       Copyright 2007, Robert Sedgewick and Kevin Wayne.
*
*  Versions:
*  	\$Id\$
*
*  Revisions:
*  	\$Log\$
*
*************************************************************************/

import java.io.*;
import java.net.*;
import java.awt.*;
import java.awt.geom.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.swing.*;
import javax.imageio.ImageIO;

/**
*  <i>Standard draw</i>. This class provides a basic capability for
*  creating drawings with your programs. It uses a simple graphics model that
*  allows you to create drawings consisting of points, lines, and curves
*  in a window on your computer and to save the drawings to a file.
*  <p>
*  For additional documentation, see <a href="http://www.cs.princeton.edu/introcs/15inout">Section 1.5</a> of
*  <i>Introduction to Programming in Java: An Interdisciplinary Approach</i> by Robert Sedgewick and Kevin Wayne.
*/
public final class StdDraw implements ActionListener, MouseListener, MouseMotionListener, KeyListener {

// pre-defined colors
public static final Color BLACK      = Color.BLACK;
public static final Color BLUE       = Color.BLUE;
public static final Color CYAN       = Color.CYAN;
public static final Color DARK_GRAY  = Color.DARK_GRAY;
public static final Color GRAY       = Color.GRAY;
public static final Color GREEN      = Color.GREEN;
public static final Color LIGHT_GRAY = Color.LIGHT_GRAY;
public static final Color MAGENTA    = Color.MAGENTA;
public static final Color ORANGE     = Color.ORANGE;
public static final Color PINK       = Color.PINK;
public static final Color RED        = Color.RED;
public static final Color WHITE      = Color.WHITE;
public static final Color YELLOW     = Color.YELLOW;
public static final Color BOOK_BLUE  = new Color(9, 90, 166);   // Intro to Programming
public static final Color BOOK_RED   = new Color(173, 32, 24);  // Algorithms 4

// default colors
private static final Color DEFAULT_PEN_COLOR   = BLACK;
private static final Color DEFAULT_CLEAR_COLOR = WHITE;

// current pen color
private static Color penColor;

// default canvas size is SIZE-by-SIZE
private static final int DEFAULT_SIZE = 512;
private static int width  = DEFAULT_SIZE;
private static int height = DEFAULT_SIZE;

private static final double DEFAULT_PEN_RADIUS = 0.002;

// show we draw immediately or wait until next show?
private static boolean defer = false;

// boundary of drawing canvas, 5% border
private static final double BORDER = 0.05;
private static final double DEFAULT_XMIN = 0.0;
private static final double DEFAULT_XMAX = 1.0;
private static final double DEFAULT_YMIN = 0.0;
private static final double DEFAULT_YMAX = 1.0;
private static double xmin, ymin, xmax, ymax;

// for synchronization
private static Object mouseLock = new Object();
private static Object keyLock = new Object();

// default font
private static final Font DEFAULT_FONT = new Font("SansSerif", Font.PLAIN, 16);

// current font
private static Font font;

// double buffered graphics
private static BufferedImage offscreenImage, onscreenImage;
private static Graphics2D offscreen, onscreen;

// singleton for callbacks: avoids generation of extra .class files
private static StdDraw std = new StdDraw();

// the frame for drawing to the screen
private static JFrame frame;

// mouse state
private static boolean mousePressed = false;
private static double mouseX = 0;
private static double mouseY = 0;

// keyboard state

// not instantiable
private StdDraw() { }

// static initializer
static { init(); }

/**
* Set the window size to w-by-h pixels.
*
* @param w the width as a number of pixels
* @param h the height as a number of pixels
* @throws a RunTimeException if the width or height is 0 or negative
*/
public static void setCanvasSize(int w, int h) {
if (w < 1 || h < 1) throw new RuntimeException("width and height must be positive");
width = w;
height = h;
init();
}

// init
private static void init() {
if (frame != null) frame.setVisible(false);
frame = new JFrame();
offscreenImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
onscreenImage  = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
offscreen = offscreenImage.createGraphics();
onscreen  = onscreenImage.createGraphics();
setXscale();
setYscale();
offscreen.setColor(DEFAULT_CLEAR_COLOR);
offscreen.fillRect(0, 0, width, height);
setPenColor();
setFont();
clear();

RenderingHints hints = new RenderingHints(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
hints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);

// frame stuff
ImageIcon icon = new ImageIcon(onscreenImage);
JLabel draw = new JLabel(icon);

frame.setContentPane(draw);
frame.addKeyListener(std);    // JLabel cannot get keyboard focus
frame.setResizable(false);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);            // closes all windows
// frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);      // closes only current window
frame.setTitle("Standard Draw");
frame.pack();
frame.requestFocusInWindow();
frame.setVisible(true);
}

// create the menu bar (changed to private)
}

/*************************************************************************
*  User and screen coordinate systems
*************************************************************************/

/**
* Set the window title.
*
* @param title The window title.
*/
public static void setTitle(String title) { frame.setTitle(title); }

/**
* Set the x-scale to be the default (between 0.0 and 1.0).
*/
public static void setXscale() { setXscale(DEFAULT_XMIN, DEFAULT_XMAX); }

/**
* Set the y-scale to be the default (between 0.0 and 1.0).
*/
public static void setYscale() { setYscale(DEFAULT_YMIN, DEFAULT_YMAX); }

/**
* Set the x-scale (a 10% border is added to the values)
* @param min the minimum value of the x-scale
* @param max the maximum value of the x-scale
*/
public static void setXscale(double min, double max) {
double size = max - min;
xmin = min - BORDER * size;
xmax = max + BORDER * size;
}

/**
* Set the y-scale (a 10% border is added to the values).
* @param min the minimum value of the y-scale
* @param max the maximum value of the y-scale
*/
public static void setYscale(double min, double max) {
double size = max - min;
ymin = min - BORDER * size;
ymax = max + BORDER * size;
}

// helper functions that scale from user coordinates to screen coordinates and back
private static double  scaleX(double x) { return width  * (x - xmin) / (xmax - xmin); }
private static double  scaleY(double y) { return height * (ymax - y) / (ymax - ymin); }
private static double factorX(double w) { return w * width  / Math.abs(xmax - xmin);  }
private static double factorY(double h) { return h * height / Math.abs(ymax - ymin);  }
private static double   userX(double x) { return xmin + x * (xmax - xmin) / width;    }
private static double   userY(double y) { return ymax - y * (ymax - ymin) / height;   }

/**
* Clear the screen to the default color (white).
*/
public static void clear() { clear(DEFAULT_CLEAR_COLOR); }
/**
* Clear the screen to the given color.
* @param color the Color to make the background
*/
public static void clear(Color color) {
offscreen.setColor(color);
offscreen.fillRect(0, 0, width, height);
offscreen.setColor(penColor);
draw();
}

/**
* Set the pen size to the default (.002).
*/
/**
* Set the radius of the pen to the given size.
* @param r the radius of the pen
* @throws RuntimeException if r is negative
*/
public static void setPenRadius(double r) {
if (r < 0) throw new RuntimeException("pen radius must be positive");
// BasicStroke stroke = new BasicStroke((float) penRadius, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND);
BasicStroke stroke = new BasicStroke((float) penRadius);
offscreen.setStroke(stroke);
}

/**
* Set the pen color to the default color (black).
*/
public static void setPenColor() { setPenColor(DEFAULT_PEN_COLOR); }
/**
* Set the pen color to the given color. The available pen colors are
* BLACK, BLUE, CYAN, DARK_GRAY, GRAY, GREEN, LIGHT_GRAY, MAGENTA,
* ORANGE, PINK, RED, WHITE, and YELLOW.
* @param color the Color to make the pen
*/
public static void setPenColor(Color color) {
penColor = color;
offscreen.setColor(penColor);
}

/**
* Set the font to the default font (sans serif, 16 point).
*/
public static void setFont() { setFont(DEFAULT_FONT); }

/**
* Set the font to the given value.
* @param f the font to make text
*/
public static void setFont(Font f) { font = f; }

/*************************************************************************
*  Drawing geometric shapes.
*************************************************************************/

/**
* Draw a line from (x0, y0) to (x1, y1).
* @param x0 the x-coordinate of the starting point
* @param y0 the y-coordinate of the starting point
* @param x1 the x-coordinate of the destination point
* @param y1 the y-coordinate of the destination point
*/
public static void line(double x0, double y0, double x1, double y1) {
offscreen.draw(new Line2D.Double(scaleX(x0), scaleY(y0), scaleX(x1), scaleY(y1)));
draw();
}

/**
* Draw one pixel at (x, y).
* @param x the x-coordinate of the pixel
* @param y the y-coordinate of the pixel
*/
private static void pixel(double x, double y) {
offscreen.fillRect((int) Math.round(scaleX(x)), (int) Math.round(scaleY(y)), 1, 1);
}

/**
* Draw a point at (x, y).
* @param x the x-coordinate of the point
* @param y the y-coordinate of the point
*/
public static void point(double x, double y) {
double xs = scaleX(x);
double ys = scaleY(y);
// double ws = factorX(2*r);
// double hs = factorY(2*r);
// if (ws <= 1 && hs <= 1) pixel(x, y);
if (r <= 1) pixel(x, y);
else offscreen.fill(new Ellipse2D.Double(xs - r/2, ys - r/2, r, r));
draw();
}

/**
* Draw a circle of radius r, centered on (x, y).
* @param x the x-coordinate of the center of the circle
* @param y the y-coordinate of the center of the circle
* @param r the radius of the circle
* @throws RuntimeException if the radius of the circle is negative
*/
public static void circle(double x, double y, double r) {
if (r < 0) throw new RuntimeException("circle radius can't be negative");
double xs = scaleX(x);
double ys = scaleY(y);
double ws = factorX(2*r);
double hs = factorY(2*r);
if (ws <= 1 && hs <= 1) pixel(x, y);
else offscreen.draw(new Ellipse2D.Double(xs - ws/2, ys - hs/2, ws, hs));
draw();
}

/**
* Draw filled circle of radius r, centered on (x, y).
* @param x the x-coordinate of the center of the circle
* @param y the y-coordinate of the center of the circle
* @param r the radius of the circle
* @throws RuntimeException if the radius of the circle is negative
*/
public static void filledCircle(double x, double y, double r) {
if (r < 0) throw new RuntimeException("circle radius can't be negative");
double xs = scaleX(x);
double ys = scaleY(y);
double ws = factorX(2*r);
double hs = factorY(2*r);
if (ws <= 1 && hs <= 1) pixel(x, y);
else offscreen.fill(new Ellipse2D.Double(xs - ws/2, ys - hs/2, ws, hs));
draw();
}

/**
* Draw an arc of radius r, centered on (x, y), from angle1 to angle2 (in degrees).
* @param x the x-coordinate of the center of the circle
* @param y the y-coordinate of the center of the circle
* @param r the radius of the circle
* @param angle1 the starting angle. 0 would mean an arc beginning at 3 o'clock.
* @param angle2 the angle at the end of the arc. For example, if
*        you want a 90 degree arc, then angle2 should be angle1 + 90.
* @throws RuntimeException if the radius of the circle is negative
*/
public static void arc(double x, double y, double r, double angle1, double angle2) {
if (r < 0) throw new RuntimeException("arc radius can't be negative");
while (angle2 < angle1) angle2 += 360;
double xs = scaleX(x);
double ys = scaleY(y);
double ws = factorX(2*r);
double hs = factorY(2*r);
if (ws <= 1 && hs <= 1) pixel(x, y);
else offscreen.draw(new Arc2D.Double(xs - ws/2, ys - hs/2, ws, hs, angle1, angle2 - angle1, Arc2D.OPEN));
draw();
}

/**
* Draw a square of side length 2r, centered on (x, y).
* @param x the x-coordinate of the center of the square
* @param y the y-coordinate of the center of the square
* @param r radius is half the length of any side of the square
* @throws RuntimeException if r is negative
*/
public static void square(double x, double y, double r) {
if (r < 0) throw new RuntimeException("square side length can't be negative");
double xs = scaleX(x);
double ys = scaleY(y);
double ws = factorX(2*r);
double hs = factorY(2*r);
if (ws <= 1 && hs <= 1) pixel(x, y);
else offscreen.draw(new Rectangle2D.Double(xs - ws/2, ys - hs/2, ws, hs));
draw();
}

/**
* Draw a filled square of side length 2r, centered on (x, y).
* @param x the x-coordinate of the center of the square
* @param y the y-coordinate of the center of the square
* @param r radius is half the length of any side of the square
* @throws RuntimeException if r is negative
*/
public static void filledSquare(double x, double y, double r) {
if (r < 0) throw new RuntimeException("square side length can't be negative");
double xs = scaleX(x);
double ys = scaleY(y);
double ws = factorX(2*r);
double hs = factorY(2*r);
if (ws <= 1 && hs <= 1) pixel(x, y);
else offscreen.fill(new Rectangle2D.Double(xs - ws/2, ys - hs/2, ws, hs));
draw();
}

/**
* Draw a polygon with the given (x[i], y[i]) coordinates.
* @param x an array of all the x-coordindates of the polygon
* @param y an array of all the y-coordindates of the polygon
*/
public static void polygon(double[] x, double[] y) {
int N = x.length;
GeneralPath path = new GeneralPath();
path.moveTo((float) scaleX(x), (float) scaleY(y));
for (int i = 0; i < N; i++)
path.lineTo((float) scaleX(x[i]), (float) scaleY(y[i]));
path.closePath();
offscreen.draw(path);
draw();
}

/**
* Draw a filled polygon with the given (x[i], y[i]) coordinates.
* @param x an array of all the x-coordindates of the polygon
* @param y an array of all the y-coordindates of the polygon
*/
public static void filledPolygon(double[] x, double[] y) {
int N = x.length;
GeneralPath path = new GeneralPath();
path.moveTo((float) scaleX(x), (float) scaleY(y));
for (int i = 0; i < N; i++)
path.lineTo((float) scaleX(x[i]), (float) scaleY(y[i]));
path.closePath();
offscreen.fill(path);
draw();
}

/*************************************************************************
*  Drawing images.
*************************************************************************/

// get an image from the given filename
private static Image getImage(String filename) {

ImageIcon icon = new ImageIcon(filename);

// try to read from URL
if ((icon == null) || (icon.getImageLoadStatus() != MediaTracker.COMPLETE)) {
try {
URL url = new URL(filename);
icon = new ImageIcon(url);
} catch (Exception e) { /* not a url */ }
}

// in case file is inside a .jar
if ((icon == null) || (icon.getImageLoadStatus() != MediaTracker.COMPLETE)) {
URL url = StdDraw.class.getResource(filename);
if (url == null) throw new RuntimeException("image " + filename + " not found");
icon = new ImageIcon(url);
}

return icon.getImage();
}

/**
* Draw picture (gif, jpg, or png) centered on (x, y).
* @param x the center x-coordinate of the image
* @param y the center y-coordinate of the image
* @param s the name of the image/picture, e.g., "ball.gif"
* @throws RuntimeException if the image is corrupt
*/
public static void picture(double x, double y, String s) {
Image image = getImage(s);
double xs = scaleX(x);
double ys = scaleY(y);
int ws = image.getWidth(null);
int hs = image.getHeight(null);
if (ws < 0 || hs < 0) throw new RuntimeException("image " + s + " is corrupt");

offscreen.drawImage(image, (int) Math.round(xs - ws/2.0), (int) Math.round(ys - hs/2.0), null);
draw();
}

/**
* Draw picture (gif, jpg, or png) centered on (x, y),
* rotated given number of degrees
* @param x the center x-coordinate of the image
* @param y the center y-coordinate of the image
* @param s the name of the image/picture, e.g., "ball.gif"
* @param degrees is the number of degrees to rotate counterclockwise
* @throws RuntimeException if the image is corrupt
*/
public static void picture(double x, double y, String s, double degrees) {
Image image = getImage(s);
double xs = scaleX(x);
double ys = scaleY(y);
int ws = image.getWidth(null);
int hs = image.getHeight(null);
if (ws < 0 || hs < 0) throw new RuntimeException("image " + s + " is corrupt");

offscreen.drawImage(image, (int) Math.round(xs - ws/2.0), (int) Math.round(ys - hs/2.0), null);

draw();
}

/**
* Draw picture (gif, jpg, or png) centered on (x, y), rescaled to w-by-h.
* @param x the center x coordinate of the image
* @param y the center y coordinate of the image
* @param s the name of the image/picture, e.g., "ball.gif"
* @param w the width of the image
* @param h the height of the image
* @throws RuntimeException if the width height are negative
* @throws RuntimeException if the image is corrupt
*/
public static void picture(double x, double y, String s, double w, double h) {
Image image = getImage(s);
double xs = scaleX(x);
double ys = scaleY(y);
if (w < 0) throw new RuntimeException("width is negative: " + w);
if (h < 0) throw new RuntimeException("height is negative: " + h);
double ws = factorX(w);
double hs = factorY(h);
if (ws < 0 || hs < 0) throw new RuntimeException("image " + s + " is corrupt");
if (ws <= 1 && hs <= 1) pixel(x, y);
else {
offscreen.drawImage(image, (int) Math.round(xs - ws/2.0),
(int) Math.round(ys - hs/2.0),
(int) Math.round(ws),
(int) Math.round(hs), null);
}
draw();
}

/**
* Draw picture (gif, jpg, or png) centered on (x, y), rotated
* given number of degrees, rescaled to w-by-h.
* @param x the center x-coordinate of the image
* @param y the center y-coordinate of the image
* @param s the name of the image/picture, e.g., "ball.gif"
* @param w the width of the image
* @param h the height of the image
* @param degrees is the number of degrees to rotate counterclockwise
* @throws RuntimeException if the image is corrupt
*/
public static void picture(double x, double y, String s, double w, double h, double degrees) {
Image image = getImage(s);
double xs = scaleX(x);
double ys = scaleY(y);
double ws = factorX(w);
double hs = factorY(h);
if (ws < 0 || hs < 0) throw new RuntimeException("image " + s + " is corrupt");
if (ws <= 1 && hs <= 1) pixel(x, y);

offscreen.drawImage(image, (int) Math.round(xs - ws/2.0),
(int) Math.round(ys - hs/2.0),
(int) Math.round(ws),
(int) Math.round(hs), null);

draw();
}

/*************************************************************************
*  Drawing text.
*************************************************************************/

/**
* Write the given text string in the current font, centered on (x, y).
* @param x the center x-coordinate of the text
* @param y the center y-coordinate of the text
* @param s the text
*/
public static void text(double x, double y, String s) {
offscreen.setFont(font);
FontMetrics metrics = offscreen.getFontMetrics();
double xs = scaleX(x);
double ys = scaleY(y);
int ws = metrics.stringWidth(s);
int hs = metrics.getDescent();
offscreen.drawString(s, (float) (xs - ws/2.0), (float) (ys + hs));
draw();
}

/**
* Write the given text string in the current font, left-aligned at (x, y).
* @param x the x-coordinate of the text
* @param y the y-coordinate of the text
* @param s the text
*/
public static void textLeft(double x, double y, String s) {
offscreen.setFont(font);
FontMetrics metrics = offscreen.getFontMetrics();
double xs = scaleX(x);
double ys = scaleY(y);
//int ws = metrics.stringWidth(s);
int hs = metrics.getDescent();
offscreen.drawString(s, (float) (xs), (float) (ys + hs));
show();
}

/**
* Write the given text string in the current font, right-aligned at (x, y).
* @param x the x-coordinate of the text
* @param y the y-coordinate of the text
* @param s the text
*/
public static void textRight(double x, double y, String s) {
offscreen.setFont(font);
FontMetrics metrics = offscreen.getFontMetrics();
double xs = scaleX(x);
double ys = scaleY(y);
int ws = metrics.stringWidth(s);
int hs = metrics.getDescent();
offscreen.drawString(s, (float) (xs - ws), (float) (ys + hs));
show();
}

/**
* Display on screen, pause for t milliseconds, and turn on
* <em>animation mode</em>: subsequent calls to
* drawing methods such as <tt>line()</tt>, <tt>circle()</tt>, and <tt>square()</tt>
* will not be displayed on screen until the next call to <tt>show()</tt>.
* This is useful for producing animations (clear the screen, draw a bunch of shapes,
* display on screen for a fixed amount of time, and repeat). It also speeds up
* drawing a huge number of shapes (call <tt>show(0)</tt> to defer drawing
* on screen, draw the shapes, and call <tt>show(0)</tt> to display them all
* on screen at once).
* @param t number of milliseconds
*/
public static void show(int t) {
defer = false;
draw();
catch (InterruptedException e) { System.out.println("Error sleeping"); }
defer = true;
}

/**
* Display on-screen and turn off animation mode:
* subsequent calls to
* drawing methods such as <tt>line()</tt>, <tt>circle()</tt>, and <tt>square()</tt>
* will be displayed on screen when called. This is the default.
*/
public static void show() {
defer = false;
draw();
}

// draw onscreen if defer is false
private static void draw() {
if (defer) return;
onscreen.drawImage(offscreenImage, 0, 0, null);
frame.repaint();
}

/*************************************************************************
*  Save drawing to a file.
*************************************************************************/

/**
* Save to file - suffix must be png, jpg, or gif.
* @param filename the name of the file with one of the required suffixes
*/
public static void save(String filename) {
File file = new File(filename);
String suffix = filename.substring(filename.lastIndexOf('.') + 1);

// png files
if (suffix.toLowerCase().equals("png")) {
try { ImageIO.write(offscreenImage, suffix, file); }
catch (IOException e) { e.printStackTrace(); }
}

// need to change from ARGB to RGB for jpeg
// reference: http://archives.java.sun.com/cgi-bin/wa?A2=ind0404&L=java2d-interest&D=0&P=2727
else if (suffix.toLowerCase().equals("jpg")) {
WritableRaster raster = offscreenImage.getRaster();
WritableRaster newRaster;
newRaster = raster.createWritableChild(0, 0, width, height, 0, 0, new int[] {0, 1, 2});
DirectColorModel cm = (DirectColorModel) offscreenImage.getColorModel();
DirectColorModel newCM = new DirectColorModel(cm.getPixelSize(),
BufferedImage rgbBuffer = new BufferedImage(newCM, newRaster, false,  null);
try { ImageIO.write(rgbBuffer, suffix, file); }
catch (IOException e) { e.printStackTrace(); }
}

else {
System.out.println("Invalid image file type: " + suffix);
}
}

/**
* This method cannot be called directly.
*/
public void actionPerformed(ActionEvent e) {
FileDialog chooser = new FileDialog(StdDraw.frame, "Use a .png or .jpg extension", FileDialog.SAVE);
chooser.setVisible(true);
String filename = chooser.getFile();
if (filename != null) {
StdDraw.save(chooser.getDirectory() + File.separator + chooser.getFile());
}
}

/*************************************************************************
*  Mouse interactions.
*************************************************************************/

/**
* Is the mouse being pressed?
* @return true or false
*/
public static boolean mousePressed() {
synchronized (mouseLock) {
return mousePressed;
}
}

/**
* What is the x-coordinate of the mouse?
* @return the value of the x-coordinate of the mouse
*/
public static double mouseX() {
synchronized (mouseLock) {
return mouseX;
}
}

/**
* What is the y-coordinate of the mouse?
* @return the value of the y-coordinate of the mouse
*/
public static double mouseY() {
synchronized (mouseLock) {
return mouseY;
}
}

/**
* This method cannot be called directly.
*/
public void mouseClicked(MouseEvent e) { }

/**
* This method cannot be called directly.
*/
public void mouseEntered(MouseEvent e) { }

/**
* This method cannot be called directly.
*/
public void mouseExited(MouseEvent e) { }

/**
* This method cannot be called directly.
*/
public void mousePressed(MouseEvent e) {
synchronized (mouseLock) {
mouseX = StdDraw.userX(e.getX());
mouseY = StdDraw.userY(e.getY());
mousePressed = true;
}
}

/**
* This method cannot be called directly.
*/
public void mouseReleased(MouseEvent e) {
synchronized (mouseLock) {
mousePressed = false;
}
}

/**
* This method cannot be called directly.
*/
public void mouseDragged(MouseEvent e)  {
synchronized (mouseLock) {
mouseX = StdDraw.userX(e.getX());
mouseY = StdDraw.userY(e.getY());
}
}

/**
* This method cannot be called directly.
*/
public void mouseMoved(MouseEvent e) {
synchronized (mouseLock) {
mouseX = StdDraw.userX(e.getX());
mouseY = StdDraw.userY(e.getY());
}
}

/*************************************************************************
*  Keyboard interactions.
*************************************************************************/

/**
* Has the user typed a key?
* @return true if the user has typed a key, false otherwise
*/
public static boolean hasNextKeyTyped() {
synchronized (keyLock) {
return !keysTyped.isEmpty();
}
}

/**
* What is the next key that was typed by the user?
* @return the next key typed
*/
public static char nextKeyTyped() {
synchronized (keyLock) {
return keysTyped.removeLast();
}
}

/**
* This method cannot be called directly.
*/
public void keyTyped(KeyEvent e) {
synchronized (keyLock) {
}
}

/**
* This method cannot be called directly.
*/
public void keyPressed(KeyEvent e) { }

/**
* This method cannot be called directly.
*/
public void keyReleased(KeyEvent e) { }

/**
* Test client.
*/
public static void main(String[] args) {
StdDraw.square(.2, .8, .1);
StdDraw.filledSquare(.8, .8, .2);
StdDraw.circle(.8, .2, .2);

StdDraw.setPenColor(StdDraw.MAGENTA);
StdDraw.arc(.8, .2, .1, 200, 45);

// draw a blue diamond
StdDraw.setPenColor(StdDraw.BLUE);
double[] x = { .1, .2, .3, .2 };
double[] y = { .2, .3, .2, .1 };
StdDraw.filledPolygon(x, y);

// text
StdDraw.setPenColor(StdDraw.BLACK);
StdDraw.text(0.2, 0.5, "black text");
StdDraw.setPenColor(StdDraw.WHITE);
StdDraw.text(0.8, 0.8, "white text");
}

}

Generated by GNU enscript 1.6.3.
[U][/U]``````
``````/*************************************************************************
*  Compilation:  javac Turtle.java
*  Execution:    java Turtle
*
*  Data type for turtle graphics using standard draw.
*
*  Copyright 2007, Robert Sedgewick and Kevin Wayne.
*
*  Version:
*  	\$Id\$
*
*  Revisions:
*  	\$Log\$
*
*************************************************************************/

import java.awt.Color;

/**
* A turtle graphics library built on StdDraw.
*
* @author Robert Sedgewick, Kevin Wayne
*/
public class Turtle {
private double x, y;     // turtle is at (x, y)
private double angle;    // facing this many degrees counterclockwise from the x-axis

/**
* Construct the Turtle object.
*
* @param x0 The starting x-coordinate for the turtle.
* @param y0 The starting y-coordinate for the turtle.
* @param a0 The degrees facing counterclockwise from the x-axis
*/
public Turtle(double x0, double y0, double a0) {
x = x0;
y = y0;
angle = a0;
}

/**
* Set the user-defined coordinate system.
*
* @param x0 The x-coordinate of the lower left corner of canvas.
* @param y0 The y-coordinate of the lower left corner of canvas.
* @param x1 The x-coordinate of the upper right corner of canvas.
* @param y1 The y-coordinate of the upper right corner of canvas.
*/
public void setWorldCoordinates(double x0, double y0, double x1, double y1) {
StdDraw.setXscale(x0, x1);
StdDraw.setYscale(y0, y1);
}

/**
* Turn the turtle left.
*
* @param delta The rotate orientation delta in degrees counterclockwise.
*/
public void turnLeft(double delta) {
angle += delta;
}

/**
* Turn the turtle right.
*
* @param delta The rotate orientation delta in degrees clockwise.
*/
public void turnRight(double delta) {
angle -= delta;
}

/**
* Move the turtle forward.
*
* @param step The amount to move forward with the pen down.
*/
public void goForward(double step) {
double oldx = x;
double oldy = y;
StdDraw.line(oldx, oldy, x, y);
}

/**
* Pause the turtle from drawing.
*
* @param t The amount in milliseconds to pause the turtle.
*/
public void pause(int t) {
StdDraw.show(t);
}

/**
* Set the turtle's pen color.
*
* @param color The pen color.
*/
public void setPenColor(Color color) {
StdDraw.setPenColor(color);
}

/**
* Set the thickness of the turtle's pen.
*
* @param radius The dot thickness.
*/
}

/**
* Set the canvas size.
*
* @param width The canvas width.
* @param height The canvas height.
*/
public void setCanvasSize(int width, int height) {
StdDraw.setCanvasSize(width, height);
}

/**
* Set the canvas title.
*
* @param title The canvas title.
*/
public void setCanvasTitle(String title) {
StdDraw.setTitle(title);
}

// sample client for testing
public static void main(String[] args) {
double x0 = 0.5;
double y0 = 0.0;
double a0 = 60.0;
double step = Math.sqrt(3)/2;
Turtle turtle  = new Turtle(x0, y0, a0);
turtle.goForward(step);
turtle.turnLeft(120.0);
turtle.goForward(step);
turtle.turnLeft(120.0);
turtle.goForward(step);
turtle.turnLeft(120.0);
}
}

Generated by GNU enscript 1.6.3.``````

here are two classes that provided.
use the Turtle class to draw the image.

I don't have time right now to check all your code, but it looks to me like your main should call drawSnowflake (passing N ans S as parameters), and drawSnowflake should call snowflakePart ( AKA snowflake ), but not vice-versa.

hmmm Jindent is very powerfull code formatter

to OP what's/are hint(s) about error by returns your IDE, I think that Robert has detailed examples, licence and TOC too on your pages, isn't it

Thank you very much James. I edited the code as you said above and its working now

Be a part of the DaniWeb community

We're a friendly, industry-focused community of 1.20 million developers, IT pros, digital marketers, and technology enthusiasts learning and sharing knowledge.