Web Aulas e av1 e 2 programação orientada a objetos

Prévia do material em texto

1) Em uma aplicação Console na ferramenta visual studio utilizando a linguagem de 
programação C#, qual o comando correto para congelar a tela no momento da 
execução do programa? 
ReadKey() 
 
2) Assinale a alternativa correta de acordo com o texto abaixo: 
Uma característica forte das interfaces é a possibilidade de prover o mecanismo da 
orientação a objetos chamado _______ . 
O texto acima está falando de: 
d) Polimorfismo 
 
3) Assinale a alternativa correta de acordo com o texto abaixo: 
A particularidade das__________ é que as classes que as herdam, acabam sendo 
modeladas por elas, isto é, as __________ nada mais são do que modelos para a 
construção de classes, que herdam suas características. 
O texto acima está falando de: 
c) Interfaces 
 
4 ) Em C#, analise o método a seguir: 
 
d) criação de uma variável que atribua o retorno do método FormatarCpf() e 
atribuição de um valor para o atributo _Cpf 
 
5) Analise as afirmativas abaixo. 
I. As classes são abstrações de um conjunto de objetos que tem características 
similares, sendo assim, as classes definem os estados e comportamentos de um 
objeto; 
II. São considerados membros de uma casse: Construtores, Destrutores, 
Propriedades e Eventos; 
III. A classe é constituída por métodos e atributos. 
Agora assinale a alternativa correta 
 
a) As afirmativas I, II e III estão corretas 
 
 
av2 
 
1) De acordo com os conhecimentos sobre Programação Orientada a Objetos, 
assinale a alternativa correta: 
 
c) Diagrama de transição de estados é uma representação do estado ou situação em 
que um objeto pode se encontrar no decorrer da execução do sistema 
 
2) Analise o texto abaixo e marque a alternativa correta. 
Tanto a _______ quanto a _______ são mecanismos que permitem a reutilização de 
códigos, contudo, durante anos, principalmente no início da explosão da orientação 
a objetos, os programadores consideravam a _______ como sendo a ferramenta 
básica da extensão e reutilização de funcionalidades 
 
e) Herança e composição 
 
3) As associações representam o equivalente mais próximo dos relacionamentos 
utilizados no modelo Entidade-Relacionamento, ou seja, seu objetivo é definir a 
maneira como as classes estão unidas e se relacionam entre si, compartilhando 
informações – (Guedes, 2006, p. 72) 
Considerando o relacionamento de agregação, analise as alternativas abaixo e 
assinale a correta. 
 
d) Agregação é um agregado de membros em que o objeto parte faz sentido mesmo 
sem o objeto todo 
 
4) Sobre parâmetros de entrada em métodos, podemos afirmar que: 
Assinale a alternativa correta. 
 
d) São valores que serão obrigatórios na chamada do método 
 
5) Assinale a alternativa correta de acordo com o texto abaixo: 
A _______ não necessita de uma programação complexa, pois em outras palavras, 
não há diferença entre _______ e um simples relacionamento "uses" em UML. 
O texto acima está falando de: 
 
e) Agregação 
 
 
ANÁLISE E DESENVOLVIMENTO DE SISTEMAS 
WEBAULA 1 
Unidade 1 – Criando minha primeira classe 
 
Apresentação 
Caros alunos, 
Sou o professor Marcio Roberto Chiaveli. 
Estaremos trabalhando juntos na Disciplina de Desenvolvimento 
Orientado a Objetos I. Vamos aplicar, na prática, o que conhecemos 
na teoria desta disciplina, um conceito amplamente discutido e 
estudado no meio tecnológico de desenvolvimento de softwares. 
Afinal, um software bem projetado garante a integridade das 
informações, que são geradas na sua execução. 
Aqui na unidade I, vamos tratar dos procedimentos iniciais de como 
projetar e implementar uma classe em c#. Também vamos aprender 
como instanciar um objeto desta classe e consumi-lo. 
O estudo da programação orientada a objeto em C# passa 
obrigatoriamente pela criação de sua primeira classe. Nesta web aula, 
vamos fazer passo-a-passo como criar uma classe. 
Para desenvolvermos todos os nossos exercícios, vamos criar 
aplicativos do tipo CONSOLE APPLICATION. 
Vamos lá! 
Vamos abrir o C# e criarmos um novo projeto, selecionando, no menu 
do sistema, a opção File -> New Project... O C# mostrará a sua 
biblioteca de templates de projetos. Selecione a template Console 
Application, e, na parte inferior da tela de templates, digite um nome 
para o nosso projeto. Então, no campo Name, coloque o nome do 
projeto de Web Aula1. 
Se tudo deu certo, estará aparecendo na sua tela o seguinte trecho de 
código: 
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
namespace ConsoleApplication1 
{ 
 class Program 
 { 
 static void Main(string[] args) 
 { 
 } 
 } 
} 
 
Muito bem, para testarmos se o nosso projeto foi criado corretamente, 
vamos fazer um teste: 
 
Escreva o seguinte código que está em negrito logo após a linha static 
void Main(string[] args). Ficando, então, da seguinte forma: 
static void Main(string[] args) 
{ 
 Console.WriteLine("Ola Mundo"); 
 Console.Write("Pressione uma tecla para continuar"); 
 Console.ReadKey(); 
} 
Agora, pressione a tecla F5 para executar a aplicação. Será mostrada 
a seguinte tela: 
 
Figura 1 
Ok!!! 
Bom, isso foi só para aquecer. Vamos agora criar a nossa classe. 
 
Conforme a figura abaixo, na janela Solution Explorer, clique com o 
botão direito sobre o nome do projeto que criamos, WebAula1, depois 
selecione Add Class... 
 
Figura 2 
Novamente, o C# mostrará a janela que disponibiliza as templates do 
projeto. Como você pode ver, a template Class já está selecionada. 
Então, vamos dar um nome para a nossa classe, substituindo o nome 
default (Class1.cs) que o C# sugere, digitando o nome Pessoa no 
campo Name na parte inferior da tela das templates, e clicando no 
botão Add. 
Temos agora em nosso projeto uma arquivo chamado Pessoa.cs, como 
está sendo mostrado na janela do Solution Explorer. 
A primeira coisa que vamos fazer é renomear a nossa classe 
como _Pessoa. Isso mesmo, coloque um tarcinho (underline) no 
começo do nome. Isso será um padrão que vamos assumir em todas a 
classes que criarmos. Vocês vão entender mais à frente a razão disto. 
Agora vamos criar os atributos private da nossa classe. Entre as 
chaves do corpo da nossa classe vamos começar a codificá-los. 
namespace WebAula1 
{ 
 class _Pessoa 
 { 
 private DateTime _DataCadastro; 
 private int _Codigo; 
 private string _Nome; 
 private string _Cpf; 
 private string _Endereco; 
 private string _Cidade; 
 private string _Uf; 
 private string _Cep; 
 } 
} 
 
Veja, criamos somente atributos private. Isso quer dizer que estes 
atributos não estarão disponíveis fora desta classe. Para que possamos 
usar esta classe e gravar valores nos atributos, precisamos publicá-los, 
ou seja, criarmos propriedades públicas que permitam o acesso a estes 
atributos. Vamos fazer isto agora. 
public DateTime DataCadastro 
 { 
 get { return _DataCadastro; } 
 set { _DataCadastro = value; } 
 } 
 public int Codigo 
 { 
 get { return _Codigo; } 
 set { _Codigo = value; } 
 } 
 public string Nome 
 { 
 get { return _Nome; } 
 set { _Nome = value; } 
 } 
 public string Cpf 
 { 
 get { return _Cpf; } 
 set { _Cpf = value; } 
 } 
 public string Endereco 
 { 
 get { return _Endereco; } 
 set { _Endereco = value; } 
 } 
 public string Cidade 
 {get { return _Cidade; } 
 set { _Cidade = value; } 
 } 
 public string Uf 
 { 
 get { return _Uf; } 
 set { _Uf = value; } 
 } 
 public string Cep 
 { 
 get { return _Cep; } 
 set { _Cep = value; } 
 } 
Com isto, já podemos ver como isso pode ser feito em classe: 
Selecione o arquivo Programa.cs, dando um duplo click no seu nome, no Solution 
Explorer, ou selecione na aba dos arquivos: 
 
Figura 3 
Apague as três linhas que fizemos no começo da aula e escreva o 
seguinte código para instanciar nossa classe: 
namespace WebAula1 
{ 
 class Program 
 { 
 static void Main(string[] args) 
 { 
 _Pessoa Pessoa = new _Pessoa(); 
 } 
 } 
} 
A linha em negrito está criando um objeto do tipo _Pessoa. Veja agora 
porque usamos um (_) underline no nome da classe: justamente para 
que, quando formos criar um a instância para um objeto, possamos 
usar o nome sem o (_) underline. Entenderam? 
Bom, vamos seguir com o nosso código. Depois de criar o objeto, 
vamos usá-lo. Para isso, vamos escrever um código que pergunte na 
tela os dados para preencher os campos da nossa classe. Veja como 
ficaria: 
namespace WebAula1 
{ 
 class Program 
 { 
 static void Main(string[] args) 
 { 
 _Pessoa Pessoa = new _Pessoa(); 
 Console.Write("Digite o código.....:"); 
 // Veja que nesta linha precisamos fazer a conversão 
 // do valor digtado pelo usuário pois toda entrada via console 
 // é do tipo texto e o nosso código e int, por isso devemos 
 // fazer a conversão utilizando o metodo ToInt32 da classe 
 // Convert. 
 Pessoa.Codigo = Convert.ToInt32(Console.ReadLine()); 
 Console.Write("Digite o nome.......:"); 
 Pessoa.Nome = Console.ReadLine(); 
 Console.Write("Digite o cpf........:"); 
 Pessoa.Cpf = Console.ReadLine(); 
 Console.Write("Digite o endereço...:"); 
 Pessoa.Endereco = Console.ReadLine(); 
 Console.Write("Digite a cidade.....:"); 
 Pessoa.Cidade = Console.ReadLine(); 
 Console.Write("Digite o estado.....:"); 
 Pessoa.Uf = Console.ReadLine(); 
 Console.Write("Digite o cep........:"); 
 Pessoa.Cep = Console.ReadLine(); 
 Console.WriteLine("=========================
================"); 
 Console.WriteLine(" Mostrando o conteúdo da classe 
Pessoa"); 
 Console.WriteLine("=========================
================"); 
 Console.WriteLine("Codigo.......: {0}", Pessoa.Codigo); 
 Console.WriteLine("Nome.........: {0}", Pessoa.Nome); 
 Console.WriteLine("Cpf..........: {0}", Pessoa.Cpf); 
 Console.WriteLine("Edereço......: {0}", Pessoa.Endereco); 
 Console.WriteLine("Cidade.......: {0}", Pessoa.Cidade); 
 Console.WriteLine("Estado.......: {0}", Pessoa.Uf); 
 Console.WriteLine("Cep..........: {0}", Pessoa.Cep); 
 Console.ReadKey(); 
 
 } 
 } 
} 
Por hoje é só! 
Clique aqui para baixar todo o projeto. 
WEBAULA 2 
Unidade 1 – Herança 
 
Bom, já estamos familiarizados com o C#, não é mesmo? 
Então, vamos direto ao assunto. 
Vamos abrir o C# e criarmos um novo projeto, selecionando no menu 
do sistema a opção File -> New Project... Selecione 
a template Console Application e, na parte inferior da tela 
de templates, digite o nome WebAula2 para nosso projeto. 
Conforme a figura abaixo, na janela Solution Explorer, clique com o 
botão direito sobre o nome do projeto que criamos, WebAula2. Depois, 
selecione Add Class... para adicionarmos um arquivo que conterá a 
classe pai. 
 
Figura 1 
Agora, dê o nome de Pessoa para o arquivo .cs. 
No arquivo Pessoa.cs, renomeie a classe Pessoa 
para _Pessoa (Lembrem do underline ( _ ) ). 
 
Agora, vamos criar os atributos private da classe, como segue: 
 private int _Codigo; 
 private string _Nome; 
 private string _Cpf; 
 private string _Fone; 
Na sequência, vamos publicar seus atributos: 
 public int Codigo 
 { 
 get { return _Codigo; } 
 set { _Codigo = value; } 
 } 
 public string Nome 
 { 
 get { return _Nome; } 
 set { _Nome = value; } 
 } 
 public string Cpf 
 { 
 get { return _Cpf; } 
 set { _Cpf = value; } 
 } 
 public string Fone 
 { 
 get { return _Fone; } 
 set { _Fone = value; } 
 } 
 
Agora, vamos criar alguns métodos para validar e formatar os valores 
dos atributos. 
Vamos criar um método para que, quando for solicitado o Cpf da 
pessoa, a classe devolva o valor formatado. 
O método é bem simples. Acompanhe: 
private string FormatarCpf() 
{ 
 return _Cpf.Substring(1, 3) + "." + 
 _Cpf.Substring(4, 3) + "." + 
 _Cpf.Substring(7, 3) + "-" + 
 _Cpf.Substring(10, 2); 
} 
O método SubString, da classe string, do qual o atributo _Cpf herda o 
tipo, extrai do atributo _Cpf. A partir de uma determinada posição, 
ele pega um valor n de caracteres estipulado. Desta forma, nós 
montamos o Cpf formatado com a máscara padrão. 
Em seguida, vamos atribuir o método FormatCpf à chamada do método 
get da propriedade Cpf. 
Obs: Quando eu falo de propriedade, estou falando daquela que nós 
publicamos com o comando Public (Ex: Cpf: sem o underline ), e 
quando falo de atributo, falo daqueles que definimos como Private (Ex 
_Cpf: com underline) 
Veja como ficaria: 
 public string Cpf 
 { 
 get { return FormatarCpf(); } 
 set { _Cpf = value; } 
 } 
 
Vamos fazer a mesma coisa para o atributo Fone, cujo método ficaria 
desta forma 
private string FormatarFone() 
{ 
return _Fone.Substring(1, 4) + "-" + 
 _Fone.Substring(5, 4); 
} 
Novamente, substitua a chamada do método: 
 public string Fone 
 { 
 get { return FormatarFone(); } 
 set { _Fone = value; } 
 } 
 
Agora, vamos fazer um programa para consumir esta classe. 
Selecione o arquivo Program.cs e vamos criar um método para 
executar a classe _Pessoa da seguinte forma: 
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
namespace WebAula2 
{ 
 class Program 
 { 
 static void Main(string[] args) 
 { 
 ExecutarPessoa() 
 } 
 public static void ExecutarPessoa() 
 { 
 _Pessoa Pessoa = new _Pessoa(); 
 Console.Write("Informe o código.: "); 
 Pessoa.Codigo = Convert.ToInt32(Console.ReadLine()); 
 Console.Write("Informe o nome...: "); 
 Pessoa.Nome = Console.ReadLine(); 
 Console.Write("Informe o cpf....: "); 
 Pessoa.Cpf = Console.ReadLine(); 
 Console.Write("Informe o fone...: "); 
 Pessoa.Fone = Console.ReadLine(); 
 Console.WriteLine("=========================
==============="); 
 Console.WriteLine(" Mostrando os dados da classe 
Pessoa"); 
 Console.WriteLine("=========================
==============="); 
 Console.WriteLine("Código.....: {0}", Pessoa.Codigo); 
 Console.WriteLine("Nome.......: {0}", Pessoa.Nome); 
 Console.WriteLine("Cpf........: {0}", Pessoa.Cpf);Console.WriteLine("Telefone...: {0}", Pessoa.Fone); 
 Console.ReadKey(); 
 } 
 } 
} 
Execute o código e verá o efeito do método de formatação. 
Bom, por enquanto, nenhuma novidade, visto que isto já aprendemos 
na aula anterior. 
Agora, vamos fazer um programa para consumir esta classe. 
Selecione o arquivo Program.cs e vamos criar um método para 
executar a classe _Pessoa da seguinte forma: 
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
namespace WebAula2 
{ 
 class Program 
 { 
 static void Main(string[] args) 
 { 
 ExecutarPessoa() 
 } 
 public static void ExecutarPessoa() 
 { 
 _Pessoa Pessoa = new _Pessoa(); 
 Console.Write("Informe o código.: "); 
 Pessoa.Codigo = Convert.ToInt32(Console.ReadLine()); 
 Console.Write("Informe o nome...: "); 
 Pessoa.Nome = Console.ReadLine(); 
 Console.Write("Informe o cpf....: "); 
 Pessoa.Cpf = Console.ReadLine(); 
 Console.Write("Informe o fone...: "); 
 Pessoa.Fone = Console.ReadLine(); 
 Console.WriteLine("=========================
==============="); 
 Console.WriteLine(" Mostrando os dados da classe 
Pessoa"); 
 Console.WriteLine("=========================
==============="); 
 Console.WriteLine("Código.....: {0}", Pessoa.Codigo); 
 Console.WriteLine("Nome.......: {0}", Pessoa.Nome); 
 Console.WriteLine("Cpf........: {0}", Pessoa.Cpf); 
 Console.WriteLine("Telefone...: {0}", Pessoa.Fone); 
 Console.ReadKey(); 
 } 
 } 
} 
Execute o código e verá o efeito do método de formatação. 
Bom, por enquanto, nenhuma novidade, visto que isto já aprendemos 
na aula anterior. 
 
Vamos codificar a classe, como segue abaixo: 
namespace WebAula2 
{ 
 class _Aluno: _Pessoa 
 { 
 public _Aluno(int pCodigo, string pNome, int pMatricula) 
 { 
 Codigo = pCodigo; 
 Nome = pNome; 
 Matricula = pMatricula; 
 } 
 public _Aluno(int pCodigo) 
 { 
 Codigo = pCodigo; 
 } 
 public _Aluno() 
 { 
 } 
 private int _Matricula; 
 private string _Curso; 
 private string _Turno; 
 private string _Turma; 
 public int Matricula 
 { 
 get { return _Matricula; } 
 set { _Matricula = value; } 
 } 
 public string Curso 
 { 
 get { return _Curso; } 
 set { _Curso = value; } 
 } 
 public string Turno 
 { 
 get { return _Turno; } 
 set { _Turno = value; } 
 } 
 public string Turma 
 { 
 get { return _Turma; } 
 set { _Turma = value; } 
 } 
 } 
} 
Ok. Agora vamos construir o programa para consumir a nossa classe 
_Alunos. 
Selecione o arquivo Program.cs e comente a linha que está chamando 
o método ExecutarPesso() e vamos criar um outro método para 
consumir a nossa classe _Alunos, da seguinte forma: 
No final do método ExecutarPessoa(), insira este código: 
 public static void ExecutarAluno() 
 { 
 _Aluno Aluno = new _Aluno(); 
 // Note que estes atributos não estão definidos na classe 
 // _Aluno no entanto estão disponiveis porque esta 
 // é uma característica da herança 
 Console.Write("Informe o código.: "); 
 Aluno.Codigo = Convert.ToInt32(Console.ReadLine()); 
 Console.Write("Informe o nome...: "); 
 Aluno.Nome = Console.ReadLine(); 
 Console.Write("Informe o cpf....: "); 
 Aluno.Cpf = Console.ReadLine(); 
 Console.Write("Informe o fone...: "); 
 Aluno.Fone = Console.ReadLine(); 
 // Ja daqui para baixo são os atribtos da classe _Alunos 
 Console.Write("Informe a matricula.: "); 
 Aluno.Matricula = Convert.ToInt32(Console.ReadLine()); 
 Console.Write("Informe o curso...: "); 
 Aluno.Curso = Console.ReadLine(); 
 Console.Write("Informe o turno....: "); 
 Aluno.Turno = Console.ReadLine(); 
 Console.Write("Informe a turma...: "); 
 Aluno.Turma = Console.ReadLine(); 
 Console.WriteLine("=========================
=============="); 
 Console.WriteLine(" Mostrando os dados da classe Aluno"); 
 Console.WriteLine("=========================
=============="); 
 Console.WriteLine("Código.....: {0}", Aluno.Codigo); 
 Console.WriteLine("Nome.......: {0}", Aluno.Nome); 
 Console.WriteLine("Cpf........: {0}", Aluno.Cpf); 
 Console.WriteLine("Telefone...: {0}", Aluno.Fone); 
 Console.WriteLine("Matrícula..: {0}", Aluno.Matricula); 
 Console.WriteLine("Curso......: {0}", Aluno.Curso); 
 Console.WriteLine("Turno......: {0}", Aluno.Turno); 
 Console.WriteLine("Turma......: {0}", Aluno.Turma); 
 
 Console.ReadKey(); 
 } 
Clique aqui para baixar o projeto inteiro. 
Resumo: Vimos como criar uma classe através da herança e como 
utilizá-la em programas. 
Até a próxima! 
 
Hoje, vamos desenvolver uma classe, usando os conceitos de herança 
e polimorfismo 
Vamos por a mão na massa! 
Vamos abrir o C# e criarmos um novo projeto, selecionando no menu 
do sistema a opção File -> New Project... Selecione 
a template Console Application e, na parte inferior da tela 
de templates, digite o nome WebAula1 para nome do nosso projeto. 
Salve o projeto, clicando no botão salvar 
 
Figura 1 
Conforme a figura abaixo, na janela Solution Explorer, clique com o 
botão direito sobre o nome do projeto que criamos, WebAula1, e 
depois selecione Add Class... para adicionarmos um arquivo que 
conterá a classe pai. 
 
Figura 2 
Agora, dê o nome de Funcionario para o arquivo .cs. 
No arquivo Funcionario.cs, renomeie a classe Funcionario 
para _Funcionario 
Agora, vamos codificar a nossa classe, conforme o código abaixo: 
 class _Funcionario 
 { 
 // Esta constante será usada para calcular o 
 // salario liquido do funcionário 
 // e corresponde a 8% 
 private const double INSS = 0.08; 
 private int _Codigo; 
 private string _Nome; 
 private string _Cpf; 
 private double _Salario; 
 public _Funcionario() 
 { 
 } 
 public int Codigo 
 { 
 get { return _Codigo; } 
 set { _Codigo = value; } 
 } 
 public string Nome 
 { 
 get { return _Nome; } 
 set { _Nome = value; } 
 } 
 public string Cpf 
 { 
 get { return _Cpf; } 
 set { _Cpf = value; } 
 } 
 public double Salario 
 { 
 get { return _Salario; } 
 set { _Salario = value; } 
 } 
 } 
 
Agora, vamos criar o método para calcular o salário do funcionário. 
O método é bem simples. Acompanhe: 
 public Double CalcularSalario() 
 { 
 return (_Salario - (_Salario * INSS)); 
 } 
O método está simplesmente subtraindo o valor de 8% (que é o valor 
da constante) do salário do funcionário e retornando o resultado. 
Vamos testar a classe. 
 
Selecione o arquivo Program.cs e vamos codificar o teste daseguinte 
forma: 
Crie um método chamado TelaFuncionario, logo abaixo do 
método Main, conforme o código abaixo: 
 class Program 
 { 
 static void Main(string[] args) 
 { 
 TelaFuncionario(); 
 } 
 private static void TelaFuncionario() 
 { 
 double Salario; 
 _Funcionario Funcionario = new _Funcionario(); 
 
 // Lembre que a console só le valores como textos 
 // por isso estamos usanto o convert para inteiro 
 Console.Write("Código.....:"); 
 Funcionario.Codigo = Convert.ToInt32(Console.ReadLine()); 
 Console.Write("Nome.......:"); 
 Funcionario.Nome = Console.ReadLine(); 
 Console.Write("Cpf........:"); 
 Funcionario.Cpf = Console.ReadLine(); 
 // E aqui estamos convertendo o valor lido 
 // pela console para Double 
 Console.Write("Salario....:"); 
 Funcionario.Salario = 
Convert.ToDouble(Console.ReadLine()); 
 Console.Write(""); 
 // Veja, aqui estamos invocando o método 
 // para calcular o salario do funcionario 
 Salario = Funcionario.CalculaSalario(); 
 // Escreva tudo na mesma linha 
 Console.Write("O salario liquido do funcionario {0} é de : 
 {1:c}",Funcionario.Nome,Salario); 
 Console.ReadKey(); 
 } 
 } 
Feito isso, pressione a tecla F5 para executar o projeto e ver o 
resultado. 
Muito bem. Agora, vamos criar um método para salvar o conteúdo da 
classe para um arquivo no sistema operacional. Para isso, vamos usar 
uma classe chamada StreamWriter. Veja a codificação a seguir: 
public void Salvar() 
 { 
 StreamWriter Funcionario = new 
StreamWriter(@"C:\Funcionario.Txt",true); 
 Funcionario.WriteLine("Código = " + _Codigo); 
 Funcionario.WriteLine("Nome = " + _Nome); 
 Funcionario.WriteLine("Cpf = " + _Cpf); 
 Funcionario.WriteLine("Salario = " + CalculaSalario()); 
 Funcionario.WriteLine("==========================
========="); 
 Funcionario.Flush(); 
 Funcionario.Close(); 
 } 
Veja que o construtor da classe StreamWriter recebe o nome do 
arquivo como parâmetro. O segundo parâmetro é booleano, e, se for 
(true), diz a classe que, se ao arquivo já existir, ele o abre para serem 
adicionados mais dados; e, se for (false), ele sempre criará um novo, 
sobrepondo o antigo. 
Método da classe StreamWriter 
 WriteLine => escreve no arquivo 
 Flush=> grava o arquivo 
 Close=> fecha o aquivo 
Agora vamos criar a classe vendedor herdando da classe funcionário. 
1. Adicione uma nova classe cujo nome do arquivo será Vendedor.cs. 
2. Renomeie a classe Vendedor para _Vendedor. 
3. Criar os seguintes Atributos privados: 
a. _Comissao (Double) 
b. _RegiaoAtuacao (string) 
c. _TipoInternoExterno (string) 
4. Publique estes atributos 
Na classe funcionário, temos dois métodos para tratamento de pessoa: 
um é o método Salvar, sendo que este método simplesmente grava 
num arquivo os dados da classe pessoa e o outro método calcula o 
salário da pessoa. Bom, só que agora nós estamos criando uma classe 
vendedor, fazendo herança da classe funcionário. Sendo assim, estes 
métodos são herdados também. Mas se nós invocarmos o método 
Salvar, por exemplo, ele gravará somente os dados de funcionário no 
arquivo Funcionário.Txt. Então, precisamos sobrescrever estes 
métodos, usando o conceito de Polimorfismo para que eles tratem 
dos dados de vendedor e não mais de funcionário. Vamos ver como 
fazer isso. 
Na nossa classe de vendedor, vamos criar o método para calcular o 
salário do vendedor. Veja: na classe funcionário eu já tenho este 
método, mas ele somente calcula o salário do funcionário. Agora, 
precisamos calcular o salário do vendedor. Usando o conceito de 
polimorfismo, vamos sobrepor o método de calcular salário da classe 
funcionário para mudarmos o cálculo, incluindo os cálculos que 
precisamos para obter o salário do vendedor. Vamos ver como fica o 
novo método. 
Para sobrepor um método, primeiro precisamos dizer na classe pai que 
o método em questão pode ser sobreposto usando a palavra 
chave virtual. Então, no método CalcularSalario da classe funcionário, 
vamos alterar o nosso método, incluindo a palavra-
chave virtual depois do public, na declaração do método: 
 
 public virtual Double CalcularSalario() 
 { 
 return _Salario - (_Salario * (INSS/100)); 
 } 
Isso faz com que o método CalcularSalario possa ser sobreposto nas 
classes filhas. 
 Muito bem, agora vamos sobrepor o método na nossa classe 
Vendedor, da seguinte forma: 
 public override double CalcularSalario() 
 { 
 double salario; 
 salario = base.CalcularSalario(); 
 salario = salario + (salario * (_Comissao / 100)); 
 return salario; 
 
 } 
Veja: na declaração do método, na classe filha, precisamos dizer que 
o método está sendo sobreposto, ou seja, é como se eu estivesse 
dizendo "Olha, o método CalcularSalario é assim agora" . Observe: 
dentro do novo método, eu chamei o método da classe pai usando a 
instrução base. Este comando diz que o CalcularSalario da classe pai 
é que deve ser executado. Com isso, ele executa o método da classe 
pai, fazendo os cálculos necessários, e armazena o valor na variável 
salário. Na sequência, eu insiro os cálculos necessários para se obter o 
salário do vendedor, retornando, assim, o salário mais a comissão. 
Vamos agora criar um método no arquivo Program.cs para testarmos 
a nossa classe vendedor. 
Crie o novo método com o nome TelaVendedor, da mesma forma 
como criamos o método TelaFuncionario, só que desta vez, usando a 
classe Vendedor conforme o código abaixo. 
 private static void TelaVendedor() 
 { 
 double Salario; 
 _Vendedor Vendedor = new _Vendedor(); 
 // Lembre que a console só le valores como textos 
 // por isso estamos usanto o convert para inteiro 
 Console.Write("Código.....:"); 
 Vendedor.Codigo = Convert.ToInt32(Console.ReadLine()); 
 Console.Write("Nome.......:"); 
 Vendedor.Nome = Console.ReadLine(); 
 Console.Write("Cpf........:"); 
 Vendedor.Cpf = Console.ReadLine(); 
 Console.Write("Região.....:"); 
 Vendedor.RegiaoAtuacao = Console.ReadLine(); 
 Console.Write("Tipo.......:"); 
 Vendedor.TipoInternoExterno = Console.ReadLine(); 
 Console.Write("Comissão...:"); 
 Vendedor.Comissao = 
Convert.ToDouble(Console.ReadLine()); 
 // E aqui estamos convertendo o valor lido 
 // pela console para Double 
 Console.Write("Salario....:"); 
 Vendedor.Salario = Convert.ToDouble(Console.ReadLine()); 
 Console.Write(""); 
 // Veja, aqui estamos invocando o método 
 // para calcular o salario do venddor 
 Salario = Vendedor.CalcularSalario(); 
 Console.Write("O salario liquido do vendedor {0} é de : 
{1:c}", Vendedor.Nome, Salario); 
 Console.ReadKey(); 
 } 
Bom, como exercício vou deixar vocês implementarem o 
método Salvar, usando o conceito de polimorfismo. 
Baixe o código completo aqui. 
 
WEBAULA 4 
Unidade 1 – Classes Abstratas, Interfaces e sealed 
 
Classe abstrata 
A classe abstrata é um tipo de classe que somente pode ser herdada e 
não instanciada. De certa forma, pode-se dizer que este tipo de classeé uma classe conceitual que pode definir funcionalidades para que as 
suas subclasses possam implementá-las. 
O conjunto de métodos na classe abstrata é obrigatoriedade, assim 
como a implementação nas suas subclasses. Em uma classe abstrata, 
os métodos declarados podem ser abstratos ou não, e suas 
implementações devem ser obrigatórias na subclasse. Quando criamos 
um método abstrato em uma classe abstrata, sua implementação é 
obrigatória. Caso você não implemente o mesmo, o compilador criará 
um erro em tempo de compilação. 
Exemplo de implementação retirado do books online em C#. 
abstract class formaClasse 
{ 
 abstract public int Area(); 
} 
class quadrado : formaClasse 
{ 
 int x, y; 
 // Se não for implementado o método Area() 
 // será gerado um compile-time error. 
 public override int Area() 
 { 
 return x * y; 
 } 
} 
 
 
Interface 
As interfaces são fundamentais em um sistema orientado a objetos. 
Quando dizemos que um objeto é a instância de uma classe, na 
verdade queremos dizer que este objeto implementa a interface 
definida pela classe, ou seja, uma interface define as operações que 
um objeto será obrigado a implementar. Para cada operação declarada 
por um objeto, deve ser especificado o nome da operação, os objetos 
que ela aceita como parâmetro e o tipo de valor retornado pela mesma; 
este conjunto de informações sobre uma determinada operação tem o 
nome de assinatura da operação, e a um conjunto de assinaturas de 
operações dá-se o nome de interface. 
É importante lembrar que uma interface nunca contém implementação, 
ou seja, numa interface não se pode definir campos, pois os mesmos 
são uma implementação de um atributo objeto. A interface também 
não permite construtores, pois num construtor temos as instruções 
usadas para inicializar campos. Para podermos usar uma interface, 
devemos criar uma classe ou estrutura e herdar da interface. Com isso, 
é obrigatório implementar todos os métodos da interface. 
Exemplo de implementação retirado do books online em C#. 
interface IExemploInterface 
{ 
 void ExemploMetodo(); 
} 
class Implementacaoclasse : IExemploInterface 
{ 
 // Implementação explicita da interface 
 void IExemploInterface.ExemploMetodo() 
 { 
 // Implementação do método 
 } 
 static void Main() 
 { 
 // Declarando uma instancia de uma interface 
 IExemploInterface obj = new Implementacaoclasse(); 
 // chame o método. 
 obj.SampleMethod(); 
 } 
} 
 
Classes Abstratas X Interfaces 
Uma classe abstrata pode conter métodos completos ou incompletos. 
Uma Interface pode conter apenas a assinatura de um método, mas 
nenhum corpo ou implementação. Portanto, em uma classe abstrata, 
pode-se implementar métodos, mas em uma Interface, não. Uma 
classe abstrata pode conter campos, construtores, ou destrutores e 
aplicar propriedades. Uma interface não pode conter campos, 
construtores, ou destrutores. Pode possuir apenas a propriedade da 
assinatura, mas não a implementação. Uma classe abstrata não 
suporta múltiplas heranças, mas uma interface pode suportá-las. 
Assim, uma classe pode herdar várias interfaces, mas apenas uma 
classe abstrata. Uma classe que implementa uma interface tem 
obrigatoriamente que implementar todos os métodos desta, mas o 
mesmo não é exigido no caso de uma classe abstrata. As classes 
abstratas são mais rápidas que as interfaces. 
 
Classe selada (Sealed Class) 
Uma classe selada é utilizada para restringir características da herança 
do objeto. Quando uma classe é definida como sealed, está classe não 
poderá ser herdada. Caso você tente, o compilador criará um erro em 
tempo de compilação. Após criar uma classe selada, quando você tenta 
criar uma herança para novas classes, pode-se observar que o 
intelisense não mostra o nome da classe definida como sealed. 
Exemplo de implementação retirado do books online em C#. 
sealed class ClasseSelada 
{ 
 public int x; 
 public int y; 
} 
class MainClass 
{ 
 static void Main() 
 { 
 ClasseSelada sc = new ClasseSelada(); 
 sc.x = 110; 
 sc.y = 150; 
 Console.WriteLine("x = {0}, y = {1}", sc.x, sc.y); 
 } 
} 
 
Quando devo utilizar o que? 
Classes Abstratas podem adicionar mais funcionalidades, sem destruir 
as funcionalidades das classes filhos. Essas poderiam estar usando 
uma versão mais antiga. Classes abstratas fornecem uma maneira 
simples e fácil para "versionar" nossos componentes. Através da 
atualização da classe base, todas as classes que herdam são 
atualizadas automaticamente com a mudança. Em uma interface, a 
criação de funções adicionais terá um efeito sobre suas classes filhos 
devido à necessidade de implementação dos Métodos criados na 
interface. 
Classes abstratas deveriam ser usadas principalmente para objetos 
que estão estritamente relacionados, enquanto o uso de interfaces é 
mais adequado para fornecer funcionalidade comum a classes 
independentes. 
Digamos que existem duas classes, de pássaros e de aviões, e que nas 
duas existem os métodos chamados voar(). Seria estranho para uma 
classe aviões herdar, a partir de uma classe pássaros, apenas porque 
necessita do método voar(). Em vez disso, o método voar() deve ser 
definido em uma interface, e, em ambas as classes, pássaros e aviões 
devem implementar a interface. Se quisermos proporcionar uma 
funcionalidade em comum para os componentes, devemos utilizar uma 
classe abstrata. 
Classes abstratas nos permitem implementar parcialmente uma classe, 
enquanto a interface não contém a implementação de qualquer 
membro. Por isso, a seleção de interface ou classes abstratas depende 
das necessidades e design do nosso projeto. Podemos fazer uma classe 
abstrata, interface, ou até uma combinação de ambas, dependendo de 
nossas necessidades. Se desejarmos criar uma classe ou método 
interno para um componente ou library, o ideal é utilizar o tipo sealed 
porque qualquer tentativa de anular algumas das suas funcionalidades 
não será permitida. 
Nós podemos marcar uma classe ou método como selados por motivos 
comerciais, a fim de impedir um terceiro de modificar nossa classe. Por 
exemplo, no .NET, a string é uma classe selada. Não devemos usar a 
palavra-chave sealed com um método, a menos que o método seja 
uma mudança de outro método; ou, se estamos definindo um novo 
método e não queremos que ninguém mais o sobreponha, não 
devemos declará-lo como virtual em primeiro lugar. A palavra-chave 
selado fornece uma maneira de garantir que, ao sobrepor um método, 
seja fornecido um "final". Significa que ninguém mais poderá sobrepo-
lo novamente. 
Conclusão 
Devemos utilizar classes abstratas quando queremos compartilhar 
funcionalidades em comum entre classes, e utilizar interfaces quando 
desejamos que uma classe possua as mesmas assinaturas. Porém, a 
implementação de cada método não precisa ser a mesma. 
 
Unidade 2 – Conceitos de classes abstratas e 
interfaces 
 
O que é uma classe abstrata? (Abstract Class) 
A classe abstrata é um tipo de classe que somente pode ser herdada e 
não instanciada. De certa forma podemos dizer que este tipo de classe 
é conceitual, que pode definir funcionalidades para que as suas 
subclasses possam implementá-las de forma não obrigatória, ou seja 
ao se definir um conjunto de métodos na classe abstrata não é de total 
obrigatoriedade a implementação de todos os métodos em 
suas subclasses. 
Em uma classe abstrata os métodos declarados podem ser abstratos 
ou não e suas implementações devem ser obrigatórias na subclasse. 
Quando criamos um método em uma classe abstrata sua 
implementação é obrigatória pelas classes herdadas.Caso você não 
implemente o mesmo, o compilador criará um erro em tempo de 
compilação. 
 Exemplo de implementação retirado do books online 
em C#. 
 abstract class formaClasse 
{ 
 abstract public int Area(); 
} 
class quadrado : formaClasse 
{ 
 int x, y; 
 // Se não for implementado o método Area() 
 // será gerado um compile-time error. 
 public override int Area() 
 { 
 return x * y; 
 } 
} 
nterface 
As interfaces são fundamentais em um sistema orientado a objetos. 
Quando dizemos que um objeto é a instancia de uma classe, na 
verdade queremos dizer que este objeto implementa 
a interface definida pela classe, ou seja, uma interface define as 
operações que um objeto será obrigado a implementar. 
Para cada operação declarada por um objeto deve ser especificado o 
nome da operação, os objetos que esta operação aceita como 
parâmetro e o tipo de valor retornado pela operação. Este conjunto de 
informações sobre uma determinada operação tem o nome de 
assinatura da operação e a um conjunto de assinaturas de operações 
dá-se o nome de interface. 
É importante lembrar que uma interface nunca contém implementação, 
ou seja, numa interface não se pode definir campos, pois o mesmo é 
uma implementação de um atributo objeto. A interface também não 
permite construtores, pois num construtor temos as instruções usadas 
para inicializar campos. Para podermos usar uma interface devemos 
criar uma classe ou estrutura e herdar da interface, com isso é 
obrigatório implementar todos os métodos da interface. 
Exemplo de implementação. 
 interface IExemploInterface 
{ 
 void ExemploMetodo(); 
} 
class Implementacaoclasse : IExemploInterface 
{ 
 // Implementação explicita da interface 
 void IExemploInterface.ExemploMetodo() 
 { 
 // Implementação do método 
 } 
static void Main() 
 { 
 // Declarando uma instancia de uma interface 
 IExemploInterface obj = new Implementacaoclasse(); 
 // chame o método. 
 obj.SampleMethod(); 
 } 
} 
Classes Abstratas X Interfaces 
Uma classe abstrata pode conter métodos completos ou incompletos. 
Uma Interface pode conter apenas a assinatura de um método, mas 
nenhum corpo ou implementação. 
Portanto, em uma classe abstrata, pode-se implementar métodos, 
mas em uma Interface não. 
Uma classe abstrata pode conter campos, construtores, ou destrutores 
e aplicar propriedades. Uma interface não pode conter campos, 
construtores, ou destrutores; pode possuir apenas a propriedade da 
assinatura, mas não a implementação. 
Uma classe abstrata não suporta múltiplas heranças, mas 
uma interface pode suportar múltiplas heranças, assim uma classe 
pode herdar várias interfaces, mas apenas uma classe abstrata e uma 
classe que implementa uma interface tem de obrigatoriamente 
implementar todos os métodos da interface, mas o mesmo não é 
exigido no caso de uma classe abstrata, que são mais rápidas que 
as interfaces. 
Então, quando devo utilizar o quê? 
Classes Abstratas podem adicionar mais funcionalidades sem destruir 
as funcionalidades das classes filhos que poderiam estar usando uma 
versão mais antiga. Classes abstratas fornecem uma maneira simples 
e fácil para versionar nossos componentes e através da atualização da 
classe base, todas as classes que herdam são atualizadas 
automaticamente com a mudança. 
Em uma interface a criação de funções adicionais terá um efeito sobre 
suas classes filhos, devido à necessidade de implementação dos 
Métodos criados na interface. Então, classes abstratas deveriam ser 
usadas principalmente para objetos que estão estritamente 
relacionados, enquanto o uso de interfaces é mais adequado para 
fornecer funcionalidade comum a classes independentes. 
Digamos que existem duas classes, de pássaros e de aviões, e nas 
duas existam os métodos chamados voar(). Seria estranho para uma 
classe avião herdar a classe pássaro apenas porque necessita do 
método voar(). Em vez disso, o método voar() deve ser definido em 
uma interface e em ambas as classes pássaro e avião devem 
implementar a interface. Se quisermos proporcionar uma 
funcionalidade em comum para os componentes, devemos utilizar uma 
classe abstrata. 
Classes abstratas nos permitem implementar parcialmente uma classe, 
enquanto a interface não contem a implementação de qualquer 
membro, por isso a seleção de interface ou classes abstratas depende 
das necessidades e design do nosso projeto. 
Podemos fazer uma classe abstrata, interface, ou até uma combinação 
de ambas, dependendo de nossas necessidades. 
Conclusão 
Devemos utilizar classes abstratas quando queremos compartilhar 
funcionalidades em comum entre classes e utilizar interfaces quando 
desejamos que uma classe possua as mesmas assinaturas porém a 
implementação de cada método não precisa ser a mesma. 
Agora que já temos a interface e a classe que a implementa, para fazer 
uso da interface o que o cliente precisa fazer é instanciar um objeto 
que implemente essa interface e assinalar esse objeto á uma variável 
do tipo interface. Então vejamos uma construção de código 
usando interface: 
IminhaInterface obj:obj = new MinhaClasse():obj.Metodo2(): 
Apesar do uso de interface prover certa “indireção” relativa à classe 
que a implementa, o cliente ainda precisa instanciar a classe, como 
pode ser visto no exemplo anterior. Deste modo, não há uma completa 
separação entre a interface e a sua implementação. 
Como os métodos de MinhaClasse são públicos, pode-se também 
utilizar o seguinte código para acessar os métodos: 
MinhaClasse obj;obj = new MinhaClasse();obj.Metodo2(); 
Como essa construção é correta e, como já foi visto, mesmo quando 
fazemos uso de interface o cliente ainda precisa instanciar a classe que 
a implementa. Acredito que seja essa uma das razões pelas quais os 
desenvolvedores não dêem muita atenção ao uso de interfaces, 
principalmente aqueles que vêm do mundo não OOP e tem uma maior 
dificuldade em abstrair conceitos, ou seja, para que 
utilizar interfaces se podemos fazer acesso direto aos métodos 
utilizando apenas a classe? 
Bem, existe aí o principio das "boas práticas". Se você quiser levar a 
sério o conceito de projeto de software baseado em componentes, 
então há a necessidade de aderir a algumas regras práticas e uma 
delas é, sempre que possível, procurar separar a interface de sua 
implementação e, fazendo o uso de interfaces, prover um máximo de 
“desacoplamento” entre cliente e o provedor de serviços. 
Uma maneira de evitar o acesso direto aos método é a utilização da 
implementação explicita da interface no servidor, em que cada 
membro da interface é implementado utilizando o nome da interface. 
public class MinhaClasse() : IMinhaInterface{ void 
IminhaInterface.Metodo1(){....} void 
IminhaInterface.Medoto2(){....}} 
Note que nesse caso, as implementações dos métodos não mais 
utilizam a palavra public. 
Desse modo, o cliente só poderá fazer o acesso aos métodos, 
via interface: 
IminhaInterface obj;obj = new MinhaClasse();obj.Metodo2(); 
Se no cliente o desenvolvedor tentar instanciar a classe e assinalar o 
objeto â uma variável que não seja do tipo da interface, o compilador 
mostrará um erro, dizendo que a classe não contém o método em 
questão. 
 
WEBAULA 2 
Unidade 2 – Criando Classes - Interface 
 
 
O que é interface? 
Para quem não domina OOP, quando se fala em interface a primeira 
coisa que vem a mente é a interface com o usuário, ou seja, telas, 
botões, caixas de texto, etc. Bem, isso não deixa de ser 
uma interface mas, em OOP, o conceito de interface é bem diferente. 
No MSDN você vai verificar queinterfaces, da mesma maneira que 
classes, definem um conjunto de propriedades, métodos e eventos, 
porém, diferentemente das classes, interfaces não provêem 
implementações. Pode-se dizer que uma interface é semelhante a uma 
classe abstrata. 
Então, poderíamos ter: 
public interface IminhaInterface{ void Metodo1(); void Metodo2();} 
que seria semelhante a 
public abstract class MinhaInterface{ abstract public void 
Metodo1(); abstract public void Metodo2();} 
Note que tanto a interface como a classe abstrata não implementam 
os dois métodos. Surge então a pergunta: então qual a diferença? 
Podemos citar algumas pequenas diferenças: 
Classe abstrata 
- Pode ter ou não alguma implementação. Pode também ter variáveis 
membros, métodos não abstratos ou propriedades. 
- Pode derivar de apenas uma classe base, mesmo que essa classe 
base seja abstrata, mas pode derivar de quantas interfaces for 
necessário. 
- Pode ter métodos e propriedades não públicos, ou seja, private ou 
protected. 
- Pode ter métodos e membros estáticos (static) e definir constantes. 
Interface 
- Não tem implementações ou variáveis membros. 
- Só pode derivar de interfaces. 
- Todos os membros são públicos. 
- Não pode ter nenhum desses itens. 
 
 
Por que essas pequenas diferenças? 
Uma comparação bastante utilizada para a definição de interfaces é 
que elas atuam como um contrato entre o cliente e o provedor do 
serviço (a classe que implementa a interface) no qual o cliente está 
interessado. Num contrato, todas as regras têm que estar muito bem 
definidas, ou seja, tudo tem que ser mostrado publicamente e nada 
pode ser escondido. Imagine só um contrato em que 
algumas informações estivessem escondidas ou mesmo escritas com 
as famosas "letras miúdas". Desse modo, quando se fala em 
uma interface, ou contrato, o cliente pode seguramente se basear no 
que está escrito no contrato (interface) porque tudo o que está lá 
escrito será cumprido pelo provedor dos serviços. Pensando dessa 
maneira, agora fica claro porque todos os membros de 
uma interface são públicos e muito bem definidos e porque 
na interface não consta nenhum detalhe da implentação. Mesmo que 
haja alterações na implementação não afeta o cliente que se baseia 
numa interface que, por definição, é imutável. Isso também permite 
um alto grau de “desacoplamento” entre o cliente e o provedor, uma 
vez que a interface não tem nenhum conhecimento das 
implementações que ficam “encapsuladas” atrás da interface, ou seja, 
no provedor (classes). 
O provedor fica livre para levar a efeito as implementações, contanto 
que o conteúdo do contrato (interface) seja respeitado. Obviamente 
que o provedor pode fornecer muito mais do que consta no contrato, 
o que não faz diferença para o cliente, pois não afeta a interface, mas 
nunca menos para que não haja quebra de contrato. 
Surge então a pergunta: caso seja necessário, como estender as 
facilidades da interface? Uma vez que a interface pode estar sendo 
utilizada por outros clientes, a saída seria a utilização de 
outras interfaces ou, em outras palavras, o cliente fazer uso de 
múltiplos contratos. 
Implementando uma interface 
Para implementar uma interface, o que a classe tem que fazer é derivar 
da interface e implementar todos os métodos definidos na interface. 
Então teremos: 
public interface IMinhaInterface{ void Metodo1(); void Metodo2();} 
Note que o nome de interface deve iniciar com um I maiúsculo. 
Então, ao implementar a interface na classe, teremos: 
public class MinhaClasse : IMinhaInterface{ public void 
Metodo1(){......} public void Metodo2(){.....} // outras 
implementacoes int Medoto3(){.......}} 
Perceba que os métodos implementados na classe devem ser 
explicitamente declarados como públicos, uma vez que, por definição, 
todos os métodos da interface também o são. 
Agora que já temos a interface e a classe que a implementa, para fazer 
uso da interface o que o cliente precisa fazer é instanciar um objeto 
que implemente essa interface e assinalar esse objeto á uma variável 
do tipo interface. Então vejamos uma construção de código 
usando interface: 
IminhaInterface obj:obj = new MinhaClasse():obj.Metodo2(): 
Apesar do uso de interface prover certa “indireção” relativa à classe 
que a implementa, o cliente ainda precisa instanciar a classe, como 
pode ser visto no exemplo anterior. Deste modo, não há uma completa 
separação entre a interface e a sua implementação. 
Como os métodos de MinhaClasse são públicos, pode-se também 
utilizar o seguinte código para acessar os métodos: 
MinhaClasse obj;obj = new MinhaClasse();obj.Metodo2(); 
Como essa construção é correta e, como já foi visto, mesmo quando 
fazemos uso de interface o cliente ainda precisa instanciar a classe que 
a implementa. Acredito que seja essa uma das razões pelas quais os 
desenvolvedores não dêem muita atenção ao uso de interfaces, 
principalmente aqueles que vêm do mundo não OOP e tem uma maior 
dificuldade em abstrair conceitos, ou seja, para que 
utilizar interfaces se podemos fazer acesso direto aos métodos 
utilizando apenas a classe? 
Bem, existe aí o principio das "boas práticas". Se você quiser levar a 
sério o conceito de projeto de software baseado em componentes, 
então há a necessidade de aderir a algumas regras práticas e uma 
delas é, sempre que possível, procurar separar a interface de sua 
implementação e, fazendo o uso de interfaces, prover um máximo de 
“desacoplamento” entre cliente e o provedor de serviços. 
Uma maneira de evitar o acesso direto aos método é a utilização da 
implementação explicita da interface no servidor, em que cada 
membro da interface é implementado utilizando o nome da interface. 
public class MinhaClasse() : IMinhaInterface{ void 
IminhaInterface.Metodo1(){....} void 
IminhaInterface.Medoto2(){....}} 
Note que nesse caso, as implementações dos métodos não mais 
utilizam a palavra public. 
Desse modo, o cliente só poderá fazer o acesso aos métodos, 
via interface: 
IminhaInterface obj;obj = new MinhaClasse();obj.Metodo2(); 
Se no cliente o desenvolvedor tentar instanciar a classe e assinalar o 
objeto â uma variável que não seja do tipo da interface, o compilador 
mostrará um erro, dizendo que a classe não contém o método em 
questão. 
WEBAULA 3 
Unidade 2 – Implementação de classes abstratas e 
interfaces 
 
Classes Abstratas 
Existem ocasiões nas quais as classes seguem um padrão para que no 
futuro outras classes herdem desta classe base. Neste caso já se tem 
a herança em mente. Imagine que ao criar uma classe você perceba 
que, ao invés dela servir a um único propósito, possa ser generalizada 
e usada para outros objetivos. 
Imagine que você esta criando uma classe e que pretende usá-la para 
efetuar processos, por exemplo, cálculos para retângulos, quadrados, 
paralelogramos e triângulos. O primeiro pensamento que vem é que 
todos estes objetos têm algo em comum, portanto pode-se criar uma 
classe que atenda a todos, mesmo que os processos (no caso algum 
cálculo) sejam diferentes em cada um. 
Esta classe seria uma Classe Base para eles. Como são objetos 
geométricos e cada um tem uma forma diferente, pode-se criar uma 
classe que tenha atributos e métodos que sirvam para todos, porém 
podem existir métodos que sejam comuns a todos, mas que o trabalho 
realizado seja diferente para cada objeto. 
Para atender a este problema, existem as classes abstratas e métodos 
abstratos, além de propriedades, eventos e indexadores abstratos. A 
implementação deste tipo de classe é diferente das chamadas Classes 
Concretas. 
Se cada objeto geométrico é uma classe, pode-se criar uma que seja 
a classe base para elas, por exemplo, ClasseForma. Neste caso, não 
se faz necessária a implementação de métodos particulares, apenas 
especificações, permitindo que a criação de apenas o protótipo de 
métodos, isto é, métodos que não têm bloco de comando, somente seu 
escopo. Estes métodos recebem o nome de métodos abstratos. 
O código de cada um destes métodos é feito somente nas classes 
derivadas da classe abstrata. Entretanto, existem duas implicações: 
a) não é possível instanciar objetos da classe, uma vez que os métodos 
são incompletos; 
b) há a obrigatoriedade da implementação de todos os métodos 
abstratos para que se possa instanciar a classe derivada. Esta segunda 
exigência cria um tipo de contrato futuro, isto é, faz com que todas as 
classes que derivarem desta classe base implementem, 
obrigatoriamente, os métodos abstratos. 
A definição de uma classe abstrata e método abstrato ficam da 
seguinte forma: 
abstract class Forma{ abstract double area() 
} 
Qualquer classe derivada da classe forma, seja ela a classe círculo, 
retângulo, triângulo ou qualquer outra do gênero terá que implementar 
o método area( ), obviamente elas farão o seu próprio código de 
cálculo de uma área. 
Interfaces 
Interfaces são modelos para a construção de outras classes. 
Diferentemente das classes abstratas, as interfaces não carregam 
código algum dentro de sua estrutura, elas apenas definem métodos, 
propriedades e permitem a declaração de constantes. Implicitamente 
os métodos das interfaces têm seus acessos declarados como public e 
abstract. 
Então, como se pode ver, uma interface não tem aplicação sozinha. Ela 
contém apenas as definições de eventos, indexadores, métodos e/ou 
propriedades. A razão pela qual as interfaces fornecem apenas as 
definições é porque elas são implementadas por classes e estruturas, 
as quais devem proporcionar uma aplicação para cada membro 
definido dentro desta interface. 
Para exemplificar a construção de uma interface e classe derivada, 
utilizou-se a idéia de impressão e edição, isto é, serão construídas duas 
interfaces. Veja o exemplo a seguir: 
interface Interf1{ public void mostrar(); public void 
mostrarnoConsole(); 
} 
 
Veja que os métodos não têm codificação, apenas definições. Logo, 
qualquer classe que implementar a interface terá o compromisso de 
criar o corpo dos métodos definidos na interface. O escopo de uma 
classe que herda da interface Interf1 fica da seguinte forma: 
class Pessoa: Interf1 
 
Como já citado, em CSharp não existe herança múltipla, contudo é 
possível implementar as operações de múltiplas interfaces. Não é 
contraditório dizer que não existe herança múltipla, mas pode 
implementar múltiplas interfaces? 
Quando se diz que não há herança múltipla, é devido à impossibilidade 
de uma classe herdar características de duas ou mais classes ou classes 
abstratas. Todas as classes e classes abstratas contêm 
implementações, isto é, seus métodos são criados dentro da sua 
classe, com exceção, é claro, dos métodos abstratos em classes 
abstratas. 
Nas interfaces não existem corpos para os métodos, apenas seus 
escopos (assinaturas), e não existem atributos com valores variáveis, 
apenas as chamadas constantes, nas quais o valor nunca muda 
durante a execução do programa. 
Em resumo, quando uma classe herda outra, pode reaproveitar ou 
especificar comportamentos de objetos em uma hierarquia. Quando 
uma classe implementa uma interface, ela não reaproveita código, uma 
vez que não existem tais códigos, todavia ela se vê obrigada a seguir 
os comportamentos ditados pela interface. 
Veja como fica a declaração de uma classe que implementa duas 
interfaces: 
 interface Idemonstra 
 { 
 void Mostrar(); 
 } 
 interface Idemonstra1 
 { 
 void Mostrar(); 
 } 
class Implementa:Idemonstra,Idemonstra1 
{ 
 void Idemonstra.Mostrar() 
 { 
 Console.WriteLine("Show() method Implemented"); 
 } 
 void Idemonstra1.Mostrar() 
 { 
 Console.WriteLine("Display() method Implemented"); 
 } 
 public static void Main(string[] args) 
 { 
 Implementa InstClasse = new Implementa(); 
 IsntClasse.Idemonstra.Mostrar(); 
 IsntClasse.Idemonstra1.Mostrar(); 
 } 
} 
Conclusão 
Nesta unidade foi abordado o conceito de herança, classes abstrata e 
interfaces. Portanto, é importante que você compreenda bem e passe 
a utilizar tal conceito de forma coerente. 
 
Resumo 
Em algumas ocasiões as classes seguem um padrão para que no futuro 
outras classes herdem desta classe, que será chamada de Classe Base. 
Uma classe base pode ter mais de uma classe derivada, porém uma 
classe que derivará de uma base só poderá herdar dela, isto é, uma 
classe derivada tem apenas uma classe base. 
Nas classes chamadas abstratas existem métodos que não contêm 
corpo, são os chamados métodos abstratos. O código destes métodos 
abstratos é feito somente nas classes derivadas da classe abstrata. 
Foram apresentadas duas regras para estas classes abstratas: 
a) não é possível instanciar objetos da classe, uma vez que os métodos 
são incompletos; 
b) há a obrigatoriedade da implementação de todos os métodos 
abstratos para que se possa instanciar a classe derivada. 
Existem ainda as interfaces, que tem similaridades com o escopo de 
uma classe, porém não são classes. As interfaces são um tipo de 
modelo para a construção de outras classes e diferenciam-se das 
classes abstratas por não carregarem código algum dentro de sua 
estrutura. Apenas definem métodos, propriedades e permitem a 
declaração de constantes. Implicitamente os métodos 
das interfaces têm seus acessos declarados como public e abstract. 
 
Implementando com interfaces 
A sintaxe do uso de interfaces pode parecer muito estranha, à primeira 
vista. 
Vamos começar com um exercício para praticar a sintaxe: 
1. Crie um projeto novo no C# com o nome UsandoInterfaces 
2. Adicione uma classe ao seu projeto clicando com o botão direito 
sobre o nome do projeto (UsandoInterfaces) e de o nome de 
IFigurasGeometricas. 
3. No arquivo troque a palavra Class por interface 
Ficando então o nosso arquivo desta forma: 
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
 
namespace UsandoInterfaces 
{ 
 interface IFormasGeometricas 
 { 
 double CalcularArea() 
 } 
} 
 
Agora vamos criar uma classe herdando da interface 
IFormasGeometricas 
Novamente clique com o botão direito no projeto e adicione mais uma 
classe e de o nome de FormasGeometricas. 
Agora vamos criar as classes que herdaram da interface 
IFormasGeometricas. 
Renomeie a classe FormasGeometricas para _Quadrado e faça a 
herança da interface da seguinte forma: 
 
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
 
namespace UsandoInterfaces 
{ 
 class _Quadrado: IFormasGeometricas 
 { 
 public int Base { get; set; } 
 
 public double CalcularArea() 
 { 
 return Base * Base; 
 } 
 } 
} 
 
 
WEBAULA 4 
Unidade 2 – Classes Abstratas 
 
Vamos testar a nossa classe, monte o form da aplicação da seguinte 
forma: 
Agora crie um atributo no seu form deste maneira: 
 public partial class Form1 : Form 
 { 
 private _Quadrado Quadrado; 
 
Agora no form_Load (duplo clique no formulário) do seu formulário 
codifique da seguinte forma: 
 private void Form1_Load(object sender, EventArgs e) 
 { 
 Quadrado = new _Quadrado(); 
 } 
 
De um duplo clique no botão que você inseriu no form e codifique desta 
forma: 
 private void button1_Click(objectsender, EventArgs e) 
 { 
 Quadrado.Base = int.Parse(textBox1.Text); 
 textBox2.Text = Quadrado.CalcularArea().ToString(); 
 } 
Execute a aplicação e teste o cálculo, digitando o valor da base do 
quadrado a ser calculado. 
Vamos criar mais uma classe usando esta interface. Crie então a classe 
Circulo, veja a codificação abaixo: 
 class _Circulo : IFormasGeometricas 
 { 
 public double Diametro { get; set; } 
 
 public double CalcularArea() 
 { 
 // Formula da area de um circulo: 
 // pi * raio ao quadrado (O raio e a metade do diâmetro ou 
seja 
 // diâmetro dividido por 2) 
 // Math.Pow é o método que calcula potencia ex: 102 
 // em c# se escreve assim: Math.Pow(10,2) 
 
 double RaioAoQuadrado = Math.Pow(Diametro / 2, 2); 
 return (Math.PI * RaioAoQuadrado); 
 } 
 } 
 
 
Agora acrescente mais alguns componentes no seu form desta forma: 
No clique do botão Calcular Área do Circulo codifique desta forma: 
 { 
 Circulo.Diametro = double.Parse(textBox3.Text); 
 textBox4.Text = Circulo.CalcularArea().ToString(); 
 } 
 
Agora teste a classe circulo. 
Repare que se você tivesse usado herança, não ia ganhar muita coisa, 
já que cada implementação é totalmente diferente da outra: um 
Quadrado, um Retangulo e um Circulo têm atributos e métodos bem 
diferentes. Mas, mesmo que eles tivessem atributos em comum, 
utilizar interfaces é uma maneira muito mais elegante de modelar suas 
classes. Todas as classes que herdarem 
da Interface IFormasGeometricas possuirão o mesmo método 
chamado CalcularArea porém cada classes efetua uma calculo diferente 
acontecendo neste momento uma característica 
chamada polimorfismo. 
 
Como trabalhar com classes abstratas 
 Para criar uma classe abstrata precisamos usar a declaração 
abstract cuja sintaxe segue abaixo: 
 abstract class Util 
 { 
 
 } 
 Para entendermos as classes abstract, vamos criar os mesmos 
exercícios acima com classes abstratas. Vamos lá: 
 
1. Crie um projeto novo no C# com o 
nome UsandoClassesAbstratas 
2. Adicione uma classe ao seu projeto clicando com o botão direito 
sobre o nome do projeto (UsandoClassesAbstratas) e de o nome 
de AFigurasGeometricas. 
3. No arquivo adicione a clausula abstract antes da palavra Class 
 
Ficando então o nosso arquivo desta forma: 
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
 
namespace UsandoClassesAbstrata 
{ 
 abstract class AFormasGeometricas 
 { 
 public abstract double CalcularArea(); 
 } 
} 
Agora vamos criar uma classe herdando das classes abstrata 
AFormasGeometricas. 
Novamente clique com o botão direito no projeto e adicione mais uma 
classe e de o nome de FormasGeometricas. 
Agora vamos criar as classes que herdaram da classe abstrata 
AFormasGeometricas. 
Renomeie a classe FormasGeometricas para _Quadrado e faça a 
herança da classes abstrata da seguinte forma: 
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
 
namespace UsandoClassesAbstrata 
{ 
 class _Quadrado: AFormasGeometricas 
 { 
 public int Base { get; set; } 
 
 public override double CalcularArea() 
 { 
 return Base * Base; 
 } 
 } 
 
Veja que para implementar uma classe com classe abstrata, os 
métodos precisam ser definidos com a cláusula override. Essa foi a 
única diferença com relação a implementação com interfaces. 
 
Vamos testar a nossa classe, monte o form da aplicação da seguinte 
forma: 
 
Agora crie um atributo no seu form deste maneira: 
 public partial class Form1 : Form 
 { 
 private _Quadrado Quadrado; 
 
Agora no form_Load (duplo clique no formulario) do seu formulário 
codifique da seguinte forma: 
 private void Form1_Load(object sender, EventArgs e) 
 { 
 Quadrado = new _Quadrado(); 
 } 
De um duplo clique no botão que você inseriu no form e codifique desta 
forma: 
 private void button1_Click(object sender, EventArgs e) 
 { 
 Quadrado.Base = int.Parse(textBox1.Text); 
 textBox2.Text = Quadrado.CalcularArea().ToString(); 
 } 
Execute a aplicação e teste o cálculo, digitando o valor da base do 
quadrado a ser calculado. 
Vamos criar mais uma classe usando esta classes abstrata. Crie então 
a classe Círculo. Veja a codificação abaixo: 
 class _Circulo : AFormasGeometricas 
 { 
 public double Diametro { get; set; } 
 
 public override double CalcularArea() 
 { 
 // Formula da area de um circulo: 
 // pi * raio ao quadrado (O raio e a metade do diâmetro ou 
seja 
 // diâmetro dividido por 2) 
 // Math.Pow é o método que calcula potencia ex: 102 
 // em c# se escreve assim: Math.Pow(10,2) 
 
 double RaioAoQuadrado = Math.Pow(Diametro / 2, 2); 
 return (Math.PI * RaioAoQuadrado); 
 } 
 } 
Agora acrescente mais alguns componentes no seu form desta forma: 
 
No clique do botão Calcular Área do Circulo codifique desta forma: 
 { 
 _Circulo Circulo = new _Circulo(); 
 Circulo.Diametro = double.Parse(textBox3.Text); 
 textBox4.Text = Circulo.CalcularArea().ToString(); 
 } 
 
Agora teste a classe circulo.