Teaching Guidelines for

Object Oriented Programming with Java

PG-DAC September2023

Duration: 112 hours (50 theory hours + 50 lab hours + 12 revision/practice hours)

Objective: To reinforce knowledge of Object Oriented Programming concepts using Core Java.

Prerequisites: Basic knowledge of computer programming

Evaluation: Total 100 marks

Weightage: CCEE – 40%, Lab exam – 40%, Internals – 20%

Text Book:
 Core and Advanced Java Black Book / Dreamtech Press

References:
 Java 8 Programming Black Book / Dreamtech Press
 Core Java : Volume 1 - Fundamentals by Cay S. Horstmann / Prentice Hall
 Core Java : Volume 2 - Advanced Features by Cay S. Horstmann / Prentice Hall
 Programming in Java by Sachin Malhotra, Saurabh Choudhary / Oxford University Press
 Java The Complete Reference by Herbert Schildt / McGraw Hill
 Core Java 8 for Beginners by Sharanam Shah, Vaishali Shah / Shroff Publishers
 Murach’s Java Programming by Joel Murach / Mike Murach
 Object-Oriented Analysis and Design with applications by Grady Booch / Pearson

(Note: Each Session is of 2 hours)

Session 1: Introduction to Java
Lecture:
 Introduction to java
 Features of java
 JVM Architecture
 JDK and its usage
 Structure of java class
 Working with data types: Primitive data types

Session 2: Basic programming concepts

Lecture:
 Java Tokens
 Declaring variables and methods
 Data type compatibility
 Operators
 Control statements
 Arrays 1-D and multidimensional array
Lab 1 & 2:
 Get yourself acquainted with java environment.
 Print different patterns of asterisk (*) using loops (e.g. triangle of *).
Tutorial:
 Compare syntactical similarities and dissimilarities between Java and C++.

Object Oriented Programming Concepts

Session 3: Object Oriented Programming Concepts
Lecture:
 Introduction to OOP
 Classes and Objects
 OOP principles
 Encapsulation, Abstraction, Inheritance and Polymorphism

Session 4:
Lecture:
 Static variables and methods
 Accessing static variables and methods of different class
 Introduction to reference data types
 Reference variables and methods
 Difference between reference data types and primitive data types
 Difference between reference variable and static variable

Session 5:
Lecture:
 Constructors, initializing reference variables using constructors.
 Pass by value v/s pass by reference.
 Re-assigning a reference variable.
 Passing reference variable to method
 Initializing reference variable of different class
 Heap memory and stack memory
Lab 3 & 4:
 Print default values of static & instance variables for different data types.
 Build a class Employee which contains details about the employee and compile and run its
instance.
 Build a class which has references to other classes. Instantiate these reference variables and
invoke instance methods.
Tutorial:

 Understand role of stack and heap memory in method invocation and object creation.

Session 6:
Lecture:
 Inheritance: single & multilevel
 Inheritance: Hierarchical
 Association, Aggregation and Composition
  Polymorphism: Compile time and runtime polymorphism
 Rules of overriding and overloading of methods
 super and this keyword
Lab 5 & 6:
 Create a class Employee and encapsulate the data members.
 Create demo applications to illustrate different types of inheritance.

Session 7:
Lecture:
 Upcasting &down casting of a reference variable
 Abstract class and abstract methods
 Interface (implementing multiple interfaces)

Session 8:
Lecture:
 Final variables, final methods and final class
 Functional interface
 New interface features (Java 8 & 11)
 Lambda Expression
 Inner Class (Regular, Method local, Anonymous & static inner class)
 Enum
Lab 7 & 8:
 Create an Array of Employee class and initialize array elements with different employee objects.
 Try to understand the no of objects on heap memory when any array is created.

Session 9:
Lecture:
 Access modifiers (public, private, protected and default)
 Packages and import statements.
 Static imports
 Constructor chaining (with and without packages)
 Accessing protected variables and methods outside the package

Session 10:
Lecture:
 Garbage collection in java
 Requesting JVM to run garbage collection.
 Different ways to make object eligible for garbage collection: (Nulling a reference variable, Re-
assigning a reference variable & island of isolation)
 Finalize method.
Lab 9 & 10:
 Create a demo application to understand the role of access modifiers.
 Implement multilevel inheritance using different packages.
 Access/invoke protected members/methods of a class outside the package.
 Override finalize method to understand the behavior of JVM garbage collector.
Sessions 11 & 12:
Wrapper Classes and String Class
Lecture:
 Wrapper classes and constant pools
 String class, StringBuffer& StringBuilder class
 String pool
Lab 11 & 12:
 Create sample classes to understand boxing & unboxing.
 Use different methods of java defined wrapper classes.
 Create StringDemo class and perform different string manipulation methods.
Tutorial:

 Understand the difference between String / StringBuffer / StringBuilder.

Sessions 13 & 14:

Exception Handling
Lecture:
 Exception hierarchy, Errors, Checked and un-checked exceptions.
 Exception propagation
 try-catch-finally block, throws clause and throw keyword.
 Multi catch block.
 Creating user defined checked and unchecked exceptions.
Lab 13 & 14:
 Create user defined checked and unchecked exceptions.

Session 15:
java.io & java.nio Package
Lecture:
 Brief introduction to InputStream, OutputStream, Reader and Writer interfaces
 NIO package
 Serialization and de-serialization
 Shallow copy and deep copy

Session 16:
Lecture:
Object Class & java.util Package
 Date, DateTime, Calendar class
 Converting Date to String and String to Date using SimpleDateFormat class
 Object Class: Overriding to String, equals &hashcodemethod
Lab 15 & 16:
 Create a Demo class to Read & write image/text files.
 Create SerializationDemo class to illustrate serialization and de-serialization process.
 Create a demo class for Date, Time and Calendar
Collections
Sessions 17, 18 & 19:
Lecture:
 Introduction to collections: Collection hierarchy
 List, Queue, Set and Map Collections
 List Collection:
o ArrayList, LinkedList
o Vector (insert, delete, search, sort, iterate, replace operations)
 Collections class
 Comparable and Comparator interfaces
 Queue collection
Labs 17, 18 & 19:
 Create DateManipulator class to convert String to date, date to String and to find out number of
days between two dates.
 Create a list of java defined wrapper classes and perform insert/delete/search/iterate/sort
operations.
 Create a collection of Employee class and sort objects using comparable and comparator
interfaces.
 Implement Queue data structure using LinkedList and Queue collection.

Sessions 20 & 21:

Lecture:
 Set Collection:
o HashSet, LinkedHashSet&TreeSet collection
o Backed set collections.
 Map Collection:
o HashTable, HashMap, LinkedHashMap&TreeMap classes
o Backed Map collections.
 Concurrent collections
Labs 20 & 21:
 Create an Employee HashSet collection and override equals &hashCode methods to understand
how the set maintains uniqueness using these methods.
 Create a Sample class to understand generic assignments using “? extends SomeClass” , “? super
someclass ” and “?”.

Session 22:
Lecture:
 MultiThreading : Thread class and Runnable Interface
 sleep, join, yield, setPriority, getPrioritymethods.
 ThreadGroup class
Lab 22:
 Create multiple threads using Thread class and Runnable interfaces.
 Assign same task and different task to multiple threads.
 Understand sleep, join, yield methods.
Sessions 23 & 24:
Lecture:
 Synchronization
 Deadlock
 Wait, notify and notifyAllmethods.
 Producer & Consumer problem
Lab 23 & 24:
 Create a Deadlock class to demonstrate deadlock in multithreading environment.
 Implement wait, notify and notifyAll methods.
 Demonstrate how to share threadlocal data between multiple threads.

Session 25 : Generics and Reflection API

Lecture:
 Introduction to generics
 Generic classes
 Generic methods
 Wild cards (upper and lower)
 Reflection
Lab 25:
 Invoke private methods of some other class using reflection.
 Create multiple threads using anonymous inner classes.
 Create multiple threads using lambda expressions.