Object Oriented Programming with Java ****** 23CSI403
Object Oriented Programming with JAVA
23CSI403
MODULE 4
Interfaces: Interfaces, Default Interface Methods, Use static Methods in an Interface, Private
Interface Methods.
Packages: Packages, Packages and Member Access, Importing Packages.
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 1
Object Oriented Programming with Java ****** 23CSI403
Interface in Java
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.
Since Java 8, we can have default and static methods in an interface.
Since Java 9, we can have private methods in an interface.
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.
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 2
Object Oriented Programming with Java ****** 23CSI403
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
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 3
Object Oriented Programming with Java ****** 23CSI403
// by default.
Java 8 Interface Improvement
Since Java 8, interface can have default and static methods which is discussed later.
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.
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 4
Object Oriented Programming with Java ****** 23CSI403
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(){System.out.println("Hello");}
public static void main(String args[]){
A6 obj = new A6();
obj.print();
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 5
Object Oriented Programming with Java ****** 23CSI403
Test it Now
Output:
Hello
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.
File: TestInterface1.java
//Interface declaration: by first user
interface Drawable{
void draw();
//Implementation: by second user
class Rectangle implements Drawable{
public void draw(){System.out.println("drawing rectangle");}
class Circle implements Drawable{
public void draw(){System.out.println("drawing circle");}
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 6
Object Oriented Programming with Java ****** 23CSI403
//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()
d.draw();
}}
Test it Now
Output:
drawing circle
Java Interface Example: Bank
Let's see another example of java interface which provides the implementation of Bank interface.
File: TestInterface2.java
interface Bank{
float rateOfInterest();
class SBI implements Bank{
public float rateOfInterest(){return 9.15f;}
class PNB implements Bank{
public float rateOfInterest(){return 9.7f;}
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 7
Object Oriented Programming with Java ****** 23CSI403
class TestInterface2{
public static void main(String[] args){
Bank b=new SBI();
System.out.println("ROI: "+b.rateOfInterest());
}}
Test it Now
Output:
ROI: 9.15
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{
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 8
Object Oriented Programming with Java ****** 23CSI403
void print();
interface Showable{
void show();
class A7 implements Printable,Showable{
public void print(){System.out.println("Hello");}
public void show(){System.out.println("Welcome");}
public static void main(String args[]){
A7 obj = new A7();
obj.print();
obj.show();
Test it Now
Output:Hello
Welcome
Q) Multiple inheritance is not supported through class in java, but it is possible by an interface,
why?
As we have explained in the inheritance chapter, 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
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 9
Object Oriented Programming with Java ****** 23CSI403
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(){System.out.println("Hello");}
public static void main(String args[]){
TestInterface3 obj = new TestInterface3();
obj.print();
Output:
Hello
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.
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 10
Object Oriented Programming with Java ****** 23CSI403
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(){System.out.println("Hello");}
public void show(){System.out.println("Welcome");}
public static void main(String args[]){
TestInterface4 obj = new TestInterface4();
obj.print();
obj.show();
Output:
Hello
Welcome
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 11
Object Oriented Programming with Java ****** 23CSI403
Java 8 Default Method in Interface
Since Java 8, we can have method body in interface. But we need to make it default method.
Let's see an example:
File: TestInterfaceDefault.java
interface Drawable{
void draw();
default void msg(){System.out.println("default method");}
class Rectangle implements Drawable{
public void draw(){System.out.println("drawing rectangle");}
class TestInterfaceDefault{
public static void main(String args[]){
Drawable d=new Rectangle();
d.draw();
d.msg();
}}
Output:
drawing rectangle
default method
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 12
Object Oriented Programming with Java ****** 23CSI403
Java 8 Static Method in Interface
Since Java 8, we can have static method in interface. Let's see an example:
File: TestInterfaceStatic.java
interface Drawable{
void draw();
static int cube(int x){return x*x*x;}
class Rectangle implements Drawable{
public void draw(){System.out.println("drawing rectangle");}
class TestInterfaceStatic{
public static void main(String args[]){
Drawable d=new Rectangle();
d.draw();
System.out.println(Drawable.cube(3));
}}
Output:
drawing rectangle
27
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 13
Object Oriented Programming with Java ****** 23CSI403
Q) What is marker or tagged interface?
An interface which has no member is known as a marker or tagged interface, for
example, Serializable, Cloneable, Remote, etc. They are used to provide some essential
information to the JVM so that JVM may perform some useful operation.
//How Serializable interface is written?
public interface Serializable{
Nested Interface in Java
Note: An interface can have another interface which is known as a nested interface. We will
learn it in detail in the nested classes chapter. For example:
interface printable{
void print();
interface MessagePrintable{
void msg();
Difference between abstract class and interface
Abstract class and interface both are used to achieve abstraction where we can declare the
abstract methods. Abstract class and interface both can't be instantiated.
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 14
Object Oriented Programming with Java ****** 23CSI403
Abstract class Interface
1) Abstract class can have abstract and non- Interface can have only abstract methods.
abstract methods. Since Java 8, it can have default and
static methods also.
2) Abstract class doesn't support multiple inheritance. Interface supports multiple inheritance.
3) Abstract class can have final, non-final, static and non- Interface has only static and final
static variables. variables.
4) Abstract class can provide the implementation of Interface can't provide the
interface. implementation of abstract class.
5) The abstract keyword is used to declare abstract class. The interface keyword is used to declare
interface.
6) An abstract class can extend another Java class and An interface can extend another Java
implement multiple Java interfaces. interface only.
7) An abstract class can be extended using keyword An interface can be implemented using
"extends". keyword "implements".
8) A Java abstract class can have class members like private, Members of a Java interface are public by
protected, etc. default.
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 15
Object Oriented Programming with Java ****** 23CSI403
9)Example: Example:
public abstract class Shape{ public interface Drawable{
public abstract void draw(); void draw();
} }
But there are many differences between abstract class and interface that are given below.
Simply, abstract class achieves partial abstraction (0 to 100%) whereas interface achieves fully
abstraction (100%).
Example of abstract class and interface in Java
Let's see a simple example where we are using interface and abstract class both.
//Creating interface that has 4 methods
interface A{
void a();//bydefault, public and abstract
void b();
void c();
void d();
//Creating abstract class that provides the implementation of one method of A interface
abstract class B implements A{
public void c(){System.out.println("I am C");}
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 16
Object Oriented Programming with Java ****** 23CSI403
//Creating subclass of abstract class, now we need to provide the implementation of rest of the
methods
class M extends B{
public void a(){System.out.println("I am a");}
public void b(){System.out.println("I am b");}
public void d(){System.out.println("I am d");}
//Creating a test class that calls the methods of A interface
class Test5{
public static void main(String args[]){
A a=new M();
a.a();
a.b();
a.c();
a.d();
}}
Test it Now
Output:
I am a
I am b
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 17
Object Oriented Programming with Java ****** 23CSI403
I am c
I am d
Java 9 Private Interface Methods
In Java 9, we can create private methods inside an interface. Interface allows us to declare
private methods that help to share common code between non-abstract methods.
Before Java 9, creating private methods inside an interface cause a compile time error. The
following example is compiled using Java 8 compiler and throws a compile time error.
Java 9 Private Interface Methods Example
interface Sayable{
default void say() {
saySomething();
// Private method inside interface
private void saySomething() {
System.out.println("Hello... I'm private method");
public class PrivateInterface implements Sayable {
public static void main(String[] args) {
Sayable s = new PrivateInterface();
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 18
Object Oriented Programming with Java ****** 23CSI403
s.say();
Output:
PrivateInterface.java:6: error: modifier private not allowed here
Note: To implement private interface methods, compile source code using Java 9 or higher
versions only.
Now, lets execute the following code by using Java 9. See the output, it executes fine.
Java 9 Private Interface Methods Example
interface Sayable{
default void say() {
saySomething();
// Private method inside interface
private void saySomething() {
System.out.println("Hello... I'm private method");
public class PrivateInterface implements Sayable {
public static void main(String[] args) {
Sayable s = new PrivateInterface();
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 19
Object Oriented Programming with Java ****** 23CSI403
s.say();
Output:
Hello... I'm private method
Such like, we can also create private static methods inside an interface. See, the following
example.
Java 9 Private Static Methods Example
interface Sayable{
default void say() {
saySomething(); // Calling private method
sayPolitely(); // Calling private static method
// Private method inside interface
private void saySomething() {
System.out.println("Hello... I'm private method");
// Private static method inside interface
private static void sayPolitely() {
System.out.println("I'm private static method");
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 20
Object Oriented Programming with Java ****** 23CSI403
public class PrivateInterface implements Sayable {
public static void main(String[] args) {
Sayable s = new PrivateInterface();
s.say();
Output:
Hello... I'm private method
I'm private static method
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 21
Object Oriented Programming with Java ****** 23CSI403
Java Package
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.
Here, we will have the detailed learning of creating and using user-defined packages.
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.
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 22
Object Oriented Programming with Java ****** 23CSI403
Simple example of java package
The package keyword is used to create a package in java.
//save as Simple.java
package mypack;
public class Simple{
public static void main(String args[]){
System.out.println("Welcome to package");
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 23
Object Oriented Programming with Java ****** 23CSI403
How to compile java package
If you are not using any IDE, you need to follow the syntax given below:
javac -d directory javafilename
For example
javac -d . Simple.java
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. mypack.Simple etc to run the class.
To Compile: javac -d . Simple.java
To Run: java mypack.Simple
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.
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 24
Object Oriented Programming with Java ****** 23CSI403
import package.*;
import package.classname;
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 A.java
package pack;
public class A{
public void msg(){System.out.println("Hello");}
//save by B.java
package mypack;
import pack.*;
class B{
public static void main(String args[]){
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 25
Object Oriented Programming with Java ****** 23CSI403
A obj = new A();
obj.msg();
Output:Hello
2) Using packagename.classname
If you import package.classname then only declared class of this package will be accessible.
Example of package by import package.classname
//save by A.java
package pack;
public class A{
public void msg(){System.out.println("Hello");}
//save by B.java
package mypack;
import pack.A;
class B{
public static void main(String args[]){
A obj = new A();
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 26
Object Oriented Programming with Java ****** 23CSI403
obj.msg();
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. java.util and java.sql packages
contain Date class.
Example of package by import fully qualified name
//save by A.java
package pack;
public class A{
public void msg(){System.out.println("Hello");}
//save by B.java
package mypack;
class B{
public static void main(String args[]){
pack.A obj = new pack.A();//using fully qualified name
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 27
Object Oriented Programming with Java ****** 23CSI403
obj.msg();
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.
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 28
Object Oriented Programming with Java ****** 23CSI403
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 domain.company.package e.g. com.javatpoint.bean or
org.sssit.dao.
Example of Subpackage
package com.javatpoint.core;
class Simple{
public static void main(String args[]){
System.out.println("Hello subpackage");
To Compile: javac -d . Simple.java
To Run: java com.javatpoint.core.Simple
Output:Hello subpackage
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 29
Object Oriented Programming with Java ****** 23CSI403
How to send the class file to another directory or drive?
There is a scenario, I want to put the class file of A.java source file in classes folder of c: drive.
For example:
//save as Simple.java
package mypack;
public class Simple{
public static void main(String args[]){
System.out.println("Welcome to package");
To Compile:
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 30
Object Oriented Programming with Java ****** 23CSI403
e:\sources> javac -d c:\classes Simple.java
To Run:
To run this program from e:\source directory, you need to set class path of the directory where the class
file resides.
e:\sources> set classpath=c:\classes;.;
e:\sources> java mypack.Simple
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 mypack.Simple
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
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 31
Object Oriented Programming with Java ****** 23CSI403
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 C.java 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 A.java
package javatpoint;
public class A{}
//save as B.java
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 32
Object Oriented Programming with Java ****** 23CSI403
package javatpoint;
public class B{}
LAB PROGRAM:
Develop a JAVA program to create a package named mypack and import & implement
it in suitable class.
package mypack;
public class A{
private int n;
public mypack( int x){
n=x;
public void msg(){System.out.println("Hello the number is:"+n);}
//save by B.java
package mypackApp;
import mypack.*;
class B{
public static void main(String args[]){
A obj = new A(10);
obj.msg();
Output:Hello the number is:10
Mr. Dhananjaya M, Dept. of CSE, SJBIT Page 33
