Start learning free

LESSON 176 OF 344 · OBJECT-ORIENTED PROGRAMMING

Defining a Class in Java: Syntax, Naming and Your First Class

Lesson Read the full explanation

TL ; DR:

A class is a blueprint for creating objects. It groups together related data and behavior under a single name.
In Java, you define a class with the class keyword, followed by the class name and a pair of curly braces:
```
class Dog {

}
```
The body of the class can be empty — that's still a valid class. We'll add data and behavior to it in the next lessons.

Full lesson:

So far, you've worked with built-in types like int, String, and arrays. But what if you want to model something the language doesn't have a type for — like a Dog, a BankAccount, or a Game?

That's what classes are for. A class lets you define your own type by listing what data it holds and what actions it can perform.

Why classes?

Imagine you're writing a program about dogs. Each dog has a name, an age, and can bark. Without classes, you'd have to track each dog's name in one variable, age in another, and write a separate bark() function for each. That gets messy fast.

With a class, you bundle all of that into one neat package called Dog:

class Dog {
    // We'll add fields (data) and methods (behavior) here in upcoming lessons.
}

The syntax

Defining an empty class in Java looks like this:

class ClassName {
}

Three things to notice:

The keyword class tells Java you're defining a new type.
ClassName is the name you choose. By convention, Java class names use PascalCase — capitalized words with no underscores: Dog, BankAccount, HighScore.
The curly braces { } hold the body of the class. They can be empty for now.

Your task

Define an empty class called Dog. The pre-filled code in mainFunction will create an instance of your class and print a confirmation message. If you define the class correctly, the program will compile and print:

Defined the Dog class!

STEP 1 OF 1

Guided

Ctrl + Enter to check

JAVA · OBJECT-ORIENTED PROGRAMMING

Defining A Class in Java, explained

What a class is

Java comes with types such as int, String and arrays. A class lets you add your own type to that list. It is a blueprint that describes what a thing knows (its data) and what it can do (its behavior). A Dog, a BankAccount or a Game can each be a class.

Without classes, a program about dogs would keep each dog's name in one variable, its age in another, and write separate code for each dog's actions. With a class, all of that lives under one name, Dog, and the rest of the program works with whole dogs instead of loose variables.

A class is not a dog, only the description of one. Real dogs, called objects or instances, come from the next lesson, where new builds them from the blueprint.

The syntax

The smallest class you can write is the keyword class, a name and a pair of curly braces:

class ClassName {
}

class tells the compiler that you are declaring a new type.
ClassName is the name you choose. Java programmers write class names in PascalCase: every word starts with a capital letter and there are no underscores, as in Dog, BankAccount or HighScore.
The braces hold the body of the class. Fields and methods go there, and for now the body can be empty. An empty class is still a valid class.

Names are case-sensitive, so Dog and dog are different identifiers. The naming convention is not enforced by the compiler, but code that ignores it is harder for other Java programmers to read, because a capitalized name tells them at a glance that it is a type and not a variable.

Where the body goes later

Everything a class contains sits between its braces. The lessons that follow fill that space in this order:

Fields hold the data of each object, such as a name and an age.
Constructors set that data when an object is created.
Methods are the actions an object can perform.

A comment placeholder is a handy way to mark that spot while you plan:

class Dog {
    // fields and methods will go here
}

The lesson's exercise, step by step

The starter code already has a Solution class whose mainFunction uses a Dog, but no Dog class exists yet:

class Solution {
    public void mainFunction() {
        Dog dog = new Dog();
        System.out.println("Defined the Dog class!");
    }
}

As it stands, this fails to compile. The compiler reaches Dog dog, finds no type with that name and reports that it cannot find the symbol. The fix has one step: declare an empty class named Dog above Solution, with the class keyword, the PascalCase name and a pair of braces.

Here is the complete reference solution:

class Dog {
}

class Solution {
    public void mainFunction() {
        Dog dog = new Dog();
        System.out.println("Defined the Dog class!");
    }
}

Once Dog exists, the line Dog dog = new Dog(); has a type to work with. It declares a variable named dog of type Dog and creates an object to store in it. The program then prints Defined the Dog class!.

Details worth knowing

One file, several classes. A Java file may hold more than one top-level class, which is why Dog and Solution can sit side by side here. A top-level class marked public is different: it must be the only public class in its file, and the file must have the same name, so public class Dog belongs in Dog.java. The classes in this lesson have no access modifier, which is fine for small exercises.
Order doesn't matter. Java lets Solution use Dog even if Dog is written after it. The lesson puts Dog first because that reads naturally.
No semicolon after the closing brace. Unlike C++, a Java class declaration doesn't end with a semicolon, so leave it out.
A class is a type. Once defined, Dog can be used wherever a type is allowed: variable declarations, method parameters, return types and array elements such as Dog[].
The compiler adds a constructor. You wrote no constructor, yet new Dog() works. When a class declares none, Java supplies a default one that takes no arguments. The constructors lesson explains this in detail.

Common mistakes

A different name. Naming the class dog, Dogs or DOG leaves Dog undefined, and new Dog() still fails with "cannot find symbol".
Missing braces. class Dog alone is not a complete declaration. The compiler expects a body, even an empty one.
Underscores in the name. bank_account compiles, but the Java convention is BankAccount.
Putting the class inside a method. The class belongs at the top level of the file, outside Solution and its methods, as in the solution above.
Confusing the class with an object. Defining Dog doesn't create any dogs. Only new Dog() does.

Key takeaways

A class is a blueprint that defines a new type, and it bundles related data and behavior under one name.
The syntax is class Name { }, and the body may be empty.
Class names use PascalCase and are case-sensitive.
Fields, constructors and methods go inside the braces, and the next lessons add them to Dog.
A class describes objects. You create them with new.

Keep going with JavaAbout 340 step-by-step lessons, from your first line of code to coding interviews. Free to start.

Start learning free