CHAPTER 1 -

REVIEW OF
OBJECT ORIENTED
PROGRAMMING
CONCEPTS

CSC584 - ENTERPRISE PROGRAMMING

REVIEW OF OBJECT ORIENTED
PROGRAMMING CONCEPTS
1. Objects, classes, packages
2. Inheritance & Polymorphism concept
3. Inheriting instances fields and methods
4. Method overriding
5. Access levels – public, protected, private
6. Abstract super classes and methods
7. Interface
INTRODUCTION TO JAVA - WHY JAVA?
2017 2019
INTRODUCTION TO JAVA - WHY JAVA?
❖Java enables users to develop and deploy applications on the Internet
for servers, desktop computers, and small hand-held devices.
❖Java is a general purpose programming language.
❖Java is the Internet programming language.
INTRODUCTION TO JAVA - JAVA, WEB, AND BEYOND

❖Java can be used to develop Web applications

❖Java Web Applications
❖Java can also be used to develop applications for hand-held devices
JDK EDITIONS
▪ Java Standard Edition (JSE)
▪ JSE can be used to develop and deploy Java applications on desktops and
servers.
(https://www.oracle.com/java/technologies/java-se-glance.html)

▪ Java Enterprise Edition (JEE)

▪ JEE can be used to develop server-side applications such as Java servlets
and Java ServerPages.
(https://www.oracle.com/technetwork/java/javaee/overview/index.html)

▪ Java Micro Edition (JME).

▪ JME can be used to develop applications for mobile devices such as cell
phones, TV set-top boxes.
(https://www.oracle.com/technetwork/java/embedded/javame/index.html)
6
POPULAR JAVA IDE(S)
▪ NetBeans Open Source by Sun
▪ Eclipse Open Source by IBM
▪ IntelliJ IDEA by JetBrains

7
OBJECTS,
CLASSES &
PACKAGES
OO PROGRAMMING CONCEPTS
▪ Object-oriented programming (OOP) involves programming using
objects.
▪ An object represents an entity in the real world that can be
distinctly identified.
▪ For example, a student, a desk, a circle, a button, and even a loan
can all be viewed as objects.
▪ An object has a unique identity, state, and behaviors.
OO PROGRAMMING CONCEPTS
▪ The state of an object consists of a set of data fields (also known
as properties) with their current values.
▪ The behavior of an object is defined by a set of methods.
OBJECTS

An object has both a state and behavior. The state defines the
object, and the behavior defines what the object does.
CLASSES
▪ Classes are constructs that define objects of the same type.
▪ A Java class uses variables to define data fields and
methods to define behaviors.
▪ A class provides a special type of methods, known as
constructors, which are invoked to construct objects from
the class.
CLASSES
UML CLASS DIAGRAM
CONSTRUCTORS
Circle() { Constructors are a special kind of methods
} that are invoked to construct objects.

Circle(double newRadius) {
radius = newRadius;
}
CONSTRUCTORS, CONT.
▪ A constructor with no parameters is referred to as a no-arg
constructor.
▪ Constructors must have the same name as the class itself.
▪ Constructors do not have a return type—not even void.
▪ Constructors are invoked using the new operator when an object is
created. Constructors play the role of initializing objects.
CREATING OBJECTS USING
CONSTRUCTORS
new ClassName();

Example:
new Circle();

new Circle(5.0);
DEFAULT CONSTRUCTOR
▪ A class may be declared without constructors.
▪ A no-arg constructor with an empty body is implicitly
declared in the class.
▪ This constructor, called a default constructor, is provided
automatically only if no constructors are explicitly
declared in the class.
DECLARING OBJECT REFERENCE VARIABLES

▪ To reference an object, assign the object to a reference variable.

▪ To declare a reference variable, use the syntax:

ClassName objectRefVar;

Example:
Circle myCircle;
DECLARING/CREATING OBJECTS
IN A SINGLE STEP
ClassName objectRefVar = new ClassName();

Assign object reference Create an object

Example
Circle myCircle = new Circle();
ACCESSING OBJECTS
▪ Referencing the object’s data:
objectRefVar.data
e.g., myCircle.radius

▪ Invoking the object’s method:

objectRefVar.methodName(arguments)
e.g., myCircle.getArea()
 Nouns
State/Properties Representation in Java
Black Hair hairColor =“black”
Brown Eyes eyeColor = “brown”
Object 160 cm height = 160
50 kg weight = 50

Behavior/Method Representation in Java

Eat eat()
Sleep sleep()
Person Walk walk()
Study study()
Play play()

Verbs
INHERITANCE & POLYMORPHISM
CONCEPT
INHERITANCE
▪ A process in which a new class is derived from an existing one.
▪ Parent class/super class: existing class.
▪ Child class/sub class: derived class.
▪ Child inherits characteristics of the parent - methods and data defined by the
parent class.
▪ Can tailor a derived class as needed by adding new variables or methods, or by
modifying the inherited ones.
INHERITANCE
▪ Inheritance relationships are shown in a UML class diagram using a solid arrow
with an unfilled triangular arrowhead pointing to the parent class

Vehicle

Car

▪ Proper inheritance creates an is-a relationship, meaning the child is a more

specific version of the parent
DERIVING SUBCLASSES

▪ In Java, we use the reserved word extends to establish an inheritance

relationship

public class Car extends Vehicle

{
// class contents
}
SIMPLE EXAMPLE : INHERITANCE
▪ We can effectively model similar, but
Pet
different types of objects using inheritance
▪ Suppose we want to model rabbit and cat.
They are different types of pets. We can
define the Pet class and the Rabbit and Cat
classes as the subclasses of the Pet class.

Rabbit Cat
THE PET CLASS
class Pet {
private String name;
public String getName() {
return name;
}
public void setName(String petName) {
name = petName;
}
public String speak( ) {
return “I’m your cuddly little pet.”;
}
}
SUBCLASSES OF THE PET CLASS
class Cat extends Pet { The Cat subclass overrides
public String speak( ) { the inherited method speak.
return “Don’t give me orders.\n” +
“I speak only when I want to.”;
}
}

class Rabbit extends Pet {

public String fetch( ) {
The Rabbit subclass adds
return “Yes, master. Fetch I will.”;
a new method fetch.
}
}
SAMPLE USAGE OF THE
SUBCLASSES
Rabbit myRabbit = new Rabbit();
I’m your cuddly little
System.out.println(myRabbit.speak());
pet.
Yes, master. Fetch I will.
System.out.println(myRabbit.fetch());

Cat myCat = new Cat();

Don’t give me orders.
System.out.println(myCat.speak()); I speak only when I want to.
System.out.println(myCat.fetch()); ERROR
DEFINING CLASSES WITH INHERITANCE

▪ Case Study:
▪ Suppose we want to implement a class roster that contains both
undergraduate and graduate students.
▪ Each student’s record will contain his or her name, three test scores, and the
final course grade.
▪ The formula for determining the course grade is different for graduate
students than for undergraduate students.
MODELING TWO TYPES OF
STUDENTS
▪ There are two ways to design the classes to model undergraduate and graduate
students.
▪ We can define two unrelated classes, one for undergraduates and one for
graduates.
▪ We can model the two kinds of students by using classes that are related in
an inheritance hierarchy.
▪ Two classes are unrelated if they are not connected in an inheritance
relationship.
CLASSES FOR THE CLASS ROSTER
▪ For the Class Roster sample, we design three classes:
▪ Student
▪ UndergraduateStudent
▪ GraduateStudent

▪ The Student class will incorporate behavior and data common to both
UndergraduateStudent and GraduateStudent objects.
▪ The UndergraduateStudent class and the GraduateStudent class will each
contain behaviors and data specific to their respective objects.
CLASSES FOR THE CLASS ROSTER -
CREATING THE ROSTER ARRAY
▪ We can maintain our class roster using an array, combining objects from the
Student, UndergraduateStudent, and GraduateStudent classes.

Student roster = new Student[40];

. . .
roster[0] = new GraduateStudent();
roster[1] = new UndergraduateStudent();
roster[2] = new UndergraduateStudent();
. . .
CLASSES FOR THE CLASS ROSTER -
STATE OF THE ROSTER ARRAY
▪ The roster array with elements referring to instances of GraduateStudent or
UndergraduateStudent classes.
CLASSES FOR THE CLASS ROSTER -
SAMPLE POLYMORPHIC MESSAGE
▪ To compute the course grade using the roster array, we execute
for (int i = 0; i < numberOfStudents; i++) {
roster[i].computeCourseGrade();
}

• If roster[i] refers to a GraduateStudent, then the computeCourseGrade method of the

GraduateStudent class is executed.
• If roster[i] refers to an UndergraduateStudent, then the computeCourseGrade method
of the UndergraduateStudent class is executed.
THE SUPER REFERENCE
▪ Unlike members of a superclass, constructors of a superclass are not inherited
by its subclasses even though they have public visibility.
▪ The super reference can be used to refer to the parent class, and often is used
to invoke the parent's constructor.
▪ A child’s constructor is responsible for calling the parent’s constructor.
▪ The first line of a child’s constructor should use the super reference to call
the parent’s constructor.
▪ The super reference can also be used to reference other variables and
methods defined in the parent’s class.
EXAMPLE: USING SUPER KEYWORD
public class Bicycle {
public int cadence;
public int gear;
public int speed;
public Bicycle(int startCadence, int startSpeed, int startGear) {
gear = startGear;
cadence = startCadence;
speed = startSpeed;
}

public MountainBike(int startHeight, int startCadence, int startSpeed, int startGear){

super(startCadence, startSpeed, startGear);
seatHeight = startHeight;
}
ACCESSING SUPERCLASS MEMBER

▪ If your method overrides one of its superclass's methods, you can invoke the
overridden method through the use of the keyword super.
▪ You can also use super to refer to a hidden field.
EXAMPLE: USING SUPER KEYWORD
public class Superclass {
public void printMethod() {
System.out.println("Printed in Superclass.");
}
}

public class Subclass extends Superclass {

public void printMethod() { //overrides printMethod in Superclass
super.printMethod();
System.out.println("Printed in Subclass");
}
public static void main(String[] args) {
Subclass s = new Subclass();
s.printMethod();
}
}
What is the output?
OVERRIDING METHODS
▪ A child class can override the definition of an inherited method in favor of its
own.
▪ The new method must have the same signature as the parent's method, but can
have a different body.
▪ The type of the object executing the method determines which version of the
method is invoked.
OVERRIDING
▪ A method in the parent class can be invoked explicitly using the super
reference
▪ If a method is declared with the final modifier, it cannot be overridden
▪ The concept of overriding can be applied to data and is called shadowing
variables
▪ Shadowing variables should be avoided because it tends to cause unnecessarily
confusing code
OVERLOADING VS. OVERRIDING

▪ Overloading deals with multiple methods with the same name in the same class,
but with different signatures
▪ Overriding deals with two methods, one in a parent class and one in a child
class, that have the same signature
▪ Overloading lets you define a similar operation in different ways for different
parameters
▪ Overriding lets you define a similar operation in different ways for different
object types
EXAMPLE: METHOD OVERLOADING
class Sample{
public static void main(String args[]){
DisplayOverloading obj = new DisplayOverloading();
obj.disp('a');
obj.disp('a',10);
}
}

class DisplayOverloading{
public void disp(char c){
System.out.println(c);
}
public void disp(char c, int num) {
System.out.println(c + " "+num);
}
}
CLASS HIERARCHIES
▪ A child class of one parent can be the parent of another child, forming a class
hierarchy.
CLASS HIERARCHIES
▪ Two children of the same parent are called siblings.
▪ Common features should be put as high in the hierarchy as is reasonable.
▪ An inherited member is passed continually down the line.
▪ Therefore, a child class inherits from all its ancestor classes.
POLYMORPHISM
▪ Polymorphism allows a single variable to refer to objects from different
subclasses in the same inheritance hierarchy
▪ For example, if Cat and Rabbit are subclasses of Pet, then the following
statements are valid:

Pet myPet;
Pet

myPet = new Rabbit();

. . .
Rabbit Cat
myPet = new Cat();
THE INSTANCEOF OPERATOR
▪ The instanceof operator can help us learn the class of an object (i.e. test
whether the object is an instance of the specified type (class or subclass or
interface))

class Simple1{  
public static void main(String args[]){  
  Simple1 s=new Simple1();  
  System.out.println(s instanceof Simple1);//true  
  }  
}  
THE INSTANCEOF OPERATOR
▪ An object of subclass type is also a type of parent class.
▪ For example, if Cat extends Animal then object of Cat can be referred by either
Cat or Animal class.

class Animal{}  
class Cat1 extends Animal{//Cat inherits Animal  
 public static void main(String args[]){  
 Cat1 c=new Cat1();  
  System.out.println(c instanceof Animal);//true  
 }  
}  
THE INSTANCEOF OPERATOR
▪ The following code counts the number of undergraduate students.

int undergradCount = 0;
for (int i = 0; i < numberOfStudents; i++) {
if ( roster[i] instanceof UndergraduateStudent ) {
undergradCount++;
}
}
INSTANCEOF: EXAMPLE
▪ Suppose you have four classes which are Animal, Animal
Mammal, Reptile, and Dolphin as shown. This can be
translated into the following:

public class Animal{

Mammal Reptile
}
public class Mammal extends Animal{
}
public class Reptile extends Animal{
}
Dolphin
public class Dolphin extends Mammal{
}

Now, based on the above example, In Object Oriented terms, the following are true:
· Animal is the superclass of Mammal class.
· Animal is the superclass of Reptile class.
· Mammal and Reptile are subclasses of Animal class.
· Dolphin is the subclass of both Mammal and Animal classes.
INSTANCEOF: EXAMPLE CONT…
▪ Now, if we consider the IS-A relationship, we can say:
· Mammal IS-A Animal
· Reptile IS-A Animal
· Dolphin IS-A Mammal
· Hence : Dolphin IS-A Animal as well

▪ With use of the extends keyword the subclasses will be able to inherit all the
properties of the superclass except for the private properties of the superclass.
INSTANCEOF: EXAMPLE CONT…
public class Test {

public static void main(String args[]){

Animal a = new Animal();
Mammal m = new Mammal();
Dolphin d = new Dolphin ();

System.out.println(m instanceof Animal);

System.out.println(d instanceof Mammal);
System.out.println(d instanceof Animal);
}
}

What is the output?

 Animal
INSTANCEOF: EXAMPLE CONT…
Mammal Reptile
Given the following:

Animal animal = new Animal(); Dolphin Turtle Snake

Mammal mammal = new Mammal();
Reptile reptile = new Reptile(); QUESTION:
Animal t = new Turtle(); a) Is animal instanceof Animal?
Animal s = new Snake(); b) Is t instanceof Turtle?
Animal d = new Dolphin(); c) Is mammal instanceof Animal?
d) Is t instanceof Mammal?
e) Is d instanceof Reptile?
f) Is mammal instanceof Mammal?
g) Is reptile instanceof Animal?
INHERITANCE AND MEMBER ACCESSIBILITY

▪ We use the following visual representation of inheritance to illustrate data

member accessibility.

Instances

This shows the inherited

components of the
superclass are part of
the subclass instance

Class Hierarchy
THE EFFECT OF THREE VISIBILITY
MODIFIERS package one

package two
ACCESSIBILITY OF SUPER FROM SUB
▪ Everything except the private members of the Super class is visible from a
method of the Sub class.
ACCESSIBILITY FROM ANOTHER INSTANCE
▪ Data members accessible from an instance are also accessible from other
instances of the same class.