Java Class Definition: A Beginner’s Guide from Scratch

Java Class Basics

In Java, a class is the basic building block of a program and consists of two parts: the class declaration (header) and the class body.

Class Declaration

The simplest declaration uses the class keyword followed by the class name, e.g., class Car. The full syntax can include optional modifiers, a superclass, and implemented interfaces:

[modifier] class ClassName [extends SuperClass] [implements Interface1, Interface2]

Modifiers are divided into access modifiers ( public, protected, default, private) and non‑access modifiers ( abstract, final, static).

Class Body

The body, enclosed in braces, contains member variables, constructors, and methods.

Member Variables

Variables (fields) describe the attributes of a class. Their syntax is: [modifier] DataType variableName; For example, a Car class can declare three attributes:

public String brand;   // brand
public String color;   // color
public double speed;   // speed

Member Methods

Methods define the behavior of a class. The general method signature is:

[modifier] ReturnType methodName([parameterList]) [throws Exception] {
    // method body
}

The return type can be any primitive type, class, array, or void. Method names must follow Java identifier rules and are usually verbs; the first word is lowercase, subsequent words start with uppercase letters. Parameter lists may be empty but parentheses are required. The throws clause lists checked exceptions that the method might raise.

Method Overloading

Overloading allows multiple methods with the same name but different parameter lists (different number, types, or order of parameters). Return type does not affect overloading. Overloading demonstrates Java’s polymorphism but can reduce readability if overused.

Example:

public class Drawmg {
    // draw an integer
    public void draw(int i) { ... }
    // draw a double
    public void draw(double f) { ... }
    // draw a string
    public void draw(String s) { ... }
}

Constructors

Constructors (also called constructors) create instances of a class. If no constructor is defined, Java provides a default no‑argument constructor. The syntax is:

[public] ClassName([parameterList]) {
    // constructor body
}

Modifiers for constructors can be public or default (no modifier). The constructor name must exactly match the class name, and constructors can be overloaded.

Example for the Car class:

public class Car {
    private String brand;   // brand
    private String color;   // color
    private String speed;   // speed
    public Car(String brand, String color, String speed) {
        this.brand = brand;
        this.color = color;
        this.speed = speed;
    }
}