MCA-109
Object Oriented Programming and JAVA
Object orientation taught through Java — classes and inheritance, exceptions, threads, collections, GUIs, JDBC and the Java 8 constructs.
- Semester
- Semester 1
- Credits
- 3
- Scheme
- 3 lectures a week
- Contact hours
- 44 across four units
- Category
- Core
What the paper is
Object Oriented Programming and JAVA is the first semester's programming paper, and it is broader than its name suggests. Only the first unit is about object orientation as a paradigm; the rest is a tour of the standard library, and by the end you are expected to have written a database-backed client-server application.
The syllabus is unusually specific about the JVM — class file format, bytecode engineering, class loaders and the sandbox security model all appear in Unit I. That is not the part of Java you meet while writing code, and it needs reading deliberately rather than picking up.
The examinable code in this paper is short but exact. Thread synchronisation, exception hierarchies, collection interfaces and JDBC connection sequences all get asked as “write a program that…”, and marks go on the details — which interface, which method, which order.
What to concentrate on
- Multithreading is where the hard marks are. Be able to write a synchronised producer-consumer with `wait` and `notify` from memory; it is the question that most reliably appears in some form, and it also covers inter-thread communication and the thread life cycle at once.
- For the collection framework, learn the interface hierarchy first and the classes second. Knowing why you would reach for a `LinkedHashMap` over a `TreeMap` answers more questions than memorising either one's methods.
- Unit IV's JDBC — obtaining a connection, `Statement` versus `PreparedStatement` versus `CallableStatement`, reading a `ResultSet` — is compact, mechanical and frequently asked. It is the cheapest unit to secure.
Syllabus, unit by unit
Summarised from the approved scheme. Hours are the contact hours the scheme allots, which is a fair guide to where the marks sit.
Unit I · The object-oriented paradigm and Java fundamentals
12 hours- Comparison of programming paradigms, characteristics of object-oriented languages, object-based languages
- History and features of Java, structure of a program, the JVM and its architecture and instruction set
- The .class file format, instrumentation, bytecode engineering libraries, class loaders and the sandbox security model
- Keywords, constants, variables, operators, looping and decision-making constructs
- Objects and classes, encapsulation, data abstraction, inheritance, polymorphism, dynamic binding, message passing
- Arrays and strings, String and StringBuffer, wrapper classes, `super`, multilevel hierarchies, abstract and final classes, the Object class, packages, interfaces and access protection
Unit II · Exceptions, threads, collections and networking
12 hours- Exception handling: exception types, caught and uncaught exceptions, throw, throws, built-in and custom exceptions
- Multithreaded programming: happens-before ordering, priorities, synchronisation, messaging, the Thread class and Runnable interface
- Inter-thread communication, suspending, resuming and stopping threads
- The collection framework: the Collection interface and architecture, collection classes, traversal, maps and sets
- Networking fundamentals: the java.net package, TCP/IP and datagram programming
Unit III · Inner classes, events and Swing
10 hours- Anonymous, nested and inner classes and their implementation
- Event handling: the delegation event model, event classes and listener interfaces, adapter and inner classes
- Working with windows, graphics and text, AWT controls, layout managers and menus
- Handling images, animation, sound and video
- Swing: introduction to the Java Foundation Classes, features, comparison with AWT, advanced controls
Unit IV · JDBC, I/O, Java 8 and RMI
10 hours- JDBC: the API and application architecture, obtaining a connection, two-tier and three-tier models
- ResultSet, PreparedStatement and CallableStatement
- Input/output: streams, byte and character streams, predefined streams, reading and writing console and files
- Java 8: default and functional interfaces, lambda expressions, the stream API and pipelines, try-with-resources, memory optimisation
- RMI: creating a remote object, stub and skeleton generation, architecture and packages
How it is examined
- Question 1 is compulsory, covers the whole syllabus, and is made of objective or short-answer questions. It carries 12 marks.
- The rest of the paper is four units matching the four above. Each unit sets two questions and you attempt one, so there are four more answers at 12 marks each.
- Examiners are asked to map every question to a course outcome using Bloom's taxonomy, which is why questions are phrased as “apply”, “analyse” or “evaluate” rather than only “explain”.
The pass mark is 40 out of 100 in every paper.
Learning objectives
- Implementing object-oriented concepts through Java
- Identifying and applying the Java thread model
- Understanding the basics of the collection framework
- Understanding and applying the Java 8 constructs
- Implementing JDBC, RMI and related concepts
Assumed beforehand
- Programming fundamentals and object orientation concepts
Paired in the scheme with MCA-167 Object Oriented Programming and JAVA Lab.
Books it is taught from
- TB1Herbert Schildt, “Java: The Complete Reference”, Oracle Press, 9th edition, 2014
- TB2Kathy Sierra and Bert Bates, “Head First Java”, O'Reilly, 2nd edition, 2005
Notes for MCA-109
Lecture notes, question papers and assignments filed against MCA-109 are in the library. Everything there has been checked by a moderator before it appears, and an account is free — new ones are approved by hand, which is what keeps the shelf clean.