An interface is more than an interface. It's a behavior.

"Hello, Amigo! It's me—again. I want to give you another point of view on interfaces. You see, most of the time a class is a model of a particular object. By contrast, interfaces are more like an object's abilities or roles, rather than the object itself."

For example, things such as cars, bicycles, motorcycles, and wheels are best represented as classes and objects. But their abilities, like «I can move», «I can carry people», and «I can park», are better represented as interfaces. Check out this example:

interface Moveable
{
void move(String newAddress);
}

interface Driveable
{
void drive(Driver driver);
}

interface Transport
{
void addStuff(Object stuff);
Object removeStuff();
}

class Wheel implements Moveable
{
...
}

class Car implements Moveable, Drivable, Transport
{
...
}

class Skateboard implements Moveable, Driveable
{
...
}

3

Task

Java Core, level 2, lesson 8

Locked

Code entry

Sometimes you don't need to think, you just need to hammer it out! As paradoxical as it may seem, sometimes your fingers will "remember" better than your conscious mind. That's why while training at the secret CodeGym center you will sometimes encounter tasks that require you to enter code. By entering code, you get used to the syntax and assimilate some material. What's more, you combat laziness.

Open

Interfaces greatly simplify the life of the programmer. Programs very often have thousands of objects, hundreds of classes, and just a couple dozen interfaces (roles). There are few roles, but they can be combined in many ways (classes).

The whole point is that you don't have to write code defining interaction with every other class. All you have to do is interact with roles (interfaces).

Here's how it would look in code:

static interface WallBuilder
{
void buildWall();
}

static class WorkerRobot implements WallBuilder
{
void buildWall()
 {
…
 }
}
static class GuardRobot implements WallBuilder
{
void buildWall()
 {
…
 }
}
static class WateringCan
{
…
}

public static void main(String[] args)
{
 //add all robots to a list
 ArrayList robots = new ArrayList();
 robots.add(new WorkerRobot());
 robots.add(new GuardRobot());
 robots.add(new WateringCan());

 //build a wall if you can
 for (Object robot: robots)
 {
  if (robot instanceof WallBuilder)
  {
   WallBuilder builder = (WallBuilder) robot;
   builder.buildWall();
   }
  }
 }
}

"That's amazingly interesting. I never dreamed that interfaces could be such an interesting topic."

"And then some! Together with polymorphism, it's totally mind-blowing."