Java beginners meetup: Introduction to class and application design

INTRODUCTION TO CLASS AND APPLICATION
DESIGN
PATRICK KOSTJENS
Java Beginners Meetup, May 2017
1

ABOUT ME
PATRICK KOSTJENS
So ware developer
2

WHY DO WE CARE?
Easier to understand
Maintainability
Team projects
Reuseability
Long term productivity
Reduce errors
4

HOW TO MAKE SURE?
Ask others
Easy to write unit tests?
Look at it later (a week, a month)
5

NAMING MATTERS
public int[] run(int[] x) {
int y;
for (int i = 1; i < x.length; i++) {
for (int j = i; j > 0; j--) {
if (x[j] < x[j - 1]) {
y = x[j];
x[j] = x[j - 1];
x[j - 1] = y;
}
}
}
return x;
}

public int[] doInsertionSort(int[] input) {
int temp;
for (int i = 1; i < input.length; i++) {
for (int j = i; j > 0; j--) {
if (input[j] < input[j - 1]) {
temp = input[j];
input[j] = input[j - 1];
input[j - 1] = temp;
}
}
}
return input;
}
7 . 2

KEEP THINGS SMALL
Small methods
Small classes
Small packages
No deep nesting
Limited number of parameters
No duplication
Use local context as much as possible
Use common sense
Small slides
The magic number 7
8

COMPOSITION
Object composition is a way to combine simple objects
or data types into more complex ones.
- Michelle Yaiser

ENCAPSULATION
A mechanism to hide implementation details so that only the necessary
information is exposed.

Bad
public class Employee {
public BigDecimal salary = new BigDecimal(50000.00);
}
10 . 2

Good
public class Employee {
private BigDecimal salary = new BigDecimal(50000.00);
public BigDecimal getSalary() {
return salary;
}
public void setSalary(BigDecimal salary) {
this.salary = salary;[
}
}
10 . 3

INHERITANCE
Inheritance means a class is based on another class.

public class Animal {
// Animal implementation
}
public class Dog extends Animal {
// Specific Dog functionality
}
public class Cat extends Animal {
// Specific Cat functionality
}
11 . 2

INTERFACES
A set of methods that can be implemented by one or more classes.

public interface Displayable {
void display();
}
public class Paper implements Displayable {
public void display() {
// Implementation to display using Paper
}
}
public class Monitor implements Displayable {
public void display() {
// Implementation to display using Monitor
}
}
12 . 2

DESIGN PATTERNS AND PRINCIPLES
13

DESIGN PATTERNS
Higher level of abstraction
Prevent duplication
Help encapsulation
Help keep things small
There are many, we'll discuss a few
14

Single responsibility principle
Open/closed principle
Liskov subsitution principle
Interface segregation principle
Dependency inversion principle
SOLID
15

BUILDER PATTERN
Helps with immutability
Reduces parameters
Hides implementation well

Hard to read/use
public class BankAccount {
private final String accountNumber;
private final String name;
private BigDecimal balance;
private final List<Transaction> transactions;
private final DateTime creationDate;
private final List<Contractant> contractants;
public BankAccount(String accountNumber, String name, BigDecimal balance, List<Transaction
DateTime creationDate, List<Contractant> contractants) {
this.accountNumber = accountNumber;
this.name = name;
this.balance = balance;
this.transactions = transactions;
this.creationDate = creationDate;
this.contractants = contractants;
}
// Getters
}
new BankAccount("NL12BANK345667", "TestAccount", new BigDecimal(100), transactions, new DateTi
16 . 2

Improved version
public class BankAccount {
private final String accountNumber;
private final String name;
private final List<Transaction> transactions;
private final DateTime creationDate;
private final List<Contractant> contractants;
private BankAccount(String accountNumber, String name, BigDecimal balance, List<Transactio
DateTime creationDate, List<Contractant> contractants) {
this.accountNumber = accountNumber;
this.name = name;
this.balance = balance;
this.transactions = transactions;
this.creationDate = creationDate;
this.contractants = contractants;
}
public static class Builder {
private String accountNumber;
private String name;
private List<Transaction> transactions;
private DateTime creationDate;

Usage
Longer, but easier to read
new BankAccount.Builder()
.withAccountNumber("NL12BANK345667")
.withName("TestAccount")
.withBalance(new BigDecimal(100))
.withContractants(contractants)
.withCreationDate(new DateTime(1980, 1, 1))
.withTransactions(transactions)
.createBankAccount();
16 . 4

SINGLETON PATTERN
Use the singleton pattern when you want only one instance of a class in the
entire system.

public final class Singleton {
private static final Singleton INSTANCE = new Singleton();
private Singleton() {}
public static Singleton getInstance() {
return INSTANCE;
}
}
17 . 2

EXERCISE
Take one of your projects and try to check and improve on the things we
discussed.
Try to discuss your solutions and improvements with each other.
20

BOOKS
And many others
Code Complete, Steve McConnel
The Pragmatic Programmer, Andrew Hunt, David
Thomas
Clean Code, Robert C. Martin
Agile So ware Development, Robert C. Martin
21

FINAL REMARKS
Carefully pick names
Don't add unnecessary complexity
No single right or wrong way
Practice
22

Java beginners meetup: Introduction to class and application design

More Related Content

What's hot (16)

Similar to Java beginners meetup: Introduction to class and application design (20)

Recently uploaded (20)

Java beginners meetup: Introduction to class and application design