(i)
Call by value: A method is called by passing primitive values. Copies of values are passed to method definition. Process are done with these copies and changes that taken place reflect in the copy only and original data remain unchanged.
(ii)
(1) Call by value
(2) Call by reference

(c) An impure function is a function that modifies the state of the received object.
E.g.:
public static void increment(A x)
{
x.a=x.a+10;
}
Here A is a class, x is its object and a is its data member.

(a) A private method is accessible only within the same class. Even methods of sub classes do not have access.

The return statement is a jump statement which is used to jump the execution from a method to its method call statement.

The arguments that resides in function prototype with data type which receives values from function call is the Formal Parameter and the arguments which resides in function call without data type which passes values to Formal Parameter is the Actual Parameter.
area(l,b) → l and b is the Actual Parameter
public static void area(int l, int b) → int l, int b is the Formal Parameter

(e) (i) The void keyword declares that the function definition does not return a value.
(ii) Only one will be executed.
(iii) Polymorphism.

Instance variables are the variables declared for objects that are declared in class level without static keyword. Each object gets separate copy of these variables. In the following example double l, b are instance variables.
public class Rectangle
{
double l,b; //instance variables
}

public : When we use public with a class and method then the class and method can be accessed by any other method in any class in any package.
protected : When we use protected with a method then these are accessible by methods of same package classes and any sub classes that are in other packages.

The actual parameter is the arguments which reside in a function call (without data type).
E.g.: l,b in area(l,b).
The formal parameter is the arguments which reside in a function prototype (with data type).
E.g.: int l, int b in public void area(int l, int b).

public static float sum(int x)

(ii) return

A pure function is the one that takes objects or primitives as arguments but does not modify the values of passing arguments.
An impure function is the one that modifies state of the received object.

The number of arguments and data type of arguments makes the functions different when the function names are same.

1) Reduce complexity (simplification): By dividing complex problems into smaller units we can solve them easily.
2) Re-use: We can re-use the functions whenever and wherever we need it and as many time we require it.

The static data members are variables declared in class level with static keyword. There is only one memory location possible for a static data member. All objects have to share this single copy of memory.
The non-static data members are variables declared in class level without static keyword. For a non-static data member multiple copies can be created. Each object gets a separate copy of this data member.

A function or data member with private visibility modifier can be accessed only by the members of the same class. The members of the other classes cannot access them.
A class or a function or a data member with protected visibility modifier can be accessed only by the members of the same class or members of sub classes in the same package or other packages. The classes which are not sub classes cannot access a protected class or member function or data member.

public static boolean check(char ch, int n)

Call by value and call by reference are the two ways of invoking functions.
Examples:
i) swap(a,b); where a and b are primitive values.
ii) swap(ob); where ob is an object.

If a function does not return a value then the function should be void.
Example:
public void area(int x,int y)
{
System.out.println(x*y);
}

public static int search(String sentnc, String wrd)

(ii) static

When a method is invoked by a method call by passing primitive values then it is call by value.
When a method is invoked by a method call by passing reference values like objects then it is call by reference.
In call by value copies of values are passed to method definition. Process is done with these copies and changes happen only on these copies and the original data remain unchanged.
In call by reference, reference of object or array is passed to method definition and process is done with this reference value and the change that happens is reflected in the original data.

(d) (i) void

(i)
(i) int a, b
(ii) static int x,y

50, 30

publicprivate

Formal parameter is the parameter that resides in function prototype.
E.g.: The double r in area(double r)
Actual parameter is the parameter that resides in function call.
E.g.: The r in area(r);

public static int PosChar(String x, char y)

1) public
2) protected

1) Call by value,
2) Call by reference

Private members of a class can be accessed by the members of the same class only.
E.g.: private int a; This varibale can be accessed by a method of the same class only.
Public members of a class can be accessed by the members of all class in any package.
E.g.: public int a; This varibale can be accessed by any method of any class in any package.

public static char check(int x)

(i) void
(ii) static

(i)
(1) When a method is called by passing primitive values then it is call by value. When a method is called by passing reference values like objects then it is known as call by reference.
(2) In call by value copies of values are passed to method definition and these copies are received by formal parameters. Process are done with these copies and any change that takes place reflects in the copy only and original data remain unchanged.