[Jared Russell]

There are three main types of constructs in the Java world: abstract classes, concrete classes, and interfaces.

Abstract classes have at least one abstract method - this means that you cannot instantiate an object of an abstract class. For example, a "Vehicle" abstract class might have an abstract method "move()" - all vehicles can move, but they do it in different enough ways that you can't just make a Vehicle object and call move() - there's not enough information for that to be meaningful. Abstract classes can provide default implementations of methods, as well.

Concrete classes have no abstract methods, but they can inherit from abstract classes and provide implementations of abstract methods from the parent class. For example, a "Bike" class might inherit from "Vehicle" and provide a "move()" method. Now any function that takes a "Vehicle" class as an input can also take a "Bike" class and call the "move()" method, because it knows that all Vehicles can move. This is called polymorphism.

Interfaces are very similar to abstract classes - you can't instantiate them, only implement them. For example, a Bike might implement a "WheelieCapable" interface, since Bikes can do wheelies. WheelieCapable provides a "wheelie()" method that Bike must not implement. The difference is that while a concrete class can only inherit from one abstract class, they can implement MANY interfaces.

// Abstract class
public abstract class Vehicle
{
  // Abstract method
  public abstract void move();

  // Concrete method that can be overridden
  public void getIn()
  {
    ... do something ...
  }
}

public interface WheelieCapable
{
  public void wheelie();
}

public class Bike extends Vehicle implements WheelieCapable
{
  // Override the abstract method
  public void move()
  {
    ... do something ...
  }

  // Don't override the getIn() method - just use the default implementation

  // Implement the interface method
  public void wheelie()
  {
    ... do something else ...
  }
}