Interfaces

An Interface is a programming structure / syntax that allows the computer to enforce certain properties on an object (class).

It is also a description of all functions than an object must have in order to be an "X". Again, as an example, anything that "ACTS LIKE" a light, should have a turn_on() method and a turn_off() method. The purpose of interfaces is to allow the computer to enforce these properties and to know that an object of TYPE T (whatever the interface is) must have functions called X,Y,Z, etc.

An Interface must have fulfill two goals. These are:

They allow the programmer to be more abstract when referencing objects (for example, var vehicle : Vehicle, can reference any car, truck, etc... anything that is a vehicle (and not care what type it is.) This occurs at "program time"). When the vehicle.start_engine() function is invoked, the correct function associated with the real object is actually used. his occurs at "run time".
They require the programmer to create specific functions that are expected in an implementing class when it implements an Interface. Again, this allows all objects in a "set" of like objects to be treated based on the "high level" type of the set, rather than on the specific type of the individual object.

How to make declare an Interface (In Java)

This is quite simple. In Java, it looks very much like a class definition. Interfaces are placed in their own files which have the same name as the interface (are Capitalized) and end with the familiar language extension (eg "as").

Here is the Syntax:


                            package
{
    public interface Vehicle
    {

        function start_engine() : void;

    }
}

The differences between an interface and a class are that: No variables are allows to be delcared by the interface, the keyword "public" is not to be placed in front of the function prototypes (all functions listed insid must be public functions) and finally, there is not code after the function prototype - the normal {} are replaced with a single semi-colon

The syntax is similar to a class declaration in Java because Interfaces are similar but also act differently.

How to implement an Interface (In Java)

To implement an Interface you must use the keyword "implements" in the same location where you can use the keyword "extends".

This is an example of a Car Class which implements the Vehicle definition:


                            package
{

    public class Car implements Vehicle
    {

        function start_engine() : void
        {

          //code to start the car engine...

        }

    }
}

While all functions in the interface must be implemented in the class, you can also create any other functions you want for that class.

A class can implement multiple interfaces but can only extend only one class. This also helps (in Java) to get around he multiple-inheritance problem (it is solved by using multiple interfaces).

How apply Polymorphism to an Interface (In Java)

Once we have a number of classes which implement the interface, from some point of view, they are equivalent. For example, we want to create a Car and a Truck, but all our program wants to do is "start" them and "drive" them. To our program's "point of view" they are just Vehicles.

Here is an example below - This shows how we would write the code without interfaces and with interfaces:


                            //Main Actions (Without Interfaces)
var car : Car = new Car();
var truck : Truck = new Truck();

car.start_engine();
truck.start_engine();

car.drive();
truck.drive();


                            //Main Actions (With Interfaces)
var vehicle1 : Vehicle = new Car();
var vehicle2 : Vehicle = new Truck();

vehicle1.start_engine();
vehicle2.start_engine();

vehicle1.drive();
vehicle2.drive();

The differences between both sets of codes is that in the second section, the type of each Vehicle is the same! Using Polymorphism saves the programmer time in coding up "exceptional" conditions - The Computer does the work for us by remembering what each object really is, and then at run time, invoking the actual function associated with the current object.

In addition to the above paragraph, this saves the programmer time and effort but also we don't know what each Vehicle is in its array when we try to search for them, but the computer does.

How apply use functions to a specific type in Implementations (In Java)

Sometimes, you will want to use a function specific to an underlying type. For Example, a dump truck implements Vehicle, but additionally has a "raise_bed" function which dumps everything out of the back of the truck. In the following code, the dump truck is thought of by the computer as a Vehicle, and thus the code does not have access to the raise_bed function.

Consider the following examples (with and without the "as" keyword):


                            var vehicle : Vehicle = new Dump_Truck();

vehicle.start_engine();
vehicle.drive();

vehicle.raise_bed();


                            var vehicle : Vehicle = new Dump_Truck();

(vehicle as Dump_Truck).raise_bed();

In the second example, the "as" keyword allows the programmer to override the computer's type checking, this lets you "take charge" of the program and force the computer to treat the contents of the vehicle variable as a Dump_Truck.

This is a function override (and will be exaplained in a future chapter).

These are the principles and basics of Interfaces.

Interface Concepts