Embed Size (px)
Citation preview
Visão geral
Apresentação da disciplina:
Vamos estudar na disciplina de Desenvolvimento orientado a Objetos I a integração das fases de análise e
implementação, conforme o paradigma orientado a objetos.
Objetivos:
Construir softwares confiáveis, Reutilizáveis e de fácil manutenção.
Capacitar o aluno para o desenvolvimento de software orientado a objetos introduzindo os
conceitos de classes, objetos, herança, polimorfismo.
Conteúdo Programático:
Histórico
O que significa POO
Linguagens OO
POO x Programação estruturada
Conceitos e aplicação:
o Classe
o Objeto
o Encapsulamento
o Herança
o Polimorfismo.
Métodos e propriedades
Modificadores de escopo
Metodologia:
Os conteúdos programáticos ofertados nessa disciplina serão desenvolvidos por meio das Tele-Aulas de
forma expositiva e interativa (chat – tira dúvidas em tempo real), Aula Atividade por Chat para
aprofundamento e reflexão e Web Aulas que estarão disponíveis no Ambiente Colaborar, compostas de
conteúdos de aprofundamento, reflexão e atividades de aplicação dos conteúdos e avaliação. Serão
também realizadas atividades de acompanhamento tutorial, participação em Fórum, atividades práticas e
estudos independentes (auto estudo) além do Material do Impresso por disciplina.
Avaliação Prevista:
O sistema de avaliação da disciplina compreende em assistir a tele-aula, participação no fórum, produção
de texto/trabalho no portfólio, realização de duas avaliações virtuais, uma avaliação presencial embasada
em todo o material didático, tele-aula e web aula da disciplina.
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, atemplate 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 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 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ó!
CliquWEBAULA 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; } }
e aqui para baixar todo o projeto.
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 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 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.
Vamos, então, criar uma nova classe, porém, herdando da classe pessoa que acabamos de construir.
Clique com o botão direito no projeto WebAula2 -> Add -> Class... e coloque o nome do arquivo deAluno. Este arquivo irá conter a definição da nossa classe herdada de _Pessoa.
No arquivo Aluno, renomeie a classe Aluno para _Aluno (Lembre do underline).
Na frente da declaração da classe _Aluno, acrescente a seguinte instrução:
: _Pessoa, ficando a declaração 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 métodos Publicos da classe pai (_Pessoa) são visíveis e estão disponíveis para serem usados na classe filha (_Aluno).
Vamos definir um construtor para a classe _Aluno.
E o que é um construtor?
O construtor é um método 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 parâmetros que serão 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 três parâmetros, o que significa que, quando instanciarmos um objeto desta classe, teremos que passar estes três parâmetros no momento da criação. Estes parâmetros estão inicializando os atributos Código, 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 nós temos três opções 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 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! WEBAULA 3
Unidade 1 – Criando minha primeira classe com herança e polimorfismo
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 da seguinte 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 Polimorfismopara 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.
