Untitled Quiz

Classes and Objects

• An object is an entity with state (data) and behavior (methods). Examples include chairs, pens, and logical entities.
• An object is an instance of a class. Objects have an address and take up memory space.
• Objects communicate without knowing the internal details of others. Only the accepted message type and returned response matter.
• Classes are templates for creating objects, defining object data types and methods. They are like blueprints.
• OOPs (Object-Oriented Programming) systems feature easier development and maintenance than procedure-oriented ones.
• OOPs provides data hiding, whereas in procedure-oriented languages, global data can be accessed from anywhere.

Constructors

• Constructors are similar to methods, but without a return type. Used to initialize an object.

• Called when an object is created and allocates memory for the object.

• The compiler calls constructors for sub-objects (members and inherited objects). Default or parameterless constructors are called automatically. Parameterized constructors can be initialized with an initializer list.

• If no constructor is explicitly defined, the Java compiler automatically provides a default constructor.

• Constructor rules:

  • The constructor's name must match the class name.
  • It shouldn't have an explicit return type.
  • It cannot be abstract, static, final, or synchronized.

• Types of constructors:

  • Default Constructor: A no-argument constructor (the compiler adds it if not specified).
  • Parameterized Constructor: Takes parameters to initialize an object with distinct values.

Constructor Overloading

• Multiple constructors within a class with different parameter lists.
• The compiler differentiates them based on the number and types of parameters.

Constructor vs. Method

• Constructor: Used for object initialization. Must not have a return type. Invoked implicitly. The Java compiler provides a default constructor if none is defined.
• Method: Used to expose an object's behavior. Must have a return type. Invoked explicitly.

Inheritance

• Inheritance: One object acquires properties and behaviors of a parent object.
• It's crucial in OOPs. You create new classes built on existing ones, reusing parent's methods and fields.
• Relationship: IS-A (e.g., Programmer IS-A Employee).
• Advantages: Method overriding, code reusability.
• Types:
  • Single Inheritance: A class inherits from one parent class.
  • Multilevel Inheritance: A class inherits from another class, which, in turn, inherits from another class (and so on).
  • Hierarchical Inheritance: Multiple classes inherit from a single class.

Polymorphism

• Polymorphism: The ability of an object to take on many forms.
• Common use: A parent class reference can refer to a child class object.
• Java objects are polymorphic because they pass the IS-A test for their own type and the Object class.
• Methods can be overloaded; having multiple methods with the same name but different parameters in the same class.

Method Overriding

• Method overriding: A subclass has a method with the same name and parameter list as a method in its superclass.
• Used to provide specific implementation for methods declared by a parent class that apply to the child class, promoting runtime polymorphism.

Encapsulation

• Encapsulation: Wrapping code and data into a single unit (like a capsule containing several medicines).
• Use private data members to create fully encapsulated classes in Java.
• Getter and setter methods are used to set and get data.
• Advantages: Data hiding, control over data, easier unit testing, and read-only/write-only class options.

Abstraction

• Abstraction: Hiding implementation details and showing only essential functionality to the user (e.g., sending an SMS).
• Ways to achieve abstraction:
  • Abstract class: A class that cannot be instantiated. Can contain abstract and concrete methods.
  • Interface: A reference type containing only abstract methods and constants. Implements complete abstraction.

Conditional Statements

• Decision making: Executes statements based on conditions.
• IF statement: Executes code based on whether a Boolean expression is true.
• IF-ELSE: Executes one block if a condition is true and another if it's false.
• IF-ELSE-IF: Handles multiple conditions using a chain of else-if statements.
• Nested IF: A nested structure where an if statement is within another if statement.
• SWITCH: Allows selecting multiple code blocks based on the possible values of an expression.

Looping Constructs

• Loop statements: Repeatedly execute a block of code multiple times.
• WHILE loop: Repeats code as long as a condition is true.
• FOR loop: Repeats code for a specific number of iterations.
• DO-WHILE loop: Repeats code at least once and then repeats as long as a condition is true.
• ENHANCED FOR loop: Simplified iteration through arrays and collections.

this Keyword

• this: Refers to the current object instance in a method/constructor.
• Resolves ambiguity between instance variables and method/constructor parameters.
• Invokes the current class's method or constructor.

super Keyword

• super: Refers to the immediate parent class, allowing access to parent class variables, methods, and constructors.

Static Keyword

• static: Belongs to the class, not an object instance.
• Used for class variables and methods shared among all objects of the class.

Final Keyword

• final: Modifies variables, methods, or classes to prevent them from being changed.
• final variables: Constants, cannot be reassigned after initialization.
• final methods: Cannot be overridden in subclasses.
• final classes: Cannot be extended, and cannot be subclassed.

String Manipulation

• Strings: Sequences of characters. Java's String class enables creating and manipulating strings.
• Creating strings directly: String greeting = "hello world";
• String length: string.length().
• Concatenating strings: string1 + string2 or string1.concat(string2)

Packages

• Packages: Group related classes, interfaces, and subpackages.
• Advantages: Categorization, access protection, naming collision avoidance.
• Accessing a package: Using import package.classname, import package.*, or the fully qualified name.

Interfaces

• Interfaces: Referencing type. Collections of abstract methods and constants—similar to classes but with no concrete implementation. Methods are implicitly public and abstract.
• Similarities: Interfaces can have instance variables, and they are placed in packages.
• Differences: Cannot be instantiated, no constructors, only abstract methods, only static-final fields. Interfaces can extend multiple interfaces; classes only one class.

Exceptions

• Exceptions: Events disrupting normal program flow (e.g., division by zero).
• Checked exceptions: Compiler enforces handling (e.g., FileNotFoundException).
• Unchecked exceptions: Runtime exceptions (e.g., ArrayIndexOutOfBoundsException), errors.
• Handling Exceptions: try-catch block handles potential exceptions.
• throws: Method signature indicates checked exceptions to be handled by a caller.
• finally: Block ensures code execution regardless of exception occurrence.

Data Structures

• Arrays: Contiguous memory locations storing elements of the same type.
• Queues: First-In, First-Out (FIFO) data structures, elements are added to the rear and removed from the front. Commonly used in various operations.
• Lists: Ordered collections of elements, allow arbitrary access.
• Sets: Collections forbidding duplicate elements.
• Maps: Collections storing key-value pairs, associating values with unique keys.

HTML

• HTML: Standard markup language for creating web pages, describing their structure.
• Elements: Building blocks (e.g., headings, paragraphs, links).
• Tags: Label content and tell the browser how to format it.
• Simple HTML document: Contains the basic structure <html>, <head>, <title>, <body>, <p>.

CSS

• CSS: Cascading Style Sheets, used to style HTML elements.
• Styling methods: inline, internal, and external.

JavaScript

• JavaScript: Programming language for web interaction.
• Syntax: Declares variables using var and assigns values to them.
• Variables & Strings: Variables store data values. Strings are text enclosed in quotes.
• Comparison Operators: Equality comparisons. == vs ===.