1. Classes and Objects Encapsulation
CMSC 202
Classes and Objects
Encapsulation

2. Topics Encapsulation Visibility of instance variables and methods
Information hiding
Visibility of instance variables and methods
public
private
Accessor and mutator methods
Private methods
Method overloading
Aug 6, 2007

3. OOP Techniques Abstraction Encapsulation Information hiding
Discarding details
Focus on observable behavior
Encapsulation
Combines data and operations into a single entity (a class)
Focus on implementation
Achieved through information hiding
Information hiding
A form of abstraction
Separating the description of how to use a class from the details of the class’ implementation
Aug 6, 2007

4. Types of Programmers
In the world of OO program development, it’s convenient to distinguish between
Class creators - those developing new classes
Client programmers - those who use the classes (a term coined by Scott Meyer)
Client programmers want to create applications by using a collection of interacting classes
Class creators want to build classes that expose the minimum interface necessary for the client program and hide everything else.
Aug 6, 2007

5. Access Control Access Control
Also known as information hiding
Provides a boundary for the client programmer
Separates interface from implementation
A form of abstraction
Visible parts of the class (the interface)
can be used and/or changed by the client programmer
Hidden parts of the class (the implementation)
Can be changed by the class creator without impacting any of the client programmer’s code
Can’t be corrupted by the client programmer
Aug 6, 2007

6. Access Control in Java
Java (and other OOP languages) provide access control to instance variables and methods via visibility modifiers
public - accessible by everyone, in particular public members are available to the client programmer.
A class interface is defined by its public methods
private - accessible only by the methods within the class
Others - later
Aug 6, 2007

7. Date2 Class public class Date2 {
In this new date class, the instance variables have been labeled private.
public class Date2 {
private String month; private int day;
private int year;
public void print( )
System.out.println(month + “ “ + day + “ “ + year); }
// setDate and monthString same as Date1 class
Any method may use the class’ private instance variables
Aug 6, 2007

8. Access Control Example
Date1 class - public instance variables were used
Date2 class - private instance variables are now used
public class Date2Demo {
public static void main( String[ ] args ) { Date2 myDate = new Date2( ); myDate.month = “July”; // compiler error myDate.day = 4; // compiler error
myDate.year = 1950; // compiler error
myDate.setDate( 7, 4, 1950 ); // OK – why?
myDate.print( ); // OK – why? }
Aug 6, 2007

9. Private Instance Variables
Private instance variables are only usable within the class.
Private instance variables hide implementation details, promoting encapsulation
Private instance variables are not accessible by the client programmer (class user)
Good programming practice:
Label all instance variables as private.
The class has complete control over how/when/if the instance variables are changed.
Instance variables primarily support class behaviors
July 21, 2008

10. Encapsulation Definition
Combining appropriate methods and data in a single class together with proper access control
Aug 6, 2007

11. The Value of Encapsulation
programmers that use a class do not need to know how the class is implemented, only how to use it
the information the programmer needs to use the class is kept to a minimum
class implementation may be changed with no impact on those who use the class
Aug 6, 2007

12. Copyright © 2008 Pearson Addison-Wesley.
Encapsulation
Aug 6, 2007
Copyright © 2008 Pearson Addison-Wesley.
All rights reserved 12

13. Encapsulation Summary
Combine methods and data in a single class
Use private instance variables for information hiding
Minimize the class’ public interface
“Keep it secret, Keep it safe”
Aug 6, 2007

14. Accessors & Mutator
In some cases class behavior may allow access to, or modification of individual private instance variables
Accessor method
retrieves the value of a private instance variable
conventional to start the name with get
Mutator method
changes the value of a private instance variable
conventional to start the name of an with set
Give the class user indirect access to the instance variables
July 21, 2008

15. More Accessors and Mutators
Question: Don’t the use of accessors and mutators defeat the purpose of making the instance variable private?
Answer: No.
The class implementer decides which instance variables will have accessors.
Mutators can:
validate the new value of the instance variable, and
decide whether or not to actually make the requested change.
Aug 6, 2007

16. Date2 Accessor and Mutator
public class Date2 {
private String month; private int day; //
private int year; // 4-digit year
// accessors return the value of private data
public int getDay ( )
{ return day; }
// mutators can validate the new value
public boolean setYear( int newYear ) {
if ( newYear < 1000 || newYear > 9999 )
// this is an invalid year
return false; }
else
year = newYear;
return true;
// rest of class definition follows
Aug 6, 2007

17. Private Methods Methods may be private
Cannot be invoked by the class user
Can only be called by other class methods
Most commonly used as “helper” methods to support top-down implementation of a public method
Aug 6, 2007

18. Private method Example
public class Date2 {
private String month; private int day; //
private int year; // 4-digit year
// mutators should validate the new value
public boolean setYear( int newYear ) {
if ( !yearIsValid( newYear )
return false;
else
year = newYear;
return true; }
// helper method - internal use only
private boolean yearIsValid( int year )
return 1000 < year && year < 9999;
July 21, 008

19. More about Methods
Many different classes can define a method with the same name (e.g. print).
Java can determine which method to call based on the type of the calling object.
Consider this code snippet:
Date2 birthday = new Date2(); Dog fido = new Dog( );
birthday.print( );
fido.print( );
birthday.print( ) will call the print( ) method defined in the Date2 class because birthday’s type is Date2
fido.print( ) will call the print( ) method defined in the Dog class because fido’s type is Dog
Jan 23, 2008

20. toString
One method which should be implemented for all classes is toString.
public String toString( )
The toString method returns a String chosen by the class implementer.
The string typically contains the values of important instance variables in a readable format.
This method is very often used for outputting the “contents” of a class.
Jan 23, 2008

21. Method Overloading
Two or more methods in the same class may have the same name.
This technique is known as method overloading.
Aug 6, 2007

22. public boolean setDate( int month, int day, int year )
Overloaded setDate
The Date2 class setDate method:
public boolean setDate( int month, int day, int year )
But suppose we wanted to change only the day and year?
We can define another method named setDate like this:
public boolean setDate( int day, int year )
(after all, setDate is a good descriptive name for what this method does)
Aug 6, 2007

23. Date3 Class - Overloaded setDate Method
public class Date3 {
private String month;
private int day; //
private int year; // 4 digits
public boolean setDate( int newMonth, int newDay, int newYear )
// code here }
public boolean setDate( int newDay, int newYear );
// code here, doesn’t change month
// print(), monthString( ), setYear( ), etc. follow
Aug 6, 2007

24. Date3Demo Class How does Java know which setDate method to call?
public class Date3Demo {
public static void main (String[ ] args)
Date3 myDate = new Date3( );
myDate.setDate( 1, 23, 1982 );
myDate.print( );
myDate.setDate( 4, 1999 ); }
How does Java know which setDate method to call?
Aug 6, 2007

25. Method Signature
In Java (and other OO languages), a method is uniquely identified by
its name and
its parameter list (parameter types and their order).
This is known as its signature.
Examples:
public boolean setDate(int newMonth, int newDay, int newYear)
public boolean setDate(String newMonth, int newDay, int newYear)
public boolean setDate(int newDay, int newYear)
public boolean setDate(int newDay, String newMonth)
Aug 6, 2007

26. Return Type is Not Enough
Suppose we attempt to overload Date3’s print( ) method by using different return types.
public void print( ) { /* code here */ }
public boolean print( ) { /* code here */ }
This is NOT valid method overloading because the code that calls print( ) can ignore the return value
birthday.print( );
The compiler can’t tell which print( ) method to call. Just because a method returns a value doesn’t mean the caller has to use it.
Aug 6, 2007

27. Too Much of a Good Thing
Automatic type promotion and overloading can sometimes interact in ways that confuse the compiler. Example:
public class X {
...
public void printAverage ( int a, double b) //version 1
public void printAverage ( double a, int b) //version 2 }
And then consider this:
myX = new X( );
myX.printAverage( 5, 7 );
The Java compiler can’t decide whether to promote 7 to 7.0 and call the first version of printAverage or to promote 5 to 5.0 and call the second.
The Java compiler is confused and will issue an error stating that the method invocation of myX.printAverage is ambiguous.
Aug 6, 2007