Не могу понять, как работать с графикой

import java.awt.*;
import javax.swing.*;
 
public class Main {
  public static void main (String[] args)
  {
    MyFrame frame = new MyFrame ();
    frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
    frame.setVisible (true);
  }
}
 
class MyFrame extends JFrame
{
  public MyFrame()
  {
    this.setBounds (0, 0, 200, 200);
    
    MyPanel panel = new MyPanel();
    this.add (panel);
  }
}
 
class MyPanel extends JPanel
{
  public void paintComponent (Graphics g)
  {
    super.paintComponent (g);   
    g.drawLine (10, 10, 180, 180);  
  }
}

import java.awt.Graphics;
import javax.swing.JFrame;
import javax.swing.JPanel;
 
public class MainForm {
 
   public MainForm() {
      JFrame mainForm = new JFrame("Main Form");
      mainForm.setSize(650, 600);
      mainForm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      mainForm.setVisible(true);
 
      final JPanel imagePanel = new JPanel();
      imagePanel.setVisible(true);
      mainForm.getContentPane().add(imagePanel);
 
      for (int i = 0; i < 10; ++i) {
         Graphics g = imagePanel.getGraphics();
         int x1 = i * 10 + i;
         int y1 = i * 20 + 5;
 
         int x2 = i + 100;
         int y2 = (i + 10) * i;
         if ((i & 1) == 0)
            g.drawLine(x1, y1, x2, y2);
         else
            g.drawRect(x1, y1, x2, y2);
         try {
            Thread.sleep(1000);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
 
   }
 
   public static void main(String[] args) {
      new MainForm();
   }
 
}

import java.awt.Graphics;
import javax.swing.JFrame;
import javax.swing.JPanel;
 
public class MainForm {
 
   public MainForm() {
      JFrame mainForm = new JFrame("Main Form");
      mainForm.setSize(650, 600);
      mainForm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      mainForm.setVisible(true);
 
      final JPanel imagePanel = new JPanel();
      imagePanel.setVisible(true);
      mainForm.getContentPane().add(imagePanel);
 
      for (int i = 0; i < 10; ++i) {
         Graphics g = imagePanel.getGraphics();
         int x1 = i * 10 + i;
         int y1 = i * 20 + 5;
 
         int x2 = i + 100;
         int y2 = (i + 10) * i;
         if ((i & 1) == 0)
            g.drawLine(x1, y1, x2, y2);
         else
            g.drawRect(x1, y1, x2, y2);
         try {
            Thread.sleep(1000);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
 
   }
 
   public static void main(String[] args) {
      new MainForm();
   }
 
}

import java.awt.*;
import javax.swing.*;
 
public class Main
{
  public static void main (String[] args)
  {
    new MyProg();
  }
}
 
class MyProg
{
  int x1, y1, x2, y2;
 
  public MyProg()
  {
    MyFrame frame = new MyFrame (this);
    frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
    frame.setVisible (true);
      
    while (true)
    {
      x1 = 10; y1 = 10; x2 = 100; y2 = 100;
      frame.repaint();
 
      try {
        Thread.sleep(1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
 
      x1 = 100; y1 = 10; x2 = 10; y2 = 100;
      frame.repaint();
 
      try {
        Thread.sleep(1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
  
  public void Draw (Graphics g)
  {
    g.drawLine (x1, y1, x2, y2);      
  }
}
 
class MyFrame extends JFrame
{
  public MyFrame (MyProg my_prog)
  {
    this.setBounds (0, 0, 200, 200);
    
    MyPanel panel = new MyPanel (my_prog);
    this.add (panel);
  }
 
  class MyPanel extends JPanel
  {
    MyProg m_MyProg;
 
    public MyPanel (MyProg my_prog)
    {
      m_MyProg = my_prog;
    }
 
    public void paintComponent (Graphics g)
    {
      super.paintComponent (g);
      m_MyProg.Draw (g);
    }
  }
}

package ru.skipy.swing;
 
import javax.swing.*;
import javax.swing.border.Border;
import java.awt.*;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.image.BufferedImage;
 
/**
 * JCanvas - canvas implementation. Component works in paint-and-forget mode - all painting operations
 * are stored in the internal buffer. Because of this painting result will not be visible till component
 * repaint - {@link java.awt.Component#repaint()} should be called explicitly after painting on visible
 * canvas.
 *
 * @author Eugene Matyushkin aka Skipy
 * @since 26.01.12
 */
public class JCanvas extends JPanel {
 
    /**
     * Internal buffer
     */
    private BufferedImage offscreen = null;
 
    /**
     * Current canvas width
     */
    private int currentWidth = 0;
 
    /**
     * Current canvas height
     */
    private int currentHeight = 0;
 
    /**
     * Creates empty transparent canvas with zero size ({@link #createCanvasGraphics()} will return
     * <code>null</code>). Internal buffer will be created on the first resize, display or explicit call to
     * {@link #extendCanvasTo(int, int)};
     */
    public JCanvas() {
        addComponentListener(new SizeTracker());
    }
 
    /**
     * Creates empty transparent canvas with the size specified.
     *
     * @param startWidth  starting canvas width
     * @param startHeight starting canvas height
     */
    public JCanvas(int startWidth, int startHeight) {
        this();
        extendCanvasTo(startWidth, startHeight);
    }
 
    /**
     * <b>Extends</b> canvas to the new size. Size setting less then current will be ignored (current setting
     * will remain). Creates new internal buffer of the specified size and paints exiting buffer's (if any)
     * content on new one.
     *
     * @param newWidth  new width
     * @param newHeight new height
     */
    public void extendCanvasTo(int newWidth, int newHeight) {
        int oldW = currentWidth;
        int oldH = currentHeight;
        int w = Math.max(newWidth, getWidth());
        int h = Math.max(newHeight, getHeight());
        currentWidth = Math.max(currentWidth, w);
        currentHeight = Math.max(currentHeight, h);
        if (currentWidth > oldW || currentHeight > oldH || offscreen == null) {
            BufferedImage old = offscreen;
            offscreen = new BufferedImage(currentWidth, currentHeight, BufferedImage.TYPE_INT_ARGB);
            if (old != null) {
                Graphics2D g = offscreen.createGraphics();
                g.drawImage(old, 0, 0, this);
                g.dispose();
            }
        }
    }
 
    /**
     * Returns current canvas size. It can differ from component size
     *
     * @return canvas' internal buffer's size
     */
    public Dimension getCanvasSize() {
        return new Dimension(currentWidth, currentHeight);
    }
 
    /**
     * Creates <code>java.awt.Graphics2D</code> object to work with canvas. This object should be explicitly disposed
     * after use by calling {@link java.awt.Graphics#dispose()}
     *
     * @return created graphics or <code>null</code> if internal buffer is not created yet.
     * @see #extendCanvasTo(int, int)
     */
    public Graphics2D createCanvasGraphics() {
        return (offscreen == null) ? null : offscreen.createGraphics();
    }
 
    /**
     * Cleans internal buffer and repaints canvas.
     */
    public void cleanCanvas() {
        offscreen = null;
        extendCanvasTo(currentWidth, currentHeight);
        repaint();
    }
 
    /**
     * Paints canvas taking into account current border (canvas' origin is moved into the topmost-leftmost point
     * inside the border, painting area is clipped according to the border's internal area)
     *
     * @param g graphics to use for painting of internal buffer
     */
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        if (offscreen != null) {
            Border b = getBorder();
            Insets i = (b == null) ? null : b.getBorderInsets(this);
            Graphics copy = (i == null) ? g.create() :
                    g.create(i.left, i.top, getWidth() - i.left - i.right, getHeight() - i.top - i.bottom);
            copy.drawImage(offscreen, 0, 0, this);
            copy.dispose();
        }
    }
 
    /**
     * This class is intended to track size/visibility change in order to adjust internal buffer size.
     */
    private class SizeTracker extends ComponentAdapter {
 
        /**
         * Component was shown
         * @param e event object
         */
        @Override
        public void componentShown(ComponentEvent e) {
            extendCanvasTo(getWidth(), getHeight());
        }
 
        /**
         * Component was resized
         * @param e event object
         */
        @Override
        public void componentResized(ComponentEvent e) {
            extendCanvasTo(getWidth(), getHeight());
        }
    }
}