# Java Source File Declaration Rules

A Java source file has specific rules that must be followed for its **structure, naming, and declaration** to ensure correct compilation and execution.

# **File Naming Rules**

1. The **Java source file name must match the public class name** (if a public class exists).
    
    * ✅ **Correct:**
        
        ```java
        public class HelloWorld { }
        ```
        
    * ❌ **Incorrect:**
        
        ```java
        public class Test { }
        ```
        
        **File name:** [`HelloWorld.java`](http://HelloWorld.java) (Mismatch, will cause an error)
        
2. **Java source file must have the** `.java` extension.
    
    * ✅ **Example:** [`MyProgram.java`](http://MyProgram.java)
        
    * ❌ **Wrong:** `MyProgram.txt`
        

# **Package Declaration Rules**

1. If the file belongs to a **package**, the `package` statement must be the **first statement** in the file.
    
    * ✅ **Correct:**
        
        ```javascript
        package com.example;
        public class MyClass { }
        ```
        
    * ❌ **Incorrect:**
        
        ```java
        public class MyClass { }
        package com.example;  // Compilation Error: Package statement must be first
        ```
        

# **Import Statement Rules**

1. **Imports must be placed after the package declaration (if any) and before the class declaration.**
    
    * ✅ **Correct:**
        
        ```plaintext
        package mypackage;
        import java.util.Scanner;
        
        public class MyClass { }
        ```
        
    * ❌ **Incorrect:**
        
        ```plaintext
        import java.util.Scanner;
        package mypackage;  // ❌ Compilation Error: Package statement must come first
        ```
        
    * **Wildcard imports (**`*`) are allowed but not recommended for efficiency.
        
    * ✅ **Correct:**
        
        ```plaintext
        javaCopyEditimport java.util.*;  // Imports all classes in java.util
        ```
        
    * ❌ **Bad Practice:**
        
        ```plaintext
        javaCopyEditimport java.util.ArrayList;
        import java.util.List;
        ```
        
    * Instead, use:
        
        ```plaintext
        javaCopyEditimport java.util.*;
        ```
        

# **Class Declaration Rules**

1. **A Java file can have multiple classes, but only one public class.**
    
    * ✅ **Correct:**
        
        ```plaintext
        javaCopyEditpublic class Main { } // Public class (must match filename)
        class Helper { } // Non-public class
        ```
        
    * ❌ **Incorrect:**
        
        ```plaintext
        javaCopyEditpublic class Main { }
        public class Helper { }  // ❌ Compilation Error: Only one public class allowed
        ```
        
2. **If a public class exists, the file name must match the public class name.**
    
    * ✅ **File:** [`Main.java`](http://Main.java)
        
        ```plaintext
        public class Main { }
        ```
        
        ❌ **File:** [`Helper.java`](http://Helper.java)
        
        ```plaintext
        public class Main { }  // ❌ Compilation Error: Filename must be "Main.java"
        ```
        

# **Method Declaration Rules**

1. **The** `main` method must be inside a class.
    
    * ✅ **Correct:**
        
        ```plaintext
        public class Main {
            public static void main(String[] args) {
                System.out.println("Hello, World!");
            }
        }
        ```
        
    * ❌ **Incorrect:**
        
        ```plaintext
        public static void main(String[] args) {  // ❌ Compilation Error: No enclosing class
            System.out.println("Hello, World!");
        }
        ```
        
2. **The** `main` method must have the exact signature.
    
    * ✅ **Correct:**
        
        ```plaintext
        public static void main(String[] args) { }
        ```
        
    * ❌ **Incorrect:**
        
        ```plaintext
        static void main(String[] args) { }  // ❌ Compilation Error: Must be public
        ```
        
    
    # **Interface and Enum Declaration Rules**
    
    1. **A Java file can contain multiple interfaces and enums.**
        
    
    * ✅ **Correct:**
        
        ```plaintext
        javaCopyEditinterface MyInterface { }
        interface AnotherInterface { }
        ```
        
    * ✅ **Enums can also be declared within a file:**
        
        ```plaintext
        javaCopyEditenum Status { ACTIVE, INACTIVE }
        ```
        
    
    2. **A Java file can contain a mix of classes, interfaces, and enums.**
        
    
    * ✅ **Example:**
        
        ```plaintext
        javaCopyEditpublic class MyClass { }
        interface MyInterface { }
        enum MyEnum { ONE, TWO }
        ```
        

# **Access Modifiers in Java Files**

| **Modifier** | **Applicable to** | **Scope** |
| --- | --- | --- |
| `public` | Classes, Methods, Variables | Accessible from anywhere |
| `private` | Methods, Variables | Accessible only within the class |
| `protected` | Methods, Variables | Accessible within the package & subclasses |
| **No Modifier (default)** | Classes, Methods, Variables | Accessible only within the package |

# **Java Source File Structure (Best Practice)**

### ✅ **Correct Java Source File Order**

```plaintext
javaCopyEdit// 1️⃣ Package declaration (optional)
package com.example;

// 2️⃣ Import statements (if needed)
import java.util.*;

// 3️⃣ Public class declaration (if required)
public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
    }
}

// 4️⃣ Other classes, interfaces, enums (if needed)
class Helper { }
interface MyInterface { }
enum Status { ACTIVE, INACTIVE }
```

---

# **Special Cases**

### **❓ Can we have a Java file without a class?**

* ❌ **No**, Java **requires** at least one class.
    
* **Example (Invalid)**
    
    ```plaintext
    javaCopyEditSystem.out.println("Hello, World!");  // ❌ Compilation Error: Not inside a class
    ```
    

# **Summary: Java Source File Declaration Rules**

| **Rule** | **Description** |
| --- | --- |
| **File Name Rule** | Must match the `public class` name (if any). |
| **Package Rule** | Must be the first statement in the file (if present). |
| **Import Rule** | Must be placed after the package and before the class. |
| **Class Rule** | Only **one public class** per file, but multiple non-public classes are allowed. |
| **Method Rule** | The `main` method must have `public static void main(String[] args)`. |
| **Interface/Enum Rule** | Multiple interfaces and enums are allowed. |
| **Access Modifier Rule** | Only `public` and default (package-private) classes are allowed at the top level. |