encapsulation cmsc 202. types of programmers class programmers – developers of new classes –...
TRANSCRIPT
Types of Programmers
• Class programmers– Developers of new classes– Goal: Expose the minimum interface necessary to
use a new class– Implementation (code) is “hidden”
• Client programmers– Write code (the client program) that uses existing
classes
2Version 9/12
Encapsulation• Combining data and operations into a single entity
(class)
• Providing appropriate access control
• Achieved through information hiding/abstraction
3
Client Program
Pre-coded Class X
Pre-coded Class Y
Version 9/12
Class X interface
Class Y interface
The Value of Encapsulation
• Client programmers do not need to know how the class is implemented, only how to use it.
• Class implementation may be changed with no impact on code that uses the class.
4Version 9/12
Client Program
Pre-coded Class XClass X interface
ModifiedClass X
Class X interface
X
Class Interface
• Instance variables– name– what it represents– type
• Methods– name– what it does (not how)– pre & post-conditions– parameters– return value
Version 9/12 5
public String make; // car makepublic String model; // car modelpublic int year; // car year
/* Resets a car’s make * Preconditions: New make is non-null * Postconditions: Car’s make is reset * Parameters: Car’s new make * Returns: Nothing*/public void getMake(String newMake )
Visibility Modifiers
• Provide access control to class– instance variables– constants– methods
• public – directly accessible by client code
• private – accessible only by methods within the class (class scope)
• Other – later
6Version 9/12
Reference: http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html
Private Instance Variables Example
7
public class Car {public String model; public String make; private int year;
public void setYear(int newYear){year = newYear;
}}
Version 9/12
public class CarDemo {public static void main(String[] args) {
Car car = new Car();car.make = “Toyota"; // OKcar.model = “Prius"; // OKcar.year = 2008; // compiler
errorcar.setYear(2008); // OK
}}
Private Instance Variables: Summary• Only accessible within the class• Are not directly accessible by a client program• Hide implementation details, promoting
encapsulation• Good programming practice:– Label all instance variables as non-public (typically,
private).• Bottom line:– The class should have complete control over
how/when/if the instance variables are changed or accessed.
8Version 9/12Reference: http://docs.oracle.com/javase/tutorial/java/javaOO/variables.html
Accessors and Mutators• Accessor method (getter)– Retrieves the value of a private instance variable– Conventions:
• Start the method name with get.• Start edge case for booleans with is.
• Mutator method (setter)– Changes the value of a private instance variable.– Convention: Start the method name with set.
• Gives the client program indirect access to the instance variables.
9Version 9/12
Why Accessors and Mutators?• Accessors– The class implementer decides • which instance variables will have accessors, and• in what form they will be returned.
• Mutators– validate the new value of the instance variable,
and– decide whether or not to actually make the
requested change.
10Version 9/12
Example Car Accessor and Mutator
11
public class Car {
private int year; // 4-digit year between 1000 and 9999private String vin; // Vehicle identification number
// Accessor to return the vin memberpublic String getVin() {
return vin;}
// Mutator to change the year memberpublic boolean setYear(int newYear) {
if(newYear >= 1000 && newYear <= 9999) {year = newYear;return true;
}return false;
}// ...
}Version 9/12
Accessor/Mutator Caution
• In general, do not provide accessors and mutators for all private instance variables.
• Bottom line: Limit the class interface.
12Version 9/12
Private Methods
• Have class scope
• Cannot be invoked by a client program
• Used as “helper” methods to support top-down implementation of a public method.
13Version 9/12
Reference: http://docs.oracle.com/javase/tutorial/java/javaOO/methods.html
Private Method Example
14
public class Car {
private int year; // 4-digit year between 1000 and 9999
// Helper method – class scopeprivate boolean isValidYear(int year) {
return(year >= 1000 && year <= 9999);}
// Mutator to change the year memberpublic boolean setYear(int newYear) {
if(isValidYear(newYear)) {year = newYear;return true;
}return false;
}// ...
}Version 9/12
Encapsulation Summary
• Combine methods and data in a single class.• Use private instance variables for information
hiding.• Minimize the class’s public interface.
15
Keep it secret, keep it safe
Keep it secret, keep it safe
Version 9/12
Method Names• Different classes can define a method with the
same name.• Example:
• Java can determine which method to call based on the type of the calling object.
17
Cat myCat = new Cat();Dog myDog = new Dog();System.out.println(myCat);System.out.println(myDog);
Version 9/12
Method Overloading
• When two or more methods in the same class have the same name
• Example:
18Version 9/12
public boolean setStyle(String make, String model)
public boolean setStyle(String make)
Reference: http://docs.oracle.com/javase/tutorial/java/javaOO/methods.html
Car Class — Overloaded setStyle
19
public class Car {// ...private String model;private String make; public boolean setStyle(String make, String model) {
if(isValidMake(make) && isValidModel(model)) {this.make = make;this.model = model;return true;
}return false;
}public boolean setStyle(String make) {
if(isValidMake(make)) {this.make = make;return true;
}return false;
}private boolean isValidMake(String make) {
return make != null && !make.equals("");}private boolean isValidModel(String model) {
return model != null && !model.equals("");}
}Version 9/12
CarDemo Class
Version 9/12 20
How does Java know which setStyle method to call?
public class CarDemo {
public static void main(String[] args) {Car car = new Car();
car.setStyle("Mazda");System.out.println(car);
car.setStyle("Audi", "A8");System.out.println(car);
}
}
Method Signature
• A method is uniquely identified by its– name and– parameter list (types and order).
• This is known as its signature.• Examples …
21
public boolean setStyle(String make, String model)public boolean setStyle(int year, String make, String model) public boolean setStyle(String make, String model, String color)public boolean setStyle(int year, String color)public boolean setStyle(String make)
Version 9/12
Reference: http://docs.oracle.com/javase/tutorial/java/javaOO/methods.html
Return Type is Not Enough• Attempt to overload Car’s setStyle() method by using
different return types:
• This is NOT valid method overloading.• The method return value can be ignored.
22
public void setStyle(String make) { /* code here */ }
public boolean setStyle(String model) { /* code here */ }
car.setStyle("Mazda");
Version 9/12
Common Problem• Type coercion can confuse the compiler:
• So now,
• The Java compiler can’t decide whether to – promote 7 to 7.0 and call the first version of calculateAverage, or– promote 5 to 5.0 and call the second.
• Solution: Cast the arguments so that they match one of the signatures.
23
//version 1public double calculateAverage(int a, double b) { /* code */ }
//version 2public double calculateAverage(double a, int b) { /* code */ }
MathUtils math = new MathUtils();math.calculateAverage(5, 7); // two int parameters
Version 9/12
math.calculateAverage(5, (double)7); ORMath.calculateAverage((double)5, 7);