Section 1.1: What Constitutes a Java Interface?

In essence, any Service Requirement Specification (SRS) can be viewed as an interface. For instance, the JDBC API serves as a SRS for the development of database drivers, which database vendors must implement. Similarly, the Servlet API acts as an SRS that web server vendors must adhere to.

From the client's viewpoint, an interface outlines the set of services expected, while from the service provider's perspective, it delineates the services available to the client. This creates a contractual relationship between the client and the service provider. A typical example would be the interface presented by a Bank ATM GUI, which defines services such as withdrawals, mini-statements, and balance inquiries.

Within an interface, every method is inherently abstract, even if not expressly stated. Consequently, an interface is considered a fully abstract class, necessitating that any implementing class provides concrete implementations for all declared methods. If a class fails to implement all methods, it must be declared abstract, as it does not fulfill the requirements of the interface. Furthermore, all methods in an interface must be declared public to allow child classes to implement them.

Section 1.2: Distinguishing Between "extends" and "implements"

While a class can only extend one superclass, an interface can inherit from multiple interfaces. For example, if we have interfaces A and B, a new interface C can extend both. A class can extend one class while also implementing multiple interfaces. For instance, class A can extend class B and implement interfaces C, D, and E.

It is important to note that interfaces cannot implement other interfaces; they can only extend them. Therefore, including an "implements" clause within an interface declaration is incorrect.

In various scenarios:

• Both X and Y in "X extends Y" can be classes or interfaces.
• In "X extends Y, Z," all X, Y, and Z must be interfaces.
• "X implements Y, Z" means X is a class while Y and Z are interfaces.
• "X extends Y implements Z" suggests X and Y are classes, and Z is an interface.
• The phrase "X implements Y extends Z" leads to a compilation error, as "extends" must precede the interface declaration.

Here is a video titled "Java Interfaces Tutorial," which provides a concise introduction to the concepts of Java interfaces, including their utility and implementation strategies.

Section 1.3: Understanding Interface Methods

All methods declared in an interface are implicitly public and abstract, regardless of how they are articulated. Therefore, the following declarations within an interface are equivalent:

void m1();

public void m1();

abstract void m1();

public abstract void m1();

abstract public void m1();

Declaring a method as public means it will be accessible to any implementing class, while the abstract keyword indicates that the implementing class is required to provide its implementation.

For instance:

interface Interf {

public abstract void m1();

}

In this example, the method m1() must be implemented by any class that implements the interface.

Since all interface methods are inherently public and abstract, the following modifiers cannot be used within an interface: private, protected, static, final, synchronized, strictfp, or native.

Section 1.4: Interface Variables and Their Characteristics

Variables within an interface serve as constant values and are always public, static, and final, even if these modifiers are not explicitly stated. The public modifier ensures that the variable is accessible to all implementing classes. The static modifier allows access to the variable without needing an instance of the implementing class. Finally, the final modifier prevents any changes to the value, meaning that if one implementing class alters the value, all other classes will be affected.

Thus, the following declarations are equivalent:

int x = 10;

public int x = 10;

static int x = 10;

final int x = 10;

public static int x = 10;

public final int x = 10;

static final int x = 10;

public static final int x = 10;

All interface variables must be initialized at the time of declaration; otherwise, a compilation error will occur. For instance:

interface Interf {

int x; // Compilation Error: expected '='.

}

In a class that implements an interface, while you can access interface variables, any attempt to modify them will result in a compilation error.

The second video titled "Java Interface Tutorial #78" delves deeper into the intricacies of Java interfaces, further enhancing your understanding of their usage and best practices.

Section 1.5: Resolving Naming Conflicts

When multiple interfaces share method names, resolving conflicts depends on various factors such as method signature, return type, and argument types.

If two interfaces have methods with the same signature and return type, the implementing class only needs to provide an implementation for one.

interface Left {

public void m1();

}

interface Right {

public void m1();

}

class Test implements Left, Right {

public void m1() {}

}

If two interfaces have methods with identical names but different argument types, the implementing class must provide implementations for both methods, treating them as overloaded methods.

interface Left {

public void m1();

}

interface Right {

public void m1(int i);

}

class Test implements Left, Right {

public void m1() {

// Implementation

}

public void m1(int i) {

// Implementation

}

}

If the methods have the same signature but different return types, implementing both interfaces is impossible unless the return types are covariant or more general.

Section 2.1: Marker Interfaces

A marker interface is one that lacks method declarations. Implementing such an interface endows objects with certain capabilities. Examples include Serializable, Clonable, and RandomAccess. These interfaces signal the JVM to provide specific behaviors or functionalities based on their implementation.

interface Serializable {

}

Despite not containing any methods, marker interfaces allow objects to gain capabilities through the internal workings of the Java Virtual Machine (JVM).

Section 2.2: Adapter Classes

An adapter class implements an interface but provides empty implementations for all the methods. This can help reduce boilerplate code when only a subset of methods needs implementation.

interface X {

void m1();

void m2();

void m3();

// ...

void m1000();

}

abstract class AdapterX implements X {

public void m1() {}

public void m2() {}

public void m3() {}

// ...

public void m1000() {}

}

By extending an adapter class, a concrete class only needs to implement the methods of interest, thereby simplifying the code.

class Test extends AdapterX {

public void m3() {

// Provide implementation for only this method

}

}

This approach enhances code readability and maintainability.

Section 2.3: Interfaces vs. Abstract Classes

When to use an interface versus an abstract class depends on the specificity of implementation details.

• Interface: Used when only requirements are known without implementation specifics, such as servlets.
• Abstract Class: Suitable when some implementation details are available but not fully fleshed out.
• Concrete Class: Chosen when there’s complete implementation knowledge.

Understanding these distinctions aids in making informed design decisions in Java programming.