Professional Documents
Culture Documents
C# e Orientao a Objetos
C# e Orientao a Objetos
5 de janeiro de 2012
Sumrio
Sobre a K19
Seguro Treinamento
Termo de Uso
Cursos
Introduo
1.1 Objetivo . . . . . . . . . . . . . . . . . . . .
1.2 Orientao a Objetos . . . . . . . . . . . .
1.3 Plataforma .NET . . . . . . . . . . . . . . .
1.4 Plataforma .NET VS Orientao a Objetos
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
5
5
5
6
6
Lgica
2.1 O que um Programa? . . . . . .
2.2 Linguagem de Mquina . . . . .
2.3 Linguagem de Programao . . .
2.4 Compilador . . . . . . . . . . . . .
2.5 Mquinas Virtuais . . . . . . . . .
2.6 Exemplo de programa C# . . . . .
2.7 Mtodo Main - Ponto de Entrada
2.8 Exerccios de Fixao . . . . . . .
2.9 Variveis . . . . . . . . . . . . . .
2.10 Operadores . . . . . . . . . . . . .
2.11 IF-ELSE . . . . . . . . . . . . . . .
2.12 WHILE . . . . . . . . . . . . . . . .
2.13 FOR . . . . . . . . . . . . . . . . .
2.14 Exerccios de Fixao . . . . . . .
2.15 Exerccios Complementares . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
7
7
7
8
8
8
11
12
12
13
16
19
19
20
20
23
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Orientao a Objetos
25
www.k19.com.br
S UMRIO
3.1
3.2
3.3
3.4
3.5
3.6
3.7
3.8
3.9
3.10
3.11
3.12
3.13
3.14
3.15
3.16
3.17
3.18
3.19
3.20
3.21
4
ii
Domnio e Aplicao . . . . . . . . . . . . . . . . . . . . .
Objetos, Atributos e Mtodos . . . . . . . . . . . . . . . .
Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Referncias . . . . . . . . . . . . . . . . . . . . . . . . . . .
Manipulando Atributos . . . . . . . . . . . . . . . . . . . .
Valores Padro . . . . . . . . . . . . . . . . . . . . . . . . .
Exerccios de Fixao . . . . . . . . . . . . . . . . . . . . .
Exerccios Complementares . . . . . . . . . . . . . . . . .
Relacionamentos: Associao, Agregao e Composio
Exerccios de Fixao . . . . . . . . . . . . . . . . . . . . .
Exerccios Complementares . . . . . . . . . . . . . . . . .
Mtodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Exerccios de Fixao . . . . . . . . . . . . . . . . . . . . .
Exerccios Complementares . . . . . . . . . . . . . . . . .
Sobrecarga (Overloading) . . . . . . . . . . . . . . . . . .
Exerccios de Fixao . . . . . . . . . . . . . . . . . . . . .
Construtores . . . . . . . . . . . . . . . . . . . . . . . . . .
Exerccios de Fixao . . . . . . . . . . . . . . . . . . . . .
Referncias como parmetro . . . . . . . . . . . . . . . .
Exerccios de Fixao . . . . . . . . . . . . . . . . . . . . .
Exerccios Complementares . . . . . . . . . . . . . . . . .
Arrays
4.1 Criando um array . . . . . . . . . . . .
4.2 Modificando o contedo de um array
4.3 Acessando o contedo de um array . .
4.4 Percorrendo um Array . . . . . . . . .
4.5 foreach . . . . . . . . . . . . . . . . . .
4.6 Operaes . . . . . . . . . . . . . . . .
4.7 Exerccios de Fixao . . . . . . . . . .
4.8 Exerccios Complementares . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
25
26
28
31
32
33
34
37
37
39
41
41
43
44
45
46
47
50
53
53
54
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
55
55
56
56
57
58
58
58
60
ii
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
67
67
68
69
71
Encapsulamento
7.1 Atributos Privados . . . . . . . . . . . . . . . . . . .
7.2 Mtodos Privados . . . . . . . . . . . . . . . . . . .
7.3 Mtodos Pblicos . . . . . . . . . . . . . . . . . . .
7.4 Implementao e Interface de Uso . . . . . . . . .
7.5 Por qu encapsular? . . . . . . . . . . . . . . . . . .
7.6 Celular - Escondendo a complexidade . . . . . . .
7.7 Carro - Evitando efeitos colateiras . . . . . . . . .
7.8 Mquinas de Porcarias - Aumentando o controle .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
73
73
74
74
75
75
75
76
77
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
www.k19.com.br
iii
S UMRIO
7.9
7.10
7.11
7.12
8
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
78
79
80
82
Herana
8.1 Reutilizao de Cdigo . . . . . . . . . .
8.2 Uma classe para todos os servios . . .
8.3 Uma classe para cada servio . . . . . .
8.4 Uma classe genrica e vrias especficas
8.5 Preo Fixo . . . . . . . . . . . . . . . . . .
8.6 Reescrita de Mtodo . . . . . . . . . . .
8.7 Fixo + Especfico . . . . . . . . . . . . . .
8.8 Construtores e Herana . . . . . . . . . .
8.9 Exerccios de Fixao . . . . . . . . . . .
8.10 Exerccios Complementares . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
83
83
83
84
85
87
87
88
90
90
93
.
.
.
.
.
.
95
95
96
97
97
98
100
.
.
.
.
101
101
102
103
105
.
.
.
.
.
.
107
107
107
108
109
110
111
.
.
.
.
.
.
.
.
115
115
115
115
116
116
117
118
119
Polimorfismo
9.1 Controle de Ponto . . . . . . . . .
9.2 Modelagem dos funcionrios . .
9.3 UM . . . . . . . . . . . . . . . .
9.4 Melhorando o controle de ponto
9.5 Exerccios de Fixao . . . . . . .
9.6 Exerccios Complementares . . .
10 Classes Abstratas
10.1 Classes Abstratas . . . . . . .
10.2 Mtodos Abstratos . . . . . .
10.3 Exerccios de Fixao . . . .
10.4 Exerccios Complementares
11 Interfaces
11.1 Padronizao . . . . .
11.2 Contratos . . . . . . .
11.3 Exemplo . . . . . . . .
11.4 Polimorfismo . . . . .
11.5 Interface e Herana .
11.6 Exerccios de Fixao
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
12 Namespace
12.1 Organizao . . . . . . . . . . . . . . . . . .
12.2 O comando namespace . . . . . . . . . . . .
12.3 Namespaces Encadeados . . . . . . . . . . .
12.4 Namespace global . . . . . . . . . . . . . . .
12.5 Unqualified Name vs Fully Qualified Name
12.6 Using . . . . . . . . . . . . . . . . . . . . . .
12.7 Nveis de visibilidade . . . . . . . . . . . . .
12.8 Exerccios de Fixao . . . . . . . . . . . . .
13 Exceptions
www.k19.com.br
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
121
iii
S UMRIO
13.1
13.2
13.3
13.4
13.5
iv
Exceptions e SystemExceptions
Lanando erros . . . . . . . . .
Capturando erros . . . . . . . .
finally . . . . . . . . . . . . . . .
Exerccios de Fixao . . . . . .
14 Object
14.1 Polimorfismo . . . . .
14.2 O mtodo ToString() .
14.3 O mtodo Equals() . .
14.4 Exerccios de Fixao
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
121
122
122
123
123
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
125
125
126
128
129
15 String
131
15.1 Imutabilidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
15.2 Mtodos e Propriedades . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
15.3 Exerccios de Fixao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
16 Entrada e Sada
16.1 Leitura . . . . . . . . . . . . .
16.2 Escrita . . . . . . . . . . . . .
16.3 Exerccios de Fixao . . . .
16.4 Exerccios Complementares
17 Collections
17.1 Listas . . . . . . . . .
17.2 Exerccios de Fixao
17.3 Generics . . . . . . . .
17.4 Exerccios de Fixao
17.5 Conjuntos . . . . . . .
17.6 Colees . . . . . . .
17.7 Lao foreach . . . . .
17.8 Exerccios de Fixao
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
135
135
135
136
137
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
139
139
142
143
145
146
147
147
148
18 Threads
18.1 Definindo Tarefas . . . . . . . . . . .
18.2 Executando Tarefas . . . . . . . . . .
18.3 Exerccios de Fixao . . . . . . . . .
18.4 Controlando a Execuo das Tarefas
18.5 Exerccios de Fixao . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
149
149
150
150
151
152
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
A Respostas
iv
155
www.k19.com.br
S UMRIO
Sobre a K19
A K19 uma empresa especializada na capacitao de desenvolvedores de software. Sua equipe
composta por profissionais formados em Cincia da Computao pela Universidade de So Paulo
(USP) e que possuem vasta experincia em treinamento de profissionais para rea de TI.
O principal objetivo da K19 oferecer treinamentos de mxima qualidade que relacionados s
principais tecnologias utilizadas pelas empresas. Atravs desses treinamentos, seus alunos se tornam
capacitados para atuar no mercado de trabalho.
Visando a mxima qualidade, a K19 mantm as suas apostilas em constante renovao e melhoria, oferece instalaes fsicas apropriadas para o ensino e seus instrutores esto sempre atualizados
didtica e tecnicamente.
www.k19.com.br
S UMRIO
Seguro Treinamento
Na K19 o aluno faz o curso quantas vezes quiser!
Comprometida com o aprendizado e com a satisfao dos seus alunos, a K19 a nica que possui 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 no preenchidas at um dia antes do incio de uma turma da K19 sero destinadas ao
alunos que desejam utilizar o Seguro Treinamento. O valor da franquia para utilizar o Seguro Treinamento 10% do valor total do curso.
www.k19.com.br
S UMRIO
Termo de Uso
Termo de Uso
Todo o contedo desta apostila propriedade da K19 Treinamentos. A apostila pode ser utilizada
livremente para estudo pessoal . Alm disso, este material didtico pode ser utilizado como material
de apoio em cursos de ensino superior desde que a instituio correspondente seja reconhecida pelo
MEC (Ministrio da Educao) e que a K19 seja citada explicitamente como proprietria do material.
proibida qualquer utilizao desse material que no se enquadre nas condies acima sem
o prvio consentimento formal, por escrito, da K19 Treinamentos. O uso indevido est sujeito s
medidas legais cabveis.
www.k19.com.br
S UMRIO
S
TO
EN
AM
EIN
TREINAMENTOS
TR
EIN
AM
EN
TO
S
TR
www.k19.com.br/cursos
www.k19.com.br
CAPTULO
I NTRODUO
Objetivo
O objetivo fundamental dos treinamentos da K19 transmitir os conhecimentos necessrios para
que os seus alunos possam atuar no mercado de trabalho na rea de desenvolvimento de software.
As plataformas .NET e Java so as mais utilizadas no desenvolvimento de software. Para utilizar
os recursos oferecidos por essas plataformas de forma eficiente, necessrio possuir conhecimento
slido em orientao a objetos.
Orientao a Objetos
Um modelo de programao ou paradigma de programao um conjunto de princpios, ideias,
conceitos e abstraes utilizado para o desenvolvimento de uma aplicao.
Analogia
M
K
P B 0O
K X
E 8
T
80
E
1
B
Y
K
19
CABANA DE NDIO
IGLU
CASA OCIDENTAL
O modelo de programao mais adotado no desenvolvimento de sistemas corporativos o modelo orientado a objetos. Esse modelo utilizado com o intuito de obter alguns benefcios especficos. Normalmente, o principal benefcio desejado facilitar a manuteno das aplicaes.
www.k19.com.br
I NTRODUO
Em geral, os conceitos do modelo de programao orientado a objetos diminuem a complexidade do desenvolvimento de sistemas que possuem as seguintes caractersticas:
Sistemas com grande quantidade de funcionalidades desenvolvidos por uma equipe.
Sistemas que sero utilizados por um longo perodo de tempo e sofrero alteraes constantes.
Plataforma .NET
A plataforma .NET ser objeto de estudo desse treinamento. Mas, devemos salientar que os conceitos de orientao a objetos que sero vistos podero ser aplicados tambm na plataforma Java.
No primeiro momento, os dois elementos mais importantes da plataforma .NET so:
A linguagem de programao C#.
O ambiente de execuo .NET.
A linguagem de programao C# permite que os conceitos de orientao a objetos sejam aplicados no desenvolvimento de uma aplicao.
O ambiente de execuo .NET permite que uma aplicao .NET seja executada em diferentes
verses do Sistema Operacional Windows.
PLATAFORMA .NET
LINGUAGEM DE PROGRAMAO
ORIENTADA A OBJETOS
AMBIENTE DE EXECUO
www.k19.com.br
CAPTULO
L GICA
O que um Programa?
Um dos maiores benefcios da utilizao de computadores a automatizao de processos realizados manualmente por pessoas. Vejamos um exemplo prtico:
Quando as apuraes dos votos das eleies 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 diminuram drasticamente.
Basicamente, os computadores so capazes de executar instrues matemticas mais rapidamente do que o homem. Essa simples capacidade permite que eles resolvam problemas complexos
de maneira mais eficiente. Porm, eles no possuem a inteligncia necessria para definir quais
instrues devem ser executadas para resolver uma determinada tarefa. Por outro lado, os seres humano possuem essa inteligncia. Dessa forma, uma pessoa precisa definir um roteiro com a sequncia de comandos necessrios para realizar uma determinada tarefa e depois passar para um computador executar esse roteiro. Formalmente, esses roteiros so chamados de programas.
Os programas devem ser colocados em arquivos no disco rgido dos computadores. Assim, quando
as tarefas precisam ser realizadas, os computadores podem ler esses arquivos para saber quais instrues devem ser executadas.
Linguagem de Mquina
Os computadores s sabem ler instrues escritas em linguagem de mquina. Uma instruo
escrita em linguagem de mquina uma sequncia formada por 0s e 1s que representa a ao
que um computador deve executar.
000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000010000000000100000000
000000000000111000011111101110100000111000000000101101000000100
111001101001000011011100000000001010011001100110100100001010101
000110100001101001011100110010000001110000011100100110111101100
111011100100110000101101101001000000110001101100001011011100110
111001101111011101000010000001100010011001010010000001110010011
Figura 2.1: Cdigo de Mquina.
Teoricamente, as pessoas poderiam escrever os programas diretamente em linguagem de mquina. Na prtica, ningum faz isso pois uma tarefa muito complicada e demorada.
www.k19.com.br
L GICA
Linguagem de Programao
Como vimos anteriormente, escrever um programa em linguagem de mquina totalmente invivel para uma pessoa. Para resolver esse problema, surgiram as linguagens de programao, que
tentam se aproximar das linguagens humanas. Confira um trecho de um cdigo escrito com a linguagem de programao C#:
1
2
3
4
5
6
7
class OlaMundo
{
static void Main ()
{
System . Console . WriteLine ( " Ol Mundo " ) ;
}
}
Cdigo C# 2.1: OlaMundo.cs
Por enquanto voc pode no entender muito do que est escrito, porm fica bem claro que um
programa escrito dessa forma fica bem mais fcil de ser lido.
Um arquivo contendo as instrues de um programa em linguagem de programao chamado
de arquivo fonte.
Compilador
Por um lado, os computadores processam apenas instrues em linguagem de mquina. Por outro lado, as pessoas definem as instrues em linguagem de programao. Dessa forma, necessrio
traduzir o cdigo escrito em linguagem de programao por uma pessoa para um cdigo em linguagem de mquina para que um computador possa processar. Essa traduo realizada por programas
especiais chamados compiladores.
while(true){
if(x < 1){
return 0;
}
return 1;
}
CDIGO FONTE
PROCESSADOR
COMPILADOR
CDIGO DE MQUINA
NO EXECUTA
while(true){
if(x < 1){
return 0;
}
return 1;
}
CDIGO FONTE
PROCESSADOR
EXECUTA
Mquinas Virtuais
8
www.k19.com.br
L GICA
Assim como as pessoas podem se comunicar atravs de lnguas diferentes, os computadores podem se comunicar atravs de linguagens de mquina diferentes. A linguagem de mquina de um
computador definida pela arquitetura do processador desse computador. H diversas arquiteturas diferentes (Intel, ARM, PowerPC, etc) e cada uma delas define uma linguagem de mquina diferente. Em outras palavras, um programa pode no executar em computadores com processadores
de arquiteturas diferentes.
Os computadores so controlados por um sistema operacional que oferece diversas bibliotecas
necessrias para o desenvolvimento das aplicaes que podem ser executadas atravs dele. Sistemas
operacionais diferentes (Windows, Linux, Mac OS X, etc) possuem bibliotecas diferentes. Em outras
palavras, um programa pode no executar em computadores com sistemas operacionais diferentes.
Portanto, para determinar se um cdigo em linguagem de mquina pode ou no ser executada
por um computador, devemos considerar a arquitetura do processador e o sistema operacional desse
computador.
Algumas bibliotecas especficas de sistema operacional so chamadas diretamente pelas instrues em linguagem de programao. Dessa forma, geralmente, o cdigo fonte est amarrado a uma
plataforma (sistema operacional + arquitetura de processador).
PROGRAMA 1
PLATAFORMA 1
EXECUTA
PROGRAMA 2
PLATAFORMA 2
EXECUTA
PROGRAMA 2
PLATAFORMA 3
NO EXECUTA
Figura 2.3: Ilustrao mostrando que cada plataforma necessita de um executvel especfico.
Uma empresa que deseja ter a sua aplicao disponvel para diversos sistemas operacionais (Windows, Linux, Mac OS X, etc), e diversas arquiteturas de processador (Intel, ARM, PowerPC, etc), ter
que desenvolver verses diferentes do cdigo fonte para cada plataforma (sistema operacional + arquitetura de processador). Isso pode causar um impacto financeiro nessa empresa que inviabiliza o
negcio.
www.k19.com.br
L GICA
10
PROGRAMA
MQUINA VIRTUAL 1
PLATAFORMA 1
EXECUTA
MQUINA VIRTUAL 2
PLATAFORMA 2
EXECUTA
MQUINA VIRTUAL 3
PLATAFORMA 3
EXECUTA
Tudo parece estar perfeito agora. Porm, olhando atentamente a figura acima, percebemos que
existe a necessidade de uma mquina virtual para cada plataforma. Algum poderia dizer que, de
fato, o problema no foi resolvido, apenas mudou de lugar.
A diferena que implementar a mquina virtual no tarefa do programador que desenvolve
as aplicaes que sero executadas nela. A implementao da mquina virtual responsabilidade
de terceiros, que geralmente so empresas bem conceituadas ou projetos de cdigo aberto que envolvem programadores do mundo inteiro. Como maiores exemplos podemos citar a Microsoft CLR
(Common Language Runtime) e Mono CLR.
Uma desvantagem em utilizar uma mquina virtual para executar um programa a diminuio
de performance, j que a prpria mquina virtual consome recursos do computador. Alm disso, as
instrues do programa so processadas primeiro pela mquina virtual e depois pelo computador.
Por outro lado, as mquinas virtuais podem aplicar otimizaes que aumentam a performance
da execuo de um programa. Inclusive, essas otimizaes podem considerar informaes geradas
durante a execuo. So exemplos de informaes geradas durante a execuo: a quantidade de uso
da memria RAM e do processador do computador, a quantidade de acessos ao disco rgido, a quantidade de chamadas de rede e a frequncia de execuo de um determinado trecho do programa.
Algumas mquinas virtuais identificam os trechos do programa que esto sendo mais chamados
10
www.k19.com.br
11
L GICA
em um determinado momento da execuo para traduzi-los para a linguagem de mquina do computador. A partir da, esses trechos podem ser executados diretamente no processador sem passar
pela mquina virtual. Essa anlise da mquina virtual realizada durante toda a execuo.
Com essas otimizaes que consideram vrias informaes geradas durante a execuo, um programa executado com mquina virtual pode at ser mais eficiente em alguns casos do que um programa executado diretamente no sistema operacional.
Mais Sobre
Geralmente, as mquinas virtuais utilizam uma estratgia de compilao chamada
Just-in-time compilation (JIT). Nessa abordagem, o cdigo de mquina pode ser
gerado diversas vezes durante o processamento de um programa com o intuito de melhorar a
utilizao dos recursos disponveis em um determinado instante da execuo.
Exemplo de programa C#
Vamos criar um simples programa para entendermos como funciona o processo de compilao e
execuo. Utilizaremos a linguagem C#, que amplamente adotada nas empresas. Observe o cdigo
do exemplo de um programa escrito em C# que imprime uma mensagem na tela:
1
2
3
4
5
6
7
class OlaMundo
{
static void Main ()
{
System . Console . WriteLine ( " Ol Mundo " ) ;
}
}
Cdigo C# 2.2: OlaMundo.cs
O cdigo fonte C# deve ser colocado em arquivos com a extenso .cs. Agora, no necessrio entender todo o cdigo do exemplo. Basta saber que toda aplicao C# precisa ter um mtodo especial
chamado Main para executar.
O prximo passo compilar o cdigo fonte, para gerar um executvel que possa ser processado
pela mquina virtual do .NET. O compilador padro da plataforma .NET (csc) pode ser utilizado para
compilar esse arquivo. O compilador pode ser executado pelo terminal.
C :\ Users \ K19 \ Documents > csc OlaMundo . cs
Microsoft ( R ) Visual C # 2010 Compiler version 4.0.30319.1
Copyright ( C ) Microsoft Corporation . All rights reserved .
O cdigo gerado pelo compilador .NET armazenado em arquivos com a extenso .exe. No
exemplo, o programa gerado pelo compilador colocado em um arquivo chamado OlaMundo.exe e
ele pode ser executado atravs de um terminal.
C :\ Users \ K19 \ Documents > OlaMundo . exe
Ol Mundo
www.k19.com.br
11
L GICA
12
Importante
Para compilar e executar um programa escrito em C#, necessrio que voc tenha instalado e configurado em seu computador uma mquina virtual .NET. Verses mais recentes do Windows j possuem uma mquina virtual .NET instalada.
static
static
static
static
void Main ()
int Main ()
void Main ( string [] args )
int Main ( string [] args )
Cdigo C# 2.3: Variaes da Assinatura do Mtodo Main
Os parmetros do mtodo Main so passados pela linha de comando e podem ser manipulados
dentro do programa. O cdigo abaixo imprime cada parmetro recebido em uma linha diferente.
1
2
3
4
5
6
7
8
9
10
class Programa
{
static void Main ( string [] args )
{
for ( int i = 0; i < args . Length ; i ++)
{
System . Console . WriteLine ( args [ i ]) ;
}
}
}
Cdigo C# 2.4: Imprimindo os parmetros da linha de comando
Exerccios de Fixao
12
www.k19.com.br
13
L GICA
1
Abra um terminal e crie uma pasta com o seu nome. Voc deve salvar os seus exerccios nessa
pasta.
C :\ Users \ K19 \ Documents > md Marcelo
Dentro da sua pasta de exerccios, crie uma pasta para os arquivos desenvolvidos nesse captulo
chamada logica.
2
Crie um programa que imprima uma mensagem na tela. Adicione o seguinte arquivo na pasta
logica.
3
1
2
3
4
5
6
7
class OlaMundo
{
static void Main ()
{
System . Console . WriteLine ( " Ol Mundo " ) ;
}
}
Cdigo C# 2.5: OlaMundo.cs
Variveis
Basicamente, o que um programa faz manipular dados. Em geral, esses dados so armazenados
em variveis localizadas na memria RAM do computador. Uma varivel pode guardar dados de
vrios tipos: nmeros, textos, booleanos (verdadeiro ou falso), referncias de objetos. Alm disso,
toda varivel possui um nome que utilizado quando a informao dentro da vriavel precisa ser
manipulada pelo programa.
numeroDaConta
numeroDaConta = 4823
MEMRIA RAM
4823
numeroDaConta
MEMRIA RAM
Declarao
Na linguagem de programao C#, as variveis devem ser declaradas para que possam ser utilizadas. A declarao de uma varivel envolve definir um nome nico (identificador) dentro de um
www.k19.com.br
13
L GICA
14
escopo e um tipo de valor. As variveis so acessadas pelos nomes e armazenam valores compatveis
com o seu tipo.
1
2
3
4
5
Mais Sobre
Uma linguagem de programao dita estaticamente tipada quando ela exige que os
tipos das variveis sejam definidos antes da compilao. A linguagem C# uma linguagem estaticamente tipada.
Uma linguagem de programao dita fortemente tipada quando ela exige que os valores
armazenados em uma varivel sejam compatveis com o tipo da varivel. A linguagem C# uma
linguagem fortemente tipada.
Mais Sobre
Em geral, as linguagens de programao possuem convenes para definir os nomes
das variveis. Essas convenes ajudam o desenvolvimento de um cdigo mais legvel.
Na conveno de nomes da linguagem C#, os nomes das variveis devem seguir o padro camel
case com a primeira letra minscula. Esse padro tambm conhecido como lower camel
case. Veja alguns exemplos:
nomeDoCliente
numeroDeAprovados
A conveno de nomes da linguagem C# pode ser consultada na seguinte url: http://msdn.
microsoft.com/en-us/library/ms229002.aspx
A declarao de uma varivel pode ser realizada em qualquer linha de um bloco. No necessrio
declarar todas as variveis no comeo do bloco como acontece em algumas linguagens de programao.
1
2
3
4
5
6
7
8
9
10
11
14
www.k19.com.br
15
L GICA
No podemos declarar duas variveis com o mesmo nome em um nico bloco ou escopo pois
ocorrer um erro de compilao.
1
2
3
4
5
// Declarao
int numero = 10;
// Erro de Compilao
int numero = 10;
Cdigo C# 2.8: Duas vriaveis com o mesmo nome no mesmo bloco.
Inicializao
Toda varivel deve ser inicializada antes de ser utilizada pela primeira vez. Se isso no for realizado, ocorrer um erro de compilao. A inicializao realizada atravs do operador de atribuio
=. Esse operador guarda um valor em uma varivel.
1
2
3
4
5
6
7
8
9
10
11
12
// Declaraes
int numero ;
double preco ;
// Inicializao
numero = 10;
// Uso Correto
System . Console . WriteLine ( numero ) ;
// Erro de compilao
System . Console . WriteLine ( preco ) ;
Cdigo C# 2.9: Inicializao
Tipos Primitivos
A linguagem C# define um conjunto de tipos bsicos de dados que so chamados tipos primitivos. A tabela abaixo mostra os oito tipos primitivos da linguagem C# e os valores compatveis.
Tipo
sbyte
byte
short
ushort
int
uint
long
ulong
float
Descrio
Valor inteiro entre -128 e 127 (inclusivo)
Valor inteiro entre 0 e 255 (inclusivo)
Valor inteiro entre -32.768 e 32.767 (inclusivo)
Valor inteiro entre 0 e 65.535 (inclusivo)
Valor inteiro entre -2.147.483.648 e 2.147.483.647 (inclusivo)
Valor inteiro entre 0 e 4.294.967.295 (inclusivo)
Valor inteiro entre -9.223.372.036.854.775.808 e
9.223.372.036.854.775.807 (inclusivo)
Valor inteiro entre 0 e 18.446.744.073.709.551.615 (inclusivo)
Valor com ponto flutuante entre 1, 40129846432481707
1045 e 3, 40282346638528860 1038 (positivo ou negativo)
www.k19.com.br
Tamanho (peso)
1 byte
1 byte
2 bytes
2 bytes
4 bytes
4 bytes
8 bytes
8 bytes
4 bytes
15
L GICA
16
Tipo
double
decimal
bool
char
Descrio
Valor com ponto flutuante entre 4, 94065645841246544
10324 e 1, 79769313486231570 10308 (positivo ou negativo)
Valor com ponto flutuante entre 1, 0 1028 e 7, 9 1028
(positivo ou negativo)
true ou false
Um nico caractere Unicode de 16 bits. Valor inteiro e
positivo entre 0 (ou \u0000) e 65.535 (ou \uffff)
Tamanho (peso)
8 bytes
16 bytes
1 bit
2 bytes
Importante
Nenhum tipo primitivo da linguagem C# permite o armazenamento de texto. O tipo
primitivo char armazena apenas um caractere. Quando necessrio armazenar um
texto, devemos utilizar o tipo string. Contudo, importante salientar que o tipo string no
um tipo primitivo.
Operadores
Para manipular os valores das variveis de um programa, devemos utilizar os operadores oferecidos pela linguagem de programao adotada. A linguagem C# possui diversos operadores e os
principais so categorizados da seguinte forma:
Aritmtico (+, -, *, /, %)
Atribuio (=, +=, -=, *=, /=, %=)
Relacional (==, !=, <, <=, >, >=)
Lgico (&&, ||)
Aritmtico
Os operadores aritmticos funcionam de forma muito semelhante aos operadores na matemtica. Os operadores aritmticos so:
Soma +
Subtrao Multiplicao *
Diviso /
Mdulo %
1
2
3
4
16
int
int
int
int
umMaisUm = 1 + 1;
//
tresVezesDois = 3 * 2;
//
quatroDivididoPor2 = 4 / 2; //
seisModuloCinco = 6 % 5;
//
umMaisUm = 2
tresVezesDois = 6
quatroDivididoPor2 = 2
seisModuloCinco = 1
www.k19.com.br
17
5
6
7
8
L GICA
int
x =
x =
x =
x
x
x
x
=
+
/
7;
1 * 2;
// x = 14
4;
// x = 10
(6 - 2 + (3*5) /(16 -1) ) ; // x = 2
Cdigo C# 2.10: Exemplo de uso dos operadores aritmticos.
Importante
O mdulo de um nmero x , na matemtica, o valor numrico de x desconsiderando
o seu sinal (valor absoluto). Na matemtica expressamos o mdulo da seguinte forma:
| 2| = 2.
Em linguagens de programao, o mdulo de um nmero o resto da diviso desse nmero por
outro. No exemplo acima, o resto da diviso de 6 por 5 igual a 1. Alm disso, lemos a expresso
6%5 da seguinte forma: seis mdulo cinco.
Importante
As operaes aritmticas em C# obedecem as mesmas regras da matemtica com relao precedncia dos operadores e parnteses. Portanto, as operaes so resolvidas a
partir dos parnteses mais internos at os mais externos, primeiro resolvemos as multiplicaes,
divises e os mdulos. Em seguida, resolvemos as adies e subtraes.
Atribuio
Nas sees anteriores, j vimos um dos operadores de atribuio, o operador = (igual). Os operadores de atribuio so:
Simples =
Incremental +=
Decremental -=
Multiplicativa *=
Divisria /=
Modular %=
1
2
3
4
5
6
int valor = 1;
valor += 2;
valor -= 1;
valor *= 6;
valor /= 3;
valor %= 3;
//
//
//
//
//
//
valor
valor
valor
valor
valor
valor
=
=
=
=
=
=
1
3
2
12
4
1
int valor = 1;
valor = valor + 2;
valor = valor - 1;
www.k19.com.br
// valor = 1
// valor = 3
// valor = 2
17
L GICA
4
5
6
18
valor = valor * 6;
valor = valor / 3;
valor = valor % 3;
// valor = 12
// valor = 4
// valor = 1
Como podemos observar, os operadores de atribuio, com exceo do simples (=), reduzem a
quantidade de cdigo escrito. Podemos dizer que esses operadores funcionam como atalhos para
as operaes que utilizam os operadores aritmticos.
Relacional
Muitas vezes precisamos determinar a relao entre uma varivel ou valor e outra varivel ou
valor. Nessas situaes, utilizamos os operadores relacionais. As operaes realizadas com os operadores relacionais devolvem valores do tipo primitivo bool. Os operadores relacionais so:
Igualdade ==
Diferena !=
Menor <
Menor ou igual <=
Maior >
Maior ou igual >=
1
2
3
4
5
6
7
8
int valor = 2;
bool t = false ;
t = ( valor == 2) ;
t = ( valor != 2) ;
t = ( valor < 2) ;
t = ( valor <= 2) ;
t = ( valor > 1) ;
t = ( valor >= 1) ;
//
//
//
//
//
//
t
t
t
t
t
t
=
=
=
=
=
=
true
false
false
true
true
true
Lgico
A linguagem C# permite verificar duas ou mais condies atravs de operadores lgicos. Os operadores lgicos devolvem valores do tipo primitivo bool. Os operadores lgicos so:
E lgico &&
OU lgico ||
1
2
3
4
5
6
7
valor
valor
valor
valor
valor
> 20;
> 30;
> 20;
< 20;
== 30;
//
//
//
//
//
teste
teste
teste
teste
teste
=
=
=
=
=
true
false
true
false
true
18
www.k19.com.br
19
L GICA
IF-ELSE
O comportamento de uma aplicao pode ser influenciado por valores definidos pelos usurios.
Por exemplo, considere um sistema de cadastro de produtos. Se um usurio tenta adicionar um
produto com preo negativo, a aplicao no deve cadastrar esse produto. Caso contrrio, se o preo
no for negativo, o cadastro pode ser realizado normalmente.
Outro exemplo, quando o pagamento de um boleto realizado em uma agncia bancria, o sistema do banco deve verificar a data de vencimento do boleto para aplicar ou no uma multa por
atraso.
Para verificar uma determinada condio e decidir qual bloco de instrues deve ser executado,
devemos aplicar o comando if.
1
2
3
4
5
6
7
8
if ( preco < 0)
{
System . Console . WriteLine ( " O preo do produto no pode ser negativo " ) ;
}
else
{
System . Console . WriteLine ( " Produto cadastrado com sucesso " ) ;
}
Cdigo C# 2.15: Comando if
O comando if permite que valores booleanos sejam testados. Se o valor passado como parmetro para o comando if for true, o bloco do if executado. Caso contrrio, o bloco do else
executado.
O parmetro passado para o comando if deve ser um valor booleano, caso contrrio o cdigo
no compila. O comando else e o seu bloco so opcionais.
WHILE
Em alguns casos, necessrio repetir um trecho de cdigo diversas vezes. Suponha que seja
necessrio imprimir 10 vezes na tela a mensagem: Bom Dia. Isso poderia ser realizado colocando
10 linhas iguais a essa no cdigo fonte:
1
Se ao invs de 10 vezes fosse necessrio imprimir 100 vezes, j seriam 100 linhas iguais no cdigo
fonte. muito trabalhoso utilizar essa abordagem para esse problema.
Atravs do comando while, possvel definir quantas vezes um determinado trecho de cdigo
deve ser executado pelo computador.
1
2
3
4
int contador = 0;
while ( contador < 100)
{
www.k19.com.br
19
L GICA
5
6
7
20
A varivel contador indica o nmero de vezes que a mensagem Bom Dia foi impressa na tela.
O operador ++ incrementa a varivel contador a cada rodada.
O parmetro do comando while tem que ser um valor booleano. Caso contrrio, ocorrer um
erro de compilao.
FOR
O comando for anlogo ao while. A diferena entre esses dois comandos que o for recebe
trs argumentos.
1
2
3
Exerccios de Fixao
4
1
2
3
4
5
6
7
8
9
10
Imprima na tela o seu nome 100 vezes. Adicione na pasta logica o seguinte arquivo.
class ImprimeNome
{
static void Main ()
{
for ( int contador = 0; contador < 100; contador ++)
{
System . Console . WriteLine ( " Marcelo Martins " ) ;
}
}
}
Cdigo C# 2.19: ImprimeNome.cs
class ImprimeAte100
20
www.k19.com.br
21
2
3
4
5
6
7
8
9
10
L GICA
{
static void Main ()
{
for ( int contador = 1; contador <= 100; contador ++)
{
System . Console . WriteLine ( contador ) ;
}
}
}
Cdigo C# 2.20: ImprimeAte100.cs
Faa um programa que percorra todos os nmero de 1 at 100. Para os nmeros mpares, deve
ser impresso um *, e para os nmeros pares, deve ser impresso dois **. Veja o exemplo abaixo:
6
*
**
*
**
*
**
Adicione o seguinte arquivo na pasta logica.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class ImprimePadrao1
{
static void Main ()
{
for ( int contador = 1; contador <= 100; contador ++)
{
int resto = contador % 2;
if ( resto == 1)
{
System . Console . WriteLine ( " * " ) ;
}
else
{
System . Console . WriteLine ( " ** " ) ;
}
}
}
}
Cdigo C# 2.21: ImprimePadrao1.cs
www.k19.com.br
21
L GICA
22
Faa um programa que percorra todos os nmero de 1 at 100. Para os nmeros mltiplos de 4,
imprima a palavra PI, e para os outros, imprima o prprio nmero. Veja o exemplo abaixo:
7
1
2
3
PI
5
6
7
PI
class ImprimePadrao2
{
static void Main ()
{
for ( int contador = 1; contador <= 100; contador ++)
{
int resto = contador % 4;
if ( resto == 0)
{
System . Console . WriteLine ( " PI " ) ;
}
else
{
System . Console . WriteLine ( contador ) ;
}
}
}
}
Cdigo C# 2.22: ImprimePadrao2.cs
22
www.k19.com.br
23
L GICA
Exerccios Complementares
1
*
**
***
****
*****
2
Crie um programa que imprima na tela vrios tringulos de *. Observe o padro abaixo.
*
**
***
****
*
**
***
****
Os nmeros de Fibonacci so uma sequncia de nmeros definida recursivamente. O primeiro
elemento da sequncia 0 e o segundo 1. Os outros elementos so calculados somando os dois
antecessores.
3
www.k19.com.br
23
L GICA
24
Se digitar o numero 1, ele automaticamente tem de executar o cdigo para o padro 1, e assim
sucessivamente.
Abaixo est o esqueleto da sua classe:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
Padro 1
Padro 2
Padro 3
Padro 4
Padro 5
}
}
}
Cdigo C# 2.26: GeradorDePadroes.cs
24
www.k19.com.br
CAPTULO
O RIENTAO A O BJETOS
Domnio e Aplicao
Um domnio composto pelas entidades, informaes e processos relacionados a um determinado contexto. Uma aplicao pode ser desenvolvida para automatizar ou tornar factvel as tarefas
de um domnio. Portanto, uma aplicao basicamente o reflexo de um domnio.
Para exemplificar, suponha que estamos interessados em desenvolver uma aplicao para facilitar as tarefas do cotidiano de um banco. Podemos identificar clientes, funcionrios, agncias e contas como entidades desse domnio. Assim como podemos identificar as informaes e os processos
relacionados a essas entidades.
FUNCIONRIO
JONAS
CONTA DO
JOS
CLIENTE
JOS
CONTA DA
MARIA
FUNCIONRIO
MARCELO
CLIENTE
MARIA
CLIENTE
JOO
CONTA DO
JOO
FUNCIONRIO
RAFAEL
DOMNIO BANCRIO
Figura 3.1: Domnio bancrio
www.k19.com.br
25
O RIENTAO A O BJETOS
26
Mais Sobre
A identificao dos elementos de um domnio uma tarefa difcil, pois depende fortemente do conhecimento das entidades, informaes e processos que o compem. Em
geral, as pessoas que possuem esse conhecimento ou parte dele esto em contato constante com
o domnio e no possuem conhecimentos tcnicos para desenvolver uma aplicao.
Desenvolvedores de software buscam constantemente mecanismos para tornar mais eficiente o
entendimento dos domnios para os quais eles devem desenvolver aplicaes.
www.k19.com.br
27
O RIENTAO A O BJETOS
Funcionario
nome = Jonas Hirata
codigo = 3
salario = 3000
Funcionario
nome = Marcelo Rezende
codigo = 2
salario = 2000
TiraFerias
AumentaSalario
MudaHorario
Funcionario
FUNCIONRIO
JONAS
TiraFerias
AumentaSalario
MudaHorario
FUNCIONRIO
MARCELO
FUNCIONRIO
RAFAEL
TiraFerias
AumentaSalario
MudaHorario
Conta
saldo = 8000
numero = 3
CONTA DA
MARIA
Conta
saldo = 4000
numero = 2
CONTA DO
JOS
Deposita
Saca
GeraExtrato
Conta
CONTA DO
JOO
Deposita
Saca
GeraExtrato
saldo = 2000
numero = 1
Deposita
Saca
GeraExtrato
Cliente
nome = Maria do Bairro
codigo = 3
Cliente
MudaEndereco
FazEmprestimo
Cliente
CLIENTE
MARIA
CLIENTE
JOS
MudaEndereco
FazEmprestimo
CLIENTE
JOO
DOMNIO BANCRIO
APLICAO
www.k19.com.br
27
O RIENTAO A O BJETOS
28
Mais Sobre
Em geral, no adequado utilizar o objeto que representa um determinado cliente
para representar outro cliente do banco, pois os dados dos clientes podem ser diferentes. Dessa forma, para cada cliente do banco, deve existir um objeto dentro do sistema para
represent-lo.
Mais Sobre
Os objetos no representam apenas coisas concretas como os clientes do banco. Eles
tambm devem ser utilizados para representar coisas abstratas como uma conta de um
cliente ou um servio que o banco oferea.
Classes
Antes de um objeto ser criado, devemos definir quais sero os seus atributos e mtodos. Essa
definio realizada atravs de uma classe elaborada por um programador. A partir de uma classe,
podemos construir objetos na memria do computador que executa a nossa aplicao.
Podemos representar uma classe atravs de diagramas UML. O diagrama UML de uma classe
composto pelo nome da mesma e pelos atributos e mtodos que ela define. Todos os objetos criados
a partir da classe Conta tero os atributos e mtodos mostrados no diagrama UML. Os valores dos
atributos de dois objetos criados a partir da classe Conta podem ser diferentes.
Analogia
M
K
P B 0O
K X
E 8
T
80
E
1
B
Y
K
19
Um objeto como se fosse uma casa ou um prdio. Para ser construdo, precisa de um
espao fsico. No caso dos objetos, esse espao fsico algum trecho vago da memria
do computador que executa a aplicao. No caso das casas e dos prdios, o espao fsico algum
terreno vazio.
Um prdio construdo a partir de uma planta criada por um engenheiro ou arquiteto. Para
criar um objeto, necessrio algo semelhante a uma planta para que sejam desenhados os
atributos e mtodos que o objeto deve ter. Em orientao a objetos, a planta de um objeto o
que chamamos de classe.
28
www.k19.com.br
29
O RIENTAO A O BJETOS
Uma classe funciona como uma receita para criar objetos. Inclusive, vrios objetos podem ser
criados a partir de uma nica classe. Assim como vrias casas ou prdios poderiam ser construdos a partir de uma nica planta; ou vrios bolos poderiam ser preparados a partir de uma nica
receita; ou vrios carros poderiam ser construdos a partir de um nico projeto.
Basicamente, as diferenas entre dois objetos criados a partir da classe Conta so os valores dos
seus atributos. Assim como duas casas construdas a partir da mesma planta podem possuir
caractersticas diferentes. Por exemplo, a cor das paredes.
www.k19.com.br
29
O RIENTAO A O BJETOS
30
Classes em C#
O conceito de classe apresentado anteriormente genrico e pode ser aplicado em diversas linguagens de programao. Mostraremos como a classe Conta poderia ser escrita utilizando a linguagem C#. Inicialmente, discutiremos apenas sobre os atributos. Os mtodos sero abordados
posteriormente.
1
2
3
4
5
6
class Conta
{
public double saldo ;
public double limite ;
public int numero ;
}
Cdigo C# 3.1: Conta.cs
A classe C# Conta declarada utilizando a palavra reservada class. No corpo dessa classe, so
declaradas trs variveis que so os atributos que os objetos possuiro. Como a linguagem C#
estaticamente tipada, os tipos dos atributos so definidos no cdigo. Os atributos saldo e limite
so do tipo double, que permite armazenar nmeros com casas decimais, e o atributo numero do
tipo int, que permite armazenar nmeros inteiros. O modificador public adicionado em cada
atributo para que eles possam ser acessados a partir de qualquer ponto do cdigo. Discutiremos
sobre esse e outros modificadores de visibilidade em captulos posteriores.
Importante
Por conveno, os nomes das classes na linguagem C# devem seguir o padro pascal
case tambm conhecido como upper camel case.
Criando objetos em C#
Aps definir a classe Conta, podemos criar objetos a partir dela. Esses objetos devem ser alocados
na memria RAM do computador. Felizmente, todo o processo de alocao do objeto na memria
gerenciado pela mquina virtual. O gerenciamento da memria um dos recursos mais importantes
oferecidos pela mquina virtual.
Do ponto de vista da aplicao, basta utilizar um comando especial para criar objetos e a mquina virtual se encarrega do resto. O comando para criar objetos o new.
1
2
3
4
5
6
7
class TestaConta
{
static void Main ()
{
new Conta () ;
}
}
Cdigo C# 3.2: TestaConta.cs
A linha com o comando new poderia ser repetida cada vez que desejssemos criar (instanciar)
um objeto da classe Conta. A classe TestaConta serve apenas para colocarmos o mtodo Main, que
o ponto de partida da aplicao.
30
www.k19.com.br
31
1
2
3
4
5
6
7
8
9
10
O RIENTAO A O BJETOS
class TestaConta
{
static void Main ()
{
// criando trs objetos
new Conta () ;
new Conta () ;
new Conta () ;
}
}
Cdigo C# 3.3: TestaConta.cs
Analogia
M
K
P B 0O
K X
E 8
T
80
E
1
B
Y
K
19
CASA
PROGRAMADOR
PEDREIRO
PLANTA
Figura 3.8: Construindo casas
Referncias
Todo objeto possui uma referncia. A referncia de um objeto a nica maneira de acessar os
seus atributos e mtodos. Dessa forma, devemos guardar as referncias dos objetos que desejamos
utilizar.
Analogia
M
K
P B 0O
K X
E 8
T
80
E
1
B
Y
K
19
www.k19.com.br
31
O RIENTAO A O BJETOS
32
Uma referncia est para um objeto assim como um controle remoto est para um aparelho de
TV. Atravs do controle remoto de uma TV voc pode aumentar o volume ou trocar de canal.
Analogamente, podemos controlar um objeto atravs da referncia do mesmo.
1
2
-/--
0
CH
Referncias em C#
Ao utilizar o comando new, um objeto alocado em algum lugar da memria. Para que possamos
acessar esse objeto, precisamos de sua referncia. O comando new devolve a referncia do objeto que
foi criado.
Para guardar as referncias devolvidas pelo comando new, devemos utilizar variveis no primitivas.
1
No cdigo C# acima, a varivel referencia receber a referncia do objeto criado pelo comando
new. Essa varivel do tipo Conta. Isso significa que ela s pode armazenar referncias de objetos do
tipo Conta.
Manipulando Atributos
Podemos alterar ou acessar os valores guardados nos atributos de um objeto se tivermos a referncia a esse objeto. Os atributos so acessados pelo nome. No caso especfico da linguagem C#, a
sintaxe para acessar um atributo utiliza o operador ".".
1
2
3
4
5
6
7
8
9
32
www.k19.com.br
33
O RIENTAO A O BJETOS
No cdigo acima, o atributo saldo recebe o valor 1000.0. O atributo limite recebe o valor
500 e o numero recebe o valor 1. Depois, os valores so impressos na tela atravs do comando
System.Console.WriteLine.
Valores Padro
Poderamos instanciar um objeto e utilizar seus atributos sem inicializ-los explicitamente, pois
os atributos so inicializados com valores padro. Os atributos de tipos numricos so inicializados
com 0, os atributos do tipo boolean so inicializados com false e os demais atributos com null
(referncia vazia).
1
2
3
4
class Conta
{
public double limite ;
}
Cdigo C# 3.6: Conta.cs
1
2
3
4
5
6
7
8
9
10
class TestaConta
{
static void Main ()
{
Conta conta = new Conta () ;
// imprime 0
System . Console . WriteLine ( conta . limite ) ;
}
}
Cdigo C# 3.7: TestaConta.cs
A inicializao dos atributos com os valores padro ocorre na instanciao, ou seja, quando o
comando new utilizado. Dessa forma, todo objeto nasce com os valores padro. Em alguns casos,
necessrio trocar esses valores. Para trocar o valor padro de um atributo, devemos inicializ-lo na
declarao. Por exemplo, suponha que o limite padro das contas de um banco seja R$ 500. Nesse
caso, seria interessante definir esse valor como padro para o atributo limite.
1
2
3
4
class Conta
{
public double limite = 500;
}
Cdigo C# 3.8: Conta.cs
1
2
3
4
5
6
7
8
9
class TestaConta
{
static void Main ()
{
Conta conta = new Conta () ;
// imprime 500
System . Console . WriteLine ( conta . limite ) ;
}
www.k19.com.br
33
O RIENTAO A O BJETOS
10
34
}
Cdigo C# 3.9: TestaConta.cs
Exerccios de Fixao
1 Dentro da sua pasta de exerccios, crie uma pasta chamada orientacao-a-objetos para os arquivos desenvolvidos neste captulo.
C :\ Users \ K19 \ Marcelo > md orientacao -a - objetos
2 Implemente uma classe para definir os objetos que representaro os clientes de um banco. Essa
classe deve declarar dois atributos: um para os nomes e outro para os cdigos dos clientes. Adicione
o seguinte arquivo na pasta orientacao-a-objetos.
1
2
3
4
5
class Cliente
{
public string nome ;
public int codigo ;
}
Cdigo C# 3.10: Cliente.cs
3
Faa um teste criando dois objetos da classe Cliente. Adicione o seguinte arquivo na pasta
orientacao-a-objetos.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class TestaCliente
{
static void Main ()
{
Cliente c1 = new Cliente () ;
c1 . nome = " Rafael Cosentino " ;
c1 . codigo = 1;
Cliente c2 = new Cliente () ;
c2 . nome = " Jonas Hirata " ;
c2 . codigo = 2;
System . Console . WriteLine ( c1 . nome ) ;
System . Console . WriteLine ( c1 . codigo ) ;
System . Console . WriteLine ( c2 . nome ) ;
System . Console . WriteLine ( c2 . codigo ) ;
}
}
Cdigo C# 3.11: TestaCliente.cs
34
www.k19.com.br
35
1
2
3
4
5
O RIENTAO A O BJETOS
class CartaoDeCredito
{
public int numero ;
public string dataDeValidade ;
}
Cdigo C# 3.12: CartaoDeCredito.cs
5
Faa um teste criando dois objetos da classe CartaoDeCredito. Altere e imprima os atributos
desses objetos. Adicione o seguinte arquivo na pasta orientacao-a-objetos.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class TestaCartaoDeCredito
{
static void Main ()
{
CartaoDeCredito cdc1 = new CartaoDeCredito () ;
cdc1 . numero = 111111;
cdc1 . dataDeValidade = " 01/01/2013 " ;
CartaoDeCredito cdc2 = new CartaoDeCredito () ;
cdc2 . numero = 222222;
cdc2 . dataDeValidade = " 01/01/2014 " ;
System . Console . WriteLine ( cdc1 . numero ) ;
System . Console . WriteLine ( cdc1 . dataDeValidade ) ;
System . Console . WriteLine ( cdc2 . numero ) ;
System . Console . WriteLine ( cdc2 . dataDeValidade ) ;
}
}
Cdigo C# 3.13: TestaCartaoDeCredito.cs
1
2
3
4
class Agencia
{
public int numero ;
}
Cdigo C# 3.14: Agencia.cs
7
Faa um teste criando dois objetos da classe Agencia. Altere e imprima os atributos desses
objetos. Adicione o seguinte arquivo na pasta orientacao-a-objetos.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class TestaAgencia
{
static void Main ()
{
Agencia a1 = new Agencia () ;
a1 . numero = 1234;
Agencia a2 = new Agencia () ;
a2 . numero = 5678;
System . Console . WriteLine ( a1 . numero ) ;
System . Console . WriteLine ( a2 . numero ) ;
}
}
www.k19.com.br
35
O RIENTAO A O BJETOS
36
1
2
3
4
5
6
class Conta
{
public int numero ;
public double saldo ;
public double limite ;
}
Cdigo C# 3.16: Conta.cs
9 Faa um teste criando dois objetos da classe Conta. Altere e imprima os atributos desses objetos.
Adicione o seguinte arquivo na pasta orientacao-a-objetos.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class TestaConta
{
static void Main ()
{
Conta c1 = new Conta () ;
c1 . numero = 1234;
c1 . saldo = 1000;
c1 . limite = 500;
Conta c2 = new Conta () ;
c2 . numero = 5678;
c2 . saldo = 2000;
c2 . limite = 250;
System . Console . WriteLine ( c1 . numero ) ;
System . Console . WriteLine ( c1 . saldo ) ;
System . Console . WriteLine ( c1 . limite ) ;
System . Console . WriteLine ( c2 . numero ) ;
System . Console . WriteLine ( c2 . saldo ) ;
System . Console . WriteLine ( c2 . limite ) ;
}
}
Cdigo C# 3.17: TestaConta.cs
1
2
3
4
5
6
7
8
9
10
11
Faa um teste que imprima os atributos de um objeto da classe Conta logo aps a sua criao.
class TestaValoresPadrao
{
static void Main ()
{
Conta c = new Conta () ;
System . Console . WriteLine ( c . numero ) ;
System . Console . WriteLine ( c . saldo ) ;
System . Console . WriteLine ( c . limite ) ;
}
}
Cdigo C# 3.18: TestaValoresPadrao.cs
36
www.k19.com.br
37
O RIENTAO A O BJETOS
Altere a classe Conta para que todos os objetos criados a partir dessa classe possuam R$ 100 de
limite inicial.
1
2
3
4
5
6
7
8
class Conta
{
public int numero ;
public double saldo ;
// Adicione a linha abaixo
public double limite = 100;
}
Exerccios Complementares
Implemente uma classe chamada Aluno na pasta orientacao-a-objetos para definir os objetos
que representaro os alunos de uma escola. Essa classe deve declarar trs atributos: o primeiro para
o nome, o segundo para o RG e o terceiro para a data de nascimento dos alunos.
1
2
Faa uma classe chamada TestaAluno e crie dois objetos da classe Aluno atribuindo valores a
eles. A classe tambm deve mostrar na tela as informaes desses objetos.
Em uma escola, alm dos alunos temos os funcionrios, que tambm precisam ser representados em nossa aplicao. Ento implemente outra classe na pasta orientacao-a-objetos chamada
Funcionario que contenha trs atributos: o primeiro para o nome e o segundo para o cargo o terceiro cargo dos funcionrios
3
4
Faa uma classe chamada TestaFuncionario e crie dois objetos da classe Funcionario atribuindo valores a eles. Mostre na tela as informaes desses objetos.
5 Em uma escola, os alunos precisam ser divididos por turmas, que devem ser representadas dentro da aplicao. Implemente na pasta orientacao-a-objetos um classe chamada Turma que contenha quatro atributos: o primeiro para o perodo, o segundo para definir a srie, o terceiro para sigla
e o quarto para o tipo de ensino.
Faa uma classe chamada TestaTurma para criar dois objetos da classe Turma. Adicione informaes a eles e depois mostre essas informaes na tela.
6
37
O RIENTAO A O BJETOS
38
DEBIT
DEBIT
DEBIT
Duas classes deveriam ser criadas: uma para definir os atributos e mtodos dos clientes e outra
para os atributos e mtodos dos cartes de crdito. Para expressar o relacionamento entre cliente e
carto de crdito, podemos adicionar um atributo do tipo Cliente na classe CartaoDeCredito.
1
2
3
4
class Cliente
{
public string nome ;
}
Cdigo C# 3.26: Cliente.cs
1
2
3
4
5
6
class CartaoDeCredito
{
public int numero ;
public string dataDeValidade ;
public Cliente cliente ;
}
Cdigo C# 3.27: CartaoDeCredito.cs
www.k19.com.br
39
1
2
3
4
5
6
7
8
9
O RIENTAO A O BJETOS
// Criando um objeto de cada classe
CartaoDeCredito cdc = new CartaoDeCredito () ;
Cliente c = new Cliente () ;
// Ligando os objetos
cdc . cliente = c ;
// Acessando o nome do cliente
cdc . cliente . nome = " Rafael Cosentino " ;
Cdigo C# 3.28: Concretizando uma agregaco
CARTO
numero = 123
dataValidade = 01/2012
cliente = null
CARTO
numero = 123
dataValidade = 01/2012
cliente = null
CARTO
numero = 123
dataValidade = 01/2012
cliente
CLIENTE
nome = Jonas Hirata
cpf = 123.456.789-0
CLIENTE
nome = Jonas Hirata
cpf = 123.456.789-0
Exerccios de Fixao
12
Defina um vnculo entre os objetos que representam os clientes e os objetos que representam
os cartes de crdito. Para isso, voc deve alterar a classe CartaoDeCredito.
1
2
3
4
5
6
7
8
9
class CartaoDeCredito
{
public int numero ;
public string dataDeValidade ;
// Adicione a linha abaixo
public Cliente cliente ;
}
Cdigo C# 3.29: CartaoDeCredito.cs
13
www.k19.com.br
39
O RIENTAO A O BJETOS
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
40
class TestaClienteECartao
{
static void Main ()
{
// Criando alguns objetos
Cliente c = new Cliente () ;
CartaoDeCredito cdc = new CartaoDeCredito () ;
// Carregando alguns dados
c . nome = " Rafael Cosentino " ;
cdc . numero = 111111;
// Ligando os objetos
cdc . cliente = c ;
System . Console . WriteLine ( cdc . numero ) ;
System . Console . WriteLine ( cdc . cliente . nome ) ;
}
}
Cdigo C# 3.30: TestaClienteECartao.cs
1
2
3
4
5
6
7
8
9
class Conta
{
public int numero ;
public double saldo ;
public double limite = 100;
// Adicione a linha abaixo
public Agencia agencia ;
}
Cdigo C# 3.31: Conta.cs
15
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
www.k19.com.br
41
O RIENTAO A O BJETOS
Exerccios Complementares
7
Defina um vnculo entre os alunos e as turmas, criando na classe Aluno um atributo do tipo
Turma.
8
Teste o relacionamento entre os alunos e as turmas, criando um objeto de cada classe e atribuindo valores a eles. Exiba na tela os valores que esto nos atributos da turma atravs do objeto da
classe Aluno.
Mtodos
No banco, possvel realizar diversas operaes em uma conta: depsito, saque, transferncia,
consultas e etc. Essas operaes podem modificar ou apenas acessar os valores dos atributos dos
objetos que representam as contas.
Essas operaes so realizadas em mtodos definidos na prpria classe Conta. Por exemplo, para
realizar a operao de depsito, podemos acrescentar o seguinte mtodo na classe Conta.
1
2
3
4
Nome: utilizado para chamar o mtodo. Na linguagem C#, uma boa prtica definir os nomes
dos mtodos utilizando a conveno Camel Case com a primeira letra maiscula.
Lista de Parmetros: Define os valores que o mtodo deve receber. Mtodos que no devem receber nenhum valor possuem a lista de parmetros vazia.
Retorno: A resposta que ser devolvida ao final do processamento do mtodo. Quando um mtodo
no devolve nenhuma resposta, ele deve ser marcado com a palavra reservada void.
www.k19.com.br
41
O RIENTAO A O BJETOS
Retorno
void
42
Nome
Lista de parmetros
this.saldo += valor;
}
Corpo
Para realizar um depsito, devemos chamar o mtodo Deposita() atravs da referncia do objeto que representa a conta que ter o dinheiro creditado.
42
www.k19.com.br
43
1
2
3
4
5
O RIENTAO A O BJETOS
// Referncia de um objeto
Conta c = new Conta () ;
// Chamando o mtodo Deposita ()
c . Deposita (1000) ;
Cdigo C# 3.36: Chamando o mtodo Deposita()
Normalmente, os mtodos acessam ou alteram os valores armazenados nos atributos dos objetos. Por exemplo, na execuo do mtodo Deposita(), necessrio alterar o valor do atributo saldo
do objeto que foi escolhido para realizar a operao.
Dentro de um mtodo, para acessar os atributos do objeto que est processando o mtodo, devemos utilizar a palavra reservada this.
1
2
3
4
O mtodo Deposita() no possui nenhum retorno lgico. Por isso, foi marcado com void. Mas,
para outros mtodos, pode ser necessrio definir um tipo de retorno especfico.
Considere, por exemplo, um mtodo para realizar a operao que consulta o saldo disponvel
das contas. Suponha tambm que o saldo disponvel igual a soma do saldo e do limite. Ento, esse
mtodo deve somar os atributos saldo e limite e devolver o resultado. Por outro lado, esse mtodo
no deve receber nenhum valor, pois todas as informaes necessrias para realizar a operao esto
nos atributos dos objetos que representam as contas.
1
2
3
4
double ConsultaSaldoDisponivel ()
{
return this . saldo + this . limite ;
}
Cdigo C# 3.38: Mtodo com retorno double
Exerccios de Fixao
16
Acrescente alguns mtodos na classe Conta para realizar as operaes de deposito, saque, impresso de extrato e consulta do saldo disponvel.
www.k19.com.br
43
O RIENTAO A O BJETOS
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
44
class Conta
{
public int numero ;
public double saldo ;
public double limite = 100;
public Agencia agencia ;
// Adicione os mtodos abaixo
public void Deposita ( double valor )
{
this . saldo += valor ;
}
public void Saca ( double valor )
{
this . saldo -= valor ;
}
public void ImprimeExtrato ()
{
System . Console . WriteLine ( " SALDO : " + this . saldo ) ;
}
public double ConsultaSaldoDisponivel ()
{
return this . saldo + this . limite ;
}
}
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Exerccios Complementares
9 Sabendo que qualquer empresa possui funcionrios, crie uma classe chamada Funcionario para
represent-los. Acrescente os atributos nome e salario a essa classe. Alm disso, voc deve criar dois
44
www.k19.com.br
45
O RIENTAO A O BJETOS
mtodos: um para aumentar o salrio e outro para consultar os dados dos funcionrios.
10
Crie uma classe chamada TestaFuncionario para testar os mtodos de um objeto da classe
Funcionario.
Sobrecarga (Overloading)
Os clientes dos bancos costumam consultar periodicamente informaes relativas s suas contas. Geralmente, essas informaes so obtidas atravs de extratos. No sistema do banco, os extratos
podem ser gerados por mtodos da classe Conta.
1
2
3
4
5
6
7
8
9
10
class Conta
{
public double saldo ;
public double limite ;
public void ImprimeExtrato ( int dias )
{
// extrato
}
}
Cdigo C# 3.44: Conta.cs
O mtodo ImprimeExtrato() recebe a quantidade de dias que deve ser considerada para gerar
o extrato da conta. Por exemplo, se esse mtodo receber o valor 30 ento ele deve gerar um extrato
com as movimentaes dos ltimos 30 dias.
Em geral, extratos dos ltimos 15 dias atendem as necessidades dos clientes. Dessa forma, poderamos acrescentar um mtodo na classe Conta para gerar extratos com essa quantidade fixa de
dias.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Conta
{
public double saldo ;
public double limite ;
public void ImprimeExtrato ()
{
// extrato dos ltimos 15 dias
}
public void ImprimeExtrato ( int dias )
{
// extrato
}
}
Cdigo C# 3.45: Conta.cs
O primeiro mtodo no recebe parmetros pois ele utilizar uma quantidade de dias padro
definida pelo banco para gerar os extratos (15 dias).
O segundo recebe um valor inteiro como parmetro e deve considerar essa quantidade de dias
para gerar os extratos.
Os dois mtodos possuem o mesmo nome e lista de parmetros diferentes. Quando dois ou mais
www.k19.com.br
45
O RIENTAO A O BJETOS
46
mtodos so definidos na mesma classe com o mesmo nome, dizemos que houve uma sobrecarga
de mtodos. Uma sobrecarga de mtodos s vlida se as listas de parmetros dos mtodos so
diferentes entre si.
No caso dos dois mtodos que geram extratos, poderamos evitar repetio de cdigo fazendo
um mtodo chamar o outro.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Conta
{
public double saldo ;
public double limite ;
public void ImprimeExtrato ( int dias )
{
// extrato
}
public void ImprimeExtrato ()
{
this . ImprimeExtrato (15) ;
}
}
Cdigo C# 3.46: Conta.cs
Exerccios de Fixao
18
Crie uma classe chamada Gerente para definir os objetos que representaro os gerentes do
banco. Defina dois mtodos de aumento salarial nessa classe. O primeiro deve aumentar o salrio
com uma taxa fixa de 10%. O segundo deve aumentar o salrio com uma taxa varivel.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Gerente
{
public String nome ;
public double salario ;
public void AumentaSalario ()
{
this . AumentaSalario (0.1) ;
}
public void AumentaSalario ( double taxa )
{
this . salario += this . salario * taxa ;
}
}
Cdigo C# 3.47: Gerente.cs
19
1
2
3
4
5
6
7
8
9
class TestaGerente
{
static void Main ()
{
Gerente g = new Gerente () ;
g . salario =1000;
46
www.k19.com.br
47
10
11
12
13
14
15
16
17
18
19
20
O RIENTAO A O BJETOS
System . Console . WriteLine ( " Aumentando o salrio em 10% " ) ;
g . AumentaSalario () ;
System . Console . WriteLine ( " Salrio : " + g . salario ) ;
System . Console . WriteLine ( " Aumentando o salrio em 30% " ) ;
g . AumentaSalario (0.3) ;
System . Console . WriteLine ( " Salrio : " + g . salario ) ;
}
}
Cdigo C# 3.48: TestaGerente.cs
Construtores
No domnio de um banco, todo carto de crdito deve possuir um nmero. Toda agncia deve
possuir um nmero. Toda conta deve estar associada a uma agncia.
Aps criar um objeto para representar um carto de crdito, poderamos definir um valor para
o atributo numero. De maneira semelhante, podemos definir um nmero para um objeto da classe
Agencia e uma agncia para um objeto da classe Conta.
1
2
1
2
1
2
Definir os valores dos atributos obrigatrios de um objeto logo aps a criao dele resolveria as
restries do sistema do banco. Porm, nada garante que todos os desenvolvedores sempre lembrem
de inicializar esses valores.
Para no correr esse risco, podemos utilizar construtores. Um construtor permite que um determinado trecho de cdigo seja executado toda vez que um objeto criado, ou seja, toda vez que
o operador new chamado. Assim como os mtodos, os construtores podem receber parmetros.
Contudo, diferentemente dos mtodos, os construtores no devolvem resposta.
Em C#, um construtor deve ter o mesmo nome da classe na qual ele foi definido.
1
2
3
4
5
class CartaoDeCredito
{
public int numero ;
public CartaoDeCredito ( int numero )
www.k19.com.br
47
O RIENTAO A O BJETOS
6
7
8
9
48
{
this . numero = numero ;
}
}
Cdigo C# 3.52: CartaoDeCredito.cs
1
2
3
4
5
6
7
8
9
class Agencia
{
public int numero ;
public Agencia ( int numero )
{
this . numero = numero ;
}
}
Cdigo C# 3.53: Agencia.cs
1
2
3
4
5
6
7
8
9
class Conta
{
Agencia agencia ;
public Conta ( Agencia agencia )
{
this . agencia = agencia ;
}
}
Cdigo C# 3.54: Conta.cs
Na criao de um objeto com o comando new, os argumentos passados devem ser compatveis
com a lista de parmetros de algum construtor definido na classe que est sendo instanciada. Caso
contrrio, um erro de compilao ocorrer para avisar o desenvolvedor dos valores obrigatrios que
devem ser passados para criar um objeto.
1
2
3
4
5
6
1
2
3
4
5
6
7
8
// ERRO DE COMPILAO
CartaoDeCredito cdc = new CartaoDeCredito () ;
// ERRO DE COMPILAO
Agencia a = new Agencia () ;
// ERRO DE COMPILAO
Conta c = new Conta () ;
Cdigo C# 3.56: Construtores
Construtor Padro
Toda vez que um objeto criado, um construtor da classe correspondente deve ser chamado.
Mesmo quando nenhum construtor for definido explicitamente, h um construtor padro que ser
48
www.k19.com.br
49
O RIENTAO A O BJETOS
inserido pelo prprio compilador. O construtor padro no recebe parmetros e ser inserido sempre que o desenvolvedor no definir pelo menos um construtor explicitamente.
Portanto, para instanciar uma classe que no possui construtores definidos no cdigo fonte, devemos utilizar o construtor padro, j que este inserido automaticamente pelo compilador.
1
2
3
4
class Conta
{
}
Cdigo C# 3.57: Conta.cs
1
2
Lembrando que o construtor padro s ser inserido pelo compilador se nenhum construtor for
definido no cdigo fonte. Dessa forma, se voc adicionar um construtor com parmetros ento no
poder utilizar o comando new sem passar argumentos, pois um erro de compilao ocorrer.
1
2
3
4
5
6
7
8
9
class Agencia
{
public int numero ;
public Agencia ( int numero )
{
this . numero = numero ;
}
}
Cdigo C# 3.59: Agencia.cs
1
2
// ERRO DE COMPILAO
Agencia a = new Agencia () ;
Cdigo C# 3.60: Chamando um construtor sem argumentos
Sobrecarga de Construtores
O conceito de sobrecarga de mtodos pode ser aplicado para construtores. Dessa forma, podemos definir diversos construtores na mesma classe.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Pessoa
{
public string rg ;
public int cpf ;
public Pessoa ( string rg )
{
this . rg = rg ;
}
public Pessoa ( int cpf )
{
this . cpf = cpf ;
}
www.k19.com.br
49
O RIENTAO A O BJETOS
15
50
}
Cdigo C# 3.61: Pessoa.cs
Quando dois construtores so definidos, h duas opes no momento de utilizar o comando new.
1
2
3
4
5
class Conta
{
public int numero ;
public double limite ;
public Conta ( int numero )
{
this . numero = numero ;
}
public Conta ( int numero , double limite ) : this ( numero )
{
this . limite = limite ;
}
}
Cdigo C# 3.63: Conta.cs
Exerccios de Fixao
20
1
2
3
4
5
6
7
8
9
10
11
50
www.k19.com.br
51
21
O RIENTAO A O BJETOS
22
Altere o cdigo da classe TestaContaEAgencia para que o erro de compilao seja resolvido.
Substitua linhas semelhantes a
1
tro.
1
2
3
4
5
6
7
8
9
10
11
12
13
class CartaoDeCredito
{
public int numero ;
public string dataDeValidade ;
public Cliente cliente ;
// Adicione o contrutor abaixo
public CartaoDeCredito ( int numero )
{
this . numero = numero ;
}
}
Cdigo C# 3.67: CartaoDeCredito.cs
24
www.k19.com.br
51
O RIENTAO A O BJETOS
52
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
Acrescente um construtor na classe Conta para receber uma referncia como parmetro.
class Conta
{
public int numero ;
public double saldo ;
public double limite = 100;
public Agencia agencia ;
// Adicione o contrutor abaixo
public Conta ( Agencia agencia )
{
this . agencia = agencia ;
}
public void Deposita ( double valor )
{
this . saldo += valor ;
}
public void Saca ( double valor )
{
this . saldo -= valor ;
}
public void ImprimeExtrato ()
{
System . Console . WriteLine ( " SALDO : " + this . saldo ) ;
}
public double ConsultaSaldoDisponivel ()
{
return this . saldo + this . limite ;
}
}
Cdigo C# 3.70: Conta.cs
27
www.k19.com.br
53
1
O RIENTAO A O BJETOS
Conta c = new Conta () ;
Cdigo C# 3.73: Cdigo antigo
Na chamada do mtodo Transfere(), devemos ter duas referncias de contas: uma para chamar
o mtodo e outra para passar como parmetro.
1
2
3
4
5
6
Quando a varivel destino passada como parmetro, somente a referncia armazenada nessa
varivel enviada para o mtodo Transfere() e no o objeto em si. Em outras palavras, somente o
endereo para a conta que receber o valor da transferncia enviado para o mtodo Transfere().
Exerccios de Fixao
29
53
O RIENTAO A O BJETOS
1
2
3
4
5
54
30
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Exerccios Complementares
11
Crie uma classe que represente as contas do banco. Essa classe deve conter trs atributos:
Crie uma classe chamada TestaConta. Dentro dessa classe, crie um objeto do tipo Conta. Receba do teclado os valores para os atributos numero, saldo e limite. Depois crie um lao que permita que o usurio escolha a operao que ele deseja realizar. As operaes que ele pode realizar so:
depositar, sacar e imprimir extrato.
14
Crie uma classe que represente os funcionrios do banco. Essa classe deve conter dois atributos:
Crie uma classe chamada TestaFuncionario. Dentro dessa classe, crie um objeto do tipo
Funcionario. Receba do teclado o valor para o atributo nome. Depois crie um lao que permita
que o usurio possa alterar o nome e o salrio dos funcionrios e tambm visualizar os dados atuais.
54
www.k19.com.br
CAPTULO
A RRAYS
Suponha que o sistema do banco tenha que gerar listas com os nmeros das contas de uma
agncia. Poderamos declarar uma varivel para cada nmero.
1
2
3
4
int numero1 ;
int numero2 ;
int numero3 ;
...
Cdigo C# 4.1: Uma varivel para cada nmero de conta
Contudo, no seria uma abordagem prtica, pois uma agncia pode ter uma quantidade muito
grande de contas. Alm disso, novas contas podem ser abertas todos os dias. Isso implicaria em
alteraes constantes no cdigo fonte.
Quando desejamos armazenar uma grande quantidade de valores de um determinado tipo, podemos utilizar arrays. Um array um objeto que pode armazenar muitos valores de um determinado
tipo.
Podemos imaginar um array como sendo um armrio com um determinado nmero de gavetas.
E cada gaveta possui um rtulo com um nmero de identificao.
0
Figura 4.1: Analogia de array.
Criando um array
Em C#, os arrays so criados atravs do comando new.
1
www.k19.com.br
55
A RRAYS
56
int[]
INFORMA O TIPO DO
NOVO OBJETO
IDENTIFICADOR DA VARIVEL
nomeDoArray
new
int[10];
INSTANCIA UM
NOVO OBJETO
INFORMA A QUANTIDADE
DE POSIES DO ARRAY
Importante
Quando um array criado com o comando new, todas as posies so inicializadas com
os valores padro (nmeros so inicializados com 0, booleanos com false e referncias
com null).
Tambm podemos definir os valores de cada posio de um array no momento da sua criao
utilizando as sintaxes abaixo:
1
www.k19.com.br
57
1
2
3
A RRAYS
int [] numeros = {100 ,87};
System . Console . WriteLine ( numeros [0]) ;
System . Console . WriteLine ( numeros [1]) ;
Cdigo C# 4.7: Acessando o contedo das posies 0 e 1
Importante
Acessar posies fora do intervalo de ndices de um array gera erro de execuo. Mais
especificamente, em C#, ocorrer a exception IndexOutOfRangeException.
Percorrendo um Array
Quando trabalhamos com um array, uma das tarefas mais comuns acessarmos todas ou algumas de suas posies sistematicamente. Geralmente, fazemos isso para resgatar todos ou alguns dos
valores armazenados e realizar algum processamento sobre tais informaes.
Para percorrermos um array, utilizaremos a instruo de repetio for. Podemos utilizar a instruo while tambm. Porm, logo perceberemos que a sintaxe da instruo for, em geral, mais
apropriada quando estamos trabalhando com arrays.
1
2
3
4
5
Para percorrer um array, necessrio saber a quantidade de posies do mesmo. Essa quantidade definida quando o array criado atravs do comando new. Nem sempre essa informao
est explcita no cdigo. Por exemplo, considere um mtodo que imprima na sada padro os valores armazenados em um array. Provavelmente, esse mtodo receber como parmetro um array e a
quantidade de posies desse array no estar explcita no cdigo fonte.
1
2
3
4
www.k19.com.br
57
A RRAYS
58
foreach
Para acessar todos os elementos de um array, possvel aplicar o comando foreach.
1
2
3
4
5
6
7
Operaes
Nas bibliotecas da plataforma .NET, existem mtodos que realizam algumas tarefas teis relacionadas a arrays. Veremos esses mtodos a seguir.
Ordenando um Array
Considere um array de string criado para armazenar nomes de pessoas. Podemos ordenar esses
nomes atravs do mtodo Arrays.sort().
1
2
3
4
5
6
7
string [] nomes = new string [] { " rafael cosentino " , " jonas hirata " , " marcelo martins " };
System . Array . Sort ( nomes ) ;
foreach ( string nome in nomes )
{
System . Console . WriteLine ( nome ) ;
}
Cdigo C# 4.12: Ordenando um array
Duplicando um Array
Para copiar o contedo de um array para outro com maior capacidade, podemos utilizar o mtodo CopyTo().
1
2
3
string [] nomes = new string [] { " rafael " , " jonas " , " marcelo " };
string [] nomesDuplicados = new string [3];
nomes . CopyTo ( nomesDuplicados , 0) ;
Cdigo C# 4.13: Duplicando
Exerccios de Fixao
58
www.k19.com.br
59
A RRAYS
1 Dentro da sua pasta de exerccios crie uma pasta chamada arrays para os arquivos desenvolvidos
nesse captulo.
C :\ Users \ K19 \ Marcelo > md arrays
Crie um programa que imprima na tela os argumentos passados na linha de comando para o
mtodo Main.
2
1
2
3
4
5
6
7
8
9
10
class ImprimeArgumentos
{
static void Main ( string [] args )
{
foreach ( string arg in args )
{
System . Console . WriteLine ( arg ) ;
}
}
}
Cdigo C# 4.14: ImprimeArgumentos.cs
1
2
3
4
5
6
7
8
9
10
11
12
www.k19.com.br
59
A RRAYS
60
Exerccios Complementares
1
Faa um programa que calcule a mdia dos elementos recebidos na linha de comando. Dica:
para converter strings para double utilize o mtodo ToDouble()
1
2
60
Crie um programa que encontre o maior nmero entre os valores passados na linha de comando.
www.k19.com.br
CAPTULO
Exerccios de Fixao
1
Faa um novo projeto no Microsoft Visual C# Express e crie um programa que imprime na tela a
mensagem Ol Mundo.
www.k19.com.br
61
62
Para criar um novo projeto, clique no menu File->New Project ou digite o atalho CTRL + SHIFT +
N. Depois, selecione o template Empty Project, defina o nome do projeto como OlaMundo e clique
no boto OK.
62
Aps a criao do projeto OlaMundo, ele deve aparecer na view Solution Explorer no canto
www.k19.com.br
63
direito. Clique com o boto direito do mouse no projeto OlaMundo e selecione o menu Add->New
Item.
Na tela de criao de novo item, selecione o template Code File, defina o nome do arquivo com
OlaMundo.cs e clique no boto Add.
63
64
class OlaMundo
{
static void Main ()
{
System . Console . WriteLine ( " Ol Mundo " ) ;
}
}
Cdigo C# 5.1: OlaMundo.cs
Para compilar, clique no menu Debug->Build Solution ou digite o atalho F6. Para executar, digite
o atalho CTRL + F5.
3
Adicione mais uma classe no projeto OlaMundo para imprimir uma mensagem diferente.
1
2
3
4
5
6
7
class HelloWorld
{
static void Main ()
{
System . Console . WriteLine ( " Hello World " ) ;
}
}
Cdigo C# 5.2: HelloWorld.cs
Tente compilar o projeto novamente atravs do menu Build->Build Solution ou digite o atalho
F6. Observe o erro apontado pelo Microsoft Visual C# Express.
Como o projeto OlaMundo possui duas classes com o mtodo Main o Microsoft Visual C# Express
no pode determinar sozinho qual mtodo deve ser chamado quando o projeto for executado.
Podemos selecionar a classe que possui o mtodo Main que desejamos executar, abrindo as propriedades do projeto para definir o Startup Object. Clique com o boto direito no nome do projeto
e depois no menu Properties.
64
www.k19.com.br
65
Salve o projeto atravs do menu File-> Save Al l na pasta padro do Microsoft Visual C# Express.
www.k19.com.br
65
66
66
www.k19.com.br
CAPTULO
Atributos Estticos
Num sistema bancrio, provavelmente, criaramos uma classe para especificar os objetos que
representariam os funcionrios do banco.
1
2
3
4
5
6
7
8
9
10
class Funcionario
{
public string nome ;
public double salario ;
public void AumentaSalario ( double aumento )
{
this . salario += aumento ;
}
}
Cdigo C# 6.1: Funcionario.cs
Suponha que o banco paga aos seus funcionrios um valor padro de vale refeio por dia trabalhado. O sistema do banco precisa guardar esse valor. Poderamos definir um atributo na classe
Funcionario para tal propsito.
1
2
3
4
5
6
7
8
9
10
11
class Funcionario
{
public string nome ;
public double salario ;
public double valeRefeicaoDiario ;
public void AumentaSalario ( double aumento )
{
this . salario += aumento ;
}
}
Cdigo C# 6.2: Funcionario.cs
FUNCIONARIO
nome = Jonas Hirata
valeRefeicaoDiario = 15
FUNCIONARIO
nome = Marcelo Martins
valeRefeicaoDiario = 15
www.k19.com.br
67
68
class Funcionario
{
public string nome ;
public double salario ;
public static double valeRefeicaoDiario ;
public void AumentaSalario ( double aumento )
{
this . salario += aumento ;
}
}
Cdigo C# 6.3: Funcionario.cs
Um atributo de classe deve ser acessado atravs do nome da classe na qual ele foi definido.
1
valeRefeicaoDiario = 15
FUNCIONARIO
FUNCIONARIO
FUNCIONARIO
nome = Marcelo Martins
Mtodos Estticos
Definimos mtodos para implementar as lgicas que manipulam os valores dos atributos de instncia. Podemos fazer o mesmo para os atributos de classe.
Suponha que o banco tenha um procedimento para reajustar o valor do vale refeio baseado em
uma taxa. Poderamos definir um mtodo na classe Funcionario para implementar esse reajuste.
1
2
3
4
www.k19.com.br
69
Contudo, como o reajuste do valor do vale refeio no depende dos dados de um funcionrio
em particular, no faz sentido precisar de uma referncia de um objeto da classe Funcionario para
poder fazer esse reajuste.
Neste caso, poderamos definir o ReajustaValeRefeicaoDiario() como mtodo de classe ao
invs de mtodo de instncia. Aplicando o modificador static nesse mtodo, ele se tornar um
mtodo de classe. Dessa forma, o reajuste poderia ser executado independentemente da existncia
de objetos da classe Funcionario.
1
2
3
4
Um mtodo de classe deve ser chamado atravs do nome da classe na qual ele foi definido.
1
Exerccios de Fixao
1
2 Crie uma classe chamada Conta no projeto Static. Defina um atributo de classe para contabilizar
o nmero de objetos instanciados a partir da classe Conta. Esse atributo deve ser incrementado toda
vez que um objeto criado. Voc pode utilizar construtores para fazer o incremento.
1
2
3
4
5
6
7
8
9
10
11
class Conta
{
// ATRIBUTO DE CLASSE
public static int contador ;
// CONSTRUTOR
public Conta ()
{
Conta . contador ++;
}
}
Cdigo C# 6.8: Conta.cs
3 Faa um teste criando dois objetos da classe Conta. Imprima o valor do contador de contas antes
e depois da criao de cada objeto.
1
2
3
4
5
6
7
8
9
10
class Teste
{
static void Main ()
{
System . Console . WriteLine ( " Contador : " + Conta . contador ) ;
new Conta () ;
System . Console . WriteLine ( " Contador : " + Conta . contador ) ;
new Conta () ;
System . Console . WriteLine ( " Contador : " + Conta . contador ) ;
}
www.k19.com.br
69
70
}
Cdigo C# 6.9: Teste.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5
70
www.k19.com.br
71
7
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Exerccios Complementares
Crie uma classe para modelar os funcionrios do banco. Defina nessa classe um atributo para
armazenar o valor do vale refeio dirio pago aos funcionrios.
1
Defina um mtodo para reajustar o vale refeio dirio a partir de uma taxa.
www.k19.com.br
71
72
72
www.k19.com.br
CAPTULO
E NCAPSULAMENTO
Atributos Privados
No sistema do banco, cada objeto da classe Funcionario possui um atributo para guardar o salrio do funcionrio que ele representa.
1
2
3
4
class Funcionario
{
public double salario ;
}
Cdigo C# 7.1: Funcionario.cs
O atributo salario pode ser acessado ou modificado por cdigo escrito por qualquer classe.
Portanto, o controle do atributo salario descentralizado.
Para identificar algum erro relacionado a manipulao dos salrios dos funcionrios, necessrio verificar o cdigo de todos os arquivos onde a classe Funcionario est definida. Quanto maior o
nmero de arquivos, menos eficiente ser a manuteno da aplicao.
Podemos obter um controle centralizado tornando o atributo salario privado e definindo mtodos para implementar todas as lgicas que utilizam ou modificam o valor desse atributo. Em C#,
se nenhum modificador de visibilidade for definido para um determinado atributo, esse atributo
ser considerado privado por padro. Contudo, uma boa prtica deixar explcito no cdigo que o
atributo privado, adicionando o modificador private.
1
2
3
4
5
6
7
8
9
class Funcionario
{
private double salario ;
public void AumentaSalario ( double aumento )
{
// lgica para aumentar o salrio
}
}
Cdigo C# 7.2: Funcionario.cs
Um atributo privado s pode ser acessado ou alterado por cdigo escrito dentro da classe na
qual ele foi definido. Se algum cdigo fora da classe Funcionario tentar acessar ou alterar o valor do
atributo privado salario, um erro de compilao ser gerado.
Definir todos os atributos como privado e mtodos para implementar as lgicas de acesso e alterao quase uma regra da orientao a objetos. O intuito ter sempre um controle centralizado do
dados dos objetos para facilitar a manuteno do sistema e a deteco de erros.
www.k19.com.br
73
E NCAPSULAMENTO
74
Mtodos Privados
O papel de alguns mtodos pode ser o de auxiliar outros mtodos da mesma classe. E muitas
vezes, no correto chamar esses mtodos auxiliares de fora da sua classe diretamente.
No exemplo abaixo, o mtodo DescontaTarifa() um mtodo auxiliar dos mtodos Deposita()
e Saca(). Alm disso, ele no deve ser chamado diretamente, pois a tarifa s deve ser descontada
quando ocorre um depsito ou um saque.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Conta
{
private double saldo ;
public void Deposita ( double valor )
{
this . saldo += valor ;
this . DescontaTarifa () ;
}
public void Saca ( double valor )
{
this . saldo -= valor ;
this . DescontaTarifa () ;
}
void DescontaTarifa ()
{
this . saldo -= 0.1;
}
}
Cdigo C# 7.3: Conta.cs
Para garantir que mtodos auxiliares no sejam chamados por cdigo escrito fora da classe na
qual eles foram definidos, podemos torn-los privados, acrescentando o modificador private.
1
2
3
4
Qualquer chamada ao mtodo DescontaTarifa() realizada fora da classe Conta gera um erro de
compilao.
Mtodos Pblicos
Os mtodos que devem ser chamados a partir de qualquer parte do sistema devem possuir o
modificador de visibilidade public.
1
2
3
4
5
6
74
class Conta
{
private double saldo ;
public void Deposita ( double valor )
{
www.k19.com.br
75
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
E NCAPSULAMENTO
this . saldo += valor ;
this . DescontaTarifa () ;
}
public void Saca ( double valor )
{
this . saldo -= valor ;
this . DescontaTarifa () ;
}
private void DescontaTarifa ()
{
this . saldo -= 0.1;
}
}
Cdigo C# 7.5: Conta.cs
Por qu encapsular?
Uma das ideias mais importantes da orientao a objetos o encapsulamento. Encapsular significa esconder a implementao dos objetos. O encapsulamento favorece principalmente dois aspectos de um sistema: a manuteno e o desenvolvimento.
A manuteno favorecida pois, uma vez aplicado o encapsulamento, quando o funcionamento
de um objeto deve ser alterado, em geral, basta modificar a classe do mesmo.
O desenvolvimento favorecido pois, uma vez aplicado o encapsulamento, conseguimos determinar precisamente as responsabilidades de cada classe da aplicao.
O conceito de encapsulamento pode ser identificado em diversos exemplos do cotidiano. Mostraremos alguns desses exemplos para esclarecer melhor a ideia.
75
E NCAPSULAMENTO
76
relhos atravs dos botes, da tela e dos menus. Os dispositivos internos de um celular e os processos
que transformam o som capturado pelo microfone em ondas que podem ser transmitidas para uma
antena da operadora de telefonia mvel constituem a implementao do celular.
Do ponto de vista do usurio de um celular, para fazer uma ligao, basta digitar o nmero do
telefone desejado e clicar no boto que efetua a ligao. Porm, diversos processos complexos so
realizados pelo aparelho para que as pessoas possam conversar atravs dele. Se os usurios tivessem
que possuir conhecimento de todo o funcionamento interno dos celulares, certamente a maioria das
pessoas no os utilizariam.
No contexto da orientao a objetos, aplicamos o encapsulamento para criar objetos mais simples de serem utilizados em qualquer parte do sistema.
Calling Maria
www.k19.com.br
77
E NCAPSULAMENTO
No contexto da orientao a objetos, aplicando o conceito do encapsulamento, as implementaes dos objetos ficam escondidas. Dessa forma, podemos modific-las sem afetar a maneira de
utilizar esses objetos. Por outro lado, se alterarmos a interface de uso que est exposta, afetaremos a
maneira de usar os objetos.
Considere, por exemplo, a mudana do nome de um mtodo pblico. Todas as chamadas a esse
mtodo devem ser alteradas, o que pode causar diversos efeitos colaterais nas classes da aplicao.
12:30
12:30
Sada do produto.
Normalmente, essas mquinas so extremamente protegidas. Elas garantem que nenhum usurio mal intencionado (ou no) tente alterar a implementao da mquina, ou seja, tente alterar como
a mquina funciona por dentro.
Levando essa ideia para um sistema orientado a objetos, um objeto deve ser bem protegido para
que outros objetos no prejudiquem o seu funcionamento interno.
www.k19.com.br
77
E NCAPSULAMENTO
78
class Cliente
{
private string nome ;
public string ConsultaNome ()
{
return this . nome ;
}
}
Cdigo C# 7.6: Cliente.cs
Da mesma forma, eventualmente, necessrio modificar o valor de um atributo a partir de qualquer lugar do sistema. Nesse caso, tambm poderamos criar um mtodo para essa tarefa.
1
2
3
4
5
6
7
8
9
class Cliente
{
private string nome ;
public void AlteraNome ( string nome )
{
this . nome = nome ;
}
}
Cdigo C# 7.7: Cliente.cs
Muitas vezes, necessrio consultar e alterar o valor de um atributo a partir de qualquer lugar do
sistema. Nessa situao, podemos definir os dois mtodos discutidos anteriormente. Mas, o que
melhor? Criar os dois mtodos (um de leitura e outro de escrita) ou deixar o atributo pblico?
78
www.k19.com.br
79
E NCAPSULAMENTO
Propriedades
A linguagem C# disponibiliza uma outra maneira para acessar os atributos: as propriedades.
Uma propriedade, basicamente, agrupa os mtodos de consulta e alterao dos atributos.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Cliente
{
private string nome ;
public string Nome
{
get
{
return this . nome ;
}
set
{
this . nome = value ;
}
}
}
Cdigo C# 7.8: Cliente.cs
Propriedades automticas
Muitas vezes, a lgica das propriedades trivial. Ou seja, queremos apenas realizar uma atribuio ou devolver um valor;
1
2
3
4
5
6
7
class Cliente
{
private string nome ;
public string Nome
{
get
www.k19.com.br
79
E NCAPSULAMENTO
8
9
10
11
12
13
14
15
16
80
{
return this . nome ;
}
set
{
this . nome = value ;
}
}
}
Cdigo C# 7.10: Cliente.cs
Nesses casos, podemos aplicar o recurso de propriedades automticas. O cdigo fica mais simples e prtico.
1
2
3
4
class Cliente
{
public string Nome { get ; set ; }
}
Cdigo C# 7.11: Cliente.cs
Exerccios de Fixao
1
Defina uma classe para representar os funcionrios do banco com um atributo para guardar os
salrios e outro para os nomes.
2
1
2
3
4
5
class Funcionario
{
public double salario ;
public string nome ;
}
Cdigo C# 7.12: Funcionario.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
80
www.k19.com.br
81
E NCAPSULAMENTO
Compile a classe Teste e perceba que ela pode acessar ou modificar os valores dos atributos de
um objeto da classe Funcionario. Execute o teste e observe o console.
4
5
Aplique a ideia do encapsulamento tornando os atributos definidos na classe Funcionario privados.
1
2
3
4
5
class Funcionario
{
private double salario ;
private string nome ;
}
Cdigo C# 7.14: Funcionario.cs
Tente compilar novamente a classe Teste. Observe os erros de compilao. Lembre-se que um
atributo privado s pode ser acessado por cdigo escrito na prpria classe do atributo.
6
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
Crie propriedades com nomes padronizados para os atributos definidos na classe Funcionario.
class Funcionario
{
private double salario ;
private string nome ;
public double Salario
{
get
{
return this . salario ;
}
set
{
this . salario = value ;
}
}
public string Nome
{
get
{
return this . nome ;
}
set
{
this . nome = value ;
}
}
}
Cdigo C# 7.15: Funcionario.cs
Altere a classe Teste para que ela utilize as propriedades ao invs de manipular os atributos do
objeto da classe Funcionario diretamente.
8
1
2
3
4
5
6
7
8
9
10
11
class Teste
{
static void Main ()
{
Funcionario f = new Funcionario () ;
f . Nome = " Rafael Cosentino " ;
f . Salario = 2000;
System . Console . WriteLine ( f . Nome ) ;
System . Console . WriteLine ( f . Salario ) ;
www.k19.com.br
81
E NCAPSULAMENTO
12
13
82
}
}
Cdigo C# 7.16: Teste.cs
1
2
3
4
5
class Funcionario
{
public double Salario { get ; set ; }
public string Nome { get ; set ; }
}
Cdigo C# 7.17: Funcionario.cs
Exerccios Complementares
1
2
Crie objetos da classe que modela as contas do banco e utilize as propriedades para alterar os
valores dos atributos.
82
www.k19.com.br
CAPTULO
H ERANA
Reutilizao de Cdigo
Um banco oferece diversos servios que podem ser contratados individualmente pelos clientes.
Quando um servio contratado, o sistema do banco deve registrar quem foi o cliente que contratou
o servio, quem foi o funcionrio responsvel pelo atendimento ao cliente e a data de contratao.
Com o intuito de ser produtivo, a modelagem dos servios do banco deve diminuir a repetio de
cdigo. A ideia reaproveitar o mximo do cdigo j criado. Essa ideia est diretamente relacionada
ao conceito Dont Repeat Yourself. Em outras palavras, devemos minimizar ao mximo a utilizao
do copiar e colar. O aumento da produtividade e a diminuio do custo de manuteno so as
principais motivaes do DRY.
Em seguida, vamos discutir algumas modelagens possveis para os servios do banco. Buscaremos seguir a ideia do DRY na criao dessas modelagens.
class Servico
{
public Cliente Contratante { get ; set ; }
public Funcionario Responsavel { get ; set ; }
public string DataDeContratacao { get ; set ; }
}
Cdigo C# 8.1: Servico.cs
Emprstimo
O emprstimo um dos servios que o banco oferece. Quando um cliente contrata esse servio,
so definidos o valor e a taxa de juros mensal do emprstimo. Devemos acrescentar duas propriedades na classe Servico: uma para o valor e outra para a taxa de juros do servio de emprstimo.
1
2
3
4
5
6
class Servico
{
public Cliente Contratante { get ; set ; }
public Funcionario Responsavel { get ; set ; }
public string DataDeContratacao { get ; set ; }
www.k19.com.br
83
H ERANA
7
8
9
84
Seguro de veculos
Outro servio oferecido pelo banco o seguro de veculos. Para esse servio devem ser definidas
as seguintes informaes: veculo segurado, valor do seguro e a franquia. Devemos adicionar trs
atributos na classe Servico.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Servico
{
// GERAL
public Cliente Contratante { get ; set ; }
public Funcionario Responsavel { get ; set ; }
public string DataDeContratacao { get ; set ; }
// EMPRESTIMO
public double Valor { get ; set ; }
public double Taxa { get ; set ; }
// SEGURO DE VEICULO
public Veiculo Veiculo { get ; set ; }
public double ValorDoSeguroDeVeiculo { get ; set ; }
public double Franquia { get ; set ; }
}
Cdigo C# 8.3: Servico.cs
Apesar de seguir a ideia do DRY, modelar todos os servios com apenas uma classe pode dificultar
o desenvolvimento. Supondo que dois ou mais desenvolvedores so responsveis pela implementao dos servios, eles provavelmente modificariam a mesma classe concorrentemente. Alm disso,
os desenvolvedores, principalmente os recm chegados no projeto do banco, ficariam confusos com
o cdigo extenso da classe Servico.
Outro problema que um objeto da classe Servico possui atributos para todos os servios que
o banco oferece. Na verdade, ele deveria possuir apenas os atributos relacionados a um servio. Do
ponto de vista de performance, essa abordagem causaria um consumo desnecessrio de memria.
84
class SeguroDeVeiculo
{
// GERAL
public Cliente Contratante { get ; set ; }
public Funcionario Responsavel { get ; set ; }
public string DataDeContratacao { get ; set ; }
// SEGURO DE VEICULO
public Veiculo Veiculo { get ; set ; }
public double ValorDoSeguroDeVeiculo { get ; set ; }
www.k19.com.br
85
11
12
H ERANA
public double Franquia { get ; set ; }
}
Cdigo C# 8.4: SeguroDeVeiculo.cs
1
2
3
4
5
6
7
8
9
10
11
class Emprestimo
{
// GERAL
public Cliente Contratante { get ; set ; }
public Funcionario Responsavel { get ; set ; }
public string DataDeContratacao { get ; set ; }
// EMPRESTIMO
public double Valor { get ; set ; }
public double Taxa { get ; set ; }
}
Cdigo C# 8.5: Emprestimo.cs
Criar uma classe para cada servio torna o sistema mais flexvel, pois qualquer alterao em um
determinado servio no causar efeitos colaterais nos outros. Mas, por outro lado, essas classes
teriam bastante cdigo repetido, contrariando a ideia do DRY. Alm disso, qualquer alterao que
deva ser realizada em todos os servios precisa ser implementada em cada uma das classes.
www.k19.com.br
85
H ERANA
86
As classes especficas so vinculadas a classe genrica utilizando o comando (:). No necessrio redefinir o contedo j declarado na classe genrica.
1
2
3
4
5
6
class Servico
{
public Cliente Contratante { get ; set ; }
public Funcionario Responsavel { get ; set ; }
public string DataDeContratacao { get ; set ; }
}
1
2
3
4
5
1
2
3
4
5
6
A classe genrica denominada super classe, classe base ou classe me. As classes especficas
so denominadas sub classes, classes derivadas ou classes filhas.
Quando o operador new aplicado em uma sub classe, o objeto construdo possuir os atributos
e mtodos definidos na sub classe e na super classe.
86
www.k19.com.br
87
H ERANA
EMPRESTIMO
valor
taxa
new Emprestimo()
SERVICO
contratante
responsavel
dataDeContratacao
Preo Fixo
Suponha que todo servio do banco possui uma taxa administrativa que deve ser paga pelo cliente que contratar o servio. Inicialmente, vamos considerar que o valor dessa taxa igual para todos
os servios do banco.
Neste caso, poderamos implementar um mtodo na classe Servico para calcular o valor da taxa.
Este mtodo ser reaproveitado por todas as classes que herdam da classe Servico.
1
2
3
4
5
6
7
8
9
class Servico
{
// propriedades
public double CalculaTaxa ()
{
return 10;
}
}
Cdigo C# 8.10: Servico.cs
1
2
3
4
5
6
7
Reescrita de Mtodo
Suponha que o valor da taxa administrativa do servio de emprstimo diferente dos outros
servios, pois ele calculado a partir do valor emprestado ao cliente. Como esta lgica especfica
para o servio de emprstimo, devemos acrescentar um mtodo para implementar esse clculo na
classe Emprestimo.
1
2
www.k19.com.br
87
H ERANA
3
4
5
6
7
8
9
88
// propriedades
public double CalculaTaxaDeEmprestimo ()
{
return this . Valor * 0.1;
}
}
Cdigo C# 8.12: Servico.cs
class Servico
{
// propriedades
public virtual double CalculaTaxa ()
{
return 10;
}
}
Cdigo C# 8.13: Servico.cs
Depois que a classe me Servico autorizou a substituio da implementao do mtodo CalculaTaxa atravs do modificador virtual, basta reescrever o mtodo CalculaTaxa() na classe Emprestimo
com a mesma assinatura que ele possui na classe Servico e com o modificador override.
1
2
3
4
5
6
7
8
9
Os mtodos das classes especficas tm prioridade sobre os mtodos das classes genricas. Em
outras palavras, se o mtodo chamado existe na classe filha ele ser chamado, caso contrrio o mtodo ser procurado na classe me.
Quando definimos um mtodo com a mesma assinatura na classe base e em alguma classe derivada, estamos aplicando o conceito de Reescrita de Mtodo.
Fixo + Especfico
88
www.k19.com.br
89
H ERANA
Suponha que o preo de um servio a soma de um valor fixo mais um valor que depende do tipo
do servio. Por exemplo, o preo do servio de emprstimo 5 reais mais uma porcentagem do valor
emprestado ao cliente. O preo do servio de seguro de veculo 5 reais mais uma porcentagem do
valor do veculo segurado. Em cada classe especfica, podemos reescrever o mtodo CalculaTaxa().
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
Se o valor fixo dos servios for atualizado, todas as classes especficas devem ser modificadas. Outra alternativa seria criar um mtodo na classe Servico para calcular o valor fixo de todos os servios
e cham-lo dos mtodos reescritos nas classes especficas.
1
2
3
4
5
6
7
8
9
class Servico
{
// propriedades
public virtual double CalculaTaxa ()
{
return 5 ;
}
}
Cdigo C# 8.17: Servico.cs
1
2
3
4
5
6
7
8
9
Dessa forma, quando o valor padro do preo dos servios alterado, basta modificar o mtodo
na classe Servico.
www.k19.com.br
89
H ERANA
90
Construtores e Herana
Quando temos uma hierarquia de classes, as chamadas dos construtores so mais complexas
do que o normal. Pelo menos um construtor de cada classe de uma mesma sequncia hierrquica
deve ser chamado ao instanciar um objeto. Por exemplo, quando um objeto da classe Emprestimo
criado, pelo menos um construtor da prpria classe Emprestimo e um da classe Servico devem ser
executados. Alm disso, os construtores das classes mais genricas so chamados antes dos construtores das classes especficas.
1
2
3
4
5
6
7
8
9
class Servico
{
// propriedades
public Servico ()
{
System . Console . WriteLine ( " Servico " ) ;
}
}
Cdigo C# 8.19: Servico.cs
1
2
3
4
5
6
7
8
9
Por padro, todo construtor chama o construtor sem argumentos da classe me se no existir
nenhuma chamada de construtor explcita.
Exerccios de Fixao
1
2 Defina uma classe para modelar os funcionrios do banco. Sabendo que todo funcionrio possui
nome e salrio, inclua as propriedades dos atributos.
1
2
3
4
5
class Funcionario
{
public string Nome { get ; set ; }
public double Salario { get ; set ; }
}
Cdigo C# 8.21: Funcionario.cs
Crie uma classe para cada tipo especfico de funcionrio herdando da classe Funcionario. Considere apenas trs tipos especficos de funcionrios: gerentes, telefonistas e secretarias. Os gerentes
possuem um nome de usurio e uma senha para acessar o sistema do banco. As telefonistas possuem
3
90
www.k19.com.br
91
H ERANA
1
2
3
4
1
2
3
4
Teste o funcionamento dos trs tipos de funcionrios criando um objeto de cada uma das classes:
class TestaFuncionarios
{
static void Main ()
{
Gerente g = new Gerente () ;
g . Nome = " Rafael Cosentino " ;
g . Salario = 2000;
g . Usuario = " rafael . cosentino " ;
g . Senha = " 12345 " ;
Telefonista t = new Telefonista () ;
t . Nome = " Carolina Mello " ;
t . Salario = 1000;
t . EstacaoDeTrabalho = 13;
Secretaria s = new Secretaria () ;
s . Nome = " Tatiane Andrade " ;
s . Salario = 1500;
s . Ramal = 198;
System . Console . WriteLine ( " GERENTE " ) ;
System . Console . WriteLine ( " Nome : " + g . Nome ) ;
System . Console . WriteLine ( " Salrio : " + g . Salario ) ;
System . Console . WriteLine ( " Usurio : " + g . Usuario ) ;
System . Console . WriteLine ( " Senha : " + g . Senha ) ;
System . Console . WriteLine ( " TELEFONISTA " ) ;
System . Console . WriteLine ( " Nome : " + t . Nome ) ;
System . Console . WriteLine ( " Salrio : " + t . Salario ) ;
System . Console . WriteLine ( " Estacao de trabalho : " + t . EstacaoDeTrabalho ) ;
System . Console . WriteLine ( " SECRETARIA " ) ;
System . Console . WriteLine ( " Nome : " + s . Nome ) ;
System . Console . WriteLine ( " Salrio : " + s . Salario ) ;
System . Console . WriteLine ( " Ramal : " + s . Ramal ) ;
}
}
Cdigo C# 8.25: TestaFuncionarios.cs
www.k19.com.br
91
H ERANA
92
1
2
3
4
5
6
7
8
9
class Funcionario
{
public string Nome { get ; set ; }
public double Salario { get ; set ; }
public double CalculaBonificacao () {
return this . Salario * 0.1;
}
}
Cdigo C# 8.26: Funcionario.cs
6
Altere a classe TestaFuncionarios para imprimir a bonificao de cada funcionrio, alm dos
dados que j foram impressos. Depois, execute o teste novamente.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class TestaFuncionarios
{
static void Main ()
{
Gerente g = new Gerente () ;
g . Nome = " Rafael Cosentino " ;
g . Salario = 2000;
g . Usuario = " rafael . cosentino " ;
g . Senha = " 12345 " ;
Telefonista t = new Telefonista () ;
t . Nome = " Carolina Mello " ;
t . Salario = 1000;
t . EstacaoDeTrabalho = 13;
Secretaria s = new Secretaria () ;
s . Nome = " Tatiane Andrade " ;
s . Salario = 1500;
s . Ramal = 198;
System . Console . WriteLine ( " GERENTE " ) ;
System . Console . WriteLine ( " Nome : " + g . Nome ) ;
System . Console . WriteLine ( " Salrio : " + g . Salario ) ;
System . Console . WriteLine ( " Usurio : " + g . Usuario ) ;
System . Console . WriteLine ( " Senha : " + g . Senha ) ;
System . Console . WriteLine ( " Bonificao : " + g . CalculaBonificacao () ) ;
System . Console . WriteLine ( " TELEFONISTA " ) ;
System . Console . WriteLine ( " Nome : " + t . Nome ) ;
System . Console . WriteLine ( " Salrio : " + t . Salario ) ;
System . Console . WriteLine ( " Estacao de trabalho : " + t . EstacaoDeTrabalho ) ;
System . Console . WriteLine ( " Bonificao : " + t . CalculaBonificacao () ) ;
System . Console . WriteLine ( " SECRETARIA " ) ;
System . Console . WriteLine ( " Nome : " + s . Nome ) ;
System . Console . WriteLine ( " Salrio : " + s . Salario ) ;
System . Console . WriteLine ( " Ramal : " + s . Ramal ) ;
System . Console . WriteLine ( " Bonificao : " + s . CalculaBonificacao () ) ;
}
}
Cdigo C# 8.27: TestaFuncionarios.cs
7 Suponha que os gerentes recebam uma bonificao maior que os outros funcionrios. Reescreva
o mtodo CalculaBonificacao() na classe Gerente. Porm, devemos permitir que as classes filhas
92
www.k19.com.br
93
H ERANA
possam reescrever o mtodo e para tal precisamos alter-lo na classe Funcionario acrescentando o
modificador virtual.
1
2
3
4
5
6
7
8
9
class Funcionario
{
public string Nome { get ; set ; }
public double Salario { get ; set ; }
public virtual double CalculaBonificacao () {
return this . Salario * 0.1;
}
}
Cdigo C# 8.28: Funcionario.cs
Exerccios Complementares
Defina na classe Funcionario um mtodo para imprimir na tela o nome, salrio e bonificao
dos funcionrios.
1
2
Reescreva o mtodo que imprime os dados dos funcionrios nas classes Gerente, Telefonista
e Secretaria para acrescentar a impresso dos dados especficos de cada tipo de funcionrio.
3
www.k19.com.br
93
H ERANA
94
94
www.k19.com.br
CAPTULO
P OLIMORFISMO
Controle de Ponto
O sistema do banco deve possuir um controle de ponto para registrar a entrada e sada dos funcionrios. O pagamento dos funcionrios depende dessas informaes. Podemos definir uma classe
para implementar o funcionamento de um relgio de ponto.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System ;
class ControleDePonto
{
public void RegistraEntrada ( Gerente g )
{
DateTime agora = DateTime . Now ;
string horario = String . Format ( " {0: d / M / yyyy HH : mm : ss } " , agora ) ;
System . Console . WriteLine ( " ENTRADA : " + g . Codigo ) ;
System . Console . WriteLine ( " DATA : "
+ horario ) ;
}
public void RegistraSaida ( Gerente g )
{
DateTime agora = DateTime . Now ;
string horario = String . Format ( " {0: d / M / yyyy HH : mm : ss } " , agora ) ;
System . Console . WriteLine ( " SADA : " + g . Codigo ) ;
System . Console . WriteLine ( " DATA : " + horario ) ;
}
}
Cdigo C# 9.1: ControleDePonto.cs
A classe acima possui dois mtodos: o primeiro para registrar a entrada e o segundo para registrar
a sada dos gerentes do banco. Contudo, esses dois mtodos no so aplicveis aos outros tipos de
funcionrios.
Seguindo essa abordagem, a classe ControleDePonto precisaria de um par de mtodos para cada
cargo. Ento, a quantidade de mtodos dessa classe seria igual a quantidade de cargos multiplicada por dois. Imagine que no banco exista 30 cargos distintos. Teramos 60 mtodos na classe
ControleDePonto.
Os procedimentos de registro de entrada e sada so idnticos para todos os funcionrios. Consequentemente, qualquer alterao na lgica desses procedimentos implicaria na modificao de
todos os mtodos da classe ControleDePonto.
Alm disso, se o banco definir um novo tipo de funcionrio, dois novos mtodos praticamente
idnticos aos que j existem teriam de ser adicionados na classe ControleDePonto. Analogamente,
se um cargo deixar de existir, os dois mtodos correspondentes da classe ControleDePonto devero
www.k19.com.br
95
P OLIMORFISMO
96
ser retirados.
SECRETRIAS
TELEFONISTAS
SECRETRIAS
TELEFONISTAS
GERENTES
GERENTES
class Funcionario
{
public int Codigo { get ; set ; }
}
Cdigo C# 9.2: Funcionario.cs
1
2
3
4
5
1
2
3
4
96
www.k19.com.br
97
P OLIMORFISMO
UM
Alm de gerar reaproveitamento de cdigo, a utilizao de herana permite que objetos criados
a partir das classes especficas sejam tratados como objetos da classe genrica.
Em outras palavras, a herana entre as classes que modelam os funcionrios permite que objetos criados a partir das classes Gerente ou Telefonista sejam tratados como objetos da classe
Funcionario.
No cdigo da classe Gerente utilizamos o smbolo : para indicar que a classe Gerente uma
subclasse de Funcionario. Esse smbolo pode ser interpretado como a expresso: UM ou UMA.
1
2
Como est explcito no cdigo que todo gerente um funcionrio ento podemos criar um objeto
da classe Gerente e trat-lo como um objeto da classe Funcionario tambm.
1
2
3
4
5
Em alguns lugares do sistema do banco ser mais vantajoso tratar um objeto da classe Gerente
como um objeto da classe Funcionario.
using System ;
class ControleDePonto
{
public void RegistraEntrada ( Funcionario f )
{
DateTime agora = DateTime . Now ;
string horario = String . Format ( " {0: d / M / yyyy HH : mm : ss } " , agora ) ;
System . Console . WriteLine ( " ENTRADA : " + f . Codigo ) ;
System . Console . WriteLine ( " DATA : "
+ horario ) ;
www.k19.com.br
97
P OLIMORFISMO
12
13
14
15
16
17
18
19
20
21
22
98
}
public void RegistraSaida ( Funcionario f )
{
DateTime agora = DateTime . Now ;
string horario = String . Format ( " {0: d / M / yyyy HH : mm : ss } " , agora ) ;
System . Console . WriteLine ( " SADA : " + f . Codigo ) ;
System . Console . WriteLine ( " DATA : " + horario ) ;
}
}
Cdigo C# 9.7: ControleDePonto.cs
FUNCIONRIOS
TELEFONISTAS
GERENTES
SECRETRIAS
FUNCIONRIOS
Exerccios de Fixao
1
1
2
3
class Conta
{
public double Saldo { set ; get ; }
98
www.k19.com.br
99
4
P OLIMORFISMO
}
Cdigo C# 9.8: Conta.cs
Defina duas classes especficas para dois tipos de contas do banco: poupana e corrente.
1
2
3
4
1
2
3
4
1
2
3
4
5
6
7
8
9
10
11
12
13
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
www.k19.com.br
99
P OLIMORFISMO
100
Exerccios Complementares
1
Implemente duas classes especficas para modelar dois tipos particulares de funcionrios do
banco: os gerentes e as telefonistas.
2
Implemente o controle de ponto dos funcionrios. Crie uma classe com dois mtodos: o primeiro
para registrar a entrada dos funcionrios e o segundo para registrar a sada.
3
4
Teste a lgica do controle de ponto, registrando a entrada e a sada de um gerente e de uma
telefonista.
100
www.k19.com.br
CAPTULO
C LASSES A BSTRATAS
10
Classes Abstratas
No banco, todas as contas so de um tipo especfico. Por exemplo, conta poupana, conta corrente ou conta salrio. Essas contas poderiam ser modeladas atravs das seguintes classes utilizando
o conceito de herana:
1
2
3
4
5
6
7
class Conta
{
// Atributos
// Propriedades
// Construtores
// Mtodos
}
Cdigo C# 10.1: Conta.cs
1
2
3
4
5
6
7
1
2
3
4
5
6
7
Para cada conta do domnio do banco, devemos criar um objeto da classe correspondente ao
tipo da conta. Por exemplo, se existe uma conta poupana no domnio do banco, devemos criar um
objeto da classe ContaPoupanca.
1
Faz sentido criar objetos da classe ContaPoupanca pois existem contas poupana no domnio do
banco. Dizemos que a classe ContaPoupanca uma classe concreta pois criaremos objetos a partir
dela.
www.k19.com.br
101
C LASSES A BSTRATAS
102
Por outro lado, a classe Conta no define uma conta que de fato existe no domnio do banco. Ela
apenas serve como base para definir as contas concretos.
No faz sentido criar um objeto da classe Conta pois estaramos instanciado um objeto que no
suficiente para representar uma conta que pertena ao domnio do banco. Mas, a princpio no h
nada proibindo a criao de objetos dessa classe. Para adicionar essa restrio no sistema, devemos
tornar a classe Conta abstrata.
Uma classe concreta pode ser diretamente utilizada para instanciar objetos. Por outro lado, uma
classe abstrata no pode. Para definir uma classe abstrata, basta adicionar o modificador abstract.
1
2
3
4
5
6
Todo cdigo que tenta criar um objeto de uma classe abstrata no compila.
1
2
// Erro de compilao
Conta c = new Conta () ;
Cdigo C# 10.6: Erro de compilao
Mtodos Abstratos
Suponha que o banco oferea extrato detalhado das contas e para cada tipo de conta as informaes e o formato desse extrato detalhado so diferentes. Alm disso, a qualquer momento o banco
pode mudar os dados e o formato do extrato detalhado de um dos tipos de conta.
Neste caso, parece no fazer sentido ter um mtodo na classe Conta para gerar extratos detalhados pois ele seria reescrito nas classes especficas sem nem ser reaproveitado.
Poderamos, simplesmente, no definir nenhum mtodo para gerar extratos detalhados na classe
Conta. Porm, no haveria nenhuma garantia que as classes que derivam direta ou indiretamente da
classe Conta implementem mtodos para gerar extratos detalhados.
Mas, mesmo supondo que toda classe derivada implemente um mtodo para gerar os extratos
que desejamos, ainda no haveria nenhuma garantia em relao as assinaturas desses mtodos. As
classes derivadas poderiam definir mtodos com nomes ou parmetros diferentes. Isso prejudicaria
a utilizao dos objetos que representam as contas devido a falta de padronizao das operaes.
Para garantir que toda classe concreta que deriva direta ou indiretamente da classe Conta tenha
uma implementao de mtodo para gerar extratos detalhados e alm disso que uma mesma assinatura de mtodo seja utilizada, devemos utilizar o conceito de mtodos abstratos.
Na classe Conta, definimos um mtodo abstrato para gerar extratos detalhados. Um mtodo
abstrato no possui corpo (implementao).
1
102
www.k19.com.br
103
2
3
4
5
6
7
8
9
C LASSES A BSTRATAS
{
//
//
//
//
Atributos
Propriedades
Construtores
Mtodos
As classes concretas que derivam direta ou indiretamente da classe Conta devem possuir uma
implementao para o mtodo ImprimeExtratoDetalhado().
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Se uma classe concreta derivada da classe Conta no possuir uma implementao do mtodo
ImprimeExtratoDetalhado() ela no compilar.
1
2
3
4
5
Exerccios de Fixao
1
1
2
3
4
class Conta
{
public double Saldo { get ; set ; }
}
Cdigo C# 10.10: Conta.cs
class TestaConta
www.k19.com.br
103
C LASSES A BSTRATAS
2
3
4
5
6
7
8
9
10
11
104
{
static void Main ()
{
Conta c = new Conta () ;
c . Saldo = 1000;
System . Console . WriteLine ( c . Saldo ) ;
}
}
Cdigo C# 10.11: TestaConta.cs
1
2
3
4
1
2
3
4
1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
104
www.k19.com.br
105
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
C LASSES A BSTRATAS
class ContaPoupanca : Conta
{
public int DiaDoAniversario { get ; set ; }
public override void ImprimeExtratoDetalhado ()
{
System . Console . WriteLine ( " EXTRATO DETALHADO DE CONTA POUPANA " ) ;
System . DateTime agora = System . DateTime . Now ;
System . Console . WriteLine ( " DATA : " + agora . ToString ( " D " ) ) ;
System . Console . WriteLine ( " SALDO : " + this . Saldo ) ;
System . Console . WriteLine ( " ANIVERSRIO : " + this . DiaDoAniversario ) ;
}
}
Cdigo C# 10.16: ContaPoupanca.cs
10
1
2
3
4
5
6
7
8
9
10
11
Exerccios Complementares
1
Crie um objeto da classe que modela os funcionrios do banco e utilize os mtodos de acesso
com nomes padronizados para alterar os valores dos atributos.
3
4 Torne a classe que modela os funcionrios do banco abstrata e verifique o que acontece na classe
de teste.
5
Defina um mtodo abstrato na classe que modela os funcionrios para calcular a bonificao
dos colaboradores.
7
10
Altere a classe de teste para que o mtodo que calcula a bonificao seja chamada e o valor seja
impresso na tela.
www.k19.com.br
105
C LASSES A BSTRATAS
106
106
www.k19.com.br
CAPTULO
I NTERFACES
11
Padronizao
No dia a dia, estamos acostumados a utilizar aparelhos que dependem de energia eltrica. Esses
aparelhos possuem um plugue que deve ser conectado a uma tomada para obter a energia necessria.
Diversas empresas fabricam aparelhos eltricos com plugues. Analogamente, diversas empresas
fabricam tomadas eltricas. Suponha que cada empresa decida por conta prpria o formato dos
plugues ou das tomadas que fabricar. Teramos uma infinidade de tipos de plugues e tomadas que
tornaria a utilizao dos aparelhos eltricos uma experincia extremamente desagradvel.
Inclusive, essa falta de padro pode gerar problemas de segurana aos usurios. Os formatos dos
plugues ou das tomadas pode aumentar o risco de uma pessoa tomar um choque eltrico.
Com o intuito de facilitar a utilizao dos consumidores e aumentar a segurana dos mesmos,
o governo atravs dos rgos responsveis estabelece padres para os plugues e tomadas. Esses
padres estabelecem restries que devem ser respeitadas pelos fabricantes dos aparelhos e das tomadas.
Em diversos contextos, padronizar pode trazer grandes benefcios. Inclusive, no desenvolvimento de aplicaes. Mostraremos como a ideia de padronizao pode ser contextualizada nos conceitos de orientao a objetos.
Contratos
Num sistema orientado a objetos, os objetos interagem entre si atravs de chamadas de mtodos
www.k19.com.br
107
I NTERFACES
108
(troca de mensagens). Podemos dizer que os objetos se encaixam atravs dos mtodos pblicos
assim como um plugue se encaixa em uma tomada atravs dos pinos.
Para os objetos de uma aplicao conversarem entre si mais facilmente importante padronizar o conjunto de mtodos oferecidos por eles. Assim como os plugues encaixam nas tomadas mais
facilmente graas aos padres definidos pelo governo.
Um padro definido atravs de especificaes ou contratos. Nas aplicaes orientadas a objetos, podemos criar um contrato para definir um determinado conjunto de mtodos que deve ser
implementado pelas classes que assinarem este contrato. Em orientao a objetos, um contrato
chamado de interface. Um interface composta basicamente por mtodos abstratos.
Exemplo
No sistema do banco, podemos definir uma interface (contrato) para padronizar as assinaturas
dos mtodos oferecidos pelos objetos que representam as contas do banco.
1
2
3
4
5
interface IConta
{
void Deposita ( double valor ) ;
void Saca ( double valor ) ;
}
Cdigo C# 11.1: IConta.cs
Observe que somente assinaturas de mtodos so declaradas no corpo de uma interface. Todos
os mtodos de uma interface so pblicos e no pode incluir modificadores de acesso. Uma interface
s pode conter mtodos, propriedades, indexadores e eventos. Por conveno, em C#, o nome de
uma interface deve ter o prefixo I.
As classes que definem os diversos tipos de contas que existem no banco devem implementar
(assinar) a interface IConta. Para isso, devemos aplicar o comando :.
1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
108
www.k19.com.br
109
11
I NTERFACES
}
Cdigo C# 11.3: ContaCorrente.cs
As classes concretas que implementam uma interface so obrigadas a possuir uma implementao para cada mtodo declarado na interface. Caso contrrio, ocorrer um erro de compilao.
1
2
3
4
5
6
7
8
A primeira vantagem de utilizar uma interface a padronizao das assinaturas dos mtodos oferecidos por um determinado conjunto de classes. A segunda vantagem garantir que determinadas
classes implementem certos mtodos.
Polimorfismo
Se uma classe implementa uma interface, podemos aplicar a ideia do polimorfismo assim como
quando aplicamos herana. Dessa forma, outra vantagem da utilizao de interfaces o ganho do
polimorfismo.
Como exemplo, suponha que a classe ContaCorrente implemente a interface IConta. Podemos
guardar a referncia de um objeto do tipo ContaCorrente em uma varivel do tipo IConta.
1
Alm disso podemos passar uma varivel do tipo ContaCorrente para um mtodo que o parmetro seja do tipo IConta.
1
2
3
4
5
6
7
class GeradorDeExtrato
{
public void GeraExtrato ( IConta c )
{
// implementao
}
}
Cdigo C# 11.6: GeradorDeExtrato.cs
1
2
3
O mtodo GeraExtrato() pode ser aproveitado para objetos criados a partir de classes que implementam direta ou indiretamente a interface IConta.
www.k19.com.br
109
I NTERFACES
110
Interface e Herana
As vantagens e desvantagens entre interface e herana, provavelmente, um dos temas mais
discutido nos blogs, fruns e revistas que abordam desenvolvimento de software orientado a objetos.
Muitas vezes, os debates sobre este assunto se estendem mais do que a prpria importncia desse
tpico. Muitas pessoas se posicionam de forma radical defendendo a utilizao de interfaces ao invs
de herana em qualquer situao.
Normalmente, esses debates so direcionados na anlise do que melhor para manuteno das
aplicaes: utilizar interfaces ou aplicar herana.
A grosso modo, priorizar a utilizao de interfaces permite que alteraes pontuais em determinados trechos do cdigo fonte sejam feitas mais facilmente pois diminui as ocorrncias de efeitos
colaterais indesejados no resto da aplicao. Por outro lado, priorizar a utilizao de herana pode
diminuir a quantidade de cdigo escrito no incio do desenvolvimento de um projeto.
Algumas pessoas propem a utilizao de interfaces juntamente com composio para substituir
totalmente o uso de herana. De fato, esta uma alternativa interessante pois possibilita que um
trecho do cdigo fonte de uma aplicao possa ser alterado sem causar efeito colateral no restante
do sistema alm de permitir a reutilizao de cdigo mais facilmente.
Em C#, como no h herana mltipla, muitas vezes, interfaces so apresentadas como uma
alternativa para obter um grau maior de polimorfismo.
Por exemplo, suponha duas rvores de herana independentes.
Suponha que os gerentes e as empresas possam acessar o sistema do banco com um nome de
usurio e uma senha. Seria interessante utilizar um nico mtodo para implementar a autenticao
desses dois tipos de objetos. Mas, qual seria o tipo de parmetro deste mtodo? Lembrando que ele
deve aceitar gerentes e empresas.
110
www.k19.com.br
111
1
2
3
4
5
6
7
I NTERFACES
class AutenticadorDeUsuario
{
public bool Autentica (??? u )
{
// implementao
}
}
Cdigo C# 11.8: AutenticadorDeUsuario.cs
Agora, conseguimos definir o que o mtodo Autentica() deve receber como parmetro para trabalhar tanto com gerentes quanto com empresas. Ele deve receber um parmetro do tipo IUsuario.
1
2
3
4
5
6
7
class AutenticadorDeUsuario
{
public bool Autentica ( IUsuario u )
{
// implementao
}
}
Cdigo C# 11.9: AutenticadorDeUsuario.cs
Exerccios de Fixao
1
Defina uma interface para padronizar as assinaturas dos mtodos das contas do banco.
www.k19.com.br
111
I NTERFACES
1
2
3
4
5
6
7
112
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
112
www.k19.com.br
113
I NTERFACES
Crie um gerador de extratos com um mtodo que pode trabalhar com todos os tipos de conta.
1
2
3
4
5
6
7
8
class GeradorDeExtrato
{
public void GeraExtrato ( IConta c )
{
System . Console . WriteLine ( " EXTRATO " ) ;
System . Console . WriteLine ( " SALDO : " + c . Saldo ) ;
}
}
Cdigo C# 11.14: GeradorDeExtrato.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
www.k19.com.br
113
I NTERFACES
114
114
www.k19.com.br
CAPTULO
N AMESPACE
12
Organizao
O cdigo fonte de uma aplicao definido em diversos arquivos. Conforme a quantidade de
arquivos cresce surge a necessidade de algum tipo de organizao para poder encontrar os arquivos
rapidamente quando for necessrio modific-los.
A ideia para organizar logicamente os arquivos de uma aplicao bem simples e as pessoas
que utilizam computadores j devem estar familiarizadas. Os arquivos so separados em pastas ou
diretrios.
O comando namespace
Na terminologia do C#, as pastas nas quais so organizadas as classes e interfaces de uma aplicao so chamadas de namespaces. Devemos utilizar o comando namespace para separar as classes
e interfaces de uma aplicao.
1
2
3
4
5
6
7
namespace Sistema
{
class Conta
{
// corpo da classe
}
}
Cdigo C# 12.1: Conta.cs
comum, para cada namespace, criar uma pasta com o mesmo nome do namespace e salvar
todos os arquivos fonte que possuem classes ou interfaces desse namespace nessa pasta.
Namespaces Encadeados
Assim como as pastas de um sistema operacional, os namespaces podem ser colocados dentro
de outros namespaces.
1
2
3
4
5
6
7
8
9
namespace Sistema
{
namespace Contas
{
class Conta
{
// corpo da classe
}
}
www.k19.com.br
115
N AMESPACE
10
116
}
Cdigo C# 12.2: Conta.cs
Namespace global
Todas as classes, interfaces ou namespaces que no forem explicitamente colocadas em um namespace so automaticamente colocados no namespace global.
116
www.k19.com.br
117
N AMESPACE
1
2
3
4
5
6
7
8
A classe ContaPoupanca declara que herda da classe Conta apenas utilizando o nome simples.
Por outro lado, duas classes de namespaces diferentes precisam utilizar o nome completo de
cada uma delas para conversar entre si. O mesmo vale para interfaces. Como exemplo, considere
as seguintes classes:
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8
9
Using
Para facilitar a escrita do cdigo fonte, podemos utilizar o comando using para no ter que repetir o nome completo de uma classe ou interface vrias vezes dentro do mesmo arquivo.
1
2
3
4
5
6
7
8
9
10
www.k19.com.br
117
N AMESPACE
118
Nveis de visibilidade
No C#, h cinco nveis de visibilidade: privado, interno, protegido, protegido interno e pblico.
Podemos definir os nveis privado, protegido, pblico e interno com os modificadores private,
protected, public e internal respectivamente.
Privado
O nvel privado aplicado com o modificador private.
O que pode ser privado? Atributos, propriedades, construtores, mtodos, classes aninhadas ou
iterfaces aninhadas.
Os itens em nvel de visibilidade privado s podem ser acessados por cdigo escrito na mesma
classe na qual eles foram declarados.
Interno
O nvel interno aplicado com o modificador internal.
O que pode ser interno? Atributos, propriedades, construtores, mtodos, classes ou interfaces.
Os itens em nvel de visibilidade interno s podem ser acessados por cdigo escrito em classes
do mesmo assembly (.exe ou .dll) da classe na qual eles foram declarados.
Protegido
O nvel protegido aplicado com o modificador protected.
Os itens em nvel de visibilidade protegido s podem ser acessados pela prpria classe ou por
classes derivadas.
O que pode ser protegido? Atributos, propriedades, construtores, mtodos, classes aninhadas ou
interfaces aninhadas.
Pblico
O nvel pblico aplicado quando o modificador public utilizado.
118
www.k19.com.br
119
N AMESPACE
Os itens em nvel de visibilidade pblico podem ser acessados de qualquer lugar do cdigo da
aplicao.
O que pode ser pblico? Atributos, propriedades, construtores, mtodos, classes ou interfaces.
Protegido Interno
O nvel protegido interno aplicado associando o modificador protected com o modificador
Exerccios de Fixao
1
Faa uma classe para modelar as contas dentro de um namespace chamado Organizacao.Sistema.Contas.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
www.k19.com.br
119
N AMESPACE
120
120
www.k19.com.br
CAPTULO
E XCEPTIONS
13
Como erros podem ocorrer durante a execuo de uma aplicao, devemos definir como eles
sero tratados. Tradicionalmente, cdigos de erro so utilizados para lidar com falhas na execuo
de um programa. Nesta abordagem, os mtodos devolveriam nmeros inteiros para indicar o tipo
de erro que ocorreu.
1
2
3
4
5
6
7
8
9
10
11
12
Utilizar cdigos de erro exige uma vasta documentao dos mtodos para explicar o que cada cdigo significa. Alm disso, esta abordagem gasta o retorno do mtodo impossibilitando que outros
tipos de dados sejam devolvidos. Em outras palavras, ou utilizamos o retorno para devolver cdigos
de erro ou para devolver algo pertinente a lgica natural do mtodo. No possvel fazer as duas
coisas sem nenhum tipo de gambiarra.
1
2
3
4
5
6
7
8
9
10
11
12
??? GeraRelatorio ()
{
if (...)
{
return 200; // cdigo de erro tipo1
}
else
{
Relatorio relatorio = ...
return relatorio ;
}
}
Cdigo C# 13.2: Cdigo de erro e retorno lgico
Observe que no cdigo do mtodo GeraRelatorio() seria necessrio devolver dois tipos de dados incompatveis: int e referncias de objetos da classe Relatorio. Porm, no possvel definir
dois tipos distintos como retorno de um mtodo.
A linguagem C# tem uma abordagem prpria para lidar com erros de execuo. Na abordagem
do C# no so utilizados cdigos de erro ou os retornos lgicos dos mtodos.
Exceptions e SystemExceptions
www.k19.com.br
121
E XCEPTIONS
122
Na plataforma .NET, os erros de execuo so definidos por classes que derivam direta ou indiretamente da classe System.Exception. Diversos erros j esto definidos na plataforma .NET. As
classes que modelam os erros pr-definidos derivam da classe System.SystemException. A seguir
uma tabela com as principais classes derivadas de System.SystemException.
Exception
DivideByZeroException
IndexOutOfRangeException
NullReferenceException
InvalidCastException
Descrio
Erro gerado quando dividimos nmeros inteiros por zero.
Erro gerado quando acessamos posies inexistentes de um array
Erro gerado quando utilizamos referncias nulas
Erro gerado quando realizamos um casting incompatvel
Lanando erros
Para lanar um erro, devemos criar um objeto de qualquer classe que deriva de Exception para
representar o erro que foi identificado.
Depois de criar uma exception podemos lanar a referncia dela utilizando o comando throw. Observe o exemplo utilizando a classe System.ArgumentException que deriva indiretamente
da classe System.Exception.
1
2
3
4
5
if ( valor < 0)
{
System . ArgumentException erro = new System . ArgumentException () ;
throw erro ;
}
Cdigo C# 13.3: Lanando uma System.ArgumentException
Capturando erros
Em um determinado trecho de cdigo, para capturar uma exception devemos utilizar o comando
try-cacth.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Teste
{
static void Main ()
{
Conta c = new Conta () ;
try
{
c . Deposita (100) ;
}
catch ( System . ArgumentException e )
{
System . Console . WriteLine ( " Houve um erro ao depositar " ) ;
}
}
}
Cdigo C# 13.4: Teste.cs
122
www.k19.com.br
123
E XCEPTIONS
Podemos encadear vrios blocos catch para capturar exceptions de classes diferentes.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Teste
{
static void Main ()
{
Conta c = new Conta () ;
try
{
c . Deposita (100) ;
}
catch ( System . ArgumentException e )
{
System . Console . WriteLine ( " Houve uma System . ArgumentException ao depositar " ) ;
}
catch ( System . IO . FileNotFoundException e )
{
System . Console . WriteLine ( " Houve um FileNotFoundException ao depositar " ) ;
}
}
}
Cdigo C# 13.5: Teste.cs
finally
Se um erro acontecer no bloco try ele abortado. Consequentemente, nem sempre todas as
linhas do bloco try sero executadas. Alm disso, somente um bloco catch executado quando
ocorre um erro.
Em alguns casos, queremos executar um trecho de cdigo independetemente se houver erros ou
no. Para isso podemos, utilizar o bloco finally.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
try
{
// cdigo
}
catch ( System . DivideByZeroException e )
{
System . Console . WriteLine ( " Tratamento de diviso por zero " ) ;
}
catch ( System . NullReferenceException e )
{
System . Console . WriteLine ( " Tratamento de referncia nula " ) ;
}
finally
{
// cdigo que deve ser sempre executado
}
Cdigo C# 13.6: Utilizando o bloco finally
Exerccios de Fixao
1
123
E XCEPTIONS
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
124
using System ;
class Funcionario
{
private double salario ;
public void AumentaSalario ( double aumento )
{
if ( aumento < 0)
{
ArgumentException erro = new ArgumentException () ;
throw erro ;
}
}
}
Cdigo C# 13.7: Funcionario.cs
1
2
3
4
5
6
7
8
class TestaFuncionario
{
static void Main ()
{
Funcionario f = new Funcionario () ;
f . AumentaSalario ( -1000) ;
}
}
Cdigo C# 13.8: TestaFuncionario.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
124
www.k19.com.br
CAPTULO
O BJECT
14
Polimorfismo
Aproveitando o polimorfismo gerado pela herana da classe Object, possvel criar uma classe
para armazenar objetos de qualquer tipo como se fosse uma repositrio de objetos.
1
2
3
4
class Repositorio
{
// codigo da classe
}
Cdigo C# 14.1: Repositorio.cs
Um array de objetos pode ser utilizado como estrutura bsica para manter os objetos da repositrio.
1
2
3
4
5
6
class Repositorio
{
// object : alias para System . Object
private object [] objetos = new object [100];
}
Cdigo C# 14.2: Repositorio.cs
www.k19.com.br
125
O BJECT
126
Alguns mtodos podem ser criados para formar a interface do repositrio. Por exemplo, mtodos
para adicionar, retirar e pesquisar elementos.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Repositorio
{
private object [] objetos = new object [100];
Com esses mtodos o repositrio teria a vantagem de armazenar objetos de qualquer tipo. Porm, na compilao, no haveria garantia sobre os tipos especficos. Em outras palavras, j que objetos de qualquer tipo podem ser armazenados no repositrio ento objetos de qualquer tipo podem
sair dele.
1
2
3
Por outro lado, na maioria dos casos, os programadores criam repositrios para armazenar objetos de um determinado tipo. Por exemplo, uma repositrio para armazenar somente nomes de
pessoas, ou seja, para armazenar objetos do tipo String. Nesse caso, em tempo de compilao
possvel forar o compilador a tratar os objetos como string aplicando casting de referncia.
1
2
3
4
O mtodo ToString()
s vezes, necessrio trabalhar com uma descrio textual de determinados objetos. Por exemplo, suponha a seguinte classe:
1
2
3
4
126
class Conta
{
public int Numero { get ; set ; }
public double Saldo { get ; set ; }
www.k19.com.br
127
5
O BJECT
}
Cdigo C# 14.6: Conta.cs
Queremos gerar um documento no qual deve constar as informaes de algumas contas. Podemos implementar um mtodo, na classe Conta, que gere uma descrio textual dos objetos dessa
classe.
1
2
3
4
5
6
7
8
9
10
class Conta
{
public int Numero { get ; set ; }
public double Saldo { get ; set ; }
public string GeraDescricao ()
{
return " Conta nmero : " + this . Numero + " possui saldo igual a " + this . Saldo ;
}
}
Cdigo C# 14.7: Conta.cs
A utilizao do mtodo que gera a descrio textual das contas seria mais ou menos assim:
1
2
3
Contudo, a classe Object possui um mtodo justamente com o mesmo propsito do GeraDescricao()
chamado ToString(). Como todas as classes derivam direta ou indiretamente da classe Object, todos os objetos possuem o mtodo ToString().
A implementao padro do mtodo ToString() monta uma descrio genrica baseada no
nome da classe mais especfica dos objetos.
1
2
3
No cdigo acima, a descrio gerada pelo mtodo ToString() definido na classe Object seria:
Conta.
Para alterar o comportamento do mtodo ToString(), basta reescrev-lo na classe Conta.
1
2
3
4
5
6
7
8
9
10
class Conta
{
public int Numero { get ; set ; }
public double Saldo { get ; set ; }
public override string ToString ()
{
return " Conta nmero : " + this . Numero + " possui saldo igual a " + this . Saldo ;
}
}
Cdigo C# 14.10: Conta.cs
www.k19.com.br
127
O BJECT
128
O mtodo Equals()
Para verificar se os valores armazenados em duas variveis de algum tipo primitivo so iguais,
devemos utilizar o operador == . Esse operador tambm pode ser aplicado em variveis de tipos
no primitivos.
1
2
3
4
Conta c1 = ...
Conta c2 = ...
System . Console . WriteLine ( c1 == c2 ) ;
Cdigo C# 14.12: Comparando com
O operador ==, aplicado variveis no primitivas, verifica se as referncias armazenadas nessas variveis apontam para o mesmo objeto na memria. Esse operador, por padro, no compara o
contedo dos objetos correspondentes s referncias armazenadas nas variveis submetidas comparao.
Para comparar o contedo de objetos, podemos utilizar mtodos. Podemos implementar um
mtodo de comparao na classe Conta.
1
2
3
4
5
6
7
8
9
10
class Conta
{
public int Numero { get ; set ; }
public double Saldo { get ; set ; }
public bool Compara ( Conta outra )
{
return this . Numero == outra . Numero ;
}
}
Cdigo C# 14.13: Conta.cs
Conta c1 = ...
Conta c2 = ...
System . Console . WriteLine ( c1 . Compara ( c2 ) ) ;
Cdigo C# 14.14: Comparando com Compara()
Contudo, na classe Object, j existe um mtodo com o mesmo propsito. O mtodo ao qual nos
referimos o Equals(). A implementao padro do mtodo Equals() na classe Object delega a
128
www.k19.com.br
129
O BJECT
comparao ao operador ==. Dessa forma, o contedo dos objetos no comparado por padro.
Podemos rescrever o mtodo Equals() para alterar esse comportamento e passar a considerar o
contedo dos objetos na comparao.
1
2
3
4
5
6
7
8
9
10
11
class Conta
{
public int Numero { get ; set ; }
public double Saldo { get ; set ; }
public override bool Equals ( object obj )
{
Conta outra = obj as Conta ;
return this . Numero == outra . Numero ;
}
}
Cdigo C# 14.15: Conta.cs
Exerccios de Fixao
1
1
2
3
4
5
6
class Funcionario
{
public string Nome { get ; set ; }
public double Salario { get ; set ; }
}
Cdigo C# 14.16: Funcionario.cs
1
2
3
4
5
6
7
8
9
10
11
12
Execute o projeto!
4
Reescreva o mtodo ToString() na classe Funcionario para alterar a descrio textual dos
objetos que representam os funcionrios.
class Funcionario
www.k19.com.br
129
O BJECT
2
3
4
5
6
7
8
9
10
11
130
{
public string Nome { get ; set ; }
public double Salario { get ; set ; }
public override string ToString ()
{
return " Funcionrio : " + this . Nome + " - Salrio : " + this . Salario ;
}
}
Cdigo C# 14.18: Funcionario.cs
6
Altere o mtodo Main a classe Aplicacao. Crie dois objetos da classe Funcionario. Utilize o
operador == e o mtodo Equals() para compar-los.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Aplicacao
{
static void Main ()
{
Funcionario f1 = new Funcionario () ;
f1 . Nome = " Jonas Hirata " ;
f1 . Salario = 3000;
Funcionario f2 = new Funcionario () ;
f2 . Nome = " Jonas Hirata " ;
f2 . Salario = 3000;
System . Console . WriteLine ( f1 == f2 ) ;
System . Console . WriteLine ( f1 . Equals ( f2 ) ) ;
}
}
Cdigo C# 14.19: Aplicacao.cs
Reescreva o mtodo Equals() na classe Funcionario para alterar o critrio de comparao dos
funcionrios.
8
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Funcionario
{
public string Nome { get ; set ; }
public double Salario { get ; set ; }
public override string ToString ()
{
return " Funcionrio : " + this . Nome + " - Salrio : " + this . Salario ;
}
public override bool Equals ( object obj )
{
Funcionario outro = ( Funcionario ) obj ;
return this . Nome == outro . Nome ;
}
}
Cdigo C# 14.20: Funcionario.cs
130
CAPTULO
S TRING
15
Imutabilidade
Uma caracterstica fundamental dos objetos da classe String que eles so imutveis. Em outras
palavras, o contedo de uma string no altera.
Alguns mtodos das strings podem dar a impresso errada de que o contedo do objeto ser alterado. Por exemplo, o mtodo ToUpper() que utilizado para obter uma string com letras maisculas.
Esse mtodo no altera a string original, ele cria uma nova string com o contedo diferente.
1
2
3
4
5
6
1
2
3
4
5
6
Mtodos e Propriedades
Todos os mtodos e propriedades da classe String podem ser consultados na url http://msdn.
microsoft.com/en-us/library/system.string.aspx. Discutiremos aqui o funcionamento dos
principais mtodos e propriedades dessa classe.
Length
A propriedade Length armazena a quantidade de caracteres de uma string.
www.k19.com.br
131
S TRING
1
2
3
4
132
ToUpper()
O mtodo ToUpper() utilizado para obter uma cpia de uma string com letras maisculas.
1
2
3
4
5
6
ToLower()
O mtodo ToLower() utilizado para obter uma cpia de uma string com letras minsculas.
1
2
3
4
5
6
Trim()
O mtodo Trim() utilizado para obter uma cpia de uma string sem os espaos em braco do
incio e do final.
1
2
3
4
5
6
";
Split()
O mtodo Split() divide uma string em vrias de acordo com um delimitador e devolve um
array com as strings obtidas.
132
www.k19.com.br
133
1
2
3
4
5
6
7
8
9
S TRING
string texto = " K31 , K32 " ;
string [] cursos = texto . Split ( new char []{ , }) ;
// imprime K31
System . Console . WriteLine ( cursos [0]) ;
// imprime K32
System . Console . WriteLine ( cursos [1]) ;
Cdigo C# 15.7: Split()
Replace()
O mtodo Replace() cria uma cpia de uma string substituindo pedaos internos por outro
contedo.
1
2
3
4
5
6
string texto = " Curso de CSharp da K19 , Curso de ASP . NET MVC da K19 " ;
string textoAlterado = texto . Replace ( " Curso " ," Treinamento " ) ;
// imprime Treinamento de CSharp da K19 , Treinamento de ASP . NET MVC da K19
System . Console . WriteLine ( textoAlterado ) ;
Cdigo C# 15.8: Replace()
Exerccios de Fixao
1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
www.k19.com.br
133
S TRING
134
134
www.k19.com.br
CAPTULO
E NTRADA E S ADA
16
Quando falamos em entrada e sada, estamos nos referindo a qualquer troca de informao entre
uma aplicao e o seu exterior.
A leitura do que o usurio digita no teclado, o contedo obtido de um arquivo ou os dados recebidos pela rede so exemplos de entrada de dados. A impresso de mensagens no console, a escrita
de texto em um arquivo ou envio de dados pela rede so exemplos de sada de dados.
A plataforma .NET oferece diversas classes e interfaces para facilitar o processo de entrada e
sada.
Leitura
Para ler um texto de um arquivo, do teclado ou de qualquer outra fonte de dados, devemos criar
objetos da classe System.IO.TextReader e associ-los a uma determinada fonte de dados (teclado,
arquivo, rede, entre outros).
1
2
3
4
5
Depois de associar um TextReader a uma fonte de dados, podemos fazer a leitura atravs do
mtodo ReadLine. Esse mtodo devolver null quando o texto acabar.
1
2
3
4
5
6
7
8
Escrita
Para escrever um texto em um arquivo, na tela ou de qualquer outro destino de dados, devemos
criar objetos da classe System.IO.TextWriter e associ-los a um determinado destino de dados (tela,
arquivo, rede, entre outros).
www.k19.com.br
135
E NTRADA E S ADA
1
2
3
4
5
136
Exerccios de Fixao
1
Crie um teste para recuperar e imprimir na tela o contedo digitado pelo usurio no teclado.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
using System ;
using System . IO ;
public class LeituraDoTeclado
{
static void Main ()
{
TextReader teclado = Console . In ;
string linha = teclado . ReadLine () ;
while ( linha != null )
{
System . Console . WriteLine ( linha ) ;
linha = teclado . ReadLine () ;
}
}
}
Cdigo C# 16.5: LeituraDoTeclado.cs
1
2
3
4
5
6
7
8
9
10
11
12
136
www.k19.com.br
137
13
14
15
16
E NTRADA E S ADA
}
arquivo . Close () ;
}
}
Cdigo C# 16.6: LeituraDeArquivo.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Exerccios Complementares
1
Crie um teste que faa a leitura do contedo de um arquivo e grave em outro arquivo.
www.k19.com.br
137
E NTRADA E S ADA
138
138
www.k19.com.br
CAPTULO
C OLLECTIONS
17
Quando uma aplicao precisa manipular uma quantidade grande de dados, ela deve utilizar
alguma estrutura de dados. Podemos dizer que a estrutura de dados mais bsica do C# so os arrays.
Muitas vezes, trabalhar diretamente com arrays no simples dado as diversas limitaes que
eles possuem. A limitao principal a capacidade fixa, um array no pode ser redimensionado. Se
todas as posies de um array estiverem ocupadas no podemos adicionar mais elementos. Normalmente, criamos um outro array com maior capacidade e transferimos os elementos do array antigo
para o novo.
Alm disso, adicionar ou remover elementos provavelmente gera a necessidade de deslocar parte
do contedo do array.
As dificuldades do trabalho com array podem ser superadas com estruturas de dados mais sofisticadas. Na biblioteca do C#, h diversas estruturas de dados que facilitam o trabalho do desenvolvedor.
Listas
As listas so estruturas de dados de armazenamento sequencial assim como os arrays. Mas, diferentemente dos arrays, as listas no possuem capacidade fixa o que facilita bastante o trabalho.
IList a interface C# que define os mtodos que uma lista deve implementar. A principal implementao dessa interface a classe ArrayList.
1
Podemos aplicar o polimorfismo e referenciar objetos criados a partir da classe: ArrayList como
IList.
1
Mtodo: Add(object)
O mtodo Add(object) adiciona uma referncia no final da lista e aceita referncias de qualquer
tipo.
1
www.k19.com.br
139
C OLLECTIONS
2
3
4
5
6
140
Propriedade: Count
A propriedade Count informa a quantidade de elementos armazenado na lista.
1
2
3
4
5
6
7
8
9
Mtodo: Clear()
O mtodo Clear() remove todos os elementos da lista.
1
2
3
4
5
6
7
8
140
www.k19.com.br
141
9
10
11
12
13
14
C OLLECTIONS
int quantidade = list . Count ;
list . Clear () ;
// quantidade = 0
quantidade = list . Count ;
Cdigo C# 17.6: Eliminando todos os elementos de uma lista
Mtodo: Contains(object)
Para verificar se um elemento est contido em uma lista, podemos utilizar o mtodo Contains(object)
1
2
3
4
5
6
7
8
9
10
Mtodo: Remove(object)
Podemos retirar elementos de uma lista atravs do mtodo Remove(object). Este mtodo remove a primeira ocorrncia do elemento passado como parmetro.
1
2
3
4
5
6
7
8
9
10
11
Mtodo: RemoveAt(int)
Outra maneira para retirar elementos de uma lista atravs do mtodo RemoveAt(int).
1
2
3
4
5
6
7
www.k19.com.br
141
C OLLECTIONS
8
9
10
11
142
Propriedade: Item
Para recuperar um elemento de uma determinada posio de uma lista podemos utilizar a propriedade Item. Com esta propriedade, podemos utilizar a seguinte sintaxe para acessar um elemento
numa determinada posio: myList[posicao]
1
2
3
4
5
6
Mtodo: IndexOf(object)
Para descobrir o ndice da primeira ocorrncia de um determinado elemento podemos utilizar o
mtodo IndexOf(object).
1
2
3
4
5
6
Exerccios de Fixao
Crie um projeto do tipo Console Application no Microsoft Visual C# Express chamado Collecti-
ons.
2
1
2
3
4
5
6
7
8
9
10
11
142
www.k19.com.br
143
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
C OLLECTIONS
Console . WriteLine ( " ArrayList : " + tempo + " ms " ) ;
}
public static long AdicionaNoFinal ( IList lista )
{
Stopwatch sw = new Stopwatch () ;
sw . Start () ;
int size = 100000;
for ( int i = 0; i < size ; i ++)
{
lista . Add ( i ) ;
}
sw . Stop () ;
return sw . ElapsedMilliseconds ;
}
}
Cdigo C# 17.12: TestaAdicionaNoFinal.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
using System ;
using System . Collections ;
using System . Diagnostics ;
public class TestaAdicionaNoComeco
{
static void Main ()
{
ArrayList arrayList = new ArrayList () ;
long tempo = TestaAdicionaNoComeco . AdicionaNoComeco ( arrayList ) ;
Console . WriteLine ( " ArrayList : " + tempo + " ms " ) ;
}
public static long AdicionaNoComeco ( IList lista )
{
Stopwatch sw = new Stopwatch () ;
sw . Start () ;
int size = 100000;
for ( int i = 0; i < size ; i ++)
{
lista . Insert (0 , i ) ;
}
sw . Stop () ;
return sw . ElapsedMilliseconds ;
}
}
Cdigo C# 17.13: TestaAdicionaNoComeco.cs
Generics
As listas armazenam referncias de qualquer tipo. Dessa forma, quando recuperamos um elemento de uma lista temos que trabalhar com referncias do tipo object.
www.k19.com.br
143
C OLLECTIONS
1
2
3
4
5
6
7
8
144
Porm, normalmente, precisamos tratar os objetos de forma especfica pois queremos ter acesso
aos mtodos especficos desses objetos. Nesses casos, devemos fazer casting nas referncias.
1
2
3
4
5
6
7
8
9
O casting de referncia arriscado pois em tempo de compilao no temos garantia que ele est
correto. Dessa forma, corremos o risco de obter um erro de execuo.
Para ter certeza da tipagem dos objetos em tempo de compilao, devemos aplicar o recurso do
Generics. Com este recurso podemos determinar o tipo de objeto que queremos armazenar em uma
coleo no momento em que ela criada. A partir da, o compilador no permitir que elementos
no compatveis com o tipo escolhido sejam adicionados na coleo. Isso garante o tipo do elemento
no momento em que ele recuperado da coleo e elimina a necessidade de casting.
As classes que contm o recurso Generics fazem parte do namespace System.Collections.Generic.
A classe genrica equivalente a ArrayList a List. Outra implementao importante de listas genricas a LinkedList.
1
2
List < string > arrayList = new List < string >() ;
LinkedList < string > linkedList = new LinkedList < string >() ;
Cdigo C# 17.16: Criando listas parametrizadas
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
144
List < string > arrayList = new List < string >() ;
arrayList . Add ( " Rafael Cosentino " ) ;
foreach ( string x in arrayList )
{
Console . WriteLine ( x . ToUpper () ) ;
}
LinkedList < string > linkedList = new LinkedList < string >() ;
linkedList . AddLast ( " Rafael Cosentino " ) ;
foreach ( string x in linkedList )
{
Console . WriteLine ( x . ToUpper () ) ;
}
www.k19.com.br
145
C OLLECTIONS
Benchmarking
As duas principais implementaes de listas genricas em C# possuem desempenho diferentes
para cada operao. O desenvolvedor deve escolher a implementao de acordo com a sua necessidade.
Operao
Adicionar ou Remover do final da lista
Adicionar ou Remover do comeo da
lista
Acessar elementos pela posio
List
LinkedList
,
/
,
,
Exerccios de Fixao
4
Crie um projeto do tipo Console Application no Microsoft Visual C# Express chamado Generic.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
using System ;
using System . Collections . Generic ;
using System . Diagnostics ;
public class TestaAdicionaNoFinal
{
static void Main ()
{
List < int > arrayList = new List < int >() ;
long tempo = TestaAdicionaNoFinal . AdicionaNoFinal ( arrayList ) ;
Console . WriteLine ( " ArrayList : " + tempo + " ms " ) ;
LinkedList < int > linkedList = new LinkedList < int >() ;
tempo = TestaAdicionaNoFinal . AdicionaNoFinal ( linkedList ) ;
Console . WriteLine ( " LinkedList : " + tempo + " ms " ) ;
}
public static long AdicionaNoFinal ( ICollection < int > lista )
{
Stopwatch sw = new Stopwatch () ;
sw . Start () ;
int size = 100000;
for ( int i = 0; i < size ; i ++)
{
lista . Add ( i ) ;
}
sw . Stop () ;
return sw . ElapsedMilliseconds ;
www.k19.com.br
145
C OLLECTIONS
35
36
146
}
}
Cdigo C# 17.18: TestaAdicionaNoFinal.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
using System ;
using System . Collections . Generic ;
using System . Diagnostics ;
public class TestaAdicionaNoComeco
{
static void Main ()
{
List < int > arrayList = new List < int >() ;
long tempo = TestaAdicionaNoComeco . AdicionaNoComecoArrayList ( arrayList ) ;
Console . WriteLine ( " ArrayList : " + tempo + " ms " ) ;
LinkedList < int > linkedList = new LinkedList < int >() ;
tempo = TestaAdicionaNoComeco . AdicionaNoComecoLinkedList ( linkedList ) ;
Console . WriteLine ( " LinkedList : " + tempo + " ms " ) ;
}
public static long AdicionaNoComecoArrayList ( List < int > lista )
{
Stopwatch sw = new Stopwatch () ;
sw . Start () ;
int size = 100000;
for ( int i = 0; i < size ; i ++)
{
lista . Insert (0 , i ) ;
}
sw . Stop () ;
return sw . ElapsedMilliseconds ;
}
public static long AdicionaNoComecoLinkedList ( LinkedList < int > lista )
{
Stopwatch sw = new Stopwatch () ;
sw . Start () ;
int size = 100000;
for ( int i = 0; i < size ; i ++)
{
lista . AddFirst ( i ) ;
}
sw . Stop () ;
return sw . ElapsedMilliseconds ;
}
}
Cdigo C# 17.19: TestaAdicionaNoComeco.cs
Teste o desempenho para remover elementos do comeo ou do fim das principais listas.
Conjuntos
146
www.k19.com.br
147
C OLLECTIONS
Os conjuntos diferem das listas pois no permitem elementos repetidos e no possuem ordem.
Como os conjuntos no possuem ordem as operaes baseadas em ndice que existem nas listas no
aparecem nos conjuntos.
ISet a interface genrica C# que define os mtodos que um conjunto deve implementar. A
principal implementao da interface ISet : HashSet.
Colees
H semelhanas conceituais entre os conjuntos e as listas por isso existe uma super interface
genrica chamada ICollection para as interfaces genricas IList e ISet.
ICollection < string > conjunto = new HashSet < string >() ;
ICollection < string > lista = new List < string >() ;
Cdigo C# 17.20: Aplicando polimorfismo
Lao foreach
As listas podem ser iteradas com um lao for tradicional.
1
2
3
4
5
6
IList < string > lista = new List < string >() ;
for ( int i = 0; i < lista . Count ; i ++)
{
string x = lista [ i ];
}
Cdigo C# 17.21: for tradicional
Porm, como os conjuntos no so baseados em ndice eles no podem ser iterados com um lao
for tradicional. A maneira mais eficiente para percorrer uma coleo utilizar um lao foreach.
1
2
www.k19.com.br
147
C OLLECTIONS
3
4
5
6
148
O foreach utilizado para percorrer os elementos da coleo e recuperar a informao que voc
deseja, mas no possvel utiliz-lo para adicionar ou remover elementos, para estes casos voc deve
utilizar o for.
Exerccios de Fixao
7
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
148
www.k19.com.br
CAPTULO
T HREADS
18
Se pensarmos nos programas que utilizamos comumente no dia a dia, conseguiremos chegar
a seguinte concluso: um programa executa um conjunto de tarefas relativamente independentes
entre si. Por exemplo, um navegador pode baixar vrios arquivos diferentes alm de permitir a navegao. Um software de visualizao de vdeos alm de reproduzir imagens tambm reproduzir
sons.
Se pensarmos em sistemas corporativos, tambm chegamos na mesma concluso: um sistema
corporativo executa um conjunto de tarefas relativamente independentes entre si. Por exemplo, dois
ou mais usurios acessando o mesmo sistema para fazer coisas diferentes.
J que um programa ou um sistema corporativo executa tarefas relativamente independentes entre si podemos pensar em execut-las simultaneamente. A primeira grande limitao para executar
tarefas simultaneamente a quantidade de unidades de processamento (cpus) disponveis.
Em geral, a regra para saber quantas tarefas podemos executar simultaneamente bem simples:
se temos N unidades de processamento podemos executar no mximo N tarefas. Uma exceo a
essa regra ocorre quando a tecnologia hyperthreading aplicada. Essa tecnologia permite o aproveitamento do tempo ocioso de uma cpu.
Geralmente, a quantidade de tarefas que desejamos executar maior do que a quantidades de
cpus. Supondo que as tarefas sejam executadas sem interrupo do comeo at o fim ento com alta
probabilidade teramos constantemente um cenrio com todas as cpus ocupadas com tarefas grandes e demoradas e diversas tarefas menores que poderiam ser executadas rapidamente esperando
em uma fila. Esse cenrio no adequado para sistema com alta interatividade com usurios pois
diminui a sua responsividade (o efeito de uma ao do usurio demora).
Para aumentar a responsividade das aplicaes, o sistema operacional faz um revezamento das
tarefas que precisam executar. Isso evita que tarefas demoradas travem a utilizao das cpus tornando a interatividade mais satisfatria.
O trabalho do desenvolvedor definir quais so as tarefas que uma aplicao deve realizar e
determinar quando elas devem executar.
Definindo Tarefas
As tarefas que uma aplicao .NET deve executar so definidas atravs de mtodos. Por exemplo,
suponha que a primeira tarefa da nossa aplicao imprimir vrias vezes a palavra K19.
1
2
3
4
5
www.k19.com.br
149
T HREADS
6
7
150
}
}
Cdigo C# 18.1: Tarefa que imprime vrias vezes a palavra K19
Executando Tarefas
As tarefas so executadas dentro de objetos da classe System.Threading.Thread. Para cada
tarefa que desejamos executar, devemos criar um objeto da classe Thread e associ-lo ao mtodo
que define a tarefa.
1
2
Depois de associar uma tarefa (mtodo que define o que queremos executar) a um objeto da
classe Thread, devemos disparar a execuo da thread atravs do mtodo Start().
1
2
Podemos disparar diversas threads e elas podero ser executadas simultaneamente de acordo
com o revezamento que a mquina virtual e o sistema operacional aplicarem.
Exerccios de Fixao
1
1
2
3
4
5
6
7
8
9
class App
{
public static void ImprimeK19 ()
{
for ( int i = 0; i < 100; i ++)
{
System . Console . WriteLine ( " K19 " ) ;
}
}
150
www.k19.com.br
151
10
11
12
13
14
15
16
17
18
T HREADS
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
Execute o teste!
151
T HREADS
152
Sleep()
Durante a execuo de uma thread, se o mtodo Sleep() for chamado a thread ficar sem executar pelo menos durante a quantidade de tempo passada como parmetro para este mtodo.
1
2
Join()
Uma thread pode pedir para esperar o trmino de outra thread para continuar a execuo atravs do mtodo Join().
1
2
3
Exerccios de Fixao
4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
152
Altere a classe App do projeto Threads, adicionando uma chamada ao mtodo Sleep().
class App
{
public static void ImprimeK19 ()
{
for ( int i = 0; i < 100; i ++)
{
System . Console . WriteLine ( " K19 " ) ;
if ( i % 10 == 0)
{
Thread . Sleep (100) ;
}
}
}
public static void ImprimeK31 ()
{
for ( int i = 0; i < 100; i ++)
{
System . Console . WriteLine ( " K31 " ) ;
if ( i % 10 == 0)
{
Thread . Sleep (100) ;
}
}
}
public static void Main ()
{
Thread thread1 = new Thread ( ImprimeK19 ) ;
Thread thread2 = new Thread ( ImprimeK31 ) ;
thread1 . Start () ;
thread2 . Start () ;
www.k19.com.br
153
34
35
T HREADS
}
}
Cdigo C# 18.9: App.cs
www.k19.com.br
153
T HREADS
154
154
www.k19.com.br
APNDICE
R ESPOSTAS
class ImprimePadrao3
{
static void Main ()
{
string linha = " * " ;
for ( int contador = 1; contador <= 10; contador ++)
{
System . Console . WriteLine ( linha ) ;
linha += " * " ;
}
}
}
Cdigo C# 2.23: ImprimePadrao3.cs
class ImprimePadrao4
{
static void Main ()
{
string linha = " * " ;
for ( int contador = 1; contador <= 10; contador ++)
{
System . Console . WriteLine ( linha ) ;
int resto = contador % 4;
if ( resto == 0)
{
linha = " * " ;
}
else
www.k19.com.br
155
R ESPOSTAS
15
16
17
18
19
20
156
{
linha += " * " ;
}
}
}
}
Cdigo C# 2.24: ImprimePadrao4.cs
class ImprimePadrao5
{
static void Main ()
{
int penultimo = 0;
int ultimo = 1;
System . Console . WriteLine ( penultimo ) ;
System . Console . WriteLine ( ultimo ) ;
for ( int contador = 0; contador < 28; contador ++)
{
int proximo = penultimo + ultimo ;
System . Console . WriteLine ( proximo ) ;
penultimo = ultimo ;
ultimo = proximo ;
}
}
}
Cdigo C# 2.25: ImprimePadrao5.cs
156
www.k19.com.br
157
R ESPOSTAS
3
5
8...
using System ;
using System . IO ;
class GeradorDePadroes
{
static void Main ()
{
int opc = 1;
while ( opc != 0)
{
System . Console . WriteLine ( " Gerador de Padroes \ n \ n Digite a opcao desejada :\ n1 - Padrao " ) ;
System . Console . WriteLine ( " 2 - Padrao \ n3 - Padrao \ n4 - Padrao \ n5 - Padrao \ n0 - Sair " ) ;
TextReader textReader = Console . In ;
string valorTela = textReader . ReadLine () ;
opc = Convert . ToInt32 ( valorTela ) ;
if ( opc == 1)
{
for ( int contador = 1; contador <= 100; contador ++)
{
int resto = contador % 2;
if ( resto == 1)
{
System . Console . WriteLine ( " * " ) ;
}
else
{
System . Console . WriteLine ( " ** " ) ;
}
}
}
else if ( opc == 2)
{
for ( int contador = 1; contador <= 100; contador ++)
{
int resto = contador % 4;
if ( resto == 0)
{
System . Console . WriteLine ( " PI " ) ;
}
else
{
System . Console . WriteLine ( contador ) ;
}
}
}
else if ( opc == 3)
{
String linha = " * " ;
for ( int contador = 1; contador <= 10; contador ++)
{
www.k19.com.br
157
R ESPOSTAS
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
158
System . Console . WriteLine ( linha ) ;
linha += " * " ;
}
}
else if ( opc == 4)
{
String linha = " * " ;
for ( int contador = 1; contador <= 10; contador ++)
{
System . Console . WriteLine ( linha ) ;
int resto = contador % 4;
if ( resto == 0)
{
linha = " * " ;
}
else
{
linha += " * " ;
}
}
}
else if ( opc == 5)
{
int penultimo = 0;
int ultimo = 1;
System . Console . WriteLine ( penultimo ) ;
System . Console . WriteLine ( ultimo ) ;
for ( int contador = 0; contador < 28; contador ++)
{
int proximo = penultimo + ultimo ;
System . Console . WriteLine ( proximo ) ;
penultimo = ultimo ;
ultimo = proximo ;
}
}
}
}
}
Cdigo C# 2.27: GeradorDePadroes.cs
class Aluno
{
public String nome ;
public String rg ;
public String dataNascimento ;
}
Cdigo C# 3.20: Aluno.cs
TestaAluno.
158
www.k19.com.br
159
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
R ESPOSTAS
class TestaAluno
{
static void Main ()
{
Aluno a1 = new Aluno () ;
a1 . nome = " Marcelo Martins " ;
a1 . rg = " 33333333 -3 " ;
a1 . dataNascimento = " 02/04/1985 " ;
Aluno a2 = new Aluno () ;
a2 . nome = " Rafael Cosentino " ;
a2 . rg = " 222222222 -2 " ;
a2 . dataNascimento = " 30/10/1984 " ;
System . Console . WriteLine ( a1 . nome ) ;
System . Console . WriteLine ( a1 . rg ) ;
System . Console . WriteLine ( a1 . dataNascimento ) ;
System . Console . WriteLine ( a2 . nome ) ;
System . Console . WriteLine ( a2 . rg ) ;
System . Console . WriteLine ( a2 . dataNascimento ) ;
}
}
Cdigo C# 3.21: TestaAluno.cs
class Funcionario
{
public string nome ;
public string cargo ;
public double salario ;
}
Cdigo C# 3.22: Funcionario.cs
class TestaFuncionario
{
static void Main ()
{
Funcionario f1 = new Funcionario () ;
f1 . nome = " Marcelo Martins " ;
f1 . cargo = " Diretor " ;
f1 . salario = 1.800;
Funcionario f2 = new Funcionario () ;
f2 . nome = " Rafael Cosentino " ;
f2 . cargo = " Professor " ;
f2 . salario = 2.000;
System . Console . WriteLine ( f1 . nome ) ;
System . Console . WriteLine ( f1 . cargo ) ;
www.k19.com.br
159
R ESPOSTAS
17
18
19
20
21
22
23
160
System . Console . WriteLine ( f1 . salario ) ;
System . Console . WriteLine ( f2 . nome ) ;
System . Console . WriteLine ( f2 . cargo ) ;
System . Console . WriteLine ( f2 . salario ) ;
}
}
Cdigo C# 3.23: TestaFuncionario.cs
class Turma
{
public string periodo ;
public int serie ;
public string sigla ;
public string tipoDeEnsino ;
}
Cdigo C# 3.24: Turma.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class TestaTurma
{
static void Main ()
{
Turma t1 = new Turma () ;
t1 . periodo = " Tarde " ;
t1 . serie = 8;
t1 . sigla = " A " ;
t1 . tipoDeEnsino = " Fundamental " ;
Turma t2 = new Turma () ;
t2 . periodo = " Manha " ;
t2 . serie = 5;
t2 . sigla = " B " ;
t2 . tipoDeEnsino = " Fundamental " ;
System . Console . WriteLine ( t1 . periodo ) ;
System . Console . WriteLine ( t1 . serie ) ;
System . Console . WriteLine ( t1 . sigla ) ;
System . Console . WriteLine ( t1 . tipoDeEnsino ) ;
System . Console . WriteLine ( t2 . periodo ) ;
System . Console . WriteLine ( t2 . serie ) ;
System . Console . WriteLine ( t2 . sigla ) ;
System . Console . WriteLine ( t2 . tipoDeEnsino ) ;
}
}
Cdigo C# 3.25: TestaTurma.cs
www.k19.com.br
161
R ESPOSTAS
class Aluno
{
public String nome ;
public String rg ;
public String dataNascimento ;
// Adicione a linha abaixo
public Turma turma ;
}
Cdigo C# 3.33: Aluno.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class TestaAlunoTurma
{
static void Main ()
{
Aluno a = new Aluno () ;
Turma t = new Turma () ;
a . nome = " Rafael Cosentino " ;
t . periodo = " Tarde " ;
a . turma = t ;
System . Console . WriteLine ( a . nome ) ;
System . Console . WriteLine ( a . turma . periodo ) ;
}
}
Cdigo C# 3.34: TesteAlunoTurma
class Funcionario
{
public string nome ;
public double salario ;
public void AumentaSalario ( double valor )
{
this . salario += valor ;
}
public String ConsultaDados ()
{
return " Nome : " + this . nome + " \ nSalrio : " + this . salario ;
}
}
Cdigo C# 3.42: Funcionario.cs
www.k19.com.br
161
R ESPOSTAS
162
class TestaFuncionario
{
static void Main ()
{
Funcionario f1 = new Funcionario () ;
// Cadastrando Funcionrio
f1 . nome = " Rafael Cosentino " ;
f1 . salario = 1000;
// Aumentando em 100 reais o salrio do funcionrio
f1 . AumentaSalario (100) ;
// Imprimindo os dados do funcionrio
System . Console . WriteLine ( f1 . consultaDados () ) ;
}
}
Cdigo C# 3.43: TestaFuncionario
class Conta
{
public int numero ;
public double limite ;
public double saldo ;
}
Cdigo C# 3.78: Conta.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
162
using System ;
class TestaConta
{
static void Main ()
{
Conta c1 = new Conta () ; // Criando uma conta
System . Console . WriteLine ( " --------------- Criando Conta - - - - - - - - - - - - - - -\ n \ n " ) ;
System . Console . WriteLine ( " Digite o numero da conta : " ) ;
// Recebendo o valor digitado
String valorTela = System . Console . ReadLine () ;
// Convertendo para int
int numero = Convert . ToInt32 ( valorTela ) ;
// Armazenando o valor recebido da tela no atributo do objeto conta
www.k19.com.br
163
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
R ESPOSTAS
c1 . numero = numero ;
System . Console . WriteLine ( " Digite o limite da conta : " ) ;
valorTela = System . Console . ReadLine () ;
double limite = Convert . ToDouble ( valorTela ) ;
c1 . limite = limite ;
System . Console . WriteLine ( " Digite o saldo inicial da conta : " ) ;
valorTela = System . Console . ReadLine () ;
double saldo = Convert . ToDouble ( valorTela ) ;
c1 . saldo = saldo ;
int opc = 1;
while ( opc != 0)
{
System . Console . WriteLine ( " \ n \ n " ) ;
System . Console . WriteLine ( " Operaes bancrias " ) ;
System . Console . WriteLine ( " Escolha a opcao desejada : " ) ;
System . Console . WriteLine ( " 0 - Sair " ) ;
System . Console . WriteLine ( " 1 - Depositar " ) ;
System . Console . WriteLine ( " 2 - Sacar " ) ;
System . Console . WriteLine ( " 3 - Extrato " ) ;
System . Console . WriteLine ( " \ n \ n " ) ;
valorTela = System . Console . ReadLine () ;
opc = Convert . ToInt32 ( valorTela ) ;
if ( opc == 1)
{
System . Console . WriteLine ( " Digite o valor para depositar : " ) ;
valorTela = System . Console . ReadLine () ;
int deposito = Convert . ToInt32 ( valorTela ) ;
// Se o valor for menor que zero vai dar erro
if ( deposito <= 0)
{
System . Console . WriteLine ( " ERRO " ) ;
}
else
{
c1 . saldo += deposito ;
System . Console . WriteLine ( " Deposito efetuado com sucesso " ) ;
}
}
else if ( opc == 2)
{
System . Console . WriteLine ( " Digite o valor para saque : " ) ;
valorTela = System . Console . ReadLine () ;
int saque = Convert . ToInt32 ( valorTela ) ;
// Se o valor for maior do que o saldo mais o limite ou menor que zero vai dar erro
if ( saque > ( c1 . saldo + c1 . limite ) || ( saque <=0) )
{
System . Console . WriteLine ( " ERRO " ) ;
}
else
{
c1 . saldo -= saque ;
System . Console . WriteLine ( " Saque efetuado com sucesso " ) ;
}
}
else if ( opc == 3)
{
System . Console . WriteLine ( " Numero : " + c1 . numero ) ;
System . Console . WriteLine ( " Limite : " + c1 . limite ) ;
System . Console . WriteLine ( " Saldo : " + c1 . saldo ) ;
}
}
www.k19.com.br
163
R ESPOSTAS
89
90
164
}
}
Cdigo C# 3.79: TestaConta.cs
class Funcionario
{
public string nome ;
public double salario ;
public Funcionario ( double salario )
{
this . salario = salario ;
}
}
Cdigo C# 3.80: Funcionario.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
164
using System ;
class TestaFuncionario
{
static void Main ()
{
Funcionario f = new Funcionario (200) ;
System . Console . WriteLine ( " Digite o nome do funcionario : " ) ;
string nome = System . Console . ReadLine () ;
f . nome = nome ;
int opc = 1;
while ( opc != 0)
{
System . Console . WriteLine ( " \ n \ n " ) ;
System . Console . WriteLine ( " Escolha a opcao desejada : " ) ;
System . Console . WriteLine ( " 0 - Sair " ) ;
System . Console . WriteLine ( " 1 - Aumentar salrio " ) ;
System . Console . WriteLine ( " 2 - Corrigir nome do funcionrio " ) ;
System . Console . WriteLine ( " 3 - Imprimir dados " ) ;
System . Console . WriteLine ( " \ n \ n " ) ;
string valorTela = System . Console . ReadLine () ;
opc = Convert . ToInt32 ( valorTela ) ;
if ( opc == 1)
{
System . Console . WriteLine ( " Digite o quanto voc deseja aumentar : " ) ;
valorTela = System . Console . ReadLine () ;
int aumentar = Convert . ToInt32 ( valorTela ) ;
if ( aumentar < 0)
{
System . Console . WriteLine ( " ERRO " ) ;
}
www.k19.com.br
165
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
R ESPOSTAS
else
{
f . salario += aumentar ;
System . Console . WriteLine ( " Aumento efetuado com sucesso " ) ;
}
}
else if ( opc == 2)
{
System . Console . WriteLine ( " Nome atual : " + f . nome ) ;
System . Console . WriteLine ( " Digite o novo nome . " ) ;
valorTela = System . Console . ReadLine () ;
f . nome = valorTela ;
System . Console . WriteLine ( " Substituio feita com sucesso . " ) ;
}
else if ( opc == 3)
{
System . Console . WriteLine ( " Dados atuais " ) ;
System . Console . WriteLine ( " Nome : " + f . nome ) ;
System . Console . WriteLine ( " Salrio : " + f . salario ) ;
}
}
}
}
Cdigo C# 3.81: TetaFuncinario.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
class Media
{
static void Main ( string [] args )
{
double soma = 0;
foreach ( string arg in args )
{
double d = System . Convert . ToDouble ( arg ) ;
soma += d ;
}
System . Console . WriteLine ( soma / args . Length ) ;
}
}
Cdigo C# 4.17: Media.cs
1
2
3
4
5
6
7
8
9
10
class Maior {
static void Main ( string [] args )
{
double maior = System . Convert . ToDouble ( args [0]) ;
for ( int i = 1; i < args . Length ; i ++)
{
double d = System . Convert . ToDouble ( args [ i ]) ;
if ( maior < d )
{
maior = d ;
www.k19.com.br
165
R ESPOSTAS
11
12
13
14
15
166
}
}
System . Console . WriteLine ( maior ) ;
}
}
Cdigo C# 4.18: Maior.cs
class Funcionario
{
public string nome ;
public double salario ;
public static double valeRefeicaoDiario ;
}
Cdigo C# 6.14: Funcionario.cs
class TestaValeRefeicao
{
static void Main ()
{
System . Console . WriteLine ( Funcionario . valeRefeicaoDiario ) ;
Funcionario . valeRefeicaoDiario = 15;
System . Console . WriteLine ( Funcionario . valeRefeicaoDiario ) ;
}
}
Cdigo C# 6.15: Funcionario.cs
Selecione a classe TestaValeRefeicao como Startup Object. Depois compile (F6) e execute
(CTRL + F5).
Resposta do Complementar 6.3
Altere a classe Funcionario:
1
2
3
4
5
6
7
8
9
10
11
class Funcionario
{
public String nome ;
public double salario ;
public static double valeRefeicaoDiario ;
public static void ReajustaValeRefeicaoDiario ( double taxa )
{
Funcionario . valeRefeicaoDiario += Funcionario . valeRefeicaoDiario * taxa ;
}
}
Cdigo C# 6.16: Funcionario.cs
166
www.k19.com.br
167
R ESPOSTAS
class TestaValeRefeicao
{
static void Main ( String [] args )
{
System . Console . WriteLine ( Funcionario . valeRefeicaoDiario ) ;
Funcionario . valeRefeicaoDiario = 15;
System . Console . WriteLine ( Funcionario . valeRefeicaoDiario ) ;
Funcionario . ReajustaValeRefeicaoDiario (0.1) ;
System . Console . WriteLine ( Funcionario . valeRefeicaoDiario ) ;
}
}
Cdigo C# 6.17: Funcionario.cs
1
2
3
4
5
class Conta
{
public double Saldo { get ; set ; }
public double Limite { get ; set ; }
}
Cdigo C# 7.18: Conta.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
class TestaConta
{
static void Main ()
{
Conta c = new Conta () ;
c . Limite = 1000;
c . Saldo = 2000;
System . Console . WriteLine ( c . Limite ) ;
System . Console . WriteLine ( c . Saldo ) ;
}
}
Cdigo C# 7.19: TestaConta.cs
Selecione a classe TestaConta como Startup Object. Depois compile (F6) e execute (CTRL + F5).
Resposta do Complementar 8.1
www.k19.com.br
167
R ESPOSTAS
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
168
class Funcionario
{
public string Nome { get ; set ; }
public double Salario { get ; set ; }
public virtual double CalculaBonificacao ()
{
return this . Salario * 0.1;
}
public void MostraDados ()
{
System . Console . WriteLine ( " Nome : " + this . Nome ) ;
System . Console . WriteLine ( " Salrio : " + this . Salario ) ;
System . Console . WriteLine ( " Bonificao : " + this . CalculaBonificacao () ) ;
}
}
Cdigo C# 8.30: Funcionario.cs
Com a permisso feita atravs do modificador virtual, podemos reescrever segundo o exemplo
abaixo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5
6
168
www.k19.com.br
169
7
8
9
10
R ESPOSTAS
base . MostraDados () ;
System . Console . WriteLine ( " Estao de Trabalho " + this . EstacaoDeTrabalho ) ;
}
}
Cdigo C# 8.33: Telefonista.cs
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class TestaFuncionarios
{
static void Main ()
{
Gerente g = new Gerente () ;
g . Nome = " Rafael Cosentino " ;
g . Salario = 2000;
g . Usuario = " rafael . cosentino " ;
g . Senha = " 12345 " ;
Telefonista t = new Telefonista () ;
t . Nome = " Carolina Mello " ;
t . Salario = 1000;
t . EstacaoDeTrabalho = 13;
Secretaria s = new Secretaria () ;
s . Nome = " Tatiane Andrade " ;
s . Salario = 1500;
s . Ramal = 198;
System . Console . WriteLine ( " GERENTE " ) ;
g . MostraDados () ;
System . Console . WriteLine ( " TELEFONISTA " ) ;
t . MostraDados () ;
System . Console . WriteLine ( " SECRETARIA " ) ;
s . MostraDados () ;
}
}
Cdigo C# 8.35: TestaFuncionarios.cs
www.k19.com.br
169
R ESPOSTAS
1
2
3
4
170
class Funcionario
{
public int Codigo { get ; set ; }
}
Cdigo C# 9.13: Funcionario.cs
1
2
3
4
5
1
2
3
4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System ;
class ControleDePonto
{
public void RegistraEntrada ( Funcionario f )
{
DateTime agora = DateTime . Now ;
string horario = String . Format ( " {0: d / M / yyyy HH : mm : ss } " , agora ) ;
System . Console . WriteLine ( " ENTRADA : " + f . Codigo ) ;
System . Console . WriteLine ( " DATA : "
+ horario ) ;
}
public void RegistraSaida ( Funcionario f )
{
DateTime agora = DateTime . Now ;
string horario = String . Format ( " {0: d / M / yyyy HH : mm : ss } " , agora ) ;
System . Console . WriteLine ( " SADA : " + f . Codigo ) ;
System . Console . WriteLine ( " DATA : " + horario ) ;
}
}
Cdigo C# 9.16: ControleDePonto.cs
170
www.k19.com.br
171
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
R ESPOSTAS
class TestaControleDePonto
{
static void Main ()
{
Gerente g = new Gerente () ;
g . Codigo = 1;
g . Usuario = " rafael . cosentino " ;
g . Senha = " 12345 " ;
Telefonista t = new Telefonista () ;
t . Codigo = 2;
t . Ramal = 13;
ControleDePonto cdp = new ControleDePonto () ;
cdp . RegistraEntrada ( g ) ;
cdp . RegistraEntrada ( t ) ;
cdp . RegistraSaida ( g ) ;
cdp . RegistraSaida ( t ) ;
}
}
Cdigo C# 9.17: TestaControleDePonto.cs
1
2
3
4
class Funcionario
{
public double Salario { get ; set ; }
}
Cdigo C# 10.18: Funcionario.cs
1
2
3
4
5
6
7
8
9
10
11
class TestaFuncionario
{
static void Main ()
{
Funcionario f = new Funcionario () ;
f . Salario = 3000;
System . Console . WriteLine ( f . Salario ) ;
}
}
Cdigo C# 10.19: TestaFuncionario.cs
www.k19.com.br
171
R ESPOSTAS
1
2
3
4
172
1
2
3
4
5
1
2
3
4
5
6
7
8
9
10
11
class TestaFuncionario
{
static void Main ()
{
Funcionario f = new Gerente () ;
f . Salario = 3000;
System . Console . WriteLine ( f . Salario ) ;
}
}
Cdigo C# 10.22: TestaFuncionario.cs
1
2
3
4
5
6
www.k19.com.br
173
R ESPOSTAS
No compila.
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10
11
12
13
class TestaFuncionario
{
static void Main ()
{
Funcionario f = new Gerente () ;
f . Salario = 3000;
System . Console . WriteLine ( f . Salario ) ;
System . Console . WriteLine ( f . CalculaBonificacao () ) ;
}
}
Cdigo C# 10.25: TestaFuncionario.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
using System . IO ;
public class ArquivoParaArquivo
{
static void Main ()
{
TextReader arquivo1 = new StreamReader ( " entrada . txt " ) ;
TextWriter arquivo2 = new StreamWriter ( " saida . txt " ) ;
string linha = arquivo1 . ReadLine () ;
while ( linha != null )
{
arquivo2 . WriteLine ( linha ) ;
linha = arquivo1 . ReadLine () ;
}
www.k19.com.br
173
R ESPOSTAS
16
17
18
19
174
arquivo1 . Close () ;
arquivo2 . Close () ;
}
}
Cdigo C# 16.8: ArquivoParaArquivo.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
using System . IO ;
using System ;
public class TecladoParaArquivo
{
static void Main ()
{
TextReader teclado = Console . In ;
TextWriter arquivo = new StreamWriter ( " saida . txt " ) ;
string linha = teclado . ReadLine () ;
while ( linha != null )
{
arquivo . WriteLine ( linha ) ;
linha = teclado . ReadLine () ;
}
arquivo . Close () ;
}
}
Cdigo C# 16.9: TecladoParaArquivo.cs
174
www.k19.com.br