Viso geral

Apresentao da disciplina:

Vamos estudar na disciplina de Desenvolvimento orientado a Objetos I a integrao das fases de anlise e
implementao, conforme o paradigma orientado a objetos.
Objetivos:

Construir softwares confiveis, Reutilizveis e de fcil manuteno.

Capacitar o aluno para o desenvolvimento de software orientado a objetos introduzindo os

conceitos de classes, objetos, herana, polimorfismo.
Contedo Programtico:

Histrico

O que significa POO

Linguagens OO

POO x Programao estruturada

Conceitos e aplicao:
o

Classe

Objeto

Encapsulamento

Herana

Polimorfismo.

Mtodos e propriedades

Modificadores de escopo
Metodologia:

Os contedos programticos ofertados nessa disciplina sero desenvolvidos por meio das Tele-Aulas de
forma expositiva e interativa (chat tira dvidas em tempo real), Aula Atividade por Chat para
aprofundamento e reflexo e Web Aulas que estaro disponveis no Ambiente Colaborar, compostas de
contedos de aprofundamento, reflexo e atividades de aplicao dos contedos e avaliao. Sero
tambm realizadas atividades de acompanhamento tutorial, participao em Frum, atividades prticas e
estudos independentes (auto estudo) alm do Material do Impresso por disciplina.
Avaliao Prevista:

O sistema de avaliao da disciplina compreende em assistir a tele-aula, participao no frum, produo

de texto/trabalho no portflio, realizao de duas avaliaes virtuais, uma avaliao presencial embasada
em todo o material didtico, tele-aula e web aula da disciplina.

ANLISE E DESENVOLVIMENTO DE SISTEMAS

WEBAULA 1

Unidade 1 Criando minha primeira classe

Apresentao
Caros alunos,
Sou o professor Marcio Roberto Chiaveli.
Estaremos trabalhando juntos na Disciplina de Desenvolvimento Orientado a Objetos I. Vamos aplicar, na prtica, o que
conhecemos na teoria desta disciplina, um conceito amplamente discutido e estudado no meio tecnolgico de desenvolvimento
de softwares.
Afinal, um software bem projetado garante a integridade das informaes, que so geradas na sua execuo.
Aqui na unidade I, vamos tratar dos procedimentos iniciais de como projetar e implementar uma classe em c#. Tambm vamos
aprender como instanciar um objeto desta classe e consumi-lo.
O estudo da programao orientada a objeto em C# passa obrigatoriamente pela criao de sua primeira classe. Nesta web aula,
vamos fazer passo-a-passo como criar uma classe.
Para desenvolvermos todos os nossos exerccios, vamos criar aplicativos do tipo CONSOLE APPLICATION.
Vamos l!
Vamos abrir o C# e criarmos um novo projeto, selecionando, no menu do sistema, a opo 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. Ento, no campo Name, coloque o nome do projeto de Web Aula1.
Se tudo deu certo, estar aparecendo na sua tela o seguinte trecho de cdigo:
using
using
using
using

System;
System.Collections.Generic;
System.Linq;
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 cdigo que est em negrito logo aps a linha static void Main(string[] args). Ficando, ento, 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 aplicao. 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 boto 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, atemplate Class j est
selecionada. Ento, 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 boto 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
comeo do nome. Isso ser um padro que vamos assumir em todas a classes que criarmos. Vocs vo entender mais frente a
razo disto.
Agora vamos criar os atributos private da nossa classe. Entre as chaves do corpo da nossa classe vamos comear 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 no estaro disponveis fora desta classe. Para que
possamos usar esta classe e gravar valores nos atributos, precisamos public-los, ou seja, criarmos propriedades pblicas 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 trs linhas que fizemos no comeo da aula e escreva o seguinte cdigo 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 instncia para um objeto, possamos usar o nome sem o (_) underline.
Entenderam?
Bom, vamos seguir com o nosso cdigo. Depois de criar o objeto, vamos us-lo. Para isso, vamos escrever um cdigo que
pergute 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 cdigo.....:");
// Veja que nesta linha precisamos fazer a converso
// do valor digtado pelo usurio pois toda entrada via console
// do tipo texto e o nosso cdigo e int, por isso devemos
// fazer a converso 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 endereo...:");
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 contedo 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("Edereo......: {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!
CliquWEBAULA 2

Unidade 1 Herana
Bom, j estamos familiarizados com o C#, no mesmo?
Ento, vamos direto ao assunto.
Vamos abrir o C# e criarmos um novo projeto, selecionando no menu do sistema a opo 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 boto 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
private
private
private

int _Codigo;
string _Nome;
string _Cpf;
string _Fone;

Na sequncia, 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; }
}
e aqui para baixar todo o projeto.
Agora, vamos criar alguns mtodos para validar e formatar os valores dos atributos.
Vamos criar um mtodo para que, quando for solicitado o Cpf da pessoa, a classe devolva o valor formatado.
O mtodo bem simples. Acompanhe:

private string FormatarCpf()

{
return _Cpf.Substring(1, 3) + "." +
_Cpf.Substring(4, 3) + "." +
_Cpf.Substring(7, 3) + "-" +
_Cpf.Substring(10, 2);
}
O mtodo SubString, da classe string, do qual o atributo _Cpf herda o tipo, extrai do atributo _Cpf. A partir de uma determinada
posio, ele pega um valor n de caracteres estipulado. Desta forma, ns montamos o Cpf formatado com a mscara padro.
Em seguida, vamos atribuir o mtodo FormatCpf chamada do mtodo get da propriedade Cpf.
Obs: Quando eu falo de propriedade, estou falando daquela que ns publicamos com o comandoPublic (Ex: Cpf: sem o
underline ), e quando falo de atributo, falo daqueles que definimos comoPrivate (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 mtodo ficaria desta forma
private string FormatarFone()
{
return _Fone.Substring(1, 4) + "-" +
_Fone.Substring(5, 4);
}
Novamente, substitua a chamada do mtodo:
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 mtodo 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 cdigo.: ");
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("Cdigo.....: {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 cdigo e ver o efeito do mtodo de formatao.
Bom, por enquanto, nenhuma novidade, visto que isto j aprendemos na aula anterior.
Vamos, ento, criar uma nova classe, porm, herdando da classe pessoa que acabamos de construir.
Clique com o boto direito no projeto WebAula2 -> Add -> Class... e coloque o nome do arquivo deAluno. Este arquivo ir
conter a definio da nossa classe herdada de _Pessoa.
No arquivo Aluno, renomeie a classe Aluno para _Aluno (Lembre do underline).
Na frente da declarao da classe _Aluno, acrescente a seguinte instruo:
: _Pessoa, ficando a declarao completa desta forma
class _Aluno: _Pessoa
Isto quer dizer que a classe _Aluno que voc est criando est sendo herdada da classe _Pessoa.
Sendo assim, todos os atributos e mtodos Publicos da classe pai (_Pessoa) so visveis e esto disponveis para serem usados
na classe filha (_Aluno).
Vamos definir um construtor para a classe _Aluno.
E o que um construtor?
O construtor um mtodo especial que executado automaticamente quando instanciamos uma classe. E todo construtor
necessariamente tem que ter o mesmo nome da classe, ou seja, no nosso caso, o construtor ter o nome de _Aluno. Os
construtores podem receber parmetros que sero usados para iniciar alguns atributos. Vejamos como vai ficar o nosso
construtor:
public _Aluno(int pCodigo, string pNome, int pMatricula)
{
Codigo = pCodigo;
Nome
= pNome;
Matricula = pMatricula
}
Veja que o construtor possui o mesmo nome da classe e aceita trs parmetros, o que significa que, quando instanciarmos um
objeto desta classe, teremos que passar estes trs parmetros no momento da criao. Estes parmetros esto inicializando os
atributos Cdigo, Nome e Matricula.
Bom, uma classe pode conter mais de um construtor. Hora, para que ter mais de um construtor? Qual a vantagem disso? Bom,
vamos l.
Para podermos escolher de que forma queremos instanciar os objetos desta classe. Por exemplo: vamos criar mais dois
construtores na nossa classe _Aluno.
public _Aluno(int pCodigo)
{
Codigo = pCodigo;
}
public _Aluno()
{
}

Veja que agora ns temos trs opes para instanciar a nossa classe _Aluno.
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
private
private
private

int _Matricula;
string _Curso;
string _Turno;
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 mtodo ExecutarPesso() e vamos criar um outro
mtodo para consumir a nossa classe _Alunos, da seguinte forma:
No final do mtodo ExecutarPessoa(), insira este cdigo:
public static void ExecutarAluno()
{
_Aluno Aluno = new _Aluno();
// Note que estes atributos no esto definidos na classe
// _Aluno no entanto esto disponiveis porque esta
// uma caracterstica da herana

Console.Write("Informe o cdigo.: ");

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 so 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("Cdigo.....: {0}", Aluno.Codigo);
Console.WriteLine("Nome.......: {0}", Aluno.Nome);
Console.WriteLine("Cpf........: {0}", Aluno.Cpf);
Console.WriteLine("Telefone...: {0}", Aluno.Fone);
Console.WriteLine("Matrcula..: {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 atravs da herana e como utiliz-la em programas.
At a prxima! WEBAULA 3
Unidade 1 Criando minha primeira classe com herana e polimorfismo

Hoje, vamos desenvolver uma classe, usando os conceitos de herana e polimorfismo

Vamos por a mo na massa!
Vamos abrir o C# e criarmos um novo projeto, selecionando no menu do sistema a opo 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 boto salvar

Figura 1
Conforme a figura abaixo, na janela Solution Explorer, clique com o boto 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 cdigo abaixo:
class _Funcionario
{
// Esta constante ser usada para calcular o
// salario liquido do funcionrio
// 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 mtodo para calcular o salrio do funcionrio.

O mtodo bem simples. Acompanhe:
public Double CalcularSalario()
{
return (_Salario - (_Salario * INSS));
}
O mtodo est simplesmente subtraindo o valor de 8% (que o valor da constante) do salrio do funcionrio e retornando o
resultado.
Vamos testar a classe.
Selecione o arquivo Program.cs e vamos codificar o teste da seguinte forma:
Crie um mtodo chamado TelaFuncionario, logo abaixo do mtodo Main, conforme o cdigo 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("Cdigo.....:");
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 mtodo
// 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 mtodo para salvar o contedo da classe para um arquivo no sistema operacional. Para isso,
vamos usar uma classe chamada StreamWriter. Veja a codificao a seguir:
public void Salvar()
{
StreamWriter Funcionario = new StreamWriter(@"C:\Funcionario.Txt",true);
Funcionario.WriteLine("Cdigo = " + _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 parmetro. O segundo parmetro 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.
Mtodo da classe StreamWriter

WriteLine => escreve no arquivo

Flush=> grava o arquivo

Close=> fecha o aquivo

Agora vamos criar a classe vendedor herdando da classe funcionrio.

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 funcionrio, temos dois mtodos para tratamento de pessoa: um o mtodo Salvar, sendo que este mtodo
simplesmente grava num arquivo os dados da classe pessoa e o outro mtodo calcula o salrio da pessoa. Bom, s que agora
ns estamos criando uma classe vendedor, fazendo herana da classe funcionrio. Sendo assim, estes mtodos so herdados
tambm. Mas se ns invocarmos o mtodo Salvar, por exemplo, ele gravar somente os dados de funcionrio no arquivo
Funcionrio.Txt. Ento, precisamos sobrescrever estes mtodos, usando o conceito de Polimorfismopara que eles tratem dos
dados de vendedor e no mais de funcionrio. Vamos ver como fazer isso.
Na nossa classe de vendedor, vamos criar o mtodo para calcular o salrio do vendedor. Veja: na classe funcionrio eu j tenho
este mtodo, mas ele somente calcula o salrio do funcionrio. Agora, precisamos calcular o salrio do vendedor. Usando o
conceito de polimorfismo, vamos sobrepor o mtodo de calcular salrio da classe funcionrio para mudarmos o clculo, incluindo
os clculos que precisamos para obter o salrio do vendedor. Vamos ver como fica o novo mtodo.
Para sobrepor um mtodo, primeiro precisamos dizer na classe pai que o mtodo em questo pode ser sobreposto usando a
palavra chave virtual. Ento, no mtodo CalcularSalario da classe funcionrio, vamos alterar o nosso mtodo, incluindo a
palavra-chave virtual depois do public, na declarao do mtodo:

public virtual Double CalcularSalario()

{
return _Salario - (_Salario * (INSS/100));
}
Isso faz com que o mtodo CalcularSalario possa ser sobreposto nas classes filhas.
Muito bem, agora vamos sobrepor o mtodo 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 declarao do mtodo, na classe filha, precisamos dizer que o mtodo est sendo sobreposto, ou seja, como se
eu estivesse dizendo "Olha, o mtodo CalcularSalario assim agora" . Observe: dentro do novo mtodo, eu chamei o mtodo da
classe pai usando a instruo base. Este comando diz que o CalcularSalario da classe pai que deve ser executado. Com isso,
ele executa o mtodo da classe pai, fazendo os clculos necessrios, e armazena o valor na varivel salrio. Na sequncia, eu
insiro os clculos necessrios para se obter o salrio do vendedor, retornando, assim, o salrio mais a comisso.
Vamos agora criar um mtodo no arquivo Program.cs para testarmos a nossa classe vendedor.

Crie o novo mtodo com o nome TelaVendedor, da mesma forma como criamos o mtodo TelaFuncionario, s que desta vez,
usando a classe Vendedor conforme o cdigo 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("Cdigo.....:");
Vendedor.Codigo = Convert.ToInt32(Console.ReadLine());
Console.Write("Nome.......:");
Vendedor.Nome = Console.ReadLine();
Console.Write("Cpf........:");
Vendedor.Cpf = Console.ReadLine();
Console.Write("Regio.....:");
Vendedor.RegiaoAtuacao = Console.ReadLine();
Console.Write("Tipo.......:");
Vendedor.TipoInternoExterno = Console.ReadLine();
Console.Write("Comisso...:");
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 mtodo
// 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 exerccio vou deixar vocs implementarem o mtodo Salvar, usando o conceito de polimorfismo.
Baixe o cdigo 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 no 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 mtodos na classe abstrata obrigatoriedade, assim como a implementao nas suas subclasses. Em uma classe
abstrata, os mtodos declarados podem ser abstratos ou no, e suas implementaes devem ser obrigatrias na subclasse.
Quando criamos um mtodo abstrato em uma classe abstrata, sua implementao obrigatria. Caso voc no implemente o
mesmo, o compilador criar um erro em tempo de compilao.
Exemplo de implementao retirado do books online em C#.
abstract class formaClasse
{
abstract public int Area();
}
class quadrado : formaClasse
{
int x, y;
// Se no for implementado o mtodo Area()

// ser gerado um compile-time error.

public override int Area()
{
return x * y;
}
}
Interface
As interfaces so fundamentais em um sistema orientado a objetos. Quando dizemos que um objeto a instncia de uma classe,
na verdade queremos dizer que este objeto implementa a interface definida pela classe, ou seja, uma interface define as
operaes que um objeto ser obrigado a implementar. Para cada operao declarada por um objeto, deve ser especificado o
nome da operao, os objetos que ela aceita como parmetro e o tipo de valor retornado pela mesma; este conjunto de
informaes sobre uma determinada operao tem o nome de assinatura da operao, e a um conjunto de assinaturas de
operaes d-se o nome de interface.
importante lembrar que uma interface nunca contm implementao, ou seja, numa interface no se pode definir campos, pois
os mesmos so uma implementao de um atributo objeto. A interface tambm no permite construtores, pois num construtor
temos as instrues usadas para inicializar campos. Para podermos usar uma interface, devemos criar uma classe ou estrutura e
herdar da interface. Com isso, obrigatrio implementar todos os mtodos da interface.
Exemplo de implementao retirado do books online em C#.
interface IExemploInterface
{
void ExemploMetodo();
}
class Implementacaoclasse : IExemploInterface
{
// Implementao explicita da interface
void IExemploInterface.ExemploMetodo()
{
// Implementao do mtodo
}
static void Main()
{
// Declarando uma instancia de uma interface
IExemploInterface obj = new Implementacaoclasse();
// chame o mtodo.
obj.SampleMethod();
}
}
Classes Abstratas X Interfaces
Uma classe abstrata pode conter mtodos completos ou incompletos. Uma Interface pode conter apenas a assinatura de um
mtodo, mas nenhum corpo ou implementao. Portanto, em uma classe abstrata, pode-se implementar mtodos, mas em uma
Interface, no. Uma classe abstrata pode conter campos, construtores, ou destrutores e aplicar propriedades. Uma interface no
pode conter campos, construtores, ou destrutores. Pode possuir apenas a propriedade da assinatura, mas no a implementao.
Uma classe abstrata no suporta mltiplas heranas, mas uma interface pode suport-las. Assim, uma classe pode herdar vrias
interfaces, mas apenas uma classe abstrata. Uma classe que implementa uma interface tem obrigatoriamente que implementar
todos os mtodos desta, mas o mesmo no exigido no caso de uma classe abstrata. As classes abstratas so mais rpidas que
as interfaces.
Classe selada (Sealed Class)
Uma classe selada utilizada para restringir caractersticas da herana do objeto. Quando uma classe definida como sealed,
est classe no poder ser herdada. Caso voc tente, o compilador criar um erro em tempo de compilao. Aps criar uma
classe selada, quando voc tenta criar uma herana para novas classes, pode-se observar que o intelisense no mostra o nome
da classe definida como sealed.
Exemplo de implementao 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 verso mais antiga. Classes abstratas fornecem uma maneira simples e fcil para "versionar" nossos componentes.
Atravs da atualizao da classe base, todas as classes que herdam so atualizadas automaticamente com a mudana. Em uma
interface, a criao de funes adicionais ter um efeito sobre suas classes filhos devido necessidade de implementao dos
Mtodos criados na interface.
Classes abstratas deveriam ser usadas principalmente para objetos que esto estritamente relacionados, enquanto o uso de
interfaces mais adequado para fornecer funcionalidade comum a classes independentes.
Digamos que existem duas classes, de pssaros e de avies, e que nas duas existem os mtodos chamados voar(). Seria
estranho para uma classe avies herdar, a partir de uma classe pssaros, apenas porque necessita do mtodo voar(). Em vez
disso, o mtodo voar() deve ser definido em uma interface, e, em ambas as classes, pssaros e avies 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 no contm a implementao de
qualquer membro. Por isso, a seleo de interface ou classes abstratas depende das necessidades e design do nosso projeto.
Podemos fazer uma classe abstrata, interface, ou at uma combinao de ambas, dependendo de nossas necessidades. Se
desejarmos criar uma classe ou mtodo interno para um componente ou library, o ideal utilizar o tipo sealed porque qualquer
tentativa de anular algumas das suas funcionalidades no ser permitida.
Ns podemos marcar uma classe ou mtodo como selados por motivos comerciais, a fim de impedir um terceiro de modificar
nossa classe. Por exemplo, no .NET, a string uma classe selada. No devemos usar a palavra-chave sealed com um mtodo, a
menos que o mtodo seja uma mudana de outro mtodo; ou, se estamos definindo um novo mtodo e no queremos que
ningum mais o sobreponha, no devemos declar-lo como virtual em primeiro lugar. A palavra-chave selado fornece uma
maneira de garantir que, ao sobrepor um mtodo, seja fornecido um "final". Significa que ningum mais poder sobrepo-lo
novamente.
Concluso
Devemos utilizar classes abstratas quando queremos compartilhar funcionalidades em comum entre classes, e utilizar interfaces
quando desejamos que uma classe possua as mesmas assinaturas. Porm, a implementao de cada mtodo no precisa ser a
mesma.