E-Learn

Object-oriented programming is a programming paradigm that organizes code into objects that represent real-world entities. It emphasizes encapsulation, inheritance, and polymorphism to achieve modular and reusable code.

An abstract class in Java can have both abstract and concrete methods, while an interface can only have abstract methods. A class can implement multiple interfaces, but it can extend only one abstract class.

A stack is a data structure that follows the Last-In-First-Out (LIFO) principle, where the last element added is the first one to be removed. On the other hand, a queue follows the First-In-First-Out (FIFO) principle, where the first element added is the first one to be removed.

The "finally" block is used to define a section of code that will be executed regardless of whether an exception is thrown or caught. It is commonly used to release resources, such as closing files or database connections, to ensure they are properly cleaned up.

Method overloading allows a class to have multiple methods with the same name but different parameters. The compiler determines which method to invoke based on the number, types, and order of the arguments passed during the method call. This enables more flexibility and convenience when working with methods that perform similar operations but with different inputs.

A shallow copy creates a new object that references the same memory locations as the original object. Changes made to the copied object will also affect the original object. In contrast, a deep copy creates a completely independent copy of the original object, including all nested objects, so changes made to the copied object do not affect the original object.

A hash table (or hash map) is a data structure that uses a hash function to map keys to indices in an array. It provides fast access and retrieval of values based on the keys. The hash function calculates the index where the key-value pair should be stored, and collisions (multiple keys hashing to the same index) are handled by techniques like chaining or open addressing.

A primary key is a column (or a set of columns) in a table that uniquely identifies each row in that table. It ensures the integrity and uniqueness of the data. On the other hand, a foreign key is a column (or a set of columns) in a table that establishes a link or relationship with the primary key of another table. It enforces referential integrity and allows data to be connected across multiple tables.

A RESTful API (Representational State Transfer) is an architectural style for designing networked applications. It follows a set of constraints and principles, such as using HTTP methods (GET, POST, PUT, DELETE) for data manipulation and utilizing standard URIs (Uniform Resource Identifiers) to represent resources. RESTful APIs are stateless, scalable, and widely used for building web services.

Recursion is a programming technique where a function calls itself to solve a problem by breaking it down into smaller, similar subproblems. Each recursive call operates on a smaller input, and the results are combined to solve the original problem. Recursion often involves a base case that terminates the recursion and prevents an infinite loop.

The "this" keyword refers to the current instance of a class. It is used to differentiate between instance variables and parameters or local variables with the same name. It is also used to invoke other constructors in the same class or to pass the current object as a parameter to other methods.

A static variable belongs to the class itself and is shared among all instances of that class. It is declared with the "static" keyword and can be accessed directly through the class name. An instance variable, on the other hand, belongs to each instance of the class and has a separate copy for each object. It is declared without the "static" keyword and is accessed through object references.

Garbage collection in Java automatically reclaims memory from objects that are no longer reachable or in use. The Java Virtual Machine (JVM) keeps track of object references and periodically identifies and removes unreferenced objects. It uses algorithms like Mark and Sweep or Copying to reclaim memory occupied by objects that are no longer needed, making memory management more convenient for developers.

Checked exceptions are exceptions that need to be declared in the method signature using the "throws" keyword or caught within a try-catch block. They are typically used for anticipated exceptional conditions that the calling code should handle. Unchecked exceptions, on the other hand, do not need to be declared or caught explicitly. They are usually related to programming errors or runtime conditions and are not expected to be handled explicitly.

The "volatile" keyword in Java is used to indicate that a variable can be accessed by multiple threads and its value should always be read from and written to the main memory, bypassing any thread-specific caching. It ensures that the most up-to-date value of the variable is visible to all threads, making it useful for synchronizing access to shared variables in concurrent programming.

Version control systems (VCS) provide several advantages, including:

• Ability to track changes to files and directories over time
• Facilitate collaboration and teamwork by enabling multiple developers to work on the same codebase simultaneously
• Revert to previous versions of code or files
• Branching and merging to manage parallel development and isolate features or bug fixes
• Backup and disaster recovery for code repositories

An index in a database is a data structure that improves the speed of data retrieval operations on database tables. It is created on one or more columns of a table and contains a sorted copy of the values in those columns. Indexes allow the database to quickly locate the rows that satisfy a query's search conditions, reducing the need for full table scans and improving query performance.

Polymorphism refers to the ability of an object to take on many forms or have multiple types. In object-oriented programming, polymorphism allows objects of different classes that are related through inheritance to be treated as objects of a common superclass. This enables more generic programming and the ability to write code that can work with objects of different classes but with shared behaviors or interfaces.

A foreign key constraint in a relational database enforces referential integrity between two tables. It ensures that the values in a foreign key column of a table match the values of a primary key in another table. This constraint prevents orphaned records and maintains the integrity of relationships between tables, enforcing consistency and preventing data inconsistencies.

Encapsulation is the process of bundling data (attributes) and methods (behaviors) together within a class. It allows the class to control the access and visibility of its internal state, providing a protective barrier around the data. Encapsulation provides abstraction, data hiding, and modularity, enabling the class to enforce its own rules and constraints on how the data is accessed and manipulated.