Este documento discute os conceitos e mitos em torno da Orientação a Objetos. Ele explica que OO é sobre passagem de mensagens e não modelagem do mundo real. Design é importante e deve evoluir conforme o entendimento do domínio. Herança deve ser usada com cuidado e composição é preferível.

1. O que você NÃO
aprendeu sobre
Orientação a
Objetos
Danilo Sato
@dtsato

2. Danilo Sato
@dtsato - www.dtsato.com
Desenvolvedor, Arquiteto, Coach, DevOps, Treinador

3. Como
aprendemos OO?

4. Orientação a Objetos é:
Herança +
Polimorfismo +
Encapsulamento

5. Orientação a Objetos é:
Modelar o Mundo Real

7. “A execução de um programa é considerada um
modelo físico, simulando o comportamento de
uma parte real ou imaginária do mundo."
-- Kristen Nygaard

9. “Programação orientada a objetos é uma
péssima ideia, que só poderia ter nascido na
Califórnia."
-- Edsger W. Dijkstra

10. “Programação orientada a objetos é uma
péssima ideia, que só poderia ter nascido na
Califórnia."
-- Edsger W. Dijkstra

12. “Na Ciência da Computação, arrogância é
medida em nano-Dijkstras"
-- Alan Kay

13. Inventou o termo “Orientação a
Objetos”

14. Inventou o termo “Orientação a
Objetos”
Smalltalk

15. Células

16. Inventou o termo “Orientação a
Objetos”

17. Inventou o termo “Orientação a
Objetos”
“OO significa passagem de mensagem,
retenção local, proteção e ocultação do estado
de um processo, e associação tardia de tudo"

18. Inventou o termo “Orientação a
Objetos”
“OO significa passagem de mensagem,
retenção local, proteção e ocultação do estado
de um processo, e associação tardia de tudo"
“A grande ideia é passagem de mensagem"

19. Inventou o termo “Orientação a
Objetos”
“OO significa passagem de mensagem,
retenção local, proteção e ocultação do estado
de um processo, e associação tardia de tudo"
“A grande ideia é passagem de mensagem"
“OO é um modelo computacional, não um
paradigma de programação"

22. “...(Erlang) é a única linguagem orientada a
objetos e talvez eu tenha sido prematuro em
dizer o que era orientação a objetos"
-- Joe Armstrong

27. Orientação a Objetos:
Programa?
Linguagem?
Paradigma?
Modelo Computacional?

28. Orientação a Objetos:
Programa?
Linguagem?
Paradigma?
Modelo Computacional?
Ninguém Concorda

29. Esta palestra
é sobre oo

30. Esta palestra
Não é sobre oo

31. Esta palestra
é sobre DESIGNDESIGN

32. O que é ?DESIGN

33. DESIGN Código==

34. DESIGN Código==
Estrutura
Organização
Flexibilidade
Testabilidade
Legibilidade
Coesão
Acoplamento
Dependências

35. BOM reduz o
custo da mudança
DESIGN

36. DESIGN

37. Hipótese da
stamina do DESIGN

38. Funcionalidades
Tempo

39. Funcionalidades
Tempo
Sem Design

40. Funcionalidades
Tempo
Bom Design
Sem Design

41. Funcionalidades
Tempo
Bom Design
Sem Design
Onde o design
se paga

43. 2004!

44. Design foi esquecido
Rails

45. Design foi esquecido
Rails
Model
View
Controller
Helper
Mailer
...

46. Model
View
Controller

47. Zero
Design
Design
Ágil
Up-front
Design

48. DESIGN É BOM
Design “ativo”

49. DESIGN É BOM
Design “passivo”

50. DESIGN É BOM
Design ágil == Design evolutivo

51. DESIGN É BOM
Design ágil == Design evolutivo

54. TUDO É UM
OBJETO!

55. TUDO É UM
OBJETO?

56. TUDO É UM
OBJETO?
class?

57. TUDO É UM
OBJETO?
if?
class?

58. TUDO É UM
OBJETO?
while?
if?
class?

59. Smalltalk

60. WARNING!
O código que você está prestes a ler foi escrito
com o propósito educacional. Não faça isso em
casa ou coloque código parecido em produção.

61. class TrueClass
def if_true(is_true, otherwise: -> {})
is_true.call
end
def if_false(is_false, otherwise: -> {})
otherwise.call
end
end
class FalseClass
def if_true(is_true, otherwise: -> {})
otherwise.call
end
def if_false(is_false, otherwise: -> {})
is_false.call
end
end
Condições

62. 2.0.0 > (2 > 1).if_true -> {
2.0.0?> puts "sim"
2.0.0?> }, otherwise: -> {
2.0.0?> puts "não"
2.0.0?> }
sim
=> nil
2.0.0 > (1 > 2).if_true -> {
2.0.0?> puts "sim"
2.0.0?> }, otherwise: -> {
2.0.0?> puts "não"
2.0.0?> }
não
=> nil
Condições

63. class Proc
def while_true(&blk)
self.call.if_true -> {
blk.call
while_true(&blk)
}
end
end
2.0.0?> i = 0
2.0.0?> -> {i < 3}.while_true do
2.0.0?> puts i
2.0.0?> i += 1
2.0.0?> end
0
1
2
=> nil
Loops

64. Herança

65. Herança
“É um”

66. Ave
Pato Pinguim
+ voa()
+ voa() + voa()

67. class Bird
def fly
puts "flap, flap, flap"
end
end
class Penguin < Bird
def fly
raise "I don't know how to fly"
end
end
flock = [Bird.new, Bird.new, Bird.new]
flock.each { |bird| bird.fly }
# >> flap, flap, flap
# >> flap, flap, flap
# >> flap, flap, flap

68. class Bird
def fly
puts "flap, flap, flap"
end
end
class Penguin < Bird
def fly
raise "I don't know how to fly"
end
end
flock = [Penguin.new, Penguin.new,
Penguin.new]
flock.each { |bird| bird.fly }
# ~> -:9:in `fly': I don't know how to fly
(RuntimeError)
# ~> from -:14:in `block in <main>'
# ~> from -:14:in `each'

69. Princípio de Substituição
de Liskov
Se S é um subtipo de T, então os
objetos do tipo T podem ser
substituídos pelos objetos de tipo
S em qualquer lugar do programa

71. Isto não é uma ave.Isto não é uma ave.

72. Herança
“É um”

73. Herança
“É um”

74. Herança

75. Herança
?

76. Herança

77. class Book < ActiveRecord::Base
def initialize(attributes = nil, options = {})
super
@my_cache = {}
end
def number_of_pages
@my_cache[:number_of_pages] ||= 10000
end
end
Book.create(
:title => "Lord of the Rings").number_of_pages
# => 10000
Book.find_by(
:title => "Lord of the Rings").number_of_pages
# ~> -:8:in `number_of_pages': undefined method
`[]' for nil:NilClass (NoMethodError)

78. class Book < ActiveRecord::Base
def after_initialize
@my_cache = {}
end
def number_of_pages
@my_cache[:number_of_pages] ||= 10000
end
end
Book.create(
:title => "Lord of the Rings").number_of_pages
# => 10000
Book.find_by(
:title => "Lord of the Rings").number_of_pages
# => 10000

79. Herança:
Preciso entender o
que a(s) classe(s)
Pai faz(em)!

80. class Deck < Array
def initialize
suits = %w(S H C D)
indexes = %w(A 2 3 4 5 6 7 8 9 10 J Q K)
cards = indexes.product(suits)
super(cards)
end
def draw(n)
self.pop(n)
end
end
deck = Deck.new
deck.shuffle!.draw(5) # => [["6", "H"], ["Q",
"H"], ["3", "C"], ["6", "S"], ["K", "C"]]
deck << ["A", "S"] << ["A", "S"]
deck.count { |card| card[0] == "A"} # => 6 aces?

81. Não use herança
se não usar todo
o comportamento
do(s) pais(s)

82. Herança é perigoso

83. Herança é perigoso

84. Herança é perigoso

85. Herança é perigoso

86. Herança é perigoso

87. Use Herança
quando há
especialização

88. Prefira
hierarquias
rasas

89. BigDecimal RationalComplexFloatInteger
Fixnum Bignum
Numeric

90. Agregação e
composição

91. Agregação Composição
“Tem um”

92. Agregação

93. Agregação

94. Agregação

95. composição

96. composição

97. composição

98. class Deck
def initialize
suits = %w(S H C D)
indexes = %w(A 2 3 4 5 6 7 8 9 10 J Q K)
@cards = indexes.product(suits)
end
def count(&blk); @cards.count(&blk) end
def <<(card)
@cards << card unless @cards.include?(card)
self
end
end
deck = Deck.new
deck << ["A", "S"] << ["A", "S"]
deck.count { |card| card[0] == "A"} # => 4

99. Prefira
composição ao
invés de Herança

100. Delegação

101. Delegação

102. require 'forwardable'
class Deck
extend Forwardable
def_delegator :@cards, :pop, :draw
def_delegators :@cards, :count
def initialize
suits = %w(S H C D)
indexes = %w(A 2 3 4 5 6 7 8 9 10 J Q K)
@cards = indexes.product(suits)
end
def <<(card)
@cards << card unless @cards.include?(card)
self
end
end
deck = Deck.new
deck.draw(5) # => [["Q", "D"], ["K", "S"], ["K",
"H"], ["K", "C"], ["K", "D"]]

103. polimorfismo

104. polimorfismo

105. polimorfismo

107. 1. Herança

108. 1. Herança
2. Duck Typing

109. 1. Herança
2. Duck Typing
3. Mixins

110. permite separar
abstração da
concretização

111. permite separar
“O que” do
“Como”

112. Princípio “Open-Closed”
Entidades de software como
classes, módulos e funções devem
ser abertas para extensão, mas
fechadas para modificação
-- Bertrand Meyer

113. MITO: Modelar OO é
modelar o mundo real

115. Actor
Ghost Pacman
center, direction
+ collidesWith(Actor)
+ advance(millis)
+ getNextDirection()

116. Actor
Ghost
Strategy
Pacman
Strategy
MovementStrategy
+ getNextDirection()

117. Actor
Random
Strategy
UserControl
Strategy
MovementStrategy
+ getNextDirection()

118. Actor
Random
Strategy
UserControl
Strategy
MovementStrategy
+ getNextDirection()
TargetChasing
Strategy
+ getTarget()

119. o design evolui
Conforme o
entendimento do
domínio evolui

120. [ ] Metallica (10)
[ ] Iron Maiden (5)
[ ] AC/DC (15)
[ ] ...
[ ] Black Album (5)
[ ] Master of
Puppets (5)
[ ] Killers (5)
[ ] ...
[x] Rock (50)
[ ] Clássico (100)
[ ] Jazz (80)
Filtros
Artista
Album
Estilo

121. class Song < ActiveRecord::Base
searchable do
string :title
string :album { album.title }
string :artist { album.artist.name }
...
end
def self.build_with_filters(p={})
search = Sunspot.new_search(Song)
search.build do
title = with(:title, p[:title]) if p[:title].present?
artist = with(:artist, p[:artist]) if p[:artist].present?
album = with(:album, p[:album]) if p[:album].present?
...
facet :artist, exclude: artist
facet :album, exclude: album
end
search
end
end

122. class Song < ActiveRecord::Base
...
def self.build_with_filters(p={})
search = Sunspot.new_search(Song)
if p[:artist]
to_reject = p[:artist_album].map do |artist_album|
JSON.parse(artist_album)['album']
end
p[:album].reject! do |element|
to_reject.include?(element)
end
p[:album] = [{}] if p[:album].empty?
end
search.build do
...
end
search
end
end

123. o domínio
não é música

124. o domínio
é busca

125. require 'forwadable'
module Search
class SongDocument
extend Forwardable
def_delegators :@song, :title
def initialize(song)
@song = song
end
def album
@song.album.title
end
def artist
@song.artist.name
end
...
end
end

126. module Search
class SongDocument
def self.search_filters(p={})
[
Search::OptionalFilter.new(:artist, p),
Search::AlbumFilter.new(:artist, :artist_album, p),
Search::OptionalFilter.new(:title, p)
]
end
def self.build_with_filters(filters, p={})
Sunspot.new_search(Song).tap do |search|
filters.each do |filter|
filter.apply_to(search)
end
Search::Faceter.new(filters, p).apply_to(search)
end
end
end
end

127. Busca
Música
Document
Filter
Facet
Indexer
Song
Album
Artist

128. Contextos
Delimitados
Busca
Música
Document
Filter
Facet
Indexer
Song
Album
Artist

129. Mapa de
Contextos
Busca
Música

131. “Todos os modelos estão errados,
alguns modelos são úteis"
-- George Box

132. MITO: Modelar OO é
modelar o mundo real

133. MITO: Modelar OO é
modelar o mundo real

134. Resumindo...

135. OO é passagem
de mensagem

136. Herança
agregação
Composição
delegação
polimorfismo

137. DESIGN É BOM
Zero
Design
Design
Ágil
Up-front
Design
Design ágil == Design evolutivo

138. DESIGN É BOM
Zero
Design
Design
Ágil
Up-front
Design
Design ágil == Design evolutivo

141. Não modele o
mundo real

142. modele o
seu domínio

143. aprenda o
seu domínio

144. evolua o
seu domínio

145. se divirta!

146. Obrigado!
Danilo Sato
@dtsato - www.dtsato.com
Desenvolvedor, Arquiteto, Coach, DevOps, Treinador

147. Referências
• “Practical Object-Oriented Design in Ruby” Sandi Metz
• “Domain-Driven Design: Tackling Complexity in the Heart of
Software” Eric Evans
• “Analysis Patterns: Reusable Object Models” Martin Fowler
• “Patterns of Enterprise Application Architecture” Martin Fowler
• “Design Patterns: Elements of Reusable Object-Oriented
Software” Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
• “Growing Object-Oriented Software, Guided by Tests” Steve
Freeman , Nat Pryce
• “Object-Oriented Software Construction” Bertrand Meyer
Livros: