Chapter 3

Chapter 2 The inside of objects and classes
By
Sirage Zeynu (M.Tech)
School of Computing

13-04-2021 class and object 2
Outline of this chapter
1. member methods and their components
2. instantiation and initializing class objects
3. constructors
1. default and parameterized
2. overloaded constructors
4. methods
5. access specifiers
6. accessors and mutators
7. calling and returning methods
8. static and instance members

What is class ?
• A class is a blueprint from which individual objects are
created.
 A class can be defined as a template/blueprint that describes
the behaviour/state that the object of its type support.
• a class is a template for an object, and an object is an instance
of a class. Because an object is an instance of a class, you will
often see the two words, object and instance, used
interchangeably.
Class Fundamentals

What is class ?
A class can contain any of the following variable types.
 Local variables: Variables defined inside methods, constructors
or blocks are called local variables. The variable will be declared
and initialized within the method and the variable will be
destroyed when the method has completed.
 Instance variables: Instance variables are variables within a
class but outside any method. These variables are initialized when
the class is instantiated. Instance variables can be accessed from
inside any method, constructor or blocks of that particular class.
 Class variables: Class variables are variables declared within a
class, outside any method, with the static keyword.
Class Fundamentals

what are objects?
 If we consider the real-world, we can find many objects around
us, cars, dogs, humans, etc. All these objects have a state and a
behaviour.
 If we consider a dog, then its state is - name, breed, color, and
the behaviour is - barking, wagging the tail, running.
 If you compare the software object with a real-world object, they
have very similar characteristics.
 Software objects also have a state and a behaviour. A software
object's state is stored in fields and behaviour is shown via
methods.
 So in software development, methods operate on the internal state
of an object and the object-to-object communication is done via
methods.

The General Form of a class
To create a class, a source file with the class keyword in it followed by a
legal identifier and a pair of curly braces for the body is required. The
general form of a class definition is shown here:
class ClassName {
type instance-variable1;
type instance –variable2;
type instance-variableN;
type methodName ( Parameter-list )
{
// body of the method
}
}
Collectively, the
methods and variables
defined within a class
are called members of
the class.

Example of sample class
// Class declaration with a method
public class Dog {
String breed; //instance variable
String color; //instance variable
int age; //instance variable
void hungry()
{
}
void sleeping()
{
}
void barking()
{
}

 new is a Java keyword. It creates a Java object and allocates
memory for it on the heap. new is also used for array creation, as
arrays are also objects.
 Syntax:
JavaType variable = new JavaObject();
className object= new className();
If you create an instance of a class, you are creating an object that
contains its own copy of each instance variable defined by the
class.
The New Keyword

Example of the use new oprator
// A program that uses the Box class
public class Box {
double width;
double height;
double depth;
}
class BoxVolum {
public static void main(String[] args){
Box mybox = new Box();
double vol;
mybox.width = 20;
mybox.height = 30;
mybox.depth = 10;
vol = mybox.width * mybox.height * mybox.depth;
System.out.println("Volume is " + vol);
}
}

Declaring Objects
A typical Java program creates many objects, which as you
know, interact by invoking methods.
Through these object interactions, a program can carry out
various tasks, such as implementing a GUI, running an
animation, or sending and receiving information over a
network.
Once an object has completed the work for which it was
created, its resources are recycled for use by other objects.
The general declaration of object
JavaType variable = new JavaObject();
className object= new className();

obtaining objects of a class is a two-step process .
First , you must declare a variable of the class type . This
variable does not define an object. Instead, it is simply a
variable that can refer to an object.
Second , you must acquire an actual, physical copy of the
object and assign it to that variable. You can do this using a
new operator . The new operator dynamically allocates ( that is,
allocates at run time) memory for an object and returns a
reference to it. This reference is, more or less, the address in
memory of the object allocated by new.
Example Box mybox = new Box ( ) ;

Assigning Object Reference Variables
 Object reference variables act differently than you might expect when an
assignment take place.
 For example, what do you think the following fragment does
Box b1 = new Box( );
Box b2 = b1;
You might think that b2 is being assigned a reference to a copy of the
object referred to by b1. That is , you might think that b1 and b2 refer to
separate and distinct objects. However, this would be wrong. Instead , after
this fragment executes, b1 and b2 will both refer to the same object. The
assignment of b1 and b2 did not allocate any memory or copy any part of
the original object . It simply makes b2 refer to the same object as does b1.
Thus, any changes made to the object through b2 will affect the object to
which b1 is referring, since they are the same object.

Methods
 Methods are functions that operate on instances of classes in
which they are defined.
 Objects can communicate with each other using methods and
can call methods in other classes.
 Just as there are class and instance variables, there are class
and instance methods .
 Instance methods apply and operate on an instance of the
class while class methods operate on the class .

Defining Methods
 Method definition has four parts .
 They are , name of the method, type of object or primitive type
the method returns, a list of parameters and body of the method.
 Java permits different methods to have the same name as long as
the argument list is different.
Returntype methodname ( type1 arg1 , type2 arg2 ) {
// Body of the methods
}
 The returntype is the primitive type or class of the value this
method returns .
 It should be void if the method does not return a value at all .
 The parameters become local variables in the body of the method
whose values are passed when the method is called

 Modifiers—such as public, private, and others
 The return type
 The method name
 The parameter list in parenthesis—a comma-delimited list of input parameters,
preceded by their data types. If there are no parameters, you must use empty
parentheses.
 An exception list—to be discussed later.
 The method body, enclosed between braces—the method's code, including the
declaration of local variables, goes here.
 Here is an example of a typical method declaration:
public double calculateAnswer(double wingSpan, int numberOfEngines, double length, double
grossTons) {
//do the calculation here}
More generally, method declarations have

 Although a method name can be any legal identifier, code conventions
restrict method names.
 By convention, method names should be a verb in lowercase or a multi-
word name that begins with a verb in lowercase, followed by adjectives,
nouns, etc. In multi-word names, the first letter of each of the second and
following words should be capitalized.
 Here are some examples:
run runFast
getBackground getFinalData
compareTo setX
isEmpty getName
Naming a Method

Calling methods
 Calling method is similar to calling or referring to an instance
variable .
 The methods are accessed using the dot notation .
 The object whose method is called is on the left of the dot,
while the name of the method and its arguments are on the
right .
Obj.methodName ( param1, param2,paramN )

Class Methods
 Class methods, like class variables, are available to instance of the class
and can be made available to other classes Methods that operate on a
particular object should be defined as instance methods.
 Methods that provide some general utility but do not directly. affect an
instance of the class are declared as class methods.
Class method is defined as given below :
static returntype methodname ( type1 arg1 , type2 arg2, .. )
{
// Body of the method
}
 The static keyword indicates that it is a class method and can be accessed
without creating a object .

Parameters refers to the list of variables in a method
declaration.
Arguments are the actual values that are passed in when the
method is invoked.
When you invoke a method, the arguments used must match the
declaration's parameters in type and order.
The objects that are passed to the body of the method are passed
by reference and the basic types are passed by value
Passing Argument to methods

Returning a Value
Out put
Volume is 3000.0

 A constructor method is a special kind of method that
determines how an object is initialized when created.
 They have the same name as the class and do not have any
return type.
 Constructor declarations look like method declaration except
that they use the name of the class and have no return type.
 When the keyword new is used to create an instance of a class,
Java allocates memory for the object, initializes the instance
variables and calls the constructor methods.
 Constructors can also be overloaded.
Constructor

 In Java it is possible to define two or more methods within the
same class that share the same name, as long as their parameter
declarations are different.
 The methods are said to be overloaded , and the process is referred
to as method overloading.
 Method Overloading is one of the ways that Java implements
polymorphism.
 While overloaded methods may have different return types, the
return type alone is insufficient to distinguish two versions of a
method . When Java encounters a call to an overloaded method,
it simply executes the version of the method whose parameters
match the arguments used in the call.
Overloading Method

 Constructors can also take varying numbers and types of
parameters.
 This enables creation of objects with the properties required.
Overloading Constructors

 Access control is controlling visibility of a variable or method . When a method
or variable is visible to another class, its methods can references the method or
variable.
 Java's access specifiers are
public,
private,
protected
default
 A public class member can be accessed by any other code.
 A private class member can only be accessed within its class.
 A default access class member has no access specifiers. A class's default features
are accessible to any class in the same package.
 A protected feature of a class is available to all classes in the same package(like
a default) and to its subclasses. protected applies only when inheritance is
involved.
Java Access Control

class A{
private int j; // private to A
}
class B extends A {
int total;
void sum() {
total = j; // ERROR, j is not accessible here
} }

The following table shows the access matrix for Java. Yes means
accessible, no means not accessible.

 static keyword always fixed the memory that means that will be located
only once in the program
 When a member is declared static, it can be accessed before any objects
of its class are created , and without reference to any object you can
declare both methods and variables to be static.
 The most common example of a static member is main( ). main( ) is
declared as static because it must be called before any objects exist.
 where as final keyword always fixed the value that means it makes
variable values constant.
 Note: As for as real time statement there concern every final variable
should be declared the static but there is no compulsion that every static
variable declared as final.
Static methods and Final variables Static methods

 They can only call other static methods.
 They must only access static data.
 They cannot refer to this or super in any way(this, super we
will see later).
 The static variable can be used to refer to the common
property of all objects.
 for example, the company name of employees, college name
of students, etc.
 The static variable gets memory only once in the class area at
the time of class loading.
Methods declared as static have several restrictions:

A static member that can be used by itself, without reference
to a specific instance.
Syntax
Here shows how to declare static method and static variable.
static int intValue; // static variable
static void aStaticMethod() //static method
{ }

Example of static variable

 A variable can be declared as final. Doing so prevents its contents
from being modified. This means that you initialize a final variable
when it is declared (in this usage, final is similar to const in C /
C++)
 A final variable cannot be modified. You must initialize a final
variable when it is declared. A final variable is essentially a
constant.
. For example
final int FILE_NEW =1 ;
final int FILE_OPEN =2;
final int FILE_SAVE = 3;
Final Key Word

public class FinalMethod {
final void meth() {
System.out.println("This is a final method.");
}
}
class B extends FinalMethod {
void meth() { // ERROR! Can't override.
System.out.println("Illegal!");
}
}

 A class usually provides methods to indirectly access and
modify the private data values
 An accessor method returns the current value of a variable
 A mutator method changes the value of a variable
 The names of accessor and mutator methods take the form
getX and setX, respectively, where X is the name of the value
 They are sometimes called “getters” and “setters”
Accessors and Mutators

 The use of mutators gives the class designer the ability to
restrict a client’s options to modify an object’s state
 A mutator is often designed so that the values of variables can
be set only within particular limits

 Getters, or accessors, are methods that provide access
to an object's instance variables. In essence, we are
providing a layer of indirection. Simple classes often
have getters that return the associated instance variable
and nothing more.

public String getTitle(){
return title;
}
public String getAuthor(){
return author;
}
public int getRating(){
return rating;
}
Example Accessors mutators
public void setTitle(String title){
this.title = title;
}
public void setAuthor(String
author){
this.author = author;
}
public void setRating(int rating){
this.rating = rating;
}

Chapter 3

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Chapter 3

Similar to Chapter 3 (20)

More from siragezeynu

More from siragezeynu (12)

Recently uploaded

Recently uploaded (20)

Chapter 3

Editor's Notes