Instance methods

An interesting fact about the class definition

How we got this far:

The class BankAccount was designed to hold the instance variables containing all information about bank account
Later, when we write method that perform operations on BankAccount typed variables, we found that it's more appropriate to put these method inside the BankAccount class

Consider the BankAccount class more carefully:

public class BankAccount { public int accNum; // These variables store information public String name; // about "BankAccounts" public double balance; /* ============================================== convToString(x): return a String containing information of BankAccount x ============================================== */ public static String convToString( BankAccount x ) { return( "Account number: " + x.accNum + ", Name: " + x.name + ", Balance: " + x.balance); } /* ============================================== deposit(x, amount): Add "amount" to x.balance ============================================== */ public static void deposit( BankAccount x, double amount ) { x.balance += amount; } /* ====================================================== withdraw(x, amount): Subtract "amount" from x.balance ====================================================== */ public static void withdraw( BankAccount x, double amount ) { if ( x.balance >= amount ) x.balance -= amount; // Subtract "amount" from x.balance } }

Notice that:

All of the methods convToString(), deposit() and withdraw():
All of the methods convToString(), deposit() and withdraw():
All of the methods convToString(), deposit() and withdraw() are:

Furthermore, if in the future you would write another (new) method that perform some useful operation on a BankAccount typed variable, it would:

have a BankAccount typed parameter variable
do something with/to the BankAccount typed parameter variable
be contained inside the class named BankAccount

Conclusion:

The BankAccount class is ideally suited to contain/store:
(that's basically everything --- remember that program = data + algorithm)

Introducing a new notation to invoke a method

Consider the way we invoke the methods that operates on a BankAccount variable in the previous example:

public class Class05 { public static void main(String[] args) { BankAccount stu1; stu1 = new BankAccount(); // Create one BankAccount object with // 3 data fields: // stu1.studID, stu1.name, stu1.major stu1.accNum = 12345; stu1.name = "Mary"; stu1.balance = 1000.0; String x; x = BankAccount.convToString( stu1 ); System.out.println("BankAccount 1: " + x); BankAccount.deposit( stu1, 450 ); x = BankAccount.convToString( stu1 ); System.out.println("After depsoiting $450: " + x); BankAccount.withdraw( stu1, 100 ); x = BankAccount.convToString( stu1 ); System.out.println("After withdraw $100: " + x); } }

New notation to invoke a method:

To make it emphatically clear that the methods convToString, deposit and withdraw are operations applied to the parameter variable stu1, Java introduces the following method invocation notation:

Notice this is a new form of syntax

We must also introduce a new way (syntax) to define methods that use the new invocation syntax !!!

Change in way to define the method:

In order to tell the Java compiler that a method will use the above form of method invocation syntax, the method definitions for these type of methods must be changed to indicate that the method will use this special format

The syntax to tell Java that a method is invoked using the new method invocation format is as follows:

***** Caveat: this is not complete correct (yet) **** public class BankAccount { public int accNum; // These variables are used to public String name; // store information on public double balance; // "BankAccounts" /* ============================================== convToString(): return a String containing information of BankAccount ============================================== */ public ~~static~~ String (BankAccount this.)convToString( ) { return( "Account number: " + this.accNum + ", Name: " + this.name + ", Balance: " + this.balance); } /* ============================================== deposit(amount): Add "amount" to balance ============================================== */ public ~~static~~ void (BankAccount this.)deposit( double amount ) { this.balance += amount; } /* ====================================================== withdraw(amount): Subtract "amount" from balance ====================================================== */ public ~~static~~ void (BankAccount this.)withdraw( double amount ) { if ( this.balance >= amount ) this.balance -= amount; // Subtract "amount" from balance } }

In other words:

We have omitted the keyword static when you want to use the special format (stu1.methodCall(parameters))
We have moved the BankAccount parameter variable outside of the method definition
(Also, the name of the BankAccount parameter variable was by the keyword this so that all methods will use this special parameter)

We have the situation where:

Every method that is defined without the use of the keyword static will have the special parameter this...
The next logical step is to simplify the notation and omit the special parameter this (because it's there all the time anyway).

The final form:

public class BankAccount { public int accNum; // These variables are used to public String name; // store information on public double balance; // "BankAccounts" /* ============================================== convToString(): return a String containing information of BankAccount ============================================== */ public String convToString( ) { return( "Account number: " + this.accNum + ", Name: " + this.name + ", Balance: " + this.balance); } /* ============================================== deposit(amount): Add "amount" to balance ============================================== */ public void deposit( double amount ) { this.balance += amount; } /* ====================================================== withdraw(amount): Subtract "amount" from balance ====================================================== */ public void withdraw( double amount ) { if ( this.balance >= amount ) this.balance -= amount; // Subtract "amount" from balance } }

Important note:

The type of the variable this is not specified in the program !!!
The Java compiler always assume that the type of the variable this is:
So in the example above, the type of the variable this is:

A main() method that uses the new method invocation format:

public class Class06 { public static void main(String[] args) { BankAccount stu1; stu1 = new BankAccount(); // Create one BankAccount object with // 3 data fields: // stu1.studID, stu1.name, stu1.major stu1.accNum = 12345; stu1.name = "Mary"; stu1.balance = 1000.0; String x; x = stu1.convToString( ); System.out.println("stu1: " + x); stu1.deposit( 450 ); x = stu1.convToString( ); System.out.println("After depsoiting $450: " + x); stu1.withdraw( 100 ); x = stu1.convToString( ); System.out.println("After withdraw $100: " + x); } }

Output: (the same as the previous program - ofcourse, only changes made are how to write it...)

stu1: Account number: 12345, Name: Mary, Balance: 1000.0 After depsoiting $450: Account number: 12345, Name: Mary, Balance: 1450.0 After withdraw $100: Account number: 12345, Name: Mary, Balance: 1350.0

Example Program: (Demo above code)
- The new BankAccount.java Prog file: click here
- The Class06.java Prog file: click here
How to run the program:

Nomenclature (terminology)

We have now seen 2 kinds of methods that can be defined inside a class:

Methods defined with the keyword static

This kind of method is called a class method

They are invoked using the format:

ClassName.MethodName( parameters )

(You can remember this syntax as: "A class method is invoked using a class name"

Methods defined without the keyword static

This kind of method is called an instance method
They are invoked using the (new) format:
The variable VariableName is passed to the method is called an instance variable (because the method operates on this instance)
(You can remember this syntax as: "A instance method is invoked using a instance variable"

Further simplification: making the use of "this" optional

The Java compiler makes the following assumption when it finds a variable name:

A variable name used inside a method:

that matches the name of a local/parameter variable refers to the local/parameter variable
Otherwise:
- it refers to a class variable (= a variable defined outside any method using the keyword static)
- or it refers to an instance variable (= a variable defined outside any method without using the keyword static) of the this instance

Example:

public class BankAccount { public int accNum; // These variables are used to public String name // store information on public double balance; // "BankAccounts" /* ============================================== convToString(): return a String containing information of BankAccount ============================================== */ public String convToString( ) { return( "Account number: " + accNum + ", Name: " + name + ", Balance: " + balance); } /* ============================================== deposit(amount): Add "amount" to balance ============================================== */ public void deposit( double amount ) { balance += amount; } /* ====================================================== withdraw(amount): Subtract "amount" from balance ====================================================== */ public void withdraw( double amount ) { if ( balance >= amount ) balance -= amount; // Subtract "amount" from balance } }

Explanation:

Because there are no variables defined inside any method with the names accNum, name and balance, we can use these names to refer to this.accNum, this.name and this.balance

Example Program: (Demo above code)
- The new BankAccount.java Prog file (without the use of this): click here
- The same Class06.java Prog file: click here
How to run the program:

Terminology: implicit parameter

Over-simplified ???....

Notice that we have simplified the method definition that:

To the untrained reader, some statements inside an instance method appear use use undefined variables

Example:

The original method definition:

/* ============================================== deposit(x, amount): Add "amount" to x.balance ============================================== */ public static void deposit( BankAccount x, double amount ) { x.balance += amount; }

We can clearly see that the variable balance is part of a parameter variable of the method

The final form of the method definition:

/* ============================================== deposit(amount): Add "amount" to balance ============================================== */ public void deposit( double amount ) { balance += amount; }

An untrained reader will not realize that the variable balance is part of some parameter variable of the method

Implicit parameter variable:

Every instance method has the parameter variable this

Furthermore:

The type of the parameter variable this is always

NameOfTheEnclosingClass this;

However, the parameter variable this is not written out explicitly
Therefore, we call the parameter variable this :