1. Encapsulation and Constructors
Comp1202
Encapsulation and Constructors

2. Coming up Recap Accessor Methods Encapsulation Constructors
Variables, Scope and Methods
Accessor Methods
Getters and Setters
Encapsulation
public and private
Constructors

3. Recap

4. Scope
public class Account{ int balance = 100; public void withdrawFiver(){ balance = balance -5; } public void withdrawTenner(){ int tenner = 10; balance = balance – tenner;
Member variables are visible in all the methods of a class.
They are created when an object is created, and destroyed when the object is garbage collected

5. Scope
public class Account{ int balance = 100; public void withdrawFiver(){ balance = balance -5; } public void withdrawTenner(){ int tenner = 10; balance = balance – tenner;
Member variables are visible in all the methods of a class.
They are created when an object is created, and destroyed when the object is garbage collected
Local variables are only visible in the method in which they are declared.
They are created when the method is invoked, and destroyed when it ends.

6. Primitives vs. References
Objects
Defined?
defined in Java
defined in Classes
Stored?
stored directly in variables
a reference is stored in the variable
Passed?
Pass by copy
Pass by reference a
int
int a; a = 10; Elephant b; b = new Elephant(); 10 b
Elephant

7. Methods and Parameters
public class Account{ int balance = 100; public static void main(String[] args){ Account myAccountObject = new Account(); myAccountObject.withdraw(5); myAccountObject.withdraw(10); } public void withdraw(int amount){ balance = balance - amount;
Values passed into a method are called arguments
Values received by a method are called parameters.
Within the method they can be used like any other local variable

8. Methods and Parameters
public class Account{ int balance = 100; int overdraft = 100; public static void main(String[] args){ Account myAccountObject = new Account(); myAccountObject.withdraw(5); int funds = getAvailableFunds(); System.out.println(funds); } public void withdraw(int amount){ balance = balance - amount; public int getAvailableFunds(){ return balance + overdraft;
You can use a return type to return a single value from a method

9. Overloading Methods can take multiple parameters
public class Account{ int balance = 100; public static void main(String[] args){ Account myAccountObject = new Account(); myAccountObject.withdraw(5); myAccountObject.withdraw(10, "ATM"); } public void withdraw(int amount){ balance = balance - amount; public void withdraw(int amount, String desc){ System.out.print(“Withdrew £”); System.out.print(amount); System.out.print(“ via ”); System.out.println(desc);
Methods can take multiple parameters
Several Methods can have the same name as long as their signatures (types and order of parameters) are different.

10. Accessor Methods and Encapsulation

11. Getters and Setters Programming convention
Puts a method between users of an object and the data inside the object
int a = student.age;
int a = student.getAge();
student.age = 20;
student.setAge(20);

12. aka These are more formally known as Accessors and Mutators.
You’ll find them a lot
The library classes that Java provides follow this convention often.

13. But Why Do It?
What reason is there to write this extra code, when you can use the class variables directly?
public int getAge(){
return age; }

14. Encapsulation
This is the idea that a class should be responsible for managing itself
And should present a clean interface (set of methods) to the outside world
An interface that does not reveal the inner workings of the class

15. Encapsulation
This is the idea that a class should be responsible for managing itself
And should present a clean interface (set of methods) to the outside world
An interface that does not reveal the inner workings of the class
This means that you can change the way that the class works, without changing any other parts of the program
Results in cleaner, more portable code, that is more maintainable and reusable.

16. For example Take this example class where age is modelled as an int
public class Student {
int age = 20;
//code omitted
public static void main(String[] args){
Student s1 = new Student();
System.out.println(s1.getAge()); }
public int getAge(){
return age;
Take this example class where age is modelled as an int

17. For example Take this example class where age is modelled as an int
public class Student {
//int age = 20;
Calendar dateOfBirth;
//code omitted
public static void main(String[] args){
Student s1 = new Student();
System.out.println(s1.getAge()); }
//public int getAge(){
// return age;
//}
public int getAge(){
Calendar rightNow = Calendar.getInstance();
int a = calculateAge(rightNow, dateofBirth);
return a;
Take this example class where age is modelled as an int
We might change the way that age is implemented – e.g. to make it based on the current date.
Because we used an Accessor we do not need to alter main

18. Enforcing Good Behaviour
So we have used methods to hide the way that our class is implemented
But what happens if we forgot and accidently access the variable directly?
Or if someone else uses our class in their program and ignores the accessor methods?

19. Private
public class Student {
//int age = 20;
private Calendar dateOfBirth;
//code omitted
public static void main(String[] args){
Student s1 = new Student();
System.out.println(s1.getAge()); }
//public int getAge(){
// return age;
//}
public int getAge(){
Calendar rightNow = Calendar.getInstance();
int a = calculateAge(rightNow, dateOfBirth);
return a;
The private keyword tells Java that only methods in this class can access this variable.

20. Private
public class Student {
//int age = 20;
private Calendar dateOfBirth;
//code omitted
public static void main(String[] args){
Student s1 = new Student();
System.out.println(s1.getAge()); }
//public int getAge(){
// return age;
//}
public int getAge(){
Calendar rightNow = Calendar.getInstance();
int a = calculateAge(rightNow, dateofBirth);
return a;
The private keyword tells Java that only methods in this class can access this variable.
And yes, public means the opposite – that all other methods can access it!

21. Encapsulation (Summary)
The idea that classes look after themselves and hide their internal workings
Is a key concept in Object Oriented Programming
And is enforced using the public or private keywords*
Which can be applied to both member variables and methods
*There is also a protected keyword (we come to that later!)

22. A Hint Good OO programmers are paranoid
If you want to make good encapsulated classes treat everything as private
Only open up methods or member variables as public if you really want them to be accessed outside of the class.

23. Constructors

24. Back at our simple Student Example
public class Student {
private int age = 20;
//code omitted
public static void main(String[] args){
Student s1 = new Student();
System.out.println(s1.getAge()); }
public int getAge(){
return age;
We have a problem – all our students will be age 20

25. Back at our simple Student Example
public class Student {
private int age = 20;
//code omitted
public static void main(String[] args){
Student s1 = new Student();
s1.setAge(19);
System.out.println(s1.getAge()); }
public int getAge(){
return age;
public void setAge(int a){
age = a;
We have a problem – all our students will be age 20
One solution is to use a Setter method. But Is this good encapsulation?

26. Back at our simple Student Example
public class Student {
private int age = 20;
//code omitted
public static void main(String[] args){
Student s1 = new Student();
s1.setAge(19);
System.out.println(s1.getAge()); }
public int getAge(){
return age;
public void setAge(int a){
age = a;
We have a problem – all our students will be age 20
One solution is to use a Setter method. But Is this good encapsulation?
No – object creation is in two steps. Someone could forget to set it before using the object.
We need a way to force a program to set the age at the point of object creation

27. Constructors Look a bit like methods
Contain code that is called during the creation of objects
Is used to initialise objects and set critical member variables
This maintains Encapsulation

28. Constructors Constructor Rules: Must have the same name as the class
public class Student {
private int age;
public Student() {
age = 20; }
//code omitted
Constructor Rules:
Must have the same name as the class
Do not need a return type

29. Constructors Constructor Rules: Must have the same name as the class
public class Student {
private int age;
public Student() {
age = 20; }
public Student(int a) {
age = a;
//code omitted
Constructor Rules:
Must have the same name as the class
Does not need a return type
Can take parameters
Can be overloaded

30. Constructors Constructor Rules: Must have the same name as the class
public class Student {
private age;
public Student() {
age = 20; }
public Student(int a) {
age = a;
public static void main(String[] args){
Student s1 = new Student(19);
System.out.println(s1.getAge());
//code omitted
Constructor Rules:
Must have the same name as the class
Does not need a return type
Can take parameters
Can be overloaded
Are invoked at the point of creation using the new keyword

31. The Default Constructor
What happens if you do not declare a constructor?
In these cases Java creates an invisible default constructor for you
The default constructor takes no parameters and contains no behavior. But allows you to create Object instances
We’ve been using them from day one
Dog d = new Dog();

32. Summary Recap Accessor Methods Encapsulation Constructors
Variables, Scope and Methods
Accessor Methods
Getters and Setters
Encapsulation
public and private
Constructors