Core Java Flashcards

Question

What is the difference between ordered and sorted collections?

Answer 1

**Ordered collections** * Maintain the order in which elements are inserted. * Example: LinkedHashSet, ArrayList. **Sorted collections** * Arrange elements according to a specific sort order (natural or custom comparator). * Example: TreeSet, TreeMap.

Answer 2

**Static class:** * Java does not have top-level static classes, but you can have static nested classes. * All members are static; cannot be instantiated on its own. **Singleton class:** * Ensures only one instance exists in the application. * Provides a global access point (usually via a static method).

Answer 3

**Java singleton:** * Ensures only one instance of a class exists per JVM using design patterns (e.g., private constructor, static instance). **Spring singleton:** * Only one instance of a bean is created per Spring IoC container (not per JVM). * Multiple containers can have their own singleton instances.

Answer 4

**Comparable:** * Interface for natural ordering; implement compareTo() in the class itself. * Used when objects have a default sort order. **Comparator:** * Interface for custom ordering; implement compare() in a separate class or as a lambda. * Used to define multiple or alternative sort orders.

Answer 5

**final:** * Keyword to mark variables as constants, prevent method overriding, or prevent class inheritance. **finally:** * Block used after try-catch to execute code regardless of exceptions. **finalize():** * Method called by the garbage collector before object destruction (deprecated in recent Java versions).

Answer 6

**Abstraction:** * Hides complex implementation details and shows only essential features. * Achieved using abstract classes and interfaces. * Example: An interface Vehicle with methods like start() and stop(), hiding how they work. **Encapsulation:** * Bundles data (fields) and methods together; restricts direct access to data. * Achieved using private fields and public getters/setters. * Example: A class Person with private age field and public getAge()/setAge() methods.

Answer 7

**Implementation:** * Make fields private. * Provide public getters and setters to access or modify fields. * Example: ``` public class Person { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } } ``` **Benefits:** * Protects data from unauthorized access/modification. * Improves code maintainability and flexibility. * Allows validation or logic in setters.

Answer 8

**Inheritance:** * Mechanism where one class (subclass) acquires fields and methods from another class (superclass). * Promotes code reuse and establishes an "is-a" relationship. * Example: ``` class Animal { void eat() { System.out.println("Eating"); } } class Dog extends Animal { void bark() { System.out.println("Barking"); } } // Usage: Dog d = new Dog(); d.eat(); // Inherited from Animal d.bark(); // Defined in Dog ```

Answer 9

* Prefer building classes by combining (composing) other classes/objects, rather than extending them. * Composition allows more flexibility and easier code changes, as behavior can be changed at runtime. * Inheritance creates tight coupling and can make code harder to maintain. Example: Instead of class Car extends Engine, use class Car { private Engine engine; }.

Answer 10

**Advantages:** * Thread-safe by default (no synchronization needed). * Simpler code, fewer bugs from shared state. * Easy to cache and reuse. **Disadvantages:** * Can lead to more object creation (higher memory usage). * May require complex patterns for updates (since objects can’t be changed).

Answer 11

**Implementation:** * Make the class final (cannot be subclassed). * Make all fields private and final. * Do not provide setters; initialize fields via constructor. * Return copies of mutable fields in getters. * Example: ``` public final class Person { private final String name; public Person(String name) { this.name = name; } public String getName() { return name; } } ``` **Usefulness:** * Thread-safe by default. * Easier to reason about and debug. * Prevents accidental changes to data.

Answer 12

**Strong reference:** * Default type; prevents object from being garbage collected. **Soft reference:** * Cleared only when memory is low; useful for caches. **Weak reference:** * Cleared at next garbage collection; used in WeakHashMap. **Phantom reference:** * Used to track object finalization; enqueued after object is finalized, before memory is reclaimed.

Answer 13

**Inner class:** * Defined inside another class; used for logically grouping classes that need access to outer class members. **Static inner class:** * Static member of outer class; used when inner class doesn’t need access to outer class instance. **Local class:** * Defined within a method; used for short-lived, method-specific tasks. **Anonymous class:** * No name; used for quick, one-off implementations (often for interfaces or abstract classes).

Answer 14

* A design principle that says: "Only talk to your immediate friends." * An object should only call methods of: * Itself * Its fields * Its method parameters * Objects it creates * Reduces coupling and increases code maintainability.

Answer 15

**Variance:** * Describes how subtyping between more complex types relates to subtyping between their components (e.g., generics). **Types of variance:** * Covariance: Allows a generic type to accept subtypes (? extends Type). Example: List. * Contravariance: Allows a generic type to accept supertypes (? super Type). Example: List. * Invariance: No subtyping; types must match exactly. Example: List is not a subtype of List

Answer 16

**Why use generics?** * Enable type-safe code (catch errors at compile time). * Eliminate need for casting. * Allow code reuse for different types (e.g., List).

Answer 17

**Type erasure:** * Java compiler removes generic type information at runtime. * All generic types are replaced with their bounds or Object. * Prevents use of generic type info at runtime (e.g., can’t create new T()).

Answer 18

* Special classes that restrict which other classes or interfaces can extend or implement them. * Use the sealed, non-sealed, and permits keywords. * Improve control over class hierarchies and enhance code safety.

Answer 19

Functional interfaces have a single abstract method; used with lambdas and method references. Common examples: * Predicate: Takes T, returns boolean. Use case: Filtering (stream.filter(x -> x > 0)). * Function: Takes T, returns R. Use case: Mapping (stream.map(String::length)). * Consumer: Takes T, returns nothing. Use case: Performing actions (stream.forEach(System.out::println)). * Supplier: Takes nothing, returns T. Use case: Lazy value generation (Supplier now = Date::new). * UnaryOperator: Takes T, returns T. Use case: Transforming values (list.replaceAll(String::toUpperCase)). * BinaryOperator: Takes two Ts, returns T. Use case: Reducing (stream.reduce(Integer::sum)).

Answer 20

* Class: Cannot be subclassed (no inheritance). Example: public final class Utility {} * Method: Cannot be overridden by subclasses. Example: public final void print() {} * Variable: Value cannot be changed after initialization (constant). Example: final int MAX = 10; * Parameter: Value cannot be changed within the method. Example: void setName(final String name) { ... }

Answer 21

**Advantages:** * final fields are guaranteed to be visible to other threads after the constructor finishes (safe publication). **Potential issues:** * If the object reference (this) escapes during construction (e.g., published to another thread before the constructor completes), other threads may see a partially constructed object, even with final fields. * Mutable objects referenced by final fields can still be changed, leading to thread-safety issues.

Core Java Flashcards

(45 cards)