Chapter Two Object Oriented Programming

Chapter Two
2. The Inside of Objects and Classes: More OOP Concepts.

2.1 Member Functions and Their Components.

Class Declaration
- Class is a java keyword and all the normal keyword restrictions apply. One
way of thinking about a java class is to note that they resemble structures. We
simply use the key word class instead of struct, and the member of the
structure become private by default.
- the class declaration syntax is:
- class class_name{
data_members;
...
class_methods();
...;
}

Instantiation & Initializing class objects.

- The process of creating an object from a class is called instantiation. To
create an object from a java class, one must use the ‘new’ keyword.

Object Creation
- No object is actually created by the declaration process. An object
declaration simply declares the name (identifier), which we use to refer to an
object. eg:
- Account account; designate that the name account is used to refer to an
account object, but the actual Account object is not yet created. We create
an object by invoking the new command. the syntax is:
- <object name> = new <class name>(<arguments>);
- Where <object name> is the name of a declared object, <class name> is the
name of the class to which the object belongs, and <argument> is a
sequence of values passed to the method.
- let us see the distinction between object declaration and object
creation/instantiation

1
Chapter Two Object Oriented Programming

A. Account account;

State of memory after A is executed account

The identifier account is

declared and placed in
Memory

Created with Created with

the first new the second new
2
Chapter Two Object Oriented Programming

Since there is no reference to the first customer object anymore, it will eventually be
erased and returned to the system. Remember that when an object is created, a certain
amount of memory space is allocated for storing objects. If this allocated but unused
space is not returned to the system for other use, the space gets wasted. This returning of
space to the system is called deallocation, and the mechanism to deallocate unused
space is called garbage collection

Constructors
- A constructor is a special initialization method that is called automatically
whenever an instance of a class is created. The constructor member method
has, by definition, the same name as the corresponding class. The constructor
has no return value specification, not even void. The Java run-time system
makes sure that the constructor of a class is called when instantiating an
object.
- Constructors are used to initialize the data members of the class. If we have
data members that must be initialized, we must have a constructor. In our
constructor, we should not do something that might fail because; the
constructor does not return a value.

Default (Non-Parameterized) constructors -

Let us look at the following example.

public class Employee{

private String empName;
private String address;

public Employee()
{
empName = “”;
address = “”;
}
}//end class

- The constructor Employee() is a default or a non-parameterized

constructor, because it declares no parameters.

3
Chapter Two Object Oriented Programming

Parameterized constructors
- The parameterized constructors can accept values into the constructor that
has different parameters in the constructor. The value would be transferred
from the main() method to the constructor either with direct values or through
variables.

Using overloaded constructors

- Overloaded constructors enable object of a class to be initialized in different
ways. To overload constructors, simply provide multiple constructor declarations
with different parameter lists.
- Attempting to overload a constructor with another constructor that has the exact
same signature (name and parameters) is a syntax error.
- for instance, consider the constructors of the following class:

Public class Person{

}
}//end of class
4
Chapter Two Object Oriented Programming

- The above class contains five overloaded constructors that provide convenient
ways to initialize objects of class person. Each constructor guarantees that
every object the constructor initializes begins in a consistent state.
- The above class uses the keyword this to call / invoke a specific constructor
with the specified number and type of argument. It is a syntax error, when the
‘this’ reference is used in a constructor’s body to call another constructor of
the same class and that statement is not the first statement in the constructor. It
is also a syntax error when a non-constructor method attempts to invoke a
constructor directly via the ‘this’ reference.

Methods
- Methods (sometimes called functions or procedures) allow the programmer to

modularize a program by separating its tasks into self-contained units. These units are

sometimes called programmer defined methods.

- A method is invoked or called by a method call. The method call specifies the
name of the method and provides information (arguments) that the called
method requires to perform its task. When the method call completes, the
method either returns a result to the calling method (or caller) or simply
returns the control to the caller.
- The first line of the method declaration is called the method header.
Following the method header, declaration and statements in brace form the
method body, which is a block. Variables can be declared in any block, and
blocks can be nested. A method can’t be declared inside another method.
- the basic format of a method declaration is :
- return-value-type method-name(para1,para2,...,paraN)
{
declarations and statements;
}
- The method-name is any valid identifier. The return-type is the type of the
result returned by the method to the caller. The return-type void indicates that
a method does not return a value. Methods can return at most one value.
- eg. public double maximum(double x,double y,double z)
{
return Math.max(x,Math.max(y,z));
}
5
Chapter Two Object Oriented Programming

Access specifiers and methods

- Access specifiers are used to restrict access to the method. Regardless of
what the access specifier is, the method is accessible from any other method
in the same class. However, although all methods in a class are accessible by
all other methods in the same class, there are certain necessary tasks that you
might not want other objects to be able to perform.
- Let us see the access specifiers of Java language; public, private and
protected.
- public: the public modifier is the most relaxed possible for a method. by
specifying a method as public, it becomes accessible to all classes regardless
of their lineage or their package;
- protected: any class that extends the current class can access protected
members. But other classes which are not related to the current class in an
inheritance can’t make use of the protected members of the current class. If
you didn’t assign a modifier in front of a class declaration, the class is
created.

with the default properties. By default, all classes are assigned to package
level visibility. This means that while the class may be extended and
employed by other classes, only those objects within the same package
may make use of this class.
- private: private is the highest degree of protection that can be applied to a
method. A private method is only accessible by those methods in the same
class. Even classes that extend from the current class do not have access to a
private member.
Other important concepts :
- final: final classes may not have any subclasses and are created by placing the
modifier final in front of he class declaration. A variable can be decaled as
final. Doing so prevents its contents from being modified. This means that you
must initialize a final variable when it is declared. (In this usage, final is
similar to const in C++).
- abstract: an abstract class is a class that is incomplete, or to be considered
incomplete. Only abstract classes may have an abstract method. That is,
methods that are declared but not yet implemented. If a class that is not
abstract contains an abstract method, then a compile-time error occurs. A
class has abstract methods if any of the following is true; if: it explicitly
contains a declaration of an abstract method. it inherits an abstract method
from its direct superclass.
- An abstract class is defined with the modifier abstract. No instance can be
created from an abstract class. consider the following example:

6
Chapter Two Object Oriented Programming

the keyword abstract public class Student{

abstract here protected String name;
denotes an abstract protected String courseGrade;
class
public Student()
{
this(“No Name”);
}

public Student(String studName)

{
name = studName;
courseGrade = “NG”;
}
here the keyword abstract public void computeCourseGrade();
denotes an abstract
method public String getCourseGrade()
{
return courseGrade;

public String getName()

{
return name;
}
}//end class

- An abstract method is a method with the keyword abstract and it ends with a
semicolon instead of a method body. We say a method is implemented if it
has a method body.

Accessors and Mutators. / get() and set() Methods

- private fields can be manipulated only by methods of the class in which the
fields are declared. Classes often provide public methods to allow clients of the
class to set (i.e., assign values to) or get (i.e., obtain the values of) private
instance variables. These methods need not be called set and get, but they often
are. Set methods are also commonly called mutator methods (because they
typically change a value). Get methods are also commonly called accessors or
query methods.
- If an instance variable is declared public, the instance variable can be read
7
Chapter Two Object Oriented Programming

or written at will by any method that has reference to an object of the class
in which the instance variable is declared.
- Using a public set and get method ensures that the new value is appropriate
for that data item. For example, an attempt to set the day of the month for a
data to 37 would be rejected; an attempt to set a person’s weight to a
negative value would be rejected, and so on. So, although set and get
methods could provide access to private data, the access is restricted by the
programmer’s implementation.

Calling and returning: methods

- Generally, the calling method controls method calls and their order. The
called method is controlled by the calling method.
- Let us see an example:

public class First{

public void next_fun()
{
System.out.println(“Inside next_fun()”);
}

public void third_fun()

{
System.out.println(“inside third_fun()”);
}
}//end class

public class TestFirst{

public static void main(String args[])
{
First fr = new First();
fr.next_fun();
fr.third_fun();
System.out.println(“main() is completed”);
}
}//end class

8
Chapter Two Object Oriented Programming

Passing values to methods

- Java provides two methods for passing variables between methods. We will see
passing by value and passing by address in the following section.

Passing by value
- Here, the actual variable will not be passed; rather, the value of the variable is
passed to the receiving method. Because the value/copy of the variable is
passed to the receiving method, the receiving method can’t modify the calling
method’s variable.
- Consider the following program that calculates the factorial of a give
number. The example illustrates passing by value.

import java.io.*;
public class Factorial{
public void calcFact(int n)
{
int i, fact=1;
for(int i=1;i<=n;i++)
fact*=i;
System.out.println(“the factorial of ”+n+ “is ”+fact);
}
}//end class

public class TestFactorial{

public static void main(String args[]){

Factorial fact = new Factorial();

InputStreamReader reader = new InputStreamReader(System.in);
BufferedReader input = new BufferedReader(reader);
String num =input.readLine();
int n =Integer.parseInt(num);
fact.calcFact(n); }
}//end class

9
Chapter Two Object Oriented Programming

Passing by address
- When we pass an argument (local variable) by address, the variable’s address is
assigned to the receiving method’s parameter. The address of the variablenot its
value is copied to the receiving method’s parameter when we pass a variable
address. In Java, all the arrays are passed by address.

Passing arrays to methods

- Java automatically passes arrays to methods using simulated call-byreference; the
called methods can modify the element values in the callers, the original values. The
value of the name of the array is the address of the first element of the array.
Because the starting address of the array is passed, the called method knows
precisely where the array is stored.
- Although entire array are passed simulated call-by-reference yet the individual
array elements are passed call-by-value, exactly as simple variables are. For a
method to receive an array through a method call, the method’s parameter list
must specify that an array would be received.
- Eg. public class ArrayEg{
public void modifyArray(int num[])
{
for(int i=0;i<num.length;i++)
num[i]+=2;
System.out.println(“inside modifyArray()”);
for(int i=0;i<num.length;i++)
System.out.println(num[i]+” ”);
}
}//end class

public class TestArray{

public static void main(String args[])
{
int a[] = new int[10];
for(int i=0;i<a.length;i++)
a[i]=i+1;
System.out.println(“inside main()”);
for(int i=0;i<a.length;i++)
System.out.print(a[i]+ “ ”);
ArrayEg aEg = new ArrayEg();
System.out,println();
aEg.modifyArray(a);
System.out.println();
System.out.println(“back inside main()”);
for(int i=0;i<a.length;i++)
System.out.print(a[i]+ “ ”);
}
}//end class
10
Chapter Two Object Oriented Programming

Method return values

- When we want to return a value from a method to its calling method, we put
the return value after the return statement.
- Do not return global variables. There would not be any need to do so
because their values are already known thought the code.

Static versus instance members

- Each object has its own copy of all the instance variables of a class. In certain
cases, only one copy of a particular variable should be shared by all objects of
a class. A static field-called a class variable- is used in such case, among
others. A class variable represents class-wide info- all objects of the class
share the same piece of data. The declaration of a static member begins with
the keyword static.
- Although class variables may seem like global variables, class variables have
class scope. A class’s public static member can be accessed through a reference
to any object of that class, or they can be accessed by qualifying the member
name with the class name and a dot (.), as in Math.random(). A class’s private
static class member can only be accessed through methods of that class.
Actually, static class member exist even when no object of that class exist- they
are available as soon as the class is loaded into memory at execution time. To
access a private static member when no object of the class exist, a public static
method must be provided and the method must be called by qualifying its name
with the class name and a dot. Consider the following example.

11
Chapter Two Object Oriented Programming

public class Employee{

private String firstName;
private String secondName;
private static int count1=0;
public static int count2=0;

public Employee(String fName,String sName)

{
firstName=fName;
secondName=sName;
count1++;
count2++;
}

public String getFirstName()

{
Return firstName;
}

public String getSecondName()

{
Return secondName;
}

public static int getCount()

{
Return count1;
}
}//end class

public class TestStatic{

public static void main(String args[])
{
System.out.println(“using public method:”+Employee.getCount());
System.out.println(“using public var:”+Employee.count2);
Employee e1 = new Employee(“Saba”,”Getachew”);
Employee e2 = new Employee(“Zeritu”,”Kebede”);
System.out.println(“using public method:”+e1.getCount());
System.out.println(“using public var:”+e2.count2);
System.out.println(“Afterinstantiation:”+Employee.getCount());
System.out.println(“After instantiation:”+Employee.count2);
System.out.println(“accessing instance members”)

12
Chapter Two Object Oriented Programming

System.out.println(“employee1:”e1.getFirstName()+“”+e1.getSecondName());
System.out.println(“employee2:”e2.getFirstName()+ “”+e2.getSecondName());
}
}//end class

NB: A method declared static can’t access a non-static class member. Unlike non static
methods, a static method has no “this” reference because static variables and static
methods exist independent of any object of a class whether or not any objects of the
class have been instantiated.

13