Scribd
Upload
88 views4 pages

Unit IV Packages&Interfaces

Packages are used to group related classes and interfaces to avoid naming conflicts. A package is defined by including a package statement at the top of a Java file. Classes in different packages must be imported to be used. Interfaces define abstract methods and can be implemented by classes using the implements keyword. Interfaces differ from classes in that interfaces cannot be instantiated, contain only static final fields, and define abstract methods.

Uploaded by

reddy
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOC, PDF, TXT or read online on Scribd
88 views4 pages

Unit IV Packages&Interfaces

Packages are used to group related classes and interfaces to avoid naming conflicts. A package is defined by including a package statement at the top of a Java file. Classes in different packages must be imported to be used. Interfaces define abstract methods and can be implemented by classes using the implements keyword. Interfaces differ from classes in that interfaces cannot be instantiated, contain only static final fields, and define abstract methods.

Uploaded by

reddy
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOC, PDF, TXT or read online on Scribd
You are on page 1/ 4

Packages & Interfaces

Definition: A package is a collection of classes, interfaces and other packages.


Packages resemble directories or folders.

Packages are used to group the logical related classes and interfaces.
Packages help in avoiding name conflicts.

Creation of package: Creation of a package is simply putting a class or interface in


it. So for this we need to add a package statement in the class or the interface we define.
package packageName;

Ex: 1
package graphics;

class Circle{
…….
}

package graphics;

class Rectangle{
…….
}

A package statement should be written at the top of every source/ java file.

If a class doesn’t have the package statement, then the class is placed in the default
package, which is the current directory location.

Accessing a package: For example if we have created the above package graphics in
say d:\ java\ graphics\Circle.java
Then if we run the Circle.java program. It will first search for the class in the current
directory or in the location where the CLASSPATH environmental variable is set.

If we always run any java program from one level above the package level, then there is
no need to set the classpath variable.
But if we set the CLASSPATH variable, then we have to run the java programs from that
path.
Importing packages:

package graphics; package graphics3D ;

Circle.java extends Rectangle3D.java


Rectangle.java
Triangle.hava

If a class Rectangle3D extends a class Rectangle existing in some other package, it has to
first import that package into the current package in order to use the classes in it.

Ex:
package graphics3D;

import graphics;

class Rectangle3D extends Rectangle{

…..
}

import is the keyword used to access the classes or interfaces of one package into
another.

Interface: An interface is a way to declare a type consisting only of abstract methods


and related constants (final data), enabling any implementation to be written for those
methods. An interface provides a protocol binding to the classes that implement it.

An interface is a collection of abstract methods and constants (final data members).

An interface cannot be instantiated.

An interface can contain only final type variables.

Fields in an interface are always static and final.

interface is the keyword used for creating interfaces.

accessSpecifier interface name{


type final-variable1 = value;
type final-variable2 = value;
… ..
.
return-type method-name1(parameter list);
return-type method-name2(parameter list);
..
..
}

Ex 1:
interface Polygon{
float PI = 3.13f;

float area();
float circumference();
}

All the methods in an interface are implicitly abstract.

The abstract methods of an interface are implemented by a class using implements


keyword.

Implementing an Interface:
Ex 1 continued.

class Circle implements Polygon{


public float radius:

public Circle( float r){


radius= r;
}

public float area(){


return PI * radius * radius ;
}

public float circumference{


return 2*PI * radius ;
}
}

class PolygonUse{
public static void main(String args[]){
Circlew c= new Circle();
System..out.println(“Area of circle = ”+ c.area() );
System..out.println(“Circumference of circle = ”+ c.circumference() );
}

The class which implements an interface should give definitions to all its abstract
methods.
If the above Polygon class doesn’t give the implementation to all the abstract methods of
the interface, then the class has to be declared as abstract.

Differences between classes and interfaces:

Classes Interfaces
1) Classes can be instantiated 1) Interfaces cannot be instantiated
2) Classes can have all types of data 2) Interfaces can have only final variables.
members.
3) One class can extend the function of 3) A class implements an interface using
another class using the extends keyword. the implements keyword.
4) Methods in classes are concrete/ 4) Methods in an interface are by default
abstract abstract
5) Classes are defined with keyword 5) Interfaces are defined using the keyword
“class”. “interface”

Extending interfaces:
An interface can extend another interface. Unlike classes, an interface can extend more
than one interface.

Ex:
interface A{
…..
}

interface B extends A{
…..
}

class C implements B{
……
}

Note: Multiple inheritance is not directly supported in java through classes, but can be
achieved using interfaces.

You might also like