K19 k11 orientacao a objetos em java, Manual de Análise e Design Orientados a Objetos. Centro Universitário do Maranhão (UNICEUMA)
clauberbarros
clauberbarros3 de Junho de 2015

K19 k11 orientacao a objetos em java, Manual de Análise e Design Orientados a Objetos. Centro Universitário do Maranhão (UNICEUMA)

PDF (12 MB)
220 páginas
1Números de download
836Número de visitas
Descrição
apostila de orientação a objeto
20pontos
Pontos de download necessários para baixar
este documento
baixar o documento
Pré-visualização3 páginas / 220
Esta é apenas uma pré-visualização
3 shown on 220 pages
baixar o documento
Esta é apenas uma pré-visualização
3 shown on 220 pages
baixar o documento
Esta é apenas uma pré-visualização
3 shown on 220 pages
baixar o documento
Esta é apenas uma pré-visualização
3 shown on 220 pages
baixar o documento

TREINAMENTOS

Orientação a Objetos em Java

Orientação a Objetos em Java

13 de fevereiro de 2013

Sumário i

Sobre a K19 1

Seguro Treinamento 2

Termo de Uso 3

Cursos 4

1 Introdução 1 1.1 Objetivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1.2 Orientação a Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1.3 Plataforma Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.4 Plataforma Java VS Orientação a Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2 Lógica 3 2.1 O que é um Programa? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 2.2 Linguagem de Máquina . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 2.3 Linguagem de Programação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.4 Compilador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.5 Máquinas Virtuais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.6 Exemplo de programa Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 2.7 Método Main - Ponto de Entrada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 2.8 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 2.9 Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 2.10 Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 2.11 IF-ELSE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 2.12 WHILE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 2.13 FOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 2.14 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 2.15 Exercícios Complementares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

3 Orientação a Objetos 21

www.facebook.com/k19treinamentos i

SUMÁRIO ii

3.1 Domínio e Aplicação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 3.2 Objetos, Atributos e Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 3.3 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 3.4 Referências . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.5 Manipulando Atributos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 3.6 Valores Padrão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 3.7 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 3.8 Exercícios Complementares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 3.9 Relacionamentos: Associação, Agregação e Composição . . . . . . . . . . . . . . . . . . 33 3.10 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 3.11 Exercícios Complementares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 3.12 Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 3.13 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 3.14 Exercícios Complementares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 3.15 Sobrecarga (Overloading) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 3.16 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 3.17 Construtores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 3.18 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 3.19 Referências como parâmetro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 3.20 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 3.21 Exercícios Complementares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

4 Arrays 49 4.1 Criando um array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 4.2 Modificando o conteúdo de um array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 4.3 Acessando o conteúdo de um array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 4.4 Percorrendo um Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 4.5 foreach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 4.6 Operações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 4.7 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 4.8 Exercícios Complementares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

5 Eclipse 55 5.1 workspace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 5.2 welcome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 5.3 perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 5.4 views . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 5.5 Criando um projeto java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 5.6 Criando uma classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 5.7 Gerando o método main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 5.8 Executando uma classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 5.9 Corrigindo erros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 5.10 Atalhos Úteis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 5.11 Save Actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 5.12 Refatoração . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

6 Atributos e Métodos de Classe 67 6.1 Atributos Estáticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 6.2 Métodos Estáticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 6.3 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

ii www.k19.com.br

iii SUMÁRIO

6.4 Exercícios Complementares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

7 Encapsulamento 73 7.1 Atributos Privados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 7.2 Métodos Privados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 7.3 Métodos Públicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 7.4 Implementação e Interface de Uso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 7.5 Por quê encapsular? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 7.6 Celular - Escondendo a complexidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 7.7 Carro - Evitando efeitos colateiras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 7.8 Máquinas de Porcarias - Aumentando o controle . . . . . . . . . . . . . . . . . . . . . . . 77 7.9 Acessando ou modificando atributos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 7.10 Getters e Setters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 7.11 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 7.12 Exercícios Complementares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

8 Herança 83 8.1 Reutilização de Código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 8.2 Uma classe para todos os serviços . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 8.3 Uma classe para cada serviço . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 8.4 Uma classe genérica e várias específicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 8.5 Preço Fixo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 8.6 Reescrita de Método . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 8.7 Fixo + Específico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 8.8 Construtores e Herança . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 8.9 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 8.10 Exercícios Complementares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

9 Polimorfismo 95 9.1 Controle de Ponto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 9.2 Modelagem dos funcionários . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 9.3 É UM (extends) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 9.4 Melhorando o controle de ponto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 9.5 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 9.6 Exercícios Complementares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

10 Classes Abstratas 101 10.1 Classes Abstratas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 10.2 Métodos Abstratos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 10.3 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 10.4 Exercícios Complementares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

11 Interfaces 107 11.1 Padronização . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 11.2 Contratos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 11.3 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 11.4 Polimorfismo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 11.5 Interface e Herança . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 11.6 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

www.facebook.com/k19treinamentos iii

SUMÁRIO iv

12 Pacotes 115 12.1 Organização . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 12.2 O comando package . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 12.3 sub-pacotes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 12.4 Unqualified Name vs Fully Qualified Name . . . . . . . . . . . . . . . . . . . . . . . . . . 116 12.5 Classes ou Interfaces públicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 12.6 Import . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 12.7 Conflito de nomes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 12.8 Níveis de visibilidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 12.9 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

13 Documentação 121 13.1 A ferramenta javadoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 13.2 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

14 Exceptions 129 14.1 Errors vs Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 14.2 Checked e Unchecked . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130 14.3 Lançando uma unchecked exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130 14.4 Lançando uma checked exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 14.5 Capturando exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 14.6 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

15 Object 133 15.1 Polimorfismo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 15.2 O método toString() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134 15.3 O método equals() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136 15.4 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

16 String 143 16.1 Pool de Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 16.2 Imutabilidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144 16.3 Métodos principais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144 16.4 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146

17 Entrada e Saída 149 17.1 Byte a Byte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 17.2 Scanner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 17.3 PrintStream . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 17.4 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 17.5 Exercícios Complementares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

18 Collections 153 18.1 Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 18.2 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 18.3 Conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158 18.4 Coleções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 18.5 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 18.6 Laço foreach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160 18.7 Generics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160

iv www.k19.com.br

v SUMÁRIO

18.8 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

A Swing 163 A.1 Componentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 A.2 Layout Manager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167 A.3 Events, Listeners e Sources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168 A.4 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169

B Empacotamento 171 B.1 Empacotando uma biblioteca . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 B.2 Empacotando uma applicação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 B.3 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

C Threads 173 C.1 Definindo Tarefas - (Runnables) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 C.2 Executando Tarefas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 C.3 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 C.4 Controlando a Execução das Tarefas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175 C.5 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176

D Socket 179 D.1 Socket . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 D.2 ServerSocket . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 D.3 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180

E Chat K19 183 E.1 Arquitetura do Sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183 E.2 Aplicação servidora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183 E.3 Aplicação cliente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184 E.4 Exercícios de Fixação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185

F Quizzes 191

G Respostas 193

www.facebook.com/k19treinamentos v

SUMÁRIO vi

vi www.k19.com.br

1 SUMÁRIO

Sobre a K19

A K19 é uma empresa especializada na capacitação de desenvolvedores de software. Sua equipe é composta por profissionais formados em Ciência da Computação pela Universidade de São Paulo (USP) e que possuem vasta experiência em treinamento de profissionais para área de TI.

O principal objetivo da K19 é oferecer treinamentos de máxima qualidade e relacionados às prin- cipais tecnologias utilizadas pelas empresas. Através desses treinamentos, seus alunos se tornam capacitados para atuar no mercado de trabalho.

Visando a máxima qualidade, a K19 mantém as suas apostilas em constante renovação e melho- ria, oferece instalações físicas apropriadas para o ensino e seus instrutores estão sempre atualizados didática e tecnicamente.

www.facebook.com/k19treinamentos 1

SUMÁRIO 2

Seguro Treinamento

Na K19 o aluno faz o curso quantas vezes quiser!

Comprometida com o aprendizado e com a satisfação dos seus alunos, a K19 é a única que pos- sui o Seguro Treinamento. Ao contratar um curso, o aluno poderá refazê-lo quantas vezes desejar mediante a disponibilidade de vagas e pagamento da franquia do Seguro Treinamento.

As vagas não preenchidas até um dia antes do início de uma turma da K19 serão destinadas ao alunos que desejam utilizar o Seguro Treinamento. O valor da franquia para utilizar o Seguro Treina- mento é 10% do valor total do curso.

2 www.k19.com.br

3 SUMÁRIO

Termo de Uso

Termo de Uso

Todo o conteúdo desta apostila é propriedade da K19 Treinamentos. A apostila pode ser utilizada livremente para estudo pessoal . Além disso, este material didático pode ser utilizado como material de apoio em cursos de ensino superior desde que a instituição correspondente seja reconhecida pelo MEC (Ministério da Educação) e que a K19 seja citada explicitamente como proprietária do material.

É proibida qualquer utilização desse material que não se enquadre nas condições acima sem o prévio consentimento formal, por escrito, da K19 Treinamentos. O uso indevido está sujeito às medidas legais cabíveis.

www.facebook.com/k19treinamentos 3

SUMÁRIO 4

K01- Lógica de Programação

K11 - Orientação a Objetos em Java

K12 - Desenvolvimento Web com JSF2 e JPA2

K21 - Persistência com JPA2 e Hibernate

K22 - Desenvolvimento Web Avançado com JFS2, EJB3.1 e CDI

K23 - Integração de Sistemas com Webservices, JMS e EJB

K31 - C# e Orientação a Objetos

K32 - Desenvolvimento Web com ASP.NET MVC

TRE INA

ME NT

OS

TREINAMENTOSTREINAMENTOS Conheça os nossos cursos

www.k19.com.br/cursos

K02 - Desenvolvimento Web com HTML, CSS e JavaScript

K03 - SQL e Modelo Relacional

K41 - Desenvolvimento Mobile com Android

K51 - Design Patterns em Java

K52 - Desenvolvimento Web com Struts

4 www.k19.com.br

INTRODUÇÃO

C A

P Í

T U

L O

1 Objetivo

O objetivo fundamental dos treinamentos da K19 é transmitir os conhecimentos necessários para que os seus alunos possam atuar no mercado de trabalho na área de desenvolvimento de software.

As plataformas Java e .NET são as mais utilizadas no desenvolvimento de software. Para utilizar os recursos oferecidos por essas plataformas de forma eficiente, é necessário possuir conhecimento sólido em orientação a objetos.

Orientação a Objetos

Um modelo de programação ou paradigma de programação é um conjunto de princípios, ideias, conceitos e abstrações utilizado para o desenvolvimento de uma aplicação.

KB 0-

X8

PO KE

T 8 01

MA DE

B Y

K1 9

Analogia Para entender melhor o que são os modelos de programação, podemos compará-los com padrões arquiteturais utilizados por diferentes povos para construção de casas. As

características ambientais definem quais técnicas devem ser adotadas para a construção das moradias. Analogamente, devemos escolher o modelo de programação mais adequado às ne- cessidades da aplicação que queremos desenvolver.

CABANA DE ÍNDIO IGLU CASA OCIDENTAL

Figura 1.1: Moradias

O modelo de programação mais adotado no desenvolvimento de sistemas corporativos é o mo- delo orientado a objetos. Esse modelo é utilizado com o intuito de obter alguns benefícios específi- cos. Normalmente, o principal benefício desejado é facilitar a manutenção das aplicações.

www.facebook.com/k19treinamentos 1

INTRODUÇÃO 2

Em geral, os conceitos do modelo de programação orientado a objetos diminuem a complexi- dade do desenvolvimento de sistemas que possuem as seguintes características:

• Sistemas com grande quantidade de funcionalidades desenvolvidos por uma equipe.

• Sistemas que serão utilizados por um longo período de tempo e sofrerão alterações constantes.

Plataforma Java

A plataforma Java será objeto de estudo desse treinamento. Mas, devemos salientar que os con- ceitos de orientação a objetos que serão vistos poderão ser aplicados também na plataforma .NET.

No primeiro momento, os dois elementos mais importantes da plataforma Java são:

• A linguagem de programação Java.

• O ambiente de execução Java.

A linguagem de programação Java permite que os conceitos de orientação a objetos sejam utili- zados no desenvolvimento de uma aplicação.

O ambiente de execução Java permite que uma aplicação Java seja executada em sistemas ope- racionais diferentes.

PLATAFORMA JAVA

LINGUAGEM DE PROGRAMAÇÃO ORIENTADA A OBJETOS

AMBIENTE DE EXECUÇÃO MULTIPLATAFORMA

Figura 1.2: Plataforma Java

Plataforma Java VS Orientação a Objetos

Do ponto de vista do aprendizado, é interessante tentar definir o que é mais importante: a pla- taforma Java ou a orientação a objetos. Consideramos que a orientação a objetos é mais importante pois ela é aplicada em muitas outras plataformas.

2 www.k19.com.br

LÓGICA

C A

P Í

T U

L O

2 O que é um Programa?

Um dos maiores benefícios da utilização de computadores é a automatização de processos reali- zados manualmente por pessoas. Vejamos um exemplo prático:

Quando as apurações dos votos das eleições no Brasil eram realizadas manualmente, o tempo para obter os resultados era alto e havia alta probabilidade de uma falha humana. Esse processo foi automatizado e hoje é realizado por computadores. O tempo para obter os resultados e a chance de ocorrer uma falha humana diminuíram drasticamente.

Basicamente, os computadores são capazes de executar instruções matemáticas mais rapida- mente do que o homem. Essa simples capacidade permite que eles resolvam problemas complexos de maneira mais eficiente. Porém, eles não possuem a inteligência necessária para definir quais instruções devem ser executadas para resolver uma determinada tarefa. Por outro lado, os seres hu- mano possuem essa inteligência. Dessa forma, uma pessoa precisa definir um roteiro com a sequên- cia de comandos necessários para realizar uma determinada tarefa e depois passar para um compu- tador executar esse roteiro. Formalmente, esses roteiros são chamados de programas.

Os programas devem ser colocados em arquivos no disco rígido dos computadores. Assim, quando as tarefas precisam ser realizadas, os computadores podem ler esses arquivos para saber quais ins- truções devem ser executadas.

Linguagem de Máquina

Os computadores só sabem ler instruções escritas em linguagem de máquina. Uma instrução escrita em linguagem de máquina é uma sequência formada por “0s” e “1s” que representa a ação que um computador deve executar.

000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000010000000000100000000 000000000000111000011111101110100000111000000000101101000000100 111001101001000011011100000000001010011001100110100100001010101 000110100001101001011100110010000001110000011100100110111101100 111011100100110000101101101001000000110001101100001011011100110 111001101111011101000010000001100010011001010010000001110010011

Figura 2.1: Código de Máquina.

Teoricamente, as pessoas poderiam escrever os programas diretamente em linguagem de má- quina. Na prática, ninguém faz isso pois é uma tarefa muito complicada e demorada.

www.facebook.com/k19treinamentos 3

LÓGICA 4

Um arquivo contendo as instruções de um programa em Linguagem de Máquina é chamado de executável.

Linguagem de Programação

Como vimos anteriormente, escrever um programa em linguagem de máquina é totalmente in- viável para uma pessoa. Para resolver esse problema, surgiram as linguagens de programação, que tentam se aproximar das linguagens humanas. Confira um trecho de um código escrito com a lin- guagem de programação Java:

1 class OlaMundo { 2 public static void main(String [] args) { 3 System.out.println("Olá Mundo"); 4 } 5 }

Código Java 2.1: OlaMundo.java

Por enquanto você pode não entender muito do que está escrito, porém fica bem claro que um programa escrito dessa forma fica bem mais fácil de ser lido.

Um arquivo contendo as instruções de um programa em linguagem de programação é chamado de arquivo fonte.

Compilador

Por um lado, os computadores processam apenas instruções em linguagem de máquina. Por ou- tro lado, as pessoas definem as instruções em linguagem de programação. Dessa forma, é necessário traduzir o código escrito em linguagem de programação por uma pessoa para um código em lingua- gem de máquina para que um computador possa processar. Essa tradução é realizada por programas especiais chamados compiladores.

while(true){ if(x < 1){ return 0; }

return 1; }

while(true){ if(x < 1){ return 0; }

return 1; }

PROCESSADORCÓDIGO FONTE NÃO EXECUTA

CÓDIGO FONTE COMPILADOR CÓDIGO DE MÁQUINA PROCESSADOR EXECUTA

Figura 2.2: Processo de compilação e execução de um programa.

Máquinas Virtuais

4 www.k19.com.br

5 LÓGICA

Assim como as pessoas podem se comunicar através de línguas diferentes, os computadores po- dem se comunicar através de linguagens de máquina diferentes. A linguagem de máquina de um computador é definida pela arquitetura do processador desse computador. Há diversas arquitetu- ras diferentes (Intel, ARM, PowerPC, etc) e cada uma delas define uma linguagem de máquina dife- rente. Em outras palavras, um programa pode não executar em computadores com processadores de arquiteturas diferentes.

Os computadores são controlados por um sistema operacional que oferece diversas bibliotecas necessárias para o desenvolvimento das aplicações que podem ser executadas através dele. Sistemas operacionais diferentes (Windows, Linux, Mac OS X, etc) possuem bibliotecas diferentes. Em outras palavras, um programa pode não executar em computadores com sistemas operacionais diferentes.

Portanto, para determinar se um código em linguagem de máquina pode ou não ser executada por um computador, devemos considerar a arquitetura do processador e o sistema operacional desse computador.

Algumas bibliotecas específicas de sistema operacional são chamadas diretamente pelas instru- ções em linguagem de programação. Dessa forma, geralmente, o código fonte está “amarrado” a uma plataforma (sistema operacional + arquitetura de processador).

PROGRAMA 1 PLATAFORMA 1 EXECUTA

EXECUTAPROGRAMA 2 PLATAFORMA 2

NÃO EXECUTAPROGRAMA 2 PLATAFORMA 3

Figura 2.3: Ilustração mostrando que cada plataforma necessita de um executável específico.

Uma empresa que deseja ter a sua aplicação disponível para diversos sistemas operacionais (Win- dows, Linux, Mac OS X, etc), e diversas arquiteturas de processador (Intel, ARM, PowerPC, etc), terá que desenvolver versões diferentes do código fonte para cada plataforma (sistema operacional + ar- quitetura de processador). Isso pode causar um impacto financeiro nessa empresa que inviabiliza o negócio.

www.facebook.com/k19treinamentos 5

LÓGICA 6

Para tentar resolver o problema do desenvolvimento de aplicações multiplataforma, surgiu o conceito de máquina virtual.

Uma máquina virtual funciona como uma camada a mais entre o código compilado e a plata- forma. Quando compilamos um código fonte, estamos criando um executável que a máquina virtual saberá interpretar e ela é quem deverá traduzir as instruções do seu programa para a plataforma.

MÁQUINA VIRTUAL 1 PLATAFORMA 1 EXECUTA

MÁQUINA VIRTUAL 2 EXECUTAPROGRAMA PLATAFORMA 2

MÁQUINA VIRTUAL 3 EXECUTAPLATAFORMA 3

Figura 2.4: Ilustração do funcionamento da máquina virtual.

Tudo parece estar perfeito agora. Porém, olhando atentamente a figura acima, percebemos que existe a necessidade de uma máquina virtual para cada plataforma. Alguém poderia dizer que, de fato, o problema não foi resolvido, apenas mudou de lugar.

A diferença é que implementar a máquina virtual não é tarefa do programador que desenvolve as aplicações que serão executadas nela. A implementação da máquina virtual é responsabilidade de terceiros, que geralmente são empresas bem conceituadas ou projetos de código aberto que envol- vem programadores do mundo inteiro. Como maiores exemplos podemos citar a Oracle JVM (Java Virtual Machine) e OpenJDK JVM.

Uma desvantagem em utilizar uma máquina virtual para executar um programa é a diminuição de performance, já que a própria máquina virtual consome recursos do computador. Além disso, as instruções do programa são processadas primeiro pela máquina virtual e depois pelo computador.

Por outro lado, as máquinas virtuais podem aplicar otimizações que aumentam a performance da execução de um programa. Inclusive, essas otimizações podem considerar informações geradas durante a execução. São exemplos de informações geradas durante a execução: a quantidade de uso da memória RAM e do processador do computador, a quantidade de acessos ao disco rígido, a quan- tidade de chamadas de rede e a frequência de execução de um determinado trecho do programa.

Algumas máquinas virtuais identificam os trechos do programa que estão sendo mais chamados

6 www.k19.com.br

7 LÓGICA

em um determinado momento da execução para traduzi-los para a linguagem de máquina do com- putador. A partir daí, esses trechos podem ser executados diretamente no processador sem passar pela máquina virtual. Essa análise da máquina virtual é realizada durante toda a execução.

Com essas otimizações que consideram várias informações geradas durante a execução, um pro- grama executado com máquina virtual pode até ser mais eficiente em alguns casos do que um pro- grama executado diretamente no sistema operacional.

Mais Sobre Geralmente, as máquinas virtuais utilizam uma estratégia de compilação chamada Just-in-time compilation (JIT). Nessa abordagem, o código de máquina pode ser

gerado diversas vezes durante o processamento de um programa com o intuito de melhorar a utilização dos recursos disponíveis em um determinado instante da execução.

Exemplo de programa Java

Vamos criar um simples programa para entendermos como funciona o processo de compilação e execução. Utilizaremos a linguagem Java, que é amplamente adotada nas empresas. Observe o código do exemplo de um programa escrito em Java que imprime uma mensagem na tela:

1 class OlaMundo { 2 public static void main(String [] args) { 3 System.out.println("Olá Mundo"); 4 } 5 }

Código Java 2.2: OlaMundo.java

O código fonte Java deve ser colocado em arquivos com a extensão .java. Agora, não é necessário entender todo o código do exemplo. Basta saber que toda aplicação Java precisa ter um método especial chamado main para executar.

O próximo passo é compilar o código fonte, para gerar um executável que possa ser processado pela máquina virtual do Java. O compilador padrão da plataforma Java (javac) pode ser utilizado para compilar esse arquivo. O compilador pode ser executado pelo terminal.

K19$ ls OlaMundo.java K19$ javac OlaMundo.java K19$ ls OlaMundo.class OlaMundo.java

Terminal 2.1: Compilando

O código gerado pelo compilador Java é armazenado em arquivos com a extensão .class. No exemplo, o programa gerado pelo compilador é colocado em um arquivo chamado OlaMundo.class e ele pode ser executado através de um terminal.

K19$ ls OlaMundo.class OlaMundo.java K19$ java OlaMundo Olá Mundo

www.facebook.com/k19treinamentos 7

LÓGICA 8

Terminal 2.2: Executando

Importante Antes de compilar e executar um programa escrito em Java, é necessário que você tenha instalado e configurado em seu computador o JDK (Java De-

velopment Kit). Consulte o artigo da K19, http://www.k19.com.br/artigos/ instalando-o-jdk-java-development-kit/.

Mais Sobre Quando uma aplicação ou biblioteca Java é composta por diversos arquivos .class, po- demos “empacotá-los” em um único arquivo com a extensão .jar com o intuito de faci-

litar a distribuição da aplicação ou da biblioteca.

Método Main - Ponto de Entrada

Para um programa Java executar, é necessário definir um método especial para ser o ponto de entrada do programa, ou seja, para ser o primeiro método a ser chamado quando o programa for executado. O método main precisa ser public, static, void e receber um array de strings como argu- mento.

Algumas das possíveis variações da assinatura do método main:

1 static public void main(String [] args) 2 public static void main(String [] args) 3 public static void main(String args []) 4 public static void main(String [] parametros)

Código Java 2.3: Variações da Assinatura do Método Main

Os parâmetros do método main são passados pela linha de comando e podem ser manipulados dentro do programa. O código abaixo imprime cada parâmetro recebido em uma linha diferente.

1 class Programa { 2 public static void main(String [] args) { 3 for(int i = 0; i < args.length; i++) { 4 System.out.println(args[i]); 5 } 6 } 7 }

Código Java 2.4: Imprimindo os parâmetros da linha de comando

Os parâmetros devem ser passados imediatamente após o nome do programa. A execução do programa é mostrada na figura abaixo.

K19$ ls Programa.class Programa.java K19$ java Programa K19 Java Rafael Cosentino K19

8 www.k19.com.br

9 LÓGICA

Java Rafael Cosentino

Terminal 2.3: Imprimindo os parâmetros da linha de comando

Exercícios de Fixação

1 Abra um terminal e crie uma pasta com o seu nome. Você deve salvar os seus exercícios nessa pasta.

K19$ mkdir Rafael K19$ cd Rafael K19/Rafael$

Terminal 2.4: Criando a pasta de exercícios

2 Dentro da sua pasta de exercícios, crie uma pasta para os arquivos desenvolvidos nesse capítulo chamada logica.

K19/Rafael$ mkdir logica K19/Rafael$ ls logica

Terminal 2.5: Criando a pasta dos exercícios desse capítulo

3 Crie um programa que imprima uma mensagem na tela. Adicione o seguinte arquivo na pasta logica.

1 class OlaMundo { 2 public static void main(String [] args) { 3 System.out.println("Olá Mundo"); 4 } 5 }

Código Java 2.5: OlaMundo.java

Compile e execute a classe OlaMundo.

Variáveis

Basicamente, o que um programa faz é manipular dados. Em geral, esses dados são armazenados em variáveis localizadas na memória RAM do computador. Uma variável pode guardar dados de vários tipos: números, textos, booleanos (verdadeiro ou falso), referências de objetos. Além disso, toda variável possui um nome que é utilizado quando a informação dentro da variável precisa ser manipulada pelo programa.

numeroDaConta = 4823

numeroDaConta

MEMÓRIA RAM

numeroDaConta

4 8 2 3

MEMÓRIA RAM

Figura 2.5: Processo de atribuição do valor numérico 4823 à variável numeroDaConta.

www.facebook.com/k19treinamentos 9

LÓGICA 10

Declaração

Na linguagem de programação Java, as variáveis devem ser declaradas para que possam ser uti- lizadas. A declaração de uma variável envolve definir um nome único (identificador) dentro de um escopo e um tipo de valor. As variáveis são acessadas pelos nomes e armazenam valores compatíveis com o seu tipo.

1 // Uma variável do tipo int chamada numeroDaConta. 2 int numeroDaConta; 3 4 // Uma variável do tipo double chamada precoDoProduto. 5 double precoDoProduto;

Código Java 2.6: Declaração de Variáveis

Mais Sobre Uma linguagem de programação é dita estaticamente tipada quando ela exige que os tipos das variáveis sejam definidos antes da compilação. A linguagem Java é uma

linguagem estaticamente tipada.

Uma linguagem de programação é dita fortemente tipada quando ela exige que os valores armazenados em uma variável sejam compatíveis com o tipo da variável. A linguagem Java é uma linguagem fortemente tipada.

Mais Sobre Em geral, as linguagens de programação possuem convenções para definir os nomes das variáveis. Essas convenções ajudam o desenvolvimento de um código mais legível.

Na convenção de nomes da linguagem Java, os nomes das variáveis devem seguir o padrão ca- mel case com a primeira letra minúscula (lower camel case). Veja alguns exemplos:

• nomeDoCliente

• numeroDeAprovados

A convenção de nomes da linguagem Java pode ser consultada na seguinte url: http://www. oracle.com/technetwork/java/codeconv-138413.html

A declaração de uma variável pode ser realizada em qualquer linha de um bloco. Não é necessário declarar todas as variáveis no começo do bloco como acontece em algumas linguagens de progra- mação.

1 // Declaração com Inicialização 2 int numero = 10; 3 4 // Uso da variável 5 System.out.println(numero); 6 7 // Outra Declaração com Inicialização 8 double preco = 137.6;

10 www.k19.com.br

11 LÓGICA

9 10 // Uso da variável 11 System.out.println(preco);

Código Java 2.7: Declarando em qualquer linha de um bloco.

Não podemos declarar duas variáveis com o mesmo nome em um único bloco ou escopo pois ocorrerá um erro de compilação.

1 // Declaração 2 int numero = 10; 3 4 // Erro de Compilação 5 int numero = 10;

Código Java 2.8: Duas variáveis com o mesmo nome no mesmo bloco.

Inicialização

Toda variável deve ser inicializada antes de ser utilizada pela primeira vez. Se isso não for reali- zado, ocorrerá um erro de compilação. A inicialização é realizada através do operador de atribuição =. Esse operador guarda um valor em uma variável.

1 // Declarações 2 int numero; 3 double preco; 4 5 // Inicialização 6 numero = 10; 7 8 // Uso Correto 9 System.out.println(numero); 10 11 // Erro de compilação 12 System.out.println(preco);

Código Java 2.9: Inicialização

Tipos Primitivos

A linguagem Java define um conjunto de tipos básicos de dados que são chamados tipos primi- tivos. A tabela abaixo mostra os oito tipos primitivos da linguagem Java e os valores compatíveis.

Tipo Descrição Tamanho (“peso”) byte Valor inteiro entre -128 e 127 (inclusivo) 1 byte short Valor inteiro entre -32.768 e 32.767 (inclusivo) 2 bytes

int Valor inteiro entre -2.147.483.648 e 2.147.483.647 (inclu- sivo)

4 bytes

long Valor inteiro entre -9.223.372.036.854.775.808 e 9.223.372.036.854.775.807 (inclusivo)

8 bytes

float Valor com ponto flutuante entre 1,40129846432481707× 10−45 e 3,40282346638528860 × 1038 (positivo ou nega- tivo)

4 bytes

www.facebook.com/k19treinamentos 11

LÓGICA 12

Tipo Descrição Tamanho (“peso”)

double Valor com ponto flutuante entre 4,94065645841246544× 10−324 e 1,79769313486231570×10308 (positivo ou nega- tivo)

8 bytes

boolean true ou false 1 bit

char Um único caractere Unicode de 16 bits. Valor inteiro e positivo entre 0 (ou ‘\u0000’) e 65.535 (ou ‘\uffff’)

2 bytes

Tabela 2.1: Tipos primitivos de dados em Java.

Importante Nenhum tipo primitivo da linguagem Java permite o armazenamento de texto. O tipo primitivo char armazena apenas um caractere. Quando é necessário armazenar um

texto, devemos utilizar o tipo String. Contudo, é importante salientar que o tipo String não é um tipo primitivo.

Operadores

Para manipular os valores das variáveis de um programa, devemos utilizar os operadores ofere- cidos pela linguagem de programação adotada. A linguagem Java possui diversos operadores e os principais são categorizados da seguinte forma:

• Aritmético (+, -, *, /, %)

• Atribuição (=, +=, -=, *=, /=, %=)

• Relacional (==, !=, <, <=, >, >=)

• Lógico (&&, ||)

Aritmético

Os operadores aritméticos funcionam de forma muito semelhante aos operadores na matemá- tica. Os operadores aritméticos são:

• Soma +

• Subtração -

• Multiplicação *

• Divisão /

• Módulo %

1 int umMaisUm = 1 + 1; // umMaisUm = 2 2 int tresVezesDois = 3 * 2; // tresVezesDois = 6 3 int quatroDivididoPor2 = 4 / 2; // quatroDivididoPor2 = 2 4 int seisModuloCinco = 6 % 5; // seisModuloCinco = 1 5 int x = 7; 6 x = x + 1 * 2; // x = 9 7 x = x - 3; // x = 6

12 www.k19.com.br

13 LÓGICA

8 x = x / (6 - 2 + (3*5) /(16 -1)); // x = 2

Código Java 2.10: Exemplo de uso dos operadores aritméticos.

Importante O módulo de um número x, na matemática, é o valor numérico de x desconsiderando o seu sinal (valor absoluto). Na matemática expressamos o módulo da seguinte forma:

|−2| = 2. Em linguagens de programação, o módulo de um número é o resto da divisão desse número por outro. No exemplo acima, o resto da divisão de 6 por 5 é igual a 1. Além disso, lemos a expressão 6%5 da seguinte forma: seis módulo cinco.

Importante As operações aritméticas em Java obedecem as mesmas regras da matemática com rela- ção à precedência dos operadores e parênteses. Portanto, as operações são resolvidas a

partir dos parênteses mais internos até os mais externos, primeiro resolvemos as multiplicações, divisões e os módulos. Em seguida, resolvemos as adições e subtrações.

Atribuição

Nas seções anteriores, já vimos um dos operadores de atribuição, o operador = (igual). Os opera- dores de atribuição são:

• Simples =

• Incremental +=

• Decremental -=

• Multiplicativa *=

• Divisória /=

• Modular %=

1 int valor = 1; // valor = 1 2 valor += 2; // valor = 3 3 valor -= 1; // valor = 2 4 valor *= 6; // valor = 12 5 valor /= 3; // valor = 4 6 valor %= 3; // valor = 1

Código Java 2.11: Exemplo de uso dos operadores de atribuição.

As instruções acima poderiam ser escritas de outra forma:

1 int valor = 1; // valor = 1 2 valor = valor + 2; // valor = 3 3 valor = valor - 1; // valor = 2 4 valor = valor * 6; // valor = 12 5 valor = valor / 3; // valor = 4 6 valor = valor % 3; // valor = 1

www.facebook.com/k19treinamentos 13

comentários (0)
Até o momento nenhum comentário
Seja o primeiro a comentar!
Esta é apenas uma pré-visualização
3 shown on 220 pages
baixar o documento