User-defined Methods: Parameters, Return Values and Call by Value (ICSE Class 10 Java)

Understand Calling Methods, Parameters, Call by Value and Pure/Impure Methods

accessSpecifier [static] returnType name(type formal1, type formal2) {
    body
    return value;   // omitted when returnType is void
}

Calling Methods, Parameters, Call by Value and Pure/Impure Methods: key facts

Method parts

• •Header: specifier, return type, name, formal parameters
• •Body
• •return statement
• •void: no return value

The prototype/signature is the name with parameter types.

Actual vs formal parameters

• •Actual: in the call, values passed
• •Formal: in the header, receive the values
• •Match in number, order and type

Names can differ.

Call by value

• •Formal parameter is a copy
• •Change inside does not affect the caller
• •Used for primitive arguments

A swap method on two ints will not swap the caller's variables.

Pure vs impure

Pure: returns a value, changes nothing | Impure: changes an object or a data member

An impure method may be void.

How to answer Calling Methods, Parameters, Call by Value and Pure/Impure Methods questions

1. 1Start from main; note the values of its variables.
2. 2At each call, copy the values of the actual parameters into the formal parameters.
3. 3Execute the method body with its own variables and stop at return or at the end.
4. 4Bring the returned value (if any) back to the place of the call and use it in the expression.
5. 5Update the caller's variables only for returned values or for objects changed in the method; primitive arguments never change.

Calling Methods, Parameters, Call by Value and Pure/Impure Methods in real life

The idea, met in an everyday situation. Answer the question in your own words, then compare with the model answer. The one-line hook is what to remember.

Tricks to remember Calling Methods, Parameters, Call by Value and Pure/Impure Methods

Short memory aids. Say each one aloud once, then use it on a question the same day.

• Actual = Arrives, Formal = Form

  Actual values arrive at the call; formal parameters are the form (slots) in the header.

  Use it when: Actual vs formal.

• Void has no return

  void = empty hands; any other type must return something.

  Use it when: Header questions.

• Primitives are photocopies

  Primitive arguments are copied; objects are shared.

  Use it when: Call by value vs reference.

Calling Methods, Parameters, Call by Value and Pure/Impure Methods: solved examples

Ordered from board level to HOTS. Try each one before you open the solution.

static int add(int x, int y) {
    return x + y;
}
// call in main:
int r = add(a, 5);

public class Test {
    static void change(int n) {
        n = n * 2;
        System.out.println(n);
    }
    public static void main(String[] args) {
        int a = 5;
        change(a);
        System.out.println(a);
    }
}

class Acct {
    int bal = 100;
    int show() { return bal + 10; }
    void dep(int x) { bal += x; }
}
public class Test {
    public static void main(String[] args) {
        Acct a = new Acct();
        System.out.println(a.show());
        a.dep(50);
        System.out.println(a.show() + " " + a.bal);
    }
}

public class Calc {
    static int sq(int n) { return n * n; }
    static int sumSq(int a, int b) { return sq(a) + sq(b); }
    static void show(String s, int v) {
        System.out.println(s + " = " + v);
    }
    public static void main(String[] args) {
        int r = sumSq(3, 4);
        show("Total", r);
        show("Next", sq(r));
    }
}

class Num {
    int v;
}
public class Test {
    static void inc(Num p) {
        p.v += 10;
    }
    public static void main(String[] args) {
        Num n = new Num();
        n.v = 5;
        inc(n);
        System.out.println(n.v);
    }
}

Where students lose marks in Calling Methods, Parameters, Call by Value and Pure/Impure Methods

The slips examiners see most often, and what to write instead.

• ✗Mistake: Saying a primitive argument changes in the caller

  Call by value copies the value; the caller's variable is untouched.

  Wrong working

  After change(a), a = 10

  Right working

  After change(a), a is still 5

  ✓Do this: Print the caller's variable from main separately.

  Usually costs: 1 mark

• ✗Mistake: Writing the data type in the call

  Types appear only in the method header, not in the call.

  Wrong working

  r = add(int a, int b);

  Right working

  r = add(a, b);

  ✓Do this: Write only the values or variable names in a call.

  Usually costs: 1 mark

• ✗Mistake: Missing return in a non-void method

  A method with a return type must return a value of that type.

  Wrong working

  int sq(int n) { int r = n * n; }

  Right working

  int sq(int n) { int r = n * n; return r; }

  ✓Do this: Check each path returns.

  Usually costs: 1 mark

Practice questions on Calling Methods, Parameters, Call by Value and Pure/Impure Methods

Write each answer on paper first. Open the hint only if you are stuck, and the answer only when you have finished.

1. Q1 · 1 mark · MCQBoard level

   A method that does not return any value has the return type:
   (a) int (b) null (c) void (d) static

   Hint

   Empty hands.

   Answer

   (c) void

2. Q2 · 1 mark · Very short answerBoard level

   Where do formal parameters appear: in the method call or in the method header?

   Hint

   They receive the values.

   Answer

   In the method header (definition).

3. Q3 · 2 marks · Short answerHarder board level

   Write the output:

   static int twice(int x) {
       x = x * 2;
       return x;
   }
   // in main
   int n = 4;
   int m = twice(n);
   System.out.println(n + " " + m);

   Hint

   Which variable does the method change?

   Answer

   4 8 (n is unchanged; the returned value 8 is stored in m)

4. Q4 · 3 marks · Short answerHarder board level

   Write a static method isEven(int n) that returns true if n is even and false otherwise. What does System.out.println(isEven(7)); display?

   Hint

   Use the remainder.

   Answer

   static boolean isEven(int n) {
   return n % 2 == 0;
   }
   isEven(7): 7 % 2 is 1, so the method returns false and false is displayed.

5. Q5 · 1 mark · Assertion-reasonHOTS / competency

   Assertion (A): A method that swaps its two int parameters does not swap the variables used in the call.
   Reason (R): Primitive arguments are passed by value, so the method works on copies.
   (a) Both A and R are true and R is the correct explanation of A. (b) Both A and R are true but R is not the correct explanation of A. (c) A is true but R is false. (d) A is false but R is true.

   Hint

   What does the method receive?

   Answer

   (a) Both are true and R explains A.

Test your recall

Answer in your head or on paper first, then open the card. Pulling an answer out of memory makes it stick far better than re-reading.

1. 1.What are actual parameters?Show answer

   The values or variables written in the method call.

2. 2.What does a pure method do?Show answer

   Returns a value without changing any data member or argument.

3. 3.What is call by value?Show answer

   Passing a copy of the value, so the caller's variable is not changed.

4. 4.Can a static method be called without an object?Show answer

   Yes, by its name or ClassName.method().

5. 5.What is a method signature?Show answer

   The method name with the types of its parameters.

6. 6.What does return do?Show answer

   Ends the method and sends a value back to the caller.

Calling Methods, Parameters, Call by Value and Pure/Impure Methods: frequently asked questions