> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Java Public Constructor
A public constructor in Java is a distinct, method-like construct with a `public` access modifier, invoked automatically during object creation using the `new` keyword. The `public` modifier grants the widest possible visibility, allowing the class to be instantiated from any other class across different packages, provided that the package is accessible under the Java Platform Module System (JPMS) restrictions (i.e., the package is explicitly exported or opened in the `module-info.java` declaration).
## Syntax
```java theme={"dark"}
public class ClassName {
// Public constructor declaration
public ClassName(Type parameter) {
// Initialization logic
}
}
```
## Technical Characteristics
* **Identifier Matching:** The constructor's identifier must exactly match the simple name of the class in which it resides.
* **Omission of Return Type:** Constructors strictly lack a return type. Declaring a return type, even `void`, causes the Java compiler to treat the declaration as a standard method rather than a constructor.
* **Access Level:** The `public` keyword allows the constructor to be invoked by the JVM, subclasses, and external classes, subject to module-level encapsulation boundaries.
* **Overloading:** A class can declare multiple public constructors. The Java compiler differentiates them via their constructor signatures (the number, type, and order of parameters).
* **Constructor Chaining:** A public constructor can invoke another constructor within the same class using the `this()` keyword, or a superclass constructor using the `super()` keyword. This invocation must be the first statement in the constructor body.
## Compiler Behavior and Default Constructors
If a class contains no explicit constructor declarations, the Java compiler automatically injects a default no-argument constructor during compilation. The access modifier of this implicit constructor mirrors the access modifier of the class. Therefore, if a class is declared `public` and lacks explicit constructors, the compiler generates a `public` default constructor.
Once any explicit constructor (public or otherwise) is defined, the compiler bypasses the automatic generation of the default constructor.
## Code Visualization
```java theme={"dark"}
public class NetworkClient {
private String endpoint;
private int port;
// Public no-argument constructor
public NetworkClient() {
// Invokes the overloaded public constructor below
this("localhost", 8080);
}
// Overloaded public constructor with parameters
public NetworkClient(String endpoint, int port) {
this.endpoint = endpoint;
this.port = port;
}
}
```
Tired of Poor Java Skills? Fix That With Deep Grasping!
Learn More
