When a class implements an interface, you can think of the class as signing a contract, agreeing to perform the specific behaviors of the interface.
Methods in an interface are implicitly public. You do not need to use the abstract keyword while declaring an interface.Įach method in an interface is also implicitly abstract, so the abstract keyword is not needed. Interfaces have the following properties −Īn interface is implicitly abstract. Any number of abstract method declarations\ Here is a simple example to declare an interface − Exampleįollowing is an example of an interface − The interface keyword is used to declare an interface. The only fields that can appear in an interface must be declared both static and final.Īn interface is not extended by a class it is implemented by a class.Īn interface can extend multiple interfaces. However, an interface is different from a class in several ways, including −Īn interface does not contain any constructors.Īll of the methods in an interface are abstract.Īn interface cannot contain instance fields. Interfaces appear in packages, and their corresponding bytecode file must be in a directory structure that matches the package name.
#Java interface code
The byte code of an interface appears in a. java extension, with the name of the interface matching the name of the file. Unless the class that implements the interface is abstract, all the methods of the interface need to be defined in the class.Īn interface is similar to a class in the following ways −Īn interface can contain any number of methods.Īn interface is written in a file with a. And an interface contains behaviors that a class implements. But a class describes the attributes and behaviors of an object. Writing an interface is similar to writing a class. Method bodies exist only for default methods and static methods. A class implements an interface, thereby inheriting the abstract methods of the interface.Īlong with abstract methods, an interface may also contain constants, default methods, static methods, and nested types. In Objective-C they are called Protocols and and object is said to conform to a protocol rather than implementing an interface.An interface is a reference type in Java. If I remember correctly, the C# implementation is very similar to Java's. The concept of interfaces is used in other languages as well. If so, you know that there will be a given set of methods implemented by the object. You can use introspection to determine if a given object implements an interface. As the consumer of an object, you know for sure that any object that implements a given interface will respond to particular methods. When designing object oriented software, an interface is a contract. The implementation for kitten.isCute() and babyTurtle.isCute() may be completely different, but they will both return (bool)true. Baby turtles and tiny octopi do as well, but amoebas do not.
We can say that a kitten implements the Cute interface. What happens for other attributes that do not come from the hierarchy? That's where interfaces come in. It inherits other attributes (like a backbone) from higher in the object hierarchy.
Lots of examples of object oriented programming refer to Linnean taxonomy. Interfaces allow certain types of behavior to be implemented across multiple classes without these classes needing to be in a common inheritance hierarchy. Some other languages (notably C++) use multiple inheritance in which a given class may descend from more than one class. Java uses a single inheritance model which means that every class has exactly one direct superclass. As long as you define Player.getTarget() as always returning something that extends Killable, then this code will always work, and you don't have to duplicate the code 1,000 times to cover each possible thing you can kill. Notice that you don't have to care which monster class you're dealing with. Then, later on, when you have the code that runs when a player kills a monster, you might have something like this: Killable target = Player.getTarget() Now you make all of your monster classes implement your "Killable" interface, which forces every one of them to have "playDeathSound" and "playDeathAnimation", or your code won't even compile. So you have an interface called "Killable", which specifies two abstract methods, "playDeathSound" and "playDeathAnimation". You have lots of monsters that the player can fight, but all monsters need to be able to be killed. For example, let's say that you're programming a game. It allows you to specify that multiple classes implement some common functionality.
0 kommentar(er)
