Methods

Question 1

What are methods used for?

Answer 1

Methods make it easier to modularize and make code reusable.

Question 2

What values can methods return?

Answer 2

Methods can return any value-type, or none at all. If nothing is returned, the returnvaluetype keyword must be “void”

Question 3

What does it mean that a method can be overloaded?

Answer 3

It means that two methods can have the same name, as long as their parameter list differ

Question 4

What is method abstraction?

Answer 4

The act of putting code into methods. The method can be used without knowing how it is implemented. The implementation details are hidden inside the method. This is known as information hiding

Question 5

Why is method abstraction a good thing?

Answer 5

Because it modularizes programs in a neat, hierarchical manner. Programs written as collections of concise methods are easier to write, debug, maintain, and modify than would otherwise be the case

Question 6

The signature of a method consists of __

Answer 6

Method name and parameter(s)

Question 7

Each time a method is invoked, the system stores parameters and local variables in an area of memory, known as __, which stores elements in last-in first-out fashion

Answer 7

A stack

Question 8

A variable inside a method is referred to as __

Answer 8

A local variable

Question 9

To execute a method you need__

A. method name
B. method name and arguments/parameters
C. return type, method name, and arguments/parameters
D. arguments/parameters

Answer 9

B. method name and arguments/parameters

Question 10

Does the return statement in the following method cause compile errors?

public static void main(String[] args) {
int max = 0;
if (max != 0)
System.out.println(max);
else
return;
}

Answer 10

No.

Question 11

Analyze the following code:

class Test {
public static void main(String[] args) {
System.out.println(xmethod(5));
}

public static int xmethod(int n, long t) {
System.out.println(“int”);
return n;
}

public static long xmethod(long n) {
System.out.println(“long”);
return n;
}
}

A. The program displays int followed by 5.
B. The program displays long followed by 5.
C. The program runs fine but displays things other than 5.
D. The program does not compile because the compiler cannot distinguish which xmethod to invoke.

Answer 11

B. The program displays long followed by 5.

Question 12

Analyze the following code.

public class Test {
public static void main(String[] args) {
System.out.println(max(1, 2));
}

public static double max(int num1, double num2) {
System.out.println(“max(int, double) is invoked”);

if (num1 > num2)
  return num1;
else
  return num2;   }

public static double max(double num1, int num2) {
System.out.println(“max(double, int) is invoked”);

if (num1 > num2)
  return num1;
else
  return num2;   } }

A. The program cannot compile because you cannot have the print statement in a non-void method.
B. The program cannot compile because the compiler cannot determine which max method should be invoked.
C. The program runs and prints 2 followed by “max(int, double)” is invoked.
D. The program runs and prints 2 followed by “max(double, int)” is invoked.
E. The program runs and prints “max(int, double) is invoked” followed by 2.

Answer 12

B. The program cannot compile because the compiler cannot determine which max method should be invoked.

Question 13

what are the 4 parts required for creating/defining a method?

Answer 13

returnType - data type or void
methodName - camel case
methodParams - input data types and names - can be blank
Curly Brackets -

Question 14

what 2 things does a return statement do?

Answer 14

returns the value
stops the running of the method

Question 15

do void methods need to return a value?

Answer 15

No

Question 16

What are the method naming restrictions?

Answer 16

Can contain letters, digits, underscores, but cannot contain whitespace
Cannot start with a digit
Cannot be a Java reserved keyword (i.e.: return)
Are case sensitive (“thisMethod” and “thismethod” are two different methods)

Question 17

what are 2 common naming conventions for methods?

Answer 17

The first word is usually a verb or action followed by a noun or adjective
Camel case

Question 18

Java only supports what type of arguments?

Answer 18

Java only supports input arguments.

Question 19

When a reference is passed in as an argument to a method is the argument returned when the method ends?

Answer 19

No, when a reference is passed in as an argument, a copy is made and the copy is deleted when the method ends.

Question 20

When a reference is passed in as an argument to a method and changes are made to the argument will they be reflected in the original variable? Why?

Answer 20

The changes will be reflected in the original variable because the argument points to the original object.

Question 21

What is the @Override annotation and why can it be useful?

Answer 21

The @Override annotation indicates that the child class method is over-writing its base class method. It can be useful for two reasons. It extracts a warning from the compiler if the annotated method doesn’t actually override anything. It can improve the readability of the source code.

Question 22

what are the variables defined in a method signature called?

Answer 22

Parameters are variables that are defined in the method signature and are used to accept input values from the caller. So the parameters are the variables defined in the method signature, and the arguments are the values passed in when the method is called.

Question 23

what are the values passed into a method called?

Answer 23

When the method is called, the actual values that are passed in are called arguments. So the parameters are the variables defined in the method signature, and the arguments are the values passed in when the method is called.

Question 24

Is java a pass by reference or value language?

Answer 24

Java is a “pass-by-value” language, which means that when passing arguments to a method, a copy of the argument is passed to the method. However, when the argument is an object or an array, the copy is actually a reference to the original object or array. This means that changes made to the object or array inside the method will affect the original object or array outside the method. In this sense, it may seem like Java is pass-by-reference for objects and arrays, but it’s actually pass-by-value for the reference to the object or array.