Working with Java

Classes

1
 Objectives
At the end of the lesson, the student should be able to:

● Explain object-oriented programming and some of its

concepts
● Differentiate between classes and objects
● Differentiate between instance variables/methods and
class(static) variables/methods
● Explain what methods are and how to call and pass
parameters to methods
● Identify the scope of a variable
● Cast primitive data types and objects
● Compare objects and determine the class of an objects
2
Brief Introduction
on OOP
3
 Introduction to OOP
● Object-Oriented programming or OOP
– Revolves around the concept of objects as the basic elements
of your programs.
– These objects are characterized by their properties and
behaviors.

4
 Introduction to OOP
● Example of objects

objects in the physical world can easily be modeled as

software objects using the properties as data and the
behaviors as methods
5
 Encapsulation

● Encapsulation
– The scheme of hiding implementation details of a class.
– The caller of the class does not need to know the
implementation details of a class
– The implementation can change without affecting the caller of
the class

6
 Classes and
Objects (Object
Instances)
7
 Classes and Objects
● Class
– can be thought of as a template, a prototype or a blueprint of an
object
– is the fundamental structure in object-oriented programming

● Two types of class members:

– Fields (properties, variables)
● specify the data types defined by the class
– Methods (behavior)
● specify the operations

8
 Classes and Objects
● Object
– An object is an instance of a class - we will call it object instance
– The property values of an object instance is different from the
ones of other object instances of a same class
– Object instances of a same class share the same behavior
(methods)

9
 Classes and Objects
● To differentiate between classes and objects, let us
discuss an example:

10
 Classes and Objects
● Classes provide the benefit of reusability.

● Software programmers can use a class over and over

again to create many object instances.

11
Creation of Object
Instances with
“new” keyword
12
 Creation of Object Instance
● To create an object instance of a class, we use the new
operator.
● For example, if you want to create an instance of the
class String, we write the following code,
String str2 = new String(“Hello world!”);
or
String str2 = "Hello world!";
● String class is a special (and only) class you can create an
instance without using new keyword as shown above

13
 Creation of Object Instance
● The new operator
– allocates a memory for that object and returns a reference of
that memory location to you.
– When you create an object, you actually invoke the class'
constructor.

● The constructor
– is a method where you place all the initializations, it has the
same name as the class.

14
 Methods
(Instance methods &
Static methods)
15
 Methods
● Method
– is a separate piece of code that can be called by a main
program or any other method to perform some specific
function.

● The following are characteristics of methods:

– It can return one or no values
– It may accept as many parameters it needs or no parameter at
all. Parameters are also called arguments.
– After the method has finished execution, it goes back to the
method that called it.

16
 Why Use Methods?
● Methods contain behavior of a class (business logic)
– The heart of effective problem solving is in problem
decomposition.
– We can do this in Java by creating methods to solve a specific
part of the problem.
– Taking a problem and breaking it into small, manageable
pieces is critical to writing large programs.

17
 Two Types of Methods
● Instance (non-static) methods
– Should be called after object instance is created
– More common than static methods
● Static methods
– Should be called in the form of [ClassName].[methodName]

18
 Calling Instance (non-static)
Methods
● To illustrate how to call methods, let's use the String
class as an example.
● You can use the Java API documentation to see all the
available methods in the String class.
● Later on, we will create our own methods, but for now,
let us use what is available.
● To call an instance method, we write the following,
nameOfObject.nameOfMethod( parameters );
● Example
String strInstance1 = new String("I am object
instance of a String class");
char x = strInstance1.charAt(2);
19
 Calling Instance Methods
● Let's take two sample methods found in the String class

20
 Calling Instance Methods
● Example

String str1 = "Hello";

char x = str1.charAt(0); //will return the character H

//and store it to variable x

String str2 = "hello";

//this will return a boolean value true

boolean result = str1.equalsIgnoreCase( str2 );

21
 Calling Static Methods
● Static methods
– methods that can be invoked without instantiating a class
(means without invoking the new keyword).
– Static methods belong to the class as a whole and not to a
certain instance (or object) of a class.
– Static methods are distinguished from instance methods in a
class definition by the keyword static.

● To call a static method, just type,

Classname.staticMethodName(params);

22
 Calling Static Methods
● Examples of static methods, we've used so far in our
examples are,

//converts the String 10, to an integer

int i = Integer.parseInt(“10”);

//Returns a String representation of the integer argument as an

//unsigned integer base 16
String hexEquivalent = Integer.toHexString( 10 );

23
Parameter Passing
(Pass-by-value &
Pass-by-reference)
24
 Parameter Passing
● Pass-by-Value
– when a pass-by-value occurs, the method makes a copy of
the value of the variable passed to the method. The method
cannot accidentally modify the original argument even if it
modifies the parameters during calculations.
– all primitive data types when passed to a method are pass-by-
value.

25
Pass-by-Value

26
 Parameter Passing
● Pass-by-Reference
– When a pass-by-reference occurs, the reference to an object
is passed to the calling method. This means that, the method
makes a copy of the reference of the variable passed to the
method.
– However, unlike in pass-by-value, the method can modify the
actual object that the reference is pointing to, since, although
different references are used in the methods, the location of
the data they are pointing to is the same.

27
Pass-by-Reference

28
Pass-by-Reference

29
Variables (Fields,
Properties)
30
 Variables
● Data identifiers
● Are used to refer to specific values that are generated
in a program--values that you want to keep around

31
 Three Types of Variables
● Local (automatic) variable
– declared within a method body
– visible only within a method body
– maintained in a stack
● Instance variable
– declared inside a class body but outside of any method bodies
– per each object instance
– cannot be referenced from static context
● Class (static) variable
– declared inside a class body but outside of any method bodies
– prepended with the static modifier
– per each class
– shared by all object instances 32
Scope of a Variable

33
 Scope of a Variable
● The scope
– determines where in the program the variable is accessible.
– determines the lifetime of a variable or how long the variable
can exist in memory.
– The scope is determined by where the variable declaration is
placed in the program.

● To simplify things, just think of the scope as anything

between the curly braces {...}. The outer curly braces
are called the outer blocks, and the inner curly braces
are called inner blocks.

34
 Scope of a Variable
● A variable's scope is
– inside the block where it is declared, starting from the point
where it is declared

35
Example 1

36
 Example 1
● The code we have in the previous slide represents five
scopes indicated by the lines and the letters
representing the scope.
● Given the variables i,j,k,m and n, and the five scopes
A,B,C,D and E, we have the following scopes for each
variable:
– The scope of variable i is A.
– The scope of variable j is B.
– The scope of variable k is C.
– The scope of variable m is D.
– The scope of variable n is E.

37
Example 2

38
 Example 2
● In the main method, the scopes of the variables are,
– ages[] - scope A
– i in B - scope B
– i in C – scope C

● In the test method, the scopes of the variables are,

– arr[] - scope D
– i in E - scope E

39
 Scope of a Variable

● When declaring variables, only one variable with a

given identifier or name can be declared in a scope.
● That means that if you have the following declaration,

{
int test = 10;
int test = 20;
}

your compiler will generate an error since you should

have unique names for your variables in one block.

40
 Scope of a Variable
● However, you can have two variables of the same
name, if they are not declared in the same block. For
example,
public class Main {
static int test = 0;
public static void main(String[] args) {
System.out.println(test); // prints 0
// test variable is defined in a new block
{
int test = 20;
System.out.println(test);// prints 20
}
System.out.println(test); // prints 0
}
} 41
 Scope of Variables
● Local (automatic) variable
– only valid from the line they are declared on until the closing
curly brace of the method or code block within which they are
declared
– most limited scope
● Instance variable
– valid as long as the object instance is alive
● Class (static) variable
– in scope from the point the class is loaded into the JVM until
the the class is unloaded. Class are loaded into the JVM the
first time the class is referenced

42
 Coding Guidelines

● Avoid having variables of the same name declared

inside one method to avoid confusion.

43
Type Casting

44
 Type Casting
● Type Casting
– Mapping type of an object to another

● To be discussed
– Casting data with primitive types
– Casting objects

45
 Casting Primitive Types
● Casting between primitive types enables you to convert
the value of one data from one type to another primitive
type.

● Commonly occurs between numeric types.

● There is one primitive data type that we cannot do

casting though, and that is the boolean data type.

● Types of Casting:
– Implicit Casting
– Explicit Casting
46
 Implicit Casting

● Suppose we want to store a value of int data type to a

variable of data type double.
int numInt = 10;
double numDouble = numInt; //implicit cast

In this example, since the destination variable's data

type (double) holds a larger value than the value's data
type (int), the data is implicitly casted to the destination
variable's data type double.

47
 Implicit Casting
● Another example:
int numInt1 = 1;
int numInt2 = 2;

//result is implicitly casted to type double

double numDouble = numInt1/numInt2;

48
 Explicit Casting
● When we convert a data that has a large type to a
smaller type, we must use an explicit cast.

● Explicit casts take the following form:

(Type)value

where,

Type - is the name of the type you're converting to

value -is an expression that results in the value of the source type

49
 Explicit Casting Examples

double valDouble = 10.12;

int valInt = (int)valDouble;

//convert valDouble to int type

double x = 10.2;
int y = 2;

int result = (int)(x/y); //typecast result of operation to int

50
 Casting Objects
● Instances of classes also can be cast into instances of
other classes, with one restriction: The source and
destination classes must be related by inheritance; one
class must be a subclass of the other.

– We'll cover more about inheritance later.

● Casting objects is analogous to converting a primitive

value to a larger type, some objects might not need to
be cast explicitly.

51
 Casting Objects
● To cast,

(classname)object

where,

classname is the name of the destination class &

object is a reference to the source object

52
 Casting Objects Example
● The following example casts an instance of the class
VicePresident to an instance of the class Employee;
VicePresident is a subclass of Employee with more
information, which here defines that the VicePresident
has executive washroom privileges.
Employee emp = new Employee();
VicePresident veep = new VicePresident();

// no cast needed for upward use

emp = veep;

// must cast explicitly

veep = (VicePresident)emp;

53
 Primitives &
Wrapper Types
54
 Converting Primitive types to
Objects and vice versa
● One thing you can't do under any circumstance is cast
from an object to a primitive data type, or vice versa
until JDK 5
– As an alternative, the java.lang package includes classes that
correspond to each primitive data type: Float, Boolean, Byte,
and so on. We call them Wrapper classes.
● In JDK 5, the autoboxing and unboxing automatically
handles the conversion

55
 Wrapper Classes
● Most of these classes have the same names as the
data types, except that the class names begin with a
capital letter
– Integer is a wrapper class of the primitive int
– Double is a wrapper class of the primitive double
– Long is a wrapper class of the primitive long
● Using the classes that correspond to each primitive
type, you can create an object that holds the same
value.

56
 Converting Primitive types to
Objects (Wrapper) and vice versa
● The following statement creates an instance of the Integer class
with the integer value 7801
Integer dataCount = new Integer(7801);
● The following statement converts an Integer object to its primitive
data type int. The result is an int with value 7801
int newCount = dataCount.intValue();
● A common translation you need in programs is converting a String
to a numeric type, such as an int (Object->primitive)
String pennsylvania = "65000";
int penn = Integer.parseInt(pennsylvania);

57
Comparing Objects

58
 Comparing Objects
● In our previous discussions, we learned about
operators for comparing values—equal, not equal, less
than, and so on. Most of these operators work only on
primitive types, not on objects.
● The exceptions to this rule are the operators for
equality: == (equal) and != (not equal). When applied to
objects, these operators don't do what you might first
expect. Instead of checking whether one object has the
same value as the other object, they determine whether
both sides of the operator refer to the same object.

59
 Comparing Objects
● Example:
1 class EqualsTest
2 {
3 public static void main(String[] arguments) {
4 String str1, str2;
5 str1 = "Free the bound periodicals.";
6 str2 = str1;
7 System.out.println("String1: " + str1);
8 System.out.println("String2: " + str2);
9 System.out.println("Same object? " + (str1 == str2));
10 str2 = new String(str1);
11 System.out.println("String1: " + str1);
12 System.out.println("String2: " + str2);
13 System.out.println("Same object? " + (str1 == str2));
14 System.out.println("Same value? " + str1.equals(str2));
15 }
16 }

60
 Comparing Objects
● This program's output is as follows:
String1: Free the bound periodicals.
String2: Free the bound periodicals.
Same object? true
String1: Free the bound periodicals.
String2: Free the bound periodicals.
Same object? false
Same value? True

61
 Comparing Objects
● NOTE on Strings:
– Given the code:

String str1 = “Hello”;

String str2 = “Hello”;
– These two references str1 and str2 will point to the same
object.
– String literals are optimized in Java; if you create a string
using a literal and then use another literal with the same
characters, Java knows enough to give you the first String
object back.
– Both strings are the same objects; you have to go out of your
way to create two separate objects.

62
getClass() method &
instanceof Operator
63
Determining the class of an object
● Want to find out what an object's class is? Here's the way
to do it.

● Suppose we have the following object:

SomeClassName key = new SomeClassName();

Now, we'll discuss two ways to know the type of the

object pointed to by the variable key.

64
 getClass() method
● The getClass() method returns a Class object instance
(where Class is itself a class)
● Class class has a method called getName().

– getName() returns a string representing the name of the class.

● For Example,

String name = key.getClass().getName();

65
 instanceof operator
● The instanceof has two operands: a reference to an
object on the left and a class name on the right.

● The expression returns true or false based on whether

the object is an instance of the named class or any of
that class's subclasses.

● For Example,
boolean ex1 = "Texas" instanceof String; // true
Object pt = new Point(10, 10);
boolean ex2 = pt instanceof String; // false

66
Summary

67
 Summary
● Classes and Objects
– Instance variables
– Class Variables
● Class Instantiation
● Methods
– Instance methods
– Passing Variables in Methods (Pass-by-value, Pass-by-
reference)
– Static methods
● Scope of a variable
● Casting (object, primitive types)
● Converting Primitive Types to Objects and Vice Versa
● Comparing Objects
● Determining the Class of an Object
68