Home Java Fundamentals

Java Fundamentals

by Bernard Baah

Java Fundamentals: Basics of Java Syntax

Java, a robust, object-oriented programming language, is widely used for building a variety of applications, from mobile apps to large enterprise systems. Understanding Java syntax is the first step towards mastering this versatile language. Below, we’ll dive into the fundamental elements of Java syntax to help you get started.

1. Java Program Structure

A typical Java program consists of a class declaration, within which lies the main method. Every Java application begins execution within the main method.

public class Main {
     public static void main(String[]args) {
          System.out.println(“Hello, world!”);
  • Class Declaration: The class keyword is followed by the class name; Java class names start with a capital letter by convention.
  • Main Method: This is the entry point of any Java application. The public static void main(String[] args) method signature is fixed and universally consistent across all Java applications.

2. Basic Syntax Rules

  • Case Sensitivity: Java is case-sensitive, meaning identifiers like variableName and VariableName are different.
  • Class Names: Class names should start with an uppercase letter. If several words are used to form the name of the class, each inner word’s first letter should be in upper case (e.g., SampleClass).
  • Method Names: All method names should start with a lowercase letter. If several words are used to create the name of the method, then each inner word’s first letter should be in uppercase (e.g., myMethodName).
  • Program File Name: The name of the program file should exactly match the class name with a .java extension.

3. Data Types and Variables

Java offers various data types, but they are mainly divided into two groups:

  • Primitive Data Types: Includes byte, short, int, long, float, double, boolean, and char.
  • Non-primitive Data Types: Includes Strings, Arrays, Classes, and more.

Here is how you might declare variables:

int myNumber = 100;
double rate = 3.142;
boolean isJavaFun = true;
char myGrade = ‘A’;
String greeting = “Hello Java”;

4. Control Structures

Java uses standard control structures that are similar to those in other programming languages.

  • Conditional Statements: if, else if, and else.
  • Loops: for, while, and do-while loops are used for iterating over a block of code several times.

Example of an if statement:

if (myNumber < 0) {
      System.out.println(“Negative Number”);
} else {
      System.out.println(“Positive Number”);

Example of a for loop:

for(int i = 0; i < 10; i++) {


Comments in Java are similar to those in C/C++. Single-line comments start with two forward slashes (//), and multi-line comments start with /* and end with */.


// This is a single-line comment
This is a multi-line comment
that spans multiple lines.

Understanding these basics forms the foundation for advancing in Java programming. Each element of Java syntax plays a critical role in building applications, making it essential for new developers to grasp these concepts thoroughly.

Understanding Java Data Types and Variables

Java offers a rich set of data types, which are the building blocks of data manipulation in the language. These types are broadly categorized into primitive data types and reference (non-primitive) data types. Understanding how to use these types effectively is crucial for any Java developer. Let’s explore these in detail, along with how variables are used to store information.

1. Primitive Data Types

Java has eight primitive data types, which are predefined by the language and named by a keyword. These data types represent single values and have no additional methods.

  • byte: The byte data type is an 8-bit signed two’s complement integer. It has a minimum value of -128 and a maximum value of 127. Suitable for small-range data needs.
  • short: The short data type is a 16-bit signed two’s complement integer. It has a minimum value of -32,768 and a maximum value of 32,767.
  • int: The most commonly used data type, int, is a 32-bit signed two’s complement integer with a minimum value of -2^31 and a maximum value of 2^31-1.
  • long: For larger integer values, long is used. It’s a 64-bit signed two’s complement integer.
  • float: This is a single-precision 32-bit IEEE 754 floating point. It’s used mainly for saving memory in large arrays of floating point numbers.
  • double: Double precision, as implied by double, is a double-precision 64-bit IEEE 754 floating point and is used for decimal values.
  • boolean: The boolean data type has only two possible values: true and false. This data type is used for simple flags that track true/false conditions.
  • char: The char data type is a single 16-bit Unicode character.

2. Non-Primitive Data Types

Non-primitive types (also called reference types) include Classes, Interfaces, and Arrays. They do not store the value directly; instead, they store the reference (address) to the value.

  • String: The String class is used to create and manipulate strings.
  • Arrays: An array is a container that holds a fixed number of values of a single type.
  • Class: A class in Java is a blueprint from which individual objects are created.
  • Interface: An interface is a reference type in Java, it is a collection of abstract methods.

3. Variables

Variables in Java are instances of data types that allow us to store data. They must be declared before they are used.

  • Declaration: Variable declaration typically has a type followed by a variable name: int age;
  • Initialization: You can initialize a variable at the time of declaration: int age = 30;
  • Variable Names: Java variable names are case-sensitive and must begin with a letter (like A-Z or a-z), currency character ($) or an underscore (_). After the first character, variable names can contain any letter, currency character, underscore, or digit.

4. Scope of Variables

  • Local Variables: Declared within a method and their scope is limited to the method itself.
  • Instance Variables (Non-Static Fields): These are declared without the static keyword. They are unique to each instance of a class.
  • Class Variables (Static Fields): Declared with the static modifier; there is only one copy of this variable in existence, regardless of how many times the class has been instantiated.

5. Type Conversion

In Java, type conversion can be automatic (widening conversion) or must be done manually via casting (narrowing conversion).

  • Widening Conversion: Automatic type conversion from a smaller to a larger type, e.g., from int to long.
  • Narrowing Conversion: Requires explicit casting because you are fitting a larger type into a smaller size type, e.g., from double to int.

int myInt = 9;
double myDouble = myInt; // Automatic casting: int to double

double myDouble = 9.78;
int myInt = (int) myDouble; // Manual casting: double to int

Understanding data types and variables is fundamental in Java programming as they form the backbone of data manipulation and storage in the language. This knowledge is crucial for creating efficient and effective Java applications.

Control Structures in Java: Loops and Conditionals

Control structures are fundamental elements in any programming language, allowing you to dictate the flow of program execution based on conditions and repetitions. Java provides several control structures, including conditionals and loops, which are essential for handling decision-making processes and repeating operations. Here’s a detailed look at these structures.

1. Conditional Statements

Conditional statements check for specified conditions and execute a block of code depending on the outcome. Java supports the following conditional statements:

  • if statement: Executes a block of code if a specified condition is true.
    if (temperature > 30) {
    System.out.println(“It’s a hot day!”);
  • if-else statement: Executes one block of code if the condition is true, and another block if the condition is false.

          if (temperature > 30) {
                 System.out.println(“It’s a   hot day!”);
         } else {
                 System.out.println(“It’s a nice day!”);

  • else-if ladder: A series of conditions to be checked sequentially.
  • if (temperature > 30) {
    System.out.println(“It’s a hot day!”);
    } else if (temperature > 20) {
    System.out.println(“It’s a warm day!”);
    } else {
    System.out.println(“It’s cold outside!”);
  • switch statement: Specifies many alternative blocks of code to be executed. This is useful when the variable being switched on will often have the same value.
  • int day = 4;
    switch (day) {
    case 1:
    case 2:
    case 3:
    case 4:
  • 2. Looping Constructs

Loops are used for executing a block of statements repeatedly until a particular condition is satisfied.

  • for loop: Repeats a group of statements a fixed number of times. It includes the initialization, condition, and the increment/decrement in one line, making it easy to read and manage.
    for (int i = 0; i < 5; i++) {
  • while loop: Repeats a statement or a group of statements while a given condition is true. It tests the condition before executing the loop body.
    int i = 0;
    while (i < 5) {
  • do-while loop: Like a while loop, except it tests the condition at the end of the loop body, ensuring that the loop will be executed at least once.
    int i = 0;
    do {
    } while (i < 5);

3. Jump Statements

These are used to alter the flow of control unconditionally. Java provides three major jump statements: break, continue, and return.

  • break: Terminates the loop or switch statement and transfers execution to the statement immediately following the loop or switch.
    for (int i = 0; i < 10; i++) {
    if (i == 4) {
  • continue: Causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating.
    for (int i = 0; i < 10; i++) {
    if (i == 4) {
  • return: Exits from the current method, and control flow returns to where the method was invoked.

Understanding and utilizing these control structures effectively can greatly enhance the logic and efficiency of your Java programs. They form the backbone of decision-making in software development, allowing for more dynamic and responsive applications.

Welcome to Coding Filly, your go-to destination for all things tech! We are a passionate team of tech enthusiasts dedicated to providing insightful and inspiring content to empower individuals in the world of technology.


Subscribe my Newsletter for new blog posts, tips & new photos. Let's stay updated!

Cooding Filly – All Right Reserved. Designed and Developed by Filly Coder

Update Required Flash plugin