Charotar University of Science and Technology (CHARUSAT)

Faculty of Technology and Engineering (FTE)

Subject: Object Oriented Programming (CEUE203)

Semester: 3rd
Teaching Scheme:
Teaching
Theory Practical Tutorial Total Credit
Scheme
Hours/Week 2 2 - 4
3
Marks 50 50 - 100

Course Pre-requisites:
➢ Basic understanding of programming concepts and familiarity with Object-Oriented
Programming (OOP) principles.
Course Description:
This course provides a comprehensive introduction to the Java programming language, equipping
students with a solid foundation in both its theoretical concepts and practical applications. It begins
with fundamental topics such as Java syntax, data types, and control structures. The curriculum
then delves into object-oriented programming principles, including classes, objects, inheritance,
and polymorphism. Students will explore key Java features like exception handling, the Collections
Framework, and input/output operations. The course also introduces advanced concepts such as
multithreading and concurrency, ensuring participants gain the skills necessary for developing
robust Java applications.
Course Objectives:
1. To understand the fundamentals of Java programming, including syntax, data types, and
control structures, to build a strong programming foundation.
2. To learn the principles of Object-Oriented Programming (OOP) through classes,
inheritance, interfaces, and packages, enabling modular and reusable code design.
3. To develop proficiency in handling arrays and strings for efficient data manipulation and
processing in Java applications.
4. To explore advanced concepts such as multithreaded programming, exception handling, and
file I/O operations, ensuring robust and concurrent application development.
5. To master the Java Collections Framework and generics for effective data management and
implementation of reusable, type-safe code structures.

Course Outcomes:
By the end of the course, students will be able to:
1. CO1: Demonstrate a comprehensive understanding of Java fundamentals, including
syntax, data types, control structures, and object-oriented programming principles such as
inheritance, polymorphism, abstraction, and encapsulation.

Page 35 of 125
 2. CO2: Utilize inheritance, interfaces, and Java package structures to create modular and
maintainable code, promoting code reusability and efficient project organization while
adhering to object-oriented design principles.
3. CO3: Construct and handle exceptions proficiently to build fault-tolerant applications,
applying exception handling mechanisms to manage errors and maintain program stability.
4. CO4: Develop and implement multi-threaded applications using Java’s built-in thread
handling mechanisms and concurrency utilities to optimize program performance and
resource utilization.
5. CO5: Design and implement Java programs using file handling, the NIO.2 package, and
Stream API to perform efficient file operations and process data streams effectively,
enhancing data-driven application capabilities.
6. CO6: Apply the concepts of the Collection Framework and Generics to create robust and
efficient programs that effectively manage and manipulate data, ensuring type safety and
reducing runtime errors.

➢ Self-study/Further Study components and materials:

Unit Unit/Topic Details
No.
INTRODUCTION
Overview of OOP principles: Encapsulation, Inheritance, Polymorphism,
1.1
Abstraction.
Data Types: Integer (byte, short, int, long), Floating-point (float, double), Character,
1.2
Boolean.
Variables: Dynamic Intialization, Scope and Lifetime of variable, Type Casting, Type
1.3
1 promotion rule
Operators: Arithmetic, Bitwise, Relational, Boolean, Assignment, ternary (three-
1.4
way).
Control Statements: if, nested ifs, Traditional Switch, Iteration statements (while, do-
1.5
while, for, For-Each, Nested Loops), Jump statements (break, continue, return)
Materials: -
➢ https://www.geeksforgeeks.org/operators-in-java/
BASICS OF ARRAY
2.1 Introduction to Arrays, Types of Array
2.2 Array Operations: Traversing arrays with for, for-each, and enhanced for loop
Copying arrays, cloning arrays, Searching and sorting elements in an array, Jagged
2.3
2 Arrays, Memory Representation of Arrays
Materials: -
➢ https://www.programiz.com/java-programming/arrays
➢ https://www.geeksforgeeks.org/jagged-array-in-java/
➢ https://www.geeksforgeeks.org/where-is-the-memory-allocated-for-arrays-in-java/
FUNDAMENTAL OF INHERITANCE
Concept and need for inheritance in OOP, Types of Inheritance: Single Inheritance,
3.1
Multilevel Inheritance, Hierarchical Inheritance
3 Materials: -
➢ https://www.scaler.com/topics/java/inheritance-in-java/
FUNDAMENTAL OF POLYMORPHISM

Page 36 of 125
 Concept and need for polymorphism in OOP, Types of polymorphism, Method
3.2
Overloading, Method Overriding
Materials: -
➢ https://www.scaler.com/topics/java/polymorphism-in-java/

Syllabus:
Unit Unit/Topic Details Hours Evaluation
No. (hr) Weightage
(%)
FUNDAMENTAL OF PROGRAMMING IN JAVA
1.1 History of Java.
1.2 Java’s Magic: The Bytecode.
1 The Java Buzzwords: Simple, Object-Oriented, Robust 02 06
1.3 Multithreaded, Architecture-Neutral, Interpreted and High
Performance, Distributed, Dynamic.
Switch Expressions, Records, and Other Recently Added
1.4
Features.
CLASS FUNDAMENTALS
2.1 Class Fundamentals: Defining classes and creating objects.
Instance and static variables, methods, and the new keyword,
2.2
Assigning Object Reference Variables.
Access modifiers: public, private, protected, default
2.3
(package-private).
Using final with classes, methods, and variables,
2.4
Understanding the this keyword.
Constructors: Types of constructors: default and
2.5 parameterized, Constructor overloading, instanceof operator,
The role of the this() constructor call.
2 04 14
Nested and Inner Classes: static nested class, inner class,
2.6
method-local inner class, and anonymous inner class
Understanding the Object Class: The Object class and its
2.7 methods: equals(), hashCode(), toString(), clone(), etc.
Overriding toString() and equals() in custom classes.
Memory Management in Java: Stack vs. heap memory,
2.8 Object lifecycle and garbage collection, Manual memory
management and implications.
Java Annotations and Meta-annotation: Overview and
2.9 purpose of annotations, Custom annotation, Reflection in
Java.
STRING HANDLING
Introduction to Strings, Methods of the String class,
3 StringBuffer and StringBuilder, String Manipulation 02 06
3.1
Techniques, Regular Expressions (Regex), String
Tokenization.
INHERITANCE, INTERFACES & PACKAGES
4 Understanding super keyword, Dynamic method dispatch 05 17
4.1
and runtime polymorphism, final Keyword in Inheritance.

Page 37 of 125
 Abstract Classes and Methods, Casting Objects in
4.2
Inheritance.
Introduction to Interfaces, Interface Segregation Principle,
Interface Methods and Variables, Multiple Inheritance
4.3
Using Interfaces, default and static method, private
interface, Functional Interfaces, Marker Interfaces.
Introduction to Packages, Access Modifiers and Packages,
Creating and Importing Packages, Static Imports, Jar Files.
Introduction to the Java Module System, Creating and
4.4
Declaring a Module, Understanding Module Descriptors,
Working with Multiple Modules, Services and Service
Loaders.
EXCEPTIONS HANDLING
Introduction to Exception Handling, Types of Exceptions:
5.1 Checked Exceptions, Unchecked Exceptions, Try-Catch-
Finally block.
5 02 06
Throw and Throws keyword, Try-With-Resources
5.2
Statement.
Try-With-Resources Statement, Custom Exceptions,
5.3
Exception Propagation.
MULTITHREADED PROGRAMMING
6.1 Introduction to Multithreading, Life cycle of a thread.
Understanding of Thread class and the Runnable interface,
6.2
Organizing threads into groups.
6 Thread Synchronization, Inter-thread Communication, 05 17
6.3 Thread Priority and Scheduling, Deadlock and Thread Safety
Issues.
Executor and ExecutorService for thread pool management,
6.4
Fork/Join Framework.
FILE NIO
7.1 Path Interface, Files Class, File Attributes.
7 7.2 Byte and Character Stream, Serialization. 04 14
NIO Fundamental: Buffer, Channel, Selector. Directory
7.3
Stream and File Walking.
COLLECTION FRAMEWORK AND GENERICS
Introduction to Collection zFramework, Collection
8.1
Interface.
8.2 List Interface: ArrayList, LinkedList and Vector and Stack.
8.3 Set Interface: HashSet, LinkedHashSet and TreeSet.
8 Map Interface: HashMap, LinkedHashMap, TreeMap and 06 20
8.4
Hashtable.
Working with Collections: Iterating through Collections,
8.5
Sorting and Searching, Thread-safe Collections.
Introduction to Generics, Generic Classes and Methods,
8.6 Bounded Type Parameters, Generics and Wildcards, Type
Erasure.
Total Hours: 30

Page 38 of 125
Course Articulation Matrix:

PO1 PO2 PO3 PO4 PO5 PO6 PO7 PO8 PO9 PO10 PO11 PO12 PSO1 PSO2
CO1 2 3 3 - - - - - - - - - - -
CO2 3 2 3 2 1 1 - - - - - - 1 3
CO3 - 2 2 3 2 - - - - - 1 1 - -
CO4 1 1 1 1 3 - - - - - 2 2 3 -
CO5 1 1 2 3 3 - - 1 - - 1 1 2 2
CO6 1 1 1 2 3 1 - 1 - - 2 1 3 3

Enter correlation levels 1, 2 or 3 as defined below:

1: Slight (Low) 2: Moderate (Medium) 3: Substantial (High), If there is no correlation, put
“-”

Recommended Study Material:

❖ Text books:
1. “Java: The Complete Reference, Thirteenth Edition”, by Herbert Schildt, McGraw Hill.
2. “OCP Oracle Certified Professional Java SE 17 Developer (Exam 1Z0-829) Programmer's
Guide”, by Khalid A. Mughal, Vasily A. Strelnikov, Oracle Press.

❖ Reference Books:
1. “Effective Java, 3rd Edition”, by Joshua Bloch, Addison-Wesley Professional.
2. “Core Java Volume I--Fundamentals (Core Series)”, by Cay S. Horstmann, Pearson.
3. “Head First Java, 3rd Edition”, by Kathy Sierra, Bert Bates, Trisha Gee, O'Reilly Media.
Online resources:
1. https://docs.oracle.com
2. https://www.baeldung.com/
3. https://dev.java/

Care-taking Points:
➢ Doubts arising from self-study topics will be addressed and clarified during classroom
sessions to ensure comprehensive understanding.
➢ Ensure that theoretical concepts are backed by hands-on practice. Every major concept, like
inheritance, interface, multithreading, stream API, collections framework etc., should be
complemented by coding exercises or projects to solidify understanding.
➢ Teach coding best practices, including clean code principles, design patterns, and proper use
of Java’s built-in utilities. This ensures students learn to write efficient, maintainable, and
scalable code.

Practical Skill Enhancement Points:

➢ Practical enhancement points bridge the gap between theoretical concepts and real-world
application, enabling students to gain hands-on experience in solving complex problems

Page 39 of 125
➢ Develop the ability to implement object-oriented programming principles to design and
create modular, reusable, and scalable Java applications.
➢ Gain hands-on experience with Java Collections, Generics, and multithreading for managing
data structures and achieving concurrency in real-world scenarios.
➢ Enhance problem-solving skills by building programs that handle exceptions, manage file
I/O, and process input/output operations efficiently.
➢ Acquire practical expertise in creating and debugging Java applications that integrate arrays,
strings, and advanced features like NIO and interfaces.

Page 40 of 125