Handout 8 Classes and Objects Continued: Static Variables and Constants.

Transcription

1 Handout 8 CS603 Object-Oriented Programming Fall 16 Page 1 of 8 Handout 8 Classes and Objects Continued: Static Variables and Constants. 1. Static variable Declared with keyword static One per class (instead of one per object, as instance variable). Created independently of objects, outside of all objects. All objects (instances) of the class have access to it Static constants Like static variables, except declared with keyword final If declared as public can be used by other classes. Prefixed with the name of class in which they are defined, e.g. JOptionPane. QUESTION_MESSAGE Example for which static variable is useful: assigning unique ids Suppose objects of BankAccount class need to have unique ids. Approach: 1. Add a new field (a.k.a. instance var) to store the id. 2. Assign value to id during object construction by using a counter of how many accounts were created so far. The use of the counter will guarantee uniqueness, because the counter will be incremented once a new object is created. Solution: /* BankAccount extended with static members. * Implements assigning unique ids to each account: ACC#1, ACC#2, etc.. */ public class BankAccount { // instance variables - each object has its own copy inside private double balance; private String id; // Static members of class - one copy shared by *all* objects // stored outside of the object private static int numaccounts = 0; // number of account objects // incremented by constructors private final static String accprefix = "ACC#"; // prefix used in all account ids 1

2 Handout 8 CS603 Object-Oriented Programming Fall 16 Page 2 of 8 // Constructors: // no-argument constructor // increments the counter of all accounts // assigns a unique id to the account public BankAccount () { BankAccount.numAccounts++; // increment the counter of bank accounts this.id = BankAccount.accPrefix + BankAccount.numAccounts; public BankAccount (double b){ this(); // calls the no-argument constructor this.balance = b; // accessor methods public String getid() { return this.id; public double getbalance() { return this.balance;/* pass back account balance */ // notice the following method is static - no object required public static int getnumaccounts() { return numaccounts; // mutator methods /* public void deposit(double amount) { * increments balance by amount, if amount is nonnegative */ public void deposit(double amount) { /* increment balance by amount passed to method */ if (amount < 0) System.out.println("Negative amount cannot be deposited"); else balance += amount; /* public void withdrawal (double amountwithdrawn){ * deducts amountwithdrawn from balance, if balance is * greater or equal to amountwithdrawn. Otherwise, leaves * balance unchanged. */ public void withdrawal (double amountwithdrawn){ if (this.balance >= amountwithdrawn) this.balance -= amountwithdrawn; else System.out.println("Insufficient funds."); 2

3 Handout 8 CS603 Object-Oriented Programming Fall 16 Page 3 of 8 public String tostring(){ DecimalFormat money = new DecimalFormat("#,###.00"); return "Account " + this.getid() + " has balance of $" + money.format( this.getbalance()); /* Class BankAccountDemo * Demonstrates BankAccount with counter and unique ids */ public class BankAccountDemo { public static void main(string[] args) { System.out.println("Number of accounts created: " + BankAccount.getNumAccounts()); BankAccount oneaccount = new BankAccount( ); System.out.println(oneAccount); System.out.println("Number of accounts created: " + BankAccount.getNumAccounts()); BankAccount otheraccount = new BankAccount(500); System.out.println(otherAccount); System.out.println("Number of accounts created: " + BankAccount.getNumAccounts()); 2. Objects can be passed as parameters and can be returned by methods: Practice problem: a. Add instance method hasmore to the BankAccount class. The method should be passed a parameter of type BankAccount. The method should return either the calling object, the parameter object, or null depending on the balances of the calling object and the parameter. If the balance of the calling object is greater than the balance of the parameter object, return the calling object; if the parameter object has a greater balance than the calling object, return the parameter object, otherwise (same balance) return null. 3

4 Handout 8 CS603 Object-Oriented Programming Fall 16 Page 4 of 8 b. Create a code segment that calls method hasmore to determine if one of the accounts created by BankAccountDemo has a greater balance, and print that object. 4

5 Handout 8 CS603 Object-Oriented Programming Fall 16 Page 5 of 8 3. Implementing object associations: Applications typically consist of collections of objects of different related classes, working together. Example: Suppose a company wants a system that would implement direct deposit as a form of payment to their employees. CLASS Employee String name double payrate double unpaidhours getname() getpayrate() giveraise(double percent) setpayrate(double newrate) getunpaidhours() incrementhoursby(int hrs) DirectDeposit to CLASS BankAccount String id double balance static int numaccounts getid() getbalance() deposit(double amt ) withdrawal(double amt ) We already have the 2 class definitions (See following pages for Employee implementation). To implement direct deposit feature, perform the following using the Employee and Bank Account class specifications: a) Add a field of type BankAccount to each Employee object. b) Add a new constructor to allow for specification of direct deposit account as well as the name and pay rate of an employee. c) Add accessor and mutator methods for the direct deposit instance variable. d) Add instance method pay to Employee class, which should work as follows: Calculate the amount due to employee for unpaidhours. In case employee does not have the direct deposit account specified on record (i.e. the value of the appropriate instance var is null), print a check for the specified amount. Otherwise, if direct deposit account field is not null, deposit the amount due to the employee on their direct deposit account (Hint: use instance method deposit of the BankAccount class). Reset the number of unpaidhours to 0. 5

6 Handout 8 CS603 Object-Oriented Programming Fall 16 Page 6 of 8 /* Implementation of Employee class */ public class Employee { private String name; // employee name private double payrate; // hourly pay rate private int unpaidhours; // hours for which pay is due private static DecimalFormat MONEY = new DecimalFormat("#,##0.00"); //Constructor public Employee (String name, double rate ){ this.name = name.touppercase(); this.payrate= rate; public String tostring (){ return this.getname() + " is paid $" + MONEY.format(this.getPayRate()) + " per hour." + " Unpaid hours: " + this.getunpaidhours(); /* Accessors */ public String getname() { return this.name; public double getpayrate() { return this.payrate; public int getunpaidhours(){ return this.unpaidhours; /** Mutator that assigns the pay rate */ public void setpayrate(double newpayrate) { if (newpayrate > 0) this.payrate = newpayrate; /** Mutator that increments the number of hours worked * Returns the updated value of unpaidhours */ public int incrementhoursby( int addidionalhours){ this.unpaidhours += addidionalhours; return this.unpaidhours; 6

7 Handout 8 CS603 Object-Oriented Programming Fall 16 Page 7 of 8 /** increases the pay rate by specified percentage value */ public void giveraise (double percent){ double newrate = 0; // this is a local variable newrate = this.payrate *(percent +1); // set the calling object's rate to newrate this.payrate = newrate; 7

8 Handout 8 CS603 Object-Oriented Programming Fall 16 Page 8 of 8 Show by modifying a program below how to use the developed code to create employee with direct deposit account, and use it to pay the amount due to them public class TestEmployee { public static void main(string[] args) { Employee one, two; // create two employee objects one = new Employee ("Debby Stone", 7.45); two = new Employee ("George Clark", 12); System.out.println(one); System.out.println(two); one.incrementhoursby(5); two.incrementhoursby(12); System.out.println("After the changes were made:"); System.out.println(one); System.out.println(two); 8