SOLID principles

AGENDA
INTRODUCTIE
SOLID
CONCLUSIE & DISCUSSIE

Acroniemen
TCP
IP XP
SOLID
JAVA EE
JSP JPA
SOAP
SMTP
SNMP
OSI
HTTP
HATEOAS
POM
PINO
JAREAR
EJB
C#
JAX-B JAX-P
JAX-WS
JAX-RS
SAAJ
k8sl10n
i18n
GRASPKISS
STAVAZA
MOSCOW
YAGNI

SOLID
Robert C. Martin
"Uncle Bob"

SOLID
Robert C. Martin Copyright (c) 2000 by Robert C. Martin. All Rights Reserved.
www.objectmentor.com
1
Design Principles and
Design Patterns
Robert C. Martinwww.objectmentor.com
What is software architecture? The answer is multitiered. At the highest level, there
are the architecture patterns that define the overall shape and structure of software
applications1
. Down a level is the architecture that is specifically related to the pur-
pose of the software application. Yet another level down resides the architecture of
the modules and their interconnections. This is the domain of design patterns2
, pack-
akges, components, and classes. It is this level that we will concern ourselves with in
this chapter.
Our scope in this chapter is quite limitted. There is much more to be said about the
principles and patterns that are exposed here. Interested readers are referred to
[Martin99].
Architecture and DependenciesWhat goes wrong with software? The design of many software applications begins as
a vital image in the minds of its designers. At this stage it is clean, elegant, and com-
pelling. It has a simple beauty that makes the designers and implementers itch to see it
working. Some of these applications manage to maintain this purity of design through
the initial development and into the first release.But then something begins to happen. The software starts to rot. At first it isn’t so
bad. An ugly wart here, a clumsy hack there, but the beauty of the design still shows
through. Yet, over time as the rotting continues, the ugly festering sores and boils
accumulate until they dominate the design of the application. The program becomes a
festering mass of code that the developers find increasingly hard to maintain. Eventu-1. [Shaw96]
2. [GOF96]

SOLID
Single Responsibility Principle 
Open Closed Principle 
Lishkov Substitution Principle
 
Interface Segregation Principle 
Dependency Inversion Principle

A class should only have a single
responsibility, that is, only changes to one
part of the software's speciﬁcation should
be able to affect the speciﬁcation of the
class.
wikipedia.org

Één verantwoordelijkheid per klasse:  
één reden om te wijzigen.

public static void main(String[] args) {
    Person user = new Person();
    user.setVoornaam(System.console().readLine("Wat is je voornaam? "));
    user.setAchternaam(System.console().readLine("Wat is je achternaam? "));
    if (user.getVoornaam() == null || user.getVoornaam().isBlank()) {
        console().printf("Je hebt geen geldige voornaam opgegeven");
        return;
    }
    if (user.getAchternaam() == null || user.getAchternaam().isBlank()) {
        console().printf("Je hebt geen geldige achternaam opgegeven");
        return;
    }
    console().printf("Je accountnaam is: %snn",
            user.getVoornaam().substring(0, 1) + user.getAchternaam());
}

public class PersonDataCapture {
    public Person getUserData() {
        user.setVoornaam(System.console().readLine("Wat is je voornaam? "));
        user.setAchternaam(System.console().readLine("Wat is je achternaam? "));
        return user;
    }
}

    PersonDataCapture input = new PersonDataCapture();
    Person user = input.getUserData();
        return;
    }
        return;
    }
}

public class PersonValidator {
    public boolean isValidUser(Person user) {
            return false;
        }
            return false;
        }
        return true;
    }
}

    PersonValidator validator = new PersonValidator();
    if (!validator.isValidUser(user)) {
        return;
    }
}

public class AccountGenerator {
    public String generateAccountFor(Person user) {
        return user.getVoornaam().substring(0, 1) + user.getAchternaam();
    }
}

        return;
    }
    AccountGenerator generator = new AccountGenerator();
    String accountnaam = generator.generateAccountFor(user);
    System.console().printf("Je accountnaam is: %snn", accountnaam);
}

        return;
    }
    AccountGenerator generator = new AccountGenerator();
    String accountnaam = generator.generateAccountFor(user);
    System.console().printf("Je accountnaam is: %snn",  
        accountnaam);
}
public class AccountGenerator {
    public String generateAccountFor(Person user) {
        return user.getVoornaam().substring(0, 1) + user.getA
    }
}
public class PersonValidator {
    public boolean isValidUser(Person user) {
        if (user.getVoornaam() == null || user.getVoornaam().isBlan
            console().printf("Je hebt geen geldige voornaam opgegev
            return false;
        }
        if (user.getAchternaam() == null || user.getAchternaam().is
            console().printf("Je hebt geen geldige achternaam opgeg
            return false;
        }
        return true;
    }
}
public class PersonDataCapture {
    public Person getUserData() {
        user.setVoornaam(console().readLine("Wat is je voorna
        user.setAchternaam(console().readLine("Wat is je acht
        return user;
    }
}

open for extension
closed for modiﬁcation

class Rectangle {
int width;
int height;
}

class AreaCalculator {
    public double area(Rectangle... rectangles) {
        double area = 0;
        for (var r : rectangles) {
            area += r.height * r.width;
        }
        return area;
    }
}
Rectangle r1 = new Rectangle();
r1.width = 2;
r1.height = 3;
var calc = new AreaCalculator();
System.out.println(calc.area(r1));

class Rectangle {
    int width;
    int height;
}
class Circle {
    int radius;
}

    public double area(Object... shapes) {
        double area = 0;
        for (var s : shapes) {
            if (s instanceof Rectangle) {
                var r = (Rectangle) s;
                area += r.height * r.width;
            } else if (s instanceof Circle) {
                var c = (Circle) s;
                area += c.radius * c.radius * Math.PI;
            }
        }
        return area;
    }
}

var rect = new Rectangle();
rect.width = 2;
rect.height = 3;
var circle = new Circle();
circle.radius = 2;
System.out.println(new AreaCalculator().area(rect, circle));

abstract class Shape {
    public abstract double area();
}
class Rectangle extends Shape {
    int height, width;
    public double area() {
        return width * height;
    }
}
class Circle extends Shape {
    int radius;
        return radius * radius * Math.PI;
    }
}

    public double area(Shape... shapes) {
        double area = 0;
        for (var s : shapes) {
            area += s.area();
        }
        return area;
    }
}

...in a computer program, if S is a
subtype of T, then objects of type T
may be replaced with objects of
type S without altering any of the
desirable properties of the program
(correctness, task performed, etc.)
wikipedia.org
Liskov substitution principle

Objecten moeten zich netjes
gedragen...
TLDR; principe

Waar een A verwacht
wordt, moet een B zich
gelijksoortig gedragen B
A

interface Sender {
    void send(String s);
}
class SmtpSender implements Sender {
    @Override
    public void send(String s) {
    }
}
class FtpSender implements Sender {
    @Override
    }
}

interface Sender {
}
    @Override
        if (s.startsWith("banaan"))
            throw new IllegalStateException();
    }
}
    @Override
    }
}

interface Sender {
}
    @Override
    public boolean send(String s) {
    }
}
    @Override
    public void send(Integer s) {
    }
}

class Filer {
    public boolean file(String x) throws FileAlreadyExistsException {
        return false;
    }
}

class Filer {
    public boolean file(String x) throws FileAlreadyExistsException {
        return false;
    }
}
class NetworkFiler extends Filer {
    public boolean file(String x)
            throws FileAlreadyExistsException, SocketException {
        return false;
    }
}

class Rectangle {
    private int width, height;
    public void setHeight(int h) {}
    public void setWidth(int w) {}
    public int getHeight() {}
    public int getWidth() {}
}
static void fillRect(Rectangle r) {
    r.setHeight(50);
    r.setWidth(150);
    assert (r.getHeight() == 50);
    assert (r.getWidth() == 150);
}
Rectangle r = new Rectangle();
fillRect(r);

class Rectangle {
    public void setHeight(int h) {}
    public void setWidth(int w) {}
    public int getHeight() {}
    public int getWidth() {}
}
class Square extends Rectangle {
    public void setHeight(int h) {
        super.setHeight(h);
        super.setWidth(h);
    }
    public void setWidth(int w) {
        super.setWidth(w);
        super.setHeight(w);
    }
} 
static void fillRect(Rectangle r) {
    r.setHeight(50);
    r.setWidth(150);
    assert (r.getHeight() == 50);
    assert (r.getWidth() == 150);
}
Square s = new Square();
s.setHeight(100);
fillRect(s);

No client should be forced to depend on
methods it does not use
wikipedia.org
Interface Segregation Principle

interface Shape {
    public double getArea();
    boolean isCongruentWith(Shape other);
    void draw();
}

interface Shape {
    void draw();
}
class Rectangle implements Shape {
    public double getArea() {
    }
    boolean isCongruentWith(Shape othe
    public void draw() {}
}

interface Shape {
    void draw();
}
    }
}
class Circle implements Shape {
    private int radius;
    }
    boolean isCongruentWith(Shape other)
}

interface Shape {
    void draw();
}
    }
}
class Circle implements Shape {
    private int radius;
    }
}
class Point implements Shape {
    private int x, y;
}

interface Drawable {
    void draw();
}
interface Shape {
    boolean congruentWith(Shape other);
}
interface Area extends Shape {
    double area();
}

    void draw();
}
interface Shape {
}
    double area();
}
class Rectangle implements Drawable,
Area, Shape {
    private int height, width;
    public void draw() {
}
    public boolean isCongruentWith(Shape
}
}
}

    void draw();
}
interface Shape {
}
    double area();
}
class Circle implements Drawable,
Area, Shape {
    private int radius;
}
    public boolean congruentWith(Shape ot
}
}
}

    void draw();
}
interface Shape {
}
    double area();
}
class Point implements Drawable, Shape {
    private int x, y;
}
    public boolean congruentWith(Shape ot
}
}

• Java Collections
• Java IO streams

Depend upon abstractions,  
not concretions

1. High-level modules should not depend
on low-level modules. Both should
depend on abstractions.
2. Abstractions should not depend on
details. Details should depend on
abstractions.
1. High-level modules should not depend
on low-level modules. Both should
depend on abstractions.
2. Abstractions should not depend on
details. Details should depend on
abstractions.

LeerlingDAOImpl RapportService
LeerlingDAO

Wanneer je het Open/Closed Principle
toepast, volgt "automatisch"  
Dependency Inversion
iemand op internet

SOLID

SOLID
GRASP
General
Responsibility
Assignment
Software
Patterns

SOLID GRASP
Het *wat* Het *hoe* en waarom

Refactoring
Code Ownership
Continuous Delivery

SOLID
DRY
YAGNI
GRASP
PATTERNS
REFACTORING

Meer lezen/zien?
• GRASP 
(wikipedia)
• Refactoring (2nd Edition)  
Martin Fowler (boek)
• Clean Code 
Robert C. Martin (boek)
• Readable code - and the long
lost secret of how to achieve it 
Christin Gorman (video, 10min)

SOLID principles

Recommandé

Recommandé

Contenu connexe

Similaire à SOLID principles

Similaire à SOLID principles (20)

Plus de Martijn Dashorst

Plus de Martijn Dashorst (20)

Dernier

Dernier (20)

SOLID principles