A Closer Look at Methods

and Classes

Deependra Rastogi
Assistant Professor
Galgotias University, Greater Noida
 Overloading Methods
In Java it is possible to define two or more methods within the same
class that share the same name, as long as their parameter
declarations are different. When this is the case, the methods are said
to be overloaded, and the process is referred to as method
overloading. Method overloading is one of the ways that Java supports
polymorphism.

When an overloaded method is invoked, Java uses the type and/or

number of arguments as its guide to determine which version of the
overloaded method to actually call. Thus, overloaded methods must
differ in the type and/or number of their parameters.

While overloaded methods may have different return types, the

return type alone is insufficient to distinguish two versions of a
method. When Java encounters a call to an overloaded method, it
simply executes the version of the method whose parameters match
the arguments used in the call.
 Overloading Methods
class OverloadDemo
{
void test()
{
System.out.println("No parameters");
}
void test(int a)
{
System.out.println("a: " + a);
}
void test(int a, int b)
{
System.out.println("a and b: " + a + " " + b);
}
double test(double a)
{
System.out.println("double a: " + a);
return a*a;
}
}
 Overloading Methods
class Overload
{
public static void main(String args[])
{
OverloadDemo ob = new OverloadDemo();
double result;

// call all versions of test()

ob.test();
ob.test(10);
ob.test(10, 20);
result = ob.test(123.25);
System.out.println("Result of ob.test(123.25): " + result);
}
}
 Overloading Methods
When an overloaded method is called, Java looks for a match between
the arguments used to call the method and the method’s parameters.
However, this match need not always be exact. In some cases, Java’s
automatic type conversions can play a role in overload resolution. For
example, consider the following program:

class OverloadDemo
{
void test()
{
System.out.println("No parameters");
}
void test(int a, int b)
{
System.out.println("a and b: " + a + " " + b);
}
void test(double a)
{
System.out.println("Inside test(double) a: " + a);
}
}
 Overloading Methods
class Overload
{
public static void main(String args[])
{
OverloadDemo ob = new OverloadDemo();
int i = 88;

ob.test();
ob.test(10, 20);

ob.test(i); // this will invoke test(double)

ob.test(123.2); // this will invoke test(double)
}
}
 A Closer Look at Argument Passing
In general, there are two ways that a computer language can pass an
argument to a subroutine.

The first way is call-by-value. This approach copies the value of an

argument into the formal parameter of the subroutine. Therefore,
changes made to the parameter of the subroutine have no effect on
the argument.

The second way an argument can be passed is call-by-reference. In

this approach, a reference to an argument (not the value of the
argument) is passed to the parameter. Inside the subroutine, this
reference is used to access the actual argument specified in the call.
This means that changes made to the parameter will affect the
argument used to call the subroutine.
 A Closer Look at Argument Passing
class Test
{
void meth(int i, int j)
{
i *= 2; j /= 2;
}
}
class CallByValue
{
public static void main(String args[])
{
Test ob = new Test();
int a = 15, b = 20;

System.out.println("a and b before call: " + a + " " + b);

ob.meth(a, b);
System.out.println("a and b after call: " + a + " " + b);
}
}
 A Closer Look at Argument Passing
class Test
{
int a, b;
Test(int i, int j)
{
a = i; b = j;
}
// pass an object
void meth(Test o)
{
o.a *= 2; o.b /= 2;
}
}
class CallByRef
{
public static void main(String args[])
{
Test ob = new Test(15, 20);
System.out.println("ob.a and ob.b before call: " +
ob.a + " " + ob.b);
 A Closer Look at Argument Passing
ob.meth(ob);

System.out.println("ob.a and ob.b after call: " +

ob.a + " " + ob.b);
}
}
 Introducing Access Control
Access level modifiers determine whether other classes can use a
particular field or invoke a particular method. There are two levels of
access control:

At the top level—public, or package-private (no explicit modifier).

At the member level—public, private, protected, or package-private (no
explicit modifier).

A class may be declared with the modifier public, in which case that class
is visible to all classes everywhere. If a class has no modifier (the default,
also known as package-private), it is visible only within its own package.
At the member level, you can also use the public modifier or no modifier
(package-private) just as with top-level classes, and with the same
meaning.

The private modifier specifies that the member can only be accessed in its

own class. The protected modifier specifies that the member can only be
accessed within its own package (as with package-private) and, in
addition, by a subclass of its class in another package.
 Introducing Access Control
The following table shows the access to members permitted by each
modifier.

Access Levels
Modifier Class Package Subclass World
public Y Y Y Y
protected Y Y Y N
no modifier Y Y N N
private Y N N N

The first data column indicates whether the class itself has access to the
member defined by the access level. As you can see, a class always has
access to its own members. The second column indicates whether classes
in the same package as the class (regardless of their parentage) have
access to the member. The third column indicates whether subclasses of
the class declared outside this package have access to the member. The
fourth column indicates whether all classes have access to the member.
 Introducing Access Control
Access levels affect you in two ways. First, when you use classes that
come from another source, such as the classes in the Java platform,
access levels determine which members of those classes your own classes
can use. Second, when you write a class, you need to decide what access
level every member variable and every method in your class should have.
Let's look at a collection of classes and see how access levels affect
visibility. The following figure shows the four classes in this example and
how they are related.
 Introducing Access Control
The following table shows where the members of the Alpha class are
visible for each of the access modifiers that can be applied to them.

Visibility
Modifier Alpha Beta Alphasub Gamma
public Y Y Y Y
protected Y Y Y N
no modifier Y Y N N
private Y N N N
 Introducing Access Control
/* This program demonstrates the difference between public and
private.*/

class Test
{
int a; // default access
public int b; // public access
private int c; // private access

// methods to access c
void setc(int i) // set c's value
{
c = i;
}
int getc()
{ // get c's value
return c;
}
}
 Introducing Access Control
class AccessTest
{
public static void main(String args[])
{
Test ob = new Test();

// These are OK, a and b may be accessed directly

ob.a = 10;
ob.b = 20;

// This is not OK and will cause an error

// ob.c = 100; // Error!

// You must access c through its methods

ob.setc(100); // OK
System.out.println("a, b, and c: " + ob.a + " " +
ob.b + " " + ob.getc());
}
}
 Understanding static
There will be times when you will want to define a class member that will
be used independently of any object of that class. Normally, a class
member must be accessed only in conjunction with an object of its class.
However, it is possible to create a member that can be used by itself,
without reference to a specific instance. To create such a member,
precede its declaration with the keyword static. When a member is
declared static, it can be accessed before any objects of its class are
created, and without reference to any object. You can declare both
methods and variables to be static. The most common example of a static
member is main( ). main( ) is declared as static because it must be called
before any objects exist.

Instance variables declared as static are, essentially, global variables.

When objects of its class are declared, no copy of a static variable is
made. Instead, all instances of the class share the same static variable.
 Understanding static
Methods declared as static have several restrictions:

They can only call other static methods.

They must only access static data.
They cannot refer to this or super in any way.

If you need to do computation in order to initialize your static variables,

you can declare a static block that gets executed exactly once, when the
class is first loaded. The following example shows a class that has a static
method, some static variables, and a static initialization block:
 Understanding static
// Demonstrate static variables, methods, and blocks.
class UseStatic
{
static int a = 3;
static int b;
static void meth(int x)
{
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);
}
static
{
System.out.println("Static block initialized.");
b = a * 4;
}
public static void main(String args[])
{
meth(42);
}
}
 Understanding static
Outside of the class in which they are defined, static methods and
variables can be used independently of any object. To do so, you need
only specify the name of their class followed by the dot operator. For
example, if you wish to call a static method from outside its class, you can
do so using the following general form:

classname.method( )

Here, classname is the name of the class in which the static method is
declared. As you can see, this format is similar to that used to call non-
static methods through object-reference variables. A static variable can be
accessed in the same way—by use of the dot operator on the name of the
class. This is how Java implements a controlled version of global methods
and global variables.
 Understanding static
class StaticDemo
{
static int a = 42;
static int b = 99;
static void callme()
{
System.out.println("a = " + a);
}
}
class StaticByName
{
public static void main(String args[])
{
StaticDemo.callme();
System.out.println("b = " + StaticDemo.b);
}
}