- Purpose of variables:
- Variables contains
information
- Variables are used to provide information to the program so that it can perform the task
- Variables contains
information
- 2 ways to provide information to user programs:
- Explanation and examples:
- Direct access:
- The variables have
public access and
they are
directly accessible
(= exposed)
to the user.
- Example:
public class BankAccount { .... public double balance; .... } - The variables balance
can be
accessed directly from
anywhere
(due to the
public access specifier
):
public class MyProgram { public static void main( String[] args ) { BankAccount stu1 = new BankAccount(123, "John", 1000.0); stu1.balance = stu1.balance + 500; } }
- The variables have
public access and
they are
directly accessible
(= exposed)
to the user.
- Indirect access:
- The variables have
private access and
they
indirectly accessible
(= hidden)
to the user through
public methods
- Example:
public class BankAccount { .... private double balance; .... public double getBalance() { return balance; } public void putBalance(double x) { balance = x; } } - Variables balance
must be accessed indirectly through the
methods getBalance() and
putBalance():
public class MyProgram { public static void main( String[] args ) { BankAccount stu1 = new BankAccount(123, "John", 1000.0); double x; x = stu1.getBalance(); stu1.putBalance(x + 500); } }
- The variables have
private access and
they
indirectly accessible
(= hidden)
to the user through
public methods
- Direct access:
- The examples are illustrated in this figure:
- There are 2 aspects in
the process of
providing information
- Implementation =
How is the
data stored that
are used to provide the information.
- Functionality = What operations (= functionality) are allowed on the information.
- Implementation =
How is the
data stored that
are used to provide the information.
- Effect of the
direct data access on these
2 aspects:
- When information is realized using the direct access technique, we say that the functionality and implementation are coupled together
- Effect of the
indirect data access on these
2 aspects:
- When information is realized using the indirect access technique, we say that the functionality and implementation are decoupled
- Terminology:
- Information hiding =
"hide" the
variables (= information) from the users so they can
not accesses the variable directly
- This is done by having
private access variables
- The user must make use of public access methods to gain access to the variables
- This is done by having
private access variables
- Abstract Data Type (ADT) =
a data storage structure that is defined by
the functionality
Functionality of an ADT:
- The functionality is
defined by what kind of information
can you obtain from the ADT.
- The ADT will provide
a number of
public access methods
to provide the functionilities
To ensure data integrity (the correct information is provide), the variables used to store the information are protected by private access permission
- The functionality is
defined by what kind of information
can you obtain from the ADT.
- Information hiding =
"hide" the
variables (= information) from the users so they can
not accesses the variable directly
- Botton line:
- Information hiding and
Abstract Data Type are
in fact the
same technique
- Functionality and implementation are decoupled when using Information Hiding and Abstract Data Type.
- They (= Information Hiding and
ADT) both use:
- private
access instance variables to
hide the
data from the users
- Users must make use of public access methods to gain access to the information.
- private
access instance variables to
hide the
data from the users
- Information hiding and
Abstract Data Type are
in fact the
same technique
- Strength of the ADT technique:
- ADT can separate
- implementation
of the information
(= how
the information is stored)
- functionality of the information (= what information will be provided)
- implementation
of the information
(= how
the information is stored)
- ADT can separate
- Illustration:
separation of
implementation and
functionality
- Design an information storage to provide the age information a person
- Functionality that the data must
provide:
- Obtain the age of a person.
- Implementation 1:
- How to provide the
age information:
- We use a variable int age to store the age of a person.
- The direct access and
indirect (ADT) access solutions:
Direct access solution ADT solution public class AgeInformation { public String name; public int age; // Constructor AgeInformation(String s, int x) { name = s; age = x; } ... }public class AgeInformation { private String name; private int age; // Constructor AgeInformation(String s, int x) { name = s; age = x; } public int getAge() { return age; } ... }
- How users access (obtain)
the age information using the
different solutions:
Direct access solution ADT solution public class MyProgram { public static void main(String[] a) { AgeInformation stu1 = new AgeInformation("John", 22); int info; info = stu1.age; ... } }public class MyProgram { public static void main(String[] a) { AgeInformation stu1 = new AgeInformation("John", 22); int info; info = stu1.getAge(); ... } }
Notice that:
- There is only one program file
that contains the
AgeInformation class
- There can be hundreds of program files that contains programs that use the AgeInformation class program
- How to provide the
age information:
-
Changing the implementation:
Implementation 2
- How to provide the
age information:
- We use 3 variable
int day, month, year to store the
birthday of a person.
- The age is computed using the curent system time
- We use 3 variable
int day, month, year to store the
birthday of a person.
- The direct access and
indirect (ADT) access solutions:
Direct access solution ADT solution public class AgeInformation { public String name; public int day, month, year; // Constructor AgeInformation(String s, int a, int b, int c) { name = s; day = a; month = b; year = c; } ... }public class AgeInformation { private String name; private int day, month, year; // Constructor AgeInformation(String s, int a, int b, int c) { name = s; day = a; month = b; year = c; } public int getAge() { Read system time and compute age (Algorithm omitted for clarity sake) return age; } ... }
- Now, look at
what you need to change
in the user programs
to make them access (obtain)
the age information using the
different solutions:
Direct access solution ADT solution public class MyProgram { public static void main(String[] a) { AgeInformation stu1 = new AgeInformation("John", 29, 2, 1967); int info; info = stu1.age ??? does not work !!!; ... } }public class MyProgram { public static void main(String[] a) { AgeInformation stu1 = new AgeInformation("John", 29, 2, 1967); int info; info = stu1.getAge() /* Still works ! */; ... } }
Notice that:
- Recall that there can be
hundreds of program files
that contains programs that
use the
AgeInformation class program
- So if you use the direct access solution, you will have to update hundreds of program to make them work again !!!
- How to provide the
age information:
- Advantage of ADT:
- But separating the
functionality and
implemnetation, we achieve
data and program
independence
- We can change the
representation of
the information
(in the example: age)
without having to
change
the
programs that
use the information
- In the example above, we
change the way we store
the information on the age
- Using the ADT approach, the programs still work (after updating the getAge() method --- which consists of one program file)
- In the example above, we
change the way we store
the information on the age
- But separating the
functionality and
implemnetation, we achieve
data and program
independence