20.3 Java encapsulation

Benefits of Encapsulation
Encapsulation
Software University
http://softuni.bg
SoftUni Team
Technical Trainers

1. What is Encapsulation?
 Keyword this
2. Access Modifiers
3. Validation
4. Mutable and Immutable Objects
5. Keyword final
Table of Contents
2

sli.do
#java-advanced
Have a Question?

Hiding Implementation
Encapsulation
Abstraction
Information Hiding
Data Encapsulation

 Process of wrapping code and data together
into a single unit
 Flexibility and extensibility of the code
 Reduces complexity
 Structural changes remain local
 Allows validation and data binding
Encapsulation
5

 Objects fields must be private
 Use getters and setters for data access
Encapsulation
6
class Person {
private int age;
}
class Person {
public int getAge()
public void setAge(int age)
}

Encapsulation – Example
 Fields should be private
 Accessors and Mutators should be public
7
Person
-name: string
-age: int
+Person(String name, int age)
+getName(): String
+setName(String name): void
+getAge(): int
+setAge(int age): void
- == private
+ == public

 this is a reference to the current object
 this can refer to current class instance
 this can invoke current class method
Keyword this (1)
8
public Person(String name) {
this.name = name;
}
public String fullName() {
return this.getFirstName() + " " + this.getLastName();
}

 this can invoke current class constructor
Keyword this (2)
9
public Person(String name) {
this.firstName = name;
}
public Person (String name, Integer age) {
this(name);
this.age = age;
}

Access Modifiers
Visibility of Class Members

 Object hides data from the outside world
 Classes and interfaces cannot be private
 Data can be accessed only within the
declared class itself
Private Access Modifier
11
class Person {
private String name;
Person (String name) {
this.name = name;
}
}

 Grants access to subclasses
 protected modifier cannot be applied to
classes and interfaces
 Prevents a nonrelated class from trying to use it
Protected Access Modifier
12
class Team {
protected String getName () {…}
protected void setName (String name) {…}
}

 Do not explicitly declare an access modifier
 Available to any other class in the same package
Default Access Modifier
13
class Team {
String getName() {…}
void setName(String name) {…}
}
Team real = new Team("Real");
real.setName("Real Madrid");
System.out.println(real.getName());
// Real Madrid

 Grants access to any class belonging to
the Java Universe
 Import a package if you need to use a class
 The main() method of an application
must be public
Public Access Modifier
14
public class Team {
public String getName() {…}
public void setName(String name) {…}
}

 Create a class Person
Problem: Sort by Name and Age
15
Person
-firstName: String
-lastName: String
-age: int
+getFirstName(): String
+getLastName(): String
+getAge(): int
+toString(): String
Check your solution here :https://judge.softuni.bg/Contests/1535/Encapsulation-Lab

Solution: Sort by Name and Age
16
public class Person {
private String firstName;
private String lastName; private int age;
// TODO: Implement Constructor
public String getFirstName() { /* TODO */ }
public String getLastName() { /* TODO */ }
public int getAge() { return age; }
@Override
public String toString() { /* TODO */ }
}

 Implement Salary
 Add:
 getter for salary
 increaseSalary by percentage
 Persons younger than 30 get
only half of the increase
Problem: Salary Increase
17
Person
-firstName: String
-lastName: String
-age: int
-salary: double
+getFirstName(): String
+getLastName() : String
+getAge() : int
+getSalary(): double
+setSalary(double): void
+increaseSalary(double): void
+toString(): String

 Expand Person from previous task
Solution: Salary Increase (1)
18
public class Person {
private double salary;
// Edit Constructor
public double getSalary() {
return this.salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
// Next Slide…
// TODO: Edit toString() method
}

 Expand Person from previous task
Solution: Salary Increase (2)
19
public void increaseSalary(double percentage) {
if (this.getAge() < 30) {
this.setSalary(this.getSalary() +
(this.getSalary() * percentage / 200));
} else {
this.setSalary(this.getSalary() +
(this.getSalary() * percentage / 100));
}
}

 Data validation happens in setters
 Printing with System.out couples your class
 Client can handle class exceptions
Validation (1)
21
private void setSalary(double salary) {
if (salary < 460) {
throw new IllegalArgumentException("Message");
}
this.salary = salary;
}
It is better to throw exceptions,
rather than printing to the Console

 Constructors use private setters with validation logic
 Guarantees valid state of object in its creation
 Guarantees valid state for public setters
Validation (2)
22
public Person(String firstName, String lastName,
int age, double salary) {
setFirstName(firstName);
setLastName(lastName);
setAge(age);
setSalary(salary);
}
Validation happens
inside the setter

 Expand Person with
validation for every field
 Names should be
at least 3 symbols
 Age cannot be zero or negative
 Salary cannot be less than 460
Problem: Validation Data
23
Person
-firstName : String
-lastName : String
-age : int
-salary : double
+Person()
+setFirstName(String fName)
+setLastName(String lName)
+setAge(int age)
+setSalary(double salary)

Solution: Validation Data
24
// TODO: Add validation for firstName
// TODO: Add validation for lastName
public void setAge(int age) {
if (age < 1) {
throw new IllegalArgumentException(
"Age cannot be zero or negative integer");
}
this.age = age;
}
// TODO: Add validation for salary

Mutable and Immutable Objects
25

Mutable vs Immutable Objects
 Mutable Objects
 The contents of that
instance can be altered
 Immutable Objects
 The contents of the
instance can't be altered
26
old String
old String
Point myPoint = new Point(0, 0);
myPoint.setLocation(1.0, 0.0);
System.out.println(myPoint);
java.awt.Point[1.0, 0.0]
String str = new String("old String");
System.out.println(str);
str.replaceAll("old", "new");
System.out.println(str);

 private mutable fields are not fully encapsulated
 In this case getter is like setter too
Mutable Fields
27
class Team {
private String name;
private List<Person> players;
public List<Person> getPlayers() {
return this.players;
}
}

Mutable Fields - Example
28
Team team = new Team();
Person person = new Person("David", "Adams", 22);
team.getPlayers().add(person);
System.out.println(team.getPlayers().size()); // 1
team.getPlayers().clear();
System.out.println(team.getPlayers().size()); // 0

 For securing our collection we can return
Collections.unmodifiableList()
Imutable Fields
29
class Team {
private List<Person> players;
public void addPlayer(Person person) {
this.players.add(person);
}
public List<Person> getPlayers() {
return Collections.unmodifiableList(players);
}
}
Returns a safe collections
Add new methods for
functionality over list

 Expand your project with class Team
 Team have two squads
first team and reserve team
 Read persons from console and
add them to team
 If they are younger than 40,
they go to first squad
 Print both squad sizes
Problem: First and Reserve Team
30
Team
-name: String
-firstTeam: List<Person>
-reserveTeam: List<Person>
+Team(String name)
+getName()
-setName(String name)
+getFirstTeam()
+getReserveTeam()
+addPlayer(Person person)

Solution: First and Reserve Team
31
private List<Person> firstTeam;
private List<Person> reserveTeam;
public void addPlayer(Person person) {
if (person.getAge() < 40)
this.firstTeam.add(person);
else
this.reserveTeam.add(person);
}
public List<Person> getFirstTeam() {
return Collections.unmodifiableList(firstTeam);
}
// TODO: add getter for reserve team

 final class can't be extended
 final method can't be overridden
Keyword final
33
public class Animal {}
public final class Mammal extends Animal {}
public class Cat extends Mammal {}
public final void move(Point point) {}
public class Mammal extends Animal {
@Override
public void move() {}
}

 final variable value can't be changed once it is set
Keyword final
34
private final String name;
private final List<Person> firstTeam;
public Team (String name) {
this.name = name;
this.firstTeam = new ArrayList<Person> ();
}
public void doSomething(Person person) {
this.name = "";
this.firstTeam = new ArrayList<>();
this.firstTeam.add(person);
}
Compile time error

 …
 …
 …
Summary
35
 Encapsulation:
 Hides implementation
 Reduces complexity
 Ensures that structural changes
remain local
 Mutable and Immutable objects
 Keyword final

 https://softuni.bg/modules/59/java-advanced

SoftUni Organizational Partners

 Software University – High-Quality Education and
Employment Opportunities
 softuni.bg
 Software University Foundation
 http://softuni.foundation/
 Software University @ Facebook
 facebook.com/SoftwareUniversity
 Software University Forums
 forum.softuni.bg
Trainings @ Software University (SoftUni)

 This course (slides, examples, demos, videos, homework, etc.)
is licensed under the "Creative Commons Attribution-
NonCommercial-ShareAlike 4.0 International" license
License
40

20.3 Java encapsulation

Recommended

More Related Content

What's hot (20)

Similar to 20.3 Java encapsulation (20)

More from Intro C# Book (20)

Recently uploaded (19)

20.3 Java encapsulation

Editor's Notes