下面是书上的一个applet的例子，Graphics是java.awt包的一个抽象类。
请解释paint()方法中是不是用的一个抽象类的实例做为参数？为什么？
import java.awt.*;
public class Picasso extends java.applet.Applet
{
    public void paint(Graphics g)
    {
        g.fillRect(30,10,200,100);
        g.clearRect(50,30,70,50);
        g.drawRcet(60,50,40,20);
        g.drawLine(10,55,250,55);
    }
} 

这是Component中的方法     
    /**
     * Creates a graphics context for this component. This method will
     * return null if this component is currently not
     * displayable.
     * @return A graphics context for this component, or null
     *             if it has none.
     * @see       java.awt.Component#paint
     * @since     JDK1.0
     */
    public Graphics getGraphics() {
if (peer instanceof java.awt.peer.LightweightPeer) {
    // This is for a lightweight component, need to
    // translate coordinate spaces and clip relative
    // to the parent.
    if (parent == null) return null;
    Graphics g = parent.getGraphics();
    if (g == null) return null;
    if (g instanceof ConstrainableGraphics) {
((ConstrainableGraphics) g).constrain(x, y, width, height);
    } else {
g.translate(x,y);
g.setClip(0, 0, width, height);
    }
    g.setFont(getFont());
    return g;
} else {
    ComponentPeer peer = this.peer;
    return (peer != null) ? peer.getGraphics() : null;
}
    }

看看这个，下面的两个类就是真正的参数，他们都是继承Graphices类。
java.awt 
Class Graphics
java.lang.Object
  |
  +--java.awt.Graphics

Direct Known Subclasses: 
DebugGraphics, Graphics2D 

public void paint(Graphics g)
    {
        g.fillRect(30,10,200,100);
        g.clearRect(50,30,70,50);
        g.drawRcet(60,50,40,20);
        g.drawLine(10,55,250,55);
    }
} 

是典型的up casting技术

上溯造型

的确是上溯造型，Graphics 是抽象类，但g是它的子类的实例。
比如，交通工具是抽象类，汽车是其子类
那么可用：交通工具 aa＝new 汽车（）；
来实例化汽车，明白吗？？

一、抽象类不能实例化
二、用抽象类定义为参数，目的是多态性，即：调用该方法时可以传入任何该抽象类的子类的实例

“
Graphics 是抽象类，但g是它的子类的实例。
可是我们并没有指定到底用哪一个具体的子类，

skyyong说它的直接子类有：
DebugGraphics, Graphics2D 

那我们的g到底是哪一个字类的实例呢？
sorry，我很笨，请不吝赐教

”

到底是哪个子类的实例就要看你调用paint方法的时候传什么参数了。

paint()方法中不是用一个抽象类的实例做为参数
请看：
public abstract class A
{
  public abstract void a();
}
class B extend A
{
  public void a()
  {
    System.out.println("B");
  }
}
class C
{
  public void c(A aa)
  {
   .....
  }
}
class D
{
  C cc = new C();
  A bb = new B();
  cc.c(bb);  
}

因为它实际传入（即g）的是一个继承Graphics的非抽象化的子类的实例。