Linguagens Dinâmicas são Melhores para Implementar OO

Palestra apresentada na RubyConf Brasil 2012

Transcript

1. Linguagens Dinâmicas São Melhores para Implementar OO Cássio Marques - RubyConf Brasil 2012
2. @cassiomarques http://cassiomarques.wordpress.com
4. Avisos
5. Muita coisa pra mostrar
6. Vamos ter que correr!
7. Muito código!
8. Não só para Rubistas :)
9. Por que usamos linguagens orientadas a objetos?
10. Maior nível de abstração
11. Facilidade para modelar o domínio do problema
12. Estado + Comportamento = Objetos
13. Encapsulamento
14. Melhor organização do código
15. Facilidade para evoluir o código em iterações
16. Separação de responsabilidades
17. História
18. Simula 67 Kristen Nygaard and Ole-Johan Dahl - Noruega (Tipagem estática)
19. Smalltalk Alan Kay - 70’s (Tipagem dinâmica)
20. C++ Bjarne Stroustrup - 1979 (Tipagem estática)
21. Java James Gosling - 1995 (Tipagem estática)
22. Ruby Yukihiro Matsumoto - 1995 (Tipagem dinâmica)
23. Herança
24. C++ permite herança múltipla
25. class FlyingAnimal { public: void fly() { cout << "Flying..." << endl; } };
26. class Feline { public: void talk() { cout << "Meow!" << endl; } };
27. class FlyingCat : public FlyingAnimal, public Feline { };
29. Java não permite herança múltipla
30. package br.com.rubyconf; public class FlyingAnimal { public void fly() { System.out.println("Flying..."); } }
31. package br.com.rubyconf; public class Feline { public void talk() { System.out.println("Meow!"); } }
32. package br.com.rubyconf; // Não funciona! public class FlyingCat extends FlyingAnimal, Feline { }
33. Java Interfaces
34. package br.com.rubyconf; public interface Feline { public void talk(); }
35. package br.com.rubyconf; public interface FlyingAnimal { public void fly(); }
36. package br.com.rubyconf; public class FlyingCat implements FlyingAnimal,Feline { public void talk() { // implementation... } public void fly() { // implementation... } }
37. Cria-se um contrato formal
38. Eu quero ter uma implementação padrão!!!
39. Porque herança múltipla é ruim?
40. class A { public: void foo() { cout << "calling A's implementation" << endl; }; };
41. class B : public A { public: void foo() { cout << "calling B's implementation" << endl; } }; class C : public A { public: void foo() { cout << "calling C's implementation" << endl; } };
42. class D : public B, public C { }; int main (int argc, char const* argv[]) { D d = D(); d.foo(); return 0; }
43. teste.cpp|50 error| error: request for member ‘foo’ is ambiguous teste.cpp|26 error| error: candidates are: void A::foo() teste.cpp|39 error| error: void C::foo() teste.cpp|33 error| error: void B::foo()
44. Ruby
45. Também não tem herança múltipla
46. Mas temos modules
47. Mixins
48. module Sellable def price 15.00 end end module Discountable def discount 0.1 end end
49. class Product include Sellable include Discountable def price super - super * discount end end item = Product.new puts item.price # 13.5
50. ou em tempo de execução...
51. class Product end product = Product.new puts product.price # undefined method `price' for #<Product: 0x00000105ab7e70> (NoMethodError)
52. Product.instance_eval { include Sellable } puts product.price # 15.0
53. module Discountable def discount 0.1 end def price_with_discount price - price * discount end end
54. product.extend Discountable puts product.price_with_discount # 13.5
55. ou
56. Product.instance_eval { include Discountable } puts product.price_with_discount # 13.5
57. Mas como isso funciona?
58. Object model do Ruby
59. class BaseClass # ... end class OurClass < BaseClass # ... end some_object = OurClass.new some_object.do_something
60. some_object.do_something Singleton class OurClass included modules included modules BaseClass Object (nativo) Module Kernel (nativo) BasicObject (nativo) undefined method `do_something' for #<OurClass: 0x0000010450fe88> (NoMethodError)
61. Podemos incluir quantos “mixins” quisermos
62. Sempre saberemos qual versão do método será executada
63. Podemos adicionar comportamento em tempo de execução
64. Classes abstratas
65. C++
66. class Vehicle { public: void virtual move() = 0; void setColor(string _color) { color = _color; } private: string color; };
67. class Car : public Vehicle { public: void move() { cout << "Moving..." << endl; } };
68. Java
69. package br.com.rubyconf; public abstract class Vehicle { private String color; public abstract void move(); public void setColor(String color) { this.color = color; } }
70. package br.com.rubyconf; public class Car extends Vehicle { public void move() { System.out.println("Moving..."); } }
71. Ruby
72. class Vehicle def move raise NotImplementedError end end
73. class Car < Vehicle def move puts "Moving..." end end
74. Não precisamos de classes abstratas em Ruby
75. Em Ruby não há como definir um contrato formal
76. O comportamento de um tipo pode mudar em tempo de execução
77. Exemplo: Enumerable
78. Faz com que um objeto se comporte como uma coleção de objetos
79. Contrato informal: é preciso que a classe que inclui o module Enumerable defina um método each
80. class Book attr_accessor :title def initialize(title) self.title = title end end
81. class Library include Enumerable def initialize @books = [] end def add_book(book) @books << book end def each @books.each { |book| yield book } end end
82. library = Library.new library.add_book Book.new("Book 1") library.add_book Book.new("Book 2") library.add_book Book.new("Book 3") library.each { |book| puts book.title } # Book 1 # Book 2 # Book 3
83. Polimorfismo
84. C++
85. class Tax { public: float virtual dueValue() = 0; float virtual retainedValue() = 0; string virtual getName() = 0; Tax(float _value) {} protected: float value; };
86. class Irpj : public Tax { public: Irpj(float _value) : Tax(_value) { this->value = _value; } float dueValue() { return value * 0.033; } float retainedValue() { return value * 0.015; } string getName() { return "IRPJ"; } };
87. class Pis : public Tax { public: Pis(float _value) : Tax(_value) { this->value = _value; } float dueValue() { return 0.0; } float retainedValue() { return value * 0.0065; } string getName() { return "PIS"; } };
88. class Invoice { public: Invoice(float _value) { value = _value; Irpj *irpj = new Irpj(value); Pis *pis = new Pis(value); taxes.push_back(irpj); taxes.push_back(pis); } void print() { for (unsigned int i = 0; i < taxes.size(); i++) { Tax *tax = taxes[i]; cout << tax->getName() << endl; cout << "Devido: R$" << tax->dueValue() << endl; cout << "Retido: R$" << tax->retainedValue() << endl; } } private: float value; vector<Tax*> taxes; };
89. int main (int argc, char const* argv[]) { Invoice invoice = Invoice(1000.00); invoice.print(); return 0; } // IRPJ // Devido: R$33 // Retido: R$15 // PIS // Devido: R$0 // Retido: R$6.5
90. Java
91. package br.com.rubyconf; public interface Tax { double dueValue(); double retainedValue(); String getName(); }
92. public class Irpj implements Tax { private double value; public Irpj(double value) { this.value = value; } public double dueValue() { return value * 0.033; } public double retainedValue() { return value * 0.015; } public String getName() { return "IRPJ"; } }
93. public class Pis implements Tax { private double value; public Pis(double value) { this.value = value; } public double dueValue() { return 0.0; } public double retainedValue() { return value * 0.0065; } public String getName() { return "PIS"; } }
94. public class Invoice { private List<Tax> taxes = new ArrayList<Tax>(); private double value; public Invoice(double value) { this.value = value; Irpj irpj = new Irpj(this.value); Pis pis = new Pis(this.value); taxes.add(irpj); taxes.add(pis); } public void print() { for(Tax tax : taxes) { System.out.println(tax.getName()); System.out.println("Devido: R$" + tax.dueValue()); System.out.println("Retido: R$" + tax.retainedValue()); } } }
95. package br.com.rubyconf; public class Main { public static void main(String[] args) { Invoice invoice = new Invoice(1000.00); invoice.print(); } } //IRPJ //Devido: R$33.0 //Retido: R$15.0 //PIS //Devido: R$0.0 //Retido: R$6.5
96. Ruby
97. module Tax attr_reader :value def initialize(value) @value = value end end
98. class Irpj include Tax def name "IRPJ" end def retained_value value * 0.015 end def due_value value * 0.033 end end
99. class Pis include Tax def name "PIS" end def retained_value value * 0.0065 end def due_value 0.0 end end
100. class Invoice def initialize(value) @value = value @taxes = [] @taxes << Irpj.new(value) @taxes << Pis.new(value) end def print @taxes.each do |tax| puts tax.name puts "Devido: R$#{tax.due_value}" puts "Retido: R$#{tax.retained_value}" end end end
101. invoice = Invoice.new(1000.0) invoice.print # IRPJ # Devido: R$33.0 # Retido: R$15.0 # PIS # Devido: R$0.0 # Retido: R$6.5
102. Sobrecarga de métodos
103. C++
104. class Printer { public: void print(Report report) { // ... } void print(Note note) { // ... } void print(Document document) { // ... } };
105. Java
106. public class Printer { public void print(Document document) { // ... } public void print(Note note) { // ... } public void print(Report report) { // ... } }
107. Ruby
108. class Printer def print(printable) # ... end end
109. E se a implementação para cada tipo de “printable” for diferente?
110. class Printer def print(printable) case printable when Document print_document printable when Note print_note printable when Report print_report printable end end private def print_document(printable) # ... end def print_note(printable) # ... end def print_report(printable) # ... end end
111. Qual a vantagem?!
112. Somente uma forma de chamar o método
113. Implementação interna está encapsulada
114. Tipos genéricos
115. C++
116. template <class Printable> class Printer { public: void print(Printable printable) { cout << "Printing a " << typeid(printable).name() << endl; } };
117. int main (int argc, char const* argv[]) { Printer<Note> printer = Printer<Note>(); printer.print(Note()); return 0; }
118. Java
119. public class Printer<Printable> { public void print(Printable document) { System.out.println("Printing a " + document); } }
120. public class Main { public static void main(String[] args) { Printer<Document> printer = new Printer<Document>(); printer.print(new Document()); } }
121. Ruby
122. class Printer def print(printable) puts "Printing a #{printable.class.name}..." end end
123. Coleções genéricas
124. C++
125. template <class Printable> class Printer { public: Printer() { printables = vector<Printable>(); } void print(Printable printable) { cout << "Printing a " << typeid(printable).name() << endl; } void addPrintable(Printable printable) { printables.push_back(printable); } void printAll() { for (int i = 0; i < printables.size(); i++) { print(printables[i]); } } private: vector<Printable> printables; };
126. Java
127. public class Printer<Printable> { private List<Printable> printables = new ArrayList<Printable>(); public void addPrintable(Printable printable) { printables.add(printable); } public void print(Printable document) { System.out.println("Printing a " + document); } public void printAll() { for(Printable printable : printables) { print(printable); } } }
128. public class Main { public static void main(String[] args) { Printer<Document> printer = new Printer<Document>(); Document doc1 = new Document(); Document doc2 = new Document(); printer.addPrintable(doc1); printer.addPrintable(doc2); printer.printAll(); } }
129. Ruby
130. class Printer def initialize @printables = [] end def add_printable(printable) @printables << printable end def print(printable) puts "Printing a #{printable.class.name}..." end def print_all @printables.each { |p| print p } end end
131. printer = Printer.new doc1 = Document.new printer.add_printable doc1 doc2 = Document.new printer.add_printable doc2 printer.print_all
132. e ainda...
133. printer = Printer.new doc = Document.new printer.add_printable doc1 note = Note.new printer.add_printable note report = Report.new printer.add_printable report foo = Foobar.new printer.add_printable foo printer.print_all
134. Desde que instâncias de FooBar respondam aos métodos necessários para serem “impressos”, vai funcionar :)
135. Testes
136. Mocks e stubs
137. Adicionar itens a um carrinho e calcular o valor total
138. C++
139. class TotalCalculatorInterface { public: virtual ~TotalCalculatorInterface() = 0; virtual double total() = 0; };
140. class TotalCalculatorWithDiscount : public TotalCalculator { private: double discountPercentage; public: TotalCalculatorWithDiscount(double discountPercentage) { this->discountPercentage = discountPercentage; } double total(vector<LineItem> items) { double t = 0.0; for (unsigned int i = 0; i < items.size(); i++) { t += items[i].getTotal(); } return t - (t * discountPercentage/100); } };
141. class Cart { private: vector<LineItem> items; TotalCalculator *calculator; public: Cart(TotalCalculator *calculator) { this->calculator = calculator; } vector<LineItem> getItems() { return items; } double getTotal(); }; double Cart::getTotal() { return calculator->total(); }
142. class MockTotalCalculator : public TotalCalculator { public: virtual ~MockTotalCalculator() { } MOCK_METHOD1(total, double(vector<LineItem> items)); };
143. TEST(Cart, ReturnsTotalValue) { MockTotalCalculator calculator; LineItem lineItem1 = LineItem(10.0, 2); LineItem lineItem2 = LineItem(15.0, 3); Cart cart = Cart(calculator); cart.addItem(lineItem1); cart.addItem(lineItem2); vector<LineItem> items; items.push_back(line_item1); items.push_back(line_item2); EXPECT_CALL(calculator, total(items)) .WillOnce(Return(65.00)); EXPECT_EQ(cart.getTotal(), 65.00); }
144. Java
145. public interface TotalCalculator { public double total(List<LineItem> items); }
146. public class TotalCalculatorWithDiscount implements TotalCalculator { private double percentageDiscount; public TotalCalculatorWithDiscount(double percentageDiscount) { this.percentageDiscount = percentageDiscount; } public double total(List<LineItem> items) { double t = 0.0; for(LineItem item : items) { t += item.getTotal(); } return t - (t * percentageDiscount/100.0); } }
147. public class Cart { private List<LineItem> items = new ArrayList<LineItem>(); private TotalCalculator calculator; public Cart(TotalCalculator calculator) { this.calculator = calculator; } public void addItem(LineItem item) { items.add(item); } public double getTotal() { return calculator.total(items); } }
148. import static org.mockito.Mockito.*; public class TestCart { @Test public void calculatesTotalValue() { LineItem item1 = mock(LineItem.class); LineItem item2 = mock(LineItem.class); List<LineItem> items = new ArrayList<LineItem>(); TotalCalculator mockedCalculator = mock(TotalCalculator.class); items.add(item1); items.add(item2); when(mockedCalculator.total(items)).thenReturn(65.00); Cart cart = new Cart(mockedCalculator); cart.addItem(item1); cart.addItem(item2); assertEquals(cart.getTotal(), 65.00, 0.0001); verify(mockedCalculator).total(items); } }
149. Ruby
150. class TotalCalculatorWithDiscount def initialize(percentage_discount) @percentage_discount = percentage_discount end def total(items) t = items.inject(0.0) { |total, item| total += item.total } t - (t * percentage_discount / 100.0) end end
151. class Cart attr_reader :items def initialize(calculator) @items = [] @calculator = calculator end def add_item(item) @items << item end def total @calculator.total items end end
152. describe Cart do describe "#total" do it "calculates the cart's total" do calculator = stub item1 = stub item2 = stub calculator.should_receive(:total) .with([item1, item2]).and_return(65.00) cart = Cart.new calculator cart.add_item item1 cart.add_item item2 cart.total.should == 65.00 end end end
153. CONCLUSÕES
154. Em linguagens estáticas, o importante é saber o tipo de um objeto
155. Se você sabe o tipo, você sabe a quais contratos o objeto atende (quais métodos são implementados)
156. Em Ruby, o importante é o que um objeto sabe fazer
157. As regras de negócio já são suficientemente complexas
158. Não precisamos da complexidade da linguagem
159. Tipagem estática só garante que você vai fornecer os tipos corretos
160. Você não está protegido contra erros de lógica :)
161. Esse tipo de erro você pode eliminar escrevendo testes automatizados
162. Você deveria estar fazendo isso independentemente da tipagem da linguagem
163. Código mais claro é melhor do que código mais rápido (na maioria das vezes)
164. ?
165. Obrigado :)