Java Fundamentals

1. Java Methods

A function is a block of statements that should return a value. A method is a block of code that runs when it is called.

• A method is a set of code referred to by name and can be called (invoked) at any point in a program by using the method's name.
• Data can be passed into a method as parameters.
• Methods are used to perform certain actions and are also known as functions.
• A method can be thought of as a subprogram that acts on data and often returns a value.
• Each method has its own name.
• When the method name is encountered, program execution branches to the body of that method.
• When the method finishes, execution returns to the point from which it was called and continues with the next line.

2. Advantages of Methods

• Simple to write.
• Easy to read, write and debug.
• Easy to maintain or modify.
• Small functions tend to be self-documenting and highly readable.
• A function can be called any number of times and from any place with different parameters.
• Methods support code reuse: define the code once and use it many times.

3. Create a Method

A method must be declared within a class. It is defined using the method name followed by parentheses ().

Java provides predefined methods such as System.out.println(), but programmers can also create their own methods to perform specific actions.

public class demo() {
    sop("Hello Welcome to Java method concepts");
}

4. Signature of a Function / Defining a Method

The source presents the basic structure of a method as:

Access Specifier
Access Modifier
return type
function name
(args list)
{
    // method body
}

5. Declaring a Method

The source gives the following general method declaration form:

AccessSpecifier AccessModifier return_type methodName(arguments/parameters);

6. What Is Actually Passed to a Method?

Example

int number1 = 25;
int number2 = 47;

int sum = add(number1, number2);   // actual parameters

public int add(int x, int y) {      // formal parameters
    return (x + y);
}

7. Method Example

The source demonstrates invoking a method and defining a method that receives two integer parameters.

// Invoke (call) the method
int number1 = 25;
int number2 = 47;
int sum = add(number1, number2);

// Method definition
public int add(int x, int y)
{
    return (x + y);
}

8. Demo Program for Methods

import java.io.*;
import BreezyGUI.*;

public class DisplayClass
{
    public static void main(String[] args)
    {
        System.out.println("Calling all methods!");
        asterisks();    // invoking method
        System.out.println("Great job, method!");
        asterisks();    // invoking method again
        System.out.println("We're outta here!");
    }

    // Method for asterisks
    public static void asterisks()
    {
        int count;
        for(count = 1; count <= 20; count++)
            System.out.print("*");
        System.out.println();
    }
}

Output

Calling all methods!
********************

Great job, method!
********************

We're outta here!

9. Pass-by-Value

The source explains that formal parameter names do not have to be the same as actual parameter names, but their data types must correspond.

With pass-by-value, when a method is called, a copy of the value of each argument is passed to the method. The copied value can be changed inside the method, but such a change has no effect on the original argument.

int number1 = 25;
int number2 = 47;

int sum = add(number1, number2);

public int add(int x, int y)
{
    return (x + y);
}

10. JVM Architecture

The source introduces JVM architecture in the context of how Java methods and classes are handled at runtime.

Main Components Shown in the Source Diagram

11. JVM Memory Areas

12. PC Registers

The PC Register keeps track of which instruction has been executed and which instruction is going to be executed.

13. Native Method Areas

14. Garbage Collection

The source explains that a class instance is explicitly created by Java code and, after use, is automatically destroyed by garbage collection for memory management.

15. Quick Revision