CS100J Lecture 7 Previous Lecture This Lecture Java Constructs Computation and computational power Abstraction Classes, Objects, and Methods References and aliases Reading: Lewis & Loftus, Chapter 4 and Section 5.1 Savitch, Chapter 4 This Lecture Programming Concepts Classes, Objects, and Methods --- reiterated Accessors Encapsulation Java Constructs return statement Visibility modifiers public private CS 100 Lecture7

Class Definition A class is a named group of declarations and methods class class-name { declarations-and-methods } A method is a named parameterized group of declarations and statements Method definition return-type method-name( parameter-list ) declaration-and-statement-list CS 100 Lecture7

Class Definition Example class Account { int balance; // current balance int deposits; // deposits to date int withdrawals; // withdrawals to date // deposit d to account void deposit(int d) balance = balance + d; deposits = deposits + d; } // withdraw w from account void withdraw(int w) balance = balance - w; withdrawals = withdrawals + w; CS 100 Lecture7

Object Instantiation The value of expression new class-name() is a reference to a new object of the given class-name CS 100 Lecture7

Object Instance Example An object is a collection of instance variables (also known as fields) and methods An object can be referred to as a unit balance deposits withdrawals deposit withdraw fields methods CS 100 Lecture7

Access to Fields and Methods If r is an expression whose value refers to an object o of class c f is a field of o m is a method of o then r.f is a variable of object o r.m is a method of o CS 100 Lecture7

Application Setting Process bank account transactions: The input consists of zero or more non-zero integers signifying “transactions”, followed by 0. A positive value is a deposit. A negative value is a withdrawal. Assume the account has an initial balance of 0, process all transactions, and output: Final balance Total of all deposits Total of all withdrawals Sample input data 100 200 -50 0 Sample output Balance: 250 Deposits: 300 Withdrawals: 50 CS 100 Lecture7

Application Example int amount; // current transaction Account account = new Account(); /* Read and process all transactions. */ amount = in.readInt(); while ( amount != 0 ) { if ( amount >= 0 ) account.deposit(amount); else account.withdraw(-amount); } /* Output summary information. */ System.out.println( ”Balance: ” + account.balance ); ”Deposits: ” + account.deposits ”Withdrawals: ” + account.withdrawals CS 100 Lecture7

Application Example, cont. The code for the application would be in a different class from Account, say /* Process banking stransactions. */ import java.io.*; public class TrivialApplication { public static void main(String args[]) declarations // Initialize Text object in to read // from standard input. TokenReader in = new TokenReader(System.in); statements } CS 100 Lecture7

Methods that Return Values Method invocation object-expression . method-name(expression-list) Method execution initialize the parameters with the values of the argument expressions execute the statement-list of the method thereafter, continue where you were before Non-void methods with return-type t can return a value of type t using the statement return expression ; A method that just returns the value of a field is called an field accessor. CS 100 Lecture7

Class Definition Example, Version 2 class Account { int balance; // current balance int deposits; // deposits to date int withdrawals; // withdrawals to date // deposit d to account void deposit(int d) { balance = balance + d; deposits = deposits + d; } // withdraw w from account void withdraw(int w) { balance = balance - w; withdrawals = withdrawals + w; // field accessors int getBalance() { return balance; } int getDeposits() { return deposits; } int getWithdrawals() { return withdrawals; } methods for accessing field values CS 100 Lecture7

Application Example, Version 2 int amount; // current transaction Account account = new Account(); /* Read and process all transactions. */ amount = in.readInt(); while ( amount != 0 ) { if ( amount >= 0 ) account.deposit(amount); else account.withdraw(-amount); } /* Output summary information. */ System.out.println( ”Balance: ” + account.getBalance() ); ”Deposits: ” + account.getDeposits() ”Withdrawals: ” + account.getWithdrawals() field values accessed via methods field values accessed via methods field values accessed via methods CS 100 Lecture7

Field Modifiers A field declarations and method definitions can have a modifier Declarations modifier type name ; Method definitions modifier return-type method-name( parameter-list ) { statement-list } Possible modifiers are: public private others later A private field or method is not visible from outside the class definition. CS 100 Lecture7

Class Definition Example, Version 3 fields hidden from clients class Account { private int balance; // current balance private int deposits; // deposits to date private int withdrawals; // withdrawals to date // deposit d to account void deposit(int d) { balance = balance + d; deposits = deposits + d; } // withdraw w from account void withdraw(int w) { balance = balance - w; withdrawals = withdrawals + w; // field accessors int getBalance() { return balance; } int getDeposits() { return deposits; } int getWithdrawals() { return withdrawals; } CS 100 Lecture7

Class Definition Example, Version 4 balance field deleted class Account { private int deposits; // deposits to date private int withdrawals; // withdrawals to date // deposit d to account void deposit(int d) { deposits = deposits + d; } // withdraw w from account void withdraw(int w) { withdrawals = withdrawals + w; // return computed balance int getBalance() { return deposits - withdrawals; // field accessors int getDeposits() { return deposits; } int getWithdrawals() { return withdrawals; } balance computed CS 100 Lecture7

Encapsulation and Information Hiding The users of a class and its objects are called its clients. The author of a class is called its implementor. Information hiding principle. Implementors hide implementation details inside a class definition so clients can’t see them. In particular, they make all fields private. The methods of a class provide services to clients. The interface of a class is the contract in which the implementor commits to deliver certain services to the clients. Implementors are free to change the implementation of a class provided the interface doesn’t change, i.e. provided clients can’t see any change in services. CS 100 Lecture7