Desenvolvedores.Net - TechBlog

Tag Archives: interface


História
Há algum tempo muito tem se falado sobre o tal Android, e muitas pessoas tem se interessado em desenvolver software e aplicativos para o mesmo, com uma plataforma de desenvolvimento do Java (JDK e SDK) é relativamente fácil desenvolver aplicativos simples para o Android.
Junto com essa facilidade o sistema foi “adotado” pelos fabricantes de clones chineses, é um ótimo sistema, grátis de vasta documentação e fácil instalação nos processadores da família MT65xx utilizados como processador desses celulares, o preço então nem se fala.
Recentemente adquiri um Hero H7000 chines, é uma cópia do HTC HD7 só que com o android 2.2.1 (froyo) instalado, e com bem menos recursos, o aparelho da empresa Hero é de muito boa qualidade, o meu já caiu umas 5 vezes só na primeira semana de uso. O objetivo era ter um aparelho novo, pois tive os meus furtados e usar como Debuger Device.
Meus problemas começaram assim que ele chegou, pois não possuí CD ou Manual, ou referência ao fabricante chines, nada que eu possa usar para chegar até os drivers, procurei na internet e achei muitos drivers para MT6516, porém somente servem para o celular “desligado” e não era esse o intuito. Depois de uma boa pesquisada em muitos sites, encontrei alguns passos e drivers para fazer e assim vou explicar como fiz funcionar no meu aparelho chines.

Como fazer

Bem, primeiro vamos aos requisitos básicos

  • Sistema Operacional Windows.
  • Eclipse instalado e rodando com o SDK da android.
  • Aparelho rodando Android 2.2.1 (não testei com outras versões).
  • Aplicativos Driver Android ADB (36828).
O processo é bem simples,
  1. Vá ao menu de seu celular -> Configurações -> Aplicativos e marque a opção Fontes Desconhecidas
  2. Entre na opção Desenvolvimento e marque os 3 itens disponíveis (Depuração USB, Permanecer ativo, Permitir locais fictícios)
  3. Faça o download do Driver Android ADB (36828) e extraia o arquivo.exe na pasta de sua preferência, segue o passo a passo da instalação

 
 
  Nesse passo precisamos parar o serviço do ADB que já foi instalado juntamente com o SDK do android Eu geralmente uso o CTRL+SHIFT+ESC para abrir o Gerenciador de Tarefas do Windows Organize por nome, o ADB geralmente é o primeiro da lista Ele vai perguntar se você deseja instalar um Device, a resposta é sim claro. Escolha a ultima opção como mostrada na imagem para celulares chineses Nessa parte você conecta o celular ao PC. Aqui ele finaliza a instalação.
Agora vamos ao nosso Eclipse para configurar o celular para rodar direto.
Abra o eclipse
 
 Vá as configurações de execução Na aba target, selecione manual e aperte em RUN. Selecione a device na parte de cima da próxima janela Pronto, aplicação rodando direto no aparelho 🙂
Espero que resolva o problema de muitas pessoas que estão tentando usar seus chineses baratinhos como debuger para o android, eu gostei muito do meu, é barato e resolve o problema, só fiquei insatisfeito com os 416Mhz que fazem dele um celular bem lento para a resolução de 800×600.
Abraços amigos e até uma próxima.

Herança (POO)

5
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

Abstração e Interface (POO)

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

Esta imagem não tem muito a ver com informática.
mas gostei dela por se tratar de uma imagem abstrata.
Abstração e Interface

Abstração
Para entendermos o que é abstração e interface em programação, vamos entender primeiro o conceito.Abstração quer dizer que devemos considerar as qualidades e comportamentos independentes dos objetos a que pertencem, isolamos seus atributos considerando o que certo grupo de objetos têm em comum.

Vamos imaginar uma mesa, todos nós iremos imaginar uma mesa que tenha pés, uma base e uma finalidade. Mas não importa quantos pés, ou tipo de base ou a finalidade da mesa. Isso não fará com que a mesa que eu imaginei, deixe de ser uma mesa. Ela sempre será uma mesa.

Em programação iremos dizer ao computador para ser um objeto mesa. Mas antes disso precisamos dizer a este objeto qual seria a sua estrutura inicial. Neste caso teremos uma classe abstrata Mesa.

Classes abstratas como vocês já devem ter percebido servem como base para outras classes que queiram ser do mesmo grupo de objetos.

Uma classe abstrata não pode ser criada, quer dizer que não pode ser instanciada. Não podemos usar o new para criar um novo objeto de uma classe abstrata. Uma classe abstrata só pode ser herdada, e todo método, propriedade, evento que for abstrato deverá ser implementado pela classe filha.
Vamos declarar a nossa classe Mesa, que irá servir de base para as outras mesas.

namespace Desenvolvedores.Net.AbstracaoInterface
{
public enum TipoMesa
{
Redonda,
Quadrada,
Retangular
}

public enum TipoBase
{
Vidro,
Madeira,
Aluminio
}

/*
* aqui declaramos a nossa classe
* como abstrata
*/
public abstract class Mesa : IMesa
{

public Mesa()
{
Pes = 4;
}

/*
* reparem que as propriedades não são abstratas,
* não é obrigatório.
* Declare como asbtrato apenas o que você deseja
* que seja implementado nas classes filhas
*/
public TipoBase Base { get; set; }
public TipoMesa Tipo { get; set; }
public int Pes { get; set; }

/*
* aqui irei ter propriedades abstratas para servir de exemplo
*/
public abstract bool Quebrada { get; set; }
public abstract string Finalidade { get; }

/*
* Aqui teremos um método abstrato, onde a classe filha
* será obrigatória a implementar
*/
public abstract void Quebrar();

public virtual void Consertar()
{
Quebrada = false;
}

public override string ToString()
{
return "Olá. Eu sou uma mesa do tipo " +
Tipo.ToString() + " e minha base é de " +
Base.ToString() + ".\nEu tenho " + Pes.ToString() + " pés. " +
"E minha finalidade é " + Finalidade.Trim() + "\n" +
"*".PadLeft(80, '*');
}

}
}

Agora temos uma classe abstrata que será nossa base para todas as nossas mesas.

Antes de continuar, vamos falar sobre interfaces.

Interfaces
Interfaces são como as classes abstratas, mas nelas não podemos implementar nenhum método, apenas declarar suas assinaturas.
Uma classe ao herdar uma interface deverá escrever todos os seus métodos (iremos ver isso em Herança de Interface nos próximos artigos), ao contrário da classe abstrata que só iremos escrever os métodos abstratos.
Com o tempo você aprenderá a ver qual é mais útil dependendo da situação é mais vantajoso usar uma classe abstrata ou uma interface. Não existe uma regra para definir isso, mas sim a necessidade de uma ou de outra.

Por boas práticas, todas as interfaces começa com I, vamos declarar nossa interface IMesa.

namespace Desenvolvedores.Net.AbstracaoInterface
{
interface IMesa
{
TipoBase Base { get; set; }
string Finalidade { get; }
bool Quebrada { get; set; }
TipoMesa Tipo { get; set; }
int Pes { get; set; }

void Consertar();
void Quebrar();
}
}

Percebam que a nossa interface IMesa tem todos os métodos e propriedades para fazer de outra classe uma Mesa, e vejam também que eu não escrevi nenhum código nela, apenas declarei as assinaturas dos métodos e propriedades. 🙂

Exemplo de Uso
Agora como exemplo de uso iremos criar alguns tipos de mesas.
Crie uma aplicação console em C#.

Copie os códigos abaixo.

Uma mesa redonda. Estamos herdando aqui a classe abstrata Mesa.

namespace Desenvolvedores.Net.AbstracaoInterface
{
/*
* repare que ao herdarmos a classe
* abstrata Mesa. Só escrevemos os métodos e propriedades
* que foram definidos como abstrato na classe pai Mesa.
*/
public class MesaRedonda : Mesa
{
public override bool Quebrada { get; set; }
public override string Finalidade
{
get { return "para discutir futebol."; }
}

public override void Quebrar()
{
Quebrada = true;
}
}
}

Agora aqui uma mesa de jantar, que também herda a classe abstrata Mesa.

namespace Desenvolvedores.Net.AbstracaoInterface
{
/*
* repare que ao herdarmos a classe
* abstrata Mesa. Só escrevemos os métodos e propriedades
* que foram definidos como abstrato na classe pai Mesa.
*/
class MesaDeJantar : Mesa
{
public override bool Quebrada { get; set; }

public override string Finalidade
{
get { return "para jantares em família."; }
}

public override void Quebrar()
{
Quebrada = true;
}
}
}

Agora aqui uma mesa de escritório. Nela herdamos a interface, reparem que tive que desenvolver todo o código para a classe filha, a interface apenas trouxe a assinatura dos métodos.

namespace Desenvolvedores.Net.AbstracaoInterface
{
/*
* Nesta classe herdamos apenas a interface IMesa.
* Vejam que tive que escrever todo o código para a classe.
* A interface trouxe apenas as assinaturas dos métodos.
*(herança de interface)
* No caso de uma classe abstrata não há a necessidade
* de se fazer todos os métodos (herança de implementação)
*/
class MesaEscritorio : IMesa
{
public MesaEscritorio()
{
Pes = 4;
}

public TipoBase Base { get; set; }

public string Finalidade
{
get { return "para trabalhar."; }
}

public bool Quebrada { get; set; }

public TipoMesa Tipo { get; set; }

public int Pes { get; set; }

public void Consertar()
{
Quebrada = false;
}

public void Quebrar()
{
Quebrada = true;
}

public override string ToString()
{
return "Olá. Eu sou uma mesa do tipo " +
Tipo.ToString() + " e minha base é de " +
Base.ToString() + ".\nEu tenho " + Pes.ToString() + " pés. " +
"E minha finalidade é " + Finalidade.Trim() + "\n" +
"*".PadLeft(80, '*');
}
}
}

E finalmente. A aplicação de exemplo:

namespace Desenvolvedores.Net.AbstracaoInterface
{
class Program
{
static void Main(string[] args)
{
//aqui criamos os nossos objetos da forma tradicional
MesaRedonda mesaRedonda = new MesaRedonda();
mesaRedonda.Base = TipoBase.Madeira;
Console.WriteLine(mesaRedonda.ToString());

MesaDeJantar mesaJantar = new MesaDeJantar();
mesaJantar.Tipo = TipoMesa.Retangular;
Console.WriteLine(mesaJantar.ToString());

MesaEscritorio mesaEscritorio = new MesaEscritorio();
mesaEscritorio.Tipo = TipoMesa.Quadrada;
Console.WriteLine(mesaEscritorio.ToString());
Console.WriteLine("Usando a interface e a classe abstrata " +
"para criar novas mesas\n" + "*".PadLeft(80,'*'));

//aqui iremos usar um pouco de polimorfismo
//que iremos discutir tambem em nossos próximos artigos
//logo, não se preocupe em saber a definição
//apenas atente para o uso da interface e da classe abstrata
//como tipo de variável

//a minha mesa pode ser de escitório.
IMesa iMesa = new MesaEscritorio();
iMesa.Tipo = TipoMesa.Redonda;
iMesa.Base = TipoBase.Madeira;

Console.WriteLine(iMesa.ToString());

//de jantar
iMesa = new MesaDeJantar();
iMesa.Base = TipoBase.Aluminio;
Console.WriteLine(iMesa.ToString());

//ou redonda
iMesa = new MesaRedonda();
Console.WriteLine(iMesa.ToString());

//e alem da interface eu posso usar a própria classe
//abstrata para definir o meu tipo de mesa
Mesa mesa = new MesaDeJantar();
Console.WriteLine(mesa.ToString());

mesa = new MesaRedonda();
mesa.Tipo = TipoMesa.Quadrada;
mesa.Base = TipoBase.Vidro;
Console.WriteLine(mesa.ToString());

Console.ReadKey();
}
}
}

Bom. espero ter respondido às dúvidas sobre abstração.
Só para reforçar, é simples. Deixe nas classes abstratas ou interfaces, todos os métodos que serão comuns aos seus objetos do mesmo grupo. Assim sendo, sempre que você declarar uma variável de um tipo Interface ou classe Abstrata poderá criar qualquer tipo de objeto que implemente uma das duas.

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

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