Methods tell us what a class can do.Developers can define their own methods and
Java Developers Kit has a variety of classes and each of them may contain
methods. Some methods require arguments - the incoming data that have to be
processed. For example, here is the code to convert a String value to a number
of the type of integer:
String testStr = "5000"; int test = Integer.parseInt(testStr);
It is said that the method parseInt() has one argument of type String.
The method parseInt() is defined in the Java class Integer. Programmers could
also define methods that take arguments, for example:
double calcTax(double grossIncome, String state,
int dependents){
// The code implementing business logic goes here
}
Arguments are used in the method body the same way as if they were declared
as local variables, but their values will be provided by the caller of the
method, for example:
double myTax = calcTax(45000.00, "NJ", 2);
The 45000.00, "NJ", and 2 are provided by the caller of the method calcTax().
Special Methods: Constructors
One of the most widely used ways of
creating an instance of a class is the operator new, for example:
Tax t = new Tax();
During the process of the class instantiation a special method called
constructor will be called automatically. In our example parentheses after the
word Tax mean that a constructor with no arguments will be called by the Java
Virtual Machine (JVM).
Constructors have the following characteristics:
- They are called only once when the class is being instantiated.
- They must have the same name as the class itself.
- They do not return a value and you do not have to specify the keyword void.
A class can have more than one constructor (see the section "Method
Overloading" below).
If you do not create a constructor for the class, Java helps you by using a
so called default no-argument constructor. That's why the Java compiler does not
complain about the statement new Tax(), even though we have not defined any
constructor for the class Tax.
Constructors are usually used to assign initial values to member variables of
the class, for example:
class Tax {
double grossIncome; // member variables
String state;
int dependents;
Tax (double gi, String st, int depen){
grossIncome = gi; // member variable initialization
state = st;
dependents=depen;
}
...
}
If a constructor with arguments has been defined in a class, you can no
longer use a default no-argument constructor - you have to write write one.
Besides the operator new, you can create an instance of the class by loading
the class first and then calling the method newInstance() which will also
executes constructor's code:
Class.forName("Tax").newInstance();
The Keyword this
The keyword this is useful when you need to refer to an
instance of the class from its method. Let's consider an example:
class Tax {
double grossIncome;
Tax(double grossIncome){
this.grossIncome = grossIncome;
}
}
The keyword this helps avoid name conflicts, for example this.grossIncome
refers to a member variable grossIncome, while the grossIncome on the right
refers to the argument's value.
Let's look at another example - say you have some class with a method
verifyTax( Tax t) that needs an instance of class Tax as an argument. This is
how you can call it from the class Tax:
class Tax {
void myMethod(){
...
SomeOtherClass s = new SomeOtherClass();
s.verifyTax(this);
}
}
Method Overloading
If a class has more than one method with the same
name, but with different argument lists, it's called method overloading. For
example, the method print() could be called with different types of arguments.
Actually there are multiple overloaded versions of the method print(), it's just
easier to remember one method print(), than printString(), printInt(), etc.
Constructors also can be overloaded.
The next version of our class Tax will have two overloaded constructors: one
with 3 arguments (income, state and dependents), and another one with 2 (income
and state). If the 2-argument constructor will be used when the class is
instantiated, the default value of 1 dependent is assumed.
class Tax {
double grossIncome;
String state;
int dependents;
Tax (double gi, String st, int depen){
grossIncome = gi;
state = st;
dependents=depen;
}
Tax (double gi, String st){
grossIncome = gi;
state = st;
dependents=1; // Default value
}
...
}
Only one constructor will be used when a class is instantiated, based on the
provided argument list. The example below uses the 3-arguments constructor:
Tax t = new Tax( 50000.00, "NJ", 2);
The following example uses 2-argument constructor:
Tax t = new Tax( 50000.00, "NJ");
The keyword super
The keyword super is used to refer to the superclass
of an object, for example it could be used to call a constructor of the
superclass:
class NJTax extends Tax{
NJTax(double income, String state){
super(income, state, 1);
...
}
}
The keyword super could also be used to call any method in the superclass.
You do not usually use it, because methods of the superclass are available just
by specifying their names. Having an overridden method could come in handy - one
in the current class and the other one in the superclass. If for any reason you
want to call a particular method from a superclass, even though there is a
method with the same signature in the subclass, do it as follows:
super.myMethod();
Access Levels
Java classes, methods and member variables could have
public, private, protected and package access levels, for example:
public class Tax {
private double grossIncome;
private String state;
private int dependents;
protected double calcTax(…) {…}
}
The keyword public means that this element (class, method or a variable)
could be accessed from any other Java class.
The keyword protected makes the element "visible" either from the current
class, or from it's subclasses.
The keyword private is the most restrictive one and makes the member variable
or a method available only within the current class. For example, our class Tax
may need some additional internal method that could be called from the method
calcTax(). Descendents of the class Tax do not need to know about it and this
method should be declared as private.
If you do not specify any access level, a default (package) access level is
used.
One of the main features of object-oriented languages is encapsulation, which
is an ability to hide and protect its elements. The classes should expose to
their possible users only the necessary methods, i.e. alcTax(). The methods that
the class Tax exposes to its prospective clients could be called Application
Program Interface (API).
Do you really know what exactly happens under the hood when you start you
car's engine? Do you really want to know? That ignition key slot and the "Check
oil" signal are example of your car's API.
If you are not sure which access level to give to methods or variables, just
make them all private. If at the later development stage another class needs to
access them, you can always change it, but this is a simple way to protect all
the internal of your application from misuse. Think of it this way: "I want to
sell my class Tax to various accounting firms across the country. If software
developers of these firms will incorporate this class into existing systems -
what's the minimum number of methods that they must know about to be able to
calculate a tax"? If car designers would not ask themselves a similar question,
you'd need to press hundreds of buttons just to start the engine.
Subscribe to JAVA Developer's Journal Email News Alerts
Subscribe via RSS
