Java Syntax

Java is a popular object-oriented programming language because of its robustness, portability, and ease of use. The Java programming language is easier to learn because of its near alignment with C and C++ syntax.

Syntax

In programming, syntax refers to the structure of statements and expressions. It determines how Java programs are written and interpreted by the compiler.

It ensures that code is written consistently and understandably, allowing the compiler or interpreter to process it correctly. According to these statements, the code will be error-free, logically organized, and readable.

Syntax includes keywords, operators, punctuations, indentations, and other elements. The combination of these elements made the program structure.

Let's see a simple "Hello World" program to learn about the syntax and structure of Java programs.

Structure of Java Program

Before diving in depth, it is necessary to understand the basic structure of the Java program in detail. At the end of this section, you will able to develop the Hello world Java program, easily.

Hello, Word Java Program

Output:

 Hello, World 

The above program shows class declaration, main() method, and print statement.

Here, note that we did not import any package. Because the package java.lang imports by default in every Java program.

Java Syntax Key Elements

1. Comments

Comments in programming are used for a better understanding of the program. There are three types of comments in Java.

• Single-line Comment: It starts with a pair of forwarding slashes (//). For example:

• Multi-line Comment: It starts with a /* and ends with */. We write comments between these two symbols. For example:

• Documentation Comment: It starts with the delimiter (/**) and ends with */. Documentation Comment is also known as a doc comment. For example:

2. Package Name

We have some following naming conventions which we use in creating a package.

• The name should always be in the lower case.
• They should be period-delimited.
• The names should be based on the company or organization name.

In order to define a package name based on an organization, first we will reverse the company URL. After that, we define it by the company and include division names and project names.

For example, if we want to create a package out of www.tpointtech.com, we will reserve it in the following way:

If we want to define a sub-package of the com.tpointtech, we will do it in the following way:

3. Source File Name

Before executing a Java program, it is necessary to save the program with the file name. We must follow the following rules to save a program in a file.

If there is a public class in the file: The name of the source file must match with the class name followed by .java extension.

• Valid Syntax: java
• Invalid Syntax: java

If there is no public class in the file: The name of the source file may be anything if the class is not public. Like the above rule, the source file does not match with the class name but must followed by a a.java extension.

For example, if the class name is Demo.java, then the file name may be Demo.java or Test.java. Both are valid source file names. Consider the following program for the same.

We can save the above source file as Test.java or Demo.java.

4. Case Sensitivity

We know that Java is a case-sensitive language. It means that identifiers like Test, TEST, TeSt, etc. are different. Let's see an example.

5. Class Names

We use the class keyword to define the class. The class is a blueprint of a Java program. It contains information about user-defined methods, variables, and constants. Every Java program has at least one class. We should follow the following rules to define a class name.

1. The first letter of the class name should be in capital Not that lowercase is also allowed but discouraged.
2. If a class name has more than one word, the initial letter of each word should be in capital
3. We can use underscore in class names, but bad practice.
4. We can also use numbers and dollar symbols ($) in class names, but they should be used for special purposes. For example, inner and anonymous classes.

Let's see some valid syntaxes for class names.

6. Method Names

Method name should begin with a lowercase letter; while capital letters are acceptable, but lowercase is preferred.

The first letter of each inner word should be capitalized if the method's name is made up of multiple words. Although they are permitted, underscores are not advised. Dollar ($) symbols and numbers are also acceptable.

Let's see some valid syntaxes for the method name.

7. Identifiers in Java

In addition to the names of classes, packages, and methods, identifiers also include the names of local variables, instance and class variables, and labels. Not only the ASCII subset of Unicode characters is valid.

• All identifiers can consist of letters (A to Z or a to z), digits (0-9), a currency symbol ($), or an underscore (_) symbol.
• Identifier must begin with a letter, an underscore (_) symbol, or a dollar sign ($), but not with a digit, space, and hyphen symbol (-), and special characters.
• After the first character, identifiers can have any combination of characters.
• Constant name must be in capital letters.
• A Java keyword (53) cannot be an identifier because these are reserved names in Java.
• Identifiers are case-sensitive.
• There is no length limit. So, it is best to keep identifiers concise and descriptive for better readability.

Let's see some valid syntaxes for the identifier names.

Valid Identifiers Names

Invalid Identifiers Names

8. White spaces in Java

In Java, white spaces are allowed only in comments because the Java compiler ignores white spaces.

9. Access Modifiers

The access modifiers specify the accessibility or scope of a field, method, constructor , and class. We can change the access level of fields, constructors, methods, and classes by prefixing the access modifier. These modifiers manage the scope of classes and methods.

There are two types of access modifiers in Java:

• Access Modifiers: default, public, protected, private.
• Non-access Modifiers: final, abstract, static, transient, synchronized, volatile, native.

Let's see the scope of access modifiers.

10. Java Keywords

In Java, reserved words are known as keywords. These are the terms in a language that are used for internal procedures or to denote specific acts. As a result, these terms cannot be utilized as identifiers. There are a total of 50 keywords in Java.