whats the use of Abstract class

[srinivas yakala]

hi,

could any one explain me the use of Abstract class and in which situation it can be used in real time scenario.

thanks in advance.

regards
srinivas.

[Jeremy Tartaglia]

Sorry for the length.

Abstract classes allow defined functions to exist, so that a function which is shared from more than one class doesn't have to be rewritten. (This is called factoring or refactoring, depending in which order it's done. ) It also allows for the programmer to devise an Interface to subsequent subclasses without having to write all the possibilities right now. Once the interface is designed, a programmer can ignore the very specific case, instead ordering the generic case to do something. For instance:

class abstract Shape
{
  // Assume all shapes are 2D and thus, have area
  public abstract double findArea();
}
 
class Circle extends Shape
{
  private double radius;
 
  public Circle(double r)
  {
    radius=r;
  }
 
  public double findArea()
  {
    return Math.PI * radius * radius;
  }
}
 
class Rectangle extends Shape
{
  private double width;
  private double height;
 
  public Rectangle(double w,double h)
  {
    width=w;
    height=h;
  }
 
  public double findArea()
  {
    return w*h;
  }
}
 
public class Main
{
  public static void main(String[] arg)
  {
    Shape[] s=new Shape[] { new Circle(2.0), new Rectangle(1.0,3.0) };
    System.out.println("Shape 1's area = "+s[0].findArea());
    System.out.println("Shape 2's area = "+s[1].findArea());
  }
}

I suppose a case could be made that an Abstract class can be factored into an interface (for all abstract methods) and a defined class (for all defined, shared methods and properties) since an Interface is just an Abstract class which cannot have defined methods. But breaking them up has an added disadvantage of having two objects which relate to a single concept, instead of one: a super class which must be extended on to be of real use.

Since the above demonstration was not very descriptive, I'll post some code from my game engine.

public abstract class LayerImage extends LittleEndianFile
{
  protected BufferedImage image;
  protected String filename;
  protected boolean fileOpened;
  protected int width;
  protected int height;
 
  public abstract boolean open(String name);
 
  public void close()
  {
    image=null;
    filename=null;
    fileOpened=false;
    width=0;
    height=0;
  }
 
  public Image getImage()
  {
    return image;
  }
 
  public int getWidth()
  {
    return width;
  }
 
  public int getHeight()
  {
    return height;
  }
 
  public String getFileName()
  {
    return filename;
  }
}
//...
public class GG2File extends LayerImage
{
  private static final int SIGNATURE_1 = 0x30414747;
  private static final int SIGNATURE_2 = 0x30303030;
 
  private static final int REPEAT_FEW     = 0;
  private static final int REPEAT_MANY    = 1;
  private static final int COPY_NEAR      = 2;
  private static final int COPY_FAR       = 3;
  private static final int BLIT_FEW_NEAR  = 4;
  private static final int BLIT_MANY_NEAR = 5;
  private static final int BLIT_FEW_FAR   = 6;
  private static final int BLIT_MANY_FAR  = 7;
  private static final int COPY_UP        = 9;
  private static final int COPY_UP_LEFT   = 10;
  private static final int COPY_UP_RIGHT  = 11;
 
  public GG2File()
  {
    fileOpened=false;
    width=height=0;
    filename="";
    image=null;
  }
 
  public GG2File(String name)
  {
    this();
    filename=name;
    open(name);
  }
 
  public boolean open(String name)
  {
    int[] buffer=null;;
    int offset=0;
    int command=0;
    int color=0;
    int count=0;
    int delta=0;
    try
    {
      BufferedInputStream file=new BufferedInputStream(new FileInputStream(name));
      if (readDWord(file)!=SIGNATURE_1)
      {
        file.close();
        return false;
      }
      if (readDWord(file)!=SIGNATURE_2)
      {
        file.close();
        return false;
      }
 
      width=readWord(file);
      height=readWord(file);
      readDWord(file);
      offset=readDWord(file)-20;
      while (offset-->0) readByte(file);
 
      image=new BufferedImage(width,height,BufferedImage.TYPE_INT_ARGB);
      DataBuffer data=image.getRaster().getDataBuffer();
      buffer=((DataBufferInt)data).getData();
 
      offset=0;
      while (offset<width*height)
      {
        command=readByte(file);
        switch (command)
        {
          case REPEAT_FEW:
            // Repeat(byte)
            count=readByte(file);
            while (count-->0)
              buffer[offset++]=color;
            break;
 
          case REPEAT_MANY:
            // Repeat(word)
            count=readWord(file);
            while (count-->0)
              buffer[offset++]=color;
            break;
 
          case COPY_NEAR:
          // .. removed for simplicity
        }
      }
 
      fileOpened=true;
      file.close();
      return fileOpened;
    }
    catch (IOException e)
    {
      e.printStackTrace();
    }
    return false;
  }
}
//...
public class GGDFile extends LayerImage
{
  private static final int SIGNATURE = 0xb3b3aab9;
  private static final int REPEAT    = 0;
  private static final int BLIT_NEAR = 1;
  private static final int BLIT_FAR  = 2;
  private static final int COPY_NEAR = 3;
  private static final int COPY_FAR  = 4;
 
  public GGDFile()
  {
    fileOpened=false;
    width=height=0;
    filename="";
    image=null;
  }
 
  public GGDFile(String name)
  {
    this();
    filename=name;
    open(name);
  }
 
  public boolean open(String name)
  {
    int command;
    int index;
    int count;
    int pos=0;
    int color;
    try
    {
      BufferedInputStream file=new BufferedInputStream(new FileInputStream(name));
      int signature=readDWord(file);
      if (signature!=SIGNATURE)
      {
        file.close();
        return false;
      }
 
      width=readWord(file);
      height=readWord(file);
 
      image=new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
      DataBuffer data=image.getRaster().getDataBuffer();
      int[] buffer=((DataBufferInt)data).getData();
 
      while (pos<width*height)
      {
        command=readByte(file);
        switch (command)
        {
          case REPEAT:
            count=readByte(file);
            color=buffer[pos-1];
            while (count-->0)
              buffer[pos++]=color;
            break;
 
          case BLIT_NEAR:
            count=readByte(file);
            index=pos-readByte(file);
            while (count-->0)
              buffer[pos++]=buffer[index++];
            break;
 
          case BLIT_FAR:
            count=readByte(file);
            index=pos-readWord(file);
            while (count-->0)
              buffer[pos++]=buffer[index++];
            break;
 
          case COPY_NEAR:
          // ..removed for simplicity
        }
      }
 
      file.close();
      fileOpened=true;
    }
    catch (IOException e)
    {
      e.printStackTrace();
    }
 
    return fileOpened;
  }
}

In the engine, I then don't have to worry about what the file type is. Everything can be accessed from LayerImage, even though I can't make a LayerImage.
[ February 09, 2006: Message edited by: Jeremy Tartaglia ]