quinta-feira, 21 de agosto de 2014

Links do Aquário

Execute seu código python passo a passo de forma interativa e visual!!!
http://pythontutor.com/

Programador Cowboy, dica para  gerenciamento de equipe
http://www.akitaonrails.com/2009/03/30/off-topic-net-negative-producing-programmer#.U25JfXWx1dk


Exercite suas habilidades de programação!


terça-feira, 19 de agosto de 2014

PHP Callback e Callable

"O verdadeiro significado das coisas é encontrado ao se dizer as mesmas coisas com outras palavras."
Charles Chaplin


<?php

function funcao(){
    echo "Olá";
}

funcao();


<?php

function funcao(){
    echo "Olá";
}

$nomeFuncao = "funcao";
$nomeFuncao();


PHP DOC Funções anonimas
<?php
//Infelizmente não vai funcionar no codepad
//O codepad utiliza PHP 5.2.5
//Recurso disponível a partir do PHP 5.3
$funcao = function(){
    echo "Olá";
};

$funcao();


PHP DOC __invoke
<?php
//Infelizmente não vai funcionar no codepad
//O codepad utiliza PHP 5.2.5
//Recurso disponível a partir do PHP 5.3
class Funcao{

    public function __invoke(){
        echo "Olá";
    }

}

$funcao = new Funcao();

$funcao();


Obrigado!

quarta-feira, 13 de agosto de 2014

Desenvolvimento de Hardware

Esse vai ser o primeiro post sobre programação em um nível mais baixo, vou falar sobre desenvolvimento de hardware, mais especificamente circuitos digitais.

Quando é falado sobre hardware hoje em dia, vem muito na cabeça plataformas como o ArduinoRaspberry PIBeagleBone e Cubieboard, porém estas plataformas não são exatamente a ideia deste post, nestas plataformas normalmente o hardware não é alterado ou desenvolvido pelo usuário final, o usuário final conecta dispositivos específicos destas plataformas e faz a programação de um processador ou de um microcontrolador.

CubieBoard
Arduino
RaspBerry PI





BeagleBone

Uma tecnologia que nos permite realizar a prototipação de hardware são os FPGAs. Um FPGA é semelhante a um brinquedo de blocos de montar (lego), mas invés de blocos são portas lógicas e flip-flops e invés de encaixar as peças com as mãos mecanicamente, as interconectamos eletronicamente.

Ainda assim utilizar um FPGA não é desenvolver um  hardware físico, afinal ele já é um hardware pronto que possibilita a montagem de outros hardwares, porém permite simular o projeto de um circuito digital. Os FPGAs vem de uma família de dispositivos chamados PLDs (programmable logic device).





Altera - DE2
FPGA

Atualmente, processadores, microcontroladores e outros circuitos digitais utilizados, são complexos, utilizam muitas portas logicas, ou seja, milhares de transistores. Provavelmente se alguém tentar projetar um processador comercial hoje em dia utilizando um diagrama elétrico com transistores, ou um diagrama lógico com portas lógicas AND e OR, terá uma tremenda dor de cabeça.

Uma das saídas para evitar este estresse é a utilização dos HDLs(hardware description language), estas linguagens possibilitam descrever o comportamento de um hardware e através desta descrição um sintetizador faz o hardware, semelhantemente a um compilador.

O hardware produzido por estes sintetizadores pode ser simulado no computador, gravado em FPGA, ou até mesmo ser utilizado para produzir um circuito integrado (ASIC).
No próximo post sobre o assunto será demonstrado alguns exemplos de código HDL, provavelmente com Verilog e VHDL.

Obrigado!

quinta-feira, 26 de junho de 2014

Compilar C++ Linux

Primeiramente antes de compilar um programa vamos precisar do programa, no caso, vou utilizar um programa que não faz nada, simplesmente implementa a função main, já que a ideia é demonstrar como compilar e não como programar.

Estou utilizando o S.O. Fedora, provavelmente os comandos utilizados não serão diferentes dos utilizados em outras distribuições de Linux ou em um Mac. Para compilar utilizarei o comando g++.

//blog.cc
int main(int argc, char ** argv){
 return 1;
}

O exemplo acima deve estar em um arquivo chamado blog.cc, o .cc ajuda a diferenciar o c puro do c++, normalmente os fontes de c++ utilizam extensão cpp ou cc, enquanto os de c puro utilizam somente o c.

Depois do arquivo criado só é necessário rodar o comando abaixo no diretório do arquivo.
g++ blog.cc -o blog

Como o programa que estamos compilando não utiliza nenhum recurso de C++, ele pode ser compilado como um programa escrito em c puro, neste caso pode ser executado o comando abaixo.
gcc blog.cc -o blog

O próximo programa também bem simples, somente define uma classe Object com alguns métodos e o instancia de três formas diferentes na função main. Este já é um programa que utiliza recursos de C++ sendo necessário compilar com o g++.

//blog.cc
#include <string>
#include <iostream>

using namespace std;

class Object {
private:
 string name; 
public:
 Object(){
  cout << "Construtor" << endl;
 }
 Object(const Object& object){
  cout << "Construtor de Cópia" << endl;
 }
 virtual ~Object(){
  cout << "Destrutor" << endl;
 }
};

int main(int argc, char ** argv){
 Object obj;
 Object obj2(obj);
 Object * p = new Object();
 delete p;
 p = new Object(obj2);
 delete p;
 return 1;
}

Porém desta forma a definição da classe fica no mesmo arquivo, o principal, o que é inviável em grandes aplicações, então vou demonstrar uma forma de separar as classes C++ em arquivos diferentes.

Uma forma simples, seria criar uma biblioteca para a classe e importá-la no arquivo principal, como demonstrado no exemplo abaixo.
//blog.cc
#include "object.hh"

int main(int argc, char ** argv){
 Object obj;
 Object obj2(obj);
 Object * p = new Object();
 delete p;
 p = new Object(obj2);
 delete p;
 return 1;
}
//object.hh
#ifndef __OBJECT_HH__
#define __OBJECT_HH__

#include <iostream>
#include <string>

using namespace std;

class Object {
private:
 string name; 
public:
 Object(){
  cout << "Construtor" << endl;
 }
 Object(const Object& object){
  cout << "Construtor de Cópia" << endl;
 }
 virtual ~Object(){
  cout << "Destrutor" << endl;
 }
};

#endif

Para compilar esse exemplo são necessários os dois arquivos blog.cc e object.hh, depois de criados basta compilar com o comando abaixo. Antes de executar o comando se certifique que os dois arquivos estão no mesmo diretório.
g++ blog.cc -o blog


Porém desta forma sempre que o arquivo principal for compilado, todas as bibliotecas importadas serão compiladas novamente, podendo ficar um pouco custoso em projetos grandes. Para evitar essa recompilação, é possível criar objetos compilados que podem ser utilizados na compilação final.

Para compilar somente uma classe C++, primeiramente será necessário separar o cabeçalho da classe de seu corpo,ou seja, sua interface de sua implementação, como demonstrado no exemplo abaixo.
//blog.cc
#include <string>
#include <iostream>

using namespace std;

class Object {
private:
 string name; 
public:
 Object();
 Object(const Object& object);
 virtual ~Object();
};


Object::Object(){
 cout << "Construtor" << endl;
}

Object::Object(const Object& object){
 cout << "Construtor de Cópia" << endl;
}

Object::~Object(){
 cout << "Destrutor" << endl;
}

int main(int argc, char ** argv){
 Object obj;
 Object obj2(obj);
 Object * p = new Object();
 delete p;
 p = new Object(obj2);
 delete p;
 return 1;
}
Neste exemplo ainda está tudo em um arquivo só, porém a classe object foi separada entre cabeçalho e corpo.
Depois o cabeçalho da classe deve ser colocado em uma biblioteca e seu corpo em um arquivo de c++, sendo que o arquivo do corpo deve importar a biblioteca com seu cabeçalho. A função main pode ser colocada em um outro arquivo.
Abaixo estão os exemplos dos três arquivos, object.hh com o cabeçalho da classe object, object.cc com o corpo da classe object e o arquivo blog.cc que implementa a função main e utiliza a classe object.

//blog.cc
#include "object.hh"

int main(int argc, char ** argv){
 Object obj;
 Object obj2(obj);
 Object * p = new Object();
 delete p;
 p = new Object(obj2);
 delete p;
 return 1;
}
//object.hh
#ifndef __OBJECT_HH__
#define __OBJECT_HH__

#include <string>

using namespace std;

class Object {
private:
 string name; 
public:
 Object();
 Object(const Object& object);
 virtual ~Object();
};

#endif
//object.cc
#include "object.hh"

#include <iostream>

Object::Object(){
 cout << "Construtor" << endl;
}

Object::Object(const Object& object){
 cout << "Construtor de Cópia" << endl;
}

Object::~Object(){
 cout << "Destrutor" << endl;
}

Para compilar somente a classe é necessário utilizar a opção de compilação -c, caso contrário o compilador emite um erro, pois ele tentará criar um executável, mas como não existe a função main isso não é possível. A opção -c diz para o compilador somente compilar. Os comandos para compilar estão logo abaixo.

g++ -c object.cc -o object.o
g++ blog.cc -o blog object.o

Primeiramente foi compilada a classe object gerando um arquivo de saída object.o, o nome do aquivo de saída foi determinado pela opção -o. Em seguida foi compilado o arquivo com a função main, gerando um arquivo de saída blog. O arquivo object.o foi passado como parâmetro de compilação, assim o compilador o utiliza para gerar o executável blog. Sem passar o object.o como parâmetro o compilador terá acesso somente ao cabeçalho da classe object, já que a implementação de seus métodos estão no arquivo object.cc, causando um erro de compilação. Porém a implementação dos métodos estão compiladas no arquivo object.o, assim o compilador utiliza esse arquivo para saber o corpo dos métodos.

Para facilitar bastante a vida dos programadores, existe um recurso que ajuda muito na compilação, que é o make, ele é basicamente uma linguagem de script feita para compilar, provavelmente será visto em um próximo post.

Obrigado!.

segunda-feira, 23 de junho de 2014

Hot Tips: cURL - O que???

Você que está no meio da programação, desenvolvimento, sistemas web, etc; provavelmente já ouviu falar de cURL... Não??? Bom então nesse caso é bom começar do zero. Quando se trata de Web e aplicações que trabalham com internet, separa-se em 2 "lados" da moeda o Cliente-Side e o Server-Side, o cliente-side é a parte da aplicação que roda no computador, tablet, smartphone do usuário do sistema, e o server-side o local onde recebe requisições do client-side, pedindo alguma informação, ou enviando algo para ser salvo por exemplo. E é exatamente nesse ponto que nossa querida libcurl entra em ação.

Um cURL é responsável pelas requisições feitas para um server-side, uma forma de comunicaçao entre os dois lados, onde é possível trabalhar com header's, paramêtros, dentre outras configurações como métodos de requisição (POST,PUT,GET,DELETE....).

Abaixo um exemplo de requisição feito em cURL para nosso blog:

variavel = "conteudo da variavel"
curl 'http://programandonoaquario.blogspot.com.br/' -H 'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8' -H 'Connection: keep-alive' -H 'Accept-Encoding: gzip,deflate,sdch' -H 'Accept-Language: pt-BR,pt;q=0.8,en-US;q=0.6,en;q=0.4' -H 'User-Agent: Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.115 Safari/537.36' --compressed

Para usar o cURL no Linux por linha de comando, em algumas distribuições é necessário instalar
  • sudo apt-get install curl
Para habilitar o modulo no PHP
  • apt-get install php5-curl
Ok, agora você já sabe como funciona uma requisição em cURL, nosso próximo assunto tratará de um tipo de sistema que utiliza muito cURL, as API's.

Abraços e até o proximo!!!

sexta-feira, 13 de junho de 2014

Introdução a Programação parte 2: Variáveis

Dando continuidade a Introdução a Programação, hoje vamos ver variáveis.
Uma variável é um "lugar" onde se pode colocar as coisas,no caso do python este "lugar" pode ter qualquer coisa.

variavel = "conteudo da variavel"
print variavel

No exemplo acima é inserido em uma variável o texto "conteudo da variavel", em seguida o comando "print" escreve a variável, não o nome da variável mas sim seu conteúdo.
Os nomes das variáveis são definidos pelos programadores tendo algumas restrições das linguagens, normalmente o primeiro caractere tem que ser uma letra de 'a' a 'z' ou '_', podendo ser maiúsculo ou minusculo e os demais caracteres podem ser letras ou números.
Exemplos de variáveis válidas:
  • cafe
  • resultado
  • nome_do_cliente
  • nomeDoCliente
  • v8

Exemplos de variáveis não válidas:
  • 1valor
  • #var
  • 123

Em algumas linguagens as variáveis podem ter caracteres especiais, como letras acentuadas, porém são poucas estas linguagens, então por padrão é bom evitar o uso de acentos.
Uma variável é na verdade um endereço de memoria ou um espaço da memoria do computador, onde podem ser armazenados os valores.
Infelizmente ou felizmente, uma variável é somente uma coisa por vez e quando utilizamos o simbolo '=' estamos utilizando o comando de atribuição, estamos atribuindo um valor a uma variável.
Realizando a atribuição, o valor anterior da variável é perdido como será demonstrado no exemplo abaixo.
oNomeQueVoceQuiser = "Programando fora do Aquario"
oNomeQueVoceQuiser = "Programando no Aquario"

print oNomeQueVoceQuiser


Algumas linguagens de programação não fazem distinção de letras maiúsculas e minusculas, ou seja, uma variável chamada "clienteNome" também pode ser chamada de "ClienteNome". Mas este não é o caso do python, como será demonstrado no próximo exemplo.

programandoNoAquario = 1
programandonoaquario = 2
PROGRAMANDONOAQUARIO = 3

print programandoNoAquario,programandonoaquario,PROGRAMANDONOAQUARIO


Devido a esta distinção podemos chamar o python de uma linguagem Case Sensitive.
Com a utilização de variáveis, podemos simplificar o entendimento de alguns programas simplesmente dando bons nomes as variáveis, ou segmentando os problemas.
raio = 5
pi = 3.14159
diametro = raio * 2
area = pi * raio * raio
perimetro = 2 * pi * raio

print "Sendo PI = ",pi
print "Sendo o raio do circulo = ",raio
print "Diametro = ",diametro
print "Area = ",area
print "Perimetro = ",perimetro


No exemplo acima é demonstrado como o uso de nomes adequados para variáveis, pode situar o leitor do código, ajudando a descobrir a verdadeira intenção do código.

Para quem quiser se aprofundar na linguagem python, segue um link de um ótimo Tutorial de Python.

Obrigado!

sexta-feira, 6 de junho de 2014

Introdução a Programação

Programar é basicamente descrever como realizar alguma ação, programar computadores é então, descrever de uma forma que o computador possa entender e executar a ação descrita.

Normalmente as descrições das ações são semelhantes ao que chamamos de algoritmos, que é algo que estamos mais acostumados do que imaginamos. Quando pensamos em uma sequencia de ações para realizar alguma coisa, é basicamente um algoritmo. Por exemplo para fazer café:

  • Colocar o filtro na cafeteira
  • Colocar água na cafeteira
  • Colocar pó de café, uma colher a cada duas xícaras de água
  • Ligar a cafeteira
  • Aguardar


Um outro exemplo poderia ser uma receita qualquer, onde são descritos os ingredientes necessários e em seguida há um texto quase que um passo a passo, descrevendo uma sequencia de operações que devem ser seguidas para realizar a receita. No caso da receita uma pessoa descreveu para outra pessoa como realizar alguma coisa, já na programação de computadores é uma pessoa descrevendo para um computador.

Para uma pessoa descrever algo para outra pessoa ou simplesmente conversar, é necessário que elas entendam o que cada uma diz, para isso existem as linguagens, como no nosso caso o português e muitas outras, com os computadores assim como com as pessoas existem diversas linguagens.

Hoje pretendo utilizar a linguagem Python, escolhi essa linguagem por ser uma linguagem bem simples para exemplos pequenos e ser de fácil instalação, para quem não quiser instalar nada, também é possível testar os códigos em Python no site codepad.

Vou iniciar com um exemplo bem simples e clássico, um programa que escreve na tela “Hello World”.


print "Hello World"


Neste simples exemplo, utilizamos praticamente duas coisas, um comando de computador para escrever (print) e o texto que gostaríamos de escrever (Hello World). As aspas duplas são utilizadas justamente para o computador conseguir diferenciar o que é um comando, do que é texto.

Vamos então para um outro exemplo, a maioria das linguagens de computador conseguem facilmente representar operações matemáticas, como será demonstrado no próximo exemplo.


print 3 + 5
print 7 - 11
print 3 * 5
print 15 / 3


Neste exemplo o que será impresso na tela será o resultado das operações matemáticas e não as próprias operações, como as operações não estão entre aspas duplas o computador irá entender as operações como comandos e não como texto. No exemplo abaixo é impresso as operações, pois elas estão entre aspas duplas sendo consideradas textos e não comandos.


print "3 + 5"
print "7 - 11"
print "3 * 5"
print "15 / 3"


Para finalizar por hoje será feito um programa que imprime algumas operações e seus resultados.


print "3 + 5 =",3+5
print "7 - 11 =",7-11
print "3 * 5 =",3*5
print "15 / 3 =",15/3


Agora o comando “print” imprime duas coisas por vez, o texto entre aspas e o resultado da operação, um detalhe importante é a utilização da vírgula realizando uma separação. Assim como no português, que utilizamos vírgulas para separar algumas palavras dentro de uma sequencia de palavras (café, açúcar, caneca) a linguagem Python adotou uma notação semelhante.

Espero que com isso seja possível ter um pouco de entendimento do que é programação. Para programar computadores é simplesmente necessário saber descrever o que deseja ser realizado utilizando uma linguagem apropriada.

Para qualquer dúvida faça um comentário, assim posso tentar esclarecer essa dúvida e melhorar o post para que outros possam entender melhor. E se você é iniciante de programação, ou está começando a aprender agora faça um comentário, isso ajudará a incentivar continuações para essa introdução.

Obrigado!

Próxima parte...

domingo, 1 de junho de 2014

Herança Virtual em C++

Antes de falar sobre a herança virtual em C++, é preciso esclarecer o motivo de seu uso, que está intimamente ligado com uma das complicações da herança múltipla.

Algumas linguagens orientada a objeto resolveram não implementar a herança múltipla, substituindo esse recurso pelo uso de interfaces. Por exemplo em Java, uma classe não pode herdar duas classes ou mais, porém pode implementar quantas interfaces desejar. Em C++ como foi feito a implementação da herança múltipla, não existe a necessidade das interfaces, já que uma classe pode herdas diversas outras classes.

Em Java, se duas interfaces diferentes tiverem métodos com a mesma assinatura e uma classe qualquer implementar as duas interfaces, não existirá problema algum, afinal a implementação dos métodos é responsabilidade da classe que está “herdando” estas interfaces.

Em C++ é possível que uma classe herde de outras duas, que possuam métodos ou até mesmo atributos com os mesmos nomes, isso se torna algo conflitante, ainda por cima é possível que as duas classes herdadas já façam herança de outras classes, podendo ter até uma classe em comum.

Imagine a seguinte situação, classe A sem nenhuma herança, classes B e C herdando de A e uma classe D herdando de B e C. Neste caso há alguns questionamentos, uma instância de D equivale a quantas instâncias de A? Afinal ela herda A por B e por C. Acredito que exista casos em que a intenção seja duas instâncias, já alguns outros que seja apenas uma.

Para isso o C++ utiliza a herança virtual, com ela pode ser especificado como resolver esse tipo de herança. No exemplo abaixo foi feita a herança de forma normal, sem a utilização da herança virtual.

#include <iostream>

using namespace std;

class A {
private:
    static int contador;
public:
    A(){
        A::contador++;
        cout << "Construtor do A  ("<< A::contador <<")"<< endl;
    }
    virtual ~A(){
        cout << "Destrutor do A (" << A::contador << ")" << endl;
        A::contador--;
    }
};

int A::contador = 0;

class B : public A {
public:
    B(){
        cout << "Construtor do B" << endl;
    }
    virtual ~B(){
        cout << "Destrutor do B " << endl;
    }
};

class C : public A {
public:
    C(){
        cout << "Construtor do C" << endl;
    }
    virtual ~C(){
        cout << "Destrutor do C " << endl;
    }
};


class D : public B,C {
public:
    D(){
        cout << "Construtor do D" << endl;
    }
    virtual ~D(){
        cout << "Destrutor do D" << endl;
    }
};


int main(int argc, char ** argv){
    D d;
}

Se observada a saída deste programa, pode ser percebido que uma instância da classe D é na verdade duas instâncias da classe A, como se D fosse composto por uma instância da classe B e uma instância da classe C.
No próximo exemplo a herança de B e C para A foi feita de forma virtual, tornando a saída do programa um pouco diferente.
#include <iostream>

using namespace std;

class A {
private:
    static int contador;
public:
    A(){
        A::contador++;
        cout << "Construtor do A  ("<< A::contador <<")"<< endl;
    }
    virtual ~A(){
        cout << "Destrutor do A (" << A::contador << ")" << endl;
        A::contador--;
    }
};

int A::contador = 0;

class B : virtual public A {
public:
    B(){
        cout << "Construtor do B" << endl;
    }
    virtual ~B(){
        cout << "Destrutor do B " << endl;
    }
};

class C : virtual public A {
public:
    C(){
        cout << "Construtor do C" << endl;
    }
    virtual ~C(){
        cout << "Destrutor do C " << endl;
    }
};


class D : public B,C {
public:
    D(){
        cout << "Construtor do D" << endl;
    }
    virtual ~D(){
        cout << "Destrutor do D" << endl;
    }
};


int main(int argc, char ** argv){
    D d;
}

Neste caso uma instância de D representa apenas uma instância de A, como se a instância de B e de C que compõem a instância de D, fossem compostas pela mesma instância de A.

Obrigado!

segunda-feira, 26 de maio de 2014

Hello World!

Esse post é mais para apresentar o novo recurso do blog, agora é possível testar os códigos online.
Infelizmente não foi possível fazer isso para todas as linguagens de programação que pretendemos abordar, mas vamos trabalhar melhor nisso.
Esse post vai apresentar o famoso "Hello World" em algumas linguagens diferentes que conseguimos compilar online.
Para realizar a compilação utilizamos o site codepad.

C

#include <stdio.h>

int main(int argc, char ** argv){
    printf("Programando no Aquário\n");
    return 1;
}

C++

#include <iostream>

int main(int argc, char ** argv){
    std::cout << "Programando no Aquário" << std::endl;
}

Python

# -*- coding: utf-8 -*- 
print "Programando no Aquário"

PHP

<?php

echo "Programando no Aquário\n";


Lua

print "Programando no Aquário"

D

import std.stdio;

void main(){
   writefln("Programando no Aquário");
}

Haskell


programando :: IO()
programando = putStrLn "Programando no Aquário"
main = programando


OCaml


print_endline "Programando no Aquário"


Perl


#!/usr/bin/perl 
print "Programando no Aquário"


Scheme


(display "Programando no Aquário")


Tcl


#!/usr/bin/tclsh
 
puts "Programando no Aquário"


Ruby


puts "Programando no Aquário"


Obrigado!
Obrigado codepad!

quinta-feira, 22 de maio de 2014

Classes Anônimas em Java

Em alguns momentos precisamos implementar alguma coisa pequena e simples, de forma “privada” e obedecendo alguma interface já definida, acho que esse é o melhor momento de se utilizar as classes anônimas.
O código abaixo vai utilizar uma classe anônima para implementar a interface Runnable, esta interface pode ser utilizada para definir a ação de uma Thread.
import java.lang.Thread;
import java.lang.Runnable;

public class Blog{

    public static void main(String... args) throws Exception{
        
        Runnable runnable = new Runnable(){
            @Override
            public void run(){
                System.out.println(this.getClass());
            }
        };

        for(int i=0;i<5;i++){
            new Thread(runnable).start();
        }
    }
}

Algo muito interessante das classes anônimas, é que sempre é guardado uma referencia da instância do objeto que a criou, assim é possível acessar essa instância de dentro da classe anônima. Para diferenciar de qual instância o this está se referenciando é utilizado o nome da classe, como no exemplo abaixo.

import java.lang.Runnable;

public class Blog{

    private int cont =0;

    public Blog(){

    }

    public Runnable constroiClasseAnonima(){
        return new Runnable(){
            private int cont = 0;
            @Override
            public void run(){
                System.out.println(
                    this.getClass()+":"+this.cont
                );
                System.out.println(
                    Blog.this.getClass()+":"+Blog.this.cont
                );
                this.cont++;
                Blog.this.cont++;
            }
        };
    }

    public static void main(String... args){
        Blog blog = new Blog();
        for(int i=0;i<5;i++){
            blog.constroiClasseAnonima().run();
        }
    }
   
}

Reparem que a classe anônima teve total acesso aos atributos privados da classe responsável por sua instanciação.
O NetBeans por padrão cria classes anônimas para responder aos eventos gerados por botões implementado a interface ActionListener, de forma semelhante ao exemplo abaixo.

import javax.swing.JFrame;
import javax.swing.JButton;
import javax.swing.JOptionPane;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.FlowLayout;

public class Blog extends JFrame{

    private JButton btOi = new JButton("Diga oi!");

    public Blog(){
        super("Programando no Aquário");
        this.setLayout(new FlowLayout());
        this.add(btOi);
        //ajusta tamanho da janela
        this.pack();
        //posiciona do centro da tela
        this.setLocationRelativeTo(null);
        //finaliza ao fechar janela
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        btOi.addActionListener(new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent event){
                Blog.this.dizOiJanela();    
            }
        });

        btOi.addActionListener(new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent event){
                Blog.this.dizOiTerminal();    
            }
        });
    }

    private void dizOiJanela(){
        JOptionPane.showMessageDialog(null,"Olá Mundo!!!");
    }

    private void dizOiTerminal(){
        System.out.println("Olá Mundo!!!");
    }

    public static void main(String... args){
        new Blog().setVisible(true);
    }
   
}

É possível também criar classes anônimas de classes abstratas ou até mesmo concretas, a sintaxe é a mesma só que invés de implementar métodos de uma interface, você terá que implementar métodos abstratos de uma classe abstrata ou sobrescrever métodos de uma classe qualquer.

Segue outro exemplo utilizando Thread, porém desta vez é sobrescrito o método run da própria classe Thread.
import java.lang.Thread;

public class Blog{

    public static void main(String... args) throws Exception{
        
        Thread thread = new Thread(){
            @Override
            public void run(){
                System.out.println(this.getClass());
            }
        };

        thread.start();
    }
}

Obrigado!

sábado, 17 de maio de 2014

Hot Tips: Acessando Atributos de Classes PHP

Deve-se ter atenção ao acessar atributos das classes PHP.

O acesso aos atributos de uma classe PHP por seus métodos deve ser feito utilizando a variável $this que irá indicar que será utilizado o atributo da classe.
Quando não for utilizado o $this, a variável é utilizada no escopo local do método.

//PHP
//Variáveis utilizadas nos métodos estão definidas no escopo local.
class Pessoa{
    public  $nome;
    public  $idade;

    public function getNome(){
        return $nome;
    }

    public function setNome($n){
        $nome = $n;
    }

    public function getIdade(){
        return $idade;
    }

    public function setIdade($i){
        $idade = $i;
    }
}

$pessoa = new Pessoa();

$pessoa->setNome("Arthur");
$pessoa->setIdade(30);

var_dump($pessoa->getNome());
var_dump($pessoa->getIdade());

A saída do var_dump do código acima será:
 NULL 
NULL
Então, para que seja setado e retornado os valores dos atributos da classe, foi utilizado o $this
//PHP
//Utilizando o $this para acessar os atributos da classe Pessoa
class Pessoa{
    public  $nome;
    private $idade;

    public function getNome(){
        return $this->nome;
    }

    public function setNome($n){
        $this->nome = $n;
    }

    public function getIdade(){
        return $this->idade;
    }

    public function setIdade($i){
        $this->idade = $i;
    }
}

$pessoa = new Pessoa();

$pessoa->setNome("Arthur");
$pessoa->setIdade(30);

var_dump($pessoa->getNome());
var_dump($pessoa->getIdade());

Deste modo a saída do var_dump será:
string(6) "Arthur"
int(30)

Obrigado!

quinta-feira, 15 de maio de 2014

Java Reflection

O conceito de reflexão é baseado na ideia de que um programa possa se observar, como se estivesse vendo sua imagem refletida em um espelho. A partir dessa auto observação o programa pode tomar decisões em tempo de execução. Praticamente os dados que representam uma instância conseguem acessar seus meta-dados.

No exemplo abaixo, foi programado em Java um exemplo do uso de reflexão. A classe Blog tem o método toString, que constrói uma String para representar aquela instância, porém o conhecimento sobre os campos daquela classe foi necessário na escrita do código. Já no método main, é construído uma String igual a gerada pelo método toString, porém utilizando reflexão.

import java.lang.reflect.*;

public class Blog{

    private String name = "Programando no Aquário";

    public String getName(){
        return this.name;
    }

    public void setName(String name){
        this.name = name;
    }

    public String toString(){
        return "Blog{name="+this.name+"}";
    }
    
    public static void main(String... args) throws Exception{
        Blog b = new Blog();
        System.out.println(b);
        Class clazz = b.getClass();
        String className = clazz.getSimpleName();
        String toString = className+'{';
        for(Field field : clazz.getDeclaredFields()){
            toString += field.getName()+'='+field.get(b);
        }
        toString += '}';
        System.out.println(toString);
    }
}

Além de acessar atributos dos objetos, também é possível invocar métodos ou até mesmo instanciar os objetos. No exemplo acima é utilizado reflection para acessar um atributo privado, isso deve ser feito com cautela, o código acima só funciona pois o método main pertence a classe Blog, logo ele tem acesso aos atributos privados, caso contrario seria disparado uma exceção.

Caso seja necessário acessar atributos ou métodos teoricamente inacessíveis, é necessário utilizar um método chamado setAccessible, cuidado com sua utilização a final os atributos é métodos não foram feitos privados atoa.

No exemplo abaixo foi criada uma classe que sobrescreve o método toString da classe Object. Utilizando reflection o método toString cria uma String com a representação da instância do objeto independente de seu tipo.

//ToString.java
import java.lang.reflect.*;

public class ToString {

    public String toString(){
        StringBuilder sb = new StringBuilder();
        Class myClass = this.getClass();
        sb.append(myClass.getSimpleName()).append('{');
        Field[] fields = myClass.getDeclaredFields();
        AccessibleObject.setAccessible(fields,true);
        if(fields.length != 0)
            fieldToString(fields[0],sb);
        for(int i=1;i<fields.length;i++){
            sb.append(',');
            fieldToString(fields[i],sb);
        }
        sb.append('}');
        return sb.toString();
    }

    private StringBuilder fieldToString(Field f,StringBuilder sb){
        try{
            Object value = f.get(this);
            String name = f.getName();
            return sb.append(name).append('=').append(value);    
        }
        catch(Exception ex){
            return null;
        }
    }
    
}

Agora qualquer classe que herdar ToString, terá por padrão um método toString que realmente apresenta seus valores.

//Blog.java
import java.lang.reflect.*;

public class Blog extends ToString{

    private String name = "Programando no Aquário";
    private String post = "Reflection Java";
    protected String protegida = "Variavel Protegida";
    public String publica = "Variavel Publica";

    public String getName(){
        return this.name;
    }

    public void setName(String name){
        this.name = name;
    }

    public static void main(String... args) throws Exception{
        System.out.println(new Blog().toString());
    }
}


Exitem muitos outros recursos oferecidos pelo uso de reflection, para ir até o fundo da toca do coelho, recomendo o estudo da própria documentação do Java.

Obrigado!

terça-feira, 13 de maio de 2014

Simulando Objetos em C

Como a maioria já sabe, a linguagem C não é uma linguagem orientada o objeto, por isso o máximo que vou conseguir demonstrar é um jeito de simular a instância de um objeto.

Para o melhor entendimento deste post, é necessário que o leitor já tenha algum conhecimento sobre ponteiro de funções, caso não tenha existe um post no blog sobre isso.

O exemplo abaixo, irá criar uma estrutura de dados (struct) que conterá ponteiros para funções. Essa estrutura será utilizada semelhantemente a uma interface em alguma linguagem orientada a objeto, ou seja, existe conhecimento de que métodos ela implementa, mas nenhum conhecimento de como é implementado.

//C
#include <stdio.h>
#include <stdlib.h>

int _soma_padrao(int a,int b){
    return a + b;
}

int _subtrai_padrao(int a,int b){
    return a - b;
}

int _soma_debug(int a,int b){
    int soma = a + b;
    printf("SOMA %d + %d = %d\n",a,b,soma);
    return soma;
}

int _subtrai_debug(int a,int b){
    int sub = a - b;
    printf("SUBTRAI %d + %d = %d\n",a,b,sub);
    return sub;
}

typedef struct{
    int (*soma)(int,int);
    int (*subtrai)(int,int);
} calculadora;

void constroiCalculadoraPadrao(calculadora * calc){
    calc->soma = _soma_padrao;
    calc->subtrai = _subtrai_padrao;
}

void constroiCalculadoraDebug(calculadora * calc){
    calc->soma = _soma_debug;
    calc->subtrai = _subtrai_debug;
}

int main(int argc,char ** argv){
    calculadora calc;

    constroiCalculadoraPadrao(&calc);
    printf("%d\n",calc.soma(2,4));
    printf("%d\n",calc.subtrai(8,7));

    constroiCalculadoraDebug(&calc);
    printf("%d\n",calc.soma(2,4));
    printf("%d\n",calc.subtrai(8,7));

}

Porém desta maneira os métodos da estrutura não tem conhecimento da estrutura, impossibilitando o uso de atributos. Umas das maneiras de se contornar esse problema, é a criação de métodos que recebem por parâmetro a estrutura, podendo assim utilizar os dados dela.
//C
#include <stdio.h>
#include <stdlib.h>

struct calculadora;

typedef struct{
    int ultimoResultado;
    int (*soma)(void*,int,int);
    int (*subtrai)(void*,int,int);
    void (*imprimeResultado)(void*);
} calculadora;

int _soma_padrao(calculadora * this,int a,int b){
    this->ultimoResultado = a + b;
    return this->ultimoResultado;
}

int _subtrai_padrao(calculadora * this,int a,int b){
    this->ultimoResultado = a - b;
    return this->ultimoResultado;
}

int _soma_debug(calculadora * this,int a,int b){
    this->ultimoResultado = a + b;
    printf("SOMA %d + %d = %d\n",a,b,this->ultimoResultado);
    return this->ultimoResultado;
}

int _subtrai_debug(calculadora * this,int a,int b){
    this->ultimoResultado = a - b;
    printf("SUBTRAI %d + %d = %d\n",a,b,this->ultimoResultado);
    return this->ultimoResultado;
}

void _imprime_resultado(calculadora * this){
    printf("Ultimo Resultado %d\n",this->ultimoResultado);
}

void constroiCalculadoraPadrao(calculadora * calc){
    calc->ultimoResultado = 0;
    calc->soma = _soma_padrao;
    calc->subtrai = _subtrai_padrao;
    calc->imprimeResultado = _imprime_resultado;
}

void constroiCalculadoraDebug(calculadora * calc){
    calc->ultimoResultado = 0;
    calc->soma = _soma_debug;
    calc->subtrai = _subtrai_debug;
    calc->imprimeResultado = _imprime_resultado;
}

int main(int argc,char ** argv){
    calculadora calc;

    constroiCalculadoraPadrao(&calc);
    printf("%d\n",calc.soma(&calc,2,4));
    calc.imprimeResultado(&calc);
    printf("%d\n",calc.subtrai(&calc,8,7));
    calc.imprimeResultado(&calc);

    constroiCalculadoraDebug(&calc);
    printf("%d\n",calc.soma(&calc,2,4));
    calc.imprimeResultado(&calc);
    printf("%d\n",calc.subtrai(&calc,8,7));
    calc.imprimeResultado(&calc);
}


O exemplo acima utiliza métodos que recebem por parâmetro a instância do "objeto", podendo assim acessar seus dados.

Obrigado!

domingo, 11 de maio de 2014

Ponteiro de void

Com programação orientada a objeto, conseguimos colocar qualquer tipo de instância em alguma variável do tipo objeto ou de alguma classe pai desta instância. Então se criarmos uma lista de objetos, seria possível adicionar qualquer tipo de objeto nesta lista. Com isso é possível reaproveitar melhor o código de uma lista, a final ela poderia ser usada em qualquer lugar.

No caso da linguagem C que não é um linguagem orientada a objeto, se torna um pouco mais complicado reaproveitar o código de uma lista. Mas sim é possível!

O tipo void que é utilizado para definir o retorno vazio de uma função, pode ter uma utilidade a mais. Void sozinho realmente significa vazio, porém um ponteiro para void não aponta para vazio, mas sim para qualquer coisa.
No exemplo abaixo a variável p que é um ponteiro para void, é utilizada para apontar para um tipo float e um tipo int.
//C
#include <stdio.h>
#include <stdlib.h>

int main(int argc,char ** argv){
    void * p;
    int valorInteiro;
    float valorReal;
    
    valorInteiro = 10;
    valorReal = 10.10f;
    
    p = &valorInteiro;
    printf("Valor Inteiro %d\n",*((int*)p));
    valorInteiro = *((int*)p);

    p = &valorReal;
    printf("Valor Real %f\n",*((float*)p));
    valorReal = *((float*)p);
}
Observe bem o uso de casting!
Como p pode apontar para qualquer coisa, o compilador não sabe como tratar os dados que estão nele, sendo necessário sempre fazer a conversão para o tipo correto.

Para exemplificar melhor o reúso de código, o exemplo abaixo contem a implementação de uma pilha com ponteiro de void, assim essa pilha pode armazenar qualquer tipo de dados.
//C
#include <stdio.h>
#include <stdlib.h>

typedef struct{
    void * data;
    void * next;
} stack_node;

typedef struct{
    unsigned int size;
    stack_node * node;
} stack;

stack * makeStack(){
    stack * s = NULL;
    s = (stack*)malloc(sizeof(stack));
    s->size = 0;
    s->node = NULL;
    return s;
}

void push(stack * s,void * data){
    stack_node * node;
    node = (stack_node*)malloc(sizeof(stack_node));
    node->data = data;
    node->next = s->node;
    s->node = node;
    s->size += 1;
}

void * pop(stack * s){
    void * val;
    stack_node * node;
    val = s->node->data;
    node = s->node;
    s->node = s->node->next;
    s->size -= 1;
    free(node);
    return val;
}

void * top(stack * s){
    if(s->node == NULL)
        return NULL;
    return s->node->data;
}

void clear(stack * s){
    stack_node * node;
    s->size = 0;
    while(s->node != NULL){
        node = s->node;
        s->node = s->node->next;
        free(node);
    }
}

int main(int argc,char ** argv){
    int i;
    int val[5] = {12,1,-5,7,13};
    stack * s = makeStack();
    printf("stack size %d\n",s->size);
    for(i=0;i<5;i++){
        printf("size %d\n",s->size);
        printf("push %d\n",*(val+i));
        push(s,(void*)(val+i));
        printf("top %d\n",*((int*)top(s)));
    }
    for(i=0;i<5;i++){
        printf("size %d\n",s->size);
        printf("top %d\n",*((int*)top(s)));   
        printf("pop %d\n",*((int*)pop(s)));
    }
    printf("stack size %d\n",s->size);
    clear(s);
    free(s);
}
A mesma pilha pode armazenar valores heterogêneos, ponteiros para inteiros, ponteiros para reais, strings e muito mais.
Obrigado!

sábado, 10 de maio de 2014

Quantidade Argumentos Variável Reticências (...)

Quando comecei a programar, sempre ficava curioso para saber como a funções é métodos nativos funcionavam. Como que o printf do C recebe infinitos parâmetros? como posso fazer isso nas minhas funções?
Procurando um pouco descobri o uso de reticencias (...)

No caso da linguagem C é necessário o uso de algumas funções(va_start,va_end)  de uma biblioteca especifica(stdarg.h).
Como em C um vetor (int * v; int v[100]) não armazena o seu próprio tamanho, é necessário que a função que utilizar ... tenha um modo de saber a quantidade dos argumentos.
Por exemplo o printf(const char * format,...) utiliza a string de formatação para saber quantos argumentos são recebidos.

//C
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

//necessario sempre ter um parametro antes dos ...
void reticencias(int tamanho,...){
    int i;
    char * str;
    va_list tresPontos;
    //va_start precisa do primero parametro da função
    va_start(tresPontos,tamanho);
    for(i=0;i < tamanho;i++){
        //va_arg (argumentos,tipo do argumento)
        str=va_arg(tresPontos,char*);
        printf("%s\n",str);
    }
    va_end(tresPontos);
}

int main(int argc, char ** argv){
    const char * const str1 = "teste";
    const char * const str2 = "outro teste";
    const char * const str3 = "programando do aquário";
    reticencias(3,str1,str2,str3);
}

Em Java a utilização do ... é bem mais simples.
public class Blog{

    //o ... pode ser usado no main
    //o método main recebe sempre um vetor de String
    public static void main(String... args){
        // não a diferença de tipo entre String... e String[]
        String[] vetorDeString = args;
        //chamada do metodo com varios argumetos
        print("teste","outro teste","programando no aquário");
        //camada do metodo passando um vetor
        print(new String[]{
            "teste",
            "outro teste",
            "programando no aquário"
            });
    }

    public static void print(String... palavras){
        for(String palavra: palavras){
            System.out.println(palavra);
        }
    }

}
Porém um método que em sua assinatura usa String[] não recebe vários argumentos, mas sim, um vetor de String.
Obrigado!

sexta-feira, 9 de maio de 2014

Ponteiro de Função (Função Callback)

Muita gente não gosta muito de trabalhar com ponteiros, confunde, é complicado e fácil de fazer alguma besteira. Porém uma linguagem que consegue trabalhar com ponteiros normalmente se torna bem poderosa.

"Com grandes poderes vem Grandes Responsabilidades" Ben Parker

Espero que quem esteja lendo já conheça  um pouco sobre ponteiros.

As variáveis e as funções na maioria dos casos estão armazenados na mesma memória.
Se conseguimos criar apontamentos para endereços de variáveis, por que não criar para funções também?


//c
#include <stdio.h>
#include <stdlib.h>

int sub(int a,int b){
    int r = a - b;
    printf("%d - %d = %d\n",a,b,r);
    return r;
}

int soma(int a,int b){
    int r = a + b;
    printf("%d + %d = %d\n",a,b,r);
    return r;
}


int main(int argc, char ** argv){
    int a,b;
    //variavel op é um ponteiro de função
    //a função necessariamente tem que retornar um inteiro
    // e receber como parâmetro dois inteiros
    int (*op)(int,int);
    a = 7;
    b = 4;
    soma(a,b);
    sub(a,b);
    // op  recebe o endereço da função soma
    // repare que não utiliza & e nem ()
    // se fosse utilizado o () a função
    // seria chamada retornando um inteiro
    op = soma;
    //chama soma utilizando op
    op(a,b);
    op = sub;
    //chama sub utilizando op
    op(a,b);
}

No exemplo acima é criado duas funções (sub;soma) para serem apontadas. A variável op (operação) é do tipo ponteiro, no caso ponteiro para função, podendo receber os endereços das funções!

Algumas bibliotecas utilizam ponteiros de funções para pedir ao usuário da biblioteca (provavelmente um programador) uma função que deve ser chamada quando algo ocorrer, como se fosse o aviso de um determinado evento.

Obrigado!

quinta-feira, 8 de maio de 2014

Sobrecarga de Métodos no PHP



Sobrecarga de métodos é um recurso muito interessante. É possível mudar o comportamento do método a partir da quantidade e tipos de parâmetro. Em varias linguagens a assinatura de um método (sua identificação unica) é composta pelo seu nome e argumentos, assim é possível diferenciar qual método chamar somente pelo seus argumentos. 
//Java
public class Blog{
    public diz(){
        System.out.println("Olá Mundo");  
    }

    public diz(String frase){
        System.out.println(frase);
    }

    public static void main(String... args){
        Blog b = new Blog();
        b.diz();
        b.diz("Uma Frase Qualquer");
    }
}
Neste simples exemplo a diferenciação do método foi feita praticamente pelo número de argumentos, que não é  muito diferente do que definir valores padrões no PHP.
<?php
class Blog{
    public function diz($frase = 'Olá Mundo'){
        echo $frase;
    }
}

$b = new Blog();
$b->diz();
$b->diz("Uma Frase Qualquer");
O problema começa quando precisamos nos preocupar com o tipo do argumento,em uma linguagem tipada é possível que o compilador detecte os tipos dos parâmetros e realize a distinção dos métodos, mas isso se torna complexo no PHP.

//Java
public class Blog{
    public String dobrar(String frase){
        return frase + frase;
    }

    public int dobrar(int val){
        return val * 2;
    }

    public static void main(String... args){
        Blog b = new Blog();
        b.dobrar("2");
        b.dobrar(2);
    }
}

No exemplo acima os métodos tem o mesmo nome, sendo necessário utilizar os tipos para a diferenciação dos métodos. Infelizmente a unica solução que eu encontrei para fazer a sobrecarga de métodos em PHP é fazendo os testes dos argumentos eu mesmo. Esses testes podem ser auxiliados por duas funções do PHP, func_get_arg, func_get_args e func_num_args.


<?php
class Blog{
    public function dobrar(){
        if(func_num_args() != 1)
            throw new Exception("dobrar com argumentos invalidos");
        $args = func_get_args();
        if(is_int($args[0])){
            return $args[0] * 2;
        }
        else if(is_string($args[0])){
            return $args[0].$args[0];
        }
        else{
            throw new Exception("dobrar com argumentos invalidos");
        }
    }
}

$b = new Blog();
$b->dobrar('2');
$b->dobrar(2);
E assim é possível simular sobrecarga de métodos em PHP.
Obrigado!

quarta-feira, 7 de maio de 2014

PHP Dinâmico



Praticamente tudo no PHP é texto, até valores que as vezes não queremos que seja texto.
Mas pensando bem o código é texto, então poderíamos criar código(texto) no PHP em tempo de execução!

Um exemplo simples disso pode ser mostrado com a função eval.
<?php
    $a = 10;
    $b = 5;
    eval(' $c = $a + $b;');
    var_dump($c);

Mas a dinamicidade do PHP não para por ai!
É possível também invocar métodos de forma dinâmica.

<?php
    class MyClass{
        public function myMethod(){
            echo 'Olá';
        }
    }

    //forma bem comum de utilização
    $instance = new MyClass();
    $instance->myMethod();

    //utilizando texto
    $className = 'MyClass';
    $methodName = 'myMethod';
    $textInstance = new $className();
    $textInstance->$methodName();

    // pode ser colocado {} para "melhorar" a vizualização
    $textInstance->{$methodName}();

Acredito que seja muito útil conseguir chamar métodos dessa forma.
É possível fazer uma tradução da URL requisitada para alguma classe ou método especifico.

Pensando que essa dinamicidade só é possível porque o PHP é uma linguagem interpretada?
Algumas linguagens compiladas também fornecem meios para isso, normalmente utilizando Reflection que funciona um pouco diferente, inclusive o próprio PHP possui classes para utilizar Reflection.
Mas vamos deixar Reflection para um outro dia!
Obrigado!