Home arrow Java arrow Page 4 - A Closer Look at Methods and Classes

A Closer Look at Methods and Classes

Have you ever wanted to get an in-depth understanding of methods and classes in Java? Look no further. This article is excerpted from chapter 7 of Java: the Complete Reference, J2SE 5 Edition, written by Herbert Schildt (McGraw-Hill/Osborne, 2004; ISBN: 0072230738). 

Author Info:
By: McGraw-Hill/Osborne
Rating: 4 stars4 stars4 stars4 stars4 stars / 22
June 30, 2005
  1. · A Closer Look at Methods and Classes
  2. · Overloading Constructors
  3. · Using Objects as Parameters
  4. · A Closer Look at Argument Passing
  5. · Returning Objects
  6. · Recursion
  7. · Introducing Access Control
  8. · Understanding static
  9. · Introducing final
  10. · Introducing Nested and Inner Classes
  11. · Exploring the String Class
  12. · Using Command-Line Arguments

print this article

A Closer Look at Methods and Classes - A Closer Look at Argument Passing
(Page 4 of 12 )

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 method 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 method, 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. As you will see, Java uses both approaches, depending upon what is passed.

In Java, when you pass a simple type to a method, it is passed by value. Thus, what occurs to the parameter that receives the argument has no effect outside the method. For example, consider the following program:

// Simple types are passed by value.
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);

The output from this program is shown here:

a and b before call: 15 20
a and b after call: 15 20

As you can see, the operations that occur inside meth( ) have no effect on the values of a and b used in the call; their values here did not change to 30 and 10.

When you pass an object to a method, the situation changes dramatically, because objects are passed by reference. Keep in mind that when you create a variable of a class type, you are only creating a reference to an object. Thus, when you pass this reference to a method, the parameter that receives it will refer to the same object as that referred to by the argument. This effectively means that objects are passed to methods by use of call-by-reference. Changes to the object inside the method do affect the object used as an argument. For example, consider the following program:

// Objects are passed by reference.
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);
System.out.println("ob.a and ob.b after call: " +
                       ob.a + " " + ob.b);

This program generates the following output:

ob.a and ob.b before call: 15 20
ob.a and ob.b after call: 30 10

As you can see, in this case, the actions inside meth( ) have affected the object used as an argument.

As a point of interest, when an object reference is passed to a method, the reference itself is passed by use of call-by-value. However, since the value being passed refers to an object, the copy of that value will still refer to the same object that its corresponding argument does.

Remember  When a simple type is passed to a method, it is 
                  done by use of call-by-value. Objects are passed  
                  by use of call-by-reference.

blog comments powered by Disqus

- Java Too Insecure, Says Microsoft Researcher
- Google Beats Oracle in Java Ruling
- Deploying Multiple Java Applets as One
- Deploying Java Applets
- Understanding Deployment Frameworks
- Database Programming in Java Using JDBC
- Extension Interfaces and SAX
- Entities, Handlers and SAX
- Advanced SAX
- Conversions and Java Print Streams
- Formatters and Java Print Streams
- Java Print Streams
- Wildcards, Arrays, and Generics in Java
- Wildcards and Generic Methods in Java
- Finishing the Project: Java Web Development ...

Watch our Tech Videos 
Dev Articles Forums 
 RSS  Articles
 RSS  Forums
 RSS  All Feeds
Write For Us 
Weekly Newsletter
Developer Updates  
Free Website Content 
Contact Us 
Site Map 
Privacy Policy 

Developer Shed Affiliates


© 2003-2019 by Developer Shed. All rights reserved. DS Cluster - Follow our Sitemap
Popular Web Development Topics
All Web Development Tutorials