What is the difference between abstract class and static class?

Answer 1

Abstract ClassAn abstract class is an abstract data type (ADT) or abstract base class (ABC). It is a conceptual class. Unlike concrete classes which can serve as generic base classes for more specialised classes, ADTs can only be instantiated through derivation. For instance, circles, triangles and rectangles are all types of shape and all can therefore be derived from a shape base class. However you wouldn't want consumers instantiating a generic shape since it would be impossible to work with a shape without knowing what type of shape it actually was. Thus the shape class is an ideal candidate for an ADT.

An ADT is simply a base class that has one or more pure-virtual methods. A pure-virtual method is similar to a virtual method except that the ADT need not provide any implementation for that method. Even if it does provide a generic implementation, all derivatives must override that method, even if only to call the generic base class method. This ensures that all derivatives provide their own specialised implementations. A derivative that does not provide an implementation for all the pure-virtual methods it inherits becomes an ADT itself. However any implementations that it does provide can subsequently be inherited by its derivatives (those methods effectively become virtual methods rather than a pure-virtual method). Only classes that provide or inherit a complete implementation of all pure-virtual methods can physically be instantiated.

Going back to our shape class, the shape::draw() method is an ideal candidate for a pure-virtual function since it is impossible to draw a shape without knowing what type of shape it is. However, a circle class would be expected to know how to draw itself thus it can provide the specific implementation for drawing circles. Similarly, rectangles and triangles will provide their own specific implementations. This then makes it possible to store a collection of generic shapes and have them draw themselves without the need to know their actual type; as with all virtual methods, the derivatives behave according to their actual type.

Static ClassA static class is simply a class that contains nothing but static members. Like an abstract base class you cannot instantiate a static class, but because the members are static they can be accessed without the need to instantiate an object of the class. Static classes are useful in that they provide global functionality without the need to declare global variables and external functions that operate upon those variables (the variables can effectively be hidden in the class, thus limiting their exposure). They can be likened to a singleton class insofar as there can only ever be one instance of each data member. However, a static class is instantiated at compile time and exists for the entire duration of a program, whereas a singleton can normally be created and destroyed at any time. In terms of memory consumption alone, a singleton is far more efficient than a static class, which is one of the reasons static classes are often frowned upon.

Note that static classes have no need for any constructors, operators or destructors (they have no this pointer since there can never be any instances of the class), thus the compiler-generated default constructor, copy constructor, destructor and assignment operator must all be declared private. Some languages may do this automatically but in C++ (which has no concept of static classes) you must explicitly declare them as such.

While static classes do have their uses, bear in mind that the point of having a class in the first place is in order to instantiate independent objects from the class. Thus the only time you should ever use a static class is when the class data members must exist for the entire duration of the program and you want to ensure there can only ever be one instance of those members. However, for memory efficiency alone, a singleton class would be the preferred method. Moreover, if some or all of the static methods are closely associated with a generic class, then it makes more sense to encapsulate those methods as static members of that generic class rather than as a completely separate static class.

Answer 2

Abstract Classes in Detail:

An Abstract class is a special kind of class that cannot be instantiated. It has one or more methods which are not implemented in the class. These methods are declared abstract and they do not contain any code inside them.

Ex:

abstract class Parent {

public abstract String getSon();

public abstract String getDaughter();

....

....

//More methods that contain specific behaviour/code in them

}

The above is an abstract class "Parent" that has a lot of functionality but it has declared two abstract methods which have no code inside them. Any class that has one or more abstract methods has to be abstract. This abstract class cannot be instantiated.

i.e., the below piece of code will not work. The code will not even compile.

Parent object = new Parent();

Purpose of Abstract Classes:

Abstract classes are generally used where you want an amount of behaviour to be used by the class that extends the abstract class while at the same time giving options to the child class to provide a certain amount of behaviour itself.

A Child Class extending the Abstract Class:

public class Child extends Parent {

public String getSon() {

return "Sons Name";

}

public String getDaughter(){

return "Daughters Name";

}

...

... //Code specific to the Child class

}

Static:

You cannot have Static Classes. You can only have static variables and methods in a class.