Java OOP Done Right

Preface

Optimise for Clarity

What is an object, anyway?

1. What’s all this got to do with Java?
2. A simple example: Greeting users
3. The big idea: calling code is simple
4. Object Oriented Design is Behaviour Driven Design

Clean Code

1. Good Names
2. Design methods around behaviours, not data
3. Hidden data - No getters, no setters

Aggregates: More than one

1. Greeting more than one user
2. Using forEach - not a loop
3. Aggregate methods work on all the things

Collaboration

1. Basic Mechanics
2. Example: Simple Point of Sale

Test Driven Development

1. Outside-in design with TDD
2. First test: total starts at zero
3. Arrange, Act, Assert - a rhythm inside each test
4. Red, Green, Refactor - a rhythm in between tests
5. Second test: Adding an item gives us the right total
6. Designing the second feature
7. TDD Steps - Too much? Too little?
8. YAGNI - You Ain’t Gonna Need It
9. YAYA - Yes, You Are
10. Optimise for Clarity with well-named tests
11. TDD and OOP - A natural fit
12. FIRST Tests are usable tests
13. Real-world TDD

Polymorphism - The Jewel in the OOP Crown

1. Classic example: Shape.draw()
2. The Shape Interface
3. Tell Don’t Ask - the key to OOP

The SOLID Principles

1. The five SOLID principles
2. SRP Single Responsibility - do one thing well
3. DIP Dependency Inversion: Bring out the Big Picture
4. LSP Liskov Substitution Principle - Making things swappable
5. OCP Open/Closed Principle - adding without change
6. ISP Interface Segregation Principle - honest interfaces

TDD and Test Doubles

1. Test Doubles - Stubs and Mocks
2. DIP for Unit Tests - Stubs and Mocks
3. Mocking libraries
4. Self-Shunt mocks and stubs

Refactoring

1. What is refactoring?
2. Rename Method, Rename Variable
3. Extract Method
4. Change Method Signature
5. Extract Parameter Object
6. Can we refactor anything into anything else?

Hexagonal Architecture

1. The problems of external systems
2. The Test Pyramid
3. Removing external systems
4. The Hexagonal Model
5. Inversion / Injection: Two sides of the same coin

Handling Errors

1. Three kinds of errors
2. The null reference
3. Null object pattern
4. Zombie object
5. Exceptions - a quick primer
6. Design By Contract, Bertrand Meyer style
7. Fatal errors: Stop the world!
8. Combined approach: Fixable and non-fixable errors
9. Which approach is best?
10. NullPointerException
11. Application Specific Exceptions
12. Error object
13. Optionals - Java 8 streams approach
14. Review: Which approach to use?

Design Patterns

1. Mechanism and Domain
2. Patterns: Not libraries, not frameworks
3. Strategy
4. Observer
5. Adapter
6. Command
7. Composite
8. Facade
9. Builder
10. Repository
11. Query
12. CollectingParameter
13. Item-Item Description
14. Moment-Interval
15. Clock
16. Rules (or Policy)
17. Aggregate
18. Cache
19. Decorator
20. External System (Proxy)
21. Configuration
22. Order-OrderLineItem
23. Request-Service-Response
24. Anti-Patterns

OOP Mistakes - OOP oops!

1. Broken Encapsulation - Getters Galore!
2. Broken Inheritance
3. Bird extends Animal
4. Square extends Rectangle
5. Inheriting implementation
6. Broken Shared State
7. Ordinary Bad Code

Data Structures and Pure Functions

1. System Boundaries
2. Fixed Data, Changing Functions
3. Algorithms and Data Structures

Putting It All Together

1. No step-by-step plans
2. Getting Started
3. Perfection and Pragmatism
4. Getting Past Stuck

Further Reading

1. Agile Software Development, Robert C Martin
2. Growing Object Oriented Software Guided By Tests, Freeman and Pryce
3. Refactoring, Martin Fowler
4. Design Patterns Helm, Johnson, Richards, Vlissides
5. Domain Driven Design, Eric Evans
6. Applying UML with Patterns, Craig Larman
7. Home page for this book
8. My Blog
9. My Quora Space
10. LinkedIn
11. LeanPub page

Cheat Sheet

1. Behaviours First
2. Design Principles
3. Clean Code
4. General Code Review Points

About the Author

1. Thanks

Buy the book!