Java Program Structure
Documentation Section
Package Statement
Import Statements
Interface Statements
Class Definitions
Main method class
{
Main method class
}
1. Documentation Section
- It includes basic information about Java program.
- The information includes the author’s name, data of creation, version, program name, compony name, and description name of the program.
- To write the statements in decompensation,
we use comments
The comments may be
1. single-line comments:-
// First Java Program
2. multi-line comments
It starts with a /* and ends, with */ we write between these two symbols.
ex :-
/* It is an example of
multiline comment */
2. Package Statement
In Java, the package statement is used to declare the package to which the current Java file belongs.
The package statement should be the first statement in a Java file, before any import statements or class declarations.
The syntax for the package statement is as follows:
package pakageName;
Where ‘packageName‘ is the name of the package to which the current file belongs.
Package names are typically written in all lowercase letters to avoid any potential name conflicts with class names.
when you compile a Java file, the compiler creates a corresponding. ‘.class’ file. The ‘.class’ file is placed in a directory structure that mirrors the package name.
For example, if your package name is ‘com.example‘, the corresponding ‘.class‘ file will be stored in a directory name ‘com/example‘.
Using package statements in your code helps to organize your classes and reduce naming conflicts, especially when working on large projects with many classes.
3. Import Statement
In Java, import statements are used to allow your code to access classes, interfaces, and other members of a package.
You can import a single class or interface using the following syntax:
import packageName.ClassName;
You can also import all the public classes and interfaces in a package using the asterisk (*) operator:
import packageName.*;
It’s important to note that Java has a default package that contains classes that are not part of any package, so you can use those classes without importing them.
However, it’s considered a good practice to always use explicit import statements to avoid any potential naming conflicts and make your code more readable.
4. Interface Statement
In Java, an interface statement defines a contract between a class and the outside world. An interface defines a set of methods and constants that a class can implement or use, but does not provide an implementation for those methods.
The syntax for declaring an interface in Java is as follows:
assessSpecifier interface InterfaceName {
// Constants and method declarations
}
Where ‘accessSpecifier‘ can be one of ‘public‘, ‘protected‘, or ‘private‘, and ‘InterfaceName‘ is the name of the interface.
Interface can include method declarations with no method bodies, as well as constant declarations.
For example:
public interface MyInterface {
int MAX_COUNT =100; // constant declaration
void method1(); // method declaration with no body
void method2(); // method declaration with no body
}
Classes can implement one or more interfaces by using the ‘implements’ keyword in their class declaration.
For example :
public class MyClass implements MyInterface{
// Implementation of the MyInterface methods
//……
}
Implementing an interface means that the class must provide implementations for all the methods declared in the interface. Using interfaces allows for a high degree of abstraction in Java programs and enables polymorphism and loos coupling between classes.
5. Class Definitions
In Java, a class is a blueprint for creating objects that have certain properties and behaviors. A class definition specifies the name of the class, the data fields or variables it contains, and the methods that define its behaviors.
The syntax for declaring a class in Java is as follows:
accessSpecifier class ClassName {
// Data fields or variables
// Constructors
// Methods
}
Where ‘accessSpecifier‘ can be one of ‘public‘, ‘protected‘, or ‘private‘, and ‘ClassName‘ is the name of the class.
A class can contain data field or variables, which represent the state or attributes of the objects created from that class. Data fields can be of any data type, including primitive types like ‘int‘ and ‘boolean‘, or reference types like objects or arrays.
A class can also contain one or more constructors, which are special methods that are called when an object of the class is created. Contractors initialize the data fields of the object and perform any other necessary setup tasks.
Finally, a Class can contain one or more methods, which define the behaviors of the objects created from that class. Methods can perform calculations, manipulate data field, or interact with other objects.
6. Main Method Class
In Java, the main method is the entry point for a Java program. It is the method that is executed when you run a Java program from the command line.
The syntax for declaring the main method in Java is as follows:
public static void main(String[] args) {
// Code to be executed when the program is run
}
The main method must be declared as ‘public‘, ‘static‘, and ‘void‘, and it must have the name ‘main‘. It takes a single parameter, an array of strings named ‘args’, which can be used to pass command-line arguments to the program.
The Main method is responsible for initializing the program and calling other methods as needed. It can also interact with user through the command line, prompting for input or displaying output as needed.
Here’s an example of a simple Java program that uses the main method:
public class MyProgram {
public static void main(String[] args){
System.out.println(“Hello, world!”);
}
}
When you compile and run this program, the main method will be executed, and the output ‘ Hello, world!’ will be printed to the command line.
Out put:-
Hello, world!
Also Read: C Language Tutorial
3 thoughts on “Java Program Structure”