PICTURE in Focus: ULO 4.

Apply OOP Techniques in solving a

transactional processing system.

In week 6, we already discussed the concepts of OOP. Now, for week 7, we will learn
how the encapsulation, inheritance and polymorphism is applied into programming
problems.

1. Encapsulation

Binding the data with the code that manipulates it.

It keeps the data and the code safe from external interference

Looking at the example of a power steering mechanism of a car. Power steering of a car
is a complex system, which internally have lots of components tightly coupled together,
they work synchronously to turn the car in the desired direction. It even controls the
power delivered by the engine to the steering wheel. But to the external world there is
only one interface is available and rest of the complexity is hidden. Moreover, the
steering unit in itself is complete and independent. It does not affect the functioning of
any other mechanism.

Similarly, same concept of encapsulation can be applied to code. Encapsulated code

should have following characteristics:

Everyone knows how to access it.

Can be easily used regardless of implementation details.
There shouldn’t any side effects of the code, to the rest of the application.

The basic foundation of encapsulation is to keep classes separated and prevent them
from having tightly coupled with each other.
A live example of encapsulation is the class of java.util.Hashtable. User only knows that
he can store data in the form of key/value pair in a Hashtable and that he can retrieve
that data in the various ways. But the actual implementation like, how and where this
data is actually stored, is hidden from the user. User can simply use Hashtable wherever
he wants to store Key/Value pairs without bothering about its implementation.

2. Inheritance

Inheritance is the mechanism by which an object acquires the some/all properties of

another object.
It supports the concept of hierarchical classification.
 College of Computing Education
3rd Floor, DPT Building
Matina Campus, Davao City
Telefax: (082)
Phone No.: (082)300-5456/305-0647 Local 116

For example: Car is a classification of Four Wheelers. Here Car acquires the properties of
a four-wheeler. Other classifications could be a jeep, tempo, van etc. Four Wheeler defines
a class of vehicles that have four wheels, and specific range of engine power, load carrying
capacity etc. Car (termed as a sub-class) acquires these properties from Four Wheeler
(termed as a super-class), and has some specific properties, which are different from other
classifications of Four Wheeler, such as luxury, comfort, shape, size, usage etc.

A car can have further classification such as an open car, small car, big car etc, which will
acquire the properties from both Four Wheeler and Car, but will still have some specific
properties. This way the level of hierarchy can be extended to any level.
Java Swing and Awt classes represent best examples for inheritance.

Inheritance is the capability of a class to use the properties and methods of another class
while adding its own functionality. An example of where this could be useful is with an
employee records system. You could create a generic employee class with states and
actions that are common to all employees. Then more specific classes could be defined
for salaried, commissioned and hourly employees. The generic class is known as the
parent (or superclassor base class) and the specific classes as children
(or subclasses or derived classes). The concept of inheritance greatly enhances the
ability to reuse code as well as making design a much simpler and cleaner process.
The Object class is the highest superclass (ie. root class) of Java. All other classes are
subclasses (children or descendants) inherited from the Object class. The Object class
includes methods such as:
clone() equals() copy(Object finalize() getClass()
src)
hashCode() notify() notifyAll() toString() wait()

Java uses the extends keyword to set the relationship between a parent class and a
child class. As an example using the previously defined Box class:
public class GraphicsBox extends Box
The GraphicsBox class assumes or inherits all the properties of the Box class and can
now add its own properties and methods as well as override existing
methods. Overriding means creating a new set of method statements for
thesame method signature (name, number of parameters and parameter types). For
example:
//define position locations
private int left, top;
//override a superclass method
public int displayVolume()
{
System.out.println(length*w idth*height);
System.out.println("Location: "+left+", "+top);
}

2
 College of Computing Education
3rd Floor, DPT Building
Matina Campus, Davao City
Telefax: (082)
Phone No.: (082)300-5456/305-0647 Local 116

When extending a class constructor you can reuse the superclass constructor and
overridden superclass methods by using the reserved word super. Note that this reference
must come first in the subclass constructor. The reserved wordthis is used to distinguish
between the object's property and the passed in parameter.

GraphicsBox(l,w ,h,left,top) // constructor

{
super (l,w ,h);
this.left=left;
this.top=top;
}
public void show Obj()
{System.out.println(super.show Obj()+"more stuff here");}

The reserved word this can also be used to reference private constructors which are
useful in initializing properties.

Special Note:You cannot override final methods, methods in final classes, private
methods or static methods.

3. Polymorphism
• Polymorphism means to process objects differently based on their data type.
• In other words it means, one method with multiple implementation, for a certain
class of action. And which implementation to be used is decided at runtime
depending upon the situation (i.e., data type of the object)
• This can be implemented by designing a generic interface, which provides generic
methods for a certain class of action and there can be multiple classes, which
provides the implementation of these generic methods.
•
Lets us look at same example of a car. A car have a gear transmission system. It has
four front gears and one backward gear. When the engine is accelerated then depending
upon which gear is engaged different amount power and movement is delivered to the
car.
Polymorphism could be static and dynamic both. Overloading is static polymorphism
while, overriding is dynamic polymorphism.
Overloading in simple words means two methods having same method name but
takes different input parameters. This called static because, which method to be
invoked will be decided at the time of compilation
Overriding means a derived class is implementing a method of its super class

3
 College of Computing Education
3rd Floor, DPT Building
Matina Campus, Davao City
Telefax: (082)
Phone No.: (082)300-5456/305-0647 Local 116

Polymorphism is the ability of an object to take on many forms. In programming

languages polymorphism is the capability of an action or method to do different things
based on the object that it is acting upon. This is the third basic principle of object oriented
programming. The three types of polymorphism are: ad-hoc (overloading and
overriding),parametric (generics) and dynamic method binding.

Overloaded methods are methods with the same name signature but either a different
number of parameters or different types in the parameter list. For example 'spinning' a
number may mean increase it, 'spinning' an image may mean rotate it by 90 degrees. By
defining a method for handling each type of parameter you control the desired effect.

Overridden methods are methods that are redefined within an inherited or subclass.
They have the same signature and the subclass definition is used.

Parametrics are generic typing procedures.

Dynamic (or late) method binding is the ability of a program to resolve references to
subclass methods at runtime. For example assume that three subclasses (Cow, Dog and
Snake) have been created based on the Animal abstract class, each having their own
speak() method. Although each method reference is to an Animal (but no animal objects
exist), the program is will resolve the correct method reference at runtime.
public class AnimalReference
{
public static void main(String args[])
Animal ref // set up var for an Animal
Cow aCow = new Cow ("Bossy"); // makes specific objects
Dog aDog = new Dog("Rover");
Snake aSnake = new Snake("Ernie");
// now reference each as an Animal
ref = aCow ; ref.speak();
ref = aDog; ref.speak();
ref = aSnake; ref.speak();
}

4
 College of Computing Education
3rd Floor, DPT Building
Matina Campus, Davao City
Telefax: (082)
Phone No.: (082)300-5456/305-0647 Local 116

Self-Help: You can refer to the sources below to help you further
understand the lesson.
1. Schildt, Herbert. (2019) Java : a beginner's guide. McGraw-Hill/Osborne
2. Farrell, Joyce (2019) Java™ programming. Cengage Learning
3. 3G E-Learning, LLC. (2018) Theory, practice and techniques in Java programming. 3G
E-learning
4. 3G E-Learning, LLC. (2018) Theory, practice and techniques in object oriented
programming. 3G E-learning
5. Padre, Nilo et .al. (2016). Programming Concepts: Logic Formulation
6. Berkovic, et. al (2016). Computers and Programming: Theory and Problems
7. Pomperada, Jake et. al (2016). Intro to Java Programming, Mindshapers Co., Inc,
Great Books
8. Smith, Jo ann (2015). Programming Logic and Design, Cengage

QUESTION AND ANSWER LIST

Do you have any questions or clarification?

Questions/ Issues Answers

1.

2.

3.

KEYWORDS INDEX

Inheritance Polymorphism Encapsulation

5
 College of Computing Education
3rd Floor, DPT Building
Matina Campus, Davao City
Telefax: (082)
Phone No.: (082)300-5456/305-0647 Local 116

Let’s Check: Showing the output of programming segments given: Try to apply this
programming segments in Java and show the result upon running the code. Submit the
screenshot of the result in word or pdf format to our BB LMS.

Machine Problem class TestStudent{

class Student{ public static void main(String arg[]){
String name; Student s1=new Student();
int regno; Student s2=new
int marks1,marks2,marks3; Student("Ann",34523,68,90,84);
Student(){// default constructor Student s3=new student(s1);
name="raju"; s1.display();
regno=12345; s2.display();
marks1=56; s3.display();
marks2=47; }
marks3=78; } }
Student(String n,int r,int m1,int m2,int m3){ //
parameterized constructor Answer/Result:
name=n;
regno=r;
marks1=m1;
marks2=m2;
marks3=m3; }
Student(student s){ // copy constructor
name=s.name;
regno=s.regno;
marks1=s.marks1;
marks2=s.marks2;
marks3=s.marks3; }
void display(){
System.out.println(name + "\t" +regno+ "\t"
+marks1+ "\t" +marks2+ "\t" + marks3);
}
}

Let’s Analyze: Laboratory Activity 7 – OOP Principles

Performance Task: Understand the game scenario where it has three Defenders.
These defenders differ in actions and mechanics.

Game Scenario:
Let’s look at Williams Electronics classic arcade game, Defender, and examine three
of the units in this game: the lander, the mutant and the bomber. By examining the
ways in which these three units differ within the game's framework of actions and
mechanics, you can see some of the ingredients necessary for intriguing enemy
behavior.
• The lander flew slowly and occasionally fired a shot at the player. Given
the chance, the lander would descend to the surface below to pick up
one of the humanoids that the player was supposed to be protecting.
When a lander grabbed a humanoid, it would rise toward the upper levels
of the atmosphere, suddenly firing like mad; when it reached the top of
the screen, the humanoid was destroyed and the lander would become
a mutant.

6
 College of Computing Education
3rd Floor, DPT Building
Matina Campus, Davao City
Telefax: (082)
Phone No.: (082)300-5456/305-0647 Local 116

• The mutant was faster than the lander and much more aggressive – it
always made a headlong attack when it spotted the player. The mutant
also had an erratic flight pattern, making it’s movements less predictable
and harder to evade.
• The bomber was slow and peaceful for the most part, but it left a trail of
bombs that hung in space; if the player contacted one of the bombs, his
ship was destroyed.

Requirements:

a. You create your main method, assign a super class, and subclasses of the
scenario above. Apply appropriate OOP techniques display the actions and
mechanics of every Defender.
b. Submit the zipped file containing all the java files (Main, superclass and
subclasses).

In a Nutshell
Briefly discuss the difference of the Principles of OOP.

Preparation For Project Presentation and Documentation

Mechanics:
A.) Any program that applies the concept of (1) add, (2) display, (3) edit, (4) delete
(5) exit. The data added must be stored in a file, display from the file, edit from
the file and can be deleted from that file. The delete must also have an option
to delete one-by-one or delete all.
B.) You can use GUI Swing, or console mode to display your output.
C.) Presentation of output must on the Final week from March 8 - March 12, 2021.
D.) No video presentation. Individual presentation will be scheduled from March 8-
12.
E.) You need to prepare a documentation, as shown template below:

Requirements: Create a documentation with the following format:

Introduction UML Class Diagram

CCE103L Project Describe the entire Draw the program
Phone book process of the program diagram to present the
relationship of the super
Submitted by: and sub-classes.
YourName

Submitted to:
Prof. Fe B. Yara

7
 College of Computing Education
3rd Floor, DPT Building
Matina Campus, Davao City
Telefax: (082)
Phone No.: (082)300-5456/305-0647 Local 116

Data type FileWriter OOP Application

Describe the data types, Discuss the importance Discuss what principle
why you use such data of this method in your of OOP applies in your
types to a certain program program.
variable
FileReader
Array
Discuss the importance
Discuss why you use of this method in your
array, if you use program
Arraylist, linkedlist or
vector discuss it also

Learning Source Codes

Source Codes
What you have learned
Main Method
about the program you
choose?

Is the program helpful,

in what manner?

Source Codes Screenshot of Output Curriculum Vitae

Copy and paste the

sources codes here from
Main method, super
class, sub-classes