Exploring the Basics of Objects and Methods in Java
Published: 2023-03-19 09:41:38

When you're first learning to program in Java, one of the most important concepts to learn and understand is objects and methods. Objects and methods form the foundation of object-oriented programming (OOP) in Java, which is a powerful programming paradigm that allows you to write more organized, efficient, and reusable code. In this article, I'll explain the fundamentals of Java objects and methods and help you understand how they work.

> Before continuing with this article, it is important that readers have a good understanding of basics of Java. If you need to brush up on your basic programming skills in Java, I recommend reading [_**the basics of Java here**_](https://dev.to/jacobe/a-beginners-guide-to-java-basics-26jn). 

## What are objects in Java?

Java is an object-oriented programming (OOP) language.
What this means is that every class in Java is supposed to be a blueprint for an object with the same name. Think of an object as an instance of a class, which is a blueprint for creating objects. 
The syntax to declare a new object
```java
<object_type> <object_name>;
```
```java
String myCar;
```
To initialize an object, you have to create it using the keyword `new`:
```java
<object_name> = new <class_name>();
```
```java
myCar = new Car();
```
You can declare and initialize the same type like this:
```java
<object_type> <object_name> = new <class_name>();
```
```java
String Car = new Car();
```
> An object in Java is also known as an instance, and the process of creating an object is called instantiation.

Objects can store values in the form of attributes and execute instructions in the form of methods. The idea of objects is that they each have a different value for a common characteristic.
 
To declare an instance attribute, create a variable outside the main method (example below). This allows Java to recognize the syntax, and every object you create will have a copy of that variable that can store a different value in each object.

To access the value of an attribute, refer to the object's name, then type a dot and the attribute's name. You may modify this value just as you do with a usual variable, but remember that you will be changing the value of that attribute for the object you are referring to.

> The word `private` below means that the attribute can only be accessed by this class. 

Here's an example of a simple class with attributes in Java.
```java
public class Car {
    private String make;
    private String model;
    private int year;
}
```
From the above class definition, "Car defines a `Car` object, which has three attributes (information): `make`, `model`, and `year`. These attributes or pieces of information represent the `make`, `model`, and `year` of the car, respectively.
 
To create an object of this class, you use the `new` keyword and the class constructor, like this:

```java
Car myCar = new Car();
```
This creates a new `Car` object and assigns it to the variable `myCar`. You can then set the attributes of the object like this:

```java
myCar.make = "Toyota Camry";
myCar.model = "Civic";
myCar.year = 2022;
```
This sets the `make`, `model`, and `year` attributes of the `myCar` object.
 
Let's see a simple Java program.
```java
public class Car
{   
     private String model;
     private String make;
     private int year;
  public static void main(String[] args)   
{     
    Car myCar = new Car();
    myCar.model = "Civic";      
    myCar.make = "Toyota Camry";      
    myCar.year = 2022; 
//creating a different object with different attributes      
    Car ourCar = new Car();      
    ourCar.model = "City";      
    ourCar.make = "Honda";      
    ourCar.year = 2023;      
//accessing values of attributes of objects      
   System.out.println("My car's model is " + 
   myCar.model);      
   System.out.println("My car's make is " + 
   myCar.make);      
   System.out.println("My car's year is " + myCar.year);
   System.out.println();      
   System.out.println("Our car's model is﻿ " + 
   ourCar.model);      
   System.out.println("Our car's model is﻿ " + 
   ourCar.make);      
   System.out.println("Our car's model is﻿ " + ourCar.year);   
  }
}
```
```java
Output:::
My car's model is a Civic.
My car's make is a Toyota Camry.
My car's year is 2022. 

Our car's model is City.
Our car's make is Honda.
Our car's year is 2023.
```
Take a look at the code above; notice any repetitiveness? How is the process of creating an object and assigning values to its variables carried out? There's a solution for that. It's constructors.

## What is a constructor in Java?
Constructors tell Java how to create an object when you already know the values you want to assign to its attributes.
 
A constructor is a special method that is used to initialize objects in a class. It is called automatically when an object of the class is created, and it is responsible for setting initial values for the object's attributes. The constructor has the same name as the class and is defined within the class.
 
The main purpose of the constructor is to ensure that all objects of a class are created with a valid initial state. This helps to prevent errors and ensures that the object is ready to be used in the program.
  
The syntax is
```java
public <class_name> ( <parameters> ) { 
values assignation 
}
```

> Never place them inside the main method.
> The keyword `public` allows any class to access it, be it a class or an attribute. 

Now, let's look at a simple example in Java to understand how constructors work:
 
```java
public class Car{
    private String model; 
    private String make;  
    private String year;
    
    // Constructor
    public Car(String model, String make, int year) {
        this.mode = model;
        this.make = make;
        this.year = year;
    }
}
```
In the example above, we have defined a class called `Car` with three attributes: `model`, `make`, and `year`. We have also defined a constructor that takes three parameters: model, make, and year.
 
Within the constructor, we use the `this` keyword to refer to the current object being created and set the initial values for the `model`, `make`, and `year` attributes.

Now, when we create a new object of the `Car` class, the constructor is called automatically and sets the initial values for the object's attributes.
 
Here's an example:
```java
// Create a new Car object in the main method.
public static void main(String[] args)
{   
    Car ourFamilyCar = new Car("City", "Honda", 2023);   
    Car daddyCar = new Car("Civic", "Toyota Camry", 2022);
}
```
In this example, we have created two new Car objects called "ourFamilyCar" and "daddyCar," which passed in the values "`City`", "`Honda`" and `2023` for `ourFamilyCar`, and "`Civic`", "`Toyota Camry`" and `2022` for `daddyCar` as the `model`, `make`, and `year` attributes, respectively.

Constructors are an essential part of object-oriented programming, as they ensure that objects are created with valid initial states and are ready to be used in the program.
## What Are Methods in Java?
Methods are blocks of code that perform a specific task. In Java, methods are defined within classes, and they can be called on objects of that class.
 
Another useful thing you can do with objects is to make them execute certain instructions. A method is essentially a piece of code that is only executed when the name of the method is called (or invoked).
 
Apart from executing a block of code, methods have the property of returning (or giving you) values. And just as with any other variable in Java, you must specify what type of thing it is.
The syntax is
```java
public <return_type> <name_of_method> (arguments) { 
code to execute when it is called 
}
```
The arguments are certain values that may be required to carry out the code's logic. Arguments are not necessary, but beware: even if you don't ask for arguments, you must put them in parentheses `()` because they're part of every method's syntax.
### Void Method in Java
In case you do not want to get a value from the method, the return type should be set as void. Like in the code here.
```java
public void start() {
    System.out.println("The car is starting.");
}
```
When this method is called, `start()` which is the method name simply prints a message to the console.
 
To invoke this method on a Car class object, use the dot notation, as shown in the main method below.
```java
public static void main(String[] args){   
Car myCar = new Car("Civic", "Toyota Camry", 2022);   
myCar.start(); //apply method to myCar object 
}
```
When the code above runs it calls the `start()` method on the myCar object, and the message "The car is starting." is printed to the console.
```java
Output:::
The car is starting.
```
### Parameters and return values in methods
Methods can also take parameters and return values. _**Parameters are inputs to the method, and return values are outputs from the method.**_

It is commonplace to code a method that does some calculation and then gives you (returns you) that value. In that case, you must know beforehand what type of data you expect to get and place it in the `<return type>` part of the method's definition instead of void. Here's an example of a method with parameters and a return value:
```java
public int accelerate(int speed) {
    int newSpeed = speed + 10;
    return newSpeed;
}
```
This method, called `accelerate()`, takes an `int` parameter called `speed` and returns an `int` value. The method adds 10 to the speed parameter and returns the result.
To call this method on an object of the Car class, you pass in a value for the speed parameter and store the return value in a variable, like this:
```java
public static void main(String[] args)
{   
   Car myCar = new Car("Civic", "Toyota Camry", 2022);   
   myCar.start();
   System.out.println("current speed: " + 
   myCar.accelerate(50));
}
```
```java
Output:::
current speed: 60
```
 
This calls the `accelerate()` method on the `myCar` object, passing in a value of 50 for the `speed` parameter. The `return` value of the method `(60)` is stored in the `newSpeed` variable.
## Wrapping-up
Objects and methods are fundamental concepts in Java and OOP. Understanding how to create and use objects and methods is essential for writing effective and efficient Java code. By following the examples provided in this article, you should be well on your way.

Your feedback is highly appreciated.
you can follow me on [twitter](https://twitter.com/IsahJakub) and [linkedIn](https://www.linkedin.com/in/isahejacob/)