CS100J Lecture 7

1. CS100J Lecture 7 • Previous Lecture • 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 Lecture7

2. Class Definition • A class is a named group of declarations and methods • Class definition classclass-name { declarations-and-methods } • A method is a named parameterized group of declarations and statements • Method definition return-typemethod-name( parameter-list ) { declaration-and-statement-list } Lecture7

3. 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; } } Lecture7

4. Object Instantiation • The value of expression newclass-name() is a reference to a new object of the given class-name Lecture7

5. balance deposits withdrawals deposit withdraw 0 fields 0 0 methods 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 Lecture7

6. 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 Lecture7

7. 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 Lecture7

8. 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); amount = in.readInt(); } /* Output summary information. */ System.out.println( ”Balance: ” + account.balance ); System.out.println( ”Deposits: ” + account.deposits ); System.out.println( ”Withdrawals: ” + account.withdrawals ); Lecture7

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

10. 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-typet can return a value of type t using the statement returnexpression ; • A method that just returns the value of a field is called an fieldaccessor. Lecture7

11. 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 Lecture7

12. 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); amount = in.readInt(); } /* Output summary information. */ System.out.println( ”Balance: ” + account.getBalance() ); System.out.println( ”Deposits: ” + account.getDeposits() ); System.out.println( ”Withdrawals: ” + account.getWithdrawals() ); field values accessed via methods field values accessed via methods field values accessed via methods Lecture7

13. Field Modifiers • A field declarations and method definitions can have a modifier • Declarations modifier type name ; • Method definitions modifier return-typemethod-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. Lecture7

14. 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; } } Lecture7

15. 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 Lecture7

16. 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. Lecture7