O

Object-Oriented Language (Java) - Syllabus

8 Chapter 0 Notes 0 Questions

1.  Course Description:

This course offers a comprehensive introduction to Java programming, starting with an overview of object-oriented programming (OOP) concepts and the transition from procedure-oriented programming. Students learn the fundamentals of Java, including variables, data types, operators, control statements, and arrays. Moving on to OOP principles, the course covers classes, objects, encapsulation, constructors, static members, and inheritance. It also explores polymorphism, abstract classes, packages, and interfaces. Exception handling and stream manipulation are addressed, along with graphical user interface (GUI) programming using Swing components. Additionally, students delve into the benefits and implementation of generics for enhanced code reusability and type safety. Through hands-on exercises and projects, students develop practical Java programming skills essential for software development.

2. General Objectives

  • To understanding of fundamental programming concepts such as variables, data types, and control statements in Java.
  • Develop proficiency in object-oriented programming principles including classes, objects, inheritance, and polymorphism.
  • Learn to effectively handle exceptions and manipulate files in Java programs.
  • Acquire practical skills in GUI programming using Swing components and understand the benefits of using generics for code reusability and type safety.

3. Specific Objectives and Contents

Specific ObjectiveContents
  • Recognize limitations of procedure-oriented programming versus object-oriented programming.
  • Highlight advantages and disadvantages of object-oriented programming, focusing on its key features.

Unit I: Introduction to Object-Oriented Programming (3 hrs.)

  1. Problems in Procedure-Oriented Programming
  2. Introduction to Object Oriented Programming,             advantages and disadvantages
  3. Features and concepts of Object-Oriented Programming
  4. Basic Concept of OOP
  • Understand Java's features like platform independence and robustness.
  • Explain JVM components and Java program structure with naming conventions
  • Apply Java fundamentals like variables, data types, operators, arrays, and I/O operations in programming.

Unit II: Basic Java [9 hrs.]

  1. Introduction to Java: Features of Java,
  2. The Java Virtual Machine (JVM), Parts of Java program, Naming Conventions in Java
  3. Variables and constants
  4. Data Types in Java
  5. Operators in Java,
  6. Reading and Displaying Output
  7. Command Line Arguments.
  8. Control Statements in Java 
  9. Array
  • Create classes and objects in Java with proper instance variable initialization.
  • Understand and apply access specifiers and encapsulation to control class member access.
  • Implement constructors and grasp garbage collection concepts, including "this" pointer and static members in Java classes.

Unit III: Object-Oriented Programming (6 hrs.)

  1. Classes and Objects: Object Creation, Initializing the Instance Variables
  2. Access Specifiers and Encapsulation
  3. Constructors and Garbage collection
  4. "this" pointer
  5. static members
  • Explain inheritance and its role in code reuse, covering inheritance types and implementation in Java.
  • Understand polymorphism principles, including method overriding, overloading, dynamic method invocation, and runtime polymorphism.
  • Describe abstract classes, methods, packages, interfaces, and lambda functions, demonstrating their usage in Java programming.

Unit IV: Inheritance and Polymorphism (6 hrs.)

  1. Inheritance and Reuse
  2. Types of Inheritance and its Implementation
  3. Polymorphism: Method Overriding, Method overloading, Dynamic method invocation and Run-time polymorphism
  4. Abstract Classes: Abstract Method and Abstract Class
  5. Packages and Interfaces
  6. Lambda function
  • Understand Java exceptions, including types and significance, and proficiently implement exception handling mechanisms for both built-in and user-defined exceptions in Java programs

Unit V: Exception Handling (6 hrs.)

  1. Introduction to Exception
  2. Errors in Java Program
  3. Types of Exceptions
  4. Exception handling mechanism
  5. Built-in Exceptions in Java
  6. User defined exception in JAVA
  • Understand Java streams, differentiating between byte and character streams.
  • Learn file management using I/O classes like File Input Stream, File Output Stream, Data Input Stream, Data Output Stream, Object Input Stream, and Object Output Stream.

Unit VI: Stream in JAVA (6 hrs.)

  1. Introduction to stream, byte stream and character stream
  2. I/O class hierarchy
  3. Manipulating file:
    • File Input Stream,
    • File Output Stream,
    • Data Input Stream,
    • Data Output Stream,
    • Object Input Stream,
    • Object Output Stream
  • Design GUI creation with Swing components, including buttons, labels, text fields, and text areas, and gain expertise in event-driven programming for mouse and key events

Unit VII: GUI Programming with Swing [8 hrs.]

  1. Introduction to graphical user interface (GUI) programming in java
  2. Using Swing components (buttons, labels, text fields, text area, etc.)
  3. Event-driven programming and event handling: Mouse event and key event
  4. Building Simple Interactive
  5. Applications
  • Develop the skill of using generics in Java and demonstrate proficiency in implementing generic classes, methods, and constructors
  • Apply polymorphism concepts within generic classes and methods

Unit VIII: Generics (4 hrs.)

  1. Advantages of using Generics
  2. Generic classes
  3. Generic methods
  4. Generic constructors
  5. Polymorphism in generic

4. List of practical

  1. Program to define the structure of a basic JAVA program
  2. Program to define the data types, variables, operators, arrays, and control structures
  3. Program to define class and constructors. Demonstrate constructors and garbage collection
  4. Program to define class, methods, and objects. Demonstrate method overloading
  5. Program to define inheritance and show method overriding.
  6. Program to demonstrate Packages.
  7. Program to demonstrate I/O operations.
  8. Program to demonstrate Exception Handling
  9. Program to demonstrate Layout managers
  10. Implementation of generic concepts

Note: Creating a project based on Java using object-oriented concepts

5. Methods of Instruction

  • Lecture
  • Group discussion
  • Question-answers
  • Demonstration and discussion
  • Presentations
  • Guest lectures
  • Group work/project work
  • Problem solving
  • Simulation
  • Tutorials

6. Evaluation System and Students’ Responsibilities Evaluation System

The internal evaluation of a student may consist of assignments, attendance, term exams, lab reports and projects etc. The tabular presentation of the internal evaluation is as follows:

Internal EvaluationWeightMarksExternal EvaluationMarks
Theory 30Semester End50
Attendance & Class Participation10%   
Assignments20%   
Presentations/Quizzes10%   
Internal Assessment60%   
Practical 20  
Attendance & Class Participation10%   
Lab Report/Project Report20%   
Practical Exam/Project Work40%   
Viva30%   
Total Internal 50  
Full Marks: 50 + 50 = 100

7. Students’ Responsibilities

Each student must secure at least 45% marks separately in internal assessment and practical evaluation with 80% attendance in the class to appear in the semester-end examination. Failing to get such a score will be given NOT QUALIFIED (NQ) to appear the Semester-End Examinations. Students are advised to attend all the classes, formal exam, test, etc. and complete all the assignments within the specified time period. Students are required to complete all the requirements defined for the completion of the course.

8. Prescribed Books and References 

Text Books

  1. Schildt, H. (2006). The Complete Reference JAVA (7th ed.). Tata McGraw
  2. Balaguruswamy, E. (2009). Programming with JAVA: A Primer (3rd ed.). TATA McGrawHill Company

References

  1. Liang, D. (2014). Introduction to Java Programming (Comprehensive Version) (7th ed.). Pearson
  2. Malhotra, S., & Chaudhary, S. (2014). Programming in Java. Oxford University Press
  3. Lowe, D., Murach, J., & Steelman, A. (2005). Murach’s Beginning Java 2. SPD