How can you use abstract classes instead of interfaces?

Answer 1

In most cases, you will want to use abstract classes IN ADDITION to interfaces.

You should use an abstract class in the following circumstance:

1. the abstract class is clearly part of class hierarchy, and does not just describe some sort of basic functionality. Specifically, abstract classes are a good idea where they will be directly inherited from to create a concrete concept, but the abstract class itself is too indistinct to have any specific instance of it created.
2. You want to provide an implementation for a set of methods that will be reused by a significant number of other classes, all of which can be fit into a class hierarchy.

In practice, abstract classes are a good way to collect common code into one place, to make maintenance easier.

For instance, say you have a class and interface structure like this:

Class A

Interface X

Class B extends A implements X

Class C extends A implements X

Both B and C will have the all the methods declared in X; if the implementation of those methods is the same (or can be made the same), then X is a good candidate for changing to an abstract method:

Class A

Abstract Class X extends A

Class B extends X

Class C extends X

Thus, you have removed the code duplication that was happening when using interfaces.

Note that doing the above is NOT a good idea if any class which implement interface X cannot be made a subclass of the new abstract class X.

Answer 2

Abstract class must be extended/subclassed (to be useful). It serves as a template. A class that is abstract may not be instantiated (ie, you may not call its constructor), abstract class may contain static data. Any class with an abstract method is automatically abstract itself, and must be declared as such.

A class may be declared abstract even if it has no abstract methods. This prevents it from being instantiated.

Answer 3

Abstract classes are those classes that cannot be instantiated. Those classes are not fully implemented. Abstract class is base class for the family of child classes. It may contain some basic features but for some features only signature are given, the body of those methods must be written after inheriting this abstract class. Only if child implements all of the abstract methods it might be used (instantiated), otherwise child class is abstract too.

To summarize it, you cannot instantiate class that is partial (missing all/some implementation).

Answer 4

In case of interface, we can enforce the child classes to implement all the methods but in case of abstract classes, you can provide implementation for as many methods as you want. In some cases this might be confusing to novice developers.

Interfaces are easier because, Complete implementation is handed over to the derived classes. depending on the requirement they can provide their own implementation.

Answer 5

An abstract class is a class that is used to inherit other classes from, but that does not serve a useful purpose to instantiate all by itself.

For example, you might have an abstract class called Shape, which contains properties that all shapes possess (color, number of sides, size, etc.), and then create specific shape classes (square, triangle, etc.) that all inherit from the class.

It wouldn't be useful to create a Shape class by itself, which is why it's abstract.

The benefit of using abstract classes are twofold. First, you can take the common properties of the derived classes and put them in one place. Second, you can cast the derived class to its abstract class when you need to pass it around in methods. C# Example:

void Test()

{

Shape triangle = new Triangle();

Shape square = new Square();

CreateShape(triangle);

CreateShape(square);

}

void CreateShape(Shape shape)

{

Console.WriteLine("I have " + shape.sides + " side(s)");

}

Because the CreateShape object is expecting a Shape, it can accept both Square and Triangle objects. (Note: This is not unique to abstract classes. You can do a similar thing with any derived class).

The CreateShape method can accept any object that was derived from the Shape class. It can only access properties and methods that were defined in the abstract class. You can cast the abstract class to the derived class, but would get an error if you passed an object of another type. For example, suppose the Triangle class had a Angle property, and you modified CreateShape like this:

void CreateShape(Shape shape)

{

Console.WriteLine("My angle is " + ((Triangle)shape).Angle);

}

This would work find if you called CreateShape(triangle), but would throw an exception if you called CreateShape(square);

Answer 6

No, not directly.

You cannot use new operator to create either. However, you may create an instance of derived class from the abstract class, and treat (by casting, for example) as an instance of the abstract class.

Similar to an interface: create an object from a class that implements the target interface, then treat that object as an instance of that interface.

Answer 7

The questions I would ask the designer (could be you, could be some one else):

• Do you have default behavior (implementation) in mind? If the answer is yes, then class-hierarchy (not necessary an abstract class) is more favorable than an interface
• Is there any data member involve? If yes, then class is more favorable.
• Are there more than 1 class involved and each derived from different base classes? If yes, then an interface is more favorable
  • Note If you cannot modify either of the base classes involved, an interface may be the only way

Answer 8

Yes. Although an instance of an abstract class cannot be created directly, it is a very good place to implement default behaviors (the interface) for the derived classes to eliminate duplicate codes, yet the derived class has the option to override the default method implementation with its own special way.

Answer 9

An abstract class has at least abstract methods. An interface has only abstract actions. For example, the javax.swing.AbstractAction class has only one abstract method that must be overriden: public void actionPerformed(ActionEvent e). The java.awt.event.ActionListener interface has the same method that must be overriden; however, it is its only method. The AbstractAction class is a subclass of the Action class, which implements the ActionListener interface. The AbstractAction class has overriden all but one of the Action class's methods.

Answer 10

Because that's the whole idea of declaring a class abstract - to avoid objects from being instantiated. The general idea is that an abstract class is "incomplete" - some details have to be filled out in derived (inherited) classes.