Java Programming Fundamentals Quiz

Unit-1

• Introduction: Covers object-oriented programming (OOP), the history and evolution of Java, data types, variables, type conversion, casting, arrays, operators, control statements, method overloading, constructor overloading, parameter passing, recursion, and string handling methods.
• History of Java: Java was developed by Sun Microsystems (now Oracle) in 1991, originally called oak. It was renamed to Java in 1995 and is now used in many devices and applications.
• Principles of Java: Java's creation had five core goals: simplicity, object-orientation, familiarity, robustness and security, architecture-neutrality and portability, high performance, and interpretation, threading, and dynamism.
• Java Editions:
• Java Standard Edition (J2SE / JSE): Used for client-side applications and applets running in web browsers.
• Java Enterprise Edition (J2EE / JEE): Used for building enterprise-oriented server applications, including servlets.
• Java Micro Edition (J2ME / JME): Primarily used for developing mobile applications.
• Java FX (JavaFX): Used for developing rich internet applications with a light-weight UI API

Unit-2

• Object-Oriented Programming (OOPs) Concepts:
• Class: A blueprint from which objects are created, containing data fields (attributes or properties) and methods (functions).
• Object: An instance of a class, with its own data and behavior.
• Inheritance: When one class (subclass) inherits properties and methods from another class (superclass) to avoid code repetition.
• Polymorphism: The ability of an object to take on many forms, achieved through inheritance and method overriding.
• Abstraction: Hiding complex implementation details and showing only essential information to the user.
• Encapsulation: Bundling data and methods that operate on that data within a class to protect the data from direct access.
• Example (OOP principle): A dog is an objective because it has states(like color, name, breed...) and behaviors(wagging, barking, eating...).
• Inheritance: One class acquires the attributes and behaviors of another class, in a parent-child relationship(subclass-superclass).
• Polymorphism: One interface/method can have multiple implementations depending on the class.
• Abstraction: Simplifying complex processes by showcasing only the core functionality to the user, hiding underlying details; achieved using classes and methods.
• Encapsulation: Consolidating data and its handling mechanisms within a class.

Unit-3

• Exception Handling Fundamentals: Exceptions are unexpected events during runtime, causing abnormal termination if not properly handled.
• Exception types:
• Checked Exceptions: These need to be handled or declared in the method signature using the 'throws' keyword.
• Unchecked Exceptions: Typically due to programming errors and don't need to be explicitly handled (runtime errors).
• Errors: Irrecoverable conditions; programmers usually can't handle them.
• Advantages of exception handling: Keeps the application running in an orderly fashion even when an error occurs. Prevents crashing by gracefully dealing with errors.Improves code readability and maintainability by segregating error handling logic.
• try-catch-finally block: The basic structure used for handling exceptions in Java, allowing the program to continue even when an exception occurs.
• Java Exception Keywords: try, catch, finally, throw, throws.
• try: The block containing the code at risk of throwing an exception.
• catch: The block to handle a specific exception type if it occurs within the try block.
• finally: The block used to execute code that must always be run, regardless of whether an exception occurred or not.
• throw: Used to explicitly generate/throw a custom exception.
• throws: Declares the exception types that a method may throw so that the caller knows how to handle it (method signature).
• Nested try-catch blocks: Try-catch blocks placed sequentially inside one another for more complex exception handling scenarios.

Unit-4

• Introduction to Streams: A stream is a sequence of data, used for translating data from one place to another, such as from keyboard to file.
• Java Standard Streams: This are predefined streams like
• System.in: input from keyboard
• System.out: output to console
• System.err: errors displayed to console
• Byte Streams: Used for handling 8-bit bytes, including
• InputStream: Used for reading data from different kinds of sources (file, string, memory).
• OutputStream: Used for writing data into different destinations.
• Character Streams: Used for handling 16-bit Unicode characters.
• Reader(Input): Used for reading text from different sources.
• Writer(Output): Used for writing text to different destinations.
• File Class: This class allows interaction with files and directories(folders), operations like: checking existence, creating, deleting, etc.
• FileWriter: Used for outputting character data to a file.
• FileReader: Used for reading character data from a file.
• RandomAccessFile: Used to access data in a file randomly, permitting both read and write operations.

Unit-5

• Introduction to Enums: Enumerations in Java represent a collection of named constants (e.g., days of the week).
• Introduction to Java Collections framework: Provides interfaces (such as List, Set, Map) and classes (such as ArrayList, HashSet, HashMap) to store and manage collections of objects.

Unit-6

• Generics: Enable writing type-safe code to handle different data types without casting, increasing code robustness.
• StringBuilder/StringBuffer: Classes providing mutable strings that can efficiently handle operations requiring text modification. They are not as fast or efficient as String objects but are better suited for modification.
• Introduction to Java GUI framework(AWT and Swing): Both AWT and Swing provide ways for creating graphical user interfaces (GUIs), but Swing is the preferred modern approach due to its platform independence for writing GUI elements.

Unit-7

• Introduction to Java Database Connectivity (JDBC): JDBC is a standard API for connecting Java programs to databases, especially relation databases.
• JDBC Drivers: Help in communicating with the database management systems (DBMS). They are important for interfacing.
• Understanding how the different types of drivers, work with Java applications and respective Databases.
• Introduction to Multithreading: Programming concepts about multitasking, creating, managing, and synchronizing threads.