A Java source file contains code defining classes, interfaces, enums, and other types, following a specific structure for proper compilation and execution. It starts with a package statement, followed by import statements, and then type declarations. The file name must match the public type it contains, and only one public type is allowed per file. Java supports various top-level declarations like classes, abstract classes, enums, records, interfaces, and annotations. Class declarations include modifiers, generalizations, and a class body with fields, methods, constructors, and nested types. Modifiers like public, protected, private, static, abstract, final, sealed, and non-sealed define access and behavior. Nested and inner classes, local classes, and anonymous classes offer different scopes and functionalities. Reachability analysis and garbage collection manage memory by identifying and collecting unreachable objects.

Source Files Structure

A Java source file contains code that defines classes, interfaces, enums, and other types. The structure of a Java source file is specific and follows a well-defined order to ensure proper compilation and execution.

Package Statement:
- The package statement specifies the package to which the class belongs. It helps in organizing classes into namespaces, making it easier to manage large codebases.
- The package statement must be the first line of code in the file (excluding comments).
```
  package com.example.myapp;
```
- Example:
```
  package com.example.utilities;
```
Import Statements:
- Import statements allow the use of classes and interfaces from other packages without needing to specify their fully qualified names each time they are used. This makes the code cleaner and more readable.
- Import statements come after the package statement and before any type declarations.
```
  import java.util.List;
  import java.io.File;
```
- Wildcard Imports: You can use a wildcard to import all classes from a package:
```
  import java.util.*;
```
- Static Imports: Static imports allow you to import static members (fields and methods) of a class:
```
  import static java.lang.Math.PI;
  import static java.lang.Math.sqrt;
```
Type Declarations:
- The main content of the file, which includes class, interface, enum, and annotation declarations. These declarations define the types that can be used in the program.
- Components:
  - Classes: Define the blueprint for objects. A class can contain fields, methods, constructors, and nested types.
  - Interfaces: Define a contract that other classes can implement. Interfaces can contain abstract methods, default methods, and static methods.
  - Enums: Special classes that represent a group of constants.
  - Annotations: Provide metadata about the code, which can be used by the compiler and at runtime.

        public class MyClass {
            // class body
        }

        interface MyInterface {
            // interface body
        }

        enum MyEnum {
            CONSTANT1, CONSTANT2;
        }

        @interface MyAnnotation {
            // annotation body
        }

Example:

  public class ExampleClass {
      private int value;

      public ExampleClass(int value) {
          this.value = value;
      }

      public int getValue() {
          return value;
      }
  }

  interface ExampleInterface {
      void performAction();
  }

  enum ExampleEnum {
      OPTION1, OPTION2;
  }

  @interface ExampleAnnotation {
      String info();
  }

Naming and Public Types

In Java, the naming and organization of source files and types follow specific conventions.

File Name and Public Type Matching:
- The name of the Java source file must exactly match the name of the public type it contains.
- This convention helps the Java compiler and developers easily find and manage the code. It ensures that each public class, interface, enum, or annotation is uniquely identifiable by its file name.
- Example: If you have a public class named MyClass, the source file must be named MyClass.java.
Single Public Type per Source File:
- A Java source file can contain at most one public type.
- This rule simplifies code organization and avoids confusion. It ensures that each public type is defined in its own file, making it easier to find and manage.
- Example: If MyClass.java contains a public class MyClass, it cannot contain another public class, interface, enum, or annotation.
Multiple Non-Public Types:
- A source file can contain multiple non-public types.
- Non-public types (those without the public modifier) are only accessible within the same package, so they do not need to follow the strict naming convention of public types. This allows for more flexible organization of related helper classes, interfaces, enums, or annotations within the same file.
- Example: In MyClass.java, you can have the public class MyClass and additional non-public classes, interfaces, enums, or annotations like HelperClass or InternalEnum.

Practical Example

// MyClass.java
package com.example;

public class MyClass {
    // Public class content
}

class HelperClass {
    // Non-public class content
}

interface InternalInterface {
    // Non-public interface content
}

enum InternalEnum {
    // Non-public enum content
}

Public Class: MyClass is the public class, and the file is named MyClass.java.
Non-Public Types: HelperClass, InternalInterface, and InternalEnum are non-public types defined within the same file.

Types of Top-Level Declarations

Java source files can contain various types of top-level declarations, each serving a specific purpose in the language.

Classes:
- Regular Classes: These are the most common type of classes in Java. They can contain fields, methods, constructors, and nested types. Regular classes can be instantiated to create objects.
- Sealed Classes: Introduced in Java 15, sealed classes restrict which other classes or interfaces may extend or implement them. This is done to provide more control over the class hierarchy.
```
  public sealed class Shape permits Circle, Square {
      // class body
  }
```
- Non-Sealed Classes: These are subclasses of sealed classes that allow further subclassing. They are used to indicate that the class hierarchy can be extended beyond the immediate subclasses of the sealed class.
```
  public non-sealed class Circle extends Shape {
      // class body
  }
```
- Final Classes: These classes cannot be subclassed. Declaring a class as final is useful when you want to prevent inheritance for security or design reasons.
```
  public final class Utility {
      // class body
  }
```
Abstract Classes:
- Abstract classes cannot be instantiated directly and are meant to be subclassed. They can contain abstract methods (without a body) that must be implemented by subclasses, as well as concrete methods (with a body).
- Abstract classes cannot be declared as final because they are intended to be extended.
```
  public abstract class Animal {
      public abstract void makeSound();

      public void sleep() {
          System.out.println("Sleeping...");
      }
  }
```
Enumerations (Enums):
- Enums are special classes that represent a group of constants. Each constant is an instance of the enum type. Enums are useful for representing fixed sets of related constants, such as days of the week, directions, etc.
```
  public enum Day {
      SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY;
  }
```
Records:
- Introduced in Java 14, records are a special kind of class designed to act as immutable data carriers. They automatically generate boilerplate code such as constructors, getters, equals(), hashCode(), and toString() methods.
```
  public record Point(int x, int y) {}
```
Interfaces:
- Interfaces are abstract types that allow the declaration of methods that must be implemented by classes. Interfaces can contain abstract methods, default methods (with a body), and static methods.
- Interfaces are used to define a contract that other classes can implement, ensuring a certain level of abstraction and decoupling in the code.
```
  public interface Vehicle {
      void start();

      default void stop() {
          System.out.println("Vehicle stopped.");
      }
  }
```
Annotations:
- Annotations are special interfaces used to add metadata to Java code. They can be applied to classes, methods, fields, parameters, and other elements. Annotations can be processed at compile-time or runtime to provide additional information or behaviour.
```
  @interface MyAnnotation {
      String value();
  }
```

Class Declaration Syntax

A class declaration in Java is a fundamental construct that defines the blueprint for objects.

Modifiers

Modifiers are keywords that provide additional information about the class and its behavior. Here are the common modifiers used in class declarations:

public

The class is accessible from any other class.
When a class is declared as public, it can be accessed from any other class in any package. This is the most permissive access level.

Example:

  public class MyClass {
      // class content
  }

protected

Not applicable to top-level classes, but for member classes, it means the class is accessible within its own package and by subclasses.
The protected modifier is used to allow access to the member class within the same package and by subclasses, even if they are in different packages.

Example:

  class OuterClass {
      protected class InnerClass {
          // class content
      }
  }

private

Also not applicable to top-level classes, but for member classes, it means the class is accessible only within its enclosing class.
The private modifier restricts access to the member class to only within the enclosing class. This is the most restrictive access level.

Example:

  class OuterClass {
      private class InnerClass {
          // class content
      }
  }

abstract

The class cannot be instantiated directly and must be subclassed. It can contain abstract methods that must be implemented by subclasses.
An abstract class is used when you want to create a base class that should not be instantiated on its own but should be extended by other classes. Abstract classes can have both abstract methods (without a body) and concrete methods (with a body).

Example:

  public abstract class Animal {
      public abstract void makeSound();
  }

final

The class cannot be subclassed. This is useful for security and design reasons.
Declaring a class as final prevents other classes from extending it. This is useful when you want to ensure that the class's behavior cannot be altered through inheritance.

Example:

  public final class Constants {
      // class content
  }

sealed

Introduced in Java 15, this modifier restricts which other classes or interfaces may extend or implement the class.
A sealed class allows you to specify a limited set of classes or interfaces that can extend or implement it. This provides more control over the class hierarchy.

Example:

  public sealed class Shape permits Circle, Square {
      // class content
  }

non-sealed

Used in conjunction with sealed classes to indicate that a subclass can be further subclassed.
A non-sealed class is a subclass of a sealed class that allows further subclassing. This means that the class hierarchy can be extended beyond the immediate subclasses of the sealed class.

Example:

  public non-sealed class Circle extends Shape {
      // class content
  }

static

Applicable to nested classes, indicating that the nested class does not have an implicit reference to an instance of the enclosing class.
A static nested class (also known as a static inner class) can be instantiated without an instance of the enclosing class. This is useful when the nested class does not need to access the instance variables or methods of the outer class.

Example:

  public class OuterClass {
      public static class StaticNestedClass {
          // class content
      }
  }Class Name

The class name is a valid identifier that must be unique within its package. It follows the naming conventions of Java, typically starting with an uppercase letter and using camel case for multi-word names.

Generalizations

Generalizations include the extends and implements clauses, which define inheritance and interface implementation:

extends: Specifies the superclass that the current class inherits from. A class can extend only one superclass.
implements: Specifies the interfaces that the class implements. A class can implement multiple interfaces, separated by commas.

Permits Clause

The permits clause is used with sealed classes to specify which classes are allowed to extend the sealed class. This provides more control over the class hierarchy.

Syntax

The permits clause is used in the class declaration of a sealed class. It lists the classes that are allowed to extend the sealed class. Here is the syntax:

public sealed class ParentClass permits ChildClass1, ChildClass2 {
    // class body
}

In this example, ParentClass is a sealed class, and only ChildClass1 and ChildClass2 are permitted to extend it.

Class Body

The class body is enclosed in curly braces {} and contains the following components:

Fields: Variables that hold the state of the class. They can be instance variables or static variables.
Methods: Functions that define the behavior of the class. They can be instance methods or static methods.
Constructors: Special methods used to initialize objects of the class. They have the same name as the class and do not have a return type.
Nested Types: Classes, interfaces, enums, or annotations defined within the class. These can be static or non-static (inner classes).

Fields

Fields, also known as member variables, are used to store the state of an object. They can be of any data type, including primitive types (like int, float, boolean) and reference types (like objects and arrays). Fields can be categorized into two types:

Instance Variables:
- These variables are associated with an instance of the class. Each object of the class has its own copy of the instance variables.
- Instance variables are used to store data that is unique to each object.
- Example:
```
  public class Person {
      private String name; // instance variable
      private int age; // instance variable
  }
```
Static Variables:
- These variables are associated with the class itself rather than any particular instance. There is only one copy of a static variable, shared among all instances of the class.
- Static variables are used for data that is common to all objects of the class.
- Example:
```
  public class Person {
      private static int population; // static variable
  }
```

Methods

Methods define the behaviour of the class. They are functions that can perform operations, modify fields, and return values. Methods can be categorized into two types:

Instance Methods:

These methods operate on instances of the class. They can access instance variables and other instance methods.
Instance methods are used to define behaviours that are specific to an object.

Example:

  public class Person {
      private String name;
      private int age;

      public void setName(String name) { // instance method
          this.name = name;
      }

      public String getName() { // instance method
          return name;
      }
  }

Static Methods:
- These methods belong to the class rather than any particular instance. They can only access static variables and other static methods.
- Static methods are used for operations that do not depend on instance variables.
- Example:
```
  public class Person {
      private static int population;

      public static int getPopulation() { // static method
          return population;
      }
  }
```

Constructors

Constructors are special methods used to initialize objects of the class. They have the same name as the class and do not have a return type. Constructors can be overloaded to provide different ways of initializing objects.

Constructors are called when an object is created using the new keyword. They set initial values for the object's fields.
Constructors are used to ensure that an object is properly initialized before it is used.

Example:

  public class Person {
      private String name;
      private int age;

      public Person(String name, int age) { // constructor
          this.name = name;
          this.age = age;
      }
  }

Nested Types

Nested types are classes, interfaces, enums, or annotations defined within the class. They can be static or non-static (inner classes).

Static Nested Classes:
- These classes are declared with the static keyword and do not have access to instance variables of the outer class.
- Static nested classes are used when the nested class does not need to access the instance variables or methods of the outer class.
- Example:
```
  public class OuterClass {
      static class StaticNestedClass {
          // static nested class
      }
  }
```
Inner Classes:
- These are non-static nested classes that have an implicit reference to an instance of the outer class.
- Inner classes are used when the nested class needs to access the instance variables or methods of the outer class.
- Example:
```
  public class OuterClass {
      class InnerClass {
          // inner class
      }
  }
```
Local Classes:
- These classes are declared within a block, such as a method, and are local to that block.
- Local classes are used for defining classes that are only needed within a specific block of code.
- Example:
```
  public class OuterClass {
      public void someMethod() {
          class LocalClass {
              // local class
          }
      }
  }
```

Anonymous Classes:

These classes are declared and instantiated in a single expression, often used for implementing interfaces or extending classes on the fly.
Anonymous classes are used for quick, one-time use implementations.

Example:

  public class OuterClass {
      public void someMethod() {
          Runnable r = new Runnable() {
              public void run() {
                  // anonymous class
              }
          };
      }
  }

Example

Here is an example of a class declaration that incorporates all these components:

public abstract class Animal implements Serializable {
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public abstract void makeSound();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static class AnimalHelper {
        public static void printAnimalDetails(Animal animal) {
            System.out.println("Name: " + animal.getName() + ", Age: " + animal.getAge());
        }
    }
}

In this example:

The class Animal is declared as public and abstract.
It implements the Serializable interface.
It has private fields name and age.
It includes a constructor to initialize these fields.
It has an abstract method makeSound and concrete methods getName, setName, getAge, and setAge.
It contains a static nested class AnimalHelper with a static method printAnimalDetails.

Modifiers and Their Rules

Public: A public class or member is accessible from any other class. This means that if a class is declared as public, it can be accessed from any other class in any package. Similarly, if a member (field, method, or inner class) is declared as public, it can be accessed from any other class.
Protected: A protected member is accessible within its own package and by subclasses. This means that any class in the same package can access the protected member, and any subclass (even if it is in a different package) can also access it.
Private: A private member is accessible only within its enclosing class. This means that no other class can access the private member, not even subclasses or classes in the same package.
Static: A static member belongs to the class itself rather than to any specific instance of the class. This means that a static member can be accessed without creating an instance of the class. Static members are shared among all instances of the class.
Abstract: An abstract class cannot be instantiated directly and must be subclassed. It can contain abstract methods (methods without a body) that must be implemented by subclasses. An abstract class can also contain concrete methods (methods with a body). An abstract class cannot be declared as final because it is intended to be extended.
Final: A final class cannot be subclassed. This means that no other class can extend a final class. Declaring a class as final is useful when you want to prevent inheritance for security or design reasons. Similarly, a final method cannot be overridden by subclasses.
Sealed: Introduced in Java 15, a sealed class restricts which other classes or interfaces may extend or implement it. This is done to provide more control over the class hierarchy. A sealed class must specify the permitted subclasses using the permits clause.
Non-Sealed: A non-sealed class is a subclass of a sealed class that allows further subclassing. This means that the class hierarchy can be extended beyond the immediate subclasses of the sealed class.
Strictfp: Obsolete since Java 17. The strictfp modifier was used to restrict floating-point calculations to ensure portability. It ensured that floating-point operations conformed to the IEEE 754 standard. However, it has been considered obsolete since Java 17.

Nested and Inner Classes

Static Nested Classes: Declared with the static keyword and do not have access to instance variables of the outer class.
Inner Classes: Non-static nested classes that have an implicit reference to an instance of the outer class.

Static Nested Classes

Static nested classes are nested classes that are declared with the static keyword. They do not have access to instance variables or methods of the outer class.

Static nested classes do not have an implicit reference to an instance of the outer class. This means they cannot directly access non-static members (fields and methods) of the outer class.
They can be instantiated without creating an instance of the outer class. This is useful when the nested class does not need to interact with the instance-specific data of the outer class.
Static nested classes are often used for grouping classes that are only used in one place, increasing encapsulation and reducing clutter in the outer class.

Example:

public class OuterClass {
    private static String staticOuterField = "Static Outer Field";

    // Static nested class
    public static class StaticNestedClass {
        public void display() {
            // Can access static members of the outer class
            System.out.println(staticOuterField);
        }
    }
}

// Instantiating the static nested class
OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
nestedObject.display();

Inner Classes

Inner classes are non-static nested classes that have an implicit reference to an instance of the outer class. This allows them to access the outer class's instance variables and methods.:

Inner classes have an implicit reference to an instance of the outer class. This means they can access both static and non-static members of the outer class.
They must be instantiated within an instance of the outer class. This is because they are tied to the instance-specific data of the outer class.
Inner classes are useful when you need to logically group classes that will be used together and when the inner class needs to access the outer class's instance members.

Example:

public class OuterClass {
    private String instanceOuterField = "Instance Outer Field";

    // Inner class
    public class InnerClass {
        public void display() {
            // Can access instance members of the outer class
            System.out.println(instanceOuterField);
        }
    }
}

// Instantiating the inner class
OuterClass outerObject = new OuterClass();
OuterClass.InnerClass innerObject = outerObject.new InnerClass();
innerObject.display();

Local and Anonymous Classes

Local Classes: Declared within a block, such as a method, and are local to that block.
Anonymous Classes: Declared and instantiated in a single expression, often used for implementing interfaces or extending classes on the fly.

Local Classes

Local classes are classes that are defined within a block of code, such as within a method, a constructor, or a static initializer. They are local to the block in which they are defined, meaning they cannot be accessed outside of that block. Here are some key points about local classes:

The scope of a local class is limited to the block in which it is defined. This means that the class is not visible outside of the block, making it useful for encapsulating helper classes that are only needed within a specific method or block of code.
Local classes can access local variables and parameters of the enclosing block, but only if these variables are declared as final or effectively final (i.e., they are not modified after their initial assignment).
Local classes are often used to implement small helper classes that are only relevant within a specific method. They can be used to improve code readability and maintainability by keeping related code together.

Example:

public class OuterClass {
    public void someMethod() {
        // Local class defined within a method
        class LocalClass {
            void display() {
                System.out.println("This is a local class.");
            }
        }

        // Creating an instance of the local class
        LocalClass local = new LocalClass();
        local.display();
    }
}

In this example, LocalClass is defined within the someMethod method and is only accessible within that method.

Anonymous Classes

Anonymous classes are a type of local class without a name. They are declared and instantiated in a single expression, often used for implementing interfaces or extending classes on the fly. Here are some key points about anonymous classes:

Anonymous classes do not have a name, which means they cannot be reused. They are typically used for one-time use cases.
Anonymous classes are instantiated at the point of declaration. They are often used to provide a quick implementation of an interface or an abstract class.
Like local classes, anonymous classes can access final or effectively final local variables and parameters of the enclosing block.
Anonymous classes are commonly used in event handling, callbacks, and other scenarios where a quick, one-off implementation is needed.

Example:

public class OuterClass {
    public void someMethod() {
        // Anonymous class implementing an interface
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("This is an anonymous class.");
            }
        };

        // Creating a thread with the anonymous class
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

In this example, an anonymous class is created to implement the Runnable interface. The class is instantiated and passed to the Thread constructor in a single expression.

Reachability and Garbage Collection

Reachability Analysis: Determines which objects are reachable and thus not eligible for garbage collection.
Garbage Collection: Unreachable objects are eligible for garbage collection, but the actual collection depends on the garbage collector's implementation.

Reachability Analysis

Reachability analysis is a process used by the Java Virtual Machine (JVM) to determine which objects in memory are still accessible and which are not. This analysis is crucial for efficient memory management and garbage collection. Here's how it works:

Root Set Identification:
- The analysis starts with identifying a set of root objects. These roots include:
  - Local variables in the stack frames of currently executing methods.
  - Active threads.
  - Static fields of loaded classes.
  - JNI (Java Native Interface) references.
Graph Traversal:
- The JVM treats the heap memory as a graph where objects are nodes and references are edges.
- Starting from the root set, the JVM traverses the graph, marking all reachable objects. An object is considered reachable if there is a path from any root to that object.
Marking Phase:
- During the traversal, each reachable object is marked. This marking helps in distinguishing between reachable and unreachable objects.
Unreachable Objects:
- Objects that are not marked during the traversal are considered unreachable. These objects are no longer accessible by any part of the program and are thus eligible for garbage collection.

Garbage Collection

Garbage collection is the process of reclaiming memory occupied by unreachable objects. The actual collection of these objects depends on the garbage collector's implementation. Here are the key steps and types of garbage collectors:

Mark-and-Sweep:
- Mark Phase: The garbage collector performs reachability analysis and marks all reachable objects.
- Sweep Phase: It then scans the heap and collects all unmarked (unreachable) objects, reclaiming their memory.
Generational Garbage Collection:
- Young Generation: This space is where new objects are allocated. It is divided into Eden and Survivor spaces. Minor garbage collections occur frequently here.
- Old Generation: Objects that survive multiple minor collections are promoted to the old generation. Major garbage collections occur less frequently but are more time-consuming.
- Permanent Generation (Metaspace in Java 8 and later): This space holds metadata about classes and methods. It is collected less frequently.
Concurrent Mark-Sweep (CMS):
- CMS is designed for applications that require low pause times. It performs most of its work concurrently with the application threads, minimizing pauses.
G1 (Garbage-First) Collector:
- G1 is designed for large heaps and aims to provide predictable pause times. It divides the heap into regions and performs garbage collection in a way that prioritizes regions with the most garbage.
Z Garbage Collector (ZGC):
- ZGC is designed for low-latency applications. It performs most of its work concurrently and aims to keep pause times below 10 milliseconds.
Shenandoah:
- Similar to ZGC, Shenandoah is designed for low-latency applications and performs concurrent garbage collection to minimize pause times.

Example

public class GarbageCollectionExample {
    public static void main(String[] args) {
        MyClass obj1 = new MyClass();
        MyClass obj2 = new MyClass();
        obj1 = null; // obj1 is now unreachable
        System.gc(); // Requesting garbage collection
    }
}

class MyClass {
    // Class definition
}

Reachability Analysis: When obj1 is set to null, the object it referenced becomes unreachable if there are no other references to it.
Garbage Collection: When System.gc() is called, the JVM may perform garbage collection. The unreachable object (previously referenced by obj1) is identified and its memory is reclaimed.

Practical Examples

Example 1: Basic Class Declaration

package com.example;

import java.util.List;

public class MyClass {
    private int id;
    private String name;

    public MyClass(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public void display() {
        System.out.println("ID: " + id + ", Name: " + name);
    }
}

Example 2: Inner Class

public class OuterClass {
    private String outerField = "Outer";

    class InnerClass {
        void display() {
            System.out.println("Outer field: " + outerField);
        }
    }
}

Example 3: Anonymous Class

Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running in an anonymous class");
    }
};
new Thread(runnable).start();

Example 4: Reachability Analysis

public class GarbageCollectionExample {
    public static void main(String[] args) {
        GarbageCollectionExample example = new GarbageCollectionExample();
        example = null; // The object is now eligible for garbage collection
        System.gc(); // Suggests the JVM to run the garbage collector
    }
}

Conclusion

A Java source file is the backbone of Java programming, defining classes, interfaces, enums, and more. Here's a breakdown of its structure:

Package Statement: Organizes classes into namespaces for better management.
Import Statements: Simplifies code by allowing the use of classes from other packages.
Type Declarations: The heart of the file, including classes, interfaces, enums, and annotations.

Naming and Public Types

File Name and Public Type Matching: The file name must match the public type it contains.
Single Public Type per Source File: Ensures clarity and ease of management.
Multiple Non-Public Types: Allows for flexible organization within the same file.

Types of Top-Level Declarations

Classes: Regular, Sealed, Non-Sealed, and Final.
Abstract Classes: Meant to be subclassed.
Enums: Represent a group of constants.
Records: Immutable data carriers.
Interfaces: Define a contract for other classes.
Annotations: Add metadata to the code.

Class Declaration Syntax

Modifiers like public, protected, private, abstract, final, sealed, non-sealed, and static define the behavior and accessibility of classes.

Nested and Inner Classes

Static Nested Classes: Do not have access to instance variables of the outer class.
Inner Classes: Have an implicit reference to an instance of the outer class.

Local and Anonymous Classes

Local Classes: Defined within a block and local to that block.
Anonymous Classes: Declared and instantiated in a single expression.

Reachability and Garbage Collection

Reachability Analysis: Determines which objects are reachable.
Garbage Collection: Unreachable objects are eligible for garbage collection.

Understanding the structure of a Java source file is crucial for writing clean, maintainable, and efficient code. By adhering to the conventions and rules outlined in this guide, developers can ensure that their Java programs are well-organized and easy to manage. From the proper use of package and import statements to the detailed breakdown of class declarations, modifiers, and nested types, this comprehensive overview provides a solid foundation for both novice and experienced Java programmers. By following these best practices, you can create robust Java applications that are easy to understand, extend, and maintain.

Command Palette

Source Files Structure

Naming and Public Types

Types of Top-Level Declarations

Class Declaration Syntax

Modifiers

public

protected

private

abstract

final

sealed

non-sealed

static

Generalizations

Permits Clause

Syntax

Class Body

Fields

Methods

Constructors

Nested Types

Example

Modifiers and Their Rules

Nested and Inner Classes

Static Nested Classes

Inner Classes

Local and Anonymous Classes

Local Classes

Anonymous Classes

Reachability and Garbage Collection

Reachability Analysis

Garbage Collection

Example

Practical Examples

Example 1: Basic Class Declaration

Example 2: Inner Class

Example 3: Anonymous Class

Example 4: Reachability Analysis

Conclusion

Comments

More from this blog