Methods and constructors

Programming in Java
Lecture 6: Methods, Constructors and Interfaces
By
Ravi Kant Sahu
Asst. Professor, LPU

Methods
Ravi Kant Sahu, Asst. Professor @ Lovely Professional University, Punjab (India)

Method
• A method is a construct for grouping statements together
to perform a function.
• A method that returns a value is called a value retuning
method, and the method that does not return a value is
called void method.
• In some other languages, methods are referred to as
procedures or functions.
• A method which does not return any value is called a
procedure.
• A method which returns some value is called a function.

Defining a Method
Syntax:
modifier returnType methodName (list of parameters)
{
// Body of the method(set of statements);
}
Example:
public static void main (String args[])
{
…
}
Method Header
Method Body

• Method header specifies the modifier, return type, method
name and parameters of method.
public void display()
{…}
• The variables defined in method header are called formal
parameters or parameters.
int display(int x, int y)
{…}
• When a method is invoked, a value as a parameter is
passed which is known as actual parameters or arguments.
a.display (3, 5);

• Method body contains a set of statements that define the
function to be performed by the method.
• A return statement using the keyword return is required for a
value-returning method to return a result.

Calling a Method
• To use a method, we need to call or invoke it.
• There are two ways to call a method:
– If the method returns a value, a call to method is usually
treated as a value.
int area = rectangleArea (4,6);
System.out.println( rectangleArea (4,6) );
– If the method returns void, a call to method must be a
statement.
– For example, println method returns void
System.out.println(“Hello…”);

CONSTRUCTORS

Constructors
• A constructor is a special method that is used to initialize a newly
created object.
• It is called just after the memory is allocated for the object.
• It can be used to initialize the objects, to required, or default
values at the time of object creation.
• Constructor cannot return values.
• Constructor has the same name as the class name.
• It is not mandatory for the coder to write constructor for the class.

Default Constructor
• If no user defined constructor is provided for a class,
compiler initializes member variables to its default
values.
– numeric data types are set to 0
– char data types are set to null character(‘’)
– reference variables are set to null
• In order to create a Constructor observe the following
rules:
– It has the same name as the class
– It should not return a value, not even void

Defining a Constructor
 Like any other method
 Invoking:
◦ There is NO explicit invocation statement needed: When
the object creation statement is executed, the constructor
method will be executed automatically.
public class ClassName {
// Data Fields…
// Constructor
public ClassName()
{
// Method Body Statements initialising Data Fields
}
//Methods to manipulate data fields
}

Constructors
• Constructor name is class name. A constructors must have
the same name as the class its in.
• Default constructor. If you don't define a constructor for a
class, a default (parameter-less) constructor is automatically
created by the compiler.
• The default constructor initializes all instance variables to
default value (zero for numeric types, null for object
references, and false for booleans).

Key Points
• Default constructor is created only if there are no
constructors.
• If you define any constructor for your class, no default
constructor is automatically created.
• There is no return type given in a constructor signature
(header).
• There is no return statement in the body of the
constructor.

Key Points
• The first line of a constructor must either be a call on
another constructor in the same class (using this), or a call
on the super-class constructor (using super).
• If the first line is neither of these, the compiler
automatically inserts a call to the parameter-less super
class constructor.

Need of Constructors
public class Cube1 {
int length;
int breadth;
int height;
public int getVolume() {
return (length * breadth * height);
}
public static void main(String args[]){
Cube1 obj1= new Cube1();
Int vol;
obj1.length=10;
obj1.breadth=20;
obj1.height=30;
vol=obj1.getVolume();
………
WAP to find out the volume of a cube in which
length, width and height of the cubes are different
for two objects.

Alternative
int length;
int breadth;
int height;
public int getVolume() {
return (length * breadth * height);
}
void setDim(int l, int b, int h){
length=l;
breadth=b;
height=h;
}
public static void main(String args[]){
Int vol;
obj1.setDim(10,20,30);
vol=obj1.getVolume();
………Ravi Kant Sahu, Asst. Professor @ Lovely Professional University, Punjab (India)

Using Constructor
int length;
int breadth;
int height;
public int getVolume()
{ return (length * breadth * height); }
Cube1() { length = 10;
breadth = 10;
height = 10; }
public static void main(String[] args) {
Cube1 c1 = new Cube1();
System.out.println("Volume of Cube1 is : " +
c1.getVolume()); }
}

Parameterized Constructors
Cube1() { length = 10;
breadth = 10;
height = 10; }
Cube1(int l, int b, int h) { length = l;
breadth = b;
height = h; }
Cube1 c2 = new Cube1(10, 20, 30);
System.out.println("Volume of Cube1 is : " + c1.getVolume());
System.out.println("Volume of Cube1 is : " + c2.getVolume());
}
}

Constructor Overloading
class Cube1 {
int length, breadth, height;
Cube1() { length = 10; breadth = 10; height = 10; }
Cube1(int l) { length = l; }
Cube1(int l, int b, int h) { length = l; breadth = b; height = h }
Cube1 c2 = new Cube1(50);
Cube1 c3 = new Cube1(10, 20, 30);
}
}

Abstract Class
• An abstract class is a class that is declared abstract.
• An abstract method is a method that is declared without an
implementation (without braces, and followed by a
semicolon), like this:
abstract void moveTo(double deltaX, double deltaY);
• Abstract class may or may not include abstract methods.
• Abstract classes cannot be instantiated, but they can be sub-
classed.

• If a class includes abstract methods, the class itself must be
declared abstract, as in:
public abstract class GraphicObject
{ // declare fields
// declare non-abstract methods
abstract void draw();
}
• When an abstract class is sub-classed, the subclass usually
provides implementations for all of the abstract methods in its
parent class.
• However, if it does not, the subclass must also be declared
abstract.

• It can be considered as a blank form consisting of
several sections, some of them may be optional (non-
abstract method) and some may be mandatory
(abstract)…
• Can we Override a constructor?
If yes, How? if No, Why?

Interfaces

Interfaces
• An interface is a collection of abstract methods.
• An interface is a group of related methods with empty bodies.
• An interface is not a class.
• A class describes the attributes and behaviors of an object
whereas an interface contains behaviors that a class
implements.
• A class implements an interface, thereby inheriting the abstract
methods of the interface.
• Unless the class that implements the interface is abstract, all
the methods of the interface need to be defined in the class.

Properties of Interfaces
• The interface keyword is used to declare an interface.
• Interfaces have the following properties:
– An interface is implicitly abstract. We do not need to use
the abstract keyword when declaring an interface.
– Each method in an interface is also implicitly abstract, so
the abstract keyword is not needed.
– Methods in an interface are implicitly public.

Interface Vs Class
An interface is similar to a class in the following ways:
• An interface can contain any number of methods.
• An interface is written in a file with a .java extension, with the
name of the interface matching the name of the file.
• The byte-code of an interface appears in a .class file.
• Interfaces appear in packages, and their corresponding byte-
code file must be in a directory structure that matches the
package name.

Interface Vs Class
An interface is different from a class in several ways,
including:
• We cannot instantiate an interface.
• An interface does not contain any constructors.
• All of the methods in an interface are abstract.
• An interface is not extended by a class; it is implemented by a
class.
• An interface can extend multiple interfaces.

Implementing Interfaces
• When a class implements an interface, then it has to
perform the specific behaviors of the interface.
• If a class does not perform all the behaviors of the
interface, the class must declare itself as abstract.
• A class uses the implements keyword to implement an
interface.
• The implements keyword appears in the class declaration
following the extends portion of the declaration.

Example
interface Animal
{
public void eat();
public void travel();
}

Example
public class Mammal implements Animal
{
public void eat()
{
System.out.println("Mammal eats");
}
public void travel()
{
System.out.println("Mammal travels");
}
public int noOfLegs()
{ return 0; }
public static void main(String args[])
{
Mammal m = new Mammal();
m.eat();
m.travel();
}
}

Abstract Class Vs Interfaces
Abstract Class Interface
May contain non-abstract methods
and non-static non final data members
Contains only method declaration and
static final data members
Multiple Inheritance is not supported
through classes
Multiple Inheritance through
Interfaces is supported
Classes provide static classing
environment
Interfaces provide dynamic classing
environment
Inheritance using ‘extends’ keyword Inheritance using ‘implements’
keyword

Why Interfaces?

Problem?
• Define a class named ‘Invoker’ that contains a static
method ‘invoke()’.
• ‘invoke ()’ receives an object of a class that contains
‘show()’.
• From the invoke() we have to invoke show() on the
argument object.

class Invoker
{
public static void invoke(___ x)
{
x.show();
}
}
Problem1: Type of argument object is not known…
Problem2: There is no guarantee that the class whose object is
provided as an argument contains show()…
Problem3: We can’t use abstract class here because it does not
support multiple inheritance.

Why Interfaces?
• We have Abstract classes…then what is the need of
Interfaces?
• To facilitate Multiple Inheritance
• To provide Dynamic classing environment

Solution is Interface
Interface Showable
{
void show();
}
class Invoker
{
public static void invoke(Showable x)
{
x.show();
}
}

class A implements Showable
{
String name;
public A(String s)
{
name=s;
}
public void show()
{
System.out.println(“It is object:” + name);
}
}

class B implements Showable
{
int p;
public B(int x)
{
p=x;
}
public void show()
{
System.out.println(“value of p is:” + p);
}
}

Class InterfaceTest
{
public static void main(String arr[])
{
A m = new A(“Hello”);
B n = new B(10);
Invoker.invoke(m);
Invoker.invoke(n);
}
}

Methods and constructors

Related slideshows

More Related Content

Methods and constructors