Apostila SENAI Programação Orientada A Objetos

SÉRIE TECNOLOGIA DA INFORMAÇÃO - HARDWARE
PROGRAMAÇÃO
ORIENTADA A
OBJETO
CONFEDERAÇÃO NACIONAL DA INDÚSTRIA – CNI
Robson Braga de Andrade

Presidente
DIRETORIA DE EDUCAÇÃO E TECNOLOGIA – DIRET
Rafael Esmeraldo Lucchesi Ramacciotti

Diretor de Educação e Tecnologia
Julio Sergio de Maya Pedrosa Moreira

Diretor Adjunto de Educação e Tecnologia
SERVIÇO NACIONAL DE APRENDIZAGEM INDUSTRIAL – SENAI
Conselho Nacional
Robson Braga de Andrade

Presidente
SENAI – Departamento Nacional
Rafael Esmeraldo Lucchesi Ramacciotti

Diretor-Geral
Julio Sergio de Maya Pedrosa Moreira

Diretor Adjunto de Educação e Tecnologia
Gustavo Leal Sales Filho

Diretor de Operações
TECNOLOGIA DA INFORMAÇÃO - HARDWARE
PROGRAMAÇÃO
ORIENTADA A
OBJETO
© 2018. SENAI – Departamento Nacional
© 2018. SENAI – Departamento Regional de Santa Catarina
A reprodução total ou parcial desta publicação por quaisquer meios, seja eletrônico, mecâ-
nico, fotocópia, de gravação ou outros, somente será permitida com prévia autorização, por
escrito, do SENAI.
Esta publicação foi elaborada pela equipe de Educação a Distância do SENAI de Santa Cata-
rina, com a coordenação do SENAI Departamento Nacional, para ser utilizada por todos os
Departamentos Regionais do SENAI nos cursos presenciais e a distância.
SENAI Departamento Nacional

Unidade de Educação Profissional e Tecnológica - UNIEP
SENAI Departamento Regional de Santa Catarina

Gerência de Educação e Tecnologia - GEDUT
FICHA CATALOGRÁFICA
S491p
Serviço Nacional de Aprendizagem Industrial. Departamento Nacional.
Programação orientada a objeto / Serviço Nacional de Aprendizagem
Industrial. Departamento Nacional, Serviço Nacional de Aprendizagem Industrial.
Departamento Regional de Santa Catarina. Brasília : SENAI/DN, 2018.
246 p. il. (Série Tecnologia da Informação – Hardware).
ISBN 978 - 85 - 505 - 2326 - 2
1. Programação orientada a objetos (Computação). 2. Programação

(Computadores). 3. Scrum (Desenvolvimento de software). 4. Desenvolvimento
organizacional. 5. Segurança do trabalho - Informática. I. Serviço Nacional de
Aprendizagem Industrial. Departamento Regional de Santa Catarina. II. Título. III.
Série.
CDU: 004.414.2
_____________________________________________________________________________
SENAI Sede
Serviço Nacional de Setor Bancário Norte • Quadra 1 • Bloco C • Edifício Roberto
Aprendizagem Industrial Simonsen • 70040-903 • Brasília – DF • Tel.: (0xx61) 3317-
Departamento Nacional 9001 Fax: (0xx61) 3317-9190 • http://www.senai.br
Lista de Ilustrações
Figura 1 - Objeto representado pela caneta.............................................................................................................19
Figura 2 - Classe Carro e dois objetos instanciados...............................................................................................22
Figura 3 - Fundamentos da Programação Orientada a Objeto..........................................................................23
Figura 4 - Representação da abstração de um produto.......................................................................................24
Figura 5 - Representação de duas classes que possuem herança....................................................................24
Figura 6 - Representação da relação entre JDBC e Drives...................................................................................41
Figura 7 - Seleção do Sistema Operacional para o Mysql....................................................................................42
Figura 8 - Acesso ao download do Mysql.................................................................................................................42
Figura 9 - Opções de download do Mysql.................................................................................................................42
Figura 10 - Opção de cadastro de conta ou download imediato.....................................................................43
Figura 11 - Inicialização do instalador do Mysql.....................................................................................................43
Figura 12 - Apresentação dos termos de licença....................................................................................................44
Figura 13 - Opções de tipos de instalação................................................................................................................44
Figura 14 - Verificação de requisitos do sistema.....................................................................................................45
Figura 15 - Instalação do Mysql concluída................................................................................................................45
Figura 16 - Configuração do Mysql..............................................................................................................................46
Figura 17 - Configuração do Mysql para tipo de conexão em rede.................................................................46
Figura 18 - Configuração do Mysql para definir protocolo de comunicação..............................................47
Figura 19 - Configuração do Mysql para definir a senha de administrador..................................................47
Figura 20 - Configuração do Mysql para definir o serviço do SO Windows..................................................47
Figura 21 - Aplicação das configurações do Mysql................................................................................................48
Figura 22 - Status da aplicação das configurações do Mysql.............................................................................48
Figura 23 - Terminal de conexão ao banco de dados Mysql..............................................................................49
Figura 24 - Projeto Senai na IDE Eclipse.....................................................................................................................51
Figura 25 - Adição do Driver Mysql ao Projeto Java...............................................................................................51
Figura 26 - Seleção do Driver de conexão Mysql....................................................................................................52
Figura 27 - Tela de download da IDE Eclipse............................................................................................................58
Figura 28 - Inicialização do Eclipse...............................................................................................................................59
Figura 29 - Seleção do Workspace................................................................................................................................59
Figura 30 - Tela principal do Eclipse............................................................................................................................60
Figura 31 - Menu para criar novo Projeto..................................................................................................................61
Figura 32 - Seleção do Projeto Java.............................................................................................................................61
Figura 33 - Criação do Projeto Java..............................................................................................................................62
Figura 34 - Projeto Java POO ........................................................................................................................................62
Figura 35 - Criação da classe Java Curso....................................................................................................................63
Figura 36 - Classe Curso no Projeto Java POO.........................................................................................................64
Figura 37 - Área de Trabalho ampliada.......................................................................................................................64
Figura 38 - Método “Main” da classe Java..................................................................................................................65
Figura 39 - Nova Instância de classe Java..................................................................................................................66
Figura 40 - Código Java com possibilidades de ajuste.........................................................................................67
Figura 41 - Arquivo de código Java não salvo..........................................................................................................67
Figura 42 - Método println do código Java...............................................................................................................68
Figura 43 - Execução do método Main da classe Java..........................................................................................69
Figura 44 - Acesso de classe referenciada no código Java..................................................................................70
Figura 45 - Abas do Eclipse.............................................................................................................................................70
Figura 46 - Seleção em bloco dos modificadores de acesso..............................................................................70
Figura 47 - Acesso ao menu do Eclipse para gerar Getters/Setters..................................................................71
Figura 48 - Mudança de posição do método setNome com os atalhos.........................................................72
Figura 49 - Diferença entre o código não formatado e formatado..................................................................73
Figura 50 - A view Search mostra onde o elemento é usado ............................................................................74
Figura 51 - Realização do Import com o atalho.......................................................................................................75
Figura 52 - Seleção da Perspectiva Java.....................................................................................................................76
Figura 53 - Apresentação da View Package Explorer.............................................................................................77
Figura 54 - View Task List................................................................................................................................................78
Figura 55 - View Outline...................................................................................................................................................78
Figura 56 - View’s Problems, Javadoc e Declaration..............................................................................................79
Figura 57 - Configuração de Task Tags........................................................................................................................79
Figura 58 - Configuração da View Tasks.....................................................................................................................80
Figura 59 - Apresentação da View Tasks.....................................................................................................................80
Figura 60 - Site para download do Git........................................................................................................................82
Figura 61 - Interface de linha de comando do Git..................................................................................................83
Figura 62 - Comando para criar novo repositório Git............................................................................................83
Figura 63 - Cadastro de usuário no GitHub...............................................................................................................86
Figura 64 - Segundo passo do cadastro no GitHub...............................................................................................87
Figura 65 - Tela para iniciar o projeto.........................................................................................................................87
Figura 66 - Tela de cadastro de novo repositório....................................................................................................88
Figura 67 - Repositório criado........................................................................................................................................89
Figura 68 - Menu da IDE para acessar o Eclipse Marktplace...............................................................................90
Figura 69 - Instalação do EGit no Eclipse Marketplace.........................................................................................91
Figura 70 - Link para configuração do repositório remoto.................................................................................92
Figura 71 - Configuração do repositório remoto....................................................................................................93
Figura 72 - Seleção do branch na configuração do repositório remoto.........................................................94
Figura 73 - Configuração do diretório local e nome do repositório................................................................95
Figura 74 - Menu do EGit.................................................................................................................................................96
Figura 75 - Atividades do processo de teste.......................................................................................................... 103
Figura 76 - Modelo V de teste..................................................................................................................................... 104
Figura 77 - Classe Java que será testada................................................................................................................. 107
Figura 78 - Criação do JUnit......................................................................................................................................... 107
Figura 79 - Definições da Classe JUnit..................................................................................................................... 108
Figura 80 - Biblioteca do JUnit 4 adicionada ao Eclipse.................................................................................... 109
Figura 81 - Estrutura da Classe de Teste JUnit...................................................................................................... 109
Figura 82 - Classe de Teste JUnit Implementada................................................................................................. 110
Figura 83 - Resultado da Execução do JUnit.......................................................................................................... 110
Figura 84 - Novo método de teste implementado.............................................................................................. 111
Figura 85 - Resultado de teste com falha............................................................................................................... 111
Figura 86 - Menu da IDE Eclipse para gerar o Javadoc..................................................................................... 133
Figura 87 - Janela da IDE Eclipse para selecionar Projeto Java...................................................................... 134
Figura 88 - Diretório de destino do Javadoc......................................................................................................... 135
Figura 89 - Página principal do Javadoc................................................................................................................. 135
Figura 90 - Documento Javadoc da classe Aluno................................................................................................ 136
Figura 93 - Menu do Eclipse para instalação de plugins.................................................................................. 139
Figura 94 - Configuração do local de download.................................................................................................. 139
Figura 95 - Inserção do local de download............................................................................................................ 140
Figura 96 - Seleção do aplicativo para ser instalado.......................................................................................... 140
Figura 97 - Progresso de instalação do novo aplicativo.................................................................................... 141
Figura 98 - Processo de instalação do novo aplicativo..................................................................................... 142
Figura 99 - Informação dos detalhes de instalação do novo aplicativo...................................................... 143
Figura 100 - Termos de licença do novo aplicativo ............................................................................................ 144
Figura 101 - Reinício do Elipse para ativar aplicativo instalado...................................................................... 144
Figura 102 - Menu para inserir breakpoint do debugging................................................................................ 149
Figura 103 - Menu para iniciar o modo Debug..................................................................................................... 152
Figura 104 - Opção do modo Debug....................................................................................................................... 152
Figura 105 - Janela de confirmação para exibir a perspectiva de Debug................................................... 153
Figura 106 - Perspectiva do modo Debug do Eclipse........................................................................................ 153
Figura 107 - Visão de Debug do Eclipse................................................................................................................. 154
Figura 108 - Visão de Variáveis do Eclipse.............................................................................................................. 154
Figura 109 - Visão de Breakpoints do Eclipse........................................................................................................ 154
Figura 110 - Visão do Código Fonte do Eclipse..................................................................................................... 155
Figura 111 - Visão do Console do Eclipse................................................................................................................ 155
Figura 112 - Botões do Eclipse para executar o debugging............................................................................ 155
Figura 113 - Configuração de condição do Breakpoint.................................................................................... 156
Figura 114 - Configuração de expressão condicional do Breakpoint.......................................................... 157
Figura 115 - Matriz de rastreabilidade cruzada.................................................................................................... 158
Figura 116 - Gráfico de rastreabilidade cruzada.................................................................................................. 159
Figura 117 - Pilares do método de trabalho Scrum............................................................................................ 166
Figura 118 - Valores do método de trabalho Scrum........................................................................................... 167
Figura 119 - Formação do Time Scrum.................................................................................................................... 168
Figura 120 - Principais funções do Product Owner............................................................................................. 169
Figura 121 - Principais funções do Scrum Master................................................................................................ 171
Figura 122 - Características do Time de Desenvolvimento.............................................................................. 172
Figura 123 - Dinâmica do método de trabalho Scrum...................................................................................... 174
Figura 124 - Trabalho colaborativo no planejamento de Sprint.................................................................... 174
Figura 125 - Simulação da estimativa por Planning Poker............................................................................... 175
Figura 126 - Lista de itens do Backlog de Produto.............................................................................................. 176
Figura 127 - Lista de itens do Backlog de Sprint.................................................................................................. 177
Figura 128 - Representação de incremento de Software................................................................................. 178
Figura 129 - Representação da Reunião Diária..................................................................................................... 179
Figura 130 - Representação da reunião de Revisão da Sprint......................................................................... 180
Figura 131 - Representação das ações da Retrospectiva da Sprint............................................................... 181
Figura 132 - Quadro fundamental do Kanban...................................................................................................... 182
Figura 133 - Interface inicial do site da ferramenta Trello................................................................................. 188
Figura 134 - Interface de cadastro de novo usuário no Trello......................................................................... 189
Figura 135 - Interface Trello de visualização de quadros pessoais................................................................ 189
Figura 136 - Interface Trello de um quadro com suas listas............................................................................. 190
Figura 137 - Interface Trello de uma lista com suas tarefas.............................................................................. 190
Figura 138 - Interface Trello para configuração da Tarefa................................................................................. 191
Figura 139 - Interface Trello para configuração rápida da tarefa................................................................... 191
Figura 140 - Interface Trello com transição de tarefas....................................................................................... 192
Figura 141 - Interface Trello com transição de tarefas II.................................................................................... 192
Figura 142 - Menu para criar time na ferramenta Trello.................................................................................... 192
Figura 143 - Interface Trello para área de trabalho de Time............................................................................ 193
Figura 144 - Interface Trello para associar membros ao Time........................................................................ 193
Figura 145 - Interface inicial do site da ferramenta Kanbanflow................................................................... 194
Figura 146 - Interface de cadastro da ferramenta Kanbanflow...................................................................... 195
Figura 147 - Interface inicial do Kanbanflow......................................................................................................... 195
Figura 148 - Interface de configuração de quadro da ferramenta Kanbanflow....................................... 196
Figura 149 - Interface de configuração de colunas do quadro....................................................................... 196
Figura 150 - Interface de configuração de uma coluna do quadro............................................................... 197
Figura 151 - Interface inicial do Kanbanflow editada........................................................................................ 197
Figura 152 - Interface do Kanbanflow para cadastro de tarefa...................................................................... 198
Figura 153 - Interface do Kanbanflow para cadastro de tarefa II .................................................................. 199
Figura 154 - Tarefa cadastrada no quadro do Kanbanflow.............................................................................. 199
Figura 155 - Menu de configuração rápida da tarefa no Kanbanflow.......................................................... 200
Figura 156 - Tarefa na coluna Feito do quadro no Kanbanflow...................................................................... 200
Figura 157 - Adição de novos usuários ao quadro do Kanbanflow............................................................... 201
Figura 158 - Envio de convite para o quadro do Kanbanflow......................................................................... 201
Figura 159 - Menu para cadastro de novo quadro do Kanbanflow.............................................................. 202
Figura 160 - Cadastro de novo quadro do Kanbanflow.................................................................................... 202
Figura 161 - Cadastro de novo quadro do Kanbanflow II................................................................................. 202
Figura 162 - Cadastro de novo quadro do Kanbanflow III................................................................................ 203
Figura 163 - Cadastro de novo quadro do Kanbanflow IV................................................................................ 203
Figura 164 - Cadastro de novo quadro do Kanbanflow V................................................................................. 204
Figura 165 - Estruturas hierárquicas......................................................................................................................... 221
Figura 166 - Fluxo de informação no sistema administrativo......................................................................... 222
Quadro 1 - Grupo de atalhos para busca...................................................................................................................74
Quadro 2 - Relação de Tags do Javadoc.................................................................................................................. 131
Quadro 3 - Normas Regulamentadoras (NRs)....................................................................................................... 209
Quadro 4 - Diferenças entre empresa formal e informal.................................................................................. 220
Quadro 5 - Diferenças entre grupo e equipe......................................................................................................... 223
Sumário
1 Introdução.........................................................................................................................................................................15
2 Orientação a Objetos.....................................................................................................................................................17
2.1 Princípios da orientação a objetos ........................................................................................................18
2.2 O que é um objeto?.....................................................................................................................................18
2.3 Responsabilidades dos objetos...............................................................................................................19
2.3.1 Quem sabe...................................................................................................................................20
2.3.2 Quem faz.......................................................................................................................................20
2.4 O que é uma classe?....................................................................................................................................22
2.5 Conceitos fundamentais............................................................................................................................22
2.5.1 Abstração......................................................................................................................................23
2.5.2 Herança..........................................................................................................................................24
2.5.3 Polimorfismo...............................................................................................................................25
2.5.4 Encapsulamento........................................................................................................................25
2.6 Aplicação prática da POO..........................................................................................................................26
2.6.1 Ferramentas desktop................................................................................................................26
2.6.2 Ferramentas online...................................................................................................................27
3 Paradigma das Linguagens de Programação.......................................................................................................31

3.1 Linguagens de programação OO x estruturada................................................................................32
3.1.1 Características da programação estruturada...................................................................34
3.1.2 Características da programação OO ..................................................................................35
3.2 Vantagens e desvantagens dos paradigmas......................................................................................35
3.2.1 Comparação entre os paradigmas.......................................................................................36
4 Criando Conexões para Persistência........................................................................................................................39

4.1 Persistência de dados no Java.................................................................................................................40
4.1.1 Mysql, conectando o caso de uso........................................................................................41
4.2 Configurando a conexão...........................................................................................................................49
4.2.1 Configuração da conexão na IDE.........................................................................................50
4.2.2 Configuração da conexão na aplicação.............................................................................52
5 A Importância de Ferramentas no Ambiente de Desenvolvimento............................................................57

5.1 Calibrando a ferramenta ...........................................................................................................................58
5.1.1 Praticando na IDE, atalhos para a produtividade...........................................................60
5.1.2 Mais facilidades e funcionalidades com o Eclipse.........................................................76
5.1.3 Integrando repositórios...........................................................................................................81
6 Testando a Implementação OO em Java ............................................................................................................ 101

6.1 Conceitos gerais sobre teste................................................................................................................. 102
6.1.1 Teste unitário............................................................................................................................ 105
6.2 Teste unitário na prática.......................................................................................................................... 106
6.2.1 Implementando teste unitário no Java........................................................................... 106
7 Técnicas de Implementação Orientada a Objetos........................................................................................... 115
7.1 Técnicas de Implementação.................................................................................................................. 116
7.1.1 Encapsulamento..................................................................................................................... 116
7.1.2 Herança....................................................................................................................................... 118
7.1.3 Polimorfismo............................................................................................................................ 120
7.2 Formatação do código............................................................................................................................ 123
7.3 Documentação de código..................................................................................................................... 131
7.4 Otimização de código.............................................................................................................................. 138
7.4.1 Técnicas de otimização de códigos ................................................................................. 145
7.5 Depuração................................................................................................................................................... 148
7.6 Rastreabilidade.......................................................................................................................................... 158
8 Estrutura Organizacional e Equipes Ágeis ......................................................................................................... 163

8.1 Manifesto para desenvolvimento ágil............................................................................................... 164
8.1.1 Valores do Manifesto Ágil .................................................................................................... 164
8.1.2 Princípios do Software Ágil................................................................................................. 164
8.2 Estruturas organizacionais no desenvolvimento ágil.................................................................. 165
8.2.1 Funções e papéis..................................................................................................................... 167
8.2.2 Time de desenvolvimento................................................................................................... 171
8.3 Método de trabalho de equipes ágeis .............................................................................................. 173
8.3.1 Artefatos do Scrum................................................................................................................ 176
8.3.2 Técnicas de gerenciamento de atividades ágil............................................................ 178
8.3.3 Ferramentas de Gerenciamento........................................................................................ 183
9 Ferramentas de Gerenciamento de Atividades................................................................................................ 187

9.1 Gerenciando atividades com o Trello................................................................................................. 188
9.2 Gerenciando atividades com o Kanbanflow................................................................................... 194
10 Segurança do Trabalho........................................................................................................................................... 207

10.1 Segurança do trabalho......................................................................................................................... 208
10.1.1 Procedimentos de segurança no trabalho ................................................................. 208
10.1.2 Normas de segurança do trabalho................................................................................. 208
10.2 Saúde ocupacional................................................................................................................................. 211
10.2.1 Riscos ocupacionais............................................................................................................. 212
10.3 Meio ambiente e sustentabilidade................................................................................................... 212
10.3.1 Responsabilidades socioambientais ............................................................................ 213
10.3.2 Políticas públicas ambientais .......................................................................................... 213
11 Gestão Organizacional ........................................................................................................................................... 217

11.1 Conceito e importância do planejamento estratégico............................................................. 218
11.2 Estrutura organizacional ..................................................................................................................... 220
11.2.1 Estruturas hierárquicas, sistemas administrativos e gestão
organizacional.................................................................................................................................... 221
11.3 Trabalho em equipe............................................................................................................................... 223
11.3.1 O relacionamento com os colegas de equipe............................................................ 224
11.3.2 Responsabilidades individuais e coletivas: a divisão de papéis e
responsabilidades............................................................................................................................. 225
11.3.3 Motivação ............................................................................................................................... 227
11.3.4 Compromisso com objetivos e metas.......................................................................... 227
11.3.5 Cooperação............................................................................................................................ 228
11.4 Conflitos nas equipes de trabalho.................................................................................................... 229
11.4.1 Tipos, características e causas ......................................................................................... 231
11.5 A relação com o líder............................................................................................................................. 233
11.5.1 Estilos de liderança.............................................................................................................. 233
11.5.2 Papéis do líder....................................................................................................................... 234
11.5.3 Autonomia nas equipes de trabalho............................................................................. 235
11.5.4 Ajustes interpessoais e cooperação............................................................................... 235
11.5.5 Avaliação de desempenho................................................................................................ 236
Referências......................................................................................................................................................................... 239
Minicurrículo dos Autores............................................................................................................................................ 241
Índice................................................................................................................................................................................... 243
Introdução
Olá! Seja bem-vindo à Unidade Curricular Programação Orientada a Objeto.

Aqui você será apresentado aos principais conceitos da programação orientada a objetos,
assim como a definições dos elementos que a constituem e técnicas para implementar solu-
ções neste padrão. Seu aprendizado será apoiado pela linguagem de programação Java, a qual
possui suporte à orientação a objeto, possibilitando a prática e reforçando o aprendizado na
correta aplicação da linguagem aos conceitos deste paradigma. No decorrer dos seus estudos,
serão apresentadas ferramentas para auxiliar na programação e proporcionar maior rendimen-
to e facilidade na construção de sistemas com estrutura orientada a objeto.
Ao final da Unidade Curricular, você estará apto a criar soluções conceituais baseadas no
paradigma da orientação a objeto, aplicando técnicas de análise e modelagem de sistemas,
possuindo também competências para implementar tais soluções e prover sua manutenção.
O profissional que atua no desenvolvimento de software encontrará no mercado de traba-
lho muitas oportunidades para criar e manter sistemas baseados na orientação a objetos, para
o qual esta Unidade irá prover os conhecimentos fundamentais, porém a especialização e atu-
alização deste profissional é imprescindível para acompanhar as novas tecnologias e métodos
de desenvolvimento.
Bons estudos!
Orientação a Objetos
Neste capítulo, você será apresentado aos principais conceitos e termos da Orientação a
Objeto (OO), que irão prover a base necessária para compreender os temas que serão aborda-
dos no decorrer da Unidade Curricular. Portanto, é recomendado maior atenção, para que você
possa construir fundamentos sólidos na construção do seu conhecimento.
Ao final deste capitulo você estará apto a:
a) compreender a definição de um objeto no contexto de software;
b) compreender as responsabilidades de um objeto;
c) compreender a definição de uma classe no contexto de software;
d) aplicar os fundamentos da Programação Orientada a Objeto;
e) compreender arquiteturas de software orientadas a objeto.
PROGRAMAÇÃO ORIENTADA A OBJETOS
18
2.1 PRINCÍPIOS DA ORIENTAÇÃO A OBJETOS
A Orientação a Objetos é um paradigma, ou seja, um padrão ou modelo a seguir, portanto é importante

ressaltar que não se trata de uma linguagem de programação, mas, sim, uma maneira de pensar soluções
que poderão ser implementadas, com linguagens de programação que possuam suporte a orientação a
objetos. Sendo assim, a OO orienta a correta aplicação de linguagens adequadas ao padrão.
Neste momento, você pode estar se perguntando: por que é importante usar a orientação a objetos
na programação? Qual a vantagem? Quais os benefícios? Para responder essas perguntas e motivar ainda
mais seus estudos, a programação orientada a objetos permite a reutilização de código e a representação
do sistema mais próximo ao mundo real, que proporcionam a otimização do tempo de desenvolvimento,
a redução da complexidade do sistema e código, maior facilidade na leitura e manutenção do código, a
criação de bibliotecas mais intuitivas e ainda provê maior segurança das aplicações.
CURIOSI Você sabia que, em estudos recentes, foi identificado que a revisão do código fonte,
DADES pelos colegas pares de programação, consegue descobrir até 60% dos defeitos?
Para alcançar todas essas vantagens, é preciso saber o que é um objeto, suas responsabilidades, qual a
origem dos objetos e os pilares da POO, a abstração, herança, polimorfismo e encapsulamento. Vamos em
frente, desbravar este novo mundo de possibilidades!
CURIOSI Você sabia que o sistema operacional Android para dispositivos móveis, implemen-
tado por uma linguagem de programação orientada a objeto, também usa o para-
DADES digma de programação estruturada para o seu desenvolvimento?
Confira a seguir o que é um objeto.
2.2 O QUE É UM OBJETO?
A pergunta mais pertinente da POO é exatamente esta, o que é um objeto? Este elemento é definido so-
bre diferentes perspectivas, podendo ser identificado como a materialização de uma abstração, por exem-
plo, se você pensar em uma caneta e idealizá-la, como você a definiria a partir de seu pensamento? Você
poderia fechar seus olhos e pensá-la com um corpo acrílico, com uma carga de tinta azul, com uma ponta
esferográfica e uma tampa plástica azul; e ao abrir seus olhos, observar a figura a seguir, que representa seu
pensamento abstrato de forma concreta, com o objeto caneta.
2 ORIENTAÇÃO A OBJETOS
19
alvesflavio ([20--?])
Figura 1 - Objeto representado pela caneta
Ainda, ao pensar sobre a caneta, é possível identificar características, como a cor de sua tinta, o material
que seu corpo é formado, o mecanismo para imprimir sua tinta e ações realizadas e/ou associadas a ela,
como escrever, recarregar sua carga, entre outras.
Dessa forma, você pode definir o objeto como sendo a materialização de uma abstração, que possui
características e ações definidas, sendo ainda possível defini-lo, sob uma segunda perspectiva e de forma
mais rigorosa, como uma instância de uma classe.
O conceito de classe você verá logo a seguir neste capítulo, por isso guarde essa definição e cruze as
informações.
2.3 RESPONSABILIDADES DOS OBJETOS
De acordo com a definição do objeto, você identificou que estes possuem características e ações asso-
ciadas, que também podem ser interpretadas como responsabilidades. Didaticamente, a ideia de respon-
sabilidades, nesse contexto, facilita a absorção dos conceitos de atributo e método relacionado ao objeto.
Veja outro exemplo, para tornar clara esta comparação. Pense agora em um carro. Entre as suas responsa-
bilidades, está a necessidade de saber sua velocidade, sua taxa de aceleração e sua potência, assim como o
carro deve fazer ações, nas quais é possível citar: acelerar e frear. Nessa analogia você tem:
Saber = Atributos
Fazer = Métodos
20
Nas sessões seguintes, você terá mais detalhes sobre os tipos de responsabilidades dos objetos e suas
equivalências.
FIQUE Atributos de referência no Java, mesmo que possuam o mesmo valor literal, são dife-
ALERTA rentes ao serem comparados de forma direta.
2.3.1 QUEM SABE
A construção do conhecimento é algo gradativo, então, se você juntar as peças ou definições apresen-
tadas até aqui, pode unir a definição de um objeto, que remete ao resultado de algo concreto e individual,
que possui características próprias, ou seja, dois objetos diferentes que são originados a partir da mesma
abstração, podem ter características diferentes, como a cor da tinta de uma caneta, uma possuindo tinta
azul e outra vermelha. Na OO, o objeto precisa saber quais são suas características próprias. Em outras pa-
lavras, é preciso conhecer seus atributos.
Abstração Caneta
Atributo: Cor da tinta
Objeto Caneta A
Atributo: Cor da tinta azul
Objeto Caneta B
Atributo: Cor da tinta vermelha
2.3.2 QUEM FAZ
As ações realizadas por um objeto possuem as mesmas lógicas de funcionamento de diferentes objetos,
originados a partir da mesma abstração, ou seja, estes diferentes objetos podem fazer, ou executar seus
métodos, com o mesmo mecanismo, porém podem produzir resultados diferentes. Ao usar novamente o
exemplo de um carro, pode-se dizer que o princípio da ação de acelerar ou frear é a mesma, porém depen-
dendo da velocidade destes diferentes carros, as ações de aceleração e frenagem produzirão diferentes
resultados de sua velocidade final.
21
Abstração Carro
Atributo: Velocidade
Método 1: Acelerar
Método 2: Frear
Objeto Carro A
Atributo: Velocidade 40km/h
Método 1: Acelerar
Método 2: Frear
Objeto Carro B
Método 1: Acelerar
Método 2: Frear
O exemplo anterior demonstra que cada objeto possui a responsabilidade de saber suas características,
ou seja, atributos, e de fazer suas ações, ou seja, executar seus métodos, de forma individual e com suas
diferenças, decorrentes das suas responsabilidades.
FIQUE A manutenção de software pode consumir até 90% dos custos de um projeto, por-
tanto produzir código fonte orientado a objetos e seguindo boas práticas tende a
ALERTA aumentar a qualidade do sistema e viabilizar um projeto.
Dando sequência aos seus estudos, a seguir você irá aprender o que é uma Classe. Acompanhe!
22
2.4 O QUE É UMA CLASSE?
A classe é a abstração dos seus objetos, ou ainda, ela pode ser vista como um projeto que servirá de
referência para originar objetos. Nas classes, também são definidas as características mais generalistas pos-
síveis, que serão propriamente seus atributos e métodos, para que possam ser compartilhados entre todos
os objetos instanciados.
A criação de objetos a partir de uma classe, ou a sua instância, consiste em criar algo concreto, o objeto,
do modelo definido na classe, como pode ser observado na figura a seguir, que produz dois novos carros
que possuem peculiaridades diferentes, mas que ainda assim são carros.
CLASSE Objeto 01
carro
Responsabilidades
Sabe
Davi Leon (2017)

(Atributos)
Faz Objeto 02
(Métodos)
Figura 2 - Classe Carro e dois objetos instanciados
A classe também pode ser interpretada como uma categoria, para facilitar no processo de análise e
definição de novas classes. Nessa perspectiva, pense em duas pessoas diferentes, João e Maria, que estu-
dam no Senai. Nesse contexto, essas pessoas podem ser categorizadas como estudantes, apesar de serem
pessoas diferentes. Em contrapartida, você pode supor que na estrutura do sistema computacional de
gestão educacional do Senai, poderia haver uma classe Estudante e, portanto, João e Maria seriam objetos
instanciados dessa classe.
2.5 CONCEITOS FUNDAMENTAIS
A Orientação a Objetos é estruturada em quatro pilares, identificados como Abstração, Herança, Poli-
morfismo e Encapsulamento, que em suas definições ressaltam como a OO é constituída e as vantagens
desse paradigma de programação.
É importante ressaltar que a linguagem de programação escolhida para implementar soluções
orientadas a objeto precisa possuir características específicas para atender este modelo, sendo essas ca-
racterísticas refletidas nos pilares da OO.
23
P.O.O
Programação Orientada a Objetos
Polimorfismo
Herança
Abstração
Encaspulamento
Davi Leon (2017)

Figura 3 - Fundamentos da Programação Orientada a Objeto
Fonte: Adaptado de DevMedia (s.d.)
O instituto IEEE, por meio do site IEEE Spectrum, mantém uma lista com as linguagens
SAIBA de programação mais populares do mercado. Visite o site, a seguir, e confira mais deta-
MAIS lhes a respeito!
<https://spectrum.ieee.org/static/interactive-the-top-programming-languages-2017>.
2.5.1 ABSTRAÇÃO
A abstração pode ser definida como a habilidade de imaginar ou tornar algo concreto em abstrato, e
mais especificamente, no contexto da programação orientada a objeto, consiste em abstrair os problemas
que precisam ser resolvidos na construção de um sistema, ou seja, buscar características do mundo real
para a modelagem ou arquitetura dos sistemas.
Esse é um processo que irá transformar objetos do mundo real em classes, com atributos e métodos,
para que possam representar o comportamento de objetos reais em objetos instanciados a partir destas
classes.
Para identificar tais abstrações ou classes é necessário definir três pontos relacionados à sua estrutura,
que são:
a) identidade ou nome da classe, que deve ser única;
b) propriedades ou atributos desta classe;
c) ações ou métodos existentes nesta classe.
24
Na figura a seguir, é ilustrada a definição da abstração de um objeto real, um produto, com seus atributos
ou características de um produto real e ações ou métodos que podem ser realizados sobre este produto.
Produto Nome da classe

- codigo : int
- nome : string
- descricao : string
- preco_compra : decimal Atributos
- preco_venda : decimal
- quantidade_estoque : int
- ativo : bool
- data_cadastro : DateTime
+ inserir() : void
Davi Leon (2017)

+alterar() : void
+excluir() : void Métodos
+pesquisar() : void
Figura 4 - Representação da abstração de um produto

Fonte: Adaptado de DevMedia (s.d.)
2.5.2 HERANÇA
Este fundamento está diretamente relacionado com a redução de código desenvolvido na POO, pois a
partir de classes mais genéricas já existentes é possível gerar novas classes mais específicas, que herdam da
classe ancestral seus atributos e métodos, além de implementar características mais específicas.
A definição de herança pode ser reforçada, se for interpretada como a herança genética de uma famí-
lia, ou seja, ao longo de gerações, de pais para filhos, de avós para netos, as características das primeiras
gerações são herdadas por sua descendência, como cor dos olhos, altura e seu modo de ser ou seus com-
portamentos.
Na figura a seguir, é exemplificada a herança, com a criação das classes “Carro” e “Avião”, a partir das
características da classe ancestral “Veículo”. Outras nomenclaturas para estas classes podem ser usadas,
como superclasse e subclasse, em que “Veículo” seria a superclasse de “Carro” e “Avião”, ou ainda, “Carro”
e “Avião” seriam subclasses de “Avião”.
Veículo
Número de passageiros
Acelerar
Frear
Carro Avião
Número de passageiros Número de passageiros
Davi Leon (2017)
Acelerar Acelerar
Frear Frear
Figura 5 - Representação de duas classes que possuem herança

Fonte: Do autor (2018)
25
A seguir você vai estudar o polimorfismo. Acompanhe!
2.5.3 POLIMORFISMO
A definição da palavra polimorfismo, pode explicar esta característica da Orientação a Objeto, que sig-
nifica a diversidade entre indivíduos (no contexto da OO, substitui-se a palavra indivíduos por objetos) que
possuem a mesma origem.
Ainda mais especificamente, o polimorfismo ocorre quando métodos de um objeto de origem são alte-
rados em seus objetos-filhos, ou seja, neste momento, é possível observar que há uma forte relação com o
fundamento de herança.
Para exemplificar este conceito, será utilizada a classe Veículo, ilustrada anteriormente, como segue:
a) identificação: veículo;
b) atributo: número de passageiros;
c) método: acelerar, frear.
Ao estender a classe Veículo, que é genérica, para duas novas classes mais específicas, identificadas
como Carro e Avião, você pode perceber que a forma utilizada por um carro para gerar aceleração, ou seja,
o funcionamento de seu motor, o acionamento do acelerador, entre outras particularidades, será diferente
da forma realizada por um avião para também gerar aceleração. Como observado, o método acelerar, para
as Classes Carro e Avião, é herdado da Classe Veículo, porém seu funcionamento interno é diferente, e essa
diferença, ou diversidade, é definida como polimorfismo.
2.5.4 ENCAPSULAMENTO
É uma técnica de grande importância na Orientação a Objeto, responsável principalmente pelo aumento
na segurança das aplicações, redução de acoplamento e aumento de independência entre as classes de
um sistema.
Ao implementar uma classe, pode ser necessário limitar ou negar o acesso direto às suas características,
por questões de segurança, como o acesso a uma conta bancária e seus atributos, ou redução de depen-
dência entre classes, como o uso de métodos de bibliotecas da linguagem de programação, no qual não é
necessário conhecer o funcionamento interno desses métodos.
Na prática da programação, são usados métodos especiais, identificados como getters e setters para re-
tornar e inserir respectivamente valores de atributos encapsulados, evitando o acesso direto a tais atributos.
Para reforçar o conceito, é interessante usar um exemplo de seu cotidiano, como o uso do seu smar-
tphone ao enviar uma mensagem pelo WhatsApp. Você não sabe como a mensagem é enviada, portanto
você pode concluir que o modo de envio desta mensagem está encapsulado.
26
2.6 APLICAÇÃO PRÁTICA DA POO
Para colocar em prática os fundamentos da programação orientada a objeto, pode-se inserir o contexto
do desenvolvimento de um software ou de funcionalidades de um sistema, no qual é realizado o processo de
modelagem, ou seja, de criar um modelo para a implementação deste software ou de suas funcionalidades.
Para criar esse modelo, é comum usar o padrão de notação UML (Unified Modeling Language), ou Lin-
guagem Unificada de Modelagem, no qual existem diversas ferramentas disponíveis. Dessa forma, serão
relacionadas algumas ferramentas e suas principais características.
2.6.1 FERRAMENTAS DESKTOP
As ferramentas de UML desktop têm como principal característica a necessidade de instalação no com-
putador e pode ter limites de acordo com o sistema operacional.
As opções que serão listadas neste tópico apresentarão: software de código aberto, ou seja, quando
não há cobrança para o seu uso; sistemas operacionais compatíveis; links de download de seus arquivos
de instalação; e breve descrição da ferramenta.
StarUML
a) SO Compativel: Windows, Linux e Mac OS X;
b) Descrição: ferramenta de modelagem de software apto para um bom substituto de softwares co-
merciais de UML;
c) Link de download: <http://staruml.io/>.
ArgoUML
a) SO Compativel: todos os SO’s que possuem a JVM (Máquina Virtual do Java);
b) Descrição: ferramenta de modelagem UML que inclui suporte para todos os diagramas desta nota-
ção, é executada em qualquer plataforma Java e está disponível em dez idiomas;
c) Link de download: <http://argouml.tigris.org/>.
Violet UML Editor

a) SO Compativel: Windows;
b) Descrição: apresenta diagramas com boa aparência, é recomendado a desenvolvedores, estudantes,
professores e autores que precisam produzir diagramas UML simples e de forma rápida;
c) Link de download: <http://alexdp.free.fr>.
27
Astah
b) Descrição: possui recursos de modelagem para ser simples e fácil de usar;
c) Link de download: <http://astah.net>.
BOUML
a) SO Compativel: Windows, Linux e Mac OS X;
b) Descrição: a ferramenta permite criar especificação do software e gerar código em C++, Java, IDL,
PHP e Python;
c) Link de download: <http://www.bouml.fr/>.
UMLet
b) Descrição: apresenta interface de usuário simples, proporciona o desenho de diagramas UML de
forma rápida, e possibilita a exportação dos diagramas para .eps, .pdf, .jpg, .svg, e clipboard, e possui
plugin para uso com a IDE Eclipse;
c) Link de download: <http://www.umlet.com/>.
2.6.2 FERRAMENTAS ONLINE
As ferramentas de UML online tem como principal característica a facilidade de uso, pois, ao acessar tais
sites, o uso é imediato. Porém, é necessária uma conexão ativa enquanto houver o seu uso.
Foram selecionadas algumas opções, que serão relacionadas neste tópico e apresentarão uma breve
descrição e seus respectivos links de acesso.
WebSequenceDiagram
a) Descrição: ferramenta simples, sendo necessário apenas acessar o site e iniciar o desenho clicando
em “Draw”;
b) Link de acesso: <https://www.websequencediagrams.com/>.
yUML
a) Descrição: permite criar e compartilhar diagramas UML simples em sites, como wikis, fóruns, entre
outros, e por e-mail;
28
b) Link de acesso: <https://yuml.me/diagram/scruffy/class/draw>.

Confira no “Casos e Relatos” a seguir a importância da adoção da Orientação a Objetos nas empresas
de desenvolvimento de sistemas.
CASOS E RELATOS
O mundo real reflete o mundo virtual

Em uma tradicional empresa de desenvolvimento de sistemas, a equipe de programadores pos-
suía certa dificuldade em associar as necessidades dos clientes às novas funcionalidades que pre-
cisariam ser criadas para seus sistemas. Foi percebido, por um inovador desenvolvedor, que essa
“falta” de visão era decorrente da forma como as soluções técnicas não possuíam uma correlação
com os anseios reais do cotidiano que o sistema deveria resolver. Para reduzir essa dificuldade e
buscar uma aproximação entre o mundo real e virtual, apresentando soluções técnicas com alta
qualidade e foco no negócio e nas necessidades do cliente, foi proposta a adoção da Orientação
a Objetos, que permitiu a abstração da realidade, transportando-a para os sistemas, além do au-
mento do desempenho da equipe de desenvolvimento, por reaproveitar código, facilitar a manu-
tenção do sistema, entre outras vantagens, como a felicidade geral dos programadores.
Reveja os principais conceitos estudados neste capítulo lendo o “Recapitulando” a seguir.

29
RECAPITULANDO
Neste capítulo, você foi apresentado aos princípios da Orientação a Objetos, suas principais caracte-
rísticas, vantagens e definições de seus elementos-chave.
Entre estes elementos, dentro do paradigma de desenvolvimento de sistema, é importante lembrar
que um objeto é a materialização de uma definição abstrata e que os objetos possuem característi-
cas chamadas de atributos e métodos. E, relacionando as informações, você pôde ver que a abstra-
ção, na POO, que origina o objeto é identificada como Classe e pode ser pensada como um projeto,
uma ideia ou ainda uma categoria de algo concreto.
Por fim, você estudou os pilares da Orientação a Objeto. Primeiro, a abstração, que consiste em
pensar o desenvolvimento de sistema ou o domínio do problema a ser resolvido pelo sistema, com
características do mundo real. Em seguida foi abordado o conceito de herança, que proporciona,
como grande vantagem na POO, a reutilização de código, com a criação de novas classes, herdando
características de classes ancestrais. Ainda nos fundamentos da OO, falou-se sobre o polimorfismo,
que provê maior flexibilidade nas soluções de sistema, com as diferentes implementações para mes-
mos métodos; e, concluindo a introdução para este paradigma de programação, foi explicado sobre
encapsulamento, que provê um nível maior de segurança às aplicações e possibilita maior indepen-
dência entre módulos do sistema.
Você está apenas começando nessa jornada por essa empolgante forma de desenvolver sistemas,
por isso continue seus estudos e amplie seu conhecimento!
Paradigma das
Linguagens de Programação
Existem diferentes formas de estruturar a construção de um sistema e de como ele é codifica-

do, que irão refletir na complexidade de sua construção, na facilidade de sua manutenção, no am-
biente no qual será desenvolvido e mantido, no seu desempenho, entre outras consequências.
Como você sabe, na codificação dos sistemas, são usadas linguagens de programação,
as quais possuem características estruturais que irão definir também a estrutura do sistema
construído a partir destas linguagens. Dessa forma, é possível concluir a importância destas
características, que podem ser identificadas como paradigmas.
Neste capítulo, você irá conhecer e refletir sobre os dois principais paradigmas da progra-
mação e algumas linguagens que dão suporte a estas estruturas de código, sendo eles: a pro-
gramação orientada a objeto e a programação estruturada, também conhecida como progra-
mação procedural.
Ao final deste capítulo você estará apto a:
a) compreender as diferenças de estrutura de código;
b) conhecer os paradigmas de programação OO e Estruturada;
c) identificar as principais diferenças, vantagens e desvantagens entre os paradigmas
de programação OO e Estruturada.
32
3.1 LINGUAGENS DE PROGRAMAÇÃO OO X ESTRUTURADA
Neste tópico, serão conceituados os paradigmas da linguagem de programação orientada a objetos e

estruturada, e também serão relacionadas as linguagens de programação que atendem estes paradigmas,
para que você possa ter subsídios para identificar qual a melhor estratégia de codificação para determina-
do sistema.
CURIOSI Você sabia que a linguagem de programação Java foi criada em 1990 para ser exe-
DADES cutada em microchips e inicialmente foi batizada de Ok?
A programação orientada a objeto tem como referência o mundo real, ou seja, a sua estrutura de codi-
ficação busca criar uma cópia da realidade, com suas características e comportamentos. Para viabilizar essa
estratégia, são usadas estruturas identificadas como “Classe”, que se torna a representação de objetos reais
no contexto da programação orientada a objeto.
Com o conceito de classe, é possível aplicar os pilares da OO, ou seja, a abstração, reduzindo as comple-
xidades de comportamentos dos objetos representados pelas classes; o encapsulamento, isolando partes
do programa na interação entre classes; a herança, com a extensão de classes para classes “filhas” ou mais
específicas, fomentando o reaproveitamento de código; e o polimorfismo, que permite modificar as clas-
ses herdeiras com comportamentos mais específicos, trazendo mais flexibilidade ao código.
A linguagem Java implementa o conceito de classe, como uma estrutura que representa objetos do
mundo real, assim como todos os pilares da orientação a objetos.
3 PARADIGMA DAS LINGUAGENS DE PROGRAMAÇÃO
33
Trecho de Código Java
class Carro { Representação do objeto Carro

string marca;
string modelo;
int ano;
double potencia;
double autonomia; Características ou atributos do objeto Carro
boolean ligado;
void Ligar() {
this.ligado = true;
System.out.println("Carro ligado!");
}
Ações ou métodos do objeto Carro

boolean Anda(double autonomia) {
if (this.ligado && autonomia > 0) {
return true;
} else {
return false;
}
}
void Desligar() {
this.ligado = false;
System.out.println("Carro desligado!");
Davi Leon (2017)

}
A programação estruturada possui três elementos que se interligam para compor o código estruturado,
que são a sequência, a seleção e a iteração. Nesse paradigma, o código é construído com instruções a se-
rem executadas de forma sequencial, seguindo a ordem de implementação de tais procedimentos.
Para que a execução deste código siga um “caminho” de execução não linear, existem elementos de
seleção, que testam condições para determinar qual será o caminho sequencial a ser seguido quando há
duas ou mais opções de sequencias de instruções a serem executadas.
Como mencionado na definição do paradigma estruturado, existe ainda mais um elemento, a iteração
(diferente de interação!), que são elementos do código que possibilitam a repetição de um conjunto de
instruções, formando um loop ou laço de repetição, enquanto as condições definidas nessas iterações
sejam atendidas.
Ainda nesse paradigma, há mais um conceito importante, identificado como modularização ou
subprogramação, que consiste em dividir o código em partes menores ou módulos, para facilitar a
implementação, promover o trabalho em grupo de forma simultânea e o reaproveitamento de código. Essas
partes menores do código podem ser chamadas de função, métodos, rotinas, entre outras denominações.
34
Um exemplo de linguagem de programação estruturada é o C, ainda presente em muitos sistemas em

funcionamento nos dias atuais.
Trecho de Código C:
# include <stdio.h>
int main()
{
int soma, ,int num, n=1;
printf(“Para realizar a soma de 1 a 100, digite 1”); Sequência
scanf (“%d”,&num);
Seleção if (num == 1)
{
soma = 0; // inicialização da variável soma
Iteração for (n=1; n<=100; n++)
soma= soma + n; // atualização da variável soma
printf("O valor da soma = %d\n",soma);

}
Davi Leon (2017)

If (num != 1) printf (“A soma não sera realizada”);
return 0;
}
FIQUE Não existe paradigma bom ou ruim, o que deve ser avaliado é em que situação tal
paradigma representa uma melhor solução, avaliando diferentes fatores, como o de-
ALERTA sempenho do sistema, processo de desenvolvimento, entre outros.
Dando sequência aos seus estudos, confira quais são as características da programação estruturada.
3.1.1 CARACTERÍSTICAS DA PROGRAMAÇÃO ESTRUTURADA
A programação estruturada costuma ser o primeiro contato para novos programadores, pela simplici-
dade do paradigma e pelo contato inicial com a lógica de programação.
Existem algumas características que evidenciam a programação estruturada, como a construção de
código com grandes blocos de instruções, o uso de sub-rotinas do sistema, a manipulação dos dados no
código sem uma organização definida ou sem o encapsulamento destes dados, e com uma arquitetura
geralmente implementada em uma única camada.
Além dessas características, é importante ressaltar que criar sistemas com esse paradigma tende a ser
mais fácil, em função do controle de um fluxo de código mais linear.
35
3.1.2 CARACTERÍSTICAS DA PROGRAMAÇÃO OO
A programação orientada a objeto é uma evolução do paradigma estruturado e diferente deste para-
digma, preocupa-se menos com a forma ou a tarefa que irá resolver determinado problema e concentra
seu foco em como resolver o problema, e, para isso, busca aproximar a codificação de objetos do mundo
real, com seus atributos e ações.
As principais características da POO são a manipulação dos dados, aqui traduzidos em atributos, pois
são encapsulados em classes, promovendo maior organização; a programação em camadas, que isola di-
ferentes partes do sistema, que possuem diferentes responsabilidades; a facilidade de reaproveitamento
de código; e, de forma geral, a facilidade para organizar o projeto de software.
SAIBA A modelagem de sistema com o paradigma orientado a objeto usa a notação UML
para esta atividade. Visite o site <http://www.uml.org/> e confira mais detalhes a
MAIS respeito!
A seguir, você irá conhecer as vantagens e as desvantagens dos paradigmas da programação. Acompanhe!
3.2 VANTAGENS E DESVANTAGENS DOS PARADIGMAS
Após relacionar os principais paradigmas da programação e listar suas principais características, é possível
extrair as vantagens e desvantagens de cada forma de estruturar o código, como pode ser observado a seguir:
PROGRAMAÇÃO ESTRUTURADA
a) Exige menor consumo de memória RAM no sistema computacional e, consequentemente,
proporciona melhor desempenho na execução do código.
Vantagem:
b) Maior facilidade de implementar os conceitos do paradigma, provocando uma curva de
aprendizado menor para o programador.
a) A possibilidade de criar códigos com grandes blocos de instruções.
b) Os dados separados das funções.
Desvantagem: c) Dificuldade de manutenção em função da dispersão dos dados no código.
d) Risco à segurança do sistema, pois existe a possibilidade de acesso a áreas indevidas de
memória.
36
PROGRAMAÇÃO ORIENTADA A OBJETO

a) Legibilidade do código, por abstrair as complexidades.
b) Facilidade de manutenção, proporcionada pela melhor legibilidade do código e pelo
encapsulamento de dados.
Vantagem:
c) Facilidade de modelagem do sistema, por representar objetos do mundo real.
d) Maior facilidade para implementar as regras de negócio tratadas pelo sistema.
e) Proporciona maior segurança, pois limita o acesso à memória do sistema computacional.
a) Possui menor desempenho, em função das suas estruturas não lineares.
Desvantagem: b) Os conceitos deste paradigma oferecem maior dificuldade de compreensão, comparado à
programação estruturada.
Agora que você já conhece as vantagens e desvantagens dos paradigmas, veja uma comparação
entre eles.
3.2.1 COMPARAÇÃO ENTRE OS PARADIGMAS
Com base nas informações e conceitos abordados para as definições, características, vantagens e des-
vantagens destes paradigmas, agora, de forma objetiva, serão comparados seus comportamentos.
Portanto, segue o quadro comparativo entre as principais características dos paradigmas de programa-
ção OO e Estruturada, para reforçar e sintetizar a essências destes meios de arquitetar um sistema.
PROGRAMAÇÃO ORIENTADA A OBJETOS PROGRAMAÇÃO ESTRUTURADA
Métodos Procedimentos e funções

Instâncias de variáveis Variáveis
Mensagens Chamadas a procedimentos e funções
Classes Tipos de dados definidos pelo usuário
Herança Não disponível
Polimorfismo Não disponível
Veja, no “Casos e Relatos” a seguir, a importância de ser um profissional bem preparado ao iniciar sua
carreira profissional.
37
CASOS E RELATOS
Desenvolvendo Sistemas
O aluno de uma renomada instituição de ensino da cidade, recém-formado em um determinado
curso que proporcionou conhecimentos técnicos sobre desenvolvimento de sistemas, iniciou sua
carreira profissional em uma fábrica de software da região. Nesta empresa, havia diversos sistemas
em desenvolvimento que precisavam ser mantidos, sendo sistemas com diferentes propósitos, ou
seja, com ênfase em desempenho ou com o foco principal no processo de desenvolvimento mais
próximo do negócio, ainda contando com sistemas legados que precisavam ser mantidos.
Nesse cenário, o novo desenvolvedor destacou-se em sua equipe, pois, ao identificar as princi-
pais diferenças entre os paradigmas de programação e conhecer os impactos nas escolhas de
estratégias de desenvolvimento, baseada em implementações procedurais ou orientada a obje-
tos, possuía subsídios para apoiar suas tomadas de decisão ao iniciar um novo projeto ou propor
mudanças estruturais em sistemas existentes.
Reveja os principais conceitos estudados neste capítulo lendo o Recapitulando” a seguir.
RECAPITULANDO
Neste capítulo, você estudou os principais paradigmas de programação, ou seja, a estrutura pela
qual os códigos de sistemas são construídos e arquitetados. A partir deste tema central, foram
apresentados os conceitos sobre linguagens de programação Orientada a Objetos e programação
Estruturada, assim como as suas principais características.
Também foram relacionadas as principais vantagens e desvantagens dos paradigmas de progra-
mação Orientada a Objetos versus a programação Estruturada, com isso, provendo subsídios para
quais situações determinado paradigma de programação é mais indicado.
Por fim, foram realizadas comparações gerais sobre os dois paradigmas de programação aborda-
dos, com a apresentação de um quadro que define de forma objetiva as estruturas de cada um
destes paradigmas.
Continue seus estudos para aprimorar seu conhecimento e construir uma sólida formação acadê-
mica sobre o desenvolvimento de software!
Criando Conexões
para Persistência
Os sistemas são desenvolvidos essencialmente para manipular dados, ou seja, criar, trans-
formar, recuperar e apagar tais registros submetidos ao seu processamento. No entanto, os
dados armazenados na memória principal dos computadores, também conhecida como me-
mória RAM, não são capazes de armazenar grandes volumes de dados e também de manter tais
dados salvos, quando o sistema computacional não estiver energizado.
Dessa forma, é necessário que os sistemas possam persistir o armazenamento destas in-
formações em estruturas de dados que poderão garantir de forma satisfatória a manutenção
destas informações.
Essas estruturas de dados são na verdade, sistemas especializados em gerenciar e manipular
dados, e também identificados como SGBD ou Sistemas Gerenciadores de Banco de Dados,
que podem manter conexões com as mais variadas aplicações, para que estas possam persistir
e recuperar seus dados.
Neste capítulo, você é convidado para criar conexões com o Java, no duplo sentido da frase,
conexões de afeição à esta linguagem de programação OO e estratégias de conexões à siste-
mas de banco de dados.
a) compreender a importância da persistência de dados em sistemas;
b) conhecer tecnologias de persistência de dados na linguagem de programação java;
c) criar uma base de dados relacional Mysql e configurar suas conexões;
d) configurar a conexão entre a IDE Eclipse e o banco de dados Mysql;
e) criar um código mínimo necessário, para estabelecer uma conexão entre uma aplicação
Java e um banco de dados.
40
4.1 PERSISTÊNCIA DE DADOS NO JAVA
Existem diferentes formas de criar uma conexão entre uma aplicação Java e um banco de dados, como
a partir da programação de classes com código de “baixo nível”, ou seja, com o código necessário para
criar a estrutura de comunicação ao banco de dados, ou usar estratégias que reduzem a complexidade de
implementação e a dependência de bancos de dados específicos.
CURIOSI Você sabia que os primeiros modelos fundamentais dos bancos de dados relacio-
DADES nais surgiram entre as décadas de 1960 e 1970, por meio da empresa IBM?
Você deve sempre buscar a simplicidade e a independência de nossos códigos, sendo assim, pode-se
concluir que usar estratégias que reduzem a complexidade na conexão aos bancos de dados é o melhor
caminho.
Essas estratégias consistem em usar implementações já existentes na linguagem, também conhecidas
como API ou bibliotecas, que irão prover a estrutura principal da conexão, que será usada em conjunto
com drivers criados pelos desenvolvedores dos sistemas de banco de dados.
Dessa forma, é possível criar uma camada ou interface de comunicação com os bancos de dados, per-
mitindo criar um código genérico, que usará parâmetros para selecionar determinado sistema de banco
de dados, proporcionando às aplicações desenvolvidas mais flexibilidade e portabilidade para diferentes
ambientes de infraestrutura.
No Java, a API responsável pela conexão aos diversos tipos de banco de dados é identificada como JDBC
(Java Data Base Connective), que consiste em interfaces prontas para serem usadas em conjunto com os
drivers dos sistemas de banco de dados.
FIQUE Nos códigos Java que usam a conexão ao banco de dados ou a manipulação estes
dados, deve haver a declaração de importação das API’s que dão suporte a estas
ALERTA operações.
Na figura a seguir, é ilustrada a relação entre o JDBC, implementado na aplicação Java, e os drivers de
alguns bancos de dados, mostrando que esta estrutura de conexão favorece à manutenção do sistema em
eventual troca do banco de dados, assim como proporciona maior flexibilidade na escolha do banco de
dados para a aplicação.
4 CRIANDO CONEXÕES PARA PERSISTÊNCIA
41
java Application
JDBC API
JDBC Driver
Manager
JDBC Driver JDBC Driver JDBC Driver
ODBC
Davi Leon (2017)

Oracle SQL Data
Server Source
Figura 6 - Representação da relação entre JDBC e Drives

Fonte: Adapto de Tutorialspoint (s.d.)
4.1.1 MYSQL, CONECTANDO O CASO DE USO
A prática é a melhor maneira de reforçar o conhecimento teórico, por isso será criado um caso de uso
para que você possa acompanhar uma simulação de conexão de uma aplicação a um banco de dados.
Para tornar possível este caso de uso, foi preciso eleger um banco de dados, e o vencedor dessa disputa
foi o Mysql, por possuir vantagens como a facilidade de instalação, o largo uso em ambientes reais e por
possuir licença gratuita.
O download do Mysql pode ser realizado pelo link <http://dev.mysql.com/downloads/mysql/>, seguin-
do as instruções que seguem:
42
a) Ao acessar o link informado, navegue na página até o combo de seleção do seu sistema operacional,
como pode ser observado na figura a seguir.
dev.mysql ([20--?])
Figura 7 - Seleção do Sistema Operacional para o Mysql
b) Após a escolha do sistema operacional, será necessário informar a versão do SO selecionado, para
que seja disponibilizado o acesso ao download do arquivo de instalação do Mysql, como pode ser
visto na figura a seguir.
dev.mysql ([20--?])
Figura 8 - Acesso ao download do Mysql
c) Após clicar no botão de download (Go to Download Page), você será redirecionado para uma nova
página, como observado na figura que segue.
dev.mysql ([20--?])
Figura 9 - Opções de download do Mysql

43
d) Ao escolher a opção de download, novamente haverá um redirecionamento da página, que permi-

tirá criar uma conta no site do Mysql ou iniciar o download imediatamente.
dev.mysql ([20--?])
Download imediato
Figura 10 - Opção de cadastro de conta ou download imediato
Após os passos anteriores, será necessário executar o arquivo de instalação do Mysql e iniciar o pro-
cesso de instalação. Será ilustrado esse procedimento para o SO Windows, no entanto, você poderá ter
acesso à informações de instalação para outros sistemas operacionais no link <http://dev.mysql.com/doc/
refman/5.7/en/installing.html>.
O procedimento a seguir é simples, mas alguns detalhes precisam ser observados para que a instalação
possa atingir o objetivo do caso de uso que será desenvolvido.
Após a execução do arquivo de instalação do Mysql, o instalador deverá ser inicializado, como mostra-
do na figura a seguir.
dev.mysql ([20--?])
Figura 11 - Inicialização do instalador do Mysql

44
Na sequência, o instalador irá apresentar o contrato de licença, o qual poderá ser lido e, se você con-
cordar com os termos, será preciso marcar o check-box de aceite destes termos, para que a instalação
continue, clicando no botão Next”.
MySQL ([20--?])
Figura 12 - Apresentação dos termos de licença
O próximo passo consiste em escolher o tipo de configuração do conteúdo que será instalado, no qual
deverá ser selecionada a opção “Developer Default”, como apresentado na figura a seguir. Para continuar
com a instalação será necessário clicar no botão “Next”.
MySQL ([20--?])
Figura 13 - Opções de tipos de instalação

45
Na sequência, veja a figura a seguir. O instalador analisa os recursos do computador e do sistema opera-
cional e verifica se os pré-requisitos necessários para a instalação estão presentes. Por isso, será necessário
verificar se estes requisitos estão atendidos, para continuar com a instalação, clicando no botão “Next”.
MySQL ([20--?])
Figura 14 - Verificação de requisitos do sistema
Após a checagem realizada, a instalação é executada e concluída, como pode ser visto na figura que segue.
MySQL ([20--?])
Figura 15 - Instalação do Mysql concluída
Com a conclusão da instalação, será preciso realizar algumas configurações no banco de dados, referen-
tes à conexão em rede, ao protocolo de comunicação, à configuração de senha de administrador (root) do
banco de dados e à definição de serviço do SO Windows.
46
As figuras que seguem mostram as opções de configurações que devem ser selecionadas para a aplica-
ção do caso de uso, com o objetivo de criar uma conexão entre um código Java e o banco de dados Mysql.
MySQL ([20--?])
Figura 16 - Configuração do Mysql
MySQL ([20--?])
Figura 17 - Configuração do Mysql para tipo de conexão em rede

47
MySQL ([20--?])
Figura 18 - Configuração do Mysql para definir protocolo de comunicação
MySQL ([20--?])
Figura 19 - Configuração do Mysql para definir a senha de administrador

MySQL ([20--?])
Figura 20 - Configuração do Mysql para definir o serviço do SO Windows

48
MySQL ([20--?])
Figura 21 - Aplicação das configurações do Mysql
MySQL ([20--?])
Figura 22 - Status da aplicação das configurações do Mysql
Por fim, na figura anterior, é verificado que as configurações foram aplicadas com sucesso e será possí-
vel continuar a construção do caso de uso, com a interação entre a API JDBC e o Mysql.
Avance nos próximos tópicos para que você possa construir uma conexão duradoura com o conhecimento!
49
4.2 CONFIGURANDO A CONEXÃO
Nesse tópico, você irá continuar a preparar o seu ambiente de dados, iniciando o serviço do banco de
dados Mysql e criando uma estrutura mínima para persistir e manipular alguns dados.
Você vai começar iniciando o cliente por linha de comando, instalado em conjunto com o Mysql. Ao
executar este terminal, será necessário inserir a senha de administrador, definido no processo de instalação
do banco de dados. Na próxima figura, pode ser visto o terminal já conectado ao servidor de banco de dados.
Windows ([20--?])
Figura 23 - Terminal de conexão ao banco de dados Mysql
Agora, você pode criar a estrutura de dados para nosso caso de uso, criado uma base de dados identifi-
cada como “Senai”, com o comando que segue:
mysql> create database Senai;
Após a execução do comando, deve retornar a mensagem:
Query OK, 1 row affected (0.03 sec)
Dessa forma, você criou a base de dados “Senai” e, para criar outras estruturas de dados nessa base, será
preciso acessá-la, como o comando:
mysql> use Senai;
Após a execução do comando, deve retornar a mensagem:
Database changed
50
Nesse momento, você está gerenciando a base de dados “Senai”, o que nos permite criar as estruturas
de dados, como uma nova tabela, que pode ser criada com o comando:
mysql> create table curso (

-> id BIGINT NOT NULL AUTO_INCREMENT,
-> nome VARCHAR(255),
-> descricao VARCHAR(255),
-> tipo VARCHAR(255),
-> PRIMARY KEY (id)
-> );
Após a criação da tabela, deve retornar a mensagem:

Query OK, 0 rows affected (0.04 sec)
Com o comando anterior, foi criado a tabela identificada como “curso”, que possui as colunas “id”,
“nome”, “descricao” e “tipo”, as quais, respectivamente irão representar a identificação do curso, o nome
do curso, a descrição do curso e a classificação ou tipo do curso.
SAIBA O Mysql é o banco de dados de código aberto mais conhecido no mundo. Visite o site
MAIS <https://www.oracle.com/br/mysql/resources.html> e confira mais detalhes a respeito!
Com estes comandos básicos do banco de dados você tem uma estrutura mínima para executar seu
caso de uso, portanto continue seus estudos para persistir o conhecimento!
4.2.1 CONFIGURAÇÃO DA CONEXÃO NA IDE
A partir da apresentação do JDBC com o conceito relacionado a sua estratégia de conexão e com o
ambiente de banco de dados preparado, conforme visto anteriormente, você pode iniciar o processo de
configuração da conexão propriamente dita, entre o código Java e o banco de dados.
A classe Java responsável por iniciar e manter a conexão com o banco de dados, ou seja, gerenciar tal
conexão, é identificada como “DriverManager” e a partir do método “getConnection”, presente nesta clas-
se, em conjunto com os dados de conexão do Mysql, configurados no processo de instalação do banco de
dados, é possível iniciar uma conexão.
51
Mas antes de você iniciar a conexão, é preciso adicionar o driver do banco de dados em sua aplicação,
inserindo em seu ambiente de desenvolvimento, conhecido também como IDE (Integrated Develop-
ment Environment) ou ambiente de desenvolvimento integrado, que neste cenário está é protagoniza-
do pelo Eclipse.
Portanto você precisa obter este driver de conexão, que para o seu caso de uso, pode ser encontrado
no link:
<https://dev.mysql.com/downloads/file/?id=472651>, para download do mysql-connector-java.
Após download do driver, será necessário incorporá-lo no Eclipse (IDE) como uma biblioteca, conforme
é apresentado nas próximas imagens.
dev.mysql ([20--?])
Figura 24 - Projeto Senai na IDE Eclipse
Na figura anterior, é mostrada a estrutura do projeto Java, chamado de Senai, para realizar o seu caso
de uso. Ao clicar com botão direito do mouse sobre o projeto, é exibido um menu com diversas opções,
entre elas deve ser selecionada a opção “Build Path” e “Add External Archives...”, como pode ser visto na
figura a seguir.
dev.mysql ([20--?])
Figura 25 - Adição do Driver Mysql ao Projeto Java

52
Ao clicar na opção selecionada, será exibida uma tela para selecionar o arquivo referente ao driver de
conexão do Mysql, como pode ser observado na figura que segue.
dev.mysql ([20--?])
Figura 26 - Seleção do Driver de conexão Mysql
Com essas ações realizadas, a estrutura de conexão, envolvendo o serviço de banco de dados ativo e o
meio necessário para conectar a IDE ao banco, está concluída.
No próximo tópico, você irá implementar o código Java que irá fazer a conexão ao banco. Por isso, con-
tinue os estudos para acompanhar o desfecho da relação entre a IDE e o Mysql.
4.2.2 CONFIGURAÇÃO DA CONEXÃO NA APLICAÇÃO
Nesse momento, você irá colocar a mão na massa e desenvolver o código responsável pela interação
entre a aplicação e o banco e uma verificação do sucesso desta conexão.
Como mencionado anteriormente, a classe como “DriverManager” e seu método “getConnection” irão
gerenciar esta conexão, portanto uma implementação possível deste código pode ser observada no tre-
cho de código que segue:
53
package conecta;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class Conecta {

public Connection getConnection(){
String url = “jdbc:mysql://localhost/Senai”;
try{
return DriverManager.getConnection(url, “root”,”1234”);
}catch (SQLException e) {
throw new RuntimeException(e);
}
}

public static void main(String[] args) throws SQLException{
Connection conecta = new Conecta().getConnection();
System.out.println(“Conexão realizada com sucesso”);
conecta.close();
}
Neste código, foram importadas algumas API’s do Java, listadas no início da implementação por meio
da instrução de import, que serão necessários disponibilizar os métodos destas bibliotecas.
54
Na definição do método “getConnection”, na classe “Conecta”, o atributo “url” possui o link de conexão
do banco de dados do Mysql, e, nesse caso, o endereço de rede é “localhost”, pelo fato do Mysql estar sen-
do executado localmente ou no mesmo computador do desenvolvedor.
Outro aspecto relevante dessa classe é o retorno do método “getConnection”, que irá usar a String de
conexão do banco e seus dados de acesso, nesse caso o acesso do administrador (root).
O tratamento de erros ou exceções nas conexões é obrigatório para que o código possa ser compilado.
Dessa forma, essas possíveis exceções também foram tratadas no desenvolvimento da classe.
Por último, foi criado um método de execução (main), para que possa ser verificado se a conexão foi
realizada com sucesso, assim mostrando o funcionamento da troca de dados entre a aplicação e o banco
ou enviando exceção de um possível erro nesta comunicação.
Neste capítulo, você obteve conhecimento sobre a estratégia de conexão entre uma aplicação Java e
um banco de dados, com o uso do JDBC, por meio da teoria envolvida nesta estratégia e da aplicação de
um caso prático de uso.
A cada capítulo você irá consolidar e edificar os caminhos do conhecimento, portanto continue cami-
nhando para uma imponente e sólida carreira profissional!
CASOS E RELATOS
Implementando o Código Java

Em uma equipe de desenvolvimento de software, Pedro é o mais novo integrante, formado por
uma renomada instituição de cursos técnicos da região. Ele foi incumbido de criar as conexões de
persistência para um novo software em desenvolvimento, que irá possibilitar o funcionamento do
módulo responsável pelo cadastro de contatos. Com os conhecimentos obtidos em seus estudos
e práticas de laboratório, Pedro implementou o código Java, no paradigma orientado a objeto, a
classe e os métodos responsáveis pela conexão de dados.
Com esta implementação, Pedro cumpriu sua tarefa com qualidade, pois possibilitou a conexão
da aplicação ao banco de dados, usando as boas práticas providas pela orientação a objeto.
Leia o “Recapitulando” a seguir e reveja os principais conceitos estudados neste capítulo.

55
RECAPITULANDO
Neste capítulo, você obteve muitos conhecimentos teóricos e demonstrações práticas do uso de
banco de dados associado ao código Java, entendendo melhor as estratégias e tecnologias de
conexão a banco de dados.
Com o uso do banco de dados Mysql, foi aplicado um caso de uso que proporcionou a prática de
criar uma base de dados, para uso no código de conexão a esta base.
Foi também apresentada a configuração do driver de conexão do banco de dados na IDE Eclipse,
criando mais uma oportunidade de conhecimento teórico diretamente relacionado com a prática.
Por fim, com os ambientes de banco de dados e IDE devidamente criados e configurados, foi de-
monstrado uma codificação na linguagem de programação Java, que possibilitou a conexão entre
uma interface Java e o banco de dados Mysql.
A cada capítulo, você desbrava novos conhecimentos e desafios. Continue nesta aventura e avance
para esta selva de novos conhecimentos!
A Importância de Ferramentas
no Ambiente de Desenvolvimento
Todo profissional precisa de uma ferramenta para realizar seu ofício, e com o desenvolvi-
mento de software não é diferente. Essa ferramenta consiste em aplicações que dão suporte
ao processo de desenvolvimento, proporcionando um ambiente que irá facilitar o trabalho do
programador e aumentar seu desempenho.
Umas das principais ferramentas é a IDE (Integrated Development Environment), ou tradu-
zindo, Ambiente de Desenvolvimento Integrado, que irá integrar diferentes tecnologias, times
de desenvolvimento, repositórios de código, versionamento de aplicação, entre outros.
Existem muitas IDE’s no cenário de desenvolvimento de software, por isso foi preciso esco-
lher uma dessas ferramentas, com critérios principais baseados no largo uso na comunidade de
desenvolvedores, no desempenho, no licenciamento gratuito, na grande quantidade de docu-
mentação disponível de forma pública e no suporte.
O Eclipse foi o eleito, por atender a todos os critérios mencionados, portanto se sobreponha
a luz do conhecimento para criar seu próprio eclipse. Trocadilhos a parte, acompanhe atenta-
mente os próximos tópicos deste importante capítulo e bom estudo!
a) compreender a importância do uso de ferramentas para o processo de desenvolvimento
de software;
b) instalar e configurar a IDE Eclipse para o ambiente de desenvolvimento;
c) utilizar as principais funcionalidades da IDE Eclipse;
d) criar repositórios online, suas configurações de versionamento e integração com a IDE
Eclipse.
58
5.1 CALIBRANDO A FERRAMENTA
Quando você calibra uma ferramenta, passa a conhecer melhor o seu funcionamento e as vantagens
que ela pode oferecer. Nesse caso, a principal vantagem da IDE consiste no auxílio de tarefas repetitivas na
codificação, reduzindo o micro retrabalho, como aumentar o uso do teclado em detrimento do mouse, que
ao longo do dia, pode gerar um ganho considerável de tempo.
Com os recursos na IDE que você irá explorar, há o aumento da produtividade por meio do uso de ata-
lhos, interpretação do código pela IDE para inserir dependências, sugerir correções de sintaxe, entre outras
facilidades que geram maior desempenho.
Para obter a ferramenta, acesse o link <http://www.eclipse.org/downloads/eclipse-packages/> e sele-
cione para download a opção “Eclipse IDE for Java EE Developers”, de acordo com a arquitetura do seu
sistema operacional (32 ou 64 bits).
eclipse([20--?])
Figura 27 - Tela de download da IDE Eclipse
Após clicar no link para obter o Eclipse, o acesso será direcionado para a tela em que o download pode-
rá ser iniciado, como é exibido na figura anterior.
Ao concluir este procedimento, você poderá observar que o arquivo obtido é uma pasta compactada,
no formato .zip. Dessa forma, será necessário extrair o conteúdo deste diretório.
A IDE Eclipse não necessita de instalação, sendo preciso apenas executar o arquivo “eclipse.exe”, dis-
ponível na pasta descompactada. Com a execução do aplicativo, a IDE é inicializada, como é ilustrado na
próxima figura.
5 A IMPORTÂNCIA DE FERRAMENTAS NO AMBIENTE E DESENVOLVIMENTO
59
Eclipse.org ([20--?])
Figura 28 - Inicialização do Eclipse
Nesse processo de inicialização, é necessário escolher o espaço de trabalho ou “Workspace”, que é um

diretório que pode ser escolhido pelo usuário, para definir onde os arquivos desenvolvidos pela IDE serão
armazenados.
Na figura a seguir, é apresentado um exemplo de seleção de “Workspace”, nesse caso na Unidade C:, no
diretório “eclipse-workspace”.
Eclipse ([20--?])
Figura 29 - Seleção do Workspace

60
A partir da escolha do diretório de trabalho, basta apenas clicar no botão “Launch” para ter acesso a
interface principal da IDE Eclipse e iniciar o desenvolvimento do seu sistema de forma otimizada.
Eclipse ([20--?])
Figura 30 - Tela principal do Eclipse
Na figura anterior, está a tela principal da ferramenta, onde você irá começar a explorar suas principais
funcionalidades e facilidades, para que o seu sistema seja eficiente, robusto e elegante.
CURIOSI A IDE Eclipse possui seu uso predominante para a linguagem de programação Java,
DADES porém apresenta suporte para diversas outras linguagens de programação.
Dando sequência aos seus estudos, você irá fazer uso da ferramenta IDE eclipse.
5.1.1 PRATICANDO NA IDE, ATALHOS PARA A PRODUTIVIDADE
Agora que você já possui a sua ferramenta pronta para o uso, ou melhor, com a sua IDE em plena exe-
cução, irá começar a praticar e apresentar as grandes vantagens no seu uso.
O primeiro passo será criar um novo projeto Java, no qual os diretórios ou pacotes deste projeto, assim
como os seus arquivos de código, serão armazenados e organizados.
Você irá iniciar usando os recursos de atalho do Eclipse, sempre lembrando que é mais interessante usar
o teclado ao invés do mouse, para manter o ritmo de trabalho e reduzir o tempo de troca de comando do
computador. O atalho a ser usado é:
61
Alt + Shift + N = Criar um novo elemento (nesse caso, um novo Projeto)
Eclipse ([20--?])
Figura 31 - Menu para criar novo Projeto
Assim que você usar o atalho citado, será exibido o menu ilustrado na figura anterior, no qual poderá
ser selecionada a opção “Project...” e pressionada a tecla “Enter” do seu teclado.
Eclipse ([20--?])
Figura 32 - Seleção do Projeto Java

62
Na sequência, será apresentada uma nova janela, para seleção do tipo do projeto, e, nesse caso, poderá
ser selecionada a opção “Java Project”, navegando entre as opções com a tecla “Tab” do teclado, para você
criar um novo projeto Java. Depois, basta navegar até o botão “Next” e pressionar a tecla “Enter” do tecla-
do, como é mostrado na figura que segue.
Eclipse ([20--?])
Figura 33 - Criação do Projeto Java
Nesse momento, com a exibição da tela, que é mostrada na próxima figura, você dará o nome ao novo
projeto Java, que sugiro (em homenagem à Unidade Curricular!) inserir POO. Depois, navegue, com o uso
do “Tab”, até o botão “Finish” para concluir a criação do projeto Java.
Eclipse ([20--?])
Figura 34 - Projeto Java POO

63
Ao visualizar o “Package Explorer” ou a visão exploratória da estrutura de diretórios dos projetos criados
no Eclipse, você poderá observar o projeto Java POO recém-criado, com a biblioteca padrão do Java e o
diretório “src” ou diretório fonte do seu projeto, como ilustrado na figura a seguir.
Agora você pode criar uma nova Classe para o projeto Java POO, usando as mesmas teclas de atalho da
criação do projeto, mas sendo necessário selecionar o projeto antes de usar o atalho.
Novamente, será exibido o menu, observado na figura “Menu para criar novo projeto”, no qual será
selecionado a opção “Class”, para criar nossa nova classe, como é mostrado na figura que segue.
Eclipse ([20--?])
Figura 35 - Criação da classe Java Curso
O próximo passo é navegar até o botão “Finish”, com a tecla “Tab” e pressionar a tecla “Enter”, para que
a classe Curso, armazenada dentro do diretório “src”, no pacote “default”, possa ser criada, de acordo com
a figura anterior.
64
Eclipse ([20--?])
Figura 36 - Classe Curso no Projeto Java POO
Na figura anterior, você tem a visão da classe Curso, dentro da estrutura do projeto Java POO, no qual
seu conteúdo pode ser acessado ao navegar entre os elementos do projeto com a tecla “Tab” e pressionar
a tecla “Enter” no elemento em que o acesso é desejado.
Na sequência, serão apresentados os principais atalhos que poderão ser usados na IDE Eclipse, para me-
lhor a experiência de uso da ferramenta, assim como aumentar o desempenho do desenvolvedor. Acom-
panhe e pratique!
Ctrl + m = Ampliar a Área de Trabalho
A ampliação da área de trabalho para desenvolver o código é importante para facilitar a visualização do
conteúdo do arquivo, sendo possível aumentar essa área ocultando a estrutura de projeto e ajustando esse
espaço para o tamanho da tela do computador, sendo possível alternar entre a Área de Trabalho ampliada
ou reduzida com o mesmo atalho, Ctrl + m.
Eclipse ([20--?])
Figura 37 - Área de Trabalho ampliada

65
Na figura anterior, a declaração da classe Curso, na qual poderá ser construído o seu código, tem sua área
de trabalho aumentada, melhorando a visualização e focando o desenvolvimento no conteúdo do código.
Ctrl + “Tecla espaço” = Criar o método Main (principal) da classe
Como você já viu na Orientação a Objeto, as classes representam um modelo de algo que deve ser
representado no sistema e sua instância, ou seja, seu objeto, é um elemento criado a partir deste modelo,
que só pode ser executado a partir de um método especial, que é identificado como método Main, ou
método principal da classe.
Nesse novo atalho apresentado, facilmente o método Main é criado, iniciando a digitação da palavra
“main” e pressionando as teclas de atalho Ctrl + “Tecla espaço”, dessa forma otimizando a criação do códi-
go e evitando possíveis erros de digitação.
Eclipse ([20--?])
Figura 38 - Método “Main” da classe Java
new + <Nome da Classe abreviada> + Ctrl + “Tecla espaço” = Criar o construtor da Classe
Com esse próximo atalho, você poderá criar a instância de uma classe Java com seu respectivo constru-
tor, sendo necessário apenas retornar para a linha criada e associar a variável deste objeto.
66
Na figura a seguir, é possível observar o uso deste atalho, que certamente irá otimizar seu desempenho.
Eclipse ([20--?])
Figura 39 - Nova Instância de classe Java
Ctrl + 1 = Usado para verificar sugestões de ajuste do código
Ao iniciar o desenvolvimento, usando a IDE Eclipse, você irá perceber que, em muitos momentos, parte
do seu código será “marcada” quando houver uma sintaxe incorreta, falta de alguma dependência, entre
outras possibilidades que impediriam que seu código seja compilado.
67
Com o atalho apresentado, ao posicionar o cursor no trecho do código marcado e usar este atalho, o
Eclipse irá sugerir possibilidades de ajuste ou correção do seu código, ou seja, a sintaxe poderá ser corrigi-
da automaticamente, uma dependência poderá ser criada ou importada para a classe, entre várias outras
possibilidades de sugestões de acordo com o ajuste necessário.
Eclipse ([20--?])
Figura 40 - Código Java com possibilidades de ajuste
Ctrl + s = Usado para salvar alterações no código
Uma facilidade que o Eclipse apresenta é evidenciar quando houve alguma alteração no seu código e
esta modificação não foi salva, por meio de um asterisco na “Aba” que identifica arquivo do seu código.
Uma forma de manter as alterações salvas é com o atalho mostrado anteriormente. Dessa forma, com o
bom hábito de salvar a evolução do seu trabalho frequentemente, este atalho mostra-se muito útil por
ajudar a otimizar seu tempo e garantir que não haverá perdas.
([20--?])
Eclipse
Figura 41 - Arquivo de código Java não salvo
Na figura anterior, os arquivos “Curso.java” e “Aluno.java” estão salvos, enquanto que o arquivo “Verifi-
caAprovacao.java” possui alguma edição sem salvamento, pois apresenta um asterisco ao lado esquerdo
do seu nome.
68
Syso + Ctrl + “Tecla espaço” = Criar a instrução de print
É muito comum, no processo de desenvolvimento e de aprendizado da linguagem, ser usado um mé-

todo de “print” ou saída no console, seja do terminal de execução ou no console da própria IDE. Apesar
desse método não ter uma sintaxe muito longa, escrevê-la com frequência é cansativo e pouco produtivo,
por isso, com o atalho destacado anteriormente, será possível criá-la de forma rápida e sem possíveis erros
de sintaxe.
Eclipse ([20--?])
Figura 42 - Método println do código Java
Ctrl + F11 = Executar o método Main da classe
Na IDE, há um botão para executar o código Java que possui seu método “Main” ou método principal,
porém seria necessário usar o mouse para posicionar o seu cursor e realizar o clique neste botão. Como
mencionado, para buscar o melhor desempenho no processo de desenvolvimento, essa ação de execução
do código também pode ser feita por meio de teclas de atalho, com o arranjo de teclas apresentado acima.
69
Eclipse ([20--?])
Figura 43 - Execução do método Main da classe Java
Ctrl + F3 = Acessar a Classe instanciada selecionada
No conteúdo do código Java, é comum haver outras classes referenciadas, e com este atalho é possível
acessar o arquivo dessas classes referenciadas, otimizando muito a realização de tarefas de desenvolvimento,
permitindo navegar entre diferentes arquivos com estas classes relacionadas que compõem um sistema.
Eclipse ([20--?])
70
Eclipse ([20--?])
Figura 44 - Acesso de classe referenciada no código Java
Alt + pgup e Ctrl + pgdn = Navegar entre as abas do Eclipse
Durante o desenvolvimento ou manutenção de um sistema, é comum abrir vários arquivos de códigos,

que normalmente possuem alguma relação, e também é frequente navegar entre tais arquivos. Dessa for-
ma, o atalho indicado permite a alternância de arquivos de forma rápida e eficiente.
([20--?])
Eclipse
Figura 45 - Abas do Eclipse
Alt + shift + a = Ativa/desativa a funcionalidade de seleção em bloco
A funcionalidade de seleção em bloco representa um exemplo nítido de como evitar ações repetitivas
na construção do código, pois permite selecionar áreas específicas de trechos do código para replicar par-
tes deste código, que, no uso convencional da ação de copiar e colar, teria que ser usada de forma repetida,
assim, trazendo mais agilidade no processo de codificação.
Eclipse ([20--?])
Figura 46 - Seleção em bloco dos modificadores de acesso

71
Ctrl + 3 = Ativa janela com menus do eclipse (getter/setter – construtor)
No Eclipse, há um menu com várias opções, que envolvem inserção de facilidades, formatação do códi-
go, configurações, entre outras. Com o atalho referenciado, esse menu pode ser acessado a partir da área
de trabalho, na qual o código está sendo desenvolvido, novamente evitando a necessidade do uso do
mouse para acessar tais opções de menu.
Na OO, você tem o conceito de encapsulamento, como já foi visto, que na prática consiste no isolamen-
to de atributos ou métodos, sendo necessário métodos especiais para acessar estas partes encapsuladas
do código. Tais métodos são identificados, por padronização da comunidade de desenvolvimento, de get-
ter e setter, responsáveis, respectivamente, por retornar e inserir valor nos elementos encapsulados. Como
a criação destes métodos é uma atividade de repetição, o Eclipse possui uma funcionalidade que escreve
tais métodos automaticamente, gerando grande economia de esforços nesta codificação.
Eclipse ([20--?])
Figura 47 - Acesso ao menu do Eclipse para gerar Getters/Setters

72
Alt + “seta para cima/seta para baixo” = Move a linha atual para cima/baixo
Este próximo atalho é muito interessante, pois com poucas combinações de teclas é possível mover
linhas inteiras de código para diferentes lugares do arquivo, sem a necessidade de copiar/recortar e colar,
bastando apenas mover para cima ou para baixo da posição atual.
Eclipse ([20--?])
Figura 48 - Mudança de posição do método setNome com os atalhos
Ctrl + Shit + f = Formatar o código automaticamente

73
A formatação ou indentação do código é de grande importância para facilitar na leitura, interpretação e

possível manutenção, para que a lógica programada possa estar melhor explícita. Com este atalho, todo o
código criado é automaticamente formatado, economizando muito tempo de verificação de indentação, e
garantindo que está corretamente formatado.
Eclipse ([20--?])
Figura 49 - Diferença entre o código não formatado e formatado
Na sequência, você verá um grupo de atalho usados para buscas de formas diversas em elementos do
seu código, no seu projeto e ainda na sua própria workspace.
Confira estes atalhos, pratique na IDE Eclipse e perceba a otimização naquela procura por uma classe
específica, um arquivo dentro da sua estrutura de projeto ou ainda um arquivo em sua workspace a partir
de um texto existente no arquivo.
74
Grupo de atalhos de busca
ATALHO FUNÇÃO
Ctrl + shift + r Busca de arquivos pelo projeto

Ctrl + shift + t Busca por classes
Ctrl + o Busca de elementos da classe
Ctrl + f Busca textual e replace
Ctrl + h Busca textual mais abrangente, em até todo o workspace
Quadro 1 - Grupo de atalhos para busca
Fonte: Fonte: Do autor (2018)
Ctrl + shift + g = Verifica onde o elemento da classe é usado
Em arquivos extensos de código, em que existem muitos elementos e o uso destes elementos ocorre
em diferentes linhas do código, é muito útil existir uma funcionalidade, nesse caso, um atalho, para verifi-
car e localizar onde tais elementos são usados. Novamente, a IDE salva nossa vida e proporciona o atalho
mostrado acima para esta função!
Eclipse ([20--?])
Figura 50 - A view Search mostra onde o elemento é usado

75
Ctrl + shift + o = Realiza import pendente
Na orientação a objeto, é mais do que normal reutilizar código de outras classes do seu sistema, locali-
zadas em diferentes pacotes e API’s diversas. Porém, é necessário declarar a origem destes elementos ex-
ternos, para que o compilador do seu código possa identificar estas bibliotecas. Para esta tarefa, o Eclipse
também oferece uma ajuda, pois com um simples atalho a IDE identifica os imports pendentes e resolve
para você, mais uma vez proporcionando mais dedicação à pura arte da programação, deixando as ações
repetitivas de lado.
Eclipse ([20--?])
Figura 51 - Realização do Import com o atalho
Ctrl + shift + w = Encerra todas as abas do Eclipse

76
Como já foi visto, na IDE, é possível trabalhar em diversos arquivos, mantendo estes arquivos abertos
de forma simultânea, possibilitando navegar entre estas abas e proporcionando mais produtividade. Para
fechar todas estas abas, a IDE também facilita, com um único atalho você consegue fechar seus arquivos e
encerrar todas as abas de uma única vez, para não tardar aquele momento especial de fim de expediente
e do merecido descanso.
FIQUE A produtividade de um desenvolvedor de software, assim como as estimativas de

suas demandas, é medida em horas. Portanto, a otimização de tarefas repetitivas é
ALERTA fundamental para o seu sucesso profissional.
Confira a seguir outras funcionalidades do Eclipse.
5.1.2 MAIS FACILIDADES E FUNCIONALIDADES COM O ECLIPSE
Além das diversas funcionalidades vistas até o momento para a IDE Eclipse, ainda há outras facilidades
para potencializar o desempenho do desenvolvedor. Uma dessas funcionalidades é denominada “View”,
que se trata de diferentes visões ou formas de observar o projeto de software e seus diversos elementos.
Serão abordadas e mostradas aqui as principais “Views” do Eclipse, que certamente irão facilitar as suas
atividades na IDE.
Como nosso foco no Eclipse é a linguagem de programação Java, será preciso selecionar a perspectiva
Java, que pode ser selecionada com o uso do atalho Ctrl + 3, que irá habilitar o menu da ferramenta, como
pode ser visto na figura a seguir.
Eclipse ([20--?])
Figura 52 - Seleção da Perspectiva Java

77
Ao selecionar a perspectiva, por padrão, o Eclipse já habilita algumas visões, como segue,
Package Explorer
Visão responsável por mostrar a estrutura do projeto, organizando os arquivos por meio de pacotes ou
diretórios, de acordo com a apresentação selecionada.
Tipos de apresentação:
a) flat: apresentação com estrutura de pacotes;
b) hierarchical: apresentação com estrutura de diretórios.
Eclipse ([20--?])
Figura 53 - Apresentação da View Package Explorer
Editor
a) Principal visão do Eclipse, pois é o local onde o código vai ser construído ou editado.
b) Pode possuir diversos arquivos abertos simultaneamente.
c) Arquivos ficam dispostos em abas.
Task List
a) Visão de gerenciador de tarefas.
b) É preciso que a IDE esteja conectada com uma ferramenta externa.
c) Pode ser minimizada, caso não exista integração com uma ferramenta externa, para proporcionar
mais espaço para a visão do Editor.
78
Eclipse ([20--?])
Figura 54 - View Task List
Outline
a) Visão dos elementos da classe.
b) Mostra atributos e métodos das classes do arquivo que está ativo no Editor da IDE.
Eclipse ([20--?])
Figura 55 - View Outline
Problems
a) Útil para localizar de forma rápida mensagens de “Warming” e possíveis erros.
b) Possui link das mensagens apresentadas aos seus respectivos arquivos.
Javadoc
a) Apresenta o Javadoc do arquivo ativo na visão do Editor, na posição do cursor.
Declaration
a) Apresenta a declaração dos elementos do arquivo ativo na visão. do Editor, na posição do cursor.
79
Eclipse ([20--?])
Figura 56 - View’s Problems, Javadoc e Declaration
Além das visões, a ferramenta provê outras facilidades, como os comentários especiais, para marcar
trechos de código, em que será necessário algum tipo de ação futura, que são relacionados abaixo:
//TODO = algo que precisa ser feito.

//FIXME = algum bug a ser corrigido.
//XXX = algo que precisa ser refatorado.
É possível configurar outros tipos de comentários, de forma personalizada, acessando o menu (Ctrl + 3)
e buscando o menu “task tags”, para acrescentar suas próprias tags ou tipos de comentários.
Eclipse ([20--?])
Figura 57 - Configuração de Task Tags
A partir da inserção destes comentários ou tags, é possível habilitar outra View, localizada na mesma
posição das abas “Problems”, “JavaDoc” e “Declaration”, vistas anteriormente, identificada como “Tasks”.
Ela irá relacionar todas as marcações ou comentários realizados com estes comentários especiais do Eclipse.
Para habilitar a View “Tasks” basta usar o atalho “Ctrl + 3” e buscar pela palavra “Tasks”, para encontrar
esta visualização.
80
Eclipse ([20--?])
Figura 58 - Configuração da View Tasks
Após inseri-la, será possível verificar uma lista de comentários especiais, evidenciando as ações neces-
sárias a serem realizadas, de acordo com os comentários especiais inseridos no código.
Eclipse ([20--?])
Figura 59 - Apresentação da View Tasks
SAIBA A IDE Eclipse é altamente direcionada a plugins, para que funcionalidades possam ser
associadas ou instaladas em seu ambiente de desenvolvimento. Acesse o site <http://
MAIS www.eclipse.org/mpc/> e saiba mais!
81
Confira na sequência como integrar repositórios.
5.1.3 INTEGRANDO REPOSITÓRIOS
No desenvolvimento de software é extremamente comum mais de um programador trabalhar no mes-

mo sistema de forma simultânea, colaborando para diferentes partes do sistema.
Porém o sistema precisa estar atualizado de forma geral, para que o desenvolvimento de um determi-
nado programador possa considerar as alterações realizadas e sobretudo para manter um processo de
versionamento efetivo.
Para resolver esse problema, são usados repositórios remotos de software, nos quais diferentes desen-
volvedores conectam-se, normalmente a partir de sua IDE, para interagir de forma coletiva com o sistema.
Nessa solução de repositórios remotos, alguns elementos atuam de forma integrada, sendo eles:
Git
a) Sistema de controle de versão.
GitHub
a) Rede social para desenvolvedores e programadores.
b) Repositório remoto.
IDE
a) Eclipse.
EGit
a) Plugin da IDE.
b) Responsável pela integração entre GitHub e Eclipse.
A seguir você irá entender para que o Git foi criado. Acompanhe!
CONHECENDO O GIT
O Git foi criado com o propósito de ser um sistema de versionamento e repositório para compartilhar as
evoluções e correções do kernel do Linux, com o objetivo de ser simples, robusto, altamente eficiente, com
capacidade para desenvolvimento não linear (ramificações) e ser distribuído.
82
Ele pode ser instalado localmente, no computador do desenvolvedor, para criar uma estrutura de ver-
sionamento e adicionar repositórios remotos, para que estes arquivos locais possam ser compartilhados e
sofram alguns processos.
Basicamente, no Git, os arquivos seguem o seguinte fluxo de trabalho:
a) armazenamento no diretório de trabalho (local);
b) adicionados para uma área temporária, identificada como Index: serve como uma marcação para
arquivos que podem seguir para o próximo passo do fluxo;
c) adicionados para uma área identificada como Head: são arquivos que foram confirmados (sofreram
“commit”);
d) enviados para o diretório remoto (comando “push”).
Existem diversos repositórios remotos, porém alguns são mais conhecidos e adotados com mais fre-
quência, entre eles está o GitHub, no qual será demostrado, no próximo tópico, como criar uma conta de
acesso e um repositório, que poderá ser integrado com a sua IDE.
No entanto, antes de ser demonstrado como instalar o Git, seus principais comandos e funcionalidades,
é importante ressaltar que não é obrigatória a instalação do Git quando há a integração da IDE com o repo-
sitório remoto, mas a instalação pode evitar possíveis erros ou comportamentos inesperados na integração.
Para iniciar o procedimento, será necessário realizar o download do arquivo de instalação, disponível
no endereço: <https://git-scm.com/downloads>, selecionando o arquivo de acordo com o seu sistema
operacional, como demonstrado na figura a seguir.
Git ([20--?])
Figura 60 - Site para download do Git
Após a instalação, você poderá executar o Git e será direcionado para uma interface de linha de coman-
do, na qual você poderá navegar entre os diretórios do seu computador e criar um diretório para o Git,
como ilustrado na próxima figura.
83
Git ([20--?])
Figura 61 - Interface de linha de comando do Git
Para tornar o diretório recém-criado em um repositório, será preciso executar o comando:
git init
Com este comando, o sistema irá iniciar um repositório vazio do Git, como é observado na figura que
segue abaixo. Git ([20--?])
Figura 62 - Comando para criar novo repositório Git

84
No Git, você poderá trabalhar localmente ou remotamente, assim como pode iniciar o trabalho a partir
de um diretório Git já existente, com os comandos que segue:
Cópia de um repositório local:
git clone <caminho para do repositório local>
Cópia de um repositório remoto:
git clone usuario@servidor:<caminho para do repositório local>
Após possuir o diretório com arquivos de seu projeto, de acordo com as alterações, evoluções, corre-
ções e edições de forma geral, será preciso identificar quais arquivos possuem suas edições concluídas
para “marcá-los” como um trabalho apto para ser confirmado ou a sofrer um commit. De acordo com o
fluxo de trabalho do Git, nesta etapa, os arquivos com edições finalizadas serão transferidos para uma área
temporária, identificada como Index.
O comando para realizar esta ação:
git add <arquivo>
git add *
No primeiro comando, somente um arquivo é marcado para a Index, enquanto que o segundo coman-
do marca todos os arquivos alterados.
Após você marcar os arquivos para a Index, será possível realizar o commit, que confirmará as alterações
realizadas e irá transferir os arquivos para uma nova área temporária, identificada como Head.
Comando para realizar o commit:
git commit -m “inserir comentário sobre a alteração”

85
Apesar da confirmação das alterações, caso esteja colaborando com um repositório remoto, estes ar-
quivos modificados ainda não permanecem somente localmente. Para enviar tais arquivos para o reposi-
tório remoto, é necessário executar o comando:
git push origin master
No comando anterior, o termo “master” refere-se ao “branch” padrão do git. Você pode entender bran-
ch como uma versão de trabalho, dessa forma será possível criar diversos branches, de acordo com as
atividades realizadas no projeto.
Para criar novos branches e selecioná-los e enviá-los para o repositório remoto, é preciso executar os
comandos listados abaixo:
git checkout -b <novo branch>

git checkout master
git push origin <novo branch>
No primeiro comando, é criado um novo branch e selecionado o mesmo; no segundo, é usado para
retornar para branch padrão; e, por último, é enviado para o repositório remoto o novo branch criado.
Como mencionado antes, a intenção do uso de repositórios remotos é a colaboração mútua, sendo
assim é comum você precisar atualizar seu repositório local, com alterações realizadas por outros desen-
volvedores.
Para esta ação é usado o comando:
git pull
E existe ainda a situação na qual as alterações realizadas em branch precisam ser incorporadas ao bran-
ch principal. Este procedimento é identificado como “merge” ou mescla de diferentes ramificações (ver-
sões) de partes do sistema.
Segue o comando usado:
git merge <branch>

86
A cada merge realizado, é possível existir conflitos de arquivos idênticos que foram alterados. Dessa
forma, é necessário analisar tais arquivos e realizar os ajustes demandados para permitir a junção das dife-
rentes ramificações.
CONHECENDO O GITHUB
Neste tópico, será retomado o assunto sobre repositório remoto, no qual pode ser adicionado no Git ou
ainda integrado em sua IDE, como você verá mais adiante.
O GitHub representa um dos maiores e mais populares repositórios remotos, além de ser uma rede
social de desenvolvedores para compartilhamento de código.
Para usar o GitHub, não será necessário instalar qualquer software em seu computador, pois todo o
serviço é disponibilizado na internet, sendo necessário apenas criar uma conta no site e realizar algumas
configurações para criar seu repositório remoto. Acompanhe o procedimento a seguir, para que você pos-
sa criar seu próprio repositório.
Para iniciar, será preciso acessar o endereço <https://github.com/join?source=header-home>, no qual
você será direcionado para o primeiro passo do cadastro no site, como é demonstrado abaixo.
Git ([20--?])
Figura 63 - Cadastro de usuário no GitHub

87
Na sequência, será necessário escolher o plano associado ao cadastro, com duas opções, sendo uma
gratuita, que possibilitará criar repositórios de forma ilimitada, mas todos sendo públicos, ou seja estando
visível para todos os usuários da plataforma, ou a segunda opção que apresentará um custo, que possi-
bilitará criar ilimitados repositórios privados, com acesso restrito a estes repositórios. Segue imagem para
ilustrar esta segunda etapa do cadastro.
Git ([20--?])
Figura 64 - Segundo passo do cadastro no GitHub
Após o segundo passo, o cadastro está concluído. O terceiro passo é uma adaptação à usabilidade do
site. A partir deste ponto, já é possível iniciar um novo projeto e criar seu repositório, de acordo com as
figuras que seguem.
Git ([20--?])
Figura 65 - Tela para iniciar o projeto

88
Git ([20--?])
Figura 66 - Tela de cadastro de novo repositório
Na figura anterior, são destacados os campos que irão compor o nome do repositório, contendo, no
campo “Owner”, o login do cadastro no GitHub e, no campo “Repository name”, o nome que se deseja dar
ao repositório, normalmente associado ao nome do projeto.
É interessante inserir uma descrição para o repositório e marcar o check-box “Initialize this repositor with
a README”, para posteriormente clicar no botão “Create repository”, para que o repositório possa ser criado.
Assim que o repositório é criado, automaticamente ele será disponibilizado e pode ser visualizado e
gerenciado pelo GitHub, de acordo com a figura a seguir.
89
Git ([20--?])
Figura 67 - Repositório criado
Neste exemplo, foi criado o repositório remoto “poo”, onde podem ser acessados os arquivos submeti-
dos, assim como demais estatísticas, informações e configurações associadas.
CONHECENDO O EGIT
O EGit é um plugin, ou uma parte adicional, da IDE Eclipse, com o propósito de integrar repositórios
remotos ao Eclipse, sendo desenvolvido e mantido pela comunidade e fundação Eclipse.
O valor agregado é muito grande, pois possibilita reunir no mesmo ambiente de desenvolvimento, fun-
cionalidades com interface gráfica, para realizar as mesmas ações do Git, que eram originalmente realiza-
das somente por interface de linha de comando, assim provendo maior desempenho no desenvolvimento
e fomentando o compartilhamento e colaboração de projetos de software.
90
INTEGRANDO O GIT E ECLIPSE
Neste último tópico sobre as ferramentas de desenvolvimento, será demonstrado como realizar a in-
tegração entre o Git ou, mais especificamente, o GitHub com o Eclipse. A demonstração será direcionada
para o GitHub, para que seja possível visualizar o uso de um repositório remoto com a IDE, porém é possí-
vel realizar a mesma configuração, alterando alguns parâmetros, para integrar o Eclipse com o Git.
Para iniciar, é preciso instalar o EGit no Eclipse, acessando o menu “Help” e a opção “Eclipse Market-
place”, na qual deverá ser realizada uma busca pelo EGit e realizada a instalação. As imagens seguintes
demonstram os passos iniciais descritos.
Git ([20--?])
Figura 68 - Menu da IDE para acessar o Eclipse Marktplace

91
Git ([20--?])
Figura 69 - Instalação do EGit no Eclipse Marketplace

92
Ao concluir a instalação, será preciso reiniciar a IDE para que a configuração do repositório remoto
possa ser realizada. Nesta etapa, será preciso selecionar a perspectiva Git do Eclipse, para que o link da
configuração esteja disponível, por meio da opção “Clone a Git repository”, tendo em vista que o propósito
é integrar um repositório remoto existente. A figura a seguir ilustra este momento inicial da configuração
da integração.
Git ([20--?])
Figura 70 - Link para configuração do repositório remoto
A configuração é basicamente restrita a três telas, nas quais, inicialmente, serão definidos o local, o
protocolo de conexão e os dados de usuário para autenticação no repositório remoto, sendo estas in-
formações obtidas a partir da conta criada, nesse contexto, no GitHub. A figura a seguir mostra a tela de
configuração e alguns dados do repositório remoto utilizado.
93
Git ([20--?])
Figura 71 - Configuração do repositório remoto
Na segunda tela de configuração, deverá ser selecionado o branch ou versão do projeto, que será reali-
zado o clone, ou seja, a parte do projeto que será espelhada localmente em sua IDE.
Neste procedimento, o repositório remoto usado possui somente o branch padrão, identificado como
branch “master”, como pode ser visto na figura que segue.
94
Git ([20--?])
Figura 72 - Seleção do branch na configuração do repositório remoto
Na última tela de configuração da integração da IDE com o repositório remoto, serão definidos o dire-
tório local, para armazenar as informações clonados do repositório, e o nome deste repositório remoto,
tendo em vista que é comum haver alguns repositórios conectados a IDE.
95
Git ([20--?])
Figura 73 - Configuração do diretório local e nome do repositório
Ao concluir todas as configurações mencionadas, deverá ser possível ter acesso às opções do menu do
plugin EGit, que disponibilizará as funcionalidades de acordo com as ações possíveis no Git, como é ilustra-
do na figura seguinte.
96
Git ([20--?])
Figura 74 - Menu do EGit
Por fim, foram descritos os principais conceitos relacionados às ferramentas mais usuais que permeiam o
cotidiano de um desenvolvedor de sistemas, assim como demonstradas boas práticas de uso, formas de ex-
plorá-las com o objetivo de obter maior produtividade do profissional, possíveis configurações e integrações.
A melhor forma de reforçar todo o conhecimento obtido é praticar, para que as suas ferramentas e ha-
bilidades possam estar sempre calibradas e bem afiadas!
97
CASOS E RELATOS
A importância da utilização das ferramentas adequadas

Ao iniciar as suas atividades de desenvolvedor de software, José utilizava ferramentas básicas para
criar e editar os códigos dos sistemas que trabalhava, porém percebia que colegas com a mesma
experiência conseguiam produzir com mais qualidade e também em quantidade. Diante desse
desafio profissional, José percebeu que o caminho para otimizar suas atividades era tornar seu
ambiente de desenvolvimento mais robusto e integrado, com ferramentas que pudessem dar su-
porte a análise de sintaxe do código, gerenciar o versionamento de seus sistemas, por meio de um
compartilhamento de código organizado, criar trechos básicos e repetitivos de codificação, assim
como proporcionar facilidades de implementação de validação de código, ou também identifica-
dos como testes unitários.
Após essa mudança de caminho que José se propôs a fazer, ele conseguiu descobrir o quanto é
importante o uso de ferramentas adequadas no processo de desenvolvimento de software.
Você chegou ao final de mais um capítulo desta Unidade Curricular. Leia o “Recapitulando” a seguir e
reveja os principais conceitos estudados aqui.
98
RECAPITULANDO
O assunto discutido neste capítulo certamente irá influenciar no seu futuro cotidiano de desenvol-
vimento de software, pois foi diretamente abordado a IDE Eclipse e suas vantagens no processo
de codificação.
Foram apresentados diversos atalhos para ações repetitivas, inerentes ao processo de codificação,
para deixar esses tipos de ações a encargo da IDE e proporcionando ao desenvolvedor mais tempo
para construir a sua obra-prima, com isso provendo mais produtividade.
A IDE Eclipse permite a instalação de plugins que trazem para o ambiente de desenvolvimento
novas funcionalidades e facilidades, as quais foram abordadas neste capítulo, incrementando mais
um conhecimento importante para o processo de desenvolvimento.
Ao final do capítulo, foram apresentadas configurações da IDE para permitir o uso de repositórios
de códigos, assim como foi criado um repositório online e demonstrado o procedimento para que
você possa replicar este conhecimento de forma prática.
Este capítulo certamente representa uma evolução na forma como o seu código pode ser construí-
do e compartilhado. Avance para os próximos capítulos e veja como o conhecimento pode evoluir
ainda mais suas habilidades!
Testando a Implementação
OO em Java
Neste capítulo, serão abordados temas que proporcionam maior qualidade ao software de-
senvolvido, com a intenção de encontrar e corrigir defeitos produzidos ao decorrer do desen-
volvimento de sistemas.
Estes temas estão relacionados a testes de software, contudo, nessa abordagem, haverá um
direcionamento para tipos de testes específicos, produzidos e executados direcionados ao de-
senvolvimento e em nível de código, na linguagem de programação orientada a objeto Java.
Boas práticas sugerem que os testes devem ser planejados e desenvolvidos em paralelo ao
desenvolvimento e, novamente remetendo estes testes ao código implementado, deve haver
um desenvolvimento de testes, que possam validar o correto funcionamento de métodos e
classes implementadas no software.
A grande vantagem de produzir tais testes durante a construção da aplicação é a garantia
de que pequenas unidades do sistema estão corretas e produziram um sistema com menos
chances de apresentarem defeitos de codificação, além de permitir a execução futura, no caso
alterações do sistema, para verificar se defeitos não foram introduzidos no software.
Nos tópicos seguintes deste capítulo, você irá conhecer mais sobre os conceitos gerais do
teste de software, aprofundamento o conhecimento sobre os testes unitários e após o conte-
údo teórico, será convidado a implementar testes em Java, no paradigma orientado a objeto.
a) compreender termos e conceitos gerais sobre testes de software;
b) diferenciar os principais e diferentes tipos de testes de sistemas;
c) compreender o conceito e a importância de testes unitários;
d) implementar um teste unitário para linguagem Java.
102
6.1 CONCEITOS GERAIS SOBRE TESTE
Os testes de software constituem um processo que pode ser iniciado desde a fase de levantamento
de requisitos do sistema até a entrega final para o cliente. Dessa forma, é possível perceber que existem
diferentes classificações, tipos, objetivos e níveis de execução de testes, ainda com diferentes formas de
executá-los.Com a intenção de contextualização do foco da nossa abordagem, o teste unitário, você irá
conhecer os conceitos gerais sobre o universo do teste de software, para que você possa visualizar como o
teste unitário é inserido neste contexto e consequentemente a sua importância.
CURIOSI Você sabia que não precisa ter um software pronto para iniciar os testes de softwa-
re? Existem técnicas estáticas para análise de documentação, como especificação de
DADES requisitos, documentos de projeto, código fonte, entre outros.
Nos fundamentos do teste de software, existem termos específicos, relacionados a ações do desenvol-
vedor do sistema, onde estes termos estarão associados a diferentes eventos durante o uso do software e
seu comportamento. Confira a seguir os termos e seus respectivos conceitos.
Erro
Está relacionado à ação equivocada do programador, como um erro de digitação de uma variável.
Defeito
Representa a manifestação do erro, durante o uso do software, ou seja, determinado componente apre-
senta um defeito ou bug quando é executado.
Falha
É o momento no qual o defeito é encontrado, fazendo com que o software apresente um comportamento
diferente do esperado.
Estes conceitos são interessantes e relevantes, pois, estatisticamente, nenhum software está livre de
erros ou defeitos. Por outro lado, tais elementos podem não ser identificados no uso do sistema, ou seja,
não se tornam falhas do sistema e, consequentemente, não são percebidos pelo usuário final.
Este fato torna evidente a necessidade de manutenção e busca por evolução do sistema, para que este
possa continuar atendendo seu propósito e proporcionar uma boa experiência de uso.
Neste processo de manutenção e evolução, o teste tem papel fundamental, pois ajuda a construir uma
relação de confiabilidade entre o software e seu usuário, pois, quanto menos defeitos, certamente a possi-
bilidade de falhas será menor.
Você, neste momento, pode estar pensando: se o teste tem tamanha importância, a solução ideal seria
testar o sistema constantemente, para que cada vez mais novos defeitos sejam encontrados e resolvidos,
para que o sistema seja cada vez melhor.
6 TESTANDO A IMPLEMENTAÇÃO OO EM JAVA
103
Este pensamento tem lógica! Mas, infelizmente, não é viável, e aqui existe outra constante do teste de
software: é impossível ou impraticável testar todo o sistema, por motivos como cronograma do projeto e
custos associados.
Sendo assim, algumas estratégias precisam ser adotadas, realizando testes em partes do sistema com
maior risco de falhas e em módulos mais importantes ou críticos do sistema.
A atividade de teste consiste em um processo, que compreende várias atividades, como o planejamen-
to e controle dos testes, seleção dos itens de teste, modelagem dos casos de teste, a execução, a verifica-
ção dos resultados, a avaliação dos critérios de conclusão dos testes e atividades de encerramento.
São muitas tarefas desenvolvidas neste processo, por isso acompanhe brevemente seus conceitos e
conheça um pouco mais sobre o que compreende o desenvolvimento de software.
No planejamento, são determinados os objetivos do teste, e o controle busca alcançar o que foi plane-
jado, criando mecanismos de acompanhamento da evolução do processo de teste.
Na modelagem dos casos de teste, os objetivos definidos no planejamento são transformados em con-
dições de teste, ou seja, como estes testes serão realizados.
A atividade de execução é onde os testes são de fato realizados, de forma manual ou automatizada,
sendo que também ocorre neste momento a checagem dos resultados e seus registrados.
A partir dos resultados dos testes, a atividade de avaliação de critérios de saída verifica se estes critérios
definidos no planejamento foram alcançados, para verificar se os testes foram ou não suficientes.
Por fim, a atividade de encerramento tem como objetivo coletar os resultados dos testes para arquiva-
mento, verificar se o planejamento foi de fato concluído e checar se os defeitos encontrados foram corrigidos.
Planejamento
Análise e
modelagem
Implementação
Controle
e execução
Avaliação do
critério de
saída e
relatórios
Davi Leon (2017)
Atividades de
encerramento
de teste
Figura 75 - Atividades do processo de teste
104
Na figura anterior, são observadas as atividades do processo de teste e o sentido que o fluxo destas
atividades percorre, destacando a atividade de controle, que é constante em todo o processo, para que a
execução das atividades esteja de acordo com o planejado.
No contexto de software, há modelos que associam o ciclo de desenvolvimento do software com testes
e, entre eles, está o “Modelo V”, que mostra a relação entre o nível de teste e seu respectivo momento de
desenvolvimento.
O modelo prevê que a cada atividade de desenvolvimento há uma atividade correspondente de teste,
reforçando a importância e a necessidade da realização de testes desde o início do ciclo de vida do sistema.
Requisito Teste de aceitação
Análise Teste de sistema

Verificação
Validação
Arquitetura Teste integração
Código Teste unitário
Davi Leon (2017)

Figura 76 - Modelo V de teste
Como pôde ser observado na figura anterior, o modelo também demonstra que, no levantamento de
requisitos de software, os testes de aceitação deverão ter seu planejamento e modelagem iniciados e assim
sucessivamente, até o ponto em que os testes unitários são criados e executados, durante a codificação do
sistema e, posteriormente, os testes previamente planejados e modelados serão colocados em prática, a
cada nível buscando mais a validação do que a verificação, ou seja, no nível mais alto de teste a intenção
não é mais verificar possíveis defeitos, mas demonstrar que o sistema está funcionando de acordo com a
especificação.
Na sequência, serão apresentados os objetivos e principais conceitos dos níveis de teste, mencionados
no “Modelo V”, acompanhe.
Teste Unitário
Este teste também é identificado como teste de componente ou de módulo, pois testa cada parte do
código, ou seja, implementações de métodos e classes. Pode ter como objetivo verificar características
funcionais ou não funcionais, como exemplo, o uso de memória, e geralmente é criado e executado pelo
implementador.
Teste de Integração
É o teste que analisa o comportamento das interfaces e interações entre partes do sistema ou entre
sistemas completos. Como mencionado, o teste pode verificar a integração entre sistemas ou em menor
105
escala, pela integração ou comunicação de elementos internos ao sistema. Estes testes também são
realizados por desenvolvedores, normalmente após a realização dos testes unitários.
Teste de Sistema
Este costuma ser o teste mais abrangente, pois testa todo o comportamento do sistema, com a finalida-
de de reduzir os defeitos existentes no sistema. Neste teste, são verificadas as características funcionais, ou
seja, as funções que o sistema deve desempenhar, as características não funcionais, relacionadas, de forma
geral, à qualidade e desempenho do sistema, e, por fim, ocorre a validação das regras de negócio que o
sistema deve atender. Este teste normalmente é realizado por testadores, que podem utilizar técnicas ba-
seadas na especificação do sistema, conhecidas como “caixa-preta”, e técnicas que analisam a estrutura do
software, identificadas como “caixa-branca”.
Teste de Aceitação
Este teste normalmente é executado pelo usuário ou existe o seu envolvimento, sendo aplicado para
o aceite do sistema por parte do cliente. Neste tipo de teste, não há a intenção de procurar defeitos, mas
demonstrar que o sistema funciona de acordo com o esperado.
O teste é um assunto muito interessante e que compreende inúmeros outros conceitos a assuntos re-
lacionados, mas, com base no que foi apresentado, você terá muitos subsídios para contextualizar o teste
unitário e perceber a importância deste teste na cadeia de execução dos mais variados testes, para buscar
a excelência na qualidade do sistema.
6.1.1 TESTE UNITÁRIO
Como se pode perceber, o teste unitário é realizado em unidades do sistema, ou seja, em partes indivi-
duais e que representam ações específicas, sendo validadas as funcionalidades ou demais características,
como o desempenho, robustez etc.
É importante destacar que estas unidades podem ter diferentes tamanhos, pois podem resumir-se a um
único método, assim como pode ser uma classe ou ainda um conjunto de classes que formam determinada
funcionalidade.
É importante que, para cada parte do sistema desenvolvida, seja também desenvolvido seu respectivo
teste, para buscar o correto funcionamento do software e reduzir defeitos causados pela implementação
do código.
A aplicação dos testes durante o desenvolvimento do sistema, tende a produzir grande valor, pois o
custo de possíveis correções, durante o período de desenvolvimento, é muito menor. Também existe um
processo reforçado de aprendizado das funções do sistema e, por fim, estes testes podem ser reaproveita-
dos na expansão do sistema, com testes de baixo custo e alta confiabilidade.
106
FIQUE Da mesma forma que o código pode ser alterado para suportar novas funcionalida-
des, o teste unitário também precisa ser modificado para refletir a implementação a
ALERTA ser testada.
Acompanhe a seguir o teste unitário na prática.
6.2 TESTE UNITÁRIO NA PRÁTICA
Ao iniciar a prática dos testes, será necessário que você conheça a ferramenta mais adequada e usual
para este propósito, considerando o tipo do teste e a linguagem de programação, nesse caso o Java.
O JUnit é um framework, que irá possibilitar criar testes de maneira fácil, por meio de classes Java, exe-
cutar estes testes e gerar relatórios. A IDE Eclipse implementa esta ferramenta, com visões específicas para
acompanhar a evolução e resultados dos testes executados a partir do JUnit.
Algumas convenções são usadas na aplicação do JUnit, para padronizar e facilitar a interpretação destes
testes, sendo estas listadas a seguir:
a) criar um diretório no projeto, exclusivo para os testes;
b) classes de teste possuem o mesmo nome da classe testada acrescida do sufixo “Test”;
c) deve ser escolhido nomes intuitivos para os métodos de teste, ou seja, que remetam ao objetivo do
teste.
SAIBA Existem certificados no mercado que garantem a qualificação do profissional de teste

MAIS de software. Visite o site <http://www.bstqb.org.br/> e confira mais detalhes a respeito!
Na sequência, você irá implementar alguns testes unitários, baseado na linguagem Java, com uso do
JUnit, demonstrando seu funcionamento, facilidades e recursos, por meio de exemplos de implementa-
ções já apresentados neste material, por isso acompanhe o próximo tópico para colocar a mão na massa!
6.2.1 IMPLEMENTANDO TESTE UNITÁRIO NO JAVA
Nesse momento, você é convidado a executar a sua IDE Eclipse e iniciar a implementação de testes
unitários automatizados com o JUnit.
Como você já havia estudado anteriormente, a IDE Eclipse proporciona diversas facilidades para o pro-
cesso de desenvolvimento, e com a implementação de testes unitários não será diferente. Para usar estes
107
recursos ao criar um novo teste, será preciso identificar qual a classe que será testada e acessá-la, para apli-
car a “mágica” da IDE, pressionando as teclas de atalho ctrl+N, selecionando a opção JUnit Test Case, como
pode ser observado nas figuras que seguem.
Git ([20--?])
Figura 77 - Classe Java que será testada
Na figura anterior, é demonstrada a classe Java que será testada pelo JUnit, no qual foi criado a partir
das teclas de atalho mencionas, conforme a imagem a seguir:
Git ([20--?])
Figura 78 - Criação do JUnit

108
Após selecionar a opção JUnit Test Case, as opções principais, como a versão do JUnit, o diretório fonte,
o pacote e o nome da Classe de teste são preenchidos automaticamente pela IDE, como pode ser visto na
figura que segue.
Git ([20--?])
Figura 79 - Definições da Classe JUnit
A seguir, o Eclipse possibilita a importação de bibliotecas necessárias para o correto funcionamento do

JUnit, fornecendo mais esta facilidade e otimizando seu trabalho, como pode ser acompanhado a seguir.
109
Git ([20--?])
Figura 80 - Biblioteca do JUnit 4 adicionada ao Eclipse
Ao concluir estes passos, a estrutura da classe de teste é criada, sendo necessária a implementação da
lógica do teste, como pode ser observado na próxima figura.
Git ([20--?])
Figura 81 - Estrutura da Classe de Teste JUnit
Nesse exemplo, você tem um projeto simples, demonstrando elementos fundamentais de uma institui-
ção de ensino, o “Curso” e o “Aluno”, e uma terceira classe que implementa o método principal, para validar
se determinado aluno foi aprovado ou reprovado em determinado curso.
110
Nossa classe JUnit irá testar o método que define a aprovação ou reprovação do aluno, de acordo com
a nota dele, sendo que nossa regra de negócio estabelece que o aluno com nota igual ou maior que 7,0
estará “Aprovado” e o aluno com nota inferior a 7,0 estará “Reprovado”.
Sendo assim, nossa classe de teste precisará comparar um resultado esperado, de acordo com a nota do
aluno, com o resultado produzido pelo método da classe “Curso”, como pode ser visto na figura que segue.
Git ([20--?])
Figura 82 - Classe de Teste JUnit Implementada
Ao executar a classe de teste, é obtido sucesso no resultado, pois o resultado esperado, comparado
pelo método “assertEquals”, com o resultado verificado foi coincidente. Este sucesso é exibido pelo Eclipse
em um relatório, como pode ser observado na figura a seguir.
Git ([20--?])
Figura 83 - Resultado da Execução do JUnit
Para simular um resultado de falha no teste, foi implementado um novo método, com resultado espe-
rado e verificado divergentes, com o objetivo de visualizar o comportamento da IDE no cenário de repro-
vação do teste.
111
Git ([20--?])
Figura 84 - Novo método de teste implementado
Na figura anterior, é destacado o novo método implementado, para validar o resultado de “Reprova-
ção”, pois a nota atribuída ao “aluno 2” foi inferior a 7,0, no entanto, o resultado esperado foi mantido
como “Aprovado”, fazendo com que o teste apresenta falha, como é ilustrado na figura seguinte.
Git ([20--?])
Figura 85 - Resultado de teste com falha

112
Observe que o teste executou os dois métodos da classe JUnit e apresentou falha no método “verifica-
ResultadoDeReprovacao”, conforme havia sido previsto na simulação.
Podem ser vistos também na visão “Failure Trace” detalhes da falha ocorrida no teste e demais informa-
ções, como comparação de resultado esperado e apresentado e acesso ao arquivo que apresentou a falha.
Ainda no contexto do desenvolvimento de testes unitários, é importante ressaltar que a API do JUnit
apresenta outros métodos, além do apresentado neste exemplo, para comparar resultados de diferentes
tipos de dados, resultados negativos, entre outros, que podem ser usados de acordo com a lógica de im-
plementação e a necessidade do teste.
CASOS E RELATOS
Qualidade do Software
A qualidade é uma característica essencial para qualquer produto ou serviço realizado, dessa for-
ma, os softwares não são uma exceção. Maria é uma jovem programadora que possui muita pre-
ocupação em entregar seu desenvolvimento de acordo com os requisitos estabelecidos. Como
ela sabe que quanto mais cedo descobrir um possível defeito no software mais barato e rápido de
corrigir, ela implementa para os seus códigos testes unitários que proporcionam maior garantia
do bom funcionamento do sistema, repassando aos usuários deste sistema a confiança e a boa
sensação de qualidade.
No “Recapitulando” a seguir reveja os principais conceitos estudados neste capítulo.

113
RECAPITULANDO
Neste capítulo, você conheceu os principais conceitos sobre teste de software, seu processo e
principais atividades, com foco nos testes unitários, reforçado com a observação da aplicação prá-
tica na IDE Eclipse por meio do JUnit.
Como tema principal, foram detalhadas as principais características do teste unitário, a sua impor-
tância e métodos de aplicação, assim como foram demonstrados trechos de código Java a serem
testados e implementações de testes unitários.
Foi também demonstrado o uso da IDE Eclipse para produzir os testes unitários, assim como exe-
cutar tais testes e emitir relatórios dos resultados dos testes executados, nas implementações de
demonstração.
Este capítulo representa a importância da responsabilidade de cada programador, sobre a quali-
dade do software que é desenvolvido, garantindo o bom funcionamento dos sistemas e viabilizan-
do testes futuros na manutenção dos sistemas.
A cada capítulo, um novo degrau é colocado na sua escalada do conhecimento. Continue dessa
forma para ampliar cada vez mais sua visão sobre o horizonte!
Técnicas de Implementação
Orientada a Objetos
Em todas as profissões, a excelência ou a qualidade da atividade exercida está diretamente

ligada às técnicas e boas práticas aplicadas e, na programação, não poderia ser diferente. Dessa
forma, neste capítulo, serão abordados tópicos que tratam de técnicas específicas de programa-
ção, com foco na linguagem Java, que irão aprimorar a sua arte ou desenvolvimento de sistemas.
As técnicas de programação proporcionam parâmetros para que, durante o processo de
desenvolvimento, erros conceituais de implementação sejam evitados, para que menos código
seja escrito desnecessariamente, para tornar mais claro e legível o código, e, com isso, facilitan-
do também o processo de manutenção do sistema.
Ao final deste capítulo, você estará apto a:
a) compreender e aplicar técnicas de programação orientada a objetos;
b) reconhecer a importância da formatação do código, para sua clareza e manutenção;
c) criar a documentação no próprio código, com auxílio da IDE Eclipse;
d) identificar a necessidade e os impactos da otimização do código;
e) aplicar técnicas de otimização de código Java;
f) usar ferramentas IDE para depurar o código implementado.
116
7.1 TÉCNICAS DE IMPLEMENTAÇÃO
Na programação Orientada a Objetos, como já mencionado nesse material, os seus principais funda-
mentos também representam técnicas de implementação, sendo elas, o Encapsulamento, a Herança, o
Polimorfismo. Conheça cada um deles na sequência.
7.1.1 ENCAPSULAMENTO
O encapsulamento prevê certo isolamento de parte do código ou ainda, prevê um controle de acesso,
permitindo que estas partes privadas do código sejam acessadas por classes específicas ou a partir de mé-
todos especiais de acesso.
O propósito desta técnica é evitar erros de programação ou a manipulação indevida dos dados proces-
sados pela classe que possui métodos ou atributos encapsulados, como, por exemplo, realizar uma ope-
ração matemática de divisão, inserindo o no atributo “divisor” o valor igual a zero, com isso provocando
um erro na execução deste código, ou ainda, em uma classe “Conta”, que represente uma conta bancária,
não é interessante que o saldo possa ser manipulado diretamente, para evitar que dados “inconsistentes”
possam ser inseridos nesse atributo.
Agora que ficou ainda mais clara a importância e eficiência desta técnica, você vai conhecer os meca-
nismos para isolar atributos e métodos especiais que possibilitam realizar o acesso às classes com partes
restritas, sem o risco de produzirmos erros no código ou gerar informações inconsistentes.
Os mecanismos mencionados, são identificados como modificadores de acesso, sendo classificados em
quatro níveis diferentes de acesso, sendo eles: private, default, protected e public.
O modificador private é o mais restritivo de todos, pois, com o seu uso, nenhuma outra classe do siste-
ma poderá acessar diretamente o atributo ou método afetado.
Na sequência de maior restrição, estão os modificadores default e protected, em que seus membros
afetados podem ser acessados por classes pertencentes ao mesmo pacote.
Por fim, há o modificador public, que torna o atributo ou método público, ou seja, disponível para qual-
quer classe que possa visualizar a classe acessada.
Para realizar o acesso indireto nos elementos de classe com modificador private, como mencionado,
são necessários métodos especiais, que são identificados como “Getters e Setters”, e foram chamados dessa
maneira por convenção, portanto na comunidade de programadores todos conhecem a aplicação e forma
de uso de tais métodos.
O método “Get” é aplicado para retornar informações de atributos privados, enquanto que o “Set” é
usado para inserir informações nestes atributos. O nome do método é então formado pela junção do atri-
buto que será acessado com o sufixo “get” ou “set”, dependendo se o objetivo for o retorno de algum dado
ou a inserção de determinada informação respectivamente.
Apesar da grande utilidade dos métodos especiais, o seu uso deve ser avaliado de acordo com cada
contexto em que partes do código estão protegidos, sendo necessário, em alguns casos, criar métodos
7 TÉCNICAS DE IMPLEMENTAÇÃO ORIENTADA A OBJETOS
117
específicos que atendam as especificações do sistema, provendo segurança e confiabilidade, pois, ao ana-
lisar as possibilidades de aplicação destes métodos, é possível perceber que o uso do método “Set” no
exemplo da classe “Conta” pode não ser uma boa ideia, pois o risco de dados inconsistentes ainda existiria.
Você vai praticar esta técnica e observar o código que segue, que define a classe “Aluno”, no qual possui
atributos, como a nota, que é interessante não ser manipulado diretamente por qualquer classe.
package Aluno;
public class Aluno {

private String nome;
private int documento;
private int idade;
private char sexo;
private double nota;
protected void setNome(String nome) {

this.nome = nome;
}
public String getNome() {
return nome;
}
public int getDocumento() {

return documento;
}
protected void setDocumento(int documento) {

this.documento = documento;
}
public int getIdade() {

return idade;
}
protected void setIdade(int idade) {

this.idade = idade;
}
public char getSexo() {

return sexo;
}
118
protected void setSexo(char sexo) {

this.sexo = sexo;
}
public double getNota() {

return nota;
}
protected double atribuitNota(double nota) {

this.nota = nota;
return nota;
}
No código anterior, todos os atributos possuem o modificador de acesso private, portanto sendo aces-
síveis somente por métodos especiais ou personalizados, como pode ser observado.
Veja também que os métodos que acessam os atributos possuem diferentes modificadores de acesso,
para permitir que determinadas ações estejam disponíveis somente para classes específicas, demonstran-
do mais uma aplicação da técnica de encapsulamento.
7.1.2 HERANÇA
A próxima técnica da orientação a objeto define o relacionamento entre classes a partir de elementos
em comum, de classes genéricas para classes mais específicas.
Como exemplo destas classes, pode-se pensar na definição de uma pessoa e um aluno, sendo que,
nesse caso, a classe pessoa e aluno teriam algumas características e comportamentos em comum, como
nome, idade, sexo, entre outras. Porém, somente a classe aluno, nesse contexto, poderá ter o atributo nota,
tornando-a mais específica do que a classe pessoa.
Uma outra forma de pensar seria resgatar as definições reais do que estas classes representam e con-
cluir logicamente que todo o aluno é uma pessoa, mas nem toda pessoa é um aluno, ou seja, o aluno é uma
pessoa específica.
Na herança, os atributos em comum, da classe mais genérica, são entregues para a classe mais específi-
ca. Dessa forma, essa classe não precisa declarar tais atributos ou comportamentos, pois estará recebendo
em forma de herança, com isso reduzindo a quantidade de código implementado.
Para aplicar essa técnica no código, é usada a palavra reservada “extends” na declaração da classe mais
específica, seguida do nome da classe mais genérica.
119
Acompanhe um trecho de código, que implementa a classe Pessoa e na sequência a classe Aluno que
irá estender a classe Pessoa, ou seja, vai aplicar o método de herança.
package Pessoa;
public class Pessoa {

private String nome;
private int idade;
private char sexo;
private int documento;

public void setNome(String nome) {
this.nome = nome;
}
public String getNome() {
return nome;
}
public int getDocumento() {

return documento;
}
public void setDocumento(int documento) {

this.documento = documento;
}
public int getIdade() {

return idade;
}
public void setIdade(int idade) {

this.idade = idade;
}
public char getSexo() {

return sexo;
}
protected void setSexo(char sexo) {

this.sexo = sexo;
}
}
120
No código anterior, a classe Pessoa provê atributos comuns a todas as pessoas e implementa os méto-
dos especiais para manipular tais atributos.
package Aluno;
import Pessoa.Pessoa;
public class Aluno extends Pessoa{

private double nota;

return nota;
}

this.nota = nota;
return nota;
}
No trecho do código que descreve a classe Aluno, foi aplicado a herança a partir da classe Pessoa, como
pode ser observado pela palavra reservada “extends”, por isso sendo necessário apenas implementar ca-
racterísticas específicas desta classe, reduzindo a quantidade de código que deveria ser implementado
para outras classes que apresentam características de Pessoa, como classes que descrevem Funcionario,
Professor, entre outras.
7.1.3 POLIMORFISMO
Nesta técnica da programação OO, o objetivo é reduzir a escrita de código, melhorar a leitura do código
e facilitar a manutenção dos sistemas. O nome desta técnica denota a prática na qual ela se baseia, pois
“Poli” representa vários ou muitos e “Morfismo” tem como significado diferentes formas, ou seja, partes do
código com a mesma identificação podem ter várias formas.
O polimorfismo também usa a herança em seu conceito, pois estas diferentes formas de partes do có-
digo acontecem em hierarquias de classes, ou seja, da classe mais genérica às classes mais específicas, que
pode ser dois, três ou mais níveis desta hierarquia.
121
Para entender um pouco melhor como essa técnica funciona e sua aplicação, recorrer-se-á a exemplos
já utilizados, nesse caso a definição de uma classe de conta bancária.
Observe que, ao implementar uma classe de conta bancária, algumas características fundamentais deve-
rão estar presentes, como o número da conta, a agência, o saldo e ações de realizar saque e consultar saldo.
Agora, se forem implementadas classes mais específicas, ou seja, que utilizem de herança, para criar
uma classe “ContaCorrente” e outra identificada como “ContaPoupanca”, os atributos e métodos da classe
genérica “Conta” serão reutilizados.
Nesse ponto, você chegou na possibilidade de usar o polimorfismo, pois é comum que sejam identifica-
dos diferentes comportamentos entre uma conta corrente e poupança, ao realizar um saque, pois a conta-
-corrente pode dispor de um limite além do saldo disponível, enquanto que a conta poupança irá permitir
o saque do valor compatível ao saldo.
Sendo assim, o método que realiza o saque poderá ser readequado na classe “ContaCorrente”, sem a
necessidade de criar um novo método, por causa de uma pequena alteração na forma do método saque.
Observa e analise a implementação dessas três classes que foram mencionadas nos exemplos da apli-
cação do polimorfismo.
No código que segue, é apresentada a definição da classe Conta, que declara seus principais atributos,
métodos especiais de acesso e os métodos de deposito e saque.
package Conta;
public class Conta {

protected int numero;
protected int agencia;
protected double saldo;

protected int getNumero() {
return numero;
}
protected void setNumero(int numero) {
this.numero = numero;
}
protected int getAgencia() {
return agencia;
}
protected void setAgencia(int agencia) {
this.agencia = agencia;
}
122
protected double getSaldo() {

return saldo;
}
protected void saque(double valor) {
if (saldo > valor) {
this.saldo -= valor;
System.out.println(“Saque realizado com sucesso”);
}
else
System.out.println(“Saldo insuficiente”);
}
protected void deposito(double valor) {
this.saldo += valor;
}
}
No código seguinte, há a implementação da classe que define a conta poupança, a qual herda grande
parte de sua estrutura da classe Conta, sendo acrescida uma característica específica, que é o rendimento
desse tipo de conta.
package Conta;
public class ContaPoupanca extends Conta{

double rendimento;

public void calculoRendimento(double saldo) {
rendimento = saldo * 0.05;
saldo += rendimento;
}
}
Por último, pode ser observado o código da classe que define a conta-corrente, que também herda
grande parte de suas características da classe Conta e apresenta, além da característica específica de uma
conta-corrente, que é o limite de saldo, a redefinição do método saque em sua lógica, porém mantendo a
mesma assinatura do método, ou seja, seu tipo de retorno, nome e parâmetro.
123
package Conta;
public class ContaCorrente extends Conta{

double limite;

if ((saldo + limite) > valor) {
System.out.println(“Saque realizado com sucesso”);
}
else
}
}
Essas são as principais técnicas da programação orientada a objeto, que devem ser constantemente
praticadas, para que a experiência desenvolvida por muito treino possa refletir na perfeita execução da
arte de programar por meio de técnicas bem aplicadas.
Nos próximos tópicos, serão apresentadas outras técnicas e boas práticas que irão proporcionar o de-
senvolvimento de capacidades para aprimorar seu desempenho e qualidade de produção de código.
7.2 FORMATAÇÃO DO CÓDIGO
A formatação do código é baseada em convenções definidas pelas linguagens de programação, nesse

contexto, mais especificamente, pela organização que mantém o Java.
A formatação tem como objetivo aumentar o desempenho dos programadores, direcionando o foco
para o negócio e entendimento do código, criar facilidade de interpretação por desenvolvedores que não
criaram o código original, tornar o código melhor escrito e mais fluido, e facilitar o desenvolvimento de
testes de unidade.
CURIOSI Você sabia que, em algumas linguagens de programação, como o Python, a inden-
tação do código é obrigatória para que a implementação seja executada de forma
DADES correta.
124
Na linguagem de programação Java, existem convenções para estrutura dos arquivos e sua formatação,
nas quais serão descritos e apresentados exemplos práticos, por isso siga em frente para mais esse impor-
tante conhecimento.
Os arquivos que contém o código Java poderão possuir dois tipos de extensão, sendo .java ou .class,
sendo que a diferença está na compilação do código, ou seja, o arquivo .java possui o código fonte origi-
nalmente escrito pelo programador, logo legível por humanos, enquanto que .class possui o código com-
pilado, também identificado como bytecode, sendo o arquivo legível pela máquina virtual do Java, a JVM.
O nome dos arquivos do Java também segue um padrão. Eles devem possuir o mesmo nome da classe
ou interface que são declaradas neste arquivo, inclusive sendo necessário ser igual as letras maiúsculas e
minúsculas.
Na construção do código, é prevista uma organização do arquivo, de forma geral, seguindo a sequência de
um comentário inicial, a declaração dos pacotes e bibliotecas importadas, e a declaração da classe ou interface,
sendo sugerido um limite máximo de vinte mil linhas, para não comprometer o desempenho do código.
No comentário inicial, existem caracteres especiais (/*...*/) que são usados para informar à JVM que o
texto marcado por esses caracteres não deve ser interpretado, permitindo inserir informações textuais
diversas. É sugerido que, neste comentário inicial, sejam inseridas informações sobre o programador autor
do código, a data de criação do arquivo, aviso sobre os direitos autorais do código e uma descrição resumi-
da do objetivo do código implementado.
A seguir, segue o trecho de um código Java, com um modelo de comentário inicial, prevendo as infor-
mações mencionadas anteriormente.
/*
* Autor:
* Data:
* Direitos autorais:
* Descrição do objetivo do código:
*
*/
Na sequência do código, deve ser feita a declaração de pacotes e bibliotecas a serem importadas para
uso na classe ou interface que será implementada no código.
Essa será a primeira linha do arquivo a ser interpretada pela JVM e usa a palavra reservada “package”,
seguida do caminho do pacote na estrutura do projeto, para declarar o pacote e permitir a visualização de
arquivos contidos no pacote declarado.
A próxima palavra reservada é “import”, seguida do caminho que se encontra a biblioteca a ser importa-
da para o código. Veja, na sequência, o trecho de código Java com as declarações de pacote e importação.
125
package Aluno;
import java.util.*;
Na estrutura geral do arquivo Java, a próxima parte macro deste arquivo é a declaração da classe ou
interface, que é composta por uma sequência predefinida de comentário de documentação, a declaração
propriamente dita, comentário de implementação, a declaração de variáveis de classe e instância, a decla-
ração de construtores e demais métodos.
Serão abordados os elementos desta sequência e ao final será apresentado um exemplo com mais um
trecho de código, demostrando como deve ser realizada a declaração de classe ou interface, de acordo
com as convenções do Java.
Há dois tipos de comentários que podem ser inseridos no código, sendo um comentário de documen-
tação, que a partir do código poderá ser gerado um arquivo de documentação do sistema, e o comentário
de implementação, que ficará visível somente ao acessar o código fonte.
O comentário de documentação, também identificado como Javadoc, será inserido no código com ca-
racteres especiais (/**..*/), iniciado com uma barra seguido de dois asteriscos e finalizado com um asterisco
e uma barra. Nesse tipo de comentário, será informado o propósito principal da classe ou interface.
Após essa parte, deverá ser feita a declaração da classe ou interface, com o uso das palavras reservadas
“class” para a declaração de classe e “interface” para a declaração de interface, seguido do nome da classe
ou interface respectivamente.
Assim que a declaração for feita, deverá ser inserido o comentário de implementação, com informações
não relevantes para a documentação, mas que farão sentido no contexto da lógica da implementação da
classe ou interface.
No escopo da classe ou interface declarados, deverão ser informado os atributos ou variáveis da classe
ou interface, seguindo por padrão uma ordem de tipo de variável e de modificadores de acesso.
Existem dois tipos de variáveis no Java, as variáveis de classe e as variáveis de instância, sendo que o
primeiro tipo de variável é comum à classe e todas as instâncias criadas a partir da classe e não é instancia-
da, pois constantemente está disponível na memória. Enquanto que a variável de instância ou de objeto, é
uma nova variável para cada objeto instanciado a partir da classe, podendo ter valores diferentes e sempre
com posições de memória diferentes.
Nessa classificação de variáveis, as variáveis de classe são identificadas com a palavra reservada “static”
e devem ser declaradas antes das variáveis de instância. Como mencionado, os modificadores de aces-
so também definem a ordem de declaração das variáveis, da seguinte maneira, primeiro o modificador
“public”, segundo o modificador “protected” e por último o modificador “private”, seguindo a ordem das
variáveis menos restritivas às mais restritivas.
Na sequência, ao declarar as variáveis de instância, a precedência dos modificadores de acesso também
deve ser aplicada, seguindo a mesma ordem restritiva, mencionada acima.
126
Seguindo a sequência da declaração da classe ou interface, deve ser informado o construtor da classe
ou interface, sendo que o construtor pode não ser informado, pois no momento da compilação do código,
o Java irá criar um construtor padrão.
Por último, nesta definição do escopo da classe ou interface, seguem as definições dos demais méto-
dos, que devem ser agrupados por funcionalidades que tais métodos irão prover para a classe ou interface.
Para reforçar essa sequência da construção de uma classe ou interface, são listados, a seguir, os passos
ou partes integrantes deste pedaço do código.
Sequência de definição de uma classe ou interface

a) Comentário de documentação da classe ou interface.
b) Declaração da classe ou interface.
c) Comentário de implementação da classe ou interface.
d) Variáveis de classe (ordem dos modificadores de acesso).
e) Variáveis de instância (ordem dos modificadores de acesso).
f) Declaração de construtores da classe ou interface.
g) Declaração de métodos agrupados por funcionalidades.
Com base na sequência definida pela convenção de declaração de classe ou interface, segue o trecho
de código que aplica esta padronização, para reforçar a importância desta boa prática e o quão melhor o
código se torna.
/**Comentário de Documentação da classe - Produção do Javadoc*/
public class Aluno extends Pessoa{

/*Comentário de implementação da classe - Informações específicas da classe*/

static String instituicao; //Declaração de uma variável de classe

private double nota; //Declaração de uma variável de instância

/*Declaração do construtor da classe*/
public void Aluno(String nome) {
setNome(nome);
}
127
/*Declaração de método para retornar a nota do aluno*/

return nota;
}

/*Declaração de método para informar a nota do aluno*/
this.nota = nota;
return nota;
}
Após as principais definições da estrutura geral do arquivo do código Java, pode os detalhar alguns
aspectos importantes que fazem parte da formatação do código, como a indentação, diferentes maneiras
de inserir comentários, boas práticas para realizar as declarações de atributos, métodos e classes, uso de
espaços em branco e detalhes das convenções para diversos elementos do código Java.
A indentação proporciona organização e clareza na leitura e interpretação visual do código, formatan-
do o código com os espaçamentos e tamanhos de linha de código adequados.
O padrão do tamanho de uma unidade de indentação é o equivalente a quatro espaços ou um Tab,
dessa forma evidenciando a hierarquia dos elementos do código, ou seja, quanto mais baixo o nível
hierárquico, maior será o número de unidades de indentação associado.
Outra questão importante, neste contexto, é o tamanho máximo de cada linha, que deve conter até
oitenta caracteres, para facilitar a visualização e manipulação do código em terminais ou ferramentas com
interface mais restritas.
Vale lembrar que a IDE Eclipse já possui uma funcionalidade de formatação automática do código, com
uma simples combinação de teclas de atalho: Ctrl + Shift + F, aplicando a formatação da melhor maneira
possível no código.
Quanto aos possíveis comentários que podem ser aplicados na implementação, como já mencionado,
existem os comentários de implementação e documentação, que são diferenciados pelos caracteres espe-
ciais usados no código.
Para os comentários de implementação, há duas variações, relacionadas a quantidade de linhas do co-
mentário, sendo um comentário para múltiplas linhas e outro tipo de comentário de implementação para
uma única linha.
Os comentários de múltiplas linhas usam os caracteres /* para iniciar o comentário, e os caracteres */
para encerrar tal comentário, sendo que estes caracteres de abertura e fechamento do comentário podem
estar em diferentes linhas do arquivo, como ilustrado no trecho de código abaixo que traz informações
sobre autoria e objetivo da implementação:
128
/*
* Autor:
* Data:
*
*/
Nos comentários de uma única linha são usados os caracteres //, e todo o texto inserido após a dupla de
barras não é interpretado como pela JVM (Java Virtual Machine), sendo um comentário destinado a uma
linha específica do código.
O último tipo de comentário com objetivo de documentação do sistema, ou o comentário de documen-
tação, também identificado como Javadoc, para a linguagem de programação Java, possui como referên-
cia de início os caracteres /**, sendo diferenciado do comentário de implementação de múltiplas linhas por
um asterisco a mais, porém com os mesmos caracteres para fechar o comentário, com o */.
No próximo tópico será detalhada a documentação gerada a partir do código e o uso do Javadoc para
este propósito, mas, enquanto isso, segue mais um exemplo de um trecho de código que usa o comentário
de documentação, para inserir informações sobre uma classe.
/** Comentário de Documentação da classe - Produção do Javadoc */
Durante a codificação, serão realizadas diversas declarações, seja de atributo, método ou classe, e para
inserir esses registros no código existem maneiras mais apropriadas, para facilitar a organização, visualiza-
ção, permitir associação de comentários, entre outras vantagens.
Serão colocadas agora algumas regras para a declaração de atributos, como o uso de uma linha para
cada atributo, ainda que possua o mesmo tipo de dado, uma linha deve ser reservada para cada atributo,
pois favorece o uso de comentários de implementação de única linha. Outro aspecto importante é a pa-
dronização no espaçamento entre o tipo de dado da variável ou atributo, e seu nome, com um espaço ou
ainda com uma unidade de identação (um Tab).
Observe o trecho de código que segue, no qual aplicam-se as regras mencionadas.
static String instituicao; // Declaração de uma variável de classe
private double nota; // Declaração de uma variável de instância
Também é importante declarar os atributos ou variáveis no início do bloco de uma classe ou método,
ou seja, não espere precisar usar uma variável ou atributo para declará-lo, para facilitar o uso destes atribu-
tos na IDE e pela organização do código.
129
As variáveis ou atributos possuem algumas classificações e comportamentos, de acordo com o local

que são declaradas, no código Java, ou seja, quando declaradas no escopo da classe são classificadas como
variáveis globais, e quando são declaradas em escopos menores, como um método ou uma expressão
condicional, seu domínio está restrito ao escopo no qual foram definidas, portanto é importante que tais
variáveis já sejam inicializadas, isso quer dizer que seja atribuído algum valor de acordo com o seu tipo de
dado, pois muito provavelmente serão usadas em sequência.
Na declaração de métodos e classes ou interfaces, também existem algumas regras, iniciando pelo es-
paçamento entre as palavras reservadas e o nome de identificação, seja da classe/interface ou do método,
com um espaço simples. Cada declaração de classe/interface possui o início do seu escopo após o carac-
tere {, que deve ser usado na mesma linha da declaração realizada, e para o fechamento do escopo da
classe/interface e método é usado o caractere oposto, o }, que deve ser usado na linha após a última
instrução da classe/interface ou método, no mesmo espaço de identação do início da declaração da
classe/interface ou método.
Na declaração de método, existe ainda mais um detalhe, a informação quanto aos parâmetros do mé-
todo, ou até mesmo a ausência de parâmetros, evidenciado pelos parênteses, junto ao nome do método,
que, quando estão vazios, significa que este método não possui parâmetros.
public class Aluno extends Pessoa {
/* Comentário de implementação da classe - Informações específicas da classe */
/* Declaração do construtor da classe */

setNome(nome);
}
/* Declaração de método para retornar a nota do aluno */

return nota;
}
/* Declaração de método para informar a nota do aluno */

this.nota = nota;
return nota;
}
}
130
No código anterior, é possível observar a aplicação das regras citadas, ressaltando as posições das cha-
ves da classe “Aluno”, na primeira linha da declaração da classe e na última linha do código, no mesmo
espaço de indentação, entre a margem esquerda e o início da declaração da classe, assim como é aplicado
para os métodos.
Ao observar o método “atribuiNota”, o parâmetro deste método é o atributo “nota”, com o tipo de dado
“double”, que está entre os parênteses, junto ao nome do método.
O uso de espaços em branco na implementação do código busca melhorar a fluidez e identificação dos
elementos usados na programação, mas algumas regras devem ser observadas, para alcançar as melhorias
ressaltadas.
Quando em um mesmo arquivo são declaradas duas ou mais classes/interfaces, é recomendado o uso
de duas linhas em branco entre o final e o início destas declarações, para tornar mais claro as seções criadas
por cada classe/interface.
Na definição interna de uma classe/interface em algumas situações deve ser usado uma linha em bran-
co, como segue:
a) entre a declaração de métodos diferentes;
b) ao anteceder um comentário, para melhorar a visualização;
c) entre partes de um mesmo método, que possuem diferentes lógicas.
Veja como simples regras podem aumentar a qualidade do seu código, que irá ser traduzido em facili-
dade de evolução e manutenção do sistema de forma geral.
Ainda existem mais algumas convenções, relacionadas aos nomes atribuídos às classes/interfaces, mé-
todos, atributos ou variáveis e constantes, por isso continue seu estudo atentamente para aprender cada
detalhe deste agradável universo de conhecimento.
Para a definição de nome de classe ou interface, a convenção prevê que o nome da classe ou interface
deve ter o mesmo nome do arquivo que contém o código Java, e este nome deve ser um substantivo, com
a primeira letra maiúscula, e caso o nome seja composto, os espaços entre os nomes devem ser eliminados
e os demais nomes também devem ser iniciados com a primeira letra maiúscula, como exemplo a classe
conta bancária, seria escrita como “ContaBancaria”.
Na definição de nome de método, que definem ações, seve ser usado verbo, iniciando com a primeira
letra minúscula, e caso seja um nome composto, os demais nomes serão iniciados com a primeira letra
maiúscula, como segue o exemplo do método atribuir nota, escrito “atribuirNota()”.
Ao definir os nomes das variáveis, também devem ser aplicadas outras regras quanto aos caracteres
com que o nome pode ser iniciado, não sendo permitido o uso do underline e $, com a primeira letra mi-
núscula, se houver o nome composto, a primeira letra dos demais nomes deve ter maiúscula, mas com o
objetivo de que estes nomes sejam concisos e objetivos.
As constantes, que são atributos com valores fixos, ou seja, quando não há variação do valor deste atri-
buto, nessa característica reside a diferença entre os atributos variáveis e atributos constantes. Existem di-
ferentes regras de apresentação destes nomes, usando somente letras maiúsculas e quando houver nome
composto, os demais nomes serão separados por underline.
131
Neste tópico, você foi apresentado aos padrões fundamentais para criar um arquivo de código e as prin-
cipais partes da estrutura deste arquivo, para que o código produzido tenha boa qualidade estrutural. No
entanto, outras questões devem ser observadas na programação, nas quais serão abordadas nos tópicos
seguintes, por isso continue seus estudos para produzir belos fontes de sistemas.
7.3 DOCUMENTAÇÃO DE CÓDIGO
A documentação gerada para os sistemas ou bibliotecas, criadas a partir da codificação Java, possuem
grande importância para descrever as funcionalidades das classes e métodos implementados.
No Java, há uma ferramenta que auxilia na produção de tal material, pois em tempo de codificação as
informações relevantes para gerar a documentação são inseridas diretamente no código e com o uso da
IDE toda a estrutura de documentação em formato HTML é gerado, proporcionando uma documentação
organizada e muito bem apresentada.
Como já mencionado, na explicação da estrutura do arquivo de código Java, os comentários de docu-
mentação ou ainda identificados como comentários especiais, que antecedem o escopo de uma classe ou
método, trazem informações relevantes sobre a utilidade e aplicação destes elementos implementados.
Além dos caracteres especiais usados para identificar estes tipos de comentários, também são aplicadas
o uso de tags HTML, para a formatação do comentário na sua apresentação, e outras marcações especiais
para especificar o tipo de informação que será inserida no comentário de documentação.
Essas tags de marcação especial, tem como característica o uso do prefixo @, seguido do nome que
tipifica a informação do comentário, sendo que estas são usadas entre os caracteres de abertura (/**) e
fechamento (*/) dos comentários que irão gerar a documentação.
A seguir, veja um quadro que relaciona todas as possíveis tags do Javadoc e seus respectivos significa-
dos, permitindo estruturar ainda melhor o resultado final deste documento.
TAG SIGNIFICADO
@author Irá especificar o autor de uma classe ou método.

@deprecated Ressalta que determinada classe ou método está obsolete e existe um substituto mais atual.
@link Permite a inserção de um link local ou remoto para outro documento.
@param Mostra um parâmetro que deverá ser passado ao método comentado.
@return Mostra o tipo de retorno do método comentado.
@see Insere outras referências para melhor entendimento da classe ou método comentado.
@since Mostra a partir de qual momento a classe ou método foram inseridos no código.
@throws Mostra os tipos de exceções que podem ser lançadas por um método.
@version Mostra a versão da classe comentada.
Quadro 2 - Relação de Tags do Javadoc
132
Acompanhe a aplicação destes comentários especiais com o uso de algumas tags e na sequência o
procedimento para gerar o Javadoc a partir da IDE Eclipse, para que possa ser visto o resultado gerado.
/*
* Autor do código:
* Data de criação:
*
*/
package Aluno;
import java.util.*;
import Pessoa.Pessoa;
/**
* Classe que irá definir o conceito de um aluno genérico, estendida da classe Pessoa
* @author <Nome do Autor>
* @since <Data de implementação da Classe>
* @version <Versão da Classe>
*/
public class Aluno extends Pessoa {
/* Comentário de implementação da classe - Informações da classe */
/** Declaração do construtor da classe

* @param String nome
* @return void
*/
setNome(nome);
}
133
/** Declaração de método para retornar a nota do aluno

* @return double nota
*/
return nota;
}
/** Declaração de método para informar a nota do aluno

* @param double nota
* @return double nota
*/
this.nota = nota;
return nota;
}
No código que define a classe “Aluno”, foram inseridos diferentes tipos de comentários, de implemen-
tação e de documentação, onde neste último foram usadas as tags especiais, para tipificar a informação
no documento que será gerado.
Nesse momento, você irá acompanhar o procedimento da IDE para gerar o documento da classe “Alu-
no” e replicar este processo para o seu projeto Java, gerando toda a documentação descrita nos arquivos
de código do sistema.
Na IDE Eclipse, o procedimento é muito simples e proporciona grande valor; sendo necessário acessar o
menu “Project” e selecionar a opção “Generate Javadoc”, como ilustrado na figura que segue.
Git ([20--?])
Figura 86 - Menu da IDE Eclipse para gerar o Javadoc

134
Após a ação ilustrada na figura anterior, será exibido a tela de diálogo, que pode ser observada na figura
a seguir, na qual será necessário selecionar o projeto Java que terá sua documentação gerada. Nesse caso,
foi selecionado o projeto Java “Senai”, que contém a classe “Aluno”, onde foram inseridos os documentá-
rios de documentação, conforme demonstrado anteriormente.
Git ([20--?])
Figura 87 - Janela da IDE Eclipse para selecionar Projeto Java
Após a escolha do projeto Java, é preciso selecionar o comando Javadoc, a partir do SDK Java, pre-
viamente instalado no seu ambiente de desenvolvimento, o diretório de destino, no qual os arquivos da
documentação serão armazenados e clicar no botão “Finish” e toda a documentação do projeto é criado
pela IDE, onde pode ser acompanhado a progressão da criação deste documento na visão de console do
Eclipse, como o trecho da saído do console, que segue.
Loading source files for package Pessoa...

Loading source files for package Curso...
Loading source files for package Aluno...
Constructing Javadoc information...
Standard Doclet version 1.8.0_131
Building tree for all the packages and classes...
135
Assim que for concluído o processamento da IDE para gerar o Javadoc, você poderá acessar o diretório
de destino, definido ao gerar o documento do projeto, e poderá observar uma estrutura de arquivos simi-
lar ao diretório apresentado na próxima figura.
Javadoc ([20--?])
Figura 88 - Diretório de destino do Javadoc
Ao executar o arquivo “index.html”, disponível no diretório de destino do Javadoc, será exibida uma
janela web local, com a documentação de seu projeto. Nas figuras que seguem, são ilustradas a página
principal da documentação e as partes do documento gerado para a classe “Aluno”.
Javadoc ([20--?])
Figura 89 - Página principal do Javadoc

136
Javadoc ([20--?])
Figura 90 - Documento Javadoc da classe Aluno
Javadoc ([20--?])

137
Javadoc ([20--?])
Neste tópico, foram apresentados importantes conceitos que irão auxiliar na evolução e manutenção
de software e, de forma dinâmica, gerar documentação técnica bem apresentada, formatada e com grande
ganho de rendimento.
Você deve seguir na busca da otimização para produzir códigos eficientes, bem escritos, com alto de-
sempenho e robustos, por isso continue seus estudos!
FIQUE A manutenção adequada de cabos e fios nas rodovias é necessária para prevenir in-
ALERTA cêndios florestais.
A seguir você irá entender a otimização de código. Acompanhe!

138
7.4 OTIMIZAÇÃO DE CÓDIGO
A otimização de um algoritmo está diretamente relacionada com a maturidade do desenvolvedor na

linguagem na qual é construído, assim como a escolha da estratégia adotada para a resolução do proble-
ma que a implementação se propõe.
A refatoração do código também está relacionada à otimização do mesmo, pois, neste processo, há um
aprendizado relacionado à lógica da implementação e, portanto, há uma melhor visão sobre outras possi-
bilidades de programação para um determinado propósito e, com isso, o uso de outras técnicas que geram
mais performance, menos consumo de recursos, entre outras consequências que tornam o processamento
do código mais otimizado.
Outra questão importante e relevante sobre a otimização do código é o custo associado a esta melho-
ria, por tratar-se de algo muito abrangente e que pode gerar alta complexidade no processo de otimização,
este custo deve ser menor que o custo de manter o código original, ou seja, se o desempenho atual pro-
vocar menos transtornos do que os riscos e complexidade de uma otimização, talvez seja melhor mantê-lo
no estado original.
Além do custo mencionado, a identificação de códigos que realmente possuem impacto no proces-
samento do sistema é muito importante. Isso quer dizer que, mesmo que determinado código possa ser
melhorado, quando executado com baixa frequência, pode não ser relevante a sua otimização, enquanto
que códigos que apresentem pouca diferença de desempenho após sua otimização, mas se executado
com alta frequência pelo sistema, podem representar alto impacto no desempenho geral do sistema.
Para auxiliar na identificação de códigos que precisam ser refatorados existem ferramentas de profiling,
que tornam evidentes problemas de consumo excessivo de processamento e espaço de memória, de-
monstrando de forma mais clara o que realmente precisa ser otimizado no sistema.
Na IDE Eclipse, há uma opção de ferramenta profiling, identificada como Eclipse TPTP ou Eclipse Test &
Performance Tools Plataform, que oferecem mecanismos para verificar a performance do sistema, baseado
no uso de memória, processamento e consumo de demais recursos computacionais.
Para usar essa ferramenta na IDE, será necessário instalá-la, como um novo plugin do Eclipse. Para isso,
será demonstrado este procedimento, como segue:
139
Javadoc ([20--?])
Figura 93 - Menu do Eclipse para instalação de plugins
Ao iniciar a instalação de um novo software no Eclipse, deverá ser apresentada uma nova janela, como
a figura que segue.
Git ([20--?])
Figura 94 - Configuração do local de download

140
Ao clicar no botão “Add” da janela de instalação do Eclipse, será exibida uma nova janela para inserir o
site no qual será realizado o download dos arquivos de instalação e dependências do plugin TPTP.
Git ([20--?])
Figura 95 - Inserção do local de download
Ao concluir a adição do local de download, deverão ser exibidas as opções de software, na tela de ins-
talação, como você pode ver na figura que segue.
Git ([20--?])
Figura 96 - Seleção do aplicativo para ser instalado

141
Ao selecionar a opção “Test and Performance”, será iniciado o processo de instalação, como é demons-
trado na próxima figura.
Git ([20--?])
Figura 97 - Progresso de instalação do novo aplicativo
142
Git ([20--?])
Figura 98 - Processo de instalação do novo aplicativo
143
Git ([20--?])
Figura 99 - Informação dos detalhes de instalação do novo aplicativo
Após algumas etapas de verificação dos pacotes que serão instalados na IDE, será necessário aceitar os
termos de licença do software, como pode ser visto na figura a seguir.
144
Git ([20--?])
Figura 100 - Termos de licença do novo aplicativo
Git ([20--?])
Figura 101 - Reinício do Elipse para ativar aplicativo instalado
Assim que concluir a instalação, será necessário reiniciar a IDE Eclipse, para que o novo plugin esteja
disponível e funcional para os testes a serem realizados no código.
Como exemplo, foi criada a classe TestePerformance, com um código propositalmente ruim, que irá
consumir muita memória e processamento, mas que servirá para avaliar o Eclipse TPTP.
145
public class TestePerformance {
public static void main(String[] args) {

for (int i = 0; i < 1000000; i++) {
String x = “a” + i;
System.out.println(x);
}
}
}
Com isso, conclui-se a demonstração da apresentação de uma ferramenta de profiling, para medir a
performance de seu código, e, na sequência, conhecer algumas técnicas de otimização.
Após a contextualização inicial da otimização de código, que deve envolver reflexões sobre o momento
ao qual partir para a melhoria do código, e o conhecimento de ferramentas de auxílio para este propósito,
você poderá relacionar boas práticas e até a escolha de determinadas técnicas para que, na versão inicial
de seu código, já sejam apresentadas características de desempenho otimizadas.
7.4.1 TÉCNICAS DE OTIMIZAÇÃO DE CÓDIGOS
As técnicas de otimização, no contexto da programação, consistem em boas práticas que irão resultar
em códigos melhorados, seja com o propósito de melhorar sua clareza e consequente a manutenção do
sistema, assim como torná-lo mais performático e eficaz, realizando as mesmas ações com menor consu-
mo de recurso e em menor tempo.
Acompanhe, a seguir, diferentes técnicas, em exemplos de trechos de código habituais, que podem
fazer a diferença na boa execução do sistema, ou seja, no bom processamento do código.
USO DE STRINGBUFFER OU STRINGBUILDER
Quando existe a necessidade de concatenar Strings no código, uma boa prática é usar StringBuffer
ou StringBuilder em substituição à String, pois como cada String é imutável, quando há uma concatena-
ção um novo objeto deve ser criado, enquanto que, ao usar as API’s mencionadas, não é necessário criar
novos objetos, reduzindo o consumo de processamento, memória e demais recursos computacionais do
ambiente que executa o sistema.
146
USO DE MÉTODOS ESTÁTICOS
Uma técnica que deve ser usada ao definir o comportamento de uma classe e seus métodos é o uso de
métodos estáticos, desde que este método seja independente da classe no qual ele esteja inserido.
Com essa técnica existem alguns ganhos, como a economia de memória, pois ao instanciar tal classe,
estes métodos estáticos não ocupam memória, a não ser no momento que forem executados, porém, na
sequência à sua execução, já liberam o espaço de memória ocupado.
Outro ganho dessa técnica, é o fato de não precisar instanciar a classe para invocar o método estático,
economizando também espaço de memória ao não precisar armazenar dados sobre os atributos da classe
que não serão utilizados.
No entanto, o uso deste tipo de método deve ser avaliado, pois os métodos de instância também pos-
suem vantagens, como o compartilhamento de atributos, sem precisar replicar informações redundantes.
USO DE ATRIBUTOS ESTÁTICOS
Uma segunda técnica, é o uso limitado de atributos estáticos, pois diferente dos métodos estáticos,
os atributos estarão constantemente ocupando memória, durante a execução do código. Dessa forma, a
menos que seja necessário manter um atributo com determinado valor atribuído durante toda a execução
do código, este tipo de atributo deve ser evitado.
DECLARAÇÃO DE VARIÁVEL INTERNA AO LOOP
Pode parecer óbvio, mas nem sempre é percebida a consequência de declarar uma variável dentro de
um loop, ou seja, a cada iteração do loop é declarado uma nova variável. Agora imagine que um determi-
nado loop tenha mil iterações, nesse caso serão mil variáveis em memória, causando grande desperdício
de memória e perca de desempenho.
Observe a diferença das implementações não otimizada e otimizada, desta boa prática, na escrita do
código.
for (int i = 0; i <= 1000; i++) {

Aluno aluno = new Aluno();
aluno.save(item[i]);
}
147
No trecho de código apresentado, fica evidente que a variável aluno será declarada mil vezes, demons-
trando o problema mencionado.
Aluno aluno = null;

for (int i = 0; i <= 1000; i++) {
aluno = new Aluno();
}
Neste trecho de código modificado, você pode observar a sua otimização, com a declaração da variável
aluno fora do escopo do “for”, com isso declarando apenas uma vez esta variável e, consequentemente,
reduzindo a quantidade de memória usada e melhorando a performance de execução.
USO DE MÉTODO INTERNO AO FOR
Nesta técnica, mais uma vez, a análise crítica em como criar seu código está presente, e basicamente ela
evita que a cada iteração de um loop com uso do “for”, o mesmo método seja executado. Novamente, po-
demos citar que se em um determinado loop houver mil iterações, o mesmo método de forma repetitiva
será executado mil vezes.
Para evitar este comportamento, a solução é declarar uma variável externa ao loop, com a execução do
método uma única vez, como você pode observar nos trechos de código que apresentam a implementa-
ção com baixo desempenho e sua versão otimizada.
for (int i = 0; i <= curso.getTotalMatricula(); i++) {

Aluno aluno = new Aluno();
}
O código anterior apresenta o método “getTotalMatricula()” interno ao loop e será executado a quanti-
dade de vezes do valor inteiro que retornar do método, e a cada loop será consumido o processamento de
acordo com a complexidade do método.
148
int total = curso.getTotalMatricula();

Aluno aluno = null;
for (int i = 0; i <= total; i++) {
aluno = new Aluno();
}
Na versão otimizada anterior, há uma variável a mais, porém o método é executado uma única vez, des-
sa forma reduzindo o consumo de processamento e melhorando a performance de execução do código.
USO PREFERENCIAL DE BIBLIOTECAS
Esta técnica ou boa prática consiste no conhecimento das bibliotecas disponibilizadas pela linguagem
de programação, para evitar que métodos sejam reescritos, tendo em vista que os métodos já disponibili-
zados são normalmente produzidos com alta qualidade e com grande carga de testes já realizadas, dessa
forma proporcionando garantias de bom desempenho e que otimizações já existem.
Estas técnicas apresentadas representam as principais e fundamentais ações para criar um código ou
refatorá-lo de forma correta. No entanto, existem técnicas mais específicas que podem variar de acordo
com a linguagem de programação utilizada.
Acompanhe a evolução da linguagem adotada, tenha o hábito frequente de estudo desta arte chamada
desenvolvimento de software e aprimore suas técnicas, seu código, sua forma de desenvolver com alto
desempenho e qualidade.
7.5 DEPURAÇÃO
Neste tópico, será abordada a depuração do código, ou o “debugging”, que consiste no processo de
buscar bugs no código, em tempo de execução do mesmo.
Neste processo, existem variações, causadas por características da linguagem de programação, assim
como as possíveis ferramentas disponíveis para realizar a depuração do código.
A linguagem de programação Java facilita o processo de depuração, pois possui mecanismos para iden-
tificar erros no código, como o lançamento de exceptions, além das ferramentas de debugging que tam-
bém auxiliam nesta atividade.
A IDE Eclipse é uma excelente ferramenta de depuração de código, pois, no mesmo ambiente onde
acontece o desenvolvimento do sistema, já é possível depurar possíveis erros, tornando este processo mais
simples e produtivo.
149
A dinâmica de depuração irá consistir em identificar as linhas do código que deverão ser marcadas para
o processo de debugging, para que na execução desse código no modo de depuração, o algoritmo esteja
referenciado ou preparado para mostrar informações, como resultados de atributos, métodos, entre outros.
Veja um exemplo, criando uma marcação, nesse contexto identificada como “breakpoint”, em um tre-
cho de código, para posteriormente observarmos as visões do Eclipse para o debugging.
O procedimento é muito simples, basta selecionar a linha desejada para a marcação do breakpoint e na
opção do menu “Run” do Eclipse, selecionar a funcionalidade “Toggle Breakpoint”, como ilustrado na figura
a seguir.
Git ([20--?])
Figura 102 - Menu para inserir breakpoint do debugging

150
Para realizar esta preparação de depuração do código com o Eclipse, também é possível simplesmente
usar as teclas de atalho Ctrl + Shift + B, proporcionando mais agilidade e produtividade nesta atividade.
O efeito da inserção do breakpoint pode ser visualizado no trecho de código que segue, com a linha
selecionada.
package Conta;
public class Conta {

protected int numero;
protected int agencia;
protected double saldo;

protected int getNumero() {
return numero;
}
protected void setNumero(int numero) {
this.numero = numero;
}
protected int getAgencia() {
return agencia;
}
protected void setAgencia(int agencia) {
this.agencia = agencia;
}
protected double getSaldo() {
return saldo;
}
if (saldo > valor) {
System.out.println(“Saque realizado com
sucesso”);
}
else
}
protected void deposito(double valor) {
this.saldo += valor;
}
}
151
Observe, de forma mais detalhada, que na classe Conta, exibida anteriormente, há o método saque,
que possui em sua lógica de execução a expressão condicional (if (saldo > valor)), no qual foi marcado para
depuração.
Para realizar a demonstração do debugging, foi criado a classe TestaConta, que possui o método main,
no qual irá instanciar a classe Conta e executar o método saque, como você pode acompanhar a seguir.
package Conta;
public class TestaConta {
public static void main(String[] args) {

Conta conta = new Conta();
conta.saque(300);
Na classe TestaConta, existe um objeto conta e a invocação do método saque, automaticamente o

Eclipse marca a linha do método, para demonstrar que ali existe uma marcação para debugging.
Após essa estrutura inicial pronta, com a definição do que é importante observar na depuração do có-
digo e realizado a sua respectiva marcação, iremos executar este código no modo debugging, sobre esta
mesma perspectiva do Eclipse, no qual irá disponibilizar várias visões sobre o processo de depuração.
Para iniciar a execução do debugging, será preciso selecionar a opção “Debug As” do menu do Eclipse
“Run”, seguido da opção “Java Application”, como está ilustrado nas duas próximas figuras.
152
Git ([20--?])
Figura 103 - Menu para iniciar o modo Debug

Git ([20--?])
Figura 104 - Opção do modo Debug
Ao executar a seleção das opções anterior, o Eclipse irá exibir uma janela de confirmação de troca de
perspectiva, alternando da perspectiva do Java para a de Debug, após aceitar a abertura desta perspectiva,
como mostrado na figura a seguir.
153
Git ([20--?])
Figura 105 - Janela de confirmação para exibir a perspectiva de Debug
Ao alternar a perspectiva, é apresentado no Eclipse algumas visões que trarão informações sobre o pro-
cesso de debugging, e que juntas formam o arranjo destas visões demonstradas na próxima figura.
Git ([20--?])
Figura 106 - Perspectiva do modo Debug do Eclipse
Para cada visão desta perspectiva de depuração, serão demonstradas as informações que são retorna-
das e sua utilidade, iniciando pela visão de Debug, referenciada na figura que segue. Aqui são demonstra-
das as Threads do processo de execução do código, que contém os métodos executados, como pode ser
observado na figura, o método saque da classe Conta e o método main da classe TestaConta.
154
Git ([20--?])
Figura 107 - Visão de Debug do Eclipse
Na visão Variables, é possível visualizar as variáveis do método que está sendo depurado e do objeto ao
qual este método pertence, como pode ser visto na figura que segue, com a variável valor pertencente ao
método em debugging e as variáveis “agencia”, “numero” e “saldo”, pertencentes ao objeto conta.
Figura 108 - Visão de Variáveis do Eclipse Git ([20--?])
Há também a visão Breakpoints, exibida na próxima figura, que informa quais são os pontos de debu-
gging do código, assim como é possível desabilitar pontos de marcações específicos, de acordo com a
necessidade do processo de depuração.
Git ([20--?])
Figura 109 - Visão de Breakpoints do Eclipse

155
Na visão seguinte, é visualizado o código fonte que está sendo depurado, da mesma forma que é apre-
sentado na perspectiva do Java, sendo ilustrado na figura a seguir.
Git ([20--?])
Figura 110 - Visão do Código Fonte do Eclipse
A visão seguinte também é comum à perspectiva Java e apresenta as saídas de console do código, que
mesmo em modo debugging irá apresentar o mesmo resultado no output do código, sendo demonstrada
na figura que segue.
Git ([20--?])
Figura 111 - Visão do Console do Eclipse
Para executar a depuração do código no Eclipse, existem algumas funcionalidades que permitem a exe-
cução sequencial, passo a passo, de retorno ao método que invoca o código depurado e execução entre
breakpoints.
Para essas ações, a IDE Eclipse disponibiliza teclas de atalho ou botões com as mesmas funções na inter-
face da ferramenta, como é exibido a seguir na lista de teclas de atalho e na próxima figura.
a) Tecla F5: Executa o próximo passo do código.
b) Tecla F6: Executa o próximo passo do código, mas não acessa código associado por método.
c) Tecla F7: Retornar ao método que invoca o método depurado.
d) Tecla F8: Executa o próximo breakpoint do código em debugging.
Git ([20-
|
-?])
Figura 112 - Botões do Eclipse para executar o debugging

156
A partir desses conceitos iniciais sobre o processo de depuração do código com o auxílio da IDE Eclipse,
será possível avançar nas possibilidades de debugging e usar recursos um pouco mais avançados, nos
quais serão apresentados como:
a) breakpoint condicional;
b) breakpoint com expressão condicional.
No primeiro tipo de breakpoint, é possível aplicar uma condição sobre a quantidade de ocorrências do
método a ser depurado, para que o debugging seja realmente executado, como pode ser observado na
figura a seguir.
Git ([20--?])
Figura 113 - Configuração de condição do Breakpoint
Na segunda possibilidade de condicionar o processo de depuração a partir do breakpoint, é possível

aplicar uma expressão condicional, da mesma forma que poderia ser implementado no código Java, pro-
porcionando mais flexibilidade nas condições de execução e permitindo o print de informações na visão
de Display da perspectiva de Debug do Eclipse. Segue a figura com o exemplo de configuração da condi-
ção do breakpoint.
157
Git ([20--?])
Figura 114 - Configuração de expressão condicional do Breakpoint
Neste tópico, você aprendeu novas técnicas para aperfeiçoar seu código e melhorar as maneiras de
analisar o seu comportamento e possíveis erros presentes na implementação.
Ainda existe mais uma importante técnica associada ao desenvolvimento de sistemas, que auxilia na
análise de impacto de sistemas, ao criar ou realizar manutenção em seus algoritmos, portanto continue
evoluindo e aprimorando seus conhecimentos!
SAIBA Você já ouviu falar no termo Clean Code ou Código Limpo? Acesse a palestra no site
<https://www.devmedia.com.br/clean-code-desenvolvendo-como-um-profissio-
MAIS nal/26130> e confira mais detalhes a respeito!
Dando sequência aos seus estudos, você irá entender o que é a rastreabilidade e quando ela acontece.
158
7.6 RASTREABILIDADE
Os sistemas são construídos a partir de necessidades ou para atender demandas de negócios diversos,
que, assim como na vida real, possuem dentro do domínio das necessidades ou de negócio, relações de
ações ou informações que serão processadas por este sistema.
Dessa forma, é necessário identificar como tais relações serão implementadas no sistema, onde certa-
mente estas especificações também terão relação na sua codificação, tornando-se necessário identificar a
rastreabilidade entre estas relações, para evitar que determinada implementação ou alteração de algorit-
mos do sistema não seja impactado no correto funcionamento da aplicação.
A rastreabilidade pode ocorrer em diferentes artefatos ou tipos de documentos criados para o projeto
de um software, como a especificação de requisitos, a arquitetura do software, o código do sistema, entre
outros, sendo que, dependendo do profissional, no contexto do desenvolvimento de sistemas, que irá
analisar essa rastreabilidade, precisará selecionar a visão da relação adequada. Por exemplo, para progra-
madores, é interessante obter uma visão de rastreabilidade entre os requisitos do sistema e as classes que
implementam tais requisitos, para identificar no código que partes do sistema serão afetados ao desenvol-
ver o sistema ou realizar manutenções.
A matriz de rastreabilidade consiste em um método que proporciona uma visão cruzada entre classes,
nesse contexto identificado como fonte, e requisitos, que são nomeados como alvos e fontes ou classes.
Em outras palavras, pode-se interpretar como, determinados fontes implementam determinados alvos, ou
ainda, que certos alvos dependem de certas fontes.
Na matriz cruzada, conforme pode ser observado na figura a seguir, a célula que possui valor 1 assinala
a relação entre este fonte e alvo, enquanto o valor 0 (zero) denota que não existe qualquer dependência
entre este fonte e alvo. Davi Leon (2017)
Figura 115 - Matriz de rastreabilidade cruzada
Na ilustração da matriz de rastreabilidade, chega-se à conclusão que a fonte f1, ou a classe f1, irá imple-
mentar os alvos ou os requisitos a1, a3 e a4, onde as classes f1 e f3 possuem relação na implementação do
requisito a3, ou seja, caso o código que implemente as classes f1 e f3 seja alterado pode haver impacto no
comportamento dos requisitos a1 e a3.
159
Outra forma de representar a matriz de rastreabilidade é de forma gráfica, como pode ser visto na figu-
ra a seguir, que demonstra de forma clara a intersecção das linhas das fontes f1 e f3 que apontam para o
requisito a3, também proporcionando uma outra forma de visão da mesma informação contida na tabela
da matriz de rastreabilidade.
f1 f2 f3
Fontes
Alvos
Davi Leon (2017)

a1 a2 a3 a4
Figura 116 - Gráfico de rastreabilidade cruzada
Neste tópico, foi apresentado o conceito geral sobre a rastreabilidade de software, com foco na visão do
programador usando o método de matriz de rastreabilidade.
É importante ressaltar que existem diversas ferramentas no mercado que dão suporte ao processo de
desenvolvimento de sistemas, que, a partir da elicitação de requisitos e aplicação de diagramas previstos
na UML, pode gerar a visão da matriz de rastreabilidade de forma automatizada.
CASOS E RELATOS
Técnicas de Programação
Na intenção de buscar a qualidade de software, a programadora Maria, que já cria testes unitários,
também reconhece a importância de aplicar técnicas de programação, de acordo com o paradig-
ma da linguagem de programação. Em seu desenvolvimento atual, Maria cria e mantém sistemas
desenvolvidos em Java, uma linguagem orientada a objetos, e, portanto, usa técnicas de encap-
sulamento, herança e polimorfismo que tornam o código mais eficiente e otimizado. Além das
técnicas de programação, Maria também lança mão de técnicas de otimização, com boas práticas
inerentes à linguagem, além de depurar todos os códigos desenvolvidos.
Faça como Maria, e perceba a importância do uso de estruturas conceituais e concretas das técni-
cas de programação.
160
Conclui-se mais um capítulo, mas, antes de finaliza-lo, leia o “Recapitulando” e relembre todos os con-
ceitos estudos.
RECAPITULANDO
Neste capítulo, foram apresentadas as principais técnicas de programação orientada a objetos,

assim como técnicas gerais para obter bons resultados no processo de codificação para desenvol-
vimento de software.
Foram apresentadas técnicas e boas práticas para a formatação do código, associado ao uso da
IDE Eclipse para que o resultado da implementação seja um código legível e de fácil compreensão.
Ainda neste capítulo, foram abordadas técnicas de documentação do código, ressaltando as di-
ferentes formas de comentários e a maneira de usá-los, assim como o uso do Eclipse para gerar o
documento, por meio do Javadoc.
Também foram estudadas as técnicas de reutilização e otimização do código, que impactam dire-
tamente na produtividade do programador e no desempenho do sistema desenvolvido, represen-
tando importantes técnicas na construção de sistemas.
Ao final deste capítulo, foram conhecidas as técnicas de depuração de código, ou debugging, e de
rastreabilidade de implementação de classes e os requisitos de software.
Este capítulo representou um grande avanço na forma de construir o sistema com mais eficiência,
qualidade e profissionalismo, portanto continue seus estudos para refinar suas habilidades!
Estrutura Organizacional
e Equipes Ágeis
As novas estruturas organizacionais, inseridas no contexto de desenvolvimento de software,

buscam cada vez mais a agilidade na relação entre os membros da organização e seus clientes,
com o objetivo de construir e manter sistemas de qualidade e de acordo com as expectativas
dos usuários, otimizando o trabalho das equipes e seu gerenciamento.
Existem diferentes métodos de trabalho que abordam a agilidade, por isso, neste capítulo
será selecionado um dos métodos de maior predominância no mercado, o Scrum, no qual serão
apresentadas as características e dinâmica de funcionamento, que estarão de acordo com os
valores do manifesto ágil.
a) reconhecer os valores do desenvolvimento ágil;
b) identificar os princípios do software ágil;
c) conhecer a estrutura organizacional de equipes ágeis;
d) iniciar a aplicação do método de trabalho SCRUM;
e) usar técnicas de gerenciamento de atividades.
164
8.1 MANIFESTO PARA DESENVOLVIMENTO ÁGIL
Antes de iniciar o estudo sobre qualquer método de trabalho ágil, é preciso conhecer o manifesto para
desenvolvimento ágil, que prevê alguns valores e determinados princípios. Acompanhe!
8.1.1 VALORES DO MANIFESTO ÁGIL
Os valores do manifesto do manifesto ágil são:

a) indivíduos e interações mais que processos e ferramentas;
b) software em funcionamento mais que documentação abrangente;
c) colaboração com o cliente mais que negociação de contratos;
d) responder a mudanças mais que seguir um plano.
Estes valores querem traduzir para uma dinâmica mais produtiva e com foco na entrega do resultado
final, ou seja, o software. O primeiro valor do manifesto ressalta a importância da proximidade entre os
membros das equipes e a troca de informações entre eles, ao invés de seguir processos predefinidos e com
fonte de dados somente nos dados das ferramentas. No segundo valor, é enfatizado que a codificação do
sistema é mais importante que documentações excessivas, reforçando que a documentação é necessária,
mas de forma contida. O terceiro valor aborda a aproximação da organização ao cliente, para estar de for-
ma constante em sintonia com as necessidades do cliente e com isso garantir a entrega de um software
que atenda às suas necessidades. E o último valor irá tratar das possíveis mudanças que poderão ocorrer
em um projeto, ou seja, determinadas necessidades de um cliente podem mudar ou deixar de existir ao
longo do desenvolvimento do software e essas mudanças precisão refletir no sistema, respondendo à es-
sas mudanças de forma ágil.
Para apoiar e detalhar esses valores, foram criados os princípios do software ágil, que você verá a seguir.
8.1.2 PRINCÍPIOS DO SOFTWARE ÁGIL
Agora você vai conhecer os princípios do software ágil criados para apoiar os valores do manifesto ágil.
Acompanhe!
a) Nossa maior prioridade é satisfazer o cliente, por meio da entrega adiantada e contínua de software
de valor.
b) Aceitar mudanças de requisitos, mesmo no fim do desenvolvimento. Processos ágeis se adequam a
mudanças, para que o cliente possa tirar vantagens competitivas.
c) Entregar software funcionando com frequência, na escala de semanas até meses, com preferência
aos períodos mais curtos.
d) Pessoas relacionadas a negócios e desenvolvedores devem trabalhar em conjunto e diariamente,
durante todo o curso do projeto.
8 ESTRUTURA ORGANIZACIONAL E EQUIPES ÁGEIS
165
e) Construir projetos ao redor de indivíduos motivados. Dando a eles o ambiente e suporte necessário,
e confiar que farão seu trabalho.
f) O método mais eficiente e eficaz de transmitir informações para, e por dentro de um time de
desenvolvimento, é por meio de uma conversa cara a cara.
g) Software funcional é a medida primária de progresso.
h) Processos ágeis promovem um ambiente sustentável. Os patrocinadores, desenvolvedores e usuá-
rios, devem ser capazes de manter indefinidamente, passos constantes.
i) Contínua atenção à excelência técnica e bom design, aumenta a agilidade.
j) Simplicidade: a arte de maximizar a quantidade de trabalho que não precisou ser feito.
k) As melhores arquiteturas, requisitos e designs emergem de times auto organizáveis.
l) Em intervalos regulares, o time reflete em como ficar mais efetivo, então, se ajustam e otimizam seu
comportamento de acordo.
Após esta contextualização dos preceitos do desenvolvimento ágil, você irá iniciar o estudo sobre o
método de trabalho Scrum, que viabiliza a aplicação dos valores e princípios ágeis no trabalho diário das
pessoas em suas organizações.
8.2 ESTRUTURAS ORGANIZACIONAIS NO DESENVOLVIMENTO ÁGIL
É importante iniciar este tópico com a definição do método de trabalho Scrum, que trará conceitos nos
quais as estruturas organizacionais tendem a se basear para realizar o desenvolvimento ágil de software.
Este método é muito simples, porém exige das organizações alto grau de comprometimento e des-
prendimento de hábitos tradicionais, para que o método seja implantado de forma plena e para que as
equipes possam desempenhar suas atividades de forma produtiva e com constante entrega de valor.
Uma palavra que estará presente de forma constante neste capítulo e no meio do desenvolvimento ágil
é “valor”, com o sentido de algo importante para as pessoas interessadas no resultado do desenvolvimento
de um sistema ou partes dele, portanto não estará associado diretamente a valor monetário, mas sim a va-
lor no grau de importância ou de relevância para resolver determinado problema ou atender determinada
necessidade.
No método de trabalho Scrum, não há um processo ou técnica específica para desenvolver um produto,
mas sim um conjunto de processos e técnicas que irão auxiliar no gerenciamento das atividades de
desenvolvimento, assim como no andamento da construção do produto propriamente dito.
Para atender as demandas do método, são definidos papéis, eventos, artefatos e regras, que irão relacio-
nar-se e compor a dinâmica de funcionamento do Scrum, nos quais serão descritos nos próximos tópicos.
Outro aspecto importante deste método é a evolução a partir do processo prático, isso quer dizer, o
conhecimento e a melhor aplicação do método consistem na experiência, ou seja, quanto mais usar este
framework ao decorrer do tempo, o sucesso da aplicação dos processos e técnicas tendem a produzir re-
sultados melhores e mais precisos.
166
Para análise deste autoconhecimento, baseado na experiência, o Scrum usa uma abordagem cíclica e
incremental, estruturada por três pilares. Confira eles a seguir.
Transparência
Este pilar tem como objetivo tornar claro as principais definições do processo de trabalho e dar visibili-
dade aos responsáveis e interessados pelos resultados obtidos no trabalho desenvolvido.
Inspeção
Este segundo pilar estimula o acompanhamento constante do desenvolvimento do trabalho, para ga-
rantir que não houveram desvios do que foi planejado inicialmente, mas com o cuidado para que estas
inspeções não provoquem atrasos na execução das tarefas relacionadas ao projeto.
Adaptação
Este último pilar é a consequência da inspeção realizada, quando é identificado algum desvio que com-
prometa a qualidade do resultado final, sendo necessário realizar ajustes ou adaptações ao trabalho que
está sendo desenvolvido.
SCRUM
Transparência
Adaptação
Inspeção
Davi Leon (2017)
Figura 117 - Pilares do método de trabalho Scrum

Para que a aplicação do método de trabalho Scrum aconteça com sucesso, é necessária a adesão de
todos os envolvidos e espera-se que as pessoas possuam valores específicos, que irão corroborar com a
aplicação dos pilares do Scrum.
Estes valores são comprometimento, coragem, foco, abertura e respeito, os quais também são desen-
volvidos durante a aplicação do método de trabalho, pois os eventos, artefatos e papéis do Scrum irão
estimular estes valores.
A relação dos valores mencionados funciona como uma corrente, na qual cada valor representa um elo
desta corrente, portanto é crucial para o bom andamento do trabalho no Scrum que estes valores estejam
sempre presentes e em constante evolução.
167
Na prática, as pessoas precisam se comprometer para alcançar objetivos estabelecidos pela equipe; a
equipe precisa de coragem para aceitar os desafios e tarefas para realizar o trabalho planejado; este traba-
lho deve ser realizado com o foco no trabalho e nos objetivos esperados; ao mesmo tempo que deve haver
abertura para a participação dos principais interessados no resultado do trabalho realizado; sempre com
o respeito mútuo entre todos os membros da equipe.
Coragem
O Time Scrum precisa ter coragem para
fazer a coisa certa e trabalhar em
problemas difíceis.
Foco
Todos coram no trabalho da Sprint e
nos objetos do Time Scrum.
Comprometimento
As pessoas se comprometem
pessoalmente em alcançar os
objetivos do Time Scrum.
Scrum
Respeito
Os membros do Time Scrum respeit-
Values
am uns aos outros para serem
pessoas capazes e independentes.
Abertura
O Time Scrum e seus Stakeholders
concordam em estarem abertos a Davi Leon (2017)
todo o trabalho e aos desafios com a
excução dos trabalhos.
Figura 118 - Valores do método de trabalho Scrum
No próximo tópico, serão abordadas as funções e papéis de equipes ágeis, baseadas no método de tra-
balho Scrum, sendo muito comuns tais funções e papéis de forma geral no mercado de desenvolvimento
de software, acompanhe!
8.2.1 FUNÇÕES E PAPÉIS
As funções e papéis do método de trabalho Scrum são agrupados no termo Time Scrum, que possui o
Product Owner (Dono/Responsável do Produto), o Time de Desenvolvimento, que possui diferentes fun-
ções, e o Scrum Master.
A característica principal do Time Scrum está relacionada a auto-organização, que garante a este time
a escolha da forma como irá organizar seu trabalho, sem a interferência externa de outros membros da
organização.
168
Para que essa característica seja viável, o Time Scrum precisa ser multifuncional, ou seja, possuir pessoas
com diferentes competências, que possam garantir que o trabalho planejado sela completado, sem preci-
sar de auxílio externo da organização.
O Time Scrum tem compromisso de realizar entregas de software funcional de forma constante, por
meio de ciclos de curto período, a cada ciclo incrementando o produto, até que este produto esteja consi-
derado pronto por todos os envolvidos no processo de desenvolvimento.
Product owner Scrum master
Time Scrum
Davi Leon (2017)
Developer QA UX/UI designer
Figura 119 - Formação do Time Scrum
Serão detalhadas as funções dos papéis de Product Owner e Scrum Master, para que você possa conhe-
cer as responsabilidades e o cotidiano dos profissionais que desempenham estes papéis.
PRODUCT OWNER
O dono do produto, como o nome do papel já ressalta, terá funções relacionadas a decisões sobre o
produto, com o objetivo de aumentar o seu valor e do trabalho do Time de Desenvolvimento.
O produto será composto por pequenas partes, que serão desenvolvidas pelo Time de Desenvolvimen-
to. Estas partes formam uma lista de tarefas a fazer, sendo esta lista identificada como Backlog e, nesse
contexto, o Backlog do Produto.
Na ação de maximizar o valor do produto, o Product Owner irá gerenciar o Backlog de Produto, identi-
ficando quais itens ou tarefas devem fazer parte desta lista, assim como a priorização dos itens do Backlog
de Produto.
169
Para realizar este gerenciamento do Backlog de Produto, determinadas ações devem ser realizadas,
como segue:
a) informar de forma clara quais são os itens do backlog de produto;
b) priorizar os itens do backlog de produto;
c) garantir que o time de desenvolvimento entregue valor no trabalho realizado;
d) tornar o backlog de produto visível para todos os envolvidos no processo de desenvolvimento;
e) informar quais itens do backlog de produto serão trabalhados pelo time scrum;
f) prover o entendimento do time de desenvolvimento sobre a perspectiva de negócio dos itens do
backlog de produto.
Todo este trabalho pode ser delegado para o Time de Desenvolvimento, porém o Product Owner con-
tinua sendo o responsável pelo trabalho mencionado.
O papel do Product Owner é composto por uma única pessoa, ou seja, mesmo que exista um comitê
para elencar novas funcionalidades para o produto, cabe somente ao Prodcut Owner a decisão final sobre
o que fará parte do backlog de Produto.
Gerenciamento Análise da visão

do Backlog do produto
Product owner
Davi Leon (2017)
Coordenação com Delegar para o time

Scrum Master de desenvolvimento
Figura 120 - Principais funções do Product Owner
Este papel também tem a função de blindar o Time de Desenvolvimento, evitando que solicitações
sobre o produto seja atendida sem a prévia autorização do Product Owner, assim como o Time de Desen-
volvimento deve ter o compromisso de não realizar demandas que surjam de fontes diferentes da definida
pelo dono do produto.
170
SCRUM MASTER
O Scrum Master é o profissional que garante a aplicação do método de trabalho, buscando servir a to-
dos os envolvidos no processo de desenvolvimento e integrantes do Time Scrum. Este papel também tem
como função tornar clara a dinâmica de interação entre pessoas da organização, externas ao Time Scrum,
para otimizar o trabalho deste time.
Há três faces de interação nas atividades desenvolvidas pelo Scrum Master, com interfaces para o Product
Owner, o Time de Desenvolvimento e as pessoas externas ao Time Scrum, que fazem parte da organização.
Para cada interação destes diferentes papéis, há atividades específicas nas quais o Scrum Master presta
estes serviços. Confira quais são elas a seguir.
Interface Product Owner

a) auxílio no gerenciamento do backlog de produto;
b) informar ao time de desenvolvimento os itens do backlog de produto, assim como o propósito des-
tes itens sobre o produto;
c) auxiliar o time scrum a cria o backlog de produto;
d) entender como realizar o planejamento, a partir da prática do time scrum;
e) entender e praticar as técnicas ágeis, para o desenvolvimento de software;
f) promover e facilitar os eventos scrum.
Interface Time de Desenvolvimento

a) tornar o time de desenvolvimento auto gerenciável e com diferentes capacidades técnicas;
b) auxiliar o time de desenvolvimento a desenvolver produtos com alto valor agregado;
c) proteger o time de desenvolvimento contra possíveis impedimentos;
d) facilitar os eventos scrum;
e) promover o time de desenvolvimento para pessoas externas ao time scrum, que fazem parte da or-
ganização.
Interface organização
a) Incentivo e treinamento da Organização para adotar o método Scrum.
b) Planejar a inserção do Scrum no cotidiano da Organização.
c) Auxílio de colaboradores da empresa para aplicar o Scrum.
d) Promovendo mudanças na Organização para aumentar a produtividade do Time Scrum.
e) Trabalho em equipe com outros Scrum Master, para inserir o Scrum na organização de forma mais
efetiva.
171
Na figura a seguir, é possível observar um resumo das principais atividades desenvolvidas pelo servo-líder
Scrum Master, que possui muitas atividades, com várias interações em diferentes vertentes da organização
que atua.
Escudo contra
Coach
interferências
Removedor de
Líder Service
impedimentos
Scrum
Master
Davi Leon (2017)

Autoridade no Agente de
processo mudanças
Figura 121 - Principais funções do Scrum Master
No próximo tópico, serão detalhadas as funções, características e responsabilidades do Time de Desen-

volvimento, por isso continue seus estudos para que possa ficar claro as responsabilidades que certamente
estarão aguardando você em sua carreira profissional.
CURIOSI Você sabia que o método de trabalho Scrum apresentou seu primeiro grande resul-
DADES tado no desenvolvimento de um grande sistema para o FBI?
A seguir você vai entender o que é o time de desenvolvimento.
8.2.2 TIME DE DESENVOLVIMENTO
O Time de Desenvolvimento é o grupo de pessoas que propriamente desenvolve um produto concreto,

apto a ser usado pelo cliente ou usuário final. Este grupo possui profissionais com diferentes qualificações
técnicas, que tornam este time autossuficiente e capaz de atender as demandas assumidas.
A principal característica deste grupo é o autogerenciamento na realização de seu trabalho, identifican-
do quanto trabalho pode realizar e de que forma irá produzir o resultado esperado. A qualidade do Time
de Desenvolvimento tende a aumentar, de acordo com a experiência e o tempo em que realizam suas
atividades, para que as estimativas e estratégias de realizar seu trabalho tornam-se mais precisas.
172
A seguir veja outras características que definem o Time de Desenvolvimento, quanto sua dinâmica de
trabalho, assim como a sua composição e os profissionais que participam deste grupo.
a) Somente o Time de Desenvolvimento tem autonomia para decidir como tornar os itens do Backlog
de Produto em um produto final ou incremento dele.
b) Existe multidisciplinaridade, para que todas as capacidades necessárias para realizar o trabalho este-
jam presentes na equipe.
c) Apesar das diversas capacidades existentes no grupo, para o método Scrum não há distinção entre
seus integrantes, sendo todos identificados como Desenvolvedores.
d) A responsabilidade sobre todas as decisões e ações do Time de Desenvolvimento pertence exclusiva-
mente ao grupo, nunca sendo delegado para integrantes específicos.
e) No Time de Desenvolvimento não há subdivisões, como equipe de teste, analista, programador, entre
outros, sendo todos um único time.
f) O tamanho do Time de Desenvolvimento deve ser pequeno, com no mínimo três e no máximo nove
integrantes.
g) Time de Desenvolvimento muito pequeno corre o risco de não possuir as capacidades necessárias
para desenvolver o trabalho.
h) Time de Desenvolvimento muito grande aumenta a complexidade de gerenciamento e impede a
manutenção das principais características deste tipo de grupo.
Comunicação
Auto-organizado
frequente
Multi-funcional Comunicação
transparente
Pessoal Tamanho
T-shaped Time de certo
desenvolvimento
Atitude Focado e
mosqueteira comprometido
Davi Leon (2017)
Trabalho em ritmo
Entrosamento
sustentável
Figura 122 - Características do Time de Desenvolvimento

173
Na figura anterior, são relacionadas as principais características do Time de Desenvolvimento, de forma

direta e indireta das características citadas para este tipo de equipe.
No tópico seguinte, você irá conhecer um pouco mais sobre a dinâmica dos métodos ágeis e irá come-
çar a ficar mais claro todas estas definições vistas até o momento e a forma como são complementares.
8.3 MÉTODO DE TRABALHO DE EQUIPES ÁGEIS
Em métodos de trabalho ágeis o foco está em curtos períodos de desenvolvimento de software, para
que as ações e gerência deste processo de desenvolvimento seja mais dinâmico, ou seja, mais ágil.
No método de trabalho Scrum, este período de desenvolvimento é identificado como Sprint, com uma
duração entre duas a quatro semanas. Ao final deste período, deve existir um produto ou fração deste
pronto e apto para uso.
Estes períodos ou ciclos de desenvolvimento são repetidos de forma sequencial, enquanto o projeto
estiver em andamento, até que seja entregue um produto final.
A cada Sprint acontecem eventos previstos no método de trabalho Scrum, que seguem:
a) planejamento da Sprint;
b) reunião diária;
c) esforço de desenvolvimento;
d) revisão da Sprint;
e) retrospectiva da Sprint.
Na próxima figura, você pode observar a forma como acontece o trabalho de desenvolvimento previsto em
um Sprint, o qual é iniciado com uma reunião de planejamento, para selecionar os itens do Backlog do Produto
que serão desenvolvidos na Sprint, traçando também estratégias de como realizar este desenvolvimento.
Após a conclusão desta etapa na Sprint, estes itens tornam-se parte do Backlog da Sprint e estarão dis-
poníveis para o Time de Desenvolvimento construir o produto ou parte dele.
A cada dia deste ciclo de desenvolvimento, ocorre a reunião diária, uma reunião rápida e objetiva, com
o propósito de informar o andamento do trabalho e possíveis impedimentos, para que o Scrum Master
possa tomar as devidas ações. Ao final do período da Sprint, ocorre a sua revisão e retrospectiva, para que
o time possa obter aprendizado sobre o ciclo de desenvolvimento realizado.
174
Daily scrum
meeting
Product
backlog
24 hours
Sprint
backlog
2.4 weeks Potentially

shippable
product
increment
Davi Leon (2017)

Figura 123 - Dinâmica do método de trabalho Scrum
O período curto da Sprint permite maior previsibilidade sobre eventuais imprevistos e ocorrências, fa-
cilitando a inspeção e adaptação do curso do trabalho, além de limitar riscos de custos inesperados a um
curto período.
O primeiro evento da Sprint é seu próprio planejamento, que consiste em uma reunião colaborativa
entre todos os membros do Time Scrum. Esta reunião costuma ter uma duração de quatro a oito horas, de-
pendendo do tamanho da Sprint, possuindo “grande” duração por ser determinante para o trabalho que
será realizado durante todo o próximo ciclo de desenvolvimento.
istockphoto ([20--?])
Figura 124 - Trabalho colaborativo no planejamento de Sprint
O planejamento precisa responder três questões gerais, veja!

175
a) Qual o propósito da Sprint?

b) O que pode ser entregue ao final da Sprint?
c) Como o trabalho da Sprint será realizado?
O Product Owner, como já mencionado, define quais itens do Backlog de Produto serão priorizados e
consequentemente orienta o propósito da Sprint por esse parâmetro.
Dessa forma, o insumo inicial desta reunião é o próprio Backlog de Produto já priorizado, o produto
construído até o momento e a capacidade do Time de Desenvolvimento, baseada na produtividade de
ciclos anteriores.
A função do Time de Desenvolvimento, neste momento, é selecionar os itens do Backlog de Produto
priorizado para o Backlog de Sprint, de acordo com o que o time reconheça que poderá entregar ao final
da Sprint.
Para o Time de Desenvolvimento estimar o esforço necessário da implementação dos itens de Backlog
da Sprint, podem ser usadas técnicas, como o Planning Poker, que consiste em um jogo de cartas, com
uma sequência numérica, identificada como números de Fibonacci, a qual consiste em números sequen-
cias em que o número seguinte é a soma do número anterior e atual da sequência.
Com posse destas cartas enumeradas, cada membro do Time de Desenvolvimento apresenta um valor
associado ao item do Backlog analisado, sendo que, após a mediação do Scrum Master e debate do Time
de Desenvolvimento, é concluído um valor estimado para a demanda, assim envolvendo todos os pontos
de vista dos membros da equipe de desenvolvimento.
Figura 125 - Simulação da estimativa por Planning Poker
A última questão da Sprint a ser respondida é como o trabalho será realizado, sendo possível responder
após a definição do que foi selecionado e estimado para o Backlog de Sprint.
O Time de Desenvolvimento também será o responsável por traçar o plano de como os itens do backlog
serão implementados. Normalmente, são criadas tarefas pequenas com duração de até um dia e existe
uma auto-organização da equipe na distribuição destas tarefas, buscando a entrega do que foi planejado.
176
Ao final do planejamento, o Time de Desenvolvimento deverá explicar ao Product Owner e Scrum Mas-
ter a estratégia adotada para desenvolver o trabalho e a maneira pela qual o time pretende atingir o obje-
tivo da Sprint.
8.3.1 ARTEFATOS DO SCRUM
Até o momento, foram mencionados algumas vezes o termo Backlog de Produto, Backlog de Sprint e
Produto Pronto ou incremento deste produto, e a partir deste tópico serão detalhados o que são e suas
respectivas utilidades.
Eles são classificados como artefatos do método de trabalho Scrum e oferecem uma forma de inspeção
e adaptação aos trabalhos realizados, orientado pelo Scrum, representando grande importância para a
estrutura do método.
Você irá iniciar com o Backlog de Produto, que é formado por uma lista de funcionalidades para o pro-
duto, ou nesse contexto, para o software, sendo a fonte de requisitos para a criação ou alteração de um
sistema.
Este backlog nunca está completo, mesmo que o sistema esteja pronto de acordo com o seu propósito
inicial, este backlog continua existindo e sendo alimentado, por novas necessidades dos usuários e melho-
rias propostas para o software.
No ciclo de vida do produto, o Backlog de Produto mantém-se vivo, até que o produto seja descontinu-
ado, sendo sempre da responsabilidade do Product Owner manter este backlog, assim como ordená-lo de
acordo com as prioridades associadas a cada item, seguindo a ordem de prioridade.
Funcionalidades
Maior
Prioridade
Product
backlog
Menor
Prioridade
Davi Leon (2017)
Figura 126 - Lista de itens do Backlog de Produto
Como pode ser observado na figura anterior, o backlog irá listar todas as funcionalidades do software.
Assim sendo, suas características, melhorias e possíveis correções, que irão compor as alterações que de-
verão ser realizadas no produto em futuros ciclos de desenvolvimento.
177
Existem diversos fatores para inserir novos itens neste backlog, após a entrega da versão inicial do pro-
duto, como mudanças nos requisitos de negócios que o sistema atende, novas necessidades dos usuários,
que não haviam sido identificadas inicialmente, troca de tecnologias, entre outros fatores.
Após a inserção de itens nesse backlog o Product Owner e o Time de Desenvolvimento fazem um refi-
namento, realizando estimativas para a sua implementação e a ordem os itens mais importantes ou com
mais prioridades.
Nesse processo de refinamento, os itens mais prioritários recebem maior atenção para serem mais deta-
lhados e estimados com maior precisão, enquanto os itens ao final da lista deste backlog possuem poucos
detalhes e somente uma estima pouco precisa.
Durante o planejamento da Sprint é criado um segundo backlog, identificado como Backlog de Sprint,
que se resume a alguns itens do Backlog de Produto, que possuem alto grau de detalhes, estimativas mais
precisas e maior prioridade, nos quais são selecionados para serem implementados no período da Sprint.
Dessa forma, os itens do Backlog de Sprint representam a nova funcionalidade ou incremento de sof-
tware que será entregue como resultado do ciclo de desenvolvimento.
Apesar da definição dos itens para este backlog, ao longo da Sprint tais itens podem ser substituídos ou
até mesmo novos itens podem ser adicionados ao Backlog de Sprint, dependendo do processo de como o
trabalho for realizado e os resultados obtidos.
Project Backlog Sprint Backlog

Tatiana Daou (2018)
Figura 127 - Lista de itens do Backlog de Sprint
Na figura anterior, há uma representação do Backlog da Sprint, tornando evidente a origem dos itens
desse backlog, assim como ele representa uma fração do backlog geral do produto.
Outra referência importante é a visibilidade associada a este backlog, pois a partir deste é que o traba-
lho do Time de Desenvolvimento é visualizado e atualizado em tempo real, de acordo com a sua evolução
para a entrega do incremento de software.
178
O último artefato produzido pelo método de trabalho Scrum, é o próprio software, ou um incremento
deste software, que constitui uma parte funcional do software como um todo.
Software
Davi Leon (2018)

Figura 128 - Representação de incremento de Software
O incremento de software representa de forma concreta os itens do Backlog de Produto que foram
selecionados para o Backlog de Sprint e implementados pelo Time de Desenvolvimento, ao longo do ciclo
de desenvolvimento da Sprint.
Quando a entrega do incremento ocorre, sendo ele de fato uma parte funcional do software, é uma
evidência do alcance dos objetivos estabelecidos pela Sprint.
Nestes tópicos foram apresentados alguns conceitos relacionados ao cotidiano de grande parte dos
desenvolvedores de software, do mercado atual. Portanto mesmo que o profissional ocupe um papel
específico dentro deste contexto, o conhecimento geral do método é fundamental, para que o método possa
ser aplicado e o trabalho de implementação, ou seja, de construção efetiva de software, possa ser realizado.
FIQUE É comum as organizações adotarem de forma parcial o método de trabalho Scrum,

ALERTA assim como mesclar com outros métodos ágeis.
A seguir você irá conhecer as técnicas de gerenciamento de atividades ágil. Acompanhe!
8.3.2 TÉCNICAS DE GERENCIAMENTO DE ATIVIDADES ÁGIL
Nesta seção, serão apresentados conceitos relacionados ao gerenciamento das atividades, dentro do
contexto ágil, porém estes conceitos devem ser claros para todos os envolvidos no processo de desenvol-
vimento ágil, pois todo o Time Scrum irá alimentar com informações os subsídios para a inspeção e adap-
tação do trabalho em andamento.
179
Uma das principais atividades ou eventos do método de trabalho Scrum é a Reunião Diária, que dentro
de um curto intervalo de tempo, normalmente são apenas quinze minutos, os integrantes possam repas-
sar informações para o time como um todo, de forma objetiva.
Essas informações tratadas na reunião, são relacionadas às atividades realizadas no dia anterior e as
próximas atividades a serem executadas. Nesse momento, também são repassadas possíveis dificuldades
ou impedimentos, ou ainda desvios do plano, para que deste modo o trabalho possa ser inspecionado e
talvez adaptado.
Figura 129 - Representação da Reunião Diária
Na figura anterior, há uma representação de como a Reunião Diária é conduzida, e, na verdade, existem
algumas regras para a realização e condução deste tipo de reunião, como segue:
a) a reunião acontece no mesmo horário e local, para facilitar a organização das pessoas;
b) cada membro de forma objetiva informa a atividade realizada no dia anterior e o que irá fazer no dia
que segue, para auxiliar o time de desenvolvimento;
c) também deve ser informado qualquer impedimento, que ocorreu ou que possa acontecer;
d) a reunião é realizada com todas as pessoas em pé, para garantir que terá uma curta duração.
A Reunião Diária é uma importante ferramenta para auxiliar o Time de Desenvolvimento no cumpri-
mento dos seus objetos da Sprint, pois permite identificar de forma muito rápida e ágil possíveis proble-
mas e oportunidades de realizar o trabalho da melhor forma possível.
É importante reforçar que o Time de Desenvolvimento é o responsável por realizar a reunião e obedecer
às suas regras e propósitos, mas que normalmente acontece de forma natural, pois o time percebe gran-
des vantagens, como o compartilhamento de conhecimento, melhora na comunicação interna do time e
aproximação dos integrantes da equipe.
180
Outro evento de grande importância para o método de trabalho Scrum, é a Revisão da Sprint, que
acontece ao final de cada ciclo de desenvolvimento, para verificar o incremento de software entregue e
possíveis alterações do Backlog de Produto.
Figura 130 - Representação da reunião de Revisão da Sprint
Na figura anterior, é ilustrada a representação de uma Revisão de Sprint, que consiste em uma reunião
mais informal, com o objetivo também de obter a percepção dos envolvidos sobre o que foi realizado e
entregue na Sprint. Essa reunião também tem um limite de duração, que pode ser de até quatro horas,
dependendo do tamanho da Sprint.
Nesse tipo de reunião, também existem algumas regras, sobre a forma como é conduzida, o que é dis-
cutido e de quem pode participar, como segue:
a) todo o Time Scrum participa, além dos principais interessados no projeto que podem ser convidados
pelo Product Owner;
b) é informado pelo Product Owner o que foi entregue como incremento de software, na Sprint;
c) é informado pelo Time de Desenvolvimento os casos de sucesso e dificuldades que ocorreram duran-
te a Sprint, como tais dificuldades foram resolvidas;
d) é demonstrado pelo Time de Desenvolvimento o incremento de software entregue;
e) o Backlog de Produto é analisado pelo Product Owner, para estimar datas de entrega dos itens deste
backlog, baseado no desempenho atual do Time de Desenvolvimento;
f) todos os participantes sugerem as próximas ações na construção ou evolução do produto;
g) análise geral de diferentes perspectivas sobre o uso do produto para auxiliar no formato da próxima
versão do produto.
181
Baseado nessa reunião, o Backlog de Produto é revisado e estará mais adequado para a reunião de
planejamento da próxima Sprint, para que possa estar mais alinhado com os itens do Backlog de Produto
mais prioritários.
O próximo evento de análise, e de certa forma de gerenciamento do trabalho desenvolvido, é a Re-
trospectiva da Sprint, que acontece depois da Revisão da Sprint e antes do Planejamento da Sprint para o
próximo ciclo de desenvolvimento, ou seja, é um momento de aprendizado com as ações do próprio Time
Scrum, para que a próxima Sprint possa ser melhor e com maior maturidade da equipe.
Essa reunião também possui um limite de duração, com até três horas, dependendo do tamanho da
Sprint que está sendo revisada, onde o Scrum Master participa deste evento com o objetivo de que a revi-
são acontece dentro das regras definidas.
O que foi bom? O que foi pode melhorar?

PO
Davi Leon (2017)

SM
Figura 131 - Representação das ações da Retrospectiva da Sprint
Essas regras têm como propósito garantir a inspeção e adaptação do Time Scrum, que pode ser apli-
cado na próxima Sprint ou a qualquer momento, quando for identificado a necessidade. Segue a relação
destas regras:
a) inspecionar a última Sprint que aconteceu, quanto aos envolvidos, relacionamentos, processos e fer-
ramentas utilizadas;
b) relacionar os itens que foram bons e o que pode ser melhorado;
c) criar uma estratégia para inserir no Time Scrum possíveis melhorias identificadas.
Você pode observar na figura anterior as ações e conclusões obtidas a partir da Retrospectiva da Sprint,
com o intuito de aumentar a qualidade do processo de desenvolvimento e consequentemente do produto
final, com a entrega de seus incrementos a cada Sprint.
A seguir, será apresenta uma poderosa ferramenta, usada em larga escala pelas equipes de desenvolvi-
mento, que possui como principal propósito a facilidade na visualização do trabalho a ser feito, no plano a
seguir e no status do que foi planejado; esta ferramenta é identificada como o quadro Kanban.
182
O quadro Kanban pode ser aplicado a qualquer segmento de mercado, em que pessoas em equipes de
trabalho precisem coordenar e dar visibilidades às suas atividades, dessa forma, o mercado de software usa
para apoiar a organização e gerenciamento de seu trabalho.
O uso desta ferramenta consiste em um quadro com no mínimo três colunas, que representam ativida-
des para fazer (ToDo), em execução (Doing) e finalizado (Done), porém este quadro pode ser personaliza-
do, acrescentando novas colunas, de acordo com o processo de cada equipe de trabalho.
Esse quadro pode ser uma interface de um software de gerenciamento de itens de trabalho ou um qua-
dro pendurado na parede, ou ainda um quadro desenhado em uma parede. Para os quadros de Kanban
físicos, normalmente são usados post-its para escrever as atividades, com isso facilitando a transição das
tarefas que estão por fazer, em execução e finalizada, apenas mudando a posição do post-it na coluna que
representa o seu respectivo status.
Para facilitar a visualização também é incentivado o uso de post-its de diferentes cores, para classificar
estas atividades, seja por tipo, prioridade, tamanho, entre outras classificações possíveis e de acordo com
o processo de cada equipe.
ToDo Doing Done
Tatiana Daou (2018)
Figura 132 - Quadro fundamental do Kanban
Veja que, na figura anterior, há uma representação de um quadro Kanban, com as três colunas
fundamentais da ferramenta e simulando o uso de post-its com diferentes cores, para facilitar a visualização
dos tipos e características das demandas.
No próximo tópico, serão apresentadas ferramentas para auxiliar na gestão das atividades dos times de
desenvolvimento, ou seja, softwares que irão simular o funcionamento do quadro Kanban e adequar-se
aos métodos de trabalho de equipes ágeis, como o Scrum.
Continue seus estudos, pois as ferramentas a seguir podem ser usadas por você em suas futuras ativi-
dades profissionais!
183
8.3.3 FERRAMENTAS DE GERENCIAMENTO
As ferramentas de gerenciamento de itens de trabalho ou produtividade, representam maior eficiência

no processo de gestão pela facilidade de organizar as tarefas das equipes de trabalho, mesmo que possam
existir diversas equipes.
Essas ferramentas buscam organizar as atividades, criar vínculos de relacionamentos entre elas, e dessa
forma formar relações de dependências, hierarquias, impedimentos, entre outros, assim como, também
podem ser classificadas de acordo com suas características, tipos e prioridades, associar processos de de-
senvolvimento, entre outras possibilidades, buscando sempre uma visão mais ampla das atividades a se-
rem desenvolvidas, com o intuito de prover mais coordenação e consequentemente mais eficiência.
SAIBA O mercado de trabalho reconhece de forma positiva, certificações baseadas no méto-

do de trabalho Scrum. Visite o site <https://www.scrum.org/professional-scrum-certifi-
MAIS cations> e confira mais detalhes a respeito!
Confira, na sequência, o “Casos e Relatos” que demonstra como é importante o trabalho em equipe
para o desenvolvimento de atividades.
CASOS E RELATOS
A importância do trabalho em equipe

Na atividade de desenvolvimento de software, é muito comum existirem equipes de desenvolvi-
mento que atuam sobre determinado projeto ou sistema, e nesse contexto Joaquim está inician-
do seu trabalho, em uma nova empresa de desenvolvimento de sistemas. Nesse emprego, será a
primeira vez que Joaquim irá trabalhar com desenvolvimento ágil e interagir com a equipe e seu
superior direto, neste conceito de trabalho. Ao passar de poucos dias Joaquim já estava familia-
rizado com a dinâmica de trabalho, percebendo a organização, rapidez e qualidade com que as
atividades eram desenvolvidas e entregues. Além destas grandes vantagens Joaquim também
observou um bom entrosamento entre ele e a equipe, sentindo-se como uma peça importante do
time, seja na sua atuação no planejamento e execução de atividades, seja na entrega constante de
valor agregado aos clientes da empresa.
Reveja os principais conceitos estudos neste capítulo lendo o “Recapitulando” a seguir.

184
RECAPITULANDO
Neste capítulo, foram abordados assuntos diretamente relacionados a dinâmica de trabalho de

equipes de desenvolvimento e a estrutura das organizações, frente aos métodos de trabalho ágeis,
predominantes atualmente no mercado de trabalho.
Foram apresentados conceitos de funções e papéis de profissionais, frente o método de trabalho
Scrum, reforçando as ações do Time de Desenvolvimento e seus integrantes, como os programadores.
Também foram apresentadas técnicas de trabalho, ou seja, uma forma de como desenvolver siste-
mas com organização e preconizando a constante entrega de valor para os principais interessados
no software.
Aliadas às técnicas de trabalho, foram também abordadas maneiras de gerenciar as atividades de-
senvolvidas pelas equipes, tornando o processo de desenvolvimento mais claro, transparente e ágil.
Este capítulo possui grande relevância pois apresenta a forma como grande parte das organiza-
ções realizam suas atividades, por isso é muito importante você estar capacitado para as regras do
jogo em sua carreira profissional!
No próximo capítulo, serão apresentadas duas ferramentas de grande uso no mercado de desen-
volvimento de software, que auxiliam pequenas e grandes empresas na organização das ativi-
dades de suas equipes de desenvolvimento. Serão apresentadas possibilidades de aplicação das
mesmas, está imperdível, acompanhe!
Ferramentas de
Gerenciamento de Atividades
As ferramentas de gerenciamento de atividades representam um importante recurso para

as equipes de desenvolvimento, assim como, para seus gestores, para auxiliar no bom anda-
mento do trabalho realizado e o processo de desenvolvimento de software.
O Trello e KanbanFlow são importantes ferramentas, reconhecidas pelo mercado de desen-
volvimento de software, que apresentam algumas semelhanças na sua abordagem e ao pro-
pósito que atendem, variando nas suas interfaces e algumas pequenas funcionalidades mais
específicas de cada ferramenta.
a) configurar e iniciar o uso da ferramenta de gestão de atividades Trello;
b) configurar e iniciar o uso da ferramenta de gestão de atividades Kanbanflow.
Nos tópicos que seguem, você irá acompanhar o procedimento para iniciar o uso em cada
uma destas ferramentas, que são totalmente online, e as possibilidades mais básicas de aplicação
das mesmas.
188
9.1 GERENCIANDO ATIVIDADES COM O TRELLO
O Trello é uma das principais ferramentas de gerenciamento de atividades do mercado, obtendo este
sucesso em boa parte por ser baseada nos conceitos do método Kanban. Dessa forma, a ferramenta pro-
porciona uma gestão simples, objetiva e capaz de integrar várias pessoas de uma mesma equipe, com
diferentes atividades.
SAIBA O método Kanban é a referência para ferramentas de gerenciamento de atividades. Vi-

site o site < https://www.culturaagil.com.br/kanban-do-inicio-ao-fim/> e confira mais
MAIS detalhes sobre seus conceitos!
Acompanhe a seguir os passos para acessar e configurar a ferramenta, você irá perceber que será um
grande apoio nas suas futuras atividades profissionais.
O Trello é online, portanto para iniciar o uso na ferramenta será necessário acessar o site oficial da ferra-
menta, <https://trello.com/>, onde será exibido a interface do site, como demonstrado na figura a seguir,
sendo necessário clicar no botão “Cadastra-se”, para seguir o procedimento de acesso e uso da ferramenta.
trello ([20--?])
Figura 133 - Interface inicial do site da ferramenta Trello
Após iniciar o cadastro, será preciso preencher alguns dados, o nome, e-mail e a senha de acesso, e
clicar no botão “Criar Nova Conta”. O procedimento para ingressar na ferramenta é muito fácil e simples e,
com esse passo, você já terá acesso ao Trello.
9 FERRAMENTAS DE GERENCIAMENTO DE ATIVIDADES
189
trello ([20--?])
Figura 134 - Interface de cadastro de novo usuário no Trello
Após o cadastro, o primeiro acesso dará a visão dos quadros existentes associados ao seu perfil de
acesso, e por padrão a ferramenta cria um quadro identificado como “Quadro de Boas-vindas” para apre-
sentação inicial do serviço.
Esta visão inicial é ilustrada na figura a seguir, assim como um botão para criar um novo quadro, no qual
será usado para criar um quadro para futuras atividades, clicando neste botão.
trello ([20--?])
Figura 135 - Interface Trello de visualização de quadros pessoais
Observe que essas ferramentas seguem a dinâmica do quadro Kanban, para uso pessoal ou de um gru-
po de pessoas, que formam um time. Ao criar um novo quadro, será possível inserir as listas que agruparão
as atividades, e a exemplo das colunas fundamentais do quadro Kanban, podem ser criadas para este
exemplo, as listas “A fazer”, “Fazendo” e “Feito”, como pode ser observado na figura que segue.
190
trello ([20--?])
Figura 136 - Interface Trello de um quadro com suas listas
Com as listas prontas, podem ser criadas as atividades ou tarefas, associadas às suas respectivas listas,
de acordo com o status de cada tarefa. Partindo de uma situação prática, como um Backlog de Sprint, as
tarefas podem ser cadastradas com o status a fazer, para que ao longo do ciclo de desenvolvimento o time
possa executar e concluir tais tarefas.
Na próxima figura, foram criadas algumas tarefas hipotéticas, para ilustrar o agrupamento destas tare-
fas de acordo com a situação atual destas, onde a medida que o time for selecionando as tarefas para o
desenvolvimento, elas são movidas para as colunas ou listas seguintes.
trello ([20--?])
Figura 137 - Interface Trello de uma lista com suas tarefas
Para cada tarefa cadastrada, a ferramenta proporciona algumas configurações, para que as tarefas pos-
sam ser classificadas e adicionadas informações para facilitar a visualização e gerenciamento.
Na figura que segue, é demonstrada a interface com as opções para adicionar membros de equipe, mar-
cações, listas de verificação, prazo para entrega da tarefa, anexos diversos, assim como podem ser inseridas
as ações de transição de listas, cópia da tarefa, assinatura e arquivamento, além do registro histórico de
atividades realizadas na tarefa.
191
trello ([20--?])
Figura 138 - Interface Trello para configuração da Tarefa
Existe também a funcionalidade para edição rápida da tarefa, como pode ser observado na próxima
figura, sem precisar alternar entre a interface do quadro e da configuração da tarefa, pois esta configuração
rápida é exibida na mesma interface do quadro, proporcionando mais desempenho e produtividade.
trello ([20--?])
Figura 139 - Interface Trello para configuração rápida da tarefa
Para ilustrar as tarefas que já sofreram transição entre as listas, são apresentadas as duas próximas fi-
guras, que respectivamente mostra a transição das tarefas 01 e 02 para a lista “Fazendo”, e na sequência a
transição das tarefas 01 e 02 para a lista “Feito” e as tarefas 03 e 04 para a lista “Fazendo”, enquanto a tarefa
05 permanece na lista “A fazer”.
192
trello ([20--?])
Figura 140 - Interface Trello com transição de tarefas
O uso da ferramenta é interativo, permitindo que as tarefas sejam “arrastadas” entre as listas existentes
do quadro, gerando facilidade no uso e de certa forma garantindo que o status das tarefas estejam cons-
tantemente atualizadas.
trello ([20--?])
Figura 141 - Interface Trello com transição de tarefas II
Até o momento, foram apresentadas a criação de quadro, listas e tarefas para uso pessoal, porém, na
prática, o maior uso da ferramenta é para equipes. Dessa forma, são necessários alguns passos adicionais
neste procedimento, para permitir o compartilhamento dos quadros, listas e tarefas.
Todas as ações necessárias para criar e configurar o ambiente para os quadros pessoais seguem o mes-
mo procedimento para os quadros de equipe, sendo diferente somente na associação de membros da
equipe aos quadros que serão compartilhados.
trello ([20--?])
Figura 142 - Menu para criar time na ferramenta Trello

193
Na figura anterior, é mostrada a opção para iniciar a criação de um novo time, clicando na área destacada
na figura mencionada. Será necessário informar um nome para o time e o mesmo estará pronto para ser
usado, da mesma forma que o uso pessoal, assim sendo, precisando criar um quadro.
trello ([20--?])
Figura 143 - Interface Trello para área de trabalho de Time
Na figura anterior, é ilustrada a área de trabalho do time “Kanban Time 1”, no qual possui o quadro
“Kanban”, e a partir de seu acesso serão exibidos as listas configuradas e as tarefas associadas, como já visto
anteriormente.
trello ([20--?])
Figura 144 - Interface Trello para associar membros ao Time
Na área de trabalho do time, também há o espaço para associar os membros do time, os quais terão
acesso aos quadros criados nesta área de trabalho e consequentemente às suas listas e tarefas.
No próximo tópico, será apresentada outra ferramenta para gestão de atividades que também possui
grande aderência do mercado e atende as necessidades das equipes que adotam métodos e técnicas de
desenvolvimento ágil.
194
CURIOSI O Trello tem como principais clientes as startups e empresas de médio porte, em
DADES razão da dinâmica de trabalho ágil presente nestes tipos de organizações.
9.2 GERENCIANDO ATIVIDADES COM O KANBANFLOW
O Kanbanflow é uma ferramenta em ascensão que se propõe a realizar o gerenciamento de tarefas,

sendo também baseada nos conceitos do método Kanban. Com esta referência, seu uso é simples, intuiti-
vo e também é capaz de integrar pessoas de uma mesma equipe, e gerir suas diferentes tarefas.
Acompanhe a seguir os passos para acessar e configurar a ferramenta, você irá perceber que será mais
uma opção para auxiliar nas suas futuras atividades profissionais.
A ferramenta de gestão de atividades Kanbanflow também é online, por isso para iniciar o uso desta
ferramenta será preciso acessar o site oficial da ferramenta, <https://kanbanflow.com>, onde será exibida
a interface do site, como demonstrado na figura que segue, sendo necessário clicar no botão “SIGN UP”,
kanban ([20--?])
Figura 145 - Interface inicial do site da ferramenta Kanbanflow
Na próxima figura, é ilustrado o primeiro e único passo para realizar o cadastro na ferramenta, sendo
necessário informar poucos dados, como o nome completo, email e senha de acesso à própria ferramen-
ta. Após inserir estes dados, é preciso clicar no botão “CREATE ACCOUNT” e automaticamente o acesso é
disponibilizado.
195
kanban ([20--?])
Figura 146 - Interface de cadastro da ferramenta Kanbanflow
Ao realizar o acesso pela primeira vez, a ferramenta já disponibiliza um quadro Kanban pronto com
quatro colunas, identificadas como “To-do”, ”Do Today”, “In Progress” e “Done”, como pode ser observado
na figura a seguir.
kanban ([20--?])
Figura 147 - Interface inicial do Kanbanflow

196
Este quadro inicial, entregue pela ferramenta, é identificado de “My first board”, e caso o usuário queira
usar este quadro inicial, o mesmo pode ser customizado, para convidar novos usuários ou membros, alte-
rar as colunas e demais configurações do quadro, como é ilustrado na figura que segue.
kanban ([20--?])
Figura 148 - Interface de configuração de quadro da ferramenta Kanbanflow
Na sequência, será demonstrada a edição das colunas deste quadro inicial, renomeando estas colunas
para a língua portuguesa, como pode ser observado na próxima figura.
kanban ([20--?])
Figura 149 - Interface de configuração de colunas do quadro

197
kanban ([20--?])
Figura 150 - Interface de configuração de uma coluna do quadro
Na figura anterior, são mostradas as opções de configuração da coluna, iniciando com o nome da colu-
na e demais opções e preferências, de acordo com a aplicação e processos da equipe de desenvolvimento,
que usará a ferramenta.
kanban ([20--?])
Figura 151 - Interface inicial do Kanbanflow editada

198
Após a edição das colunas da interface inicial da ferramenta, o resultado pode ser visualizado na figura
anterior, que a partir deste ponto estaria apto para uso, iniciando a inserção de tarefas em suas respectivas
colunas.
Para criar uma nova tarefa o procedimento é muito simples, basta clicar no botão “+”, presente em cada
coluna, ao lado do seu nome. A tarefa será associada à coluna em que for criada, mas poderá posteriormen-
te transitar entre as demais colunas presentes no quadro.
Nas duas figuras que seguem, são apresentadas as interfaces de cadastro de uma nova tarefa, onde reúne
as informações mais triviais, como o nome e descrição, assim como a cor da tarefa, simulando o uso de post-
its com diferentes cores, membros, tempo estimado, datas, sub tarefas, comentários, entre outras opções.
kanban ([20--?])
Figura 152 - Interface do Kanbanflow para cadastro de tarefa

199
kanban ([20--?])
Figura 153 - Interface do Kanbanflow para cadastro de tarefa II
Após criar a tarefa, esta é apresentada na sua respectiva coluna, representando um post-it em quadro
de kanban físico, o qual, igualmente, pode ser “arrastado” entre as colunas. kanban ([20--?])
Figura 154 - Tarefa cadastrada no quadro do Kanbanflow

200
Na próxima figura, pode ser observada a ação de transição da tarefa, assim como é demonstrado o
menu de configuração rápida da tarefa, proporcionando mais produtividade, pelo fato de não precisar
alternar entre diferentes interfaces.
kanban ([20--?])
Figura 155 - Menu de configuração rápida da tarefa no Kanbanflow
Para finalizar as possíveis transições, a tarefa é movida para a coluna “Feito”, na qual pode ser configura-
da para que a ferramenta arquive automaticamente a tarefa, quando for transitada para esta coluna, como
pode ser visto na figura que segue.
kanban ([20--?])
Figura 156 - Tarefa na coluna Feito do quadro no Kanbanflow

201
kanban ([20--?])
Figura 157 - Adição de novos usuários ao quadro do Kanbanflow
Até o momento, com as configurações e ações aplicadas ao quadro inicial do Kanbanflow, está restrita a
um único usuário, dessa forma, para usar a ferramenta para a gestão de atividades de uma equipe, é preci-
so adicionar novos usuários ao quadro, como é ilustrado nas duas figuras que seguem, ao enviar o convite.
kanban ([20--?])
Figura 158 - Envio de convite para o quadro do Kanbanflow
FIQUE Ao escolher uma ferramenta, é importante avaliar todos os seus recursos e possíveis
custos, pois uma mudança de ferramentas tende a baixar a produtividade da equipe
ALERTA durante sua curva de aprendizagem.
A ferramenta também disponibiliza a opção de criar novos quadros Kanban, com o procedimento que
será demonstrado a seguir. Este cadastro é iniciado pelo menu que é ilustrado na figura 160, clicando no
botão “Create board”.
202
kanban ([20--?])
Figura 159 - Menu para cadastro de novo quadro do Kanbanflow
Ao iniciar o cadastro, é apresentado a interface ilustrada na figura que segue, para inserir o nome do
novo quadro, que será cadastrado na ferramenta Kanbanflow. Para seguir com o cadastro é preciso clicar
no botão “Next”.
kanban ([20--?])
Figura 160 - Cadastro de novo quadro do Kanbanflow
No passo seguinte, serão definidas as colunas do novo quadro, onde a ferramenta sugere as mesmas co-
lunas do quadro inicial, nas quais podem ser editadas ou removidas, como pode ser visto na figura a seguir.
kanban ([20--?])
Figura 161 - Cadastro de novo quadro do Kanbanflow II

203
A seguir, é apresentada a configuração de arquivamento automático das tarefas, selecionando uma

coluna específica, onde ao transitar a tarefa para esta coluna, a ferramenta irá automaticamente encerrar a
demanda. Há também a opção para não associar qualquer coluna a esta opção de configuração, que pode
ser observada na próxima figura.
kanban ([20--?])
Figura 162 - Cadastro de novo quadro do Kanbanflow III
kanban ([20--?])
Figura 163 - Cadastro de novo quadro do Kanbanflow IV
No Kanban, há o conceito de limite de tarefas por status, para evitar que existam “gargalos” de
atividades em diferentes status, ou seja, este conceito busca um fluxo constante e equilibrado das tarefas
nas transições de seus status.
Na figura anterior é ilustrado a opção de configuração para cadastro deste limite, identificado como
WIP, sendo possível informar limites individuais por cada coluna do quadro.
Ao final do processo de cadastro do novo quadro, será possível encaminhar o convite para os membros
da equipe que realizará o trabalho nas tarefas cadastradas neste novo quadro, conforme ilustrado na figura
que segue.
204
kanban ([20--?])
Figura 164 - Cadastro de novo quadro do Kanbanflow V
A ferramenta Kanbanflow ainda apresenta outras funcionalidades mais específicas, que podem ser ex-
ploradas em seu estudo, para uso posterior em sua carreira profissional!
CASOS E RELATOS
Gerenciando Tarefas
No decorrer da realização de suas atividades, Joaquim que faz parte de uma equipe de desenvol-
vimento ágil, foi instruído a usar ferramentas de gerenciamento de tarefas, tendo em vista que ha-
viam muitas tarefas a serem executadas e também para garantir que essas tarefas estavam sendo
realizadas de acordo com a estimativa planejada.
Joaquim, em pouco tempo, percebeu a importância deste tipo de ferramenta e pôde dar visibili-
dade às suas atividades em andamento e concluídas, assim como conseguiu demonstrar o traba-
lho pendente, no planejamento do ciclo de desenvolvimento.
Com o conhecimento e uso deste simples sistema de gestão, Joaquim foi capaz de organizar suas
tarefas, aumentando a garantia de entrega frequente dos resultados de suas atividades, contri-
buindo para o bom desempenho da equipe.
Leia o “Recapitulando” a seguir e reveja o que foi estudado neste capítulo.

205
RECAPITULANDO
Neste capítulo foram apresentadas de forma prática o uso de importantes ferramentas para a ges-
tão de atividades, no processo de desenvolvimento de software.
Além das ferramentas, foram citados e reforçados conceitos como o uso do quadro Kanban, o WIP
e as práticas que proporcionam maior visibilidade e organização nas atividades planejadas.
Foram selecionadas duas ferramentas de grande aderência do mercado, sendo elas o Trello e o
Kanbanflow, nas quais foram demonstrados os procedimentos para obter acesso e realizar as con-
figurações fundamentais para iniciar o uso das ferramentas.
Este capítulo reforça a importância da preparação para o mercado de trabalho e do fato de obter
vantagens profissionais ao estar familiarizados à técnicas e ferramentas usadas pelas organizações.
Segurança do Trabalho
10
Neste capítulo você vai conhecer os conceitos básicos de Saúde e Segurança do Trabalho
(SST). Conhecerá também as maneiras de se evitar acidentes e o seu papel no cumprimento das
normas ambientais e de segurança. Aprenderá ainda sobre saúde ocupacional, meio ambiente
e sustentabilidade.
a) reconhecer situações de risco à saúde e segurança do trabalhador;
b) entender as normas de segurança do trabalho;
c) entender o conceito de saúde ocupacional;
d) reconhecer as normas ambientais.
208
10.1 SEGURANÇA DO TRABALHO
A segurança do trabalho é um conjunto de medidas tomadas para se evitar ou minimizar os acidentes

de trabalho, as doenças ocupacionais e também proteger a integridade física e a capacidade do trabalha-
dor em exercer sua função.
Dando sequência aos seus estudos sobre segurança no trabalho, você aprenderá acerca dos procedi-
mentos de segurança no trabalho e das normas regulamentadoras. Siga em frente!
10.1.1 PROCEDIMENTOS DE SEGURANÇA NO TRABALHO
As empresas podem elaborar os procedimentos básicos de segurança no trabalho. Tais procedimentos

podem variar de acordo com a atividade exercida. Normalmente, são escritos com base em normas padro-
nizadas de segurança no trabalho.
FIQUE Os procedimentos de segurança têm o objetivo de assegurar a integridade física dos

funcionários durante o exercício de suas atividades laborais, além de favorecer uma
ALERTA cultura de comportamento seguro.
Estes procedimentos podem fazer parte do regulamento interno e seu objetivo principal é o de dimi-
nuir os riscos de acidentes de trabalho ou doenças ocupacionais, garantindo uma melhor qualidade de
vida do trabalhador.
Os procedimentos de segurança podem ser escritos pela área de segurança do trabalho, pelo fabricante
de um equipamento – quando este for o instrumento de trabalho – ou por um especialista no processo em
que o trabalho está sendo executado.
O procedimento pode ser apresentado como uma simples checklist1 de atividades.
A seguir você irá aprender sobre as normas que regulamentam a proteção do trabalhador.
10.1.2 NORMAS DE SEGURANÇA DO TRABALHO
As normas de segurança do trabalho estabelecem procedimentos de segurança, visando garantir a se-

gurança do trabalho nas empresas e instituições.
1 É uma lista com várias atividades a serem executadas ou verificadas, como um procedimento operacional ou mesmo como um
manual de instruções.
10 SEGURANÇA DO TRABALHO
209
NORMAS REGULAMENTADORAS (NRS)
As NRs são elaboradas pelo Ministério do Trabalho (MTb). Essas normas foram criadas a fim de promo-
ver SST na empresa. Uma das principais funções das NRs é garantir o cumprimento da Consolidação das
Leis do Trabalho (CLT) e também detalhá-la.
Vamos conhecer a lista de normas?
Nº DA Nº DA
TEMA DA NR TEMA DA NR
NR NR
NR 1 Disposições Gerais NR 19 Explosivos
Segurança e Saúde no Trabalho com Inflamáveis e
NR 2 Inspeção Prévia NR 20
Combustíveis
NR 3 Embargo ou Interdição NR 21 Trabalho a Céu Aberto
Serviços Especializados em Engenharia de Seguran-
NR 4 NR 22 Segurança e Saúde Ocupacional na Mineração
ça e em Medicina do Trabalho
NR 5 Comissão Interna de Prevenção de Acidentes NR 23 Proteção contra Incêndios
Condições Sanitárias e de Conforto nos Locais de
NR 6 Equipamentos de Proteção Individual – EPIs NR 24
Trabalho
Programa de Controle Médico de Saúde Ocupacio-
NR 7 NR 25 Resíduos Industriais
nal – PCMSO
NR 8 Edificações NR 26 Sinalização de Segurança
Revogada pela Portaria GM nº 262, 29/05/2008 –
Programa de Prevenção de Riscos Ambientais –
NR 9 NR 27 Registro Profissional do Técnico de Segurança do
PPRA
Trabalho no MTb
Segurança em Instalações e Serviços em Eletricida-
NR 10 NR 28 Fiscalização e Penalidades
de
Transporte, Movimentação, Armazenagem e Manu-
NR 11 NR 29 Segurança e Saúde no Trabalho Portuário
seio de Materiais
Segurança no Trabalho em Máquinas e Equipamen-
NR 12 NR 30 Segurança e Saúde no Trabalho Aquaviário
tos
Segurança e Saúde no Trabalho na Agricultura, na
NR 13 Caldeiras, Vasos de Pressão e Tubulações NR 31 Pecuária, na Silvicultura, na Exploração Florestal e na
Aquicultura
Segurança e Saúde no Trabalho em Estabelecimen-
NR 14 Fornos NR 32
tos de Saúde
Segurança e Saúde no Trabalho em Espaços Confi-
NR 15 Atividades e Operações Insalubres NR 33
nados
Condições e Meio Ambiente de Trabalho na Indús-
NR 16 Atividades e Operações Perigosas NR 34
tria da Construção e Reparação Naval
NR 17 Ergonomia NR 35 Trabalho em Altura
Condições e Meio Ambiente de Trabalho na Indús- Segurança e Saúde no Trabalho em Empresas de
NR 18 NR 36
tria da Construção Abate e Processamento de Carnes e Derivados
Quadro 3 - Normas Regulamentadoras (NRs)
Fonte: Adaptado de MTb ([s.d.])
210
A NR 30 tem o Anexo I, que regulamenta a pesca comercial, e o Anexo II, que trata das plataformas e
instalações de apoio.
SAIBA O MTb mantém a lista das NRs atualizadas e publicadas em sua página da internet. As
normas estão disponíveis em: <http://trabalho.gov.br/seguranca-e-saude-no-traba-
MAIS lho/normatizacao/normas-regulamentadoras>. Acesso em: 23 nov. 2014.
A seguir você irá conhecer a OHSAS 18001. Acompanhe!
OHSAS 18001
A OHSAS 18001 é uma norma de caráter preventivo que visa à redução e ao controle dos riscos no am-
biente de trabalho seguindo a abordagem PDCA2.
A OHSAS 18001 estabelece os requisitos para Sistemas de Gestão da SST.
Veja os principais itens da norma que uma organização deverá atender, segundo o Portal Total Qualidade:
a) estabelecer uma política de SST;
b) identificar perigos, avaliação de riscos e determinação de medidas de controle;
c) atender à legislação de SST;
d) estabelecer objetivos e programas de SST;
e) definir recursos, responsabilidades e autoridade para as atividades ligadas à SST;
f) definir competência e treinamento necessários aos colaboradores;
g) estabelecer mecanismos para comunicação, participação e consulta a partes interessadas;
h) desenvolver e implementar a documentação do seu Sistema de Gestão de SST;
i) estabelecer controle de documentos e registros;
j) estabelecer métodos de controle operacional;
k) estabelecer métodos de resposta a emergências;
l) medir e monitorar o desempenho de SST;
m) estabelecer métodos para avaliar incidentes, não conformidades, ações corretivas e preventivas;
n) estabelecer um processo de auditoria interna e análises críticas pela direção.
2 Sigla em inglês que significa Plan, Do, Check, Act. Em tradução livre para o português: Planejar, Executar, Controlar, Agir. Ferra-
menta da qualidade utilizada para solução de problemas. Consiste em quatro fases distintas: Plan – planejar o trabalho, identifi-
car e medir o problema; Do – aplicar as medidas para eliminação do problema; Check – acompanhar os resultados das ações; Act
– trabalhar em medidas para corrigir desvios.
211
Você acabou de conhecer as normas que regulamentam e promovem a SST na empresa. Agora chegou
a hora de estudar sobre saúde ocupacional. Vamos lá?
10.2 SAÚDE OCUPACIONAL
Saúde ocupacional é uma área da saúde que cuida da saúde do trabalhador.

Essa área olha especialmente para a prevenção de doenças ou problemas que possam ser gerados pelo
trabalho, e seu objetivo é promover o bem-estar tanto físico quanto mental e social dos trabalhadores no
exercício de suas ocupações.
A saúde ocupacional não se limita apenas a cuidar das condições físicas do trabalhador, já que também
trata da questão psicológica. Para os empregadores, ela supõe um apoio ao aperfeiçoamento do funcioná-
rio e à conservação da sua capacidade de trabalho.
FIQUE Todas as empresas com mais de um funcionário têm a obrigação de manter um Pro-
ALERTA grama de Controle Médico de Saúde Ocupacional (PCMSO).
Este programa tem uma série de documentos padronizados para registro e acompanhamento da evo-
lução das condições físicas dos trabalhadores. Esses documentos devem ser elaborados por profissionais
competentes, pertencentes à empresa ou terceirizados.
Leandro Rosa (2018)
O PCMSO está presente na NR 7 e também é respaldado pela Convenção 161 da Organização Interna-
cional do Trabalho (OIT), respeitando os princípios éticos, morais e técnicos.
212
Você aprendeu sobre os agentes agressores e como combatê-los, não é mesmo?

Na sequência, poderá complementar seus conhecimentos sobre o tema, aprendendo sobre os riscos
ocupacionais e a exposição a esses riscos.
10.2.1 RISCOS OCUPACIONAIS
Os riscos ocupacionais são os perigos que incidem sobre a saúde humana. Neste caso, os riscos sobre
o trabalhador. Eles podem afetar o bem-estar dos trabalhadores que exercem determinadas profissões.
Embora sejam feitos esforços para minimizar estes riscos no trabalho, eles sempre continuaram pre-
sentes em todos os ramos de negócios, sejam eles administrativos, sejam industriais, comerciais e demais
ambientes profissionais.
Reconhecer os riscos ocupacionais é o primeiro passo para elaborar e implementar

FIQUE programas de segurança do trabalho e redução de riscos, em que o foco é manter a
ALERTA qualidade de vida dos trabalhadores, especialmente os que atuam em locais insalu-
bres, como na indústria de mineração ou no setor elétrico.
Além de todas as capacitações que o trabalhador recebe para trabalhar de forma segura, ele também
precisa ficar atento ao comportamento seguro. O comportamento seguro nada mais é do que a utilização
correta dos equipamentos e das ferramentas, seguir com atenção os procedimentos de segurança e agir
com cautela sempre que houver riscos.
Dando sequência aos seus estudos, você irá estudar sobre o meio ambiente e a sustentabilidade. Acom-
panhe!
10.3 MEIO AMBIENTE E SUSTENTABILIDADE
Com o passar do tempo, o ser humano se desenvolveu, fixou residência e começou a aumentar os
impactos de suas ações sobre o meio ambiente. Nesse processo de desenvolvimento foram construídas
cidades, criadas máquinas e o ser humano se tornou especialista em poluir.
Após muito tempo, a humanidade começou a entender que era preciso agir de formas mais sustentá-
veis3, em uma tentativa de proteger inclusive a vida humana. A seguir, você conhecerá um pouco mais
sobre algumas práticas e ações para que a sustentabilidade ambiental seja alcançada.
3 Vem do verbo sustentar, que significa manter, manter-se (SIGNIFICADOS, [s.d.]).

213
10.3.1 RESPONSABILIDADES SOCIOAMBIENTAIS
Nos últimos anos, a sociedade avançou quando o assunto é conscientização ambiental. No entanto,
apesar das inúmeras discussões sobre efeito estufa, reaproveitamento e reciclagem de materiais e uso
racional dos recursos, pouco se fala em responsabilidade socioambiental.
spukkato (2017)
O que você está fazendo para reduzir as emissões de poluentes? Está apagando a luz ao sair? Está sepa-
rando o lixo? Tem certeza de que o lixo separado está sendo coletado pela coleta seletiva de sua cidade?
CURIOSI Você sabia que a responsabilidade socioambiental nada mais é do que fazer a sua
parte? Inserir-se no processo e agir de forma correta, utilizando o mínimo possível
DADES dos recursos naturais.
Entretanto, depender das ações individuais pode não gerar os resultados esperados em curto prazo,
então é preciso investir em políticas públicas ambientais. E é esse o próximo tema de estudo. Acompanhe!
10.3.2 POLÍTICAS PÚBLICAS AMBIENTAIS
As políticas públicas são o conjunto de ações, programas e atividades desenvolvido pelo Estado. Essas
políticas envolvem entes públicos e privados e visam assegurar alguns direitos para a sociedade.
As políticas públicas ambientais servem para proteger o meio ambiente e fomentar o crescimento sus-
tentável, garantindo, assim, uma evolução da sociedade em harmonia com o meio ambiente.
214
São exemplos de políticas públicas ambientais:

a) processo de licenciamento ambiental para implantação de determinados tipos de atividades, obras
etc.;
b) o Conselho Nacional de Meio Ambiente (Conama) e suas resoluções, que criam padrões de qualidade
e controle da poluição do ar;
c) criação de áreas de proteção ambiental;
d) Política Nacional de Recursos Hídricos (PNRH).
Acordos internacionais de proteção ao meio ambiente servem de base para a elaboração de políticas
públicas.
Um exemplo de política pública ambiental é o Protocolo de Montreal, que é um acordo internacional
que visa à redução do uso de substâncias que destroem a camada de ozônio. O Brasil aderiu a esse tratado
em 1990, por meio de um decreto de lei com metas para eliminar o CFC (cloro-flúor-carbono) completa-
mente até 2010.
O Brasil é signatário de outro protocolo: o de Quioto. Este também discute políticas públicas para redu-
zir a emissão de gases de efeito estufa.
O Protocolo de Quioto é um acordo internacional criado no âmbito da Convenção-Qua-

dro das Nações Unidas sobre Mudanças Climáticas, aprovado na cidade de Quioto, no
Japão, em 1997, e que entrou em vigor em 16 de fevereiro de 2005. Seu principal obje-
tivo é estabilizar a emissão de gases de efeito estufa (GEE) na atmosfera e assim frear o
aquecimento global e seus possíveis impactos. Ao todo, 184 países ratificaram o tratado
até o momento (BRASIL, [201?]).
A INDÚSTRIA E O MEIO AMBIENTE
Você já ouviu falar em licença ambiental?

O licenciamento ambiental é obrigatório para a implantação de qualquer empreendimento ou ativi-
dade potencialmente poluidora, e é emitido pelos órgãos estaduais de meio ambiente e pelo Instituto
Brasileiro do Meio Ambiente e dos Recursos Naturais Renováveis (Ibama). Uma de suas características é a
participação social na tomada de decisão da sua liberação ou não, por meio de audiências públicas.
O objetivo do licenciamento ambiental é garantir que tal atividade possa ser realizada ou implantada
com o mínimo risco ambiental possível, bem como medidas de contenção desses riscos.
Um exemplo de exigência é a obrigatoriedade de manutenção de certa área de mata no terreno da
empresa para balancear a emissão de poluentes dessa empresa.
215
MrJub (2018)
As empresas brasileiras já estão cientes da necessidade de adotarem práticas de gestão ambiental. Já é
fato que grande parte dessas empresas está planejando o aumento de seu investimento nessas práticas.
RECAPITULANDO
Neste capítulo você aprendeu sobre aspectos da SST, estudou a importância de se conhecer as
normas que dizem respeito a ela, compreendeu o que é a saúde ocupacional e pôde reconhecer
como a aplicação das normas ambientais são importantes para a sociedade.
Gestão Organizacional
11
Neste capítulo você irá estudar os principais conceitos de gestão organizacional. Serão abor-
dados assuntos como trabalho em equipe e alguns fatores que tornam as equipes mais efica-
zes, planejamento estratégico, coordenação, estrutura e cultura organizacional, administração
de conflitos e hierarquia nas relações de trabalho.
a) compreender os conceitos de planejamento estratégico;
b) identificar a estrutura organizacional;
c) identificar a cultura organizacional;
d) reconhecer as hierarquias nas relações de trabalho;
e) compreender a importância do trabalho em equipe.
Você iniciará seus estudos conhecendo o conceito e a importância do planejamento estra-
tégico. Acompanhe!
218
11.1 CONCEITO E IMPORTÂNCIA DO PLANEJAMENTO ESTRATÉGICO
Planejar é antecipar os acontecimentos do futuro, é se preparar para a ação. Veja o conceito de Mint-
zberg (2000, p. 299): “planejamento é um processo formalizado para produzir e articular resultados na
forma de um sistema integrado de decisões”. Pode-se dizer, então, que o planejamento estratégico é o
planejamento das ações em todos os setores da empresa, com o intuito de alcançar seus objetivos.
Os resultados das decisões do processo de planejamento são os planos que registram (de forma geral-
mente escrita) as ações a serem implementadas.
O planejamento requer o envolvimento das pessoas de uma organização e o entendimento das neces-
sidades das diversas partes interessadas ou daquelas que influenciam, de uma forma ou de outra, as ações
e os resultados. É importante que ele seja flexível, adaptando-se às mudanças e à instabilidade do meio
ambiente em que está inserido.
O planejamento deverá permitir a autonomia dos responsáveis em sua execução, por meio da dele-
gação e do compartilhamento transparente e aberto das informações entre os envolvidos em ações de
complementaridade.
Assim, o planejamento estratégico deve permitir a ordenação do processo decisório para o futuro da
organização e convergir os esforços no alcance de objetivos, metas e resultados.
Ele define os objetivos de longo prazo, a maneira de alcançá-los e a forma de interagir e reagir às variá-
veis externas e internas da organização.
Portanto, o planejamento estratégico permite à organização definir o seu futuro por meio de um pro-
cesso planejado, estruturado e formalizado.
CURIOSI Você sabia que muitas empresas vão à falência por falta de estratégia definidas cor-
DADES retamente durante a construção do planejamento estratégico?
No Brasil, em torno de 700 mil empresas são abertas por ano, segundo dados do Instituto Brasileiro
de Geografia e Estatística (IBGE). Desse número, a cada dez organizações, seis fecham as portas antes de
completar cinco anos de existência. Com a crise dos últimos anos no nosso país, o tempo de sobrevivência
tem se tornado cada vez menor devido às dificuldades que o mercado competitivo tem proporcionado a
pequenas, médias e grandes empresas.
11 GESTÃO ORGANIZACIONAL
219
Violka08 (2014)
Um dos fatores que geram a falência de tantos empreendimentos é a falta de planejamento estra-
tégico. Muitas organizações, principalmente de pequeno porte, desvalorizam a relevância da adoção de
estratégias de organização e planejamento em curto, médio e longo prazos
Um dos desafios que os empresários enxergam é a dificuldade de iniciar o procedimento, por não sa-
berem quais passos adotar para iniciar o processo de planejamento estratégico do seu negócio. Então,
para que uma empresa não se torne mais uma estatística de falência, é de suma importância que haja bom
planejamento estratégico. É necessário, ainda, cumprir todas as etapas de implantação e acompanhar pe-
riodicamente se as estratégias traçadas estão alcançando os resultados desejados.
Para o desenvolvimento de um planejamento estratégico, é importante ter profissionais especializados
no assunto, consultores com experiência e gestores que auxiliem na definição dos horizontes da empresa.
No Brasil, é cada maior a preocupação das empresas em desenvolverem planejamen-

to estratégico. As Micro e Pequenas Empresas (MPEs) estão cada vez mais buscando
SAIBA mecanismos para traçar suas estratégias. Visite o site, a seguir, e confira mais detalhes
MAIS a respeito: <http://www.administradores.com.br/artigos/economia-e-financas/a-
-importancia-planejamento-estrategico-para-o-sucesso-das-micro-e-pequenas-em-
presas/50643/>.
Dando continuidade aos seus estudos, a seguir você irá estudar as estruturas hierárquicas, os sistemas
administrativos e a gestão organizacional. Siga em frente!
220
11.2 ESTRUTURA ORGANIZACIONAL
Quando se fala em estrutura organizacional de uma empresa, é preciso levar em consideração que exis-
tem empresas formais e informais. Você conhece as características de cada uma? Veja no quadro a seguir.
EMPRESA FORMAL EMPRESA INFORMAL

Chefia definida e conhecida Chefia indefinida e desconhecida
Processos definidos Sem processos indefinidos
Departamentos integrados Ninguém sabe o que acontece no outro departamento
Planejamento na tomada de decisão Tomada de decisão de última hora
Com controle definidos Sem controle definido
Estável Instável
Líder formal Líder formal
Com organograma Sem organograma
Dinâmica Estática
Estruturada Desestruturada
Organizada Não muito organizada
Quadro 4 - Diferenças entre empresa formal e informal
A empresa informal se dá pela união de pessoas com um objetivo comum. São procedimentos não do-
cumentados, e a hierarquia não é reconhecida oficialmente entre os membros da empresa.
A empresa formal é a mais adequada para se trabalhar, pois ela é organizada. Cada membro da empresa
tem sua função definida, a qual é conhecida por todos, e as decisões são planejadas.
Jirsak (2013)
As estruturas organizacionais mais utilizadas são a funcional, a divisional e a por produtos, mas a esco-
lha da estrutura dependerá dos objetivos da empresa, pois cada uma possui uma característica diferente.
Acompanhe as definições a seguir.
221
11.2.1 ESTRUTURAS HIERÁRQUICAS, SISTEMAS ADMINISTRATIVOS E GESTÃO ORGANIZACIONAL
A forma pela qual as empresas se organizam recebe uma representação gráfica, que apresenta a estru-
tura e a hierarquia dos cargos da empresa. Esse formato de representação demonstra as relações de poder
e as relações de responsabilidade entre as diversas áreas da empresa, pelas atividades do trabalho. A estru-
tura hierárquica pode ser classificada como vertical ou horizontal e tem como objetivo a coordenação das
atividades ao alcance do resultado esperado pela empresa.
Ou seja, a estrutura organizacional pode ser conceituada como a “forma pela qual as atividades de uma or-
ganização são divididas, organizadas e coordenadas” (STONER, 1992, p. 230). A partir dessa conceituação, ob-
serve as figuras que seguem para entender melhor os tipos vertical e horizontal das estruturas hierárquicas.
Exemplo Estrutura Hierárquica

Horizontal
Presidência
Assesoria
Dir. Marketing Dir. Financeira Dir. Recursos

Humanos
Exemplo Estrutura Hierárquica

Vertical
Nível 1 Presidência
Dir. Dir.
Nível 2 Financeira Marketing
Leandro Rosa (2018)
Gerência Gerência Gerência

Nível 3 Caixa Compras MKT
Figura 165 - Estruturas hierárquicas

Fonte: Fonte: Do autor (2018)
222
A informação e a comunicação são o que sustentam a estrutura da empresa; portanto, a falta delas
torna-se a maior vilã da hierarquia das empresas.
Para que as empresas mantenham sua estrutura organizada e íntegra, precisam utilizar normas que per-
mitam a ordem dentro delas. Os sistemas administrativos que têm esse objetivo permitem também uma
visualização objetiva “do todo” da empresa.
Os sistemas administrativos configuram as relações entre os diversos elementos da empresa, ou seja,
de que forma as informações e os recursos são processados e que tipos de resultados são obtidos por meio
deles. A figura a seguir mostra um exemplo de fluxo de informações e recursos que compõem um sistema
administrativo.
Objetivo
Razão pela qual o Sistema existe
Entrada Processamento Saída
Informação, Recursos Resultados
Retroalimentação
(nova informação)
Leandro Rosa (2018)

Figura 166 - Fluxo de informação no sistema administrativo
Esses sistemas podem ser abertos ou fechados, e a diferença envolve a forma pela qual a empresa se re-
laciona com o meio ambiente. Os sistemas administrativos abertos influenciam ou se mostram influencia-
dos pelo ambiente, e, por isso, quanto mais adaptados às mudanças de origem externa, mais desenvolvida
estará sua estrutura organizacional. Portanto, independentemente da sua área de atuação e do seu nível
hierárquico, é importante estar alerta ao ambiente de trabalho como um todo, pois ele pode influenciar o
seu dia a dia.
Todo sistema está diretamente relacionado ao ambiente, que, por sua vez, é dinâmico, e, por isso, está
em constante mudança. Sendo assim, o ambiente pode influenciar o sistema administrativo de forma po-
sitiva, como um recurso (ex.: avanço tecnológico), ou de forma negativa, como uma ameaça (ex.: aumento
da concorrência).
A gestão organizacional, por sua vez, objetiva planejar, organizar, executar, avaliar e monitorar o de-
sempenho de uma empresa visando à efetividade, à eficácia e à eficiência dos processos e das atividades.
Dois bons exemplos de gestão organizacional são:
223
a) melhoria do clima organizacional (um ambiente de trabalho bem avaliado pelos colaboradores);
b) ampliação dos resultados da empresa como um todo.
A gestão organizacional, que está focada no alcance dos objetivos, promove uma série de benefícios à
empresa, pois a orienta para os resultados e para a otimização na utilização dos recursos organizacionais.
A gestão organizacional apresenta-se, cada vez mais, como uma questão estratégica das organizações,
visto que a economia mundial é muito dinâmica. Em resumo, gestão significa gerenciar, administrar os
recursos de uma empresa que tem objetivos já estabelecidos, por meio do esforço humano organizado.
Dando continuidade aos seus estudos, a seguir você irá estudar sobre o trabalho em equipe.
11.3 TRABALHO EM EQUIPE
O trabalho em equipe é um grande aliado das empresas e há muito tempo se faz presente na maioria
das organizações. Principalmente com a grande inserção de programas de qualidade, esta forma coletiva
de trabalho voltou com muito mais força. Em vista disto, as empresas atualmente têm valorizado muito os
profissionais que sabem trabalhar em equipe.
De acordo com Ribeiro (2006), é possível apresentar quatro aspectos fundamentais que diferenciam
grupo e equipe. Veja a seguir:
DIFERENÇAS ENTRE GRUPO E EQUIPE
NO QUE SE REFERE GRUPO EQUIPE
Ao objetivo Apenas partilham as informações Preocupam-se com o desempenho coletivo e integrado

À sinergia Neutra ou negativa Positiva
À responsabilidade Por indivíduos e isolados Individuais e mútuas, coletivas e solidárias entre as pessoas
Utilizam as habilidades de seus com- Utilizam as habilidades de forma complementar, a fim de
Às habilidades
ponentes de forma aleatória e variada realizar as atividades de maneira coesa e integrada
Quadro 5 - Diferenças entre grupo e equipe
Para que uma equipe possa ser considerada eficaz, há alguns fatores que precisam de atenção, como:
a) os objetivos e as metas, bem como a missão e os valores, precisam estar bem definidos e bem claros
para todos os integrantes;
b) o respeito à individualidade deve ser valorizado, pois as equipes são formadas por pessoas diferentes;
c) os papéis e as responsabilidades de cada integrante precisam ser conhecidos e compreendidos, afinal,
se cada um não tiver entendimento da sua parte, haverá dificuldade no alcance do objetivo comum;
224
d) o reconhecimento e a motivação são fatores fundamentais;

e) o acompanhamento e o monitoramento das atividades, bem como a avaliação dos resultados e a
realização de feedback, são muito importantes para que os integrantes tenham a consciência da evo-
lução de seu desempenho e o que ainda precisa ser melhorado.
Agora que você já conhece o trabalho em equipe, confira, no próximo tópico, o relacionamento com os
colegas de equipe.
11.3.1 O RELACIONAMENTO COM OS COLEGAS DE EQUIPE
Como a maior parte do trabalho nunca é feita de forma isolada, é importante que os membros da equi-
pe reconheçam as interdependências das tarefas, como já foi mencionado anteriormente, pelo fato de
intensificar o desempenho e o desenvolvimento individual.
A união das equipes encontra-se exatamente nas diferenças individuais relevantes ao trabalho, e que,
somadas, tornam a equipe muito mais forte. Nota-se que colaboradores que estão comprometidos com
seus colegas de trabalho e mostram-se dispostos a ajudar quando necessário, colocando muitas vezes as
necessidades dos demais à frente das suas, demonstram atitudes e comportamentos facilmente identifica-
dos em equipes de alto desempenho.
scyther5 (2017)
Equipes de trabalho serão mais eficazes quanto maior for o respeito entre os integrantes e a capacidade
de entendimento das individualidades, no que tange à construção do trabalho.
O mais importante de ressaltar é que essas atitudes e esses comportamentos podem vir a ser desen-
volvidos, principalmente quando apoiados e incentivados pela liderança. Sendo assim, o relacionamento
entre os colegas de equipe é fortalecido quando:
225
a) há partilha de ideais e expectativas em relação ao trabalho;

b) há visualização da interdependência das tarefas de todos os integrantes da equipe;
c) há separação e negociação dos conflitos.
Finalmente, é importante destacar que leva um tempo para se construir um relacionamento entre co-
legas de equipe, mas ele é fundamental para que haja eficácia na busca pelos resultados coletivos. Afinal,
confiança é algo que se conquista.
CASOS E RELATOS
Contratado por técnicas, demitido por comportamento

Uma empresa multinacional abriu um processo seletivo para o cargo de gerente administrativo,
com um salário de aproximadamente R$ 12.000,00. Só no primeiro dia após a abertura da vaga
já existiam 800 pessoas inscritas. Após 15 dias o processo foi encerrado e iniciou-se a etapa de
classificação. A vaga era muito disputada; exigia-se especialização, inglês fluente, conhecimen-
to avançado de ferramentas de informática, conhecimentos de ferramentas da qualidade e até
experiência no exterior, aliada a cinco anos de experiência na função. Depois de várias etapas de
seleção o aprovado foi Robert, que possuía todos os requisitos da vaga e mais um mestrado em
gestão. Transcorridos três meses os subordinados de Robert começaram a reclamar dele, e entre
as reclamações sempre aparecia a falta de respeito com seus colegas. Ele os xingava, os ofendia
utilizando o poder e, quando questionado, retrucava ao seu superior. Diante disso tudo, a compa-
nhia decidiu demiti-lo por mau comportamento e por falta de habilidade de se relacionar com as
pessoas.
Você irá estudar, a seguir, as responsabilidades individuais e coletivas. Acompanhe!
11.3.2 RESPONSABILIDADES INDIVIDUAIS E COLETIVAS: A DIVISÃO DE PAPÉIS E

RESPONSABILIDADES
As equipes tendem a ser mais bem-sucedidas quando todos os participantes têm suas responsabili-
dades bem definidas. Muitas vezes a divisão da responsabilidade dentro da equipe é função exclusiva do
líder, mas se todos os participantes sentirem essa obrigação frente ao coletivo, as tarefas certamente serão
melhor encaminhadas e desempenhadas.
Mas e as responsabilidades? Como defini-las e dividi-las?
226
Que tal conferir a definição da palavra segundo o dicionário de português Michaelis On-line (2009) an-
tes de seguir em frente?
sf (responsável+i+dade) 1 Qualidade de responsável. 2 Dir Dever jurídico de responder

pelos próprios atos e os de outrem, sempre que estes atos violem os direitos de tercei-
ros, protegidos por lei, e de reparar os danos causados. 3 O dever de dar conta de algu-
ma coisa que se fez ou mandou fazer, por ordem pública ou particular. 4 Imposição legal
ou moral de reparar ou satisfazer qualquer dano ou perda.
A responsabilidade, se depositada em apenas uma única pessoa, sobrecarrega-a e impede que o talen-
to dos demais integrantes seja utilizado. Por isso é importante que os papéis e as responsabilidades sejam
distribuídos e claros, afinal a principal razão para a constituição de uma equipe é a oportunidade de aplicar
as diferentes competências, os conhecimentos e as habilidades no local de trabalho.
yands (2014)
Na construção de uma equipe, entende-se que cada um dos integrantes vai desempenhar um papel; por-
tanto, é conveniente que as competências específicas sejam direcionadas ao objetivo central do grupo. Além
das competências técnicas, imprescindíveis para o bom desempenho das tarefas, existem as competências
pessoais, aquelas que todos os integrantes devem possuir (como ética, respeito, integridade, atitude).
Portanto, a fim de alcançar os resultados, os integrantes de uma equipe devem aprender a conduzir as
capacidades e experiências individuais à superação das metas coletivas.
227
11.3.3 MOTIVAÇÃO
A motivação é uma grande impulsionadora da ação. A motivação aflora a criatividade, o entusiasmo e

a capacidade de realização.
Você se considera uma pessoa motivada? Como você se mostra ao acordar? É daqueles que já abre um
sorriso e deseja bom dia para todos à sua volta ou talvez aquele que acorda mal-humorado e não quer
conversar com ninguém?
As pessoas motivadas são realizadoras, gostam de desafios e parecem sempre estar felizes. Diante dos
desafios, não importa se grandes ou pequenos, este tipo de pessoa sempre comemorará como uma vitória.
Você já parou para avaliar a motivação das pessoas à sua volta? Que tal ser um agente de motivação na
sua empresa? Pois com um simples sorriso o seu ambiente de trabalho pode transformar-se em um lugar
muito melhor para se trabalhar.
É possível citar alguns fatores que podem motivar os empregados: ambiente de trabalho, salário,
reconhecimento profissional, clima organizacional, desafios criativos, aprendizagem.
Muitas vezes pequenos gestos podem ser capazes de motivar muito além do que supostamente se ima-
ginava. Receber um elogio e a oportunidade de ajudar uma pessoa são dois exemplos que podem ocorrer
no seu dia a dia e mudar o rumo da sua motivação.
FIQUE Existem fatores que podem agir no sentido inverso e desmotivar os empregados,
como, por exemplo: discriminação, preconceito, desorganização, instabilidade pro-
ALERTA fissional.
A origem da motivação dos indivíduos pode ser encontrada nos seus próprios valores. Pensamentos,
comportamentos e sentimentos positivos tendem a melhorar o dia de qualquer pessoa.
11.3.4 COMPROMISSO COM OBJETIVOS E METAS
Embora cada integrante da equipe esteja com seu papel e suas responsabilidades bem definidos, é
preciso que cada um esteja disposto a assumir as atividades de todos, pois dessa forma torna-se possível o
alcance das metas comuns de desempenho.
Quando a equipe possui objetivos comuns, haverá entre os integrantes um sentimento de compro-
misso, afinal são todos parte de um todo, em que a participação de cada um destina-se ao sucesso da
coletividade.
228
Para que a equipe atinja sua meta, faz-se necessário que todos se prontifiquem a auxiliar os que tive-
rem mais dificuldade, afinal ninguém precisa receber crédito pessoal por seus esforços. Pelo contrário, em
equipes de alto desempenho o esforço individual é visto como benefício para todo o time, e, por definição,
para si próprio. Assim, todos colhem os frutos.
11.3.5 COOPERAÇÃO
Você ouviu falar muito de cooperação nos últimos tópicos, mesmo que de forma intrínseca a outros
conceitos.
Nos dias atuais tornou-se essencial, para o melhor desempenho das empresas, o trabalho em equipe. E,
para que os resultados esperados sejam totalmente atingidos pela equipe, a interação entre os integrantes
é elemento fundamental.
Nem sempre é fácil lidar com seres humanos, pois muitas vezes a imposição do modo de pensar por al-
guns e o compartilhamento de ideais limitado, entre outros vários fatores, podem comprometer o trabalho.
O grande desafio é fazer com que a cooperação aconteça mesmo em equipes que possuam integrantes
com pensamentos diversos. A cooperação é fator primordial das equipes de alto desempenho.
Dessa forma, para que o respeito e a paciência sejam estimulados em todos os componentes da equipe,
veja, a seguir, uma lista de alguns fatores que contribuem com a cooperação:
a) compreenda que o objetivo da equipe é comum e que vaidades pessoais não devem ser colocadas
em evidência;
b) seja um bom ouvinte, evitando uma má interpretação dos fatos;
c) demonstre humildade, entendendo que outros integrantes podem apresentar ideias melhores do
que as suas;
d) tenha espírito cooperativo.
Quando se fala em cooperação, logo se pensa em uma forma de ação impossível de ser praticada so-
zinha, afinal cooperar indica uma ação colaborativa para com alguém. Ou seja, indica uma forma de agir
coletivamente, e, por isso, é para ser praticada em um grupo que objetiva um resultado comum.
229
AndreyPopov (2013)
Muitos fatores motivam as pessoas a cooperarem, principalmente a sua consciência social. Você é capaz
de se preocupar com o outro porque isso o faz se sentir bem. A cooperação é essencial para qualquer am-
biente de trabalho. Ou seja, como coloca Castiglioni (2011), colaborar traz a ideia de trabalho em equipe e
a soma dos conhecimentos individuais aplicados resulta em produtividade.
Você vai estudar, a seguir, os conflitos nas equipes de trabalho. Confira!
11.4 CONFLITOS NAS EQUIPES DE TRABALHO
Nos dias de hoje, as pessoas parecem mais estressadas do que nunca. Até mesmo quando tudo aparenta
estar nos conformes, parece que existe um pensamento negativo que tenta provar que algo pode dar errado.
Dentro do ambiente de trabalho, parece que tudo se amplifica. Muitas vezes as pessoas parecem estar
à beira de um ataque de nervos por conta de suas metas e de seus prazos. Algumas fontes de estresse do
ambiente organizacional são:
a) ambiguidade do cargo;
b) trabalho inacabado;
c) expectativas mal definidas quanto à função.
230
À medida que o mundo se tornou mais globalizado e a concorrência mais acirrada, os ganhos de pro-
dutividade em prazos cada vez menores têm intensificado os inevitáveis atritos nas organizações. Cola-
boradores divergem por diversos motivos, entre eles: como organizar as atividades, quem deve tomar as
decisões, quando modificar as estratégias para a consecução dos objetivos.
Entretanto, não pense você que esses “atritos” são apenas de cunho negativo, eles podem ser uma força
positiva para a organização que souber gerenciá-los. Mas é claro que, dentro do ambiente de trabalho, em
todos os níveis da organização, os gerentes empenham-se para minimizá-los.
Além dos conflitos que ocorrem nas equipes de trabalho, existem os conflitos internos, os chamados
intrapessoais. Lewin (1935) identificou três tipos de conflitos intrapessoais:
a) aqueles que ocorrem quando é preciso escolher entre dois resultados ou cursos de ação desejáveis
(ex.: uma seleção de candidatos, em que tem que se escolher apenas um);
b) quando se percebe que determinado objetivo ou resultado tem consequências tanto positivas quan-
to negativas (ex.: assumir um novo emprego por questões de remuneração, mas abandonar o antigo,
no qual que já tinha conquistado estabilidade);
c) quando é preciso escolher entre dois resultados ou curso de ação negativos.
FIQUE O conflito intrapessoal gera desconforto, e viver sob essa confusão e angústia pode
ALERTA vir a atrapalhar o desempenho profissional.
Tjosvold (1993) lembra que a premissa de que os conflitos surgem em decorrência de interesses ou
objetivos antagônicos é verdadeira apenas em parte, e que, com mais frequência, eles se devem à inter-
dependência, ou seja, os confrontos ocorrem não porque dois departamentos ou unidades de trabalho
têm interesses ou metas de longo prazo incompatíveis, mas porque discordam quanto ao caminho ou aos
meios para atingi-los, e, sobretudo, um não pode fazê-lo sem o outro.
Algumas questões que permeiam o indivíduo, como atitudes, valores, crenças, podem ser as causas de
conflitos dentro das equipes de trabalho. Uma má comunicação entre as partes envolvidas, a diversidade
cultural dos integrantes, os erros de percepção e de interpretação são alguns exemplos do que pode ser a
faísca para os mencionados atritos.
231
roberthyrons (2012)
Você vai conhecer, de forma um pouco mais específica, os tipos, as características e as causas desses
conflitos, até porque o objetivo final será minimizá-los no seu ambiente de trabalho.
11.4.1 TIPOS, CARACTERÍSTICAS E CAUSAS
É possível destacar alguns fatores que são comuns aos conflitos nas equipes de trabalho, como estresse,
pouca cooperação e falta de união. Quando estes não são gerenciados, é preciso que entre em ação uma so-
lução rápida e eficiente, para que eles não desestruturem a equipe. É importante ressaltar que fugir do con-
flito não é uma solução, pois ignorar um problema poderá causar efeitos negativos graves à organização.
As possíveis causas dos conflitos podem ser:
a) frustação: de um ou mais integrantes que compõem a equipe;
b) incapacidade de alcance da meta: por algum tipo de interferência comportamental, técnica ou
limitação pessoal;
c) personalidade: diferenças na personalidade dos integrantes da equipe que são reveladas no desen-
volvimento das atividades, por meio de características desagradáveis de algum integrante;
d) metas pessoais: divergência de metas entre os integrantes, podendo gerar tensões no desenvolvi-
mento das ações;
e) percepções: interpretação e percepção das informações de forma muito distinta pelos participantes
que interagem em uma mesma equipe.
232
É possível, ainda, discutir sobre alguns níveis que esses conflitos podem tomar. Iniciam por uma breve
discussão, entram em debate mais profundo, partem para a falta de confiança, uma imagem imutável é
estabelecida, a falta de humanidade entra em ação e um possível ataque pode vir a ocorrer. Entretanto,
volto a lembrar: quando o conflito é reconhecido e ações corretivas são brevemente iniciadas, este pode
ser solucionado e transformado em uma forma positiva de mudar alguns hábitos e estimular ainda mais a
busca por resultados.
A identificação de conflitos pode auxiliar a detectar a forma mais pertinente para administrá-lo. Portan-
to, você conhecerá, a seguir, os tipos de conflitos que podem surgir na sua equipe de trabalho.
Conflito latente
Não declarado, não há consciência de sua existência, talvez não precise ser imediatamente trabalhado.
Conflito percebido
O conflito é racionalmente percebido, mas não existe expressão clara dele.
Conflito sentido
Declarado, atinge os integrantes que se mostram emotivos.
Conflito manifesto
Totalmente declarado e percebido não só interna, mas externamente, podendo interferir na rotina da
organização. gmast3r (2018)
Para que a negociação desses conflitos possa ocorrer e eles possam ser solucionados de forma eficaz,
é preciso que todos os integrantes da equipe engajem-se e esforcem-se em: melhorar a atmosfera, escla-
233
recer as percepções, olhar para o futuro (levando em conta as lições aprendidas no passado), promover
opções de ganho mútuo, estabelecer acordos com benefícios recíprocos. Ou seja, você deve sempre esti-
mular em sua equipe:
a) o saber ouvir;
b) o saber comunicar;
c) o saber perguntar;
d) a colaboração;
e) o compromisso.
As consequências dos conflitos nas equipes de trabalho muitas vezes vão além do próprio ambiente,
refletindo em posturas agressivas por parte dos integrantes e afetando sobremaneira o desempenho da
equipe como um todo. Isto é, pode haver um comprometimento da estrutura da equipe, o que irá impedir
que os objetivos a ela destinados sejam alcançados.
Pode-se dizer que a principal consequência dos conflitos nas equipes de trabalho é o desperdício de
tempo e o desvio das atenções.
Cabe lembrar que costumeiramente são dessas situações de conflitos que nascem as grandes e não
pensadas oportunidades. Portanto, desenvolva o hábito de ouvir mais atentamente os seus colegas de
equipe, promovendo o hábito do respeito.
11.5 A RELAÇÃO COM O LÍDER
O líder é aquele que influencia o outro, no sentido de mudar comportamento, fazendo com que o inte-
grante da equipe empenhe-se em alcançar os objetivos determinados.
A liderança nada mais é do que a aptidão de conduzir pessoas a atingir os resultados almejados. Profis-
sionais que tenham características de um líder, com habilidades para acompanhar, delegar, inspirar e mobi-
lizar colaboradores na busca por resultados com qualidade, são cada vez mais requisitados pelo mercado.
11.5.1 ESTILOS DE LIDERANÇA
Entre os vários estilos de liderança, você vai conhecer três: a democrática, a centralizadora e a liberal.
O LÍDER DEMOCRÁTICO
Este estilo de liderança é participativo. Cria-se um ambiente em que as decisões são compartilhadas. As
características deste líder assemelham-se à de uma liderança ideal: que conduz, delega e acompanha as
atividades de todos os integrantes da equipe. Dessa forma, esse líder estimula a autonomia e a confiança
de seus liderados.
234
O LÍDER CENTRALIZADOR
As decisões são centralizadas na figura do líder e não há qualquer participação dos demais colabora-
dores. Este estilo de liderança costuma estar focado no ego do líder, e por vezes humilha os subordinados.
Dessa forma, a presença do líder muitas vezes causa desconforto geral, e não há valorização das qualida-
des, dos conhecimentos e das habilidades dos colaboradores.
O LÍDER LIBERAL
É o estilo de liderança menos influente, pois dá aos integrantes da equipe mais liberdade na execução
de suas tarefas e no gerenciamento de seus resultados. Dessa forma, este líder precisa estar atento para
que os integrantes da equipe não fiquem sem um rumo e venham a cometer falhas de percurso.
11.5.2 PAPÉIS DO LÍDER
Liderar é diferente de gerenciar. E, por isso, o líder tem um papel fundamental de aceitar e encorajar as
diferenças, a fim de que cada um possa dar o melhor de si. Além de executar as funções que são exclusivas
a ele, o líder deve concentrar-se em desenvolver as pessoas da sua equipe.
monkeybusinessimages ([20--?])
Um líder atento e participativo é capaz de identificar e intensificar os potenciais dos integrantes de sua
equipe, otimizando os resultados de todo o grupo. Consequentemente, a equipe torna-se mais participa-
tiva e contribui de maneira mais eficiente.
A seguir, observe algumas características e responsabilidades do líder:
235
a) estabelecer metas coerentes e válidas;

b) estimular e obter o comprometimento de todos os integrantes;
c) aceitar e fazer jus às responsabilidades;
d) apoiar e assistir os subordinados;
e) tomar decisões;
f) estimular a comunicação.
Frente a essas responsabilidades, é importante que o líder saiba se comunicar. E essa comunicação irá,
muitas vezes, apresentar tanto sugestões quanto críticas.
11.5.3 AUTONOMIA NAS EQUIPES DE TRABALHO
O conceito de autonomia dentro das equipes de trabalho está diretamente relacionado ao de liderança,
visto que permite aos integrantes da equipe a tomada de decisão, mas claro que baseada nas informações
fornecidas pelo líder, aumentando a responsabilidade e a participação de cada um no contexto geral.
Muitos líderes não se sentem à vontade em conceder mais autonomia para os integrantes das suas
equipes, porque sentem que estão perdendo o controle e o poder. Mas o que vale ser destacado, neste
momento, é que essa autonomia valoriza os integrantes da equipe e tende a melhorar a condução das
atividades do grupo, o que inclui o aumento da satisfação e da motivação de todos, a taxa de retenção de
talentos, o compartilhamento das responsabilidades, bem como promove maior agilidade.
Dentro das equipes de trabalho é importante que fique claro até onde vai a sua autonomia, para que,
assim, a liderança seja saudável e não haja retrabalho. Por exemplo, caso o seu líder não saiba responder a
um questionamento seu, é preciso respeitar que é o líder que vai se dirigir ao superior para encaminhar o
questionamento.
Vale destacar que a responsabilidade e o nível de autonomia variam de equipes para equipes, mas esse
nível (integrante, líder, superior) deve ser respeitado para que ninguém interfira nas atividades do outro.
Respeito é a chave da boa convivência.
11.5.4 AJUSTES INTERPESSOAIS E COOPERAÇÃO
É preciso que você pense nos ajustes interpessoais como um relógio. Esta máquina funciona porque
todas as suas engrenagens estão ajustadas e sincronizadas. Da mesma forma, isso é válido para o trabalho
em equipe.
Todos em uma equipe, portanto, precisam estar alinhados, como você veio observando até aqui. E a
comunicação é, sem dúvida, a ferramenta mais importante. A equipe necessita de uma comunicação es-
clarecedora, para que o trabalho seja desenvolvido em harmonia. Para se ter um bom trabalho em equipe,
leve em consideração:
236
a) a paciência;
b) as ideias dos outros;
c) um trabalho participativo e solidário;
d) o diálogo;
e) o planejamento.
Em resumo, espero que você tenha compreendido, nos seus estudos até aqui, que o trabalho em equi-
pe é um conjunto de pessoas que buscam objetivos comuns por meio de metas bem definidas. O respeito
é, sem dúvida, um dos princípios da equipe, e a interdependência entre os integrantes irá favorecer não só
os resultados do próprio grupo como os da organização como um todo.
11.5.5 AVALIAÇÃO DE DESEMPENHO
A avaliação de desempenho é uma importante ferramenta utilizada na gestão de pessoas. Seu objetivo
é analisar o desempenho individual ou de uma equipe de trabalho. A partir dessa avaliação, é possível ver
se a postura do funcionário ou da equipe está de acordo com a cultura da empresa.
A avaliação de desempenho pode ser feita quando o gestor considerar necessário, mas o ideal é que ela
seja realizada mensalmente, para que seja possível analisar a evolução do funcionário e da equipe.
Reveja os principais conceitos estudados deste capítulo lendo o “Recapitulando” a seguir.
RECAPITULANDO
Neste capítulo você estudou sobre planejamento estratégico e estrutura organizacional, pôde
compreender o que é e a importância do trabalho em equipe e aprendeu ainda o que é liderança
e quais são os tipos de líderes.
237
REFERÊNCIAS
ARAÚJO, Everton Coimbra de. Orientação a objetos com java: simples, fácil e eficiente.
Florianópolis: Visual Books, 2008. 186 p. ISBN 9788575022269.
BARBOSA FILHO, Antonio Nunes. Segurança do trabalho & gestão ambiental. 4. ed. São Paulo
(SP): Atlas, 2011. 378 p.
BARMES, David J.; KÖLLING, Michael. Programação orientada a objetos com Java: uma
introdução prática usando o Blue J. São Paulo (SP): Pearson Education do Brasil, 2004. xxviii, 368 p.
+ CD-ROM ISBN 8576050129.
BERNARDI, Ricardo. Vantagens de programar com orientação a objetos (OOP). 2012. Disponível
em: <http://dev.rbtech.info/vantagens-de-programar-com-orientacao-a-objetos-oop/>. Acesso
em: 01 jul de 2017.
BRASIL. Ministério do Trabalho. Normas Reguladoras. Disponível em: <http://portal.mte.gov.br/
legislacao/normas-regulamentadoras-1.htm>. Acesso em: 02 abr 2015.
______. Portal Brasil. Saiba mais sobre o Protocolo de Quioto. Disponível em: <http:// www.
brasil.gov.br/meio-ambiente/2010/11/protocolo-de-quioto> Acesso em: 29 nov. 2014.
COSTA, Marco Antonio F. da; COSTA, Maria de Fátima Barrozo da. Segurança e saúde no trabalho:
cidadania, competitividade e produtividade. Rio de Janeiro (RJ): Qualitymark, 2005c. 195 p.
FUSTIER, Michel. O conflito na empresa. São Paulo: L. Martins Fontes, 1982.
GASPAROTTO, Henrique Machado. Os 4 pilares da Programação Orientada a Objetos. 2014.
Disponível em: <https://www.devmedia.com.br/os-4-pilares-da-programacao-orientada-a-
objetos/9264>. Acesso em: 01 jul de 2017.
ISTQB. Certified Tester: Foundation Level Syllabus, 77p.
JUNGTHON, Gustavo; GOULART, Cristian Machado. Paradigmas de Programação. Taquara (RS):
Faculdade de Informática de Taquara, 8p.
LEAL, L., R., Pedro J. Requisitos de Métodos de Rastreabilidade entre os Requisitos e o Código
de Software. Belo Horizonte (MG): Universidade Federal de Minas Gerais, 6p.
MCLAUGHLIN, Brett; POLLICE, Gary; WEST, David. Use a cabeça! análise e projeto orientado ao
objeto. Rio de Janeiro (RJ): Alta Books, 2007. 442 p. (Use a cabeça!). ISBN 9788576081456.
MINTZBERG, H. O processo da estratégia. São Paulo: Bookman, 2000.
MULLER, Nicolas. Qual a diferença entre programação estruturada e programação orientada
a objetos? 2015. Disponível em: < https://www.oficinadanet.com.br/post/14463-qual-a-diferenca-
entre-programacao-estruturada-e-programacao-orientada-a-objetos>. Acesso em: 20 ago de 2017.
OLIVEIRA, Djalma de Pinho Rebouças de. Planejamento Estratégico - Conceitos Metodologia e
Práticas. São Paulo: Atlas, 1999.
PINHO, Márcio Sarroglia. Introdução à Linguagem C. Disponível em: <http://www.inf.pucrs.
br/~pinho/LaproI/IntroC/IntroC.htm>. Acesso em: 20 ago de 2017.
PINHO, Márcio Sarroglia. Subalgoritmos (Funções). Disponível em: < http://www.inf.pucrs.
br/~pinho/LaproI/Funcoes/AulaDeFuncoes.htm>. Acesso em: 20 ago de 2017.
SANTOS, Igor Abílio Santana. Programação Orientada a Objetos versus Programação
Estruturada. 2015. Disponível em: <https://www.devmedia.com.br/programacao-orientada-a-
objetos-versus-programacao-estruturada/32813>. Acesso em: 20 ago de 2017.
SCHWABER, Ken; SUTHERLAND, Jeff. Um guia definitivo para o Scrum: As regras do jogo, 19p.
TAFNER, Malcon Anderson; CORREIA, Carlos Henrique. Análise orientada a objetos. Florianópolis:
Visual Books, 2001. 112 p. ISBN 8575020250.
TURINI, Rodrigo. Explorando APIs e bibliotecas Java: JDBC, IO, Threads, Java FX e mais. São Paulo
(SP): Casa do Código, 2017. 195 p. ISBN 978-85-5519-049-0.
WAZLAWICK, Raul Sidnei. Análise e projeto de sistemas de informação orientados a objetos.
2. ed. Rio de Janeiro (RJ): Elsevier, 2011. 330 p. (Sociedade brasileira de computação). ISBN
9788535239164.
YOURDON, Edward; ARGILA, Carl. Análise e projeto orientados a objetos: estudos de casos. São
Paulo (SP): Makron Books do Brasil, 1999. 328 p. ISBN 8534609756.
MINICURRÍCULO DOS AUTORES
EVANDRO MEDEIROS MARQUES

Evandro Medeiros Marques tem formação em Engenharia de Produção e Sistemas e 15 anos de
experiência em atividades industriais. É especialista em estratégias de redução de custos ligadas
à diminuição de desperdícios nos processos fabris, englobando a padronização de atividades la-
borais, a conservação de equipamentos e o desenho de sistemas logísticos enxutos.
THIAGO ROBERTO MENDES

Thiago Roberto Mendes é pós-graduando em Engenharia de Projeto de Software pela Universi-
dade do Sul de Santa Catarina (Unisul), graduado em Gerenciamento de Redes de Computadores
pelo Instituto de Ensino Superior da Grande Florianópolis (IES) e técnico em Telecomunicações
com ênfase em Redes de Computadores pelo Instituto Federal de Santa Catarina (IFSC), certifica-
do em gerenciamento de serviços de TI ITIL V3, certificado em governança de TI COBIT 4.1 e certi-
ficado em teste de software CTFL. No SENAI/SC, em Florianópolis, atua como professor do curso
superior de Análise de Sistemas. Ao longo dos anos, atuou como analista de rede e infraestrutura
na empresa Cianet Networking, envolvendo atividades relacionadas a tecnologias e meios de
transmissão de dados e VoIP. Atualmente, também atua como analista de sistemas na empresa
Softplan/Poligraph.
ÍNDICE
A
Abstração, 5, 11, 18, 19, 20, 22, 23, 24, 28, 29, 32
API, 40, 48, 53, 75, 112, 145
Atributos, 19, 20, 21, 22, 23, 24, 25, 29, 35, 54, 71, 78, 116, 117, 118, 120, 121, 125, 127, 128, 129,
130, 146, 149
Atributos estáticos, 146
B
Backlog, 8, 168, 169, 170, 172, 173, 175, 176, 177, 178, 180, 181, 190
Branch, 6, 85, 93, 94
Bytecode, 124
C
Classe, 5, 6, 7, 11, 17, 19, 21, 22, 23, 24, 25, 28, 29, 32, 50, 52, 54, 63, 64, 65, 66, 67, 69, 70, 73, 74,
78, 105, 106, 107, 108, 109, 110, 112, 116, 117, 118, 119, 120, 121, 122, 124, 125, 126, 128, 129,
130, 131, 133, 134, 135, 136, 137, 144, 146, 151, 153, 158
Commit, 82, 84
Controle de versão, 81
D
Debugging, 7, 148, 149, 151, 153, 154, 155, 156, 160
Depuração, 12, 148, 149, 150, 151, 153, 154, 155, 156, 160
E
Eclipse, 5, 6, 7, 11, 27, 39, 51, 55, 57, 58, 59, 60, 63, 64, 66, 67, 70, 71, 73, 75, 76, 77, 79, 80, 81, 89,
90, 91, 92, 98, 106, 108, 109, 110, 113, 115, 127, 132, 133, 134, 138, 139, 140, 144, 148, 149, 150,
151, 152, 153, 154, 155, 156, 160
EGit, 6, 81, 89, 90, 91, 95, 96
Encapsulamento, 11, 12, 18, 22, 25, 29, 32, 34, 36, 71, 116, 118, 159
F
Ferramentas, 8, 11, 12, 15, 26, 27, 57, 58, 60, 64, 76, 77, 79, 90, 96, 97, 106, 115, 127, 131, 138, 145,
148, 155, 159, 164, 179, 181, 182, 183, 184, 187, 188, 189, 190, 192, 193, 194, 195, 196, 197, 198,
200, 201, 202, 203, 204, 205, 212, 225, 235, 236
Formatação, 12, 71, 73, 115, 123, 124, 127, 131, 160
Framework, 106, 165
G
Getter/Setter, 6, 71, 81, 82, 83, 84, 85, 86, 89, 90, 92, 95
GitHub, 6, 81, 82, 86, 87, 88, 90, 92
H
Herança, 5, 11, 12, 18, 22, 24, 25, 29, 32, 36, 116, 118, 119, 120, 121, 159
I
IDE, 5, 6, 7, 11, 27, 39, 50, 51, 52, 55, 57, 58, 59, 60, 64, 66, 68, 73, 74, 75, 76, 77, 78, 80, 81, 82, 86,
89, 90, 92, 93, 94, 98, 106, 107, 108, 110, 113, 115, 127, 128, 131, 132, 133, 134, 135, 138, 143, 144,
148, 155, 156, 160
Indentação, 73, 123, 127, 130
Integrated Development Environment, 51, 57
J
Java Data Base Connective, 40
Javadoc, 6, 7, 9, 78, 79, 125, 128, 131, 132, 133, 134, 135, 136, 137, 160
Java Virtual Machine, 128
JDBC, 5, 6, 7, 40, 41, 48, 50, 54, 106, 107, 108, 109, 110, 112, 113, 240
JVM, 26, 124, 128
K
Kanban, 8, 12, 181, 182, 187, 188, 189, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204,
205
M
Main, 5, 6, 54, 65, 68, 69, 151, 153
Manifesto ágil, 12, 163, 164
Master, 7, 85, 93, 167, 168, 170, 171, 173, 175, 176, 181, 244
Merge, 85, 86
Métodos, 5, 6, 7, 12, 15, 19, 20, 21, 22, 23, 24, 25, 29, 33, 36, 50, 52, 53, 54, 65, 68, 69, 71, 72, 78,
101, 104, 105, 106, 109, 110, 111, 112, 113, 116, 117, 118, 119, 120, 121, 122, 125, 126, 127, 128,
129, 130, 131, 146, 147, 148, 149, 151, 153, 154, 155, 156, 158, 159, 163, 164, 165, 166, 167, 170,
171, 172, 173, 174, 176, 178, 179, 180, 182, 183, 184, 188, 193, 194, 210, 239
Métodos Estáticos, 146
Modelo V, 6, 104
Modificadores de acesso, 1, 3, 5, 6, 11, 15, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 29, 31, 32, 35, 36,
54, 65, 70, 75, 101, 116, 118, 123, 125, 126, 145, 151, 154, 239
Mysql, 5, 11, 39, 41, 42, 43, 45, 46, 47, 48, 49, 50, 51, 52, 54, 55
O
Otimização, 12, 18, 73, 76, 115, 137, 138, 145, 147, 159, 160, 223
P
Package Explorer, 6, 63, 77
Polimorfismo, 11, 12, 18, 22, 25, 29, 32, 36, 116, 120, 121, 159
Princípios do Software Ágil, 12, 163, 164
Processo de teste, 6, 11, 58, 60, 76, 96, 98, 103, 104, 150, 160, 170, 175, 183, 191, 200, 201, 229,
230, 239
Product Owner, 7, 11, 39, 40, 167, 168, 169, 170, 175, 176, 177, 180
Programação Estruturada, 11, 18, 31, 33, 34, 35, 36, 37, 239, 240
Programação Orientada a Objeto, 1, 3, 5, 15, 17, 18, 23, 26, 31, 32, 35, 36, 101, 123
Push, 82
R
Rastreabilidade, 7, 12, 138, 157, 158, 159, 160, 239
Repositório, 6, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 92, 93, 94, 95, 98
S
Scrum, 7, 12, 163, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 178, 179, 180, 181,
182, 183, 184, 240
Scrum Master, 7, 167, 168, 170, 171, 173, 175, 176, 181
SDK, 134
SGBD, 39
Sistemas Gerenciadores de Banco de Dados, 39
Software, 8, 12, 15, 17, 21, 26, 27, 35, 37, 54, 57, 76, 81, 86, 89, 97, 98, 101, 102, 103, 104, 105, 106,
112, 113, 137, 139, 140, 143, 148, 158, 159, 160, 163, 164, 165, 167, 168, 170, 173, 176, 177, 178,
180, 182, 183, 184, 187, 205, 239, 241
Sprint, 7, 8, 173, 174, 175, 176, 177, 178, 179, 180, 181, 190
StringBuffer, 145
StringBuilder, 145
T
Teste de Aceitação, 105
Teste de Integração, 104
Teste de Sistema, 7, 12, 105, 165, 167, 168, 169, 170, 171, 172, 173, 175, 176, 177, 178, 179, 180,
184
Teste unitário, 11, 101, 102, 104, 105, 106, 113
Trello, 8, 12, 187, 188, 189, 190, 191, 192, 193, 194, 205
U
UML, 5, 8, 11, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 31, 33, 34, 35, 36, 37, 39, 40, 41, 43,
46, 51, 54, 55, 57, 58, 59, 60, 62, 65, 67, 68, 69, 70, 71, 73, 74, 75, 76, 81, 82, 83, 84, 85, 86, 87, 89,
90, 92, 96, 97, 98, 101, 102, 103, 105, 106, 107, 109, 110, 112, 113, 116, 118, 119, 121, 124, 125,
126, 127, 128, 129, 130, 131, 138, 139, 144, 145, 146, 147, 148, 149, 151, 156, 158, 159, 160, 163,
164, 165, 166, 169, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 187, 188, 189,
190, 193, 195, 199, 201, 203, 208, 210, 211, 212, 214, 218, 219, 220, 222, 223, 225, 226, 227, 228,
229, 230, 231, 232, 233, 234, 235, 236, 240
Unified Modeling Language, 26
SENAI – DEPARTAMENTO NACIONAL
UNIDADE DE EDUCAÇÃO PROFISSIONAL E TECNOLÓGICA – UNIEP
Felipe Esteves Morgado

Gerente Executivo
Luiz Eduardo Leão

Gerente de Tecnologias Educacionais
Catarina Gama Catão

Coordenação Geral do Desenvolvimento dos Livros Didáticos
SENAI – DEPARTAMENTO REGIONAL DE SANTA CATARINA
Jefferson de Oliveira Gomes

Diretor Regional SENAI/SC
Mauricio Cappra Pauletti

Diretor Técnico do SENAI/SC
Roberto de Medeiros Junior

Diretor Instituto da Indústria e Novos Produtos do SENAI/SC
Leonardo Bernardo de Oliveira

Gerente de Educação e Tecnologia – Instituto da Indústria – CTAI
Jehan Carla Zunino Lückmann, Me

Coordenadora de Educação e Tecnologia - Instituto da Indústria - CTAI
Priscila Carneiro Gallasse Cesconetto

Gestora de Projetos
Evandro Medeiros Marques

Thiago Roberto Mendes
Elaboração
Mauro César Matias

Revisão técnica
Sabrina Paula Soares Scaranto

Design educacional
Davi Leon Dias
Leandro Rosa da Silva
Tatiana Daou Segalin
Ilustrações e tratamento de imagens
IStock
SENAI/SC
Banco de imagens
Leandro Rosa da Silva

Diagramação

Revisão e Fechamento de Arquivos
Luciana Effting Takiuchi

CRB – 14/937
Ficha Catalográfica
i-Comunicação
Projeto Gráfico
Editorar Multimídia Ltda.

Revisão Ortográfica e Gramatical
Editorar Multimídia Ltda.

Normalização

Apostila SENAI Programação Orientada A Objetos

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila SENAI Programação Orientada A Objetos

Enviado por

Direitos autorais:

Formatos disponíveis

SÉRIE TECNOLOGIA DA INFORMAÇÃO - HARDWARE

Robson Braga de Andrade

DIRETORIA DE EDUCAÇÃO E TECNOLOGIA – DIRET

Rafael Esmeraldo Lucchesi Ramacciotti

Julio Sergio de Maya Pedrosa Moreira

SERVIÇO NACIONAL DE APRENDIZAGEM INDUSTRIAL – SENAI

Robson Braga de Andrade

SENAI – Departamento Nacional

Rafael Esmeraldo Lucchesi Ramacciotti

Julio Sergio de Maya Pedrosa Moreira

Gustavo Leal Sales Filho

© 2018. SENAI – Departamento Regional de Santa Catarina

SENAI Departamento Nacional

SENAI Departamento Regional de Santa Catarina

ISBN 978 - 85 - 505 - 2326 - 2

1. Programação orientada a objetos (Computação). 2. Programação

3 Paradigma das Linguagens de Programação.......................................................................................................31

4 Criando Conexões para Persistência........................................................................................................................39

5 A Importância de Ferramentas no Ambiente de Desenvolvimento............................................................57

6 Testando a Implementação OO em Java ............................................................................................................ 101

8 Estrutura Organizacional e Equipes Ágeis ......................................................................................................... 163

9 Ferramentas de Gerenciamento de Atividades................................................................................................ 187

10 Segurança do Trabalho........................................................................................................................................... 207

11 Gestão Organizacional ........................................................................................................................................... 217

Minicurrículo dos Autores............................................................................................................................................ 241

Olá! Seja bem-vindo à Unidade Curricular Programação Orientada a Objeto.

2.1 PRINCÍPIOS DA ORIENTAÇÃO A OBJETOS

A Orientação a Objetos é um paradigma, ou seja, um padrão ou modelo a seguir, portanto é importante

Confira a seguir o que é um objeto.

2.2 O QUE É UM OBJETO?

2.3 RESPONSABILIDADES DOS OBJETOS

2.3.1 QUEM SABE

2.3.2 QUEM FAZ

2.4 O QUE É UMA CLASSE?

Davi Leon (2017)

Figura 2 - Classe Carro e dois objetos instanciados

2.5 CONCEITOS FUNDAMENTAIS

Programação Orientada a Objetos

Davi Leon (2017)

Produto Nome da classe

Davi Leon (2017)

Figura 4 - Representação da abstração de um produto

Figura 5 - Representação de duas classes que possuem herança

A seguir você vai estudar o polimorfismo. Acompanhe!

2.6 APLICAÇÃO PRÁTICA DA POO

2.6.1 FERRAMENTAS DESKTOP

Violet UML Editor

2.6.2 FERRAMENTAS ONLINE

b) Link de acesso: <https://yuml.me/diagram/scruffy/class/draw>.

O mundo real reflete o mundo virtual

Reveja os principais conceitos estudados neste capítulo lendo o “Recapitulando” a seguir.

Existem diferentes formas de estruturar a construção de um sistema e de como ele é codifica-

3.1 LINGUAGENS DE PROGRAMAÇÃO OO X ESTRUTURADA

Neste tópico, serão conceituados os paradigmas da linguagem de programação orientada a objetos e

Trecho de Código Java

class Carro { Representação do objeto Carro

Ações ou métodos do objeto Carro

Davi Leon (2017)

Um exemplo de linguagem de programação estruturada é o C, ainda presente em muitos sistemas em

printf("O valor da soma = %d\n",soma);

Davi Leon (2017)

3.1.1 CARACTERÍSTICAS DA PROGRAMAÇÃO ESTRUTURADA

3.1.2 CARACTERÍSTICAS DA PROGRAMAÇÃO OO