java awt Canvas getInstance undefined (newbie)

Question

Trying the exercise in lesson2 of the Udacity course. Despite importing the classes (I'm at java.awt.* now, but I also tried java.awt.Color and java.awt.Canvas separately (also need Shape))..

package com.jul.udacity.lesson2;

public class TestRectangle {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Rectangle rect1 = new Rectangle(100.0, 100.0, 200.0, 100.0);
		rect1.draw();
		}
}

And the class is copied from there and java.awt import added. Any help will be great. Thanks!

package com.jul.udacity.lesson2;

//HIDE
import java.awt.Graphics2D;
import java.awt.geom.Rectangle2D;
//import java.awt.Color;
//import java.awt.Shape;
//import java.awt.Canvas;
import java.awt.*;


public class Rectangle implements Shape
{
  private Color color = Color.BLACK;
  private boolean filled = false;
  private double x;
  private double y;
  private double width;
  private double height;

  /**
     Constructs an empty rectangle.
  */
  public Rectangle()
  {
      x = 0;
      y = 0;
      width = 0;
      height = 0;
  }       

  /**
     Constructs a rectangle.
     @param x the leftmost x-coordinate
     @param y the topmost y-coordinate
     @param width the width
     @param height the height
  */
  public Rectangle(double x, double y, double width, double height)
  {
      this.x = x;
      this.y = y;
      this.width = width;
      this.height = height;
  }

  /**
     Gets the leftmost x-position of this rectangle.
     @return the leftmost x-position
  */
  public int getX()
  {
      return (int) Math.round(x);
  }

  /**
     Gets the topmost y-position of this rectangle.
     @return the topmost y-position
  */
  public int getY()
  {
      return (int) Math.round(y);
  }

  /**
     Gets the width of this rectangle.
     @return the width
  */    
  public int getWidth()
  {
      return (int) Math.round(width);
  }

  /**
     Gets the height of this rectangle.
     @return the height
  */    
  public int getHeight()
  {
      return (int) Math.round(height);
  }

  /**
     Moves this rectangle by a given amount.
     @param dx the amount by which to move in x-direction
     @param dy the amount by which to move in y-direction
  */
  public void translate(double dx, double dy)
  {
      x += dx;
      y += dy;
      Canvas.getInstance().repaint();
  }

  /**
     Resizes this rectangle both horizontally and vertically.
     @param dw the amount by which to resize the width on each side
     @param dw the amount by which to resize the height on each side
  */
  public void grow(double dw, double dh)
  {
      width += 2 * dw;
      height += 2 * dh;
      x -= dw;
      y -= dh;
      Canvas.getInstance().repaint();
  }

  /**
     Sets the color of this rectangle.
     @param newColor the new color
  */
  public void setColor(Color newColor)
  {
      color = newColor;
      Canvas.getInstance().repaint();
  }

  /**
     Draws this rectangle.
  */
  public void draw()
  {
      filled = false;
      Canvas.getInstance().show(this);
  }

  /**
     Fills this rectangle.
  */
  public void fill()
  {
      filled = true;
      Canvas.getInstance().show(this);
  }

  public String toString()
  {
      return "Rectangle[x=" + getX() + ",y=" + getY() + ",width=" + getWidth() + ",height=" + getHeight() + "]";
  }

  public void paintShape(Graphics2D g2)
  {
      Rectangle2D.Double rect = new Rectangle2D.Double(getX(), getY(),
              getWidth(), getHeight());
      g2.setColor(new java.awt.Color((int) color.getRed(), (int) color.getGreen(), (int) color.getBlue()));
      if (filled)
      {
          g2.fill(rect);
      }
      else
      {
          g2.draw(rect);
      }
  }
}

Answer 1

markspace is correct: Canvas here is not the class from java.awt - the Udacity instructors are using their own class called Canvas. I suggest grabbing the lesson files and using those. Here's the Canvas class from that Intro To Java Course:

  import java.awt.image.BufferedImage;
  import java.awt.Dimension;
  import java.awt.Graphics;
  import java.awt.Graphics2D;
  import java.awt.image.RescaleOp;
  import java.io.IOException;
  import java.io.File;
  import java.util.ArrayList;

  import javax.imageio.ImageIO;
  import javax.swing.JComponent;
  import javax.swing.JFrame;
  import javax.swing.JOptionPane;

  public class Canvas
  {
    private static Canvas canvas = new Canvas();

    private ArrayList<Shape> shapes = new ArrayList<Shape>();
    private BufferedImage background;
    private JFrame frame;
    private CanvasComponent component;

    private static final int MIN_SIZE = 100;
    private static final int MARGIN = 10;
    private static final int LOCATION_OFFSET = 120;

  class CanvasComponent extends JComponent
  {
      public void paintComponent(Graphics g)
      {
          g.setColor(java.awt.Color.WHITE);
          g.fillRect(0, 0, getWidth(), getHeight());
          g.setColor(java.awt.Color.BLACK);
          if (background != null)
          {
              g.drawImage(background, 0, 0, null);
          }               
          for (Shape s : new ArrayList<Shape>(shapes))
          {
              Graphics2D g2 = (Graphics2D) g.create();
              s.paintShape(g2);
              g2.dispose();
          }
      }

      public Dimension getPreferredSize()
      {
          int maxx = MIN_SIZE;
          int maxy = MIN_SIZE;
          if (background != null)
          {
              maxx = Math.max(maxx, background.getWidth());
              maxy = Math.max(maxx, background.getHeight());
          }
          for (Shape s : shapes)
          {
              maxx = (int) Math.max(maxx, s.getX() + s.getWidth());
              maxy = (int) Math.max(maxy, s.getY() + s.getHeight());
          }
          return new Dimension(maxx + MARGIN, maxy + MARGIN);
      }
  }

  private Canvas()
  {
      component = new CanvasComponent();

      if (System.getProperty("com.horstmann.codecheck") == null)
      {
          frame = new JFrame();
          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
          frame.add(component);
          frame.pack();
          frame.setLocation(LOCATION_OFFSET, LOCATION_OFFSET);
          frame.setVisible(true);
      }
      else
      {
          final String SAVEFILE ="canvas.png";
          final Thread currentThread = Thread.currentThread();
          Thread watcherThread = new Thread() 
              {
                  public void run()
                  {
                      try
                      {
                          final int DELAY = 10;

                          while (currentThread.getState() != Thread.State.TERMINATED)
                          {
                              Thread.sleep(DELAY);
                          }
                          saveToDisk(SAVEFILE);
                      }
                      catch (Exception ex)
                      {
                          ex.printStackTrace();
                      }
                  }
              };
          watcherThread.start();
      }
  }

  public static Canvas getInstance()
  {
      return canvas;
  }

  public void show(Shape s)
  {
      if (!shapes.contains(s))
      {
          shapes.add(s);
      }
      repaint();
  }

  public void repaint()
  {
      if (frame == null) return;
      Dimension dim = component.getPreferredSize();
      if (dim.getWidth() > component.getWidth()
              || dim.getHeight() > component.getHeight())
      {
          frame.pack();
      }
      else
      {
          frame.repaint();
      }
  }

    /**
     * Pauses so that the user can see the picture before it is transformed.
     */
    public void pause()
    {
        if (frame == null) return;
        JOptionPane.showMessageDialog(frame, "Click Ok to continue");
    }

    /**
     * Takes a snapshot of the screen, fades it, and sets it as the background.
     */
    public static void snapshot()
    {
        Dimension dim = getInstance().component.getPreferredSize();
        java.awt.Rectangle rect = new java.awt.Rectangle(0, 0, dim.width, dim.height);
        BufferedImage image = new BufferedImage(rect.width, rect.height, BufferedImage.TYPE_INT_RGB);
        Graphics g = image.getGraphics();
        g.setColor(java.awt.Color.WHITE);
        g.fillRect(0, 0, rect.width, rect.height);
        g.setColor(java.awt.Color.BLACK);
        getInstance().component.paintComponent(g);
        float factor = 0.8f;
        float base = 255f * (1f - factor);
        RescaleOp op = new RescaleOp(factor, base, null);
        BufferedImage filteredImage
           = new BufferedImage(image.getWidth(), image.getHeight(), image.getType());
        op.filter(image, filteredImage);
        getInstance().background = filteredImage;
        getInstance().component.repaint();
    }

    public void saveToDisk(String fileName)
    {
        Dimension dim = component.getPreferredSize();
        java.awt.Rectangle rect = new java.awt.Rectangle(0, 0, dim.width, dim.height);
        BufferedImage image = new BufferedImage(rect.width, rect.height, BufferedImage.TYPE_INT_RGB);
        Graphics2D g = (Graphics2D) image.getGraphics();
        g.setColor(java.awt.Color.WHITE);
        g.fill(rect);
        g.setColor(java.awt.Color.BLACK);
        component.paintComponent(g);
        String extension = fileName.substring(fileName.lastIndexOf('.') + 1);
        try
        {
            ImageIO.write(image, extension, new File(fileName));
        } 
        catch(IOException e)
        {
            System.err.println("Was unable to save the image to " + fileName);
        }
        g.dispose();        
    }
}

Answer 2

You might want to check the lesson directions carefully. java.awt.Canvas has no getInstance() method. You just use new to make a Canvas. So you either didn't read carefully and are using the wrong Canvas, or there's something else going on.

Also the show() methods are deprecated, so I'm leaning towards you are supposed to be using a different Canvas class.

Also, Swing is not thread safe. Read up on how to use Swing objects