<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>Curso Online de C# .NET</title>
	<atom:link href="//www.tomasvasquez.com.br/cursocsharp/feed" rel="self" type="application/rss+xml" />
	<link>//www.tomasvasquez.com.br/cursocsharp</link>
	<description>Uma iniciativa de Tomás Vásquez</description>
	<lastBuildDate>Sun, 06 May 2018 04:22:10 +0000</lastBuildDate>
	<language>pt-BR</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>https://wordpress.org/?v=4.9.8</generator>
	<item>
		<title>Sobrecarga de Operadores</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/sobrecarga-de-operadores</link>
		<pubDate>Tue, 09 Mar 2010 19:22:54 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Programação Orientada a Objetos em .NET]]></category>
		<category><![CDATA[Sobrecarga de Operadores]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=429</guid>
		<description><![CDATA[Sobrecarregar um operador significa redefinir o seu símbolo, de maneira que ele se aplique também a tipos de dados definidos pelo usuário como classes e estruturas. Usar novas definições de operadores e usar classes para criar novos tipos de variáveis implica, de certa forma, na possibilidade de estender o C# a fim de adaptá-lo às &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/sobrecarga-de-operadores" class="more-link">Continue lendo <span class="screen-reader-text">Sobrecarga de Operadores</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<p>Sobrecarregar um operador significa redefinir o seu símbolo, de maneira que ele se aplique também a tipos de dados definidos pelo usuário como classes e estruturas. Usar novas definições de operadores e usar classes para criar novos tipos de variáveis implica, de certa forma, na possibilidade de estender o C# a fim de adaptá-lo às suas conveniências.</p>
<p>Sobrecarregar significa utilizar um mesmo nome para tarefas parecidas, mas de código de programas diferentes. A implementação de sobrecarga de operadores é definida por meio da palavra chave “operator”. Sobrecarga permite uma redefinição de como funciona um operador. Entretanto, é necessário respeitar sua definição original. Por exemplo, não é possível mudar um operador binário para criar um operador unário.</p>
<p>Porque utilizar sobrecarga de um operador? Se você cria uma classe chamada “MinhaClasse” e declara dois objetos desta, por exemplo:</p>
<pre lang="csharp" line="1">...
class MinhaClasse
{
      // ...
}

class MinhaMain
{
      static void Main()
      {
            MinhaClasse c1 = new MinhaClasse();
            MinhaClasse c2 = new MinhaClasse();
            c1 + c2;
      }
}
...</pre>
<p>Qual o significado da linha destacada(c1 + c2)? O compilador não reconhece o comando, pois não há uma implementação do operador binário soma (+) para o tipo MinhaClasse. O recurso de sobrecarga de operadores nos permite tornar essa e outras operações válidas para os tipos e classe que criamos.</p>
<p>Você pode sobrecarregar os seguintes operadores:</p>
<ul>
<li>Unários: +   &#8211;   !   +  +   &#8212;   true   false</li>
<li>Binários: +  &#8211;  * /  %  &amp;  I  A  &lt;&lt;  &gt;&gt;  ==  !=  &gt; &lt;  &gt;= &lt;=</li>
</ul>
<p>Porém, não é possível:</p>
<ul>
<li>Criar novos operadores.</li>
<li>Alterar a ordem de precedência (por exemplo, “*” sempre será executado antes que “+”)</li>
<li>Mudar o significado dos operadores para tipos já definidos;</li>
<li>Sobrecarregar os operadores de acesso a método, invocação de método =, &amp;&amp;, II, ?:, new, typeof, sizeof, is.</li>
<li>Definir implementações diferentes para os operadores ++/&#8211; em relação a prefixo/sufixo.</li>
</ul>
<p>Veja um código de exemplo:</p>
<pre lang="csharp" line="1">using System;
 
class SobrecargaOperador
{
      private int x, y;
      public SobrecargaOperador(int x1, int y1)
      {
            x = x1;
            y = y1;
      }
      public string imprime_SobrecargaOperador()
      {
                  return "x = " + x.ToString() + " e y = " + y.ToString();
      }
            // sobrecarrega o operador ++ para a classe SobreCargaOperado
      public static SobrecargaOperador operator ++(SobrecargaOperador op)
      {
            SobrecargaOperador op1 = op;
            op1.x = op1.x + 1;
            op1.y = op1.y + 1;
            return op1;
      }
}
 
class MinhaClasse
{
      static void Main()
      {
            SobrecargaOperador v1 = new SobrecargaOperador(0,0);
            SobrecargaOperador v2 = new SobrecargaOperador(2,3);
            Console.WriteLine("v1 = {0}", v1.imprime_SobrecargaOperador());
            Console.WriteLine("v2 = {0}", v2.imprime_SobrecargaOperador());
            v1++;
            v2++;
            Console.WriteLine("v1 = {0}", v1.imprime_SobrecargaOperador());
            Console.WriteLine("v2 = {0}", v2.imprime_SobrecargaOperador());
      }
}</pre>
<p>Compile e veja a saída no console:</p>
<p><a href="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image058.jpg"><img src="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image058-300x151.jpg" alt="" title="image058" width="300" height="151" class="alignnone size-medium wp-image-430" srcset="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image058-300x151.jpg 300w, //www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image058.jpg 566w" sizes="(max-width: 300px) 100vw, 300px" /></a></p>
<p>O código acima nos promove uma implementação válida para o operador unário ++ para objetos do tipo “SobrecargaOperador”.</p>
<p>Note que os métodos que sobrecarregam operadores são necessariamente “static” e “public”.</p>
<p>Veja um trecho de código que implementa o operador binário soma (+) para a classe “SobrecargaOperador”:</p>
<pre lang="csharp" line="1">...
// sobrecarrega o operador + para a classe SobreCargaOperador
public static SobrecargaOperador operator +(SobrecargaOperador op1, SobrecargaOperador op2)
{
      SobrecargaOperador opAux = op1;
      opAux.x = op1.x + op2.x;
      opAux.y = op1.y + op2.y;
      return opAux;
}
...</pre>
<p>Implementando este método, a soma de dois objetos do tipo SobrecargaOperador passa a ser válida.</p>
]]></content:encoded>
			</item>
		<item>
		<title>Eventos</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/eventos</link>
		<pubDate>Tue, 09 Mar 2010 19:08:57 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Programação Orientada a Objetos em .NET]]></category>
		<category><![CDATA[Eventos]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=426</guid>
		<description><![CDATA[O C# fornece suporte direto para eventos. Embora o tratamento de eventos tenha sido uma parte fundamental da programação desde seu início, um esforço surpreendentemente pequeno tem sido feito pela maior parte das linguagens para formalizar este conceito. O C# usa delegates junto com a palavra reservada “event” para fornecer uma solução bastante limpa para &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/eventos" class="more-link">Continue lendo <span class="screen-reader-text">Eventos</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<p>O C# fornece suporte direto para eventos. Embora o tratamento de eventos tenha sido uma parte fundamental da programação desde seu início, um esforço surpreendentemente pequeno tem sido feito pela maior parte das linguagens para formalizar este conceito. O C# usa delegates junto com a palavra reservada “event” para fornecer uma solução bastante limpa para tratamento de eventos. A melhor forma de ilustrar isto é dando um exemplo que mostre todo o processo de declaração, disparo e tratamento do evento: </p>
<pre lang="csharp" line="1">using System;
 
// Declaração do delegate
public delegate void TrataAlteracaoPontos (int novaPontuacao, ref bool cancela);
 
// Classe que cria o evento
public class MeuJogo
{
      //    declara o evento baseado no delegate
      public event TrataAlteracaoPontos AlteraPontos;
 
      int Pontuacao;
 
      // proopriedade que trata os pontos informados
      public int pontos
      {
            get
            {
                  return Pontuacao;
            }
            set
            {
                  if (Pontuacao != value)
                  {
                        bool cancela = false;
                        // dispara o evento AlteraPontos
                        AlteraPontos (value, ref cancela);
                        if (! cancela)
                             Pontuacao = value;
                  }
            }
      }
}
 
// Classe que trata o evento
public class MonitoraJogo
{
      public MonitoraJogo (MeuJogo jogo)
      {
            // Adiciona o método jogo_AlteraPontos ao tratamento do evento AlteraPontos
            jogo.AlteraPontos += new TrataAlteracaoPontos (jogo_AlteraPontos);
      }
 
      // método que irá manipular o evento Altera pontos e emitirá uma mensagem
      // com base na pontuação informada
      private void jogo_AlteraPontos(int novaPontuacao, ref bool cancela)
      {
            if (novaPontuacao < 50)
                  System.Console.WriteLine ("Você precisa melhorar sua pontuação");
            else if (novaPontuacao >= 50 && novaPontuacao < 100)
                  System.Console.WriteLine ("Boa pontuação");
            else
            {
                  cancela = true;
                  System.Console.WriteLine ("Ótima pontuação!");
            }
      }
}
 
// Testa a implementação
public class Jogar
{
      public static void Main ()
      {
            MeuJogo novoJogo = new MeuJogo();
            MonitoraJogo trata = new MonitoraJogo (novoJogo);
            Console.WriteLine("Digite o sua pontuação atual: ");
            novoJogo.pontos = Convert.ToInt32(Console.ReadLine());
      }
}</pre>
<p>Compile e veja a saída no console:</p>
<p><a href="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image056.jpg"><img src="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image056-300x151.jpg" alt="" title="image056" width="300" height="151" class="alignnone size-medium wp-image-427" srcset="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image056-300x151.jpg 300w, //www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image056.jpg 566w" sizes="(max-width: 300px) 100vw, 300px" /></a></p>
<p>Informamos 3 pontuações diferentes, e o evento reagiu da maneira correta.</p>
<p>A classe “Jogar” cria uma nova partida do jogo, a classe “MonitoraJogo” monitora o jogo (como se fosse um juiz), e então informamos nossa pontuação jogo para ver qual será a resposta. Com este sistema, assim como nos delegates, “MeuJogo” não tem conhecimento de “MonitoraJogo”, e simplesmente permite que qualquer classe escute e interaja sobre as mudanças feitas ao seu placar. A palavra-reservada event oculta todos os métodos de delegate adicionados com += e -= nas classes diferentes da que ele foi declarado. Esses operadores permitem que você adicione (e remova) quantos tratadores de evento você quiser ao evento, desde que estes tenham sempre os mesmo argumentos.</p>
]]></content:encoded>
			</item>
		<item>
		<title>Delegates</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/delegates</link>
		<pubDate>Tue, 09 Mar 2010 18:50:32 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Programação Orientada a Objetos em .NET]]></category>
		<category><![CDATA[Delegates]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=423</guid>
		<description><![CDATA[Delegates são ponteiros para métodos orientados a objetos e seguros. É uma maneira simples de evocar vários métodos em determinadas classes e objetos, sem que sequer algumas das classes saibam que as outras existem. Uma vantagem natural do delegate é que ele elimina a uso de variáveis globais em casos em que seu uso se &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/delegates" class="more-link">Continue lendo <span class="screen-reader-text">Delegates</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<p>Delegates são ponteiros para métodos orientados a objetos e seguros. É uma maneira simples de evocar vários métodos em determinadas classes e objetos, sem que sequer algumas das classes saibam que as outras existem. Uma vantagem natural do delegate é que ele elimina a uso de variáveis globais em casos em que seu uso se tornaria inevitável, por exemplo, ao trocar dados entre dois formulários Windows. Existem 2 tipos de delegates:</p>
<ul>
<li> Single Cast Delegate: aponta apenas para um método. Este método pode retornar algo diferente de void;</li>
<li> Multi Cast Delegate: aponta para varias funções. Porém, estes métodos só poderão retornar void, pois, quando o delegate é disparado, todos os métodos que são referenciados serão disparados simultaneamente, mas não é possível esperar terminar todos os métodos, e mesmo que pudesse, não poderíamos determinar qual retorno seria o correto.</li>
</ul>
<p>Veja um exemplo de delegate no código abaixo:</p>
<pre lang="csharp" line="1">using System;
 
public class Classe1
{
      public void Mensagem()
      {
            Console.WriteLine("Método Mensagem da Classe1 executado");
      }
}
 
public class Classe2
{
      // declara o delegate sem parâmetros
      public delegate void MyDelegate();
      // decalara uma variável do tipo delegate
      public MyDelegate d;
      // método para execurtar os métodos associados ao delegate
      public void ExecutaDelegate()
      {
            d();
      }
}

public class MinhaClasse
{
      static void Main()
      {
            Classe1 c1 = new Classe1();
            Classe2 c2 = new Classe2();
            c2.d = new Classe2.MyDelegate(c1.Mensagem);
            c2.ExecutaDelegate();
      }
}</pre>
<p>Compile e veja a saída no console:</p>
<p><a href="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image054.jpg"><img src="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image054-300x150.jpg" alt="" title="image054" width="300" height="150" class="alignnone size-medium wp-image-424" srcset="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image054-300x150.jpg 300w, //www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image054.jpg 567w" sizes="(max-width: 300px) 100vw, 300px" /></a></p>
<p>Note que pudemos executar um método classe “Classe1” a partir da classe “Classe2” sem que esta precise saber da existência desta classe. Sobre como disparar mais métodos através de um único delegate será visto no conceito de eventos.</p>
]]></content:encoded>
			</item>
		<item>
		<title>Propriedades</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/propriedades</link>
		<pubDate>Tue, 09 Mar 2010 18:39:32 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Programação Orientada a Objetos em .NET]]></category>
		<category><![CDATA[Propriedades]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=418</guid>
		<description><![CDATA[Uma forma mais inteligente de fazer implementações de campos em classes são as propriedades. Propriedades consistem em um par de métodos “get” e “set” que respectivamente servem para recuperar e atribuir o valor a um campo. Essa implementação nos permite enriquecer a validação de um campo que deve ser numérico, por exemplo. Veja o exemplo &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/propriedades" class="more-link">Continue lendo <span class="screen-reader-text">Propriedades</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<p>Uma forma mais inteligente de fazer implementações de campos em classes são as propriedades. Propriedades consistem em um par de métodos “get” e “set” que respectivamente servem para recuperar e atribuir o valor a um campo. Essa implementação nos permite enriquecer a validação de um campo que deve ser numérico, por exemplo. Veja o exemplo de código abaixo. Vamos aproveitar para colocar em prova os conhecimentos já adquiridos:</p>
<pre lang="csharp" line="1">using System;
 
public class Pessoa
{
      private string meuNome;
      private byte minhaIdade;
      private DateTime meuNascimento;
 
      public Pessoa()
      {
            // construtor vazio
      }
 
      public Pessoa(string nome, byte idade, DateTime nascimento)
      {
            meuNome = nome;
            minhaIdade = idade;
            meuNascimento = nascimento;
      }
 
      public override string ToString()
      {
            return "Meu nome é: " + meuNome + System.Environment.NewLine +
                  "Minha idade é: " + minhaIdade.ToString() + System.Environment.NewLine +
                   "Minha data de nascimento é: " + meuNascimento.ToString("dd/MM/yyyy");
      }
 
 
      public string Nome
      {
            get
            {
                  // devolve o nome
                  return meuNome;
            }
            set
            {
                  // atribui o nome à variável nome
                  meuNome = value.ToString();
            }
      }
 
      public byte Idade
      {
            get
            {
                  // devolve a idade
                  return minhaIdade;
            }
            set
            {
            // tenta atribuir o valor de value à minhaIdade
            // se o valor for inválida, retorna uma mensagem
                  try
                  {
                        minhaIdade = value;
                  }
                  catch(System.FormatException)
                  {
                        Console.WriteLine("A variável só aceita números");
                  }
                  catch(System.Exception)
                  {
                        Console.WriteLine("Didite uma idade válida");
                  }
            }
      }
 
      public DateTime Nascimento
      {
            get
            {
                  // devolve a data de nascimento
                  return meuNascimento;
            }
            set
            {
            // tenta atribuir o valor de value à meuNascimento
            // se o valor for inválido, retorna uma mensagem
                  try
                  {
                        meuNascimento = value;
                  }
                  catch(System.FormatException)
                  {
                        Console.WriteLine("Digite uma data válida");
                  }
            }
      }
}
 
public class MinhaClasse
{
      static void Main()
      {
            Pessoa eu = new Pessoa();
            Pessoa voce = new Pessoa("Mané", 20, Convert.ToDateTime("01/01/1984"));
            eu.Nome = "José";
            eu.Idade = 30;
            eu.Nascimento = Convert.ToDateTime("10/10/1974");
            Console.WriteLine(voce.ToString());
            Console.WriteLine(eu.ToString());
      }
}</pre>
<p>Compile e veja a saída no console:</p>
<p><a href="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image052.jpg"><img src="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image052-300x150.jpg" alt="" title="image052" width="300" height="150" class="alignnone size-medium wp-image-419" srcset="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image052-300x150.jpg 300w, //www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image052.jpg 567w" sizes="(max-width: 300px) 100vw, 300px" /></a></p>
<p>Note que o acesso às propriedades é simples como fazemos em  campo comuns ou em qualquer ambiente de programação visual. Procure atribuir outros valores, teste o código e veja se as mensagens e as rotinas para tratar os erros dão resultado.</p>
<p>O método “set” que atribui o valor à propriedade, recebe o valor da variável de atribuição como um parâmetro de nome “value”. Por isso usamos essa variável na atribuição. As propriedades “set” do código anterior poderiam ser representadas da seguinte maneira, para melhorar o entendimento:</p>
<pre lang="csharp" line="1">...
public string Nome
      {
            get
            {
                  // devolve o nome
                  return meuNome;
            }
            set(string value)
            {
                  // atribui o nome à variável nome
                  meuNome = value.ToString();
            }
      }
...</pre>
<p>Assim como podemos criar campos “readonly”(somente leitura), podemos também criar propriedades “readonly”. Para isso, basta omitir o método “set” da propriedade. A propriedade “Nome” readonly ficaria da seguinte forma:</p>
<pre lang="csharp" line="1">...
public string Nome
      {
            get
            {
                  // devolve o nome
                  return meuNome;
            }
      }
...</pre>
<p>As propriedades também podem ser “writeonly”(somente escrita). Para isso, basta omitir o método “get” da propriedade. A propriedade “Nome” writeonly ficaria da seguinte forma:</p>
<pre lang="csharp" line="1">...
public string Nome
      {
            set
            {
                  // atribui o nome à variável nome
                  meuNome = value.ToString();
            }
      }
...</pre>
]]></content:encoded>
			</item>
		<item>
		<title>Interfaces</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/interfaces</link>
		<pubDate>Tue, 09 Mar 2010 18:27:55 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Programação Orientada a Objetos em .NET]]></category>
		<category><![CDATA[Interface]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=416</guid>
		<description><![CDATA[O .NET Framework disponibiliza uma espécie de classe que nos permite implementar classes completamente abstratas, ou seja, sem nenhuma implementação com algumas vantagens e desvantagens. São chamadas de “Interfaces”. As regras para criação de uma interface em relação às classes abstratas são: tem o identificados “interface” e não “class”; não precisam do modificador “abstract”, nem &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/interfaces" class="more-link">Continue lendo <span class="screen-reader-text">Interfaces</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<p>O .NET Framework disponibiliza uma espécie de classe que nos permite implementar classes completamente abstratas, ou seja, sem nenhuma implementação com algumas vantagens e desvantagens. São chamadas de “Interfaces”. As regras para criação de uma interface em relação às classes abstratas são:</p>
<ul>
<li> tem o identificados “interface” e não “class”;</li>
<li> não precisam do modificador “abstract”, nem nos métodos;</li>
<li> não podem conter campos, só métodos;</li>
<li> não podem conter modificadores de acesso (public, private);</li>
<li> só podem ser herdadas;</li>
</ul>
<p>Se não tivéssemos a implementação do método “ImprimeValores” na classe anterior, através de Intefaces poderíamos defini-la do seguinte modo:</p>
<pre lang="csharp" line="1">...
interface  IMinhaInterface
{
       void RecebeValores(int v1, int v2);
       void CalculaValores();
       void ImprimeValores();
}
...</pre>
<p>Por convenção, nomeia-se uma interface com um “I” maiúsculo no início do nome para facilitar sua identificação em meio a classes.</p>
<p>A principal vantagem das interfaces sobre as classes abstratas é o fato do mecanismo de herança funcionar com herança múltipla. Como dito anteriormente, o .NET não permite herança múltipla de classes dado os problemas gerados por esse processo. Como as interfaces não geram implementações, pode-se herdar mais de uma interface em uma classe. O código abaixo demonstra um exemplo de herança múltipla com interfaces e classes:</p>
<pre lang="csharp" line="1">...
interface  IMinhaInterface
{
      void CalculaValores();
      void ImprimeValores();
}
 
abstract class MinhaClasseAbstrata
{
      public abstract void RecebeValores(int v1, int v2);
}
 
// declara a classe e herda a classe abstrata e a interface
class HerdaMultiplas: MinhaClasseAbstrata, IMinhaInterface
{
      public void CalculaValores()
      {
            // ..
      }
      public void ImprimeValores()
      {
            // ...
      }
            public override void RecebeValores(int v1, int v2)
      {
            // ...
      }
}
...</pre>
<p>Podemos herdar duas ou mais interfaces. O .NET Framework implementa uma série de interfaces que implementam métodos padrão de diversos objetos. As mais conhecidas são IComparable (implementa o método CompareTo) e IDisposable (implementa o método Dispose). Basta herdá-las, pois fazem parte do namespace “System”.</p>
]]></content:encoded>
			</item>
		<item>
		<title>Abstração em C#</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/abstracao-em-c</link>
		<pubDate>Tue, 09 Mar 2010 18:21:08 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Programação Orientada a Objetos em .NET]]></category>
		<category><![CDATA[Abstração]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=413</guid>
		<description><![CDATA[O conceito de abstração é na prática, criar modelos de classes abstratas para definição de classes a serem construídas. As características de uma classe abstrata são: não ser completamente implementada; deve ter o modificador “abstract”; métodos não implementados(abstratos) recebem o modificador “abstract”; a definição do método na classe derivada deve ter o modificador “override”; não &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/abstracao-em-c" class="more-link">Continue lendo <span class="screen-reader-text">Abstração em C#</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<p>O conceito de abstração é na prática, criar modelos de classes abstratas para definição de classes a serem construídas. As características de uma classe abstrata são:</p>
<ul>
<li> não ser completamente implementada;</li>
<li>deve ter o modificador “abstract”;</li>
<li>métodos não implementados(abstratos) recebem o modificador “abstract”;</li>
<li>a definição do método na classe derivada deve ter o modificador “override”;</li>
<li>não podem ser instanciadas diretamente;</li>
</ul>
<p>Por exemplo, você quer definir um modelo de objeto para um determinado aplicativo que todos os desenvolvedores deverão seguir. Você pode então definir uma classe somente com os campos, propriedades e a definição dos métodos que ela deve possuir, por exemplo:</p>
<pre lang="csharp" line="1">...
abstract class  MinhaClasseAbstrata
{
      protected int valor1;
      protected int valor2;
      protected decimal ValorTotal;
      // métodos não implementados
      public abstract void RecebeValores(int v1, int v2);
      public abstract void CalculaValores();
      // métodos implementados
      public void ImprimeValores()
      {
            Console.WriteLine("O valor total é: {0}", ValorTotal.ToString());
      }
}
...</pre>
<p>Isso nos dá um modelo de classe a ser construído. Na construção do aplicativo, bastaria definir que os desenvolvedores devem herdar essas classes abstratas (o que é possível) para a construção das classes a serem usadas no mesmo. Note que temos a implementação completa do método “ImprimeValores”. Isso nos dá a possibilidade de construir classes abstratas já com algumas implementações. Métodos definidos com a palavra chave “abstract” devem ser implementados na classe derivada ou o projeto não poderá ser compilado gerando um erro. </p>
<p>A classe abstrata acima deve ser herdada da de seguinte maneira:</p>
<pre lang="csharp" line="1">...
//declara a classe e herda a classe abstrata
class  MinhaClasse: MinhaClasseAbstrata
{    
      public override void RecebeValores(int v1, int v2)
      {
            // ...
      }
      public override void CalculaValores()
      {
            // ...
      }
}
...</pre>
]]></content:encoded>
			</item>
		<item>
		<title>Herança e métodos virtuais (Polimorfismo)</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/heranca-e-metodos-virtuais-polimorfismo</link>
		<pubDate>Tue, 09 Mar 2010 18:18:13 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Programação Orientada a Objetos em .NET]]></category>
		<category><![CDATA[Herança]]></category>
		<category><![CDATA[Polimorfismo]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=405</guid>
		<description><![CDATA[Supondo que quiséssemos promover novas implementações para métodos de uma classe base, na classe derivada, ou variações destes. Outra questão interessante oriunda do processo de herança é a compatibilidade de tipos de classe base de derivada. Algumas regras devem ser consideradas. O tipo da classe base é compatível com o da classe derivada, mas somente &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/heranca-e-metodos-virtuais-polimorfismo" class="more-link">Continue lendo <span class="screen-reader-text">Herança e métodos virtuais (Polimorfismo)</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<p>Supondo que quiséssemos promover novas implementações para métodos de uma classe base, na classe derivada, ou variações destes. Outra questão interessante oriunda do processo de herança é a compatibilidade de tipos de classe base de derivada. Algumas regras devem ser consideradas. </p>
<p>O tipo da classe base é compatível com o da classe derivada, mas somente podemos atribuir objetos do tipo derivada a um objeto do tipo base. O código abaixo exemplifica esse conceito:</p>
<pre lang="csharp" line="1">...
class Base
{
      ...
}
 
class Derivada: Base
{
      ...  
}
 
class MinhaClasse
{
      Static void Main()
      {    
            Base B = new Base();
            Derivada D = new Derivada()
            B = D; // Atribuição válida
            D = B; // Atribuição inválida
      }
}
...</pre>
<p>Tendo isso claro, vejamos como se comportam métodos na atribuição de classe de tipos compatíveis. Um caso a ser resolvido é muito típico: é o de métodos com mesmo nome. Veja um exemplo:</p>
<pre lang="csharp" line="1">using System;

public class Base
{
      public void EscreveNome()
      {
            Console.WriteLine("Base");
      }
}
 
public class Derivada1: Base
{
      public void EscreveNome()
      {
            Console.WriteLine("Derivada1");
      }
}
 
public class Derivada2: Base
{
      public void EscreveNome()
      {
            Console.WriteLine("Derivada2");
      }
}
public class MinhaClassePolimorfismo
{
      static void Main()
      {
            Derivada1 minhaDerivada1 = new Derivada1();
            Derivada2 minhaDerivada2 = new Derivada2();
            Base minhaBase;
            string valor;
            Console.WriteLine("Digite um valor");
            valor = Console.ReadLine();
 
            if (valor == "1")
                  minhaBase = minhaDerivada1;
            else
                  minhaBase = minhaDerivada2;
            minhaDerivada1.EscreveNome();
            minhaDerivada2.EscreveNome();
            minhaBase.EscreveNome();
      }
}</pre>
<p>Compile e veja a saída no console:</p>
<p><a href="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image042.jpg"><img src="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image042-300x151.jpg" alt="" title="image042" width="300" height="151" class="alignnone size-medium wp-image-406" srcset="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image042-300x151.jpg 300w, //www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image042.jpg 564w" sizes="(max-width: 300px) 100vw, 300px" /></a></p>
<p>O código compila, mas gera alguns avisos. Isso ocorre porque implementamos de maneira forçada método de mesmo nome da classe base na classe derivada. O jeito fácil de resolver o problema é preceder a declaração do método com o operados “new”:</p>
<pre lang="csharp" line="1">using System;
 
public class Base
{
      public void EscreveNome()
      {
            Console.WriteLine("Base");
      }
}
 
public class Derivada1: Base
{
      new public void EscreveNome()
      {
            Console.WriteLine("Derivada1");
      }
}
 
public class Derivada2: Base
{
      new public void EscreveNome()
      {
            Console.WriteLine("Derivada2");
      }
}
public class MinhaClassePolimorfismo
{
      static void Main()
      {
            Derivada1 minhaDerivada1 = new Derivada1();
            Derivada2 minhaDerivada2 = new Derivada2();
            Base minhaBase;
            string valor;
            Console.WriteLine("Digite um valor");
            valor = Console.ReadLine();
 
            if (valor == "1")
                  minhaBase = minhaDerivada1;
            else
                  minhaBase = minhaDerivada2;
            minhaDerivada1.EscreveNome();
            minhaDerivada2.EscreveNome();
            minhaBase.EscreveNome();
      }
}</pre>
<p>Ao compilar os avisos não são emitidos:</p>
<p><a href="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image044.jpg"><img src="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image044-300x151.jpg" alt="" title="image044" width="300" height="151" class="alignnone size-medium wp-image-407" srcset="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image044-300x151.jpg 300w, //www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image044.jpg 566w" sizes="(max-width: 300px) 100vw, 300px" /></a></p>
<p>Mas ainda temos um problema. Repare que tanto no primeiro resultado como neste último, apesar do valor informado ser 1, a última mensagem impressa se refere à classe base, apesar de termos atribuído à variável “minhaBase” a variável “minhaDerivada1”. Por que então não foi impressa a mensagem “Derivada1” ao invés de “Base”?</p>
<p>Tudo bem, classe base é base e ponto final, certo? Quase. A característica de <strong>polimorfismo</strong> nos permite “muitas formas” como já foi dito anteriormente. Através de um tipo ancestral, podemos obter diferentes comportamentos condicionalmente. Como fazer para que isso aconteça?</p>
<p>Para redefinir um método na classe derivada de forma que ele seja entendido por um objeto de classe base, estes métodos devem ser “virtuais”. A palavra chave “virtual” deve ser utilizada na declaração do método na classe base e a palavra chave “override” na declaração do método de mesmo nome da classe derivada. Veja a implementação de código a seguir:</p>
<pre lang="csharp" line="1">using System;
 
public class Base
{
      public virtual void EscreveNome()
      {
            Console.WriteLine("Base");
      }
}
 
public class Derivada1: Base
{
      public override void EscreveNome()
      {
            Console.WriteLine("Derivada1");
      }
}
 
public class Derivada2: Base
{
      <strong>public override void EscreveNome()</strong>
      {
            Console.WriteLine("Derivada2");
      }
}
public class MinhaClassePolimorfismo
{
      static void Main()
      {
            Derivada1 minhaDerivada1 = new Derivada1();
            Derivada2 minhaDerivada2 = new Derivada2();
            Base minhaBase;
            string valor;
            Console.WriteLine("Digite um valor");
            valor = Console.ReadLine();
 
            if (valor == "1")
                  minhaBase = minhaDerivada1;
            else
                  minhaBase = minhaDerivada2;
            minhaDerivada1.EscreveNome();
            minhaDerivada2.EscreveNome();
            minhaBase.EscreveNome();
      }
}</pre>
<p>Veja a saída após compilado o programa:</p>
<p><a href="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image046.jpg"><img src="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image046-300x151.jpg" alt="" title="image046" width="300" height="151" class="alignnone size-medium wp-image-408" srcset="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image046-300x151.jpg 300w, //www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image046.jpg 566w" sizes="(max-width: 300px) 100vw, 300px" /></a></p>
<p>Note que tornamos a saída condicional. Dependendo do valor digitado, a atribuição muda e o objeto de classe base entende a implementação do objeto de classe derivada. Sim, pois uma classe derivada também é uma classe base. Se fizermos uma analogia aos conceitos apresentados no início deste capítulo, poderemos chamar a classe base de “Animal” e as classes derivadas de “Cachorro” e “Gato”, por exemplo. Adaptando os conceitos aos exemplos, podemos dizer que o cachorro e gato são animais. Veja a o código implementado sob esta ótica:</p>
<pre lang="csharp" line="1">using System;
 
public class Animal
{
      public virtual void EscreveNome()
      {
            Console.WriteLine("Sou um Animal");
      }
}
 
public class Cachorro: Animal
{
      public override void EscreveNome()
      {
            Console.WriteLine("Sou um Cachorro");
      }
}
 
public class Gato: Animal
{
      public override void EscreveNome()
      {
            Console.WriteLine("Sou um Gato");
      }
}

public class minhaClassePolimorfismo
{
      static void Main()
      {
            Cachorro meuCachorro = new Cachorro();
            Gato meuGato = new Gato();
            Animal meuAnimal;
            string valor;
            Console.WriteLine("Digite um valor");
            valor = Console.ReadLine();
 
            if (valor == "1")
                  meuAnimal = meuCachorro;
            else
                  meuAnimal = meuGato;
            meuCachorro.EscreveNome();
            meuGato.EscreveNome();
            meuAnimal.EscreveNome();
      }
}</pre>
<p>Veja a saída no console:</p>
<p><a href="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image048.jpg"><img src="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image048-300x150.jpg" alt="" title="image048" width="300" height="150" class="alignnone size-medium wp-image-409" srcset="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image048-300x150.jpg 300w, //www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image048.jpg 567w" sizes="(max-width: 300px) 100vw, 300px" /></a></p>
<p>Este exemplo deixa mais claro o conceito de implementação, uso e entendimento de polimorfismo. </p>
<p>Veremos agora um uso mais prático de métodos virtuais. Uma das implementações sobrecarregadas no método Console.WriteLine recebe um object como parâmetro. Dessa forma, podemos passar qualquer objeto já que qualquer tipo herda de object e é automaticamente compatível com este. Quando se passa um object para este método, ele automaticamente faz uma chamada ao método “ToString” da classe object. O método “ToString” é declarado como “virtual” e portanto pode ser sobrescrito usando a palavra chave “override”. Veja um exemplo:</p>
<pre lang="csharp" line="1">using System;
 
class Polegadas
{
      decimal valorMetros;

      public Polegadas(decimal v)
      {
            valorMetros = v * 100/2.54M;
      }
 
      public void ConverteMetros(decimal v)
      {
            valorMetros = v * 100/2.54M;      
      }
 
      public override string ToString()
      {
            return "O valor em metros é: " + valorMetros.ToString();
      }
}
 
class MinhaClasse
{
      static void Main()
      {
            Polegadas p = new Polegadas(100M);
            Console.WriteLine(p.ToString());
      }
}</pre>
<p>Veja a saída no console:</p>
<p><a href="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image050.jpg"><img src="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image050-300x150.jpg" alt="" title="image050" width="300" height="150" class="alignnone size-medium wp-image-410" srcset="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image050-300x150.jpg 300w, //www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image050.jpg 567w" sizes="(max-width: 300px) 100vw, 300px" /></a></p>
<p>Se mesmo com uma nova implementação (“override”) quisermos ter acesso ao método da classe base, é possível faze-lo através da palavra reservada “base”, porém, seu uso é diferenciado dos construtores. Veja um exemplo:</p>
<pre lang="csharp" line="1">using System;
 
public class Animal
{
      public virtual void EscreveNome()
      {
            Console.WriteLine("Sou um Animal");
      }
}
 
public class Cachorro: Animal
{
      public override void EscreveNome()
      {
            Console.WriteLine("Sou um Cachorro");
      }
}
 
public class Gato: Animal
{
      // redefine o método EscreveNome
      public override void EscreveNome()
      {
            Console.WriteLine("Sou um Gato");
            //chama o método EscreveNome da classe base
            Base.EscreveNome();
      }
}</pre>
]]></content:encoded>
			</item>
		<item>
		<title>Herança com construtores</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/heranca-com-construtores</link>
		<pubDate>Tue, 09 Mar 2010 17:02:51 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Programação Orientada a Objetos em .NET]]></category>
		<category><![CDATA[Construtores]]></category>
		<category><![CDATA[Herança]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=400</guid>
		<description><![CDATA[Como já dito, no processo de herança somente o construtor sem parâmetros é herdado. O código de exemplo mostra o processo de uso dos construtores: using System; public class Base { public Base() { Console.WriteLine("Estou no construtor da classe base"); } } //declara a classe derivada herdando a classe base public class Derivada: Base { &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/heranca-com-construtores" class="more-link">Continue lendo <span class="screen-reader-text">Herança com construtores</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<p>Como já dito, no processo de herança somente o construtor sem parâmetros é herdado. O código de exemplo mostra o processo de uso dos construtores:</p>
<pre lang="csharp" line="1">using System;
 
public class Base
{
      public Base()
      {
            Console.WriteLine("Estou no construtor da classe base");
      }
}
 
//declara a classe derivada herdando a classe base
public class Derivada: Base
{
      public Derivada()
      {
            Console.WriteLine("Estou no construtor da classe derivada");
      }
}
 
public class MinhaClasse
{
      static void Main()
      {
            // objeto da classe base executando o construtor
            Base minhaBase = new Base();
            // objeto da classe derivada executando o construtor
            Derivada minhaDerivada = new Derivada();
 
      }
}</pre>
<p>Compile e veja a saída no console:</p>
<p><a href="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image038.jpg"><img src="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image038-300x151.jpg" alt="" title="image038" width="300" height="151" class="alignnone size-medium wp-image-401" srcset="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image038-300x151.jpg 300w, //www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image038.jpg 566w" sizes="(max-width: 300px) 100vw, 300px" /></a></p>
<p>Note que o construtor sem parâmetros da classe base foi automaticamente herdado. O 1º texto se refere à criação do objeto “minhaBase” e os seguintes se referem à criação do objeto “minhaDerivada”. No momento da criação do objeto “minhaDerivada”, foram executados o construtor da classe base e o construtor da classe derivada. Se quisermos herdar os outros construtores, devemos criar um equivalente na classe derivada e evocar o construtor da classe base com a palavra chave “base” passando os parâmetros necessários. O código abaixo exemplifica a chamada de um construtor de classe base através da classe derivada:</p>
<pre lang="csharp" line="1">using System;
 
public class Base
{
      public Base()
      {
            Console.WriteLine("Estou no 1º construtor da classe base");
      }
      public Base(int valor)
      {
            Console.WriteLine("Estou no 2º construtor da classe base");
      }
}
 
public class Derivada: Base
{
      // declara o construtor da classe derivada herdando o construtor da classe base
      public Derivada(): base()
      {
            Console.WriteLine("Estou no 1º construtor da classe derivada");
      }
     // declara o construtor da classe derivada herdando o construtor da classe base. Como o construtor da classe base exige um parâmetro, este é passado no pelo lista de parâmetros do próprio contrutor
      public Derivada(int valor): base(valor)
      {
            Console.WriteLine("Estou no 2º construtor da classe derivada");
      }
}
 
public class MinhaClasse
{
      static void Main()
      {
            // objeto da classe base executando o 1º construtor
            Base minhaBase1 = new Base();
            // objeto da classe base executando o 2º construtor
            Base minhaBase2 = new Base(1);
            // objeto da classe derivada executando o 1º construtor
            Derivada minhaDerivada1 = new Derivada();
            // objeto da classe derivada executando o 2º construtor
            Derivada minhaDerivada2 = new Derivada(1);
      }
}</pre>
<p>Compile e veja a saída no console:</p>
<p><a href="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image040.jpg"><img src="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image040-300x151.jpg" alt="" title="image040" width="300" height="151" class="alignnone size-medium wp-image-402" srcset="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image040-300x151.jpg 300w, //www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image040.jpg 566w" sizes="(max-width: 300px) 100vw, 300px" /></a></p>
<p>As duas primeiras saídas se referem à criação do objeto “minhaBase1” e “minhaBase2”, as duas seguintes se referem à criação do objeto “minhaDerivada1”, e as duas últimas, ao objeto “minhaDerivada2”.</p>
]]></content:encoded>
			</item>
		<item>
		<title>Herança em C#</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/heranca-em-c</link>
		<pubDate>Tue, 09 Mar 2010 15:40:58 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Programação Orientada a Objetos em .NET]]></category>
		<category><![CDATA[Herança]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=397</guid>
		<description><![CDATA[O mecanismo de herança do .NET obedece aos critérios definidos nos conceitos de herança já citados e não prevê herança múltipla de classes, processo contornado pelas interfaces. Para herdar classes em C#, deve-se utilizar o símbolo ”:” após a declaração da classe, por exemplo: ... class Base { // ... } // Declara e herda &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/heranca-em-c" class="more-link">Continue lendo <span class="screen-reader-text">Herança em C#</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<p>O mecanismo de herança do .NET obedece aos critérios definidos nos conceitos de herança já citados e não prevê herança múltipla de classes, processo contornado pelas interfaces. Para herdar classes em C#, deve-se utilizar o símbolo ”:” após a declaração da classe, por exemplo:</p>
<pre lang="csharp" line="1">...
class Base
{
      // ...
}

// Declara e herda a classe Base
class Derivada: Base
{
      // ...
}
...</pre>
<p>Com esse recurso, praticamente todos os membros da classe base passarão a fazer parte da classe derivada. Existem algumas ressalvas no processo de herança que devem ser consideradas:</p>
<ul>
<li> membros private não são herdados;</li>
<li>somente o construtor sem parâmetros (se houver) é herdado;</li>
<li>todas as classes derivam de object, portanto, a classe herdada e a derivada conterão os membros de object;</li>
<li>não é permitido eliminar uma funcionalidade já existente, mas é possível redefini-la;</li>
<li>para redefinir métodos de classes bases, estes devem ser virtuais;</li>
</ul>
]]></content:encoded>
			</item>
		<item>
		<title>Construtores e Destrutores em C#</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/construtores-e-destrutores-em-c</link>
		<pubDate>Tue, 09 Mar 2010 15:37:21 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Programação Orientada a Objetos em .NET]]></category>
		<category><![CDATA[Contrutores]]></category>
		<category><![CDATA[Destrutores]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=391</guid>
		<description><![CDATA[Construtores são métodos executados na criação da classe. As regras para definição de um construtor são: o construtor deve ter o mesmo nome da classe; não tem tipo de retorno; é executado apenas um, apenas uma vez, no momento da criação do objeto; não pode ser chamado diretamente; deve ser “public”; Um construtor “private” não &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/programacao_orientada_objetos_net/construtores-e-destrutores-em-c" class="more-link">Continue lendo <span class="screen-reader-text">Construtores e Destrutores em C#</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<p>Construtores são métodos executados na criação da classe. As regras para definição de um construtor são:</p>
<ul>
<li> o construtor deve ter o mesmo nome da classe;</li>
<li>não tem tipo de retorno;</li>
<li>é executado apenas um, apenas uma vez, no momento da criação do objeto;</li>
<li>não pode ser chamado diretamente;</li>
<li>deve ser “public”;</li>
</ul>
<p>Um construtor “private” não permite que a classe seja criada ou instanciada. Isso pode ser conveniente em alguns aspectos, por exemplo, se a classe contiver somente membros “static”.</p>
<p>Tirando essas regras, os construtores são como os métodos convencionais e podem ser sobrecarregados e conter parâmetros. A função dos construtores é inicializar ou dar forma à classe. É nele que indicamos os valores dos campos de uma classe. Esses valores podem ser internos (no código) ou externos (passados por parâmetros). Veremos a implementação de construtores na classe “MinhaClasse” com que vínhamos trabalhando até então. Crie um novo arquivo chamado “exemploContrutor.cs” e digite o código abaixo:</p>
<pre lang="csharp" line="1">// cria um alias para facilitar o acesso aos membros do System
using System;

// Cria a nossa classe de exemplo
class MinhaClasse
{
      //cria o contrutor da classe
      public MinhaClasse()
      {
            Console.WriteLine("Estamos no construtor");
      }

}

// classe para execução do aplicativo
class Class1
{
      static void Main()
      {
            // cria uma nova instância da classe MinhaClasse
            MinhaClasse obj = new MinhaClasse();
      }
}</pre>
<p>Compile e veja o resultado:</p>
<p><a href="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image032.jpg"><img class="alignnone size-medium wp-image-392" title="image032" src="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image032-300x151.jpg" alt="" width="300" height="151" srcset="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image032-300x151.jpg 300w, //www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image032.jpg 566w" sizes="(max-width: 300px) 100vw, 300px" /></a></p>
<p>Note que foi preciso apenas criar a classe para que o construtor fosse executado. Modifique agora o código para o seguinte:</p>
<pre lang="csharp" line="1">// cria um alias para facilitar o acesso aos membros do System
using System;

// Cria a nossa classe de exemplo
class MinhaClasse
{
      //campos da classe
      int v1, v2;
      //cria o contrutor da classe
      public MinhaClasse()
      {
            v1 = 1;
            v2 = 2;
      }

      public MinhaClasse(int p1, int p2)
      {
            v1 = p1;
            v2 = p2;
      }

      public void ImprimeValores()
      {
            Console.WriteLine("O valor de v1 e: {0} e v2 = {1}", v1, v2);
      }

}

// classe para execução do aplicativo
class Class1
{
      static void Main()
      {
            // Esta instância executa o primeiro construtor
            MinhaClasse obj1 = new MinhaClasse();
            // Esta instância executa o segundo construtor
            MinhaClasse obj2 = new MinhaClasse(10, 20);
            obj1.ImprimeValores();
            obj2.ImprimeValores();
      }
}</pre>
<p>Compile e veja a saída do Console:</p>
<p><a href="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image034.jpg"><img class="alignnone size-medium wp-image-393" title="image034" src="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image034-300x150.jpg" alt="" width="300" height="150" srcset="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image034-300x150.jpg 300w, //www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image034.jpg 567w" sizes="(max-width: 300px) 100vw, 300px" /></a></p>
<p>Como os valores de v1 e v2 são acessíveis somente à classe, colocá-los para serem inicializados no construtor é uma alternativa eficiente para garantir a integridade dos valores e do objeto criado, além oferecer mais opções para a criação e utilização de uma classe.</p>
<p>Os destrutores são métodos que são executados automaticamente quando o objeto não é mais utilizado e referenciado. A definição de um destrutor segue as seguintes regras:</p>
<ul>
<li>Assim como o construtor, não pode ser chamado diretamente;</li>
<li>não tem tipo de retorno;</li>
<li>tem o mesmo nome da classe precedido de “~”;</li>
<li>não pode conter parâmetros;</li>
<li>não pode ser sobrecarregado;</li>
<li>não é herdado (processo de herança de classes);</li>
</ul>
<p>Alguns problemas cercam o destrutores nas linguagens do .NET. Os destrutores foram concebidos principalmente para liberação de memória, processo que deveria ser feito manualmente pelo programador em linguagens como C e C++. Como no .NET a memória é gerenciada pelo “Garbage Collector”, não temos controle de quanto o destrutor será executado. Um exemplo de destrutor é dado no código abaixo:</p>
<pre lang="csharp" line="1">// cria um alias para facilitar o acesso aos membros do System
using System;
 
// Cria a nossa classe de exemplo
class MinhaClasse
{
      //cria o construtor da classe
      public MinhaClasse()
      {
            Console.WriteLine("Estamos no construtor");
      }
 
      //cria o destrutor da classe
      ~MinhaClasse()
      {
            Console.WriteLine("Estamos no destrutor");
      }
 
 
}
 
// classe para execução do aplicativo
class Class1
{
      static void Main()
      {
            // cria uma nova instância da classe MinhaClasse
            MinhaClasse obj = new MinhaClasse();
      }
}</pre>
<p>Compile e veja a saída no console:</p>
<p><a href="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image036.jpg"><img src="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image036-300x151.jpg" alt="" title="image036" width="300" height="151" class="alignnone size-medium wp-image-394" srcset="//www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image036-300x151.jpg 300w, //www.tomasvasquez.com.br/cursocsharp/wp-content/uploads/2010/03/image036.jpg 566w" sizes="(max-width: 300px) 100vw, 300px" /></a></p>
<p>Apesar de quase instantâneo, neste caso, não podemos prever a execução do destrutor. Na prática, é melhor deixar o trabalho com o Garbage Collector.</p>
]]></content:encoded>
			</item>
	</channel>
</rss>
