Cheatsheets / Learn Java

Object-Oriented Java
Java objects’ state and behavior
In Java, instances of a class are known as objects. Every
object has state and behavior in the form of instance public class Person {

fields and methods respectively. // state of an object

int age;

String name;

// behavior of an object

public void set_value() {

age = 20;

name = "Robin";

public void get_value() {

System.out.println("Age is " + age);

System.out.println("Name is " + name);

// main method

public static void main(String [] args)

{

// creates a new Person object

Person p = new Person();

// changes state through behavior

p.set_value();

}
Java instance
Java instances are objects that are based on classes. For
example, Bob may be an instance of the class Person . public class Person {

Every instance has access to its own set of variables int age;

which are known as instance fields, which are variables String name;

declared within the scope of the instance. Values for

instance fields are assigned within the constructor

// Constructor method

method.
public Person(int age, String name) {

this.age = age;

this.name = name;

public static void main(String[] args) {

Person Bob = new Person(31, "Bob");

Person Alice = new Person(27,

"Alice");

Java dot notation

In Java programming language, we use . to access the
variables and methods of an object or a Class. public class Person {

This is known as dot notation and the structure looks like int age;

this-

instanceOrClassName.fieldOrMethodName
public static void main(String [] args)
{

Person p = new Person();

// here we use dot notation to set age

p.age = 20;

// here we use dot notation to access

age and print

System.out.println("Age is " + p.age);

// Output: Age is 20

}
Constructor Method in Java
Java classes contain a constructor method which is used
to create instances of the class. public class Maths {

The constructor is named after the class. If no public Maths() {

constructor is defined, a default empty constructor is System.out.println("I am

used. constructor");

public static void main(String [] args)

{

System.out.println("I am main");

Maths obj1 = new Maths();

Creating a new Class instance in Java

In Java, we use the new keyword followed by a call to the
class constructor in order to create a new instance of a public class Person {

class. int age;

The constructor can be used to provide initial values to // Constructor:

instance fields.
public Person(int a) {

age = a;

public static void main(String [] args)

{

// Here, we create a new instance of

the Person class:

Person p = new Person(20);

System.out.println("Age is " + p.age);

// Prints: Age is 20

}
Reference Data Types
A variable with a reference data type has a value that
references the memory address of an instance. During public class Cat {

variable declaration, the class name is used as the public Cat() {

variable’s type. // instructions for creating a Cat

instance

public static void main(String[] args) {

// garfield is declared with reference

data type `Cat`

Cat garfield = new Cat();

System.out.println(garfield); //
Prints: Cat@76ed5528

Constructor Signatures
A class can contain multiple constructors as long as they
have different parameter values. A signature helps the // The signature is `Cat(String furLength,
compiler differentiate between the different boolean hasClaws)`.

constructors. public class Cat {

A signature is made up of the constructor’s name and a String furType;

list of its parameters.

boolean containsClaws;

public Cat(String furLength, boolean

hasClaws) {

furType = furLength;

containsClaws = hasClaws;

public static void main(String[] args) {

Cat garfield = new Cat("Long-hair",

true);

}
null Values
null is a special value that denotes that an object has a
void reference. public class Bear {

String species;

public Bear(String speciesOfBear;) {

species = speciesOfBear;

public static void main(String[] args) {

Bear baloo = new Bear("Sloth bear");

System.out.println(baloo); // Prints:
Bear@4517d9a3

// set object to null

baloo = null;

System.out.println(baloo); // Prints:
null

The body of a Java method

In Java, we use curly brackets {} to enclose the body of
a method. public class Maths {

The statements written inside the {} are executed when public static void sum(int a, int b) {
a method is called. // Start of sum

int result = a + b;

System.out.println("Sum is " +
result);

} // End of sum

public static void main(String [] args)

{

// Here, we call the sum method

sum(10, 20);

// Output: Sum is 30

}
Method parameters in Java
In java, parameters are declared in a method definition.
The parameters act as variables inside the method and public class Maths {

hold the value that was passed in. They can be used public int sum(int a, int b) {

inside a method for printing or calculation purposes. int k = a + b;

In the example, a and b are two parameters which, when return k;

the method is called, hold the value 10 and 20

}

respectively.

public static void main(String [] args)

{

Maths m = new Maths();

int result = m.sum(10, 20);

System.out.println("sum is " +
result);

// prints - sum is 30

Java Variables Inside a Method

Java variables defined inside a method cannot be used
outside the scope of that method. //For example, `i` and `j` variables are
available in the `main` method only:

public class Maths {

public static void main(String [] args)

{

int i, j;

System.out.println("These two
variables are available in main method
only");

Returning info from a Java method

A Java method can return any value that can be saved in a
variable. The value returned must match with the return public class Maths {

type specified in the method signature.

The value is returned using the return keyword. // return type is int

public int sum(int a, int b) {

int k;

k = a + b;

// sum is returned using the return

keyword

return k;

public static void main(String [] args)

{

Maths m = new Maths();

int result;

result = m.sum(10, 20);

System.out.println("Sum is " +
result);

// Output: Sum is 30

Declaring a Method
Method declarations should define the following method
information: scope (private or public), return type, // Here is a public method named sum whose
method name, and any parameters it receives. return type is int and has two int
parameters a and b

public int sum(int a, int b) {

return(a + b);