- 1Java OOP Introduction
- 2Java Class
- 3Java Class Constructor
- 4Java Class Objects
- 5Java Access Modifiers
- 6Java Static Variables in Classes
- 7Java Static Methods Explained
- 8Java Static Blocks
- 9Java final Variables
- 10Java final Methods
- 11Java final class
- 12Inheritance in Java
- 13Java Method Overriding
- 14Java Abstraction in OOP
- 15Interfaces in Java
- 16Polymorphism in Java
- 17Encapsulation in Java
- 18Java Nested Classes
- 19Java Nested Static Class
- 20Java Anonymous Class
- 21Java Singleton Class
- 22Java Enums
- 23Reflection in Java
Java Class - Blueprint of Objects
What is a Class?
A class in Java is like a blueprint for making cars. It defines what features the car will have (like color, engine type, or number of doors) and what actions it can perform (like start, stop, or accelerate). But the class itself isn’t the actual car — it’s just the design. Just like a car blueprint isn’t a car you can drive, a class isn’t an object — it simply describes how the object should be built and behave.
How to Declare a Class in Java
Declaring a class is simple. Here's the syntax:
class ClassName {
// Fields (variables)
// Methods (functions)
}
class
is the keyword used to declare a class.ClassName
is the name you give to your class. By convention, class names start with a capital letter.- The class body is enclosed in curly braces
{ }
. - Inside the class, you can define:
- Fields: variables that hold data for each object.
- Methods: functions that define what the object can do.
Explanation of the Class Diagram
class ClassName
: This line declares a class namedClassName
. It’s similar to the Java syntaxclass ClassName { ... }
.-type field1
and-type field2
: These represent fields (also called attributes or variables) in the class.- The
-
symbol means the fields are private, meaning they can only be accessed within the class. type
is a placeholder for the data type (likeint
,String
, etc.).
- The
+method1()
and+method2()
: These represent methods (also called functions) in the class.- The
+
symbol means the methods are public, meaning they can be accessed from outside the class. - The empty parentheses
()
indicate that the methods do not take any parameters in this diagram.
- The
Class diagrams help you visualize the structure of your class, including its data (fields) and behavior (methods), before writing the actual code.
Defining a Class
Let’s define a class called Car
with a few attributes and a method to display its details.
class Car {
String brand;
int year;
void displayDetails() {
System.out.println("Brand: " + brand);
System.out.println("Year: " + year);
}
}
Creating Objects from a Class
Once we have a class, we can create objects (instances) from it using the new
keyword.
class Car {
String brand;
int year;
void displayDetails() {
System.out.println("Brand: " + brand);
System.out.println("Year: " + year);
}
}
public class Main {
public static void main(String[] args) {
Car myCar = new Car();
myCar.brand = "Toyota";
myCar.year = 2020;
myCar.displayDetails();
}
}
Brand: Toyota
Year: 2020
Class Diagram
Explanation
- Car is a class with two private fields:
brand
andyear
. - It also has one public method:
displayDetails()
, which prints the values ofbrand
andyear
. - Main is the entry point of the program. It contains the
main()
method. - Inside
main()
, an objectmyCar
of classCar
is created and initialized. - The line
Main --> Car : uses
indicates that theMain
class uses theCar
class by creating and interacting with its object.
Here, we created an object myCar
of type Car
. We then assigned values to its brand
and year
fields. Calling displayDetails()
printed those values to the console.
Example 3: Adding Constructors
A constructor is a special method used to initialize objects. Let’s modify our Car
class to include one.
class Car {
String brand;
int year;
// Constructor
Car(String b, int y) {
brand = b;
year = y;
}
void displayDetails() {
System.out.println("Brand: " + brand);
System.out.println("Year: " + year);
}
}
public class Main {
public static void main(String[] args) {
Car car1 = new Car("Honda", 2018);
car1.displayDetails();
}
}
Brand: Honda
Year: 2018
Key Concepts Around Classes
- Fields: Variables declared inside a class that define the state of an object.
- Methods: Functions defined in a class that describe its behavior.
- Constructors: Special methods to initialize objects. If not defined, Java provides a default one.
- Access Modifiers: Such as
public
,private
, andprotected
to control visibility.
Example 4: Using Multiple Objects
You can create multiple objects from the same class, each with its own set of data.
class Car {
String brand;
int year;
// Constructor
Car(String b, int y) {
brand = b;
year = y;
}
void displayDetails() {
System.out.println("Brand: " + brand);
System.out.println("Year: " + year);
}
}
public class Main {
public static void main(String[] args) {
Car car1 = new Car("Ford", 2021);
Car car2 = new Car("Tesla", 2022);
car1.displayDetails();
System.out.println("---");
car2.displayDetails();
}
}
Brand: Ford
Year: 2021Brand: Tesla
Year: 2022
Importance of Classes
Classes bring structure to your code. Instead of writing repetitive logic, you define it once in a class and reuse it by creating objects. They support abstraction, encapsulation, inheritance, and polymorphism — all pillars of OOP and we shall learn each of them in detail in our next classes.
Remember
- Class name should start with an uppercase letter by convention.
- You can create as many objects from a class as you need.
- Fields store data; methods manipulate or display it.
- Constructor names must match the class name.
QUIZ
Question 1:What does a class represent in Java?
Question 2:In Java, classes can have both variables and methods inside them.
Question 3:Which of the following statements about constructors in Java are true?
Question 4:What is the output of the following code?
Car car1 = new Car("Ford", 2021);
car1.displayDetails();
Assuming the Car
class has a constructor and a display method as defined in the tutorial.
Car car1 = new Car("Ford", 2021);
car1.displayDetails();
Comments
Loading comments...