1
00:00:00,040 --> 00:00:02,880
Olá, bem vindos a nossa conversa
de hoje. 

2
00:00:03,160 --> 00:00:07,160
Vamos explorar aqui 2 técnicas 
de refaturação de código que são

3
00:00:07,160 --> 00:00:11,520
bem interessantes, inline de 
método e movimentação de método.

4
00:00:11,920 --> 00:00:15,280
A gente está se baseando num 
trecho do livro engenharia de 

5
00:00:15,280 --> 00:00:20,080
software Moderna, do Marco Túlio
Valente, e a ideia é entender 

6
00:00:20,080 --> 00:00:23,120
melhor como essas práticas podem
dar uma organizada no código, 

7
00:00:23,120 --> 00:00:24,800
né? 
Facilitar a vida na hora da 

8
00:00:24,800 --> 00:00:27,600
manutenção. 
Exatamente, são assim 

9
00:00:27,600 --> 00:00:31,480
ferramentas que a gente usa para
refinar mesmo a estrutura do 

10
00:00:31,480 --> 00:00:35,480
software, garantir que cada 
pedacinho de lógica fique no 

11
00:00:35,480 --> 00:00:38,360
lugar mais mais sensato 
possível, sabe? 

12
00:00:38,440 --> 00:00:40,880
Vamos começar então pelo enlaine
de método? 

13
00:00:41,240 --> 00:00:44,440
Isso aí soa um pouco contra 
intuitivo, talvez porque 

14
00:00:44,440 --> 00:00:47,800
geralmente a gente ouve falar em
extrair métodos para organizar. 

15
00:00:47,800 --> 00:00:51,120
É, você tem um ponto. 
A extração é bem mais comum, com

16
00:00:51,120 --> 00:00:53,520
certeza. 
Mas o inline ele tem o seu 

17
00:00:53,520 --> 00:00:56,880
lugar, sim. 
Pensa num método que é Hum 

18
00:00:56,880 --> 00:01:02,200
minúsculo, uma linha talvez 2, e
que é chamado pouquíssimas vezes

19
00:01:02,200 --> 00:01:04,040
uhum. 
Nesses casos, sabe? 

20
00:01:04,040 --> 00:01:07,920
A abstração extra que ele cria 
pode acabar mais atrapalhando a 

21
00:01:07,920 --> 00:01:10,800
leitura do que ajudando. 
O custo de ter que pular pra 

22
00:01:10,800 --> 00:01:12,800
definição dele pode não 
compensar. 

23
00:01:13,280 --> 00:01:16,360
Ah, saquei. 
Então, em vez de ter o método 

24
00:01:16,360 --> 00:01:20,240
separado ali, fazendo quase 
nada, a gente simplesmente pega 

25
00:01:20,240 --> 00:01:24,000
aquele código e, bom, coloca 
direto onde ele IA ser chamado. 

26
00:01:24,600 --> 00:01:28,120
O livro até menciona um caso 
numa ideia Java famosa, né? 

27
00:01:28,120 --> 00:01:31,840
Isso menciona assim, era um 
método de uma linha só, usado 

28
00:01:31,880 --> 00:01:40,800
uma única vez. 
Entendi. 

29
00:01:41,320 --> 00:01:43,280
É uma otimização bem local, 
então? 

30
00:01:43,280 --> 00:01:45,560
Precisamente. 
Agora, se a gente pensar numa 

31
00:01:45,560 --> 00:01:50,760
escala maior, né, na organização
geral, aí entra a movimentação 

32
00:01:50,760 --> 00:01:54,000
de método. 
Enquanto o inlaine simplifica 

33
00:01:54,000 --> 00:01:57,520
dentro de um fluxo, a 
movimentação repensa onde uma 

34
00:01:57,520 --> 00:02:00,600
responsabilidade deveria morar 
no sistema, certo? 

35
00:02:01,440 --> 00:02:07,560
A ideia é que, sei lá, às vezes 
o método tá na classe a, mas ele

36
00:02:07,560 --> 00:02:10,639
parece muito mais ligado aos 
dados ou ao comportamento da 

37
00:02:10,639 --> 00:02:15,840
classe b mover pra b parece 
lógico, mas qual é o ganho real 

38
00:02:15,840 --> 00:02:18,880
disso, além de parecer mais 
organizado? 

39
00:02:19,160 --> 00:02:23,320
AO ganho é bem estratégico. 
Quando você move um método, 

40
00:02:23,320 --> 00:02:26,800
primeiro você aumenta a coesão 
da classe b ela passa a 

41
00:02:26,800 --> 00:02:29,440
concentrar mais 
responsabilidades, que são tipo 

42
00:02:29,440 --> 00:02:31,720
naturalmente dela, OK? 
E. 

43
00:02:31,760 --> 00:02:34,760
O que é muito importante, você 
diminui o acoplamento. 

44
00:02:34,880 --> 00:02:38,200
A classe anão precisa mais 
conhecer tanto a classe b ou 

45
00:02:38,200 --> 00:02:41,080
depender dela para executar 
aquela lógica específica. 

46
00:02:41,280 --> 00:02:45,360
Isso deixa as 2 classes mais. 
Independentes, mais fáceis de 

47
00:02:45,360 --> 00:02:48,400
entender sozinhas. 
Ah, agora faz mais sentido? 

48
00:02:48,560 --> 00:02:51,560
O objetivo é deixar o trabalho 
de cada classe mais. 

49
00:02:51,680 --> 00:02:55,440
Claro, mais alto contido. 
Teve aquele exemplo do livro 

50
00:02:55,440 --> 00:02:58,000
também, né? 
Moveram uma função que calculava

51
00:02:58,000 --> 00:03:00,640
umas médias. 
Isso essa função estava numa 

52
00:03:00,640 --> 00:03:04,480
classe de utilitários de teste. 
Que não tinha muito a ver, né? 

53
00:03:04,560 --> 00:03:07,160
Nada a ver. 
Aí moveram para uma classe de 

54
00:03:07,160 --> 00:03:11,000
utilitários de manipulação de 
arras, um lugar muito mais 

55
00:03:11,000 --> 00:03:14,440
lógico para ela. 
Perfeito, um exemplo claro de 

56
00:03:14,440 --> 00:03:19,240
realocação por lógica mesmo. 
Exato, mas olha, mover nem 

57
00:03:19,240 --> 00:03:23,400
sempre é tão simples assim. 
A parte mais crítica é atualizar

58
00:03:23,640 --> 00:03:27,280
todos os lugares que chamavam o 
método na localização antiga. 

59
00:03:27,480 --> 00:03:30,000
Imagino. 
Se o método for estático, como 

60
00:03:30,000 --> 00:03:33,440
nesse exemplo do cálculo de 
médias, geralmente é mais fácil,

61
00:03:33,760 --> 00:03:38,080
é só trocar o nome da classe na 
chamada tipo classe antiga ponto

62
00:03:38,080 --> 00:03:40,640
método vira classe nova ponto 
método. 

63
00:03:40,760 --> 00:03:45,560
Tá, isso parece gerenciável, mas
e se o método não for estático? 

64
00:03:45,800 --> 00:03:48,000
Aí complica, né? 
Porque ele pode usar coisas do 

65
00:03:48,000 --> 00:03:50,160
objeto original, o estado 
interno. 

66
00:03:50,320 --> 00:03:54,880
Exatamente aí que a coisa pega, 
métodos não estáticos, eles usam

67
00:03:54,880 --> 00:03:57,600
muito as variáveis da instância,
o zis, né? 

68
00:03:57,960 --> 00:04:01,520
Quando você move pra outra 
classe, vem a pergunta, como 

69
00:04:01,520 --> 00:04:04,720
essa nova classe vai acessar 
aquele estado? 

70
00:04:04,800 --> 00:04:07,360
É verdade? 
Aí você tem que começar a passar

71
00:04:07,360 --> 00:04:11,120
o objeto original como parâmetro
ou passar só os dados que o 

72
00:04:11,120 --> 00:04:14,360
método precisa. 
O que, ironicamente, pode até 

73
00:04:14,360 --> 00:04:16,959
aumentar um pouco o acoplamento 
que a gente queria diminuir 

74
00:04:16,959 --> 00:04:19,200
inicialmente. 
Que dilema e como é que o 

75
00:04:19,200 --> 00:04:22,400
pessoal lida com isso na prática
pra não quebrar tudo de uma vez 

76
00:04:22,400 --> 00:04:24,520
só? 
Bom, uma abordagem bem comum é 

77
00:04:24,520 --> 00:04:26,720
usar o que chamam de método 
delegador. 

78
00:04:27,120 --> 00:04:30,400
Você mantém um método bem 
simples na classe original, com 

79
00:04:30,400 --> 00:04:33,440
a mesma assinatura e tudo. 
Só que o único trabalho desse 

80
00:04:33,440 --> 00:04:37,400
método é é chamar o método lá na
nova casa dele, na outra classe.

81
00:04:37,760 --> 00:04:40,040
Funciona como uma ponte. 
Ah, que interessante. 

82
00:04:40,040 --> 00:04:43,400
Assim, quem chamava o método 
antigo nem percebe a mudança de 

83
00:04:43,400 --> 00:04:45,560
imediato. 
Continua funcionando. 

84
00:04:45,560 --> 00:04:47,480
Entendi. 
É tipo um redirecionamento 

85
00:04:47,480 --> 00:04:49,840
temporário para o código? 
Bem pensado isso. 

86
00:04:49,920 --> 00:04:52,760
Mas eu imagino que o lado ruim é
manter esse método fantasma ali,

87
00:04:52,760 --> 00:04:54,560
né? 
É uma camada a mais. 

88
00:04:54,560 --> 00:04:57,480
Sim, é uma indireção. 
É uma técnica útil 

89
00:04:57,480 --> 00:05:00,680
principalmente para transições 
em base de código muito grandes,

90
00:05:00,680 --> 00:05:03,120
sabe? 
Mas o ideal, claro, ao longo 

91
00:05:03,120 --> 00:05:06,560
prazo, seria atualizar as 
chamadas para serem diretas. 

92
00:05:06,560 --> 00:05:08,800
Faz sentido? 
E tem outras variações 

93
00:05:08,800 --> 00:05:11,800
importantes também, né? 
Como mover métodos na hierarquia

94
00:05:11,800 --> 00:05:14,200
de herança? 
Ah, sim, você mencionou isso, é?

95
00:05:14,200 --> 00:05:17,360
Tem o pull up método. 
Quando você pega um método que 

96
00:05:17,360 --> 00:05:20,640
está repetido em várias 
subclasses e puxa ele para cima 

97
00:05:20,640 --> 00:05:24,560
para superclasse comum, evita 
duplicação legal e o postar, o 

98
00:05:24,560 --> 00:05:26,960
método é o contrário. 
Você pega um método da 

99
00:05:26,960 --> 00:05:30,400
superclasse que só é usado por 
uma subclasse específica, e 

100
00:05:30,400 --> 00:05:32,520
empurra ele para baixo para essa
subclasse. 

101
00:05:32,520 --> 00:05:36,680
Pull up, push down. 
Os nomes ajudam a visualizar e 

102
00:05:36,680 --> 00:05:38,840
essas refaturações, elas não 
precisam ser feitas 

103
00:05:38,840 --> 00:05:41,960
isoladamente, né? 
Dá para combinar, tipo primeiro 

104
00:05:42,120 --> 00:05:46,200
extrair um trecho para um método
novo e depois mover esse método.

105
00:05:46,280 --> 00:05:49,880
Com certeza, refaturação é um 
processo contínuo, sabe? 

106
00:05:50,040 --> 00:05:52,680
Muitas vezes é uma sequência 
desses pequenos passos. 

107
00:05:52,920 --> 00:05:56,160
São ferramentas assim essenciais
para a gente ir melhorando a 

108
00:05:56,160 --> 00:05:59,360
saúde do código aos poucos, de 
forma segura. 

109
00:05:59,360 --> 00:06:01,200
Ótimo. 
Então, resumindo o que a gente 

110
00:06:01,200 --> 00:06:05,040
viu hoje, o enline de método 
serve mais para simplificar 

111
00:06:05,040 --> 00:06:08,400
localmente, né? 
Tirar umas abstrações que não 

112
00:06:08,400 --> 00:06:12,240
ajudam tanto. 
Já a movimentação de método é 

113
00:06:12,240 --> 00:06:15,120
para reorganizar mesmo as 
responsabilidades entre as 

114
00:06:15,120 --> 00:06:17,280
classes. 
Isso para melhorar a coesão, 

115
00:06:17,280 --> 00:06:20,680
diminuir o acoplamento. 
Deixando o código mais claro e 

116
00:06:20,680 --> 00:06:22,360
organizado. 
Esse é o espírito. 

117
00:06:22,640 --> 00:06:26,120
O objetivo final é sempre ter um
código mais claro, com uma 

118
00:06:26,120 --> 00:06:30,080
estrutura mais lógica e claro 
que seja mais fácil de manter e 

119
00:06:30,080 --> 00:06:31,920
de evoluir no futuro. 
Perfeito. 

120
00:06:32,200 --> 00:06:34,920
Essa análise foi muito boa, bem 
esclarecedora. 

121
00:06:34,920 --> 00:06:36,560
Obrigado a todos que nos 
acompanharam. 

122
00:06:36,560 --> 00:06:38,000
Valeu. 
Pessoal, até a próxima.