[Go to site: main page, start]
Scribd
Upload
15 views20 pages

Understanding Java Interfaces and Inheritance

The document provides an overview of Java interfaces, explaining their purpose, declaration, and usage, including examples of interface implementation and multiple inheritance. It also covers the concept of packages in Java, detailing how to create, compile, and access them, along with the advantages of using packages. Additionally, it discusses the organization of classes and interfaces within packages and subpackages, as well as methods for managing class files and classpaths.

Uploaded by

Varada Raj
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
15 views20 pages

Understanding Java Interfaces and Inheritance

The document provides an overview of Java interfaces, explaining their purpose, declaration, and usage, including examples of interface implementation and multiple inheritance. It also covers the concept of packages in Java, detailing how to create, compile, and access them, along with the advantages of using packages. Additionally, it discusses the organization of classes and interfaces within packages and subpackages, as well as methods for managing class files and classpaths.

Uploaded by

Varada Raj
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd

Module-3

Interface: An interface in Java is a blueprint of a class. It has static constants


and abstract methods.
The interface in Java is a mechanism to achieve abstraction. There can be only
abstract methods in the Java interface, not method body. It is used to achieve
abstraction and multiple inheritance in Java.
In other words, you can say that interfaces can have abstract methods and
variables. It cannot have a method body.
Java Interface also represents the IS-A relationship.
It cannot be instantiated just like the abstract class.

Why use Java interface?


There are mainly three reasons to use interface. They are given below.
o It is used to achieve abstraction.
o By interface, we can support the functionality of multiple inheritance.
o It can be used to achieve loose coupling.

How to declare an interface?


An interface is declared by using the interface keyword. It provides total
abstraction; means all the methods in an interface are declared with the empty
body, and all the fields are public, static and final by default. A class that
implements an interface must implement all the methods declared in the
interface.
Syntax:
interface <interface_name>{
// declare constant fields
// declare methods that abstract
// by default.
}
Internal addition by the compiler
The Java compiler adds public and abstract keywords before the interface
method. Moreover, it adds public, static and final keywords before data
members.
In other words, Interface fields are public, static and final by default, and the
methods are public and abstract.

The relationship between classes and interfaces


As shown in the figure given below, a class extends another class, an interface
extends another interface, but a class implements an interface.

Java Interface Example


In this example, the Printable interface has only one method, and its
implementation is provided in the A6 class.
interface printable{
void print();
}
class A6 implements printable{
public void print(){[Link]("Hello");}

public static void main(String args[]){


A6 obj = new A6();
[Link]();
}
}

Java Interface Example: Drawable


In this example, the Drawable interface has only one method. Its
implementation is provided by Rectangle and Circle classes. In a real scenario,
an interface is defined by someone else, but its implementation is provided by
different implementation providers. Moreover, it is used by someone else. The
implementation part is hidden by the user who uses the interface.

//Interface declaration: by first user


interface Drawable{
void draw();
}
//Implementation: by second user
class Rectangle implements Drawable{
public void draw(){[Link]("drawing rectangle");}
}
class Circle implements Drawable{
public void draw(){[Link]("drawing circle");}
}
//Using interface: by third user
class TestInterface1{
public static void main(String args[]){
Drawable d=new Circle();//In real scenario, object is provided by method
e.g. getDrawable()
[Link]();
}}

Java Interface Example: Bank


Let's see another example of java interface which provides the implementation
of Bank interface.
interface Bank{
float rateOfInterest();
}
class SBI implements Bank{
public float rateOfInterest(){return 9.15f;}
}
class PNB implements Bank{
public float rateOfInterest(){return 9.7f;}
}
class TestInterface2{
public static void main(String[] args){
Bank b=new SBI();
[Link]("ROI: "+[Link]());
}}

interface Bank{
float rateOfInterest();
}
class SBI implements Bank{
public float rateOfInterest(){return 9.15f;}
}
class PNB implements Bank{
public float rateOfInterest(){return 9.7f;}
}
class TestInterface2{
public static void main(String[] args){
Bank b=new SBI();
[Link]("ROI: "+[Link]());
}}

Multiple inheritance in Java by interface


If a class implements multiple interfaces, or an interface extends multiple
interfaces, it is known as multiple inheritance.

interface Printable{
void print();
}
interface Showable{
void show();
}
class A7 implements Printable,Showable{
public void print(){[Link]("Hello");}
public void show(){[Link]("Welcome");}

public static void main(String args[]){


A7 obj = new A7();
[Link]();
[Link]();
}
}

Multiple inheritance is not supported through class in java, but it is possible by


an interface, why?
Multiple inheritance is not supported in the case of class because of ambiguity.
However, it is supported in case of an interface because there is no ambiguity. It
is because its implementation is provided by the implementation class. For
example:
interface Printable{
void print();
}
interface Showable{
void print();
}

class TestInterface3 implements Printable, Showable{


public void print(){[Link]("Hello");}
public static void main(String args[]){
TestInterface3 obj = new TestInterface3();
[Link]();
}
}
As you can see in the above example, Printable and Showable interface have
same methods but its implementation is provided by class TestTnterface1, so
there is no ambiguity.

Interface inheritance
A class implements an interface, but one interface extends another interface.
interface Printable{
void print();
}
interface Showable extends Printable{
void show();
}
class TestInterface4 implements Showable{
public void print(){[Link]("Hello");}
public void show(){[Link]("Welcome");}

public static void main(String args[]){


TestInterface4 obj = new TestInterface4();
[Link]();
[Link]();
}
}
Accessing implementations through interface references
We can declare variables as object references that use an interface rather than a
class.
Any instance that implements the declared interface can be referred to by such a
variable.
When you call a method through one of these references, the correct version
will be called based on the actual instance of the interface being referred to.
This process is similar to using a superclass reference to access a subclass
object.
The following example calls the callback() method via an interface reference
variable:

interface Callback {
void callback(int param);
}
class Client implements Callback {
// Implement Callback's interface
public void callback(int p) {
[Link]("callback called with " + p);
}
void aa() {
[Link]("hi.");
}
}
public class Main{
public static void main(String args[]) {
Callback c = new Client();
[Link](42);
}
}

The variable c is declared to be of the interface type Callback, yet it was


assigned an instance of Client.
Although c can be used to access the callback() method, it cannot access any
other members of the Client class.
An interface reference variable has knowledge only of the methods declared by
its interface declaration.
Thus, c could not be used to access aa() since it is defined by Client but
not Callback.

How to extend Interfaces in Java

A program that demonstrates extending interfaces in Java is given as


follows:

interface A {
void funcA();
}
interface B extends A {
void funcB();
}
class C implements B {
public void funcA() {
[Link]("This is funcA");
}
public void funcB() {
[Link]("This is funcB");
}
}
public class Demo {
public static void main(String args[]) {
C obj = new C();
[Link]();
[Link]();
}
}
Output
This is funcA
This is funcB

The interface A has an abstract method funcA(). The interface B extends the
interface A and has an abstract method funcB(). The class C implements the
interface B. A code snippet which demonstrates this is as follows:
interface A {
void funcA();
}
interface B extends A {
void funcB();
}
class C implements B {
public void funcA() {
[Link]("This is funcA");
}
public void funcB() {
[Link]("This is funcB");
}
}
In the method main() in class Demo, an object obj of class C is created. Then
the methods funcA() and funcB() are called. A code snippet which demonstrates
this is as follows:
public class Demo {
public static void main(String args[]) {
C obj = new C();
[Link]();
[Link]();
}
}
Packages: Defining, creating and accessing a package, understanding
classpath, importing packages
A java package is a group of similar types of classes, interfaces and sub-
packages.
Package in java can be categorized in two form, built-in package and user-
defined package.
There are many built-in packages such as java, lang, awt, javax, swing, net, io,
util, sql etc.
Advantage of Java Package
1) Java package is used to categorize the classes and interfaces so that they can
be easily maintained.
2) Java package provides access protection.
3) Java package removes naming collision.

Simple example of java package


The package keyword is used to create a package in java.
//save as [Link]
package mypack;
public class Simple{
public static void main(String args[]){
[Link]("Welcome to package");
}
}
How to compile java package
1. javac -d . [Link]
The -d switch specifies the destination where to put the generated class file. You
can use any directory name like /home (in case of Linux), d:/abc (in case of
windows) etc. If you want to keep the package within the same directory, you
can use . (dot).

How to run java package program


You need to use fully qualified name e.g. [Link] etc to run the class.

To Compile: javac -d . [Link]


To Run: java [Link]
Output:Welcome to package
The -d is a switch that tells the compiler where to put the class file i.e. it represents
destination. The . represents the current folder.
How to access package from another package?
There are three ways to access the package from outside the package.
1. import package.*;
2. import [Link];
3. fully qualified name.
1) Using packagename.*
If you use package.* then all the classes and interfaces of this package will be
accessible but not subpackages.
The import keyword is used to make the classes and interface of another
package accessible to the current package.
Example of package that import the packagename.*
//save by [Link]
package pack;
public class A{
public void msg(){[Link]("Hello");}
}
//save by [Link]
package mypack;
import pack.*;

class B{
public static void main(String args[]){
A obj = new A();
[Link]();
}
}
Output:Hello

2) Using [Link]
If you import [Link] then only declared class of this package will
be accessible.
Example of package by import [Link]
//save by [Link]

package pack;
public class A{
public void msg(){[Link]("Hello");}
}
//save by [Link]
package mypack;
import pack.A;

class B{
public static void main(String args[]){
A obj = new A();
[Link]();
}
}
Output:Hello
3) Using fully qualified name
If you use fully qualified name then only declared class of this package will be
accessible. Now there is no need to import. But you need to use fully qualified
name every time when you are accessing the class or interface.
It is generally used when two packages have same class name e.g. [Link] and
[Link] packages contain Date class.
Example of package by import fully qualified name
//save by [Link]
package pack;
public class A{
public void msg(){[Link]("Hello");}
}
//save by [Link]
package mypack;
class B{
public static void main(String args[]){
pack.A obj = new pack.A();//using fully qualified name
[Link]();
}
}
Output:Hello

Note: If you import a package, subpackages will not be imported.

If you import a package, all the classes and interface of that package will be
imported excluding the classes and interfaces of the subpackages. Hence, you
need to import the subpackage as well.

Note: Sequence of the program must be package then import then class.

Subpackage in java
Package inside the package is called the subpackage. It should be created to
categorize the package further.

Let's take an example, Sun Microsystem has definded a package named java
that contains many classes like System, String, Reader, Writer, Socket etc.
These classes represent a particular group e.g. Reader and Writer classes are for
Input/Output operation, Socket and ServerSocket classes are for networking etc
and so on. So, Sun has subcategorized the java package into subpackages such
as lang, net, io etc. and put the Input/Output related classes in io package,
Server and ServerSocket classes in net packages and so on.
The standard of defining package is [Link] e.g.
[Link] or [Link].
Example of Subpackage
package [Link];
class Simple{
public static void main(String args[]){
[Link]("Hello subpackage");
}
}
To Compile: javac -d . [Link]
To Run: java [Link]
Output:Hello subpackage

How to send the class file to another directory or drive?


There is a scenario, I want to put the class file of [Link] source file in classes
folder of c: drive. For example:
//save as [Link]
package mypack;
public class Simple{
public static void main(String args[]){
[Link]("Welcome to package");
}
}
To Compile:
e:\sources> javac -d c:\classes [Link]
To Run:
To run this program from e:\source directory, you need to set classpath of the directory
where the class file resides.
e:\sources> set classpath=c:\classes;.;
e:\sources> java [Link]
Another way to run this program by -classpath switch of java:
The -classpath switch can be used with javac and java tool.
To run this program from e:\source directory, you can use -classpath switch of
java that tells where to look for class file. For example:
e:\sources> java -classpath c:\classes [Link]
Output:Welcome to package

Ways to load the class files or jar files


There are two ways to load the class files temporary and permanent.
o Temporary
o By setting the classpath in the command prompt
o By -classpath switch
o Permanent
o By setting the classpath in the environment variables
o By creating the jar file, that contains all the class files, and copying
the jar file in the jre/lib/ext folder.

Rule: There can be only one public class in a java source file and it must be
saved by the public class name.
//save as [Link] otherwise Compilte Time Error

class A{}
class B{}
public class C{}

How to put two public classes in a package?


If you want to put two public classes in a package, have two java source files containing
one public class, but keep the package name same. For example:
//save as [Link]

package javatpoint;
public class A{}
//save as [Link]

package javatpoint;
public class B{}

Common questions

Powered by AI

A major limitation of using an interface reference variable in Java is that it can invoke only the methods declared in the interface, not any additional methods that may be defined by the implementing class. For example, if a reference is declared of the interface type Callback and is assigned an instance of Client, it can only access the callback() method and not any other methods such as aa() that may be present in the Client class. This restricts the functionality accessible through the interface reference and requires casting or alternative references to access additional methods .

Using subpackages in a large Java application offers several benefits, such as better organization and categorization of related classes, which enhances code maintainability and clarity. Subpackages can help avoid class name conflicts by providing additional layers of namespace management. However, potential drawbacks include increased complexity if the package hierarchy becomes too deep or fragmented, which might confuse developers regarding where specific classes or functionalities are located. Careful planning and documentation are required to prevent such drawbacks and ensure the package structure remains clear and manageable .

In Java, extending an interface means creating a new interface that inherits the abstract methods of one or more existing interfaces. This is analogous to subclassing, where the new interface can add additional methods. Implementing an interface, on the other hand, involves a class providing concrete implementations for all abstract methods defined in the interface it implements. While extending is used to build on existing interfaces, implementing is about providing operational functionality. For example, interface B can extend interface A to include more methods, and class C can implement interface B to provide the specific behavior .

Interfaces in Java are used for achieving abstraction, supporting the functionality of multiple inheritance, and enabling loose coupling. An interface provides a way to declare methods that must be implemented by classes, without specifying how these methods should be implemented, which aids in abstraction. Additionally, because Java does not support multiple inheritance through classes due to ambiguity issues, interfaces allow multiple inheritance by letting a class implement multiple interfaces. Furthermore, interfaces promote loose coupling by separating the definition from the implementation, allowing changes in the implementation without affecting code that depends on the interface .

Java ensures loose coupling between definition and implementation using interfaces by separating the contract (interface) from the implementation. An interface only defines the methods that need to be implemented, without any specific implementation. This allows different classes to implement the same interface in different ways, providing flexibility. The user of the interface relates to the contract rather than the specific implementation, meaning the underlying implementation can change without affecting the code that uses the interface. This separation makes code more modular and adaptable to change .

Interfaces enhance codebase flexibility by allowing different classes to implement the same interface in diverse ways. This enables the same functionality to be achieved through various implementations, which can be selected or changed at runtime, thus adapting to new requirements without altering the existing code. For maintainability, this means that changes to an algorithm or data handling can be achieved by creating new implementations of the interface, facilitating easier updates and upgrades. However, improper use could lead to unnecessary complexity, so interfaces should be used judiciously to keep the codebase manageable and maintainable .

The 'package' keyword in Java is used to organize classes, interfaces, and sub-packages into namespaces, which enable categorizing the code structure more efficiently. It affects class accessibility by imposing a namespace boundary, whereby classes are not accessible outside their package unless explicitly imported. Packages also help in managing files in large applications by providing controlled access through package-private access level, and they prevent naming collisions by encapsulating classes within a structure specific to a domain, allowing similar class names to co-exist if they reside in different packages .

Using a fully qualified name is preferred in scenarios where there are naming conflicts between classes in different packages. For example, if two packages each have a class named Date, you would use the fully qualified name (e.g., java.util.Date vs. java.sql.Date) to specify which class you are referring to without importing both packages, which could lead to ambiguity. Another reason for using fully qualified names is when you want to avoid importing an entire package or class and just want to access the class or interface in a specific instance, maintaining control over the visible identifiers in your code .

Java interfaces facilitate multiple inheritance by allowing a class to implement multiple interfaces. This is important because Java does not allow multiple inheritance through classes due to potential ambiguity when methods from multiple parent classes overlap. Interfaces resolve this by separating implementation from declaration. Because implementation is defined in the implementing class, and not in the interface itself, there is no ambiguity if multiple interfaces declare the same method signature. Consequently, multiple inheritance through interfaces provides flexibility and modularization in Java programming .

In Java, an interface can represent an IS-A relationship by defining a contract that implementing classes must adhere to. When a class implements an interface, it effectively asserts that "this class IS-A" type of whatever the interface defines. For instance, if an interface Drawable is implemented by a class Rectangle, then Rectangle is a type of Drawable. This IS-A relationship ensures that wherever a Drawable is required, a Rectangle can be used, emphasizing polymorphism and consistency in code design .

You might also like