Logcat 2018,

1. SOLID Principles in Action
Arash Khangaldi: @irLogcat 2018

2. Agenda
● S — Single Responsibility Principle(S.R.P)
● O — Open-Closed Principle
● L — Liskov Substitution Principle
● I — Interface Segregation Principle
● D — Dependency Inversion Principle

3. Single Responsibility
A class should have one, and only one, reason to change.
Don’t be Swiss Army Knife!
In the context of the Single Responsibility Principle (SRP) we define a
responsibility as “a reason for change”. If you can think of more than one
motive for changing a class, then that class has more than one responsibility.

4. Violating Single
Responsibility

5. @Override
public void onBindViewHolder(ViewHolder holder, int position) {
final Movie movie = movies.get(position);
holder.itemView.setTag(movie);
holder.title.setText(movie.getTitle());
holder.rating.setText(movie.getRating());
String genreStr = "";
for (String str: movie.getGenre()) {
genreStr += str + ", ";
}
genreStr = genreStr.length() > 0 ?
genreStr.substring(0, genreStr.length() - 2) : genreStr;
holder.genre.setText(genreStr);
holder.releaseYear.setText(movie.getYear());
Glide.with(holder.thumbNail.getContext())
.load(movies.get(position)
.getThumbnailUrl())
.into(holder.thumbNail);
}

6. Fixing Single Responsibility

7. @Override
public void onBindViewHolder(ViewHolder holder, int position) {
final Movie movie = movies.get(position);
holder.itemView.setTag(movie);
holder.title.setText(movie.getTitle());
holder.rating.setText(movie.getRating());
holder.genre.setText(
ArraysUtil.convertArrayListToString(movie.getGenre()));
holder.releaseYear.setText(movie.getYear());
Glide.with(holder.thumbNail.getContext())
.load(movies.get(position)
.getThumbnailUrl())
.into(holder.thumbNail);
}

8. Violating Single
Responsibility in Tests

9. @Test
public void testScenario1And2() {
//...
assertEqual(resultOne, mUnderTest.getScenarioOne());
assertEqual(resultTwo, mUnderTest.getScenarioTwo());
}

10. Fixing Single Responsibility

11. @Test
public void testScenarioOne() {
//...
assertEqual(resultOne, mUnderTest.getScenarioOne());
}
@Test
public void testScenarioTwo() {
//...
assertEqual(resultTwo, mUnderTest.getScenarioTwo());
}

12. Open/Closed Principle
You should be able to extend a classes behavior, without modifying it.
This principle is the foundation for building code that is maintainable and
reusable.
Robert C. Martin

13. Violating O/C Principle

14. public class Music {
private String title;
private String uri;
// getters/setters ...
}
public class DataFactory {
public ArrayList<String> fetchUri(ArrayList<Object>...
medias) {
ArrayList<String> uris = new ArrayList<String>();
for (Object media : medias) {
if (media instanceof Music) {
Music music = (Music)media;
uris.add(Music.getUri());
} else if (media instanceof Image) {
Image image = (Image)media;
uris.add(
Environment.getStorageDirectory()+
image.getPath());
} else {
throw new RuntimeException("Media not
supported");
}
}
return uris;
}
}
public class Image {
private String title;
private String user;
private String path;
// getters/setters ...
}

15. Fixing O/C

16. public interface Media {
String getPath();
}
public class Music implements Media{
private String title;
private String uri;
// getters/setters ...
@Override
public getPath() {
return //...;
}
}
// Image.java
public class Image implements Media{
private String title;
// getters/setters ...
@Override
public getPath() {
return //...;
}
}

17. public class DataFactory {
public ArrayList<String> fetchUri(ArrayList<Media>... medias) {
ArrayList<String> uris = new ArrayList<String>();
for (Media media : medias) {
uris.add(shape.getArea());
}
return area;
}
}

18. The Liskov Substitution Principle (LSP)
Child classes should never break the parent class’ type definitions.

20. Violating LSP Principle

21. public interface CustomerLayout {
public void render();
}
public PremiumCustomer implements CustomerLayout {
...
@Override
public void render() {
//logic ...
}
}
public FreeCustomer implements CustomerLayout{
...
@Override
public void render() {
if (!hasSeenAd)
return;
//logic ...
}
}
public void renderView(CustomerLayout layout) {
layout.render();
}

22. Fixing LSP

23. public interface CustomerLayout {
public void render();
}
public PremiumCustomer implements CustomerLayout {
...
@Override
public void render() {
//logic ...
}
}
public FreeCustomer implements CustomerLayout{
...
@Override
public void render() {
if (!hasSeenAd)
ShowAdd();
//logic ...
}
}
public void renderView(CustomerLayout layout) {
layout.render();
}

24. Interface Segregation Principle
Clients should not be forced to implement interfaces they do not use.
Robert C. Martin

26. Violating Interface
Segregation Principle

27. Button valid = (Button)findViewById(R.id.valid);
valid.setOnClickListener(new View.OnClickListener {
public void onClick(View v) {
// TODO: do some stuff...
}
public void onLongClick(View v) {
// we don't need to it
}
public void onTouch(View v, MotionEvent event) {
// we don't need to it
}
});

28. Fixing Interface Segregation

29. public interface OnClickListener {
void onClick(View v);
}
public interface OnLongClickListener {
void onLongClick(View v);
}
public interface OnTouchListener {
void onTouch(View v, MotionEvent event);
}

30. The Dependency Inversion Principle
1. High-level modules should not depend on low-level modules. Both should
depend on abstractions.
2. Abstractions should not depend upon details. Details should depend upon
abstractions.
Robert C. Martin

32. Violating DIP

33. class Program {
public void work() {
// ....code
}
}
class Engineer{
Program program;
public void setProgram(Program p) {
program = p;
}
public void manage() {
program.work();
}
}

34. Fixing DIP

35. Interface IProgram {
public void work();
}
class Program implements IProgram{
public void work() {
// ....code
}
}
class SuperProgram implements IProgram{
public void work() {
//....code
}
}
class Engineer{
IProgram program;
public void setProgram(IProgram p) {
program = p;
}
public void manage() {
program.work();
}
}

36. Questions?