Methods, Arguments, Static Members and Overloading (ISC Class 12 Computer Science)

Understand Methods, Arguments, Static Members and Method Overloading

Methods, Arguments, Static Members and Method Overloading: key facts

Argument passing

• •Primitive: the value is copied, caller unchanged
• •Object or array: the reference is copied, contents can change
• •Reassigning the parameter never changes the caller

Java passes everything by value.

static versus instance

static variable	one copy for the class
Instance variable	one copy per object
static method	no this, call by ClassName.method()

A static method cannot use instance variables directly.

Overloading rules

• •Same name
• •Different number or types of parameters
• •Return type alone is not enough
• •Chosen at compile time

area(int), area(int, int), area(double) are valid overloads.

Method header

• •returnType name(type param, ...)
• •void returns nothing
• •return ends the method
• •Formal parameters get copies of the actual arguments

Match the number, order and type of arguments.

How to answer Methods, Arguments, Static Members and Method Overloading questions

1. 1Mark which arguments are primitives and which are objects or arrays.
2. 2For each call, copy the actual values into the formal parameters.
3. 3Execute the body: changes to a primitive parameter stay local; changes through a reference reach the shared object.
4. 4Track static variables in one shared cell and instance variables per object.
5. 5For overloaded calls, match the number and types of actual arguments to the signature.
6. 6Print the caller's variables after the call to see what really changed.

Methods, Arguments, Static Members and Method Overloading 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 Methods, Arguments, Static Members and Method Overloading

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

• Formal is form, actual is act

  Formal parameters sit in the method definition (form); actual arguments are what the caller actually sends.

  Use it when: Terminology marks.

• Copy of a reference

  The method gets a copy of the key, not a new room: it can change the room but not give you a new key.

  Use it when: Object argument questions.

• static = class-wide

  One copy for the class, called with the class name.

  Use it when: Static variable and method questions.

• Overload by arguments

  Same name, different arguments; the return type does not count.

  Use it when: Method overloading questions.

Methods, Arguments, Static Members and Method Overloading: solved examples

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

static void change(int a, int[] arr) {
    a = a + 10;
    arr[0] = arr[0] + 10;
}
// in main
int x = 5;
int[] y = {5};
change(x, y);
System.out.println(x + " " + y[0]);

class Counter {
    static int total = 0;
    int id;
    Counter() { total++; id = total; }
}
// in main
Counter a = new Counter();
Counter b = new Counter();
Counter c = new Counter();
System.out.println(a.id + " " + c.id + " " + Counter.total);

static void move(Pt p)   { p.x += 5; }
static void reset(Pt p)  { p = new Pt(0); }
static void swap(int a, int b) { int t = a; a = b; b = t; }

Where students lose marks in Methods, Arguments, Static Members and Method Overloading

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

• ✗Mistake: Expecting a primitive argument to change in the caller

  The method works on a copy of the value.

  Wrong working

  After change(x) with a = a + 10, x becomes 15

  Right working

  x stays unchanged

  ✓Do this: Return the new value and assign it in the caller.

  Usually costs: 1 mark

• ✗Mistake: Using an instance variable in a static method

  A static method has no this and cannot see instance fields directly.

  Wrong working

  static int get() { return id; }

  Right working

  int get() { return id; }

  ✓Do this: Make the method non-static or pass an object.

  Usually costs: 1 mark

• ✗Mistake: Overloading by return type only

  The compiler cannot choose between two methods with identical parameters.

  Wrong working

  int f(int a) and double f(int a)

  Right working

  int f(int a) and double f(double a)

  ✓Do this: Change the number or types of parameters.

  Usually costs: 1 mark

Practice questions on Methods, Arguments, Static Members and Method Overloading

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

   The keyword that refers to the current object inside an instance method is
   (a) super (b) static (c) this (d) final

   Hint

   It names the object that received the call.

   Answer

   (c) this

2. Q2 · 2 marks · Short answerBoard level

   Distinguish between formal and actual arguments with an example.

   Hint

   Definition versus call.

   Answer

   In static int sq(int n) { return n * n; } the parameter n is the formal argument. In the call sq(7) the value 7 is the actual argument, and n receives a copy of 7.

3. Q3 · 4 marks · Short answerHarder board level

   Write a method int hcf(int a, int b) using the Euclidean algorithm with a loop and trace it for hcf(12, 18).

   Hint

   Replace (a, b) by (b, a % b) until b is 0.

   Answer

   static int hcf(int a, int b) {
       while (b != 0) {
           int t = b;
           b = a % b;
           a = t;
       }
       return a;
   }

   Trace for (12, 18): t = 18, b = 12 % 18 = 12, a = 18; then t = 12, b = 18 % 12 = 6, a = 12; then t = 6, b = 12 % 6 = 0, a = 6. b is 0, so it returns 6.

4. Q4 · 3 marks · Short answerHarder board level

   Write the output:

   class Demo {
       static int s = 0;
       int i = 0;
       void inc() { s++; i++; }
   }
   // in main
   Demo p = new Demo(), q = new Demo();
   p.inc(); p.inc(); q.inc();
   System.out.println(p.i + " " + q.i + " " + Demo.s);

   Hint

   One variable is shared, the other is per object.

   Answer

   p.inc() is called twice, so p.i = 2; q.inc() once, so q.i = 1. The shared s is incremented three times: 3. Output: 2 1 3

5. Q5 · 4 marks · Case-basedHOTS / competency

   A method static void swap(int a, int b) exchanges its parameters. With x = 3 and y = 8, main calls swap(x, y) and prints x and y. (i) State the output and the reason. (ii) Write a method that works, using an int array {3, 8}, and give the output.

   Hint

   The array reference lets the method change shared data.

   Answer

   (i) 3 8: the method swaps copies of the values, so x and y are unchanged. (ii)

   static void swap(int[] v) {
       int t = v[0];
       v[0] = v[1];
       v[1] = t;
   }

   With int[] v = {3, 8}; swap(v); the array holds 8 and 3, so printing v[0] and v[1] gives 8 3.

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 the arguments in a method call called?Show answer

   Actual arguments.

2. 2.What does a method receive when an array is passed?Show answer

   A copy of the reference to the same array.

3. 3.How is a static method called?Show answer

   ClassName.methodName(arguments), without an object.

4. 4.What is method overloading?Show answer

   Methods with the same name but different parameter lists.

5. 5.Can a static method use this?Show answer

   No.

6. 6.What does void mean in a method header?Show answer

   The method returns no value.

Methods, Arguments, Static Members and Method Overloading: frequently asked questions