Last lecture. Lecture 9. in a nutshell. in a nutshell 2. Example of encapsulation. Example of encapsulation. Class test. Procedural Programming

Transcription

1 1 Lecture 9 Last lecture Class test Has been marked Collect your marks at your next seminar Seminars There are seminars this week to go through the class test Meet in the classroom indicated on the timetable Coursework 2 Now is a good time to start Procedural Programming Data and operations on the data are separate Object Oriented Programming Data and operations are bundled together in a structure called an Object Justification Allowed related data and operations to be grouped together, provides a better way of structuring large complex code Allowed more complex datatypes to be represented 2 in a nutshell in a nutshell 2 Objects more sophisticated data types (e.g. Person, Car, Circle etc) contain data and related operations Classes Object classes Main class Instantiation house blueprints/plans for objects houses main method Objects are created from their blueprint classes using the new command, e.g. Circle mycircle = new Circle (5.0, white ); A constructor method defines how object is initialised (has same name as class) Access objects components using the dot notation mycircle.radius // access property mycircle.findarea() // access behaviour Modifier keywords public defined beyond class private restricted to defined class Good object design using encapsulation To define methods as public And data as private And offer public methods for getting and setting data 3 4 Example of encapsulation Example of encapsulation class Circle private double radius; // private data field class Circle private double radius; // private data field public Circle (double r) // Constructor for radius = r; // Circle object public Circle (double r) // Constructor for radius = r; // Circle object public double getradius() return radius; // get method public double getradius() return radius; // get method public void setradius(double input) radius = input; // set method public void setradius(double input) radius = input; // set method public double findarea() return radius * radius * ; // extra methods public double findarea() return radius * radius * ; // extra methods 5 6

2 7 Example of encapsulation Interface to Circle class Circle private double radius; // private data field public Circle (double r) // Constructor for radius = r; // Circle object public double getradius() return radius; // get method Public methods provide an interface to the object Circle (double r) double getradius() void setradius(double input) double findarea() This is how we communicate with the object Yet the implementation remains private the programmer reserves the right to change the implementation e.g., public void setradius(double input) radius = input; // set method private double diameter; not a problem as the interface remains the same, even if the implementation details are different public double findarea() return radius * radius * ; // extra methods This is a way of hiding the unnecessary detail It is known as program abstraction 8 Instance variables Class variables The variable radius is known as instance variable belong to each instance of the class are not shared between objects of that class If you want instances to share data, use class variables class variables are stored in common memory locations to declare class variable, use modifier static Circle mycircle = new Circle(1.0); static double commonweight; Circle yourcircle = new Circle(1.0); If you change mycircle s data, mycircle.setradius(5.0); a change to variable commonweight, in any of the instances, causes commonweight of all other instances to change it does not affect yourcircle s data, and vice versa 9 10 Instance and Class methods Case study: Bank accounts Similarly, instance methods belong to each object of the class they can only be applied after an instance is created Specification Ability to create an account (with specified account number and owner) objectname.method() mycircle.findarea(); robot.getlocationx(); Class methods can be called without creating an instance of the class To safely store account balances Pay in and withdraw money from the account To provide overdraft facilities Concerns class methods are defined using the modifier static classname.method() System.out.println(); Security Privacy 11 12

3 13 Characteristics Procedural version Accounts have the same basic properties Account number Account owner Balance Overdraft facilities and these properties are modified through the same basic behaviours int accountnumber1 = ; // Account holder Jarvis String accountowner1 = new String( Stephen Jarvis ); double accountbalance1 = 50.00; accountbalance1 = withdraw(101102,accountowner1, accountbalance1,20.00); Accounts can be created Overdraft limits can be set Pay in and withdraw money public double withdraw(int accnum, String owner, double currentbalance, double amount) double newbalance = currentbalance amount; return newbalance; 14 Procedural version Procedural version int accountnumber1 = ; // Account holder Jarvis String accountowner1 = new String( Stephen Jarvis ); double accountbalance1 = 50.00; int accountnumber1 = ; // Account holder Jarvis String accountowner1 = new String( Stephen Jarvis ); double accountbalance1 = 50.00; accountbalance1 = withdraw(101102,accountowner1, accountbalance1,20.00); accountbalance1 = withdraw(101102,accountowner1, accountbalance1,20.00); public double withdraw(int accnum, String owner, double currentbalance, double amount) double newbalance = currentbalance amount; return newbalance; public double withdraw(int accnum, String owner, double currentbalance, double amount) double newbalance = currentbalance amount; return newbalance; Account types Account objects This could become nasty Account data For each new account holder we need at least 3 new variables inside main There is no separation of data between one account and the next (bad for privacy and security) What we really want is an account type accountnumber, accountowner, accountbalance, overdraftlimit Where the types are selected accordingly Will all Accounts have this same data? Then we can place the data inside the class So we can create a new self contained account Account accountnumber1; inside which we find details such as the account holders name, balance etc. accountnumber1.getbalance(); Can do this by introducing an Account object String accountowner; double accountbalance; int overdraftlimit; // storesaccount number // and account owners name // and their balance // and their overdraft limit 17 18

4 19 Account accountnumber1; Account accountnumber2; Account accountnumber3; BankAccounts.java // Declare three new accounts Creating Accounts Declaring the accounts is not the same as creating them to create an account object we need a constructor method etc // stores account number String accountowner; double accountbalance; int overdraftlimit; // stores account number // and account owners name // and their balance // and their overdraft limit Account(int accnum, String owner, double startingbalance, int odlimit) accountnumber = accnum; accountowner = owner; accountbalance = startingbalance; overdraftlimit = odlimit; accountnumber1 = new Account(101102,"Stephen Jarvis",10.00,-50); 20 A small bank Instance data and methods So we can create some new accounts accountnumber1 = new Account(101102, Stephen Jarvis",10.00,-50); accountnumber2 = new Account(101103, George (smug) W", ,-50000); accountnumber3 = new Account(101104, John (I want a recount) K",1.00,0); How do we print the account details? Class Account Scope is OK etc void printaccountdetails() System.out.println("Account " + accountnumber); System.out.println(" is owned by " + accountowner); System.out.println(" whose balance is " + accountbalance); System.out.println(" and whose overdraft limit is " + overdraftlimit); System.out.println(); 21 Each of our three objects contains its own instance data and instance methods accountnumber = accountnumber = accountnumber = accountowner = Stephen Jarvis accountowner = George W accountowner = John K accountbalance = accountbalance = accountbalance = 1.00 overdraftlimit = -50 overdraftlimit = overdraftlimit = 0 Account() printaccountdetails() Account() printaccountdetails() The instance data and methods are currently public (by default) Account() printaccountdetails() accountnumber1 accountnumber2 accountnumber3 22 Public v Private Public v Private cont. This allows us to access (and modify the data) // pinch the Bush fortune accountnumber1.accountbalance = accountnumber1.accountbalance + accountnumber2.accountbalance; // and then set his account to zero accountnumber2.accountbalance = 0; The data should therefore be made private and then accessed through get and set methods // make the data private private double accountbalance; // and also add a PIN for security reasons private int PIN; // now we can add an appropriate get method double getbalance(int accnum, int identificationnumber) if (identificationnumber==pin) return accountbalance; else return 0.0; 23 In this context, should the following be public or private? the instance data accountnumber the instance data accountowner the instance data overdraftlimit The instance methods are also public by default. Should they be public or private? the instance method getbalance() the instance method printaccountdetails() the constructor method Account() 24

5 25 The static modifier Instances (objects) can share data using class variables class variables are stored in common memory locations and are common to all instances of the class To declare a class variable use the static modifier private static double interestrate; etc. // interest rate on account Constants static variables are quite rare; however, static constants are common public class Math public static final double PI = ; The modifier final ensures that the field can not be modified We can access this constant using Math.PI If static had been omitted, an instance of the Math class would have to be created before PI could be used 26 The static modifier Static methods To access or modify private static class data, public static class methods must be defined static methods are methods which do not operate on objects static void resetinterestrate(double newrate) interestrate = newrate; Math.pow(x,y) is another example of a static method from the Math class Static methods are called from the class Account.resetInterestRate(4.5); Because static methods do not operate on objects, you can not access instance data from static methods Not from the instance static methods should be used to access static data accountnumber1.resetinterestrate(4.5); Resetting the interest rate will reset that rate for all instances of the Account object Error: Can not make static reference to non-static variable Static v non-static Modifiers In this context, should the following be static or not? the data accountnumber the data interestrate the data accountowner the data overdraftlimit the data accountcharges and what about the following methods? the method getbalance() the method resetinterestrate() the method printaccountdetails() the constructor method Account() So now we know if the data should be declared as public or private and, static or non-static The data and methods must correspond private static data = public static methods private data = public non-static methods public data = direct access or public non-static methods public static data = direct access or public static methods Making decisions on your modifiers will make a difference to the remainder of your code the method setaccountcharges() 29 30

6 31 Account accountnumber1; Account accountnumber2; Account accountnumber3; // Declare new accounts Class Account private // stores the account number private String accountowner; // and the account owners name private double accountbalance; // and their balance private int overdraftlimit; // and their overdraft limit private int PIN; // the PIN private static double interestrate; // the global interest rate Account.resetInterestRate(4.5); // Set the global interest rate // Set up some accounts accountnumber1 = new Account(101102,"Stephen Jarvis",10.00,-50, 1007); accountnumber2 = new Account(101103, George(Smug) W", ,-50000, 1234); accountnumber3 = new Account(101104, John (Recount) K",1.00,0, 0000); accountnumber1.printaccountdetails(); // Print their details accountnumber2.printaccountdetails(); accountnumber3.printaccountdetails(); Account.resetInterestRate(4.0); // Reset the interest rate accountnumber1.printaccountdetails(); // and then print the account details again accountnumber2.printaccountdetails(); accountnumber3.printaccountdetails(); Account(int accnum, String owner, double startingbalance, int odlimit, int pin) // Constructor accountnumber = accnum; accountowner = owner; accountbalance = startingbalance; overdraftlimit = odlimit; PIN = pin; double getbalance(int accnum, int identificationnumber) if (identificationnumber==pin) return accountbalance; else return 0.0; void printaccountdetails() System.out.println("Account " + accountnumber + " is owned by " + accountowner); System.out.println(" whose balance is " + accountbalance); System.out.println(" and whose overdraft limit is " + overdraftlimit); System.out.println(" and whose interest rate is " + interestrate); System.out.println(); static void resetinterestrate(double newrate) // resets global interest rate interestrate = newrate; 32 Where next? Next Monday Arrays Processing arrays Arrays and classes Next Thursday All you need to know for coursework 2 Multi-dimensional arrays Games programming Week Monday Inheritance Abstraction Dynamic binding 33