---
title: "Java Syntax"
url: https://weworkworldwide.com/tutorials/java-syntax-3/
description: ""What makes sense is not law, syntax, rules or structure" Aaron Betsky Before we get into the nitty gritty details of how to program in Java, we need to ha"
date: 2026-06-01T13:00:03+00:00
source: https://weworkworldwide.com/llms.txt
---

# Java Syntax

“What makes sense is not law, syntax, rules or structure” Aaron Betsky

Before we get into the nitty gritty details of how to program in Java, we need to have a general sense of how a Java program looks like.

So in this section we will give a general view about the syntax of a Java program.

Take a look at the example below:

``` line-numbers
public class Simple {
 
 public static void main(String[] args){
 System.out.println("Hello World");
 }
 }
```

If we compile and run this example, we will see the message “Hello World” on the screen.

Note: the file that this example is stored in, should have the same name as the name of the class (in this case `Simple`).

## Classes in Java:

The first line of this example is ` public class Simple`:

In Java we use classes to define how an object of type of that class is about to behave when it’s running. If you open any Java program, you’ll see at least one class is defined in its source code.

In this example we have one class and that is named `Simple`.

Also in order to declare a class we use two keywords before the name of that class:

`public`: the keyword `public` is actually an access specifier and it declares whether or not an object can be created out of that class.

There are other types of access specifiers like `protected` and `private`.

`class`: anytime we want to create a class, we use the keyword `class` before the name of that class. This will declare the next block of code as the body of that class.

Note: the name of a class usually starts with a capital letter.

``` line-numbers
`{}`: after the name of a class we used braces `{}` and these declare the border of a class. So basically the opening brace `{` declares the beginning of a class and the closing brace `}` declares the end of that class.
```

In short a class has this structure:

``` line-numbers
Access-specifiers class ClassName {//body…}
```

## Main method in Java:

Next we have this line in the example:

``` line-numbers
public static void main(String[] args){//body…}
```

This is called method.

Methods are the places where we declare the instructions and tasks of a program.

Depending on the need of a class, it can have many methods.

We can say that methods of a class are like the departments of a company.

In a company each department is in charge of working on a specific task right? For example the work of R&D department is to do research and invent new technologies that can be used to improve the product etc.

Or the task of a marketing department is to focus on finding new markets or trying to advertise the product of the company to as many people as possible.

In a program, the tasks are divided into sub-tasks and each method is in charge of one or more of these tasks.

Now in this example we have a method named `main` and that is the first place or the entry point when the program is running.

Basically the computer will look for the method named `main` when it wants to run a program and starts from there to run instructions of that program.

Just like when we declare a class, we need to declare the access specifier of a method as well.

Note: for the `main` method, we have only one choice and that is `public`. But for other methods we can use `private` and `protected` access specifiers as well.

``` line-numbers
`static`: In Java we work with objects and objects are created from classes. Basically classes are the template or the map from which objects create from. Also for any object that we create from a class, all the methods and other elements of that class will be copied to a new location in the memory.
```

This means if we create 10 objects from a class, and if in that class we have one method, then each object will have a separate and independent copy of that method. But when a method is declared `static` like this one in this example, it means there’s only one method with this name no-matter how many objects we create from that class. Also a method that is declared as `static` will not be accessible from an object. We can only access the method via the name of the class that the method is defined in (the Simple class in this example).

``` line-numbers
`void`: methods in a class are callable. That means we can call a method and expect a return value or no-value. For example let's say a method in a class is named `printTime()` and any time we call that method, it will return the current time. But there are methods that do not return a value. These types of methods just run a task and that's it, there's no return value or something.
```

The `main` method here is an example of a method that runs a set of instructions but does not return any value.

In such case we declare the keyword `void` before the name of the method to mention that the method does not return a value.

`main`: a method needs name, otherwise how can we call a method in a program? In this example the name of the method is `main`.

Note:

-   Any Java program should have one method named `main` exactly like  
    the one we’ve declared in this example.

-   There are some rules on how to set a name of a method which will  
    be explained in later sections.

`()`: sometimes for a method to function correctly, it needs an input. For example let’s say there is a method named `sum` and this method adds two values together and return the result to the caller. But the method needs two values in order to be able to function correctly. The declaration of the need of these two values for the method happens in the parentheses.

For example:

``` line-numbers
public int sum(int a, int b){
 //body...
 }
```

As you can see in the parentheses of this method we have declare two parameters named `a` and `b` with the type `integer`.

That means when we call this method, we need to put two integer values in it so that it can function correctly.

``` line-numbers
`{}`: any method has a body. This body is the place where we declare the instructions that is allocated to that method. The body of a method starts from the opening brace `{` and ends at the closing brace `}`;
```

## The println method:

In our example, at the body of the `main` method, we ran this statement:

``` line-numbers
System.out.println("Hello World");
```

The name `System` here is the name of a class and inside of that class there’s an object named `out` that is created from a class named `PrintStream` and inside this class we have a method named `println` (which stands for print line) and that accepts a message and will send that message to the output stream (in this case the screen).

So the message “Hello World” is sent to the output when we called it inside the body of the `main` method.

At the end, when the program reaches the closing brace `}` of the `main` method, it will terminate the program.

Note: in later sections we will dive dip into each of these materials you see here. So for now just try to remember that in a program there are classes, methods etc. and that’s all you need to know for this section.