Desenvolvedores.Net - TechBlog

Tag Archives: Classes

Herança (POO)

6
1 Estrela2 Estrelas3 Estrelas4 Estrelas5 Estrelas (6 votos, média: 4,83 de 5)
Loading...
29 de janeiro de 2011
Para um melhor entendimento deste Artigo veja o Índice (Programação Orientada a Objetos)

Herança

Iremos entrar agora em um tópico que teremos muito o que discutir. Tentarei ser o mais simples , claro e objetivo.
Mas antes de falarmos sobre herança, iremos falar sobre a hierarquia das classes.

Hierarquia

Quando vamos trabalhar com muitas classes, temos que ter em mente a hierarquia (ordem) que estas classes deverão seguir.

Por exemplo:

Não poderemos ter os filhos antes dos pais e antes dos avós. A hierarquia correta para este tipo de classe seria:

Avô -> Pai -> Filho



(quando ví esta imagem, não resisti. Serve perfeitamente para o exemplo de hierarquia)

Assim temos a hierarquia bem definida dentro de nossas classes.

Transformando isso em programação teríamos generalização e especialização.

Como foi visto, a classe mais ao topo da hierarquia é a generalização, enquanto a última classe é a mais especializada.
No diagrama de seqüencia abaixo, podemos ver que as classes mais a esquerda são as genéricas e as mais a direita são as especializadas.

Agora vamos tratar dos tipos de herança que podemos ter.

Herança de Implementação

A herança de implementação é aquela onde herdamos todo o código da classe Pai, não precisamos reescrever código para utilizá-lo, estamos falando de reutilização de código.

Caso desejamos subsitituir um método da classe pai devemos usar overriding, como foi discutido em Definição (Intermediário).

Creio que a herança de implementação é a mais usada, pois herda a assinatura e os métodos da classe pai.

Herança de Interface

Caso não conheçam Interface e Abstração leiam este tópico.

A herança de interface é útil quando precisamos:

  • agrupar as nossas classes dentro de um mesmo contexto;
  • Na programação genérica (veja: Tipos Genéricos (Generics) );
  • Outros que vocês irão descobrir com o tempo;

Na herança de interface apenas herdamos as assinaturas de métodos e propriedades ao contrário da herança de implementação que além de herdar  as assinaturas herdamos também seu código, logo, no caso da interface temos que escrever o código do método ou propriedade.

Agregação

A agregação define uma dependência fraca entre as classes, isto quer dizer que os outros objetos continuam existindo mesmo que o todo for removido.
Podemos dizer que uma classe agregada (o todo) é montada com um conjunto de componentes (as partes).

Como exemplo vamos usar um carro.
Em nosso carro (classe agregada, o todo) temos os componentes (as partes), rodas, portas, motor.
Se desmontarmos o carro, as partes (rodas, portas, motor) continuaram a existir e poderão ser usadas em outro carro.

Composição

A composição define uma dependência forte entre as classes, isto quer dizer que se o todo deixar de existir as suas partes também deixaram de existir.

Exemplo:
Uma revista em quadrinhos, ela é composta por suas páginas. Se o todo, a revista, deixar de existir, suas páginas não farão sentido.

Como outro exemplo podemos citar um pedido e seus itens. Esta ligação é forte, logo é uma composição. Os itens não fariam sentido sem o Pedido. Se excluirmos o pedido seus itens serão excluídos. (Isto não te lembra um relacionamento feito em definição de tabelas? 1 para n ON DELETE CASCADE).

Para finalizarmos vamos colocar um diagrama de classes e um código para reforçar a idéia.

Diagrama acima convertido em código:

Interface IPessoa

namespace Heranca
{
    /// <summary>
    /// esta é uma interface.
    /// Percebam que declaramos apenas os métodos,
    /// iremos usar neste caso a herança de interface
    /// </summary>
    interface IPessoa
    {
        void Dancar();
        DateTime DataNascimento { get; set; }
        void Envelhecer();
        void Falar();
        int Idade { get; }
        string Nome { get; set; }
        Sexo Sexo { get;  }
    }
}

Classe Pessoa

namespace Heranca
{
    public enum Sexo
    {
        NaoDefinido,
        Masculino,
        Feminino
    }

    /// <summary>
    /// esta classe é uma classe genérica pra todo tipo de pessoa.
    /// vejam que aqui iremos herdar a interface IPessoa,
    /// neste caso será uma herança de interface.
    /// Devemos escrever código para todo método e propriedade
    /// definido na interface.
    /// </summary>
    abstract class Pessoa : IPessoa
    {
        /// <summary>
        /// esta propriedade poderá ser sobreescrita
        /// nas classes filhas. mas não é obrigatória
        /// </summary>
        public virtual int Idade
        {
            get
            {
                int idade = DateTime.Now.Year - DataNascimento.Year;
                if (DateTime.Now.Month < DataNascimento.Month ||
                (DateTime.Now.Month == DataNascimento.Month &&
                DateTime.Now.Day < DataNascimento.Day))
                    idade--;
                return idade;
            }
        }

        public DateTime DataNascimento { get; set; }

        /// <summary>
        /// esta propriedade deverá obrigatoriamente ser declarada
        /// na classe pai
        /// </summary>
        public abstract Sexo Sexo { get; }

        public virtual String Nome { get; set; }

        public virtual void Envelhecer()
        {
            DataNascimento = DataNascimento.AddYears(1);
            Console.WriteLine("A pessoa envelheceu um ano.");
        }

        public virtual void Dancar()
        {
            Console.WriteLine("A pessoa está dançando");
        }

        public virtual void Falar()
        {
            Console.WriteLine(@"A pessoa disse: visitem
            http://desenvolvedores.net");
        }
    }
}

Classe Pai

namespace Heranca
{
    /// <summary>
    /// Aqui iremos herdar a classe pessoa.
    /// vejam que apenas escrevi a propriedade Sexo.
    /// Pois na classe pai (abstrata) estava definido
    /// que as filhas deveria escrever o código para sexo.
    /// Mas as outras propriedades e métodos serão herdados de pessoa
    /// </summary>
    class Pai : Pessoa
    {
        public override Sexo Sexo { get { return Sexo.Masculino; } }

        /// <summary>
        /// este método poderá ser sobreescrito nas classes filhas
        /// neste caso o pai está apenas brincando.
        /// Veremos ele sobreescrito na classe filha
        /// </summary>
        public virtual void Brincar()
        {
            Console.WriteLine("O pai está brincando");
        }
    }
}

Classe Filho

namespace Heranca
{
    /// <summary>
    /// aqui o filho herdou todas as características do pai
    /// </summary>
    class Filho : Pai
    {

        /// <summary>
        /// aqui iremos substituir o método Brincar
        /// </summary>
        public override void Brincar()
        {
            Console.WriteLine("O filho está brincando com seu pai.");
        }
    }
}

Classe Aluno

namespace Heranca
{
    /// <summary>
    /// mais um classe que herda de pessoa
    /// </summary>
    class Aluno : Pessoa
    {
        public override Sexo Sexo
        {
            get { return Sexo.Feminino; }
        }

        public int VerNota()
        {
            return new Random().Next(0, 10);
        }
    }
}

E finalmente o código escrito em uma aplicação do tipo console.
Atenção, prestem bastante atenção aos comentários, eles têm dicas importantes.

namespace Heranca
{
    class Program
    {
        static void Main(string[] args)
        {
            /*
             * aqui vai um dica útil.
             * Cuidado ao declarar o seu tipo de objeto
             * pois as propriedades e métodos que você
             * irá visualizar depende do tipo declarado
             *
             * Vejam aqui, vou declarar como um objeto Pessoa
             * mas vou instanciar como um Aluno
             */

            Pessoa pessoaAluno = new Aluno();

            pessoaAluno.Nome = "Marcelo";

            /*
             * reparem que o método VerNota() só existe
             * na classe Aluno, logo na linha 17,
             * mesmo o objeto sendo instanciado como
             * new Aluno() seus métodos só existirão
             * através do seu tipo definido Pessoa
             */

            Console.WriteLine(pessoaAluno.Nome);

            /*
             * Mas, e se precisarmos acessar
             * os dados de Aluno?
             * Simplesmente faça um cast (conversão)
             * de um objeto para outro
             * Vejam:
             */

            Aluno aluno = pessoaAluno as Aluno;

            Console.WriteLine(aluno.VerNota());

            /*
             * A dica acima é válida tambem para os tipos
             * interfaces
             */

            IPessoa pessoaFilho = new Filho();
            pessoaFilho.Falar();

            Filho filho = pessoaFilho as Filho;
            filho.Brincar();

            /*
             * Abaixo um exemplo do override em filho
             */

            Pai pai = new Pai();

            //aqui chamamos o método brincar de Pai
            pai.Brincar();

            //aqui chamamos o método brincar que foi substituido
            Filho meuFilho = new Filho();
            meuFilho.Brincar();

            /*
             * Legal. Mas posso chamar o método
             * Brincar da classe base?
             */

            pai = filho as Pai;
            pai.Brincar();

            /*
             * Não. Não podemos.
             * Apesar da instrução acima não dar erro
             * o método que será chamado é sempre
             * o método substituído.
             *
             * Mas a afirmação acima não é 100% correta.
             * Se em nossa classe Filho o método tivesse
             * sido declarado assim:
             * public new void Brincar()
             * O método chamado seria o da classe Pai,
             * pois neste caso não substituimos o método
             * e sim criamos um novo.
             *
             * Vejam as duas declarações juntas para comparar
             *
             * public new void Brincar()
             * public override void Brincar()
             */

            Console.ReadKey();

        }
    }
}

Ver Índice

É isso ai pessoal 🙂
Até o próximo
♦ Marcelo

About Marcelo

Nascido em Juruaia/MG em uma fazenda de criação de búfalos, e residindo na região Sul do Brasil. Trabalha com desenvolvimento de aplicações desde os 17 anos. Atualmente é Arquiteto Organizacional na Unimake Software. Para saber mais ... http://desenvolvedores.net/marcelo []'s

Encapsulamento (POO)

1
1 Estrela2 Estrelas3 Estrelas4 Estrelas5 Estrelas (Sem votação.)
Loading...
17 de janeiro de 2011
Para um melhor entendimento deste Artigo veja o Índice (Programação Orientada a Objetos)

Entenda como encapsulamento o ato de proteger características de nossos objetos, isto quer dizer que o que não for público estará protegido de ação externa.

Como exemplo iremos pegar um motor. Não precisamos saber o funcionamento dele, apenas temos que saber que o método Ligar() da nossa classe Motor irá fazer com que o nosso motor entre em funcionamento.

Mas não precisamos saber quais componentes o método irá acessar, modificar ou criar para que o nosso motor entre em funcionamento.

O que o método ligar faz, não nos diz respeito, apenas usamos e sabemos que vai funcionar.

No conceito de orientação a objetos podemos proteger aquilo que não queremos que sofram intervenção, nossas variáveis locais, nossos métodos e atributos.

Os dados protegidos só podem ser alterados dentro dos métodos em que foram declarados ou dentro do objeto a que eles pertencem.

Exemplo:

namespace Desenvolvedores.Net.Encapsulamento
{
 public class Motor
 {
 /*
 * Aqui podemos apenas recuperar o valor de Ligado.
 * Mas percebam que para modificar o motor para Ligado
 * não iremos conseguir fazer isso pois a propriedade
 * está como Private, logo podemos dizer que está
 * encapsulada.
 * Só iremos conseguir modificar este valor
 * internamente, dentro desta classe.
 */
 public bool Ligado { get; private set; }

 public void Ligar()
 {
 //variável declarada localmente.
 //podemos dizer que está encapsulada dentro
 //do método Ligar e é acessível
 //somente dentro deste método
 bool temGasolina = TemGasolina();

 if (temGasolina)
 /*
 * aqui modificamos a propriedade Ligado para verdadeiro.
 * Veja que só podemos alterar por aqui ou outro
 * método dentro deste objeto e nunca externamente.
 */
 Ligado = true;
 }

 /*
 * Este método está encapsulado, pois está acessível apenas
 * dentro desta classe (objeto)
 */
 private bool TemGasolina()
 {
 return true;
 }

public override string ToString()
 {
 if (Ligado)
 return "O motor está ligado.";
 else
 return "O motor está desligado.";
 }
 }

 class Program
 {
 static void Main(string[] args)
 {
 Motor motor = new Motor();

 Console.WriteLine(motor.ToString());

 motor.Ligar();

 Console.WriteLine(motor.ToString());

 //se tentarmos forçar o motor a ser ligado iremos
 //receber um erro do compilador:
 //Erro em C#
 //The property or indexer 'Encapsulamento.Motor.Ligado'
 //cannot be used in this context because the
 //set accessor is inaccessible

 motor.Ligado = true;

 Console.ReadKey();
 }
 }
}

Ver Índice

É isso ai pessoal 🙂
Até o próximo
♦ Marcelo

About Marcelo

Nascido em Juruaia/MG em uma fazenda de criação de búfalos, e residindo na região Sul do Brasil. Trabalha com desenvolvimento de aplicações desde os 17 anos. Atualmente é Arquiteto Organizacional na Unimake Software. Para saber mais ... http://desenvolvedores.net/marcelo []'s

Definições – Básico (POO)

3
1 Estrela2 Estrelas3 Estrelas4 Estrelas5 Estrelas (10 votos, média: 5,00 de 5)
Loading...
17 de dezembro de 2010
Para um melhor entendimento deste Artigo veja o Índice (Programação Orientada a Objetos)
Nós, como seres humanos distinguimos estes objetos em três formas de pensamento: 

  • Diferenciação;
  • Distinção entre o todo e a parte;
  • Classificação;

Vemos nestas três formas, dentro da orientação a objetos, uma forma de diminuir a diferença semântica entre o que é real e o que é modelo.

O “homenzinho” acima é chamado de stickman.
É a representação dentro de um UseCase (UML)

O que é um objeto?
Podemos dizer que um objeto é algo quem tem características, ações, possui comportamento, uma identidade, distingui-se um do outro.
Os objetos podem ser físicos:
Um carro, uma casa, um pessoa, um cachorro …
Um conceito:
Um organograma, uma idéia …
Uma entidade:
Um botão, uma combobox, uma planilha Excel® …

O conjunto de ações, qualidades, as mudanças deste objeto influenciam no seu comportamento..
Podemos traduzir para a OO os termos, ações, qualidades, mudanças e comportamento da seguinte forma:

  • Ações:
    • O que o objeto faz, o verbo. Estes serão nossos Métodos.
      • Ex: Andar, Falar, Comer, Quebrar, Salvar.
  • Qualidades:
    • Serão nossos adjetivos, qualificam nossos objetos. Estes serão nossas Propriedades.
      • Ex: Cor, Tipo, Inquebrável, Esfomeado.
  • Mudanças:
    • Estas serão responsáveis por definir o Estado do nosso objeto.
    • Estes por sua vez podem se modificar ao longo do tempo.
      • Ex: Com fome, Andando, Quebrando, Comendo.
  • Comportamento:
    • O comportamento determina como este objeto responde às mudanças de suas qualidades e as ações que ele pode realizar.
      • Ex: João está com fome* porque é esfomeado**, logo ele tem que comer***.
        * com fome: Mudança de estado;
        ** esfomeado: Qualidade, adjetivo;
        *** comer: Ação, verbo
        Logo o comportamento do João pode modificar-se pelo fato de estar com fome.

Instância de um Objeto:
Imagine que temos o objeto Pessoa,  este objeto apenas representa uma pessoa, mas se quisermos dar uma identidade a este objeto temos que instanciá-lo, seria como dizer, trazer esta pessoa à vida, criar um novo objeto, um novo carro, um novo botão, uma nova planilha.

Classes:
Uma classe é a descrição (código) de um grupo de objetos com propriedades, comportamento, relacionamentos com outros objetos (associações e agregações).
Um objeto é uma instância de uma classe.

Modificadores deAcesso e Visibilidade:
Os modificadores, como o próprio nome diz, modificam as declarações de propriedades, métodos e classes, eles podem ser:

C# Java Descrição
Public Public Declaram queo método, propriedade ou classe é publica.
Isso quer dizer que está acessível a todos.

//declaração daclasse
public class Pessoa
{
//em uma propriedade
public string Nome { get; set; }

//em um método
public void Comer()
{
}
}
Private Private Declaram que o método, propriedade ou classe é privativo.
Isso quer dizer que está acessível apenas localmente.
Dentro do mesmo objeto.

//declaração daclasse
private class Pessoa
{
//em umapropriedade
private string Nome { get; set; }

//em um método
private void Comer()
{
}
}
Static Static Declaram quea classe não precisa ser instanciada.
Isso quer dizer que não é preciso criar um “novo” objeto,
podemos simplesmente chamar seus métodos e propriedades.

//declaração daclasse
public static class Pessoa
{
//em uma propriedade
public static string Nome { get; set; }

//em um método
public static void Comer()
{
}
}
Const Final Declara um variável constante.
Isso quer dizer que seuvalor não pode ser modificado.

public class Pessoa
{
public const string CPF = "000.000.000-00";
}
Sealed Final Uma classe “selada” não pode ser modificada nem herdada.

//declaração daclasse
public sealed class Pessoa
{
public string Nome { get; set; }

public void Comer()
{
}
}
Internal Package Apenas as classes que fazem parte do mesmo assembly
(executável, DLL) podem acessar esta classe ou método.
No caso do Java as que fazem parte do mesmo “Pacote”.

//na declaração daclasse
internal class Pessoa
{
//na declaração de uma propriedade
internal string Nome { get; set; }

//na declaração deum método
internal void Comer()
{
}
}
Protected Protected Apenas as classes filhas podem herdar estes métodos.
É visível apenas na classe pai e nas filhas.
Não são visíveis publicamente.

public class Pessoa
{
//na declaração de uma propriedade
protected string Nome { get; set; }

//na declaração deum método
protected void Comer()
{
}
}
Internal  Protected É a junção de Internal e Protected.
Isso quer dizer que apenas as classes do mesmo assembly
podemver seus métodos e herdar  suas características.

class Pessoa
{
//na declaração de uma propriedade
internal protected string Nome { get; set; }

//na declaração deum método
internal protected void Comer()
{
}
}
Abstract Abstract Declaram quea classe ou método será abstrato.
Isso quer dizer que o método deverá ser implementado na classe filha.
Classes abstratas não podem ser criados como
“novo objeto” só podem ser herdadas.

//na declaração daclasse
abstract class Pessoa
{
//na declaração de uma propriedade
public abstract string Nome { get; set; }

//na declaração de um método
public abstract void Comer();
}
Interface Interface Declara quea classe possui apenas a assinatura dos métodos e propriedades.
Todos os seus métodos e propriedades deverão ser implementados.

//na declaração da interface
public interface Pessoa
{
//interface apenas implementam a
//assinatura da propriedade
string Nome { get; set; }

//interface apenas implementam a
//assinatura dos métodos
void Comer();
}
Virtual Virtual Declara que o método/ propriedade pode ser sobrescrito (override)

//na declaração daclasse
public class Pessoa
{
//na declaração da propriedade
public virtual string Nome { get; set; }

//na declaração do método
public virtual void Comer() { }
}
Void Void Indica que o método não tem retorno.

public class Pessoa
{
//na declaração do método indica que
//não tem retorno
public virtual void Comer() { }

//Este método tem retorno não podemos
//usar o VOID e sim o tipo de retorno
public virtual Boolean Sonhar()
{
//retorna true se foi possível sonhar
return true;
}
}

Com isso temos uma visão geral dos modificadores mais comuns. Claro. Posso ter esquecido de alguns. 🙂
Estes modificadores podem ser combinados de acordo com a necessidade. Mas isso você irá aprender com o tempo, aqui o intuito é explicar o que são eles e para que servem.

Construtores e Destrutores:
O construtor é um método utilizado para inicializar os objetos da classe quando estes são criados.
Este método possui o mesmo nome da Classe e não tem nenhum tipo de retorno, nem mesmo void.
No construtor podemos iniciar todos os outros objetos e propriedades, ele será sempre chamada ao iniciar o objeto.

O destrutor é chamado quando o objeto é descarregado da memória.
Neste método podemos descarregar todos os outros objetos que usamos durante o tempo de vida da classe em memória

public class Pessoa
{
//o Nome da pessoa será iniciado quando construtor for chamado
public string Nome { get; set; }

//construtor sem parâmetros
public Pessoa()
{
//aqui o nome da pessoa é vazio
Nome = "";
}

//construtor com parâmetros
public Pessoa(string _nome)
{
//aqui o nome da pessoa é o mesmo do parâmetro _nome
Nome = _nome;
}

//aqui o destrutor
~Pessoa()
{
//podemos limpar os nossos objetos
Nome = null;
}
}

Atributo e Propriedade:
Muitas pessoas dizem que atributos e propriedades são às mesmas coisas. Eu costumo dizer que não.
Atributos são variáveis que guardam os valores das propriedades, e as propriedades são as qualidades de nossas classes visíveis ao mundo externo.
Veja:

public class Pessoa
{
//esta declaração é um atributo, pois armazena o valor da propriedade Nome
//normalmente são visíveis apenas local.
private string mNome = "";

//o Nome é uma propriedade.
//normalmente são públicas
public string Nome
{
// aqui usamos o atributo mNome para retornar o valor da propriedade
get { return mNome; }

// aqui usamos o atributo mNome para salvar o valor da propriedade
set { mNome = value; }
}
}

Métodos:
Os métodos serão os “verbos”, as ações que nossos objetos podem executar.

public class Pessoa
{
public void Andar()
{ }

public void Comer()
{ }

public void Falar()
{ }

public Boolean Sonhar()
{
return true;
}
}

Ver Índice

É isso aí pessoal 🙂
Até o próximo
♦ Marcelo

About Marcelo

Nascido em Juruaia/MG em uma fazenda de criação de búfalos, e residindo na região Sul do Brasil. Trabalha com desenvolvimento de aplicações desde os 17 anos. Atualmente é Arquiteto Organizacional na Unimake Software. Para saber mais ... http://desenvolvedores.net/marcelo []'s

Programação Orientada a Objetos (POO)

17
1 Estrela2 Estrelas3 Estrelas4 Estrelas5 Estrelas (12 votos, média: 5,00 de 5)
Loading...
13 de dezembro de 2010
Olá Pessoal.Agora vou iniciar uma série de artigos sobre Programação Orientada a Objetos (POO) ou Object-Oriented Programming (OOP).Na medida do possível irei mostrar como programar cada explicação em alguma linguagem.Este primeiro artigo irá servir como um índice para os outros, sempre que eu postar um item deste índice, irei modificar este artigo fazendo um link daqui para a explicação e vice-versa.Então vamos lá, mãos à obra e vamos ver o que teremos 🙂
É isso ai pessoal 🙂
Até o próximo
♦ Marcelo

About Marcelo

Nascido em Juruaia/MG em uma fazenda de criação de búfalos, e residindo na região Sul do Brasil. Trabalha com desenvolvimento de aplicações desde os 17 anos. Atualmente é Arquiteto Organizacional na Unimake Software. Para saber mais ... http://desenvolvedores.net/marcelo []'s