1. Class (Type, File)

Question 1

Ways to Create a New Type/Class in Java

Answer 1

To create a new type or class in Java, we need to declare it. There are three types of class declarations: normal class declarations, enum declarations, and record declarations. A normal class declaration includes class modifiers, type identifier, type parameters (if any), class extends, class implements, class permits, and the class body.

Question 2

Inner Classes in Java

Answer 2

Java defines three types of inner classes: member inner classes, local inner classes, and anonymous inner classes. Member inner classes are classes defined at the member level of another class and can access the members of the outer class, including private ones. They can have various access modifiers, be abstract or final, extend classes, implement interfaces, and declare static fields or methods.

Question 3

Anonymous Inner Class

Answer 3

An anonymous inner class is an inner class that lacks a name and is declared and instantiated in one statement using the new keyword, type name with parentheses, and braces {}. It must extend an existing class or implement an existing interface. It is useful for short implementations that won’t be used elsewhere.

Question 4

Multiple Classes in a Single Java File

Answer 4

A single Java file can contain multiple classes, but only one of them can have a public access modifier. Other classes in the same file must not have the public access modifier.

Question 5

Naming Convention for Java Classes

Answer 5

Class names in Java should follow the PascalCase convention and should be nouns.

Question 6

Keywords for Creating New Classes/Types

Answer 6

To create new classes or types in Java, you can use class modifiers, including Annotation, public, private, abstract, static, final, sealed, non-sealed, and strictfp.

Question 7

Structure of a New Type in Java

Answer 7

A Java class can include various structural elements, including fields, methods, nested classes, nested interfaces, or nested enum types. Additionally, a class body may contain instance initializers, static initializers, and constructor declarations.

Question 8

Java Bytecode

Answer 8

Java bytecode is the instruction set for the Java Virtual Machine (JVM). It is generated during compilation and enables platform independence for Java programs.

Question 9

Structure of a ‘.class’ File

Answer 9

A ‘.class’ file consists of 8-bit bytes and contains the definition of a single class, interface, or module. It includes various components such as magic, minor_version, major_version, constant_pool_count, constant_pool, access_flags, and more.

Question 10

What is a Class in Java?

Answer 10

A class in Java serves as a blueprint for creating objects. It defines the structure and behavior of objects.

Question 11

Abstract Class

Answer 11

An abstract class in Java cannot be instantiated. It is declared using the ‘abstract’ keyword and serves as a template for concrete subclasses.

Question 12

Abstract Class and ‘final’ Modifier

Answer 12

An abstract class cannot be declared as ‘final’ because it’s meant to be extended by subclasses, and declaring it ‘final’ would prevent this.

Question 13

Abstract Method in Non-Abstract Class

Answer 13

It is a compile-time error to declare an abstract method in a non-abstract class in Java.

Question 14

Methods in a Class

Answer 14

A class in Java can have up to 65,535 methods.

Question 15

Constructors in an Abstract Class

Answer 15

Abstract classes can have constructors, even though they cannot be directly instantiated. Constructors in an abstract class may initialize its members.

Question 16

Interface Inside a Class

Answer 16

Java allows classes to have nested interfaces, which can have various access modifiers, including public, private, or protected.

Question 17

Records

Answer 17

Records in Java are a specialized kind of class that represents a simple aggregate of values. They have a compact syntax for defining data classes.

Question 18

Shadowing

Answer 18

Shadowing occurs when a declaration of a type in a particular scope has the same name as another declaration in the enclosing scope, leading to the shadowed declaration not being accessible by its name alone.

Question 19

Purpose of Static and Non-Static Blocks

Answer 19

Static blocks are used for class initialization and execute when the class is loaded.
Non-static blocks (instance initializers) run when an instance of the class is created.

Question 20

Static Blocks

Answer 20

Defined using the static keyword.
Multiple static blocks execute in the order they are declared.
Cannot contain the return statement or reference variables outside the block.

Question 21

Non-Static Blocks

Answer 21

Also known as instance initializers.
Executed when an instance is created.
Cannot contain the return statement.

Question 22

Difference between Code Blocks and Instance Initializers

Answer 22

Code blocks and instance initializers are not the same.
Instance initializers cannot be inside methods.

Question 23

Life Cycle of Static and Non-Static Blocks

Answer 23

Static Blocks:

Run when the class is first used, either through object creation or accessing static members.
Execute in the order they are defined.
Assign static variables as needed.
Non-Static Blocks:

Run in the order they appear in the file.
Execute before the constructor.

Question 24

Static and Non-Static Blocks in Inheritance

Answer 24

Execution Rules:
Parent class’s static initializer runs when any method in its subclass is executed.
Parent class’s static initializer doesn’t run if only a method in the parent class is called.
Parent’s instance initializer runs when a parent class instance is created inside a method being executed.
Order when child class object is first created: Parent static block → Child static block → Parent instance block → Parent constructor → Child instance block → Child constructor.

Question 25

Usage of Static Blocks and Best Practices

Answer 25

Static Blocks Usage:
Typically used for initializing static fields with complex logic.
Commonly seen when initializing collections like ArrayList.
Recommended to consolidate all static initialization within a single block for clarity.

Question 26

Non-Static Blocks Usage and Best Practices

Answer 26

Non-Static Blocks Usage:
Use instance initializers when logic cannot be handled by constructors.
Double brace initialization pattern can be used for initializing collections.

Question 27

Classloading Mechanism in Java

Answer 27

ClassLoader Phases:
ClassLoader is responsible for loading .class files into memory.
ClassLoader has three phases: loading, linking, and initialization.

Question 28

Default ClassLoader Hierarchy

Answer 28

ClassLoader Hierarchy:
Class loaders follow a delegation hierarchy.
Bootstrap class loader (primordial), Extension class loader, and Application class loader.

Question 29

Roles of ClassLoaders in Hierarchy

Answer 29

Roles in the Hierarchy:
Bootstrap ClassLoader: Loads classes from rt.jar.
Extension ClassLoader: Loads extensions of core Java classes.
System (Application) ClassLoader: Loads application-specific classes from CLASSPATH.

Question 30

Importance of Multiple ClassLoaders

Answer 30

Why Use Multiple ClassLoaders:
All class loaders are essential for Java applications to function correctly.
Removing any class loader would disrupt the hierarchy.

Question 31

Life Cycle of a Class Loaded by ClassLoaders

Answer 31

Class Loading Life Cycle:
Delegation model: System ClassLoader → Extension ClassLoader → Bootstrap ClassLoader.
ClassNotFoundException if not found in any loader.
Life cycle stages: Loading, Linking, Initialization, Instance Creation, Finalization, Unloading.

Question 32

Stages of Class Construction

Answer 32

Stages of Class Construction:
Loading: Producing binary data, parsing, creating java.lang.Class instance.
Linking: Verification, preparation, and optionally resolution.
Initialization: Initializing class and its superclass.
Unloading: Removing classes from memory.

Question 33

User-Defined ClassLoaders

Answer 33

User-Defined ClassLoaders:
Used to load classes dynamically during runtime.
Enables loading classes from various sources.
Provides flexibility in class loading.

Question 34

Resolving Library Version Conflicts

Answer 34

Library Version Conflicts Resolution:
Custom ClassLoaders can load and run multiple versions of the same class.
Useful for resolving conflicts when libraries depend on different versions of a JAR.

Question 35

Loading Different Versions of the Same Libraries

Answer 35

Loading Different Versions of Libraries:
Achieved through custom (user-defined) ClassLoaders.
Default ClassLoader loads the same class only once.

Question 36

Exceptions Thrown by Classloading Mechanism

Answer 36

Exceptions Thrown:
ClassNotFoundException
LinkageError subclasses: ClassCircularityError, ClassFormatError, NoClassDefFoundError, OutOfMemoryError, IllegalAccessError, NoSuchMethodError, InstantiationError, NoSuchFieldError, UnsatisfiedLinkError, UnsupportedClassVersionError.

Question 37

Best Practices for Custom ClassLoaders

Answer 37

Best Practices:
Based on Joshua Bloch’s article.
Maintain class isolation.
Ensure proper delegation to parent loaders.

Question 38

Framework Using Custom ClassLoaders

Answer 38

Framework Using Custom ClassLoaders:
Spring Framework.

Question 39

Why Spring Framework Uses Custom ClassLoaders

Answer 39

Reasons for Spring’s Custom ClassLoaders:
Enhanced security among other reasons.

Question 40

Extending Bootstrap ClassLoader

Answer 40

Extending Bootstrap ClassLoader:
Yes, it’s possible to extend the bootstrap classloader.

Question 41

Class Loading Lifecycle:

Answer 41

Three phases: Loading, Linking, and Initializing.

Question 42

Storage of Class Text Representation:

Answer 42

In memory cache.

Question 43

Order of Creation:

Answer 43

NewClass instance is created first, followed by MyInterface.

Question 44

Importing the Same Class Twice:

Answer 44

Yes, it’s allowed, but the compiler loads the class only once.

Question 45

CLASSPATH Meaning:

Answer 45

Parameter specifying where the JVM should look for classes and packages.

Question 46

Run-Time Constant Pool:

Answer 46

Maintained for each class and interface in the JVM.
Contains two types of entries: symbolic references and static constants.

Question 47

JVM Startup process

Answer 47

Starts by creating an initial class or interface using the bootstrap class loader or a user-defined class loader.
Links, initializes, and invokes the public static void main(String[]) method.
Further execution is driven by the main method.

Question 48

Creation of a Class or Interface:

Answer 48

Involves constructing an implementation-specific internal representation in the method area.

Question 49

Loading Process:

Answer 49

Finding the class file representing a class or interface.
Reading it into a byte array.
Parsing the bytes for correctness.
Creating a class or interface object from the binary representation.

Question 50

Class Loading

Answer 50

Class Loading Process:
JVM searches for the class in a specific order: bootstrap class loader, extension class loader, application class loader.
Class is loaded when found; otherwise, ClassNotFoundException is thrown.
Loaded classes are tracked by the class loader used.

Question 51

Linking Process:

Answer 51

Incorporating binary type data into the runtime state.
Consists of verification, preparation, and optionally, resolution.
Verification:

Ensures structural correctness and semantic requirements.
Checks include symbol table consistency, method access control, parameter types, bytecode stack manipulation, etc.
Flashcard 6: Preparation and Initialization

Preparation:

Allocating memory for static storage and JVM data structures.
Initializing static fields to their default values.
Initialization:

Executing a class or interface initialization method if present (named <clinit>).
Initialization order involves superclass initialization.</clinit>

Question 52

Dynamic Linking:

Answer 52

Resolving symbolic references into direct references.
Symbolic references are replaced with direct references to classes, fields, or methods.
The virtual machine caches direct references for efficiency.

Question 53

Class Loading Optimization:

Answer 53

Class loaders can load types early in anticipation of use.
Problems during early loading are reported upon the type’s first active use.

Question 54

Memory Areas in JVM

Answer 54

Memory Areas:

JVM divides memory into runtime data areas.
Shared areas include method area and heap, while others may vary between threads.
Namespace Control:

Java’s architecture enables multiple namespaces within a single application through class loader isolation.

Question 55

Class Loaders and Security

Answer 55

Class Loaders and Security:

Class loaders define namespaces, protecting Java’s security features.
They interact with the security manager for permission checks.
Class loaders set up permissions for class objects (protection domains).
Custom Class Loaders for Security:

Custom class loaders can establish different security policies for an application.