A Java interface is a blueprint or guide for a class. It lists methods that a class must have, but it does not say how those methods should work. It also defines unchanging values. Classes then implement<\/b> these interfaces, which means they promise to follow the rules set by the interface.<\/p>\n\n\n\n
You use the word This example interface, Interfaces offer many good things that help you build strong and adaptable Java applications. They are very useful for designing your programs.<\/p>\n\n\n\n \n Java Programming Course<\/a>\n <\/p>\n Learn Java the right way! Our course teaches you essential programming skills, from coding basics to complex projects, setting you up for success in the tech industry.<\/p>\n Making an interface is quite simple. You just use the word All methods you put in an interface are automatically public<\/b> and abstract<\/b>. This means anyone can use them, and they do not have a body or code inside them. Also, any variables you put in an interface are automatically public<\/b>, static<\/b>, and final<\/b>.<\/p>\n\n\n\n This means they are constant values that belong to the interface itself, not to an object of the interface. You do not need to add these keywords yourself; Java adds them for you.<\/p>\n\n\n\n A class uses an interface by adding the word Here is an example of how a You must include the A single class can use more than one interface. You just list them with commas in between their names.<\/p>\n\n\n People sometimes get abstract classes and interfaces<\/a> mixed up. However, they are used for different things.<\/p>\n\n\n\n Here is a table that shows the main differences between them:<\/p>\n\n\n\n Java versions 8 and newer added new features to interfaces. These changes make interfaces more powerful for developers. They help you reuse code and write less repeated code.<\/p>\n\n\n\n Default methods<\/b> provide some ready-made code inside the interface itself. Classes that use this interface can use these methods as they are, or they can write their own version of these methods. This is very helpful when you want to add a new method to an interface without forcing all existing classes that use it to change their code.<\/p>\n\n\ninterface<\/code> to tell Java you are making an interface. An interface mostly tells you what a class should do, rather than how the class will do it.<\/p>\n\n\n\npublic interface Printable {\n void print(); \/\/ This is a method that classes must implement\n int PAGE_LIMIT = 100; \/\/ This is a constant value\n}\n<\/pre><\/div>\n\n\nPrintable<\/code>, makes sure that any class using it will have a method named print()<\/code>. It also gives a constant value, PAGE_LIMIT<\/code>, which is set to 100.<\/p>\n\n\n\nWhy Interfaces are Important?<\/h2>\n\n\n\n
\n
How to Make an Interface<\/h2>\n\n\n\n
interface<\/code> before its name.<\/p>\n\n\n\npublic interface MyInterface {\n void doSomething(); \/\/ This method must be public and abstract\n String getData(); \/\/ This method must also be public and abstract\n}\n<\/pre><\/div>\n\n\nHow to Use an Interface in a Class<\/h2>\n\n\n\n
implements<\/code> followed by the interface's name. The class then must write the code for all the methods that the interface said it should have.<\/p>\n\n\n\nDocument<\/code> class uses the Printable<\/code> interface:<\/p>\n\n\n\npublic class Document implements Printable {\n @Override\n public void print() { \/\/ This method provides the actual code for print()\n System.out.println("Printing document...");\n }\n}\n<\/pre><\/div>\n\n\n@Override<\/code> tag and write the code for the print()<\/code> method inside the Document<\/code> class. If you do not provide code for all the methods from the interface, the Java compiler will show an error.<\/p>\n\n\n\n\npublic class Report implements Printable, Exportable {\n \/\/ This class must write code for methods from both Printable and Exportable interfaces.\n @Override\n public void print() {\n System.out.println("Printing report...");\n }\n\n @Override\n public void export() {\n System.out.println("Exporting report...");\n }\n}\n<\/pre><\/div>\n\n\nAbstract Classes Versus Interfaces<\/h2>\n\n\n\n
<\/th> Abstract Class<\/th> Interface<\/th><\/tr><\/thead> What It Is<\/b><\/td> A class that cannot be directly created as an object and can contain abstract methods (methods without a body).<\/td> A blueprint for a class that contains only abstract methods (before Java 8) and constant variables.<\/td><\/tr> Methods<\/a><\/b><\/td> Can have methods with code and methods without code.<\/td> Can only have methods without code (before Java 8). After Java 8, can also have methods with default code, static methods, and private methods.<\/td><\/tr> Variables<\/b><\/td> Can have variables that belong to an object and variables that belong to the class.<\/td> Can only have unchanging values that are public, static, and final.<\/td><\/tr> Constructors<\/a><\/b><\/td> Can have special methods to create objects (constructors).<\/td> Cannot have special methods to create objects (constructors).<\/td><\/tr> Inheritance<\/a><\/b><\/td> A class can only extend one abstract class.<\/td> A class can implement many interfaces.<\/td><\/tr> Main Goal<\/b><\/td> Gives a common base for classes that are related to each other.<\/td> Defines a set of actions or behaviors that classes must follow.<\/td><\/tr> Access Types<\/a><\/b><\/td> Methods and variables can have different access levels, like public, private, protected.<\/td> Methods are always public.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n Newer Features for Interfaces (Java 8 and Later)<\/h2>\n\n\n\n
Default Methods<\/h3>\n\n\n\n